Enabling worker indexing for Logic apps behind an enviornment setting

src/WebJobs.Script/Environment/EnvironmentExtensions.cs

@@ -425,6 +425,15 @@ public static bool IsLogicApp(this IEnvironment environment)
             return !string.IsNullOrEmpty(appKind) && appKind.Contains(ScriptConstants.WorkFlowAppKind);
         }
 
+        /// <summary>
+        /// Gets if codeful mode is enabled for Logic App app kind.
+        /// </summary>
+        public static bool IsLogicAppCodefulModeEnabled(this IEnvironment environment)
+        {
+            bool.TryParse(environment.GetEnvironmentVariable(EnvironmentSettingNames.LogicAppCodefulModeEnabled), out bool logicAppCodefulModeEnabled);
+            return logicAppCodefulModeEnabled;
+        }
+
         /// <summary>
         /// Gets if runtime environment needs multi language.
         /// </summary>

src/WebJobs.Script/Environment/EnvironmentSettingNames.cs

@@ -150,6 +150,8 @@ public static class EnvironmentSettingNames
 
         public const string AppKind = "APP_KIND";
 
+        public const string LogicAppCodefulModeEnabled = "WORKFLOW_CODEFUL_ENABLED";
+
         public const string DrainOnApplicationStopping = "FUNCTIONS_ENABLE_DRAIN_ON_APP_STOPPING";
     }
 }

src/WebJobs.Script/Host/ScriptHost.cs

@@ -787,7 +787,7 @@ internal async Task<Collection<FunctionDescriptor>> GetFunctionDescriptorsAsync(
             Collection<FunctionDescriptor> functionDescriptors = new Collection<FunctionDescriptor>();
             if (!cancellationToken.IsCancellationRequested)
             {
-                bool throwOnWorkerRuntimeAndPayloadMetadataMismatch = true;
+                bool throwOnWorkerRuntimeAndPayloadMetadataMismatch = !(_environment.IsLogicApp() && _environment.IsLogicAppCodefulModeEnabled());
                 // this dotnet isolated specific logic is temporary to ensure in-proc payload compatibility with "dotnet-isolated" as the FUNCTIONS_WORKER_RUNTIME value.
                 if (string.Equals(workerRuntime, RpcWorkerConstants.DotNetIsolatedLanguageWorkerName, StringComparison.OrdinalIgnoreCase))
                 {

src/WebJobs.Script/Utility.cs

@@ -1028,7 +1028,8 @@ public static void ValidateRetryOptions(RetryOptions
         // WORKER_INDEXING_DISABLED contains the customers app name worker indexing is then disabled for that customer only
         public static bool CanWorkerIndex(IEnumerable<RpcWorkerConfig> workerConfigs, IEnvironment environment, FunctionsHostingConfigOptions functionsHostingConfigOptions)
         {
-            if (environment.IsLogicApp())
+            // NOTE: Enabling the worker indexing for Logic Apps with codeful mode enabled.
+            if (environment.IsLogicApp() && !environment.IsLogicAppCodefulModeEnabled())
             {
                 return false;
             }

test/WebJobs.Script.Tests/UtilityTests.cs

@@ -966,6 +966,31 @@ public void WorkerIndexingDecisionLogic_NullConfig(bool workerIndexingFeatureFla
             Assert.Equal(expected, workerShouldIndex);
         }
 
+        [Theory]
+        [InlineData(true, true, true)]
+        [InlineData(true, false, false)]
+        public void WorkerIndexingDecisionLogic_LogicApps(bool workerIndexingFeatureFlag, bool enableIndexingForCodeful, bool expected)
+        {
+            var testEnv = new TestEnvironment();
+            testEnv.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, RpcWorkerConstants.DotNetExecutableName);
+            testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AppKind, ScriptConstants.WorkFlowAppKind);
+
+            if (workerIndexingFeatureFlag)
+            {
+                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagEnableWorkerIndexing);
+            }
+
+            if (enableIndexingForCodeful)
+            {
+                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.LogicAppCodefulModeEnabled, "true");
+            }
+
+            RpcWorkerConfig workerConfig = new RpcWorkerConfig() { Description = TestHelpers.GetTestWorkerDescription("dotnet", "none", true) };
+
+            bool workerShouldIndex = Utility.CanWorkerIndex(new List<RpcWorkerConfig>() { workerConfig }, testEnv, new FunctionsHostingConfigOptions());
+            Assert.Equal(expected, workerShouldIndex);
+        }
+
         [Theory]
         [InlineData(true, false)]
         [InlineData(false, false)]