fix(logging): don't skip enrichers, add env to logs

sitkoru · Dec 2, 2022 · 36c2f8f · 36c2f8f
1 parent 80a9a68
commit 36c2f8f
Show file tree

Hide file tree

Showing 12 changed files with 53 additions and 59 deletions.
diff --git a/src/Sitko.Core.App/Application.cs b/src/Sitko.Core.App/Application.cs
@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Text.Json;
-using System.Threading.Tasks;
 using JetBrains.Annotations;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
@@ -35,7 +31,7 @@ protected Application(string[] args)
 
     protected Dictionary<string, LogEventLevel> LogEventLevels { get; } = new();
 
-    protected List<Action<IApplicationContext, LoggerConfiguration>>
+    protected List<Func<IApplicationContext, LoggerConfiguration, LoggerConfiguration>>
         LoggerConfigurationActions { get; } = new();
 
     protected List<Action<IApplicationContext, IServiceCollection>>
@@ -125,23 +121,25 @@ protected void ConfigureConfiguration(IApplicationContext appContext, IConfigura
         }
     }
 
-    protected virtual void ConfigureLogging(IApplicationContext applicationContext,
+    protected virtual LoggerConfiguration ConfigureLogging(IApplicationContext applicationContext,
         LoggerConfiguration loggerConfiguration)
     {
         foreach (var (key, value) in LogEventLevels)
         {
-            loggerConfiguration.MinimumLevel.Override(key, value);
+            loggerConfiguration = loggerConfiguration.MinimumLevel.Override(key, value);
         }
 
         foreach (var moduleRegistration in GetEnabledModuleRegistrations<ILoggingModule>(applicationContext))
         {
-            moduleRegistration.ConfigureLogging(applicationContext, loggerConfiguration);
+            loggerConfiguration = moduleRegistration.ConfigureLogging(applicationContext, loggerConfiguration);
         }
 
         foreach (var loggerConfigurationAction in LoggerConfigurationActions)
         {
-            loggerConfigurationAction(applicationContext, loggerConfiguration);
+            loggerConfiguration = loggerConfigurationAction(applicationContext, loggerConfiguration);
         }
+
+        return loggerConfiguration;
     }
 
     [PublicAPI]
@@ -396,7 +394,7 @@ public Application ConfigureLogLevel(string source, LogEventLevel level)
         return this;
     }
 
-    public Application ConfigureLogging(Action<IApplicationContext, LoggerConfiguration> configure)
+    public Application ConfigureLogging(Func<IApplicationContext, LoggerConfiguration, LoggerConfiguration> configure)
     {
         LoggerConfigurationActions.Add(configure);
         return this;
@@ -452,3 +450,4 @@ public Application AddModule<TModule>() where TModule : BaseApplicationModule, n
             configureOptions?.Invoke(moduleOptions);
         }, optionsKey);
 }
+
diff --git a/src/Sitko.Core.App/ApplicationModuleRegistration.cs b/src/Sitko.Core.App/ApplicationModuleRegistration.cs
@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Threading.Tasks;
+using System.Reflection;
 using FluentValidation;
 using IL.FluentValidation.Extensions.Options;
 using Microsoft.Extensions.Configuration;
@@ -73,17 +69,16 @@ internal class ApplicationModuleRegistration<TModule, TModuleOptions> : Applicat
         return this;
     }
 
-    public override ApplicationModuleRegistration ConfigureLogging(
-        IApplicationContext context,
+    public override LoggerConfiguration ConfigureLogging(IApplicationContext context,
         LoggerConfiguration loggerConfiguration)
     {
-        if (instance is ILoggingModule<TModuleOptions> loggingModule)
+        if (instance is not ILoggingModule<TModuleOptions> loggingModule)
         {
-            var options = CreateOptions(context, true);
-            loggingModule.ConfigureLogging(context, options, loggerConfiguration);
+            return loggerConfiguration;
         }
 
-        return this;
+        var options = CreateOptions(context, true);
+        return loggingModule.ConfigureLogging(context, options, loggerConfiguration);
     }
 
     public override ApplicationModuleRegistration ConfigureHostBuilder(IApplicationContext context,
@@ -205,7 +200,7 @@ public abstract class ApplicationModuleRegistration
     public abstract ApplicationModuleRegistration ConfigureOptions(IApplicationContext context,
         IServiceCollection services);
 
-    public abstract ApplicationModuleRegistration ConfigureLogging(IApplicationContext context,
+    public abstract LoggerConfiguration ConfigureLogging(IApplicationContext context,
         LoggerConfiguration loggerConfiguration);
 
     public abstract ApplicationModuleRegistration ConfigureServices(IApplicationContext context,
@@ -233,3 +228,4 @@ public abstract class ApplicationModuleRegistration
 
     public abstract bool IsEnabled(IApplicationContext context);
 }
+
diff --git a/src/Sitko.Core.App/HostedApplication.cs b/src/Sitko.Core.App/HostedApplication.cs
@@ -1,6 +1,5 @@
-using System;
+using System.Globalization;
 using System.Text;
-using System.Threading.Tasks;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
@@ -25,6 +24,7 @@ protected HostedApplication(string[] args) : base(args)
         var loggerConfiguration = new LoggerConfiguration();
         loggerConfiguration
             .WriteTo.Console(outputTemplate: ApplicationOptions.BaseConsoleLogFormat,
+                formatProvider: CultureInfo.InvariantCulture,
                 restrictedToMinimumLevel: LogEventLevel.Debug);
         InternalLogger = new SerilogLoggerFactory(loggerConfiguration.CreateLogger()).CreateLogger<Application>();
     }
@@ -139,14 +139,15 @@ protected IHostBuilder ConfigureHostBuilder(Action<IHostBuilder>? configure = nu
                 LoggingExtensions.ConfigureSerilog(bootApplicationContext, builder, serilogConfiguration,
                     configuration =>
                     {
-                        configuration.Enrich.WithMachineName();
+                        configuration = configuration.Enrich.WithMachineName();
                         if (bootApplicationContext.Options.EnableConsoleLogging == true)
                         {
-                            configuration.WriteTo.Console(
-                                outputTemplate: bootApplicationContext.Options.ConsoleLogFormat);
+                            configuration = configuration.WriteTo.Console(
+                                outputTemplate: bootApplicationContext.Options.ConsoleLogFormat,
+                                formatProvider: CultureInfo.InvariantCulture);
                         }
 
-                        ConfigureLogging(bootApplicationContext, configuration);
+                        configuration = ConfigureLogging(bootApplicationContext, configuration);
                     });
             });
         configure?.Invoke(hostBuilder);

diff --git a/src/Sitko.Core.App/IApplicationContext.cs b/src/Sitko.Core.App/IApplicationContext.cs
@@ -1,4 +1,4 @@
-using System;
+using System.Globalization;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using Serilog;
@@ -34,6 +34,7 @@ protected BaseApplicationContext(Application application, IConfiguration configu
         var loggerConfiguration = new LoggerConfiguration();
         loggerConfiguration
             .WriteTo.Console(outputTemplate: ApplicationOptions.BaseConsoleLogFormat,
+                formatProvider: CultureInfo.InvariantCulture,
                 restrictedToMinimumLevel: LogEventLevel.Debug);
         Logger = new SerilogLoggerFactory(loggerConfiguration.CreateLogger()).CreateLogger<IApplicationContext>();
     }

diff --git a/src/Sitko.Core.App/IApplicationModule.cs b/src/Sitko.Core.App/IApplicationModule.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
@@ -56,7 +53,7 @@ public interface ILoggingModule : IApplicationModule
 public interface ILoggingModule<in TModuleOptions> : ILoggingModule, IApplicationModule<TModuleOptions>
     where TModuleOptions : class, new()
 {
-    void ConfigureLogging(IApplicationContext context, TModuleOptions options,
+    LoggerConfiguration ConfigureLogging(IApplicationContext context, TModuleOptions options,
         LoggerConfiguration loggerConfiguration);
 }
 
@@ -71,3 +68,6 @@ public interface IConfigurationModule<in TModuleOptions> : IApplicationModule<TM
     void ConfigureAppConfiguration(IConfigurationBuilder configurationBuilder,
         TModuleOptions startupOptions);
 }
+
+
+
diff --git a/src/Sitko.Core.App/Logging/LoggingExtensions.cs b/src/Sitko.Core.App/Logging/LoggingExtensions.cs
@@ -24,7 +24,8 @@ public class LoggingExtensions
         loggerConfiguration
             .Enrich.FromLogContext()
             .Enrich.WithProperty("App", appContext.Name)
-            .Enrich.WithProperty("AppVersion", appContext.Version);
+            .Enrich.WithProperty("AppVersion", appContext.Version)
+            .Enrich.WithProperty("AppEnvironment", appContext.Environment);
 
 
         configureLogging(loggerConfiguration);

diff --git a/src/Sitko.Core.ElasticStack/ElasticStackModule.cs b/src/Sitko.Core.ElasticStack/ElasticStackModule.cs
@@ -1,7 +1,4 @@
-using System;
-using System.Collections.Generic;
 using System.Globalization;
-using System.Linq;
 using Elastic.Apm.NetCoreAll;
 using Elastic.Apm.SerilogEnricher;
 using Elastic.CommonSchema.Serilog;
@@ -87,7 +84,7 @@ public class ElasticStackModule : BaseApplicationModule<ElasticStackModuleOption
 
     public override string OptionsKey => "ElasticApm";
 
-    public void ConfigureLogging(IApplicationContext context, ElasticStackModuleOptions options,
+    public LoggerConfiguration ConfigureLogging(IApplicationContext context, ElasticStackModuleOptions options,
         LoggerConfiguration loggerConfiguration)
     {
         if (options.LoggingEnabled)
@@ -121,15 +118,16 @@ public class ElasticStackModule : BaseApplicationModule<ElasticStackModuleOption
                 sinkOptions.IndexAliases = new[] { rolloverAlias };
             }
 
-            loggerConfiguration.Enrich.WithElasticApmCorrelationInfo()
-                .WriteTo.Elasticsearch(sinkOptions)
-                .Enrich.WithProperty("ApplicationName", context.Name)
-                .Enrich.WithProperty("ApplicationVersion", context.Version);
+            loggerConfiguration = loggerConfiguration
+                .Enrich.WithElasticApmCorrelationInfo()
+                .WriteTo.Elasticsearch(sinkOptions);
         }
 
         if (options.ApmEnabled)
         {
-            loggerConfiguration.MinimumLevel.Override("Elastic.Apm", LogEventLevel.Error);
+            loggerConfiguration = loggerConfiguration.MinimumLevel.Override("Elastic.Apm", LogEventLevel.Error);
         }
+
+        return loggerConfiguration;
     }
 }
diff --git a/src/Sitko.Core.Graylog/GraylogModule.cs b/src/Sitko.Core.Graylog/GraylogModule.cs
@@ -8,8 +8,9 @@ public class GraylogModule : BaseApplicationModule<GraylogModuleOptions>, ILoggi
 {
     public override string OptionsKey => "Logging:Graylog";
 
-    public void ConfigureLogging(IApplicationContext context, GraylogModuleOptions options,
+    public LoggerConfiguration ConfigureLogging(IApplicationContext context, GraylogModuleOptions options,
         LoggerConfiguration loggerConfiguration) =>
         loggerConfiguration.WriteTo.Async(to => to.Graylog(
             new GraylogSinkOptions { HostnameOrAddress = options.Host, Port = options.Port, Facility = context.Name }));
 }
+
diff --git a/src/Sitko.Core.NewRelic.Logging/NewRelicLoggingModule.cs b/src/Sitko.Core.NewRelic.Logging/NewRelicLoggingModule.cs
@@ -9,16 +9,18 @@ public class NewRelicLoggingModule : BaseApplicationModule<NewRelicLoggingModule
 {
     public override string OptionsKey => "Logging:NewRelic";
 
-    public void ConfigureLogging(IApplicationContext context, NewRelicLoggingModuleOptions options,
+    public LoggerConfiguration ConfigureLogging(IApplicationContext context, NewRelicLoggingModuleOptions options,
         LoggerConfiguration loggerConfiguration)
     {
         if (options.EnableLogging)
         {
-            loggerConfiguration
+            loggerConfiguration = loggerConfiguration
                 .Enrich.WithNewRelicLogsInContext()
                 .WriteTo.NewRelicLogs(options.LogsUrl,
                     context.Name,
                     options.LicenseKey);
         }
+
+        return loggerConfiguration;
     }
 }
diff --git a/src/Sitko.Core.Xunit/BaseTestScope.cs b/src/Sitko.Core.Xunit/BaseTestScope.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Threading.Tasks;
 using JetBrains.Annotations;
 using Microsoft.Extensions.Configuration;
@@ -56,9 +57,11 @@ public async Task ConfigureAsync(string name, ITestOutputHelper testOutputHelper
 
         scopeApplication.ConfigureLogging((_, loggerConfiguration) =>
         {
-            loggerConfiguration.WriteTo.TestOutput(testOutputHelper,
+            loggerConfiguration = loggerConfiguration.WriteTo.TestOutput(testOutputHelper,
                 outputTemplate:
-                "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}{NewLine}---------{NewLine}{Properties:j}{NewLine}---------");
+                "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}{NewLine}---------{NewLine}{Properties:j}{NewLine}---------",
+                formatProvider: CultureInfo.InvariantCulture);
+            return loggerConfiguration;
         });
 
         scopeApplication = ConfigureApplication(scopeApplication, name);

diff --git a/tests/Sitko.Core.Repository.EntityFrameworkCore.Tests/Data/EFTestScope.cs b/tests/Sitko.Core.Repository.EntityFrameworkCore.Tests/Data/EFTestScope.cs
@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 using Serilog.Events;
 using Sitko.Core.App;
 using Sitko.Core.Db.Postgres;
@@ -24,9 +20,7 @@ protected override TestApplication ConfigureApplication(TestApplication applicat
             options.AddRepositoriesFromAssemblyOf<TestModel>();
         });
         application.ConfigureLogging((_, configuration) =>
-        {
-            configuration.MinimumLevel.Override("Sitko.Core.Repository", LogEventLevel.Debug);
-        });
+            configuration.MinimumLevel.Override("Sitko.Core.Repository", LogEventLevel.Debug));
         return base.ConfigureApplication(application, name);
     }
 

diff --git a/tests/Sitko.Core.Repository.Remote.Tests/Data/RemoteRepositoryTestScope.cs b/tests/Sitko.Core.Repository.Remote.Tests/Data/RemoteRepositoryTestScope.cs
@@ -122,9 +122,7 @@ protected override TestApplication ConfigureApplication(TestApplication applicat
             }
         });
         application.ConfigureLogging((_, configuration) =>
-        {
-            configuration.MinimumLevel.Override("Sitko.Core.Repository", LogEventLevel.Debug);
-        });
+            configuration.MinimumLevel.Override("Sitko.Core.Repository", LogEventLevel.Debug));
 
         return application;
     }