feat:create-minute-exponential-backoff

Author: asalsys

packages/remote-feature-flag-controller/src/client-config-api-service/client-config-api-service.test.ts

@@ -192,6 +192,64 @@ describe('ClientConfigApiService', () => {
       expect(mockFetch).toHaveBeenCalledTimes(maxRetries + 1); // Initial + retries
     });
 
+    it('should retry at correct time intervals (1min, 2min, 4min)', async () => {
+      jest.useFakeTimers();
+      
+      const networkError = new Error('Network error');
+      let callCount = 0;
+      
+      // Mock fetch to fail 3 times then succeed, and track call times with fake Date.now()
+      const mockFetch = jest.fn().mockImplementation(() => {
+        callCount++;
+        if (callCount <= 3) {
+          return Promise.reject(networkError);
+        }
+        return Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve([{ testFlag: true }]),
+        });
+      });
+
+      const clientConfigApiService = new ClientConfigApiService({
+        fetch: mockFetch,
+        retries: 3, // Allow 3 retries (4 total attempts)
+        maximumConsecutiveFailures: 10, // Prevent circuit breaker from interfering
+        config: {
+          client: ClientType.Extension,
+          distribution: DistributionType.Main,
+          environment: EnvironmentType.Production,
+        },
+      });
+
+      // Start the operation
+      const fetchPromise = clientConfigApiService.fetchRemoteFeatureFlags();
+      
+      // Initial call should happen immediately
+      await jest.advanceTimersByTimeAsync(0); // Process immediate promises
+      expect(mockFetch).toHaveBeenCalledTimes(1);
+
+      // First retry should happen after 1 minute
+      await jest.advanceTimersByTimeAsync(60 * 1000);
+      expect(mockFetch).toHaveBeenCalledTimes(2);
+
+      // Second retry should happen after 2 more minutes
+      await jest.advanceTimersByTimeAsync(2 * 60 * 1000);
+      expect(mockFetch).toHaveBeenCalledTimes(3);
+
+      // Third retry should happen after 4 more minutes
+      await jest.advanceTimersByTimeAsync(4 * 60 * 1000);
+      expect(mockFetch).toHaveBeenCalledTimes(4);
+
+      // The final call should succeed
+      const result = await fetchPromise;
+      expect(result).toEqual({
+        remoteFeatureFlags: { testFlag: true },
+        cacheTimestamp: expect.any(Number),
+      });
+
+      jest.useRealTimers();
+    });
+
     it('should call the onBreak callback when the circuit opens', async () => {
       const onBreak = jest.fn();
       const mockFetch = createMockFetch({ error: networkError });

packages/remote-feature-flag-controller/src/client-config-api-service/client-config-api-service.ts

@@ -3,6 +3,7 @@ import {
   DEFAULT_CIRCUIT_BREAK_DURATION,
   DEFAULT_MAX_CONSECUTIVE_FAILURES,
   DEFAULT_MAX_RETRIES,
+  ExponentialBackoff,
 } from '@metamask/controller-utils';
 import type { ServicePolicy } from '@metamask/controller-utils';
 
@@ -17,6 +18,22 @@ import type {
   ApiDataResponse,
 } from '../remote-feature-flag-controller-types';
 
+/**
+ * Custom backoff factory that implements exponential progression in minutes.
+ * 1st retry: 1 minute, 2nd retry: 2 minutes, 3rd retry: 4 minutes, etc.
+ * Uses Cockatiel's ExponentialBackoff with minute-based intervals.
+ */
+function createMinuteBasedExponentialBackoff() {
+  return new ExponentialBackoff({
+    // Start with 1 minute base delay (60,000 ms)
+    initialDelay: 60 * 1000,
+    // Use a multiplier of 2 for exponential progression (1min, 2min, 4min, 8min...)
+    exponent: 2,
+    // Maximum delay to prevent extremely long waits
+    maxDelay: 15 * 60 * 1000, // 15 minutes max
+  });
+}
+
 /**
  * This service is responsible for fetching feature flags from the ClientConfig API.
  */
@@ -138,6 +155,7 @@ export class ClientConfigApiService implements AbstractClientConfigApiService {
       maxRetries: retries,
       maxConsecutiveFailures: maximumConsecutiveFailures,
       circuitBreakDuration,
+      backoff: createMinuteBasedExponentialBackoff(),
     });
     if (onBreak) {
       this.#policy.onBreak(onBreak);