Adding event source name property to DurabilityProvider (#1710)

These changes add an event source name property to DurabilityProvider and remove the hard coded event source names for different storage backends in OnEventSourceCreated().

Author: bachuv

src/WebJobs.Extensions.DurableTask/AzureStorageDurabilityProvider.cs

@@ -56,6 +56,8 @@ public AzureStorageDurabilityProvider(
 
         public override TimeSpan LongRunningTimerIntervalLength { get; set; } = TimeSpan.FromDays(3);
 
+        public override string EventSourceName { get; set; } = "DurableTask-AzureStorage";
+
         /// <inheritdoc/>
         public async override Task<IList<OrchestrationState>> GetAllOrchestrationStates(CancellationToken cancellationToken)
         {

src/WebJobs.Extensions.DurableTask/DurabilityProvider.cs

@@ -82,6 +82,11 @@ public DurabilityProvider(string storageProviderName, IOrchestrationService serv
         /// </summary>
         public virtual TimeSpan LongRunningTimerIntervalLength { get; set; }
 
+        /// <summary>
+        /// Event source name (e.g. DurableTask-AzureStorage).
+        /// </summary>
+        public virtual string EventSourceName { get; set; }
+
         /// <inheritdoc/>
         public int TaskOrchestrationDispatcherCount => this.GetOrchestrationService().TaskOrchestrationDispatcherCount;
 

src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs

@@ -382,7 +382,7 @@ private void InitializeLinuxLogging()
                 // Since our logging payload can be quite large, linux telemetry by default
                 // disables verbose-level telemetry to avoid a performance hit.
                 bool enableVerbose = this.Options.Tracing.AllowVerboseLinuxTelemetry;
-                this.eventSourceListener = new EventSourceListener(linuxLogger, enableVerbose, this.TraceHelper);
+                this.eventSourceListener = new EventSourceListener(linuxLogger, enableVerbose, this.TraceHelper, this.defaultDurabilityProvider.EventSourceName);
             }
         }
 

src/WebJobs.Extensions.DurableTask/EventSourceListener.cs

@@ -15,6 +15,7 @@ internal class EventSourceListener : EventListener
     {
         private readonly LinuxAppServiceLogger logger;
         private readonly bool disableVerbose;
+        private readonly string durabilityProviderEventSourceName;
         private EndToEndTraceHelper traceHelper;
 
         /// <summary>
@@ -24,11 +25,13 @@ internal class EventSourceListener : EventListener
         /// <param name="logger">A LinuxAppService logger configured for the current linux host.</param>
         /// <param name="enableVerbose">If true, durableTask.Core verbose logs are enabled. The opposite if false.</param>
         /// <param name="traceHelper">A tracing client to log exceptions.</param>
-        public EventSourceListener(LinuxAppServiceLogger logger, bool enableVerbose, EndToEndTraceHelper traceHelper)
+        /// <param name="durabilityProviderEventSourceName">The durability provider's event source name.</param>
+        public EventSourceListener(LinuxAppServiceLogger logger, bool enableVerbose, EndToEndTraceHelper traceHelper, string durabilityProviderEventSourceName)
         {
             this.logger = logger;
             this.disableVerbose = !enableVerbose; // We track the opposite value ro simplify logic later
             this.traceHelper = traceHelper;
+            this.durabilityProviderEventSourceName = durabilityProviderEventSourceName;
         }
 
         /// <summary>
@@ -43,9 +46,8 @@ protected override void OnEventSourceCreated(EventSource eventSource)
             // so we provide extra logic to ignore it.
             if ((eventSource.Name == "DurableTask-Core"
                   && eventSource.Guid != new Guid("7DA4779A-152E-44A2-A6F2-F80D991A5BEE")) ||
-                eventSource.Name == "DurableTask-AzureStorage" ||
                 eventSource.Name == "WebJobs-Extensions-DurableTask" ||
-                eventSource.Name == "DurableTask-SqlServer")
+                eventSource.Name == this.durabilityProviderEventSourceName)
             {
                 this.EnableEvents(eventSource, EventLevel.LogAlways, EventKeywords.All);
             }

src/WebJobs.Extensions.DurableTask/Microsoft.Azure.WebJobs.Extensions.DurableTask-net461.xml

@@ -226,6 +226,55 @@ public async Task ParentInstanceId_Not_Assigned_In_Orchestrator(bool extendedSes
         }
 
 #if !FUNCTIONS_V1
+        /// <summary>
+        /// By simulating the appropiate environment variables for Linux Consumption,
+        /// this test checks that we are emitting logs from DurableTask.AzureStorage
+        /// and reading the DurabilityProvider's EventSourceName property correctly.
+        /// </summary>
+        [Fact]
+        [Trait("Category", PlatformSpecificHelpers.TestCategory)]
+        public async Task AzureStorageEmittingLogsWithEventSourceName()
+        {
+            var prefix = "MS_DURABLE_FUNCTION_EVENTS_LOGS";
+            string orchestratorName = nameof(TestOrchestrations.SayHelloInline);
+
+            // To capture console output in a StringWritter
+            using (StringWriter sw = new StringWriter())
+            {
+                // Set console to write to StringWritter
+                Console.SetOut(sw);
+
+                // Simulate enviroment variables indicating linux consumption
+                var nameResolver = new SimpleNameResolver(new Dictionary<string, string>()
+                {
+                    { "CONTAINER_NAME", "val1" },
+                    { "WEBSITE_STAMP_DEPLOYMENT_ID", "val3" },
+                    { "WEBSITE_HOME_STAMPNAME", "val4" },
+                });
+
+                // Run trivial orchestrator
+                using (var host = TestHelpers.GetJobHost(
+                    this.loggerProvider,
+                    nameResolver: nameResolver,
+                    testName: "FiltersVerboseLogsByDefault",
+                    enableExtendedSessions: false,
+                    storageProviderType: "azure_storage"))
+                {
+                    await host.StartAsync();
+                    var client = await host.StartOrchestratorAsync(orchestratorName, input: "World", this.output);
+                    var status = await client.WaitForCompletionAsync(this.output);
+                    await host.StopAsync();
+                }
+
+                string consoleOutput = sw.ToString();
+
+                // Validate that the JSON has DurableTask-AzureStorage fields
+                string[] lines = consoleOutput.Split('\n');
+                var azureStorageLogLines = lines.Where(l => l.Contains("DurableTask-AzureStorage") && l.StartsWith(prefix));
+                Assert.NotEmpty(azureStorageLogLines);
+            }
+        }
+
         /// <summary>
         /// By simulating the appropiate enviorment variables for Linux Consumption,
         /// this test checks that we are writing our JSON logs to the console. It does not