Monitorozás és naplózás
Ezen az oldalon
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_callobjektumból olvassa be a műveleteket, az elemeket pedig aresponse.outputtartalmából (üzenetek aphase, érvelési összefoglalók és hívások adatokkal), nem pedig az Anthropic APItool_useblokkjaiból; a korábban hardcoded Claude Sonnet árakat a használt modell aktuális árazása váltotta fel, és a elavultdatetime.utcnow()(Python 3.12 óta) helyett adatetime.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
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)