Lazily import ILoggerProviders (#10327)

Fixes #10326

This change makes our `AbstractLoggerFactory` take a set of
`Lazy<ILoggerProvider>` instances and only realize them the first time a
message is logged.

🤔 _I wonder if it would be possible to change our `ILoggerProvider`
instances to declare their minimum `LogLevel` via MEF and import that as
metadata? That would allow us to avoid instantiating all the logger
providers just to call `IsEnabled`._

Author: DustinCampbell

src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/LanguageServer/RazorLanguageServerBenchmarkBase.cs

@@ -19,7 +19,6 @@
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CommonLanguageServerProtocol.Framework;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.VisualStudio.LanguageServer.Protocol;
 using Nerdbank.Streams;
 
 namespace Microsoft.AspNetCore.Razor.Microbenchmarks.LanguageServer;

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/RazorLanguageServer.LoggerFactoryWrapper.cs

@@ -14,7 +14,7 @@ internal partial class RazorLanguageServer
     /// </summary>
     private sealed class LoggerFactoryWrapper(ILoggerFactory loggerFactory) : ILoggerFactory
     {
-        private ILoggerFactory _loggerFactory = loggerFactory;
+        private readonly ILoggerFactory _loggerFactory = loggerFactory;
 
         public void AddLoggerProvider(ILoggerProvider provider)
         {

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/AbstractLoggerFactory.AggregateLogger.cs

@@ -8,15 +8,36 @@ namespace Microsoft.CodeAnalysis.Razor.Logging;
 
 internal abstract partial class AbstractLoggerFactory
 {
-    private class AggregateLogger(ImmutableArray<ILogger> loggers) : ILogger
+    private sealed class LazyLogger(Lazy<ILoggerProvider, LoggerProviderMetadata> lazyProvider, string categoryName)
     {
-        private ImmutableArray<ILogger> _loggers = loggers;
+        private readonly LoggerProviderMetadata _metadata = lazyProvider.Metadata;
+        private readonly Lazy<ILogger> _lazyLogger = new(() => lazyProvider.Value.CreateLogger(categoryName));
+
+        public ILogger Instance => _lazyLogger.Value;
+
+        public bool IsEnabled(LogLevel logLevel)
+        {
+            // If the ILoggerProvider's metadata has a minimum log level, we can use that
+            // rather than forcing the ILoggerProvider to be created.
+            if (_metadata.MinimumLogLevel is LogLevel minimumLogLevel &&
+                !logLevel.IsAtLeast(minimumLogLevel))
+            {
+                return false;
+            }
+
+            return Instance.IsEnabled(logLevel);
+        }
+    }
+
+    private class AggregateLogger(ImmutableArray<LazyLogger> lazyLoggers) : ILogger
+    {
+        private ImmutableArray<LazyLogger> _lazyLoggers = lazyLoggers;
 
         public bool IsEnabled(LogLevel logLevel)
         {
-            foreach (var logger in _loggers)
+            foreach (var lazyLogger in _lazyLoggers)
             {
-                if (logger.IsEnabled(logLevel))
+                if (lazyLogger.IsEnabled(logLevel))
                 {
                     return true;
                 }
@@ -27,18 +48,18 @@ public bool IsEnabled(LogLevel logLevel)
 
         public void Log(LogLevel logLevel, string message, Exception? exception)
         {
-            foreach (var logger in _loggers)
+            foreach (var lazyLogger in _lazyLoggers)
             {
-                if (logger.IsEnabled(logLevel))
+                if (lazyLogger.IsEnabled(logLevel))
                 {
-                    logger.Log(logLevel, message, exception);
+                    lazyLogger.Instance.Log(logLevel, message, exception);
                 }
             }
         }
 
-        internal void AddLogger(ILogger logger)
+        internal void AddLogger(LazyLogger lazyLogger)
         {
-            ImmutableInterlocked.Update(ref _loggers, (set, l) => set.Add(l), logger);
+            ImmutableInterlocked.Update(ref _lazyLoggers, (set, l) => set.Add(l), lazyLogger);
         }
     }
 }

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/AbstractLoggerFactory.cs

@@ -13,10 +13,15 @@ namespace Microsoft.CodeAnalysis.Razor.Logging;
 
 internal abstract partial class AbstractLoggerFactory : ILoggerFactory
 {
+    private ImmutableArray<Lazy<ILoggerProvider, LoggerProviderMetadata>> _providers;
     private ImmutableDictionary<string, AggregateLogger> _loggers;
-    private ImmutableArray<ILoggerProvider> _providers;
 
     protected AbstractLoggerFactory(ImmutableArray<ILoggerProvider> providers)
+        : this(providers.SelectAsArray(p => new Lazy<ILoggerProvider, LoggerProviderMetadata>(() => p, LoggerProviderMetadata.Empty)))
+    {
+    }
+
+    protected AbstractLoggerFactory(ImmutableArray<Lazy<ILoggerProvider, LoggerProviderMetadata>> providers)
     {
         _providers = providers;
         _loggers = ImmutableDictionary.Create<string, AggregateLogger>(StringComparer.OrdinalIgnoreCase);
@@ -29,24 +34,26 @@ public ILogger GetOrCreateLogger(string categoryName)
             return logger;
         }
 
-        using var loggers = new PooledArrayBuilder<ILogger>(_providers.Length);
+        using var lazyLoggers = new PooledArrayBuilder<LazyLogger>(_providers.Length);
 
         foreach (var provider in _providers)
         {
-            loggers.Add(provider.CreateLogger(categoryName));
+            lazyLoggers.Add(new(provider, categoryName));
         }
 
-        var result = new AggregateLogger(loggers.DrainToImmutable());
+        var result = new AggregateLogger(lazyLoggers.DrainToImmutable());
         return ImmutableInterlocked.AddOrUpdate(ref _loggers, categoryName, result, (k, v) => v);
     }
 
     public void AddLoggerProvider(ILoggerProvider provider)
     {
-        if (ImmutableInterlocked.Update(ref _providers, (set, p) => set.Add(p), provider))
+        var lazyProvider = new Lazy<ILoggerProvider, LoggerProviderMetadata>(() => provider, LoggerProviderMetadata.Empty);
+
+        if (ImmutableInterlocked.Update(ref _providers, (set, p) => set.Add(p), lazyProvider))
         {
-            foreach (var (category, logger) in _loggers)
+            foreach (var (categoryName, logger) in _loggers)
             {
-                logger.AddLogger(provider.CreateLogger(category));
+                logger.AddLogger(new(lazyProvider, categoryName));
             }
         }
     }

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/LoggerProviderMetadata.cs

@@ -0,0 +1,25 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+
+namespace Microsoft.CodeAnalysis.Razor.Logging;
+
+internal sealed class LoggerProviderMetadata
+{
+    public static LoggerProviderMetadata Empty { get; } = new();
+
+    public LogLevel? MinimumLogLevel { get; }
+
+    private LoggerProviderMetadata()
+    {
+    }
+
+    public LoggerProviderMetadata(IDictionary<string, object> data)
+        : this()
+    {
+        MinimumLogLevel = data.TryGetValue(nameof(MinimumLogLevel), out var minimumLogLevel)
+            ? (LogLevel?)minimumLogLevel
+            : null;
+    }
+}

src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Logging/RazorLogHubLogger.cs

@@ -9,16 +9,10 @@
 
 namespace Microsoft.VisualStudio.Razor.LanguageClient.Logging;
 
-internal sealed class RazorLogHubLogger : ILogger
+internal sealed class RazorLogHubLogger(string categoryName, RazorLogHubTraceProvider traceProvider) : ILogger
 {
-    private string _categoryName;
-    private RazorLogHubTraceProvider _traceProvider;
-
-    public RazorLogHubLogger(string categoryName, RazorLogHubTraceProvider traceProvider)
-    {
-        _categoryName = categoryName;
-        _traceProvider = traceProvider;
-    }
+    private readonly string _categoryName = categoryName;
+    private readonly RazorLogHubTraceProvider _traceProvider = traceProvider;
 
     public bool IsEnabled(LogLevel logLevel)
     {

src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Logging/RazorLogHubLoggerProvider.cs

@@ -7,16 +7,11 @@
 
 namespace Microsoft.VisualStudio.Razor.LanguageClient.Logging;
 
-[Export(typeof(ILoggerProvider))]
-internal sealed class RazorLogHubLoggerProvider : ILoggerProvider
+[ExportLoggerProvider]
+[method: ImportingConstructor]
+internal sealed class RazorLogHubLoggerProvider(RazorLogHubTraceProvider traceProvider) : ILoggerProvider
 {
-    private readonly RazorLogHubTraceProvider _traceProvider;
-
-    [ImportingConstructor]
-    public RazorLogHubLoggerProvider(RazorLogHubTraceProvider traceProvider)
-    {
-        _traceProvider = traceProvider;
-    }
+    private readonly RazorLogHubTraceProvider _traceProvider = traceProvider;
 
     public ILogger CreateLogger(string categoryName)
     {

src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/ActivityLogLoggerProvider.cs

@@ -10,7 +10,7 @@ namespace Microsoft.VisualStudio.LanguageServices.Razor.Logging;
 /// <summary>
 /// An <see cref="ILoggerProvider"/> that logs any warnings or errors to the Visual Studio Activity Log.
 /// </summary>
-[Export(typeof(ILoggerProvider))]
+[ExportLoggerProvider(minimumLogLevel: LogLevel.Warning)]
 [method: ImportingConstructor]
 internal sealed partial class ActivityLogLoggerProvider(RazorActivityLog activityLog) : ILoggerProvider
 {

src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/ExportLoggerProviderAttribute.cs

@@ -0,0 +1,27 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System;
+using System.ComponentModel.Composition;
+using Microsoft.CodeAnalysis.Razor.Logging;
+
+namespace Microsoft.VisualStudio.Razor.Logging;
+
+[MetadataAttribute]
+[AttributeUsage(AttributeTargets.Class)]
+internal sealed class ExportLoggerProviderAttribute : ExportAttribute
+{
+    public LogLevel? MinimumLogLevel { get; }
+
+    public ExportLoggerProviderAttribute()
+        : base(typeof(ILoggerProvider))
+    {
+        MinimumLogLevel = null;
+    }
+
+    public ExportLoggerProviderAttribute(LogLevel minimumLogLevel)
+        : base(typeof(ILoggerProvider))
+    {
+        MinimumLogLevel = minimumLogLevel;
+    }
+}

src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/MemoryLoggerProvider.cs

@@ -1,14 +1,12 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT license. See License.txt in the project root for license information.
 
-using System.ComponentModel.Composition;
 using Microsoft.CodeAnalysis.Razor.Logging;
 
 namespace Microsoft.VisualStudio.Razor.Logging;
 
-[Export(typeof(ILoggerProvider))]
-[method: ImportingConstructor]
-internal partial class MemoryLoggerProvider() : ILoggerProvider
+[ExportLoggerProvider]
+internal partial class MemoryLoggerProvider : ILoggerProvider
 {
     // How many messages will the buffer contain
     private const int BufferSize = 5000;