Fixes #50 - include named scopes

Author: nblumhardt

src/Serilog.Extensions.Logging/Extensions/Logging/SerilogLoggerProvider.cs

@@ -12,6 +12,7 @@
 using Serilog.Core;
 using Serilog.Events;
 using FrameworkLogger = Microsoft.Extensions.Logging.ILogger;
+using System.Collections.Generic;
 
 namespace Serilog.Extensions.Logging
 {
@@ -21,17 +22,49 @@ namespace Serilog.Extensions.Logging
     public class SerilogLoggerProvider : ILoggerProvider, ILogEventEnricher
     {
         internal const string OriginalFormatPropertyName = "{OriginalFormat}";
+        internal const string ScopePropertyName = "Scope";
 
         // May be null; if it is, Log.Logger will be lazily used
         readonly ILogger _logger;
         readonly Action _dispose;
+        readonly bool _includeNamedScopes;
+
+        /// <summary>
+        /// Construct a <see cref="SerilogLoggerProvider"/>.
+        /// </summary>
+        public SerilogLoggerProvider()
+            : this(null)
+        {
+        }
+
+        /// <summary>
+        /// Construct a <see cref="SerilogLoggerProvider"/>.
+        /// </summary>
+        /// <param name="logger">A Serilog logger to pipe events through; if null, the static <see cref="Log"/> class will be used.</param>
+        public SerilogLoggerProvider(ILogger logger)
+            : this(logger, false)
+        {
+        }
 
         /// <summary>
         /// Construct a <see cref="SerilogLoggerProvider"/>.
         /// </summary>
         /// <param name="logger">A Serilog logger to pipe events through; if null, the static <see cref="Log"/> class will be used.</param>
         /// <param name="dispose">If true, the provided logger or static log class will be disposed/closed when the provider is disposed.</param>
-        public SerilogLoggerProvider(ILogger logger = null, bool dispose = false)
+        public SerilogLoggerProvider(ILogger logger, bool dispose)
+            : this(logger, dispose, false)
+        {
+        }
+
+        /// <summary>
+        /// Construct a <see cref="SerilogLoggerProvider"/>.
+        /// </summary>
+        /// <param name="logger">A Serilog logger to pipe events through; if null, the static <see cref="Log"/> class will be used.</param>
+        /// <param name="dispose">If true, the provided logger or static log class will be disposed/closed when the provider is disposed.</param>
+        /// <param name="includeNamedScopes">Indicates whether a <code>Scope</code> property should be generated when
+        /// <see cref="Microsoft.Extensions.Logging.ILogger.BeginScope"/> is called with <see cref="string"/> arguments. The
+        /// default is false.</param>
+        public SerilogLoggerProvider(ILogger logger, bool dispose, bool includeNamedScopes)
         {
             if (logger != null)
                 _logger = logger.ForContext(new[] { this });
@@ -43,6 +76,8 @@ public SerilogLoggerProvider(ILogger logger = null, bool dispose = false)
                 else
                     _dispose = Log.CloseAndFlush;
             }
+
+            _includeNamedScopes = includeNamedScopes;
         }
 
         /// <inheritdoc />
@@ -64,6 +99,25 @@ public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
             {
                 scope.Enrich(logEvent, propertyFactory);
             }
+
+            if (_includeNamedScopes)
+            {
+                List<ScalarValue> names = null;
+                for (var scope = CurrentScope; scope != null; scope = scope.Parent)
+                {
+                    string name;
+                    if (scope.TryGetName(out name))
+                    {
+                        names = names ?? new List<ScalarValue>();
+                        names.Insert(0, new ScalarValue(name));
+                    }
+                }
+
+                if (names != null)
+                {
+                    logEvent.AddPropertyIfAbsent(new LogEventProperty(ScopePropertyName, new SequenceValue(names)));
+                }
+            }
         }
 
 #if ASYNCLOCAL

src/Serilog.Extensions.Logging/Extensions/Logging/SerilogLoggerScope.cs

@@ -72,5 +72,11 @@ public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
                 }
             }
         }
+
+        public bool TryGetName(out string name)
+        {
+            name = _state as string;
+            return name != null;
+        }
     }
 }

src/Serilog.Extensions.Logging/SerilogLoggerFactoryExtensions.cs

@@ -20,15 +20,19 @@ public static class SerilogLoggerFactoryExtensions
         /// <param name="dispose">When true, dispose <paramref name="logger"/> when the framework disposes the provider. If the
         /// logger is not specified but <paramref name="dispose"/> is true, the <see cref="Log.CloseAndFlush()"/> method will be
         /// called on the static <see cref="Log"/> class instead.</param>
+        /// <param name="includeNamedScopes">Indicates whether a <code>Scope</code> property should be generated when
+        /// <see cref="Microsoft.Extensions.Logging.ILogger.BeginScope"/> is called with <see cref="string"/> arguments. The
+        /// default is false.</param>
         /// <returns>The logger factory.</returns>
         public static ILoggerFactory AddSerilog(
             this ILoggerFactory factory,
             ILogger logger = null,
-            bool dispose = false)
+            bool dispose = false,
+            bool includeNamedScopes = false)
         {
             if (factory == null) throw new ArgumentNullException(nameof(factory));
 
-            factory.AddProvider(new SerilogLoggerProvider(logger, dispose));
+            factory.AddProvider(new SerilogLoggerProvider(logger, dispose, includeNamedScopes));
 
             return factory;
         }

test/Serilog.Extensions.Logging.Tests/SerilogLoggerTests.cs

@@ -19,7 +19,7 @@ public class SerilogLoggerTest
         private const string Name = "test";
         private const string TestMessage = "This is a test";
 
-        private Tuple<SerilogLogger, SerilogSink> SetUp(LogLevel logLevel)
+        private Tuple<SerilogLogger, SerilogSink> SetUp(LogLevel logLevel, bool includeNamedScopes = false)
         {
             var sink = new SerilogSink();
 
@@ -28,7 +28,7 @@ private Tuple<SerilogLogger, SerilogSink> SetUp(LogLevel logLevel)
 
             SetMinLevel(config, logLevel);
 
-            var provider = new SerilogLoggerProvider(config.CreateLogger());
+            var provider = new SerilogLoggerProvider(config.CreateLogger(), false, includeNamedScopes);
             var logger = (SerilogLogger)provider.CreateLogger(Name);
 
             return new Tuple<SerilogLogger, SerilogSink>(logger, sink);
@@ -364,6 +364,30 @@ public void BeginScopeDoesNotModifyKeyWhenDestructurerIsNotUsedInDictionary()
             Assert.True(sink.Writes[0].Properties.ContainsKey("FirstName"));
         }
 
+        [Fact]
+        public void NamedScopesAreCapturedWhenRequested()
+        {
+            var t = SetUp(LogLevel.Trace, includeNamedScopes: true);
+            var logger = t.Item1;
+            var sink = t.Item2;
+
+            using (logger.BeginScope("Outer"))
+            using (logger.BeginScope("Inner"))
+            {
+                logger.Log(LogLevel.Information, 0, TestMessage, null, null);
+            }
+
+            Assert.Equal(1, sink.Writes.Count);
+
+            LogEventPropertyValue scopeValue;
+            Assert.True(sink.Writes[0].Properties.TryGetValue(SerilogLoggerProvider.ScopePropertyName, out scopeValue));
+
+            var items = (scopeValue as SequenceValue)?.Elements.Select(e => ((ScalarValue)e).Value).Cast<string>().ToArray();
+            Assert.Equal(2, items.Length);
+            Assert.Equal("Outer", items[0]);
+            Assert.Equal("Inner", items[1]);
+        }
+
         private class FoodScope : IEnumerable<KeyValuePair<string, object>>
         {
             readonly string _name;