circuit breaker with exponential backoff

Resilience Patterns

Meaning

A circuit breaker is a resilience pattern that temporarily stops requests to a failing service, preventing cascade failures. When combined with exponential backoff, the breaker gradually increases the wait time before allowing test requests, giving the service more time to recover. Use it when dealing with remote calls that may experience transient or prolonged outages.

Primary Function

Fault tolerance

Communicative Purpose

Prevents overload of a failing service and allows recovery time via increasing retry delays.

Pattern

Wrap service calls in a circuit breaker that retries with exponential backoff

Core Structure

delay = base * 2 ** attempt

Função primária

Fault tolerance

Propósito comunicativo

Prevents overload of a failing service and allows recovery time via increasing retry delays.

Situações de gatilho

Intermittent network failures, service degradation under load, dependent API experiencing prolonged downtime

Contextos

Distributed systems, microservices architectures, cloud-native applications, API gateways, client-side libraries

Padrão

Wrap service calls in a circuit breaker that retries with exponential backoff

Estrutura central

delay = base * 2 ** attempt

Colocados típicos

timeout settings
retry policies
bulkhead pattern
health checks

Substituições comuns

Fixed interval retries (simpler but less adaptive)
jitter‑based backoff (reduces synchronization)
disabling retries (fails fast)

Erros comuns

Setting thresholds too low causing premature tripping, forgetting to reset the breaker after recovery, using excessive backoff delays that hurt user experience

Similar / contraste

Bulkhead pattern (isolates resources to limit failure spread), Retry pattern (simple retries without backoff), Timeout pattern (bounds call duration but does not retry)

Interferências

Coming from simple retry logic: may assume exponential backoff always improves performance, but under persistent failures it can increase latency and worsen user experience.

Família do chunk

circuit breaker
retry pattern
bulkhead pattern
timeout pattern
rate limiter

Nuance

Can add latency during transient spikes; requires tuning of failure threshold and timeout window; not ideal for low‑latency real‑time systems where fast failure is preferred.

Efeito pragmático

Prevents cascade failures, lets the system degrade gracefully while giving the failing service time to recover, improving overall availability.

Dica de memória

Like a safety fuse that waits longer before blowing each time.

Nota

Adding random jitter to the exponential delay prevents synchronized retries (the thundering‑herd problem) and improves overall system stability.

Upgrade path

Adaptive circuit breaker with dynamic threshold adjustment based on success rates

Frequência: MediumFormulaicidade: FlexibleTipo de construção: conceptualPrioridade de aquisição: Recognition firstPrioridade de output: BothTag de espaçamento: Medium-term

Examples

import time import random def call_service(): # placeholder for actual remote call raise Exception("Service unavailable") def circuit_breaker(max_failures=5, base_delay=0.5): failures = 0 while True: try: return call_service() except Exception: failures += 1 if failures >= max_failures: raise delay = base_delay * (2 ** (failures - 1)) time.sleep(delay) # usage try: circuit_breaker() except Exception as e: print("Call failed:", e)

from tenacity import retry, stop_after_attempt, wait_exponential_jitter @retry(stop=stop_after_attempt(5), wait=wait_exponential_jitter(multiplier=0.5)) def fetch_data(): # simulate remote request raise ConnectionError("Temporary failure") try: fetch_data() except Exception as e: print("All retries exhausted:", e)

from circuitbreaker import circuit, CircuitBreakerError import time @circuit(failure_threshold=3, recovery_timeout=10, expected_exception=Exception) def get_resource(): # simulate intermittent failure if time.time() % 2 < 1: raise Exception("Transient error") return "resource" for _ in range(5): try: print(get_resource()) except CircuitBreakerError: print("Circuit open, skipping call") time.sleep(1)