Merge pull request #41 from serilog/dev

2.3.0 Release

Author: nblumhardt

Diff for: sample/Sample/Program.cs

@@ -5,6 +5,7 @@
 using System.IO;
 
 using Serilog.Core;
+using Serilog.Events;
 
 namespace Sample
 {
@@ -32,4 +33,12 @@ public static void Main(string[] args)
             while (Console.ReadKey().KeyChar != 'q');
         }
     }
+
+    public class CustomFilter : ILogEventFilter
+    {
+        public bool IsEnabled(LogEvent logEvent)
+        {
+            return true;
+        }
+    }
 }

Diff for: sample/Sample/appsettings.json

@@ -26,6 +26,20 @@
     "Enrich": ["FromLogContext", "WithMachineName", "WithThreadId"],
     "Properties": {
       "Application": "Sample"
-    }
+    },
+    "Filter": [
+      {
+        "Name": "ByIncludingOnly",
+        "Args": {
+          "expression": "Application = 'Sample'"
+        }
+      },
+      {
+        "Name": "With",
+        "Args": {
+          "filter": "Sample.CustomFilter, Sample"
+        }
+      }
+    ]
   }
 }

Diff for: sample/Sample/project.json

@@ -9,7 +9,8 @@
     "Serilog.Sinks.Literate": "2.0.0",
     "Serilog.Sinks.RollingFile":  "3.0.0",
     "Serilog.Enrichers.Environment": "2.0.0",
-    "Serilog.Enrichers.Thread":  "2.0.0"
+    "Serilog.Enrichers.Thread": "2.0.0",
+    "Serilog.Filters.Expressions": "1.0.0-*"
   },
   "frameworks": {
     "net4.6": {

Diff for: src/Serilog.Settings.Configuration/Settings/Configuration/ConfigurationReader.cs

@@ -11,6 +11,7 @@
 using Serilog.Core;
 using Serilog.Debugging;
 using Serilog.Events;
+using System.Linq.Expressions;
 
 namespace Serilog.Settings.Configuration
 {
@@ -33,9 +34,20 @@ public void Configure(LoggerConfiguration loggerConfiguration)
 
             ApplyMinimumLevel(loggerConfiguration);
             ApplyEnrichment(loggerConfiguration, configurationAssemblies);
+            ApplyFilters(loggerConfiguration, configurationAssemblies);
             ApplySinks(loggerConfiguration, configurationAssemblies);
         }
 
+        void ApplyFilters(LoggerConfiguration loggerConfiguration, Assembly[] configurationAssemblies)
+        {
+            var filterDirective = _configuration.GetSection("Filter");
+            if (filterDirective != null)
+            {
+                var methodCalls = GetMethodCalls(filterDirective);
+                CallConfigurationMethods(methodCalls, FindFilterConfigurationMethods(configurationAssemblies), loggerConfiguration.Filter);
+            }
+        }
+
         void ApplySinks(LoggerConfiguration loggerConfiguration, Assembly[] configurationAssemblies)
         {
             var writeToDirective = _configuration.GetSection("WriteTo");
@@ -156,31 +168,33 @@ Assembly[] LoadConfigurationAssemblies()
 
             foreach (var assemblyName in GetSerilogConfigurationAssemblies())
             {
-                var assumedName = new AssemblyName(assemblyName);
-                var assumed = Assembly.Load(assumedName);
+                var assumed = Assembly.Load(assemblyName);
                 if (assumed != null && !assemblies.ContainsKey(assumed.FullName))
                     assemblies.Add(assumed.FullName, assumed);
             }
 
             return assemblies.Values.ToArray();
         }
 
-        string[] GetSerilogConfigurationAssemblies()
+        AssemblyName[] GetSerilogConfigurationAssemblies()
         {
-            var query = Enumerable.Empty<string>();
+            var query = Enumerable.Empty<AssemblyName>();
             var filter = new Func<string, bool>(name => name != null && name.ToLowerInvariant().Contains("serilog"));
 
             if (_dependencyContext != null)
             {
-                query = from lib in _dependencyContext.RuntimeLibraries where filter(lib.Name) select lib.Name;
+                query = from library in _dependencyContext.RuntimeLibraries
+                        from assemblyName in library.GetDefaultAssemblyNames(_dependencyContext)
+                        where filter(assemblyName.Name)
+                        select assemblyName;
             }
             else
             {
 #if APPDOMAIN
                 query = from outputAssemblyPath in System.IO.Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory, "*.dll")
                         let assemblyFileName = System.IO.Path.GetFileNameWithoutExtension(outputAssemblyPath)
                         where filter(assemblyFileName)
-                        select AssemblyName.GetAssemblyName(outputAssemblyPath).FullName;
+                        select AssemblyName.GetAssemblyName(outputAssemblyPath);
 #endif
             }
 
@@ -273,21 +287,20 @@ internal static IList<MethodInfo> FindSinkConfigurationMethods(IEnumerable<Assem
             return FindConfigurationMethods(configurationAssemblies, typeof(LoggerSinkConfiguration));
         }
 
-        // Unlike the other configuration methods, FromLogContext is an instance method rather than an extension.
-        internal static LoggerConfiguration FromLogContext(LoggerEnrichmentConfiguration loggerEnrichmentConfiguration)
+        internal static IList<MethodInfo> FindFilterConfigurationMethods(IEnumerable<Assembly> configurationAssemblies)
         {
-            return loggerEnrichmentConfiguration.FromLogContext();
-        }
+            var found = FindConfigurationMethods(configurationAssemblies, typeof(LoggerFilterConfiguration));
+            if (configurationAssemblies.Contains(typeof(LoggerFilterConfiguration).GetTypeInfo().Assembly))
+                found.Add(GetSurrogateConfigurationMethod<LoggerFilterConfiguration, ILogEventFilter>((c, f) => With(c, f)));
 
-        static readonly MethodInfo SurrogateFromLogContextConfigurationMethod = typeof(ConfigurationReader)
-            .GetTypeInfo()
-            .DeclaredMethods.Single(m => m.Name == "FromLogContext");
+            return found;
+        }
 
         internal static IList<MethodInfo> FindEventEnricherConfigurationMethods(IEnumerable<Assembly> configurationAssemblies)
         {
             var found = FindConfigurationMethods(configurationAssemblies, typeof(LoggerEnrichmentConfiguration));
             if (configurationAssemblies.Contains(typeof(LoggerEnrichmentConfiguration).GetTypeInfo().Assembly))
-                found.Add(SurrogateFromLogContextConfigurationMethod);
+                found.Add(GetSurrogateConfigurationMethod<LoggerEnrichmentConfiguration, object>((c, _) => FromLogContext(c)));
 
             return found;
         }
@@ -303,5 +316,22 @@ internal static IList<MethodInfo> FindConfigurationMethods(IEnumerable<Assembly>
                 .Where(m => m.GetParameters()[0].ParameterType == configType)
                 .ToList();
         }
+
+        // don't support (yet?) arrays in the parameter list (ILogEventEnricher[])
+        internal static LoggerConfiguration With(LoggerFilterConfiguration loggerFilterConfiguration, ILogEventFilter filter)
+        {
+            return loggerFilterConfiguration.With(filter);
+        }
+
+        // Unlike the other configuration methods, FromLogContext is an instance method rather than an extension.
+        internal static LoggerConfiguration FromLogContext(LoggerEnrichmentConfiguration loggerEnrichmentConfiguration)
+        {
+            return loggerEnrichmentConfiguration.FromLogContext();
+        }
+
+        internal static MethodInfo GetSurrogateConfigurationMethod<TConfiguration, TArg>(Expression<Action<TConfiguration, TArg>> method)
+        {
+            return (method.Body as MethodCallExpression)?.Method;
+        }
     }
 }

Diff for: src/Serilog.Settings.Configuration/project.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.2.0-*",
+  "version": "2.3.0-*",
   "description": "Microsoft.Extensions.Configuration (appsettings.json) support for Serilog.",
   "authors": [ "Serilog Contributors" ],
   "packOptions": {