Implementing function metadata transform support (#3145)

* Implementing function metadata transform support

* Updates to metadata transform feature

---------

Co-authored-by: Fabio Cavalcante <[email protected]>

Author: liliankasem

release_notes.md

@@ -10,8 +10,8 @@
 
 ### Microsoft.Azure.Functions.Worker.Core <version>
 
-- <entry>
+- Support for function metadata transforms (#3145)
 
 ### Microsoft.Azure.Functions.Worker.Grpc <version>
 
-- <entry>
+- Updated to use the new metadata manage and leverage metadata transforms (#3145)

src/DotNetWorker.Core/FunctionMetadata/DefaultFunctionMetadataManager.cs

@@ -0,0 +1,62 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Azure.Functions.Worker.Core.FunctionMetadata
+{
+    internal sealed class DefaultFunctionMetadataManager : IFunctionMetadataManager
+    {
+        private readonly IFunctionMetadataProvider _functionMetadataProvider;
+        private readonly ImmutableArray<IFunctionMetadataTransformer> _transformers;
+        private readonly ILogger<DefaultFunctionMetadataManager> _logger;
+
+        public DefaultFunctionMetadataManager(IFunctionMetadataProvider functionMetadataProvider,
+                                              IEnumerable<IFunctionMetadataTransformer> transformers,
+                                              ILogger<DefaultFunctionMetadataManager> logger)
+        {
+            _functionMetadataProvider = functionMetadataProvider;
+            _transformers = transformers.ToImmutableArray();
+            _logger = logger;
+        }
+
+        public async Task<ImmutableArray<IFunctionMetadata>> GetFunctionMetadataAsync(string directory)
+        {
+            ImmutableArray<IFunctionMetadata> functionMetadata = await _functionMetadataProvider.GetFunctionMetadataAsync(directory);
+
+            return ApplyTransforms(functionMetadata);
+        }
+
+        private ImmutableArray<IFunctionMetadata> ApplyTransforms(ImmutableArray<IFunctionMetadata> functionMetadata)
+        {
+            // Return early if there are no transformers to apply
+            if (_transformers.Length == 0)
+            {
+                return functionMetadata;
+            }
+
+            var metadataResult = functionMetadata.ToBuilder();
+
+            foreach (var transformer in _transformers)
+            {
+                try
+                {
+                    _logger?.LogTrace("Applying metadata transformer: {Transformer}.", transformer.Name);
+                    transformer.Transform(metadataResult);
+                }
+                catch (Exception exc)
+                {
+                    _logger?.LogError(exc, "Metadata transformer '{Transformer}' failed.", transformer.Name);
+                    throw;
+                }
+            }
+
+            return metadataResult.ToImmutable();
+        }
+    }
+}

src/DotNetWorker.Core/FunctionMetadata/IFunctionMetadataManager.cs

@@ -0,0 +1,20 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System.Collections.Immutable;
+using System.Threading.Tasks;
+
+namespace Microsoft.Azure.Functions.Worker.Core.FunctionMetadata
+{
+    /// <summary>
+    /// Manages function metadata, providing functionality that combines metadata from the registered provider and metadata transforms.
+    /// </summary>
+    public interface IFunctionMetadataManager
+    {
+        /// <summary>
+        /// Retrieves all function metadata for the current application.
+        /// </summary>
+        /// <returns>A <see cref="Task{TResult}"/> representing the asynchronous metadata retrieval operation, where the result is an <see cref="ImmutableArray{IFunctionMetadata}"/>.</returns>
+        Task<ImmutableArray<IFunctionMetadata>> GetFunctionMetadataAsync(string directory);
+    }
+}

src/DotNetWorker.Core/FunctionMetadata/IFunctionMetadataTransformer.cs

@@ -0,0 +1,24 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+
+namespace Microsoft.Azure.Functions.Worker.Core.FunctionMetadata;
+
+/// <summary>
+/// Defines a contract for transforming <see cref="IFunctionMetadata"/> instances for Azure Functions.
+/// Implementations can modify, augment, or filter function metadata before it is used by the host.
+/// </summary>
+public interface IFunctionMetadataTransformer
+{
+    /// <summary>
+    /// Gets the name of the transformer.
+    /// </summary>
+    public string Name { get; }
+
+    /// <summary>
+    /// Transforms the provided collection of <see cref="IFunctionMetadata"/> instances.
+    /// </summary>
+    /// <param name="original">The original collection of function metadata. This collection may be modified.</param>
+    void Transform(IList<IFunctionMetadata> original);
+}

src/DotNetWorker.Core/Hosting/ServiceCollectionExtensions.cs

@@ -10,13 +10,13 @@
 using Microsoft.Azure.Functions.Worker.Context.Features;
 using Microsoft.Azure.Functions.Worker.Converters;
 using Microsoft.Azure.Functions.Worker.Core;
+using Microsoft.Azure.Functions.Worker.Core.FunctionMetadata;
 using Microsoft.Azure.Functions.Worker.Diagnostics;
 using Microsoft.Azure.Functions.Worker.Invocation;
 using Microsoft.Azure.Functions.Worker.Logging;
 using Microsoft.Azure.Functions.Worker.OutputBindings;
 using Microsoft.Azure.Functions.Worker.Pipeline;
 using Microsoft.Extensions.DependencyInjection.Extensions;
-using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 
@@ -71,6 +71,9 @@ public static IFunctionsWorkerApplicationBuilder AddFunctionsWorkerCore(this ISe
             // Worker initialization service
             services.AddHostedService<WorkerHostedService>();
 
+            // Worker metadata management
+            services.TryAddSingleton<IFunctionMetadataManager, DefaultFunctionMetadataManager>();
+
             // Default serializer settings
             services.AddOptions();
             services.TryAddEnumerable(ServiceDescriptor.Transient<IPostConfigureOptions<WorkerOptions>, WorkerOptionsSetup>());

src/DotNetWorker.Grpc/GrpcWorker.cs

@@ -4,7 +4,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text.RegularExpressions;
 using System.Threading;
@@ -18,7 +17,6 @@
 using Microsoft.Azure.Functions.Worker.Invocation;
 using Microsoft.Azure.Functions.Worker.Rpc;
 using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using MsgType = Microsoft.Azure.Functions.Worker.Grpc.Messages.StreamingMessage.ContentOneofCase;
 
@@ -32,14 +30,14 @@ internal partial class GrpcWorker : IWorker, IMessageProcessor
         private readonly IHostApplicationLifetime _hostApplicationLifetime;
         private readonly IWorkerClientFactory _workerClientFactory;
         private readonly IInvocationHandler _invocationHandler;
-        private readonly IFunctionMetadataProvider _functionMetadataProvider;
+        private readonly IFunctionMetadataManager _metadataManager;
         private IWorkerClient? _workerClient;
 
         public GrpcWorker(IFunctionsApplication application,
                           IWorkerClientFactory workerClientFactory,
                           IMethodInfoLocator methodInfoLocator,
                           IOptions<WorkerOptions> workerOptions,
-                          IFunctionMetadataProvider functionMetadataProvider,
+                          IFunctionMetadataManager metadataManager,
                           IHostApplicationLifetime hostApplicationLifetime,
                           IInvocationHandler invocationHandler)
         {
@@ -48,7 +46,7 @@ public GrpcWorker(IFunctionsApplication application,
             _application = application ?? throw new ArgumentNullException(nameof(application));
             _methodInfoLocator = methodInfoLocator ?? throw new ArgumentNullException(nameof(methodInfoLocator));
             _workerOptions = workerOptions.Value ?? throw new ArgumentNullException(nameof(workerOptions));
-            _functionMetadataProvider = functionMetadataProvider ?? throw new ArgumentNullException(nameof(functionMetadataProvider));
+            _metadataManager = metadataManager ?? throw new ArgumentNullException(nameof(metadataManager));
 
             _invocationHandler = invocationHandler;
         }
@@ -152,7 +150,7 @@ private async Task<FunctionMetadataResponse> GetFunctionMetadataAsync(string fun
 
             try
             {
-                var functionMetadataList = await _functionMetadataProvider.GetFunctionMetadataAsync(functionAppDirectory);
+                var functionMetadataList = await _metadataManager.GetFunctionMetadataAsync(functionAppDirectory);
 
                 foreach (var func in functionMetadataList)
                 {

test/DotNetWorkerTests/FunctionMetadata/DefaultFunctionMetadataManagerTests.cs

@@ -0,0 +1,99 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading.Tasks;
+using Microsoft.Azure.Functions.Worker.Core.FunctionMetadata;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Xunit;
+
+namespace Microsoft.Azure.Functions.Worker.Tests.FunctionMetadata
+{
+    public class DefaultFunctionMetadataManagerTests
+    {
+        [Fact]
+        public async Task GetFunctionMetadataAsync_ReturnsTransformedMetadata()
+        {
+            var mockProvider = new Mock<IFunctionMetadataProvider>(MockBehavior.Strict);
+            var mockTransformer = new Mock<IFunctionMetadataTransformer>(MockBehavior.Strict);
+            var mockLogger = new Mock<ILogger<DefaultFunctionMetadataManager>>();
+
+            var metadata = new List<IFunctionMetadata> { new TestFunctionMetadata() }.ToImmutableArray();
+            mockProvider.Setup(p => p.GetFunctionMetadataAsync(It.IsAny<string>())).ReturnsAsync(metadata);
+
+            mockTransformer.SetupGet(t => t.Name).Returns("TestTransformer");
+            mockTransformer.Setup(t => t.Transform(It.IsAny<IList<IFunctionMetadata>>()));
+
+            var manager = new DefaultFunctionMetadataManager(
+                mockProvider.Object,
+                new[] { mockTransformer.Object },
+                mockLogger.Object);
+
+            var result = await manager.GetFunctionMetadataAsync("test");
+
+            Assert.Single(result);
+            mockProvider.Verify(p => p.GetFunctionMetadataAsync("test"), Times.Once);
+            mockTransformer.Verify(t => t.Transform(It.IsAny<IList<IFunctionMetadata>>()), Times.Once);
+        }
+
+        [Fact]
+        public async Task GetFunctionMetadataAsync_NoTransformers_ReturnsOriginalMetadata()
+        {
+            var mockProvider = new Mock<IFunctionMetadataProvider>(MockBehavior.Strict);
+            var mockLogger = new Mock<ILogger<DefaultFunctionMetadataManager>>();
+            var metadata = new List<IFunctionMetadata> { new TestFunctionMetadata() }.ToImmutableArray();
+            mockProvider.Setup(p => p.GetFunctionMetadataAsync(It.IsAny<string>())).ReturnsAsync(metadata);
+
+            var manager = new DefaultFunctionMetadataManager(
+                mockProvider.Object,
+                Array.Empty<IFunctionMetadataTransformer>(),
+                mockLogger.Object);
+
+            var result = await manager.GetFunctionMetadataAsync("test");
+
+            Assert.Single(result);
+            mockProvider.Verify(p => p.GetFunctionMetadataAsync("test"), Times.Once);
+        }
+
+        [Fact]
+        public async Task GetFunctionMetadataAsync_TransformerThrows_LogsAndThrows()
+        {
+            var mockProvider = new Mock<IFunctionMetadataProvider>(MockBehavior.Strict);
+            var mockTransformer = new Mock<IFunctionMetadataTransformer>(MockBehavior.Strict);
+            var mockLogger = new Mock<ILogger<DefaultFunctionMetadataManager>>();
+            var metadata = ImmutableArray<IFunctionMetadata>.Empty;
+
+            mockProvider.Setup(p => p.GetFunctionMetadataAsync(It.IsAny<string>())).ReturnsAsync(metadata);
+            mockTransformer.SetupGet(t => t.Name).Returns("ThrowingTransformer");
+            mockTransformer.Setup(t => t.Transform(It.IsAny<IList<IFunctionMetadata>>()))
+                .Throws(new InvalidOperationException("fail"));
+
+            var manager = new DefaultFunctionMetadataManager(
+                mockProvider.Object,
+                new[] { mockTransformer.Object },
+                mockLogger.Object);
+
+            var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => manager.GetFunctionMetadataAsync("test"));
+            Assert.Equal("fail", ex.Message);
+            mockLogger.Verify(l => l.Log(
+                LogLevel.Error,
+                It.IsAny<EventId>(),
+                It.Is<It.IsAnyType>((v, t) => v.ToString().Contains("ThrowingTransformer")),
+                It.IsAny<Exception>(),
+                It.IsAny<Func<It.IsAnyType, Exception, string>>()), Times.Once);
+        }
+
+        private class TestFunctionMetadata : IFunctionMetadata
+        {
+            public string? FunctionId => "id";
+            public bool IsProxy => false;
+            public string? Language => "dotnet";
+            public bool ManagedDependencyEnabled => false;
+            public string? Name => "Test";
+            public string? EntryPoint => "Test.Run";
+            public IList<string>? RawBindings => new List<string>();
+            public string? ScriptFile => "Test.dll";
+            public IRetryOptions? Retry => null;
+        }
+    }
+}

test/DotNetWorkerTests/GrpcWorkerTests.cs

@@ -279,7 +279,7 @@ public async Task Invocation_WhenSynchronous_DoesNotBlock()
 
             var clientFactoryMock = new Mock<IWorkerClientFactory>();
             var clientMock = new Mock<IWorkerClient>();
-            var metadataProvider = new Mock<IFunctionMetadataProvider>();
+            var metadataManager = new Mock<IFunctionMetadataManager>();
             var invocationHandlerMock = new Mock<IInvocationHandler>();
 
             InvocationResponse ValueFunction(InvocationRequest request)
@@ -310,7 +310,7 @@ InvocationResponse ValueFunction(InvocationRequest request)
                                         clientFactoryMock.Object,
                                         _mockMethodInfoLocator.Object,
                                         new OptionsWrapper<WorkerOptions>(new WorkerOptions()),
-                                        metadataProvider.Object,
+                                        metadataManager.Object,
                                         new ApplicationLifetime(TestLogger<ApplicationLifetime>.Create()),
                                         invocationHandlerMock.Object);