Optimizing API Calls with Axios Retry and Memoization in Node.js

When working with APIs in modern web applications, handling network errors and improving performance are crucial for a smooth user experience. In this article, we’ll explore how to implement retry logic using axios and axios-retry and how to use memoization to optimize repeated API calls with the memoizee library.

Retry Logic in Axios with axios-retry

Imagine you’re building a service that needs to make HTTP POST requests to another service or API. Sometimes, the network can be unreliable, and requests may fail due to temporary issues. Instead of immediately failing, it’s often beneficial to retry the request after a delay. The axios-retry library makes this easy by automatically retrying failed requests.

Here’s a template of an axios POST call with retry logic:

 
const axios = require('axios');
const axiosRetry = require('axios-retry');

// Set up axios-retry to retry the request 3 times with exponential backoff
axiosRetry(axios, {
  retries: 3, // Number of retry attempts
  retryDelay: retryCount => retryCount * 1000, // Delay between retries (in ms)
});

const config = require('../config'); // Import your config
const { getServiceHeaders } = require('../utils/api'); // Import your function to get headers

// Function to make a POST request
const getServiceData = async (data) => {
  const { service_timeout, service_base_url } = config.getConfig(); // Get config values
  const url = `${service_base_url}/path_to_resource`; // Construct the API URL
  const headers = await getServiceHeaders(); // Get headers for the service

  const response = await axios.post(url, data, {
    headers, 
    timeout: service_timeout, // Set a timeout for the request
  });

  return response.data; // Return the response data
};

module.exports = {
  getServiceData,
};

Explanation of Key Elements:

1. Retries: The number of times the request will be retried if it fails. In the example above, the request is retried up to 3 times.
2. retryDelay: A function that defines the delay between retries. Here, the delay increases by 1 second for each retry.
3. Configurable Headers: The headers passed to the API can be dynamically generated or imported based on your project’s setup.
4. Timeout: A timeout is defined for the request, ensuring that long-running requests fail gracefully after a certain period.

This pattern ensures that your application can handle temporary failures without breaking the user experience, retrying the request automatically in case of issues like network instability.

Using Memoization with memoizee for Improved Performance

Memoization is a powerful technique used to optimize repeated function calls by caching the result of an expensive computation and returning the cached result when the same inputs occur again. This is particularly useful when making the same API call multiple times within a short period of time, reducing the overhead of repeated network requests.

The memoizee library provides a simple and efficient way to implement memoization in JavaScript.

Here’s an example of memoizing a function that fetches an API token:

 
const axios = require('axios');
const memo = require('memoizee');

// Memoized function to get the API token
const getBearerToken = memo(
  async () => {
    const url = `${process.env.API_BASE_URL}/auth/token`; // Construct API URL
    const response = await axios.post(url, {
      clientId: process.env.CLIENT_ID,
      clientSecret: process.env.CLIENT_SECRET,
    });

    return `Bearer ${response.data.token}`; // Return the token
  },
  { maxAge: 780000, promise: true } // Cache the token for 13 minutes
);

Why Memoization?

• Improves Performance: When making frequent API calls, memoization stores the result of the API response and prevents redundant network requests. This improves application speed and reduces load on the API.
• Reduces Latency: Cached responses are returned almost instantly, significantly improving response times for end users.

When to Use Memoization

• Frequent API Calls: If the same API call is made multiple times within a short time frame, memoization helps reduce overhead.
• Static or Rarely Changing Data: If the data returned by the API doesn’t change often, caching the result for a few minutes can save resources.

When NOT to Use Memoization

• Frequently Changing Data: If the API response is likely to change frequently, caching it can lead to stale data being served.
• Infrequent API Calls: If the API call is rare, memoization overhead might not provide significant performance improvements.

Combining Retry Logic and Memoization

You can combine both retry logic and memoization to create robust and efficient API services. For example, if your application frequently requests a token from an authentication service, memoization ensures that the token is cached and reused for a specified duration, while retry logic ensures that if the token fetch fails due to a temporary network issue, the request is retried.

Conclusion

Retry logic and memoization are simple but powerful techniques to improve the resilience and performance of your API calls. By implementing these patterns using axios-retry and memoizee, you can handle temporary failures more gracefully and reduce redundant API requests, leading to faster, more efficient applications.

Key Takeaways:

• Retry Logic: Use axios-retry to automatically retry failed API calls with a delay, improving reliability.
• Memoization: Use memoizee to cache API responses and avoid redundant network calls, improving performance.
• Best Practices: Understand when to apply memoization and retry logic based on the nature of your API calls and application needs.

These techniques can significantly enhance the robustness and performance of your Node.js applications, ensuring they can handle real-world conditions effectively.

Further Reading

• Memoizee library
• Axios library
• Axios retry library