Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Obdelava napak in nadomestne rešitve

Lekcija 4 od 20 Razvijalec
Na tej strani
  1. Obdelava napak in nadomestne rešitve
  2. Vračanje napak modelu
  3. Ponovni poskus z eksponentnim zamikom
  4. Časovne omejitve za posamezne funkcije
  5. Nadomestne rešitve med funkcijami
  6. Odklopnik (Circuit Breaker)
  7. Popoln robusten zank
  8. Ključne ugotovitve

Obdelava napak in nadomestne rešitve

Klicanje funkcij prinaša izziv, s katerim se klasična koda ne sooča: ko tvoja funkcija odpove, imata napako dva prejemnika. Tvoja aplikacija, kot običajno, in model, ki čaka na rezultat za nadaljevanje. Pozaba na to ustvari najbolj zmeden simptom v produkciji: pogovor, ki se nenadoma ustavi brez razlage, ker je bila izjema pogoltnjena na strani strežnika, model pa še vedno čaka.

Pravilo, ki sledi, strukturira celotno lekcijo: vedno vrni function_call_output, tudi ob napaki. Model, obveščen, da API ni na voljo, lahko predlaga alternativo, zaprosi za pojasnilo ali uporabniku razloži situacijo. Model, ki ne prejme ničesar, ne more storiti ničesar.

Vračanje napak modelu

Format napake je prav tako pomemben kot njen pošiljanje. Golo sporočilo “Napaka” modelu ne pove ničesar; objekt JSON, ki razlikuje vrsto napake, ali je prehodna ali trajna, in naslednje korake, omogoča modelu odločitev. To je protislovno: pišeš sporočila o napakah, namenjena branju s strani stroja za razmišljanje, ne beleženju za ljudi.

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)
            })
        }

Ponovni poskus z eksponentnim zamikom

Ponovni poskus ima smisel le pri težavah, ki se lahko ob drugem poskusu razrešijo: prekinitve omrežja, statusne kode 429 ali začasne izpadi. Ponovni poskus zahteve, zavrnjene zaradi neveljavne avtentikacije ali napačnih parametrov, le odlaša neuspeh in hkrati množi število klicev. Zato spodnja koda izrecno filtrira napake – filtriranje opravi delo, zamik pa je le vljudnost, ki jo dolguješ oddaljeni storitvi.

import time
import random

def execute_with_retry(func, args, max_retries=3, base_delay=1.0):
    """Ponovni poskus z eksponentnim zamikom in naključnim odmikom."""
    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:
            # Napaka podatkov: ne ponavljaj
            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
            })
        }

Časovne omejitve za posamezne funkcije

Ena sama časovna omejitev za vse funkcije je vedno napačno nastavljena: prekratka ubije težko obdelavo; predolga pa prisili uporabnika v čakanje na preprost iskalni pomnilnik. Vsako vrednost določi na podlagi opaženih trajanj v normalnih pogojih, z robom – ne na podlagi najslabšega možnega primera, kar bi v praksi pomenilo, da časovne omejitve sploh nimaš.

import signal
from functools import wraps

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

def with_timeout(func, timeout_seconds):
    """Izvede funkcijo s časovno omejitvijo."""
    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)  # privzeto 10 s

    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"
            })
        }

Nadomestne rešitve med funkcijami

Nadomestna rešitev je kompromis, ne refleks: streženje šest ur starih predpomnjenih podatkov je za nadzorno ploščo bolje kot nič, za stanje na bančnem računu pa bistveno slabše kot nič. Ko degradiraš storitev, to tudi povej – v rezultatu, vrnjenem modelu, da lahko opozori uporabnika, namesto da zastarele podatke predstavi kot sveže.

async def search_product(term: str) -> dict:
    """Iskanje z nadomestno rešitvijo: glavni API -> predpomnilnik -> lokalna baza podatkov."""
    # Poskus 1: API kataloga
    try:
        return await api_catalog.search(term)
    except Exception:
        pass

    # Poskus 2: Predpomnilnik Redis
    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

    # Poskus 3: Lokalna baza podatkov SQLite
    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"
    }

Odklopnik (Circuit Breaker)

Odklopnik obravnava tisto, česar ponovni poskus ne more: storitev, ki je dlje časa nedostopna. Po N neuspehih se sproži in takoj vrne napako, ne da bi sploh poskusil, nato pa občasno dovoli testni zahtevek, da preveri obnovitev. Dobiček je dvojen – tvoji uporabniki ne čakajo več na časovni iztek pri vsaki zahtevi, storitev v težavah pa ni zaradi tvojih ponovnih poskusov še dodatno obremenjena.

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: dovoli en testni poskus

    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"

# En odklopnik na zunanjo storitev
breakers = {
    "weather_api": CircuitBreaker(failure_threshold=3, open_duration=30),
    "catalog_api": CircuitBreaker(failure_threshold=5, open_duration=60),
}

Popoln robusten zank

Celoten vzorec združuje zgornjih pet mehanizmov. En previdnostni ukrep ga naredi resnično varnega in ga je lahko spregledati: omeji število iteracij. Model, ki v zanki kliče funkcijo, katere rezultat mu ni všeč, je redek, a brez zgornje meje bo porabil tvoj proračun do izčrpanosti – in to je vrsta incidenta, ki jo odkriješ šele na računu.

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"

Ključne ugotovitve

  • Vedno vrni function_call_output, tudi ob napaki
  • Strukturiraj napake kot JSON, da jih model lahko uporabi
  • Ponavljaj le prehodne napake z eksponentnim zamikom
  • Implementiraj nadomestne rešitve med viri podatkov
  • Uporabi odklopnik za zaščito odpovedujočih storitev