Премини към основното съдържание
Български— Изберете език
Меню

Повторни опити, експоненциално отлагане и прекъсвач на веригата

Урок 14 от 22 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Повторни опити, експоненциално отлагане и прекъсвач на веригата
  2. Експоненциално отлагане
  3. Използване на библиотеката Tenacity
  4. Шаблонът „Прекъсвач на веригата“ (Circuit Breaker)
  5. Комбиниране на трите шаблона
  6. Ключови изводи

Повторни опити, експоненциално отлагане и прекъсвач на веригата

Преходните грешки са нормални в производствена среда. OpenAI SDK автоматично извършва два повторни опита, но за максимална устойчивост трябва да внедрите собствени стратегии. Предходният урок Ви научи как да разпознавате грешки, подлежащи на повторен опит; този урок Ви учи как да правите повторни опити интелигентно – без да влошавате ситуацията, която се опитвате да поправите.

Експоненциално отлагане

Принципът е прост: всеки следващ повторен опит изчаква по-дълго от предишния. Това предотвратява претоварването на API, когато то е под напрежение. Случайното отклонение (jitter) заслужава специално внимание, тъй като липсата му води до класически режим на отказ: петдесет екземпляра от Вашия сервис получават грешка 429 в една и съща секунда, всички изчакват точно една секунда, след което всички рестартират едновременно и отново биват отхвърлени като група. Чрез добавяне на случайно забавяне разпределяте този рестарт – това е лекът срещу ефекта на „тъпчещото се стадо“ (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)

Обърнете внимание на последния опит: ние предаваме оригиналната грешка, вместо да я поглъщаме. Така извикващият код получава реалната диагностика – 429 или 500 – и може да реши какво да предприеме с нея.

Използване на библиотеката Tenacity

Ръчното написване на този цикъл бързо става повтарящо се, щом имате пет функции за защита. За по-усъвършенствано управление на повторните опити, tenacity е предпочитаният инструмент: декораторът декларира политиката, а тялото на функцията съдържа само извикването на бизнес логиката. Получавате същите съставки, но именувани и конфигурируеми – списък с изключения за повторен опит, експоненциално изчакване с ограничение от шестдесет секунди, спиране след пет опита и автоматично регистриране в дневника преди всяка пауза.

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

Шаблонът „Прекъсвач на веригата“ (Circuit Breaker)

Повторните опити решават инциденти, продължаващи няколко секунди. Те стават вредни, когато прекъсването продължава по-дълго: тогава всяка потребителска заявка консумира пет опита и тридесет секунди изчакване, преди да се провали, нишките Ви се натрупват и Вашият собствен сервис спира да работи. Прекъсвачът на веригата предотвратява продължаването на извикванията към неуспешен API от страна на Вашето приложение.

Той работи като електрически прекъсвач, с три състояния. Затворено (Closed): всичко работи нормално и извикванията преминават. Отворено (Open): API се счита за спрян и извикванията се блокират незабавно, без дори да се опитва мрежова връзка – потребителят получава грешка за милисекунди, вместо след изтичане на таймаут. Полуотворено (Half-open): след изтичане на периода на изчакване се изпраща тестово извикване, за да се провери дали API е възстановен: ако успее, веригата се затваря; ако се провали, тя се отваря отново за нов цикъл.

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

Броячът на грешките се нулира веднага щом едно извикване успее: именно последователните неуспехи отварят веригата, а не исторически кумулативен брой. Интеграцията от страна на клиента се свежда до три стъпки – поискване на разрешение, сигнализиране на успех, сигнализиране на неуспех.

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

Комбиниране на трите шаблона

В производствена среда комбинирайте експоненциалното отлагане, прекъсвача на веригата и таймаута. Обърнете внимание на конструктора: клиентът се създава с max_retries=0, което деактивара вътрешните повторни опити на SDK. Без това Вашите три опита биха се умножили по двата опита на SDK и бихте изчакали много по-дълго от очакваното. Тридесетсекундният таймаут ограничава всяко отделно извикване, цикълът обработва повторните опити, а прекъсвачът на веригата следи общото здраве на сервиса.

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

Преди да продължите, тествайте този клиент, като симулирате прекъсване: спрете мрежата, стартирайте дузина извиквания и проверете дали последните се провалят мигновено, вместо да чакат. Ако това не е така, Вашият праг е твърде висок за обработвания обем.

Ключови изводи

  • SDK извършва 2 повторни опита по подразбиране – коригирайте чрез max_retries
  • Експоненциалното отлагане със случайно отклонение (jitter) избягва ефекта на „тъпчещото се стадо“
  • Прекъсвачът на веригата защитава Вашето приложение от продължителни прекъсвания
  • Използвайте tenacity за декларативно управление на повторните опити в производство
  • Комбинирайте и трите шаблона за максимална устойчивост
  • Никога не правете повторни опити при грешки 400/401/403 (грешки от страна на клиента)