Proof-of-concept AddProvider() infrastructure

Author: nblumhardt

samples/Sample/Program.cs

@@ -2,26 +2,37 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Serilog;
+using Serilog.Extensions.Logging;
 
 namespace Sample
 {
     public class Program
     {
         public static void Main(string[] args)
         {
+            // Creating a `LoggerProviderCollection` lets Serilog optionally write
+            // events through other dynamically-added MEL ILoggerProviders.
+            var providers = new LoggerProviderCollection();
+
             Log.Logger = new LoggerConfiguration()
                 .MinimumLevel.Debug()
-                .WriteTo.LiterateConsole()
+                .WriteTo.Console()
+                .WriteTo.Providers(providers)
                 .CreateLogger();
 
-            var services = new ServiceCollection()
-                .AddLogging(builder =>
-                {
-                    builder.AddSerilog();
-                });
+            var services = new ServiceCollection();
+            services.AddSingleton<ILoggerFactory>(sc =>
+            {
+                // Add providers already registered through IoC
+                foreach (var provider in sc.GetServices<ILoggerProvider>())
+                    providers.AddProvider(provider);
+
+                return new SerilogLoggerFactory(null, true, providers);
+            });
+
+            services.AddLogging(l => l.AddConsole());
 
             var serviceProvider = services.BuildServiceProvider();
-            // getting the logger using the class's name is conventional
             var logger = serviceProvider.GetRequiredService<ILogger<Program>>();
 
             var startTime = DateTimeOffset.UtcNow;
@@ -57,6 +68,8 @@ public static void Main(string[] args)
             logger.LogInformation("{Result,-10:l}{StartTime,15:l}{EndTime,15:l}{Duration,15:l}", "RESULT", "START TIME", "END TIME", "DURATION(ms)");
             logger.LogInformation("{Result,-10:l}{StartTime,15:l}{EndTime,15:l}{Duration,15:l}", "------", "----- ----", "--- ----", "------------");
             logger.LogInformation("{Result,-10:l}{StartTime,15:mm:s tt}{EndTime,15:mm:s tt}{Duration,15}", "SUCCESS", startTime, endTime, (endTime - startTime).TotalMilliseconds);
+
+            serviceProvider.Dispose();
         }
     }
 }

samples/Sample/Sample.csproj

@@ -14,7 +14,8 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.0.0" />
     <PackageReference Include="Microsoft.Extensions.Logging" Version="2.0.0" />
-    <PackageReference Include="Serilog.Sinks.Literate" Version="2.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="2.0.0" />
+    <PackageReference Include="Serilog.Sinks.Console" Version="3.1.1" />
   </ItemGroup>
 
 </Project>

src/Serilog.Extensions.Logging/Extensions/Logging/LevelMapping.cs

@@ -0,0 +1,50 @@
+using Microsoft.Extensions.Logging;
+using Serilog.Events;
+
+namespace Serilog.Extensions.Logging
+{
+    static class LevelMapping
+    {
+        public static LogEventLevel ToSerilogLevel(LogLevel logLevel)
+        {
+            switch (logLevel)
+            {
+                case LogLevel.Critical:
+                    return LogEventLevel.Fatal;
+                case LogLevel.Error:
+                    return LogEventLevel.Error;
+                case LogLevel.Warning:
+                    return LogEventLevel.Warning;
+                case LogLevel.Information:
+                    return LogEventLevel.Information;
+                case LogLevel.Debug:
+                    return LogEventLevel.Debug;
+                // ReSharper disable once RedundantCaseLabel
+                case LogLevel.Trace:
+                default:
+                    return LogEventLevel.Verbose;
+            }
+        }
+
+        public static LogLevel ToExtensionsLevel(LogEventLevel logEventLevel)
+        {
+            switch (logEventLevel)
+            {
+                case LogEventLevel.Fatal:
+                    return LogLevel.Critical;
+                case LogEventLevel.Error:
+                    return LogLevel.Error;
+                case LogEventLevel.Warning:
+                    return LogLevel.Warning;
+                case LogEventLevel.Information:
+                    return LogLevel.Information;
+                case LogEventLevel.Debug:
+                    return LogLevel.Debug;
+                // ReSharper disable once RedundantCaseLabel
+                case LogEventLevel.Verbose:
+                default:
+                    return LogLevel.Trace;
+            }
+        }
+    }
+}

src/Serilog.Extensions.Logging/Extensions/Logging/LoggerProviderCollection.cs

@@ -0,0 +1,67 @@
+// Copyright 2019 Serilog Contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using Microsoft.Extensions.Logging;
+
+namespace Serilog.Extensions.Logging
+{
+    /// <summary>
+    /// A dynamically-modifiable collection of <see cref="ILoggerProvider"/>s.
+    /// </summary>
+    public class LoggerProviderCollection : IDisposable
+    {
+        volatile ILoggerProvider[] _providers = new ILoggerProvider[0];
+
+        /// <summary>
+        /// Add <paramref name="provider"/> to the collection.
+        /// </summary>
+        /// <param name="provider">A logger provider.</param>
+        public void AddProvider(ILoggerProvider provider)
+        {
+            if (provider == null) throw new ArgumentNullException(nameof(provider));
+
+            var existing = _providers;
+            var added = existing.Concat(new[] {provider}).ToArray();
+
+#pragma warning disable 420 // ref to a volatile field
+            while (Interlocked.CompareExchange(ref _providers, added, existing) != existing)
+#pragma warning restore 420
+            {
+                existing = _providers;
+                added = existing.Concat(new[] { provider }).ToArray();
+            }
+        }
+
+        /// <summary>
+        /// Get the currently-active providers.
+        /// </summary>
+        /// <remarks>
+        /// If the collection has been disposed, we'll leave the individual
+        /// providers with the job of throwing <see cref="ObjectDisposedException"/>.
+        /// </remarks>
+        public IEnumerable<ILoggerProvider> Providers => _providers;
+
+        /// <inheritdoc cref="IDisposable"/>
+        public void Dispose()
+        {
+            foreach (var provider in _providers)
+                provider.Dispose();
+        }
+    }
+}

src/Serilog.Extensions.Logging/Extensions/Logging/LoggerProviderCollectionSink.cs

@@ -0,0 +1,61 @@
+// Copyright 2019 Serilog Contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using Microsoft.Extensions.Logging;
+using Serilog.Core;
+using Serilog.Events;
+
+namespace Serilog.Extensions.Logging
+{
+    class LoggerProviderCollectionSink : ILogEventSink, IDisposable
+    {
+        readonly LoggerProviderCollection _providers;
+
+        public LoggerProviderCollectionSink(LoggerProviderCollection providers)
+        {
+            _providers = providers ?? throw new ArgumentNullException(nameof(providers));
+        }
+
+        public void Emit(LogEvent logEvent)
+        {
+            string categoryName = null;
+
+            if (logEvent.Properties.TryGetValue("SourceContext", out var sourceContextProperty) &&
+                sourceContextProperty is ScalarValue sourceContextValue &&
+                sourceContextValue.Value is string sourceContext)
+            {
+                categoryName = sourceContext;
+            }
+
+            foreach (var provider in _providers.Providers)
+            {
+                var logger = provider.CreateLogger(categoryName);
+
+
+                logger.Log(
+                    LevelMapping.ToExtensionsLevel(logEvent.Level), 
+                    default(EventId), 
+                    logEvent,
+                    logEvent.Exception,
+                    (s, ex) => s.RenderMessage());
+            }
+        }
+
+        public void Dispose()
+        {
+            _providers.Dispose();
+        }
+    }
+}

src/Serilog.Extensions.Logging/Extensions/Logging/SerilogLogger.cs

@@ -39,7 +39,7 @@ public SerilogLogger(
 
         public bool IsEnabled(LogLevel logLevel)
         {
-            return _logger.IsEnabled(ConvertLevel(logLevel));
+            return _logger.IsEnabled(LevelMapping.ToSerilogLevel(logLevel));
         }
 
         public IDisposable BeginScope<TState>(TState state)
@@ -49,7 +49,7 @@ public IDisposable BeginScope<TState>(TState state)
 
         public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
         {
-            var level = ConvertLevel(logLevel);
+            var level = LevelMapping.ToSerilogLevel(logLevel);
             if (!_logger.IsEnabled(level))
             {
                 return;
@@ -133,27 +133,6 @@ static object AsLoggableValue<TState>(TState state, Func<TState, Exception, stri
             return sobj;
         }
 
-        static LogEventLevel ConvertLevel(LogLevel logLevel)
-        {
-            switch (logLevel)
-            {
-                case LogLevel.Critical:
-                    return LogEventLevel.Fatal;
-                case LogLevel.Error:
-                    return LogEventLevel.Error;
-                case LogLevel.Warning:
-                    return LogEventLevel.Warning;
-                case LogLevel.Information:
-                    return LogEventLevel.Information;
-                case LogLevel.Debug:
-                    return LogEventLevel.Debug;
-                // ReSharper disable once RedundantCaseLabel
-                case LogLevel.Trace:
-                default:
-                    return LogEventLevel.Verbose;
-            }
-        }
-
         static LogEventProperty CreateEventIdProperty(EventId eventId)
         {
             var properties = new List<LogEventProperty>(2);

src/Serilog.Extensions.Logging/Extensions/Logging/SerilogLoggerFactory.cs

@@ -0,0 +1,76 @@
+// Copyright 2019 Serilog Contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using Microsoft.Extensions.Logging;
+using Serilog.Debugging;
+
+namespace Serilog.Extensions.Logging
+{
+    /// <summary>
+    /// A complete Serilog-backed implementation of the .NET Core logging infrastructure.
+    /// </summary>
+    public class SerilogLoggerFactory : ILoggerFactory
+    {
+        readonly LoggerProviderCollection _providerCollection;
+        readonly SerilogLoggerProvider _provider;
+        
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SerilogLoggerFactory"/> class.
+        /// </summary>
+        /// <param name="logger">The Serilog logger; if not supplied, the static <see cref="Serilog.Log"/> will be used.</param>
+        /// <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="providerCollection">A <see cref="LoggerProviderCollection"/>, for use with <c>WriteTo.Providers()</c>.</param>
+        public SerilogLoggerFactory(ILogger logger = null, bool dispose = false, LoggerProviderCollection providerCollection = null)
+        {
+            _provider = new SerilogLoggerProvider(logger, dispose);
+            _providerCollection = providerCollection;
+        }
+
+        /// <summary>
+        /// Disposes the provider.
+        /// </summary>
+        public void Dispose()
+        {
+            _provider.Dispose();
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="T:Microsoft.Extensions.Logging.ILogger" /> instance.
+        /// </summary>
+        /// <param name="categoryName">The category name for messages produced by the logger.</param>
+        /// <returns>
+        /// The <see cref="T:Microsoft.Extensions.Logging.ILogger" />.
+        /// </returns>
+        public Microsoft.Extensions.Logging.ILogger CreateLogger(string categoryName)
+        {
+            return _provider.CreateLogger(categoryName);
+        }
+
+        /// <summary>
+        /// Adds an <see cref="T:Microsoft.Extensions.Logging.ILoggerProvider" /> to the logging system.
+        /// </summary>
+        /// <param name="provider">The <see cref="T:Microsoft.Extensions.Logging.ILoggerProvider" />.</param>
+        public void AddProvider(ILoggerProvider provider)
+        {
+            if (provider == null) throw new ArgumentNullException(nameof(provider));
+            if (_providerCollection != null)
+                _providerCollection.AddProvider(provider);
+            else
+                SelfLog.WriteLine("Ignoring added logger provider {0}", provider);
+        }
+    }
+}

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

@@ -57,7 +57,7 @@ public FrameworkLogger CreateLogger(string name)
             return new SerilogLogger(this, _logger, name);
         }
 
-        /// <inheritdoc />
+        /// <inheritdoc cref="IDisposable" />
         public IDisposable BeginScope<T>(T state)
         {
             if (CurrentScope != null)
@@ -66,7 +66,7 @@ public IDisposable BeginScope<T>(T state)
             // The outermost scope pushes and pops the Serilog `LogContext` - once
             // this enricher is on the stack, the `CurrentScope` property takes care
             // of the rest of the `BeginScope()` stack.
-            var popSerilogContext = LogContext.PushProperties(this);
+            var popSerilogContext = LogContext.Push(this);
             return new SerilogLoggerScope(this, state, popSerilogContext);
         }