How to retry after exception?

The ins and outs of retry mechanisms

Incorporating retry mechanisms is an exercise in application resilience. Few considerations to bear in mind:

• Catch only expected exceptions. You wouldn't try catching a baseball with spaghetti, would you?
• Implementing a maximum retry limit is critical, unless infinite loops are your cup of tea.
• Keep idempotency in mind. Repeated operations shouldn't multiply like rabbits.
• Never underestimate the power of logging. Good logs are worth their weight in gold.

Controlling retries - from basic to advanced

The fundamental way

Retrying at its core is all about loops and error handling. Here's a buffed-up version with a while loop for more control:

max_retries = 5
attempts = 0

while attempts < max_retries:
    try:
        result = your_function()  # Let's give this another whirl
        break  # Success, break free from the loop!
    except YourException as e:  # Oops, an exception
        attempts += 1  # Let's notch up attempts
        if attempts == max_retries:
            raise  # Give up after a (generous) 5 tries.
        time.sleep(1)  # A little nap before the next round


Using ready-made libraries

For those desiring a few more bells and whistles, consider retrying libraries like tenacity or backoff. Here's how you can work it with tenacity:

import tenacity

@tenacity.retry(
    wait=tenacity.wait_fixed(1) + tenacity.wait_random(0, 1), 
    stop=tenacity.stop_after_attempt(5), 
    reraise=True
)
def robust_function():
    # Code that might fail goes here
    pass

robust_function()  # Let's see it soar. Or crash and burn.


This smart bit sets both fixed and random wait times, caps the number of retries, and ensures the exception doesn't run away after the last attempt.

Adjusting retry mechanisms to fit your needs

Custom exception for the win

For more focused retries under specific conditions, define your very own custom exception classes:

class MyCustomError(Exception):
    pass

@tenacity.retry(retry=tenacity.retry_if_exception_type(MyCustomError))
def my_function():
    # Code that might raise MyCustomError
    pass


Network retries - because Internet gremlins exist

For unpredictable network operations, where disappearances are quite common, a reconnection logic embedded in the retry loop could work wonders:

@tenacity.retry(wait=tenacity.wait_exponential(multiplier=1, max=60), stop=tenacity.stop_after_attempt(7))
def network_operation():
    # The function that's likely to fail, yet keeps popping back up like a whac-a-mole game
    pass


Dealing with persistent failure like a boss

There will be times the operation simply refuses to succeed. In such scenarios:

• Log the failure. In the world of programming, the log is your captain's log.
• Consider a fallback operation - defeat is simply the addition of time to victory.
• Throw a monitoring alarm. Let’s make some noise!

Best practices for resilient code

The significance of well-documented code

Nothing screams professional like well-documented code. Draw clear roadmaps – trust me, future you will thank you!

Library data freshness

A fresh library, with regular updates and activity, is always more appealing than a stale one.

Breaking bad with Circuit Breaker pattern

Faced with a stubborn operation that just won't succeed? Consider using the Circuit Breaker pattern to prevent drained resources and enhance system stability.

References