Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Monitorozás és naplózás

13. lecke 14 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Az ügynök megfigyelése éles környezetben
  2. A naplózás három szintje
  3. Monitorozandó metrikák
  4. Monitorozó irányítópult
  5. Automatikus riasztások
  6. Főbb megállapítások

Lecke frissítve: 2026. november 3. az OpenAI Computer use útmutatója és a Responses API dokumentációja alapján: a naplózás most a computer_call objektumból olvassa be a műveleteket, az elemeket pedig a response.output tartalmából (üzenetek a phase, érvelési összefoglalók és hívások adatokkal), nem pedig az Anthropic API tool_use blokkjaiból; a korábban hardcoded Claude Sonnet árakat a használt modell aktuális árazása váltotta fel, és a elavult datetime.utcnow() (Python 3.12 óta) helyett a datetime.now(timezone.utc) függvényt használjuk. Források: Computer use · Árazás.

Az ügynök megfigyelése éles környezetben

Egy éles környezetben futó Computer Use ügynök fekete doboz marad, ha nem állítasz be megfelelő monitorozást. Egy szabványos API-val ellentétben, ahol csak a kéréseket és válaszokat naplózod, itt vizuális műveleteket, képernyőképeket és a modell döntéseit is nyomon kell követned. A különbség kézzelfogható: ha egy munkafolyamat hajnali 3-kor elbukik, a lényeges kérdés nem az, hogy „milyen kivételt dobott a rendszer“, hanem az, hogy „mit látott az ügynök, és miért kattintott oda?“. Egy olyan napló, amely erre nem ad választ, reggelre haszontalanná válik.

A naplózás három szintje

Az instrumentáció ezért három kiegészítő rétegre épül: mit tett az ügynök, mit gondolt a cselekvés előtt, és mit látott a döntés pillanatában. Mindegyik más csatornára ír, mivel sem a mennyiségük, sem a hasznos élettartamuk nem azonos.

1. szint: Műveletek

Minden, az ügynök által végrehajtott műveletet nyomon kell követni. Az alábbi formátum szisztematikusan előtagként használja az iteráció számát és az aktuális lépés nevét, így több ezer soros naplóból is kiszűrheted azt az egyetlen szekvenciát, amely hibázott. A műveletek objektumként érkeznek a computer_call-ból, ugyanazokkal a mezőkkel, mint a kezelődben (x, y, scroll_x, keys…). Figyeld meg a type művelet kezelését: a beírt szöveg hosszát rögzítjük, de soha magát a tartalmát. Ha az ügynök egy bejelentkezési űrlapot tölt ki, jelszót gépel be, és itt az előző leckéből származó szabály kivétel nélkül érvényesül.

import logging

logger = logging.getLogger("computer_use")
logger.setLevel(logging.INFO)

handler = logging.FileHandler("agent.log")
handler.setFormatter(logging.Formatter("%(asctime)s | %(levelname)s | %(message)s"))
handler.addFilter(SensitiveFilter())  # szűrő a 12. leckéből
logger.addHandler(handler)


def log_action(action, iteration: int, step: str = ""):
    """Naplóz egy műveletet egy computer_call-ból."""
    prefix = f"[iter={iteration}] [{step}]"
    match action.type:
        case "click" | "double_click" | "move":
            logger.info("%s %s at (%s, %s)", prefix, action.type.upper(), action.x, action.y)
        case "type":
            # Soha nem magát a szöveget: csak a hosszát
            logger.info("%s TYPE (%d chars)", prefix, len(action.text))
        case "scroll":
            logger.info("%s SCROLL dx=%s dy=%s", prefix, action.scroll_x, action.scroll_y)
        case "keypress":
            logger.info("%s KEYPRESS %s", prefix, "+".join(action.keys))
        case "drag":
            logger.info("%s DRAG (%d points)", prefix, len(action.path))
        case _:
            logger.info("%s %s", prefix, action.type.upper())

2. szint: Modell döntések

Naplózd, mit mond a modell a választásairól, hogy megértsd, miért választott egy adott műveletet. Egy váratlan koordinátára történő kattintás önmagában semmit sem jelent; de ha párosítod a megelőző mondattal – „a beküldés gombot eltakarja a cookie-sáv“ –, máris diagnózissá válik. A szöveget kétszáz karakterre vágjuk le; ez bőven elég a szándék megértéséhez anélkül, hogy elszállna a fájl mérete. Egy Responses API válaszban kétféle szövegforrás létezik. A közbenső üzenetek, amelyeket a modell cselekvés előtt ír, phase: "commentary" értékkel bírnak, míg a végső válasz phase: "final_answer" fázisú. És ha a használt modell támogatja az érvelési összefoglalókat (reasoning summaries), akkor azokat a reasoning={"summary": "auto"} kéréssel érheted el: ezek reasoning típusú elemekben érkeznek.

A tokenfogyasztást ugyanilyen ütemben naplózzuk, és ez fokozott figyelmet érdemel: még a previous_response_id használata mellett is, a láncban lévő összes előző válasz bemeneti tokenjét újra számlázzák bemenetként, a képernyőképeket is beleértve. Egy kör költsége tehát a munkamenet hosszával nő.

def log_model_response(response, iteration: int):
    """Naplózza a megjegyzéseket, összefoglalókat és hívásokat egy válaszból (képek nélkül)."""
    for item in response.output:
        if item.type == "reasoning":
            for summary in item.summary:
                logger.info("[iter=%d] REASONING: %s", iteration, summary.text[:200])
        elif item.type == "message":
            text = "".join(c.text for c in item.content if c.type == "output_text")
            logger.info("[iter=%d] MESSAGE (%s): %s", iteration, item.phase or "-", text[:200])
        elif item.type == "computer_call":
            actions = ", ".join(a.type for a in item.actions or [])
            logger.info("[iter=%d] COMPUTER_CALL %s: %s", iteration, item.call_id, actions)
        elif item.type == "function_call":
            logger.info("[iter=%d] FUNCTION_CALL %s", iteration, item.name)

    # Elhasznált tokenek
    logger.info(
        "[iter=%d] TOKENS: in=%d out=%d",
        iteration, response.usage.input_tokens, response.usage.output_tokens,
    )

3. szint: Képernyőképek

Mentsd el a képernyőképeket utólagos hibakeresés céljából, de figyeld a lemezterületet: egy PNG mentés gyakran több száz kilobájtot nyom, egy hosszú munkafolyamat pedig több száz ilyet generál. Az alábbi osztály ezt egyszerű rotációval oldja meg. A fájlnév időbélyeggel kezdődik, így az ábécé sorrend megegyezik az időbeli sorrenddel; a _cleanup metódusban végzett rendezés így elegendő ahhoz, hogy azonosítsuk a legrégebbi képeket, és töröljük őket addig, amíg vissza nem csökkenünk száz fájl alá. A label mező lehetővé teszi érdekes pillanatok megjelölését, például error vagy before_validation, így azok első ránézésre kiszúrhatók a mappában.

from datetime import datetime, timezone
from pathlib import Path

class ScreenshotLogger:
    """Képernyőképek mentése rotációval."""

    def __init__(self, base_dir: str = "logs/screenshots", max_files: int = 100):
        self.base_dir = Path(base_dir)
        self.base_dir.mkdir(parents=True, exist_ok=True)
        self.max_files = max_files
        self.counter = 0

    def save(self, screenshot_bytes: bytes, iteration: int, label: str = ""):
        """Képernyőkép mentése leíró névvel."""
        ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
        filename = f"{ts}_iter{iteration:03d}_{label}.png"
        filepath = self.base_dir / filename

        with open(filepath, "wb") as f:
            f.write(screenshot_bytes)

        self.counter += 1
        self._cleanup()

        return filepath

    def _cleanup(self):
        """Régi képernyőképek törlése."""
        files = sorted(self.base_dir.glob("*.png"))
        while len(files) > self.max_files:
            files[0].unlink()
            files.pop(0)

Monitorozandó metrikák

Sikeresség
munkafolyamatonként
Átlagos
időtartam lépésenként
Költség
tokenben végrehajtásonként
Hibák
típus és gyakoriság szerint

Ez a négy mutató csak akkor értékes, ha időben önmagukhoz viszonyítjuk őket: ha egy munkafolyamat sikeressége kilencvenötről nyolcvan százalékra esik vissza, az jelzi, hogy egy felület elmozdult, jóval azelőtt, hogy az első felhasználó panaszkodna. Ezért implementálj egy metrikagyűjtőt, amely minden végrehajtáshoz kapcsolódik. A WorkflowMetrics adatosztály (dataclass) iterációról iterációra halmozza a tokeneket, nyomon követi a hibákat a lépésükkel és időbélyegükkel együtt, és két számított tulajdonságot tesz elérhetővé: az időtartamot (ami akkor is működik, ha a munkafolyamat még nem fejeződött be), valamint egy költségbecslést a használt modell árazása alapján, amelyet az OpenAI árazási oldaláról veszel át, nem pedig hardcoded értékként kezeled. A summary metódus előállítja azt a tömör szótárat, amelyet minden végrehajtásnál archiválni fogsz.

from dataclasses import dataclass, field
from datetime import datetime, timezone

def now() -> datetime:
    return datetime.now(timezone.utc)

@dataclass
class WorkflowMetrics:
    """Metrikák gyűjtése egy munkafolyamathoz."""
    workflow_id: str
    input_price_per_million: float  # a használt modell árazása
    output_price_per_million: float
    start_time: datetime = field(default_factory=now)
    end_time: datetime | None = None
    iterations: int = 0
    total_input_tokens: int = 0
    total_output_tokens: int = 0
    errors: list = field(default_factory=list)
    steps_completed: int = 0
    steps_total: int = 0

    def record_iteration(self, response):
        self.iterations += 1
        self.total_input_tokens += response.usage.input_tokens
        self.total_output_tokens += response.usage.output_tokens

    def record_error(self, error: str, step: str):
        self.errors.append({
            "step": step,
            "error": error,
            "timestamp": now().isoformat(),
        })

    def finalize(self):
        self.end_time = now()

    @property
    def duration_seconds(self) -> float:
        end = self.end_time or now()
        return (end - self.start_time).total_seconds()

    @property
    def estimated_cost_usd(self) -> float:
        # Becslés: a prompt gyorsítótárazást és a hosztolt környezetet nem számoljuk
        input_cost = self.total_input_tokens / 1_000_000 * self.input_price_per_million
        output_cost = self.total_output_tokens / 1_000_000 * self.output_price_per_million
        return input_cost + output_cost

    def summary(self) -> dict:
        return {
            "workflow_id": self.workflow_id,
            "duration_s": round(self.duration_seconds, 1),
            "iterations": self.iterations,
            "tokens": self.total_input_tokens + self.total_output_tokens,
            "cost_usd": round(self.estimated_cost_usd, 4),
            "success": len(self.errors) == 0,
            "errors": len(self.errors),
            "steps": f"{self.steps_completed}/{self.steps_total}",
        }

Monitorozó irányítópult

Valós idejű monitorozáshoz küldd el a metrikákat egy monitorozó szolgáltatásnak, ahelyett, hogy állni hagynád őket egy fájlban. Az alábbi függvény időbélyeggel ellátott összefoglalót küld egy HTTP végpontra, két olyan óvintézkedéssel, amelyek ugyanolyan fontosak, mint maga a küldés: maximum öt másodperces időtúllépés, és a kivételkezelés, amely beéri egy figyelmeztetéssel. Egy elérhetetlen metrikagyűjtő soha nem állíthatja le azt a munkafolyamatot, amelyet figyel – az ellenkezője lenne a kontraproduktív felügyelet definíciója.

import requests  # pip install requests

def push_metrics(metrics: WorkflowMetrics, endpoint: str):
    """Metrikák küldése egy monitorozó szolgáltatásnak."""
    payload = metrics.summary()
    payload["timestamp"] = now().isoformat()

    try:
        requests.post(
            endpoint,
            json=payload,  # a requests maga állítja be a JSON fejlécet
            timeout=5,
        )
    except requests.RequestException as e:
        logger.warning(f"Metrics push error: {e}")

Automatikus riasztások

Egy irányítópult, amelyet senki sem figyel, csupán egy archívum. Ezért állíts be küszöbértékeken alapuló riasztásokat, hogy az anomália keressen meg téged. Az itt megtartott négy feltétel klasszikus elcsúszásokat fed le: kettő dollárnál magasabb költség, három percet meghaladó időtartam, harmincnál több iteráció, vagy kettőnél több hiba ugyanabban a végrehajtásban. Ezek az értékek kiindulópontok, nem abszolút igazságok: kalibráld őket a saját sikeres végrehajtásaid mérései alapján, úgy helyezve el a küszöböt, hogy jóval a megfigyelt medián felett legyen. Egy olyan riasztás, amely minden nap megszólal, a második hétre már figyelmen kívül marad.

def check_alerts(metrics: WorkflowMetrics):
    """Küszöbértékek ellenőrzése és riasztások indítása."""
    alerts = []

    if metrics.estimated_cost_usd > 2.0:
        alerts.append(f"High cost: ${metrics.estimated_cost_usd:.2f}")

    if metrics.duration_seconds > 180:
        alerts.append(f"Excessive duration: {metrics.duration_seconds:.0f}s")

    if metrics.iterations > 30:
        alerts.append(f"Too many iterations: {metrics.iterations}")

    if len(metrics.errors) > 2:
        alerts.append(f"Multiple errors: {len(metrics.errors)}")

    for alert in alerts:
        logger.warning(f"ALERT: {alert}")
        # Értesítés küldése (e-mail, Slack stb.)

    return alerts

Szoktasd rá magad, hogy a check_alerts függvényt közvetlenül a finalize után hívod meg, majd a push_metrics-et: így minden végrehajtásnál kapsz egy archivált nyomvonalat, egy jelet az irányítópultra, és értesítést csak akkor, ha valami valóban figyelmet érdemel.

Főbb megállapítások

  • Naplózd a műveleteket, a modell üzeneteit és összefoglalóit, valamint a képernyőképeket három külön szinten
  • Figyeld a sikerességi rátát, az időtartamot, a tokenköltséget és a hibákat; a láncolt előzményeket minden körben újra számlázzák bemenetként
  • Implementálj képernyőkép-rotációt a lemezterület telítődésének elkerülésére
  • Állíts be automatikus riasztásokat kritikus küszöbértékekre
  • Soha ne naplózz érzékeny adatokat (jelszavak, tokenek, személyes adatok)