Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Spracovanie chýb a záložné riešenia

Lekcia 4 z 20 Vývojár
Na tejto strane
  1. Spracovanie chýb a záložné riešenia
  2. Vracanie chýb modelu
  3. Opakovanie s exponenciálnym oneskorením (Exponential Backoff)
  4. Časové limity pre jednotlivé funkcie
  5. Záložné prepínanie medzi funkciami
  6. Istič (Circuit Breaker)
  7. Kompletný robustný cyklus
  8. Kľúčové poznatky

Spracovanie chýb a záložné riešenia

Volanie funkcií prináša výzvu, ktorej čelí klasický kód len zriedka: keď tvoja funkcia zlyhá, majú túto chybu dvoch adresátov. Tvoju aplikáciu ako obvykle – a model, ktorý čaká na výsledok, aby mohol pokračovať. Ak na toto zabudneš, vznikne v produkcii najmatúcejší symptóm: konverzácia sa úplne zastaví bez vysvetlenia, pretože výnimka bola na strane servera potlačená a model stále čaká.

Pravidlo, ktoré štruktúruje celú túto lekciu, znie: vždy vráť function_call_output, aj pri zlyhaní. Model informovaný o nedostupnosti API môže navrhnúť alternatívu, požiadať o objasnenie alebo situáciu vysvetliť používateľovi. Model, ktorý nedostane nič, nemôže urobiť nič.

Vracanie chýb modelu

Formát chyby je rovnako dôležitý ako samotné jej odoslanie. Holé „Chyba“ modelu nič nepovie; JSON objekt, ktorý rozlišuje typ chyby, či je dočasná alebo trvalá, a navrhuje ďalšie kroky, umožňuje modelu rozhodnúť sa. Toto môže pôsobiť counterintuitívne: píšeš chybové hlášky určené na čítanie uvažujúcim strojom, nie na logovanie pre ľudí.

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

Opakovanie s exponenciálnym oneskorením (Exponential Backoff)

Opakovanie má zmysel len pri problémoch, ktoré sa môžu pri druhom pokuse vyriešiť: výpadky siete, stavové kódy 429 alebo dočasné nedostupnosti. Opakovanie požiadavky zamietnutej kvôli neplatnej autentifikácii alebo nesprávnym parametrom len oneskorí zlyhanie a zároveň znásobí počet volaní. Preto kód nižšie explicitne filtruje chyby – filtrácia robí hlavnú prácu, zatiaľ čo backoff je len zdvorilosť, ktorú dlhuješ vzdialenej službe.

import time
import random

def execute_with_retry(func, args, max_retries=3, base_delay=1.0):
    """Retry with exponential backoff and 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:
            # Data error: do not retry
            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
            })
        }

Časové limity pre jednotlivé funkcie

Jediný časový limit pre všetky funkcie je vždy nastavený nesprávne: príliš krátky zabíja náročné spracovanie; príliš dlhý núti používateľa čakať na jednoduché vyhľadanie v cache. Každú hodnotu založ na pozorovaných trvaniach za normálnych podmienok s určitou rezervou – nie na najhoršom predstaviteľnom prípade, čo by v praxi znamenalo mať žiadny časový limit vôbec.

import signal
from functools import wraps

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

def with_timeout(func, timeout_seconds):
    """Executes a function with a timeout."""
    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 by default

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

Záložné prepínanie medzi funkciami

Záložné riešenie (fallback) je kompromis, nie reflex: poskytnutie šesť hodín starých dát z cache je pre dashboard lepšie ako nič, ale pre zostatok na bankovom účte je to oveľa horšie ako nič. Keď degraduješ kvalitu, povedz to – v výsledku vrátenom modelu, aby mohol používateľa upozorniť, namiesto toho, aby prezentoval zastarané dáta ako čerstvé.

async def search_product(term: str) -> dict:
    """Search with fallback: primary API -> cache -> local database."""
    # Attempt 1: Catalog API
    try:
        return await api_catalog.search(term)
    except Exception:
        pass

    # Attempt 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

    # Attempt 3: Local 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"
    }

Istič (Circuit Breaker)

Istič rieši to, čo opakovanie nedokáže: službu, ktorá je dlhodobo nedostupná. Po N zlyhaniach sa „vyhodí“ a okamžite vráti chybu bez akéhokoľvek pokusu, potom príležitostne povolí testovaciu požiadavku, aby skontroloval obnovenie služby. Zisk je dvojnásobný – tvoji používatelia prestanú čakať na vypršanie časového limitu pri každej požiadavke a trpiaca služba nie je udržiavaná v stave výpadku tvojimi opakovanými pokusmi.

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: allow one test attempt

    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"

# One circuit breaker per external service
breakers = {
    "weather_api": CircuitBreaker(failure_threshold=3, open_duration=30),
    "catalog_api": CircuitBreaker(failure_threshold=5, open_duration=60),
}

Kompletný robustný cyklus

Úplný vzor spája vyššie uvedených päť mechanizmov. Jedna opatrnosť ho robí skutočne bezpečným a je ľahké ju prehliadnuť: obmedz počet iterácií. Model, ktorý donekonečna volá funkciu, ktorej výsledok sa mu nepáči, je síce zriedkavý, ale bez stropu minie tvoj rozpočet až do vyčerpania – a toto je typ incidentu, ktorý objavíš až na faktúre.

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"

Kľúčové poznatky

  • Vždy vráť function_call_output, aj pri chybe
  • Štruktúruj chyby ako JSON, aby ich model mohol využiť
  • Opakuj len prechodné chyby s exponenciálnym oneskorením
  • Implementuj záložné prepínanie medzi zdrojmi dát
  • Použi istič (circuit breaker) na ochranu zlyhávajúcich služieb