multiple sinks of the same kind

Author: Sergey Komisarchik

sample/Sample/appsettings.json

@@ -8,38 +8,36 @@
         "MyApp.Something.Tricky": "Verbose"
       }
     },
-    "WriteTo": [
-      {
-        "Name": "Logger",
-        "Args": {
-          "configureLogger": {
-            "WriteTo": [
-              {
-                "Name": "LiterateConsole",
-                "Args": {
-                  "outputTemplate": "[{Timestamp:HH:mm:ss} {SourceContext} [{Level}] {Message}{NewLine}{Exception}"
-                }
-              }
-            ]
-          },
-          "restrictedToMinimumLevel": "Debug"
-        }
-      },
-      {
-        "Name": "Async",
-        "Args": {
-          "configure": [
+    "WriteTo:Sublogger": {
+      "Name": "Logger",
+      "Args": {
+        "configureLogger": {
+          "WriteTo": [
             {
-              "Name": "File",
+              "Name": "LiterateConsole",
               "Args": {
-                "path": "%TEMP%\\Logs\\serilog-configuration-sample.txt",
-                "outputTemplate": "{Timestamp:o} [{Level:u3}] ({Application}/{MachineName}/{ThreadId}) {Message}{NewLine}{Exception}"
+                "outputTemplate": "[{Timestamp:HH:mm:ss} {SourceContext} [{Level}] {Message}{NewLine}{Exception}"
               }
             }
           ]
-        }
-      }      
-    ],
+        },
+        "restrictedToMinimumLevel": "Debug"
+      }
+    },
+    "WriteTo:Async": {
+      "Name": "Async",
+      "Args": {
+        "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": {
       "Application": "Sample"

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

@@ -123,46 +123,51 @@ void ApplyEnrichment(LoggerConfiguration loggerConfiguration)
             }
         }
 
-        Dictionary<string, Dictionary<string, IConfigurationArgumentValue>> GetMethodCalls(IConfigurationSection directive)
+        internal ILookup<string, Dictionary<string, IConfigurationArgumentValue>> GetMethodCalls(IConfigurationSection directive)
         {
-            var result = new Dictionary<string, Dictionary<string, IConfigurationArgumentValue>>();
-            foreach (var child in directive.GetChildren())
+            var children = directive.GetChildren();
+
+            var result =
+                (from child in children
+                 where child.Value != null // Plain string
+                 select new { Name = child.Value, Args = new Dictionary<string, IConfigurationArgumentValue>() })
+                     .Concat(
+                (from child in children
+                 where child.Value == null
+                 let name = GetSectionName(child)
+                 let callArgs = (from argument in child.GetSection("Args").GetChildren()
+                                 select new {
+                                     Name = argument.Key,
+                                     Value = GetArgumentValue(argument) }).ToDictionary(p => p.Name, p => p.Value)
+                 select new { Name = name, Args = callArgs }))
+                     .ToLookup(p => p.Name, p => p.Args);
+
+            return result;
+
+            IConfigurationArgumentValue GetArgumentValue(IConfigurationSection argumentSection)
             {
-                if (child.Value != null)
+                IConfigurationArgumentValue argumentValue;
+                if (argumentSection.Value != null)
                 {
-                    // Plain string
-                    result.Add(child.Value, new Dictionary<string, IConfigurationArgumentValue>());
+                    argumentValue = new StringArgumentValue(() => argumentSection.Value, argumentSection.GetReloadToken);
                 }
                 else
                 {
-                    var name = child.GetSection("Name");
-                    if (name.Value == null)
-                        throw new InvalidOperationException($"The configuration value in {name.Path} has no Name element.");
-
-                    var callArgs = new Dictionary<string, IConfigurationArgumentValue>();
-                    var args = child.GetSection("Args");
-                    if (args != null)
-                    {
-                        foreach (var argument in args.GetChildren())
-                        {
-                            IConfigurationArgumentValue argumentValue;
-                            if (argument.Value != null)
-                            {
-                                argumentValue = new StringArgumentValue(() => argument.Value, argument.GetReloadToken);
-                            }
-                            else
-                            {
-                                argumentValue = new ConfigurationSectionArgumentValue(new ConfigurationReader(argument, _configurationAssemblies, _dependencyContext));
-                            }
-
-                            callArgs.Add(argument.Key, argumentValue);
-                        }
-                    }
-                    result.Add(name.Value, callArgs);
+                    argumentValue = new ConfigurationSectionArgumentValue(new ConfigurationReader(argumentSection, _configurationAssemblies, _dependencyContext));
                 }
+
+                return argumentValue;
             }
-            return result;
-        }        
+
+            string GetSectionName(IConfigurationSection s)
+            {
+                var name = s.GetSection("Name");
+                if (name.Value == null)
+                    throw new InvalidOperationException($"The configuration value in {name.Path} has no 'Name' element.");
+
+                return name.Value;
+            }
+        }
 
         Assembly[] LoadConfigurationAssemblies()
         {
@@ -178,7 +183,8 @@ Assembly[] LoadConfigurationAssemblies()
                             "A zero-length or whitespace assembly name was supplied to a Serilog.Using configuration statement.");
 
                     var assembly = Assembly.Load(new AssemblyName(simpleName));
-                    assemblies.Add(assembly.FullName, assembly);
+                    if (!assemblies.ContainsKey(assembly.FullName))
+                        assemblies.Add(assembly.FullName, assembly);
                 }
             }
 
@@ -217,9 +223,9 @@ where filter(assemblyFileName)
             return query.ToArray();
         }
 
-        static void CallConfigurationMethods(Dictionary<string, Dictionary<string, IConfigurationArgumentValue>> methods, IList<MethodInfo> configurationMethods, object receiver)
+        static void CallConfigurationMethods(ILookup<string, Dictionary<string, IConfigurationArgumentValue>> methods, IList<MethodInfo> configurationMethods, object receiver)
         {
-            foreach (var method in methods)
+            foreach (var method in methods.SelectMany(g => g.Select(x => new { g.Key, Value = x })))
             {
                 var methodInfo = SelectConfigurationMethod(configurationMethods, method.Key, method.Value);
 

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

@@ -3,11 +3,139 @@
 using Xunit;
 using System.Reflection;
 using System.Linq;
+using Serilog.Settings.Configuration.Tests.Support;
 
 namespace Serilog.Settings.Configuration.Tests
 {
     public class ConfigurationReaderTests
     {
+        readonly ConfigurationReader _configurationReader;
+
+        public ConfigurationReaderTests()
+        {
+            _configurationReader = new ConfigurationReader(JsonStringConfigSource.LoadSection(@"{ 'Serilog': {  } }", "Serilog"), null);
+        }
+
+        [Fact]
+        public void WriteToSupportSimplifiedSyntax()
+        {
+            var json = @"
+{
+    'WriteTo': [ 'LiterateConsole', 'DiagnosticTrace' ]
+}";
+
+            var result = _configurationReader.GetMethodCalls(JsonStringConfigSource.LoadSection(json, "WriteTo"));
+            Assert.Equal(2, result.Count);
+            Assert.True(result.Contains("LiterateConsole"));
+            Assert.True(result.Contains("DiagnosticTrace"));
+
+            Assert.Equal(1, result["LiterateConsole"].Count());
+            Assert.Equal(1, result["DiagnosticTrace"].Count());
+        }
+
+        [Fact]
+        public void WriteToSupportExpandedSyntaxWithoutArgs()
+        {
+            var json = @"
+{
+    'WriteTo': [ {
+        'Name': 'LiterateConsole'
+    }]
+}";
+
+            var result = _configurationReader.GetMethodCalls(JsonStringConfigSource.LoadSection(json, "WriteTo"));
+            Assert.Equal(1, result.Count);
+            Assert.True(result.Contains("LiterateConsole"));
+
+            Assert.Equal(1, result["LiterateConsole"].Count());
+        }
+
+        [Fact]
+        public void WriteToSupportExpandedSyntaxWithArgs()
+        {
+            var json = @"
+{
+    'WriteTo': [ {
+        'Name': 'LiterateConsole',
+        'Args': {
+            'outputTemplate': '{Message}'
+        },
+    }]
+}";
+
+            var result = _configurationReader.GetMethodCalls(JsonStringConfigSource.LoadSection(json, "WriteTo"));
+
+            Assert.Equal(1, result.Count);
+            Assert.True(result.Contains("LiterateConsole"));
+
+            Assert.Equal(1, result["LiterateConsole"].Count());
+
+            var args = result["LiterateConsole"].Single().Cast<KeyValuePair<string, IConfigurationArgumentValue>>().ToArray();
+
+            Assert.Equal(1, args.Length);
+            Assert.Equal("outputTemplate", args[0].Key);
+            Assert.Equal("{Message}", args[0].Value.ConvertTo(typeof(string)));
+        }
+
+        [Fact]
+        public void WriteToSupportMultipleSinksOfTheSameKind()
+        {
+            var json = @"
+{
+    'WriteTo': [
+      {
+        'Name': 'LiterateConsole',
+        'Args': {
+            'outputTemplate': '{Message}'
+          },
+      },
+      'DiagnosticTrace'
+    ],
+    'WriteTo:File1': {
+        'Name': 'File',
+        'Args': {
+            'outputTemplate': '{Message}'
+        },
+    },
+    'WriteTo:File2': {
+        'Name': 'File',
+        'Args': {
+            'outputTemplate': '{Message}'
+        },
+    }
+}";
+
+            var result = _configurationReader.GetMethodCalls(JsonStringConfigSource.LoadSection(json, "WriteTo"));
+
+            Assert.Equal(3, result.Count);
+            Assert.True(result.Contains("LiterateConsole"));
+            Assert.True(result.Contains("DiagnosticTrace"));
+            Assert.True(result.Contains("File"));
+
+            Assert.Equal(1, result["LiterateConsole"].Count());
+            Assert.Equal(1, result["DiagnosticTrace"].Count());
+            Assert.Equal(2, result["File"].Count());
+        }
+
+        [Fact]
+        public void Enrich_SupportSimplifiedSyntax()
+        {
+            var json = @"
+{
+    'Enrich': [ 'FromLogContext', 'WithMachineName', 'WithThreadId' ]
+}";
+
+            var result = _configurationReader.GetMethodCalls(JsonStringConfigSource.LoadSection(json, "Enrich"));
+            Assert.Equal(3, result.Count);
+            Assert.True(result.Contains("FromLogContext"));
+            Assert.True(result.Contains("WithMachineName"));
+            Assert.True(result.Contains("WithThreadId"));
+
+            Assert.Equal(1, result["FromLogContext"].Count());
+            Assert.Equal(1, result["WithMachineName"].Count());
+            Assert.Equal(1, result["WithThreadId"].Count());
+        }
+
         [Fact]
         public void CallableMethodsAreSelected()
         {

test/Serilog.Settings.Configuration.Tests/Serilog.Settings.Configuration.Tests.csproj

@@ -17,7 +17,7 @@
     <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
     <PackageReference Include="xunit" Version="2.2.0" />
 
-    <PackageReference Include="Microsoft.Extensions.Configuration" Version="1.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="1.0.0" />
   </ItemGroup>
 
   <ItemGroup>

test/Serilog.Settings.Configuration.Tests/Support/JsonStringConfigSource.cs

@@ -0,0 +1,53 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Configuration.Json;
+
+using System.IO;
+
+namespace Serilog.Settings.Configuration.Tests.Support
+{
+    class JsonStringConfigSource : IConfigurationSource
+    {
+        readonly string _json;
+
+        public JsonStringConfigSource(string json)
+        {
+            _json = json;
+        }
+
+        public IConfigurationProvider Build(IConfigurationBuilder builder)
+        {
+            return new JsonStringConfigProvider(_json);
+        }
+
+        public static IConfigurationSection LoadSection(string json, string section)
+        {
+            return new ConfigurationBuilder().Add(new JsonStringConfigSource(json)).Build().GetSection(section);
+        }
+
+        class JsonStringConfigProvider : JsonConfigurationProvider
+        {
+            readonly string _json;
+
+            public JsonStringConfigProvider(string json) : base(new JsonConfigurationSource { Optional = true })
+            {
+                _json = json;
+            }
+
+            public override void Load()
+            {
+                Load(StringToStream(_json));
+            }
+
+            static Stream StringToStream(string str)
+            {
+                var memStream = new MemoryStream();
+                var textWriter = new StreamWriter(memStream);
+                textWriter.Write(str);
+                textWriter.Flush();
+                memStream.Seek(0, SeekOrigin.Begin);
+
+                return memStream;
+            }
+        }
+    }
+}