use 1-based attempt number (#272)

Author: zhongkechen

sdk-integration-tests/src/test/java/software/amazon/lambda/durable/WaitForConditionIntegrationTest.java

@@ -269,7 +269,7 @@ void propertyWaitStrategyReceivesCorrectStateAndAttempt() {
             // Check function returns state + 1, starting from 0
             // So after check i, state = i + 1, and strategy receives that value
             assertEquals(i + 1, observedStates.get(i), "State at strategy call " + (i + 1));
-            assertEquals(i, observedAttempts.get(i), "Attempt at strategy call " + (i + 1));
+            assertEquals(i + 1, observedAttempts.get(i), "Attempt at strategy call " + (i + 1));
         }
     }
 }

sdk-testing/src/main/java/software/amazon/lambda/durable/testing/TestOperation.java

@@ -126,6 +126,6 @@ public ErrorObject getError() {
     /** Returns the current retry attempt number (0-based), defaulting to 0 if not available. */
     public int getAttempt() {
         var details = operation.stepDetails();
-        return details != null && details.attempt() != null ? details.attempt() : 0;
+        return details != null && details.attempt() != null ? details.attempt() : 1;
     }
 }

sdk/src/main/java/software/amazon/lambda/durable/execution/CheckpointManager.java

@@ -30,6 +30,7 @@
 class CheckpointManager {
     private static final int MAX_BATCH_SIZE_BYTES = 750 * 1024; // 750KB
     private static final int MAX_ITEM_COUNT = 200; // max updates in one batch
+    private static final int FIRST_ATTEMPT = 1;
     private static final Logger logger = LoggerFactory.getLogger(CheckpointManager.class);
 
     private final Consumer<List<Operation>> callback;
@@ -96,7 +97,7 @@ CompletableFuture<Operation> pollForUpdate(String operationId, PollingStrategy p
                     .computeIfAbsent(operationId, k -> Collections.synchronizedList(new ArrayList<>()))
                     .add(future);
         }
-        pollForUpdateInternal(future, 0, Instant.now(), pollingStrategy);
+        pollForUpdateInternal(future, FIRST_ATTEMPT, Instant.now(), pollingStrategy);
         return future;
     }
 

sdk/src/main/java/software/amazon/lambda/durable/operation/StepOperation.java

@@ -33,7 +33,7 @@
  * @param <T> the result type of the step function
  */
 public class StepOperation<T> extends SerializableDurableOperation<T> {
-    private static final Integer FIRST_ATTEMPT = 0;
+    private static final Integer FIRST_ATTEMPT = 1;
 
     private final Function<StepContext, T> function;
     private final StepConfig config;
@@ -60,7 +60,7 @@ protected void start() {
     @Override
     protected void replay(Operation existing) {
         var attempt = existing.stepDetails() != null && existing.stepDetails().attempt() != null
-                ? existing.stepDetails().attempt()
+                ? existing.stepDetails().attempt() + 1
                 : FIRST_ATTEMPT;
         switch (existing.status()) {
             case SUCCEEDED, FAILED -> markAlreadyCompleted();

sdk/src/main/java/software/amazon/lambda/durable/operation/WaitForConditionOperation.java

@@ -36,6 +36,7 @@
  * @param <T> the type of state being polled
  */
 public class WaitForConditionOperation<T> extends SerializableDurableOperation<T> {
+    private static final Integer FIRST_ATTEMPT = 1;
 
     private final BiFunction<T, StepContext, WaitForConditionResult<T>> checkFunc;
     private final WaitForConditionConfig<T> config;
@@ -61,7 +62,7 @@ public WaitForConditionOperation(
 
     @Override
     protected void start() {
-        executeCheckLogic(config.initialState(), 0);
+        executeCheckLogic(config.initialState(), FIRST_ATTEMPT);
     }
 
     @Override
@@ -99,7 +100,8 @@ public T get() {
 
     private void resumeCheckLoop(Operation existing) {
         var stepDetails = existing.stepDetails();
-        int attempt = (stepDetails != null && stepDetails.attempt() != null) ? stepDetails.attempt() : 0;
+        int attempt =
+                (stepDetails != null && stepDetails.attempt() != null) ? stepDetails.attempt() + 1 : FIRST_ATTEMPT;
         var checkpointData = stepDetails != null ? stepDetails.result() : null;
         T currentState; // Get current state
         if (checkpointData != null) {

sdk/src/main/java/software/amazon/lambda/durable/retry/PollingStrategies.java

@@ -23,7 +23,7 @@ public static class Presets {
     /**
      * Creates an exponential backoff polling strategy.
      *
-     * <p>The delay calculation follows the formula: delay = jitter(baseInterval × backoffRate^attempt)
+     * <p>The delay calculation follows the formula: delay = jitter(baseInterval × backoffRate^(attempt-1))
      *
      * @param baseInterval Base delay before first poll
      * @param backoffRate Multiplier for exponential backoff (must be positive)
@@ -49,7 +49,8 @@ public static PollingStrategy exponentialBackoff(
         }
 
         return (attempt) -> {
-            double delayMs = baseInterval.toMillis() * Math.pow(backoffRate, attempt);
+            // attempt is 1-based
+            double delayMs = baseInterval.toMillis() * Math.pow(backoffRate, attempt - 1);
             delayMs = Math.min(jitter.apply(delayMs), maxInterval.toMillis());
             return Duration.ofMillis(Math.round(delayMs));
         };

sdk/src/main/java/software/amazon/lambda/durable/retry/PollingStrategy.java

@@ -11,7 +11,7 @@ public interface PollingStrategy {
     /**
      * Computes the delay before the next polling attempt.
      *
-     * @param attempt The current attempt number (0-based)
+     * @param attempt The current attempt number (1-based)
      * @return Duration to wait before the next poll
      */
     Duration computeDelay(int attempt);

sdk/src/main/java/software/amazon/lambda/durable/retry/RetryStrategies.java

@@ -29,13 +29,13 @@ public static class Presets {
                 );
 
         /** No retry strategy - fails immediately on first error. Use this for operations that should not be retried. */
-        public static final RetryStrategy NO_RETRY = (error, attemptNumber) -> RetryDecision.fail();
+        public static final RetryStrategy NO_RETRY = (error, attempt) -> RetryDecision.fail();
     }
 
     /**
      * Creates an exponential backoff retry strategy.
      *
-     * <p>The delay calculation follows the formula: baseDelay = min(initialDelay × backoffRate^attemptNumber, maxDelay)
+     * <p>The delay calculation follows the formula: baseDelay = min(initialDelay × backoffRate^(attempt-1), maxDelay)
      *
      * @param maxAttempts Maximum number of attempts (including initial attempt)
      * @param initialDelay Initial delay before first retry
@@ -56,17 +56,17 @@ public static RetryStrategy exponentialBackoff(
             throw new IllegalArgumentException("backoffRate must be positive");
         }
 
-        return (error, attemptNumber) -> {
-            // Check if we've exceeded max attempts (attemptNumber is 0-based)
-            if (attemptNumber + 1 >= maxAttempts) {
+        return (error, attempt) -> {
+            // Check if we've exceeded max attempts (attemptNumber is 1-based)
+            if (attempt >= maxAttempts) {
                 return RetryDecision.fail();
             }
 
             // Calculate delay with exponential backoff
             double initialDelaySeconds = initialDelay.toSeconds();
             double maxDelaySeconds = maxDelay.toSeconds();
 
-            double baseDelay = Math.min(initialDelaySeconds * Math.pow(backoffRate, attemptNumber), maxDelaySeconds);
+            double baseDelay = Math.min(initialDelaySeconds * Math.pow(backoffRate, attempt - 1), maxDelaySeconds);
 
             // Apply jitter
             double delayWithJitter = jitter.apply(baseDelay);
@@ -92,8 +92,8 @@ public static RetryStrategy fixedDelay(int maxAttempts, Duration fixedDelay) {
         }
         ParameterValidator.validateDuration(fixedDelay, "fixedDelay");
 
-        return (error, attemptNumber) -> {
-            if (attemptNumber + 1 >= maxAttempts) {
+        return (error, attempt) -> {
+            if (attempt >= maxAttempts) {
                 return RetryDecision.fail();
             }
             return RetryDecision.retry(fixedDelay);

sdk/src/main/java/software/amazon/lambda/durable/retry/RetryStrategy.java

@@ -15,8 +15,8 @@ public interface RetryStrategy {
      * Determines whether to retry a failed operation and calculates the retry delay.
      *
      * @param error The error that occurred during the operation
-     * @param attemptNumber The current attempt number (0-based, so first attempt is 0)
+     * @param attempt The current attempt number (1-based, so first attempt is 1)
      * @return RetryDecision indicating whether to retry and the delay before next attempt
      */
-    RetryDecision makeRetryDecision(Throwable error, int attemptNumber);
+    RetryDecision makeRetryDecision(Throwable error, int attempt);
 }

sdk/src/main/java/software/amazon/lambda/durable/retry/WaitForConditionWaitStrategy.java

@@ -23,7 +23,7 @@ public interface WaitForConditionWaitStrategy<T> {
      * Computes the delay before the next polling attempt based on the current state and attempt number.
      *
      * @param state the current state returned by the check function
-     * @param attempt the attempt number
+     * @param attempt the attempt number (1-based)
      * @return a {@link Duration} representing the delay before the next polling attempt
      * @throws WaitForConditionFailedException if the maximum number of attempts has been exceeded
      */