Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Uzraudzība un žurnālu reģistrēšana

Nodarbība 13 no 14 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Sava aģenta novērošana ražošanas vidē
  2. Trīs žurnālu reģistrēšanas līmeņi
  3. Uzraugāmie rādītāji
  4. Uzraudzības panelis
  5. Automātiski brīdinājumi
  6. Galvenās atziņas

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_call un elementus no response.output (ziņojumi ar to phase, secinājumu kopsavilkumiem, izsaukumiem), nevis tool_use blokus 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 ar datetime.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

Veiksmes
rādītājs katrā darbplūsmā
Vidējais
ilgums katrā solī
Izmaksas
tokenos par izpildi
Kļūdas
pēc veida un biežuma

Š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)