Retry with exponential backoff and jitter for transient failures

A service calls an external API that occasionally returns 429 or 503. Retrying immediately causes a thundering herd that worsens the outage.

Implement exponential backoff with jitter:

async function withRetry(fn, options = {}) {
  const {
    maxAttempts = 3,
    baseDelayMs = 100,
    maxDelayMs = 30000,
    retryOn = (err) => err.status >= 500 || err.status === 429,
  } = options;

  let lastError;
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    try {
      return await fn();
    } catch (err) {
      lastError = err;
      if (attempt === maxAttempts - 1 || !retryOn(err)) throw err;

      // Exponential backoff with full jitter
      const expDelay = Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
      const jitter = Math.random() * expDelay;
      const delay = Math.floor(jitter);

      console.log(`Attempt ${attempt + 1} failed, retrying in ${delay}ms`, { error: err.message });
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
  throw lastError;
}

// Usage
const result = await withRetry(
  () => fetch('https://api.example.com/data').then(r => r.json()),
  { maxAttempts: 4, baseDelayMs: 200 }
);

Full jitter (random delay between 0 and the exponential cap) spreads retries across time, preventing all clients from retrying in sync which would recreate the spike.