Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Παρακολούθηση και καταγραφή συμβάντων

Μάθημα 13 / 14 Ενημερώθηκε 3 Νοεμβρίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Παρατήρηση του πράκτορά σας σε παραγωγή
  2. Τα τρία επίπεδα καταγραφής
  3. Μετρικές προς παρακολούθηση
  4. Πίνακας ελέγχου παρακολούθησης
  5. Αυτόματες ειδοποιήσεις
  6. Βασικά σημεία

Μάθημα ενημερώθηκε στις 3 Νοεμβρίου 2026 με βάση τον οδηγό Computer use της OpenAI και την τεκμηρίωση του Responses API: η καταγραφή συμβάντων διαβάζει πλέον ενέργειες από ένα computer_call και στοιχεία από το response.output (μηνύματα με το phase τους, περιλήψεις συλλογισμού, κλήσεις), αντί για τα μπλοκ tool_use από το API της Anthropic· οι σταθερές τιμές του Claude Sonnet αντικαθίστανται από την τιμολόγηση του μοντέλου που χρησιμοποιείται, και το απαξιωμένο datetime.utcnow() (από την Python 3.12) αντικαθίσταται από το datetime.now(timezone.utc). Πηγές: Computer use · Τιμολόγηση.

Παρατήρηση του πράκτορά σας σε παραγωγή

Ένας πράκτορας Computer Use σε περιβάλλον παραγωγής αποτελεί «μαύρο κουτί» αν δεν ρυθμίσετε κατάλληλη παρακολούθηση. Σε αντίθεση με ένα τυπικό API όπου καταγράφετε αιτήματα και αποκρίσεις, εδώ πρέπει επίσης να ιχνηλατείτε οπτικές ενέργειες, στιγμιότυπα οθόνης και τις αποφάσεις του μοντέλου. Η διαφορά είναι συγκεκριμένη: όταν μια ροή εργασίας αποτυγχάνει στις 3 π.μ., το ερώτημα που έχει σημασία δεν είναι «ποια εξαίρεση εγέρθηκε», αλλά «τι είδε ο πράκτορας και γιατί έκανε κλικ εκεί;». Ένα αρχείο καταγραφής που δεν απαντά σε αυτό το ερώτημα δεν θα σας βοηθήσει το επόμενο πρωί.

Τα τρία επίπεδα καταγραφής

Η οργανομέτρηση βασίζεται επομένως σε τρία συμπληρωματικά επίπεδα: τι έκανε ο πράκτορας, τι σκέφτηκε πριν το κάνει και τι είδε όταν αποφάσιζε. Το καθένα γράφει σε διαφορετικό κανάλι, καθώς ούτε ο όγκος ούτε η χρήσιμη διάρκεια ζωής τους είναι ίδια.

Επίπεδο 1: Ενέργειες

Κάθε ενέργεια που εκτελεί ο πράκτορας πρέπει να ιχνηλατείται. Η παρακάτω μορφή προσθέτει συστηματικά ως πρόθεμα τον αριθμό επανάληψης και το όνομα του τρέχοντος βήματος, επιτρέποντάς σας να φιλτράρετε ένα αρχείο καταγραφής several χιλιάδων γραμμών μέχρι την ακολουθία που πήγε στραβά. Οι ενέργειες φτάνουν ως αντικείμενα από το 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())  # filter from lesson 12
logger.addHandler(handler)


def log_action(action, iteration: int, step: str = ""):
    """Logs an action from a 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":
            # Never the text itself: only its length
            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: Αποφάσεις μοντέλου

Καταγράψτε τι λέει το μοντέλο για τις επιλογές του για να κατανοήσετε γιατί επέλεξε μια συγκεκριμένη ενέργεια. Ένα κλικ σε απροσδόκητες συντεταγμένες δεν σημαίνει τίποτα από μόνο του· σε συνδυασμό με την πρόταση που προηγήθηκε —«το κουμπί υποβολής φαίνεται κρυμμένο από το banner cookies»— γίνεται διάγνωση. Το κείμενο περικόπτεται στους διακόσιους χαρακτήρες, αρκετούς για να κατανοήσετε την πρόθεση χωρίς να εκτοξεύσετε τον όγκο του αρχείου. Υπάρχουν δύο πηγές κειμένου σε μια απόκριση Responses API. Τα ενδιάμεσα μηνύματα που γράφει το μοντέλο πριν ενεργήσει φέρουν phase: "commentary", ενώ η τελική απόκριση φέρει phase: "final_answer". Και αν το μοντέλο που χρησιμοποιείτε υποστηρίζει περιλήψεις συλλογισμού, τις λαμβάνετε ζητώντας τες (reasoning={"summary": "auto"}): φτάνουν σε στοιχεία τύπου reasoning.

Η κατανάλωση token καταγράφεται με τον ίδιο ρυθμό και αξίζει στενή προσοχή: ακόμη και με previous_response_id, όλα τα token εισόδου από προηγούμενες αποκρίσεις στην αλυσίδα χρεώνονται εκ νέου ως είσοδος, συμπεριλαμβανομένων των στιγμιότυπων οθόνης. Το κόστος ενός γύρου αυξάνεται επομένως καθώς η συνεδρία μακραίνει.

def log_model_response(response, iteration: int):
    """Logs notes, summaries, and calls from a response (excluding images)."""
    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)

    # Tokens consumed
    logger.info(
        "[iter=%d] TOKENS: in=%d out=%d",
        iteration, response.usage.input_tokens, response.usage.output_tokens,
    )

Επίπεδο 3: Στιγμιότυπα οθόνης

Αποθηκεύστε στιγμιότυπα οθόνης για μεταθανάτια αποσφαλμάτωση, αλλά προσέξτε τον χώρο στον δίσκο: ένα στιγμιότυπο PNG ζυγίζει συχνά αρκετές εκατοντάδες kilobytes και μια μακρά ροή εργασίας παράγει εκατοντάδες από αυτά. Η παρακάτω κλάση λύνει το πρόβλημα με απλή περιστροφή. Το όνομα αρχείου ξεκινά με χρονοσήμανση, ευθυγραμμίζοντας την αλφαβητική σειρά με τη χρονολογική· η ταξινόμηση στο _cleanup αρκεί τότε για να εντοπιστούν οι παλαιότερες λήψεις και να διαγραφούν μέχρι να πέσουμε κάτω από το ανώτατο όριο των εκατό αρχείων. Το πεδίο label σάς επιτρέπει να σχολιάζετε ενδιαφέρουσες στιγμές, για παράδειγμα error ή before_validation, και να τις εντοπίζετε με μια ματιά στον φάκελο.

from datetime import datetime, timezone
from pathlib import Path

class ScreenshotLogger:
    """Saves screenshots with rotation."""

    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 = ""):
        """Saves a screenshot with a descriptive name."""
        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):
        """Deletes old screenshots."""
        files = sorted(self.base_dir.glob("*.png"))
        while len(files) > self.max_files:
            files[0].unlink()
            files.pop(0)

Μετρικές προς παρακολούθηση

Ποσοστό
επιτυχίας ανά ροή εργασίας
Μέση
διάρκεια ανά βήμα
Κόστος
σε token ανά εκτέλεση
Σφάλματα
ανά τύπο και συχνότητα

Αυτοί οι τέσσερις δείκτες έχουν αξία μόνο όταν συγκρίνονται με τον εαυτό τους στον χρόνο: μια ροή εργασίας που πέφτει από ενενήντα πέντε σε ογδόντα τοις εκατό επιτυχία σας λέει ότι μια διεπαφή μετακινήθηκε, πολύ πριν παραπονεθεί ο πρώτος χρήστης. Επομένως, υλοποιήστε έναν συλλέκτη μετρικών προσαρτημένο σε κάθε εκτέλεση. Το dataclass WorkflowMetrics συσσωρεύει token επανάληψη προς επανάληψη, παρακολουθεί τα σφάλματα με το βήμα και τη χρονοσήμανσή τους και εκθέτει δύο υπολογισμένες ιδιότητες: τη διάρκεια, η οποία λειτουργεί ακόμη και αν η ροή εργασίας δεν έχει ολοκληρωθεί, και μια εκτίμηση κόστους βάσει της τιμολόγησης του μοντέλου που χρησιμοποιείται, την οποία λαμβάνετε από τη σελίδα τιμολόγησης της OpenAI αντί να την κωδικοποιήσετε στατικά. Η μέθοδος summary παράγει το συμπαγές λεξικό που θα αρχειοθετείτε σε κάθε εκτέλεση.

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

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

@dataclass
class WorkflowMetrics:
    """Collects metrics for a workflow."""
    workflow_id: str
    input_price_per_million: float  # pricing for the model in use
    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:
        # Estimate: prompt caching and a hosted environment are not counted
        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 endpoint, με δύο προφυλάξεις που έχουν τόση σημασία όσο και η ίδια η αποστολή: μέγιστη καθυστέρηση πέντε δευτερολέπτων και παγιδευμένη εξαίρεση που αρκείται σε μια προειδοποίηση. Ένας μη διαθέσιμος συλλέκτης μετρικών δεν πρέπει ποτέ να ρίξει τη ροή εργασίας που παρατηρεί· το αντίθετο θα ήταν ο ορισμός της αντιπαραγωγικής εποπτείας.

import requests  # pip install requests

def push_metrics(metrics: WorkflowMetrics, endpoint: str):
    """Sends metrics to a monitoring service."""
    payload = metrics.summary()
    payload["timestamp"] = now().isoformat()

    try:
        requests.post(
            endpoint,
            json=payload,  # requests sets the JSON header itself
            timeout=5,
        )
    except requests.RequestException as e:
        logger.warning(f"Metrics push error: {e}")

Αυτόματες ειδοποιήσεις

Ένας πίνακας ελέγχου που κανείς δεν παρακολουθεί είναι απλώς ένα αρχείο. Επομένως, διαμορφώστε ειδοποιήσεις βάσει κατωφλίων ώστε η ανωμαλία να έρχεται σε εσάς. Οι τέσσερις συνθήκες που κρατήθηκαν εδώ καλύπτουν κλασικές αποκλίσεις: κόστος υψηλότερο από δύο δολάρια, διάρκεια που υπερβαίνει τα τρία λεπτά, περισσότερες από τριάντα επαναλήψεις ή περισσότερα από δύο σφάλματα στην ίδια εκτέλεση. Αυτές οι τιμές είναι σημεία εκκίνησης, όχι αλήθειες: βαθμονομήστε τες σε μετρήσεις από τις δικές σας επιτυχημένες εκτελέσεις, τοποθετώντας το κατώφλι πολύ πάνω από τον παρατηρούμενο διάμεσο. Μια ειδοποίηση που ενεργοποιείται κάθε μέρα θα αγνοηθεί από τη δεύτερη εβδομάδα.

def check_alerts(metrics: WorkflowMetrics):
    """Checks thresholds and triggers alerts."""
    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}")
        # Send notification (email, Slack, etc.)

    return alerts

Κάντε συνήθεια να καλείτε το check_alerts αμέσως μετά το finalize και έπειτα το push_metrics: έχετε έτσι ένα αρχειοθετημένο ίχνος σε κάθε εκτέλεση, ένα σήμα που στέλνεται στον πίνακα ελέγχου και μια ειδοποίηση μόνο όταν κάτι αξίζει την προσοχή σας.

Βασικά σημεία

  • Καταγράφετε ενέργειες, μηνύματα και περιλήψεις μοντέλου, καθώς και λήψεις σε τρία ξεχωριστά επίπεδα
  • Παρακολουθείτε το ποσοστό επιτυχίας, τη διάρκεια, το κόστος token και τα σφάλματα· το αλυσιδωτό ιστορικό χρεώνεται εκ νέου ως είσοδος σε κάθε γύρο
  • Υλοποιήστε περιστροφή στιγμιότυπων οθόνης για να αποφύγετε τον κορεσμό του δίσκου
  • Ρυθμίστε αυτόματες ειδοποιήσεις σε κρίσιμα κατώφλια
  • Μην καταγράφετε ποτέ ευαίσθητα δεδομένα (κωδικούς πρόσβασης, token, προσωπικά δεδομένα)