Include empty entries when building InvocationRequest payload for OOP workers (#8642)

* Adding empty entries when preparing the RpcInvocation payload sent to OOP workers based on a new worker capability we are introducing "IncludeEmptyEntriesInMessagePayload"

* Removing capability check

* Updated release notesRevert "Removing capability check"

This reverts commit 52303be4

Author: kshyju

release_notes.md

@@ -9,6 +9,7 @@
 - Updated Java Worker Version to [2.4.0](https://github.com/Azure/azure-functions-java-worker/releases/tag/2.4.0)
 - Update PowerShell Worker 7.0 to 4.0.2255 [Release Note](https://github.com/Azure/azure-functions-powershell-worker/releases/tag/v4.0.2255)
 - Update PowerShell Worker 7.2 to 4.0.2258 [Release Note](https://github.com/Azure/azure-functions-powershell-worker/releases/tag/v4.0.2258)
+- Adding support to conditionally include empty entries from trigger payload when sending to OOP workers. ([#8499](https://github.com/Azure/azure-functions-host/issues/8499))
 
 **Release sprint:** Sprint 128
 [ [bugs](https://github.com/Azure/azure-functions-host/issues?q=is%3Aissue+milestone%3A%22Functions+Sprint+128%22+label%3Abug+is%3Aclosed) | [features](https://github.com/Azure/azure-functions-host/issues?q=is%3Aissue+milestone%3A%22Functions+Sprint+128%22+label%3Afeature+is%3Aclosed) ]

src/WebJobs.Script.Grpc/MessageExtensions/GrpcMessageConversionExtensions.cs

@@ -54,7 +54,8 @@ public static ValueTask<TypedData> ToRpc(this object value, ILogger logger, Grpc
                     string str => new TypedData() { String = str },
                     double dbl => new TypedData() { Double = dbl },
                     byte[][] arrBytes when IsTypedDataCollectionSupported(capabilities) => arrBytes.ToRpcByteArray(),
-                    string[] arrStr when IsTypedDataCollectionSupported(capabilities) => arrStr.ToRpcStringArray(),
+                    string[] arrStr when IsTypedDataCollectionSupported(capabilities) => arrStr.ToRpcStringArray(
+                                                            ShouldIncludeEmptyEntriesInMessagePayload(capabilities)),
                     double[] arrDouble when IsTypedDataCollectionSupported(capabilities) => arrDouble.ToRpcDoubleArray(),
                     long[] arrLong when IsTypedDataCollectionSupported(capabilities) => arrLong.ToRpcLongArray(),
                     _ => value.ToRpcDefault(),
@@ -203,7 +204,7 @@ private static async Task PopulateBodyAndRawBody(HttpRequest request, RpcHttp ht
                     rawBodyString = await request.ReadAsStringAsync();
                     try
                     {
-                        // REVIEW: We are json deserializing this to a JObject only to serialze
+                        // REVIEW: We are json deserializing this to a JObject only to serialize
                         // it back to string below. Why?
                         body = JsonConvert.DeserializeObject(rawBodyString);
                     }
@@ -273,16 +274,25 @@ internal static TypedData ToRpcByteArray(this byte[][] arrBytes)
             return typedData;
         }
 
-        internal static TypedData ToRpcStringArray(this string[] arrString)
+        internal static TypedData ToRpcStringArray(this string[] arrString, bool includeEmptyEntries)
         {
             TypedData typedData = new TypedData();
             CollectionString collectionString = new CollectionString();
             foreach (string element in arrString)
             {
-                if (!string.IsNullOrEmpty(element))
+                // Don't add null entries.("Add" method below will throw)
+                if (element is null)
                 {
-                    collectionString.String.Add(element);
+                    continue;
                 }
+
+                // Empty string entries are okay to add based on includeEmptyEntries param value.
+                if (element == string.Empty && !includeEmptyEntries)
+                {
+                    continue;
+                }
+
+                collectionString.String.Add(element);
             }
             typedData.CollectionString = collectionString;
 
@@ -315,6 +325,11 @@ internal static TypedData ToRpcLongArray(this long[] arrLong)
             return typedData;
         }
 
+        private static bool ShouldIncludeEmptyEntriesInMessagePayload(GrpcCapabilities capabilities)
+        {
+            return !string.IsNullOrWhiteSpace(capabilities.GetCapabilityState(RpcWorkerConstants.IncludeEmptyEntriesInMessagePayload));
+        }
+
         private static bool IsRawBodyBytesRequested(GrpcCapabilities capabilities)
         {
             return !string.IsNullOrEmpty(capabilities.GetCapabilityState(RpcWorkerConstants.RawHttpBodyBytes));

src/WebJobs.Script/Workers/Rpc/RpcWorkerConstants.cs

@@ -55,6 +55,11 @@ public static class RpcWorkerConstants
         public const string HandlesWorkerTerminateMessage = "HandlesWorkerTerminateMessage";
         public const string HandlesInvocationCancelMessage = "HandlesInvocationCancelMessage";
 
+        /// <summary>
+        /// Indicates whether empty entries in the trigger message should be included when sending RpcInvocation data to OOP workers.
+        /// </summary>
+        public const string IncludeEmptyEntriesInMessagePayload = "IncludeEmptyEntriesInMessagePayload";
+
         // Host Capabilities
         public const string V2Compatable = "V2Compatable";
 

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

@@ -485,6 +485,41 @@ public async Task ToRpc_Collection_String_Without_Capabilities_Value()
             Assert.Equal(typedData.Json, returned_typedata.Json);
         }
 
+        [Fact]
+        public async Task ToRpc_Collection_String_IgnoreEmptyEntries_When_Capability_Is_Not_Present()
+        {
+            var logger = MockNullLoggerFactory.CreateLogger();
+            var capabilities = new GrpcCapabilities(logger);
+            capabilities.UpdateCapabilities(new MapField<string, string>
+                {
+                    { RpcWorkerConstants.TypedDataCollection, bool.TrueString },
+                });
+
+            string[] arrString = { "element1", string.Empty, "element_2" };
+            TypedData actual = await arrString.ToRpc(logger, capabilities);
+
+            var expected = new RepeatedField<string> { "element1", "element_2" };
+            Assert.Equal(expected, actual.CollectionString.String);
+        }
+
+        [Fact]
+        public async Task ToRpc_Collection_String_IncludeEmptyEntries_When_Capability_Is_Present()
+        {
+            var logger = MockNullLoggerFactory.CreateLogger();
+            var capabilities = new GrpcCapabilities(logger);
+            capabilities.UpdateCapabilities(new MapField<string, string>
+                {
+                    { RpcWorkerConstants.TypedDataCollection, bool.TrueString },
+                    { RpcWorkerConstants.IncludeEmptyEntriesInMessagePayload, bool.TrueString }
+                });
+
+            string[] arrString = { "element1", string.Empty, "element_2", null };
+            TypedData actual = await arrString.ToRpc(logger, capabilities);
+
+            var expected = new RepeatedField<string> { "element1", string.Empty, "element_2" }; // null entry should be still skipped
+            Assert.Equal(expected, actual.CollectionString.String);
+        }
+
         [Fact]
         public async Task ToRpc_Collection_Long_With_Capabilities_Value()
         {