Przejdź do głównej treści
Polski— Wybierz język
Menu

Monitorowanie i logowanie

Lekcja 13 z 14 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Obserwacja Twojego agenta w produkcji
  2. Trzy poziomy logowania
  3. Metryki do monitorowania
  4. Panel monitoringu
  5. Automatyczne alerty
  6. Kluczowe wnioski

Lekcja zaktualizowana 3 listopada 2026 na podstawie przewodnika Computer use od OpenAI oraz dokumentacji Responses API: logowanie obecnie odczytuje akcje z computer_call, a elementy z response.output (wiadomości z ich phase, podsumowaniami rozumowania, wywołaniami), zamiast bloków tool_use z API Anthropic; zakodowane na sztywno ceny modelu Claude Sonnet zastąpiono cenami używanego modelu, a przestarzałe datetime.utcnow() (od Pythona 3.12) zastąpiono przez datetime.now(timezone.utc). Źródła: Computer use · Cennik.

Obserwacja Twojego agenta w produkcji

Agent Computer Use działający w środowisku produkcyjnym jest czarną skrzynką, jeśli nie skonfigurujesz odpowiedniego monitoringu. W przeciwieństwie do standardowego API, gdzie logujesz żądania i odpowiedzi, tutaj musisz również śledzić działania wizualne, zrzuty ekranu oraz decyzje modelu. Różnica jest konkretna: gdy przepływ pracy zawiedzie o 3 nad ranem, kluczowym pytaniem nie jest „jaki wyjątek został zgłoszony“, ale „co zobaczył agent i dlaczego kliknął właśnie tam?“. Log, który nie odpowiada na to pytanie, nie pomoże Ci następnego ranka.

Trzy poziomy logowania

Instrumentacja opiera się zatem na trzech uzupełniających się warstwach: co agent zrobił, co myślał przed wykonaniem działania i co widział podczas podejmowania decyzji. Każda z nich zapisuje dane do innego kanału, ponieważ ani ich objętość, ani przydatny czas życia nie są takie same.

Poziom 1: Akcje

Każda akcja wykonana przez agenta musi być śledzona. Poniższy format systematycznie dodaje prefiks z numerem iteracji i nazwą bieżącego kroku, co pozwala przefiltrować log liczący kilka tysięcy linii do pojedynczej sekwencji, która zawiodła. Akcje docierają jako obiekty z computer_call, z tymi samymi polami co w Twoim handlerze (x, y, scroll_x, keys…). Zwróć uwagę na obsługę akcji type: rejestrujemy długość wprowadzonego tekstu, nigdy jego zawartość. Agent wypełniający formularz logowania wpisuje hasło i zasada z poprzedniej lekcji ma tu zastosowanie bez wyjątku.

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())  # filtr z lekcji 12
logger.addHandler(handler)


def log_action(action, iteration: int, step: str = ""):
    """Loguje akcję 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":
            # Nigdy sam tekst: tylko jego długość
            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())

Poziom 2: Decyzje modelu

Loguj to, co model mówi o swoich wyborach, aby zrozumieć, dlaczego podjął konkretną akcję. Kliknięcie w nieoczekiwanych współrzędnych samo w sobie nic nie znaczy; w połączeniu ze zdaniem, które je poprzedziło – „przycisk wysyłania wydaje się zasłonięty przez baner cookie“ – staje się diagnozą. Tekst jest skracany do dwustu znaków, co w zupełności wystarcza, by zrozumieć intencję bez drastycznego zwiększania objętości pliku. W odpowiedzi Responses API istnieją dwa źródła tekstu. Wiadomości pośrednie, które model zapisuje przed działaniem, mają phase: "commentary", podczas gdy odpowiedź końcowa ma phase: "final_answer". A jeśli używany model obsługuje podsumowania rozumowania, otrzymasz je, żądając ich (reasoning={"summary": "auto"}): pojawią się w elementach typu reasoning.

Zużycie tokenów jest logowane w tym samym tempie i zasługuje na szczególną uwagę: nawet przy użyciu previous_response_id, wszystkie tokeny wejściowe z poprzednich odpowiedzi w łańcuchu są ponownie rozliczane jako dane wejściowe, włącznie ze zrzutami ekranu. Koszt pojedynczego cyklu rośnie więc wraz z wydłużaniem się sesji.

def log_model_response(response, iteration: int):
    """Loguje notatki, podsumowania i wywołania z odpowiedzi (z wyłączeniem obrazów)."""
    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)

    # Zużyte tokeny
    logger.info(
        "[iter=%d] TOKENS: in=%d out=%d",
        iteration, response.usage.input_tokens, response.usage.output_tokens,
    )

Poziom 3: Zrzuty ekranu

Zapisuj zrzuty ekranu do analizy powypadkowej, ale uważaj na miejsce na dysku: pojedynczy plik PNG często waży kilkaset kilobajtów, a długi przepływ pracy generuje ich setki. Poniższa klasa rozwiązuje ten problem dzięki prostej rotacji. Nazwa pliku zaczyna się od znacznika czasu, co sprawia, że kolejność alfabetyczna pokrywa się z chronologiczną; sortowanie w metodzie _cleanup wystarcza zatem do zidentyfikowania najstarszych przechwyceń i usunięcia ich, aż liczba plików spadnie poniżej pułapu stu. Pole label pozwala annotować istotne momenty, na przykład error lub before_validation, i błyskawicznie je odnaleźć w folderze.

from datetime import datetime, timezone
from pathlib import Path

class ScreenshotLogger:
    """Zapisuje zrzuty ekranu z rotacją."""

    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 = ""):
        """Zapisuje zrzut ekranu z opisową nazwą."""
        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):
        """Usuwa stare zrzuty ekranu."""
        files = sorted(self.base_dir.glob("*.png"))
        while len(files) > self.max_files:
            files[0].unlink()
            files.pop(0)

Metryki do monitorowania

Wskaźnik
sukcesu na przepływ
Średni
czas trwania kroku
Koszt
w tokenach na wykonanie
Błędy
według typu i częstotliwości

Te cztery wskaźniki mają wartość tylko wtedy, gdy porównuje się je do nich samych w czasie: spadek wskaźnika sukcesu przepływu pracy z dziewięćdziesięciu pięciu do osiemdziesięciu procent informuje Cię, że interfejs uległ zmianie, na długo zanim pierwszy użytkownik zacznie narzekać. Dlatego zaimplementuj kolektor metryk podpięty do każdego wykonania. Klasa danych WorkflowMetrics kumuluje tokeny iteracja po iteracji, śledzi błędy wraz z ich krokiem i znacznikiem czasu oraz udostępnia dwie właściwości obliczeniowe: czas trwania, który działa nawet jeśli przepływ pracy nie został jeszcze zakończony, oraz szacunkowy koszt oparty na cenniku używanego modelu, który pobierasz ze strony cennika OpenAI, zamiast kodować go na sztywno. Metoda summary generuje zwarty słownik, który będziesz archiwizować przy każdym wykonaniu.

from dataclasses import dataclass, field
from datetime import datetime, timezone

def now() -> datetime:
    return datetime.now(timezone.utc)

@dataclass
class WorkflowMetrics:
    """Zbiera metryki dla przepływu pracy."""
    workflow_id: str
    input_price_per_million: float  # cennik dla używanego modelu
    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:
        # Szacunek: buforowanie promptów i środowisko hostowane nie są liczone
        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}",
        }

Panel monitoringu

Do monitoringu w czasie rzeczywistym wysyłaj metryki do usługi monitorującej, zamiast pozwalać im spać w pliku. Poniższa funkcja wysyła podsumowanie ze znacznikiem czasu na punkt końcowy HTTP, z dwoma środkami ostrożności równie ważnymi co samo wysyłanie: maksymalnym opóźnieniem pięciu sekund i przechwyconym wyjątkiem, który poprzestaje na ostrzeżeniu. Niedostępny kolektor metryk nigdy nie może zatrzymać przepływu pracy, który obserwuje – przeciwny scenariusz byłby definicją kontrproduktywnego nadzoru.

import requests  # pip install requests

def push_metrics(metrics: WorkflowMetrics, endpoint: str):
    """Wysyła metryki do usługi monitorującej."""
    payload = metrics.summary()
    payload["timestamp"] = now().isoformat()

    try:
        requests.post(
            endpoint,
            json=payload,  # requests sam ustawia nagłówek JSON
            timeout=5,
        )
    except requests.RequestException as e:
        logger.warning(f"Błąd wysyłania metryk: {e}")

Automatyczne alerty

Panel, którego nikt nie obserwuje, to jedynie archiwum. Dlatego skonfiguruj alerty oparte na progach, aby anomalia sama do Ciebie dotarła. Cztery warunki zachowane tutaj pokrywają klasyczne dryfy: koszt wyższy niż dwa dolary, czas trwania przekraczający trzy minuty, więcej niż trzydzieści iteracji lub więcej niż dwa błędy w tym samym wykonaniu. Te wartości to punkty wyjścia, nie prawdy absolutne: skalibruj je na pomiarach z własnych, udanych wykonań, ustawiając próg znacznie powyżej obserwowanej mediany. Alert wyzwalany codziennie zostanie zignorowany już w drugim tygodniu.

def check_alerts(metrics: WorkflowMetrics):
    """Sprawdza progi i wyzwala alerty."""
    alerts = []

    if metrics.estimated_cost_usd > 2.0:
        alerts.append(f"Wysoki koszt: ${metrics.estimated_cost_usd:.2f}")

    if metrics.duration_seconds > 180:
        alerts.append(f"Nadmierny czas trwania: {metrics.duration_seconds:.0f}s")

    if metrics.iterations > 30:
        alerts.append(f"Zbyt wiele iteracji: {metrics.iterations}")

    if len(metrics.errors) > 2:
        alerts.append(f"Wiele błędów: {len(metrics.errors)}")

    for alert in alerts:
        logger.warning(f"ALERT: {alert}")
        # Wyślij powiadomienie (e-mail, Slack itp.)

    return alerts

Weź sobie za nawyk wywoływanie check_alerts zaraz po finalize, a następnie push_metrics: uzyskasz w ten sposób zarchiwizowany ślad przy każdym wykonaniu, sygnał wysłany do panelu i powiadomienie tylko wtedy, gdy coś zasługuje na Twoją uwagę.

Kluczowe wnioski

  • Loguj akcje, wiadomości i podsumowania modelu oraz przechwycone obrazy na trzech oddzielnych poziomach
  • Monitoruj wskaźnik sukcesu, czas trwania, koszt tokenów i błędy; powiązana historia jest rozliczana jako dane wejściowe w każdym cyklu
  • Zaimplementuj rotację zrzutów ekranu, aby uniknąć zapchania dysku
  • Skonfiguruj automatyczne alerty na krytyczne progi
  • Nigdy nie loguj danych wrażliwych (hasła, tokeny, dane osobowe)