Destructure support

README.md

@@ -14,6 +14,12 @@ Configuration is read from the `Serilog` section.
       { "Name": "File", "Args": { "path": "%TEMP%\\Logs\\serilog-configuration-sample.txt" } }
     ],
     "Enrich": ["FromLogContext", "WithMachineName", "WithThreadId"],
+    "Destructure": [
+      { "Name": "With", "Args": { "policy": "Sample.CustomPolicy, Sample" } },
+      { "Name": "ToMaximumDepth", "Args": { "maximumDestructuringDepth": 4 } },
+      { "Name": "ToMaximumStringLength", "Args": { "maximumStringLength": 100 } },
+      { "Name": "ToMaximumCollectionCount", "Args": { "maximumCollectionCount": 10 } }
+    ],
     "Properties": {
 		"Application": "Sample"
     }

sample/Sample/Program.cs

@@ -6,6 +6,7 @@
 using System.Linq;
 using Serilog.Core;
 using Serilog.Events;
+using System.Collections.Generic;
 
 namespace Sample
 {
@@ -32,17 +33,56 @@ public static void Main(string[] args)
                 logger.ForContext(Constants.SourceContextPropertyName, "Microsoft").Error("Hello, world!");
                 logger.ForContext(Constants.SourceContextPropertyName, "MyApp.Something.Tricky").Verbose("Hello, world!");
 
-                Console.WriteLine();
+                logger.Information("Destructure with max object nesting depth:\n{@NestedObject}",
+                    new { FiveDeep = new { Two = new { Three = new { Four = new { Five = "the end" } } } } });
+
+                logger.Information("Destructure with max string length:\n{@LongString}",
+                    new { TwentyChars = "0123456789abcdefghij" });
+
+                logger.Information("Destructure with max collection count:\n{@BigData}",
+                    new { TenItems = new string[] { "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten" } });
+
+                logger.Information("Destructure with policy to strip password:\n{@LoginData}",
+                    new LoginData { Username = "BGates", Password = "isityearoflinuxyet" });
+
+                Console.WriteLine("\nPress \"q\" to quit, or any other key to run again.\n");
             }
-            while (!args.Contains("--run-once") && (Console.ReadKey().KeyChar != 'q'));
+            while(!args.Contains("--run-once") && (Console.ReadKey().KeyChar != 'q'));
         }
     }
 
+    // The filter syntax in the sample configuration file is
+    // processed by the Serilog.Filters.Expressions package.
     public class CustomFilter : ILogEventFilter
     {
         public bool IsEnabled(LogEvent logEvent)
         {
             return true;
         }
     }
+
+    public class LoginData
+    {
+        public string Username;
+        public string Password;
+    }
+
+    public class CustomPolicy : IDestructuringPolicy
+    {
+        public bool TryDestructure(object value, ILogEventPropertyValueFactory propertyValueFactory, out LogEventPropertyValue result)
+        {
+            result = null;
+
+            if(value is LoginData)
+            {
+                result = new StructureValue(
+                    new List<LogEventProperty>
+                    {
+                        new LogEventProperty("Username", new ScalarValue(((LoginData)value).Username))
+                    });
+            }
+
+            return (result != null);
+        }
+    }
 }

sample/Sample/appsettings.json

@@ -43,6 +43,24 @@
     "Properties": {
       "Application": "Sample"
     },
+    "Destructure": [
+      {
+        "Name": "With",
+        "Args": { "policy": "Sample.CustomPolicy, Sample" }
+      },
+      {
+        "Name": "ToMaximumDepth",
+        "Args": { "maximumDestructuringDepth": 3 }
+      },
+      {
+        "Name": "ToMaximumStringLength",
+        "Args": { "maximumStringLength": 10 }
+      },
+      {
+        "Name": "ToMaximumCollectionCount",
+        "Args": { "maximumCollectionCount": 5 }
+      }
+    ],
     "Filter": [
       {
         "Name": "ByIncludingOnly",

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

@@ -57,6 +57,7 @@ public void Configure(LoggerConfiguration loggerConfiguration)
             ApplyMinimumLevel(loggerConfiguration, declaredLevelSwitches);
             ApplyEnrichment(loggerConfiguration, declaredLevelSwitches);
             ApplyFilters(loggerConfiguration, declaredLevelSwitches);
+            ApplyDestructuring(loggerConfiguration, declaredLevelSwitches);
             ApplySinks(loggerConfiguration, declaredLevelSwitches);
             ApplyAuditSinks(loggerConfiguration, declaredLevelSwitches);
         }
@@ -152,6 +153,16 @@ void ApplyFilters(LoggerConfiguration loggerConfiguration, IReadOnlyDictionary<s
             }
         }
 
+        void ApplyDestructuring(LoggerConfiguration loggerConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
+        {
+            var filterDirective = _section.GetSection("Destructure");
+            if(filterDirective.GetChildren().Any())
+            {
+                var methodCalls = GetMethodCalls(filterDirective);
+                CallConfigurationMethods(methodCalls, FindDestructureConfigurationMethods(_configurationAssemblies), loggerConfiguration.Destructure, declaredLevelSwitches);
+            }
+        }
+
         void ApplySinks(LoggerConfiguration loggerConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
         {
             var writeToDirective = _section.GetSection("WriteTo");
@@ -339,7 +350,7 @@ internal static MethodInfo SelectConfigurationMethod(IEnumerable<MethodInfo> can
 
         internal static IList<MethodInfo> FindSinkConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)
         {
-            var found = FindConfigurationMethods(configurationAssemblies, typeof(LoggerSinkConfiguration));
+            var found = FindConfigurationExtensionMethods(configurationAssemblies, typeof(LoggerSinkConfiguration));
             if (configurationAssemblies.Contains(typeof(LoggerSinkConfiguration).GetTypeInfo().Assembly))
                 found.Add(GetSurrogateConfigurationMethod<LoggerSinkConfiguration, Action<LoggerConfiguration>, LoggingLevelSwitch>((c, a, s) => Logger(c, a, LevelAlias.Minimum, s)));
 
@@ -348,30 +359,44 @@ internal static IList<MethodInfo> FindSinkConfigurationMethods(IReadOnlyCollecti
 
         internal static IList<MethodInfo> FindAuditSinkConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)
         {
-            var found = FindConfigurationMethods(configurationAssemblies, typeof(LoggerAuditSinkConfiguration));
+            var found = FindConfigurationExtensionMethods(configurationAssemblies, typeof(LoggerAuditSinkConfiguration));
 
             return found;
         }
 
         internal static IList<MethodInfo> FindFilterConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)
         {
-            var found = FindConfigurationMethods(configurationAssemblies, typeof(LoggerFilterConfiguration));
+            var found = FindConfigurationExtensionMethods(configurationAssemblies, typeof(LoggerFilterConfiguration));
             if (configurationAssemblies.Contains(typeof(LoggerFilterConfiguration).GetTypeInfo().Assembly))
                 found.Add(GetSurrogateConfigurationMethod<LoggerFilterConfiguration, ILogEventFilter, object>((c, f, _) => With(c, f)));
 
             return found;
         }
 
+        internal static IList<MethodInfo> FindDestructureConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)
+        {
+            var found = FindConfigurationExtensionMethods(configurationAssemblies, typeof(LoggerDestructuringConfiguration));
+            if(configurationAssemblies.Contains(typeof(LoggerDestructuringConfiguration).GetTypeInfo().Assembly))
+            {
+                found.Add(GetSurrogateConfigurationMethod<LoggerDestructuringConfiguration, IDestructuringPolicy, object>((c, d, _) => With(c, d)));
+                found.Add(GetSurrogateConfigurationMethod<LoggerDestructuringConfiguration, int, object>((c, m, _) => ToMaximumDepth(c, m)));
+                found.Add(GetSurrogateConfigurationMethod<LoggerDestructuringConfiguration, int, object>((c, m, _) => ToMaximumStringLength(c, m)));
+                found.Add(GetSurrogateConfigurationMethod<LoggerDestructuringConfiguration, int, object>((c, m, _) => ToMaximumCollectionCount(c, m)));
+            }
+
+            return found;
+        }
+
         internal static IList<MethodInfo> FindEventEnricherConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)
         {
-            var found = FindConfigurationMethods(configurationAssemblies, typeof(LoggerEnrichmentConfiguration));
+            var found = FindConfigurationExtensionMethods(configurationAssemblies, typeof(LoggerEnrichmentConfiguration));
             if (configurationAssemblies.Contains(typeof(LoggerEnrichmentConfiguration).GetTypeInfo().Assembly))
                 found.Add(GetSurrogateConfigurationMethod<LoggerEnrichmentConfiguration, object, object>((c, _, __) => FromLogContext(c)));
 
             return found;
         }
 
-        internal static IList<MethodInfo> FindConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies, Type configType)
+        internal static IList<MethodInfo> FindConfigurationExtensionMethods(IReadOnlyCollection<Assembly> configurationAssemblies, Type configType)
         {
             return configurationAssemblies
                 .SelectMany(a => a.ExportedTypes
@@ -383,15 +408,34 @@ internal static IList<MethodInfo> FindConfigurationMethods(IReadOnlyCollection<A
                 .ToList();
         }
 
-        // don't support (yet?) arrays in the parameter list (ILogEventEnricher[])
+        /*
+        Pass-through calls to various Serilog config methods which are
+        implemented as instance methods rather than extension methods. The
+        FindXXXConfigurationMethods calls (above) use these to add method
+        invocation expressions as surrogates so that SelectConfigurationMethod
+        has a way to match and invoke these instance methods.
+        */
+
+        // TODO: add overload for array argument (ILogEventEnricher[])
         internal static LoggerConfiguration With(LoggerFilterConfiguration loggerFilterConfiguration, ILogEventFilter filter)
             => loggerFilterConfiguration.With(filter);
 
-        // Unlike the other configuration methods, FromLogContext is an instance method rather than an extension.
+        // TODO: add overload for array argument (IDestructuringPolicy[])
+        internal static LoggerConfiguration With(LoggerDestructuringConfiguration loggerDestructuringConfiguration, IDestructuringPolicy policy)
+            => loggerDestructuringConfiguration.With(policy);
+
+        internal static LoggerConfiguration ToMaximumDepth(LoggerDestructuringConfiguration loggerDestructuringConfiguration, int maximumDestructuringDepth)
+            => loggerDestructuringConfiguration.ToMaximumDepth(maximumDestructuringDepth);
+
+        internal static LoggerConfiguration ToMaximumStringLength(LoggerDestructuringConfiguration loggerDestructuringConfiguration, int maximumStringLength)
+            => loggerDestructuringConfiguration.ToMaximumStringLength(maximumStringLength);
+
+        internal static LoggerConfiguration ToMaximumCollectionCount(LoggerDestructuringConfiguration loggerDestructuringConfiguration, int maximumCollectionCount)
+            => loggerDestructuringConfiguration.ToMaximumCollectionCount(maximumCollectionCount);
+
         internal static LoggerConfiguration FromLogContext(LoggerEnrichmentConfiguration loggerEnrichmentConfiguration)
             => loggerEnrichmentConfiguration.FromLogContext();
 
-        // Unlike the other configuration methods, Logger is an instance method rather than an extension.
         internal static LoggerConfiguration Logger(
             LoggerSinkConfiguration loggerSinkConfiguration,
             Action<LoggerConfiguration> configureLogger,

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

@@ -492,7 +492,6 @@ public void SinkWithIntArrayArgument()
             Assert.Equal(1, DummyRollingFileSink.Emitted.Count);
         }
 
-
         [Trait("Bugfix", "#91")]
         [Fact]
         public void WriteToLoggerWithRestrictedToMinimumLevelIsSupported()
@@ -597,5 +596,88 @@ public void InconsistentComplexVsScalarArgumentValuesThrowsIOE()
             Assert.Contains("The value for the argument", ex.Message);
             Assert.Contains("'Serilog:WriteTo:0:Args:pathFormat'", ex.Message);
         }
+
+        [Fact]
+        public void DestructureLimitsNestingDepth()
+        {
+            var json = @"{
+                ""Serilog"": {
+                    ""Destructure"": [
+                    {
+                        ""Name"": ""ToMaximumDepth"",
+                        ""Args"": { ""maximumDestructuringDepth"": 3 }
+                    }]
+                }
+            }";
+
+            var NestedObject = new
+            {
+                A = new
+                {
+                    B = new
+                    {
+                        C = new
+                        {
+                            D = "F"
+                        }
+                    }
+                }
+            };
+
+            var msg = GetDestructuredProperty(NestedObject, json);
+
+            Assert.Contains("C", msg);
+            Assert.DoesNotContain("D", msg);
+        }
+
+        [Fact]
+        public void DestructureLimitsStringLength()
+        {
+            var json = @"{
+                ""Serilog"": {
+                    ""Destructure"": [
+                    {
+                        ""Name"": ""ToMaximumStringLength"",
+                        ""Args"": { ""maximumStringLength"": 3 }
+                    }]
+                }
+            }";
+
+            var inputString = "ABCDEFGH";
+            var msg = GetDestructuredProperty(inputString, json);
+
+            Assert.Equal("\"AB…\"", msg);
+        }
+
+        [Fact]
+        public void DestructureLimitsCollectionCount()
+        {
+            var json = @"{
+                ""Serilog"": {
+                    ""Destructure"": [
+                    {
+                        ""Name"": ""ToMaximumCollectionCount"",
+                        ""Args"": { ""maximumCollectionCount"": 3 }
+                    }]
+                }
+            }";
+
+            var collection = new[] { 1, 2, 3, 4, 5, 6 };
+            var msg = GetDestructuredProperty(collection, json);
+
+            Assert.Contains("3", msg);
+            Assert.DoesNotContain("4", msg);
+        }
+
+        private string GetDestructuredProperty(object x, string json)
+        {
+            LogEvent evt = null;
+            var log = ConfigFromJson(json)
+                .WriteTo.Sink(new DelegatingSink(e => evt = e))
+                .CreateLogger();
+            log.Information("{@X}", x);
+            var result = evt.Properties["X"].ToString();
+            return result;
+        }
     }
 }