Support host-appname and host-basedir and host-environment (#789)

snakefoot · web-flow · commit 2172c9e3a5a2 · 2025-06-07T09:47:14.000+02:00
diff --git a/examples/NetCore2/HostingExample/Program.cs b/examples/NetCore2/HostingExample/Program.cs
@@ -18,7 +18,7 @@ private static async Task Main()
             var config = new ConfigurationBuilder().Build();
 
             var logger = LogManager.Setup()
-                                   .SetupExtensions(ext => ext.RegisterConfigSettings(config))
+                                   .SetupExtensions(ext => ext.RegisterHostSettings(config))
                                    .GetCurrentClassLogger();
 
             try
diff --git a/src/NLog.Extensions.Hosting/Config/SetupExtensionsBuilderExtensions.cs b/src/NLog.Extensions.Hosting/Config/SetupExtensionsBuilderExtensions.cs
@@ -0,0 +1,24 @@
+﻿using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Hosting;
+using NLog.Config;
+using NLog.Extensions.Logging;
+
+namespace NLog.Extensions.Hosting
+{
+    /// <summary>
+    /// Extension methods to setup NLog extensions, so they are known when loading NLog LoggingConfiguration
+    /// </summary>
+    public static class SetupExtensionsBuilderExtensions
+    {
+        /// <summary>
+        /// Setup the MEL-configuration for the ${configsetting} layoutrenderer
+        /// </summary>
+        public static ISetupExtensionsBuilder RegisterHostSettings(this ISetupExtensionsBuilder setupBuilder, IConfiguration? configuration)
+        {
+            setupBuilder.RegisterConfigSettings(configuration);
+            return setupBuilder.RegisterLayoutRenderer<HostAppNameLayoutRenderer>("host-appname")
+                        .RegisterLayoutRenderer<HostBaseDirLayoutRenderer>("host-basedir")
+                        .RegisterLayoutRenderer<HostEnvironmentLayoutRenderer>("host-environment");
+        }
+    }
+}
diff --git a/src/NLog.Extensions.Hosting/Extensions/ConfigureExtensions.cs b/src/NLog.Extensions.Hosting/Extensions/ConfigureExtensions.cs
@@ -60,6 +60,7 @@ public static IHostBuilder UseNLog(this IHostBuilder builder, NLogProviderOption
             builder.ConfigureServices((builderContext, services) => AddNLogLoggerProvider(services, builderContext.Configuration, builderContext.HostingEnvironment, options, (serviceProvider, config, hostEnv, opt) =>
 #endif
             {
+                RegisterHostNLogExtensions(LogManager.LogFactory, serviceProvider, hostEnv);
                 config = serviceProvider.SetupNLogConfigSettings(config, LogManager.LogFactory);
 
                 // Delay initialization of targets until we have loaded config-settings
@@ -107,6 +108,7 @@ public static IHostApplicationBuilder UseNLog(this IHostApplicationBuilder build
             Guard.ThrowIfNull(builder);
             builder.Services.TryAddNLogLoggingProvider((svc, addlogging) => svc.AddLogging(addlogging), builder.Configuration, options, (serviceProvider, config, opt) =>
             {
+                RegisterHostNLogExtensions(LogManager.LogFactory, serviceProvider, builder.Environment);
                 config = serviceProvider.SetupNLogConfigSettings(config, LogManager.LogFactory);
 
                 // Delay initialization of targets until we have loaded config-settings
@@ -125,11 +127,13 @@ private static void AddNLogLoggerProvider(IServiceCollection services, IConfigur
 
         private static NLogLoggerProvider CreateNLogLoggerProvider(IServiceProvider serviceProvider, IConfiguration? hostConfiguration, IHostEnvironment? hostEnvironment, NLogProviderOptions options)
         {
-            return serviceProvider.CreateNLogLoggerProvider(hostConfiguration, options, LogManager.LogFactory);
+            return CreateNLogLoggerProvider(serviceProvider, hostConfiguration, hostEnvironment, options, LogManager.LogFactory);
         }
 
         private static NLogLoggerProvider CreateNLogLoggerProvider(IServiceProvider serviceProvider, IConfiguration? hostConfiguration, IHostEnvironment? hostEnvironment, NLogProviderOptions options, LogFactory logFactory)
         {
+            RegisterHostNLogExtensions(logFactory, serviceProvider, hostEnvironment);
+
             NLogLoggerProvider provider = serviceProvider.CreateNLogLoggerProvider(hostConfiguration, options, logFactory);
 
             string nlogConfigFile = string.Empty;
@@ -158,6 +162,20 @@ private static NLogLoggerProvider CreateNLogLoggerProvider(IServiceProvider serv
             return provider;
         }
 
+        private static void RegisterHostNLogExtensions(LogFactory logFactory, IServiceProvider serviceProvider, IHostEnvironment? hostingEnvironment)
+        {
+            (logFactory ?? LogManager.LogFactory).Setup().SetupExtensions(ext =>
+            {
+                if (serviceProvider != null)
+                    ext.RegisterServiceProvider(serviceProvider);
+                if (hostingEnvironment != null)
+                    ext.RegisterSingletonService(hostingEnvironment);
+                ext.RegisterLayoutRenderer<HostEnvironmentLayoutRenderer>("host-environment");
+                ext.RegisterLayoutRenderer<HostBaseDirLayoutRenderer>("host-basedir");
+                ext.RegisterLayoutRenderer<HostAppNameLayoutRenderer>("host-appname");
+            });
+        }
+
         private static string ResolveEnvironmentNLogConfigFile(string? basePath, string? environmentName)
         {
             if (!string.IsNullOrWhiteSpace(basePath))
diff --git a/src/NLog.Extensions.Hosting/LayoutRenderers/HostAppNameLayoutRenderer.cs b/src/NLog.Extensions.Hosting/LayoutRenderers/HostAppNameLayoutRenderer.cs
@@ -0,0 +1,73 @@
+﻿using System;
+using System.Text;
+using Microsoft.Extensions.Hosting;
+using NLog.Config;
+using NLog.LayoutRenderers;
+
+#if NETSTANDARD2_0
+using IHostEnvironment = Microsoft.Extensions.Hosting.IHostingEnvironment;
+#endif
+
+namespace NLog.Extensions.Hosting
+{
+    /// <summary>
+    /// Rendering development environment. <see cref="IHostingEnvironment.ApplicationName" />
+    /// </summary>
+    /// <remarks>
+    /// <code>${host-environment}</code>
+    /// </remarks>
+    /// <seealso href="https://github.com/NLog/NLog/wiki/Host-AppName-layout-renderer">Documentation on NLog Wiki</seealso>
+    [LayoutRenderer("host-appname")]
+    [ThreadAgnostic]
+    public class HostAppNameLayoutRenderer : LayoutRenderer
+    {
+        /// <summary>
+        /// Provides access to the current IHostEnvironment
+        /// </summary>
+        /// <returns>IHostEnvironment or <c>null</c></returns>
+        internal IHostEnvironment? HostEnvironment => _hostEnvironment ?? (_hostEnvironment = ResolveHostEnvironment());
+        private IHostEnvironment? _hostEnvironment;
+        private string? _hostAppName;
+        private static string? _currentProcessName;
+
+        /// <inheritdoc />
+        protected override void Append(StringBuilder builder, LogEventInfo logEvent)
+        {
+            var environmentName = _hostAppName ?? (_hostAppName = ResolveHostAppName());
+            builder.Append(environmentName ?? ResolveProcessName());
+        }
+
+        private IHostEnvironment? ResolveHostEnvironment()
+        {
+            return ResolveService<IHostEnvironment>();
+        }
+
+        private string? ResolveHostAppName()
+        {
+            try
+            {
+                var appName = HostEnvironment?.ApplicationName;
+                return string.IsNullOrWhiteSpace(appName) ? null : appName;
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private static string ResolveProcessName()
+        {
+            if (_currentProcessName is null)
+                _currentProcessName = System.Diagnostics.Process.GetCurrentProcess()?.ProcessName ?? "UnknownHostName";
+            return _currentProcessName;
+        }
+
+        /// <inheritdoc/>
+        protected override void CloseLayoutRenderer()
+        {
+            _hostEnvironment = null;
+            _hostAppName = null;
+            base.CloseLayoutRenderer();
+        }
+    }
+}
diff --git a/src/NLog.Extensions.Hosting/LayoutRenderers/HostBaseDirLayoutRenderer.cs b/src/NLog.Extensions.Hosting/LayoutRenderers/HostBaseDirLayoutRenderer.cs
@@ -0,0 +1,126 @@
+﻿using System;
+using System.IO;
+using System.Text;
+using NLog;
+using NLog.Config;
+using NLog.LayoutRenderers;
+
+#if NETSTANDARD2_0
+using IHostEnvironment = Microsoft.Extensions.Hosting.IHostingEnvironment;
+#endif
+
+namespace Microsoft.Extensions.Hosting
+{
+    /// <summary>
+    /// Rendering Application Host <see cref="IHostEnvironment.ContentRootPath" />
+    /// </summary>
+    /// <remarks>
+    /// <code>${host-basedir}</code>
+    /// </remarks>
+    /// <seealso href="https://github.com/NLog/NLog/wiki/Host-BaseDir-layout-renderer">Documentation on NLog Wiki</seealso>
+    [LayoutRenderer("host-basedir")]
+    [ThreadAgnostic]
+    public class HostBaseDirLayoutRenderer : LayoutRenderer
+    {
+        /// <summary>
+        /// Provides access to the current IHostEnvironment
+        /// </summary>
+        /// <returns>IHostEnvironment or <c>null</c></returns>
+        internal IHostEnvironment? HostEnvironment => _hostEnvironment ?? (_hostEnvironment = ResolveHostEnvironment());
+        private IHostEnvironment? _hostEnvironment;
+        private string? _contentRootPath;
+        private static string? _currentAppPath;
+
+        /// <inheritdoc />
+        protected override void Append(StringBuilder builder, LogEventInfo logEvent)
+        {
+            var contentRootPath = _contentRootPath ?? (_contentRootPath = ResolveContentRootPath());
+            builder.Append(contentRootPath ?? ResolveCurrentAppDirectory());
+        }
+
+        private IHostEnvironment? ResolveHostEnvironment()
+        {
+            return ResolveService<IHostEnvironment>();
+        }
+
+        private string? ResolveContentRootPath()
+        {
+            string? contentRootPath = null;
+            try
+            {
+                contentRootPath = HostEnvironment?.ContentRootPath;
+            }
+            catch
+            {
+                contentRootPath = null;
+            }
+            if (string.IsNullOrEmpty(contentRootPath))
+            {
+                contentRootPath = GetDotnetHostEnvironment("ASPNETCORE_CONTENTROOT") ?? GetDotnetHostEnvironment("DOTNET_CONTENTROOT");
+            }
+            return TrimEndDirectorySeparator(contentRootPath);
+        }
+
+        private static string? TrimEndDirectorySeparator(string? directoryPath)
+        {
+            return (directoryPath is null || string.IsNullOrEmpty(directoryPath)) ? null : directoryPath.TrimEnd(Path.DirectorySeparatorChar).TrimEnd(Path.AltDirectorySeparatorChar);
+        }
+
+        private static string? ResolveCurrentAppDirectory()
+        {
+            if (!string.IsNullOrEmpty(_currentAppPath))
+                return _currentAppPath;
+
+            var currentAppPath = AppContext.BaseDirectory;
+
+            try
+            {
+                var currentBasePath = Environment.CurrentDirectory;
+                var normalizeCurDir = Path.GetFullPath(currentBasePath).TrimEnd(Path.DirectorySeparatorChar).TrimEnd(Path.AltDirectorySeparatorChar).Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
+                var normalizeAppDir = Path.GetFullPath(currentAppPath).TrimEnd(Path.DirectorySeparatorChar).TrimEnd(Path.AltDirectorySeparatorChar).Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
+                if (string.IsNullOrEmpty(normalizeCurDir) || !normalizeCurDir.StartsWith(normalizeAppDir, StringComparison.OrdinalIgnoreCase))
+                {
+                    currentBasePath = currentAppPath; // Avoid using Windows-System32 as current directory
+                }
+                return _currentAppPath = TrimEndDirectorySeparator(currentBasePath);
+            }
+            catch
+            {
+                // Not supported or access denied
+                return _currentAppPath = TrimEndDirectorySeparator(currentAppPath);
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override void InitializeLayoutRenderer()
+        {
+            ResolveCurrentAppDirectory();   // Capture current directory at startup, before it changes
+            base.InitializeLayoutRenderer();
+        }
+
+        /// <inheritdoc/>
+        protected override void CloseLayoutRenderer()
+        {
+            _hostEnvironment = null;
+            _contentRootPath = null;
+            base.CloseLayoutRenderer();
+        }
+
+        private static string? GetDotnetHostEnvironment(string variableName)
+        {
+            try
+            {
+                var environment = Environment.GetEnvironmentVariable(variableName);
+                if (string.IsNullOrWhiteSpace(environment))
+                    return null;
+
+                return environment.Trim();
+            }
+            catch (Exception ex)
+            {
+                NLog.Common.InternalLogger.Error(ex, "Failed to lookup environment variable {0}", variableName);
+                return null;
+            }
+        }
+    }
+}
diff --git a/src/NLog.Extensions.Hosting/LayoutRenderers/HostEnvironmentLayoutRenderer.cs b/src/NLog.Extensions.Hosting/LayoutRenderers/HostEnvironmentLayoutRenderer.cs
@@ -0,0 +1,87 @@
+﻿using System;
+using System.Text;
+using Microsoft.Extensions.Hosting;
+using NLog.Config;
+using NLog.LayoutRenderers;
+
+#if NETSTANDARD2_0
+using IHostEnvironment = Microsoft.Extensions.Hosting.IHostingEnvironment;
+#endif
+
+namespace NLog.Extensions.Hosting
+{
+    /// <summary>
+    /// Rendering development environment. <see cref="IHostingEnvironment.EnvironmentName" />
+    /// </summary>
+    /// <remarks>
+    /// <code>${host-environment}</code>
+    /// </remarks>
+    /// <seealso href="https://github.com/NLog/NLog/wiki/Host-Environment-layout-renderer">Documentation on NLog Wiki</seealso>
+    [LayoutRenderer("host-environment")]
+    [ThreadAgnostic]
+    public class HostEnvironmentLayoutRenderer : LayoutRenderer
+    {
+        /// <summary>
+        /// Provides access to the current IHostEnvironment
+        /// </summary>
+        /// <returns>IHostEnvironment or <c>null</c></returns>
+        internal IHostEnvironment? HostEnvironment => _hostEnvironment ?? (_hostEnvironment = ResolveHostEnvironment());
+        private IHostEnvironment? _hostEnvironment;
+        private string? _environmentName;
+
+        /// <inheritdoc />
+        protected override void Append(StringBuilder builder, LogEventInfo logEvent)
+        {
+            var environmentName = _environmentName ?? (_environmentName = ResolveEnvironmentName());
+            builder.Append(environmentName ?? "Production");
+        }
+
+        private IHostEnvironment? ResolveHostEnvironment()
+        {
+            return ResolveService<IHostEnvironment>();
+        }
+
+        private string? ResolveEnvironmentName()
+        {
+            string? environmentName = null;
+            try
+            {
+                environmentName = HostEnvironment?.EnvironmentName;
+            }
+            catch
+            {
+                environmentName = null;
+            }
+            if (string.IsNullOrEmpty(environmentName))
+            {
+                environmentName = GetDotnetHostEnvironment("ASPNETCORE_ENVIRONMENT") ?? GetDotnetHostEnvironment("DOTNET_ENVIRONMENT");
+            }
+            return string.IsNullOrEmpty(environmentName) ? null : environmentName;
+        }
+
+        /// <inheritdoc/>
+        protected override void CloseLayoutRenderer()
+        {
+            _hostEnvironment = null;
+            _environmentName = null;
+            base.CloseLayoutRenderer();
+        }
+
+        private static string? GetDotnetHostEnvironment(string variableName)
+        {
+            try
+            {
+                var environment = Environment.GetEnvironmentVariable(variableName);
+                if (string.IsNullOrWhiteSpace(environment))
+                    return null;
+
+                return environment.Trim();
+            }
+            catch (Exception ex)
+            {
+                NLog.Common.InternalLogger.Error(ex, "Failed to lookup environment variable {0}", variableName);
+                return null;
+            }
+        }
+    }
+}
