feat(logging): Use per-context replay status for log suppression

Author: ayushiahjolia

sdk/src/main/java/software/amazon/lambda/durable/logging/DurableLogger.java

@@ -93,8 +93,7 @@ public void error(String message, Throwable t) {
     }
 
     private boolean shouldSuppress() {
-        return context.getDurableConfig().getLoggerConfig().suppressReplayLogs()
-                && context.getExecutionManager().isReplaying();
+        return context.getDurableConfig().getLoggerConfig().suppressReplayLogs() && context.isReplaying();
     }
 
     private void log(Runnable logAction) {

sdk/src/test/java/software/amazon/lambda/durable/logging/DurableLoggerTest.java

@@ -42,7 +42,7 @@ void setUp() {
     }
 
     private DurableLogger createLogger(Mode mode, Suppression suppression) {
-        when(mockExecutionManager.isReplaying()).thenReturn(mode == Mode.REPLAYING);
+        when(mockExecutionManager.hasOperationsForContext(null)).thenReturn(mode == Mode.REPLAYING);
         return new DurableLogger(mockLogger, createDurableContext(REQUEST_ID, suppression));
     }
 
@@ -104,7 +104,7 @@ void setsExecutionMdcInConstructor() {
     void setStepThreadPropertiesSetsMdc() {
         try (MockedStatic<MDC> mdcMock = mockStatic(MDC.class)) {
             mdcMock.clearInvocations();
-            when(mockExecutionManager.isReplaying()).thenReturn(false);
+            when(mockExecutionManager.hasOperationsForContext(null)).thenReturn(false);
             var logger = new DurableLogger(
                     mockLogger,
                     createDurableContext(REQUEST_ID, Suppression.ENABLED)
@@ -130,13 +130,17 @@ void clearThreadPropertiesRemovesMdc() {
 
     @Test
     void replayModeTransitionAllowsSubsequentLogs() {
-        when(mockExecutionManager.isReplaying()).thenReturn(true, false);
-        var logger = new DurableLogger(mockLogger, createDurableContext(REQUEST_ID, Suppression.ENABLED));
+        when(mockExecutionManager.hasOperationsForContext(null)).thenReturn(true);
+        var durableContext = createDurableContext(REQUEST_ID, Suppression.ENABLED);
+        var logger = new DurableLogger(mockLogger, durableContext);
 
         // During replay - suppressed
         logger.info("suppressed");
         verify(mockLogger, never()).info(anyString(), any(Object[].class));
 
+        // Transition to execution mode at per-context level
+        durableContext.setExecutionMode();
+
         // After transition to execution mode - logged
         logger.info("logged after transition");
         verify(mockLogger).info(eq("logged after transition"), any(Object[].class));
@@ -163,10 +167,40 @@ void allLogLevelsDelegateCorrectly() {
         verify(mockLogger).error("error with exception", exception);
     }
 
+    @Test
+    void concurrentContextsHaveIndependentReplayState() {
+        // Simulate two child contexts: one still replaying, one already executing
+        when(mockExecutionManager.hasOperationsForContext(null)).thenReturn(true);
+        when(mockExecutionManager.hasOperationsForContext("child-a")).thenReturn(false);
+        when(mockExecutionManager.hasOperationsForContext("child-b")).thenReturn(true);
+
+        var rootContext = createDurableContext(REQUEST_ID, Suppression.ENABLED);
+        var childA = rootContext.createChildContext("child-a", "branch-a", false);
+        var childB = rootContext.createChildContext("child-b", "branch-b", false);
+
+        var loggerForA = mock(Logger.class);
+        var loggerForB = mock(Logger.class);
+        var durableLoggerA = new DurableLogger(loggerForA, childA);
+        var durableLoggerB = new DurableLogger(loggerForB, childB);
+
+        // Child A is in execution mode — logs should pass through
+        durableLoggerA.info("from branch A");
+        verify(loggerForA).info(eq("from branch A"), any(Object[].class));
+
+        // Child B is still replaying — logs should be suppressed
+        durableLoggerB.info("from branch B");
+        verify(loggerForB, never()).info(anyString(), any(Object[].class));
+
+        // After child B transitions, its logs should pass through
+        childB.setExecutionMode();
+        durableLoggerB.info("branch B after transition");
+        verify(loggerForB).info(eq("branch B after transition"), any(Object[].class));
+    }
+
     @Test
     void handlesNullRequestId() {
         try (MockedStatic<MDC> mdcMock = mockStatic(MDC.class)) {
-            when(mockExecutionManager.isReplaying()).thenReturn(false);
+            when(mockExecutionManager.hasOperationsForContext(null)).thenReturn(false);
             new DurableLogger(mockLogger, createDurableContext(null, Suppression.DISABLED));
 
             mdcMock.verify(() -> MDC.put(DurableLogger.MDC_EXECUTION_ARN, EXECUTION_ARN));