4.9.300 Hotfix in-proc (#11005)

* Update version to 4.39.300

* Clear release notes

* Fixes circular dependency when resolving LinuxContainerLegionMetricsPublisher (#11000) (#11002)

---------

Co-authored-by: Azure Functions Release <[email protected]>
Co-authored-by: Shyju Krishnankutty <[email protected]>

Author: 3 people

release_notes.md

@@ -2,5 +2,4 @@
 
 <!-- Please add your release notes in the following format:
 - My change description (#PR)
--->
-- Add JitTrace Files for v4.39
+-->

src/Directory.Version.props

@@ -1,6 +1,6 @@
 <Project>
   <PropertyGroup>
-    <VersionPrefix>4.$(MinorVersionPrefix)39.200</VersionPrefix>
+    <VersionPrefix>4.$(MinorVersionPrefix)39.300</VersionPrefix>
     <UpdateBuildNumber>true</UpdateBuildNumber>
   </PropertyGroup>
 </Project>

src/WebJobs.Script.WebHost/Metrics/LinuxContainerLegionMetricsPublisher.cs

@@ -9,6 +9,7 @@
 using Microsoft.Azure.Functions.Platform.Metrics.LinuxConsumption;
 using Microsoft.Azure.WebJobs.Script.Diagnostics;
 using Microsoft.Azure.WebJobs.Script.WebHost.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 
@@ -24,7 +25,7 @@ public sealed class LinuxContainerLegionMetricsPublisher : IMetricsPublisher, ID
         private readonly IDisposable _standbyOptionsOnChangeSubscription;
         private readonly IEnvironment _environment;
         private readonly ILogger _logger;
-        private readonly IScriptHostManager _scriptHostManager;
+        private readonly IServiceProvider _serviceProvider;
         private readonly string _containerName;
 
         private IMetricsLogger _metricsLogger;
@@ -36,14 +37,14 @@ public sealed class LinuxContainerLegionMetricsPublisher : IMetricsPublisher, ID
 
         public LinuxContainerLegionMetricsPublisher(IEnvironment environment, IOptionsMonitor<StandbyOptions> standbyOptions,
             IOptions<LinuxConsumptionLegionMetricsPublisherOptions> options, ILogger<LinuxContainerLegionMetricsPublisher> logger,
-            IFileSystem fileSystem, ILinuxConsumptionMetricsTracker metricsTracker, IScriptHostManager scriptHostManager,
+            IFileSystem fileSystem, ILinuxConsumptionMetricsTracker metricsTracker, IServiceProvider serviceProvider,
             int? metricsPublishIntervalMS = null)
         {
             _standbyOptions = standbyOptions ?? throw new ArgumentNullException(nameof(standbyOptions));
             _environment = environment ?? throw new ArgumentNullException(nameof(environment));
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
             _metricsTracker = metricsTracker ?? throw new ArgumentNullException(nameof(metricsTracker));
-            _scriptHostManager = scriptHostManager ?? throw new ArgumentNullException(nameof(scriptHostManager));
+            _serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
             _containerName = options.Value.ContainerName;
 
             // Set this to 15 minutes worth of files
@@ -67,21 +68,7 @@ public LinuxContainerLegionMetricsPublisher(IEnvironment environment, IOptionsMo
             }
         }
 
-        public IMetricsLogger MetricsLogger
-        {
-            get
-            {
-                if (_metricsLogger == null)
-                {
-                    if (!Utility.TryGetHostService<IMetricsLogger>(_scriptHostManager, out _metricsLogger))
-                    {
-                        throw new InvalidOperationException($"Unable to resolve {nameof(IMetricsLogger)} service.");
-                    }
-                }
-
-                return _metricsLogger;
-            }
-        }
+        private IMetricsLogger MetricsLogger => _metricsLogger ??= _serviceProvider.GetRequiredService<IMetricsLogger>();
 
         public void Initialize()
         {

src/WebJobs.Script.WebHost/WebHostServiceCollectionExtensions.cs

@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
+using System;
 using System.IO.Abstractions;
 using System.Net.Http;
 using System.Runtime.InteropServices;
@@ -285,8 +286,8 @@ private static void AddLinuxContainerServices(this IServiceCollection services)
                     var logger = s.GetService<ILogger<LinuxContainerLegionMetricsPublisher>>();
                     var metricsTracker = s.GetService<ILinuxConsumptionMetricsTracker>();
                     var standbyOptions = s.GetService<IOptionsMonitor<StandbyOptions>>();
-                    var scriptHostManager = s.GetService<IScriptHostManager>();
-                    return new LinuxContainerLegionMetricsPublisher(environment, standbyOptions, options, logger, new FileSystem(), metricsTracker, scriptHostManager);
+                    var serviceProvider = s.GetService<IServiceProvider>();
+                    return new LinuxContainerLegionMetricsPublisher(environment, standbyOptions, options, logger, new FileSystem(), metricsTracker, serviceProvider);
                 }
                 else if (environment.IsLinuxMetricsPublishingEnabled())
                 {

test/WebJobs.Script.Tests.Integration/Host/StandbyManager/StandbyManagerE2ETestBase.cs

@@ -12,6 +12,7 @@
 using System.Web.Http;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.TestHost;
+using Microsoft.Azure.Functions.Platform.Metrics.LinuxConsumption;
 using Microsoft.Azure.WebJobs.Extensions.Http;
 using Microsoft.Azure.WebJobs.Host.Executors;
 using Microsoft.Azure.WebJobs.Script.Diagnostics;
@@ -73,6 +74,7 @@ protected async Task<IWebHostBuilder> CreateWebHostBuilderAsync(string testDirNa
                 environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteName, websiteSiteName);
             }
 
+            var testMetricsTracker = new TestMetricsTracker();
             var webHostBuilder = Program.CreateWebHostBuilder()
                 .ConfigureAppConfiguration(c =>
                 {
@@ -102,6 +104,7 @@ protected async Task<IWebHostBuilder> CreateWebHostBuilderAsync(string testDirNa
 
                     c.AddSingleton<IEnvironment>(_ => environment);
                     c.AddSingleton<IMetricsLogger>(_ => _metricsLogger);
+                    c.AddSingleton<ILinuxConsumptionMetricsTracker>(_ => testMetricsTracker);
                 })
                 .ConfigureScriptHostLogging(b =>
                 {
@@ -121,9 +124,9 @@ protected async Task<IWebHostBuilder> CreateWebHostBuilderAsync(string testDirNa
             return webHostBuilder;
         }
 
-        protected async Task InitializeTestHostAsync(string testDirName, IEnvironment environment, string websiteSiteName = TestSiteName)
+        protected async Task<IWebHost> InitializeTestHostAsync(string testDirName, IEnvironment environment, string websiteSiteName = TestSiteName)
         {
-            var webHostBuilder = await CreateWebHostBuilderAsync(testDirName, environment, websiteSiteName);
+            IWebHostBuilder webHostBuilder = await CreateWebHostBuilderAsync(testDirName, environment, websiteSiteName);
             _httpServer = new TestServer(webHostBuilder);
             _httpClient = _httpServer.CreateClient();
             _httpClient.BaseAddress = new Uri("https://localhost/");
@@ -135,6 +138,8 @@ protected async Task InitializeTestHostAsync(string testDirName, IEnvironment en
             Assert.NotNull(traces.Single(p => p.FormattedMessage.StartsWith("Host is in standby mode")));
 
             _expectedHostId = await _httpServer.Host.Services.GetService<IHostIdProvider>().GetHostIdAsync(CancellationToken.None);
+
+            return _httpServer.Host;
         }
 
 

test/WebJobs.Script.Tests.Integration/Host/StandbyManager/StandbyManagerE2ETests_Linux.cs

@@ -13,6 +13,7 @@
 using Microsoft.Azure.WebJobs.Script.Tests.Integration.Fixtures;
 using Microsoft.Azure.WebJobs.Script.WebHost;
 using Microsoft.Azure.WebJobs.Script.WebHost.Authentication;
+using Microsoft.Azure.WebJobs.Script.WebHost.Metrics;
 using Microsoft.Azure.WebJobs.Script.WebHost.Models;
 using Microsoft.Azure.WebJobs.Script.WebHost.Security;
 using Microsoft.Azure.WebJobs.Script.Workers;
@@ -32,6 +33,43 @@ namespace Microsoft.Azure.WebJobs.Script.Tests
     [Trait(TestTraits.Group, TestTraits.StandbyModeTestsLinux)]
     public class StandbyManagerE2ETests_Linux(AzuriteFixture azurite) : StandbyManagerE2ETestBase, IClassFixture<AzuriteFixture>
     {
+        [Fact]
+        public async Task StandbyModeE2E_LinuxConsumptionOnLegion()
+        {
+            var vars = new Dictionary<string, string>
+            {
+                { EnvironmentSettingNames.AzureWebsitePlaceholderMode, "1" },
+                { EnvironmentSettingNames.ContainerName, "testContainer" },
+                { EnvironmentSettingNames.AzureWebsiteHostName, "testapp.azurewebsites.net" },
+                { EnvironmentSettingNames.AzureWebsiteName, "TestApp" },
+                { EnvironmentSettingNames.ContainerEncryptionKey, Convert.ToBase64String(TestHelpers.GenerateKeyBytes()) },
+                { EnvironmentSettingNames.AzureWebsiteContainerReady, null },
+                { EnvironmentSettingNames.AzureWebsiteSku, "Dynamic" },
+                { EnvironmentSettingNames.AzureWebsiteZipDeployment, null },
+                { EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagEnableProxies },
+                { "AzureWebEncryptionKey", "0F75CA46E7EBDD39E4CA6B074D1F9A5972B849A55F91A248" },
+                { EnvironmentSettingNames.FunctionsTimeZone, "Europe/Berlin" },
+                { EnvironmentSettingNames.FunctionWorkerRuntime, "dotnet" },
+                { EnvironmentSettingNames.LegionServiceHost, "1"}
+            };
+
+            var environment = new TestEnvironment(vars);
+
+            Assert.True(environment.IsLinuxConsumptionOnLegion());
+            Assert.True(environment.IsAnyLinuxConsumption());
+
+            var webHost = await InitializeTestHostAsync("Linux", environment);
+
+            // verify the expected startup logs
+            var logEntries = _loggerProvider.GetAllLogMessages().Where(p => p.FormattedMessage != null).ToList();
+            Assert.True(logEntries.Any(m => m.Category == "Host.Startup" && m.FormattedMessage.Contains("Host is in standby mode")));
+            Assert.True(logEntries.Any(cat => cat.Category == "Microsoft.Azure.WebJobs.Script.WebHost.StandbyManager"));
+            Assert.True(logEntries.Any(cat => cat.Category == "Host.Triggers.Warmup"));
+
+            // verify that the expected (legion specific) implementations are resolved
+            Assert.Equal(typeof(LinuxContainerLegionMetricsPublisher), webHost.Services.GetRequiredService<IMetricsPublisher>().GetType());
+        }
+
         [Fact]
         public async Task StandbyModeE2E_LinuxContainer()
         {

test/WebJobs.Script.Tests.Shared/TestMetricsTracker.cs

@@ -0,0 +1,40 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using Microsoft.Azure.Functions.Platform.Metrics.LinuxConsumption;
+
+namespace Microsoft.Azure.WebJobs.Script.Tests
+{
+    public class TestMetricsTracker : ILinuxConsumptionMetricsTracker
+    {
+        public event EventHandler<DiagnosticEventArgs> OnDiagnosticEvent;
+
+        public List<FunctionActivity> FunctionActivities { get; } = new List<FunctionActivity>();
+
+        public List<MemoryActivity> MemoryActivities { get; } = new List<MemoryActivity>();
+
+        public Queue<LinuxConsumptionMetrics> MetricsQueue { get; } = new Queue<LinuxConsumptionMetrics>();
+
+        public void AddFunctionActivity(FunctionActivity activity)
+        {
+            FunctionActivities.Add(activity);
+        }
+
+        public void AddMemoryActivity(MemoryActivity activity)
+        {
+            MemoryActivities.Add(activity);
+        }
+
+        public bool TryGetMetrics(out LinuxConsumptionMetrics metrics)
+        {
+            return MetricsQueue.TryDequeue(out metrics);
+        }
+
+        public void LogEvent(string eventName)
+        {
+            OnDiagnosticEvent?.Invoke(this, new DiagnosticEventArgs(eventName));
+        }
+    }
+}

test/WebJobs.Script.Tests.Shared/WebJobs.Script.Tests.Shared.projitems

@@ -24,6 +24,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)TestFunctionMetadataManager.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)TestHostBuilderExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)TestHostExtensions.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)TestMetricsTracker.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)TestOutputHelperLogger.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)TestOutputHelperLoggerProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)TestMetricsLogger.cs" />

test/WebJobs.Script.Tests/Metrics/LinuxContainerLegionMetricsPublisherTests.cs

@@ -32,7 +32,7 @@ public class LinuxContainerLegionMetricsPublisherTests
         private readonly Random _random = new Random();
         private readonly TestLogger<LinuxContainerLegionMetricsPublisher> _logger;
         private readonly TestMetricsLogger _testMetricsLogger;
-        private readonly IScriptHostManager _scriptHostManager;
+        private readonly IServiceProvider _serviceProvider;
 
         private IOptions<LinuxConsumptionLegionMetricsPublisherOptions> _options;
         private StandbyOptions _standbyOptions;
@@ -44,7 +44,7 @@ public LinuxContainerLegionMetricsPublisherTests()
             _environment = new TestEnvironment();
             _logger = new TestLogger<LinuxContainerLegionMetricsPublisher>();
             _testMetricsLogger = new TestMetricsLogger();
-            _scriptHostManager = new TestScriptHostManager(_testMetricsLogger);
+            _serviceProvider = new TestScriptHostManager(_testMetricsLogger);
 
             _environment.SetEnvironmentVariable(EnvironmentSettingNames.FunctionsMetricsPublishPath, _metricsFilePath);
 
@@ -62,7 +62,7 @@ private LinuxContainerLegionMetricsPublisher CreatePublisher(int? metricsPublish
                 MetricsFilePath = _metricsFilePath
             });
 
-            return new LinuxContainerLegionMetricsPublisher(_environment, _standbyOptionsMonitor, _options, _logger, new FileSystem(), _testMetricsTracker, _scriptHostManager, metricsPublishInterval);
+            return new LinuxContainerLegionMetricsPublisher(_environment, _standbyOptionsMonitor, _options, _logger, new FileSystem(), _testMetricsTracker, _serviceProvider, metricsPublishInterval);
         }
 
         [Fact]
@@ -237,37 +237,6 @@ private static FileInfo[] GetMetricsFilesSafe(string path)
             return new FileInfo[0];
         }
 
-        private class TestMetricsTracker : ILinuxConsumptionMetricsTracker
-        {
-            public event EventHandler<DiagnosticEventArgs> OnDiagnosticEvent;
-
-            public List<FunctionActivity> FunctionActivities { get; } = new List<FunctionActivity>();
-
-            public List<MemoryActivity> MemoryActivities { get; } = new List<MemoryActivity>();
-
-            public Queue<LinuxConsumptionMetrics> MetricsQueue { get; } = new Queue<LinuxConsumptionMetrics>();
-
-            public void AddFunctionActivity(FunctionActivity activity)
-            {
-                FunctionActivities.Add(activity);
-            }
-
-            public void AddMemoryActivity(MemoryActivity activity)
-            {
-                MemoryActivities.Add(activity);
-            }
-
-            public bool TryGetMetrics(out LinuxConsumptionMetrics metrics)
-            {
-                return MetricsQueue.TryDequeue(out metrics);
-            }
-
-            public void LogEvent(string eventName)
-            {
-                OnDiagnosticEvent?.Invoke(this, new DiagnosticEventArgs(eventName));
-            }
-        }
-
         private class TestScriptHostManager : IServiceProvider, IScriptHostManager
         {
             private readonly IMetricsLogger _metricsLogger;