Work in progress

jasontaylordev · jasontaylordev · commit 5d50cbf77b52 · 2025-06-12T17:09:33.000+10:00
diff --git a/src/Directory.Packages.props b/src/Directory.Packages.props
@@ -24,6 +24,7 @@
     <PackageVersion Include="Microsoft.Extensions.Hosting" Version="8.0.1" />
     <PackageVersion Include="Microsoft.Extensions.Hosting.Abstractions" Version="8.0.1" />
     <PackageVersion Include="Microsoft.Extensions.Hosting.WindowsServices" Version="8.0.1" />
+    <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.3" />
     <PackageVersion Include="Microsoft.Extensions.TimeProvider.Testing" Version="8.10.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageVersion Include="Microsoft-WindowsAPICodePack-Shell" Version="1.1.5" />
@@ -63,6 +64,7 @@
     <PackageVersion Include="PublicApiGenerator" Version="11.4.6" />
     <PackageVersion Include="RavenDB.Embedded" Version="6.2.5" />
     <PackageVersion Include="ReactiveUI.WPF" Version="20.1.63" />
+    <PackageVersion Include="Seq.Extensions.Logging" Version="8.0.0" />
     <PackageVersion Include="ServiceControl.Contracts" Version="5.0.0" />
     <PackageVersion Include="System.Configuration.ConfigurationManager" Version="8.0.1" />
     <PackageVersion Include="System.Diagnostics.PerformanceCounter" Version="8.0.1" />
@@ -91,4 +93,4 @@
     <GlobalPackageReference Include="Microsoft.Build.CopyOnWrite" Version="1.0.334" />
     <GlobalPackageReference Include="Particular.Packaging" Version="4.2.2" />
   </ItemGroup>
-</Project>
+</Project>
diff --git a/src/ServiceControl.AcceptanceTests/TestSupport/ServiceControlComponentRunner.cs b/src/ServiceControl.AcceptanceTests/TestSupport/ServiceControlComponentRunner.cs
@@ -15,7 +15,7 @@
     using Microsoft.AspNetCore.TestHost;
     using Microsoft.Extensions.DependencyInjection;
     using Microsoft.Extensions.Hosting;
-    using NLog;
+    using Microsoft.Extensions.Logging;
     using NServiceBus;
     using NServiceBus.AcceptanceTesting;
     using NServiceBus.AcceptanceTesting.Support;
diff --git a/src/ServiceControl.Audit.AcceptanceTests/TestSupport/ServiceControlComponentRunner.cs b/src/ServiceControl.Audit.AcceptanceTests/TestSupport/ServiceControlComponentRunner.cs
@@ -17,6 +17,7 @@ namespace ServiceControl.Audit.AcceptanceTests.TestSupport
     using Microsoft.AspNetCore.Builder;
     using Microsoft.AspNetCore.TestHost;
     using Microsoft.Extensions.Hosting;
+    using Microsoft.Extensions.Logging;
     using NServiceBus;
     using NServiceBus.AcceptanceTesting;
     using NServiceBus.AcceptanceTesting.Support;
@@ -43,7 +44,7 @@ async Task InitializeServiceControl(ScenarioContext context)
             var logPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
             Directory.CreateDirectory(logPath);
 
-            var loggingSettings = new LoggingSettings(Settings.SettingsRootNamespace, defaultLevel: NLog.LogLevel.Debug, logPath: logPath);
+            var loggingSettings = new LoggingSettings(Settings.SettingsRootNamespace, defaultLevel: LogLevel.Debug, logPath: logPath);
 
             settings = new Settings(transportToUse.TypeName, persistenceToUse.PersistenceType, loggingSettings)
             {
diff --git a/src/ServiceControl.Audit.Persistence.RavenDB/CustomChecks/CheckFreeDiskSpace.cs b/src/ServiceControl.Audit.Persistence.RavenDB/CustomChecks/CheckFreeDiskSpace.cs
@@ -8,7 +8,6 @@
     using Microsoft.Extensions.Logging;
     using NServiceBus.CustomChecks;
     using RavenDB;
-    using ServiceControl.Infrastructure;
 
     class CheckFreeDiskSpace(DatabaseConfiguration databaseConfiguration, ILogger<CheckFreeDiskSpace> logger) : CustomCheck("ServiceControl.Audit database", "Storage space", TimeSpan.FromMinutes(5))
     {
@@ -45,7 +44,7 @@ public override Task<CheckResult> PerformCheck(CancellationToken cancellationTok
                 : CheckResult.Failed($"{percentRemaining:P0} disk space remaining on data drive '{dataDriveInfo.VolumeLabel} ({dataDriveInfo.RootDirectory})' on '{Environment.MachineName}'.");
         }
 
-        public static int Parse(IDictionary<string, string> settings)
+        public static int Parse(IDictionary<string, string> settings, ILogger logger)
         {
             if (!settings.TryGetValue(RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey, out var thresholdValue))
             {
@@ -54,19 +53,19 @@ public static int Parse(IDictionary<string, string> settings)
 
             if (!int.TryParse(thresholdValue, out var threshold))
             {
-                Logger.LogCritical("{RavenPersistenceConfigurationDataSpaceRemainingThresholdKey} must be an integer.", RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey);
+                logger.LogCritical("{RavenPersistenceConfigurationDataSpaceRemainingThresholdKey} must be an integer.", RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey);
                 throw new Exception($"{RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey} must be an integer.");
             }
 
             if (threshold < 0)
             {
-                Logger.LogCritical("{RavenPersistenceConfigurationDataSpaceRemainingThresholdKey} is invalid, minimum value is 0.", RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey);
+                logger.LogCritical("{RavenPersistenceConfigurationDataSpaceRemainingThresholdKey} is invalid, minimum value is 0.", RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey);
                 throw new Exception($"{RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey} is invalid, minimum value is 0.");
             }
 
             if (threshold > 100)
             {
-                Logger.LogCritical("{RavenPersistenceConfigurationDataSpaceRemainingThresholdKey} is invalid, maximum value is 100.", RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey);
+                logger.LogCritical("{RavenPersistenceConfigurationDataSpaceRemainingThresholdKey} is invalid, maximum value is 100.", RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey);
                 throw new Exception($"{RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey} is invalid, maximum value is 100.");
             }
 
@@ -75,7 +74,6 @@ public static int Parse(IDictionary<string, string> settings)
 
         readonly string dataPathRoot = Path.GetPathRoot(databaseConfiguration.ServerConfiguration.DbPath);
         readonly decimal percentageThreshold = databaseConfiguration.DataSpaceRemainingThreshold / 100m;
-        static readonly ILogger<CheckFreeDiskSpace> Logger = LoggerUtil.CreateStaticLogger<CheckFreeDiskSpace>();
         public const int DataSpaceRemainingThresholdDefault = 20;
     }
 }
diff --git a/src/ServiceControl.Audit.Persistence.RavenDB/RavenPersistenceConfiguration.cs b/src/ServiceControl.Audit.Persistence.RavenDB/RavenPersistenceConfiguration.cs
@@ -114,7 +114,7 @@ internal static DatabaseConfiguration GetDatabaseConfiguration(PersistenceSettin
                 serverConfiguration = new ServerConfiguration(dbPath, serverUrl, logPath, logsMode);
             }
 
-            var dataSpaceRemainingThreshold = CheckFreeDiskSpace.Parse(settings.PersisterSpecificSettings);
+            var dataSpaceRemainingThreshold = CheckFreeDiskSpace.Parse(settings.PersisterSpecificSettings, Logger);
             var minimumStorageLeftRequiredForIngestion = CheckMinimumStorageRequiredForIngestion.Parse(settings.PersisterSpecificSettings);
 
             var expirationProcessTimerInSeconds = GetExpirationProcessTimerInSeconds(settings);
diff --git a/src/ServiceControl.Audit/HostApplicationBuilderExtensions.cs b/src/ServiceControl.Audit/HostApplicationBuilderExtensions.cs
@@ -41,7 +41,7 @@ public static void AddServiceControlAudit(this IHostApplicationBuilder builder,
 
         builder.Logging.ClearProviders();
         builder.Logging.AddNLog();
-        builder.Logging.SetMinimumLevel(settings.LoggingSettings.ToHostLogLevel());
+        builder.Logging.SetMinimumLevel(settings.LoggingSettings.LogLevel);
 
         var services = builder.Services;
         var transportSettings = settings.ToTransportSettings();
diff --git a/src/ServiceControl.Audit/Infrastructure/WebApi/RootController.cs b/src/ServiceControl.Audit/Infrastructure/WebApi/RootController.cs
@@ -51,7 +51,7 @@ public OkObjectResult Config()
                     Logging = new
                     {
                         settings.LoggingSettings.LogPath,
-                        LoggingLevel = settings.LoggingSettings.LogLevel.Name
+                        LoggingLevel = settings.LoggingSettings.LogLevel
                     }
                 },
                 DataRetention = new
diff --git a/src/ServiceControl.Infrastructure/LoggerUtil.cs b/src/ServiceControl.Infrastructure/LoggerUtil.cs
@@ -9,13 +9,16 @@ public static class LoggerUtil
         public static void BuildLogger(this ILoggingBuilder loggingBuilder, LogLevel level)
         {
             loggingBuilder.AddNLog();
+            loggingBuilder.AddSeq();
             loggingBuilder.SetMinimumLevel(level);
         }
 
         public static ILogger<T> CreateStaticLogger<T>(LogLevel level = LogLevel.Information)
         {
             var factory = LoggerFactory.Create(configure => configure.BuildLogger(level));
-            return factory.CreateLogger<T>();
+            var logger = factory.CreateLogger<T>();
+            logger.LogError("JTD: This is a test log message.");
+            return logger;
         }
 
         public static ILogger CreateStaticLogger(Type type, LogLevel level = LogLevel.Information)
diff --git a/src/ServiceControl.Infrastructure/LoggingConfigurator.cs b/src/ServiceControl.Infrastructure/LoggingConfigurator.cs
@@ -60,11 +60,15 @@ public static void ConfigureLogging(LoggingSettings loggingSettings)
             nlogConfig.LoggingRules.Add(aspNetCoreRule);
             nlogConfig.LoggingRules.Add(httpClientRule);
 
-            nlogConfig.LoggingRules.Add(new LoggingRule("*", loggingSettings.LogLevel, consoleTarget));
+            // HACK: Fix LogLevel to Info for testing purposes only.
+            // nlogConfig.LoggingRules.Add(new LoggingRule("*", loggingSettings.LogLevel, consoleTarget));
+            nlogConfig.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, consoleTarget));
 
             if (!AppEnvironment.RunningInContainer)
             {
-                nlogConfig.LoggingRules.Add(new LoggingRule("*", loggingSettings.LogLevel, fileTarget));
+                // HACK: Fix LogLevel to Info for testing purposes only.
+                //nlogConfig.LoggingRules.Add(new LoggingRule("*", loggingSettings.LogLevel, fileTarget));
+                nlogConfig.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, fileTarget));
             }
 
             NLog.LogManager.Configuration = nlogConfig;
@@ -74,7 +78,7 @@ public static void ConfigureLogging(LoggingSettings loggingSettings)
             var logger = LogManager.GetLogger("LoggingConfiguration");
             var logEventInfo = new LogEventInfo { TimeStamp = DateTime.UtcNow };
             var loggingTo = AppEnvironment.RunningInContainer ? "console" : fileTarget.FileName.Render(logEventInfo);
-            logger.InfoFormat("Logging to {0} with LogLevel '{1}'", loggingTo, loggingSettings.LogLevel.Name);
+            logger.InfoFormat("Logging to {0} with LogLevel '{1}'", loggingTo, LogLevel.Info.Name);
         }
 
         const long megaByte = 1024 * 1024;
diff --git a/src/ServiceControl.Infrastructure/LoggingSettings.cs b/src/ServiceControl.Infrastructure/LoggingSettings.cs
@@ -1,53 +1,60 @@
 namespace ServiceControl.Infrastructure;
 
 using System;
+using System.Collections.Generic;
 using System.IO;
-using NLog;
-using NLog.Common;
+using Microsoft.Extensions.Logging;
 using ServiceControl.Configuration;
 
-public class LoggingSettings(SettingsRootNamespace rootNamespace, LogLevel defaultLevel = null, string logPath = null)
+public class LoggingSettings(SettingsRootNamespace rootNamespace, LogLevel defaultLevel = LogLevel.Information, string logPath = null)
 {
     public LogLevel LogLevel { get; } = InitializeLogLevel(rootNamespace, defaultLevel);
 
-    public string LogPath { get; } = SettingsReader.Read(rootNamespace, "LogPath", Environment.ExpandEnvironmentVariables(logPath ?? DefaultLogLocation()));
+    public string LogPath { get; } = SettingsReader.Read(rootNamespace, logPathKey, Environment.ExpandEnvironmentVariables(logPath ?? DefaultLogLocation()));
 
     static LogLevel InitializeLogLevel(SettingsRootNamespace rootNamespace, LogLevel defaultLevel)
     {
-        defaultLevel ??= LogLevel.Info;
-
         var levelText = SettingsReader.Read<string>(rootNamespace, logLevelKey);
 
         if (string.IsNullOrWhiteSpace(levelText))
         {
             return defaultLevel;
         }
 
-        try
-        {
-            return LogLevel.FromString(levelText);
-        }
-        catch
-        {
-            InternalLogger.Warn($"Failed to parse {logLevelKey} setting. Defaulting to {defaultLevel.Name}.");
-            return defaultLevel;
-        }
+        return ParseLogLevel(levelText, defaultLevel);
     }
 
     // SC installer always populates LogPath in app.config on installation/change/upgrade so this will only be used when
     // debugging or if the entry is removed manually. In those circumstances default to the folder containing the exe
     static string DefaultLogLocation() => Path.Combine(AppContext.BaseDirectory, ".logs");
 
-    public Microsoft.Extensions.Logging.LogLevel ToHostLogLevel() => LogLevel switch
+    // This is not a complete mapping of NLog levels, just the ones that are different.
+    static readonly Dictionary<string, LogLevel> NLogAliases =
+        new(StringComparer.OrdinalIgnoreCase)
+        {
+            ["info"] = LogLevel.Information,
+            ["warn"] = LogLevel.Warning,
+            ["fatal"] = LogLevel.Critical,
+            ["off"] = LogLevel.None
+        };
+
+    static LogLevel ParseLogLevel(string value, LogLevel defaultLevel)
     {
-        _ when LogLevel == LogLevel.Trace => Microsoft.Extensions.Logging.LogLevel.Trace,
-        _ when LogLevel == LogLevel.Debug => Microsoft.Extensions.Logging.LogLevel.Debug,
-        _ when LogLevel == LogLevel.Info => Microsoft.Extensions.Logging.LogLevel.Information,
-        _ when LogLevel == LogLevel.Warn => Microsoft.Extensions.Logging.LogLevel.Warning,
-        _ when LogLevel == LogLevel.Error => Microsoft.Extensions.Logging.LogLevel.Error,
-        _ when LogLevel == LogLevel.Fatal => Microsoft.Extensions.Logging.LogLevel.Critical,
-        _ => Microsoft.Extensions.Logging.LogLevel.None
-    };
+        if (Enum.TryParse(value, ignoreCase: true, out LogLevel parsedLevel))
+        {
+            return parsedLevel;
+        }
+
+        if (NLogAliases.TryGetValue(value.Trim(), out parsedLevel))
+        {
+            return parsedLevel;
+        }
+
+        LoggerUtil.CreateStaticLogger<LoggingSettings>().LogWarning("Failed to parse {LogLevelKey} setting. Defaulting to {DefaultLevel}.", logLevelKey, defaultLevel);
+
+        return defaultLevel;
+    }
 
     const string logLevelKey = "LogLevel";
+    const string logPathKey = "LogPath";
 }
diff --git a/src/ServiceControl.Infrastructure/ServiceControl.Infrastructure.csproj b/src/ServiceControl.Infrastructure/ServiceControl.Infrastructure.csproj
@@ -9,9 +9,11 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
     <PackageReference Include="NLog.Extensions.Logging" />
     <PackageReference Include="NServiceBus" />
     <PackageReference Include="NServiceBus.Extensions.Logging" />
+    <PackageReference Include="Seq.Extensions.Logging" />
   </ItemGroup>
 
 </Project>
diff --git a/src/ServiceControl.Monitoring.AcceptanceTests/TestSupport/ServiceControlComponentRunner.cs b/src/ServiceControl.Monitoring.AcceptanceTests/TestSupport/ServiceControlComponentRunner.cs
@@ -18,7 +18,6 @@ namespace ServiceControl.Monitoring.AcceptanceTests.TestSupport
     using NServiceBus.AcceptanceTesting;
     using NServiceBus.AcceptanceTesting.Support;
     using NServiceBus.Logging;
-    using ServiceControl.Infrastructure;
 
     class ServiceControlComponentRunner(
         ITransportIntegration transportToUse,
@@ -73,7 +72,7 @@ async Task InitializeServiceControl(ScenarioContext context)
 
             using (new DiagnosticTimer($"Creating infrastructure for {settings.InstanceName}"))
             {
-                var setupCommand = new SetupCommand(LoggerUtil.CreateStaticLogger<SetupCommand>());
+                var setupCommand = new SetupCommand();
                 await setupCommand.Execute(new HostArguments([]), settings);
             }
 
diff --git a/src/ServiceControl.Monitoring/HostApplicationBuilderExtensions.cs b/src/ServiceControl.Monitoring/HostApplicationBuilderExtensions.cs
@@ -22,6 +22,7 @@ namespace ServiceControl.Monitoring;
 using NServiceBus.Features;
 using NServiceBus.Transport;
 using QueueLength;
+using ServiceControl.Infrastructure;
 using Timings;
 using Transports;
 
@@ -31,9 +32,8 @@ public static void AddServiceControlMonitoring(this IHostApplicationBuilder host
         Func<ICriticalErrorContext, CancellationToken, Task> onCriticalError, Settings settings,
         EndpointConfiguration endpointConfiguration)
     {
-        hostBuilder.Logging.ClearProviders();
-        hostBuilder.Logging.AddNLog();
-        hostBuilder.Logging.SetMinimumLevel(settings.LoggingSettings.ToHostLogLevel());
+        hostBuilder.Services.AddLogging();
+        hostBuilder.Logging.BuildLogger(settings.LoggingSettings.LogLevel);
 
         var services = hostBuilder.Services;
 
diff --git a/src/ServiceControl.Monitoring/Hosting/Commands/SetupCommand.cs b/src/ServiceControl.Monitoring/Hosting/Commands/SetupCommand.cs
@@ -2,15 +2,16 @@ namespace ServiceControl.Monitoring
 {
     using System.Threading.Tasks;
     using Microsoft.Extensions.Logging;
+    using ServiceControl.Infrastructure;
     using Transports;
 
-    class SetupCommand(ILogger<SetupCommand> logger) : AbstractCommand
+    class SetupCommand : AbstractCommand
     {
         public override Task Execute(HostArguments args, Settings settings)
         {
             if (args.SkipQueueCreation)
             {
-                logger.LogInformation("Skipping queue creation");
+                LoggerUtil.CreateStaticLogger<SetupCommand>().LogInformation("Skipping queue creation");
                 return Task.CompletedTask;
             }
 
diff --git a/src/ServiceControl.Monitoring/Program.cs b/src/ServiceControl.Monitoring/Program.cs
@@ -5,9 +5,11 @@
 using ServiceControl.Infrastructure;
 using ServiceControl.Monitoring;
 
+var logger = LoggerUtil.CreateStaticLogger<Program>();
+
 try
 {
-    AppDomain.CurrentDomain.UnhandledException += (s, e) => LoggerUtil.CreateStaticLogger<Program>().LogError(e.ExceptionObject as Exception, "Unhandled exception was caught.");
+    AppDomain.CurrentDomain.UnhandledException += (s, e) => logger.LogError(e.ExceptionObject as Exception, "Unhandled exception was caught.");
 
     // Hack: See https://github.com/Particular/ServiceControl/issues/4392
     var exitCode = await IntegratedSetup.Run();
@@ -32,11 +34,11 @@
 }
 catch (Exception ex)
 {
-    LoggerUtil.CreateStaticLogger<Program>().LogCritical(ex, "Unrecoverable error");
+    logger.LogCritical(ex, "Unrecoverable error");
     throw;
 }
 finally
 {
     // The following log statement is meant to leave a trail in the logs to determine if the process was killed
-    LoggerUtil.CreateStaticLogger<Program>().LogInformation("Shutdown complete");
+    logger.LogInformation("Shutdown complete");
 }
diff --git a/src/ServiceControl.Monitoring/ServiceControl.Monitoring.csproj b/src/ServiceControl.Monitoring/ServiceControl.Monitoring.csproj
@@ -25,6 +25,7 @@
     <PackageReference Include="Microsoft.Extensions.Hosting.WindowsServices" />
     <PackageReference Include="NServiceBus.Extensions.Hosting" />
     <PackageReference Include="NServiceBus.Persistence.NonDurable" />
+    <PackageReference Include="Seq.Extensions.Logging" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/ServiceControl/HostApplicationBuilderExtensions.cs b/src/ServiceControl/HostApplicationBuilderExtensions.cs
@@ -46,7 +46,7 @@ public static void AddServiceControl(this IHostApplicationBuilder hostBuilder, S
             logging.ClearProviders();
             //HINT: configuration used by NLog comes from LoggingConfigurator.cs
             logging.AddNLog();
-            logging.SetMinimumLevel(settings.LoggingSettings.ToHostLogLevel());
+            logging.SetMinimumLevel(settings.LoggingSettings.LogLevel);
 
             var services = hostBuilder.Services;
             var transportSettings = settings.ToTransportSettings();
diff --git a/src/ServiceControl/Infrastructure/Api/ConfigurationApi.cs b/src/ServiceControl/Infrastructure/Api/ConfigurationApi.cs
@@ -60,7 +60,7 @@ public Task<object> GetConfig(CancellationToken cancellationToken)
                 Logging = new
                 {
                     settings.LoggingSettings.LogPath,
-                    LoggingLevel = settings.LoggingSettings.LogLevel.Name
+                    LoggingLevel = settings.LoggingSettings.LogLevel
                 }
             },
             DataRetention = new

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,6 @@`
`8`	`8`	`using Microsoft.Extensions.Logging;`
`9`	`9`	`using NServiceBus.CustomChecks;`
`10`	`10`	`using RavenDB;`
`11`		`- using ServiceControl.Infrastructure;`
`12`	`11`
`13`	`12`	`class CheckFreeDiskSpace(DatabaseConfiguration databaseConfiguration, ILogger<CheckFreeDiskSpace> logger) : CustomCheck("ServiceControl.Audit database", "Storage space", TimeSpan.FromMinutes(5))`
`14`	`13`	`{`
`@@ -45,7 +44,7 @@ public override Task<CheckResult> PerformCheck(CancellationToken cancellationTok`
`45`	`44`	`: CheckResult.Failed($"{percentRemaining:P0} disk space remaining on data drive '{dataDriveInfo.VolumeLabel} ({dataDriveInfo.RootDirectory})' on '{Environment.MachineName}'.");`
`46`	`45`	`}`
`47`	`46`
`48`		`- public static int Parse(IDictionary<string, string> settings)`
	`47`	`+ public static int Parse(IDictionary<string, string> settings, ILogger logger)`
`49`	`48`	`{`
`50`	`49`	`if (!settings.TryGetValue(RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey, out var thresholdValue))`
`51`	`50`	`{`
`@@ -54,19 +53,19 @@ public static int Parse(IDictionary<string, string> settings)`
`54`	`53`
`55`	`54`	`if (!int.TryParse(thresholdValue, out var threshold))`
`56`	`55`	`{`
`57`		`- Logger.LogCritical("{RavenPersistenceConfigurationDataSpaceRemainingThresholdKey} must be an integer.", RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey);`
	`56`	`+ logger.LogCritical("{RavenPersistenceConfigurationDataSpaceRemainingThresholdKey} must be an integer.", RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey);`
`58`	`57`	`throw new Exception($"{RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey} must be an integer.");`
`59`	`58`	`}`
`60`	`59`
`61`	`60`	`if (threshold < 0)`
`62`	`61`	`{`
`63`		`- Logger.LogCritical("{RavenPersistenceConfigurationDataSpaceRemainingThresholdKey} is invalid, minimum value is 0.", RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey);`
	`62`	`+ logger.LogCritical("{RavenPersistenceConfigurationDataSpaceRemainingThresholdKey} is invalid, minimum value is 0.", RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey);`
`64`	`63`	`throw new Exception($"{RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey} is invalid, minimum value is 0.");`
`65`	`64`	`}`
`66`	`65`
`67`	`66`	`if (threshold > 100)`
`68`	`67`	`{`
`69`		`- Logger.LogCritical("{RavenPersistenceConfigurationDataSpaceRemainingThresholdKey} is invalid, maximum value is 100.", RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey);`
	`68`	`+ logger.LogCritical("{RavenPersistenceConfigurationDataSpaceRemainingThresholdKey} is invalid, maximum value is 100.", RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey);`
`70`	`69`	`throw new Exception($"{RavenPersistenceConfiguration.DataSpaceRemainingThresholdKey} is invalid, maximum value is 100.");`
`71`	`70`	`}`
`72`	`71`
`@@ -75,7 +74,6 @@ public static int Parse(IDictionary<string, string> settings)`
`75`	`74`
`76`	`75`	`readonly string dataPathRoot = Path.GetPathRoot(databaseConfiguration.ServerConfiguration.DbPath);`
`77`	`76`	`readonly decimal percentageThreshold = databaseConfiguration.DataSpaceRemainingThreshold / 100m;`
`78`		`- static readonly ILogger<CheckFreeDiskSpace> Logger = LoggerUtil.CreateStaticLogger<CheckFreeDiskSpace>();`
`79`	`77`	`public const int DataSpaceRemainingThresholdDefault = 20;`
`80`	`78`	`}`
`81`	`79`	`}`
Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ internal static DatabaseConfiguration GetDatabaseConfiguration(PersistenceSettin`
`114`	`114`	`serverConfiguration = new ServerConfiguration(dbPath, serverUrl, logPath, logsMode);`
`115`	`115`	`}`
`116`	`116`
`117`		`- var dataSpaceRemainingThreshold = CheckFreeDiskSpace.Parse(settings.PersisterSpecificSettings);`
	`117`	`+ var dataSpaceRemainingThreshold = CheckFreeDiskSpace.Parse(settings.PersisterSpecificSettings, Logger);`
`118`	`118`	`var minimumStorageLeftRequiredForIngestion = CheckMinimumStorageRequiredForIngestion.Parse(settings.PersisterSpecificSettings);`
`119`	`119`
`120`	`120`	`var expirationProcessTimerInSeconds = GetExpirationProcessTimerInSeconds(settings);`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ public OkObjectResult Config()`
`51`	`51`	`Logging = new`
`52`	`52`	`{`
`53`	`53`	`settings.LoggingSettings.LogPath,`
`54`		`- LoggingLevel = settings.LoggingSettings.LogLevel.Name`
	`54`	`+ LoggingLevel = settings.LoggingSettings.LogLevel`
`55`	`55`	`}`
`56`	`56`	`},`
`57`	`57`	`DataRetention = new`
Original file line number	Diff line number	Diff line change
`@@ -9,13 +9,16 @@ public static class LoggerUtil`
`9`	`9`	`public static void BuildLogger(this ILoggingBuilder loggingBuilder, LogLevel level)`
`10`	`10`	`{`
`11`	`11`	`loggingBuilder.AddNLog();`
	`12`	`+ loggingBuilder.AddSeq();`
`12`	`13`	`loggingBuilder.SetMinimumLevel(level);`
`13`	`14`	`}`
`14`	`15`
`15`	`16`	`public static ILogger<T> CreateStaticLogger<T>(LogLevel level = LogLevel.Information)`
`16`	`17`	`{`
`17`	`18`	`var factory = LoggerFactory.Create(configure => configure.BuildLogger(level));`
`18`		`- return factory.CreateLogger<T>();`
	`19`	`+ var logger = factory.CreateLogger<T>();`
	`20`	`+ logger.LogError("JTD: This is a test log message.");`
	`21`	`+ return logger;`
`19`	`22`	`}`
`20`	`23`
`21`	`24`	`public static ILogger CreateStaticLogger(Type type, LogLevel level = LogLevel.Information)`