Add scopes to azure loggers (#928)

pakrym · web-flow · commit e94b64f96b42 · 2018-11-06T11:29:45.000-08:00
diff --git a/src/Microsoft.Extensions.Logging.AzureAppServices/AzureAppServicesLoggerFactoryExtensions.cs b/src/Microsoft.Extensions.Logging.AzureAppServices/AzureAppServicesLoggerFactoryExtensions.cs
@@ -6,6 +6,7 @@
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Logging.AzureAppServices;
 using Microsoft.Extensions.Logging.AzureAppServices.Internal;
+using Microsoft.Extensions.Logging.Configuration;
 using Microsoft.Extensions.Options;
 using static Microsoft.Extensions.DependencyInjection.ServiceDescriptor;
 
@@ -54,6 +55,7 @@ internal static ILoggingBuilder AddAzureWebAppDiagnostics(this ILoggingBuilder b
                 services.AddSingleton<IConfigureOptions<AzureFileLoggerOptions>>(new FileLoggerConfigureOptions(config, context));
                 services.AddSingleton<IOptionsChangeTokenSource<AzureFileLoggerOptions>>(
                     new ConfigurationChangeTokenSource<AzureFileLoggerOptions>(config));
+                LoggerProviderOptions.RegisterProviderOptions<AzureFileLoggerOptions, FileLoggerProvider>(builder.Services);
             }
 
             if (addedBlobLogger)
@@ -62,6 +64,7 @@ internal static ILoggingBuilder AddAzureWebAppDiagnostics(this ILoggingBuilder b
                 services.AddSingleton<IConfigureOptions<AzureBlobLoggerOptions>>(new BlobLoggerConfigureOptions(config, context));
                 services.AddSingleton<IOptionsChangeTokenSource<AzureBlobLoggerOptions>>(
                     new ConfigurationChangeTokenSource<AzureBlobLoggerOptions>(config));
+                LoggerProviderOptions.RegisterProviderOptions<AzureBlobLoggerOptions, BlobLoggerProvider>(builder.Services);
             }
 
             return builder;
diff --git a/src/Microsoft.Extensions.Logging.AzureAppServices/Internal/BatchingLogger.cs b/src/Microsoft.Extensions.Logging.AzureAppServices/Internal/BatchingLogger.cs
@@ -40,7 +40,22 @@ public void Log<TState>(DateTimeOffset timestamp, LogLevel logLevel, EventId eve
             builder.Append(logLevel.ToString());
             builder.Append("] ");
             builder.Append(_category);
-            builder.Append(": ");
+
+            var scopeProvider = _provider.ScopeProvider;
+            if (scopeProvider != null)
+            {
+                scopeProvider.ForEachScope((scope, stringBuilder) =>
+                {
+                    stringBuilder.Append(" => ").Append(scope);
+                }, builder);
+
+                builder.AppendLine(":");
+            }
+            else
+            {
+                builder.Append(": ");
+            }
+
             builder.AppendLine(formatter(state, exception));
 
             if (exception != null)
diff --git a/src/Microsoft.Extensions.Logging.AzureAppServices/Internal/BatchingLoggerOptions.cs b/src/Microsoft.Extensions.Logging.AzureAppServices/Internal/BatchingLoggerOptions.cs
@@ -66,5 +66,11 @@ public int? BatchSize
         /// Gets or sets value indicating if logger accepts and queues writes.
         /// </summary>
         public bool IsEnabled { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether scopes should be included in the message.
+        /// Defaults to <c>false</c>.
+        /// </summary>
+        public bool IncludeScopes { get; set; } = false;
     }
 }
diff --git a/src/Microsoft.Extensions.Logging.AzureAppServices/Internal/BatchingLoggerProvider.cs b/src/Microsoft.Extensions.Logging.AzureAppServices/Internal/BatchingLoggerProvider.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.Extensions.Logging.AzureAppServices.Internal
 {
-    public abstract class BatchingLoggerProvider: ILoggerProvider
+    public abstract class BatchingLoggerProvider: ILoggerProvider, ISupportExternalScope
     {
         private readonly List<LogMessage> _currentBatch = new List<LogMessage>();
         private readonly TimeSpan _interval;
@@ -22,6 +22,11 @@ public abstract class BatchingLoggerProvider: ILoggerProvider
         private Task _outputTask;
         private CancellationTokenSource _cancellationTokenSource;
 
+        private bool _includeScopes;
+        private IExternalScopeProvider _scopeProvider;
+
+        internal IExternalScopeProvider ScopeProvider => _includeScopes ? _scopeProvider : null;
+
         protected BatchingLoggerProvider(IOptionsMonitor<BatchingLoggerOptions> options)
         {
             // NOTE: Only IsEnabled is monitored
@@ -50,6 +55,8 @@ private void UpdateOptions(BatchingLoggerOptions options)
         {
             var oldIsEnabled = IsEnabled;
             IsEnabled = options.IsEnabled;
+            _includeScopes = options.IncludeScopes;
+
             if (oldIsEnabled != IsEnabled)
             {
                 if (IsEnabled)
@@ -159,5 +166,10 @@ public ILogger CreateLogger(string categoryName)
         {
             return new BatchingLogger(this, categoryName);
         }
+
+        void ISupportExternalScope.SetScopeProvider(IExternalScopeProvider scopeProvider)
+        {
+            _scopeProvider = scopeProvider;
+        }
     }
 }
diff --git a/src/Microsoft.Extensions.Logging.Configuration/LoggerProviderConfigurationExtensions.cs b/src/Microsoft.Extensions.Logging.Configuration/LoggerProviderConfigurationExtensions.cs
@@ -0,0 +1,26 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Options;
+
+namespace Microsoft.Extensions.Logging.Configuration
+{
+    /// <summary>
+    /// Provides a set of helpers to initialize options objects from logger provider configuration.
+    /// </summary>
+    public static class LoggerProviderOptions
+    {
+        /// <summary>
+        /// Indicates that settings for <typeparamref name="TProvider"/> should be loaded into <typeparamref name="TOptions"/> type.
+        /// </summary>
+        /// <typeparam name="TOptions">The options class </typeparam>
+        /// <typeparam name="TProvider">The provider class</typeparam>
+        public static void RegisterProviderOptions<TOptions, TProvider>(IServiceCollection services) where TOptions : class
+        {
+            services.TryAddEnumerable(ServiceDescriptor.Singleton<IConfigureOptions<TOptions>, LoggerProviderConfigureOptions<TOptions, TProvider>>());
+            services.TryAddEnumerable(ServiceDescriptor.Singleton<IOptionsChangeTokenSource<TOptions>, LoggerProviderOptionsChangeTokenSource<TOptions, TProvider>>());
+        }
+    }
+}
diff --git a/src/Microsoft.Extensions.Logging.Configuration/LoggerProviderConfigureOptions.cs b/src/Microsoft.Extensions.Logging.Configuration/LoggerProviderConfigureOptions.cs
@@ -0,0 +1,18 @@
+﻿// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.Extensions.Options;
+
+namespace Microsoft.Extensions.Logging.Configuration
+{
+    /// <summary>
+    /// Loads settings for <typeparamref name="TProvider"/> into <typeparamref name="TOptions"/> type.
+    /// </summary>
+    internal class LoggerProviderConfigureOptions<TOptions, TProvider> : ConfigureFromConfigurationOptions<TOptions> where TOptions : class
+    {
+        public LoggerProviderConfigureOptions(ILoggerProviderConfiguration<TProvider> providerConfiguration)
+            : base(providerConfiguration.Configuration)
+        {
+        }
+    }
+}
diff --git a/src/Microsoft.Extensions.Logging.Console/ConsoleLoggerFactoryExtensions.cs b/src/Microsoft.Extensions.Logging.Console/ConsoleLoggerFactoryExtensions.cs
@@ -22,8 +22,7 @@ public static ILoggingBuilder AddConsole(this ILoggingBuilder builder)
             builder.AddConfiguration();
 
             builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<ILoggerProvider, ConsoleLoggerProvider>());
-            builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<IConfigureOptions<ConsoleLoggerOptions>, ConsoleLoggerOptionsSetup>());
-            builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<IOptionsChangeTokenSource<ConsoleLoggerOptions>, LoggerProviderOptionsChangeTokenSource<ConsoleLoggerOptions, ConsoleLoggerProvider>>());
+            LoggerProviderOptions.RegisterProviderOptions<ConsoleLoggerOptions, ConsoleLoggerProvider>(builder.Services);
             return builder;
         }
 
diff --git a/test/Microsoft.Extensions.Logging.AzureAppServices.Test/BatchingLoggerProviderTests.cs b/test/Microsoft.Extensions.Logging.AzureAppServices.Test/BatchingLoggerProviderTests.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging.AzureAppServices.Internal;
@@ -13,8 +14,9 @@ namespace Microsoft.Extensions.Logging.AzureAppServices.Test
 {
     public class BatchingLoggerProviderTests
     {
-        DateTimeOffset _timestampOne = new DateTimeOffset(2016, 05, 04, 03, 02, 01, TimeSpan.Zero);
-        string _nl = Environment.NewLine;
+        private DateTimeOffset _timestampOne = new DateTimeOffset(2016, 05, 04, 03, 02, 01, TimeSpan.Zero);
+        private string _nl = Environment.NewLine;
+        private Regex _timeStampRegex = new Regex(@"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}.\d{3} .\d{2}:\d{2} ");
 
         [Fact]
         public async Task LogsInIntervals()
@@ -34,6 +36,33 @@ public async Task LogsInIntervals()
             Assert.Equal("2016-05-04 04:02:01.000 +00:00 [Error] Cat: Error message" + _nl, provider.Batches[0][1].Message);
         }
 
+        [Fact]
+        public async Task IncludesScopes()
+        {
+            var provider = new TestBatchingLoggingProvider(includeScopes: true);
+            var factory = new LoggerFactory(new [] { provider });
+            var logger = factory.CreateLogger("Cat");
+
+            await provider.IntervalControl.Pause;
+
+            using (logger.BeginScope("Scope"))
+            {
+                using (logger.BeginScope("Scope2"))
+                {
+                    logger.Log(LogLevel.Information, 0, "Info message", null, (state, ex) => state);
+                }
+            }
+
+            provider.IntervalControl.Resume();
+            await provider.IntervalControl.Pause;
+
+            Assert.Matches(_timeStampRegex, provider.Batches[0][0].Message);
+            Assert.EndsWith(
+                " [Information] Cat => Scope => Scope2:" + _nl +
+                "Info message" + _nl,
+                provider.Batches[0][0].Message);
+        }
+
         [Fact]
         public async Task RespectsBatchSize()
         {
@@ -85,13 +114,14 @@ private class TestBatchingLoggingProvider: BatchingLoggerProvider
             public List<LogMessage[]> Batches { get; } = new List<LogMessage[]>();
             public ManualIntervalControl IntervalControl { get; } = new ManualIntervalControl();
 
-            public TestBatchingLoggingProvider(TimeSpan? interval = null, int? maxBatchSize = null, int? maxQueueSize = null)
+            public TestBatchingLoggingProvider(TimeSpan? interval = null, int? maxBatchSize = null, int? maxQueueSize = null, bool includeScopes = false)
                 : base(new OptionsWrapperMonitor<BatchingLoggerOptions>(new BatchingLoggerOptions
                 {
                     FlushPeriod = interval ?? TimeSpan.FromSeconds(1),
                     BatchSize = maxBatchSize,
                     BackgroundQueueSize = maxQueueSize,
-                    IsEnabled = true
+                    IsEnabled = true,
+                    IncludeScopes = includeScopes
                 }))
             {
             }

Original file line number	Diff line number	Diff line change
`@@ -66,5 +66,11 @@ public int? BatchSize`
`66`	`66`	`/// Gets or sets value indicating if logger accepts and queues writes.`
`67`	`67`	`/// </summary>`
`68`	`68`	`public bool IsEnabled { get; set; }`
	`69`	`+`
	`70`	`+ /// <summary>`
	`71`	`+ /// Gets or sets a value indicating whether scopes should be included in the message.`
	`72`	`+ /// Defaults to <c>false</c>.`
	`73`	`+ /// </summary>`
	`74`	`+ public bool IncludeScopes { get; set; } = false;`
`69`	`75`	`}`
`70`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`
`11`	`11`	`namespace Microsoft.Extensions.Logging.AzureAppServices.Internal`
`12`	`12`	`{`
`13`		`- public abstract class BatchingLoggerProvider: ILoggerProvider`
	`13`	`+ public abstract class BatchingLoggerProvider: ILoggerProvider, ISupportExternalScope`
`14`	`14`	`{`
`15`	`15`	`private readonly List<LogMessage> _currentBatch = new List<LogMessage>();`
`16`	`16`	`private readonly TimeSpan _interval;`
`@@ -22,6 +22,11 @@ public abstract class BatchingLoggerProvider: ILoggerProvider`
`22`	`22`	`private Task _outputTask;`
`23`	`23`	`private CancellationTokenSource _cancellationTokenSource;`
`24`	`24`
	`25`	`+ private bool _includeScopes;`
	`26`	`+ private IExternalScopeProvider _scopeProvider;`
	`27`	`+`
	`28`	`+ internal IExternalScopeProvider ScopeProvider => _includeScopes ? _scopeProvider : null;`
	`29`	`+`
`25`	`30`	`protected BatchingLoggerProvider(IOptionsMonitor<BatchingLoggerOptions> options)`
`26`	`31`	`{`
`27`	`32`	`// NOTE: Only IsEnabled is monitored`
`@@ -50,6 +55,8 @@ private void UpdateOptions(BatchingLoggerOptions options)`
`50`	`55`	`{`
`51`	`56`	`var oldIsEnabled = IsEnabled;`
`52`	`57`	`IsEnabled = options.IsEnabled;`
	`58`	`+ _includeScopes = options.IncludeScopes;`
	`59`	`+`
`53`	`60`	`if (oldIsEnabled != IsEnabled)`
`54`	`61`	`{`
`55`	`62`	`if (IsEnabled)`
`@@ -159,5 +166,10 @@ public ILogger CreateLogger(string categoryName)`
`159`	`166`	`{`
`160`	`167`	`return new BatchingLogger(this, categoryName);`
`161`	`168`	`}`
	`169`	`+`
	`170`	`+ void ISupportExternalScope.SetScopeProvider(IExternalScopeProvider scopeProvider)`
	`171`	`+ {`
	`172`	`+ _scopeProvider = scopeProvider;`
	`173`	`+ }`
`162`	`174`	`}`
`163`	`175`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,8 +22,7 @@ public static ILoggingBuilder AddConsole(this ILoggingBuilder builder)`
`22`	`22`	`builder.AddConfiguration();`
`23`	`23`
`24`	`24`	`builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<ILoggerProvider, ConsoleLoggerProvider>());`
`25`		`- builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<IConfigureOptions<ConsoleLoggerOptions>, ConsoleLoggerOptionsSetup>());`
`26`		`- builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<IOptionsChangeTokenSource<ConsoleLoggerOptions>, LoggerProviderOptionsChangeTokenSource<ConsoleLoggerOptions, ConsoleLoggerProvider>>());`
	`25`	`+ LoggerProviderOptions.RegisterProviderOptions<ConsoleLoggerOptions, ConsoleLoggerProvider>(builder.Services);`
`27`	`26`	`return builder;`
`28`	`27`	`}`
`29`	`28`