Definitely not stealing

src/Discord.Net.Core/Logging/DefaultLogger.cs

@@ -0,0 +1,54 @@
+using Microsoft.Extensions.Logging;
+using System;
+
+namespace Discord.Logging
+{
+    internal class DefaultLogger : ILogger
+    {
+        private static readonly object _lock = new object();
+
+        private LogLevel MinimumLevel { get; }
+
+        internal DefaultLogger(LogLevel minLevel = LogLevel.Information)
+        {
+            this.MinimumLevel = minLevel;
+        }
+
+        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+        {
+            if (!this.IsEnabled(logLevel))
+                return;
+
+            lock (_lock)
+            {
+                var ename = eventId.Name;
+                ename = ename?.Length > 12 ? ename?.Substring(0, 12) : ename;
+                Console.Write($"[{DateTimeOffset.Now}] [{eventId.Id,-4}/{ename,-12}] ");
+                
+                Console.Write(logLevel switch 
+                {
+                    LogLevel.Trace =>       "[Trace] ",
+                    LogLevel.Debug =>       "[Debug] ",
+                    LogLevel.Information => "[Info ] ",
+                    LogLevel.Warning =>     "[Warn ] ",
+                    LogLevel.Error =>       "[Error] ",
+                    LogLevel.Critical =>    "[Crit ]",
+                    LogLevel.None =>        "[None ] ",
+                    _ =>                    "[?????] "
+                });
+
+                var message = formatter(state, exception);
+                Console.WriteLine(message);
+                if (exception != null)
+                    Console.WriteLine(exception);
+            }
+        }
+
+        public bool IsEnabled(LogLevel logLevel) => logLevel >= this.MinimumLevel;
+
+        public IDisposable BeginScope<TState>(TState state)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

src/Discord.Net.Core/Logging/DefaultLoggerFactory.cs

@@ -0,0 +1,41 @@
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Discord.Logging
+{
+    internal class DefaultLoggerFactory : ILoggerFactory
+    {
+        private List<ILoggerProvider> Providers { get; } = new List<ILoggerProvider>();
+        private bool _isDisposed = false;
+
+        public void Dispose()
+        {
+            if (this._isDisposed)
+                return;
+            this._isDisposed = true;
+
+            foreach (var provider in this.Providers)
+                provider.Dispose();
+
+            this.Providers.Clear();
+        }
+
+        public ILogger CreateLogger(string categoryName)
+        {
+            if (this._isDisposed)
+                throw new InvalidOperationException("This logger factory is already disposed.");
+
+            // HEHEHE XDXD
+            var provider = Providers.FirstOrDefault();
+
+            return provider?.CreateLogger(categoryName) ?? throw new ArgumentNullException(nameof(provider));
+        }
+
+        public void AddProvider(ILoggerProvider provider)
+        {
+            this.Providers.Add(provider);
+        }
+    }
+}

src/Discord.Net.Core/Logging/DefaultLoggerProvider.cs

@@ -0,0 +1,31 @@
+using Microsoft.Extensions.Logging;
+using System;
+
+namespace Discord.Logging
+{
+    internal class DefaultLoggerProvider : ILoggerProvider
+    {
+        private LogLevel MinimumLevel { get; }
+
+        private bool _isDisposed = false;
+        
+
+        internal DefaultLoggerProvider(LogLevel minLevel = LogLevel.Information)
+        {
+            this.MinimumLevel = minLevel;
+        }
+
+        public ILogger CreateLogger(string categoryName)
+        {
+            if (this._isDisposed)
+                throw new InvalidOperationException("This logger provider is already disposed.");
+
+            return new DefaultLogger(this.MinimumLevel);
+        }
+
+        public void Dispose()
+        {
+            this._isDisposed = true;
+        }
+    }
+}