Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Ponovni pokušaji, eksponencijalno povlačenje i prekidač kruga

Lekcija 14 od 22 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Ponovni pokušaji, eksponencijalno povlačenje i prekidač kruga
  2. Eksponencijalno povlačenje (Exponential Backoff)
  3. Korištenje biblioteke Tenacity
  4. Uzorak prekidača kruga (Circuit Breaker)
  5. Kombiniranje triju uzoraka
  6. Ključne točke

Ponovni pokušaji, eksponencijalno povlačenje i prekidač kruga

Prolazne greške su u produkciji sasvim normalne. OpenAI SDK automatski obrađuje dva ponovna pokušaja, no za maksimalnu otpornost trebao bi implementirati vlastite strategije. Prethodna lekcija naučila te je prepoznavati greške koje valja ponoviti; ova te uči kako to učiniti pametno—bez pogoršavanja situacije koju pokušavaš popraviti.

Eksponencijalno povlačenje (Exponential Backoff)

Princip je jednostavan: svaki ponovni pokušaj čeka dulje od prethodnog. Time se sprječava preopterećenje API-ja kada je pod pritiskom. Jitter (nasumično kašnjenje) zaslužuje posebnu pozornost jer njegovo odsustvo uzrokuje klasični način otkaza: pedeset instanci tvoje usluge primi kod 429 u istoj sekundi, sve čekaju točno jednu sekundu, zatim se sve zajedno ponovno pokrenu i budu odbijene kao grupa. Dodavanjem nasumičnog kašnjenja raspoređuješ ta ponovna pokretanja—to je lijek za efekt „grmljavinskog krda“ (thundering herd).

import time
import random
from openai import OpenAI, RateLimitError, InternalServerError, APIConnectionError

client = OpenAI()

def call_with_backoff(prompt: str, max_retries: int = 5) -> str:
    """API call with exponential backoff and jitter."""

    for attempt in range(max_retries):
        try:
            response = client.responses.create(
                model="gpt-5.6-terra",
                input=prompt
            )
            return response.output_text

        except (RateLimitError, InternalServerError, APIConnectionError) as e:
            if attempt == max_retries - 1:
                raise  # Last attempt, propagate the error

            # Exponential backoff: 1s, 2s, 4s, 8s, 16s
            base_delay = 2 ** attempt

            # Random jitter to avoid thundering herd
            jitter = random.uniform(0, base_delay * 0.5)
            delay = base_delay + jitter

            print(f"Attempt {attempt + 1}/{max_retries} failed. "
                  f"Retrying in {delay:.1f}s...")
            time.sleep(delay)

    raise RuntimeError("Should never reach here")

# Usage
result = call_with_backoff("Explain exponential backoff.")
print(result)

Obrati pažnju na konačni pokušaj: prosljeđujemo izvornu grešku umjesto da je progutamo. Pozivatelj tako dobiva pravu dijagnostiku—429 ili 500—i može odlučiti što učiniti s njom.

Korištenje biblioteke Tenacity

Ručno pisanje ove petlje brzo postaje repetitivno čim imaš pet funkcija koje trebaš zaštititi. Za naprednije upravljanje ponovnim pokušajima, tenacity je alat po izboru: dekorator deklarira politiku, a tijelo funkcije sadrži samo poziv poslovne logike. Dobivaš iste sastojke, ali imenovane i konfigurabilne—popis iznimki za ponovni pokušaj, eksponencijalno čekanje ograničeno na šezdeset sekundi, zaustavljanje nakon pet pokušaja i automatsko bilježenje prije svake pauze.

# pip install tenacity
from tenacity import (
    retry,
    stop_after_attempt,
    wait_exponential,
    retry_if_exception_type,
    before_sleep_log,
)
from openai import RateLimitError, InternalServerError, APIConnectionError
import logging

logger = logging.getLogger(__name__)

@retry(
    retry=retry_if_exception_type(
        (RateLimitError, InternalServerError, APIConnectionError)
    ),
    wait=wait_exponential(multiplier=1, min=1, max=60),
    stop=stop_after_attempt(5),
    before_sleep=before_sleep_log(logger, logging.WARNING),
)
def resilient_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
    """API call with automatic retry via tenacity."""
    response = client.responses.create(
        model=model,
        input=prompt
    )
    return response.output_text

# Usage — retries are transparent
result = resilient_call("Hello!")
print(result)

Uzorak prekidača kruga (Circuit Breaker)

Ponovni pokušaji rješavaju incidente koji traju nekoliko sekundi. Postaju štetni kada prekid traje dulje: svaki korisnički zahtjev tada troši pet pokušaja i trideset sekundi čekanja prije neuspjeha, tvoji threadovi se gomilaju i na kraju pada tvoja vlastita usluga. Prekidač kruga sprječava tvoju aplikaciju da nastavi zvati API koji ne radi.

Radi poput električnog prekidača kruga, s tri stanja. Zatvoreno (Closed), sve radi normalno i pozivi prolaze. Otvoreno (Open), API se smatra nedostupnim i pozivi se odmah blokiraju, bez pokušaja mrežnog poziva—korisnik prima grešku u milisekundama umjesto nakon isteka vremena. Poluotvoreno (Half-open), nakon što protekne razdoblje odmora, šalje se testni poziv kako bi se provjerilo je li API ponovno dostupan: ako uspije, krug se zatvara; ako ne uspije, ponovno se otvara za novi ciklus.

import time
from enum import Enum

class CircuitState(Enum):
    CLOSED = "closed"
    OPEN = "open"
    HALF_OPEN = "half_open"

class CircuitBreaker:
    """Circuit breaker for API calls."""

    def __init__(self, error_threshold: int = 5, reset_timeout: float = 30.0):
        self.threshold = error_threshold
        self.reset_timeout = reset_timeout
        self.consecutive_errors = 0
        self.state = CircuitState.CLOSED
        self.last_error_time = 0.0

    def can_call(self) -> bool:
        """Checks if a call is allowed."""
        if self.state == CircuitState.CLOSED:
            return True

        if self.state == CircuitState.OPEN:
            if time.monotonic() - self.last_error_time > self.reset_timeout:
                self.state = CircuitState.HALF_OPEN
                return True  # One test call
            return False

        # Half-open: only one call allowed
        return True

    def record_success(self):
        """Records a successful call."""
        self.consecutive_errors = 0
        self.state = CircuitState.CLOSED

    def record_error(self):
        """Records a failure."""
        self.consecutive_errors += 1
        self.last_error_time = time.monotonic()

        if self.consecutive_errors >= self.threshold:
            self.state = CircuitState.OPEN
            print(f"Circuit OPEN after {self.threshold} consecutive errors")

Brojač greški resetira se na nulu čim poziv uspije: krug otvaraju uzastopni neuspjesi, a ne povijesni kumulativni zbroj. Integracija na strani klijenta svodi se na tri koraka—zatraži dopuštenje, signaliziraj uspjeh, signaliziraj neuspjeh.

# Integration with the OpenAI client
circuit = CircuitBreaker(error_threshold=3, reset_timeout=30.0)

def call_with_circuit_breaker(prompt: str) -> str:
    """API call protected by a circuit breaker."""
    if not circuit.can_call():
        raise RuntimeError(
            f"Circuit open — API unavailable. "
            f"Retry in {circuit.reset_timeout}s"
        )

    try:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=prompt
        )
        circuit.record_success()
        return response.output_text

    except (RateLimitError, InternalServerError, APIConnectionError) as e:
        circuit.record_error()
        raise

# Usage
try:
    result = call_with_circuit_breaker("Hello!")
    print(result)
except RuntimeError as e:
    print(f"Error: {e}")

Kombiniranje triju uzoraka

U produkciji kombiniraj povlačenje, prekidač kruga i vremensko ograničenje (timeout). Obrati pažnju na konstruktor: klijent se stvara s max_retries=0, što onemogućuje interne ponovne pokušaje SDK-a. Bez ovoga, tvoja tri pokušaja bi se pomnožila s dva iz SDK-a i čekao bi mnogo dulje nego što očekuješ. Vremensko ograničenje od trideset sekundi ograničava svaki pojedinačni poziv, petlja obrađuje ponovne pokušaje, a prekidač kruga prati opće zdravstveno stanje usluge.

class APIClient:
    """Resilient API client combining all patterns."""

    def __init__(self):
        self.client = OpenAI(timeout=30.0, max_retries=0)
        self.circuit = CircuitBreaker(error_threshold=5, reset_timeout=60.0)

    def call(self, prompt: str, max_retries: int = 3) -> str:
        if not self.circuit.can_call():
            raise RuntimeError("Service temporarily unavailable")

        for attempt in range(max_retries):
            try:
                response = self.client.responses.create(
                    model="gpt-5.6-terra",
                    input=prompt
                )
                self.circuit.record_success()
                return response.output_text

            except (RateLimitError, InternalServerError) as e:
                self.circuit.record_error()

                if attempt < max_retries - 1:
                    delay = (2 ** attempt) + random.uniform(0, 1)
                    time.sleep(delay)
                else:
                    raise

        raise RuntimeError("Failed after all attempts")

# Usage
api = APIClient()
print(api.call("Explain resilience in software engineering."))

Prije nego što nastaviš, testiraj ovog klijenta simuliranjem prekida: isključi mrežu, pokreni desetak poziva i provjeri da posljednji ne uspiju trenutno umjesto da čekaju. Ako to nije slučaj, tvoj prag je previsok za volumen koji se obrađuje.

Ključne točke

  • SDK prema zadanim postavkama obrađuje 2 ponovna pokušaja — prilagodi s max_retries
  • Eksponencijalno povlačenje s jitterom izbjegava efekt grmljavinskog krda
  • Prekidač kruga štiti tvoju aplikaciju od dugotrajnih prekida
  • Koristi tenacity za deklarativno upravljanje ponovnim pokušajima u produkciji
  • Kombiniraj sva tri uzorka za maksimalnu otpornost
  • Nikada ne ponavljaj greške 400/401/403 (greške klijenta)