Add IHostApplicationBuilder support

src/NLog.Extensions.Hosting/Extensions/ConfigureExtensions.cs

@@ -45,6 +45,32 @@ public static IHostBuilder UseNLog(this IHostBuilder builder, NLogProviderOption
             return builder;
         }
 
+#if NET8_0_OR_GREATER
+        /// <summary>
+        /// Enable NLog as logging provider for Microsoft Extension Logging
+        /// </summary>
+        /// <param name="builder"></param>
+        /// <returns>IHostApplicationBuilder for chaining</returns>
+        public static IHostApplicationBuilder UseNLog(this IHostApplicationBuilder builder)
+        {
+            Guard.ThrowIfNull(builder);
+            return builder.UseNLog(null);
+        }
+
+        /// <summary>
+        /// Enable NLog as logging provider for Microsoft Extension Logging
+        /// </summary>
+        /// <param name="builder"></param>
+        /// <param name="options">NLogProviderOptions object to configure NLog behavior</param>
+        /// <returns>IHostApplicationBuilder for chaining</returns>
+        public static IHostApplicationBuilder UseNLog(this IHostApplicationBuilder builder, NLogProviderOptions options)
+        {
+            Guard.ThrowIfNull(builder);
+            builder.Services.TryAddNLogLoggingProvider((svc, addlogging) => svc.AddLogging(addlogging), builder.Configuration, options, (provider, cfg, opt) => CreateNLogLoggerProvider(provider, cfg, builder.Environment, opt));
+            return builder;
+        }
+#endif
+
         private static void AddNLogLoggerProvider(IServiceCollection services, IConfiguration hostConfiguration, IHostEnvironment hostEnvironment, NLogProviderOptions options, Func<IServiceProvider, IConfiguration, IHostEnvironment, NLogProviderOptions, NLogLoggerProvider> factory)
         {
             services.TryAddNLogLoggingProvider((svc, addlogging) => svc.AddLogging(addlogging), hostConfiguration, options, (provider, cfg, opt) => factory(provider, cfg, hostEnvironment, opt));
@@ -73,7 +99,7 @@ private static NLogLoggerProvider CreateNLogLoggerProvider(IServiceProvider serv
             {
                 provider.LogFactory.Setup().LoadConfigurationFromFile(nlogConfigFile, optional: true);
             }
-            
+
             provider.LogFactory.Setup().SetupLogFactory(ext => ext.AddCallSiteHiddenAssembly(typeof(ConfigureExtensions).Assembly));
             return provider;
         }

test/NLog.Extensions.Hosting.Tests/ExtensionMethodTests.cs

@@ -128,6 +128,136 @@ public void UseNLog_LoadConfigurationFromSection()
 
             Assert.Single(logged);
             Assert.Equal("logger1|error1|Memory", logged[0]);
+            //Reset
+            LogManager.Configuration = null;
         }
+
+#if NET8_0_OR_GREATER
+        [Fact]
+        public void IHostApplicationBuilder_UseNLog_ArgumentNullException()
+        {
+            IHostApplicationBuilder hostBuilder = null;
+            var argNulLException = Assert.Throws<ArgumentNullException>(() => hostBuilder.UseNLog());
+            Assert.Equal("builder", argNulLException.ParamName);
+        }
+
+        [Fact]
+        public void IHostApplicationBuilder_UseNLog_noParams_WorksWithNLog()
+        {
+            var builder = new HostApplicationBuilder();
+            builder.UseNLog();
+
+            var actual = builder.Build();
+            TestHostingResult(actual, true);
+        }
+
+        [Fact]
+        public void IHostApplicationBuilder_UseNLog_withOptionsParam_WorksWithNLog()
+        {
+            var someParam = new NLogProviderOptions { CaptureMessageProperties = false, CaptureMessageTemplates = false };
+
+            var builder = new HostApplicationBuilder();
+            builder.UseNLog(someParam);
+
+            var actual = builder.Build();
+            TestHostingResult(actual, true);
+        }
+
+        [Fact]
+        public void IHostApplicationBuilder_UseNLog_withConfiguration_WorksWithNLog()
+        {
+            var memoryConfig = new Dictionary<string, string>();
+            memoryConfig["NLog:CaptureMessageProperties"] = "true";
+            memoryConfig["NLog:CaptureMessageTemplates"] = "false";
+            memoryConfig["NLog:IgnoreScopes"] = "false";
+
+            var someParam = new NLogProviderOptions { CaptureMessageProperties = false, CaptureMessageTemplates = false };
+
+            var builder = new HostApplicationBuilder();
+            builder.Configuration.AddInMemoryCollection(memoryConfig);
+            builder.UseNLog(someParam);
+
+            var actual = builder.Build();
+            TestHostingResult(actual, true);
+        }
+
+        [Fact]
+        public void IHostApplicationBuilder_AddNLog_withShutdownOnDispose_worksWithNLog()
+        {
+            var someParam = new NLogProviderOptions { ShutdownOnDispose = true };
+
+            var builder = new HostApplicationBuilder();
+            builder.Logging.AddNLog(someParam);
+
+            var actual = builder.Build();
+            try
+            {
+                TestHostingResult(actual, false);
+                Assert.NotNull(LogManager.Configuration);
+            }
+            finally
+            {
+                actual.Dispose();
+                Assert.Null(LogManager.Configuration);
+            }
+        }
+
+        [Fact]
+        public void IHostApplicationBuilder_UseNLog_withAddNLog_worksWithNLog()
+        {
+            var builder = new HostApplicationBuilder();
+            builder.UseNLog();
+            builder.Logging.AddNLog();
+
+            var actual = builder.Build();
+            TestHostingResult(actual, true);
+        }
+
+        [Fact]
+        public void IHostApplicationBuilder_UseNLog_ReplaceLoggerFactory()
+        {
+            var builder = new HostApplicationBuilder();
+            builder.Services.AddLogging();
+            builder.UseNLog(new NLogProviderOptions() { ReplaceLoggerFactory = true, RemoveLoggerFactoryFilter = true });
+
+            var actual = builder.Build();
+
+            var loggerFactory = actual.Services.GetService<ILoggerFactory>();
+
+            Assert.Equal(typeof(NLogLoggerFactory), loggerFactory.GetType());
+        }
+
+        [Fact]
+        public void IHostApplicationBuilder_UseNLog_LoadConfigurationFromSection()
+        {
+            var memoryConfig = new Dictionary<string, string>();
+            memoryConfig["NLog:Rules:0:logger"] = "*";
+            memoryConfig["NLog:Rules:0:minLevel"] = "Trace";
+            memoryConfig["NLog:Rules:0:writeTo"] = "inMemory";
+            memoryConfig["NLog:Targets:inMemory:type"] = "Memory";
+            memoryConfig["NLog:Targets:inMemory:layout"] = "${logger}|${message}|${configsetting:NLog.Targets.inMemory.type}";
+
+            var builder = new HostApplicationBuilder();
+            builder.Configuration.AddInMemoryCollection(memoryConfig);
+            builder.UseNLog(new NLogProviderOptions() { LoggingConfigurationSectionName = "NLog", ReplaceLoggerFactory = true });
+
+            var host = builder.Build();
+
+            var loggerFact = host.Services.GetService<ILoggerFactory>();
+            var logger = loggerFact.CreateLogger("logger1");
+
+            ConfigSettingLayoutRenderer.DefaultConfiguration = null;    // See dependency resolving is working
+
+            logger.LogError("error1");
+
+            var loggerProvider = host.Services.GetService<ILoggerProvider>() as NLogLoggerProvider;
+            var logged = loggerProvider.LogFactory.Configuration.FindTargetByName<Targets.MemoryTarget>("inMemory").Logs;
+
+            Assert.Single(logged);
+            Assert.Equal("logger1|error1|Memory", logged[0]);
+            //Reset
+            LogManager.Configuration = null;
+        }
+#endif
     }
 }