Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Håndtering af fejl og fallbacks

Lektion 4 af 20 Udvikler
På denne side
  1. Håndtering af fejl og fallbacks
  2. Returnering af fejl til modellen
  3. Genforsøg med eksponentiel backoff
  4. Tidsudløb pr. funktion
  5. Fallback mellem funktioner
  6. Circuit breaker
  7. Komplet robust løkke
  8. Vigtige pointer

Håndtering af fejl og fallbacks

Funktionskald introducerer en udfordring, som klassisk kode ikke står over for: Når din funktion fejler, er der to modtagere af den fejl. Din applikation, som sædvanligt – og modellen, som venter på et resultat for at kunne fortsætte. Glemmer du dette, opstår det mest forvirrende symptom i produktion: En samtale, der stopper brat uden forklaring, fordi en undtagelse blev slugt på serversiden, mens modellen stadig venter.

Reglen, der strukturerer hele denne lektion, er følgende: Returnér altid en function_call_output, også ved fejl. En model, der får besked om, at en API ikke er tilgængelig, kan foreslå en alternativ løsning, bede om afklaring eller forklare brugeren situationen. En model, der ikke modtager noget, kan intet gøre.

Returnering af fejl til modellen

Formatet på fejlen er lige så vigtigt som selve afsendelsen. En nøgen “Error” lærer modellen ingenting; et JSON-objekt, der skelner mellem fejltypen, om den er midlertidig eller permanent, og hvilke næste skridt der skal tages, giver modellen mulighed for at træffe en beslutning. Det virker måske kontraintuitivt: Du skriver fejlmeddelelser, der er beregnet til at blive læst af en ræsonnerende maskine, ikke logget til mennesker.

import json
from openai import OpenAI

client = OpenAI()

def execute_function(name: str, arguments: str, call_id: str) -> dict:
    try:
        args = json.loads(arguments)
        result = dispatcher[name](**args)
        return {
            "type": "function_call_output",
            "call_id": call_id,
            "output": json.dumps(result)
        }
    except KeyError:
        return {
            "type": "function_call_output",
            "call_id": call_id,
            "output": json.dumps({
                "error": "unknown_function",
                "message": f"The function '{name}' does not exist"
            })
        }
    except json.JSONDecodeError:
        return {
            "type": "function_call_output",
            "call_id": call_id,
            "output": json.dumps({
                "error": "invalid_arguments",
                "message": "The JSON arguments are malformed"
            })
        }
    except Exception as e:
        return {
            "type": "function_call_output",
            "call_id": call_id,
            "output": json.dumps({
                "error": "internal_error",
                "message": str(e)
            })
        }

Genforsøg med eksponentiel backoff

Genforsøg giver kun mening for problemer, der kan løse sig selv ved et andet forsøg: Netværksafbrydelser, 429-statuskoder eller midlertidige nedbrud. At genforsøge en anmodning, der er afvist på grund af ugyldig godkendelse eller forkerte parametre, forsinker kun fejlen, samtidig med at antallet af kald ganges. Derfor filtrerer koden nedenstående eksplicit efter fejltyper – filtreringen udfører arbejdet, mens backoff blot er den høflighed, du skylder den eksterne tjeneste.

import time
import random

def execute_with_retry(func, args, max_retries=3, base_delay=1.0):
    """Genforsøg med eksponentiel backoff og jitter."""
    for attempt in range(max_retries + 1):
        try:
            return func(**args)
        except (ConnectionError, TimeoutError) as e:
            if attempt == max_retries:
                raise
            delay = base_delay * (2 ** attempt) + random.uniform(0, 0.5)
            time.sleep(delay)
        except ValueError:
            # Datafejl: Forsøg ikke igen
            raise

def execute_function_robust(name, arguments, call_id):
    args = json.loads(arguments)
    try:
        result = execute_with_retry(dispatcher[name], args)
        return {
            "type": "function_call_output",
            "call_id": call_id,
            "output": json.dumps(result)
        }
    except Exception as e:
        return {
            "type": "function_call_output",
            "call_id": call_id,
            "output": json.dumps({
                "error": type(e).__name__,
                "message": str(e),
                "retries_performed": 3
            })
        }

Tidsudløb pr. funktion

Et enkelt tidsudløb for alle funktioner er altid forkert konfigureret: Er det for kort, dræber det tung behandling; er det for langt, får du brugeren til at vente på et simpelt cache-opslag. Basisér hver værdi på observerede varigheder under normale forhold med en margin – ikke på det værst tænkelige scenarie, hvilket i praksis ville betyde, at du slet ikke har noget tidsudløb.

import signal
from functools import wraps

TIMEOUTS = {
    "search_client": 5,
    "generate_report": 30,
    "send_email": 10,
}

def with_timeout(func, timeout_seconds):
    """Udfører en funktion med et tidsudløb."""
    import concurrent.futures
    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
        future = executor.submit(func)
        try:
            return future.result(timeout=timeout_seconds)
        except concurrent.futures.TimeoutError:
            raise TimeoutError(
                f"Function interrupted after {timeout_seconds}s"
            )

def execute_with_timeout(name, arguments, call_id):
    args = json.loads(arguments)
    timeout = TIMEOUTS.get(name, 10)  # 10s som standard

    try:
        result = with_timeout(
            lambda: dispatcher[name](**args),
            timeout
        )
        return {
            "type": "function_call_output",
            "call_id": call_id,
            "output": json.dumps(result)
        }
    except TimeoutError as e:
        return {
            "type": "function_call_output",
            "call_id": call_id,
            "output": json.dumps({
                "error": "timeout",
                "message": str(e),
                "suggestion": "Retry with more specific criteria"
            })
        }

Fallback mellem funktioner

Fallback er en afvejning, ikke en refleks: At levere seks timer gamle cachelagrede data er bedre end ingenting til et dashboard, men langt værre end ingenting til en banksaldo. Når du degraderer ydelsen, så sig det – i resultatet returneret til modellen, så den kan advare brugeren i stedet for at præsentere forældede data som friske.

async def search_product(term: str) -> dict:
    """Søgning med fallback: Primær API -> cache -> lokal database."""
    # Forsøg 1: Katalog-API
    try:
        return await api_catalog.search(term)
    except Exception:
        pass

    # Forsøg 2: Redis-cache
    try:
        cached = await redis_client.get(f"product:{term}")
        if cached:
            result = json.loads(cached)
            result["_source"] = "cache"
            result["_warning"] = "Data may be outdated"
            return result
    except Exception:
        pass

    # Forsøg 3: Lokal SQLite-database
    try:
        row = db.execute(
            "SELECT * FROM products WHERE name LIKE ?",
            (f"%{term}%",)
        ).fetchone()
        if row:
            return {
                "name": row["name"],
                "price": row["price"],
                "_source": "local_db",
                "_warning": "Data from last synchronization"
            }
    except Exception:
        pass

    return {
        "error": "unavailable",
        "message": "No data source accessible for this search"
    }

Circuit breaker

Circuit breaker håndterer det, som genforsøg ikke kan: En tjeneste, der er nede i længere tid. Efter N fejl udløses den og returnerer straks en fejl uden overhovedet at forsøge, hvorefter den lejlighedsvis tillader en testanmodning at passere for at tjekke, om tjenesten er kommet sig. Gevinsten er dobbelt: Dine brugere holder op med at vente på tidsudløb ved hver anmodning, og den pressede tjeneste holdes ikke nede af dine genforsøg.

from datetime import datetime, timedelta

class CircuitBreaker:
    def __init__(self, failure_threshold=5, open_duration=60):
        self.threshold = failure_threshold
        self.duration = open_duration
        self.failures = 0
        self.last_failure = None
        self.state = "closed"  # closed, open, half-open

    def can_execute(self) -> bool:
        if self.state == "closed":
            return True
        if self.state == "open":
            if datetime.now() - self.last_failure > timedelta(seconds=self.duration):
                self.state = "half-open"
                return True
            return False
        return True  # half-open: tillad ét testforsøg

    def record_success(self):
        self.failures = 0
        self.state = "closed"

    def record_failure(self):
        self.failures += 1
        self.last_failure = datetime.now()
        if self.failures >= self.threshold:
            self.state = "open"

# Én circuit breaker pr. ekstern tjeneste
breakers = {
    "weather_api": CircuitBreaker(failure_threshold=3, open_duration=30),
    "catalog_api": CircuitBreaker(failure_threshold=5, open_duration=60),
}

Komplet robust løkke

Det fulde mønster samler de fem mekanismer ovenfor. Én forholdsregel gør det virkelig sikkert, og den er let at overse: Sæt en grænse for antallet af iterationer. Det er sjældent, at en model løber i en løkke, hvor den kalder en funktion, hvis resultat den ikke bryder sig om, men uden et loft vil den brænde dit budget af indtil udmattelse – og det er den slags hændelser, du først opdager på regningen.

def robust_loop(prompt, tools, max_turns=10):
    messages = prompt
    for turn in range(max_turns):
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=messages,
            tools=tools
        )

        calls = [i for i in response.output if i.type == "function_call"]
        if not calls:
            return response.output_text

        results = []
        for call in calls:
            result = execute_function_robust(
                call.name, call.arguments, call.call_id
            )
            results.append(result)

        messages = response.output + results

    return "Workflow interrupted: turn limit reached"

Vigtige pointer

  • Returnér altid en function_call_output, også ved fejl
  • Strukturér fejl som JSON, så modellen kan bruge dem
  • Genforsøg kun midlertidige fejl med eksponentiel backoff
  • Implementér fallbacks mellem datakilder
  • Brug en circuit breaker til at beskytte fejlramte tjenester