Monitorovanie a logovanie
Na tejto strane
Lekcia aktualizovaná 3. novembra 2026 na základe príručky Computer use od OpenAI a dokumentácie k Responses API: logovanie teraz číta akcie z
computer_calla prvky zresponse.output(správy s ichphase, zhrnutia úvah, volania), namiesto blokovtool_usez API Anthropic; hardcoded ceny modelu Claude Sonnet sú nahradené cenami práve používaného modelu a zastaraná funkciadatetime.utcnow()(od Pythonu 3.12) je nahradená funkcioudatetime.now(timezone.utc). Zdroje: Computer use · Ceny.
Sledovanie tvojho agenta v produkcii
Agent Computer Use v produkcii je čiernou skrinkou, ak nenastavíš správne monitorovanie. Na rozdiel od štandardného API, kde loguješ požiadavky a odpovede, tu musíš sledovať aj vizuálne akcie, snímky obrazovky a rozhodnutia modelu. Rozdiel je konkrétny: keď workflow zlyhá o tretej ráno, dôležitou otázkou nie je „aká výnimka bola vyvolaná“, ale „čo agent videl a prečo tam klikol?“. Log, ktorý na túto otázku neodpovie, ti nasledujúce ráno nepomôže.
Tri úrovne logovania
Inštrumentácia preto stojí na troch doplnkových vrstvách: čo agent urobil, čo si myslel pred tým, než to urobil, a čo videl pri rozhodovaní. Každá píše do iného kanála, pretože ani objem, ani užitočná životnosť nie sú rovnaké.
Úroveň 1: Akcie
Každá akcia vykonaná agentom musí byť zaznamenaná. Nižšie uvedený formát systematicky pridáva prefix s číslom iterácie a názvom aktuálneho kroku, čo ti umožňuje filtrovať log s niekoľkými tisícami riadkov až na jedinú sekvenciu, ktorá zlyhala. Akcie prichádzajú ako objekty z computer_call s rovnakými poľami ako v tvojom obslužnom programe (x, y, scroll_x, keys…). Všimni si spracovanie akcie type: zaznamenávame dĺžku zadaného textu, nikdy nie jeho obsah. Ak agent vypĺňa prihlasovací formulár a zadáva heslo, pravidlo z predchádzajúcej lekcie platí aj tu bez výnimky.
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()) # filter z lekcie 12
logger.addHandler(handler)
def log_action(action, iteration: int, step: str = ""):
"""Loguje akciu z computer_call."""
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":
# Nikdy samotný text: iba jeho dĺžka
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())
Úroveň 2: Rozhodnutia modelu
Loguj, čo model hovorí o svojich voľbách, aby si pochopil, prečo si vybral konkrétnu akciu. Kliknutie na neočakávané súradnice samo o ničom nehovorí; v spojení s vetou, ktorá mu predchádzala – „tlačidlo odoslať sa zdá byť skryté za bannerom so súhlasom so súbormi cookie“ – sa stáva diagnózou. Text je orezaný na dvesto znakov, čo úplne stačí na pochopenie zámeru bez explózie objemu súboru. V odpovedi Responses API existujú dva zdroje textu. Predbežné správy, ktoré model napíše pred konaním, majú phase: "commentary", zatiaľ čo konečná odpoveď má phase: "final_answer". A ak používaný model podporuje zhrnutia úvah, získaš ich ich vyžiadaním (reasoning={"summary": "auto"}): prichádzajú v prvkoch typu reasoning.
Spotreba tokenov sa loguje rovnakým tempom a zaslúži si pozornosť: aj pri použití previous_response_id sa všetky vstupné tokeny z predchádzajúcich odpovedí v reťazci znova účtujú ako vstup, snímky obrazovky nevynímajúc. Cena jedného kola sa preto so zvyšujúcou sa dĺžkou relácie zvyšuje.
def log_model_response(response, iteration: int):
"""Loguje poznámky, zhrnutia a volania z odpovede (okrem obrázkov)."""
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)
# Spotrebované tokeny
logger.info(
"[iter=%d] TOKENS: in=%d out=%d",
iteration, response.usage.input_tokens, response.usage.output_tokens,
)
Úroveň 3: Snímky obrazovky
Ukladaj snímky obrazovky pre následnú analýzu chybových stavov (post-mortem debugging), ale sleduj miesto na disku: jeden záber PNG často váži niekoľko stoviek kilobajtov a dlhé workflow ich vyprodukuje stovky. Nižšie uvedená trieda to rieši jednoduchou rotáciou. Názov súboru začína časovou pečiatkou, čím sa abecedné poradie zhoduje s chronologickým; triedenie v _cleanup potom stačí na identifikáciu najstarších záberov a ich vymazanie, kým sa počet nevráti pod strop sto súborov. Pole label ti umožňuje anotovať zaujímavé momenty, napríklad error alebo before_validation, a rýchlo ich nájsť v priečinku.
from datetime import datetime, timezone
from pathlib import Path
class ScreenshotLogger:
"""Ukladá snímky obrazovky s rotáciou."""
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 = ""):
"""Uloží snímku obrazovky s popisným názvom."""
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):
"""Vymaže staré snímky obrazovky."""
files = sorted(self.base_dir.glob("*.png"))
while len(files) > self.max_files:
files[0].unlink()
files.pop(0)
Metriky na monitorovanie
Tieto štyri ukazovatele majú hodnotu len vtedy, keď ich porovnávaš v čase so sebou samými: pokles úspešnosti workflow z deväťdesiatich piatich na osemdesiat percent ti signalizuje, že sa rozhranie zmenilo, dlho predtým, než si prvý používateľ sťažuje. Implementuj preto zberač metrík pripojený ku každému vykonaniu. Dátová trieda WorkflowMetrics akumuluje tokeny iteráciu po iterácii, sleduje chyby s ich krokom a časovou pečiatkou a poskytuje dve vypočítané vlastnosti: duration (doba trvania), ktorá funguje aj vtedy, ak workflow ešte nie je dokončené, a odhad nákladov založený na cenách práve používaného modelu, ktoré si vezmeš zo stránky s cenami OpenAI namiesto hardcoded hodnôt. Metóda summary vytvorí kompaktný slovník, ktorý archivuješ pri každom vykonaní.
from dataclasses import dataclass, field
from datetime import datetime, timezone
def now() -> datetime:
return datetime.now(timezone.utc)
@dataclass
class WorkflowMetrics:
"""Zhromažďuje metriky pre workflow."""
workflow_id: str
input_price_per_million: float # ceny pre používaný model
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:
# Odhad: ukladanie promptov do cache a hostované prostredie sa nepočítajú
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}",
}
Monitorovací dashboard
Pre monitorovanie v reálnom čase odosielaj metriky do monitorovacej služby, namiesto toho, aby spali v súbore. Nižšie uvedená funkcia odosiela časovo označené zhrnutie na HTTP endpoint s dvoma opatreniami, ktoré sú rovnako dôležité ako samotné odoslanie: maximálne oneskorenie päť sekúnd a zachytená výnimka, ktorá sa uspokojí s upozornením. Nedostupný zberač metrík nesmie nikdy zhodiť workflow, ktoré pozoruje – opak by bol definíciou kontraproduktívneho dohľadu.
import requests # pip install requests
def push_metrics(metrics: WorkflowMetrics, endpoint: str):
"""Odošle metriky do monitorovacej služby."""
payload = metrics.summary()
payload["timestamp"] = now().isoformat()
try:
requests.post(
endpoint,
json=payload, # requests sám nastaví hlavičku JSON
timeout=5,
)
except requests.RequestException as e:
logger.warning(f"Chyba odoslania metrík: {e}")
Automatické alerty
Dashboard, ktorý nikto nesleduje, je len archív. Nakonfiguruj preto alerty založené na prahových hodnotách, aby sa anomália dostala k tebe. Štyri tu uvedené podmienky pokrývajú klasické drifty: náklady vyššie ako dva doláre, trvanie presahujúce tri minúty, viac ako tridsať iterácií alebo viac ako dve chyby v rovnakom vykonaní. Tieto hodnoty sú východiskovými bodmi, nie pravdami: kalibruj ich na meraniach z vlastných úspešných vykonaní a prahovú hodnotu umiestni vysoko nad pozorovaný medián. Alert, ktorý sa spúšťa každý deň, bude druhý týždeň ignorovaný.
def check_alerts(metrics: WorkflowMetrics):
"""Kontroluje prahové hodnoty a spúšťa alerty."""
alerts = []
if metrics.estimated_cost_usd > 2.0:
alerts.append(f"Vysoké náklady: ${metrics.estimated_cost_usd:.2f}")
if metrics.duration_seconds > 180:
alerts.append(f"Nadmerné trvanie: {metrics.duration_seconds:.0f}s")
if metrics.iterations > 30:
alerts.append(f"Príliš veľa iterácií: {metrics.iterations}")
if len(metrics.errors) > 2:
alerts.append(f"Viaceré chyby: {len(metrics.errors)}")
for alert in alerts:
logger.warning(f"ALERT: {alert}")
# Odoslať notifikáciu (e-mail, Slack atď.)
return alerts
Zvykni si volať check_alerts hneď po finalize a potom push_metrics: získaš archivovanú stopu pri každom vykonaní, signál odoslaný na dashboard a notifikáciu len vtedy, keď si niečo zaslúži tvoju pozornosť.
Kľúčové poznatky
- Loguj akcie, správy a zhrnutia modelu a snímky obrazovky na troch samostatných úrovniach
- Monitoruj mieru úspešnosti, trvanie, náklady na tokeny a chyby; prepojená história sa v každom kole znova účtuje ako vstup
- Implementuj rotáciu snímok obrazovky, aby sa nezaplnil disk
- Nastav automatické alerty na kritické prahové hodnoty
- Nikdy neloguj citlivé údaje (heslá, tokeny, osobné údaje)