Lazily import ILoggerProviders

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

Author: DustinCampbell

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

@@ -108,7 +108,7 @@ public Task<TResponse> SendRequestAsync<TParams, TResponse>(string method, TPara
         }
     }
 
-    internal class NoopLoggerFactory() : AbstractLoggerFactory([new NoopLoggerProvider()]);
+    internal class NoopLoggerFactory() : AbstractLoggerFactory([new(() => new NoopLoggerProvider())]);
 
     internal class NoopLoggerProvider : ILoggerProvider
     {

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,15 @@ namespace Microsoft.CodeAnalysis.Razor.Logging;
 
 internal abstract partial class AbstractLoggerFactory
 {
-    private class AggregateLogger(ImmutableArray<ILogger> loggers) : ILogger
+    private class AggregateLogger(ImmutableArray<Lazy<ILogger>> lazyLoggers) : ILogger
     {
-        private ImmutableArray<ILogger> _loggers = loggers;
+        private ImmutableArray<Lazy<ILogger>> _lazyLoggers = lazyLoggers;
 
         public bool IsEnabled(LogLevel logLevel)
         {
-            foreach (var logger in _loggers)
+            foreach (var lazyLogger in _lazyLoggers)
             {
-                if (logger.IsEnabled(logLevel))
+                if (lazyLogger.Value.IsEnabled(logLevel))
                 {
                     return true;
                 }
@@ -27,18 +27,20 @@ public bool IsEnabled(LogLevel logLevel)
 
         public void Log(LogLevel logLevel, string message, Exception? exception)
         {
-            foreach (var logger in _loggers)
+            foreach (var lazyLogger in _lazyLoggers)
             {
+                var logger = lazyLogger.Value;
+
                 if (logger.IsEnabled(logLevel))
                 {
                     logger.Log(logLevel, message, exception);
                 }
             }
         }
 
-        internal void AddLogger(ILogger logger)
+        internal void AddLogger(Lazy<ILogger> 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,10 @@ namespace Microsoft.CodeAnalysis.Razor.Logging;
 
 internal abstract partial class AbstractLoggerFactory : ILoggerFactory
 {
+    private ImmutableArray<Lazy<ILoggerProvider>> _providers;
     private ImmutableDictionary<string, AggregateLogger> _loggers;
-    private ImmutableArray<ILoggerProvider> _providers;
 
-    protected AbstractLoggerFactory(ImmutableArray<ILoggerProvider> providers)
+    protected AbstractLoggerFactory(ImmutableArray<Lazy<ILoggerProvider>> providers)
     {
         _providers = providers;
         _loggers = ImmutableDictionary.Create<string, AggregateLogger>(StringComparer.OrdinalIgnoreCase);
@@ -29,24 +29,26 @@ public ILogger GetOrCreateLogger(string categoryName)
             return logger;
         }
 
-        using var loggers = new PooledArrayBuilder<ILogger>(_providers.Length);
+        using var lazyLoggers = new PooledArrayBuilder<Lazy<ILogger>>(_providers.Length);
 
         foreach (var provider in _providers)
         {
-            loggers.Add(provider.CreateLogger(categoryName));
+            lazyLoggers.Add(new(() => provider.Value.CreateLogger(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>(() => provider);
+
+        if (ImmutableInterlocked.Update(ref _providers, (set, p) => set.Add(p), lazyProvider))
         {
             foreach (var (category, logger) in _loggers)
             {
-                logger.AddLogger(provider.CreateLogger(category));
+                logger.AddLogger(new(() => provider.CreateLogger(category)));
             }
         }
     }

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

@@ -1,6 +1,7 @@
 // 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.Collections.Generic;
 using System.Collections.Immutable;
 using System.ComponentModel.Composition;
@@ -10,7 +11,7 @@ namespace Microsoft.VisualStudio.Razor.Logging;
 
 [Export(typeof(ILoggerFactory))]
 [method: ImportingConstructor]
-internal sealed class VisualStudioLoggerFactory([ImportMany] IEnumerable<ILoggerProvider> providers)
+internal sealed class VisualStudioLoggerFactory([ImportMany] IEnumerable<Lazy<ILoggerProvider>> providers)
     : AbstractLoggerFactory(providers.ToImmutableArray())
 {
 }

src/Razor/src/rzls/LoggerFactory.cs

@@ -1,12 +1,13 @@
 // 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.Collections.Immutable;
 using Microsoft.CodeAnalysis.Razor.Logging;
 
 namespace Microsoft.AspNetCore.Razor.LanguageServer;
 
-internal sealed class LoggerFactory(ImmutableArray<ILoggerProvider> providers)
+internal sealed class LoggerFactory(ImmutableArray<Lazy<ILoggerProvider>> providers)
     : AbstractLoggerFactory(providers)
 {
 }

src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/Logging/TestOutputLoggerFactory.cs

@@ -7,6 +7,6 @@
 namespace Microsoft.AspNetCore.Razor.Test.Common.Logging;
 
 internal sealed class TestOutputLoggerFactory(ITestOutputHelper output)
-    : AbstractLoggerFactory([new TestOutputLoggerProvider(output)])
+    : AbstractLoggerFactory([new(() => new TestOutputLoggerProvider(output))])
 {
 }