diff --git a/CHANGELOG.md b/CHANGELOG.md
index 160e790f..da1ef398 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,6 @@
## Unreleased
+* Add replay-safe logging on `TaskOrchestrationContext`: `createReplaySafeLogger(String)`, `createReplaySafeLogger(Class)`, `getReplaySafeLoggerFactory()`, and `getLoggerFactory()`. Wraps SLF4J loggers so both the classic API (`info`, `debug`, ...) and the SLF4J 2.x fluent API (`atInfo()`, `atDebug()`, ...) are no-ops during orchestration replay. Mirrors the .NET `ReplaySafeLogger` / `ReplaySafeLoggerFactory` surface.
+* **Compatibility note:** `slf4j-api` is now an `api`-scoped dependency (floor `2.0.0`). Downstream consumers still on `slf4j-api 1.7.x` via other transitive paths will be upgraded to `2.0.x` via Gradle/Maven version conflict resolution. SLF4J 2.x is backward-compatible at the API level for log call sites; SLF4J 1.x bindings (e.g. `slf4j-log4j12`, `logback-classic` <1.3) must be replaced with their 2.x equivalents.
## v1.9.0
* Fix entity locking deserialization and add Jackson support for EntityInstanceId/EntityMetadata ([#281](https://github.com/microsoft/durabletask-java/pull/281))
diff --git a/client/build.gradle b/client/build.gradle
index b7839ea3..e0bbd87a 100644
--- a/client/build.gradle
+++ b/client/build.gradle
@@ -52,6 +52,11 @@ dependencies {
implementation "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:${jacksonVersion}"
implementation "io.opentelemetry:opentelemetry-api:${openTelemetryVersion}"
implementation "io.opentelemetry:opentelemetry-context:${openTelemetryVersion}"
+ // slf4j-api is `api`-scoped because org.slf4j.Logger and org.slf4j.ILoggerFactory appear
+ // on the public TaskOrchestrationContext surface. The version is the declared floor (2.0.0,
+ // required for the SLF4J 2.x fluent API and NOPLoggingEventBuilder); downstream consumers
+ // are free to resolve a newer 2.0.x patch.
+ api "org.slf4j:slf4j-api:2.0.0"
testImplementation "io.opentelemetry:opentelemetry-sdk:${openTelemetryVersion}"
testImplementation "io.opentelemetry:opentelemetry-sdk-trace:${openTelemetryVersion}"
@@ -59,6 +64,9 @@ dependencies {
testImplementation project(':azuremanaged')
testImplementation "com.azure:azure-core:${azureCoreVersion}"
testImplementation "com.azure:azure-identity:${azureIdentityVersion}"
+ testImplementation 'org.mockito:mockito-core:5.21.0'
+ testImplementation 'org.mockito:mockito-junit-jupiter:5.21.0'
+ testImplementation "org.slf4j:slf4j-simple:2.0.16"
testImplementation "io.grpc:grpc-inprocess:${grpcVersion}"
}
diff --git a/client/src/main/java/com/microsoft/durabletask/ReplaySafeLogger.java b/client/src/main/java/com/microsoft/durabletask/ReplaySafeLogger.java
new file mode 100644
index 00000000..7b788a44
--- /dev/null
+++ b/client/src/main/java/com/microsoft/durabletask/ReplaySafeLogger.java
@@ -0,0 +1,158 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+package com.microsoft.durabletask;
+
+import org.slf4j.Logger;
+import org.slf4j.Marker;
+import org.slf4j.event.Level;
+import org.slf4j.spi.LoggingEventBuilder;
+import org.slf4j.spi.NOPLoggingEventBuilder;
+
+/**
+ * An SLF4J {@link Logger} wrapper that suppresses log output during orchestration replay.
+ *
+ * Traditional logging methods ({@code info}, {@code debug}, etc.) and the SLF4J 2.x fluent API
+ * ({@code atInfo()}, {@code atDebug()}, etc.) are both gated on
+ * {@link TaskOrchestrationContext#getIsReplaying()}. The {@code isXxxEnabled()} family of methods
+ * always passes through to the underlying logger unchanged.
+ *
+ *
This mirrors the {@code ReplaySafeLogger} nested class in the modern .NET
+ * {@code TaskOrchestrationContext}.
+ *
+ *
Note on overloads: The {@code (String, Object, Object)} and {@code (String, Object...)}
+ * overloads at each log level are both defined by the {@link Logger} interface. SLF4J provides the
+ * explicit 2-arg overload to avoid varargs array allocation in the common case. Java's overload
+ * resolution (JLS §15.12.2) always prefers the non-varargs form, so dispatch is unambiguous despite
+ * the apparent overlap. This wrapper delegates each overload to the identical overload on the inner
+ * logger.
+ */
+@SuppressWarnings("java:S2177") // Required SLF4J Logger overload set; cannot be changed in this adapter.
+final class ReplaySafeLogger implements Logger {
+
+ private final TaskOrchestrationContext context;
+ private final Logger inner;
+
+ ReplaySafeLogger(TaskOrchestrationContext context, Logger inner) {
+ Helpers.throwIfArgumentNull(context, "context");
+ Helpers.throwIfArgumentNull(inner, "inner");
+ this.context = context;
+ this.inner = inner;
+ }
+
+ // -----------------------------------------------------------------------
+ // getName — always pass through
+ // -----------------------------------------------------------------------
+
+ @Override
+ public String getName() {
+ return inner.getName();
+ }
+
+ // -----------------------------------------------------------------------
+ // isXxxEnabled — always pass through (matches .NET IsEnabled behavior)
+ // -----------------------------------------------------------------------
+
+ @Override public boolean isTraceEnabled() { return inner.isTraceEnabled(); }
+ @Override public boolean isTraceEnabled(Marker marker) { return inner.isTraceEnabled(marker); }
+ @Override public boolean isDebugEnabled() { return inner.isDebugEnabled(); }
+ @Override public boolean isDebugEnabled(Marker marker) { return inner.isDebugEnabled(marker); }
+ @Override public boolean isInfoEnabled() { return inner.isInfoEnabled(); }
+ @Override public boolean isInfoEnabled(Marker marker) { return inner.isInfoEnabled(marker); }
+ @Override public boolean isWarnEnabled() { return inner.isWarnEnabled(); }
+ @Override public boolean isWarnEnabled(Marker marker) { return inner.isWarnEnabled(marker); }
+ @Override public boolean isErrorEnabled() { return inner.isErrorEnabled(); }
+ @Override public boolean isErrorEnabled(Marker marker) { return inner.isErrorEnabled(marker); }
+
+ // -----------------------------------------------------------------------
+ // SLF4J 2.x fluent API — gate via makeLoggingEventBuilder
+ //
+ // atInfo(), atDebug(), atWarn(), atError(), atTrace(), atLevel() are
+ // default methods on Logger that all delegate to makeLoggingEventBuilder().
+ // They bypass the traditional info/debug/warn/error/trace methods
+ // entirely, so we MUST override this single entry point to prevent
+ // fluent-API calls from escaping replay safety.
+ // -----------------------------------------------------------------------
+
+ @Override
+ public LoggingEventBuilder makeLoggingEventBuilder(Level level) {
+ if (context.getIsReplaying()) {
+ return NOPLoggingEventBuilder.singleton();
+ }
+ return inner.makeLoggingEventBuilder(level);
+ }
+
+ // -----------------------------------------------------------------------
+ // trace — gated on !isReplaying
+ // -----------------------------------------------------------------------
+
+ @Override public void trace(String msg) { if (!context.getIsReplaying()) inner.trace(msg); }
+ @Override public void trace(String format, Object arg) { if (!context.getIsReplaying()) inner.trace(format, arg); }
+ @Override public void trace(String format, Object arg1, Object arg2) { if (!context.getIsReplaying()) inner.trace(format, arg1, arg2); }
+ @Override public void trace(String format, Object... arguments) { if (!context.getIsReplaying()) inner.trace(format, arguments); }
+ @Override public void trace(String msg, Throwable t) { if (!context.getIsReplaying()) inner.trace(msg, t); }
+ @Override public void trace(Marker marker, String msg) { if (!context.getIsReplaying()) inner.trace(marker, msg); }
+ @Override public void trace(Marker marker, String format, Object arg) { if (!context.getIsReplaying()) inner.trace(marker, format, arg); }
+ @Override public void trace(Marker marker, String format, Object arg1, Object arg2) { if (!context.getIsReplaying()) inner.trace(marker, format, arg1, arg2); }
+ @Override public void trace(Marker marker, String format, Object... argArray) { if (!context.getIsReplaying()) inner.trace(marker, format, argArray); }
+ @Override public void trace(Marker marker, String msg, Throwable t) { if (!context.getIsReplaying()) inner.trace(marker, msg, t); }
+
+ // -----------------------------------------------------------------------
+ // debug — gated on !isReplaying
+ // -----------------------------------------------------------------------
+
+ @Override public void debug(String msg) { if (!context.getIsReplaying()) inner.debug(msg); }
+ @Override public void debug(String format, Object arg) { if (!context.getIsReplaying()) inner.debug(format, arg); }
+ @Override public void debug(String format, Object arg1, Object arg2) { if (!context.getIsReplaying()) inner.debug(format, arg1, arg2); }
+ @Override public void debug(String format, Object... arguments) { if (!context.getIsReplaying()) inner.debug(format, arguments); }
+ @Override public void debug(String msg, Throwable t) { if (!context.getIsReplaying()) inner.debug(msg, t); }
+ @Override public void debug(Marker marker, String msg) { if (!context.getIsReplaying()) inner.debug(marker, msg); }
+ @Override public void debug(Marker marker, String format, Object arg) { if (!context.getIsReplaying()) inner.debug(marker, format, arg); }
+ @Override public void debug(Marker marker, String format, Object arg1, Object arg2) { if (!context.getIsReplaying()) inner.debug(marker, format, arg1, arg2); }
+ @Override public void debug(Marker marker, String format, Object... arguments) { if (!context.getIsReplaying()) inner.debug(marker, format, arguments); }
+ @Override public void debug(Marker marker, String msg, Throwable t) { if (!context.getIsReplaying()) inner.debug(marker, msg, t); }
+
+ // -----------------------------------------------------------------------
+ // info — gated on !isReplaying
+ // -----------------------------------------------------------------------
+
+ @Override public void info(String msg) { if (!context.getIsReplaying()) inner.info(msg); }
+ @Override public void info(String format, Object arg) { if (!context.getIsReplaying()) inner.info(format, arg); }
+ @Override public void info(String format, Object arg1, Object arg2) { if (!context.getIsReplaying()) inner.info(format, arg1, arg2); }
+ @Override public void info(String format, Object... arguments) { if (!context.getIsReplaying()) inner.info(format, arguments); }
+ @Override public void info(String msg, Throwable t) { if (!context.getIsReplaying()) inner.info(msg, t); }
+ @Override public void info(Marker marker, String msg) { if (!context.getIsReplaying()) inner.info(marker, msg); }
+ @Override public void info(Marker marker, String format, Object arg) { if (!context.getIsReplaying()) inner.info(marker, format, arg); }
+ @Override public void info(Marker marker, String format, Object arg1, Object arg2) { if (!context.getIsReplaying()) inner.info(marker, format, arg1, arg2); }
+ @Override public void info(Marker marker, String format, Object... arguments) { if (!context.getIsReplaying()) inner.info(marker, format, arguments); }
+ @Override public void info(Marker marker, String msg, Throwable t) { if (!context.getIsReplaying()) inner.info(marker, msg, t); }
+
+ // -----------------------------------------------------------------------
+ // warn — gated on !isReplaying
+ // -----------------------------------------------------------------------
+
+ @Override public void warn(String msg) { if (!context.getIsReplaying()) inner.warn(msg); }
+ @Override public void warn(String format, Object arg) { if (!context.getIsReplaying()) inner.warn(format, arg); }
+ @Override public void warn(String format, Object arg1, Object arg2) { if (!context.getIsReplaying()) inner.warn(format, arg1, arg2); }
+ @Override public void warn(String format, Object... arguments) { if (!context.getIsReplaying()) inner.warn(format, arguments); }
+ @Override public void warn(String msg, Throwable t) { if (!context.getIsReplaying()) inner.warn(msg, t); }
+ @Override public void warn(Marker marker, String msg) { if (!context.getIsReplaying()) inner.warn(marker, msg); }
+ @Override public void warn(Marker marker, String format, Object arg) { if (!context.getIsReplaying()) inner.warn(marker, format, arg); }
+ @Override public void warn(Marker marker, String format, Object arg1, Object arg2) { if (!context.getIsReplaying()) inner.warn(marker, format, arg1, arg2); }
+ @Override public void warn(Marker marker, String format, Object... arguments) { if (!context.getIsReplaying()) inner.warn(marker, format, arguments); }
+ @Override public void warn(Marker marker, String msg, Throwable t) { if (!context.getIsReplaying()) inner.warn(marker, msg, t); }
+
+ // -----------------------------------------------------------------------
+ // error — gated on !isReplaying
+ // -----------------------------------------------------------------------
+
+ @Override public void error(String msg) { if (!context.getIsReplaying()) inner.error(msg); }
+ @Override public void error(String format, Object arg) { if (!context.getIsReplaying()) inner.error(format, arg); }
+ @Override public void error(String format, Object arg1, Object arg2) { if (!context.getIsReplaying()) inner.error(format, arg1, arg2); }
+ @Override public void error(String format, Object... arguments) { if (!context.getIsReplaying()) inner.error(format, arguments); }
+ @Override public void error(String msg, Throwable t) { if (!context.getIsReplaying()) inner.error(msg, t); }
+ @Override public void error(Marker marker, String msg) { if (!context.getIsReplaying()) inner.error(marker, msg); }
+ @Override public void error(Marker marker, String format, Object arg) { if (!context.getIsReplaying()) inner.error(marker, format, arg); }
+ @Override public void error(Marker marker, String format, Object arg1, Object arg2) { if (!context.getIsReplaying()) inner.error(marker, format, arg1, arg2); }
+ @Override public void error(Marker marker, String format, Object... arguments) { if (!context.getIsReplaying()) inner.error(marker, format, arguments); }
+ @Override public void error(Marker marker, String msg, Throwable t) { if (!context.getIsReplaying()) inner.error(marker, msg, t); }
+}
diff --git a/client/src/main/java/com/microsoft/durabletask/ReplaySafeLoggerFactory.java b/client/src/main/java/com/microsoft/durabletask/ReplaySafeLoggerFactory.java
new file mode 100644
index 00000000..081b811b
--- /dev/null
+++ b/client/src/main/java/com/microsoft/durabletask/ReplaySafeLoggerFactory.java
@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+package com.microsoft.durabletask;
+
+import org.slf4j.ILoggerFactory;
+import org.slf4j.Logger;
+
+/**
+ * An {@link ILoggerFactory} that produces replay-safe loggers backed by the context's
+ * underlying {@link TaskOrchestrationContext#getLoggerFactory() logger factory}.
+ *
+ *
Mirrors the {@code ReplaySafeLoggerFactoryImpl} nested class in the modern .NET
+ * {@code TaskOrchestrationContext}.
+ */
+final class ReplaySafeLoggerFactory implements ILoggerFactory {
+
+ private final TaskOrchestrationContext context;
+
+ ReplaySafeLoggerFactory(TaskOrchestrationContext context) {
+ Helpers.throwIfArgumentNull(context, "context");
+ this.context = context;
+ }
+
+ /**
+ * Returns the factory underlying this wrapper. Used by {@link ReplaySafeLoggers#unwrap}
+ * to walk past nested replay-safe wrappers (wrapper-context delegation pattern).
+ */
+ ILoggerFactory underlying() {
+ return context.getLoggerFactory();
+ }
+
+ @Override
+ public Logger getLogger(String name) {
+ Helpers.throwIfArgumentNullOrWhiteSpace(name, "name");
+ return new ReplaySafeLogger(context, ReplaySafeLoggers.unwrap(context).getLogger(name));
+ }
+}
diff --git a/client/src/main/java/com/microsoft/durabletask/ReplaySafeLoggers.java b/client/src/main/java/com/microsoft/durabletask/ReplaySafeLoggers.java
new file mode 100644
index 00000000..9f1546ba
--- /dev/null
+++ b/client/src/main/java/com/microsoft/durabletask/ReplaySafeLoggers.java
@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+package com.microsoft.durabletask;
+
+import org.slf4j.ILoggerFactory;
+
+/**
+ * Utility class for unwrapping nested {@link ReplaySafeLoggerFactory} instances.
+ *
+ *
Mirrors {@code TaskOrchestrationContext.GetUnwrappedLoggerFactory()} in the modern .NET SDK.
+ * When a wrapper context delegates {@code getLoggerFactory()} to
+ * {@code inner.getReplaySafeLoggerFactory()}, the returned factory is already a
+ * {@link ReplaySafeLoggerFactory}. Without unwrapping, loggers produced from it would be
+ * double-wrapped with redundant replay-safe checks.
+ */
+final class ReplaySafeLoggers {
+
+ private static final int MAX_UNWRAP_DEPTH = 10;
+
+ private ReplaySafeLoggers() {
+ // utility class
+ }
+
+ /**
+ * Returns the underlying {@link ILoggerFactory} for the given context, walking past any
+ * nested {@link ReplaySafeLoggerFactory} wrappers.
+ *
+ * @param context the orchestration context whose logger factory to unwrap
+ * @return the first non-replay-safe-wrapped factory in the chain
+ * @throws IllegalStateException if more than {@value #MAX_UNWRAP_DEPTH} levels of wrapping
+ * are encountered (cycle protection)
+ */
+ static ILoggerFactory unwrap(TaskOrchestrationContext context) {
+ Helpers.throwIfArgumentNull(context, "context");
+ ILoggerFactory factory = context.getLoggerFactory();
+ if (factory == null) {
+ throw new IllegalStateException(
+ "getLoggerFactory() returned null on context of type " +
+ context.getClass().getName() +
+ ". Override TaskOrchestrationContext.getLoggerFactory() to return a non-null " +
+ "ILoggerFactory (typically inner.getReplaySafeLoggerFactory() for wrapper contexts).");
+ }
+ int depth = 0;
+ while (factory instanceof ReplaySafeLoggerFactory) {
+ if (++depth > MAX_UNWRAP_DEPTH) {
+ throw new IllegalStateException(
+ "Maximum unwrap depth exceeded while resolving the underlying ILoggerFactory. " +
+ "Ensure the wrapper's getLoggerFactory() delegates to the inner context's " +
+ "getReplaySafeLoggerFactory() (e.g., 'inner.getReplaySafeLoggerFactory()'), " +
+ "not 'this.getReplaySafeLoggerFactory()'.");
+ }
+ factory = ((ReplaySafeLoggerFactory) factory).underlying();
+ }
+ return factory;
+ }
+}
diff --git a/client/src/main/java/com/microsoft/durabletask/TaskOrchestrationContext.java b/client/src/main/java/com/microsoft/durabletask/TaskOrchestrationContext.java
index e94acde4..c9143315 100644
--- a/client/src/main/java/com/microsoft/durabletask/TaskOrchestrationContext.java
+++ b/client/src/main/java/com/microsoft/durabletask/TaskOrchestrationContext.java
@@ -13,6 +13,10 @@
import java.util.UUID;
import javax.annotation.Nonnull;
+import org.slf4j.ILoggerFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
/**
* Used by orchestrators to perform actions such as scheduling tasks, durable timers, waiting for external events,
* and for getting basic information about the current orchestration.
@@ -855,4 +859,85 @@ default Task callHttp(String method, URI uri,
@Nullable String content) {
return DurableHttp.callHttp(this, method, uri, headers, content);
}
+
+ /**
+ * Returns the {@link ILoggerFactory} used by this context to resolve loggers.
+ *
+ * This method is an extension point for wrapper-context implementations, not a
+ * convenience getter for orchestrator code. Orchestrator code should always use
+ * {@link #createReplaySafeLogger(String)} / {@link #createReplaySafeLogger(Class)} or
+ * {@link #getReplaySafeLoggerFactory()} — never call {@code getLoggerFactory()}
+ * directly to obtain a logger, as the returned factory produces non-replay-safe
+ * loggers that will emit duplicate messages on every replay.
+ *
+ *
This is the Java analog of the .NET SDK's {@code protected abstract ILoggerFactory
+ * LoggerFactory} property. Java interfaces cannot express {@code protected}, so this method
+ * is exposed as a {@code public default} returning the SLF4J global
+ * {@link LoggerFactory#getILoggerFactory()}. Wrapper contexts should override it
+ * — for example, a wrapper that wants its own logging to also be replay-safe must
+ * return the inner context's {@link #getReplaySafeLoggerFactory()}:
+ *
+ * @Override
+ * public ILoggerFactory getLoggerFactory() {
+ * return inner.getReplaySafeLoggerFactory();
+ * }
+ *
+ *
+ * To prevent double-wrapping, the SDK unwraps any nested factory returned from this
+ * method that is itself a replay-safe wrapper.
+ *
+ * @return the {@code ILoggerFactory} backing logger creation for this context; must not
+ * be {@code null}. Returning {@code null} from an override causes
+ * {@link #createReplaySafeLogger(String)} and {@link #getReplaySafeLoggerFactory()}
+ * to throw {@link IllegalStateException}.
+ */
+ @Nonnull
+ default ILoggerFactory getLoggerFactory() {
+ return LoggerFactory.getILoggerFactory();
+ }
+
+ /**
+ * Returns an SLF4J {@link Logger} that is replay-safe: logging methods are no-ops while the
+ * orchestrator is replaying history, and forward to the underlying logger otherwise.
+ * {@code isXxxEnabled()} always passes through unchanged.
+ *
+ *
The underlying logger is resolved via {@link #getLoggerFactory()}.
+ *
+ *
Requires {@code slf4j-api} version 2.0.0 or later on the classpath.
+ *
+ * @param name the SLF4J logger name (category)
+ * @return a replay-safe SLF4J {@code Logger}
+ */
+ default Logger createReplaySafeLogger(String name) {
+ Helpers.throwIfArgumentNullOrWhiteSpace(name, "name");
+ return new ReplaySafeLogger(this, ReplaySafeLoggers.unwrap(this).getLogger(name));
+ }
+
+ /**
+ * Returns an SLF4J {@link Logger} that is replay-safe, using the fully-qualified class name
+ * as the logger category.
+ *
+ * @param categoryType the class whose name to use as the logger category
+ * @return a replay-safe SLF4J {@code Logger}
+ * @see #createReplaySafeLogger(String)
+ */
+ default Logger createReplaySafeLogger(Class categoryType) {
+ Helpers.throwIfArgumentNull(categoryType, "categoryType");
+ return new ReplaySafeLogger(this, ReplaySafeLoggers.unwrap(this).getLogger(categoryType.getName()));
+ }
+
+ /**
+ * Returns an {@link ILoggerFactory} that produces replay-safe loggers backed by
+ * {@link #getLoggerFactory()}. Mirrors the {@code ReplaySafeLoggerFactory} property in the
+ * modern .NET SDK.
+ *
+ *
Implementations are expected to cache the returned factory for the lifetime of the
+ * context. The default implementation allocates on every call; the concrete runtime
+ * implementation overrides this to cache.
+ *
+ * @return an {@code ILoggerFactory} wrapping each created logger with replay-safe semantics
+ */
+ default ILoggerFactory getReplaySafeLoggerFactory() {
+ return new ReplaySafeLoggerFactory(this);
+ }
}
diff --git a/client/src/main/java/com/microsoft/durabletask/TaskOrchestrationExecutor.java b/client/src/main/java/com/microsoft/durabletask/TaskOrchestrationExecutor.java
index 8e60080e..59fc89d6 100644
--- a/client/src/main/java/com/microsoft/durabletask/TaskOrchestrationExecutor.java
+++ b/client/src/main/java/com/microsoft/durabletask/TaskOrchestrationExecutor.java
@@ -14,6 +14,8 @@
import com.microsoft.durabletask.implementation.protobuf.OrchestratorService.ScheduleTaskAction.Builder;
import com.microsoft.durabletask.util.UUIDGenerator;
+import org.slf4j.ILoggerFactory;
+
import javax.annotation.Nullable;
import java.time.Duration;
import java.time.Instant;
@@ -130,6 +132,9 @@ private class ContextImplTask implements TaskOrchestrationContext {
private String version;
private String defaultVersion;
+ // Replay-safe logger factory cache (matches .NET ReplaySafeLoggerFactory caching)
+ private ReplaySafeLoggerFactory cachedReplaySafeLoggerFactory;
+
// LinkedHashMap to maintain insertion order when returning the list of pending actions
private final LinkedHashMap pendingActions = new LinkedHashMap<>();
private final HashMap> openTasks = new HashMap<>();
@@ -247,6 +252,14 @@ private void setDoneReplaying() {
this.isReplaying = false;
}
+ @Override
+ public ILoggerFactory getReplaySafeLoggerFactory() {
+ if (this.cachedReplaySafeLoggerFactory == null) {
+ this.cachedReplaySafeLoggerFactory = new ReplaySafeLoggerFactory(this);
+ }
+ return this.cachedReplaySafeLoggerFactory;
+ }
+
@Override
public String getVersion() {
return this.version;
diff --git a/client/src/test/java/com/microsoft/durabletask/ReplaySafeLoggerFactoryTest.java b/client/src/test/java/com/microsoft/durabletask/ReplaySafeLoggerFactoryTest.java
new file mode 100644
index 00000000..760d2d25
--- /dev/null
+++ b/client/src/test/java/com/microsoft/durabletask/ReplaySafeLoggerFactoryTest.java
@@ -0,0 +1,292 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+package com.microsoft.durabletask;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.slf4j.ILoggerFactory;
+import org.slf4j.Logger;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.time.ZonedDateTime;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class ReplaySafeLoggerFactoryTest {
+
+ @Mock
+ private Logger mockLogger;
+
+ // -----------------------------------------------------------------------
+ // Constructor validation
+ // -----------------------------------------------------------------------
+
+ @Test
+ void constructor_throwsOnNullContext() {
+ assertThrows(IllegalArgumentException.class, () -> new ReplaySafeLoggerFactory(null));
+ }
+
+ // -----------------------------------------------------------------------
+ // getLogger produces replay-safe loggers
+ // -----------------------------------------------------------------------
+
+ @Test
+ void getLogger_returnsLoggerWithMatchingName() {
+ ILoggerFactory underlying = mock(ILoggerFactory.class);
+ when(underlying.getLogger("com.example.Test")).thenReturn(mockLogger);
+ when(mockLogger.getName()).thenReturn("com.example.Test");
+
+ TaskOrchestrationContext context = createMinimalContext(false, underlying);
+ ReplaySafeLoggerFactory factory = new ReplaySafeLoggerFactory(context);
+
+ Logger logger = factory.getLogger("com.example.Test");
+ assertEquals("com.example.Test", logger.getName());
+ }
+
+ @Test
+ void getLogger_producesLoggerThatSuppressesDuringReplay() {
+ ILoggerFactory underlying = mock(ILoggerFactory.class);
+ when(underlying.getLogger("test")).thenReturn(mockLogger);
+
+ // Context is replaying
+ TaskOrchestrationContext context = createMinimalContext(true, underlying);
+ ReplaySafeLoggerFactory factory = new ReplaySafeLoggerFactory(context);
+
+ Logger logger = factory.getLogger("test");
+ logger.info("should be suppressed");
+ verify(mockLogger, never()).info(anyString());
+ }
+
+ @Test
+ void getLogger_producesLoggerThatForwardsWhenNotReplaying() {
+ ILoggerFactory underlying = mock(ILoggerFactory.class);
+ when(underlying.getLogger("test")).thenReturn(mockLogger);
+
+ // Context is NOT replaying
+ TaskOrchestrationContext context = createMinimalContext(false, underlying);
+ ReplaySafeLoggerFactory factory = new ReplaySafeLoggerFactory(context);
+
+ Logger logger = factory.getLogger("test");
+ logger.info("should be forwarded");
+ verify(mockLogger).info("should be forwarded");
+ }
+
+ // -----------------------------------------------------------------------
+ // Caching in OrchestrationContextImpl — verify same instance returned
+ // -----------------------------------------------------------------------
+
+ @Test
+ void getReplaySafeLoggerFactory_defaultAllocatesNewInstance() {
+ ILoggerFactory underlying = mock(ILoggerFactory.class);
+ TaskOrchestrationContext context = createMinimalContext(false, underlying);
+
+ // Default method (no caching) — returns different instances
+ ILoggerFactory f1 = context.getReplaySafeLoggerFactory();
+ ILoggerFactory f2 = context.getReplaySafeLoggerFactory();
+ assertNotSame(f1, f2);
+ }
+
+ // -----------------------------------------------------------------------
+ // Wrapper-context delegation — no double-wrapping
+ // Mirrors .NET's ChecksReplayOnce test (F-01/F-10 fix)
+ // Uses mismatched replay flags to prove the wrapper's gate is consulted
+ // -----------------------------------------------------------------------
+
+ @Test
+ void wrapperContext_doesNotDoubleWrapLoggers() {
+ ILoggerFactory underlying = mock(ILoggerFactory.class);
+ when(underlying.getLogger("test")).thenReturn(mockLogger);
+
+ // Inner context is NOT replaying
+ TaskOrchestrationContext innerContext = createMinimalContext(false, underlying);
+
+ // Wrapper context IS replaying — and delegates getLoggerFactory() to inner's replay-safe factory
+ // If double-wrapping occurred, the inner (non-replaying) gate would also be checked,
+ // producing inconsistent behavior
+ TaskOrchestrationContext wrapperContext = new MinimalContext(true, null) {
+ @Override
+ public ILoggerFactory getLoggerFactory() {
+ return innerContext.getReplaySafeLoggerFactory();
+ }
+ };
+
+ // createReplaySafeLogger on the wrapper should unwrap and produce a logger
+ // that checks isReplaying on the WRAPPER context (which is replaying)
+ Logger logger = wrapperContext.createReplaySafeLogger("test");
+ assertNotNull(logger);
+ assertTrue(logger instanceof ReplaySafeLogger);
+
+ // The wrapper is replaying, so the log should be suppressed
+ logger.info("should be suppressed");
+ verify(mockLogger, never()).info(anyString());
+ }
+
+ // -----------------------------------------------------------------------
+ // Cycle detection — mirrors .NET's cyclic-factory test
+ // -----------------------------------------------------------------------
+
+ @Test
+ void cyclicFactory_throwsIllegalStateException() {
+ // A context whose getLoggerFactory() returns this.getReplaySafeLoggerFactory()
+ // creates an infinite loop
+ TaskOrchestrationContext cyclicContext = new MinimalContext(false, null) {
+ @Override
+ public ILoggerFactory getLoggerFactory() {
+ return this.getReplaySafeLoggerFactory();
+ }
+ };
+
+ IllegalStateException ex = assertThrows(IllegalStateException.class,
+ () -> cyclicContext.createReplaySafeLogger("test"));
+ assertTrue(ex.getMessage().contains("Maximum unwrap depth exceeded"));
+ }
+
+ // -----------------------------------------------------------------------
+ // Null factory from override — error message must name the offending context class
+ // -----------------------------------------------------------------------
+
+ @Test
+ void nullLoggerFactory_throwsIllegalStateExceptionNamingContextClass() {
+ // A wrapper context whose getLoggerFactory() returns null (a contract violation)
+ // should produce an error message that identifies the offending class so the
+ // user knows where to look.
+ TaskOrchestrationContext nullFactoryContext = new MinimalContext(false, null) {
+ @Override
+ public ILoggerFactory getLoggerFactory() {
+ return null;
+ }
+ };
+
+ IllegalStateException ex = assertThrows(IllegalStateException.class,
+ () -> nullFactoryContext.createReplaySafeLogger("test"));
+ assertTrue(ex.getMessage().contains("returned null"),
+ "Message should explain the null return: " + ex.getMessage());
+ assertTrue(ex.getMessage().contains(nullFactoryContext.getClass().getName()),
+ "Message should name the offending context class: " + ex.getMessage());
+ }
+
+ // -----------------------------------------------------------------------
+ // F-02: Verify wrapper-context forwards when inner is not replaying
+ // (complementary to the suppression test above — proves single gate)
+ // -----------------------------------------------------------------------
+
+ @Test
+ void wrapperContext_forwardsWhenWrapperNotReplaying() {
+ ILoggerFactory underlying = mock(ILoggerFactory.class);
+ when(underlying.getLogger("test")).thenReturn(mockLogger);
+
+ // Inner context IS replaying (but shouldn't matter — wrapper's gate is what's consulted)
+ TaskOrchestrationContext innerContext = createMinimalContext(true, underlying);
+
+ // Wrapper is NOT replaying
+ TaskOrchestrationContext wrapperContext = new MinimalContext(false, null) {
+ @Override
+ public ILoggerFactory getLoggerFactory() {
+ return innerContext.getReplaySafeLoggerFactory();
+ }
+ };
+
+ Logger logger = wrapperContext.createReplaySafeLogger("test");
+ logger.info("should be forwarded");
+ verify(mockLogger).info("should be forwarded");
+ }
+
+ // -----------------------------------------------------------------------
+ // F-05: Fluent API end-to-end — verifies atInfo().log() is gated
+ // -----------------------------------------------------------------------
+
+ @Test
+ void fluentApi_suppressedDuringReplay() {
+ ILoggerFactory underlying = mock(ILoggerFactory.class);
+ when(underlying.getLogger("test")).thenReturn(mockLogger);
+
+ TaskOrchestrationContext context = createMinimalContext(true, underlying);
+ Logger logger = context.createReplaySafeLogger("test");
+
+ // atInfo() calls makeLoggingEventBuilder() which should return NOP during replay
+ // The NOP builder's log() is a no-op, so mockLogger should never see the call
+ logger.atInfo().log("fluent msg");
+ verify(mockLogger, never()).info(anyString());
+ }
+
+ @Test
+ void fluentApi_forwardedWhenNotReplaying() {
+ ILoggerFactory underlying = mock(ILoggerFactory.class);
+ when(underlying.getLogger("test")).thenReturn(mockLogger);
+ when(mockLogger.isInfoEnabled()).thenReturn(true);
+ // makeLoggingEventBuilder on the real mock needs to return a real builder
+ // that will call back into mockLogger. We use a mock builder to verify log() is called.
+ org.slf4j.spi.LoggingEventBuilder realBuilder = mock(org.slf4j.spi.LoggingEventBuilder.class);
+ when(mockLogger.makeLoggingEventBuilder(org.slf4j.event.Level.INFO)).thenReturn(realBuilder);
+
+ TaskOrchestrationContext context = createMinimalContext(false, underlying);
+ Logger logger = context.createReplaySafeLogger("test");
+
+ logger.atInfo().log("fluent msg");
+ // The builder's log() should have been called (not NOP)
+ verify(realBuilder).log("fluent msg");
+ }
+
+ // -----------------------------------------------------------------------
+ // Helpers
+ // -----------------------------------------------------------------------
+
+ private TaskOrchestrationContext createMinimalContext(boolean isReplaying, ILoggerFactory loggerFactory) {
+ return new MinimalContext(isReplaying, loggerFactory);
+ }
+
+ /**
+ * Minimal concrete implementation of TaskOrchestrationContext for tests.
+ * Only getIsReplaying() and getLoggerFactory() are meaningful; everything else stubs.
+ */
+ private static class MinimalContext implements TaskOrchestrationContext {
+ private final boolean isReplaying;
+ private final ILoggerFactory loggerFactory;
+
+ MinimalContext(boolean isReplaying, ILoggerFactory loggerFactory) {
+ this.isReplaying = isReplaying;
+ this.loggerFactory = loggerFactory;
+ }
+
+ @Override public boolean getIsReplaying() { return isReplaying; }
+
+ @Override
+ public ILoggerFactory getLoggerFactory() {
+ return loggerFactory != null ? loggerFactory : TaskOrchestrationContext.super.getLoggerFactory();
+ }
+
+ // Stubs for all other interface methods
+ @Override public String getName() { return "test"; }
+ @Override public V getInput(Class t) { return null; }
+ @Override public String getInstanceId() { return "id"; }
+ @Override public Instant getCurrentInstant() { return Instant.now(); }
+ @Override public String getVersion() { return ""; }
+ @Override public Task> allOf(List> tasks) { return null; }
+ @Override public Task> anyOf(List> tasks) { return null; }
+ @Override public Task callActivity(String name, Object input, TaskOptions options, Class returnType) { return null; }
+ @Override public Task callSubOrchestrator(String name, Object input, String instanceId, TaskOptions options, Class returnType) { return null; }
+ @Override public Task createTimer(Duration delay) { return null; }
+ @Override public Task createTimer(ZonedDateTime zonedDateTime) { return null; }
+ @Override public Task waitForExternalEvent(String name, Duration timeout, Class dataType) { return null; }
+ @Override public void complete(Object output) {}
+ @Override public void continueAsNew(Object input, boolean preserveUnprocessedEvents) {}
+ @Override public UUID newUUID() { return UUID.randomUUID(); }
+ @Override public void setCustomStatus(Object customStatus) {}
+ @Override public void clearCustomStatus() {}
+ @Override public void sendEvent(String instanceId, String eventName, Object eventData) {}
+ @Override public void signalEntity(EntityInstanceId entityId, String operationName, Object input, SignalEntityOptions options) {}
+ @Override public Task callEntity(EntityInstanceId entityId, String operationName, Object input, Class returnType) { return null; }
+ @Override public Task callEntity(EntityInstanceId entityId, String operationName, Object input, Class returnType, CallEntityOptions options) { return null; }
+ @Override public Task lockEntities(List entityIds) { return null; }
+ @Override public boolean isInCriticalSection() { return false; }
+ @Override public List getLockedEntities() { return Collections.emptyList(); }
+ }
+}
diff --git a/client/src/test/java/com/microsoft/durabletask/ReplaySafeLoggerTest.java b/client/src/test/java/com/microsoft/durabletask/ReplaySafeLoggerTest.java
new file mode 100644
index 00000000..fb4b6284
--- /dev/null
+++ b/client/src/test/java/com/microsoft/durabletask/ReplaySafeLoggerTest.java
@@ -0,0 +1,328 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+package com.microsoft.durabletask;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.slf4j.Logger;
+import org.slf4j.Marker;
+import org.slf4j.MarkerFactory;
+import org.slf4j.event.Level;
+import org.slf4j.spi.LoggingEventBuilder;
+import org.slf4j.spi.NOPLoggingEventBuilder;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class ReplaySafeLoggerTest {
+
+ @Mock
+ private TaskOrchestrationContext context;
+
+ @Mock
+ private Logger inner;
+
+ // -----------------------------------------------------------------------
+ // Constructor validation
+ // -----------------------------------------------------------------------
+
+ @Test
+ void constructor_throwsOnNullContext() {
+ assertThrows(IllegalArgumentException.class, () -> new ReplaySafeLogger(null, inner));
+ }
+
+ @Test
+ void constructor_throwsOnNullLogger() {
+ assertThrows(IllegalArgumentException.class, () -> new ReplaySafeLogger(context, null));
+ }
+
+ // -----------------------------------------------------------------------
+ // getName — always passes through
+ // -----------------------------------------------------------------------
+
+ @Test
+ void getName_returnsInnerLoggerName() {
+ when(inner.getName()).thenReturn("com.example.MyOrchestrator");
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+ assertEquals("com.example.MyOrchestrator", logger.getName());
+ }
+
+ // -----------------------------------------------------------------------
+ // isXxxEnabled — always passes through regardless of replay state
+ // -----------------------------------------------------------------------
+
+ @Test
+ void isInfoEnabled_passesThroughDuringReplay() {
+ when(inner.isInfoEnabled()).thenReturn(true);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+ assertTrue(logger.isInfoEnabled());
+ }
+
+ @Test
+ void isDebugEnabled_passesThroughWhenNotReplaying() {
+ when(inner.isDebugEnabled()).thenReturn(false);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+ assertFalse(logger.isDebugEnabled());
+ }
+
+ @Test
+ void isWarnEnabled_withMarker_passesThroughDuringReplay() {
+ Marker marker = MarkerFactory.getMarker("TEST");
+ when(inner.isWarnEnabled(marker)).thenReturn(true);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+ assertTrue(logger.isWarnEnabled(marker));
+ }
+
+ @Test
+ void isTraceEnabled_passesThroughDuringReplay() {
+ when(inner.isTraceEnabled()).thenReturn(false);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+ assertFalse(logger.isTraceEnabled());
+ }
+
+ @Test
+ void isErrorEnabled_passesThroughDuringReplay() {
+ when(inner.isErrorEnabled()).thenReturn(true);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+ assertTrue(logger.isErrorEnabled());
+ }
+
+ // -----------------------------------------------------------------------
+ // Suppresses logs during replay — one representative per level
+ // -----------------------------------------------------------------------
+
+ @Test
+ void info_suppressedDuringReplay() {
+ when(context.getIsReplaying()).thenReturn(true);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ logger.info("test message");
+ verify(inner, never()).info(anyString());
+ }
+
+ @Test
+ void debug_suppressedDuringReplay() {
+ when(context.getIsReplaying()).thenReturn(true);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ logger.debug("test message");
+ verify(inner, never()).debug(anyString());
+ }
+
+ @Test
+ void warn_suppressedDuringReplay() {
+ when(context.getIsReplaying()).thenReturn(true);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ logger.warn("test message");
+ verify(inner, never()).warn(anyString());
+ }
+
+ @Test
+ void error_suppressedDuringReplay() {
+ when(context.getIsReplaying()).thenReturn(true);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ logger.error("test message");
+ verify(inner, never()).error(anyString());
+ }
+
+ @Test
+ void trace_suppressedDuringReplay() {
+ when(context.getIsReplaying()).thenReturn(true);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ logger.trace("test message");
+ verify(inner, never()).trace(anyString());
+ }
+
+ // -----------------------------------------------------------------------
+ // Forwards logs when NOT replaying — one representative per level
+ // -----------------------------------------------------------------------
+
+ @Test
+ void info_forwardedWhenNotReplaying() {
+ when(context.getIsReplaying()).thenReturn(false);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ logger.info("hello");
+ verify(inner).info("hello");
+ }
+
+ @Test
+ void debug_forwardedWhenNotReplaying() {
+ when(context.getIsReplaying()).thenReturn(false);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ logger.debug("hello");
+ verify(inner).debug("hello");
+ }
+
+ @Test
+ void warn_forwardedWhenNotReplaying() {
+ when(context.getIsReplaying()).thenReturn(false);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ logger.warn("hello");
+ verify(inner).warn("hello");
+ }
+
+ @Test
+ void error_forwardedWhenNotReplaying() {
+ when(context.getIsReplaying()).thenReturn(false);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ logger.error("hello");
+ verify(inner).error("hello");
+ }
+
+ @Test
+ void trace_forwardedWhenNotReplaying() {
+ when(context.getIsReplaying()).thenReturn(false);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ logger.trace("hello");
+ verify(inner).trace("hello");
+ }
+
+ // -----------------------------------------------------------------------
+ // Format-string overloads
+ // -----------------------------------------------------------------------
+
+ @Test
+ void info_formatOneArg_forwardedWhenNotReplaying() {
+ when(context.getIsReplaying()).thenReturn(false);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ logger.info("count={}", 42);
+ verify(inner).info("count={}", (Object) 42);
+ }
+
+ @Test
+ void info_formatTwoArgs_suppressedDuringReplay() {
+ when(context.getIsReplaying()).thenReturn(true);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ logger.info("{} + {}", 1, 2);
+ verify(inner, never()).info(anyString(), any(), any());
+ }
+
+ @Test
+ void warn_formatVarargs_forwardedWhenNotReplaying() {
+ when(context.getIsReplaying()).thenReturn(false);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ logger.warn("{} {} {}", "a", "b", "c");
+ verify(inner).warn("{} {} {}", "a", "b", "c");
+ }
+
+ // -----------------------------------------------------------------------
+ // Throwable overload
+ // -----------------------------------------------------------------------
+
+ @Test
+ void error_withThrowable_forwardedWhenNotReplaying() {
+ when(context.getIsReplaying()).thenReturn(false);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+ Exception ex = new RuntimeException("boom");
+
+ logger.error("failed", ex);
+ verify(inner).error("failed", ex);
+ }
+
+ @Test
+ void error_withThrowable_suppressedDuringReplay() {
+ when(context.getIsReplaying()).thenReturn(true);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+ Exception ex = new RuntimeException("boom");
+
+ logger.error("failed", ex);
+ verify(inner, never()).error(anyString(), any(Throwable.class));
+ }
+
+ // -----------------------------------------------------------------------
+ // Marker overloads
+ // -----------------------------------------------------------------------
+
+ @Test
+ void info_withMarker_forwardedWhenNotReplaying() {
+ Marker marker = MarkerFactory.getMarker("IMPORTANT");
+ when(context.getIsReplaying()).thenReturn(false);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ logger.info(marker, "hello");
+ verify(inner).info(marker, "hello");
+ }
+
+ @Test
+ void info_withMarker_suppressedDuringReplay() {
+ Marker marker = MarkerFactory.getMarker("IMPORTANT");
+ when(context.getIsReplaying()).thenReturn(true);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ logger.info(marker, "hello");
+ verify(inner, never()).info(any(Marker.class), anyString());
+ }
+
+ // -----------------------------------------------------------------------
+ // Dynamic replay state changes
+ // -----------------------------------------------------------------------
+
+ @Test
+ void respectsChangesInReplayState() {
+ when(context.getIsReplaying()).thenReturn(true);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ logger.info("during replay");
+ verify(inner, never()).info("during replay");
+
+ // Transition to not replaying
+ when(context.getIsReplaying()).thenReturn(false);
+
+ logger.info("after replay");
+ verify(inner).info("after replay");
+ }
+
+ // -----------------------------------------------------------------------
+ // SLF4J 2.x fluent API — makeLoggingEventBuilder
+ // -----------------------------------------------------------------------
+
+ @Test
+ void makeLoggingEventBuilder_returnsNOPDuringReplay() {
+ when(context.getIsReplaying()).thenReturn(true);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ LoggingEventBuilder builder = logger.makeLoggingEventBuilder(Level.INFO);
+ assertSame(NOPLoggingEventBuilder.singleton(), builder);
+ verify(inner, never()).makeLoggingEventBuilder(any());
+ }
+
+ @Test
+ void makeLoggingEventBuilder_delegatesWhenNotReplaying() {
+ when(context.getIsReplaying()).thenReturn(false);
+ LoggingEventBuilder mockBuilder = mock(LoggingEventBuilder.class);
+ when(inner.makeLoggingEventBuilder(Level.WARN)).thenReturn(mockBuilder);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ LoggingEventBuilder builder = logger.makeLoggingEventBuilder(Level.WARN);
+ assertSame(mockBuilder, builder);
+ }
+
+ @Test
+ void fluentApi_atInfo_suppressedDuringReplay() {
+ when(context.getIsReplaying()).thenReturn(true);
+ // atInfo() is a default method that calls makeLoggingEventBuilder(INFO)
+ // then checks isInfoEnabled(). We need isInfoEnabled to pass through.
+ when(inner.isInfoEnabled()).thenReturn(true);
+ ReplaySafeLogger logger = new ReplaySafeLogger(context, inner);
+
+ // The returned builder should be a NOP — calling log() does nothing.
+ LoggingEventBuilder builder = logger.atInfo();
+ assertNotNull(builder);
+ // Verify makeLoggingEventBuilder on inner was NOT called
+ verify(inner, never()).makeLoggingEventBuilder(any());
+ }
+}
diff --git a/samples/build.gradle b/samples/build.gradle
index 877afa29..e3ee01e6 100644
--- a/samples/build.gradle
+++ b/samples/build.gradle
@@ -88,6 +88,11 @@ task runTypedEntityProxySample(type: JavaExec) {
environment dtsEnv
}
+task runReplaySafeLoggingPattern(type: JavaExec) {
+ classpath = sourceSets.main.runtimeClasspath
+ mainClass = 'io.durabletask.samples.ReplaySafeLoggingPattern'
+}
+
task printClasspath {
doLast {
println sourceSets.main.runtimeClasspath.asPath
@@ -117,4 +122,7 @@ dependencies {
// install lombok
annotationProcessor 'org.projectlombok:lombok:1.18.42'
compileOnly 'org.projectlombok:lombok:1.18.42'
-}
\ No newline at end of file
+
+ // SLF4J binding for replay-safe logger sample output
+ runtimeOnly 'org.slf4j:slf4j-simple:2.0.16'
+}
diff --git a/samples/src/main/java/io/durabletask/samples/ReplaySafeLoggingPattern.java b/samples/src/main/java/io/durabletask/samples/ReplaySafeLoggingPattern.java
new file mode 100644
index 00000000..fee8439b
--- /dev/null
+++ b/samples/src/main/java/io/durabletask/samples/ReplaySafeLoggingPattern.java
@@ -0,0 +1,146 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+package io.durabletask.samples;
+
+import com.microsoft.durabletask.DurableTaskClient;
+import com.microsoft.durabletask.DurableTaskGrpcClientBuilder;
+import com.microsoft.durabletask.DurableTaskGrpcWorker;
+import com.microsoft.durabletask.DurableTaskGrpcWorkerBuilder;
+import com.microsoft.durabletask.NewOrchestrationInstanceOptions;
+import com.microsoft.durabletask.OrchestrationMetadata;
+import com.microsoft.durabletask.TaskActivity;
+import com.microsoft.durabletask.TaskActivityFactory;
+import com.microsoft.durabletask.TaskOrchestration;
+import com.microsoft.durabletask.TaskOrchestrationFactory;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.time.Duration;
+import java.util.concurrent.TimeoutException;
+
+/**
+ * Demonstrates the replay-safe logging API on {@code TaskOrchestrationContext}, the Java
+ * counterpart of the .NET SDK's {@code ReplaySafeLoggerFactorySample}.
+ *
+ * An orchestrator replays its history every time it resumes. A normal SLF4J logger therefore
+ * emits the same message multiple times — once per replay. A logger obtained from
+ * {@link com.microsoft.durabletask.TaskOrchestrationContext#createReplaySafeLogger(Class)}
+ * suppresses output during replay and logs only on the first (non-replay) execution.
+ *
+ *
This sample runs an orchestrator that calls two activities. Each activity call causes the
+ * orchestrator to yield and replay on resume, so the messages logged via the standard logger
+ * appear more than once while the replay-safe logger's messages appear exactly once.
+ *
+ *
Run it like any other sample (requires a Durable Task sidecar / DTS emulator on the default
+ * gRPC endpoint):
+ *
{@code
+ * ./gradlew :samples:runReplaySafeLoggingPattern
+ * }
+ *
+ * Wrapper-context pattern (.NET parity)
+ * If you wrap {@code TaskOrchestrationContext} in your own type and want logging emitted from
+ * the wrapper to also be replay-safe, override {@code getLoggerFactory()} to return the inner
+ * context's {@code getReplaySafeLoggerFactory()}:
+ * {@code
+ * final class LoggingContext implements TaskOrchestrationContext {
+ * private final TaskOrchestrationContext inner;
+ * LoggingContext(TaskOrchestrationContext inner) { this.inner = inner; }
+ *
+ * @Override
+ * public ILoggerFactory getLoggerFactory() {
+ * return inner.getReplaySafeLoggerFactory(); // SDK unwraps to avoid double-wrapping
+ * }
+ * // ... forward all other methods to `inner` ...
+ * }
+ * }
+ * Implementing the full wrapper requires forwarding every abstract method on the interface, so
+ * it is omitted here for brevity. The mechanism is the same as the .NET SDK's
+ * {@code protected override ILoggerFactory LoggerFactory => inner.ReplaySafeLoggerFactory;}.
+ */
+final class ReplaySafeLoggingPattern {
+
+ private static final String ORCHESTRATION_NAME = "ReplaySafeLoggingOrchestration";
+ private static final String ECHO_ACTIVITY = "Echo";
+
+ public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
+ DurableTaskGrpcWorker worker = createWorker();
+ worker.start();
+
+ try {
+ DurableTaskClient client = new DurableTaskGrpcClientBuilder().build();
+
+ String instanceId = client.scheduleNewOrchestrationInstance(
+ ORCHESTRATION_NAME,
+ new NewOrchestrationInstanceOptions().setInput("Seattle"));
+ System.out.printf("Started new orchestration instance: %s%n", instanceId);
+
+ OrchestrationMetadata completed = client.waitForInstanceCompletion(
+ instanceId,
+ Duration.ofSeconds(30),
+ true);
+
+ System.out.printf("Orchestration completed: %s%n", completed.getRuntimeStatus());
+ System.out.printf("Output: %s%n", completed.readOutputAs(String.class));
+ System.out.println();
+ System.out.println(
+ "Note: the non-replay-safe logger's messages should appear multiple times " +
+ "(once per replay), while the replay-safe logger's messages appear once.");
+ } finally {
+ worker.stop();
+ }
+ }
+
+ private static DurableTaskGrpcWorker createWorker() {
+ DurableTaskGrpcWorkerBuilder builder = new DurableTaskGrpcWorkerBuilder();
+
+ builder.addOrchestration(new TaskOrchestrationFactory() {
+ @Override
+ public String getName() { return ORCHESTRATION_NAME; }
+
+ @Override
+ public TaskOrchestration create() {
+ return ctx -> {
+ String input = ctx.getInput(String.class);
+
+ // Non-replay-safe logger: emits on every replay.
+ Logger plainLogger = LoggerFactory.getLogger(ReplaySafeLoggingPattern.class);
+
+ // Replay-safe logger: emits only when the orchestrator is NOT replaying.
+ Logger replaySafeLogger = ctx.createReplaySafeLogger(ReplaySafeLoggingPattern.class);
+
+ plainLogger.info("[plain] starting orchestration for input='{}'", input);
+ replaySafeLogger.info("[replay-safe] starting orchestration for input='{}'", input);
+
+ String greeting = ctx.callActivity(ECHO_ACTIVITY, "Hello, " + input + "!", String.class).await();
+
+ plainLogger.info("[plain] first activity returned '{}'", greeting);
+ replaySafeLogger.info("[replay-safe] first activity returned '{}'", greeting);
+
+ String farewell = ctx.callActivity(ECHO_ACTIVITY, "Goodbye, " + input + "!", String.class).await();
+
+ plainLogger.info("[plain] second activity returned '{}'", farewell);
+ replaySafeLogger.info("[replay-safe] second activity returned '{}'", farewell);
+
+ ctx.complete(greeting + " / " + farewell);
+ };
+ }
+ });
+
+ builder.addActivity(new TaskActivityFactory() {
+ @Override
+ public String getName() { return ECHO_ACTIVITY; }
+
+ @Override
+ public TaskActivity create() {
+ return ctx -> ctx.getInput(String.class);
+ }
+ });
+ return builder.build();
+ }
+
+ private ReplaySafeLoggingPattern() {
+ // sample entry point
+ }
+}