Merge pull request #11035 from umbraco/v9/feature/10965-allow-app-settings-configuration-of-the-Umbraco-file-sink

Added support for configuring the UmbraocFile "sink", using IConfiguration

src/Umbraco.Infrastructure/Logging/Serilog/LoggerConfigExtensions.cs

@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using System.Text;
+using Microsoft.Extensions.Configuration;
 using Serilog;
 using Serilog.Configuration;
 using Serilog.Core;
@@ -10,6 +11,7 @@ using Serilog.Formatting.Compact;
 using Umbraco.Cms.Core.Hosting;
 using Umbraco.Cms.Core.Logging;
 using Umbraco.Cms.Core.Logging.Serilog.Enrichers;
+using Umbraco.Cms.Infrastructure.Logging.Serilog;
 
 namespace Umbraco.Extensions
 {
@@ -28,7 +30,8 @@ namespace Umbraco.Extensions
         public static LoggerConfiguration MinimalConfiguration(
             this LoggerConfiguration logConfig,
             IHostingEnvironment hostingEnvironment,
-            ILoggingConfiguration loggingConfiguration)
+            ILoggingConfiguration loggingConfiguration,
+            IConfiguration configuration)
         {
             global::Serilog.Debugging.SelfLog.Enable(msg => System.Diagnostics.Debug.WriteLine(msg));
 
@@ -48,10 +51,18 @@ namespace Umbraco.Extensions
                 .Enrich.With<Log4NetLevelMapperEnricher>()
                 .Enrich.FromLogContext(); // allows us to dynamically enrich
 
+            //This is not optimal, but seems to be the only way if we do not make an Serilog.Sink.UmbracoFile sink all the way.
+            var umbracoFileConfiguration = new UmbracoFileConfiguration(configuration);
 
             logConfig.WriteTo.UmbracoFile(
-                Path.Combine(loggingConfiguration.LogDirectory, $"UmbracoTraceLog.{Environment.MachineName}..json")
-                );
+                path : umbracoFileConfiguration.GetPath(loggingConfiguration.LogDirectory),
+                fileSizeLimitBytes: umbracoFileConfiguration.FileSizeLimitBytes,
+                restrictedToMinimumLevel: umbracoFileConfiguration.RestrictedToMinimumLevel,
+                rollingInterval: umbracoFileConfiguration.RollingInterval,
+                flushToDiskInterval: umbracoFileConfiguration.FlushToDiskInterval,
+                rollOnFileSizeLimit: umbracoFileConfiguration.RollOnFileSizeLimit,
+                retainedFileCountLimit: umbracoFileConfiguration.RetainedFileCountLimit
+            );
 
             return logConfig;
         }

src/Umbraco.Infrastructure/Logging/Serilog/SerilogLogger.cs

@@ -30,7 +30,7 @@ namespace Umbraco.Cms.Core.Logging.Serilog
             IConfiguration configuration)
         {
             var loggerConfig = new LoggerConfiguration()
-                .MinimalConfiguration(hostingEnvironment, loggingConfiguration)
+                .MinimalConfiguration(hostingEnvironment, loggingConfiguration, configuration)
                 .ReadFrom.Configuration(configuration);
 
             return new SerilogLogger(loggerConfig);

src/Umbraco.Infrastructure/Logging/Serilog/UmbracoFileConfiguration.cs

@@ -0,0 +1,47 @@
+using System;
+using System.IO;
+using System.Linq;
+using Microsoft.Extensions.Configuration;
+using Serilog;
+using Serilog.Events;
+
+namespace Umbraco.Cms.Infrastructure.Logging.Serilog
+{
+    public class UmbracoFileConfiguration
+    {
+        public UmbracoFileConfiguration(IConfiguration configuration)
+        {
+            if (configuration == null)
+            {
+                throw new ArgumentNullException(nameof(configuration));
+            }
+
+            var appSettings = configuration.GetSection("Serilog:WriteTo");
+            var umbracoFileAppSettings = appSettings.GetChildren().LastOrDefault(x => x.GetValue<string>("Name") == "UmbracoFile");
+
+            if (umbracoFileAppSettings is not null)
+            {
+                var args = umbracoFileAppSettings.GetSection("Args");
+
+                RestrictedToMinimumLevel = args.GetValue(nameof(RestrictedToMinimumLevel), RestrictedToMinimumLevel);
+                FileSizeLimitBytes = args.GetValue(nameof(FileSizeLimitBytes), FileSizeLimitBytes);
+                RollingInterval = args.GetValue(nameof(RollingInterval), RollingInterval);
+                FlushToDiskInterval = args.GetValue(nameof(FlushToDiskInterval), FlushToDiskInterval);
+                RollOnFileSizeLimit = args.GetValue(nameof(RollOnFileSizeLimit), RollOnFileSizeLimit);
+                RetainedFileCountLimit = args.GetValue(nameof(RetainedFileCountLimit), RetainedFileCountLimit);
+            }
+        }
+
+        public LogEventLevel RestrictedToMinimumLevel { get; set; } = LogEventLevel.Verbose;
+        public long FileSizeLimitBytes { get; set; } = 1073741824;
+        public RollingInterval RollingInterval { get; set; } = RollingInterval.Day;
+        public TimeSpan? FlushToDiskInterval { get; set; } = null;
+        public bool RollOnFileSizeLimit { get; set; } = false;
+        public int RetainedFileCountLimit { get; set; } = 31;
+
+        public string GetPath(string logDirectory)
+        {
+            return Path.Combine(logDirectory, $"UmbracoTraceLog.{Environment.MachineName}..json");
+        }
+    }
+}