Merge pull request #455 from filipw/fix-obsolete-logging

filipw · web-flow · commit e160e0ff3f53 · 2019-10-08T12:52:29.000+02:00
Removed obsolete logging
diff --git a/src/Dotnet.Script/Dotnet.Script.csproj b/src/Dotnet.Script/Dotnet.Script.csproj
@@ -24,7 +24,7 @@
     <ItemGroup>
         <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.3.1" />
         <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="2.2.5" />
-        <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="2.2.0" />
+        <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="3.0.0" />
     </ItemGroup>
     <ItemGroup>
         <ProjectReference Include="..\Dotnet.Script.Core\Dotnet.Script.Core.csproj" />
diff --git a/src/Dotnet.Script/LogHelper.cs b/src/Dotnet.Script/LogHelper.cs
@@ -1,128 +1,54 @@
 ﻿using System;
-using System.Collections.Concurrent;
-using System.Reflection;
-using System.Runtime.InteropServices;
 using Dotnet.Script.DependencyModel.Logging;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Console;
-using Microsoft.Extensions.Logging.Console.Internal;
+using Microsoft.Extensions.Options;
 using LogLevel = Microsoft.Extensions.Logging.LogLevel;
 
 namespace Dotnet.Script
 {
     public static class LogHelper
-    {                     
+    {
         public static LogFactory CreateLogFactory(string verbosity)
         {
             var logLevel = (LogLevel)LevelMapper.FromString(verbosity);
-            
-            var loggerFactory = new LoggerFactory();            
 
-            loggerFactory.AddProvider(new ConsoleErrorLoggerProvider((message, level) => level >= logLevel));                        
+            var loggerFilterOptions = new LoggerFilterOptions() { MinLevel = logLevel };
+
+            var consoleLoggerProvider = new ConsoleLoggerProvider(new ConsoleOptionsMonitor());
+
+            var loggerFactory = new LoggerFactory(new[] { consoleLoggerProvider }, loggerFilterOptions);
 
             return type =>
             {
                 var logger = loggerFactory.CreateLogger(type);
                 return (level, message, exception) =>
                 {
-                    logger.Log((LogLevel)level, message, exception);                   
+                    logger.Log((LogLevel)level, message, exception);
                 };
             };
-        }    
-    }   
-    
-    public class WindowsLogErrorConsole : IConsole
-    {
-        private void SetColor(ConsoleColor? background, ConsoleColor? foreground)
-        {
-            if (background.HasValue)
-            {
-                Console.BackgroundColor = background.Value;
-            }
-
-            if (foreground.HasValue)
-            {
-                Console.ForegroundColor = foreground.Value;
-            }
-        }
-
-        private void ResetColor()
-        {
-            Console.ResetColor();
-        }
-
-        public void Write(string message, ConsoleColor? background, ConsoleColor? foreground)
-        {
-            SetColor(background, foreground);
-            Console.Error.Write(message);
-            ResetColor();
-        }
-
-        public void WriteLine(string message, ConsoleColor? background, ConsoleColor? foreground)
-        {
-            SetColor(background, foreground);
-            Console.Error.WriteLine(message);
-            ResetColor();
-        }
-
-        public void Flush()
-        {            
-            // No action required as for every write, data is sent directly to the console
-            // output stream
         }
     }
 
-    public class AnsiSystemErrorConsole : IAnsiSystemConsole
+    internal class ConsoleOptionsMonitor : IOptionsMonitor<ConsoleLoggerOptions>
     {
-        public void Write(string message)
-        {
-            System.Console.Error.Write(message);
-        }
+        private ConsoleLoggerOptions _consoleLoggerOptions;
 
-        public void WriteLine(string message)
+        public ConsoleOptionsMonitor()
         {
-            System.Console.Error.WriteLine(message);
-        }
-    }
-
-    public class ConsoleErrorLoggerProvider : ILoggerProvider
-    {
-        private readonly Func<string, LogLevel, bool> _filter;
-
-        private readonly ConcurrentDictionary<string, ConsoleLogger> _loggers = new ConcurrentDictionary<string, ConsoleLogger>();
-
-        private readonly ConsoleLoggerProcessor _messageQueue = new ConsoleLoggerProcessor();
-
-        private readonly static ConstructorInfo ConsoleLoggerConstructor = typeof(ConsoleLogger).GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic)[0];
-
-        public ConsoleErrorLoggerProvider(Func<string, LogLevel, bool> filter)
-        {
-            _filter = filter;
-        }
-    
-        public ILogger CreateLogger(string name)
-        {
-            return _loggers.GetOrAdd(name, CreateLoggerImplementation);            
+            _consoleLoggerOptions = new ConsoleLoggerOptions()
+            {
+                LogToStandardErrorThreshold = LogLevel.Trace
+            };
         }
 
-        private ConsoleLogger CreateLoggerImplementation(string name)
-        {            
-            var consoleLogger = (ConsoleLogger)ConsoleLoggerConstructor.Invoke(new object[] { name, _filter, null, _messageQueue });
-            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-            {
-                consoleLogger.Console = new WindowsLogErrorConsole();
-            }
-            else
-            {
-                consoleLogger.Console = new AnsiLogConsole(new AnsiSystemErrorConsole());
-            }
+        public ConsoleLoggerOptions CurrentValue => _consoleLoggerOptions;
 
-            return consoleLogger;
-        }
+        public ConsoleLoggerOptions Get(string name) => _consoleLoggerOptions;
 
-        public void Dispose()
+        public IDisposable OnChange(Action<ConsoleLoggerOptions, string> listener)
         {
-            _messageQueue.Dispose();
+            return null;
         }
-    }   
+    }
 }
