tenacity

Tenacity has been rock-solid in production environments handling millions of retries daily. The decorator-based API is clean and the ability to compose retry strategies (exponential backoff, jitter, max attempts) makes it extremely flexible. I particularly appreciate the before/after/on_error callback hooks which integrate seamlessly with our observability stack - we log retry attempts with context, track metrics in Datadog, and get detailed visibility into transient failures.

The wait strategies are well-designed with sensible defaults. Exponential backoff with jitter is trivial to implement and the stop conditions (after_attempt, after_delay) prevent runaway retries. Memory usage is minimal since it doesn't accumulate state between calls. The retry_if_exception_type and retry_if_result predicates give fine-grained control over what triggers retries.

Configuration is straightforward and works well with environment-based settings. We've used it for API calls, database operations, and distributed system coordination. The library handles edge cases gracefully - no leaked connections or hanging threads. The only gotcha is remembering that decorators are applied at import time, so dynamic configuration needs reraise=True with try/except or the Retrying class directly.

Tenacity makes adding retry logic dead simple with its decorator-based API. The `@retry` decorator works out of the box for most cases, and when you need customization, the options are intuitive: `stop=stop_after_attempt(3)`, `wait=wait_exponential(multiplier=1, min=4, max=10)`. The fluent API reads like plain English, which drastically reduces the learning curve. I was productive within 15 minutes of reading the docs.

The error messages are surprisingly helpful. When a retry fails after all attempts, you get the original exception with clear context about retry attempts made. The `retry_error_callback` parameter lets you customize failure handling easily. I particularly appreciate the `before_sleep` callback for logging - it's simple to add visibility into what's happening during retries without complex instrumentation.

Documentation includes practical examples for common scenarios: API calls with rate limiting, database connections, exponential backoff with jitter. The combination of decorators and programmatic retry objects (`Retrying()`) gives flexibility for both simple and complex use cases. Community support on GitHub is responsive, and most questions are already answered in issues.

Tenacity makes retry logic remarkably intuitive through its decorator-based API. The `@retry` decorator handles 90% of use cases out of the box, while the composable stop/wait/retry strategies make complex scenarios straightforward. Type hints are comprehensive, making IDE autocomplete incredibly helpful when chaining strategies like `stop=stop_after_attempt(3) | stop_after_delay(10)`. Error messages clearly indicate which retry condition triggered, saving debugging time.

The documentation strikes the perfect balance between quick-start simplicity and deep-dive complexity. Real-world examples cover everything from basic retries to custom callbacks for logging. The `retry_if_exception_type()` and `wait_exponential()` functions handle the most common patterns elegantly, while advanced features like `before_sleep` callbacks integrate seamlessly with logging frameworks.

Migration between versions has been painless in my experience. The library's philosophy of composable, reusable components means you can start simple and add complexity incrementally. AsyncIO support through `@retry_async` works flawlessly, though the async documentation could be slightly more prominent.