Adds ILoggingBuilder extension for LanguageServer logging.

sample/SampleServer/Program.cs

@@ -19,10 +19,11 @@ static void Main(string[] args)
 
         static async Task MainAsync(string[] args)
         {
-            // while (!System.Diagnostics.Debugger.IsAttached)
-            // {
+            //Debugger.Launch();
+            //while (!System.Diagnostics.Debugger.IsAttached)
+            //{
             //    await Task.Delay(100);
-            // }
+            //}
 
             Log.Logger = new LoggerConfiguration()
               .Enrich.FromLogContext()
@@ -35,8 +36,10 @@ static async Task MainAsync(string[] args)
                 options
                     .WithInput(Console.OpenStandardInput())
                     .WithOutput(Console.OpenStandardOutput())
-                    .ConfigureLogging(x => x.AddSerilog())
-                    .AddDefaultLoggingProvider()
+                    .ConfigureLogging(x => x
+                        .AddSerilog()
+                        .AddLanguageServer(LogLevel.Error)
+                        .SetMinimumLevel(LogLevel.Error))
                     .WithHandler<TextDocumentHandler>()
                     .WithHandler<DidChangeWatchedFilesHandler>()
                     .WithHandler<FoldingRangeHandler>()

sample/SampleServer/TextDocumentHandler.cs

@@ -36,6 +36,9 @@ public TextDocumentHandler(ILogger<TextDocumentHandler> logger, Foo foo)
 
         public Task<Unit> Handle(DidChangeTextDocumentParams notification, CancellationToken token)
         {
+            _logger.LogCritical("Critical");
+            _logger.LogDebug("Debug");
+            _logger.LogTrace("Trace");
             _logger.LogInformation("Hello world!");
             return Unit.Task;
         }

src/Server/LanguageServer.cs

@@ -26,6 +26,8 @@
 using OmniSharp.Extensions.LanguageServer.Server.Pipelines;
 using ISerializer = OmniSharp.Extensions.LanguageServer.Protocol.Serialization.ISerializer;
 using System.Reactive.Disposables;
+using Microsoft.Extensions.Options;
+using OmniSharp.Extensions.LanguageServer.Server.Logging;
 
 namespace OmniSharp.Extensions.LanguageServer.Server
 {
@@ -106,8 +108,7 @@ public static ILanguageServer PreInit(LanguageServerOptions options)
                 options.TextDocumentIdentifierTypes,
                 options.InitializeDelegates,
                 options.InitializedDelegates,
-                options.LoggingBuilderAction,
-                options.AddDefaultLoggingProvider
+                options.LoggingBuilderAction
             );
         }
 
@@ -127,20 +128,12 @@ internal LanguageServer(
             IEnumerable<Type> textDocumentIdentifierTypes,
             IEnumerable<InitializeDelegate> initializeDelegates,
             IEnumerable<InitializedDelegate> initializedDelegates,
-            Action<ILoggingBuilder> loggingBuilderAction,
-            bool addDefaultLoggingProvider)
+            Action<ILoggingBuilder> loggingBuilderAction)
         {
             var outputHandler = new OutputHandler(output, serializer);
 
-            services.AddLogging(builder =>
-            {
-                loggingBuilderAction(builder);
-
-                if (addDefaultLoggingProvider)
-                {
-                    builder.AddProvider(new LanguageServerLoggerProvider(this));
-                }
-            });
+            services.AddLogging(builder => loggingBuilderAction(builder));
+            services.AddSingleton<IOptionsMonitor<LoggerFilterOptions>, LanguageServerLoggerFilterOptions>();
 
             _reciever = reciever;
             _serializer = serializer;
@@ -248,11 +241,6 @@ internal LanguageServer(
         public InitializeParams ClientSettings { get; private set; }
         public InitializeResult ServerSettings { get; private set; }
 
-        /// <summary>
-        ///     The minimum level for the server's default logger.
-        /// </summary>
-        public LogLevel MinimumLogLevel { get; set; }
-
         public IServiceProvider Services => _serviceProvider;
 
         public IDisposable AddHandler(string method, IJsonRpcHandler handler)
@@ -357,9 +345,22 @@ async Task<InitializeResult> IRequestHandler<InitializeParams, InitializeResult>
         {
             ClientSettings = request;
 
-            if (request.Trace == InitializeTrace.Verbose && MinimumLogLevel >= LogLevel.Information)
+            if (request.Trace == InitializeTrace.Verbose)
             {
-                MinimumLogLevel = LogLevel.Trace;
+                var loggerSettings = _serviceProvider.GetService<LanguageServerLoggerSettings>();
+
+                if (loggerSettings?.MinimumLogLevel <= LogLevel.Information)
+                {
+                    loggerSettings.MinimumLogLevel = LogLevel.Trace;
+                }
+
+                var optionsMonitor = _serviceProvider.GetService<IOptionsMonitor<LoggerFilterOptions>>() as LanguageServerLoggerFilterOptions;
+
+                if (optionsMonitor?.CurrentValue.MinLevel <= LogLevel.Information)
+                {
+                    optionsMonitor.CurrentValue.MinLevel = LogLevel.Trace;
+                    optionsMonitor.Set(optionsMonitor.CurrentValue);
+                }
             }
 
             _clientVersion = request.Capabilities?.GetClientVersion() ?? ClientVersion.Lsp2;

src/Server/LanguageServerOptions.cs

@@ -33,7 +33,6 @@ public LanguageServerOptions()
         internal List<Type> HandlerTypes { get; set; } = new List<Type>();
         internal List<Type> TextDocumentIdentifierTypes { get; set; } = new List<Type>();
         internal List<Assembly> HandlerAssemblies { get; set; } = new List<Assembly>();
-        internal bool AddDefaultLoggingProvider { get; set; }
         internal Action<ILoggingBuilder> LoggingBuilderAction { get; set; } = new Action<ILoggingBuilder>(_ => { });
 
         internal readonly List<InitializeDelegate> InitializeDelegates = new List<InitializeDelegate>();

src/Server/LanguageServerOptionsExtensions.cs

@@ -78,13 +78,6 @@ public static LanguageServerOptions WithServices(this LanguageServerOptions opti
             return options;
         }
 
-        public static LanguageServerOptions AddDefaultLoggingProvider(this LanguageServerOptions options)
-        {
-            options.AddDefaultLoggingProvider = true;
-            return options;
-        }
-
-
         public static LanguageServerOptions OnInitialize(this LanguageServerOptions options, InitializeDelegate @delegate)
         {
             options.InitializeDelegates.Add(@delegate);

src/Server/LanguageServerLogger.cs → src/Server/Logging/LanguageServerLogger.cs

@@ -1,18 +1,16 @@
 using System;
 using Microsoft.Extensions.Logging;
-using OmniSharp.Extensions.JsonRpc;
-using OmniSharp.Extensions.LanguageServer.Protocol;
 using OmniSharp.Extensions.LanguageServer.Protocol.Models;
 using OmniSharp.Extensions.LanguageServer.Protocol.Server;
 
 namespace OmniSharp.Extensions.LanguageServer.Server
 {
     class LanguageServerLogger : ILogger
     {
-        private readonly LanguageServer _responseRouter;
+        private readonly ILanguageServer _responseRouter;
         private readonly Func<LogLevel> _logLevelGetter;
 
-        public LanguageServerLogger(LanguageServer responseRouter, Func<LogLevel> logLevelGetter)
+        public LanguageServerLogger(ILanguageServer responseRouter, Func<LogLevel> logLevelGetter)
         {
             _logLevelGetter = logLevelGetter;
             _responseRouter = responseRouter;

src/Server/Logging/LanguageServerLoggerExtensions.cs

@@ -0,0 +1,17 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+namespace OmniSharp.Extensions.LanguageServer.Server
+{
+    public static class LanguageServerLoggerExtensions
+    {
+        public static ILoggingBuilder AddLanguageServer(this ILoggingBuilder builder, LogLevel minLevel = LogLevel.Information)
+        {
+            builder.Services.AddSingleton<LanguageServerLoggerSettings>(_ => new LanguageServerLoggerSettings { MinimumLogLevel = minLevel });
+            builder.Services.AddSingleton<ILoggerProvider, LanguageServerLoggerProvider>();
+
+            return builder;
+        }
+    }
+}

src/Server/Logging/LanguageServerLoggerFilterOptions.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+namespace OmniSharp.Extensions.LanguageServer.Server.Logging
+{
+    internal class LanguageServerLoggerFilterOptions : IOptionsMonitor<LoggerFilterOptions>, IDisposable
+    {
+        private readonly List<IDisposable> _registrations = new List<IDisposable>();
+        private event Action<LoggerFilterOptions, string> _onChange;
+
+        public LanguageServerLoggerFilterOptions(IOptions<LoggerFilterOptions> options)
+        {
+            CurrentValue = options.Value;
+        }
+
+        public LoggerFilterOptions CurrentValue { get; private set; }
+
+        public LoggerFilterOptions Get(string _) => CurrentValue;
+
+        public IDisposable OnChange(Action<LoggerFilterOptions, string> listener)
+        {
+            var disposable = new ChangeTrackerDisposable(this, listener);
+            _onChange += disposable.OnChange;
+            return disposable;
+        }
+
+        public void Dispose()
+        {
+            foreach (var registration in _registrations)
+            {
+                registration.Dispose();
+            }
+
+            _registrations.Clear();
+        }
+
+        internal void Set(LoggerFilterOptions options)
+        {
+            CurrentValue = options;
+            _onChange?.Invoke(options, Options.DefaultName);
+        }
+
+        private class ChangeTrackerDisposable : IDisposable
+        {
+            private readonly Action<LoggerFilterOptions, string> _listener;
+            private readonly LanguageServerLoggerFilterOptions _monitor;
+
+            public ChangeTrackerDisposable(LanguageServerLoggerFilterOptions monitor, Action<LoggerFilterOptions, string> listener)
+            {
+                _listener = listener;
+                _monitor = monitor;
+            }
+
+            public void OnChange(LoggerFilterOptions options, string name) => _listener.Invoke(options, name);
+
+            public void Dispose() => _monitor._onChange -= OnChange;
+        }
+    }
+}

src/Server/LanguageServerLoggerProvider.cs → src/Server/Logging/LanguageServerLoggerProvider.cs

@@ -5,16 +5,18 @@ namespace OmniSharp.Extensions.LanguageServer.Server
 {
     class LanguageServerLoggerProvider : ILoggerProvider
     {
-        private readonly LanguageServer _languageServer;
+        private readonly ILanguageServer _languageServer;
+        private readonly LanguageServerLoggerSettings _settings;
 
-        public LanguageServerLoggerProvider(LanguageServer languageServer)
+        public LanguageServerLoggerProvider(ILanguageServer languageServer, LanguageServerLoggerSettings settings)
         {
             _languageServer = languageServer;
+            _settings = settings;
         }
 
         public ILogger CreateLogger(string categoryName)
         {
-            return new LanguageServerLogger(_languageServer, () => _languageServer.MinimumLogLevel);
+            return new LanguageServerLogger(_languageServer, () => _settings.MinimumLogLevel);
         }
 
         public void Dispose()

src/Server/Logging/LanguageServerLoggerSettings.cs

@@ -0,0 +1,9 @@
+using Microsoft.Extensions.Logging;
+
+namespace OmniSharp.Extensions.LanguageServer.Server
+{
+    internal class LanguageServerLoggerSettings
+    {
+        public LogLevel MinimumLogLevel { get; set; }
+    }
+}