chore: use virtual context when wrapInChildContext is false

Author: hsilan

sdk/src/main/java/software/amazon/lambda/durable/DurableContext.java

@@ -740,9 +740,10 @@ <T> DurableFuture<T> waitForConditionAsync(
      * <p>Every side-effect in the loop is a durable operation, so the loop is replay-safe by construction. On replay,
      * completed operations return cached results instantly and the loop fast-forwards to the current attempt.
      *
-     * <p>By default, the retry loop runs directly on the caller's context. If
-     * {@link WithRetryConfig#wrapInChildContext()} is enabled, the loop is wrapped in a child context so all attempts
-     * are grouped under a single named operation in execution history.
+     * <p>The retry loop always runs in a child context to provide an isolated operation ID namespace. If
+     * {@link WithRetryConfig#wrapInChildContext()} is enabled, the child context is checkpointed (persisted) so all
+     * attempts are grouped under a single named operation in execution history. Otherwise, a virtual child context is
+     * used — no checkpointing overhead, but the child re-executes on replay.
      *
      * @param <T> the result type
      * @param name operation name (used for backoff wait names, and as the child context name when wrapping)
@@ -755,9 +756,10 @@ <T> DurableFuture<T> waitForConditionAsync(
     /**
      * Replay-safe retry loop for any durable operation (anonymous form, sync).
      *
-     * <p>By default, the retry loop runs directly on the caller's context. If
-     * {@link WithRetryConfig#wrapInChildContext()} is enabled, the loop is wrapped in a child context with a default
-     * name so all attempts are grouped under a single operation in execution history.
+     * <p>The retry loop always runs in a child context to provide an isolated operation ID namespace. If
+     * {@link WithRetryConfig#wrapInChildContext()} is enabled, the child context is checkpointed (persisted) so all
+     * attempts are grouped under a single named operation in execution history. Otherwise, a virtual child context is
+     * used — no checkpointing overhead, but the child re-executes on replay.
      *
      * @param <T> the result type
      * @param operation the retryable operation — receives the context and 1-based attempt number
@@ -769,8 +771,10 @@ <T> DurableFuture<T> waitForConditionAsync(
     /**
      * Replay-safe retry loop for any durable operation (named form, async).
      *
-     * <p>Wraps the retry loop in {@code runInChildContextAsync} so all attempts are grouped under a single named
-     * operation in execution history, and returns a {@link DurableFuture} that can be composed or blocked on.
+     * <p>The retry loop always runs in a child context to provide an isolated operation ID namespace. If
+     * {@link WithRetryConfig#wrapInChildContext()} is enabled, the child context is checkpointed (persisted) so all
+     * attempts are grouped under a single named operation in execution history. Otherwise, a virtual child context is
+     * used — no checkpointing overhead, but the child re-executes on replay.
      *
      * @param <T> the result type
      * @param name operation name (used for child context and backoff wait names)
@@ -783,8 +787,10 @@ <T> DurableFuture<T> waitForConditionAsync(
     /**
      * Replay-safe retry loop for any durable operation (anonymous form, async).
      *
-     * <p>Wraps the retry loop in {@code runInChildContextAsync} with a default name so all attempts are grouped under a
-     * single operation in execution history, and returns a {@link DurableFuture} that can be composed or blocked on.
+     * <p>The retry loop always runs in a child context to provide an isolated operation ID namespace. If
+     * {@link WithRetryConfig#wrapInChildContext()} is enabled, the child context is checkpointed (persisted) so all
+     * attempts are grouped under a single named operation in execution history. Otherwise, a virtual child context is
+     * used — no checkpointing overhead, but the child re-executes on replay.
      *
      * @param <T> the result type
      * @param operation the retryable operation — receives the context and 1-based attempt number

sdk/src/main/java/software/amazon/lambda/durable/config/RetryOperationConfig.java

@@ -238,6 +238,25 @@ private <T> DurableFuture<T> runInChildContextAsync(
             Function<DurableContext, T> func,
             RunInChildContextConfig config,
             OperationSubType subType) {
+        return runInChildContextAsync(name, resultType, func, config, subType, false);
+    }
+
+    private <T> DurableFuture<T> runInVirtualChildContextAsync(
+            String name,
+            TypeToken<T> resultType,
+            Function<DurableContext, T> func,
+            RunInChildContextConfig config,
+            OperationSubType subType) {
+        return runInChildContextAsync(name, resultType, func, config, subType, true);
+    }
+
+    private <T> DurableFuture<T> runInChildContextAsync(
+            String name,
+            TypeToken<T> resultType,
+            Function<DurableContext, T> func,
+            RunInChildContextConfig config,
+            OperationSubType subType,
+            boolean isVirtual) {
         Objects.requireNonNull(resultType, "resultType cannot be null");
         Objects.requireNonNull(config, "RunInChildContextConfig cannot be null");
         ParameterValidator.validateOperationName(name);
@@ -253,7 +272,9 @@ private <T> DurableFuture<T> runInChildContextAsync(
                 func,
                 resultType,
                 config,
-                this);
+                this,
+                isVirtual,
+                null);
 
         operation.execute();
         return operation;
@@ -386,10 +407,21 @@ public <T> T withRetry(String name, WithRetry<T> operation, WithRetryConfig conf
         Objects.requireNonNull(config, "config cannot be null");
 
         if (config.wrapInChildContext()) {
-            return (T) runInChildContext(
-                    name, new TypeToken<Object>() {}, childCtx -> executeRetryLoop(childCtx, name, operation, config));
+            return (T) runInChildContextAsync(
+                            name,
+                            new TypeToken<Object>() {},
+                            childCtx -> executeRetryLoop(childCtx, name, operation, config),
+                            RunInChildContextConfig.builder().build(),
+                            OperationSubType.WITH_RETRY)
+                    .get();
         }
-        return executeRetryLoop(this, name, operation, config);
+        return (T) runInVirtualChildContextAsync(
+                        name,
+                        new TypeToken<Object>() {},
+                        childCtx -> executeRetryLoop(childCtx, name, operation, config),
+                        RunInChildContextConfig.builder().build(),
+                        OperationSubType.WITH_RETRY)
+                .get();
     }
 
     @Override
@@ -399,12 +431,21 @@ public <T> T withRetry(WithRetry<T> operation, WithRetryConfig config) {
         Objects.requireNonNull(config, "config cannot be null");
 
         if (config.wrapInChildContext()) {
-            return (T) runInChildContext(
-                    ANONYMOUS_CHILD_CONTEXT_NAME,
-                    new TypeToken<Object>() {},
-                    childCtx -> executeRetryLoop(childCtx, null, operation, config));
+            return (T) runInChildContextAsync(
+                            ANONYMOUS_CHILD_CONTEXT_NAME,
+                            new TypeToken<Object>() {},
+                            childCtx -> executeRetryLoop(childCtx, null, operation, config),
+                            RunInChildContextConfig.builder().build(),
+                            OperationSubType.WITH_RETRY)
+                    .get();
         }
-        return executeRetryLoop(this, null, operation, config);
+        return (T) runInVirtualChildContextAsync(
+                        ANONYMOUS_CHILD_CONTEXT_NAME,
+                        new TypeToken<Object>() {},
+                        childCtx -> executeRetryLoop(childCtx, null, operation, config),
+                        RunInChildContextConfig.builder().build(),
+                        OperationSubType.WITH_RETRY)
+                .get();
     }
 
     @Override
@@ -414,8 +455,20 @@ public <T> DurableFuture<T> withRetryAsync(String name, WithRetry<T> operation,
         Objects.requireNonNull(operation, "operation cannot be null");
         Objects.requireNonNull(config, "config cannot be null");
 
-        return (DurableFuture<T>) runInChildContextAsync(
-                name, new TypeToken<Object>() {}, childCtx -> executeRetryLoop(childCtx, name, operation, config));
+        if (config.wrapInChildContext()) {
+            return (DurableFuture<T>) runInChildContextAsync(
+                    name,
+                    new TypeToken<Object>() {},
+                    childCtx -> executeRetryLoop(childCtx, name, operation, config),
+                    RunInChildContextConfig.builder().build(),
+                    OperationSubType.WITH_RETRY);
+        }
+        return (DurableFuture<T>) runInVirtualChildContextAsync(
+                name,
+                new TypeToken<Object>() {},
+                childCtx -> executeRetryLoop(childCtx, name, operation, config),
+                RunInChildContextConfig.builder().build(),
+                OperationSubType.WITH_RETRY);
     }
 
     @Override
@@ -424,10 +477,20 @@ public <T> DurableFuture<T> withRetryAsync(WithRetry<T> operation, WithRetryConf
         Objects.requireNonNull(operation, "operation cannot be null");
         Objects.requireNonNull(config, "config cannot be null");
 
-        return (DurableFuture<T>) runInChildContextAsync(
+        if (config.wrapInChildContext()) {
+            return (DurableFuture<T>) runInChildContextAsync(
+                    ANONYMOUS_CHILD_CONTEXT_NAME,
+                    new TypeToken<Object>() {},
+                    childCtx -> executeRetryLoop(childCtx, null, operation, config),
+                    RunInChildContextConfig.builder().build(),
+                    OperationSubType.WITH_RETRY);
+        }
+        return (DurableFuture<T>) runInVirtualChildContextAsync(
                 ANONYMOUS_CHILD_CONTEXT_NAME,
                 new TypeToken<Object>() {},
-                childCtx -> executeRetryLoop(childCtx, null, operation, config));
+                childCtx -> executeRetryLoop(childCtx, null, operation, config),
+                RunInChildContextConfig.builder().build(),
+                OperationSubType.WITH_RETRY);
     }
 
     /**

sdk/src/main/java/software/amazon/lambda/durable/context/DurableContextImpl.java

@@ -15,7 +15,8 @@ public enum OperationSubType {
     PARALLEL("Parallel"),
     PARALLEL_BRANCH("ParallelBranch"),
     WAIT_FOR_CALLBACK("WaitForCallback"),
-    WAIT_FOR_CONDITION("WaitForCondition");
+    WAIT_FOR_CONDITION("WaitForCondition"),
+    WITH_RETRY("WithRetry");
 
     private final String value;
 

sdk/src/main/java/software/amazon/lambda/durable/model/OperationSubType.java

@@ -240,7 +240,7 @@ private Throwable translateException(Operation op, ErrorObject errorObject) {
             case WAIT_FOR_CALLBACK -> handleWaitForCallbackFailure();
             case MAP_ITERATION -> new MapIterationFailedException(op);
             case PARALLEL_BRANCH -> new ParallelBranchFailedException(op);
-            case RUN_IN_CHILD_CONTEXT -> new ChildContextFailedException(op);
+            case RUN_IN_CHILD_CONTEXT, WITH_RETRY -> new ChildContextFailedException(op);
 
             // the following subtypes should not be able to reach here
             case PARALLEL, MAP, WAIT_FOR_CONDITION -> new IllegalStateException("Unexpected sub-type: " + getSubType());