minimum retry delay config should be used as the base delay

Author: jimmyjames

src/main/java/dev/openfga/sdk/api/configuration/Configuration.java

@@ -37,9 +37,14 @@ public class Configuration implements BaseConfiguration {
     private static final Duration DEFAULT_READ_TIMEOUT = Duration.ofSeconds(10);
     private static final Duration DEFAULT_CONNECT_TIMEOUT = Duration.ofSeconds(10);
     private static final int DEFAULT_MAX_RETRIES = 3;
-    private static final Duration DEFAULT_MINIMUM_RETRY_DELAY = Duration.ofMillis(100);
     private static final int MAX_ALLOWABLE_RETRIES = 15;
 
+    /**
+     * Default minimum retry delay of 100ms.
+     * This value is also used as the default base delay for exponential backoff calculations.
+     */
+    public static final Duration DEFAULT_MINIMUM_RETRY_DELAY = Duration.ofMillis(100);
+
     private String apiUrl;
     private Credentials credentials;
     private String userAgent;

src/main/java/dev/openfga/sdk/util/ExponentialBackoff.java

@@ -19,13 +19,12 @@
  * Utility class for calculating exponential backoff delays with jitter.
  *
  * Implements the retry strategy specified in GitHub issue #155:
- * - Base delay: 2^retryCount * 100ms
+ * - Base delay: 2^retryCount * baseDelay (configurable)
  * - Jitter: Random value between base and 2 * base
  * - Maximum delay: 120 seconds (capped after 10th retry)
  */
 public class ExponentialBackoff {
 
-    private static final int BASE_DELAY_MS = 100;
     private static final int MAX_DELAY_SECONDS = 120;
     private static final Random RANDOM = new Random();
 
@@ -37,37 +36,45 @@ private ExponentialBackoff() {
      * Calculates the exponential backoff delay with jitter for a given retry attempt.
      *
      * @param retryCount The current retry attempt (0-based, so first retry is 0)
+     * @param baseDelay The base delay to use for exponential calculation
      * @return Duration representing the delay before the next retry
      */
-    public static Duration calculateDelay(int retryCount) {
-        return calculateDelay(retryCount, RANDOM);
+    public static Duration calculateDelay(int retryCount, Duration baseDelay) {
+        return calculateDelay(retryCount, baseDelay, RANDOM);
     }
 
     /**
      * Calculates the exponential backoff delay with jitter using a provided Random instance.
      * This method is primarily for testing purposes to ensure deterministic behavior.
      *
      * @param retryCount The current retry attempt (0-based, so first retry is 0)
+     * @param baseDelay The base delay to use for exponential calculation
      * @param random Random instance to use for jitter calculation
      * @return Duration representing the delay before the next retry
      */
-    static Duration calculateDelay(int retryCount, Random random) {
+    static Duration calculateDelay(int retryCount, Duration baseDelay, Random random) {
         if (retryCount < 0) {
             return Duration.ZERO;
         }
 
-        // Calculate base delay: 2^retryCount * 100ms
-        long baseDelayMs = (long) Math.pow(2, retryCount) * BASE_DELAY_MS;
+        // Use provided base delay (caller must provide a valid value)
+        if (baseDelay == null) {
+            throw new IllegalArgumentException("baseDelay cannot be null");
+        }
+        long baseDelayMs = baseDelay.toMillis();
+
+        // Calculate exponential delay: 2^retryCount * baseDelay
+        long exponentialDelayMs = (long) Math.pow(2, retryCount) * baseDelayMs;
 
         // Cap at maximum delay
         long maxDelayMs = MAX_DELAY_SECONDS * 1000L;
-        if (baseDelayMs > maxDelayMs) {
-            baseDelayMs = maxDelayMs;
+        if (exponentialDelayMs > maxDelayMs) {
+            exponentialDelayMs = maxDelayMs;
         }
 
-        // Add jitter: random value between baseDelay and 2 * baseDelay
-        long minDelayMs = baseDelayMs;
-        long maxDelayMsWithJitter = Math.min(baseDelayMs * 2, maxDelayMs);
+        // Add jitter: random value between exponentialDelay and 2 * exponentialDelay
+        long minDelayMs = exponentialDelayMs;
+        long maxDelayMsWithJitter = Math.min(exponentialDelayMs * 2, maxDelayMs);
 
         // Generate random delay within the jitter range
         long jitterRange = maxDelayMsWithJitter - minDelayMs;

src/main/java/dev/openfga/sdk/util/RetryStrategy.java

@@ -12,6 +12,7 @@
 
 package dev.openfga.sdk.util;
 
+import dev.openfga.sdk.api.configuration.Configuration;
 import dev.openfga.sdk.errors.HttpStatusCode;
 import java.time.Duration;
 import java.util.Optional;
@@ -60,7 +61,7 @@ public static boolean shouldRetry(int statusCode) {
      *
      * @param retryAfterDelay Optional delay from Retry-After header
      * @param retryCount Current retry attempt (0-based)
-     * @param minimumRetryDelay Minimum delay to enforce (can be null)
+     * @param minimumRetryDelay Minimum delay to enforce (also used as base delay for exponential backoff)
      * @return Duration representing the delay before the next retry
      */
     public static Duration calculateRetryDelay(
@@ -75,11 +76,8 @@ public static Duration calculateRetryDelay(
             return retryAfterValue;
         }
 
-        // Otherwise, use exponential backoff with jitter, respecting minimum retry delay
-        Duration exponentialDelay = ExponentialBackoff.calculateDelay(retryCount);
-        if (minimumRetryDelay != null && minimumRetryDelay.compareTo(exponentialDelay) > 0) {
-            return minimumRetryDelay;
-        }
-        return exponentialDelay;
+    // Otherwise, use exponential backoff with jitter, respecting minimum retry delay
+        Duration baseDelay = minimumRetryDelay != null ? minimumRetryDelay : Configuration.DEFAULT_MINIMUM_RETRY_DELAY;
+        return ExponentialBackoff.calculateDelay(retryCount, baseDelay);
     }
 }

src/test/java/dev/openfga/sdk/api/client/HttpRequestAttemptRetryTest.java

@@ -283,9 +283,10 @@ void shouldUseExponentialBackoffWhenNoRetryAfterHeader() throws Exception {
         // Verify both requests were made
         wireMockServer.verify(2, getRequestedFor(urlEqualTo("/test")));
 
-        // Verify some delay occurred (exponential backoff should add at least 100ms for first retry)
+        // Verify some delay occurred (exponential backoff with 10ms minimum delay)
         // Note: Using a generous range due to test timing variability
-        assertThat(endTime - startTime).isGreaterThan(400L);
+        // With minimumRetryDelay=10ms, first retry should be at least 10ms
+        assertThat(endTime - startTime).isGreaterThan(8L);
     }
 
     @Test

src/test/java/dev/openfga/sdk/util/ExponentialBackoffTest.java

@@ -13,6 +13,7 @@
 package dev.openfga.sdk.util;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import java.time.Duration;
 import java.util.Random;
@@ -24,10 +25,11 @@ class ExponentialBackoffTest {
     void calculateDelay_withRetryCountZero_shouldReturnBaseDelay() {
         // Given
         int retryCount = 0;
+        Duration baseDelay = Duration.ofMillis(100);
         Random fixedRandom = new Random(42); // Fixed seed for deterministic testing
 
         // When
-        Duration result = ExponentialBackoff.calculateDelay(retryCount, fixedRandom);
+        Duration result = ExponentialBackoff.calculateDelay(retryCount, baseDelay, fixedRandom);
 
         // Then
         // For retry count 0: 2^0 * 100ms = 100ms base
@@ -39,10 +41,11 @@ void calculateDelay_withRetryCountZero_shouldReturnBaseDelay() {
     void calculateDelay_withRetryCountOne_shouldReturnDoubledDelay() {
         // Given
         int retryCount = 1;
+        Duration baseDelay = Duration.ofMillis(100);
         Random fixedRandom = new Random(42); // Fixed seed for deterministic testing
 
         // When
-        Duration result = ExponentialBackoff.calculateDelay(retryCount, fixedRandom);
+        Duration result = ExponentialBackoff.calculateDelay(retryCount, baseDelay, fixedRandom);
 
         // Then
         // For retry count 1: 2^1 * 100ms = 200ms base
@@ -54,10 +57,11 @@ void calculateDelay_withRetryCountOne_shouldReturnDoubledDelay() {
     void calculateDelay_withRetryCountTwo_shouldReturnQuadrupledDelay() {
         // Given
         int retryCount = 2;
+        Duration baseDelay = Duration.ofMillis(100);
         Random fixedRandom = new Random(42); // Fixed seed for deterministic testing
 
         // When
-        Duration result = ExponentialBackoff.calculateDelay(retryCount, fixedRandom);
+        Duration result = ExponentialBackoff.calculateDelay(retryCount, baseDelay, fixedRandom);
 
         // Then
         // For retry count 2: 2^2 * 100ms = 400ms base
@@ -69,10 +73,11 @@ void calculateDelay_withRetryCountTwo_shouldReturnQuadrupledDelay() {
     void calculateDelay_withHighRetryCount_shouldCapAtMaximum() {
         // Given
         int retryCount = 10; // This would normally result in 2^10 * 100ms = 102400ms
+        Duration baseDelay = Duration.ofMillis(100);
         Random fixedRandom = new Random(42); // Fixed seed for deterministic testing
 
         // When
-        Duration result = ExponentialBackoff.calculateDelay(retryCount, fixedRandom);
+        Duration result = ExponentialBackoff.calculateDelay(retryCount, baseDelay, fixedRandom);
 
         // Then
         // Should be capped at 120 seconds (120000ms)
@@ -85,7 +90,7 @@ void calculateDelay_withNegativeRetryCount_shouldReturnZero() {
         int retryCount = -1;
 
         // When
-        Duration result = ExponentialBackoff.calculateDelay(retryCount);
+        Duration result = ExponentialBackoff.calculateDelay(retryCount, Duration.ofMillis(100));
 
         // Then
         assertThat(result).isEqualTo(Duration.ZERO);
@@ -97,7 +102,7 @@ void calculateDelay_withoutRandomParameter_shouldReturnValidRange() {
         int retryCount = 1;
 
         // When
-        Duration result = ExponentialBackoff.calculateDelay(retryCount);
+        Duration result = ExponentialBackoff.calculateDelay(retryCount, Duration.ofMillis(100));
 
         // Then
         // For retry count 1: 2^1 * 100ms = 200ms base
@@ -111,9 +116,9 @@ void calculateDelay_shouldProduceVariousResults() {
         int retryCount = 1;
 
         // When - call multiple times to ensure randomness
-        Duration result1 = ExponentialBackoff.calculateDelay(retryCount);
-        Duration result2 = ExponentialBackoff.calculateDelay(retryCount);
-        Duration result3 = ExponentialBackoff.calculateDelay(retryCount);
+        Duration result1 = ExponentialBackoff.calculateDelay(retryCount, Duration.ofMillis(100));
+        Duration result2 = ExponentialBackoff.calculateDelay(retryCount, Duration.ofMillis(100));
+        Duration result3 = ExponentialBackoff.calculateDelay(retryCount, Duration.ofMillis(100));
 
         // Then - all should be in valid range but likely different
         assertThat(result1.toMillis()).isBetween(200L, 400L);
@@ -125,12 +130,13 @@ void calculateDelay_shouldProduceVariousResults() {
     void calculateDelay_withFixedRandom_shouldBeDeterministic() {
         // Given
         int retryCount = 1;
+        Duration baseDelay = Duration.ofMillis(100);
         Random fixedRandom1 = new Random(123);
         Random fixedRandom2 = new Random(123); // Same seed
 
         // When
-        Duration result1 = ExponentialBackoff.calculateDelay(retryCount, fixedRandom1);
-        Duration result2 = ExponentialBackoff.calculateDelay(retryCount, fixedRandom2);
+        Duration result1 = ExponentialBackoff.calculateDelay(retryCount, baseDelay, fixedRandom1);
+        Duration result2 = ExponentialBackoff.calculateDelay(retryCount, baseDelay, fixedRandom2);
 
         // Then
         assertThat(result1).isEqualTo(result2);
@@ -139,13 +145,14 @@ void calculateDelay_withFixedRandom_shouldBeDeterministic() {
     @Test
     void calculateDelay_progressionTest_shouldFollowExponentialPattern() {
         // Given
+        Duration baseDelay = Duration.ofMillis(100);
         Random fixedRandom = new Random(42);
 
         // When & Then - test the progression follows expected pattern
         for (int i = 0; i < 8; i++) {
             // Reset the random seed for consistent results across iterations
             fixedRandom.setSeed(42);
-            Duration delay = ExponentialBackoff.calculateDelay(i, fixedRandom);
+            Duration delay = ExponentialBackoff.calculateDelay(i, baseDelay, fixedRandom);
             long expectedBaseMs = (long) Math.pow(2, i) * 100;
             long expectedMaxMs = Math.min(expectedBaseMs * 2, 120000);
 
@@ -160,13 +167,43 @@ void calculateDelay_progressionTest_shouldFollowExponentialPattern() {
     void calculateDelay_atCapThreshold_shouldCapCorrectly() {
         // Given - retry count that would exceed 120s base delay
         int retryCount = 11; // 2^11 * 100ms = 204800ms > 120000ms
+        Duration baseDelay = Duration.ofMillis(100);
         Random fixedRandom = new Random(42);
 
         // When
-        Duration result = ExponentialBackoff.calculateDelay(retryCount, fixedRandom);
+        Duration result = ExponentialBackoff.calculateDelay(retryCount, baseDelay, fixedRandom);
 
         // Then - should be capped at 120s maximum
         assertThat(result.toMillis()).isLessThanOrEqualTo(120000L);
         assertThat(result.toMillis()).isGreaterThanOrEqualTo(120000L); // Should be exactly at cap for base delay
     }
+
+    @Test
+    void calculateDelay_withCustomBaseDelay_shouldUseConfigurableBase() {
+        // Given - custom base delay of 500ms
+        int retryCount = 1;
+        Duration baseDelay = Duration.ofMillis(500);
+        Random fixedRandom = new Random(42);
+
+        // When
+        Duration result = ExponentialBackoff.calculateDelay(retryCount, baseDelay, fixedRandom);
+
+        // Then
+        // For retry count 1 with 500ms base: 2^1 * 500ms = 1000ms base
+        // With jitter: between 1000ms and 2000ms
+        assertThat(result.toMillis()).isBetween(1000L, 2000L);
+    }
+
+    @Test
+    void calculateDelay_withNullBaseDelay_shouldThrowException() {
+        // Given
+        int retryCount = 0;
+        Duration baseDelay = null;
+        Random fixedRandom = new Random(42);
+
+        // When & Then
+        assertThatThrownBy(() -> ExponentialBackoff.calculateDelay(retryCount, baseDelay, fixedRandom))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("baseDelay cannot be null");
+    }
 }