From 520263cf1cbb5a2fb4183c7da684c03042fb6374 Mon Sep 17 00:00:00 2001 From: Alex Castillo Date: Wed, 18 Nov 2026 22:50:29 -0400 Subject: [PATCH] fix: leave replay mode once an operation completed during suspension is consumed DurableLogger suppresses logs while the context is replaying, but the context only left replay mode when starting an operation with no checkpoint. If the last checkpointed operation (wait/callback) completed while suspended, the context stayed in replay and dropped the handler's new logs after it. Fixes #859 Co-Authored-By: Claude Sonnet 5.5 --- .../ReplayModeAfterSuspensionTest.java | 69 +++++++++++++++++++ .../operation/BaseDurableOperation.java | 8 +++ 2 files changed, 77 insertions(+) create mode 100644 sdk-integration-tests/src/test/java/software/amazon/lambda/durable/ReplayModeAfterSuspensionTest.java diff --git a/sdk-integration-tests/src/test/java/software/amazon/lambda/durable/ReplayModeAfterSuspensionTest.java b/sdk-integration-tests/src/test/java/software/amazon/lambda/durable/ReplayModeAfterSuspensionTest.java new file mode 100644 index 000000000..2e9ec942b --- /dev/null +++ b/sdk-integration-tests/src/test/java/software/amazon/lambda/durable/ReplayModeAfterSuspensionTest.java @@ -0,0 +1,69 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 +package software.amazon.lambda.durable; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.time.Duration; +import java.util.ArrayList; +import java.util.List; +import org.junit.jupiter.api.Test; +import software.amazon.lambda.durable.model.ExecutionStatus; +import software.amazon.lambda.durable.testing.LocalDurableTestRunner; + +/** The context must leave replay mode once the first operation that completed during suspension is consumed. */ +class ReplayModeAfterSuspensionTest { + + @Test + void waitCompletedDuringSuspension_codeAfterWaitIsNotReplay() { + var replayStates = new ArrayList(); + var runner = LocalDurableTestRunner.create(String.class, (input, ctx) -> { + ctx.step("before", String.class, s -> "a"); + ctx.wait("pause", Duration.ofSeconds(1)); + replayStates.add(ctx.isReplaying()); + return "done"; + }); + + assertEquals(ExecutionStatus.PENDING, runner.run("x").getStatus()); + replayStates.clear(); + runner.advanceTime(); + assertEquals(ExecutionStatus.SUCCEEDED, runner.run("x").getStatus()); + assertEquals(List.of(false), replayStates); + } + + @Test + void callbackCompletedDuringSuspension_codeAfterGetIsNotReplay() { + var replayStates = new ArrayList(); + var runner = LocalDurableTestRunner.create(String.class, (input, ctx) -> { + var cb = ctx.createCallback("approval", String.class); + var value = cb.get(); + replayStates.add(ctx.isReplaying()); + return value; + }); + + assertEquals(ExecutionStatus.PENDING, runner.run("x").getStatus()); + replayStates.clear(); + runner.completeCallback(runner.getCallbackId("approval"), "\"ok\""); + assertEquals(ExecutionStatus.SUCCEEDED, runner.run("x").getStatus()); + assertEquals(List.of(false), replayStates); + } + + @Test + void waitAsyncThenStep_intermediateStepStaysReplay() { + var states = new ArrayList(); + var runner = LocalDurableTestRunner.create(String.class, (input, ctx) -> { + var w = ctx.waitAsync("pause", Duration.ofSeconds(1)); + ctx.step("middle", String.class, s -> "m"); + states.add("middle=" + ctx.isReplaying()); + w.get(); + states.add("after=" + ctx.isReplaying()); + return "done"; + }); + + assertEquals(ExecutionStatus.PENDING, runner.run("x").getStatus()); + states.clear(); + runner.advanceTime(); + assertEquals(ExecutionStatus.SUCCEEDED, runner.run("x").getStatus()); + assertEquals(List.of("middle=true", "after=false"), states); + } +} diff --git a/sdk/src/main/java/software/amazon/lambda/durable/operation/BaseDurableOperation.java b/sdk/src/main/java/software/amazon/lambda/durable/operation/BaseDurableOperation.java index cd884796e..3b3ace42c 100644 --- a/sdk/src/main/java/software/amazon/lambda/durable/operation/BaseDurableOperation.java +++ b/sdk/src/main/java/software/amazon/lambda/durable/operation/BaseDurableOperation.java @@ -261,6 +261,14 @@ protected Operation waitForOperationCompletion() { throw terminateExecutionWithIllegalDurableOperationException( String.format("%s operation not found: %s", getType(), getOperationId())); } + // An operation that completed while the execution was suspended is the first new event of this + // invocation. Once its result is consumed, the code that follows is no longer a replay, so leave + // replay mode and stop suppressing the handler's logs. + if (replayCompletedOperation.get() + && durableContext.isReplaying() + && executionManager.isOperationUpdatedSinceLastInvocation(getOperationId())) { + durableContext.setExecutionMode(); + } return op; } }