Merge pull request #46 from skomis-mm/sublog

Configure sub-loggers through JSON appsettings

Author: nblumhardt

sample/Sample/Sample.csproj

@@ -14,7 +14,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="1.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="1.1.1" />
+    <PackageReference Include="Serilog.Sinks.Async" Version="1.0.1" />
     <PackageReference Include="Serilog.Sinks.Literate" Version="2.0.0" />
     <PackageReference Include="Serilog.Sinks.RollingFile" Version="3.0.0" />
     <PackageReference Include="Serilog.Enrichers.Environment" Version="2.0.0" />

sample/Sample/appsettings.json

@@ -10,18 +10,35 @@
     },
     "WriteTo": [
       {
-        "Name": "LiterateConsole",
+        "Name": "Logger",
         "Args": {
-          "outputTemplate": "[{Timestamp:HH:mm:ss} {SourceContext} [{Level}] {Message}{NewLine}{Exception}"
-        } 
+          "configureLogger": {
+            "WriteTo": [
+              {
+                "Name": "LiterateConsole",
+                "Args": {
+                  "outputTemplate": "[{Timestamp:HH:mm:ss} {SourceContext} [{Level}] {Message}{NewLine}{Exception}"
+                }
+              }
+            ]
+          },
+          "restrictedToMinimumLevel": "Debug"
+        }
       },
-      {        
-        "Name": "File",
+      {
+        "Name": "Async",
         "Args": {
-          "path": "%TEMP%\\Logs\\serilog-configuration-sample.txt",
-          "outputTemplate": "{Timestamp:o} [{Level:u3}] ({Application}/{MachineName}/{ThreadId}) {Message}{NewLine}{Exception}"
+          "configure": [
+            {
+              "Name": "File",
+              "Args": {
+                "path": "%TEMP%\\Logs\\serilog-configuration-sample.txt",
+                "outputTemplate": "{Timestamp:o} [{Level:u3}] ({Application}/{MachineName}/{ThreadId}) {Message}{NewLine}{Exception}"
+              }
+            }
+          ]
         }
-      }
+      }      
     ],
     "Enrich": ["FromLogContext", "WithMachineName", "WithThreadId"],
     "Properties": {

src/Serilog.Settings.Configuration/Settings/Configuration/ConfigurationReader.cs

@@ -0,0 +1,39 @@
+using Serilog.Configuration;
+using System;
+using System.Reflection;
+
+namespace Serilog.Settings.Configuration
+{
+    class ConfigurationSectionArgumentValue : IConfigurationArgumentValue
+    {
+        readonly IConfigurationReader _configReader;
+
+        public ConfigurationSectionArgumentValue(IConfigurationReader configReader)
+        {
+            _configReader = configReader ?? throw new ArgumentNullException(nameof(configReader));
+        }
+
+        public object ConvertTo(Type toType)
+        {
+            var typeInfo = toType.GetTypeInfo();
+            if (!typeInfo.IsGenericType || 
+                 typeInfo.GetGenericTypeDefinition() is Type genericType && genericType != typeof(Action<>))
+            {
+                throw new InvalidOperationException("Argument value should be of type Action<>.");
+            }
+
+            var configurationType = typeInfo.GenericTypeArguments[0];
+            if (configurationType == typeof(LoggerSinkConfiguration))
+            {
+                return new Action<LoggerSinkConfiguration>(_configReader.ApplySinks);
+            }
+
+            if (configurationType == typeof(LoggerConfiguration))
+            {
+                return new Action<LoggerConfiguration>(_configReader.Configure);
+            }
+
+            throw new ArgumentException($"Handling {configurationType} is not implemented.");
+        }
+    }
+}

src/Serilog.Settings.Configuration/Settings/Configuration/ConfigurationSectionArgumentValue.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Serilog.Settings.Configuration
+{
+    interface IConfigurationArgumentValue
+    {
+        object ConvertTo(Type toType);
+    }
+}

src/Serilog.Settings.Configuration/Settings/Configuration/IConfigurationArgumentValue.cs

@@ -0,0 +1,9 @@
+using Serilog.Configuration;
+
+namespace Serilog.Settings.Configuration
+{
+    interface IConfigurationReader : ILoggerSettings
+    {
+        void ApplySinks(LoggerSinkConfiguration loggerSinkConfiguration);
+    }
+}

src/Serilog.Settings.Configuration/Settings/Configuration/IConfigurationReader.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+using Microsoft.Extensions.Primitives;
+
+using Serilog.Core;
+using Serilog.Debugging;
+using Serilog.Events;
+
+namespace Serilog.Settings.Configuration
+{
+    class StringArgumentValue : IConfigurationArgumentValue
+    {
+        readonly Func<string> _valueProducer;
+        readonly Func<IChangeToken> _changeTokenProducer;
+
+        public StringArgumentValue(Func<string> valueProducer, Func<IChangeToken> changeTokenProducer = null)
+        {
+            _valueProducer = valueProducer ?? throw new ArgumentNullException(nameof(valueProducer));
+            _changeTokenProducer = changeTokenProducer;
+        }
+
+        static readonly Dictionary<Type, Func<string, object>> ExtendedTypeConversions = new Dictionary<Type, Func<string, object>>
+            {
+                { typeof(Uri), s => new Uri(s) },
+                { typeof(TimeSpan), s => TimeSpan.Parse(s) }
+            };
+
+        public object ConvertTo(Type toType)
+        {
+            var argumentValue = Environment.ExpandEnvironmentVariables(_valueProducer());
+
+            var toTypeInfo = toType.GetTypeInfo();
+            if (toTypeInfo.IsGenericType && toType.GetGenericTypeDefinition() == typeof(Nullable<>))
+            {
+                if (string.IsNullOrEmpty(argumentValue))
+                    return null;
+
+                // unwrap Nullable<> type since we're not handling null situations
+                toType = toTypeInfo.GenericTypeArguments[0];
+                toTypeInfo = toType.GetTypeInfo();
+            }
+
+            if (toTypeInfo.IsEnum)
+                return Enum.Parse(toType, argumentValue);
+
+            var convertor = ExtendedTypeConversions
+                .Where(t => t.Key.GetTypeInfo().IsAssignableFrom(toTypeInfo))
+                .Select(t => t.Value)
+                .FirstOrDefault();
+
+            if (convertor != null)
+                return convertor(argumentValue);
+
+            if (toTypeInfo.IsInterface && !string.IsNullOrWhiteSpace(argumentValue))
+            {
+                var type = Type.GetType(argumentValue.Trim(), throwOnError: false);
+                if (type != null)
+                {
+                    var ctor = type.GetTypeInfo().DeclaredConstructors.FirstOrDefault(ci =>
+                    {
+                        var parameters = ci.GetParameters();
+                        return parameters.Length == 0 || parameters.All(pi => pi.HasDefaultValue);
+                    });
+
+                    if (ctor == null)
+                        throw new InvalidOperationException($"A default constructor was not found on {type.FullName}.");
+
+                    var call = ctor.GetParameters().Select(pi => pi.DefaultValue).ToArray();
+                    return ctor.Invoke(call);
+                }
+            }
+
+            if (toType == typeof(LoggingLevelSwitch))
+            {
+                if (!Enum.TryParse(argumentValue, out LogEventLevel minimumLevel))
+                    throw new InvalidOperationException($"The value `{argumentValue}` is not a valid Serilog level.");
+
+                var levelSwitch = new LoggingLevelSwitch(minimumLevel);
+
+                if (_changeTokenProducer != null)
+                {
+                    ChangeToken.OnChange(
+                        _changeTokenProducer,
+                        () =>
+                        {
+                            var newArgumentValue = _valueProducer();
+
+                            if (Enum.TryParse(newArgumentValue, out minimumLevel))
+                                levelSwitch.MinimumLevel = minimumLevel;
+                            else
+                                SelfLog.WriteLine($"The value `{newArgumentValue}` is not a valid Serilog level.");
+                        });
+                }
+
+                return levelSwitch;
+            }
+
+            return Convert.ChangeType(argumentValue, toType);
+        }
+    }
+}

src/Serilog.Settings.Configuration/Settings/Configuration/StringArgumentValue.cs

@@ -1,7 +1,5 @@
 using System.Collections.Generic;
-using Serilog.Settings.Configuration;
 using Serilog.Formatting;
-using Serilog.Formatting.Json;
 using Xunit;
 using System.Reflection;
 using System.Linq;
@@ -10,21 +8,14 @@ namespace Serilog.Settings.Configuration.Tests
 {
     public class ConfigurationReaderTests
     {
-        [Fact]
-        public void StringValuesConvertToDefaultInstancesIfTargetIsInterface()
-        {
-            var result = ConfigurationReader.ConvertToType("Serilog.Formatting.Json.JsonFormatter, Serilog", typeof(ITextFormatter));
-            Assert.IsType<JsonFormatter>(result);
-        }
-
         [Fact]
         public void CallableMethodsAreSelected()
         {
             var options = typeof(DummyLoggerConfigurationExtensions).GetTypeInfo().DeclaredMethods.ToList();
             Assert.Equal(2, options.Count(mi => mi.Name == "DummyRollingFile"));
-            var suppliedArguments = new Dictionary<string, string>
+            var suppliedArguments = new Dictionary<string, IConfigurationArgumentValue>
             {
-                {"pathFormat", "C:\\" }
+                {"pathFormat", new StringArgumentValue(() => "C:\\") }
             };
 
             var selected = ConfigurationReader.SelectConfigurationMethod(options, "DummyRollingFile", suppliedArguments);
@@ -36,10 +27,10 @@ public void MethodsAreSelectedBasedOnCountOfMatchedArguments()
         {
             var options = typeof(DummyLoggerConfigurationExtensions).GetTypeInfo().DeclaredMethods.ToList();
             Assert.Equal(2, options.Count(mi => mi.Name == "DummyRollingFile"));
-            var suppliedArguments = new Dictionary<string, string>()
+            var suppliedArguments = new Dictionary<string, IConfigurationArgumentValue>()
             {
-                { "pathFormat", "C:\\" },
-                { "formatter", "SomeFormatter, SomeAssembly" }
+                { "pathFormat", new StringArgumentValue(() => "C:\\") },
+                { "formatter", new StringArgumentValue(() => "SomeFormatter, SomeAssembly") }
             };
 
             var selected = ConfigurationReader.SelectConfigurationMethod(options, "DummyRollingFile", suppliedArguments);

test/Serilog.Settings.Configuration.Tests/ConfigurationReaderTests.cs

@@ -0,0 +1,19 @@
+using Serilog.Formatting;
+using Serilog.Formatting.Json;
+using Xunit;
+
+namespace Serilog.Settings.Configuration.Tests
+{
+    public class StringArgumentValueTests
+    {
+        [Fact]
+        public void StringValuesConvertToDefaultInstancesIfTargetIsInterface()
+        {
+            var stringArgumentValue = new StringArgumentValue(() => "Serilog.Formatting.Json.JsonFormatter, Serilog");
+
+            var result = stringArgumentValue.ConvertTo(typeof(ITextFormatter));
+
+            Assert.IsType<JsonFormatter>(result);
+        }
+    }
+}