Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Kļūdu apstrāde un rezerves risinājumi

Nodarbība 4 no 20 Programmētājs
Šajā lapā
  1. Kļūdu apstrāde un rezerves risinājumi
  2. Kļūdu atgriešana modelim
  3. Atkārtošana ar eksponenciālu aizturi
  4. Laika limiti katrai funkcijai
  5. Rezerves risinājumi starp funkcijām
  6. Ķēdes pārtraucējs (Circuit Breaker)
  7. Pilns robusts cikls
  8. Galvenās atziņas

Kļūdu apstrāde un rezerves risinājumi

Funkciju izsaukšana rada izaicinājumu, ar ko klasiskais kods nesaskaras: ja tava funkcija neizdodas, šī kļūda ir adresēta diviem saņēmējiem. Tavam lietojumam, kā parasti, un modelim, kas gaida rezultātu, lai turpinātu darbu. Aizmirstot par to, rodas vismulsinošākais simptoms darbības vidē: saruna pēkšņi apstājas bez jebkāda skaidrojuma, jo izņēmums tika “norīts” servera pusē, bet modelis joprojām gaida.

Noteikums, uz kura balstās visa šī nodarbība, ir šāds: vienmēr atgriez function_call_output, pat ja rodas kļūda. Modelis, kas informēts par API nepieejamību, var piedāvāt alternatīvu, lūgt precizējumus vai izskaidrot situāciju lietotājam. Modelis, kas nesaņem neko, nevar darīt neko.

Kļūdu atgriešana modelim

Kļūdas formāts ir tikpat svarīgs kā tās nosūtīšana. Tukšs “Kļūda” modelim nemāca neko; JSON objekts, kas norāda kļūdas veidu, vai tā ir pārejoša vai pastāvīga, un kādi ir nākamie soļi, ļauj modelim pieņemt lēmumu. Tas šķiet pretrunā ar intuīciju: tu raksti kļūdas ziņojumus, kas domāti lasīšanai spriežojošai mašīnai, nevis žurnālfailiem cilvēkiem.

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

Atkārtošana ar eksponenciālu aizturi

Atkārtošanai ir jēga tikai tad, ja problēmas varētu atrisināties otrajā mēģinājumā: tīkla pārtraukumi, 429 statusa kodi vai īslaicīgi darbības traucējumi. Atkārtota pieprasījuma nosūtīšana, kas noraidīts nepareizas autentifikācijas vai nepareizu parametru dēļ, tikai aizkavē neveiksmi, vienlaikus reizinot izsaukumu skaitu. Tāpēc zemāk esošais kods skaidri filtrē kļūdas – filtrēšana veic galveno darbu, bet aizture ir tikai pieklājība, ko parādi attālajam servisam.

import time
import random

def execute_with_retry(func, args, max_retries=3, base_delay=1.0):
    """Atkārtošana ar eksponenciālu aizturi un nejaušību (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:
            # Datu kļūda: neatkārtot
            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
            })
        }

Laika limiti katrai funkcijai

Viens laika limits visām funkcijām vienmēr būs nepareizi konfigurēts: ja tas ir pārāk īss, tas pārtrauc smagu apstrādi; ja pārāk garš, tas liek lietotājam gaidīt vienkāršas kešatmiņas meklēšanas dēļ. Katrai vērtībai jābūt balstītai uz novērotajiem ilgumiem normālos apstākļos ar nelielu rezervi, nevis uz sliktāko iespējamo scenāriju, kas faktiski nozīmētu, ka laika limita nav vispār.

import signal
from functools import wraps

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

def with_timeout(func, timeout_seconds):
    """Izpilda funkciju ar laika limitu."""
    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)  # Pēc noklusējuma 10s

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

Rezerves risinājumi starp funkcijām

Rezerves risinājums ir kompromiss, nevis automātisks reflekss: sešas stundas vecu kešatmiņas datu piegāde ir labāk nekā nekas informācijas panelim, bet daudz sliktāk nekā nekas bankas konta atlikumam. Kad veic pasliktināšanu (degradāciju), pasaki to – rezultātā, kas tiek atgriezts modelim, lai tas varētu brīdināt lietotāju, nevis pasniegt novecojušus datus kā svaigus.

async def search_product(term: str) -> dict:
    """Meklēšana ar rezerves risinājumu: primārais API -> kešatmiņa -> lokālā datubāze."""
    # 1. mēģinājums: Kataloga API
    try:
        return await api_catalog.search(term)
    except Exception:
        pass

    # 2. mēģinājums: Redis kešatmiņa
    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

    # 3. mēģinājums: Lokālā SQLite datubāze
    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"
    }

Ķēdes pārtraucējs (Circuit Breaker)

Ķēdes pārtraucējs risina to, ko atkārtošana nevar: serviss, kas ir nefunkcionējošs ilgstoši. Pēc N neveiksmēm tas “izslēdzas” un nekavējoties atgriež kļūdu, pat nemēģinot izpildīt pieprasījumu, un tikai reizēm ļauj cauri testa pieprasījumam, lai pārbaudītu atjaunošanos. Ieguvums ir divkāršs – tavi lietotāji vairs negaida laika limita beigas katrā pieprasījumā, un grūtībās nonākušais serviss netiek turēts lejā ar taviem atkārtojumiem.

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"

# Viens ķēdes pārtraucējs katram ārējam servisam
breakers = {
    "weather_api": CircuitBreaker(failure_threshold=3, open_duration=30),
    "catalog_api": CircuitBreaker(failure_threshold=5, open_duration=60),
}

Pilns robusts cikls

Pilns modelis apvieno iepriekš minētos piecus mehānismus. Viens piesardzības pasākums padara to patiesi drošu, un to ir viegli palaist garām: ierobežo iterāciju skaitu. Modelis, kas ciklā izsauc funkciju, kuras rezultāts tam nepatīk, ir rets gadījums, bet bez augšējās robežas tas iztērēs tavu budžetu līdz izsīkumam – un tieši šādu incidentu tu uzzini no rēķina.

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"

Galvenās atziņas

  • Vienmēr atgriez function_call_output, pat ja rodas kļūda
  • Strukturē kļūdas kā JSON, lai modelis tās varētu izmantot
  • Atkārto tikai pārejošas kļūdas, izmantojot eksponenciālu aizturi
  • Ievies rezerves risinājumus starp datu avotiem
  • Izmanto ķēdes pārtraucēju, lai aizsargātu nefunkcionējošus servisus