Add export attribute to allow logger providers to optionally provider minimum log level

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

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

@@ -8,15 +8,35 @@ namespace Microsoft.CodeAnalysis.Razor.Logging;
 
 internal abstract partial class AbstractLoggerFactory
 {
-    private class AggregateLogger(ImmutableArray<Lazy<ILogger>> lazyLoggers) : ILogger
+    private sealed class LazyLogger(Lazy<ILoggerProvider, LoggerProviderMetadata> lazyProvider, string categoryName)
     {
-        private ImmutableArray<Lazy<ILogger>> _lazyLoggers = lazyLoggers;
+        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)
+            {
+                return logLevel.IsAtLeast(minimumLogLevel);
+            }
+
+            return Instance.IsEnabled(logLevel);
+        }
+    }
+
+    private class AggregateLogger(ImmutableArray<LazyLogger> lazyLoggers) : ILogger
+    {
+        private ImmutableArray<LazyLogger> _lazyLoggers = lazyLoggers;
 
         public bool IsEnabled(LogLevel logLevel)
         {
             foreach (var lazyLogger in _lazyLoggers)
             {
-                if (lazyLogger.Value.IsEnabled(logLevel))
+                if (lazyLogger.IsEnabled(logLevel))
                 {
                     return true;
                 }
@@ -29,16 +49,14 @@ public void Log(LogLevel logLevel, string message, Exception? exception)
         {
             foreach (var lazyLogger in _lazyLoggers)
             {
-                var logger = lazyLogger.Value;
-
-                if (logger.IsEnabled(logLevel))
+                if (lazyLogger.IsEnabled(logLevel))
                 {
-                    logger.Log(logLevel, message, exception);
+                    lazyLogger.Instance.Log(logLevel, message, exception);
                 }
             }
         }
 
-        internal void AddLogger(Lazy<ILogger> lazyLogger)
+        internal void AddLogger(LazyLogger lazyLogger)
         {
             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>> _providers;
+    private ImmutableArray<Lazy<ILoggerProvider, LoggerProviderMetadata>> _providers;
     private ImmutableDictionary<string, AggregateLogger> _loggers;
 
-    protected AbstractLoggerFactory(ImmutableArray<Lazy<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,11 +34,11 @@ public ILogger GetOrCreateLogger(string categoryName)
             return logger;
         }
 
-        using var lazyLoggers = new PooledArrayBuilder<Lazy<ILogger>>(_providers.Length);
+        using var lazyLoggers = new PooledArrayBuilder<LazyLogger>(_providers.Length);
 
         foreach (var provider in _providers)
         {
-            lazyLoggers.Add(new(() => provider.Value.CreateLogger(categoryName)));
+            lazyLoggers.Add(new(provider, categoryName));
         }
 
         var result = new AggregateLogger(lazyLoggers.DrainToImmutable());
@@ -42,13 +47,13 @@ public ILogger GetOrCreateLogger(string categoryName)
 
     public void AddLoggerProvider(ILoggerProvider provider)
     {
-        var lazyProvider = new Lazy<ILoggerProvider>(() => 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(new(() => 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;

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

@@ -14,7 +14,7 @@
 
 namespace Microsoft.VisualStudio.Razor.Logging;
 
-[Export(typeof(ILoggerProvider))]
+[ExportLoggerProvider]
 [method: ImportingConstructor]
 internal class OutputWindowLoggerProvider(
     // Anything this class imports would have a circular dependency if they tried to log anything,