Merge pull request #5480 from Azure/dev

mhoeger · web-flow · commit 1f8e2cd63249 · 2020-01-14T20:08:52.000-08:00
Merge dev to v3.x
diff --git a/src/WebJobs.Script.WebHost/Diagnostics/LinuxContainerEventGenerator.cs b/src/WebJobs.Script.WebHost/Diagnostics/LinuxContainerEventGenerator.cs
@@ -38,7 +38,7 @@ public LinuxContainerEventGenerator(IEnvironment environment, Action<string> wri
 
         public static string DetailsEventRegex { get; } = $"{ScriptConstants.LinuxFunctionDetailsEventStreamName} (?<AppName>[^,]*),(?<FunctionName>[^,]*),\\\\\"(?<InputBindings>.*)\\\\\",\\\\\"(?<OutputBindings>.*)\\\\\",(?<ScriptType>[^,]*),(?<IsDisabled>[0|1])";
 
-        public static string AzureMonitorEventRegex { get; } = $"{ScriptConstants.LinuxAzureMonitorEventStreamName} (?<Level>[0-6]),(?<ResourceId>[^,]*),(?<OperationName>[^,]*),(?<Category>[^,]*),(?<RegionName>[^,]*),(?<Properties>[^,]*),(?<ContainerName>[^,\"]*),(?<TenantId>[^,\"]*),(?<EventTimestamp>[^,]+)";
+        public static string AzureMonitorEventRegex { get; } = $"{ScriptConstants.LinuxAzureMonitorEventStreamName} (?<Level>[0-6]),(?<ResourceId>[^,]*),(?<OperationName>[^,]*),(?<Category>[^,]*),(?<RegionName>[^,]*),\"(?<Properties>[^,]*)\",(?<ContainerName>[^,\"]*),(?<TenantId>[^,\"]*),(?<EventTimestamp>[^,]+)";
 
         private string StampName
         {
@@ -104,7 +104,7 @@ private void ConsoleWriter(string evt)
 
         public override void LogAzureMonitorDiagnosticLogEvent(LogLevel level, string resourceId, string operationName, string category, string regionName, string properties)
         {
-            _writeEvent($"{ScriptConstants.LinuxAzureMonitorEventStreamName} {(int)ToEventLevel(level)},{resourceId},{operationName},{category},{regionName},{properties},{_containerName},{TenantId}, {DateTime.UtcNow.ToString()}");
+            _writeEvent($"{ScriptConstants.LinuxAzureMonitorEventStreamName} {(int)ToEventLevel(level)},{resourceId},{operationName},{category},{regionName},{NormalizeString(properties)},{_containerName},{TenantId},{DateTime.UtcNow.ToString()}");
         }
     }
 }
diff --git a/src/WebJobs.Script/Extensions/HttpRequestExtensions.cs b/src/WebJobs.Script/Extensions/HttpRequestExtensions.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Net.Http.Headers;
+using System.Security.Claims;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Http.Extensions;
@@ -110,7 +111,7 @@ public static bool IsMediaTypeOctetOrMultipart(this HttpRequest request)
         public static async Task<JObject> GetRequestAsJObject(this HttpRequest request)
         {
             var jObjectHttp = new JObject();
-            jObjectHttp["Url"] = $"{(request.IsHttps ? "https" : "http")}://{request.Host.ToString()}{request.Path.ToString()}{request.QueryString.ToString()}"; // [http|https]://{url}{path}{query}
+            jObjectHttp["Url"] = $"{(request.IsHttps ? "https" : "http")}://{request.Host.ToString()}{request.Path.ToString()}{request.QueryString.ToString()}";
             jObjectHttp["Method"] = request.Method.ToString();
             if (request.Query != null)
             {
@@ -131,7 +132,7 @@ public static async Task<JObject> GetRequestAsJObject(this HttpRequest request)
 
             if (request.HttpContext?.User?.Identities != null)
             {
-                jObjectHttp["Identities"] = JsonConvert.SerializeObject(request.HttpContext.User.Identities);
+                jObjectHttp["Identities"] = GetUserIdentitiesAsString(request.HttpContext.User.Identities);
             }
 
             // parse request body as content-type
@@ -165,5 +166,14 @@ internal static IDictionary<string, string> GetQueryCollectionAsDictionary(this
             }
             return queryParamsDictionary;
         }
+
+        internal static string GetUserIdentitiesAsString(IEnumerable<ClaimsIdentity> claimsIdentities)
+        {
+            return JsonConvert.SerializeObject(claimsIdentities, new JsonSerializerSettings
+            {
+                // Claims property in Identities had circular reference to property 'Subject'
+                ReferenceLoopHandling = ReferenceLoopHandling.Ignore
+            });
+        }
     }
 }
diff --git a/src/WebJobs.Script/Host/FunctionMetadataManager.cs b/src/WebJobs.Script/Host/FunctionMetadataManager.cs
@@ -18,19 +18,17 @@ namespace Microsoft.Azure.WebJobs.Script
     public class FunctionMetadataManager : IFunctionMetadataManager
     {
         private const string _functionConfigurationErrorMessage = "Unable to determine the primary function script.Make sure atleast one script file is present.Try renaming your entry point script to 'run' or alternatively you can specify the name of the entry point script explicitly by adding a 'scriptFile' property to your function metadata.";
-        private readonly IEnumerable<RpcWorkerConfig> _workerConfigs;
         private readonly bool _isHttpWorker;
         private readonly Lazy<ImmutableArray<FunctionMetadata>> _functionMetadataArray;
         private readonly IOptions<ScriptJobHostOptions> _scriptOptions;
         private readonly IFunctionMetadataProvider _functionMetadataProvider;
         private readonly ILogger _logger;
         private Dictionary<string, ICollection<string>> _functionErrors = new Dictionary<string, ICollection<string>>();
 
-        public FunctionMetadataManager(IOptions<ScriptJobHostOptions> scriptOptions, IFunctionMetadataProvider functionMetadataProvider, IOptions<LanguageWorkerOptions> languageWorkerOptions, IOptions<HttpWorkerOptions> httpWorkerOptions, ILoggerFactory loggerFactory)
+        public FunctionMetadataManager(IOptions<ScriptJobHostOptions> scriptOptions, IFunctionMetadataProvider functionMetadataProvider, IOptions<HttpWorkerOptions> httpWorkerOptions, ILoggerFactory loggerFactory)
         {
             _scriptOptions = scriptOptions;
             _functionMetadataProvider = functionMetadataProvider;
-            _workerConfigs = languageWorkerOptions.Value.WorkerConfigs;
             _logger = loggerFactory.CreateLogger(LogCategories.Startup);
             _functionMetadataArray = new Lazy<ImmutableArray<FunctionMetadata>>(LoadFunctionMetadata);
             _isHttpWorker = httpWorkerOptions.Value.Description != null;
diff --git a/src/WebJobs.Script/Utility.cs b/src/WebJobs.Script/Utility.cs
@@ -585,6 +585,11 @@ internal static string GetWorkerRuntime(IEnumerable<FunctionMetadata> functions)
             {
                 var functionsListWithoutProxies = functions?.Where(f => f.IsProxy == false);
                 string functionLanguage = functionsListWithoutProxies.FirstOrDefault()?.Language;
+                if (string.IsNullOrEmpty(functionLanguage))
+                {
+                    return null;
+                }
+
                 if (IsDotNetLanguageFunction(functionLanguage))
                 {
                     return RpcWorkerConstants.DotNetLanguageWorkerName;
@@ -604,7 +609,7 @@ internal static bool IsFunctionMetadataLanguageSupportedByWorkerRuntime(Function
             {
                 return true;
             }
-            return functionMetadata.Language.Equals(workerRuntime, StringComparison.OrdinalIgnoreCase);
+            return !string.IsNullOrEmpty(functionMetadata.Language) && functionMetadata.Language.Equals(workerRuntime, StringComparison.OrdinalIgnoreCase);
         }
 
         public static bool IsDotNetLanguageFunction(string functionLanguage)
@@ -625,7 +630,7 @@ private static bool ContainsFunctionWithWorkerRuntime(IEnumerable<FunctionMetada
             }
             if (functions != null && functions.Any())
             {
-                return functions.Any(f => f.Language.Equals(workerRuntime, StringComparison.OrdinalIgnoreCase));
+                return functions.Any(f => !string.IsNullOrEmpty(f.Language) && f.Language.Equals(workerRuntime, StringComparison.OrdinalIgnoreCase));
             }
             return false;
         }
diff --git a/src/WebJobs.Script/Workers/Rpc/Configuration/RpcWorkerConfigFactory.cs b/src/WebJobs.Script/Workers/Rpc/Configuration/RpcWorkerConfigFactory.cs
@@ -143,6 +143,7 @@ internal void AddProvider(string workerDir)
                         workerDescription.FormatWorkerPathIfNeeded(_systemRuntimeInformation, _environment, _logger);
                         workerDescription.ThrowIfDefaultWorkerPathNotExists();
                         _workerDescripionDictionary[workerDescription.Language] = workerDescription;
+                        _logger.LogDebug($"Added WorkerConfig for language: {workerDescription.Language}");
                     }
                 }
                 catch (Exception ex)
@@ -226,6 +227,11 @@ internal string GetExecutablePathForJava(string defaultExecutablePath)
         internal bool ShouldAddWorkerConfig(string workerDescriptionLanguage)
         {
             string workerRuntime = _environment.GetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeSettingName);
+            if (_environment.IsPlaceholderModeEnabled())
+            {
+                return true;
+            }
+
             if (!string.IsNullOrEmpty(workerRuntime))
             {
                 _logger.LogDebug($"EnvironmentVariable {RpcWorkerConstants.FunctionWorkerRuntimeSettingName}: {workerRuntime}");
diff --git a/test/WebJobs.Script.Tests/Diagnostics/LinuxContainerEventGeneratorTests.cs b/test/WebJobs.Script.Tests/Diagnostics/LinuxContainerEventGeneratorTests.cs
@@ -214,7 +214,7 @@ public void ParseAzureMonitoringEvents(LogLevel level, string resourceId, string
                 p => Assert.Equal(operationName, p),
                 p => Assert.Equal(category, p),
                 p => Assert.Equal(regionName, p),
-                p => Assert.Equal(properties, p),
+                p => Assert.Equal(properties, UnNormalize(p)),
                 p => Assert.Equal(_containerName.ToUpperInvariant(), p),
                 p => Assert.Equal(_tenantId, p),
                 p => Assert.True(DateTime.TryParse(p, out DateTime dt)));
diff --git a/test/WebJobs.Script.Tests/Extensions/HttpRequestExtensionsTest.cs b/test/WebJobs.Script.Tests/Extensions/HttpRequestExtensionsTest.cs
@@ -3,6 +3,8 @@
 
 using System;
 using System.Collections.Generic;
+using System.Security.Claims;
+using System.Security.Principal;
 using System.Text;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Azure.WebJobs.Script.Config;
@@ -39,5 +41,27 @@ public void IsAppServiceInternalRequest_ReturnsExpectedResult()
                 Assert.True(request.IsAppServiceInternalRequest());
             }
         }
+
+        [Fact]
+        public void ConvertUserIdentitiesToString_RemovesCircularReference()
+        {
+            string expectedUserIdentities = "[{\"AuthenticationType\":\"TestAuthType\",\"IsAuthenticated\":true";
+            IIdentity identity = new TestIdentity();
+            Claim claim = new Claim("authlevel", "admin", "test", "LOCAL AUTHORITY", "LOCAL AUTHORITY");
+            List<Claim> claims = new List<Claim>() { claim };
+            ClaimsIdentity claimsIdentity = new ClaimsIdentity(identity, claims);
+            List<ClaimsIdentity> claimsIdentities = new List<ClaimsIdentity>() { claimsIdentity };
+            string userIdentitiesString = HttpRequestExtensions.GetUserIdentitiesAsString(claimsIdentities);
+            Assert.Contains(expectedUserIdentities, userIdentitiesString);
+        }
+    }
+
+    internal class TestIdentity : IIdentity
+    {
+        public string AuthenticationType => "TestAuthType";
+
+        public bool IsAuthenticated => true;
+
+        public string Name => "TestIdentityName";
     }
 }
diff --git a/test/WebJobs.Script.Tests/FunctionMetadataManagerTests.cs b/test/WebJobs.Script.Tests/FunctionMetadataManagerTests.cs
@@ -29,7 +29,7 @@ public FunctionMetadataManagerTests()
             string functionsPath = Path.Combine(Environment.CurrentDirectory, @"..\..\..\..\..\sample\node");
             _defaultHttpWorkerOptions = new HttpWorkerOptions();
             _scriptJobHostOptions.RootScriptPath = functionsPath;
-            _testFunctionMetadataManager = new FunctionMetadataManager(new OptionsWrapper<ScriptJobHostOptions>(_scriptJobHostOptions), _mockFunctionMetadataProvider.Object, new OptionsWrapper<LanguageWorkerOptions>(GetTestLanguageWorkerOptions()), new OptionsWrapper<HttpWorkerOptions>(_defaultHttpWorkerOptions), MockNullLoggerFactory.CreateLoggerFactory());
+            _testFunctionMetadataManager = new FunctionMetadataManager(new OptionsWrapper<ScriptJobHostOptions>(_scriptJobHostOptions), _mockFunctionMetadataProvider.Object, new OptionsWrapper<HttpWorkerOptions>(_defaultHttpWorkerOptions), MockNullLoggerFactory.CreateLoggerFactory());
         }
 
         [Theory]
@@ -54,7 +54,7 @@ public void FunctionMetadataManager_Verify_FunctionErrors(string scriptFile)
             mockFunctionMetadataProvider.Setup(m => m.GetFunctionMetadata(false)).Returns(functionMetadataCollection.ToImmutableArray());
             mockFunctionMetadataProvider.Setup(m => m.FunctionErrors).Returns(mockFunctionErrors);
 
-            FunctionMetadataManager testFunctionMetadataManager = new FunctionMetadataManager(new OptionsWrapper<ScriptJobHostOptions>(_scriptJobHostOptions), mockFunctionMetadataProvider.Object, new OptionsWrapper<LanguageWorkerOptions>(GetTestLanguageWorkerOptions()), new OptionsWrapper<HttpWorkerOptions>(_defaultHttpWorkerOptions), MockNullLoggerFactory.CreateLoggerFactory());
+            FunctionMetadataManager testFunctionMetadataManager = new FunctionMetadataManager(new OptionsWrapper<ScriptJobHostOptions>(_scriptJobHostOptions), mockFunctionMetadataProvider.Object, new OptionsWrapper<HttpWorkerOptions>(_defaultHttpWorkerOptions), MockNullLoggerFactory.CreateLoggerFactory());
 
             var validatedFunctionMetadataArray = testFunctionMetadataManager.LoadFunctionMetadata();
             Assert.Empty(validatedFunctionMetadataArray);
@@ -71,7 +71,7 @@ public void FunctionMetadataManager_Verify_FunctionErrors(string scriptFile)
         public void IsScriptFileDetermined_ScriptFile_Emtpy_HttpWorker_Returns_True(string scriptFile)
         {
             FunctionMetadata functionMetadata = GetTestFunctionMetadata(scriptFile);
-            FunctionMetadataManager testFunctionMetadataManager = new FunctionMetadataManager(new OptionsWrapper<ScriptJobHostOptions>(_scriptJobHostOptions), _mockFunctionMetadataProvider.Object, new OptionsWrapper<LanguageWorkerOptions>(GetTestLanguageWorkerOptions()), new OptionsWrapper<HttpWorkerOptions>(GetTestHttpWorkerOptions()), MockNullLoggerFactory.CreateLoggerFactory());
+            FunctionMetadataManager testFunctionMetadataManager = new FunctionMetadataManager(new OptionsWrapper<ScriptJobHostOptions>(_scriptJobHostOptions), _mockFunctionMetadataProvider.Object, new OptionsWrapper<HttpWorkerOptions>(GetTestHttpWorkerOptions()), MockNullLoggerFactory.CreateLoggerFactory());
 
             Assert.True(testFunctionMetadataManager.IsScriptFileDetermined(functionMetadata));
         }
diff --git a/test/WebJobs.Script.Tests/ScriptHostTests.cs b/test/WebJobs.Script.Tests/ScriptHostTests.cs
@@ -914,6 +914,37 @@ public void IsSupportedRuntime_Returns_True()
             Assert.True(Utility.IsSupportedRuntime(RpcWorkerConstants.NodeLanguageWorkerName, TestHelpers.GetTestWorkerConfigs()));
         }
 
+        [Fact]
+        public void GetWorkerRuntime_Returns_null()
+        {
+            FunctionMetadata funcJs1 = new FunctionMetadata()
+            {
+                Name = "funcJs1",
+                Language = "node"
+            };
+            FunctionMetadata funcPython1 = new FunctionMetadata()
+            {
+                Name = "funcPython1",
+                Language = null,
+            };
+            IEnumerable<FunctionMetadata> functionsList = new Collection<FunctionMetadata>()
+            {
+                funcJs1, funcPython1
+            };
+            string actualRuntime = Utility.GetWorkerRuntime(functionsList);
+            Assert.Equal(null, actualRuntime);
+
+            FunctionMetadata funcLanguageNull = new FunctionMetadata()
+            {
+                Name = "func"
+            };
+            functionsList = new Collection<FunctionMetadata>()
+            {
+                funcJs1, funcPython1, funcLanguageNull
+            };
+            Assert.Equal(null, actualRuntime);
+        }
+
         [Theory]
         [InlineData("CSharp")]
         [InlineData("DotNetAssembly")]
diff --git a/test/WebJobs.Script.Tests/Workers/Rpc/RpcWorkerConfigFactoryTests.cs b/test/WebJobs.Script.Tests/Workers/Rpc/RpcWorkerConfigFactoryTests.cs
@@ -223,12 +223,18 @@ public void AddArgumentsFromAppSettings_JavaOpts(string expectedArgument, string
         }
 
         [Theory]
-        [InlineData("python", "Python", true)]
-        [InlineData("python", "NOde", false)]
-        [InlineData("python", "", true)]
-        [InlineData("python", null, true)]
-        public void ShouldAddProvider_Returns_Expected(string workerLanguage, string workerRuntime, bool expectedResult)
+        [InlineData("python", "Python", false, true)]
+        [InlineData("python", "NOde", false, false)]
+        [InlineData("python", "", false, true)]
+        [InlineData("python", null, false, true)]
+        [InlineData("python", "NOde", true, true)]
+        [InlineData("python", null, true, true)]
+        public void ShouldAddProvider_Returns_Expected(string workerLanguage, string workerRuntime, bool placeholderMode, bool expectedResult)
         {
+            if (placeholderMode)
+            {
+                _testEnvironment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsitePlaceholderMode, "1");
+            }
             var expectedWorkersDir = Path.Combine(Path.GetDirectoryName(new Uri(typeof(RpcWorkerConfigFactory).Assembly.CodeBase).LocalPath), RpcWorkerConstants.DefaultWorkersDirectoryName);
             var config = new ConfigurationBuilder().Build();
             var testLogger = new TestLogger("test");

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public LinuxContainerEventGenerator(IEnvironment environment, Action<string> wri`
`38`	`38`
`39`	`39`	`public static string DetailsEventRegex { get; } = $"{ScriptConstants.LinuxFunctionDetailsEventStreamName} (?<AppName>[^,]),(?<FunctionName>[^,]),\\\\\"(?<InputBindings>.)\\\\\",\\\\\"(?<OutputBindings>.)\\\\\",(?<ScriptType>[^,]*),(?<IsDisabled>[0\|1])";`
`40`	`40`
`41`		`- public static string AzureMonitorEventRegex { get; } = $"{ScriptConstants.LinuxAzureMonitorEventStreamName} (?<Level>[0-6]),(?<ResourceId>[^,]),(?<OperationName>[^,]),(?<Category>[^,]),(?<RegionName>[^,]),(?<Properties>[^,]),(?<ContainerName>[^,\"]),(?<TenantId>[^,\"]*),(?<EventTimestamp>[^,]+)";`
	`41`	`+ public static string AzureMonitorEventRegex { get; } = $"{ScriptConstants.LinuxAzureMonitorEventStreamName} (?<Level>[0-6]),(?<ResourceId>[^,]),(?<OperationName>[^,]),(?<Category>[^,]),(?<RegionName>[^,]),\"(?<Properties>[^,])\",(?<ContainerName>[^,\"]),(?<TenantId>[^,\"]*),(?<EventTimestamp>[^,]+)";`
`42`	`42`
`43`	`43`	`private string StampName`
`44`	`44`	`{`
`@@ -104,7 +104,7 @@ private void ConsoleWriter(string evt)`
`104`	`104`
`105`	`105`	`public override void LogAzureMonitorDiagnosticLogEvent(LogLevel level, string resourceId, string operationName, string category, string regionName, string properties)`
`106`	`106`	`{`
`107`		`- _writeEvent($"{ScriptConstants.LinuxAzureMonitorEventStreamName} {(int)ToEventLevel(level)},{resourceId},{operationName},{category},{regionName},{properties},{_containerName},{TenantId}, {DateTime.UtcNow.ToString()}");`
	`107`	`+ _writeEvent($"{ScriptConstants.LinuxAzureMonitorEventStreamName} {(int)ToEventLevel(level)},{resourceId},{operationName},{category},{regionName},{NormalizeString(properties)},{_containerName},{TenantId},{DateTime.UtcNow.ToString()}");`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`using System.Collections.Generic;`
`6`	`6`	`using System.Linq;`
`7`	`7`	`using System.Net.Http.Headers;`
	`8`	`+using System.Security.Claims;`
`8`	`9`	`using System.Threading.Tasks;`
`9`	`10`	`using Microsoft.AspNetCore.Http;`
`10`	`11`	`using Microsoft.AspNetCore.Http.Extensions;`
`@@ -110,7 +111,7 @@ public static bool IsMediaTypeOctetOrMultipart(this HttpRequest request)`
`110`	`111`	`public static async Task<JObject> GetRequestAsJObject(this HttpRequest request)`
`111`	`112`	`{`
`112`	`113`	`var jObjectHttp = new JObject();`
`113`		`- jObjectHttp["Url"] = $"{(request.IsHttps ? "https" : "http")}://{request.Host.ToString()}{request.Path.ToString()}{request.QueryString.ToString()}"; // [http\|https]://{url}{path}{query}`
	`114`	`+ jObjectHttp["Url"] = $"{(request.IsHttps ? "https" : "http")}://{request.Host.ToString()}{request.Path.ToString()}{request.QueryString.ToString()}";`
`114`	`115`	`jObjectHttp["Method"] = request.Method.ToString();`
`115`	`116`	`if (request.Query != null)`
`116`	`117`	`{`
`@@ -131,7 +132,7 @@ public static async Task<JObject> GetRequestAsJObject(this HttpRequest request)`
`131`	`132`
`132`	`133`	`if (request.HttpContext?.User?.Identities != null)`
`133`	`134`	`{`
`134`		`- jObjectHttp["Identities"] = JsonConvert.SerializeObject(request.HttpContext.User.Identities);`
	`135`	`+ jObjectHttp["Identities"] = GetUserIdentitiesAsString(request.HttpContext.User.Identities);`
`135`	`136`	`}`
`136`	`137`
`137`	`138`	`// parse request body as content-type`
`@@ -165,5 +166,14 @@ internal static IDictionary<string, string> GetQueryCollectionAsDictionary(this`
`165`	`166`	`}`
`166`	`167`	`return queryParamsDictionary;`
`167`	`168`	`}`
	`169`	`+`
	`170`	`+ internal static string GetUserIdentitiesAsString(IEnumerable<ClaimsIdentity> claimsIdentities)`
	`171`	`+ {`
	`172`	`+ return JsonConvert.SerializeObject(claimsIdentities, new JsonSerializerSettings`
	`173`	`+ {`
	`174`	`+ // Claims property in Identities had circular reference to property 'Subject'`
	`175`	`+ ReferenceLoopHandling = ReferenceLoopHandling.Ignore`
	`176`	`+ });`
	`177`	`+ }`
`168`	`178`	`}`
`169`	`179`	`}`
Original file line number	Diff line number	Diff line change
`@@ -585,6 +585,11 @@ internal static string GetWorkerRuntime(IEnumerable<FunctionMetadata> functions)`
`585`	`585`	`{`
`586`	`586`	`var functionsListWithoutProxies = functions?.Where(f => f.IsProxy == false);`
`587`	`587`	`string functionLanguage = functionsListWithoutProxies.FirstOrDefault()?.Language;`
	`588`	`+ if (string.IsNullOrEmpty(functionLanguage))`
	`589`	`+ {`
	`590`	`+ return null;`
	`591`	`+ }`
	`592`	`+`
`588`	`593`	`if (IsDotNetLanguageFunction(functionLanguage))`
`589`	`594`	`{`
`590`	`595`	`return RpcWorkerConstants.DotNetLanguageWorkerName;`
`@@ -604,7 +609,7 @@ internal static bool IsFunctionMetadataLanguageSupportedByWorkerRuntime(Function`
`604`	`609`	`{`
`605`	`610`	`return true;`
`606`	`611`	`}`
`607`		`- return functionMetadata.Language.Equals(workerRuntime, StringComparison.OrdinalIgnoreCase);`
	`612`	`+ return !string.IsNullOrEmpty(functionMetadata.Language) && functionMetadata.Language.Equals(workerRuntime, StringComparison.OrdinalIgnoreCase);`
`608`	`613`	`}`
`609`	`614`
`610`	`615`	`public static bool IsDotNetLanguageFunction(string functionLanguage)`
`@@ -625,7 +630,7 @@ private static bool ContainsFunctionWithWorkerRuntime(IEnumerable<FunctionMetada`
`625`	`630`	`}`
`626`	`631`	`if (functions != null && functions.Any())`
`627`	`632`	`{`
`628`		`- return functions.Any(f => f.Language.Equals(workerRuntime, StringComparison.OrdinalIgnoreCase));`
	`633`	`+ return functions.Any(f => !string.IsNullOrEmpty(f.Language) && f.Language.Equals(workerRuntime, StringComparison.OrdinalIgnoreCase));`
`629`	`634`	`}`
`630`	`635`	`return false;`
`631`	`636`	`}`
Original file line number	Diff line number	Diff line change
`@@ -143,6 +143,7 @@ internal void AddProvider(string workerDir)`
`143`	`143`	`workerDescription.FormatWorkerPathIfNeeded(_systemRuntimeInformation, _environment, _logger);`
`144`	`144`	`workerDescription.ThrowIfDefaultWorkerPathNotExists();`
`145`	`145`	`_workerDescripionDictionary[workerDescription.Language] = workerDescription;`
	`146`	`+ _logger.LogDebug($"Added WorkerConfig for language: {workerDescription.Language}");`
`146`	`147`	`}`
`147`	`148`	`}`
`148`	`149`	`catch (Exception ex)`
`@@ -226,6 +227,11 @@ internal string GetExecutablePathForJava(string defaultExecutablePath)`
`226`	`227`	`internal bool ShouldAddWorkerConfig(string workerDescriptionLanguage)`
`227`	`228`	`{`
`228`	`229`	`string workerRuntime = _environment.GetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeSettingName);`
	`230`	`+ if (_environment.IsPlaceholderModeEnabled())`
	`231`	`+ {`
	`232`	`+ return true;`
	`233`	`+ }`
	`234`	`+`
`229`	`235`	`if (!string.IsNullOrEmpty(workerRuntime))`
`230`	`236`	`{`
`231`	`237`	`_logger.LogDebug($"EnvironmentVariable {RpcWorkerConstants.FunctionWorkerRuntimeSettingName}: {workerRuntime}");`