absorbing HTTP tracking changes

Author: brettsam

src/WebJobs.Script.WebHost/Controllers/FunctionsController.cs

@@ -108,7 +108,19 @@ public IActionResult Invoke(string name, [FromBody] FunctionInvocation invocatio
             {
                 { inputParameter.Name, invocation.Input }
             };
-            Task.Run(() => scriptHost.CallAsync(function.Name, arguments));
+
+            Task.Run(async () =>
+            {
+                IDictionary<string, object> loggerScope = new Dictionary<string, object>
+                {
+                    { "MS_IgnoreActivity", null }
+                };
+
+                using (_logger.BeginScope(loggerScope))
+                {
+                    await scriptHost.CallAsync(function.Name, arguments);
+                }
+            });
 
             return Accepted();
         }

src/WebJobs.Script.WebHost/WebJobsScriptHostService.cs

@@ -6,6 +6,9 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.ApplicationInsights.AspNetCore;
+using Microsoft.ApplicationInsights.AspNetCore.Extensions;
+using Microsoft.ApplicationInsights.Extensibility.Implementation.ApplicationId;
 using Microsoft.Azure.WebJobs.Logging;
 using Microsoft.Azure.WebJobs.Script.Scale;
 using Microsoft.Extensions.DependencyInjection;
@@ -34,6 +37,8 @@ public class WebJobsScriptHostService : IHostedService, IScriptHostManager, IDis
         private int _hostStartCount;
         private bool _disposed = false;
 
+        private static IDisposable _requestTrackingModule;
+
         public WebJobsScriptHostService(IOptionsMonitor<ScriptApplicationHostOptions> applicationHostOptions, IScriptHostBuilder scriptHostBuilder, ILoggerFactory loggerFactory, IServiceProvider rootServiceProvider,
             IServiceScopeFactory rootScopeFactory, IScriptWebHostEnvironment scriptWebHostEnvironment, IEnvironment environment,
             HostPerformanceManager hostPerformanceManager, IOptions<HostHealthMonitorOptions> healthMonitorOptions)
@@ -43,6 +48,9 @@ public WebJobsScriptHostService(IOptionsMonitor<ScriptApplicationHostOptions> ap
                 throw new ArgumentNullException(nameof(loggerFactory));
             }
 
+            // This will no-op if already initialized.
+            InitializeApplicationInsightsRequestTracking();
+
             _applicationHostOptions = applicationHostOptions ?? throw new ArgumentNullException(nameof(applicationHostOptions));
             _scriptWebHostEnvironment = scriptWebHostEnvironment ?? throw new ArgumentNullException(nameof(scriptWebHostEnvironment));
             _rootServiceProvider = rootServiceProvider;
@@ -144,6 +152,13 @@ private async Task StartHostAsync(CancellationToken cancellationToken, int attem
 
                 LogInitialization(localHost, isOffline, attemptCount, ++_hostStartCount);
 
+                if (!_scriptWebHostEnvironment.InStandbyMode)
+                {
+                    // At this point we know that App Insights is initialized (if being used), so we
+                    // can dispose this early request tracking module, which forces our new one to take over.
+                    DisposeRequestTrackingModule();
+                }
+
                 await _host.StartAsync(cancellationToken);
 
                 if (!startupMode.HasFlag(JobHostStartupMode.HandlingError))
@@ -231,6 +246,12 @@ await Utility.DelayWithBackoffAsync(attemptCount, cancellationToken, min: TimeSp
             }
         }
 
+        private void DisposeRequestTrackingModule()
+        {
+            _requestTrackingModule?.Dispose();
+            _requestTrackingModule = null;
+        }
+
         public async Task StopAsync(CancellationToken cancellationToken)
         {
             _startupLoopTokenSource?.Cancel();
@@ -418,6 +439,33 @@ private async Task Orphan(IHost instance, ILogger logger, CancellationToken canc
             }
         }
 
+        private static void InitializeApplicationInsightsRequestTracking()
+        {
+            if (_requestTrackingModule != null)
+            {
+                return;
+            }
+
+            // Requests may come in before the JobHost has started (like during cold starts), which means
+            // they will not be properly tracked by Application Insights because there's nothing listening
+            // for them yet. This wires up the request tracking module with default values to catch those
+            // events and properly create an Activity. Once the JobHost has started, we dispose this and the
+            // JobHost tracking module takes over.
+            var module = new RequestTrackingTelemetryModule(new ApplicationInsightsApplicationIdProvider())
+            {
+                CollectionOptions = new RequestCollectionOptions
+                {
+                    TrackExceptions = false,
+                    EnableW3CDistributedTracing = true,
+                    InjectResponseHeaders = true
+                }
+            };
+
+            module.Initialize(null);
+
+            _requestTrackingModule = module;
+        }
+
         protected virtual void Dispose(bool disposing)
         {
             if (!_disposed)
@@ -426,6 +474,7 @@ protected virtual void Dispose(bool disposing)
                 {
                     _startupLoopTokenSource?.Dispose();
                     _hostRestartSemaphore.Dispose();
+                    DisposeRequestTrackingModule();
                 }
                 _disposed = true;
             }

src/WebJobs.Script/Diagnostics/FunctionsSdkVersionProvider.cs

@@ -0,0 +1,15 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using Microsoft.Azure.WebJobs.Logging.ApplicationInsights;
+
+namespace Microsoft.Azure.WebJobs.Script.Diagnostics
+{
+    internal class FunctionsSdkVersionProvider : ISdkVersionProvider
+    {
+        public string GetSdkVersion()
+        {
+            return $"azurefunctions: {ScriptHost.Version}";
+        }
+    }
+}

src/WebJobs.Script/ScriptHostBuilderExtensions.cs

@@ -3,10 +3,8 @@
 
 using System;
 using System.Collections.Generic;
-using Microsoft.ApplicationInsights;
 using Microsoft.ApplicationInsights.DependencyCollector;
 using Microsoft.ApplicationInsights.Extensibility;
-using Microsoft.ApplicationInsights.Extensibility.Implementation;
 using Microsoft.Azure.WebJobs.Host.Executors;
 using Microsoft.Azure.WebJobs.Logging;
 using Microsoft.Azure.WebJobs.Logging.ApplicationInsights;
@@ -242,19 +240,7 @@ internal static void ConfigureApplicationInsights(HostBuilderContext context, IL
                 builder.AddApplicationInsights(o => o.InstrumentationKey = appInsightsKey);
                 builder.Services.ConfigureOptions<ApplicationInsightsLoggerOptionsSetup>();
 
-                builder.Services.AddSingleton<ISdkVersionProvider, ApplicationInsightsSdkVersionProvider>();
-
-                // Override the default SdkVersion with the functions key
-                builder.Services.AddSingleton<TelemetryClient>(provider =>
-                {
-                    TelemetryConfiguration configuration = provider.GetService<TelemetryConfiguration>();
-                    TelemetryClient client = new TelemetryClient(configuration);
-
-                    ISdkVersionProvider versionProvider = provider.GetService<ISdkVersionProvider>();
-                    client.Context.GetInternalContext().SdkVersion = versionProvider.GetSdkVersion();
-
-                    return client;
-                });
+                builder.Services.AddSingleton<ISdkVersionProvider, FunctionsSdkVersionProvider>();
 
                 if (SystemEnvironment.Instance.IsPlaceholderModeEnabled())
                 {
@@ -267,6 +253,12 @@ internal static void ConfigureApplicationInsights(HostBuilderContext context, IL
                             break;
                         }
                     }
+
+                    // Disable auto-http tracking when in placeholder mode.
+                    builder.Services.Configure<ApplicationInsightsLoggerOptions>(o =>
+                    {
+                        o.HttpAutoCollectionOptions.EnableHttpTriggerExtendedInfoCollection = false;
+                    });
                 }
             }
         }

src/WebJobs.Script/WebJobs.Script.csproj

@@ -41,10 +41,10 @@
     <PackageReference Include="Microsoft.Azure.Functions.JavaWorker" Version="1.3.1-SNAPSHOT" />
     <PackageReference Include="Microsoft.Azure.Functions.NodeJsWorker" Version="1.0.2" />
     <PackageReference Include="Microsoft.Azure.Functions.PowerShellWorker" Version="0.1.90-preview" />
-    <PackageReference Include="Microsoft.Azure.WebJobs" Version="3.0.6" />
+    <PackageReference Include="Microsoft.Azure.WebJobs" Version="3.0.7-11551" />
     <PackageReference Include="Microsoft.Azure.WebJobs.Extensions" Version="3.0.2" />
     <PackageReference Include="Microsoft.Azure.WebJobs.Extensions.Http" Version="3.0.2" />
-    <PackageReference Include="Microsoft.Azure.WebJobs.Logging.ApplicationInsights" Version="3.0.6" />
+    <PackageReference Include="Microsoft.Azure.WebJobs.Logging.ApplicationInsights" Version="3.0.7-11551" />
     <PackageReference Include="Microsoft.Build" Version="15.8.166" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="2.8.2" />
     <PackageReference Include="Microsoft.DotNet.PlatformAbstractions" Version="2.1.0" />