Expose ILogger creation on TaskOrchestrationContext (#106)

Author: jviau

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## v1.0.0
 
+- `TaskOrchestrationContext.CreateReplaySafeLogger` now creates `ILogger` directly (as opposed to wrapping an existing `ILogger`).
 - Durable Functions class-based syntax now resolves `ITaskActivity` instances from `IServiceProvider`, if available there.
 - `DurableTaskClient` methods have been touched up to ensure `CancellationToken` is included, as well as is the last parameter.
 

src/Abstractions/TaskOrchestrationContext.cs

@@ -58,6 +58,11 @@ public abstract class TaskOrchestrationContext
     /// </value>
     public abstract bool IsReplaying { get; }
 
+    /// <summary>
+    /// Gets the logger factory for this context.
+    /// </summary>
+    protected abstract ILoggerFactory LoggerFactory { get; }
+
     /// <summary>
     /// Gets the deserialized input of the orchestrator.
     /// </summary>
@@ -364,18 +369,20 @@ public Task CallSubOrchestratorAsync(
     /// Returns an instance of <see cref="ILogger"/> that is replay-safe, meaning that the logger only
     /// writes logs when the orchestrator is not replaying previous history.
     /// </summary>
-    /// <remarks>
-    /// This method wraps the provider <paramref name="logger"/> instance with a new <see cref="ILogger"/>
-    /// implementation that only writes log messages when <see cref="IsReplaying"/> is <c>false</c>.
-    /// The resulting logger can be used normally in orchestrator code without needing to worry about duplicate
-    /// log messages caused by orchestrator replays.
-    /// </remarks>
-    /// <param name="logger">The <see cref="ILogger"/> to be wrapped for use by the orchestration.</param>
-    /// <returns>An instance of <see cref="ILogger"/> that wraps the specified <paramref name="logger"/>.</returns>
-    public ILogger CreateReplaySafeLogger(ILogger logger)
-    {
-        return new ReplaySafeLogger(this, logger);
-    }
+    /// <param name="categoryName">The logger's category name.</param>
+    /// <returns>An instance of <see cref="ILogger"/> that is replay-safe.</returns>
+    public ILogger CreateReplaySafeLogger(string categoryName)
+        => new ReplaySafeLogger(this, this.LoggerFactory.CreateLogger(categoryName));
+
+    /// <inheritdoc cref="CreateReplaySafeLogger(string)" />
+    /// <param name="type">The type to derive the category name from.</param>
+    public virtual ILogger CreateReplaySafeLogger(Type type)
+        => new ReplaySafeLogger(this, this.LoggerFactory.CreateLogger(type));
+
+    /// <inheritdoc cref="CreateReplaySafeLogger(string)" />
+    /// <typeparam name="T">The type to derive category name from.</typeparam>
+    public virtual ILogger CreateReplaySafeLogger<T>()
+        => new ReplaySafeLogger(this, this.LoggerFactory.CreateLogger<T>());
 
     class ReplaySafeLogger : ILogger
     {

src/Abstractions/TaskOrchestrator.cs

@@ -81,9 +81,9 @@ public interface ITaskOrchestrator
 ///       input.
 ///     </item>
 ///     <item>
-///       Avoid logging directly in the orchestrator code because log messages will be duplicated on each replay.
-///       Instead, use the <see cref="TaskOrchestrationContext.CreateReplaySafeLogger"/> method to wrap an existing
-///       <see cref="ILogger"/> into a new <c>ILogger</c> that automatically filters out replay logs.
+///       When logging, ensure you use only loggers created from
+///       <see cref="TaskOrchestrationContext.CreateReplaySafeLogger(string)"/> or other overloads, as this will ensure
+///       logging is not duplicated on each replay.
 ///     </item>
 ///   </list>
 /// </para>

src/Worker/Core/Shims/TaskOrchestrationContextWrapper.cs

@@ -31,17 +31,15 @@ sealed partial class TaskOrchestrationContextWrapper : TaskOrchestrationContext
     /// </summary>
     /// <param name="innerContext">The inner orchestration context.</param>
     /// <param name="invocationContext">The invocation context.</param>
-    /// <param name="logger">The logger.</param>
     /// <param name="deserializedInput">The deserialized input.</param>
     public TaskOrchestrationContextWrapper(
         OrchestrationContext innerContext,
         OrchestrationInvocationContext invocationContext,
-        ILogger logger,
         object? deserializedInput)
     {
         this.innerContext = Check.NotNull(innerContext);
         this.invocationContext = Check.NotNull(invocationContext);
-        this.logger = this.CreateReplaySafeLogger(Check.NotNull(logger));
+        this.logger = this.CreateReplaySafeLogger("Microsoft.DurableTask");
         this.deserializedInput = deserializedInput;
     }
 
@@ -60,9 +58,10 @@ public TaskOrchestrationContextWrapper(
     /// <inheritdoc/>
     public override DateTime CurrentUtcDateTime => this.innerContext.CurrentUtcDateTime;
 
-    DataConverter DataConverter => this.invocationContext.Options.DataConverter;
+    /// <inheritdoc/>
+    protected override ILoggerFactory LoggerFactory => this.invocationContext.LoggerFactory;
 
-    ILoggerFactory LoggerFactory => this.invocationContext.LoggerFactory;
+    DataConverter DataConverter => this.invocationContext.Options.DataConverter;
 
     /// <inheritdoc/>
     public override T GetInput<T>() => (T)this.deserializedInput!;

src/Worker/Core/Shims/TaskOrchestrationShim.cs

@@ -45,8 +45,7 @@ public TaskOrchestrationShim(
         innerContext.ErrorDataConverter = converterShim;
 
         object? input = this.DataConverter.Deserialize(rawInput, this.implementation.InputType);
-        ILogger contextLogger = this.LoggerFactory.CreateLogger("Microsoft.DurableTask");
-        this.wrapperContext = new(innerContext, this.invocationContext, contextLogger, input);
+        this.wrapperContext = new(innerContext, this.invocationContext, input);
         object? output = await this.implementation.RunAsync(this.wrapperContext, input);
 
         // Return the output (if any) as a serialized string.