fix: reduce debugger logspam

Author: pandinocoder

Intersect (Core)/Logging/Log.cs

@@ -47,7 +47,7 @@ static Log()
                 {
                     Formatters = ImmutableList.Create(new DefaultFormatter()) ?? throw new InvalidOperationException(),
                     LogLevel = LogConfiguration.Default.LogLevel,
-                    Outputs = outputs
+                    Outputs = outputs,
                 }
             );
         }

Intersect.Server.Core/Database/DbLogger.cs

@@ -1,76 +1,65 @@
 using Microsoft.Extensions.Logging;
 
-namespace Intersect.Server.Database
+namespace Intersect.Server.Database;
+
+public partial class DbLogger : ILogger
 {
+    private readonly Intersect.Logging.Logger _intersectLogger;
 
-    public partial class DbLogger : ILogger
+    public DbLogger(Intersect.Logging.Logger intersectLogger)
     {
+        _intersectLogger = intersectLogger;
+    }
 
-        private Intersect.Logging.Logger _intersectLogger;
-
-        public DbLogger(Intersect.Logging.Logger intersectLogger)
-        {
-            _intersectLogger = intersectLogger;
-        }
+    public IDisposable BeginScope<TState>(TState state) => null;
 
-        public IDisposable BeginScope<TState>(TState state)
-        {
-            return null;
-        }
+    public bool IsEnabled(LogLevel logLevel) => true;
 
-        public bool IsEnabled(LogLevel logLevel)
+    public void Log<TState>(
+        LogLevel logLevel,
+        EventId eventId,
+        TState state,
+        Exception exception,
+        Func<TState, Exception, string> formatter
+    )
+    {
+        if (!IsEnabled(logLevel))
         {
-            return true;
+            return;
         }
 
-        public void Log<TState>(
-            LogLevel logLevel,
-            EventId eventId,
-            TState state,
-            Exception exception,
-            Func<TState, Exception, string> formatter
-        )
+        var msg = $"{eventId.Id} - {formatter(state, exception)}";
+        switch (logLevel)
         {
-            if (!IsEnabled(logLevel))
-            {
-                return;
-            }
+            case LogLevel.Trace:
+                _intersectLogger.Trace(msg);
+                break;
 
-            if (_intersectLogger != null)
-            {
-                var msg = $"{eventId.Id} - {formatter(state, exception)}";
-                switch (logLevel)
-                {
-                    case LogLevel.Trace:
-                        _intersectLogger.Trace(msg);
+            case LogLevel.Debug:
+                _intersectLogger.Debug(msg);
+                break;
 
-                        break;
-                    case LogLevel.Debug:
-                        _intersectLogger.Debug(msg);
+            case LogLevel.Information:
+                _intersectLogger.Info(msg);
+                break;
 
-                        break;
-                    case LogLevel.Information:
-                        _intersectLogger.Info(msg);
+            case LogLevel.Warning:
+                _intersectLogger.Warn(msg);
+                break;
 
-                        break;
-                    case LogLevel.Warning:
-                        _intersectLogger.Warn(msg);
+            case LogLevel.Error:
+                _intersectLogger.Error(msg);
+                break;
 
-                        break;
-                    case LogLevel.Error:
-                        _intersectLogger.Error(msg);
+            case LogLevel.Critical:
+                _intersectLogger.Error(msg);
+                break;
 
-                        break;
-                    case LogLevel.Critical:
-                        _intersectLogger.Error(msg);
+            case LogLevel.None:
+                break;
 
-                        break;
-                    case LogLevel.None:
-                        break;
-                }
-            }
+            default:
+                throw new ArgumentOutOfRangeException(nameof(logLevel), logLevel, null);
         }
-
     }
-
-}
+}

Intersect.Server.Core/Database/DbLoggerProvider.cs

@@ -1,35 +1,23 @@
 using Microsoft.Extensions.Logging;
 
-namespace Intersect.Server.Database
-{
-
-    public partial class DbLoggerProvider : ILoggerProvider
-    {
-
-        private Intersect.Logging.Logger _intersectLogger;
-
-        private DbLogger _logger;
+namespace Intersect.Server.Database;
 
-        public DbLoggerProvider(Intersect.Logging.Logger intersectLogger)
-        {
-            _intersectLogger = intersectLogger;
-        }
+public sealed partial class DbLoggerProvider : ILoggerProvider
+{
+    private readonly Intersect.Logging.Logger _intersectLogger;
 
-        public ILogger CreateLogger(string categoryName)
-        {
-            if (_logger == null)
-            {
-                _logger = new DbLogger(_intersectLogger);
-            }
+    private DbLogger? _logger;
 
-            return _logger;
-        }
+    public DbLoggerProvider(Intersect.Logging.Logger intersectLogger)
+    {
+        _intersectLogger = intersectLogger;
+    }
 
-        public void Dispose()
-        {
-            _logger = null;
-        }
+    public ILogger CreateLogger(string categoryName) => _logger ??= new DbLogger(_intersectLogger);
 
+    public void Dispose()
+    {
+        GC.SuppressFinalize(this);
+        _logger = default;
     }
-
-}
+}

Intersect.Server.Core/Database/IntersectLoggerFactory.cs

@@ -1,25 +1,52 @@
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Reflection;
 using Intersect.Logging;
+using Intersect.Logging.Formatting;
+using Intersect.Logging.Output;
 using Intersect.Reflection;
 using Microsoft.Extensions.Logging;
 using ILogger = Microsoft.Extensions.Logging.ILogger;
+using IntersectLogLevel = Intersect.Logging.LogLevel;
 
 namespace Intersect.Server.Database;
 
 internal sealed class IntersectLoggerFactory : ILoggerFactory
 {
-    private readonly DbLoggerProvider _loggerProvider = new(Log.Default);
+    private static string ExecutableName => Path.GetFileNameWithoutExtension(
+        Process.GetCurrentProcess().MainModule?.FileName ?? Assembly.GetExecutingAssembly().GetName().Name
+    );
 
-    public void Dispose()
+    private readonly DbLoggerProvider _loggerProvider;
+
+    internal IntersectLoggerFactory()
     {
+        var outputs = ImmutableList.Create<ILogOutput>(
+            new FileOutput($"db-{ExecutableName}.log"),
+            new FileOutput($"errors-{ExecutableName}.log", IntersectLogLevel.Error),
+            new ConciseConsoleOutput(Debugger.IsAttached ? IntersectLogLevel.Warn : IntersectLogLevel.Error)
+        );
+
+        _loggerProvider = new DbLoggerProvider(
+            new Logger(
+                new LogConfiguration
+                {
+                    Formatters = ImmutableList.Create(new DefaultFormatter()),
+                    LogLevel = IntersectLogLevel.Debug,
+                    Outputs = outputs,
+                }
+            )
+        );
     }
 
     public void AddProvider(ILoggerProvider provider)
     {
         Log.Warn($"Tried to add provider but this is not implemented: {provider.GetFullishName()}");
     }
 
-    public ILogger CreateLogger(string categoryName)
+    public ILogger CreateLogger(string categoryName) => _loggerProvider.CreateLogger(categoryName);
+
+    public void Dispose()
     {
-        return _loggerProvider.CreateLogger(categoryName);
     }
 }