Exponential Backoff: Optimal Retry Timing

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// Basic exponential backoff implementation
interface BackoffConfig {
    baseDelayMs: number;    // Initial delay (e.g., 100ms)
    multiplier: number;     // Growth factor (typically 2)
    maxDelayMs: number;     // Cap to prevent absurdly long waits
    maxAttempts: number;    // Maximum retry attempts
}
 
function calculateBackoffDelay(
    attemptNumber: number,  // 0-indexed: 0 = first retry
    config: BackoffConfig
): number {
    // Calculate exponential delay
    const exponentialDelay = config.baseDelayMs * Math.pow(config.multiplier, attemptNumber);
    
    // Apply maximum cap
    return Math.min(exponentialDelay, config.maxDelayMs);
}
 
// Example usage
const config: BackoffConfig = {
    baseDelayMs: 100,
    multiplier: 2,
    maxDelayMs: 30000,  // Cap at 30 seconds
    maxAttempts: 8,
};
 
// See how delays grow
for (let attempt = 0; attempt < config.maxAttempts; attempt++) {
    const delay = calculateBackoffDelay(attempt, config);
    console.log(`Attempt ${attempt + 1}: wait ${delay}ms before retry`);
}
 
// Output:
// Attempt 1: wait 100ms before retry
// Attempt 2: wait 200ms before retry
// Attempt 3: wait 400ms before retry
// Attempt 4: wait 800ms before retry
// Attempt 5: wait 1600ms before retry
// Attempt 6: wait 3200ms before retry
// Attempt 7: wait 6400ms before retry
// Attempt 8: wait 12800ms before retry

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

// Complete exponential backoff with cap
interface CappedBackoffConfig {
    baseDelayMs: number;
    multiplier: number;
    maxDelayMs: number;
    maxAttempts: number;
    totalTimeoutMs?: number;  // Optional: total budget across all retries
}
 
class ExponentialBackoff {
    private attempt: number = 0;
    private totalElapsed: number = 0;
    private startTime: number = Date.now();
    
    constructor(private config: CappedBackoffConfig) {}
    
    /**
     * Returns next delay duration, or null if retries exhausted
     */
    nextDelay(): number | null {
        // Check attempt limit
        if (this.attempt >= this.config.maxAttempts) {
            return null;
        }
        
        // Check total time budget if configured
        if (this.config.totalTimeoutMs) {
            const elapsed = Date.now() - this.startTime;
            if (elapsed >= this.config.totalTimeoutMs) {
                return null;
            }
        }
        
        // Calculate delay
        const exponentialDelay = this.config.baseDelayMs * 
            Math.pow(this.config.multiplier, this.attempt);
        const cappedDelay = Math.min(exponentialDelay, this.config.maxDelayMs);
        
        // If total timeout configured, cap delay to remaining time
        if (this.config.totalTimeoutMs) {
            const remaining = this.config.totalTimeoutMs - (Date.now() - this.startTime);
            if (cappedDelay > remaining) {
                return null;  // Not enough time for this retry
            }
        }
        
        this.attempt++;
        return cappedDelay;
    }
    
    /**
     * Record that a delay was executed (for tracking)
     */
    recordWait(actualDelayMs: number): void {
        this.totalElapsed += actualDelayMs;
    }
    
    /**
     * Reset for reuse
     */
    reset(): void {
        this.attempt = 0;
        this.totalElapsed = 0;
        this.startTime = Date.now();
    }
    
    /**
     * Current attempt number
     */
    get currentAttempt(): number {
        return this.attempt;
    }
    
    /**
     * Total time spent waiting
     */
    get totalWaitTime(): number {
        return this.totalElapsed;
    }
}
 
// Usage example
async function retryWithBackoff<T>(
    operation: () => Promise<T>,
    config: CappedBackoffConfig
): Promise<T> {
    const backoff = new ExponentialBackoff(config);
    let lastError: Error | undefined;
    
    while (true) {
        try {
            return await operation();
        } catch (error) {
            lastError = error as Error;
            const delay = backoff.nextDelay();
            
            if (delay === null) {
                throw new Error(
                    `Retry exhausted after ${backoff.currentAttempt} attempts ` +
                    `(${backoff.totalWaitTime}ms total wait): ${lastError.message}`
                );
            }
            
            console.log(`Attempt ${backoff.currentAttempt} failed, ` +
                                        `waiting ${delay}ms before retry...`);
            
            await sleep(delay);
            backoff.recordWait(delay);
        }
    }
}
 
function sleep(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195

// Production-ready exponential backoff with full features
interface RetryOptions {
    // Backoff configuration
    baseDelayMs: number;
    maxDelayMs: number;
    multiplier: number;
    maxAttempts: number;
    
    // Error classification  
    isRetryable: (error: Error) => boolean;
    
    // Observability
    onRetry?: (attempt: number, delay: number, error: Error) => void;
    onExhausted?: (totalAttempts: number, totalWaitMs: number, lastError: Error) => void;
    
    // Advanced options
    respectRetryAfter?: boolean;
    abortSignal?: AbortSignal;
}
 
interface RetryResult<T> {
    success: boolean;
    value?: T;
    error?: Error;
    attempts: number;
    totalWaitMs: number;
}
 
/**
 * Execute an operation with exponential backoff retry
 */
async function executeWithRetry<T>(
    operation: (attempt: number) => Promise<T>,
    options: RetryOptions
): Promise<RetryResult<T>> {
    let attempts = 0;
    let totalWaitMs = 0;
    let lastError: Error | undefined;
    
    while (attempts < options.maxAttempts) {
        // Check for cancellation
        if (options.abortSignal?.aborted) {
            return {
                success: false,
                error: new Error('Operation cancelled'),
                attempts,
                totalWaitMs,
            };
        }
        
        attempts++;
        
        try {
            const result = await operation(attempts);
            return {
                success: true,
                value: result,
                attempts,
                totalWaitMs,
            };
        } catch (error) {
            lastError = error as Error;
            
            // Check if retryable
            if (!options.isRetryable(lastError)) {
                return {
                    success: false,
                    error: lastError,
                    attempts,
                    totalWaitMs,
                };
            }
            
            // Check if more attempts available
            if (attempts >= options.maxAttempts) {
                break;
            }
            
            // Calculate delay
            let delay = calculateDelay(attempts - 1, options);
            
            // Check for Retry-After header
            if (options.respectRetryAfter) {
                const retryAfter = extractRetryAfter(lastError);
                if (retryAfter) {
                    delay = Math.max(delay, retryAfter);
                }
            }
            
            // Notify observer
            options.onRetry?.(attempts, delay, lastError);
            
            // Wait
            await sleep(delay, options.abortSignal);
            totalWaitMs += delay;
        }
    }
    
    // Exhausted
    options.onExhausted?.(attempts, totalWaitMs, lastError!);
    
    return {
        success: false,
        error: lastError,
        attempts,
        totalWaitMs,
    };
}
 
function calculateDelay(attemptIndex: number, options: RetryOptions): number {
    const exponential = options.baseDelayMs * Math.pow(options.multiplier, attemptIndex);
    return Math.min(exponential, options.maxDelayMs);
}
 
function extractRetryAfter(error: Error): number | null {
    // Implementation depends on your HTTP client
    const response = (error as any).response;
    const retryAfterHeader = response?.headers?.['retry-after'];
    
    if (!retryAfterHeader) return null;
    
    // Could be seconds or HTTP date
    const seconds = parseInt(retryAfterHeader, 10);
    if (!isNaN(seconds)) return seconds * 1000;
    
    const date = new Date(retryAfterHeader);
    if (!isNaN(date.getTime())) {
        return Math.max(0, date.getTime() - Date.now());
    }
    
    return null;
}
 
function sleep(ms: number, signal?: AbortSignal): Promise<void> {
    return new Promise((resolve, reject) => {
        const timeout = setTimeout(resolve, ms);
        
        signal?.addEventListener('abort', () => {
            clearTimeout(timeout);
            reject(new Error('Sleep aborted'));
        });
    });
}
 
// Example usage
async function exampleUsage() {
    const result = await executeWithRetry(
        async (attempt) => {
            console.log(`Executing attempt ${attempt}`);
            const response = await fetch('https://api.example.com/data');
            if (!response.ok) {
                throw new HttpError(response.status, await response.text());
            }
            return response.json();
        },
        {
            baseDelayMs: 100,
            maxDelayMs: 10000,
            multiplier: 2,
            maxAttempts: 5,
            
            isRetryable: (error) => {
                if (error instanceof HttpError) {
                    return [408, 429, 502, 503, 504].includes(error.status);
                }
                return error.name === 'NetworkError';
            },
            
            onRetry: (attempt, delay, error) => {
                console.log(`Attempt ${attempt} failed: ${error.message}. ` +
                                        `Retrying in ${delay}ms`);
            },
            
            onExhausted: (attempts, wait, error) => {
                console.error(`Failed after ${attempts} attempts ` +
                                    `(${wait}ms total): ${error.message}`);
            },
            
            respectRetryAfter: true,
        }
    );
    
    if (result.success) {
        console.log('Success:', result.value);
    } else {
        console.error('Failed:', result.error);
    }
}
 
class HttpError extends Error {
    constructor(public status: number, message: string) {
        super(`HTTP ${status}: ${message}`);
        this.name = 'HttpError';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

// Configuration presets for common scenarios
const BackoffPresets = {
    // Fast user-facing calls
    userFacing: {
        baseDelayMs: 50,
        multiplier: 1.5,
        maxDelayMs: 5000,
        maxAttempts: 4,
        // Total max wait: ~500ms
    },
    
    // Standard microservice communication
    internalService: {
        baseDelayMs: 100,
        multiplier: 2,
        maxDelayMs: 10000,
        maxAttempts: 5,
        // Total max wait: ~15s
    },
    
    // External API with rate limiting
    externalApi: {
        baseDelayMs: 2000,
        multiplier: 2,
        maxDelayMs: 300000, // 5 minutes
        maxAttempts: 6,
        respectRetryAfter: true,
        // Total max wait: ~6min (if not hitting max)
    },
    
    // Background job processing
    backgroundJob: {
        baseDelayMs: 1000,
        multiplier: 2,
        maxDelayMs: 900000, // 15 minutes  
        maxAttempts: 15,
        // Will retry for a long time
    },
    
    // Database connection retry
    databaseConnection: {
        baseDelayMs: 200,
        multiplier: 2,
        maxDelayMs: 60000, // 1 minute
        maxAttempts: 10,
        // Reasonable for DB reconnection
    },
    
    // Aggressive backoff for overloaded service
    overloadedService: {
        baseDelayMs: 500,
        multiplier: 3, // Aggressive multiplier
        maxDelayMs: 120000, // 2 minutes
        maxAttempts: 8,
        // Grows very fast to reduce pressure
    },
} as const;
 
// Helper to calculate total max wait time for a configuration
function calculateTotalMaxWait(config: {
    baseDelayMs: number;
    multiplier: number;
    maxDelayMs: number;
    maxAttempts: number;
}): number {
    let total = 0;
    for (let i = 0; i < config.maxAttempts - 1; i++) {
        const delay = Math.min(
            config.baseDelayMs * Math.pow(config.multiplier, i),
            config.maxDelayMs
        );
        total += delay;
    }
    return total;
}
 
// Log configurations with their max wait times
for (const [name, config] of Object.entries(BackoffPresets)) {
    const maxWait = calculateTotalMaxWait(config);
    console.log(`${name}: max wait = ${(maxWait / 1000).toFixed(1)}s`);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

// Decorrelated backoff implementation
interface DecorrelatedBackoffConfig {
    baseDelayMs: number;
    maxDelayMs: number;
}
 
class DecorrelatedBackoff {
    private previousDelay: number;
    
    constructor(private config: DecorrelatedBackoffConfig) {
        this.previousDelay = config.baseDelayMs;
    }
    
    /**
     * Calculate next delay using decorrelated algorithm
     */
    nextDelay(): number {
        // Random delay between base and 3x previous
        const minDelay = this.config.baseDelayMs;
        const maxDelay = this.previousDelay * 3;
        
        // Random value in range [minDelay, maxDelay]
        const nextDelay = minDelay + Math.random() * (maxDelay - minDelay);
        
        // Cap at maximum
        this.previousDelay = Math.min(nextDelay, this.config.maxDelayMs);
        
        return this.previousDelay;
    }
    
    /**
     * Reset to initial state
     */
    reset(): void {
        this.previousDelay = this.config.baseDelayMs;
    }
}
 
// Demonstration: generate sequence of delays
function demonstrateDecorrelatedBackoff() {
    const backoff = new DecorrelatedBackoff({
        baseDelayMs: 100,
        maxDelayMs: 30000,
    });
    
    console.log('Decorrelated backoff sequence:');
    for (let i = 0; i < 10; i++) {
        const delay = backoff.nextDelay();
        console.log(`  Attempt ${i + 1}: ${delay.toFixed(0)}ms`);
    }
}
 
// Compare multiple sequences to show decorrelation
function compareSequences() {
    console.log('
Three independent sequences (showing decorrelation):');
    
    for (let seq = 1; seq <= 3; seq++) {
        const backoff = new DecorrelatedBackoff({
            baseDelayMs: 100,
            maxDelayMs: 30000,
        });
        
        const delays: number[] = [];
        for (let i = 0; i < 6; i++) {
            delays.push(Math.round(backoff.nextDelay()));
        }
        
        console.log(`  Sequence ${seq}: ${delays.join(' -> ')} ms`);
    }
}
 
demonstrateDecorrelatedBackoff();
compareSequences();
 
// Sample output:
// Decorrelated backoff sequence:
//   Attempt 1: 178ms
//   Attempt 2: 312ms
//   Attempt 3: 534ms
//   Attempt 4: 1245ms
//   Attempt 5: 2156ms
//   Attempt 6: 5432ms
//   ...
//
// Three independent sequences (showing decorrelation):
//   Sequence 1: 167 -> 389 -> 892 -> 2134 -> 5678 -> 12345 ms
//   Sequence 2: 234 -> 456 -> 567 -> 1456 -> 3456 -> 8765 ms
//   Sequence 3: 145 -> 278 -> 712 -> 1823 -> 4321 -> 9876 ms

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

// CORRECT: Circuit breaker wraps retry logic
async function correctPattern<T>(operation: () => Promise<T>): Promise<T> {
    // Circuit breaker check first
    if (circuitBreaker.isOpen()) {
        throw new CircuitOpenError('Circuit is open, failing fast');
    }
    
    try {
        // Retry logic inside circuit breaker context
        const result = await executeWithRetry(operation, backoffConfig);
        circuitBreaker.recordSuccess();
        return result;
    } catch (error) {
        circuitBreaker.recordFailure();
        throw error;
    }
}
 
// INCORRECT: Retry logic wraps circuit breaker
async function incorrectPattern<T>(operation: () => Promise<T>): Promise<T> {
    return executeWithRetry(async () => {
        // This is wrong: we'd retry even when circuit is open!
        if (circuitBreaker.isOpen()) {
            throw new CircuitOpenError('Circuit open');
        }
        return await operation();
    }, backoffConfig);
}
 
// The issue with incorrect pattern:
// - When circuit opens, each retry attempt immediately fails
// - Backoff waits between attempts that can't possibly succeed
// - Wastes time without providing any benefit
// - Circuit cooldown may end mid-retry sequence, causing inconsistent behavior
 
// Complete integrated example
class ResilientClient {
    private circuitBreaker: CircuitBreaker;
    private backoffConfig: BackoffConfig;
    
    constructor(
        private serviceName: string,
        circuitBreakerConfig: CircuitBreakerConfig,
        backoffConfig: BackoffConfig
    ) {
        this.circuitBreaker = new CircuitBreaker(circuitBreakerConfig);
        this.backoffConfig = backoffConfig;
    }
    
    async call<T>(operation: () => Promise<T>): Promise<T> {
        // 1. Check circuit state
        const circuitState = this.circuitBreaker.getState();
        
        if (circuitState === 'OPEN') {
            throw new CircuitOpenError(
                `Circuit for ${this.serviceName} is open. ` +
                                        `Will retry after ${this.circuitBreaker.getRemainingCooldown()}ms`
            );
        }
        
        // 2. If half-open, allow limited testing
        const retryConfig = circuitState === 'HALF_OPEN'
            ? { ...this.backoffConfig, maxAttempts: 1 }  // Single attempt for probing
            : this.backoffConfig;
        
        try {
            // 3. Execute with retry (inside circuit context)
            const result = await executeWithRetry(operation, retryConfig);
            
            // 4. Record success (may close circuit if half-open)
            this.circuitBreaker.recordSuccess();
            
            return result;
        } catch (error) {
            // 5. Record failure (may open circuit)
            this.circuitBreaker.recordFailure(error as Error);
            throw error;
        }
    }
}