Премини към основното съдържание
Български— Изберете език
Меню

Мониторинг и регистриране на събития

Урок 13 от 14 Обновен 3 ноември 2026 г. Програмист
На тази страница
  1. Наблюдение на Вашия агент в продукционна среда
  2. Трите нива на регистриране
  3. Метрики за мониторинг
  4. Табло за мониторинг
  5. Автоматични предупреждения
  6. Ключови изводи

Урокът е актуализиран на 3 ноември 2026 г. въз основа на ръководството на OpenAI за Computer use и документацията на Responses API: регистрирането вече чете действията от computer_call, а елементите – от response.output (съобщения с техните phase, обобщения на разсъжденията, повиквания), вместо блоковете tool_use от API на Anthropic; твърдо кодираното ценообразуване на Claude Sonnet е заменено с това на използвания модел, а остарялата функция datetime.utcnow() (от Python 3.12 насам) е заменена с datetime.now(timezone.utc). Източници: Computer use · Pricing.

Наблюдение на Вашия агент в продукционна среда

Агентът за Computer Use в продукционна среда е „черна кутия“, ако не настроите подходящ мониторинг. За разлика от стандартното API, където регистрирате само заявките и отговорите, тук трябва да проследявате и визуалните действия, екранните снимки и решенията на модела. Разликата е конкретна: когато работен поток се провали в 3 часа сутринта, важният въпрос не е „какво изключение беше генерирано“, а „какво видя агентът и защо кликна точно там?“. Регистър, който не отговаря на този въпрос, няма да Ви помогне на следващата сутрин.

Трите нива на регистриране

Инструментирането следователно се гради върху три допълващи се слоя: какво е направил агентът, какво е мислил преди да го направи и какво е видял, когато е вземал решението. Всеки слой пише в различен канал, защото нито обемът, нито полезният живот на данните са еднакви.

Ниво 1: Действия

Всяко действие, изпълнено от агента, трябва да бъде проследено. Форматът по-долу систематично добавя префикс с номера на итерацията и името на текущата стъпка, което Ви позволява да филтрирате регистър от няколко хиляди реда до единствената последователност, която е се е объркала. Действията пристигат като обекти от computer_call, със същите полета като във Вашия обработчик (x, y, scroll_x, keys…). Обърнете внимание на обработката на действието type: записваме дължината на въведения текст, никога неговото съдържание. Агент, който попълва форма за вход, въвежда парола и правилото от предишния урок важи тук без изключение.

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())  # филтър от урок 12
logger.addHandler(handler)


def log_action(action, iteration: int, step: str = ""):
    """Регистрира действие от 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":
            # Никога самият текст: само неговата дължина
            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: Решения на модела

Регистрирайте какво казва моделът за своите избори, за да разберете защо е избрал конкретно действие. Кликване на неочаквани координати само по себе си не означава нищо; съчетано с изречението, което му е предхождало – „бутонът за изпращане изглежда скрит зад банера за бисквитки“ – то се превръща в диагноза. Текстът се съкращава до двеста знака, което е повече от достатъчно, за да се схване намерението, без да се раздуе обемът на файла. В отговора на Responses API съществуват два източника на текст. Междинните съобщения, които моделът пише преди да действа, носят phase: "commentary", докато крайният отговор носи phase: "final_answer". И ако използваният модел поддържа обобщения на разсъжденията, можете да ги получите, като ги поискате (reasoning={"summary": "auto"}): те пристигат в елементи от тип reasoning.

Консумацията на токени се регистрира със същата честота и заслужава специално внимание: дори с previous_response_id, всички входни токени от предишни отговори във веригата се таксуват отново като вход, включително екранните снимки. Следователно цената на един цикъл нараства с удължаването на сесията.

def log_model_response(response, iteration: int):
    """Регистрира бележки, обобщения и повиквания от отговор (без изображения)."""
    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)

    # Консумирани токени
    logger.info(
        "[iter=%d] TOKENS: in=%d out=%d",
        iteration, response.usage.input_tokens, response.usage.output_tokens,
    )

Ниво 3: Екранни снимки

Запазвайте екранни снимки за последващ анализ при грешки (post-mortem debugging), но следете дисковото пространство: едно PNG изображение често тежи няколкостотин килобайта, а един дълъг работен поток произвежда стотици такива. Класът по-долу решава проблема с проста ротация. Името на файла започва с времеви печат, подравнявайки азбучния ред с хронологичния; сортирането в _cleanup след това е достатъчно, за да се идентифицират най-старите снимки и да се изтрият, докато броят им падне под тавана от сто файла. Полето label Ви позволява да анотирате интересни моменти, например error или before_validation, и да ги откривате с един поглед в папката.

from datetime import datetime, timezone
from pathlib import Path

class ScreenshotLogger:
    """Запазва екранни снимки с ротация."""

    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 = ""):
        """Запазва екранна снимка с описателно име."""
        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):
        """Изтрива стари екранни снимки."""
        files = sorted(self.base_dir.glob("*.png"))
        while len(files) > self.max_files:
            files[0].unlink()
            files.pop(0)

Метрики за мониторинг

Успешност
на работен поток
Средна
продължителност на стъпка
Разход
в токени на изпълнение
Грешки
по тип и честота

Тези четири показателя имат стойност само когато се сравняват със самите себе си във времето: спад на успешността на работен поток от деветдесет и пет на осемдесет процента Ви подсказва, че интерфейсът се е преместил, много преди първият потребител да се оплаче. Затова внедрете колектор за метрики, прикрепен към всяко изпълнение. Класът данни WorkflowMetrics натрупва токени итерация след итерация, следи грешките с тяхната стъпка и времеви печат и предоставя две изчислени свойства: продължителност, която работи дори ако работният поток все още не е завършен, и оценка на разхода въз основа на ценообразуването на използвания модел, което вземате от страницата с цени на OpenAI, вместо да го твърдо кодирате. Методът summary произвежда компактен речник, който ще архивирате при всяко изпълнение.

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

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

@dataclass
class WorkflowMetrics:
    """Събира метрики за работен поток."""
    workflow_id: str
    input_price_per_million: float  # ценообразуване за използвания модел
    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:
        # Оценка: кеш паметта на промптовете и хостваната среда не се броят
        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}",
        }

Табло за мониторинг

За мониторинг в реално време изпращайте метриките към услуга за мониторинг, вместо да ги оставяте да спят във файл. Функцията по-долу публикува обобщението с времеви печат към HTTP крайна точка, с две предпазни мерки, които са също толкова важни, колкото и самото изпращане: максимално забавяне от пет секунди и хванато изключение, което се ограничава до предупреждение. Недостъпен колектор за метрики никога не трябва да срива работния поток, който наблюдава – обратното би било дефиниция за контрапродуктивен надзор.

import requests  # pip install requests

def push_metrics(metrics: WorkflowMetrics, endpoint: str):
    """Изпраща метрики към услуга за мониторинг."""
    payload = metrics.summary()
    payload["timestamp"] = now().isoformat()

    try:
        requests.post(
            endpoint,
            json=payload,  # requests сам задава JSON заглавката
            timeout=5,
        )
    except requests.RequestException as e:
        logger.warning(f"Metrics push error: {e}")

Автоматични предупреждения

Табло, което никой не наблюдава, е просто архив. Затова конфигурирайте предупреждения въз основа на прагове, така аномалията да идва при Вас. Четирите условия, запазени тук, покриват класически отклонения: разход, по-висок от два долара, продължителност, надвишаваща три минути, повече от тридесет итерации или повече от две грешки в едно и също изпълнение. Тези стойности са отправни точки, а не истини: калибрирайте ги въз основа на измервания от Вашите собствени успешни изпълнения, като поставите прага добре над наблюдаваната медиана. Предупреждение, което се задейства всеки ден, ще бъде игнорирано още втората седмица.

def check_alerts(metrics: WorkflowMetrics):
    """Проверява прагове и задейства предупреждения."""
    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}")
        # Изпращане на известие (имейл, Slack и др.)

    return alerts

Направете си навик да извиквате check_alerts веднага след finalize, а след това push_metrics: така получавате архивирана следа при всяко изпълнение, сигнал, изпратен до таблото, и известие само когато нещо заслужава Вашето внимание.

Ключови изводи

  • Регистрирайте действията, съобщенията и обобщенията на модела, както и екранните снимки на три отделни нива
  • Следете процента на успех, продължителността, разхода за токени и грешките; верижната история се таксува отново като вход при всеки цикъл
  • Внедрете ротация на екранните снимки, за да избегнете запълване на диска
  • Настройте автоматични предупреждения за критични прагове
  • Никога не регистрирайте чувствителни данни (пароли, токени, лични данни)