Uzraudzība un žurnālu reģistrēšana
Šajā lapā
Nodarbība atjaunināta 2026. gada 3. novembrī, balstoties uz OpenAI Computer use rokasgrāmatu un Responses API dokumentāciju: žurnālu reģistrēšana tagad nolasa darbības no
computer_callun elementus noresponse.output(ziņojumi ar tophase, secinājumu kopsavilkumiem, izsaukumiem), nevistool_useblokus no Anthropic API; iepriekš iekodētās Claude Sonnet cenas ir aizstātas ar izmantotā modeļa cenām, un novecojusīdatetime.utcnow()(kopš Python 3.12) ir aizstāta ardatetime.now(timezone.utc). Avoti: Computer use · Cenas.
Sava aģenta novērošana ražošanas vidē
Computer Use aģents ražošanas vidē ir melnā kaste, ja neizveido atbilstošu uzraudzību. Atšķirībā no standarta API, kur reģistrējat pieprasījumus un atbildes, šeit jums ir jāizseko arī vizuālās darbības, ekrānuzņēmumi un modeļa lēmumi. Atšķirība ir konkrēta: ja darbplūsma neizdodas pulksten 3 naktī, svarīgākais jautājums nav “kāds izņēmums tika izraisīts”, bet gan “ko aģents redzēja un kāpēc tas noklikšķināja tieši tur?”. Žurnāls, kas neatbild uz šo jautājumu, jums nākamajā rītā nepalīdzēs.
Trīs žurnālu reģistrēšanas līmeņi
Tāpēc instrumentācija balstās uz trim papildinošiem slāņiem: ko aģents darīja, ko tas domāja pirms darbības veikšanas un ko tas redzēja, pieņemot lēmumu. Katrs raksta savā kanālā, jo ne apjoms, ne lietderīgais kalpošanas laiks nav vienāds.
1. līmenis: Darbības
Katra aģenta veiktā darbība ir jāreģistrē. Tālāk redzamais formāts sistemātiski pievieno iterācijas numuru un pašreizējā soļa nosaukumu, ļaujot filtrēt vairāku tūkstošu rindu žurnālu līdz vienīgajai secībai, kas izgāja greizi. Darbības nonāk kā objekti no computer_call ar tādiem pašiem laukiem kā jūsu apdarinātājā (x, y, scroll_x, keys…). Ņemiet vērā type darbības apstrādi: mēs reģistrējam ievadītā teksta garumu, nekad tā saturu. Aģents, aizpildot pieteikšanās veidlapu, ieraksta paroli, un iepriekšējās nodarbības noteikums šeit attiecas bez izņēmumiem.
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()) # filtrs no 12. nodarbības
logger.addHandler(handler)
def log_action(action, iteration: int, step: str = ""):
"""Reģistrē darbību no 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":
# Nekad pats teksts: tikai tā garums
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. līmenis: Modeļa lēmumi
Reģistrējiet to, ko modelis saka par savu izvēli, lai saprastu, kāpēc tas izvēlējās konkrētu darbību. Noklikšķināšana negaidītās koordinātās pati par sevi neko nenozīmē; apvienojumā ar teikumu, kas tai priekšā – „iesniegšanas poga šķiet paslēpta aiz sīkdatņu banera” – tā kļūst par diagnozi. Teksts tiek saīsināts līdz divsimt rakstzīmēm, kas ir vairāk nekā pietiekami, lai saprastu nodomu, nespridzinot faila apjomu. Responses API atbildē pastāv divi teksta avoti. Starpziņojumus, ko modelis raksta pirms darbības, pavada phase: "commentary", bet galīgo atbildi pavada phase: "final_answer". Un ja izmantotais modelis atbalsta secinājumu kopsavilkumus, jūs tos saņemat, pieprasot tos (reasoning={"summary": "auto"}): tie nonāk elementos ar tipu reasoning.
Tokena patēriņš tiek reģistrēts tajā pašā ritmā, un tas ir pelnījis lielu uzmanību: pat ar previous_response_id, visi iepriekšējo atbilžu ievades tokeni ķēdē tiek atkārtoti apmaksāti kā ievade, ieskaitot ekrānuzņēmumus. Tādējādi viena apgrieziena izmaksas pieaug, sesijai pagarinoties.
def log_model_response(response, iteration: int):
"""Reģistrē piezīmes, kopsavilkumus un izsaukumus no atbildes (izņemot attēlus)."""
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)
# Patērētie tokeni
logger.info(
"[iter=%d] TOKENS: in=%d out=%d",
iteration, response.usage.input_tokens, response.usage.output_tokens,
)
3. līmenis: Ekrānuzņēmumi
Saglabājiet ekrānuzņēmumus pēcnāves atkļūdošanai, bet sekojiet līdzi diska vietai: PNG attēls bieži vien sver vairākus simtus kilobaitu, un gara darbplūsma rada simtiem no tiem. Tālāk redzamā klase to atrisina ar vienkāršu rotāciju. Faila nosaukums sākas ar laika zīmogu, saskaņojot alfabētisko kārtību ar hronoloģisko; šķirošana funkcijā _cleanup tad ir pietiekama, lai identificētu vecākos uzņēmumus un dzēstu tos, līdz skaits nokrītas zem simt failu griestiem. Lauks label ļauj anotēt interesantus brīžus, piemēram, error vai before_validation, un acumirklī tos pamanīt mapē.
from datetime import datetime, timezone
from pathlib import Path
class ScreenshotLogger:
"""Saglabā ekrānuzņēmumus ar rotāciju."""
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 = ""):
"""Saglabā ekrānuzņēmumu ar aprakstošu nosaukumu."""
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):
"""Dzēš vecos ekrānuzņēmumus."""
files = sorted(self.base_dir.glob("*.png"))
while len(files) > self.max_files:
files[0].unlink()
files.pop(0)
Uzraugāmie rādītāji
Šie četri rādītāji ir vērtīgi tikai tad, ja tos salīdzina pašus ar sevi laika gaitā: darbplūsmai, kuras veiksmes rādītājs krītas no deviņdesmit pieciem uz astoņdesmit procentiem, tas norāda, ka saskarne ir pārvietojusies, krietni pirms pirmais lietotājs sūdzas. Tāpēc ieviesiet metrikas vācēju, kas piesaistīts katrai izpildei. Datu klase WorkflowMetrics uzkrāj tokenus iterāciju pēc iterācijas, izseko kļūdām ar to soli un laika zīmogu un eksponē divas aprēķinātās īpašības: ilgumu, kas darbojas pat tad, ja darbplūsma vēl nav pabeigta, un izmaksu aplēsi, kas balstīta uz izmantotā modeļa cenām, kuras jūs ņemat no OpenAI cenu lapas, nevis iekodējat. Metode summary ģenerē kompaktu vārdnīcu, ko arhivēsiet katras izpildes beigās.
from dataclasses import dataclass, field
from datetime import datetime, timezone
def now() -> datetime:
return datetime.now(timezone.utc)
@dataclass
class WorkflowMetrics:
"""Vāc metrikas darbplūsmai."""
workflow_id: str
input_price_per_million: float # izmantotā modeļa cenas
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:
# Aplēse: pieprasījumu kešošana un mitināta vide netiek skaitīta
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}",
}
Uzraudzības panelis
Lai veiktu uzraudzību reāllaikā, nosūtiet metrikas uzraudzības servisam, nevis ļaujiet tām gulēt failā. Tālāk redzamā funkcija nosūta laika zīmoga kopsavilkumu uz HTTP galapunktu, ievērojot divus piesardzības pasākumus, kas ir tikpat svarīgi kā pati nosūtīšana: maksimālais aizkaves laiks ir piecas sekundes, un noķertais izņēmums aprobežojas ar brīdinājumu. Nepieejams metrikas vācējs nedrīkst apturēt darbplūsmu, ko tas novēro – pretējais būtu kontrproduktīvas uzraudzības definīcija.
import requests # pip install requests
def push_metrics(metrics: WorkflowMetrics, endpoint: str):
"""Nosūta metrikas uzraudzības servisam."""
payload = metrics.summary()
payload["timestamp"] = now().isoformat()
try:
requests.post(
endpoint,
json=payload, # requests pats iestata JSON headeri
timeout=5,
)
except requests.RequestException as e:
logger.warning(f"Metrics push error: {e}")
Automātiski brīdinājumi
Panelis, ko neviens neskatās, ir tikai arhīvs. Tāpēc konfigurējiet brīdinājumus, pamatojoties uz sliekšņiem, lai anomālija nonāktu pie jums. Šeit saglabātie četri nosacījumi aptver klasiskas novirzes: izmaksas, kas pārsniedz divus dolārus, ilgums, kas pārsniedz trīs minūtes, vairāk nekā trīsdesmit iterācijas vai vairāk nekā divas kļūdas vienā izpildē. Šīs vērtības ir sākumpunkti, nevis patiesības: kalibrējiet tās, balstoties uz savu veiksmīgo izpildžu mērījumiem, novietojot slieksni ievērojami virs novērotās mediānas. Brīdinājums, kas tiek aktivizēts katru dienu, otrajā nedēļā tiks ignorēts.
def check_alerts(metrics: WorkflowMetrics):
"""Pārbauda sliekšņus un aktivizē brīdinājumus."""
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}")
# Nosūtīt paziņojumu (e-pasts, Slack u.c.)
return alerts
Pieradiet izsaukt check_alerts tūlīt pēc finalize, un tad push_metrics: jūs iegūstat arhivētu izsekojamību katrā izpildē, signālu, kas nosūtīts panelim, un paziņojumu tikai tad, kad kaut kas ir pelnījis jūsu uzmanību.
Galvenās atziņas
- Reģistrējiet darbības, modeļa ziņojumus un kopsavilkumus, kā arī uzņēmumus trīs atsevišķos līmeņos
- Uzraugiet veiksmes rādītāju, ilgumu, tokena izmaksas un kļūdas; ķēdes vēsture tiek atkārtoti apmaksāta kā ievade katrā aplī
- Ieviesiet ekrānuzņēmumu rotāciju, lai izvairītos no diska piesātināšanas
- Iestatiet automātiskus brīdinājumus par kritiskiem sliekšņiem
- Nekad nereģistrējiet sensitīvus datus (paroles, tokenus, personas datus)