Switching the worker indexing to use hosting config feature flag (#9245)

soninaren · web-flow · commit fba2162ce368 · 2023-05-03T15:39:46.000-07:00
diff --git a/src/WebJobs.Script.WebHost/WebHostServiceCollectionExtensions.cs b/src/WebJobs.Script.WebHost/WebHostServiceCollectionExtensions.cs
@@ -175,13 +175,9 @@ public static void AddWebJobsScriptHost(this IServiceCollection services, IConfi
             // Language Worker Hosted Services need to be intialized before WebJobsScriptHostService
             ScriptHostBuilderExtensions.AddCommonServices(services);
 
-            services.AddSingleton<IFunctionMetadataProvider>(sp =>
-            {
-                return new FunctionMetadataProvider(
-                    sp.GetRequiredService<ILogger<FunctionMetadataProvider>>(),
-                    ActivatorUtilities.CreateInstance<WorkerFunctionMetadataProvider>(sp),
-                    ActivatorUtilities.CreateInstance<HostFunctionMetadataProvider>(sp));
-            });
+            services.AddSingleton<IWorkerFunctionMetadataProvider, WorkerFunctionMetadataProvider>();
+            services.AddSingleton<IHostFunctionMetadataProvider, HostFunctionMetadataProvider>();
+            services.AddSingleton<IFunctionMetadataProvider, FunctionMetadataProvider>();
 
             // Core script host services
             services.AddSingleton<WebJobsScriptHostService>();
diff --git a/src/WebJobs.Script/Config/FunctionsHostingConfigOptions.cs b/src/WebJobs.Script/Config/FunctionsHostingConfigOptions.cs
@@ -43,6 +43,28 @@ public bool WorkerWarmupEnabled
             }
         }
 
+        /// <summary>
+        /// Gets a value indicating whether worker indexing feature is enabled in the hosting config.
+        /// </summary>
+        public bool WorkerIndexingEnabled
+        {
+            get
+            {
+                return GetFeature(RpcWorkerConstants.WorkerIndexingEnabled) == "1";
+            }
+        }
+
+        /// <summary>
+        /// Gets a string delimited by '|' that contains the name of the apps with worker indexing disabled.
+        /// </summary>
+        public string WorkerIndexingDisabledApps
+        {
+            get
+            {
+                return GetFeature(RpcWorkerConstants.WorkerIndexingDisabledApps) ?? string.Empty;
+            }
+        }
+
         /// <summary>
         /// Gets a value indicating whether Linux Log Backoff is disabled in the hosting config.
         /// </summary>
diff --git a/src/WebJobs.Script/Host/FunctionMetadataProvider.cs b/src/WebJobs.Script/Host/FunctionMetadataProvider.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Threading.Tasks;
+using Microsoft.Azure.WebJobs.Script.Config;
 using Microsoft.Azure.WebJobs.Script.Description;
 using Microsoft.Azure.WebJobs.Script.Workers.Rpc;
 using Microsoft.Extensions.Logging;
@@ -16,22 +17,24 @@ internal class FunctionMetadataProvider : IFunctionMetadataProvider
     {
         private readonly IEnvironment _environment;
         private readonly ILogger<FunctionMetadataProvider> _logger;
+        private readonly FunctionsHostingConfigOptions _functionsHostingConfigOptions;
         private IWorkerFunctionMetadataProvider _workerFunctionMetadataProvider;
         private IHostFunctionMetadataProvider _hostFunctionMetadataProvider;
 
-        public FunctionMetadataProvider(ILogger<FunctionMetadataProvider> logger, IWorkerFunctionMetadataProvider workerFunctionMetadataProvider, IHostFunctionMetadataProvider hostFunctionMetadataProvider)
+        public FunctionMetadataProvider(ILogger<FunctionMetadataProvider> logger, IWorkerFunctionMetadataProvider workerFunctionMetadataProvider, IHostFunctionMetadataProvider hostFunctionMetadataProvider, IOptions<FunctionsHostingConfigOptions> functionsHostingConfigOptions)
         {
             _logger = logger;
             _workerFunctionMetadataProvider = workerFunctionMetadataProvider;
             _hostFunctionMetadataProvider = hostFunctionMetadataProvider;
+            _functionsHostingConfigOptions = functionsHostingConfigOptions.Value;
             _environment = SystemEnvironment.Instance;
         }
 
         public ImmutableDictionary<string, ImmutableArray<string>> FunctionErrors { get; private set; }
 
         public async Task<ImmutableArray<FunctionMetadata>> GetFunctionMetadataAsync(IEnumerable<RpcWorkerConfig> workerConfigs, IEnvironment environment, bool forceRefresh = false)
         {
-            bool workerIndexing = Utility.CanWorkerIndex(workerConfigs, _environment);
+            bool workerIndexing = Utility.CanWorkerIndex(workerConfigs, _environment, _functionsHostingConfigOptions);
             if (!workerIndexing)
             {
                 return await GetMetadataFromHostProvider(workerConfigs, environment, forceRefresh);
diff --git a/src/WebJobs.Script/Utility.cs b/src/WebJobs.Script/Utility.cs
@@ -924,28 +924,37 @@ public static void ValidateRetryOptions(RetryOptions
             }
         }
 
-        public static bool CanWorkerIndex(IEnumerable<RpcWorkerConfig> workerConfigs, IEnvironment environment)
+        // EnableWorkerIndexing set through AzureWebjobsFeatuerFlag always take precdence
+        // if AzureWebjobsFeatuerFlag is not set then WORKER_INDEXING_ENABLED hosting config controls stamplevel enablement
+        // if WORKER_INDEXING_ENABLED is set and WORKER_INDEXING_DISABLED contains the customers app name worker indexing is then disabled for that customer only
+        // Also Worker indexing is disabled for Logic apps
+        public static bool CanWorkerIndex(IEnumerable<RpcWorkerConfig> workerConfigs, IEnvironment environment, FunctionsHostingConfigOptions functionsHostingConfigOptions)
         {
-            if (!FeatureFlags.IsEnabled(ScriptConstants.FeatureFlagEnableWorkerIndexing, environment))
+            string appName = environment.GetAzureWebsiteUniqueSlotName();
+            bool workerIndexingEnabled = FeatureFlags.IsEnabled(ScriptConstants.FeatureFlagEnableWorkerIndexing, environment)
+                                          || (functionsHostingConfigOptions.WorkerIndexingEnabled
+                                          && !functionsHostingConfigOptions.WorkerIndexingDisabledApps.ToLowerInvariant().Split("|").Contains(appName)
+                                           && !environment.IsLogicApp());
+
+            if (!workerIndexingEnabled)
             {
                 return false;
             }
 
-            if (workerConfigs != null && !environment.IsMultiLanguageRuntimeEnvironment())
+            bool workerIndexingAvailable = false;
+            if (workerConfigs != null)
             {
                 var workerRuntime = environment.GetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime);
                 var workerConfig = workerConfigs.FirstOrDefault(c => c.Description?.Language != null && c.Description.Language.Equals(workerRuntime, StringComparison.InvariantCultureIgnoreCase));
 
                 // if feature flag is enabled and workerConfig.WorkerIndexing == true, then return true
-                if (workerConfig != null
+                workerIndexingAvailable = workerConfig != null
                         && workerConfig.Description != null
                         && workerConfig.Description.WorkerIndexing != null
-                        && workerConfig.Description.WorkerIndexing.Equals("true", StringComparison.OrdinalIgnoreCase))
-                {
-                    return true;
-                }
+                        && workerConfig.Description.WorkerIndexing.Equals("true", StringComparison.OrdinalIgnoreCase);
             }
-            return false;
+
+            return workerIndexingEnabled && workerIndexingAvailable;
         }
 
         public static void LogAutorestGeneratedJsonIfExists(string rootScriptPath, ILogger logger)
diff --git a/src/WebJobs.Script/Workers/Rpc/RpcWorkerConstants.cs b/src/WebJobs.Script/Workers/Rpc/RpcWorkerConstants.cs
@@ -81,5 +81,8 @@ public static class RpcWorkerConstants
         public const string DotNetCoreDebugEngine = ".NETCore";
         public const string DotNetFrameworkDebugEngine = ".NETFramework";
         public const string DotNetFramework = "Framework";
+
+        public const string WorkerIndexingEnabled = "WORKER_INDEXING_ENABLED";
+        public const string WorkerIndexingDisabledApps = "WORKER_INDEXING_DISABLED_APPS";
     }
 }
diff --git a/test/WebJobs.Script.Tests.Integration/Management/FunctionsSyncManagerTests.cs b/test/WebJobs.Script.Tests.Integration/Management/FunctionsSyncManagerTests.cs
@@ -140,7 +140,7 @@ public FunctionsSyncManagerTests()
             _hostNameProvider = new HostNameProvider(_mockEnvironment.Object);
 
             var functionMetadataProvider = new HostFunctionMetadataProvider(optionsMonitor, NullLogger<HostFunctionMetadataProvider>.Instance, new TestMetricsLogger());
-            var defaultProvider = new FunctionMetadataProvider(NullLogger<FunctionMetadataProvider>.Instance, null, functionMetadataProvider);
+            var defaultProvider = new FunctionMetadataProvider(NullLogger<FunctionMetadataProvider>.Instance, null, functionMetadataProvider, new OptionsWrapper<FunctionsHostingConfigOptions>(new FunctionsHostingConfigOptions()));
             var functionMetadataManager = TestFunctionMetadataManager.GetFunctionMetadataManager(new OptionsWrapper<ScriptJobHostOptions>(jobHostOptions), defaultProvider, null, new OptionsWrapper<HttpWorkerOptions>(new HttpWorkerOptions()), loggerFactory, new TestOptionsMonitor<LanguageWorkerOptions>(CreateLanguageWorkerConfigSettings()));
 
             _scriptHostManager = new TestScriptHostService(configuration);
diff --git a/test/WebJobs.Script.Tests.Integration/TestFunctionHost.cs b/test/WebJobs.Script.Tests.Integration/TestFunctionHost.cs
@@ -15,6 +15,7 @@
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.TestHost;
 using Microsoft.Azure.WebJobs.Host.Executors;
+using Microsoft.Azure.WebJobs.Script.Config;
 using Microsoft.Azure.WebJobs.Script.ExtensionBundle;
 using Microsoft.Azure.WebJobs.Script.Models;
 using Microsoft.Azure.WebJobs.Script.WebHost;
@@ -477,7 +478,7 @@ private FunctionMetadataManager GetMetadataManager(IOptionsMonitor<ScriptApplica
             var managerServiceProvider = manager as IServiceProvider;
 
             var metadataProvider = new HostFunctionMetadataProvider(optionsMonitor, NullLogger<HostFunctionMetadataProvider>.Instance, new TestMetricsLogger());
-            var defaultProvider = new FunctionMetadataProvider(NullLogger<FunctionMetadataProvider>.Instance, null, metadataProvider);
+            var defaultProvider = new FunctionMetadataProvider(NullLogger<FunctionMetadataProvider>.Instance, null, metadataProvider, new OptionsWrapper<FunctionsHostingConfigOptions>(new FunctionsHostingConfigOptions()));
             var metadataManager = new FunctionMetadataManager(managerServiceProvider.GetService<IOptions<ScriptJobHostOptions>>(), defaultProvider,
                 managerServiceProvider.GetService<IOptions<HttpWorkerOptions>>(), manager, factory, new TestOptionsMonitor<LanguageWorkerOptions>(workerOptions), environment);
 
diff --git a/test/WebJobs.Script.Tests.Integration/WebHostEndToEnd/ProxyEndToEndTests.cs b/test/WebJobs.Script.Tests.Integration/WebHostEndToEnd/ProxyEndToEndTests.cs
@@ -414,7 +414,7 @@ public TestFixture()
                 };
 
                 var hostProvider = new HostFunctionMetadataProvider(optionsMonitor, NullLogger<HostFunctionMetadataProvider>.Instance, new TestMetricsLogger());
-                var provider = new FunctionMetadataProvider(NullLogger<FunctionMetadataProvider>.Instance, null, hostProvider);
+                var provider = new FunctionMetadataProvider(NullLogger<FunctionMetadataProvider>.Instance, null, hostProvider, new OptionsWrapper<FunctionsHostingConfigOptions>(new FunctionsHostingConfigOptions()));
 
                 TestHost = new TestFunctionHost(HostOptions.ScriptPath, HostOptions.LogPath,
                     configureScriptHostServices: services =>
diff --git a/test/WebJobs.Script.Tests.Shared/TestHostBuilderExtensions.cs b/test/WebJobs.Script.Tests.Shared/TestHostBuilderExtensions.cs
@@ -6,6 +6,7 @@
 using Microsoft.Azure.WebJobs;
 using Microsoft.Azure.WebJobs.Host.Storage;
 using Microsoft.Azure.WebJobs.Script;
+using Microsoft.Azure.WebJobs.Script.Config;
 using Microsoft.Azure.WebJobs.Script.Description;
 using Microsoft.Azure.WebJobs.Script.Diagnostics;
 using Microsoft.Azure.WebJobs.Script.Grpc;
@@ -101,7 +102,8 @@ private static IServiceCollection AddFunctionMetadataManager(this IServiceCollec
             var optionsMonitor = new OptionsMonitor<ScriptApplicationHostOptions>(factory, changeTokens, factory);
 
             var metadataProvider = new HostFunctionMetadataProvider(optionsMonitor, NullLogger<HostFunctionMetadataProvider>.Instance, metricsLogger);
-            var defaultProvider = new FunctionMetadataProvider(NullLogger<FunctionMetadataProvider>.Instance, null, metadataProvider);
+            var hostingOptionsMonitor = TestHelpers.CreateOptionsMonitor(new FunctionsHostingConfigOptions());
+            var defaultProvider = new FunctionMetadataProvider(NullLogger<FunctionMetadataProvider>.Instance, null, metadataProvider, new OptionsWrapper<FunctionsHostingConfigOptions>(new FunctionsHostingConfigOptions()));
             var metadataManager = TestFunctionMetadataManager.GetFunctionMetadataManager(new OptionsWrapper<ScriptJobHostOptions>(new ScriptJobHostOptions()), defaultProvider, new List<IFunctionProvider>(), new OptionsWrapper<HttpWorkerOptions>(new HttpWorkerOptions()), new NullLoggerFactory(), new TestOptionsMonitor<LanguageWorkerOptions>(TestHelpers.GetTestLanguageWorkerOptions()));
             services.AddSingleton<IFunctionMetadataManager>(metadataManager);
             services.AddSingleton<IFunctionMetadataProvider>(defaultProvider);
diff --git a/test/WebJobs.Script.Tests/FunctionMetadataProviderTests.cs b/test/WebJobs.Script.Tests/FunctionMetadataProviderTests.cs
@@ -8,6 +8,7 @@
 using System.IO.Abstractions.TestingHelpers;
 using System.Linq;
 using System.Threading.Tasks;
+using Microsoft.Azure.WebJobs.Script.Config;
 using Microsoft.Azure.WebJobs.Script.Description;
 using Microsoft.Azure.WebJobs.Script.Diagnostics;
 using Microsoft.Azure.WebJobs.Script.Tests.Workers.Rpc;
@@ -56,7 +57,7 @@ public void GetFunctionMetadataAsync_WorkerIndexing_HostFallback()
             environment.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, "node");
             environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, "EnableWorkerIndexing");
 
-            var defaultProvider = new FunctionMetadataProvider(_logger, _workerFunctionMetadataProvider.Object, _hostFunctionMetadataProvider.Object);
+            var defaultProvider = new FunctionMetadataProvider(_logger, _workerFunctionMetadataProvider.Object, _hostFunctionMetadataProvider.Object, new OptionsWrapper<FunctionsHostingConfigOptions>(new FunctionsHostingConfigOptions()));
 
             FunctionMetadataResult result = new FunctionMetadataResult(true, functionMetadataCollection.ToImmutableArray());
             _workerFunctionMetadataProvider.Setup(m => m.GetFunctionMetadataAsync(workerConfigs, false)).Returns(Task.FromResult(result));
@@ -91,8 +92,8 @@ public void GetFunctionMetadataAsync_HostIndexing()
             var environment = SystemEnvironment.Instance;
             environment.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, "node");
             environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, string.Empty);
-
-            var defaultProvider = new FunctionMetadataProvider(_logger, _workerFunctionMetadataProvider.Object, _hostFunctionMetadataProvider.Object);
+            var optionsMonitor = TestHelpers.CreateOptionsMonitor(new FunctionsHostingConfigOptions());
+            var defaultProvider = new FunctionMetadataProvider(_logger, _workerFunctionMetadataProvider.Object, _hostFunctionMetadataProvider.Object, new OptionsWrapper<FunctionsHostingConfigOptions>(new FunctionsHostingConfigOptions()));
 
             FunctionMetadataResult result = new FunctionMetadataResult(true, functionMetadataCollection.ToImmutableArray());
             _hostFunctionMetadataProvider.Setup(m => m.GetFunctionMetadataAsync(workerConfigs, environment, false)).Returns(Task.FromResult(functionMetadataCollection.ToImmutableArray()));
diff --git a/test/WebJobs.Script.Tests/Managment/WebFunctionsManagerTests.cs b/test/WebJobs.Script.Tests/Managment/WebFunctionsManagerTests.cs
@@ -11,6 +11,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Azure.WebJobs.Host.Executors;
+using Microsoft.Azure.WebJobs.Script.Config;
 using Microsoft.Azure.WebJobs.Script.WebHost;
 using Microsoft.Azure.WebJobs.Script.WebHost.Management;
 using Microsoft.Azure.WebJobs.Script.Workers.Http;
@@ -85,7 +86,7 @@ public WebFunctionsManagerTests()
             FileUtility.Instance = fileSystem;
             _fileSystem = fileSystem;
             var metadataProvider = new HostFunctionMetadataProvider(optionsMonitor, NullLogger<HostFunctionMetadataProvider>.Instance, new TestMetricsLogger());
-            var defaultProvider = new FunctionMetadataProvider(NullLogger<FunctionMetadataProvider>.Instance, null, metadataProvider);
+            var defaultProvider = new FunctionMetadataProvider(NullLogger<FunctionMetadataProvider>.Instance, null, metadataProvider, new OptionsWrapper<FunctionsHostingConfigOptions>(new FunctionsHostingConfigOptions()));
             var functionMetadataManager = TestFunctionMetadataManager.GetFunctionMetadataManager(new OptionsWrapper<ScriptJobHostOptions>(new ScriptJobHostOptions()), defaultProvider, null, new OptionsWrapper<HttpWorkerOptions>(new HttpWorkerOptions()), loggerFactory, new TestOptionsMonitor<LanguageWorkerOptions>(TestHelpers.GetTestLanguageWorkerOptions()));
 
             var emptyOptions = new JobHostInternalStorageOptions();
diff --git a/test/WebJobs.Script.Tests/UtilityTests.cs b/test/WebJobs.Script.Tests/UtilityTests.cs

Original file line number	Diff line number	Diff line change
`@@ -924,28 +924,37 @@ public static void ValidateRetryOptions(RetryOptions`
`924`	`924`	`}`
`925`	`925`	`}`
`926`	`926`
`927`		`- public static bool CanWorkerIndex(IEnumerable<RpcWorkerConfig> workerConfigs, IEnvironment environment)`
	`927`	`+ // EnableWorkerIndexing set through AzureWebjobsFeatuerFlag always take precdence`
	`928`	`+ // if AzureWebjobsFeatuerFlag is not set then WORKER_INDEXING_ENABLED hosting config controls stamplevel enablement`
	`929`	`+ // if WORKER_INDEXING_ENABLED is set and WORKER_INDEXING_DISABLED contains the customers app name worker indexing is then disabled for that customer only`
	`930`	`+ // Also Worker indexing is disabled for Logic apps`
	`931`	`+ public static bool CanWorkerIndex(IEnumerable<RpcWorkerConfig> workerConfigs, IEnvironment environment, FunctionsHostingConfigOptions functionsHostingConfigOptions)`
`928`	`932`	`{`
`929`		`- if (!FeatureFlags.IsEnabled(ScriptConstants.FeatureFlagEnableWorkerIndexing, environment))`
	`933`	`+ string appName = environment.GetAzureWebsiteUniqueSlotName();`
	`934`	`+ bool workerIndexingEnabled = FeatureFlags.IsEnabled(ScriptConstants.FeatureFlagEnableWorkerIndexing, environment)`
	`935`	`+ \|\| (functionsHostingConfigOptions.WorkerIndexingEnabled`
	`936`	`+ && !functionsHostingConfigOptions.WorkerIndexingDisabledApps.ToLowerInvariant().Split("\|").Contains(appName)`
	`937`	`+ && !environment.IsLogicApp());`
	`938`	`+`
	`939`	`+ if (!workerIndexingEnabled)`
`930`	`940`	`{`
`931`	`941`	`return false;`
`932`	`942`	`}`
`933`	`943`
`934`		`- if (workerConfigs != null && !environment.IsMultiLanguageRuntimeEnvironment())`
	`944`	`+ bool workerIndexingAvailable = false;`
	`945`	`+ if (workerConfigs != null)`
`935`	`946`	`{`
`936`	`947`	`var workerRuntime = environment.GetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime);`
`937`	`948`	`var workerConfig = workerConfigs.FirstOrDefault(c => c.Description?.Language != null && c.Description.Language.Equals(workerRuntime, StringComparison.InvariantCultureIgnoreCase));`
`938`	`949`
`939`	`950`	`// if feature flag is enabled and workerConfig.WorkerIndexing == true, then return true`
`940`		`- if (workerConfig != null`
	`951`	`+ workerIndexingAvailable = workerConfig != null`
`941`	`952`	`&& workerConfig.Description != null`
`942`	`953`	`&& workerConfig.Description.WorkerIndexing != null`
`943`		`- && workerConfig.Description.WorkerIndexing.Equals("true", StringComparison.OrdinalIgnoreCase))`
`944`		`- {`
`945`		`- return true;`
`946`		`- }`
	`954`	`+ && workerConfig.Description.WorkerIndexing.Equals("true", StringComparison.OrdinalIgnoreCase);`
`947`	`955`	`}`
`948`		`- return false;`
	`956`	`+`
	`957`	`+ return workerIndexingEnabled && workerIndexingAvailable;`
`949`	`958`	`}`
`950`	`959`
`951`	`960`	`public static void LogAutorestGeneratedJsonIfExists(string rootScriptPath, ILogger logger)`
Original file line number	Diff line number	Diff line change
`@@ -81,5 +81,8 @@ public static class RpcWorkerConstants`
`81`	`81`	`public const string DotNetCoreDebugEngine = ".NETCore";`
`82`	`82`	`public const string DotNetFrameworkDebugEngine = ".NETFramework";`
`83`	`83`	`public const string DotNetFramework = "Framework";`
	`84`	`+`
	`85`	`+ public const string WorkerIndexingEnabled = "WORKER_INDEXING_ENABLED";`
	`86`	`+ public const string WorkerIndexingDisabledApps = "WORKER_INDEXING_DISABLED_APPS";`
`84`	`87`	`}`
`85`	`88`	`}`