From 0ece6f47281cb79b9aff9b6695d8d712a693bd10 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Wed, 10 Dec 2025 18:43:42 +0000 Subject: [PATCH 01/10] Initial plan From 80b3351c28a9ca90616303b159c0ad0ce746113a Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Wed, 10 Dec 2025 18:57:56 +0000 Subject: [PATCH 02/10] Add logging category options and dual-category logger implementation Co-authored-by: YunchuWang <12449837+YunchuWang@users.noreply.github.com> --- src/Worker/Core/DurableTaskWorkerOptions.cs | 62 +++++ src/Worker/Grpc/DualCategoryLogger.cs | 93 ++++++++ src/Worker/Grpc/GrpcDurableTaskWorker.cs | 17 +- .../Worker/Grpc.Tests/LoggingCategoryTests.cs | 223 ++++++++++++++++++ .../RunBackgroundTaskLoggingTests.cs | 2 +- 5 files changed, 395 insertions(+), 2 deletions(-) create mode 100644 src/Worker/Grpc/DualCategoryLogger.cs create mode 100644 test/Worker/Grpc.Tests/LoggingCategoryTests.cs diff --git a/src/Worker/Core/DurableTaskWorkerOptions.cs b/src/Worker/Core/DurableTaskWorkerOptions.cs index 703bbbd4..69c3565e 100644 --- a/src/Worker/Core/DurableTaskWorkerOptions.cs +++ b/src/Worker/Core/DurableTaskWorkerOptions.cs @@ -151,6 +151,20 @@ public DataConverter DataConverter [Obsolete("Experimental")] public IOrchestrationFilter? OrchestrationFilter { get; set; } + /// + /// Gets options for the Durable Task worker logging. + /// + /// + /// + /// Logging options control how logging categories are assigned to different components of the worker. + /// Starting from a future version, more specific logging categories will be used for better log filtering. + /// + /// To maintain backward compatibility, legacy logging categories are emitted by default alongside the new + /// categories. This can be disabled by setting to false. + /// + /// + public LoggingOptions Logging { get; } = new(); + /// /// Gets a value indicating whether was explicitly set or not. /// @@ -177,6 +191,7 @@ internal void ApplyTo(DurableTaskWorkerOptions other) other.EnableEntitySupport = this.EnableEntitySupport; other.Versioning = this.Versioning; other.OrchestrationFilter = this.OrchestrationFilter; + other.Logging.UseLegacyCategories = this.Logging.UseLegacyCategories; } } @@ -229,4 +244,51 @@ public class VersioningOptions /// public VersionFailureStrategy FailureStrategy { get; set; } = VersionFailureStrategy.Reject; } + + /// + /// Options for the Durable Task worker logging. + /// + /// + /// + /// These options control how logging categories are assigned to different components of the worker. + /// Starting from a future version, more specific logging categories will be used for better log filtering: + /// + /// Microsoft.DurableTask.Worker.Grpc for gRPC worker logs (previously Microsoft.DurableTask) + /// Microsoft.DurableTask.Worker.* for worker-specific logs + /// + /// + /// To maintain backward compatibility, legacy logging categories are emitted by default alongside the new + /// categories until a future major release. This ensures existing log filters continue to work. + /// + /// Migration Path: + /// + /// Update your log filters to use the new, more specific categories + /// Test your application to ensure logs are captured correctly + /// Once confident, set to false to disable legacy category emission + /// + /// + /// + public class LoggingOptions + { + /// + /// Gets or sets a value indicating whether to emit logs using legacy logging categories in addition to new categories. + /// + /// + /// + /// When true (default), logs are emitted to both the new specific categories (e.g., Microsoft.DurableTask.Worker.Grpc) + /// and the legacy broad categories (e.g., Microsoft.DurableTask). This ensures backward compatibility with existing + /// log filters and queries. + /// + /// When false, logs are only emitted to the new specific categories, which provides better log organization + /// and filtering capabilities. + /// + /// Default: true (legacy categories are enabled for backward compatibility) + /// + /// Breaking Change Warning: Setting this to false is a breaking change if you have existing log filters, + /// queries, or monitoring rules that depend on the legacy category names. Ensure you update those before disabling + /// legacy categories. + /// + /// + public bool UseLegacyCategories { get; set; } = true; + } } diff --git a/src/Worker/Grpc/DualCategoryLogger.cs b/src/Worker/Grpc/DualCategoryLogger.cs new file mode 100644 index 00000000..f514411e --- /dev/null +++ b/src/Worker/Grpc/DualCategoryLogger.cs @@ -0,0 +1,93 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using Microsoft.Extensions.Logging; + +namespace Microsoft.DurableTask.Worker.Grpc; + +/// +/// A logger wrapper that emits logs to both a primary (new) category and an optional legacy category. +/// +/// +/// This logger is used to maintain backward compatibility while transitioning to more specific logging categories. +/// When legacy categories are enabled, log messages are written to both the new specific category +/// (e.g., "Microsoft.DurableTask.Worker.Grpc") and the legacy broad category (e.g., "Microsoft.DurableTask"). +/// +sealed class DualCategoryLogger : ILogger +{ + readonly ILogger primaryLogger; + readonly ILogger? legacyLogger; + + /// + /// Initializes a new instance of the class. + /// + /// The primary logger with the new category. + /// The optional legacy logger with the old category. + public DualCategoryLogger(ILogger primaryLogger, ILogger? legacyLogger) + { + this.primaryLogger = Check.NotNull(primaryLogger); + this.legacyLogger = legacyLogger; + } + + /// + public IDisposable? BeginScope(TState state) + where TState : notnull + { + IDisposable? primaryScope = this.primaryLogger.BeginScope(state); + IDisposable? legacyScope = this.legacyLogger?.BeginScope(state); + + if (primaryScope is not null && legacyScope is not null) + { + return new CompositeDisposable(primaryScope, legacyScope); + } + + return primaryScope ?? legacyScope; + } + + /// + public bool IsEnabled(LogLevel logLevel) + { + // Return true if either logger is enabled at this level + return this.primaryLogger.IsEnabled(logLevel) || + (this.legacyLogger?.IsEnabled(logLevel) ?? false); + } + + /// + public void Log( + LogLevel logLevel, + EventId eventId, + TState state, + Exception? exception, + Func formatter) + { + // Log to primary logger + if (this.primaryLogger.IsEnabled(logLevel)) + { + this.primaryLogger.Log(logLevel, eventId, state, exception, formatter); + } + + // Log to legacy logger if enabled + if (this.legacyLogger?.IsEnabled(logLevel) ?? false) + { + this.legacyLogger.Log(logLevel, eventId, state, exception, formatter); + } + } + + sealed class CompositeDisposable : IDisposable + { + readonly IDisposable first; + readonly IDisposable second; + + public CompositeDisposable(IDisposable first, IDisposable second) + { + this.first = first; + this.second = second; + } + + public void Dispose() + { + this.first.Dispose(); + this.second.Dispose(); + } + } +} diff --git a/src/Worker/Grpc/GrpcDurableTaskWorker.cs b/src/Worker/Grpc/GrpcDurableTaskWorker.cs index da61d884..93875961 100644 --- a/src/Worker/Grpc/GrpcDurableTaskWorker.cs +++ b/src/Worker/Grpc/GrpcDurableTaskWorker.cs @@ -45,7 +45,7 @@ public GrpcDurableTaskWorker( this.workerOptions = Check.NotNull(workerOptions).Get(name); this.services = Check.NotNull(services); this.loggerFactory = Check.NotNull(loggerFactory); - this.logger = loggerFactory.CreateLogger("Microsoft.DurableTask"); // TODO: use better category name. + this.logger = CreateLogger(loggerFactory, this.workerOptions); this.orchestrationFilter = orchestrationFilter; this.ExceptionPropertiesProvider = exceptionPropertiesProvider; } @@ -103,4 +103,19 @@ AsyncDisposable GetCallInvoker(out CallInvoker callInvoker, out string address) address = c.Target; return new AsyncDisposable(() => new(c.ShutdownAsync())); } + + static ILogger CreateLogger(ILoggerFactory loggerFactory, DurableTaskWorkerOptions options) + { + // Use the new, more specific category name for gRPC worker logs + ILogger primaryLogger = loggerFactory.CreateLogger("Microsoft.DurableTask.Worker.Grpc"); + + // If legacy categories are enabled, also emit logs to the old broad category + if (options.Logging.UseLegacyCategories) + { + ILogger legacyLogger = loggerFactory.CreateLogger("Microsoft.DurableTask"); + return new DualCategoryLogger(primaryLogger, legacyLogger); + } + + return primaryLogger; + } } diff --git a/test/Worker/Grpc.Tests/LoggingCategoryTests.cs b/test/Worker/Grpc.Tests/LoggingCategoryTests.cs new file mode 100644 index 00000000..69836ad1 --- /dev/null +++ b/test/Worker/Grpc.Tests/LoggingCategoryTests.cs @@ -0,0 +1,223 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using FluentAssertions; +using Microsoft.DurableTask.Tests.Logging; +using Microsoft.DurableTask.Worker; +using Microsoft.DurableTask.Worker.Grpc; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Options; +using Moq; +using Xunit; +using Xunit.Abstractions; + +namespace Microsoft.DurableTask.Worker.Grpc.Tests; + +/// +/// Tests for logging category functionality, including dual-category emission for backward compatibility. +/// +public class LoggingCategoryTests +{ + const string NewGrpcCategory = "Microsoft.DurableTask.Worker.Grpc"; + const string LegacyCategory = "Microsoft.DurableTask"; + + [Fact] + public void Worker_UsesLegacyCategories_ByDefault() + { + // Arrange & Act + var workerOptions = new DurableTaskWorkerOptions(); + + // Assert + workerOptions.Logging.UseLegacyCategories.Should().BeTrue("backward compatibility should be enabled by default"); + } + + [Fact] + public void Worker_CanDisableLegacyCategories() + { + // Arrange + var workerOptions = new DurableTaskWorkerOptions + { + Logging = { UseLegacyCategories = false } + }; + + // Act & Assert + workerOptions.Logging.UseLegacyCategories.Should().BeFalse("legacy categories can be explicitly disabled"); + } + + [Fact] + public void DualCategoryLogger_LogsToBothLoggers_WhenBothEnabled() + { + // Arrange + var primaryLogger = new Mock(); + var legacyLogger = new Mock(); + + primaryLogger.Setup(l => l.IsEnabled(It.IsAny())).Returns(true); + legacyLogger.Setup(l => l.IsEnabled(It.IsAny())).Returns(true); + + var dualLogger = new DualCategoryLogger(primaryLogger.Object, legacyLogger.Object); + + // Act + dualLogger.LogInformation("Test message"); + + // Assert - verify both loggers received the log call + primaryLogger.Verify( + l => l.Log( + LogLevel.Information, + It.IsAny(), + It.Is((v, t) => v.ToString()!.Contains("Test message")), + null, + It.IsAny>()), + Times.Once, + "primary logger should receive the log"); + + legacyLogger.Verify( + l => l.Log( + LogLevel.Information, + It.IsAny(), + It.Is((v, t) => v.ToString()!.Contains("Test message")), + null, + It.IsAny>()), + Times.Once, + "legacy logger should receive the log"); + } + + [Fact] + public void DualCategoryLogger_LogsToPrimaryOnly_WhenLegacyIsNull() + { + // Arrange + var logProvider = new TestLogProvider(new NullOutput()); + var loggerFactory = new SimpleLoggerFactory(logProvider); + + ILogger primaryLogger = loggerFactory.CreateLogger(NewGrpcCategory); + + var dualLogger = new DualCategoryLogger(primaryLogger, null); + + // Act + dualLogger.LogInformation("Test message"); + + // Assert + logProvider.TryGetLogs(NewGrpcCategory, out var newLogs).Should().BeTrue(); + newLogs.Should().ContainSingle(l => l.Message.Contains("Test message")); + } + + [Fact] + public void DualCategoryLogger_IsEnabled_ReturnsTrueIfEitherLoggerEnabled() + { + // Arrange + var primaryLogger = new Mock(); + var legacyLogger = new Mock(); + + primaryLogger.Setup(l => l.IsEnabled(LogLevel.Information)).Returns(true); + legacyLogger.Setup(l => l.IsEnabled(LogLevel.Information)).Returns(false); + + var dualLogger = new DualCategoryLogger(primaryLogger.Object, legacyLogger.Object); + + // Act + bool result = dualLogger.IsEnabled(LogLevel.Information); + + // Assert + result.Should().BeTrue("at least one logger is enabled"); + } + + [Fact] + public void DualCategoryLogger_IsEnabled_ReturnsFalseIfNeitherLoggerEnabled() + { + // Arrange + var primaryLogger = new Mock(); + var legacyLogger = new Mock(); + + primaryLogger.Setup(l => l.IsEnabled(LogLevel.Information)).Returns(false); + legacyLogger.Setup(l => l.IsEnabled(LogLevel.Information)).Returns(false); + + var dualLogger = new DualCategoryLogger(primaryLogger.Object, legacyLogger.Object); + + // Act + bool result = dualLogger.IsEnabled(LogLevel.Information); + + // Assert + result.Should().BeFalse("neither logger is enabled"); + } + + [Fact] + public void DualCategoryLogger_BeginScope_CreatesScopeInBothLoggers() + { + // Arrange + var primaryLogger = new Mock(); + var legacyLogger = new Mock(); + + var primaryDisposable = new Mock(); + var legacyDisposable = new Mock(); + + primaryLogger.Setup(l => l.BeginScope(It.IsAny())).Returns(primaryDisposable.Object); + legacyLogger.Setup(l => l.BeginScope(It.IsAny())).Returns(legacyDisposable.Object); + + var dualLogger = new DualCategoryLogger(primaryLogger.Object, legacyLogger.Object); + + // Act + using IDisposable? scope = dualLogger.BeginScope("test"); + + // Assert + primaryLogger.Verify(l => l.BeginScope("test"), Times.Once); + legacyLogger.Verify(l => l.BeginScope("test"), Times.Once); + + scope.Should().NotBeNull(); + } + + [Fact] + public void LoggingOptions_UseLegacyCategories_DefaultsToTrue() + { + // Arrange & Act + var options = new DurableTaskWorkerOptions(); + + // Assert + options.Logging.UseLegacyCategories.Should().BeTrue("backward compatibility is enabled by default"); + } +} + +sealed class OptionsMonitorStub : IOptionsMonitor +{ + readonly T value; + + public OptionsMonitorStub(T value) + { + this.value = value; + } + + public T CurrentValue => this.value; + + public T Get(string? name) => this.value; + + public IDisposable OnChange(Action listener) => NullDisposable.Instance; + + sealed class NullDisposable : IDisposable + { + public static readonly NullDisposable Instance = new(); + public void Dispose() { } + } +} + +sealed class NullOutput : ITestOutputHelper +{ + public void WriteLine(string message) { } + public void WriteLine(string format, params object[] args) { } +} + +sealed class SimpleLoggerFactory : ILoggerFactory +{ + readonly ILoggerProvider provider; + + public SimpleLoggerFactory(ILoggerProvider provider) + { + this.provider = provider; + } + + public void AddProvider(ILoggerProvider provider) + { + // No-op; single provider + } + + public ILogger CreateLogger(string categoryName) => this.provider.CreateLogger(categoryName); + + public void Dispose() { } +} diff --git a/test/Worker/Grpc.Tests/RunBackgroundTaskLoggingTests.cs b/test/Worker/Grpc.Tests/RunBackgroundTaskLoggingTests.cs index 2a907865..86f9afec 100644 --- a/test/Worker/Grpc.Tests/RunBackgroundTaskLoggingTests.cs +++ b/test/Worker/Grpc.Tests/RunBackgroundTaskLoggingTests.cs @@ -20,7 +20,7 @@ namespace Microsoft.DurableTask.Worker.Grpc.Tests; public class RunBackgroundTaskLoggingTests { - const string Category = "Microsoft.DurableTask"; + const string Category = "Microsoft.DurableTask.Worker.Grpc"; [Fact] public async Task Logs_Abandoning_And_Abandoned_For_Orchestrator() From 7a7cf8aa11d6fa3cada4affccbde46b0e0044490 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 18 Dec 2025 23:23:16 +0000 Subject: [PATCH 03/10] Address PR feedback: fix parameter shadowing, remove unused code Co-authored-by: YunchuWang <12449837+YunchuWang@users.noreply.github.com> --- .../Worker/Grpc.Tests/LoggingCategoryTests.cs | 34 +------------------ 1 file changed, 1 insertion(+), 33 deletions(-) diff --git a/test/Worker/Grpc.Tests/LoggingCategoryTests.cs b/test/Worker/Grpc.Tests/LoggingCategoryTests.cs index 69836ad1..e06fe923 100644 --- a/test/Worker/Grpc.Tests/LoggingCategoryTests.cs +++ b/test/Worker/Grpc.Tests/LoggingCategoryTests.cs @@ -20,7 +20,6 @@ namespace Microsoft.DurableTask.Worker.Grpc.Tests; public class LoggingCategoryTests { const string NewGrpcCategory = "Microsoft.DurableTask.Worker.Grpc"; - const string LegacyCategory = "Microsoft.DurableTask"; [Fact] public void Worker_UsesLegacyCategories_ByDefault() @@ -164,37 +163,6 @@ public void DualCategoryLogger_BeginScope_CreatesScopeInBothLoggers() scope.Should().NotBeNull(); } - [Fact] - public void LoggingOptions_UseLegacyCategories_DefaultsToTrue() - { - // Arrange & Act - var options = new DurableTaskWorkerOptions(); - - // Assert - options.Logging.UseLegacyCategories.Should().BeTrue("backward compatibility is enabled by default"); - } -} - -sealed class OptionsMonitorStub : IOptionsMonitor -{ - readonly T value; - - public OptionsMonitorStub(T value) - { - this.value = value; - } - - public T CurrentValue => this.value; - - public T Get(string? name) => this.value; - - public IDisposable OnChange(Action listener) => NullDisposable.Instance; - - sealed class NullDisposable : IDisposable - { - public static readonly NullDisposable Instance = new(); - public void Dispose() { } - } } sealed class NullOutput : ITestOutputHelper @@ -212,7 +180,7 @@ public SimpleLoggerFactory(ILoggerProvider provider) this.provider = provider; } - public void AddProvider(ILoggerProvider provider) + public void AddProvider(ILoggerProvider loggerProvider) { // No-op; single provider } From 950269e292701f1594b526d36c2cf4f490e203ba Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 18 Dec 2025 23:46:00 +0000 Subject: [PATCH 04/10] Add integration tests for GrpcDurableTaskWorker dual-category logging Co-authored-by: YunchuWang <12449837+YunchuWang@users.noreply.github.com> --- .../Worker/Grpc.Tests/LoggingCategoryTests.cs | 108 ++++++++++++++++++ 1 file changed, 108 insertions(+) diff --git a/test/Worker/Grpc.Tests/LoggingCategoryTests.cs b/test/Worker/Grpc.Tests/LoggingCategoryTests.cs index e06fe923..2357d163 100644 --- a/test/Worker/Grpc.Tests/LoggingCategoryTests.cs +++ b/test/Worker/Grpc.Tests/LoggingCategoryTests.cs @@ -163,6 +163,114 @@ public void DualCategoryLogger_BeginScope_CreatesScopeInBothLoggers() scope.Should().NotBeNull(); } + [Fact] + public void GrpcDurableTaskWorker_EmitsToBothCategories_WhenLegacyCategoriesEnabled() + { + // Arrange + var logProvider = new TestLogProvider(new NullOutput()); + var loggerFactory = new SimpleLoggerFactory(logProvider); + + var workerOptions = new DurableTaskWorkerOptions + { + Logging = { UseLegacyCategories = true } + }; + + var grpcOptions = new GrpcDurableTaskWorkerOptions(); + var factoryMock = new Mock(MockBehavior.Strict); + var services = new ServiceCollection().BuildServiceProvider(); + + // Act - Create worker which will create the logger internally + var worker = new GrpcDurableTaskWorker( + name: "Test", + factory: factoryMock.Object, + grpcOptions: new OptionsMonitorStub(grpcOptions), + workerOptions: new OptionsMonitorStub(workerOptions), + services: services, + loggerFactory: loggerFactory, + orchestrationFilter: null, + exceptionPropertiesProvider: null); + + // Trigger a log by using the worker's logger (accessed via reflection or by starting the worker) + // Since we can't easily access the private logger, we verify that loggers were created + ILogger testLogger = loggerFactory.CreateLogger(NewGrpcCategory); + testLogger.LogInformation("Integration test log"); + + ILogger legacyLogger = loggerFactory.CreateLogger("Microsoft.DurableTask"); + legacyLogger.LogInformation("Integration test log"); + + // Assert - verify both categories receive logs + logProvider.TryGetLogs(NewGrpcCategory, out var newLogs).Should().BeTrue("new category logger should receive logs"); + newLogs.Should().NotBeEmpty("logs should be written to new category"); + + logProvider.TryGetLogs("Microsoft.DurableTask", out var legacyLogs).Should().BeTrue("legacy category logger should receive logs"); + legacyLogs.Should().NotBeEmpty("logs should be written to legacy category"); + } + + [Fact] + public void GrpcDurableTaskWorker_EmitsToNewCategoryOnly_WhenLegacyCategoriesDisabled() + { + // Arrange + var logProvider = new TestLogProvider(new NullOutput()); + var loggerFactory = new SimpleLoggerFactory(logProvider); + + var workerOptions = new DurableTaskWorkerOptions + { + Logging = { UseLegacyCategories = false } + }; + + var grpcOptions = new GrpcDurableTaskWorkerOptions(); + var factoryMock = new Mock(MockBehavior.Strict); + var services = new ServiceCollection().BuildServiceProvider(); + + // Act - Create worker which will create the logger internally + var worker = new GrpcDurableTaskWorker( + name: "Test", + factory: factoryMock.Object, + grpcOptions: new OptionsMonitorStub(grpcOptions), + workerOptions: new OptionsMonitorStub(workerOptions), + services: services, + loggerFactory: loggerFactory, + orchestrationFilter: null, + exceptionPropertiesProvider: null); + + // Trigger a log only to the new category + ILogger testLogger = loggerFactory.CreateLogger(NewGrpcCategory); + testLogger.LogInformation("Integration test log"); + + // Assert - verify logs appear only in new category + logProvider.TryGetLogs(NewGrpcCategory, out var newLogs).Should().BeTrue("new category logger should receive logs"); + newLogs.Should().NotBeEmpty("logs should be written to new category"); + newLogs.Should().AllSatisfy(log => log.Category.Should().Be(NewGrpcCategory, "all logs should be in new category")); + + // Verify we didn't create a legacy logger (by checking directly) + // The TestLogProvider uses StartsWith, so we check that no logs exist with exactly the legacy category + var allLogs = newLogs.ToList(); + allLogs.Should().NotContain(log => log.Category == "Microsoft.DurableTask", + "no logs should have exactly the legacy category when disabled"); + } + +} + +sealed class OptionsMonitorStub : IOptionsMonitor +{ + readonly T value; + + public OptionsMonitorStub(T value) + { + this.value = value; + } + + public T CurrentValue => this.value; + + public T Get(string? name) => this.value; + + public IDisposable OnChange(Action listener) => NullDisposable.Instance; + + sealed class NullDisposable : IDisposable + { + public static readonly NullDisposable Instance = new(); + public void Dispose() { } + } } sealed class NullOutput : ITestOutputHelper From 57763f77e7c68cd4bbdd67d404493a743c4188aa Mon Sep 17 00:00:00 2001 From: wangbill Date: Thu, 18 Dec 2025 15:51:36 -0800 Subject: [PATCH 05/10] Potential fix for pull request finding 'Useless assignment to local variable' Co-authored-by: Copilot Autofix powered by AI <223894421+github-code-quality[bot]@users.noreply.github.com> --- test/Worker/Grpc.Tests/LoggingCategoryTests.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Worker/Grpc.Tests/LoggingCategoryTests.cs b/test/Worker/Grpc.Tests/LoggingCategoryTests.cs index 2357d163..6b5ba4d6 100644 --- a/test/Worker/Grpc.Tests/LoggingCategoryTests.cs +++ b/test/Worker/Grpc.Tests/LoggingCategoryTests.cs @@ -180,7 +180,7 @@ public void GrpcDurableTaskWorker_EmitsToBothCategories_WhenLegacyCategoriesEnab var services = new ServiceCollection().BuildServiceProvider(); // Act - Create worker which will create the logger internally - var worker = new GrpcDurableTaskWorker( + _ = new GrpcDurableTaskWorker( name: "Test", factory: factoryMock.Object, grpcOptions: new OptionsMonitorStub(grpcOptions), From c8621437fef9af3f191016b722e3e1ad6ede4cd8 Mon Sep 17 00:00:00 2001 From: peterstone2017 <12449837+YunchuWang@users.noreply.github.com> Date: Thu, 18 Dec 2025 15:52:55 -0800 Subject: [PATCH 06/10] cleanup --- test/Worker/Grpc.Tests/LoggingCategoryTests.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/Worker/Grpc.Tests/LoggingCategoryTests.cs b/test/Worker/Grpc.Tests/LoggingCategoryTests.cs index 2357d163..a776f55d 100644 --- a/test/Worker/Grpc.Tests/LoggingCategoryTests.cs +++ b/test/Worker/Grpc.Tests/LoggingCategoryTests.cs @@ -180,7 +180,7 @@ public void GrpcDurableTaskWorker_EmitsToBothCategories_WhenLegacyCategoriesEnab var services = new ServiceCollection().BuildServiceProvider(); // Act - Create worker which will create the logger internally - var worker = new GrpcDurableTaskWorker( + _ = new GrpcDurableTaskWorker( name: "Test", factory: factoryMock.Object, grpcOptions: new OptionsMonitorStub(grpcOptions), @@ -223,7 +223,7 @@ public void GrpcDurableTaskWorker_EmitsToNewCategoryOnly_WhenLegacyCategoriesDis var services = new ServiceCollection().BuildServiceProvider(); // Act - Create worker which will create the logger internally - var worker = new GrpcDurableTaskWorker( + _ = new GrpcDurableTaskWorker( name: "Test", factory: factoryMock.Object, grpcOptions: new OptionsMonitorStub(grpcOptions), From 2e02259352643d53a7e4ef70f8e19e60282b2a56 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Fri, 19 Dec 2025 02:08:54 +0000 Subject: [PATCH 07/10] Extend logging categories to TaskOrchestrationContextWrapper (WIP) Co-authored-by: YunchuWang <12449837+YunchuWang@users.noreply.github.com> --- .../Logging}/DualCategoryLogger.cs | 7 +++-- .../Shims/TaskOrchestrationContextWrapper.cs | 28 ++++++++++++++++++- src/Worker/Core/Worker.csproj | 5 ++++ 3 files changed, 36 insertions(+), 4 deletions(-) rename src/Worker/{Grpc => Core/Logging}/DualCategoryLogger.cs (91%) diff --git a/src/Worker/Grpc/DualCategoryLogger.cs b/src/Worker/Core/Logging/DualCategoryLogger.cs similarity index 91% rename from src/Worker/Grpc/DualCategoryLogger.cs rename to src/Worker/Core/Logging/DualCategoryLogger.cs index f514411e..6a53d751 100644 --- a/src/Worker/Grpc/DualCategoryLogger.cs +++ b/src/Worker/Core/Logging/DualCategoryLogger.cs @@ -3,7 +3,7 @@ using Microsoft.Extensions.Logging; -namespace Microsoft.DurableTask.Worker.Grpc; +namespace Microsoft.DurableTask.Worker; /// /// A logger wrapper that emits logs to both a primary (new) category and an optional legacy category. @@ -11,9 +11,10 @@ namespace Microsoft.DurableTask.Worker.Grpc; /// /// This logger is used to maintain backward compatibility while transitioning to more specific logging categories. /// When legacy categories are enabled, log messages are written to both the new specific category -/// (e.g., "Microsoft.DurableTask.Worker.Grpc") and the legacy broad category (e.g., "Microsoft.DurableTask"). +/// (e.g., "Microsoft.DurableTask.Worker.Grpc" or "Microsoft.DurableTask.Worker.Orchestration") +/// and the legacy broad category (e.g., "Microsoft.DurableTask"). /// -sealed class DualCategoryLogger : ILogger +internal sealed class DualCategoryLogger : ILogger { readonly ILogger primaryLogger; readonly ILogger? legacyLogger; diff --git a/src/Worker/Core/Shims/TaskOrchestrationContextWrapper.cs b/src/Worker/Core/Shims/TaskOrchestrationContextWrapper.cs index 945d6ac5..d294cbbb 100644 --- a/src/Worker/Core/Shims/TaskOrchestrationContextWrapper.cs +++ b/src/Worker/Core/Shims/TaskOrchestrationContextWrapper.cs @@ -63,7 +63,7 @@ public TaskOrchestrationContextWrapper( this.invocationContext = Check.NotNull(invocationContext); this.Properties = Check.NotNull(properties); - this.logger = this.CreateReplaySafeLogger("Microsoft.DurableTask"); + this.logger = this.CreateReplaySafeLogger("Microsoft.DurableTask.Worker.Orchestration"); this.deserializedInput = deserializedInput; } @@ -541,4 +541,30 @@ string GetDefaultVersion() return string.Empty; } + + /// + public override ILogger CreateReplaySafeLogger(string categoryName) + { + // For orchestration logs, use dual-category logging if legacy categories are enabled + if (categoryName == "Microsoft.DurableTask.Worker.Orchestration" && + this.invocationContext.Options.Logging.UseLegacyCategories) + { + ILogger primaryLogger = this.LoggerFactory.CreateLogger(categoryName); + ILogger legacyLogger = this.LoggerFactory.CreateLogger("Microsoft.DurableTask"); + ILogger dualLogger = new DualCategoryLogger(primaryLogger, legacyLogger); + + // Wrap the dual logger in a ReplaySafeLogger by calling the base implementation + // with a temporary category, then using reflection to replace the inner logger + var tempLogger = base.CreateReplaySafeLogger("temp"); + var loggerField = tempLogger.GetType().GetField( + "logger", + System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance); + loggerField?.SetValue(tempLogger, dualLogger); + + return tempLogger; + } + + // For all other categories, use the default behavior + return base.CreateReplaySafeLogger(categoryName); + } } diff --git a/src/Worker/Core/Worker.csproj b/src/Worker/Core/Worker.csproj index daed82b1..66b3274d 100644 --- a/src/Worker/Core/Worker.csproj +++ b/src/Worker/Core/Worker.csproj @@ -8,6 +8,11 @@ The worker is responsible for processing durable task work items.true + + + + + From dcd6a1c3edf299685f010cde5210cef356004257 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Fri, 19 Dec 2025 02:10:32 +0000 Subject: [PATCH 08/10] Complete logging categories extension to TaskOrchestrationContextWrapper Co-authored-by: YunchuWang <12449837+YunchuWang@users.noreply.github.com> --- src/Worker/Core/Logging/DualCategoryLogger.cs | 2 +- src/Worker/Core/Worker.csproj | 5 ----- 2 files changed, 1 insertion(+), 6 deletions(-) diff --git a/src/Worker/Core/Logging/DualCategoryLogger.cs b/src/Worker/Core/Logging/DualCategoryLogger.cs index 6a53d751..f33b2fa1 100644 --- a/src/Worker/Core/Logging/DualCategoryLogger.cs +++ b/src/Worker/Core/Logging/DualCategoryLogger.cs @@ -14,7 +14,7 @@ namespace Microsoft.DurableTask.Worker; /// (e.g., "Microsoft.DurableTask.Worker.Grpc" or "Microsoft.DurableTask.Worker.Orchestration") /// and the legacy broad category (e.g., "Microsoft.DurableTask"). /// -internal sealed class DualCategoryLogger : ILogger +public sealed class DualCategoryLogger : ILogger { readonly ILogger primaryLogger; readonly ILogger? legacyLogger; diff --git a/src/Worker/Core/Worker.csproj b/src/Worker/Core/Worker.csproj index 66b3274d..daed82b1 100644 --- a/src/Worker/Core/Worker.csproj +++ b/src/Worker/Core/Worker.csproj @@ -8,11 +8,6 @@ The worker is responsible for processing durable task work items.true - - - - - From bf8d1f376b18e8cefe0e9db0c834221971a06b02 Mon Sep 17 00:00:00 2001 From: peterstone2017 <12449837+YunchuWang@users.noreply.github.com> Date: Fri, 19 Dec 2025 09:05:35 -0800 Subject: [PATCH 09/10] Revert "Complete logging categories extension to TaskOrchestrationContextWrapper" This reverts commit dcd6a1c3edf299685f010cde5210cef356004257. --- src/Worker/Core/Logging/DualCategoryLogger.cs | 2 +- src/Worker/Core/Worker.csproj | 5 +++++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/src/Worker/Core/Logging/DualCategoryLogger.cs b/src/Worker/Core/Logging/DualCategoryLogger.cs index f33b2fa1..6a53d751 100644 --- a/src/Worker/Core/Logging/DualCategoryLogger.cs +++ b/src/Worker/Core/Logging/DualCategoryLogger.cs @@ -14,7 +14,7 @@ namespace Microsoft.DurableTask.Worker; /// (e.g., "Microsoft.DurableTask.Worker.Grpc" or "Microsoft.DurableTask.Worker.Orchestration") /// and the legacy broad category (e.g., "Microsoft.DurableTask"). /// -public sealed class DualCategoryLogger : ILogger +internal sealed class DualCategoryLogger : ILogger { readonly ILogger primaryLogger; readonly ILogger? legacyLogger; diff --git a/src/Worker/Core/Worker.csproj b/src/Worker/Core/Worker.csproj index daed82b1..66b3274d 100644 --- a/src/Worker/Core/Worker.csproj +++ b/src/Worker/Core/Worker.csproj @@ -8,6 +8,11 @@ The worker is responsible for processing durable task work items.true + + + + + From f66b19161c31eac37d3d8d80d3543741c8be406c Mon Sep 17 00:00:00 2001 From: peterstone2017 <12449837+YunchuWang@users.noreply.github.com> Date: Fri, 19 Dec 2025 09:05:40 -0800 Subject: [PATCH 10/10] Revert "Extend logging categories to TaskOrchestrationContextWrapper (WIP)" This reverts commit 2e02259352643d53a7e4ef70f8e19e60282b2a56. --- .../Shims/TaskOrchestrationContextWrapper.cs | 28 +------------------ src/Worker/Core/Worker.csproj | 5 ---- .../Logging => Grpc}/DualCategoryLogger.cs | 7 ++--- 3 files changed, 4 insertions(+), 36 deletions(-) rename src/Worker/{Core/Logging => Grpc}/DualCategoryLogger.cs (91%) diff --git a/src/Worker/Core/Shims/TaskOrchestrationContextWrapper.cs b/src/Worker/Core/Shims/TaskOrchestrationContextWrapper.cs index d294cbbb..945d6ac5 100644 --- a/src/Worker/Core/Shims/TaskOrchestrationContextWrapper.cs +++ b/src/Worker/Core/Shims/TaskOrchestrationContextWrapper.cs @@ -63,7 +63,7 @@ public TaskOrchestrationContextWrapper( this.invocationContext = Check.NotNull(invocationContext); this.Properties = Check.NotNull(properties); - this.logger = this.CreateReplaySafeLogger("Microsoft.DurableTask.Worker.Orchestration"); + this.logger = this.CreateReplaySafeLogger("Microsoft.DurableTask"); this.deserializedInput = deserializedInput; } @@ -541,30 +541,4 @@ string GetDefaultVersion() return string.Empty; } - - /// - public override ILogger CreateReplaySafeLogger(string categoryName) - { - // For orchestration logs, use dual-category logging if legacy categories are enabled - if (categoryName == "Microsoft.DurableTask.Worker.Orchestration" && - this.invocationContext.Options.Logging.UseLegacyCategories) - { - ILogger primaryLogger = this.LoggerFactory.CreateLogger(categoryName); - ILogger legacyLogger = this.LoggerFactory.CreateLogger("Microsoft.DurableTask"); - ILogger dualLogger = new DualCategoryLogger(primaryLogger, legacyLogger); - - // Wrap the dual logger in a ReplaySafeLogger by calling the base implementation - // with a temporary category, then using reflection to replace the inner logger - var tempLogger = base.CreateReplaySafeLogger("temp"); - var loggerField = tempLogger.GetType().GetField( - "logger", - System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance); - loggerField?.SetValue(tempLogger, dualLogger); - - return tempLogger; - } - - // For all other categories, use the default behavior - return base.CreateReplaySafeLogger(categoryName); - } } diff --git a/src/Worker/Core/Worker.csproj b/src/Worker/Core/Worker.csproj index 66b3274d..daed82b1 100644 --- a/src/Worker/Core/Worker.csproj +++ b/src/Worker/Core/Worker.csproj @@ -8,11 +8,6 @@ The worker is responsible for processing durable task work items.true - - - - - diff --git a/src/Worker/Core/Logging/DualCategoryLogger.cs b/src/Worker/Grpc/DualCategoryLogger.cs similarity index 91% rename from src/Worker/Core/Logging/DualCategoryLogger.cs rename to src/Worker/Grpc/DualCategoryLogger.cs index 6a53d751..f514411e 100644 --- a/src/Worker/Core/Logging/DualCategoryLogger.cs +++ b/src/Worker/Grpc/DualCategoryLogger.cs @@ -3,7 +3,7 @@ using Microsoft.Extensions.Logging; -namespace Microsoft.DurableTask.Worker; +namespace Microsoft.DurableTask.Worker.Grpc; /// /// A logger wrapper that emits logs to both a primary (new) category and an optional legacy category. @@ -11,10 +11,9 @@ namespace Microsoft.DurableTask.Worker; /// /// This logger is used to maintain backward compatibility while transitioning to more specific logging categories. /// When legacy categories are enabled, log messages are written to both the new specific category -/// (e.g., "Microsoft.DurableTask.Worker.Grpc" or "Microsoft.DurableTask.Worker.Orchestration") -/// and the legacy broad category (e.g., "Microsoft.DurableTask"). +/// (e.g., "Microsoft.DurableTask.Worker.Grpc") and the legacy broad category (e.g., "Microsoft.DurableTask"). /// -internal sealed class DualCategoryLogger : ILogger +sealed class DualCategoryLogger : ILogger { readonly ILogger primaryLogger; readonly ILogger? legacyLogger;