Switching worker indexing feature flag from opt-in to opt-out (#8941)

Author: soninaren

release_notes.md

@@ -2,5 +2,6 @@
 <!-- Please add your release notes in the following format:
 - My change description (#PR)
 -->
+- Making feature flag for worker indexing opt-out instead of opt-in
 **Release sprint:** Sprint 132
 [ [bugs](https://github.com/Azure/azure-functions-host/issues?q=is%3Aissue+milestone%3A%22Functions+Sprint+132%22+label%3Abug+is%3Aclosed) | [features](https://github.com/Azure/azure-functions-host/issues?q=is%3Aissue+milestone%3A%22Functions+Sprint+132%22+label%3Afeature+is%3Aclosed) ]

src/WebJobs.Script/Host/WorkerFunctionMetadataProvider.cs

@@ -20,20 +20,20 @@ namespace Microsoft.Azure.WebJobs.Script
     internal class WorkerFunctionMetadataProvider : IWorkerFunctionMetadataProvider
     {
         private readonly Dictionary<string, ICollection<string>> _functionErrors = new Dictionary<string, ICollection<string>>();
-        private readonly IOptions<ScriptJobHostOptions> _scriptOptions;
+        private readonly IOptions<ScriptApplicationHostOptions> _scriptApplicationHostOptions;
         private readonly ILogger _logger;
         private readonly IEnvironment _environment;
         private readonly IWebHostRpcWorkerChannelManager _channelManager;
         private readonly string _workerRuntime;
         private ImmutableArray<FunctionMetadata> _functions;
 
         public WorkerFunctionMetadataProvider(
-            IOptions<ScriptJobHostOptions> scriptOptions,
+            IOptions<ScriptApplicationHostOptions> scriptOptions,
             ILogger<WorkerFunctionMetadataProvider> logger,
             IEnvironment environment,
             IWebHostRpcWorkerChannelManager webHostRpcWorkerChannelManager)
         {
-            _scriptOptions = scriptOptions;
+            _scriptApplicationHostOptions = scriptOptions;
             _logger = logger;
             _environment = environment;
             _channelManager = webHostRpcWorkerChannelManager;
@@ -91,7 +91,7 @@ public async Task<FunctionMetadataResult> GetFunctionMetadataAsync(IEnumerable<R
                             _logger.FunctionMetadataProviderFunctionFound(_functions.IsDefault ? 0 : _functions.Count());
 
                             // Validate if the app has functions in legacy format and add in logs to inform about the mixed app
-                            _ = Task.Delay(TimeSpan.FromMinutes(1)).ContinueWith(t => ValidateFunctionAppFormat(_scriptOptions.Value.RootScriptPath, _logger, environment));
+                            _ = Task.Delay(TimeSpan.FromMinutes(1)).ContinueWith(t => ValidateFunctionAppFormat(_scriptApplicationHostOptions.Value.ScriptPath, _logger, environment));
 
                             break;
                         }

src/WebJobs.Script/ScriptConstants.cs

@@ -118,7 +118,7 @@ public static class ScriptConstants
         public const string FeatureFlagDisableDiagnosticEventLogging = "DisableDiagnosticEventLogging";
         public const string FeatureFlagDisableMergedWebHostScriptHostConfiguration = "DisableMergedConfiguration";
         public const string FeatureFlagDisableAspNetCoreGrpc = "DisableAspNetCoreGrpc";
-        public const string FeatureFlagEnableWorkerIndexing = "EnableWorkerIndexing";
+        public const string FeatureFlagDisableWorkerIndexing = "DisableWorkerIndexing";
         public const string FeatureFlagEnableMultiLanguageWorker = "EnableMultiLanguageWorker";
         public const string FeatureFlagEnableLinuxEPExecutionCount = "EnableLinuxFEC";
 

src/WebJobs.Script/Utility.cs

@@ -912,12 +912,9 @@ public static void ValidateRetryOptions(RetryOptions
 
         public static bool CanWorkerIndex(IEnumerable<RpcWorkerConfig> workerConfigs, IEnvironment environment)
         {
-            if (!FeatureFlags.IsEnabled(ScriptConstants.FeatureFlagEnableWorkerIndexing, environment))
-            {
-                return false;
-            }
-
-            if (workerConfigs != null && !environment.IsMultiLanguageRuntimeEnvironment())
+            if (!FeatureFlags.IsEnabled(ScriptConstants.FeatureFlagDisableWorkerIndexing, environment)
+                && workerConfigs != null
+                && !environment.IsMultiLanguageRuntimeEnvironment())
             {
                 var workerRuntime = environment.GetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime);
                 var workerConfig = workerConfigs.Where(c => c.Description != null && c.Description.Language != null && c.Description.Language.Equals(workerRuntime, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();

test/WebJobs.Script.Tests.Integration/WebHostEndToEnd/EndToEndTestFixture.cs

@@ -122,6 +122,9 @@ string GetDestPath(int counter)
             string logPath = Path.Combine(Path.GetTempPath(), @"Functions");
             if (!string.IsNullOrEmpty(_functionsWorkerRuntime))
             {
+                string currentFeatureFlags = Environment.GetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags);
+                var featureFlags = string.IsNullOrEmpty(currentFeatureFlags) ? ScriptConstants.FeatureFlagDisableWorkerIndexing : $"{currentFeatureFlags}, {ScriptConstants.FeatureFlagDisableWorkerIndexing}";
+                Environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, featureFlags);
                 Environment.SetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeSettingName, _functionsWorkerRuntime);
                 Environment.SetEnvironmentVariable(RpcWorkerConstants.FunctionsWorkerProcessCountSettingName, _workerProcessCount.ToString());
             }

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

@@ -3,6 +3,8 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading.Tasks;
 using Microsoft.Azure.WebJobs;
 using Microsoft.Azure.WebJobs.Script;
 using Microsoft.Azure.WebJobs.Script.Description;
@@ -98,11 +100,13 @@ private static IServiceCollection AddFunctionMetadataManager(this IServiceCollec
             var optionsMonitor = new OptionsMonitor<ScriptApplicationHostOptions>(factory, changeTokens, factory);
 
             var hostMetadataProvider = new HostFunctionMetadataProvider(optionsMonitor, NullLogger<HostFunctionMetadataProvider>.Instance, metricsLogger);
-            var defaultProvider = new FunctionMetadataProvider(NullLogger<FunctionMetadataProvider>.Instance, null, hostMetadataProvider);
+
+            var workerProvider = new Mock<IWorkerFunctionMetadataProvider>();
+            workerProvider.Setup(m => m.GetFunctionMetadataAsync(It.IsAny<IEnumerable<RpcWorkerConfig>>(), SystemEnvironment.Instance, false)).Returns(Task.FromResult(new FunctionMetadataResult(true, ImmutableArray<FunctionMetadata>.Empty)));
+            var defaultProvider = new FunctionMetadataProvider(NullLogger<FunctionMetadataProvider>.Instance, workerProvider.Object, hostMetadataProvider);
             var metadataManager = TestFunctionMetadataManager.GetFunctionMetadataManager(new OptionsWrapper<ScriptJobHostOptions>(new ScriptJobHostOptions()), defaultProvider, new List<IFunctionProvider>(), new OptionsWrapper<HttpWorkerOptions>(new HttpWorkerOptions()), new NullLoggerFactory(), new OptionsWrapper<LanguageWorkerOptions>(TestHelpers.GetTestLanguageWorkerOptions()));
             services.AddSingleton<IFunctionMetadataManager>(metadataManager);
             services.AddSingleton<IFunctionMetadataProvider>(defaultProvider);
-
             return services;
         }
     }

test/WebJobs.Script.Tests/FunctionMetadataProviderTests.cs

@@ -84,7 +84,7 @@ public void GetFunctionMetadataAsync_HostIndexing()
             functionMetadataCollection.Add(GetTestFunctionMetadata());
 
             var workerConfigs = TestHelpers.GetTestWorkerConfigs().ToImmutableArray();
-            workerConfigs.ToList().ForEach(config => config.Description.WorkerIndexing = "true");
+            workerConfigs.ToList().ForEach(config => config.Description.WorkerIndexing = "false");
             var scriptjobhostoptions = new ScriptJobHostOptions();
             scriptjobhostoptions.RootScriptPath = Path.Combine(Environment.CurrentDirectory, @"..", "..", "..", "..", "..", "sample", "node");
 

test/WebJobs.Script.Tests/ScriptStartupTypeDiscovererTests.cs

@@ -517,7 +517,6 @@ void CopyToBin(string path)
                 tempOptions.WorkerConfigs.Add(workerConfig);
 
                 var languageWorkerOptions = new OptionsWrapper<LanguageWorkerOptions>(tempOptions);
-                Environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagEnableWorkerIndexing);
                 Environment.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, "python");
                 var discoverer = new ScriptStartupTypeLocator(directory.Path, testLogger, mockExtensionBundleManager.Object, mockFunctionMetadataManager, testMetricsLogger, languageWorkerOptions);
 

test/WebJobs.Script.Tests/UtilityTests.cs

@@ -854,17 +854,17 @@ public void GetFunctionAppContentEditingState_Returns_Expected(bool isFileSystem
         }
 
         [Theory]
-        [InlineData(false, true, false)]
-        [InlineData(false, false, false)]
+        [InlineData(true, true, false)]
         [InlineData(true, false, false)]
-        [InlineData(true, true, true)]
-        public void VerifyWorkerIndexingDecisionLogic(bool workerIndexingFeatureFlag, bool workerIndexingConfigProperty, bool expected)
+        [InlineData(false, false, false)]
+        [InlineData(false, true, true)]
+        public void VerifyWorkerIndexingDecisionLogic(bool disableWorkerIndexingFeatureFlag, bool workerIndexingConfigProperty, bool expected)
         {
             var testEnv = new TestEnvironment();
             testEnv.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, RpcWorkerConstants.PythonLanguageWorkerName);
-            if (workerIndexingFeatureFlag)
+            if (disableWorkerIndexingFeatureFlag)
             {
-                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagEnableWorkerIndexing);
+                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagDisableWorkerIndexing);
             }
             RpcWorkerConfig workerConfig = new RpcWorkerConfig() { Description = TestHelpers.GetTestWorkerDescription("python", "none", workerIndexingConfigProperty) };
             bool workerShouldIndex = Utility.CanWorkerIndex(new List<RpcWorkerConfig>() { workerConfig }, testEnv);
@@ -878,9 +878,9 @@ public void WorkerIndexingDecisionLogic_NullConfig(bool workerIndexingFeatureFla
         {
             var testEnv = new TestEnvironment();
             testEnv.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, RpcWorkerConstants.PythonLanguageWorkerName);
-            if (workerIndexingFeatureFlag)
+            if (!workerIndexingFeatureFlag)
             {
-                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagEnableWorkerIndexing);
+                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagDisableWorkerIndexing);
             }
             bool workerShouldIndex = Utility.CanWorkerIndex(null, testEnv);
             Assert.Equal(expected, workerShouldIndex);
@@ -893,9 +893,9 @@ public void WorkerIndexingDecisionLogic_NullConfigDescription(bool workerIndexin
         {
             var testEnv = new TestEnvironment();
             testEnv.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, RpcWorkerConstants.PythonLanguageWorkerName);
-            if (workerIndexingFeatureFlag)
+            if (!workerIndexingFeatureFlag)
             {
-                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagEnableWorkerIndexing);
+                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagDisableWorkerIndexing);
             }
             RpcWorkerConfig workerConfig = new RpcWorkerConfig();
             bool workerShouldIndex = Utility.CanWorkerIndex(new List<RpcWorkerConfig>() { workerConfig }, testEnv);
@@ -909,9 +909,9 @@ public void WorkerIndexingDecisionLogic_NullWorkerIndexingProperty(bool workerIn
         {
             var testEnv = new TestEnvironment();
             testEnv.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, RpcWorkerConstants.PythonLanguageWorkerName);
-            if (workerIndexingFeatureFlag)
+            if (!workerIndexingFeatureFlag)
             {
-                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagEnableWorkerIndexing);
+                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagDisableWorkerIndexing);
             }
             RpcWorkerConfig workerConfig = new RpcWorkerConfig()
             {

test/WebJobs.Script.Tests/Workers/Rpc/RpcFunctionInvocationDispatcherTests.cs

@@ -625,9 +625,9 @@ private static RpcFunctionInvocationDispatcher GetTestFunctionDispatcher(int max
             {
                 testEnv.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, runtime);
             }
-            if (workerIndexing)
+            if (!workerIndexing)
             {
-                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagEnableWorkerIndexing);
+                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagDisableWorkerIndexing);
             }
             if (placeholder)
             {