Järelevalve ja logimine
Sellel lehel
Tund uuendatud 3. novembril 2026, lähtudes OpenAI Computer use juhendist ja Responses API dokumentatsioonist: logimine loeb nüüd tegevusi
computer_call-ist ja elementeresponse.output-ist (sõnumid koos nendephase, põhjenduste kokkuvõtete ja väljakutsetega), mitte Anthropicu APItool_useplokke; kodeeritud Claude Sonneti hinnastus on asendatud kasutatava mudeli hinnastusega ja iganenuddatetime.utcnow()(alates Python 3.12-st) on asendatuddatetime.now(timezone.utc)-ga. Allikad: Computer use · Pricing.
Oma agendi jälgimine tootmises
Tootmises olev Computer Use agent on must kast, kui sa ei sea sisse korralikku järelevalvet. Erinevalt tavapärasest API-st, kus logid päringuid ja vastuseid, pead siin jälgima ka visuaalseid tegevusi, ekraanitõmmiseid ja mudeli otsuseid. Erinevus on konkreetne: kui töövoog kukub läbi kell 3 öösel, pole oluline küsimus „milline erand tekitati“, vaid „mida agent nägi ja miks ta sinna klõpsas?“. Logi, mis sellele küsimusele ei vasta, ei aita sind järgmisel hommikul.
Logimise kolm taset
Instrumenteerimine põhineb seetõttu kolmel täiendaval kihil: mida agent tegi, mida ta enne tegutsemist mõtles ja mida ta otsuse langetamisel nägi. Igaüks kirjutab erinevasse kanalisse, sest neither maht ega kasulik eluiga pole samad.
1. tase: Tegevused
Iga agendi poolt tehtud tegevus tuleb jälgida. Allpool olev vorming lisab süstemaatiliselt iteratsiooni numbri ja praeguse sammu nime, võimaldades sul filtreerida mitme tuhande rea pikkuse logi alla ühele ainukesele järjestusele, mis valesti läks. Tegevused saabuvad objektidena computer_call-ist, samade väljadega nagu sinu käitlejas (x, y, scroll_x, keys…). Pane tähele type tegevuse käsitlemist: me salvestame sisestatud teksti pikkuse, mitte kunagi selle sisu. Agent, kes täidab sisselogimisvormi, trükib parooli ja eelmise tunni reegel kehtib siin eranditeta.
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 from lesson 12
logger.addHandler(handler)
def log_action(action, iteration: int, step: str = ""):
"""Logs an action from a 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":
# Never the text itself: only its length
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. tase: Mudeli otsused
Logi, mida mudel oma valikute kohta ütleb, et mõista, miks ta valis konkreetse tegevuse. Klõps ootamatutel koordinaatidel ei tähenda iseenesest midagi; koos seda eelnenud lausega – „saada nupp paistab olevat küpsisebänneri poolt peidetud“ – muutub see diagnoosiks. Tekst lühendatakse kahe saja tähemärgini, mis on enam kui piisav kavatsuse mõistmiseks ilma failimahtu plahvatamata. Responses API vastuses on kaks tekstiallikat. Vahepealsed sõnumid, mida mudel kirjutab enne tegutsemist, kannavad phase: "commentary", samas kui lõplik vastus kannab phase: "final_answer". Ja kui kasutatav mudel toetab põhjenduste kokkuvõtteid, saad need, kui need pärid (reasoning={"summary": "auto"}): need saabuvad tüüpi reasoning elementidena.
Tokenite tarbimist logitakse sama kiirusega ja see väärib tähelepanelikku jälgimist: isegi previous_response_id korral arveldatakse kõik eelmiste vastuste sisendtokenid ahelas uuesti sisendina, kaasa arvatud ekraanitõmmised. Pöörde hind kasvab seetõttu sessiooni pikenedes.
def log_model_response(response, iteration: int):
"""Logs notes, summaries, and calls from a response (excluding images)."""
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)
# Tokens consumed
logger.info(
"[iter=%d] TOKENS: in=%d out=%d",
iteration, response.usage.input_tokens, response.usage.output_tokens,
)
3. tase: Ekraanitõmmised
Salvesta ekraanitõmmised järelanalüüsiks, kuid jälgi oma kettaruumi: PNG-vormingus jäädvustus kaalub sageli mitusada kilobaiti ja pikk töövoog toodab sadu neist. Allpool olev klass lahendab selle lihtsa rotatsiooniga. Failinimi algab ajatempliga, joondades tähestikulise järjekorra kronoloogilise järjekorraga; sorteerimine _cleanup-is on seejärel piisav vanimate jäädvustuste tuvastamiseks ja kustutamiseks, kuni langeme tagasi alla saja faili lae. Väli label võimaldab sul märkida huvitavaid hetki, näiteks error või before_validation, ja need kaustas pilguga ära tunda.
from datetime import datetime, timezone
from pathlib import Path
class ScreenshotLogger:
"""Saves screenshots with rotation."""
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 = ""):
"""Saves a screenshot with a descriptive name."""
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):
"""Deletes old screenshots."""
files = sorted(self.base_dir.glob("*.png"))
while len(files) > self.max_files:
files[0].unlink()
files.pop(0)
Jälgitavad mõõdikud
Need neli näitajat on väärtuslikud ainult siis, kui neid võrreldakse ajas nendega endiga: töövoog, mis langeb üheksakümne viielt kaheksakümnele protsendile, annab märku, et liides on nihkunud, ammu enne kui esimene kasutaja kaebab. Seetõttu rakenda iga täitmise külge kinnitatud mõõdikute koguja. Andmeklass WorkflowMetrics kogub tokeneid iteratsioon iteratsiooni haaval, peab arvet vigadest koos nende sammu ja ajatempliga ning avaldab kaks arvutatud omadust: kestus, mis töötab isegi kui töövoog pole veel lõppenud, ja kuluhinnang, mis põhineb kasutatava mudeli hinnastusel, mille võtad OpenAI hinnalehelt, mitte ei kodeeri seda käsitsi. Meetod summary toodab kompaktse sõnastiku, mille arhiveerid iga täitmise juures.
from dataclasses import dataclass, field
from datetime import datetime, timezone
def now() -> datetime:
return datetime.now(timezone.utc)
@dataclass
class WorkflowMetrics:
"""Collects metrics for a workflow."""
workflow_id: str
input_price_per_million: float # pricing for the model in use
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:
# Estimate: prompt caching and a hosted environment are not counted
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}",
}
Järelevalve armatuurlaud
Reaalajas jälgimiseks saada mõõdikud järelevalveteenusesse, selle asemel et lasta neil failis magada. Allpool olev funktsioon postitab ajatemplitud kokkuvõtte HTTP-lõpppunkti, kahe ettevaatusabinõuga, mis on sama olulised kui saatmine ise: maksimaalne viivitus viis sekundit ja püütud erand, mis lepitab hoiatusega. Kättesaamatu mõõdikute koguja ei tohi kunagi nurjata töövoogu, mida ta jälgib – vastupidine oleks vastutootliku järelevalve definitsioon.
import requests # pip install requests
def push_metrics(metrics: WorkflowMetrics, endpoint: str):
"""Sends metrics to a monitoring service."""
payload = metrics.summary()
payload["timestamp"] = now().isoformat()
try:
requests.post(
endpoint,
json=payload, # requests sets the JSON header itself
timeout=5,
)
except requests.RequestException as e:
logger.warning(f"Metrics push error: {e}")
Automaatsed hoiatused
Armatuurlaud, mida keegi ei vaata, on lihtsalt arhiiv. Seetõttu konfigureeri hoiatused lävendite põhjal, et anomaalia tuleks sinu juurde. Siin säilitatud neli tingimust katavad klassikalised kõrvalekalded: kulu üle kahe dollari, kestus üle kolme minuti, rohkem kui kolmkümmend iteratsiooni või rohkem kui kaks viga samal täitmisel. Need väärtused on lähtepunktid, mitte tõed: kalibreeri neid omaenda edukate täitmiste mõõtmiste põhjal, asetades lävendi hästi üle oma vaadeldud mediaani. Hoiatus, mis käivitub iga päev, ignoreeritakse teiseks nädalaks.
def check_alerts(metrics: WorkflowMetrics):
"""Checks thresholds and triggers alerts."""
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}")
# Send notification (email, Slack, etc.)
return alerts
Harjuta kutsuma check_alerts kohe pärast finalize, seejärel push_metrics: saad iga täitmise juures arhiveeritud jälje, signaali saadetud armatuurlauale ja teavituse ainult siis, kui midagi väärib sinu tähelepanu.
Peamised punktid
- Logi tegevused, mudeli sõnumid ja kokkuvõtted ning jäädvustused kolmel eraldatud tasemel
- Jälgi õnnestumismäära, kestust, tokenite kulu ja vigu; aheldatud ajalugu arveldatakse iga pöörde juures uuesti sisendina
- Rakenda ekraanitõmmiste rotatsioon, et vältida ketta ületäitumist
- Seadista automaatsed hoiatused kriitilistel lävenditel
- Ära kunagi logi tundlikke andmeid (paroolid, tokenid, isikuandmed)