Function Retrier: Implement a Retry Decorator with Backoff and Exception Filtering

Question

## Problem

Implement a `retry` decorator that wraps a function and automatically retries it on failure. The decorator should accept:
- `max_attempts`: maximum number of tries (including the first)
- `delay`: seconds to wait between attempts (float)
- `exceptions`: tuple of exception types to catch (retry only on these)

If all attempts fail, re-raise the last exception. If the function succeeds, return its result.

```python
import time
from functools import wraps

def retry(max_attempts: int = 3, delay: float = 1.0, exceptions: tuple = (Exception,)):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            ...
        return wrapper
    return decorator

# Usage
@retry(max_attempts=3, delay=0.5, exceptions=(ConnectionError, TimeoutError))
def fetch_data(url: str) -> dict:
    ...
```

**Example:**
```
fetch_data raises ConnectionError twice, then succeeds.
-> decorator retries twice, returns result on 3rd attempt.

fetch_data raises ValueError (not in exceptions tuple).
-> decorator does NOT catch it; ValueError propagates immediately.
```

## Follow-ups

1. Add exponential backoff: delay doubles on each retry. How do you implement this without changing the function signature?
2. Add jitter (random offset to delay) to avoid thundering herd. Why is this important in distributed systems?
3. How would you make the retrier async-compatible for use with `asyncio`?
4. How would you log each retry attempt with the attempt number and exception message?

Function Retrier: Implement a Retry Decorator with Backoff and Exception Filtering

Question Details

Full Details

Topics

More from Airbnb