Adding ILoggerFactory to the container, so it can be injected in a constructor parameter. (#3)

Author: junalmeida

Autofac.Extensions.DependencyInjection.AzureFunctions/ConfigurationExtensions.cs

@@ -27,24 +27,20 @@ public static IFunctionsHostBuilder UseAutofacServiceProviderFactory(this IFunct
         {
             var containerBuilder = new ContainerBuilder();
             containerBuilder.Populate(hostBuilder.Services);
-            configurationAction?.Invoke(containerBuilder);
+            containerBuilder.RegisterModule<LoggerModule>();
 
-            containerBuilder
-                .Register((ctx, p) =>
-                {
-                    var factory = p.Named<ILoggerFactory>("loggerFactory") ?? ctx.Resolve<ILoggerFactory>();
-                    var functionName = p.Named<string>("functionName") ?? "Unknown";
-                    return factory.CreateLogger(Microsoft.Azure.WebJobs.Logging.LogCategories.CreateFunctionUserCategory(functionName));
-                })
-                .AsSelf()
-                .InstancePerTriggerRequest();
+            // Call the user code to configure the container
+            configurationAction?.Invoke(containerBuilder);
 
             var container = containerBuilder.Build();
 
             var scoped = new ScopedJobActivator(new AutofacServiceProvider(container));
+
+            // Replacing Azure Functions ServiceProvider
             hostBuilder.Services.Replace(ServiceDescriptor.Singleton(typeof(IJobActivator), scoped));
             hostBuilder.Services.Replace(ServiceDescriptor.Singleton(typeof(IJobActivatorEx), scoped));
 
+            // This will create a scoped execution when a function is triggered.
             hostBuilder.Services.AddScoped((provider) =>
             {
                 var lifetimeScope = container.BeginLifetimeScope(Scopes.RootLifetimeScopeTag);

Autofac.Extensions.DependencyInjection.AzureFunctions/LoggerModule.cs

@@ -0,0 +1,35 @@
+using Microsoft.Extensions.Logging;
+
+namespace Autofac.Extensions.DependencyInjection.AzureFunctions
+{
+    internal class LoggerModule : Module
+    {
+        public const string functionNameParam = "functionName";
+        public const string loggerFactoryParam = "loggerFactory";
+
+        protected override void Load(ContainerBuilder builder)
+        {
+            builder
+                .Register((ctx, p) =>
+                {
+                    var factory = ctx.Resolve<ILoggerFactory>();
+                    var functionName = p.Named<string>(functionNameParam);
+
+                    return factory.CreateLogger(Microsoft.Azure.WebJobs.Logging.LogCategories.CreateFunctionUserCategory(functionName));
+                })
+                .AsSelf()
+                .InstancePerTriggerRequest();
+
+            builder
+                .Register((ctx, p) =>
+                {
+                    var factory = p.Named<ILoggerFactory>(loggerFactoryParam) ?? ctx.Resolve<ILoggerFactory>();
+
+                    return factory;
+                })
+                .AsSelf()
+                .SingleInstance();
+
+        }
+    }
+}

Autofac.Extensions.DependencyInjection.AzureFunctions/ScopedJobActivator.cs

@@ -31,14 +31,16 @@ public T CreateInstance<T>(IFunctionInstanceEx functionInstance)
             // ILoggerFactory from Autofac container. 
             // So we are retrieving it from InstanceServices.
             var loggerFactory = functionInstance.InstanceServices.GetService<ILoggerFactory>() ?? scope.Resolve<ILoggerFactory>();
-            var functionName = functionInstance.FunctionDescriptor.ShortName;
+            scope.Resolve<ILoggerFactory>(
+                new NamedParameter(LoggerModule.loggerFactoryParam, loggerFactory)
+            );
 
             // This will create the same ILogger of a regular ILogger not using DI.
             // This ILogger is scoped under the function trigger and will be disposed
             // right after the code execution.
+            var functionName = functionInstance.FunctionDescriptor.ShortName;
             scope.Resolve<ILogger>(
-                new NamedParameter(nameof(loggerFactory), loggerFactory),
-                new NamedParameter(nameof(functionName), functionName)
+                new NamedParameter(LoggerModule.functionNameParam, functionName)
             );
 
             return CreateInstance<T>(scope);

SampleAutofacFunction/Services/Service2.cs

@@ -7,11 +7,12 @@ class Service2 : IService2, IDisposable
     {
         private readonly Guid _id = Guid.NewGuid();
         private readonly ILogger _logger;
+        private readonly ILoggerFactory _loggerFactory;
 
-        public Service2(ILogger logger)
+        public Service2(ILogger logger, ILoggerFactory loggerFactory)
         {
             _logger = logger;
-
+            _loggerFactory = loggerFactory;
             _logger.LogWarning($"Creating {this}");
         }
         public string Value { get; set; } = "Example injected service 2";