When dealing with network requests or other transient errors in JavaScript, a common strategy is to retry failed requests. However, retrying too frequently can overwhelm the server or cause network congestion. A well-known approach to mitigate this is exponential backoff, which spaces out retries over increasingly longer intervals. In this article, we’ll explore a simple yet customizable solution to calculate backoff time in JavaScript using a utility function called calcBackoffMs.

Note: calcBackoffMs is not a retry library. It is a utility function to calculate backoff times. You will need to implement the retry logic separately based on your application’s requirements.

What is Exponential Backoff?

Exponential backoff is a technique where the time between retries increases exponentially with each attempt. For example, if the first retry happens after 1 second, the second retry will happen after 2 seconds, the third after 4 seconds, and so on. This strategy is commonly used in networked environments to avoid hammering a server with requests after repeated failures.

To further reduce the chances of simultaneous retries by multiple clients, randomization can be applied to the delay. This means adding some variability to the calculated backoff time, ensuring that not all retries happen at the exact same interval.

Exponential Backoff Timeline

Introducing calcBackoffMs

The calcBackoffMs utility function simplifies the process of calculating exponential backoff time. It takes into account the number of attempts and provides an optional randomization factor for variability.

Features:

• Exponential delay: The delay between retries increases exponentially.
• Customizable: Configure the base time, maximum retry attempts, and maximum allowable backoff time.
• Randomization: Add a randomization factor to ensure retries don’t happen all at once.

Simple Usage Example

The simplest usage scenario involves providing just the retry attempt, allowing calcBackoffMs to calculate the backoff time using default values for the base time and randomization.

import { calcBackoffMs } from 'exponential-backoff-calculator';

// Retry attempt #3
const backoffTime = calcBackoffMs({ attempt: 3 });
console.log(backoffTime); // Outputs the backoff time in milliseconds

In this example, the backoff time is calculated based on the third retry with a base time of 1 second, doubling the delay with each retry.

Advanced Usage Example

For more control, you can customize the options such as the base retry time, maximum backoff time, maximum number of retry attempts, and the randomization factor.

import { calcBackoffMs } from 'exponential-backoff-calculator';

// Custom configuration for advanced retry strategy
const options = {
  attempt: 5,                // Retry attempt #5
  baseTimeMs: 500,           // Base time of 500ms
  maxTimeMs: 60000,          // Max backoff time capped at 1 minute
  maxAttempts: 8,            // Maximum 8 retry attempts
  randomizationFactor: 0.1,  // 10% randomization factor
};

const backoffTime = calcBackoffMs(options);
console.log(backoffTime); // Outputs the customized backoff time

In this advanced example, we adjust the base time to 500ms, set a maximum backoff cap of 60 seconds, and apply a randomization factor of 10%.

Real-World Use Case

Imagine a scenario where your application is making API calls to a third-party service that occasionally fails. Instead of immediately retrying after a failure (which could flood the service), you can implement exponential backoff with calcBackoffMs.

async function makeApiRequest(attempt = 1) {
  try {
    // Simulate API request
    const response = await fetch('https://api.example.com/data');
    return await response.json();
  } catch (error) {
    // Calculate backoff time before retrying
    const backoff = calcBackoffMs({ attempt });
    console.log(`Attempt ${attempt}: Retrying in ${backoff}ms...`);

    if (attempt < 10) {
      await new Promise(resolve => setTimeout(resolve, backoff));
      return makeApiRequest(attempt + 1);
    } else {
      throw new Error('Max retry attempts reached');
    }
  }
}

This code retries the API request with increasing backoff intervals up to a maximum of 10 attempts.

Conclusion

Exponential backoff is a powerful strategy to handle transient errors in distributed systems. The calcBackoffMs function offers a simple yet flexible way to implement exponential backoff with randomization in JavaScript.

Whether you’re dealing with network retries, API requests, or any other operation prone to intermittent failures, incorporating a backoff strategy like this can greatly improve the resilience of your applications.

For more in-depth knowledge on exponential backoff and jitter, check out this AWS blog post.