Övervakning och loggning
På denna sida
Lektionen uppdaterad 3 november 2026 baserat på OpenAIs guide för Computer use och dokumentationen för Responses API: loggning läser nu åtgärder från ett
computer_calloch element frånresponse.output(meddelanden med derasphase, resonemangssammanfattningar, anrop), istället förtool_use-block från Anthropic API; hårdkodad prissättning för Claude Sonnet ersätts med prissättning för den modell som används, och den föråldradedatetime.utcnow()(sedan Python 3.12) ersätts avdatetime.now(timezone.utc). Källor: Computer use · Pricing.
Att observera din agent i produktion
En Computer Use-agent i produktion är en svart låda om du inte sätter upp korrekt övervakning. Till skillnad från ett vanligt API där du loggar förfrågningar och svar, måste du här också spåra visuella åtgärder, skärmdumpar och modellens beslut. Skillnaden är konkret: när ett arbetsflöde misslyckas klockan 03.00 är frågan som spelar roll inte “vilket undantag utlöstes”, utan “vad såg agenten, och varför klickade den där?”. En logg som inte svarar på den frågan hjälper dig inte nästa morgon.
De tre loggningsnivåerna
Instrumenteringen bygger därför på tre kompletterande lager: vad agenten gjorde, vad den tänkte innan den gjorde det, och vad den såg när den beslutade. Varje lager skriver till en egen kanal eftersom varken volymen eller den användbara livslängden är densamma.
Nivå 1: Åtgärder
Varje åtgärd som agenten utför måste spåras. Formatet nedan prefixar systematiskt iterationsnumret och namnet på det aktuella steget, vilket låter dig filtrera en logg på flera tusen rader ner till den enskilda sekvens som gick fel. Åtgärder anländer som objekt från computer_call, med samma fält som i din hanterare (x, y, scroll_x, keys…). Notera hanteringen av åtgärden type: vi registrerar längden på den inmatade texten, aldrig innehållet. En agent som fyller i ett inloggningsformulär skriver ett lösenord, och regeln från föregående lektion gäller här utan undantag.
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 från lektion 12
logger.addHandler(handler)
def log_action(action, iteration: int, step: str = ""):
"""Loggar en åtgärd från ett 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":
# Aldrig själva texten: bara dess längd
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())
Nivå 2: Modellbeslut
Logga vad modellen säger om sina val för att förstå varför den valde en specifik åtgärd. Ett klick vid oväntade koordinater betyder inget i sig; parat med meningen som föregick det – “knappen för skicka verkar vara dold av cookie-bannern” – blir det en diagnos. Texten trunkeras till tvåhundra tecken, mer än nog för att fatta avsikten utan att spränga filvolymen. Det finns två textkällor i ett svar från Responses API. Intermediära meddelanden som modellen skriver innan den agerar bär phase: "commentary", medan det slutgiltiga svaret bär phase: "final_answer". Och om modellen som används stöder sammanfattningar av resonemang får du dem genom att begära dem (reasoning={"summary": "auto"}): de anländer i element av typen reasoning.
Tokenförbrukning loggas i samma takt, och den förtjänar noggrann uppmärksamhet: även med previous_response_id debiteras alla inmatningstokens från tidigare svar i kedjan på nytt som inmatning, inklusive skärmdumpar. Kostnaden för en omgång ökar därför ju längre sessionen blir.
def log_model_response(response, iteration: int):
"""Loggar anteckningar, sammanfattningar och anrop från ett svar (exklusive bilder)."""
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)
# Förbrukade tokens
logger.info(
"[iter=%d] TOKENS: in=%d out=%d",
iteration, response.usage.input_tokens, response.usage.output_tokens,
)
Nivå 3: Skärmdumpar
Spara skärmdumpar för felsökning i efterhand, men håll koll på ditt diskutrymme: en PNG-bild väger ofta flera hundra kilobyte, och ett långt arbetsflöde producerar hundratals av dem. Klassen nedan löser detta med enkel rotation. Filnamnet börjar med en tidsstämpel, vilket alignerar alfabetisk ordning med kronologisk ordning; sortering i _cleanup räcker sedan för att identifiera de äldsta bilderna och radera dem tills antalet sjunker under taket på hundra filer. Fältet label låter dig annotera intressanta ögonblick, till exempel error eller before_validation, och spotte dem vid en första anblick i mappen.
from datetime import datetime, timezone
from pathlib import Path
class ScreenshotLogger:
"""Sparar skärmdumpar med 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 = ""):
"""Sparar en skärmdump med ett beskrivande namn."""
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):
"""Raderar gamla skärmdumpar."""
files = sorted(self.base_dir.glob("*.png"))
while len(files) > self.max_files:
files[0].unlink()
files.pop(0)
Mätvärden att övervaka
Dessa fyra indikatorer är bara värdefulla när de jämförs med sig själva över tid: ett arbetsflöde som sjunker från 95 till 80 procents framgång berättar att ett gränssnitt har flyttats, långt innan den första användaren klagar. Implementera därför en mätvärdesinsamlare kopplad till varje körning. Dataklassen WorkflowMetrics ackumulerar tokens iteration efter iteration, håller reda på fel med deras steg och tidsstämpel, och exponerar två beräknade egenskaper: varaktighet, vilket fungerar även om arbetsflödet inte är avslutat än, och en kostnadsuppskattning baserad på prissättningen för den modell som används, vilken du hämtar från OpenAIs prissida istället för att hårdkoda. Metoden summary producerar den kompakta ordlista du kommer att arkivera vid varje körning.
from dataclasses import dataclass, field
from datetime import datetime, timezone
def now() -> datetime:
return datetime.now(timezone.utc)
@dataclass
class WorkflowMetrics:
"""Samlar in mätvärden för ett arbetsflöde."""
workflow_id: str
input_price_per_million: float # prissättning för modellen som används
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:
# Uppskattning: prompt-cachning och en hostad miljö räknas inte
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}",
}
Övervakningsdashboard
För övervakning i realtid, skicka mätvärden till en övervakningstjänst istället för att låta dem sova i en fil. Funktionen nedan postar den tidsstämplade sammanfattningen till en HTTP-slutpunkt, med två försiktighetsåtgärder som är lika viktiga som själva sändningen: en maximal fördröjning på fem sekunder, och ett fångat undantag som nöjer sig med en varning. En otillgänglig mätvärdesinsamlare får aldrig få ner det arbetsflöde den observerar – motsatsen vore definitionen av kontraproduktiv övervakning.
import requests # pip install requests
def push_metrics(metrics: WorkflowMetrics, endpoint: str):
"""Skickar mätvärden till en övervakningstjänst."""
payload = metrics.summary()
payload["timestamp"] = now().isoformat()
try:
requests.post(
endpoint,
json=payload, # requests sätter JSON-headern själv
timeout=5,
)
except requests.RequestException as e:
logger.warning(f"Metrics push error: {e}")
Automatiska varningar
En dashboard som ingen tittar på är bara ett arkiv. Konfigurera därför varningar baserade på tröskelvärden så att anomalin kommer till dig. De fyra villkoren som behållits här täcker klassiska avvikelser: en kostnad högre än två dollar, en varaktighet som överstiger tre minuter, fler än trettio iterationer, eller fler än två fel i samma körning. Dessa värden är startpunkter, inte sanningar: kalibrera dem på mätningar från dina egna lyckade körningar, och placera tröskeln väl över din observerade median. En varning som utlöses varje dag kommer att ignoreras från den andra veckan.
def check_alerts(metrics: WorkflowMetrics):
"""Kontrollerar tröskelvärden och utlöser varningar."""
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}")
# Skicka notifiering (e-post, Slack, etc.)
return alerts
Gör det till en vana att anropa check_alerts direkt efter finalize, och sedan push_metrics: du får en arkiverad spårning vid varje körning, en signal skickad till dashboarden, och en notifiering endast när något förtjänar din uppmärksamhet.
Viktiga punkter
- Logga åtgärder, modellmeddelanden och sammanfattningar, samt skärmdumpar på tre separata nivåer
- Övervaka framgångsfrekvens, varaktighet, tokenkostnad och fel; den kedjade historiken debiteras som inmatning vid varje omgång
- Implementera rotation av skärmdumpar för att undvika att mätta disken
- Sätt upp automatiska varningar vid kritiska tröskelvärden
- Logga aldrig känslig data (lösenord, tokens, personuppgifter)