Capture the property bag from metadata request and pass it to Function load request

src/WebJobs.Script.Grpc/Channel/GrpcWorkerChannel.cs

@@ -553,6 +553,13 @@ internal FunctionLoadRequest GetFunctionLoadRequest(FunctionMetadata metadata, M
 
                 request.Metadata.Bindings.Add(binding.Name, bindingInfo);
             }
+
+            foreach (var property in metadata.Properties)
+            {
+                // worker properties are expected to be string values
+                request.Metadata.Properties.Add(property.Key, property.Value?.ToString());
+            }
+
             return request;
         }
 
@@ -721,6 +728,14 @@ internal void ProcessFunctionMetadataResponses(FunctionMetadataResponse function
 
                     functionMetadata.SetFunctionId(metadata.FunctionId);
 
+                    foreach (var property in metadata.Properties)
+                    {
+                        if (!functionMetadata.Properties.TryAdd(property.Key, property.Value?.ToString()))
+                        {
+                            _workerChannelLogger?.LogDebug("{metadataPropertyKey} is already a part of metadata properties for {functionId}", property.Key, metadata.FunctionId);
+                        }
+                    }
+
                     var bindings = new List<string>();
                     foreach (string binding in metadata.RawBindings)
                     {

src/WebJobs.Script.Grpc/azure-functions-language-worker-protobuf/src/proto/FunctionRpc.proto

@@ -326,7 +326,7 @@ message RpcFunctionMetadata {
   // Properties for function metadata
   // They're usually specific to a worker and largely passed along to the controller API for use
   // outside the host
-   map<string,string> Properties = 16;
+   map<string,string> properties = 16;
 }
 
 // Host tells worker it is ready to receive metadata

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

@@ -16,6 +16,7 @@
 using Microsoft.Azure.WebJobs.Script.Grpc;
 using Microsoft.Azure.WebJobs.Script.Grpc.Eventing;
 using Microsoft.Azure.WebJobs.Script.Grpc.Messages;
+using Microsoft.Azure.WebJobs.Script.Tests.Description.DotNet;
 using Microsoft.Azure.WebJobs.Script.Workers;
 using Microsoft.Azure.WebJobs.Script.Workers.FunctionDataCache;
 using Microsoft.Azure.WebJobs.Script.Workers.Rpc;
@@ -605,6 +606,75 @@ public async Task SendLoadRequests_PublishesOutboundEvents_OrdersDisabled()
             Assert.Equal(3, functionLoadLogs.Count());
         }
 
+        [Fact]
+        public async Task GetFunctionMetadata_IncludesMetadataProperties()
+        {
+            await CreateDefaultWorkerChannel();
+
+            var functionMetadata = GetTestFunctionsList("python", true);
+            var functionId = "id123";
+            _testFunctionRpcService.OnMessage(StreamingMessage.ContentOneofCase.FunctionsMetadataRequest,
+               _ => _testFunctionRpcService.PublishWorkerMetadataResponse(_workerId, functionId, functionMetadata, successful: true, useDefaultMetadataIndexing: false));
+
+            var functions = await _workerChannel.GetFunctionMetadata();
+
+            Assert.Equal(functions[0].Metadata.Properties.Count, 4);
+            Assert.Equal(functions[0].Metadata.Properties["worker.functionId"], "fn1");
+        }
+
+        [Fact]
+        public async Task SendLoadRequests_IncludesMetadataProperties()
+        {
+            await CreateDefaultWorkerChannel();
+
+            var functionMetadata = GetTestFunctionsList("python", true);
+            var functionId = "id123";
+            _testFunctionRpcService.OnMessage(StreamingMessage.ContentOneofCase.FunctionsMetadataRequest,
+               _ => _testFunctionRpcService.PublishWorkerMetadataResponse(_workerId, functionId, functionMetadata, successful: true, useDefaultMetadataIndexing: false));
+
+            var functions = await _workerChannel.GetFunctionMetadata();
+
+            functionMetadata = functions.Select(f => f.Metadata);
+            _workerChannel.SetupFunctionInvocationBuffers(functionMetadata);
+            _workerChannel.SendFunctionLoadRequests(null, null);
+
+            _testFunctionRpcService.OnMessage(StreamingMessage.ContentOneofCase.FunctionLoadRequest,
+               (m) =>
+               {
+                   Assert.Contains("\"worker.functionId\": \"fn1\"", m.Message.ToString());
+               });
+
+            await Task.Delay(500);
+        }
+
+        [Fact]
+        public async Task GetFunctionLoadRequest_IncludesAvoidsDuplicateProperties()
+        {
+            await CreateDefaultWorkerChannel();
+            var functionMetadata = GetTestFunctionsList("python");
+            var functionId = "TestFunctionId1";
+            _testFunctionRpcService.OnMessage(StreamingMessage.ContentOneofCase.FunctionsMetadataRequest,
+               _ => _testFunctionRpcService.PublishWorkerMetadataResponse(_workerId, functionId, functionMetadata, true));
+            var functions = _workerChannel.GetFunctionMetadata();
+
+            await Task.Delay(500);
+            var traces = _logger.GetLogMessages();
+            ShowOutput(traces);
+            Assert.True(traces.Any(m => string.Equals(m.FormattedMessage, $"FunctionId is already a part of metadata properties for TestFunctionId1")));
+        }
+
+        [Fact]
+        public async Task GetFunctionLoadRequest_IncludesWorkerProperties()
+        {
+            await CreateDefaultWorkerChannel();
+
+            var functionMetadata = GetTestFunctionsList("python", true);
+            _workerChannel.SetupFunctionInvocationBuffers(functionMetadata);
+            var loadRequest = _workerChannel.GetFunctionLoadRequest(functionMetadata.ElementAt(0), null);
+
+            Assert.Equal(loadRequest.Metadata.Properties["worker.functionId"], "fn1");
+        }
+
         [Fact]
         public async Task SendLoadRequests_DoesNotTimeout_FunctionTimeoutNotSet()
         {
@@ -1136,7 +1206,7 @@ public async Task SendInvocationRequest_ValidateTraceContext_SessionId()
             }
         }
 
-        private IEnumerable<FunctionMetadata> GetTestFunctionsList(string runtime)
+        private IEnumerable<FunctionMetadata> GetTestFunctionsList(string runtime, bool addWorkerProperties = false)
         {
             var metadata1 = new FunctionMetadata()
             {
@@ -1147,6 +1217,12 @@ private IEnumerable<FunctionMetadata> GetTestFunctionsList(string runtime)
             metadata1.SetFunctionId("TestFunctionId1");
             metadata1.Properties.Add(LogConstants.CategoryNameKey, "testcat1");
             metadata1.Properties.Add(ScriptConstants.LogPropertyHostInstanceIdKey, "testhostId1");
+
+            if (addWorkerProperties)
+            {
+                metadata1.Properties.Add("worker.functionId", "fn1");
+            }
+
             var metadata2 = new FunctionMetadata()
             {
                 Language = runtime,
@@ -1156,6 +1232,12 @@ private IEnumerable<FunctionMetadata> GetTestFunctionsList(string runtime)
             metadata2.SetFunctionId("TestFunctionId2");
             metadata2.Properties.Add(LogConstants.CategoryNameKey, "testcat2");
             metadata2.Properties.Add(ScriptConstants.LogPropertyHostInstanceIdKey, "testhostId2");
+
+            if (addWorkerProperties)
+            {
+                metadata2.Properties.Add("WORKER.functionId", "fn2");
+            }
+
             return new List<FunctionMetadata>()
             {
                 metadata1,

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

@@ -11,7 +11,9 @@
 using Microsoft.Azure.WebJobs.Script.Eventing;
 using Microsoft.Azure.WebJobs.Script.Grpc.Eventing;
 using Microsoft.Azure.WebJobs.Script.Grpc.Messages;
+using Microsoft.Azure.WebJobs.Script.Workers.Rpc;
 using Microsoft.Extensions.Logging;
+using Newtonsoft.Json.Linq;
 
 namespace Microsoft.Azure.WebJobs.Script.Tests.Workers.Rpc
 {
@@ -324,6 +326,11 @@ public void PublishWorkerMetadataResponse(string workerId, string functionId, IE
                         FunctionId = functionId
                     };
 
+                    foreach (var property in response.Properties)
+                    {
+                        indexingResponse.Properties.Add(property.Key, property.Value.ToString());
+                    }
+
                     overallResponse.FunctionMetadataResults.Add(indexingResponse);
                 }
             }