Squashed 'apollo-ios/' changes from f0c9d1282..038b6e707

038b6e707 feat: Add exponential backoff support to MaxRetryInterceptor (#711)

git-subtree-dir: apollo-ios
git-subtree-split: 038b6e70731b15f0530fd099575de3011de0df14

Author: gh-action-runner

Sources/Apollo/MaxRetryInterceptor.swift

@@ -3,10 +3,51 @@ import Foundation
 import ApolloAPI
 #endif
 
-/// An interceptor to enforce a maximum number of retries of any `HTTPRequest`
+/// An interceptor to enforce a maximum number of retries of any `HTTPRequest` with optional exponential backoff support
 public class MaxRetryInterceptor: ApolloInterceptor {
 
-  private let maxRetries: Int
+  /// A configuration object that defines behavior for retry logic and exponential backoff.
+  public struct Configuration {
+    /// Maximum number of retries allowed. Defaults to `3`.
+    public let maxRetries: Int
+    /// Initial delay in seconds for exponential backoff. Defaults to `0.3`.
+    public let baseDelay: TimeInterval
+    /// Multiplier for exponential backoff calculation. Defaults to `2.0`.
+    public let multiplier: Double
+    /// Maximum delay cap in seconds to prevent excessive wait times. Defaults to `20.0`.
+    public let maxDelay: TimeInterval
+    /// Whether to enable exponential backoff delays between retries. Defaults to `false`.
+    public let enableExponentialBackoff: Bool
+    /// Whether to add jitter to delays to prevent thundering herd problems. Defaults to `true`.
+    public let enableJitter: Bool
+    
+    /// Designated initializer
+    ///
+    /// - Parameters:
+    ///   - maxRetries: Maximum number of retries allowed.
+    ///   - baseDelay: Initial delay in seconds for exponential backoff.
+    ///   - multiplier: Multiplier for exponential backoff calculation. Should be ≥ 1.0.
+    ///   - maxDelay: Maximum delay cap in seconds to prevent excessive wait times.
+    ///   - enableExponentialBackoff: Whether to enable exponential backoff delays between retries.
+    ///   - enableJitter: Whether to add jitter to delays to prevent thundering herd problems.
+    public init(
+      maxRetries: Int = 3,
+      baseDelay: TimeInterval = 0.3,
+      multiplier: Double = 2.0,
+      maxDelay: TimeInterval = 20.0,
+      enableExponentialBackoff: Bool = false,
+      enableJitter: Bool = true
+    ) {
+      self.maxRetries = maxRetries
+      self.baseDelay = baseDelay
+      self.multiplier = multiplier
+      self.maxDelay = maxDelay
+      self.enableExponentialBackoff = enableExponentialBackoff
+      self.enableJitter = enableJitter
+    }
+  }
+  
+  private let configuration: Configuration
   private var hitCount = 0
 
   public var id: String = UUID().uuidString
@@ -26,17 +67,24 @@ public class MaxRetryInterceptor: ApolloInterceptor {
   ///
   /// - Parameter maxRetriesAllowed: How many times a query can be retried, in addition to the initial attempt before
   public init(maxRetriesAllowed: Int = 3) {
-    self.maxRetries = maxRetriesAllowed
+    self.configuration = Configuration(maxRetries: maxRetriesAllowed)
+  }
+  
+  /// Designated initializer with full configuration support.
+  ///
+  /// - Parameter configuration: Configuration object defining retry behavior and exponential backoff settings.
+  public init(configuration: Configuration) {
+    self.configuration = configuration
   }
 
   public func interceptAsync<Operation: GraphQLOperation>(
     chain: any RequestChain,
     request: HTTPRequest<Operation>,
     response: HTTPResponse<Operation>?,
     completion: @escaping (Result<GraphQLResult<Operation.Data>, any Error>) -> Void) {
-    guard self.hitCount <= self.maxRetries else {
+    guard self.hitCount <= self.configuration.maxRetries else {
       let error = RetryError.hitMaxRetryCount(
-        count: self.maxRetries,
+        count: self.configuration.maxRetries,
         operationName: Operation.operationName
       )
 
@@ -51,11 +99,48 @@ public class MaxRetryInterceptor: ApolloInterceptor {
     }
 
     self.hitCount += 1
-    chain.proceedAsync(
-      request: request,
-      response: response,
-      interceptor: self,
-      completion: completion
-    )
+    
+    // Apply exponential backoff delay if enabled and this is a retry (hitCount > 1)
+    if self.configuration.enableExponentialBackoff && self.hitCount > 1 {
+      let delay = calculateExponentialBackoffDelay()
+      DispatchQueue.global(qos: .userInitiated).asyncAfter(deadline: .now() + delay) { [weak self] in
+        guard let self = self else { return }
+        chain.proceedAsync(
+          request: request,
+          response: response,
+          interceptor: self,
+          completion: completion
+        )
+      }
+    } else {
+      chain.proceedAsync(
+        request: request,
+        response: response,
+        interceptor: self,
+        completion: completion
+      )
+    }
+  }
+  
+  /// Calculates the exponential backoff delay based on current retry attempt.
+  ///
+  /// - Returns: The calculated delay in seconds, including jitter if enabled.
+  private func calculateExponentialBackoffDelay() -> TimeInterval {
+    // Calculate exponential delay: baseDelay * multiplier^(hitCount - 1)
+    // We use (hitCount - 1) because hitCount includes the initial attempt
+    let retryAttempt = hitCount - 1
+    let exponentialDelay = configuration.baseDelay * pow(configuration.multiplier, Double(retryAttempt))
+    
+    // Apply maximum delay cap
+    let cappedDelay = min(exponentialDelay, configuration.maxDelay)
+    
+    // Apply jitter if enabled to prevent thundering herd problems
+    if configuration.enableJitter {
+      // Equal jitter: random value between 50% and 100% of calculated delay
+      let minDelay = cappedDelay / 2
+      return TimeInterval.random(in: minDelay...cappedDelay)
+    } else {
+      return cappedDelay
+    }
   }
 }