Monitorowanie i logowanie
Na tej stronie
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 zresponse.output(wiadomości z ichphase, podsumowaniami rozumowania, wywołaniami), zamiast blokówtool_usez API Anthropic; zakodowane na sztywno ceny modelu Claude Sonnet zastąpiono cenami używanego modelu, a przestarzałedatetime.utcnow()(od Pythona 3.12) zastąpiono przezdatetime.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
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)