Add support for LoggingLevelSwitch

Thibaud DESODT · Thibaud DESODT · commit 12f563e16531 · 2018-02-13T08:28:22.000+01:00
solves #69 Supports : - declaration of LoggingLevelSwitch - MinimumLevel.ControlledBy(switch) - MinimumLevel.Override(prefix, switch) - passing a switch by reference as the argument to a Sink (or any callable method)
diff --git a/src/Serilog.Settings.Configuration/Settings/Configuration/ConfigurationReader.cs b/src/Serilog.Settings.Configuration/Settings/Configuration/ConfigurationReader.cs
@@ -12,11 +12,14 @@
 using Serilog.Debugging;
 using Serilog.Events;
 using System.Linq.Expressions;
+using System.Text.RegularExpressions;
 
 namespace Serilog.Settings.Configuration
 {
     class ConfigurationReader : IConfigurationReader
     {
+        const string LevelSwitchNameRegex = @"^\$[A-Za-z]+[A-Za-z0-9]*$";
+
         readonly IConfigurationSection _configuration;
         readonly DependencyContext _dependencyContext;
         readonly Assembly[] _configurationAssemblies;
@@ -37,14 +40,48 @@ public ConfigurationReader(IConfigurationSection configuration, DependencyContex
 
         public void Configure(LoggerConfiguration loggerConfiguration)
         {
-            ApplyMinimumLevel(loggerConfiguration);
-            ApplyEnrichment(loggerConfiguration);
-            ApplyFilters(loggerConfiguration);
-            ApplySinks(loggerConfiguration);
-            ApplyAuditSinks(loggerConfiguration);
-        }        
-
-        void ApplyMinimumLevel(LoggerConfiguration loggerConfiguration)
+            var declaredLevelSwitches = ProcessLevelSwitchDeclarations();
+            ApplyMinimumLevel(loggerConfiguration, declaredLevelSwitches);
+            ApplyEnrichment(loggerConfiguration, declaredLevelSwitches);
+            ApplyFilters(loggerConfiguration, declaredLevelSwitches);
+            ApplySinks(loggerConfiguration, declaredLevelSwitches);
+            ApplyAuditSinks(loggerConfiguration, declaredLevelSwitches);
+        }
+
+        private IReadOnlyDictionary<string, LoggingLevelSwitch> ProcessLevelSwitchDeclarations()
+        {
+            var levelSwitchesDirective = _configuration.GetSection("LevelSwitches");
+            var namedSwitches = new Dictionary<string, LoggingLevelSwitch>();
+            if (levelSwitchesDirective != null)
+            {
+                foreach (var levelSwitchDeclaration in levelSwitchesDirective.GetChildren())
+                {
+                    var switchName = levelSwitchDeclaration.Key;
+                    var switchInitialLevel = levelSwitchDeclaration.Value;
+                    // switchName must be something like $switch to avoid ambiguities
+                    if (!IsValidSwitchName(switchName))
+                    {
+                        throw new FormatException($"\"{switchName}\" is not a valid name for a Level Switch declaration. Level switch must be declared with a '$' sign, like \"LevelSwitches\" : {{\"$switchName\" : \"InitialLevel\"}}");
+                    }
+                    LoggingLevelSwitch newSwitch;
+                    if (string.IsNullOrEmpty(switchInitialLevel))
+                    {
+                        newSwitch = new LoggingLevelSwitch();
+                    }
+                    else
+                    {
+                        var initialLevel = ParseLogEventLevel(switchInitialLevel);
+                        newSwitch = new LoggingLevelSwitch(initialLevel);
+                    }
+                    namedSwitches.Add(switchName, newSwitch);
+                }
+            }
+
+            return namedSwitches;
+        }
+
+        void ApplyMinimumLevel(LoggerConfiguration loggerConfiguration,
+            IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
         {
             var minimumLevelDirective = _configuration.GetSection("MinimumLevel");
 
@@ -54,15 +91,33 @@ void ApplyMinimumLevel(LoggerConfiguration loggerConfiguration)
                 ApplyMinimumLevel(defaultMinLevelDirective, (configuration, levelSwitch) => configuration.ControlledBy(levelSwitch));
             }
 
+            var minLevelControlledByDirective = minimumLevelDirective.GetSection("ControlledBy");
+            if (minLevelControlledByDirective?.Value != null)
+            {
+                var globalMinimumLevelSwitch = declaredLevelSwitches.LookUpSwitchByName(minLevelControlledByDirective.Value);
+                // not calling ApplyMinimumLevel local function because here we have a reference to a LogLevelSwitch already
+                loggerConfiguration.MinimumLevel.ControlledBy(globalMinimumLevelSwitch);
+            }
+
             foreach (var overrideDirective in minimumLevelDirective.GetSection("Override").GetChildren())
             {
-                ApplyMinimumLevel(overrideDirective, (configuration, levelSwitch) => configuration.Override(overrideDirective.Key, levelSwitch));
+                var overridePrefix = overrideDirective.Key;
+                var overridenLevelOrSwitch = overrideDirective.Value;
+                if (Enum.TryParse(overridenLevelOrSwitch, out LogEventLevel _))
+                {
+                    ApplyMinimumLevel(overrideDirective, (configuration, levelSwitch) => configuration.Override(overridePrefix, levelSwitch));
+                }
+                else
+                {
+                    var overrideSwitch = declaredLevelSwitches.LookUpSwitchByName(overridenLevelOrSwitch);
+                    // not calling ApplyMinimumLevel local function because here we have a reference to a LogLevelSwitch already
+                    loggerConfiguration.MinimumLevel.Override(overridePrefix, overrideSwitch);
+                }
             }
 
             void ApplyMinimumLevel(IConfigurationSection directive, Action<LoggerMinimumLevelConfiguration, LoggingLevelSwitch> applyConfigAction)
             {
-                if (!Enum.TryParse(directive.Value, out LogEventLevel minimumLevel))
-                    throw new InvalidOperationException($"The value {directive.Value} is not a valid Serilog level.");
+                var minimumLevel = ParseLogEventLevel(directive.Value);
 
                 var levelSwitch = new LoggingLevelSwitch(minimumLevel);
                 applyConfigAction(loggerConfiguration.MinimumLevel, levelSwitch);
@@ -79,49 +134,56 @@ void ApplyMinimumLevel(IConfigurationSection directive, Action<LoggerMinimumLeve
             }
         }
 
-        void ApplyFilters(LoggerConfiguration loggerConfiguration)
+
+
+        void ApplyFilters(LoggerConfiguration loggerConfiguration,
+            IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
         {
             var filterDirective = _configuration.GetSection("Filter");
             if (filterDirective != null)
             {
                 var methodCalls = GetMethodCalls(filterDirective);
-                CallConfigurationMethods(methodCalls, FindFilterConfigurationMethods(_configurationAssemblies), loggerConfiguration.Filter);
+                CallConfigurationMethods(methodCalls, FindFilterConfigurationMethods(_configurationAssemblies), loggerConfiguration.Filter, declaredLevelSwitches);
             }
         }
 
-        void ApplySinks(LoggerConfiguration loggerConfiguration)
+        void ApplySinks(LoggerConfiguration loggerConfiguration,
+            IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
         {
             var writeToDirective = _configuration.GetSection("WriteTo");
             if (writeToDirective != null)
             {
                 var methodCalls = GetMethodCalls(writeToDirective);
-                CallConfigurationMethods(methodCalls, FindSinkConfigurationMethods(_configurationAssemblies), loggerConfiguration.WriteTo);
+                CallConfigurationMethods(methodCalls, FindSinkConfigurationMethods(_configurationAssemblies), loggerConfiguration.WriteTo, declaredLevelSwitches);
             }
         }
 
-        void ApplyAuditSinks(LoggerConfiguration loggerConfiguration)
+        void ApplyAuditSinks(LoggerConfiguration loggerConfiguration,
+            IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
         {
             var auditToDirective = _configuration.GetSection("AuditTo");
             if (auditToDirective != null)
             {
                 var methodCalls = GetMethodCalls(auditToDirective);
-                CallConfigurationMethods(methodCalls, FindAuditSinkConfigurationMethods(_configurationAssemblies), loggerConfiguration.AuditTo);
+                CallConfigurationMethods(methodCalls, FindAuditSinkConfigurationMethods(_configurationAssemblies), loggerConfiguration.AuditTo, declaredLevelSwitches);
             }
         }
 
-        void IConfigurationReader.ApplySinks(LoggerSinkConfiguration loggerSinkConfiguration)
+        void IConfigurationReader.ApplySinks(LoggerSinkConfiguration loggerSinkConfiguration,
+            IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
         {
             var methodCalls = GetMethodCalls(_configuration);
-            CallConfigurationMethods(methodCalls, FindSinkConfigurationMethods(_configurationAssemblies), loggerSinkConfiguration);
+            CallConfigurationMethods(methodCalls, FindSinkConfigurationMethods(_configurationAssemblies), loggerSinkConfiguration, declaredLevelSwitches);
         }
 
-        void ApplyEnrichment(LoggerConfiguration loggerConfiguration)
+        void ApplyEnrichment(LoggerConfiguration loggerConfiguration,
+            IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
         {
             var enrichDirective = _configuration.GetSection("Enrich");
             if (enrichDirective != null)
             {
                 var methodCalls = GetMethodCalls(enrichDirective);
-                CallConfigurationMethods(methodCalls, FindEventEnricherConfigurationMethods(_configurationAssemblies), loggerConfiguration.Enrich);
+                CallConfigurationMethods(methodCalls, FindEventEnricherConfigurationMethods(_configurationAssemblies), loggerConfiguration.Enrich, declaredLevelSwitches);
             }
 
             var propertiesDirective = _configuration.GetSection("Properties");
@@ -234,7 +296,7 @@ where filter(assemblyFileName)
             return query.ToArray();
         }
 
-        static void CallConfigurationMethods(ILookup<string, Dictionary<string, IConfigurationArgumentValue>> methods, IList<MethodInfo> configurationMethods, object receiver)
+        static void CallConfigurationMethods(ILookup<string, Dictionary<string, IConfigurationArgumentValue>> methods, IList<MethodInfo> configurationMethods, object receiver, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
         {
             foreach (var method in methods.SelectMany(g => g.Select(x => new { g.Key, Value = x })))
             {
@@ -244,7 +306,7 @@ static void CallConfigurationMethods(ILookup<string, Dictionary<string, IConfigu
                 {
                     var call = (from p in methodInfo.GetParameters().Skip(1)
                                 let directive = method.Value.FirstOrDefault(s => s.Key == p.Name)
-                                select directive.Key == null ? p.DefaultValue : directive.Value.ConvertTo(p.ParameterType)).ToList();
+                                select directive.Key == null ? p.DefaultValue : directive.Value.ConvertTo(p.ParameterType, declaredLevelSwitches)).ToList();
 
                     call.Insert(0, receiver);
 
@@ -322,5 +384,17 @@ internal static LoggerConfiguration Logger(LoggerSinkConfiguration loggerSinkCon
 
         internal static MethodInfo GetSurrogateConfigurationMethod<TConfiguration, TArg1, TArg2>(Expression<Action<TConfiguration, TArg1, TArg2>> method)
             => (method.Body as MethodCallExpression)?.Method;
+
+        internal static bool IsValidSwitchName(string input)
+        {
+            return Regex.IsMatch(input, LevelSwitchNameRegex);
+        }
+
+        internal static LogEventLevel ParseLogEventLevel(string value)
+        {
+            if (!Enum.TryParse(value, out LogEventLevel parsedLevel))
+                throw new InvalidOperationException($"The value {value} is not a valid Serilog level.");
+            return parsedLevel;
+        }
     }
 }
diff --git a/src/Serilog.Settings.Configuration/Settings/Configuration/ConfigurationSectionArgumentValue.cs b/src/Serilog.Settings.Configuration/Settings/Configuration/ConfigurationSectionArgumentValue.cs
@@ -1,6 +1,8 @@
 ﻿using Serilog.Configuration;
 using System;
+using System.Collections.Generic;
 using System.Reflection;
+using Serilog.Core;
 
 namespace Serilog.Settings.Configuration
 {
@@ -13,10 +15,10 @@ public ConfigurationSectionArgumentValue(IConfigurationReader configReader)
             _configReader = configReader ?? throw new ArgumentNullException(nameof(configReader));
         }
 
-        public object ConvertTo(Type toType)
+        public object ConvertTo(Type toType, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
         {
             var typeInfo = toType.GetTypeInfo();
-            if (!typeInfo.IsGenericType || 
+            if (!typeInfo.IsGenericType ||
                  typeInfo.GetGenericTypeDefinition() is Type genericType && genericType != typeof(Action<>))
             {
                 throw new InvalidOperationException("Argument value should be of type Action<>.");
@@ -25,7 +27,7 @@ public object ConvertTo(Type toType)
             var configurationType = typeInfo.GenericTypeArguments[0];
             if (configurationType == typeof(LoggerSinkConfiguration))
             {
-                return new Action<LoggerSinkConfiguration>(_configReader.ApplySinks);
+                return new Action<LoggerSinkConfiguration>(loggerSinkConfig => _configReader.ApplySinks(loggerSinkConfig, declaredLevelSwitches));
             }
 
             if (configurationType == typeof(LoggerConfiguration))
diff --git a/src/Serilog.Settings.Configuration/Settings/Configuration/IConfigurationArgumentValue.cs b/src/Serilog.Settings.Configuration/Settings/Configuration/IConfigurationArgumentValue.cs
@@ -1,9 +1,11 @@
 ﻿using System;
+using System.Collections.Generic;
+using Serilog.Core;
 
 namespace Serilog.Settings.Configuration
 {
     interface IConfigurationArgumentValue
     {
-        object ConvertTo(Type toType);
+        object ConvertTo(Type toType, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches);
     }
 }
diff --git a/src/Serilog.Settings.Configuration/Settings/Configuration/IConfigurationReader.cs b/src/Serilog.Settings.Configuration/Settings/Configuration/IConfigurationReader.cs
@@ -1,9 +1,11 @@
-﻿using Serilog.Configuration;
+﻿using System.Collections.Generic;
+using Serilog.Configuration;
+using Serilog.Core;
 
 namespace Serilog.Settings.Configuration
 {
     interface IConfigurationReader : ILoggerSettings
     {
-        void ApplySinks(LoggerSinkConfiguration loggerSinkConfiguration);
+        void ApplySinks(LoggerSinkConfiguration loggerSinkConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches);
     }
 }
diff --git a/src/Serilog.Settings.Configuration/Settings/Configuration/LevelSwitchDictionaryExtensions.cs b/src/Serilog.Settings.Configuration/Settings/Configuration/LevelSwitchDictionaryExtensions.cs
@@ -0,0 +1,30 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Serilog.Core;
+
+namespace Serilog.Settings.Configuration
+{
+    internal static class LevelSwitchDictionaryExtensions
+    {
+        /// <summary>
+        /// Looks up a switch in the declared LoggingLevelSwitches
+        /// </summary>
+        /// <param name="namedLevelSwitches">the dictionary of switches to look up by name</param>
+        /// <param name="switchName">the name of a switch to look up</param>
+        /// <returns>the LoggingLevelSwitch registered with the name</returns>
+        /// <exception cref="InvalidOperationException">if no switch has been registered with <paramref name="switchName"/></exception>
+        public static LoggingLevelSwitch LookUpSwitchByName(this IReadOnlyDictionary<string, LoggingLevelSwitch> namedLevelSwitches, string switchName)
+        {
+            if (namedLevelSwitches == null) throw new ArgumentNullException(nameof(namedLevelSwitches));
+            if (namedLevelSwitches.TryGetValue(switchName, out var levelSwitch))
+            {
+                return levelSwitch;
+            }
+
+            throw new InvalidOperationException($"No LoggingLevelSwitch has been declared with name \"{switchName}\". You might be missing a section \"LevelSwitches\":{{\"{switchName}\":\"InitialLevel\"}}");
+        }
+    }
+}
diff --git a/src/Serilog.Settings.Configuration/Settings/Configuration/StringArgumentValue.cs b/src/Serilog.Settings.Configuration/Settings/Configuration/StringArgumentValue.cs
@@ -30,10 +30,15 @@ public StringArgumentValue(Func<string> valueProducer, Func<IChangeToken> change
                 { typeof(TimeSpan), s => TimeSpan.Parse(s) }
             };
 
-        public object ConvertTo(Type toType)
+        public object ConvertTo(Type toType, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
         {
             var argumentValue = Environment.ExpandEnvironmentVariables(_valueProducer());
 
+            if (toType == typeof(LoggingLevelSwitch))
+            {
+                return declaredLevelSwitches.LookUpSwitchByName(argumentValue);
+            }
+
             var toTypeInfo = toType.GetTypeInfo();
             if (toTypeInfo.IsGenericType && toType.GetGenericTypeDefinition() == typeof(Nullable<>))
             {
diff --git a/test/Serilog.Settings.Configuration.Tests/ConfigurationReaderTests.cs b/test/Serilog.Settings.Configuration.Tests/ConfigurationReaderTests.cs
@@ -3,6 +3,7 @@
 using Xunit;
 using System.Reflection;
 using System.Linq;
+using Serilog.Core;
 using Serilog.Settings.Configuration.Tests.Support;
 
 namespace Serilog.Settings.Configuration.Tests
@@ -74,7 +75,7 @@ public void WriteToSupportExpandedSyntaxWithArgs()
 
             Assert.Equal(1, args.Length);
             Assert.Equal("outputTemplate", args[0].Key);
-            Assert.Equal("{Message}", args[0].Value.ConvertTo(typeof(string)));
+            Assert.Equal("{Message}", args[0].Value.ConvertTo(typeof(string), new Dictionary<string, LoggingLevelSwitch>()));
         }
 
         [Fact]
diff --git a/test/Serilog.Settings.Configuration.Tests/ConfigurationSettingsTests.cs b/test/Serilog.Settings.Configuration.Tests/ConfigurationSettingsTests.cs
diff --git a/test/Serilog.Settings.Configuration.Tests/StringArgumentValueTests.cs b/test/Serilog.Settings.Configuration.Tests/StringArgumentValueTests.cs

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,8 @@`
`1`	`1`	`using Serilog.Configuration;`
`2`	`2`	`using System;`
	`3`	`+using System.Collections.Generic;`
`3`	`4`	`using System.Reflection;`
	`5`	`+using Serilog.Core;`
`4`	`6`
`5`	`7`	`namespace Serilog.Settings.Configuration`
`6`	`8`	`{`
`@@ -13,10 +15,10 @@ public ConfigurationSectionArgumentValue(IConfigurationReader configReader)`
`13`	`15`	`_configReader = configReader ?? throw new ArgumentNullException(nameof(configReader));`
`14`	`16`	`}`
`15`	`17`
`16`		`- public object ConvertTo(Type toType)`
	`18`	`+ public object ConvertTo(Type toType, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)`
`17`	`19`	`{`
`18`	`20`	`var typeInfo = toType.GetTypeInfo();`
`19`		`- if (!typeInfo.IsGenericType \|\|`
	`21`	`+ if (!typeInfo.IsGenericType \|\|`
`20`	`22`	`typeInfo.GetGenericTypeDefinition() is Type genericType && genericType != typeof(Action<>))`
`21`	`23`	`{`
`22`	`24`	`throw new InvalidOperationException("Argument value should be of type Action<>.");`
`@@ -25,7 +27,7 @@ public object ConvertTo(Type toType)`
`25`	`27`	`var configurationType = typeInfo.GenericTypeArguments[0];`
`26`	`28`	`if (configurationType == typeof(LoggerSinkConfiguration))`
`27`	`29`	`{`
`28`		`- return new Action<LoggerSinkConfiguration>(_configReader.ApplySinks);`
	`30`	`+ return new Action<LoggerSinkConfiguration>(loggerSinkConfig => _configReader.ApplySinks(loggerSinkConfig, declaredLevelSwitches));`
`29`	`31`	`}`
`30`	`32`
`31`	`33`	`if (configurationType == typeof(LoggerConfiguration))`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,11 @@`
`1`	`1`	`using System;`
	`2`	`+using System.Collections.Generic;`
	`3`	`+using Serilog.Core;`
`2`	`4`
`3`	`5`	`namespace Serilog.Settings.Configuration`
`4`	`6`	`{`
`5`	`7`	`interface IConfigurationArgumentValue`
`6`	`8`	`{`
`7`		`- object ConvertTo(Type toType);`
	`9`	`+ object ConvertTo(Type toType, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches);`
`8`	`10`	`}`
`9`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,11 @@`
`1`		`-using Serilog.Configuration;`
	`1`	`+using System.Collections.Generic;`
	`2`	`+using Serilog.Configuration;`
	`3`	`+using Serilog.Core;`
`2`	`4`
`3`	`5`	`namespace Serilog.Settings.Configuration`
`4`	`6`	`{`
`5`	`7`	`interface IConfigurationReader : ILoggerSettings`
`6`	`8`	`{`
`7`		`- void ApplySinks(LoggerSinkConfiguration loggerSinkConfiguration);`
	`9`	`+ void ApplySinks(LoggerSinkConfiguration loggerSinkConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches);`
`8`	`10`	`}`
`9`	`11`	`}`