Make loggerfactory react on loglevel changes.

Author: bjorkstromm

sample/SampleServer/Program.cs

@@ -19,7 +19,7 @@ static void Main(string[] args)
 
         static async Task MainAsync(string[] args)
         {
-            Debugger.Launch();
+            //Debugger.Launch();
             //while (!System.Diagnostics.Debugger.IsAttached)
             //{
             //    await Task.Delay(100);
@@ -38,8 +38,8 @@ static async Task MainAsync(string[] args)
                     .WithOutput(Console.OpenStandardOutput())
                     .ConfigureLogging(x => x
                         .AddSerilog()
-                        .AddLanguageServer(LogLevel.Critical)
-                        .SetMinimumLevel(LogLevel.Trace))
+                        .AddLanguageServer(LogLevel.Error)
+                        .SetMinimumLevel(LogLevel.Error))
                     .WithHandler<TextDocumentHandler>()
                     .WithHandler<DidChangeWatchedFilesHandler>()
                     .WithHandler<FoldingRangeHandler>()

src/Server/LanguageServer.cs

@@ -27,6 +27,7 @@
 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
 {
@@ -132,6 +133,7 @@ internal LanguageServer(
             var outputHandler = new OutputHandler(output, serializer);
 
             services.AddLogging(builder => loggingBuilderAction(builder));
+            services.AddSingleton<IOptionsMonitor<LoggerFilterOptions>, LanguageServerLoggerFilterOptions>();
 
             _reciever = reciever;
             _serializer = serializer;
@@ -347,10 +349,18 @@ async Task<InitializeResult> IRequestHandler<InitializeParams, InitializeResult>
             {
                 var loggerSettings = _serviceProvider.GetService<LanguageServerLoggerSettings>();
 
-                if (loggerSettings?.MinimumLogLevel >= LogLevel.Information)
+                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/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;
+        }
+    }
+}