Create a function-level request telemetry when none exists. (#3146)

* Adding a default activity.

Author: RohitRanjanMS

sample/SampleHost/Functions.cs

@@ -62,7 +62,7 @@ public async Task ProcessWorkItem_ServiceBus(
         }
 
         /// <summary>
-        /// If there is an error during function invocation, function execution will be retried up to 3 times waiting for "00:00:20" between each retry
+        /// If there is an error during function invocation, function execution will be retried up to 3 times waiting for "00:00:20" between each retry.
         /// </summary>
         /// <param name="events"></param>
         /// <param name="log"></param>

src/Microsoft.Azure.WebJobs.Host/Abstractions/IActivitySourceAbstraction.cs

@@ -0,0 +1,18 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+#nullable enable
+
+using Microsoft.Azure.WebJobs.Host.Executors;
+using System;
+
+namespace Microsoft.Azure.WebJobs.Host.Abstractions
+{
+    /// <summary>
+    /// Abstraction for ActivitySource to avoid dependency on System.Diagnostics.DiagnosticSource
+    /// </summary>
+    public interface IActivitySourceAbstraction
+    {
+        IDisposable? StartActivity(IFunctionInstanceEx functionInstance);
+    }
+}

src/Microsoft.Azure.WebJobs.Host/Executors/FunctionExecutor.cs

@@ -10,6 +10,7 @@
 using System.Runtime.ExceptionServices;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Azure.WebJobs.Host.Abstractions;
 using Microsoft.Azure.WebJobs.Host.Bindings;
 using Microsoft.Azure.WebJobs.Host.Indexers;
 using Microsoft.Azure.WebJobs.Host.Loggers;
@@ -31,6 +32,7 @@ internal class FunctionExecutor : IFunctionExecutor, IFunctionActivityStatusProv
         private readonly IEnumerable<IFunctionFilter> _globalFunctionFilters;
         private readonly IDrainModeManager _drainModeManager;
         private readonly ConcurrencyManager _concurrencyManager;
+        private readonly IActivitySourceAbstraction _activitySource;
         private int _outstandingInvocations;
         private int _outstandingRetries;
 
@@ -57,7 +59,8 @@ public FunctionExecutor(
                 ConcurrencyManager concurrencyManager,
                 ILoggerFactory loggerFactory = null,
                 IEnumerable<IFunctionFilter> globalFunctionFilters = null,
-                IDrainModeManager drainModeManager = null)
+                IDrainModeManager drainModeManager = null,
+                IActivitySourceAbstraction activitySource = null)
         {
             _functionInstanceLogger = functionInstanceLogger ?? throw new ArgumentNullException(nameof(functionInstanceLogger));
             _functionOutputLogger = functionOutputLogger;
@@ -68,6 +71,7 @@ public FunctionExecutor(
             _globalFunctionFilters = globalFunctionFilters ?? Enumerable.Empty<IFunctionFilter>();
             _drainModeManager = drainModeManager;
             _concurrencyManager = concurrencyManager ?? throw new ArgumentNullException(nameof(concurrencyManager));
+            _activitySource = activitySource;
         }
 
         public HostOutputMessage HostOutputMessage
@@ -97,6 +101,7 @@ public async Task<IDelayedException> TryExecuteAsync(IFunctionInstance functionI
                 }
 
                 using (_resultsLogger?.BeginFunctionScope(functionInstanceEx, HostOutputMessage.HostInstanceId))
+                using (_activitySource?.StartActivity(functionInstanceEx))
                 using (parameterHelper)
                 {
                     try

test/Microsoft.Azure.WebJobs.Host.UnitTests/Executors/ActivitySourceWrapper.cs

@@ -0,0 +1,29 @@
+using Microsoft.Azure.WebJobs.Host.Abstractions;
+using Microsoft.Azure.WebJobs.Host.Executors;
+using System;
+using System.Diagnostics;
+
+#nullable enable
+
+namespace Microsoft.Azure.WebJobs.Host.UnitTests.Executors
+{
+    public class ActivitySourceWrapper : IActivitySourceAbstraction
+    {
+        private readonly ActivitySource _activitySource;
+
+        public ActivitySourceWrapper(string sourceName)
+        {
+            _activitySource = new ActivitySource(sourceName);
+        }
+
+        public IDisposable? StartActivity(IFunctionInstanceEx functionInstance)
+        {
+            if (Activity.Current != null)
+            {
+                return null;
+            }
+
+            return _activitySource.StartActivity(functionInstance.FunctionDescriptor.LogName, ActivityKind.Server);
+        }
+    }   
+}

test/Microsoft.Azure.WebJobs.Host.UnitTests/Executors/FunctionExecutorTests.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
 using System.Threading;
@@ -328,6 +329,28 @@ private FunctionExecutor GetTestFunctionExecutor(DrainModeManager drainModeManag
             return functionExecutor;
         }
 
+        private FunctionExecutor GetActivitySourceWrapperExecutor(DrainModeManager drainModeManager = null)
+        {
+            var mockFunctionInstanceLogger = new Mock<IFunctionInstanceLogger>();
+            var mockFunctionOutputLogger = new NullFunctionOutputLogger();
+            var mockExceptionHandler = new Mock<IWebJobsExceptionHandler>();
+            var mockFunctionEventCollector = new Mock<IAsyncCollector<FunctionInstanceLogEntry>>();
+            var mockConcurrencyManager = new Mock<ConcurrencyManager>();
+            var activitySourceAbstraction = new ActivitySourceWrapper("Microsoft.Azure.WebJobs");
+
+            var functionExecutor = new FunctionExecutor(
+                mockFunctionInstanceLogger.Object,
+                mockFunctionOutputLogger,
+                mockExceptionHandler.Object,
+                mockFunctionEventCollector.Object,
+                mockConcurrencyManager.Object,
+                NullLoggerFactory.Instance,
+                null,
+                drainModeManager, activitySourceAbstraction);
+
+            return functionExecutor;
+        }
+
         private static void TestFunction()
         {
             // used for a FunctionDescriptor
@@ -441,6 +464,30 @@ await TestHelpers.Await(() =>
             Assert.Equal(status.OutstandingRetries, 0);
         }
 
+        [Fact]
+        public async Task TryExecuteAsync_DefaultActivity_Expected()
+        {
+            using var testListener = new ActivityTestListener("Microsoft.Azure.WebJobs");
+            var triggerData = new TriggeredFunctionData
+            {
+                TriggerValue = 123,
+                TriggerDetails = new Dictionary<string, string>()
+            };
+            var functionDescriptor = FunctionExecutorTestHelper.GetFunctionDescriptor();
+            var functionInstance = FunctionExecutorTestHelper.CreateFunctionInstance(Guid.NewGuid(), triggerData.TriggerDetails, false, functionDescriptor, 1000);
+            FunctionExecutor executor = GetActivitySourceWrapperExecutor();
+
+            // Arrange
+            HostStartedMessage testMessage = new HostStartedMessage();
+            executor.HostOutputMessage = testMessage;
+
+            await executor.TryExecuteAsync(functionInstance, CancellationToken.None);
+
+            // Assert
+            Assert.True(testListener.Activities.Count > 0, "No activities were captured by the listener.");
+            Assert.Contains(testListener.Activities, a => a.OperationName == "TestFunction");
+        }
+
         private void RunOnFunctionTimeoutTest(bool isDebugging, string expectedMessage)
         {
             System.Timers.Timer timer = new System.Timers.Timer(TimeSpan.FromMinutes(1).TotalMilliseconds);
@@ -498,4 +545,28 @@ public static void NoCancellationTokenParameter()
             }
         }
     }
+
+    internal sealed class ActivityTestListener : IDisposable
+    {
+        public List<Activity> Activities { get; } = new List<Activity>();
+        private readonly ActivityListener _listener;
+
+        public ActivityTestListener(string sourceName)
+        {
+            _listener = new ActivityListener
+            {
+                ShouldListenTo = s => s.Name == sourceName,
+                Sample = (ref ActivityCreationOptions<ActivityContext> _) => ActivitySamplingResult.AllDataAndRecorded,
+                ActivityStarted = activity => Activities.Add(activity),
+                ActivityStopped = _ => { }
+            };
+
+            ActivitySource.AddActivityListener(_listener);
+        }
+
+        public void Dispose()
+        {
+            _listener.Dispose();
+        }
+    }
 }

test/Microsoft.Azure.WebJobs.Host.UnitTests/PublicSurfaceTests.cs

@@ -158,6 +158,7 @@ public void WebJobs_Host_VerifyPublicSurfaceArea()
                 "FunctionResultAggregatorOptions",
                 "FunctionTimeoutAbortException",
                 "FunctionTimeoutException",
+                "IActivitySourceAbstraction",
                 "IArgumentBinding`1",
                 "IArgumentBindingProvider`1",
                 "IAsyncConverter`2",