Retry logic

Prevents overwhelming a service by spacing out repeated requests after failures.

Web API client: handling HTTP 429 Too Many Requests responses; Distributed system: retrying failed RPC calls due to transient network errors; Database client: reconnecting after a connection timeout.

Microservices, cloud SDKs, networking libraries, database client wrappers, any client‑side retry mechanism.

def retry_with_backoff(operation, max_retries, base_delay, jitter_factor): for attempt_index in range(max_retries): try: return operation() except Exception: sleep_duration = base_delay * (2 ** attempt_index) sleep_duration += random.uniform(0, jitter_factor * sleep_duration) time.sleep(sleep_duration) raise RuntimeError("Maximum retries exceeded")

def ...(..., ..., ..., ...): for ... in ...: try: return ...() except ...: ... = ... * (2 ** ...) ... += random.uniform(0, ... * ...) time.sleep(...) raise ...

operation: callable that performs the desired action; max_retries: int ≥ 1; base_delay: float seconds; jitter_factor: float between 0 and 1; attempt_index: int (generated by loop); sleep_duration: float seconds (computed delay).

• time.sleep
• random.uniform
• try/except
• for loop
• max_retries
• exponential growth
• jitter
• raise RuntimeError

• Replace random jitter with a fixed small delay to simplify logic (reduces randomness but may cause synchronized retries)
• Use async sleep (await asyncio.sleep) for asynchronous code
• Cap the maximum delay with a min/max bound to avoid excessively long waits.

Omitting jitter, which can cause many clients to retry simultaneously; Using integer division for delay, resulting in zero‑second sleeps; Catching a broad Exception and swallowing non‑transient errors; Not limiting the maximum backoff, leading to impractically long waits; Forgetting to reset attempt count after a successful call, causing premature failure.

Fixed interval retry – uses a constant delay instead of exponential growth; Linear backoff – increases delay linearly rather than exponentially; Circuit breaker – stops retries entirely after a threshold is reached.

Coming from JavaScript: using setTimeout with milliseconds while Python's time.sleep expects seconds → ensure units match; Coming from Go: assuming defer will run after each retry, but Python's finally block behaves differently → place cleanup inside the except or finally as needed.

• Retry patterns
• Backoff strategies
• Circuit breaker

1) Do not use when the operation is non‑idempotent, as repeated attempts may cause side effects; 2) Exponential growth can produce long delays, so consider capping the maximum backoff; 3) Jitter should be a fraction of the computed delay to avoid creating delays longer than intended.

Reduces load spikes on overloaded services, improves overall system resilience, and lowers the chance of cascading failures in distributed environments.

Think of a person repeatedly calling a busy friend: each failed call makes them wait longer, but they pick a random moment to try again so they don't always ring at the same time.

It is advisable to set an upper bound on the backoff delay to keep retry latency within acceptable limits.

After mastering randomized exponential backoff, move to implementing a full circuit breaker with stateful failure tracking and fallback actions.