Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Logning og observerbarhed

Lektion 15 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Logning og observerbarhed
  2. Grundlæggende struktureret logning
  3. Lognings-middleware
  4. Sporing af kald med kontekst
  5. Eksport til et overvågningssystem
  6. Vigtige pointer

Logning og observerbarhed

I produktion skal du vide præcis, hvad der sker med dine API-kald: ventetid, forbrugte tokens, fejl og omkostninger. Struktureret logning og observerbarhed giver dig denne indsigt. Forskellen bliver tydelig i det øjeblik, en bruger rapporterer: „Assistenten har været langsom siden i morges.” Uden instrumentering står du tilbage med gætterier. Med den kan du på tredive sekunder se, at p95-ventetiden er fordoblet efter en ændring af prompten, der tredoblede kontekststørrelsen.

Grundlæggende struktureret logning

Gør det til en vane at måle omkring kaldet, ikke inde i det. Aflæs uret før, læs det igen bagefter, og udsend én enkelt linje, der beskriver hele hændelsen. JSON er ikke bare pynt: Det lader din aggregator filtrere på status, spore duration_ms over tid eller slå en specifik response_id op – noget frit tekstformat aldrig kan. Blokken except producerer nøjagtig samme struktur, inklusive undtagelsestypen og beskeden, og genudløser derefter fejlen. Logning er ikke håndtering.

import logging
import json
import time
from openai import OpenAI

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(message)s"
)
logger = logging.getLogger("openai_api")

client = OpenAI()

def appel_avec_logging(prompt: str, model: str = "gpt-5.6-terra") -> str:
    """API-kald med fuld struktureret logning."""
    start = time.monotonic()
    request_id = None

    try:
        response = client.responses.create(
            model=model,
            input=prompt
        )

        duree = time.monotonic() - start

        logger.info(json.dumps({
            "event": "api_call",
            "status": "success",
            "model": response.model,
            "response_id": response.id,
            "input_tokens": response.usage.input_tokens,
            "output_tokens": response.usage.output_tokens,
            "total_tokens": response.usage.total_tokens,
            "duration_ms": round(duree * 1000),
            "prompt_length": len(prompt),
        }))

        return response.output_text

    except Exception as e:
        duree = time.monotonic() - start

        logger.error(json.dumps({
            "event": "api_call",
            "status": "error",
            "error_type": type(e).__name__,
            "error_message": str(e),
            "model": model,
            "duration_ms": round(duree * 1000),
            "prompt_length": len(prompt),
        }))
        raise

resultat = appel_avec_logging("Hello!")

Bemærk, at vi logger prompt_length, ikke selve prompten. Det er et designvalg, ikke en oversight: Længden er nok til at korrelere med ventetid uden at eksportere brugerdata til dit logningssystem.

Lognings-middleware

Hvis du gentager denne blok i hver funktion, der kalder API’et, garanterer du, at du glemmer det et sted. Det er bedre at wrappe klienten én gang for alle. Dataklassen APIMetrics definerer kontrakten for, hvad vi måler, og ObservableClient udfylder denne post og arkiverer den, uanset om kaldet lykkes eller fejler. Metoden rapport omdanner derefter historikken til direkte handlingsdygtige måletal: succesrate, gennemsnitlig ventetid, p95-ventetid.

Det sidste tal er vigtigst. Et gennemsnit på 450 ms kan skjule den ene ud af tyve brugere, der venter tre sekunder; p95 afslører det. Ved at sortere varighederne og tage værdien ved 95. percentilen beskriver du den reelle oplevelse for dine dårligst betjente aktive brugere.

from dataclasses import dataclass, field
from typing import Optional
import time
import json

@dataclass
class APIMetrics:
    """Måletal indsamlet for hvert kald."""
    model: str = ""
    input_tokens: int = 0
    output_tokens: int = 0
    total_tokens: int = 0
    duration_ms: int = 0
    status: str = "unknown"
    error: Optional[str] = None
    response_id: Optional[str] = None

class ObservableClient:
    """OpenAI-klient med indbygget observerbarhed."""

    def __init__(self):
        self.client = OpenAI()
        self.metrics_history: list[APIMetrics] = []

    def create(self, model: str, input: str, **kwargs) -> object:
        start = time.monotonic()
        metrics = APIMetrics(model=model)

        try:
            response = self.client.responses.create(
                model=model,
                input=input,
                **kwargs
            )

            metrics.status = "success"
            metrics.response_id = response.id
            metrics.input_tokens = response.usage.input_tokens
            metrics.output_tokens = response.usage.output_tokens
            metrics.total_tokens = response.usage.total_tokens
            metrics.duration_ms = round((time.monotonic() - start) * 1000)

            self.metrics_history.append(metrics)
            return response

        except Exception as e:
            metrics.status = "error"
            metrics.error = str(e)
            metrics.duration_ms = round((time.monotonic() - start) * 1000)
            self.metrics_history.append(metrics)
            raise

    def rapport(self) -> dict:
        """Generer en rapport over indsamlede måletal."""
        if not self.metrics_history:
            return {"message": "No calls recorded"}

        total_calls = len(self.metrics_history)
        erreurs = sum(1 for m in self.metrics_history if m.status == "error")
        total_tokens = sum(m.total_tokens for m in self.metrics_history)
        durees = [m.duration_ms for m in self.metrics_history]

        return {
            "total_appels": total_calls,
            "erreurs": erreurs,
            "taux_succes": f"{((total_calls - erreurs) / total_calls) * 100:.1f}%",
            "total_tokens": total_tokens,
            "latence_moyenne_ms": round(sum(durees) / len(durees)),
            "latence_p95_ms": sorted(durees)[int(len(durees) * 0.95)],
        }

# Brug
obs_client = ObservableClient()

obs_client.create("gpt-5.6-terra", "Hello!")
obs_client.create("gpt-5.6-terra", "How are you?")
obs_client.create("gpt-5.6-terra", "Thanks!")

print(json.dumps(obs_client.rapport(), indent=2))
# Resultat:
# {
#   "total_appels": 3,
#   "erreurs": 0,
#   "taux_succes": "100.0%",
#   "total_tokens": 95,
#   "latence_moyenne_ms": 450,
#   "latence_p95_ms": 520
# }

Sporing af kald med kontekst

I en distribueret arkitektur eksisterer et API-kald aldrig isoleret: Det udløses af en HTTP-forespørgsel, som igen stammer fra en brugerhandling, og nogle gange følges det op af to flere kald. trace_id er den tråd, der binder disse hændelser sammen. Ved at propagere det fra dit weblag – her user-123-req-456 – kan du rekonstruere en hel session i dine logs ud fra en enkelt kundeklage. Der udsendes to linjer, én ved start og én ved afslutning, hvilket også hjælper med at spotte kald, der aldrig returnerede.

import uuid

class TracingClient:
    """Klient med sporing til korrelation af forespørgsler."""

    def __init__(self):
        self.client = OpenAI()

    def create_with_trace(self, prompt: str, trace_id: str = None,
                          **kwargs) -> tuple:
        """Kald med trace_id til korrelation."""
        if trace_id is None:
            trace_id = str(uuid.uuid4())[:8]

        start = time.monotonic()

        logger.info(json.dumps({
            "event": "api_request_start",
            "trace_id": trace_id,
            "prompt_preview": prompt[:100],
        }))

        response = self.client.responses.create(
            model=kwargs.get("model", "gpt-5.6-terra"),
            input=prompt,
            **{k: v for k, v in kwargs.items() if k != "model"}
        )

        duration = time.monotonic() - start

        logger.info(json.dumps({
            "event": "api_request_complete",
            "trace_id": trace_id,
            "response_id": response.id,
            "tokens": response.usage.total_tokens,
            "duration_ms": round(duration * 1000),
        }))

        return response, trace_id

# Brug med trace_id til korrelation i logs
tracing = TracingClient()
response, trace = tracing.create_with_trace(
    "Summarize logging best practices.",
    trace_id="user-123-req-456"
)
print(f"Trace: {trace} | Response: {response.output_text[:80]}...")

Vær forsigtig med prompt_preview: De første hundrede tegn går direkte ind i dine logs, som de er. Acceptabelt i udvikling, men fjern det, så snart rigtige data strømmer.

Eksport til et overvågningssystem

En historik i hukommelsen forsvinder, når processen genstartes. For at overvåge en tjeneste over tid skal du eksponere måletal til et eksternt værktøj. Det universelle mønster stole på to familier: tællere, som kun stiger og udledes til rater, og histogrammer, som beholder en fordeling til at udtrække percentiler. Denne klasse er bevidst neutral – du skal blot forbinde get_metrics til et endpoint, som Prometheus kan scrape, eller skubbe ordbogen til Datadog.

# Mønster til eksport til Prometheus, Datadog osv.
class MetricsExporter:
    """Målekseksportør kompatibel med overvågningssystemer."""

    def __init__(self):
        self.counters = {
            "api_calls_total": 0,
            "api_errors_total": 0,
            "tokens_consumed_total": 0,
        }
        self.histograms = {
            "api_latency_ms": [],
        }

    def record_success(self, tokens: int, latency_ms: int):
        self.counters["api_calls_total"] += 1
        self.counters["tokens_consumed_total"] += tokens
        self.histograms["api_latency_ms"].append(latency_ms)

    def record_error(self):
        self.counters["api_calls_total"] += 1
        self.counters["api_errors_total"] += 1

    def get_metrics(self) -> dict:
        latencies = self.histograms["api_latency_ms"]
        return {
            **self.counters,
            "latency_avg_ms": round(sum(latencies) / max(len(latencies), 1)),
            "error_rate": self.counters["api_errors_total"] /
                         max(self.counters["api_calls_total"], 1),
        }

exporter = MetricsExporter()
# Kald exporter.record_success() eller exporter.record_error()
# efter hvert API-kald

Vigtige pointer

  • Log hvert kald med: model, tokens, ventetid, status, response_id
  • Brug struktureret JSON til logs, dine værktøjer kan parse
  • Indsaml nøgletal: succesrate, p95-ventetid, tokenforbrug
  • Tilføj et trace_id for at korrelere forespørgsler i distribuerede systemer
  • Eksporter måletal til dit overvågningssystem (Prometheus, Datadog osv.)
  • Log aldrig prompt-indhold i produktion (følsomme data)