From b3af9541a251b7673a0c669c2bae7617478a25fd Mon Sep 17 00:00:00 2001
From: waldekmastykarz <waldek@mastykarz.nl>
Date: Mon, 6 May 2024 17:07:53 +0200
Subject: [PATCH 1/3] Refactors IProxyLogger to ILogger

---
 dev-proxy-abstractions/BaseProxyPlugin.cs     |  32 +-
 dev-proxy-abstractions/ILoggerExtensions.cs   |  22 +
 dev-proxy-abstractions/IProxyLogger.cs        |   1 +
 dev-proxy-abstractions/IProxyPlugin.cs        |   6 +-
 dev-proxy-abstractions/MSGraphDbUtils.cs      |  10 +-
 dev-proxy-abstractions/PluginEvents.cs        |  28 +-
 .../RateLimitingCustomResponseLoader.cs       |   4 +-
 .../Behavior/RateLimitingPlugin.cs            |  34 +-
 .../Behavior/RetryAfterPlugin.cs              |  20 +-
 .../Guidance/CachingGuidancePlugin.cs         |  22 +-
 .../GraphBetaSupportGuidancePlugin.cs         |  22 +-
 .../GraphClientRequestIdGuidancePlugin.cs     |  22 +-
 .../Guidance/GraphConnectorGuidancePlugin.cs  |  25 +-
 .../Guidance/GraphSdkGuidancePlugin.cs        |  20 +-
 .../Guidance/GraphSelectGuidancePlugin.cs     |  27 +-
 .../Guidance/ODSPSearchGuidancePlugin.cs      |  20 +-
 .../Guidance/ODataPagingGuidancePlugin.cs     |  31 +-
 .../Inspection/DevToolsPlugin.cs              |  23 +-
 .../Inspection/WebSocketServer.cs             |  13 +-
 .../Mocks/CrudApiDefinitionLoader.cs          |   4 +-
 dev-proxy-plugins/Mocks/CrudApiPlugin.cs      |  75 ++--
 .../Mocks/EntraMockResponsePlugin.cs          |  13 +-
 .../Mocks/GraphConnectorNotificationPlugin.cs |  44 +-
 .../Mocks/GraphMockResponsePlugin.cs          |  13 +-
 dev-proxy-plugins/Mocks/MockRequestLoader.cs  |   4 +-
 dev-proxy-plugins/Mocks/MockRequestPlugin.cs  |  31 +-
 dev-proxy-plugins/Mocks/MockResponsePlugin.cs |  32 +-
 .../Mocks/MockResponsesLoader.cs              |   4 +-
 .../GenericErrorResponsesLoader.cs            |   4 +-
 .../RandomErrors/GenericRandomErrorPlugin.cs  |  42 +-
 .../RandomErrors/GraphRandomErrorPlugin.cs    |  38 +-
 .../RandomErrors/LatencyPlugin.cs             |  23 +-
 .../RequestLogs/ApiCenterOnboardingPlugin.cs  | 139 +++---
 .../ApiCenterProductionVersionPlugin.cs       |  83 ++--
 .../RequestLogs/ExecutionSummaryPlugin.cs     |  18 +-
 .../MinimalPermissionsGuidancePlugin.cs       |  19 +-
 .../RequestLogs/MinimalPermissionsPlugin.cs   |  32 +-
 .../RequestLogs/MockGeneratorPlugin.cs        |  53 +--
 .../RequestLogs/OpenApiSpecGeneratorPlugin.cs | 123 +++---
 dev-proxy/CertificateDiskCache.cs             |   3 +
 dev-proxy/ConsoleLogger.cs                    | 380 -----------------
 dev-proxy/Logging/ILoggerBuilderExtensions.cs |  21 +
 dev-proxy/Logging/ProxyConsoleFormatter.cs    | 397 ++++++++++++++++++
 .../Logging/ProxyConsoleFormatterOptions.cs   |  12 +
 dev-proxy/Logging/RequestLogger.cs            |  29 ++
 dev-proxy/Logging/RequestLoggerProvider.cs    |  25 ++
 dev-proxy/Logging/TextWriterExtensions.cs     |  16 +
 dev-proxy/MSGraphDbCommandHandler.cs          |   5 +-
 dev-proxy/PluginLoader.cs                     |  23 +-
 dev-proxy/PresetGetCommandHandler.cs          |   8 +-
 dev-proxy/Program.cs                          |  33 +-
 dev-proxy/ProxyCommandHandler.cs              |   9 +-
 dev-proxy/ProxyContext.cs                     |   4 +-
 dev-proxy/ProxyEngine.cs                      |   6 +-
 dev-proxy/ProxyHost.cs                        |   5 +-
 dev-proxy/dev-proxy.csproj                    |   1 +
 56 files changed, 1185 insertions(+), 968 deletions(-)
 create mode 100644 dev-proxy-abstractions/ILoggerExtensions.cs
 delete mode 100644 dev-proxy/ConsoleLogger.cs
 create mode 100644 dev-proxy/Logging/ILoggerBuilderExtensions.cs
 create mode 100644 dev-proxy/Logging/ProxyConsoleFormatter.cs
 create mode 100644 dev-proxy/Logging/ProxyConsoleFormatterOptions.cs
 create mode 100644 dev-proxy/Logging/RequestLogger.cs
 create mode 100644 dev-proxy/Logging/RequestLoggerProvider.cs
 create mode 100644 dev-proxy/Logging/TextWriterExtensions.cs

diff --git a/dev-proxy-abstractions/BaseProxyPlugin.cs b/dev-proxy-abstractions/BaseProxyPlugin.cs
index 49978aad..0eadb1e7 100644
--- a/dev-proxy-abstractions/BaseProxyPlugin.cs
+++ b/dev-proxy-abstractions/BaseProxyPlugin.cs
@@ -3,21 +3,26 @@
 
 using System.CommandLine;
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
 
 namespace Microsoft.DevProxy.Abstractions;
 
 public abstract class BaseProxyPlugin : IProxyPlugin
 {
-    protected ISet<UrlToWatch>? _urlsToWatch;
-    protected IProxyLogger? _logger;
+    protected ISet<UrlToWatch> UrlsToWatch { get; }
+    protected ILogger Logger { get; }
+    protected IConfigurationSection? ConfigSection { get; }
+    protected IPluginEvents PluginEvents { get; }
+    protected IProxyContext Context { get; }
 
     public virtual string Name => throw new NotImplementedException();
 
     public virtual Option[] GetOptions() => Array.Empty<Option>();
     public virtual Command[] GetCommands() => Array.Empty<Command>();
 
-    public virtual void Register(IPluginEvents pluginEvents,
+    public BaseProxyPlugin(IPluginEvents pluginEvents,
                          IProxyContext context,
+                         ILogger logger,
                          ISet<UrlToWatch> urlsToWatch,
                          IConfigurationSection? configSection = null)
     {
@@ -26,18 +31,29 @@ public abstract class BaseProxyPlugin : IProxyPlugin
             throw new ArgumentNullException(nameof(pluginEvents));
         }
 
-        if (context is null || context.Logger is null)
+        if (context is null)
         {
-            throw new ArgumentException($"{nameof(context)} must not be null and must supply a non-null Logger", nameof(context));
+            throw new ArgumentNullException(nameof(context));
+        }
 
+        if (logger is null)
+        {
+            throw new ArgumentNullException(nameof(logger));
         }
 
-        if (urlsToWatch is null || urlsToWatch.Count == 0)
+        if (urlsToWatch is null || !urlsToWatch.Any())
         {
             throw new ArgumentException($"{nameof(urlsToWatch)} cannot be null or empty", nameof(urlsToWatch));
         }
 
-        _urlsToWatch = urlsToWatch;
-        _logger = context.Logger;
+        UrlsToWatch = urlsToWatch;
+        Context = context;
+        Logger = logger;
+        ConfigSection = configSection;
+        PluginEvents = pluginEvents;
+    }
+
+    public virtual void Register()
+    {
     }
 }
diff --git a/dev-proxy-abstractions/ILoggerExtensions.cs b/dev-proxy-abstractions/ILoggerExtensions.cs
new file mode 100644
index 00000000..235b63e6
--- /dev/null
+++ b/dev-proxy-abstractions/ILoggerExtensions.cs
@@ -0,0 +1,22 @@
+using System.Text.Json;
+using Microsoft.DevProxy.Abstractions;
+
+namespace Microsoft.Extensions.Logging;
+
+public static class ILoggerExtensions
+{
+    public static void LogRequest(this ILogger logger, string[] message, MessageType messageType, LoggingContext? context = null)
+    {
+        logger.Log(new RequestLog(message, messageType, context));
+    }
+
+    public static void LogRequest(this ILogger logger, string[] message, MessageType messageType, string method, string url)
+    {
+        logger.Log(new RequestLog(message, messageType, method, url));
+    }
+
+    public static void Log(this ILogger logger, RequestLog message)
+    {
+        logger.Log(LogLevel.Information, 0, message, exception: null, (m, _) => JsonSerializer.Serialize(m));
+    }
+}
\ No newline at end of file
diff --git a/dev-proxy-abstractions/IProxyLogger.cs b/dev-proxy-abstractions/IProxyLogger.cs
index 3d92df3f..76967516 100644
--- a/dev-proxy-abstractions/IProxyLogger.cs
+++ b/dev-proxy-abstractions/IProxyLogger.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 using Titanium.Web.Proxy.EventArguments;
 using Microsoft.Extensions.Logging;
+using System.Text.Json.Serialization;
 
 namespace Microsoft.DevProxy.Abstractions;
 
diff --git a/dev-proxy-abstractions/IProxyPlugin.cs b/dev-proxy-abstractions/IProxyPlugin.cs
index ce285267..d5a48dc9 100644
--- a/dev-proxy-abstractions/IProxyPlugin.cs
+++ b/dev-proxy-abstractions/IProxyPlugin.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT License.
 
 using System.CommandLine;
-using Microsoft.Extensions.Configuration;
 
 namespace Microsoft.DevProxy.Abstractions;
 
@@ -11,8 +10,5 @@ public interface IProxyPlugin
     string Name { get; }
     Option[] GetOptions();
     Command[] GetCommands();
-    void Register(IPluginEvents pluginEvents,
-                  IProxyContext context,
-                  ISet<UrlToWatch> urlsToWatch,
-                  IConfigurationSection? configSection = null);
+    void Register();
 }
diff --git a/dev-proxy-abstractions/MSGraphDbUtils.cs b/dev-proxy-abstractions/MSGraphDbUtils.cs
index 0cb05506..9f4d8e6b 100644
--- a/dev-proxy-abstractions/MSGraphDbUtils.cs
+++ b/dev-proxy-abstractions/MSGraphDbUtils.cs
@@ -32,7 +32,7 @@ public static SqliteConnection MSGraphDbConnection
         }
     }
 
-    public static async Task<int> GenerateMSGraphDb(IProxyLogger logger, bool skipIfUpdatedToday = false)
+    public static async Task<int> GenerateMSGraphDb(ILogger logger, bool skipIfUpdatedToday = false)
     {
         var appFolder = ProxyUtils.AppFolder;
         if (string.IsNullOrEmpty(appFolder))
@@ -75,7 +75,7 @@ public static async Task<int> GenerateMSGraphDb(IProxyLogger logger, bool skipIf
 
     }
 
-    private static void CreateDb(SqliteConnection dbConnection, IProxyLogger logger)
+    private static void CreateDb(SqliteConnection dbConnection, ILogger logger)
     {
         logger.LogInformation("Creating database...");
 
@@ -97,7 +97,7 @@ private static void CreateDb(SqliteConnection dbConnection, IProxyLogger logger)
         createIndex.ExecuteNonQuery();
     }
 
-    private static void FillData(SqliteConnection dbConnection, IProxyLogger logger)
+    private static void FillData(SqliteConnection dbConnection, ILogger logger)
     {
         logger.LogInformation("Filling database...");
 
@@ -143,7 +143,7 @@ private static void FillData(SqliteConnection dbConnection, IProxyLogger logger)
         logger.LogInformation("Inserted {endpointCount} endpoints in the database", i);
     }
 
-    private static async Task UpdateOpenAPIGraphFilesIfNecessary(string folder, IProxyLogger logger)
+    private static async Task UpdateOpenAPIGraphFilesIfNecessary(string folder, ILogger logger)
     {
         logger.LogInformation("Checking for updated OpenAPI files...");
 
@@ -176,7 +176,7 @@ private static async Task UpdateOpenAPIGraphFilesIfNecessary(string folder, IPro
         }
     }
 
-    private static async Task LoadOpenAPIFiles(string folder, IProxyLogger logger)
+    private static async Task LoadOpenAPIFiles(string folder, ILogger logger)
     {
         logger.LogInformation("Loading OpenAPI files...");
 
diff --git a/dev-proxy-abstractions/PluginEvents.cs b/dev-proxy-abstractions/PluginEvents.cs
index 0c6ced73..01f9b64e 100644
--- a/dev-proxy-abstractions/PluginEvents.cs
+++ b/dev-proxy-abstractions/PluginEvents.cs
@@ -4,6 +4,7 @@
 using System.CommandLine;
 using System.CommandLine.Invocation;
 using System.Security.Cryptography.X509Certificates;
+using System.Text.Json.Serialization;
 using Titanium.Web.Proxy;
 using Titanium.Web.Proxy.EventArguments;
 using Titanium.Web.Proxy.Http;
@@ -13,7 +14,6 @@ namespace Microsoft.DevProxy.Abstractions;
 public interface IProxyContext
 {
     IProxyConfiguration Configuration { get; }
-    IProxyLogger Logger { get; }
     X509Certificate2? Certificate { get; }
 }
 
@@ -126,13 +126,37 @@ public class RequestLog
 {
     public string[] MessageLines { get; set; }
     public MessageType MessageType { get; set; }
+    [JsonIgnore]
     public LoggingContext? Context { get; set; }
+    public string? Method { get; init; }
+    public string? Url { get; init; }
 
-    public RequestLog(string[] messageLines, MessageType messageType, LoggingContext? context)
+    public RequestLog(string[] messageLines, MessageType messageType, LoggingContext? context) :
+        this(messageLines, messageType, context?.Session.HttpClient.Request.Method, context?.Session.HttpClient.Request.Url, context)
+    {
+    }
+
+    public RequestLog(string[] messageLines, MessageType messageType, string method, string url) :
+        this(messageLines, messageType, method, url, context: null)
+    {
+    }
+
+    private RequestLog(string[] messageLines, MessageType messageType, string? method, string? url, LoggingContext? context)
     {
         MessageLines = messageLines ?? throw new ArgumentNullException(nameof(messageLines));
         MessageType = messageType;
         Context = context;
+        Method = method;
+        Url = url;
+    }
+
+    public void Deconstruct(out string[] message, out MessageType messageType, out LoggingContext? context, out string? method, out string? url)
+    {
+        message = MessageLines;
+        messageType = MessageType;
+        context = Context;
+        method = Method;
+        url = Url;
     }
 }
 
diff --git a/dev-proxy-plugins/Behavior/RateLimitingCustomResponseLoader.cs b/dev-proxy-plugins/Behavior/RateLimitingCustomResponseLoader.cs
index cab5864f..d66331cc 100644
--- a/dev-proxy-plugins/Behavior/RateLimitingCustomResponseLoader.cs
+++ b/dev-proxy-plugins/Behavior/RateLimitingCustomResponseLoader.cs
@@ -9,10 +9,10 @@ namespace Microsoft.DevProxy.Plugins.Behavior;
 
 internal class RateLimitingCustomResponseLoader : IDisposable
 {
-    private readonly IProxyLogger _logger;
+    private readonly ILogger _logger;
     private readonly RateLimitConfiguration _configuration;
 
-    public RateLimitingCustomResponseLoader(IProxyLogger logger, RateLimitConfiguration configuration)
+    public RateLimitingCustomResponseLoader(ILogger logger, RateLimitConfiguration configuration)
     {
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         _configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
diff --git a/dev-proxy-plugins/Behavior/RateLimitingPlugin.cs b/dev-proxy-plugins/Behavior/RateLimitingPlugin.cs
index d0e30529..f658956e 100644
--- a/dev-proxy-plugins/Behavior/RateLimitingPlugin.cs
+++ b/dev-proxy-plugins/Behavior/RateLimitingPlugin.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
 using Microsoft.DevProxy.Abstractions;
 using System.Net;
 using System.Text.Json;
@@ -49,6 +50,10 @@ public class RateLimitingPlugin : BaseProxyPlugin
     private DateTime _resetTime = DateTime.MinValue;
     private RateLimitingCustomResponseLoader? _loader = null;
 
+    public RateLimitingPlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     private ThrottlingInfo ShouldThrottle(Request request, string throttlingKey)
     {
         var throttleKeyForRequest = BuildThrottleKey(request);
@@ -123,31 +128,28 @@ private string BuildThrottleKey(Request r)
         }
     }
 
-    public override void Register(IPluginEvents pluginEvents,
-                         IProxyContext context,
-                         ISet<UrlToWatch> urlsToWatch,
-                         IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        configSection?.Bind(_configuration);
+        ConfigSection?.Bind(_configuration);
         if (_configuration.WhenLimitExceeded == RateLimitResponseWhenLimitExceeded.Custom)
         {
-            _configuration.CustomResponseFile = Path.GetFullPath(ProxyUtils.ReplacePathTokens(_configuration.CustomResponseFile), Path.GetDirectoryName(context.Configuration?.ConfigFile ?? string.Empty) ?? string.Empty);
-            _loader = new RateLimitingCustomResponseLoader(_logger!, _configuration);
+            _configuration.CustomResponseFile = Path.GetFullPath(ProxyUtils.ReplacePathTokens(_configuration.CustomResponseFile), Path.GetDirectoryName(Context.Configuration.ConfigFile ?? string.Empty) ?? string.Empty);
+            _loader = new RateLimitingCustomResponseLoader(Logger, _configuration);
             // load the responses from the configured mocks file
             _loader.InitResponsesWatcher();
         }
 
-        pluginEvents.BeforeRequest += OnRequest;
-        pluginEvents.BeforeResponse += OnResponse;
+        PluginEvents.BeforeRequest += OnRequest;
+        PluginEvents.BeforeResponse += OnResponse;
     }
 
     // add rate limiting headers to the response from the API
     private Task OnResponse(object? sender, ProxyResponseArgs e)
     {
-        if (_urlsToWatch is null ||
-            !e.HasRequestUrlMatch(_urlsToWatch))
+        if (UrlsToWatch is null ||
+            !e.HasRequestUrlMatch(UrlsToWatch))
         {
             return Task.CompletedTask;
         }
@@ -161,8 +163,8 @@ private Task OnRequest(object? sender, ProxyRequestArgs e)
         var session = e.Session;
         var state = e.ResponseState;
         if (e.ResponseState.HasBeenSet ||
-            _urlsToWatch is null ||
-            !e.ShouldExecute(_urlsToWatch))
+            UrlsToWatch is null ||
+            !e.ShouldExecute(UrlsToWatch))
         {
             return Task.CompletedTask;
         }
@@ -191,7 +193,7 @@ private Task OnRequest(object? sender, ProxyRequestArgs e)
             _resourcesRemaining = 0;
             var request = e.Session.HttpClient.Request;
 
-            _logger?.LogRequest([$"Exceeded resource limit when calling {request.Url}.", "Request will be throttled"], MessageType.Failed, new LoggingContext(e.Session));
+            Logger.LogRequest([$"Exceeded resource limit when calling {request.Url}.", "Request will be throttled"], MessageType.Failed, new LoggingContext(e.Session));
             if (_configuration.WhenLimitExceeded == RateLimitResponseWhenLimitExceeded.Throttle)
             {
                 if (!e.GlobalData.ContainsKey(RetryAfterPlugin.ThrottledRequestsKey))
@@ -250,7 +252,7 @@ private Task OnRequest(object? sender, ProxyRequestArgs e)
                 }
                 else
                 {
-                    _logger?.LogRequest([$"Custom behavior not set. {_configuration.CustomResponseFile} not found."], MessageType.Failed, new LoggingContext(e.Session));
+                    Logger.LogRequest([$"Custom behavior not set. {_configuration.CustomResponseFile} not found."], MessageType.Failed, new LoggingContext(e.Session));
                 }
             }
         }
diff --git a/dev-proxy-plugins/Behavior/RetryAfterPlugin.cs b/dev-proxy-plugins/Behavior/RetryAfterPlugin.cs
index 3b6afb2e..b938ab00 100644
--- a/dev-proxy-plugins/Behavior/RetryAfterPlugin.cs
+++ b/dev-proxy-plugins/Behavior/RetryAfterPlugin.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
 using Microsoft.DevProxy.Abstractions;
 using System.Net;
 using System.Text.Json;
@@ -16,22 +17,23 @@ public class RetryAfterPlugin : BaseProxyPlugin
     public override string Name => nameof(RetryAfterPlugin);
     public static readonly string ThrottledRequestsKey = "ThrottledRequests";
 
-    public override void Register(IPluginEvents pluginEvents,
-                         IProxyContext context,
-                         ISet<UrlToWatch> urlsToWatch,
-                         IConfigurationSection? configSection = null)
+    public RetryAfterPlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+    }
+
+    public override void Register()
+    {
+        base.Register();
 
-        pluginEvents.BeforeRequest += OnRequest;
+        PluginEvents.BeforeRequest += OnRequest;
     }
 
     private Task OnRequest(object? sender, ProxyRequestArgs e)
     {
         if (e.ResponseState.HasBeenSet ||
-            _urlsToWatch is null ||
+            UrlsToWatch is null ||
             e.Session.HttpClient.Request.Method.ToUpper() == "OPTIONS" ||
-            !e.ShouldExecute(_urlsToWatch))
+            !e.ShouldExecute(UrlsToWatch))
         {
             return Task.CompletedTask;
         }
@@ -71,7 +73,7 @@ private void ThrottleIfNecessary(ProxyRequestArgs e)
             if (throttleInfo.ThrottleForSeconds > 0)
             {
                 var messageLines = new[] { $"Calling {request.Url} before waiting for the Retry-After period.", "Request will be throttled.", $"Throttling on {throttler.ThrottlingKey}." };
-                _logger?.LogRequest(messageLines, MessageType.Failed, new LoggingContext(e.Session));
+                Logger.LogRequest(messageLines, MessageType.Failed, new LoggingContext(e.Session));
 
                 throttler.ResetTime = DateTime.Now.AddSeconds(throttleInfo.ThrottleForSeconds);
                 UpdateProxyResponse(e, throttleInfo, string.Join(' ', messageLines));
diff --git a/dev-proxy-plugins/Guidance/CachingGuidancePlugin.cs b/dev-proxy-plugins/Guidance/CachingGuidancePlugin.cs
index 4e23c191..e6b880a4 100644
--- a/dev-proxy-plugins/Guidance/CachingGuidancePlugin.cs
+++ b/dev-proxy-plugins/Guidance/CachingGuidancePlugin.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
 using Microsoft.DevProxy.Abstractions;
 using Titanium.Web.Proxy.Http;
 
@@ -18,21 +19,22 @@ public class CachingGuidancePlugin : BaseProxyPlugin
     private readonly CachingGuidancePluginConfiguration _configuration = new();
     private IDictionary<string, DateTime> _interceptedRequests = new Dictionary<string, DateTime>();
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public CachingGuidancePlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
-        configSection?.Bind(_configuration);
+    }
 
-        pluginEvents.BeforeRequest += BeforeRequest;
+    public override void Register()
+    {
+        base.Register();
+        
+        ConfigSection?.Bind(_configuration);
+        PluginEvents.BeforeRequest += BeforeRequest;
     }
 
     private Task BeforeRequest(object? sender, ProxyRequestArgs e)
     {
-        if (_urlsToWatch is null ||
-          !e.HasRequestUrlMatch(_urlsToWatch) ||
+        if (UrlsToWatch is null ||
+          !e.HasRequestUrlMatch(UrlsToWatch) ||
           e.Session.HttpClient.Request.Method.ToUpper() == "OPTIONS")
         {
             return Task.CompletedTask;
@@ -52,7 +54,7 @@ private Task BeforeRequest(object? sender, ProxyRequestArgs e)
         var secondsSinceLastIntercepted = (now - lastIntercepted).TotalSeconds;
         if (secondsSinceLastIntercepted <= _configuration.CacheThresholdSeconds)
         {
-            _logger?.LogRequest(BuildCacheWarningMessage(request, _configuration.CacheThresholdSeconds, lastIntercepted), MessageType.Warning, new LoggingContext(e.Session));
+            Logger.LogRequest(BuildCacheWarningMessage(request, _configuration.CacheThresholdSeconds, lastIntercepted), MessageType.Warning, new LoggingContext(e.Session));
         }
 
         _interceptedRequests[url] = now;
diff --git a/dev-proxy-plugins/Guidance/GraphBetaSupportGuidancePlugin.cs b/dev-proxy-plugins/Guidance/GraphBetaSupportGuidancePlugin.cs
index 314a114b..b570e209 100644
--- a/dev-proxy-plugins/Guidance/GraphBetaSupportGuidancePlugin.cs
+++ b/dev-proxy-plugins/Guidance/GraphBetaSupportGuidancePlugin.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
 using Microsoft.DevProxy.Abstractions;
 using Titanium.Web.Proxy.Http;
 
@@ -9,29 +10,30 @@ namespace Microsoft.DevProxy.Plugins.Guidance;
 
 public class GraphBetaSupportGuidancePlugin : BaseProxyPlugin
 {
+    public GraphBetaSupportGuidancePlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     public override string Name => nameof(GraphBetaSupportGuidancePlugin);
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        pluginEvents.AfterResponse += AfterResponse;
+        PluginEvents.AfterResponse += AfterResponse;
     }
 
     private Task AfterResponse(object? sender, ProxyResponseArgs e)
     {
         Request request = e.Session.HttpClient.Request;
-        if (_urlsToWatch is not null &&
-            e.HasRequestUrlMatch(_urlsToWatch) &&
+        if (UrlsToWatch is not null &&
+            e.HasRequestUrlMatch(UrlsToWatch) &&
             e.Session.HttpClient.Request.Method.ToUpper() != "OPTIONS" &&
             ProxyUtils.IsGraphBetaRequest(request))
-            _logger?.LogRequest(BuildBetaSupportMessage(request), MessageType.Warning, new LoggingContext(e.Session));
+            Logger.LogRequest(BuildBetaSupportMessage(request), MessageType.Warning, new LoggingContext(e.Session));
         return Task.CompletedTask;
     }
 
     private static string GetBetaSupportGuidanceUrl() => "https://aka.ms/devproxy/guidance/beta-support";
-    private static string[] BuildBetaSupportMessage(Request r) => new[] { $"Don't use beta APIs in production because they can change or be deprecated.", $"More info at {GetBetaSupportGuidanceUrl()}" };
+    private static string[] BuildBetaSupportMessage(Request r) => [$"Don't use beta APIs in production because they can change or be deprecated.", $"More info at {GetBetaSupportGuidanceUrl()}"];
 }
diff --git a/dev-proxy-plugins/Guidance/GraphClientRequestIdGuidancePlugin.cs b/dev-proxy-plugins/Guidance/GraphClientRequestIdGuidancePlugin.cs
index 670b8673..6e13597e 100644
--- a/dev-proxy-plugins/Guidance/GraphClientRequestIdGuidancePlugin.cs
+++ b/dev-proxy-plugins/Guidance/GraphClientRequestIdGuidancePlugin.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
 using Microsoft.DevProxy.Abstractions;
 using Titanium.Web.Proxy.Http;
 
@@ -9,31 +10,32 @@ namespace Microsoft.DevProxy.Plugins.Guidance;
 
 public class GraphClientRequestIdGuidancePlugin : BaseProxyPlugin
 {
+    public GraphClientRequestIdGuidancePlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     public override string Name => nameof(GraphClientRequestIdGuidancePlugin);
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        pluginEvents.BeforeRequest += BeforeRequest;
+        PluginEvents.BeforeRequest += BeforeRequest;
     }
 
     private Task BeforeRequest(object? sender, ProxyRequestArgs e)
     {
         Request request = e.Session.HttpClient.Request;
-        if (_urlsToWatch is not null &&
-          e.HasRequestUrlMatch(_urlsToWatch) &&
+        if (UrlsToWatch is not null &&
+          e.HasRequestUrlMatch(UrlsToWatch) &&
           e.Session.HttpClient.Request.Method.ToUpper() != "OPTIONS" &&
           WarnNoClientRequestId(request))
         {
-            _logger?.LogRequest(BuildAddClientRequestIdMessage(request), MessageType.Warning, new LoggingContext(e.Session));
+            Logger.LogRequest(BuildAddClientRequestIdMessage(request), MessageType.Warning, new LoggingContext(e.Session));
 
             if (!ProxyUtils.IsSdkRequest(request))
             {
-                _logger?.LogRequest(MessageUtils.BuildUseSdkMessage(request), MessageType.Tip, new LoggingContext(e.Session));
+                Logger.LogRequest(MessageUtils.BuildUseSdkMessage(request), MessageType.Tip, new LoggingContext(e.Session));
             }
         }
 
diff --git a/dev-proxy-plugins/Guidance/GraphConnectorGuidancePlugin.cs b/dev-proxy-plugins/Guidance/GraphConnectorGuidancePlugin.cs
index 421921f1..2b5b38bd 100644
--- a/dev-proxy-plugins/Guidance/GraphConnectorGuidancePlugin.cs
+++ b/dev-proxy-plugins/Guidance/GraphConnectorGuidancePlugin.cs
@@ -28,22 +28,23 @@ class ExternalConnectionSchemaProperty
 
 public class GraphConnectorGuidancePlugin : BaseProxyPlugin
 {
+    public GraphConnectorGuidancePlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     public override string Name => nameof(GraphConnectorGuidancePlugin);
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        pluginEvents.BeforeRequest += BeforeRequest;
+        PluginEvents.BeforeRequest += BeforeRequest;
     }
 
     private Task BeforeRequest(object sender, ProxyRequestArgs e)
     {
-        if (_urlsToWatch is null ||
-          !e.HasRequestUrlMatch(_urlsToWatch) ||
+        if (UrlsToWatch is null ||
+          !e.HasRequestUrlMatch(UrlsToWatch) ||
           e.Session.HttpClient.Request.Method.ToUpper() != "PATCH")
         {
             return Task.CompletedTask;
@@ -54,14 +55,14 @@ private Task BeforeRequest(object sender, ProxyRequestArgs e)
             var schemaString = e.Session.HttpClient.Request.BodyString;
             if (string.IsNullOrEmpty(schemaString))
             {
-                _logger?.LogRequest([ "No schema found in the request body." ], MessageType.Failed, new LoggingContext(e.Session));
+                Logger.LogRequest([ "No schema found in the request body." ], MessageType.Failed, new LoggingContext(e.Session));
                 return Task.CompletedTask;
             }
 
             var schema = JsonSerializer.Deserialize<ExternalConnectionSchema>(schemaString, ProxyUtils.JsonSerializerOptions);
             if (schema is null || schema.Properties is null)
             {
-                _logger?.LogRequest([ "Invalid schema found in the request body." ], MessageType.Failed, new LoggingContext(e.Session));
+                Logger.LogRequest([ "Invalid schema found in the request body." ], MessageType.Failed, new LoggingContext(e.Session));
                 return Task.CompletedTask;
             }
 
@@ -95,7 +96,7 @@ private Task BeforeRequest(object sender, ProxyRequestArgs e)
                     !hasUrl ? "url" : ""
                 ];
 
-                _logger?.LogRequest(
+                Logger.LogRequest(
                     [
                         $"The schema is missing the following semantic labels: {string.Join(", ", missingLabels.Where(s => s != ""))}.",
                         "Ingested content might not show up in Microsoft Copilot for Microsoft 365.",
@@ -107,7 +108,7 @@ private Task BeforeRequest(object sender, ProxyRequestArgs e)
         }
         catch (Exception ex)
         {
-            _logger?.LogError(ex, "An error has occurred while deserializing the request body");
+            Logger.LogError(ex, "An error has occurred while deserializing the request body");
         }
 
         return Task.CompletedTask;
diff --git a/dev-proxy-plugins/Guidance/GraphSdkGuidancePlugin.cs b/dev-proxy-plugins/Guidance/GraphSdkGuidancePlugin.cs
index 0e3f2dc6..a258dbbf 100644
--- a/dev-proxy-plugins/Guidance/GraphSdkGuidancePlugin.cs
+++ b/dev-proxy-plugins/Guidance/GraphSdkGuidancePlugin.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
 using Microsoft.DevProxy.Abstractions;
 using Titanium.Web.Proxy.Http;
 
@@ -9,16 +10,17 @@ namespace Microsoft.DevProxy.Plugins.Guidance;
 
 public class GraphSdkGuidancePlugin : BaseProxyPlugin
 {
+    public GraphSdkGuidancePlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     public override string Name => nameof(GraphSdkGuidancePlugin);
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        pluginEvents.AfterResponse += OnAfterResponse;
+        PluginEvents.AfterResponse += OnAfterResponse;
     }
 
     private Task OnAfterResponse(object? sender, ProxyResponseArgs e)
@@ -26,12 +28,12 @@ private Task OnAfterResponse(object? sender, ProxyResponseArgs e)
         Request request = e.Session.HttpClient.Request;
         // only show the message if there is an error.
         if (e.Session.HttpClient.Response.StatusCode >= 400 &&
-            _urlsToWatch is not null &&
-            e.HasRequestUrlMatch(_urlsToWatch) &&
+            UrlsToWatch is not null &&
+            e.HasRequestUrlMatch(UrlsToWatch) &&
             e.Session.HttpClient.Request.Method.ToUpper() != "OPTIONS" &&
             WarnNoSdk(request))
         {
-            _logger?.LogRequest(MessageUtils.BuildUseSdkForErrorsMessage(request), MessageType.Tip, new LoggingContext(e.Session));
+            Logger.LogRequest(MessageUtils.BuildUseSdkForErrorsMessage(request), MessageType.Tip, new LoggingContext(e.Session));
         }
 
         return Task.CompletedTask;
diff --git a/dev-proxy-plugins/Guidance/GraphSelectGuidancePlugin.cs b/dev-proxy-plugins/Guidance/GraphSelectGuidancePlugin.cs
index 4ea716dd..f70ae30a 100644
--- a/dev-proxy-plugins/Guidance/GraphSelectGuidancePlugin.cs
+++ b/dev-proxy-plugins/Guidance/GraphSelectGuidancePlugin.cs
@@ -10,33 +10,30 @@ namespace Microsoft.DevProxy.Plugins.Guidance;
 
 public class GraphSelectGuidancePlugin : BaseProxyPlugin
 {
+    public GraphSelectGuidancePlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     public override string Name => nameof(GraphSelectGuidancePlugin);
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        pluginEvents.AfterResponse += AfterResponse;
+        PluginEvents.AfterResponse += AfterResponse;
 
-        // for background db refresh, let's use a separate logger
-        // that only logs warnings and errors
-        var _logger2 = (IProxyLogger)context.Logger.Clone();
-        _logger2.LogLevel = LogLevel.Warning;
         // let's not await so that it doesn't block the proxy startup
-        _ = MSGraphDbUtils.GenerateMSGraphDb(_logger2, true);
+        _ = MSGraphDbUtils.GenerateMSGraphDb(Logger, true);
     }
 
     private Task AfterResponse(object? sender, ProxyResponseArgs e)
     {
         Request request = e.Session.HttpClient.Request;
-        if (_urlsToWatch is not null &&
-            e.HasRequestUrlMatch(_urlsToWatch) &&
+        if (UrlsToWatch is not null &&
+            e.HasRequestUrlMatch(UrlsToWatch) &&
             e.Session.HttpClient.Request.Method.ToUpper() != "OPTIONS" &&
             WarnNoSelect(request))
-            _logger?.LogRequest(BuildUseSelectMessage(request), MessageType.Warning, new LoggingContext(e.Session));
+            Logger.LogRequest(BuildUseSelectMessage(request), MessageType.Warning, new LoggingContext(e.Session));
 
         return Task.CompletedTask;
     }
@@ -81,7 +78,7 @@ private bool EndpointSupportsSelect(string graphVersion, string relativeUrl)
         }
         catch (Exception ex)
         {
-            _logger?.LogError(ex, "Error looking up endpoint in database");
+            Logger.LogError(ex, "Error looking up endpoint in database");
             return fallback;
         }
     }
diff --git a/dev-proxy-plugins/Guidance/ODSPSearchGuidancePlugin.cs b/dev-proxy-plugins/Guidance/ODSPSearchGuidancePlugin.cs
index 9e3504d0..751ecb99 100644
--- a/dev-proxy-plugins/Guidance/ODSPSearchGuidancePlugin.cs
+++ b/dev-proxy-plugins/Guidance/ODSPSearchGuidancePlugin.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
 using Microsoft.DevProxy.Abstractions;
 using Titanium.Web.Proxy.Http;
 
@@ -9,26 +10,27 @@ namespace Microsoft.DevProxy.Plugins.Guidance;
 
 public class ODSPSearchGuidancePlugin : BaseProxyPlugin
 {
+    public ODSPSearchGuidancePlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     public override string Name => nameof(ODSPSearchGuidancePlugin);
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        pluginEvents.BeforeRequest += BeforeRequest;
+        PluginEvents.BeforeRequest += BeforeRequest;
     }
 
     private Task BeforeRequest(object sender, ProxyRequestArgs e)
     {
         Request request = e.Session.HttpClient.Request;
-        if (_urlsToWatch is not null &&
-            e.HasRequestUrlMatch(_urlsToWatch) &&
+        if (UrlsToWatch is not null &&
+            e.HasRequestUrlMatch(UrlsToWatch) &&
             e.Session.HttpClient.Request.Method.ToUpper() != "OPTIONS" &&
             WarnDeprecatedSearch(request))
-            _logger?.LogRequest(BuildUseGraphSearchMessage(), MessageType.Warning, new LoggingContext(e.Session));
+            Logger.LogRequest(BuildUseGraphSearchMessage(), MessageType.Warning, new LoggingContext(e.Session));
 
         return Task.CompletedTask;
     }
diff --git a/dev-proxy-plugins/Guidance/ODataPagingGuidancePlugin.cs b/dev-proxy-plugins/Guidance/ODataPagingGuidancePlugin.cs
index 0b5c9aea..a680d53f 100644
--- a/dev-proxy-plugins/Guidance/ODataPagingGuidancePlugin.cs
+++ b/dev-proxy-plugins/Guidance/ODataPagingGuidancePlugin.cs
@@ -14,22 +14,23 @@ public class ODataPagingGuidancePlugin : BaseProxyPlugin
     public override string Name => nameof(ODataPagingGuidancePlugin);
     private IList<string> pagingUrls = new List<string>();
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public ODataPagingGuidancePlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+    }
+
+    public override void Register()
+    {
+        base.Register();
 
-        pluginEvents.BeforeRequest += OnBeforeRequest;
-        pluginEvents.BeforeResponse += OnBeforeResponse;
+        PluginEvents.BeforeRequest += OnBeforeRequest;
+        PluginEvents.BeforeResponse += OnBeforeResponse;
     }
 
     private Task OnBeforeRequest(object? sender, ProxyRequestArgs e)
     {
-        if (_urlsToWatch is null ||
+        if (UrlsToWatch is null ||
             e.Session.HttpClient.Request.Method != "GET" ||
-            !e.HasRequestUrlMatch(_urlsToWatch))
+            !e.HasRequestUrlMatch(UrlsToWatch))
         {
             return Task.CompletedTask;
         }
@@ -37,7 +38,7 @@ private Task OnBeforeRequest(object? sender, ProxyRequestArgs e)
         if (IsODataPagingUrl(e.Session.HttpClient.Request.RequestUri) &&
             !pagingUrls.Contains(e.Session.HttpClient.Request.Url))
         {
-            _logger?.LogRequest(BuildIncorrectPagingUrlMessage(), MessageType.Warning, new LoggingContext(e.Session));
+            Logger.LogRequest(BuildIncorrectPagingUrlMessage(), MessageType.Warning, new LoggingContext(e.Session));
         }
 
         return Task.CompletedTask;
@@ -45,8 +46,8 @@ private Task OnBeforeRequest(object? sender, ProxyRequestArgs e)
 
     private async Task OnBeforeResponse(object? sender, ProxyResponseArgs e)
     {
-        if (_urlsToWatch is null ||
-            !e.HasRequestUrlMatch(_urlsToWatch) ||
+        if (UrlsToWatch is null ||
+            !e.HasRequestUrlMatch(UrlsToWatch) ||
             e.Session.HttpClient.Request.Method != "GET" ||
             e.Session.HttpClient.Response.StatusCode >= 300 ||
             e.Session.HttpClient.Response.ContentType is null ||
@@ -96,13 +97,13 @@ private string GetNextLinkFromJson(string responseBody)
         }
         catch (Exception e)
         {
-            _logger?.LogDebug(e, "An error has occurred while parsing the response body");
+            Logger.LogDebug(e, "An error has occurred while parsing the response body");
         }
 
         return nextLink;
     }
 
-    private static string GetNextLinkFromXml(string responseBody)
+    private string GetNextLinkFromXml(string responseBody)
     {
         var nextLink = string.Empty;
 
@@ -117,7 +118,7 @@ private static string GetNextLinkFromXml(string responseBody)
         }
         catch (Exception e)
         {
-            Console.WriteLine(e.Message);
+            Logger.LogError(e.Message);
         }
 
         return nextLink;
diff --git a/dev-proxy-plugins/Inspection/DevToolsPlugin.cs b/dev-proxy-plugins/Inspection/DevToolsPlugin.cs
index adbad4a6..b6195152 100644
--- a/dev-proxy-plugins/Inspection/DevToolsPlugin.cs
+++ b/dev-proxy-plugins/Inspection/DevToolsPlugin.cs
@@ -34,19 +34,20 @@ public class DevToolsPlugin : BaseProxyPlugin
     public override string Name => nameof(DevToolsPlugin);
     private readonly DevToolsPluginConfiguration _configuration = new();
 
-    public override void Register(IPluginEvents pluginEvents,
-                              IProxyContext context,
-                              ISet<UrlToWatch> urlsToWatch,
-                              IConfigurationSection? configSection = null)
+    public DevToolsPlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
-        configSection?.Bind(_configuration);
+    }
+
+    public override void Register()
+    {
+        base.Register();
+        ConfigSection?.Bind(_configuration);
 
         InitInspector();
 
-        pluginEvents.BeforeRequest += BeforeRequest;
-        pluginEvents.AfterResponse += AfterResponse;
-        pluginEvents.AfterRequestLog += AfterRequestLog;
+        PluginEvents.BeforeRequest += BeforeRequest;
+        PluginEvents.AfterResponse += AfterResponse;
+        PluginEvents.AfterRequestLog += AfterRequestLog;
     }
 
     private static int GetFreePort()
@@ -77,7 +78,7 @@ private string GetChromiumProcessName(DevToolsPluginConfiguration configuration)
     private void InitInspector()
     {
         var port = GetFreePort();
-        webSocket = new WebSocketServer(port);
+        webSocket = new WebSocketServer(port, Logger);
         webSocket.MessageReceived += SocketMessageReceived;
         webSocket.Start();
 
@@ -85,7 +86,7 @@ private void InitInspector()
         var inspectionUrl = $"http://localhost:9222/devtools/inspector.html?ws=localhost:{port}";
         var args = $"{inspectionUrl} --remote-debugging-port=9222 --profile-directory=devproxy";
 
-        _logger?.LogInformation("DevTools available at {inspectionUrl}", inspectionUrl);
+        Logger.LogInformation("DevTools available at {inspectionUrl}", inspectionUrl);
 
         var process = new Process
         {
diff --git a/dev-proxy-plugins/Inspection/WebSocketServer.cs b/dev-proxy-plugins/Inspection/WebSocketServer.cs
index bdb99731..247bbfd0 100644
--- a/dev-proxy-plugins/Inspection/WebSocketServer.cs
+++ b/dev-proxy-plugins/Inspection/WebSocketServer.cs
@@ -10,20 +10,23 @@ namespace Microsoft.DevProxy.Plugins.Inspection;
 using System.Text.Json;
 using System.Threading;
 using Microsoft.DevProxy.Abstractions;
+using Microsoft.Extensions.Logging;
 
 public class WebSocketServer
 {
     private HttpListener? listener;
-    private int port;
+    private int _port;
+    private ILogger _logger;
     private WebSocket? webSocket;
     static SemaphoreSlim webSocketSemaphore = new SemaphoreSlim(1, 1);
 
     public bool IsConnected => webSocket is not null;
     public event Action<string>? MessageReceived;
 
-    public WebSocketServer(int port)
+    public WebSocketServer(int port, ILogger logger)
     {
-        this.port = port;
+        _port = port;
+        _logger = logger;
     }
 
     private async Task HandleMessages(WebSocket ws)
@@ -49,14 +52,14 @@ private async Task HandleMessages(WebSocket ws)
         }
         catch (InvalidOperationException)
         {
-            Console.WriteLine("[WS] Tried to receive message while already reading one.");
+            _logger.LogError("[WS] Tried to receive message while already reading one.");
         }
     }
 
     public async void Start()
     {
         listener = new HttpListener();
-        listener.Prefixes.Add($"http://localhost:{port}/");
+        listener.Prefixes.Add($"http://localhost:{_port}/");
         listener.Start();
 
         while (true)
diff --git a/dev-proxy-plugins/Mocks/CrudApiDefinitionLoader.cs b/dev-proxy-plugins/Mocks/CrudApiDefinitionLoader.cs
index 9c640d15..12189e03 100644
--- a/dev-proxy-plugins/Mocks/CrudApiDefinitionLoader.cs
+++ b/dev-proxy-plugins/Mocks/CrudApiDefinitionLoader.cs
@@ -9,10 +9,10 @@ namespace Microsoft.DevProxy.Plugins.Mocks;
 
 internal class CrudApiDefinitionLoader : IDisposable
 {
-    private readonly IProxyLogger _logger;
+    private readonly ILogger _logger;
     private readonly CrudApiConfiguration _configuration;
 
-    public CrudApiDefinitionLoader(IProxyLogger logger, CrudApiConfiguration configuration)
+    public CrudApiDefinitionLoader(ILogger logger, CrudApiConfiguration configuration)
     {
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         _configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
diff --git a/dev-proxy-plugins/Mocks/CrudApiPlugin.cs b/dev-proxy-plugins/Mocks/CrudApiPlugin.cs
index d30fc660..c054f0d0 100644
--- a/dev-proxy-plugins/Mocks/CrudApiPlugin.cs
+++ b/dev-proxy-plugins/Mocks/CrudApiPlugin.cs
@@ -80,28 +80,29 @@ public class CrudApiPlugin : BaseProxyPlugin
     private JArray? _data;
     private OpenIdConnectConfiguration? _openIdConnectConfiguration;
 
-    public override async void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public CrudApiPlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+    }
+
+    public override async void Register()
+    {
+        base.Register();
 
-        configSection?.Bind(_configuration);
+        ConfigSection?.Bind(_configuration);
 
-        pluginEvents.BeforeRequest += OnRequest;
+        PluginEvents.BeforeRequest += OnRequest;
 
-        _proxyConfiguration = context.Configuration;
+        _proxyConfiguration = Context.Configuration;
 
         _configuration.ApiFile = Path.GetFullPath(ProxyUtils.ReplacePathTokens(_configuration.ApiFile), Path.GetDirectoryName(_proxyConfiguration?.ConfigFile ?? string.Empty) ?? string.Empty);
 
-        _loader = new CrudApiDefinitionLoader(_logger!, _configuration);
+        _loader = new CrudApiDefinitionLoader(Logger, _configuration);
         _loader?.InitApiDefinitionWatcher();
 
         if (_configuration.Auth == CrudApiAuthType.Entra &&
             _configuration.EntraAuthConfig is null)
         {
-            _logger?.LogError("Entra auth is enabled but no configuration is provided. API will work anonymously.");
+            Logger.LogError("Entra auth is enabled but no configuration is provided. API will work anonymously.");
             _configuration.Auth = CrudApiAuthType.None;
         }
 
@@ -119,7 +120,7 @@ private async Task SetupOpenIdConnectConfiguration()
         }
         catch (Exception ex)
         {
-            _logger?.LogError(ex, "An error has occurred while loading OpenIdConnectConfiguration");
+            Logger.LogError(ex, "An error has occurred while loading OpenIdConnectConfiguration");
         }
     }
 
@@ -130,7 +131,7 @@ private void LoadData()
             var dataFilePath = Path.GetFullPath(ProxyUtils.ReplacePathTokens(_configuration.DataFile), Path.GetDirectoryName(_configuration.ApiFile) ?? string.Empty);
             if (!File.Exists(dataFilePath))
             {
-                _logger?.LogError($"Data file '{dataFilePath}' does not exist. The {_configuration.BaseUrl} API will be disabled.");
+                Logger.LogError($"Data file '{dataFilePath}' does not exist. The {_configuration.BaseUrl} API will be disabled.");
                 _configuration.Actions = Array.Empty<CrudApiAction>();
                 return;
             }
@@ -140,7 +141,7 @@ private void LoadData()
         }
         catch (Exception ex)
         {
-            _logger?.LogError(ex, "An error has occurred while reading {configFile}", _configuration.DataFile);
+            Logger.LogError(ex, "An error has occurred while reading {configFile}", _configuration.DataFile);
         }
     }
 
@@ -149,7 +150,7 @@ protected virtual Task OnRequest(object? sender, ProxyRequestArgs e)
         Request request = e.Session.HttpClient.Request;
         ResponseState state = e.ResponseState;
 
-        if (_urlsToWatch is not null && e.ShouldExecute(_urlsToWatch))
+        if (UrlsToWatch is not null && e.ShouldExecute(UrlsToWatch))
         {
             if (!AuthorizeRequest(e))
             {
@@ -185,7 +186,7 @@ private bool AuthorizeRequest(ProxyRequestArgs e, CrudApiAction? action = null)
         {
             if (action is null)
             {
-                _logger?.LogDebug("No auth is required for this API.");
+                Logger.LogDebug("No auth is required for this API.");
             }
             return true;
         }
@@ -196,7 +197,7 @@ private bool AuthorizeRequest(ProxyRequestArgs e, CrudApiAction? action = null)
         // is there a token
         if (string.IsNullOrEmpty(token))
         {
-            _logger?.LogRequest(["401 Unauthorized", "No token found on the request."], MessageType.Failed, new LoggingContext(e.Session));
+            Logger.LogRequest(["401 Unauthorized", "No token found on the request."], MessageType.Failed, new LoggingContext(e.Session));
             return false;
         }
 
@@ -204,7 +205,7 @@ private bool AuthorizeRequest(ProxyRequestArgs e, CrudApiAction? action = null)
         var tokenHeaderParts = token.Split(' ');
         if (tokenHeaderParts.Length != 2 || tokenHeaderParts[0] != "Bearer")
         {
-            _logger?.LogRequest(["401 Unauthorized", "The specified token is not a valid Bearer token."], MessageType.Failed, new LoggingContext(e.Session));
+            Logger.LogRequest(["401 Unauthorized", "The specified token is not a valid Bearer token."], MessageType.Failed, new LoggingContext(e.Session));
             return false;
         }
 
@@ -244,7 +245,7 @@ private bool AuthorizeRequest(ProxyRequestArgs e, CrudApiAction? action = null)
                 {
                     var rolesRequired = string.Join(", ", authConfig.Roles);
 
-                    _logger?.LogRequest(["401 Unauthorized", $"The specified token does not have the necessary role(s). Required one of: {rolesRequired}, found: {rolesFromTheToken}"], MessageType.Failed, new LoggingContext(e.Session));
+                    Logger.LogRequest(["401 Unauthorized", $"The specified token does not have the necessary role(s). Required one of: {rolesRequired}, found: {rolesFromTheToken}"], MessageType.Failed, new LoggingContext(e.Session));
                     return false;
                 }
 
@@ -260,7 +261,7 @@ private bool AuthorizeRequest(ProxyRequestArgs e, CrudApiAction? action = null)
                 {
                     var scopesRequired = string.Join(", ", authConfig.Scopes);
 
-                    _logger?.LogRequest(["401 Unauthorized", $"The specified token does not have the necessary scope(s). Required one of: {scopesRequired}, found: {scopesFromTheToken}"], MessageType.Failed, new LoggingContext(e.Session));
+                    Logger.LogRequest(["401 Unauthorized", $"The specified token does not have the necessary scope(s). Required one of: {scopesRequired}, found: {scopesFromTheToken}"], MessageType.Failed, new LoggingContext(e.Session));
                     return false;
                 }
 
@@ -269,7 +270,7 @@ private bool AuthorizeRequest(ProxyRequestArgs e, CrudApiAction? action = null)
         }
         catch (Exception ex)
         {
-            _logger?.LogRequest(["401 Unauthorized", $"The specified token is not valid: {ex.Message}"], MessageType.Failed, new LoggingContext(e.Session));
+            Logger.LogRequest(["401 Unauthorized", $"The specified token is not valid: {ex.Message}"], MessageType.Failed, new LoggingContext(e.Session));
             return false;
         }
 
@@ -335,7 +336,7 @@ private void SendJsonResponse(string body, HttpStatusCode statusCode, SessionEve
     private void GetAll(SessionEventArgs e, CrudApiAction action, IDictionary<string, string> parameters)
     {
         SendJsonResponse(JsonConvert.SerializeObject(_data, Formatting.Indented), HttpStatusCode.OK, e);
-        _logger?.LogRequest([$"200 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
+        Logger.LogRequest([$"200 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
     }
 
     private void GetOne(SessionEventArgs e, CrudApiAction action, IDictionary<string, string> parameters)
@@ -346,17 +347,17 @@ private void GetOne(SessionEventArgs e, CrudApiAction action, IDictionary<string
             if (item is null)
             {
                 SendNotFoundResponse(e);
-                _logger?.LogRequest([$"404 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
+                Logger.LogRequest([$"404 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
                 return;
             }
 
             SendJsonResponse(JsonConvert.SerializeObject(item, Formatting.Indented), HttpStatusCode.OK, e);
-            _logger?.LogRequest([$"200 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
+            Logger.LogRequest([$"200 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
         }
         catch (Exception ex)
         {
             SendJsonResponse(JsonConvert.SerializeObject(ex, Formatting.Indented), HttpStatusCode.InternalServerError, e);
-            _logger?.LogRequest([$"500 {action.Url}"], MessageType.Failed, new LoggingContext(e));
+            Logger.LogRequest([$"500 {action.Url}"], MessageType.Failed, new LoggingContext(e));
         }
     }
 
@@ -371,12 +372,12 @@ private void GetMany(SessionEventArgs e, CrudApiAction action, IDictionary<strin
             }
 
             SendJsonResponse(JsonConvert.SerializeObject(items, Formatting.Indented), HttpStatusCode.OK, e);
-            _logger?.LogRequest([$"200 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
+            Logger.LogRequest([$"200 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
         }
         catch (Exception ex)
         {
             SendJsonResponse(JsonConvert.SerializeObject(ex, Formatting.Indented), HttpStatusCode.InternalServerError, e);
-            _logger?.LogRequest([$"500 {action.Url}"], MessageType.Failed, new LoggingContext(e));
+            Logger.LogRequest([$"500 {action.Url}"], MessageType.Failed, new LoggingContext(e));
         }
     }
 
@@ -386,12 +387,12 @@ private void Create(SessionEventArgs e, CrudApiAction action, IDictionary<string
         {
             _data?.Add(JObject.Parse(e.HttpClient.Request.BodyString));
             SendJsonResponse(JsonConvert.SerializeObject(e.HttpClient.Request.BodyString, Formatting.Indented), HttpStatusCode.Created, e);
-            _logger?.LogRequest([$"201 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
+            Logger.LogRequest([$"201 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
         }
         catch (Exception ex)
         {
             SendJsonResponse(JsonConvert.SerializeObject(ex, Formatting.Indented), HttpStatusCode.InternalServerError, e);
-            _logger?.LogRequest([$"500 {action.Url}"], MessageType.Failed, new LoggingContext(e));
+            Logger.LogRequest([$"500 {action.Url}"], MessageType.Failed, new LoggingContext(e));
         }
     }
 
@@ -403,18 +404,18 @@ private void Merge(SessionEventArgs e, CrudApiAction action, IDictionary<string,
             if (item is null)
             {
                 SendNotFoundResponse(e);
-                _logger?.LogRequest([$"404 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
+                Logger.LogRequest([$"404 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
                 return;
             }
             var update = JObject.Parse(e.HttpClient.Request.BodyString);
             ((JContainer)item)?.Merge(update);
             SendEmptyResponse(HttpStatusCode.NoContent, e);
-            _logger?.LogRequest([$"204 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
+            Logger.LogRequest([$"204 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
         }
         catch (Exception ex)
         {
             SendJsonResponse(JsonConvert.SerializeObject(ex, Formatting.Indented), HttpStatusCode.InternalServerError, e);
-            _logger?.LogRequest([$"500 {action.Url}"], MessageType.Failed, new LoggingContext(e));
+            Logger.LogRequest([$"500 {action.Url}"], MessageType.Failed, new LoggingContext(e));
         }
     }
 
@@ -426,18 +427,18 @@ private void Update(SessionEventArgs e, CrudApiAction action, IDictionary<string
             if (item is null)
             {
                 SendNotFoundResponse(e);
-                _logger?.LogRequest([$"404 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
+                Logger.LogRequest([$"404 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
                 return;
             }
             var update = JObject.Parse(e.HttpClient.Request.BodyString);
             ((JContainer)item)?.Replace(update);
             SendEmptyResponse(HttpStatusCode.NoContent, e);
-            _logger?.LogRequest([$"204 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
+            Logger.LogRequest([$"204 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
         }
         catch (Exception ex)
         {
             SendJsonResponse(JsonConvert.SerializeObject(ex, Formatting.Indented), HttpStatusCode.InternalServerError, e);
-            _logger?.LogRequest([$"500 {action.Url}"], MessageType.Failed, new LoggingContext(e));
+            Logger.LogRequest([$"500 {action.Url}"], MessageType.Failed, new LoggingContext(e));
         }
     }
 
@@ -449,18 +450,18 @@ private void Delete(SessionEventArgs e, CrudApiAction action, IDictionary<string
             if (item is null)
             {
                 SendNotFoundResponse(e);
-                _logger?.LogRequest([$"404 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
+                Logger.LogRequest([$"404 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
                 return;
             }
 
             item?.Remove();
             SendEmptyResponse(HttpStatusCode.NoContent, e);
-            _logger?.LogRequest([$"204 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
+            Logger.LogRequest([$"204 {action.Url}"], MessageType.Mocked, new LoggingContext(e));
         }
         catch (Exception ex)
         {
             SendJsonResponse(JsonConvert.SerializeObject(ex, Formatting.Indented), HttpStatusCode.InternalServerError, e);
-            _logger?.LogRequest([$"500 {action.Url}"], MessageType.Failed, new LoggingContext(e));
+            Logger.LogRequest([$"500 {action.Url}"], MessageType.Failed, new LoggingContext(e));
         }
     }
 
diff --git a/dev-proxy-plugins/Mocks/EntraMockResponsePlugin.cs b/dev-proxy-plugins/Mocks/EntraMockResponsePlugin.cs
index 0f111f25..757c96f2 100644
--- a/dev-proxy-plugins/Mocks/EntraMockResponsePlugin.cs
+++ b/dev-proxy-plugins/Mocks/EntraMockResponsePlugin.cs
@@ -8,6 +8,8 @@
 using System.Text.RegularExpressions;
 using System.Web;
 using Microsoft.DevProxy.Abstractions;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
 
 namespace Microsoft.DevProxy.Plugins.Mocks;
 
@@ -33,6 +35,11 @@ class IdToken
 public class EntraMockResponsePlugin : MockResponsePlugin
 {
     private string? lastNonce;
+
+    public EntraMockResponsePlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     public override string Name => nameof(EntraMockResponsePlugin);
 
     protected override void ProcessMockResponse(ref byte[] body, IList<MockResponseHeader> headers, ProxyRequestArgs e, MockResponse? matchingResponse)
@@ -139,19 +146,19 @@ private void UpdateMsalState(ref string body, ProxyRequestArgs e, ref bool chang
 
     private string GetKeyId()
     {
-        return _context?.Certificate?.Thumbprint ?? "";
+        return Context.Certificate?.Thumbprint ?? "";
     }
 
     private List<string> GetCertificateChain()
     {
-        if (_context?.Certificate is null)
+        if (Context.Certificate is null)
         {
             return new List<string>();
         }
 
         var collection = new X509Certificate2Collection
         {
-            _context.Certificate
+            Context.Certificate
         };
 
         var certificateChain = new List<string>();
diff --git a/dev-proxy-plugins/Mocks/GraphConnectorNotificationPlugin.cs b/dev-proxy-plugins/Mocks/GraphConnectorNotificationPlugin.cs
index 7df74b71..68a0bbab 100644
--- a/dev-proxy-plugins/Mocks/GraphConnectorNotificationPlugin.cs
+++ b/dev-proxy-plugins/Mocks/GraphConnectorNotificationPlugin.cs
@@ -22,24 +22,22 @@ public class GraphConnectorNotificationConfiguration : MockRequestConfiguration
 public class GraphConnectorNotificationPlugin : MockRequestPlugin
 {
     private string? _ticket = null;
-    private IProxyContext? _context;
     private GraphConnectorNotificationConfiguration _graphConnectorConfiguration = new();
 
+    public GraphConnectorNotificationPlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     public override string Name => nameof(GraphConnectorNotificationPlugin);
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        _context = context;
-
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
-        configSection?.Bind(_graphConnectorConfiguration);
+        base.Register();
+        ConfigSection?.Bind(_graphConnectorConfiguration);
         _graphConnectorConfiguration.MockFile = _configuration.MockFile;
         _graphConnectorConfiguration.Request = _configuration.Request;
-
-        pluginEvents.BeforeRequest += OnBeforeRequest;
+        
+        PluginEvents.BeforeRequest += OnBeforeRequest;
     }
 
     private Task OnBeforeRequest(object sender, ProxyRequestArgs e)
@@ -78,13 +76,13 @@ private void VerifyTicket(SessionEventArgs session)
         var ticketFromHeader = request.Headers.FirstOrDefault(h => h.Name.Equals("GraphConnectors-Ticket", StringComparison.OrdinalIgnoreCase))?.Value;
         if (ticketFromHeader is null)
         {
-            _logger?.LogRequest(["No ticket header found in the Graph connector notification"], MessageType.Failed, new LoggingContext(session));
+            Logger.LogRequest(["No ticket header found in the Graph connector notification"], MessageType.Failed, new LoggingContext(session));
             return;
         }
 
         if (ticketFromHeader != _ticket)
         {
-            _logger?.LogRequest([$"Ticket on the request does not match the expected ticket. Expected: {_ticket}. Request: {ticketFromHeader}"], MessageType.Failed, new LoggingContext(session));
+            Logger.LogRequest([$"Ticket on the request does not match the expected ticket. Expected: {_ticket}. Request: {ticketFromHeader}"], MessageType.Failed, new LoggingContext(session));
         }
     }
 
@@ -92,7 +90,7 @@ protected override async Task OnMockRequest(object sender, EventArgs e)
     {
         if (_configuration.Request is null)
         {
-            _logger?.LogDebug("No mock request is configured. Skipping.");
+            Logger.LogDebug("No mock request is configured. Skipping.");
             return;
         }
 
@@ -100,7 +98,7 @@ protected override async Task OnMockRequest(object sender, EventArgs e)
         var requestMessage = GetRequestMessage();
         if (requestMessage.Content is null)
         {
-            _logger?.LogError("No body found in the mock request. Skipping.");
+            Logger.LogError("No body found in the mock request. Skipping.");
             return;
         }
         var requestBody = await requestMessage.Content.ReadAsStringAsync();
@@ -110,13 +108,13 @@ protected override async Task OnMockRequest(object sender, EventArgs e)
 
         try
         {
-            _logger?.LogRequest(["Sending Graph connector notification"], MessageType.Mocked, _configuration.Request.Method, _configuration.Request.Url);
+            Logger.LogRequest(["Sending Graph connector notification"], MessageType.Mocked, _configuration.Request.Method, _configuration.Request.Url);
 
             var response = await httpClient.SendAsync(requestMessage);
 
             if (response.StatusCode != HttpStatusCode.Accepted)
             {
-                _logger?.LogRequest([$"Incorrect response status code {(int)response.StatusCode} {response.StatusCode}. Expected: 202 Accepted"], MessageType.Failed, _configuration.Request.Method, _configuration.Request.Url);
+                Logger.LogRequest([$"Incorrect response status code {(int)response.StatusCode} {response.StatusCode}. Expected: 202 Accepted"], MessageType.Failed, _configuration.Request.Method, _configuration.Request.Url);
             }
 
             if (response.Content is not null)
@@ -124,19 +122,19 @@ protected override async Task OnMockRequest(object sender, EventArgs e)
                 var content = await response.Content.ReadAsStringAsync();
                 if (!string.IsNullOrEmpty(content))
                 {
-                    _logger?.LogRequest(["Received response body while empty response expected"], MessageType.Failed, _configuration.Request.Method, _configuration.Request.Url);
+                    Logger.LogRequest(["Received response body while empty response expected"], MessageType.Failed, _configuration.Request.Method, _configuration.Request.Url);
                 }
             }
         }
         catch (Exception ex)
         {
-            _logger?.LogError(ex, "An error has occurred while sending the Graph connector notification to {url}", _configuration.Request.Url);
+            Logger.LogError(ex, "An error has occurred while sending the Graph connector notification to {url}", _configuration.Request.Url);
         }
     }
 
     private string GetJwtToken()
     {
-        var signingCredentials = new X509SigningCredentials(_context?.Certificate, SecurityAlgorithms.RsaSha256);
+        var signingCredentials = new X509SigningCredentials(Context.Certificate, SecurityAlgorithms.RsaSha256);
 
         var tokenHandler = new JwtSecurityTokenHandler();
         var tokenDescriptor = new SecurityTokenDescriptor
@@ -168,7 +166,7 @@ private void LoadTicket()
 
         if (_configuration.Request?.Body is null)
         {
-            _logger?.LogWarning("No body found in the Graph connector notification. Ticket will not be loaded.");
+            Logger.LogWarning("No body found in the Graph connector notification. Ticket will not be loaded.");
             return;
         }
 
@@ -179,12 +177,12 @@ private void LoadTicket()
 
             if (string.IsNullOrEmpty(_ticket))
             {
-                _logger?.LogError("No ticket found in the Graph connector notification body");
+                Logger.LogError("No ticket found in the Graph connector notification body");
             }
         }
         catch (Exception ex)
         {
-            _logger?.LogError(ex, "An error has occurred while reading the ticket from the Graph connector notification body");
+            Logger.LogError(ex, "An error has occurred while reading the ticket from the Graph connector notification body");
         }
     }
 }
diff --git a/dev-proxy-plugins/Mocks/GraphMockResponsePlugin.cs b/dev-proxy-plugins/Mocks/GraphMockResponsePlugin.cs
index 8bce81a7..54e4da2e 100644
--- a/dev-proxy-plugins/Mocks/GraphMockResponsePlugin.cs
+++ b/dev-proxy-plugins/Mocks/GraphMockResponsePlugin.cs
@@ -6,6 +6,7 @@
 using System.Text.RegularExpressions;
 using Microsoft.DevProxy.Abstractions;
 using Microsoft.DevProxy.Plugins.Behavior;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using Titanium.Web.Proxy.Models;
 
@@ -13,6 +14,10 @@ namespace Microsoft.DevProxy.Plugins.Mocks;
 
 public class GraphMockResponsePlugin : MockResponsePlugin
 {
+    public GraphMockResponsePlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     public override string Name => nameof(GraphMockResponsePlugin);
 
     protected override async Task OnRequest(object? sender, ProxyRequestArgs e)
@@ -70,7 +75,7 @@ protected override async Task OnRequest(object? sender, ProxyRequestArgs e)
                     }
                 };
 
-                _logger?.LogRequest([$"502 {request.Url}"], MessageType.Mocked, new LoggingContext(e.Session));
+                Logger.LogRequest([$"502 {request.Url}"], MessageType.Mocked, new LoggingContext(e.Session));
             }
             else
             {
@@ -106,7 +111,7 @@ protected override async Task OnRequest(object? sender, ProxyRequestArgs e)
                         var filePath = Path.Combine(Path.GetDirectoryName(_configuration.MocksFile) ?? "", ProxyUtils.ReplacePathTokens(bodyString.Trim('"').Substring(1)));
                         if (!File.Exists(filePath))
                         {
-                            _logger?.LogError("File {filePath} not found. Serving file path in the mock response", filePath);
+                            Logger.LogError("File {filePath} not found. Serving file path in the mock response", filePath);
                             body = bodyString;
                         }
                         else
@@ -128,7 +133,7 @@ protected override async Task OnRequest(object? sender, ProxyRequestArgs e)
                     Body = body
                 };
 
-                _logger?.LogRequest([$"{mockResponse.Response?.StatusCode ?? 200} {mockResponse.Request?.Url}"], MessageType.Mocked, new LoggingContext(e.Session));
+                Logger.LogRequest([$"{mockResponse.Response?.StatusCode ?? 200} {mockResponse.Request?.Url}"], MessageType.Mocked, new LoggingContext(e.Session));
             }
 
             responses.Add(response);
@@ -144,7 +149,7 @@ protected override async Task OnRequest(object? sender, ProxyRequestArgs e)
         var batchResponseString = JsonSerializer.Serialize(batchResponse, ProxyUtils.JsonSerializerOptions);
         ProcessMockResponse(ref batchResponseString, batchHeaders, e, null);
         e.Session.GenericResponse(batchResponseString ?? string.Empty, HttpStatusCode.OK, batchHeaders.Select(h => new HttpHeader(h.Name, h.Value)));
-        _logger?.LogRequest([$"200 {e.Session.HttpClient.Request.RequestUri}"], MessageType.Mocked, new LoggingContext(e.Session));
+        Logger.LogRequest([$"200 {e.Session.HttpClient.Request.RequestUri}"], MessageType.Mocked, new LoggingContext(e.Session));
         e.ResponseState.HasBeenSet = true;
     }
 
diff --git a/dev-proxy-plugins/Mocks/MockRequestLoader.cs b/dev-proxy-plugins/Mocks/MockRequestLoader.cs
index 33f2e932..203bf363 100644
--- a/dev-proxy-plugins/Mocks/MockRequestLoader.cs
+++ b/dev-proxy-plugins/Mocks/MockRequestLoader.cs
@@ -9,10 +9,10 @@ namespace Microsoft.DevProxy.Plugins.Mocks;
 
 internal class MockRequestLoader : IDisposable
 {
-    private readonly IProxyLogger _logger;
+    private readonly ILogger _logger;
     private readonly MockRequestConfiguration _configuration;
 
-    public MockRequestLoader(IProxyLogger logger, MockRequestConfiguration configuration)
+    public MockRequestLoader(ILogger logger, MockRequestConfiguration configuration)
     {
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         _configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
diff --git a/dev-proxy-plugins/Mocks/MockRequestPlugin.cs b/dev-proxy-plugins/Mocks/MockRequestPlugin.cs
index b233eee6..cbafd2bc 100644
--- a/dev-proxy-plugins/Mocks/MockRequestPlugin.cs
+++ b/dev-proxy-plugins/Mocks/MockRequestPlugin.cs
@@ -23,22 +23,23 @@ public class MockRequestPlugin : BaseProxyPlugin
     protected MockRequestConfiguration _configuration = new();
     private MockRequestLoader? _loader = null;
 
+    public MockRequestPlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     public override string Name => nameof(MockRequestPlugin);
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        configSection?.Bind(_configuration);
-        _loader = new MockRequestLoader(_logger!, _configuration);
+        ConfigSection?.Bind(_configuration);
+        _loader = new MockRequestLoader(Logger, _configuration);
 
-        pluginEvents.MockRequest += OnMockRequest;
+        PluginEvents.MockRequest += OnMockRequest;
 
         // make the mock file path relative to the configuration file
-        _configuration.MockFile = Path.GetFullPath(ProxyUtils.ReplacePathTokens(_configuration.MockFile), Path.GetDirectoryName(context.Configuration?.ConfigFile ?? string.Empty) ?? string.Empty);
+        _configuration.MockFile = Path.GetFullPath(ProxyUtils.ReplacePathTokens(_configuration.MockFile), Path.GetDirectoryName(Context.Configuration.ConfigFile ?? string.Empty) ?? string.Empty);
 
         // load the request from the configured mock file
         _loader.InitResponsesWatcher();
@@ -48,7 +49,7 @@ protected HttpRequestMessage GetRequestMessage()
     {
         Debug.Assert(_configuration.Request is not null, "The mock request is not configured");
 
-        _logger?.LogDebug("Preparing mock {method} request to {url}", _configuration.Request.Method, _configuration.Request.Url);
+        Logger.LogDebug("Preparing mock {method} request to {url}", _configuration.Request.Method, _configuration.Request.Url);
         var requestMessage = new HttpRequestMessage
         {
             RequestUri = new Uri(_configuration.Request.Url),
@@ -58,7 +59,7 @@ protected HttpRequestMessage GetRequestMessage()
         var contentType = "";
         if (_configuration.Request.Headers is not null)
         {
-            _logger?.LogDebug("Adding headers to the mock request");
+            Logger.LogDebug("Adding headers to the mock request");
 
             foreach (var header in _configuration.Request.Headers)
             {
@@ -74,7 +75,7 @@ protected HttpRequestMessage GetRequestMessage()
 
         if (_configuration.Request.Body is not null)
         {
-            _logger?.LogDebug("Adding body to the mock request");
+            Logger.LogDebug("Adding body to the mock request");
 
             if (_configuration.Request.Body is string)
             {
@@ -93,7 +94,7 @@ protected virtual async Task OnMockRequest(object sender, EventArgs e)
     {
         if (_configuration.Request is null)
         {
-            _logger?.LogDebug("No mock request is configured. Skipping.");
+            Logger.LogDebug("No mock request is configured. Skipping.");
             return;
         }
 
@@ -102,13 +103,13 @@ protected virtual async Task OnMockRequest(object sender, EventArgs e)
 
         try
         {
-            _logger?.LogRequest(["Sending mock request"], MessageType.Mocked, _configuration.Request.Method, _configuration.Request.Url);
+            Logger.LogRequest(["Sending mock request"], MessageType.Mocked, _configuration.Request.Method, _configuration.Request.Url);
 
             await httpClient.SendAsync(requestMessage);
         }
         catch (Exception ex)
         {
-            _logger?.LogError(ex, "An error has occurred while sending the mock request to {url}", _configuration.Request.Url);
+            Logger.LogError(ex, "An error has occurred while sending the mock request to {url}", _configuration.Request.Url);
         }
     }
 }
\ No newline at end of file
diff --git a/dev-proxy-plugins/Mocks/MockResponsePlugin.cs b/dev-proxy-plugins/Mocks/MockResponsePlugin.cs
index 9ddafa06..457dee6b 100644
--- a/dev-proxy-plugins/Mocks/MockResponsePlugin.cs
+++ b/dev-proxy-plugins/Mocks/MockResponsePlugin.cs
@@ -34,7 +34,6 @@ public class MockResponseConfiguration
 public class MockResponsePlugin : BaseProxyPlugin
 {
     protected MockResponseConfiguration _configuration = new();
-    protected IProxyContext? _context;
     private MockResponsesLoader? _loader = null;
     private static readonly string _noMocksOptionName = "--no-mocks";
     private static readonly string _mocksFileOptionName = "--mocks-file";
@@ -44,6 +43,10 @@ public class MockResponsePlugin : BaseProxyPlugin
     // used in combination with mocks that have an Nth property
     private Dictionary<string, int> _appliedMocks = new();
 
+    public MockResponsePlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     public override Option[] GetOptions()
     {
         var _noMocks = new Option<bool?>(_noMocksOptionName, "Disable loading mock requests")
@@ -60,22 +63,17 @@ public override Option[] GetOptions()
         return [_noMocks, _mocksFile];
     }
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        _context = context;
-
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        configSection?.Bind(_configuration);
-        _loader = new MockResponsesLoader(_logger!, _configuration);
+        ConfigSection?.Bind(_configuration);
+        _loader = new MockResponsesLoader(Logger, _configuration);
 
-        pluginEvents.OptionsLoaded += OnOptionsLoaded;
-        pluginEvents.BeforeRequest += OnRequest;
+        PluginEvents.OptionsLoaded += OnOptionsLoaded;
+        PluginEvents.BeforeRequest += OnRequest;
 
-        _proxyConfiguration = context.Configuration;
+        _proxyConfiguration = Context.Configuration;
     }
 
     private void OnOptionsLoaded(object? sender, OptionsLoadedArgs e)
@@ -111,7 +109,7 @@ protected virtual Task OnRequest(object? sender, ProxyRequestArgs e)
     {
         Request request = e.Session.HttpClient.Request;
         ResponseState state = e.ResponseState;
-        if (!_configuration.NoMocks && _urlsToWatch is not null && e.ShouldExecute(_urlsToWatch))
+        if (!_configuration.NoMocks && UrlsToWatch is not null && e.ShouldExecute(UrlsToWatch))
         {
             var matchingResponse = GetMatchingMockResponse(request);
             if (matchingResponse is not null)
@@ -291,7 +289,7 @@ private void ProcessMockResponseInternal(ProxyRequestArgs e, MockResponse matchi
                 if (!File.Exists(filePath))
                 {
 
-                    _logger?.LogError("File {filePath} not found. Serving file path in the mock response", filePath);
+                    Logger.LogError("File {filePath} not found. Serving file path in the mock response", filePath);
                     body = bodyString;
                 }
                 else
@@ -299,7 +297,7 @@ private void ProcessMockResponseInternal(ProxyRequestArgs e, MockResponse matchi
                     var bodyBytes = File.ReadAllBytes(filePath);
                     ProcessMockResponse(ref bodyBytes, headers, e, matchingResponse);
                     e.Session.GenericResponse(bodyBytes, statusCode, headers.Select(h => new HttpHeader(h.Name, h.Value)));
-                    _logger?.LogRequest([$"{matchingResponse.Response.StatusCode ?? 200} {matchingResponse.Request?.Url}"], MessageType.Mocked, new LoggingContext(e.Session));
+                    Logger.LogRequest([$"{matchingResponse.Response.StatusCode ?? 200} {matchingResponse.Request?.Url}"], MessageType.Mocked, new LoggingContext(e.Session));
                     return;
                 }
             }
@@ -320,6 +318,6 @@ private void ProcessMockResponseInternal(ProxyRequestArgs e, MockResponse matchi
         ProcessMockResponse(ref body, headers, e, matchingResponse);
         e.Session.GenericResponse(body ?? string.Empty, statusCode, headers.Select(h => new HttpHeader(h.Name, h.Value)));
 
-        _logger?.LogRequest([$"{matchingResponse.Response?.StatusCode ?? 200} {matchingResponse.Request?.Url}"], MessageType.Mocked, new LoggingContext(e.Session));
+        Logger.LogRequest([$"{matchingResponse.Response?.StatusCode ?? 200} {matchingResponse.Request?.Url}"], MessageType.Mocked, new LoggingContext(e.Session));
     }
 }
diff --git a/dev-proxy-plugins/Mocks/MockResponsesLoader.cs b/dev-proxy-plugins/Mocks/MockResponsesLoader.cs
index 638c495c..4b43481f 100644
--- a/dev-proxy-plugins/Mocks/MockResponsesLoader.cs
+++ b/dev-proxy-plugins/Mocks/MockResponsesLoader.cs
@@ -9,10 +9,10 @@ namespace Microsoft.DevProxy.Plugins.Mocks;
 
 internal class MockResponsesLoader : IDisposable
 {
-    private readonly IProxyLogger _logger;
+    private readonly ILogger _logger;
     private readonly MockResponseConfiguration _configuration;
 
-    public MockResponsesLoader(IProxyLogger logger, MockResponseConfiguration configuration)
+    public MockResponsesLoader(ILogger logger, MockResponseConfiguration configuration)
     {
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         _configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
diff --git a/dev-proxy-plugins/RandomErrors/GenericErrorResponsesLoader.cs b/dev-proxy-plugins/RandomErrors/GenericErrorResponsesLoader.cs
index b942adbf..3ee1fcd4 100644
--- a/dev-proxy-plugins/RandomErrors/GenericErrorResponsesLoader.cs
+++ b/dev-proxy-plugins/RandomErrors/GenericErrorResponsesLoader.cs
@@ -9,10 +9,10 @@ namespace Microsoft.DevProxy.Plugins.RandomErrors;
 
 internal class GenericErrorResponsesLoader : IDisposable
 {
-    private readonly IProxyLogger _logger;
+    private readonly ILogger _logger;
     private readonly GenericRandomErrorConfiguration _configuration;
 
-    public GenericErrorResponsesLoader(IProxyLogger logger, GenericRandomErrorConfiguration configuration)
+    public GenericErrorResponsesLoader(ILogger logger, GenericRandomErrorConfiguration configuration)
     {
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         _configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
diff --git a/dev-proxy-plugins/RandomErrors/GenericRandomErrorPlugin.cs b/dev-proxy-plugins/RandomErrors/GenericRandomErrorPlugin.cs
index ac3b5419..b5eabd37 100644
--- a/dev-proxy-plugins/RandomErrors/GenericRandomErrorPlugin.cs
+++ b/dev-proxy-plugins/RandomErrors/GenericRandomErrorPlugin.cs
@@ -30,19 +30,18 @@ public class GenericRandomErrorPlugin : BaseProxyPlugin
 {
     private readonly GenericRandomErrorConfiguration _configuration = new();
     private GenericErrorResponsesLoader? _loader = null;
-    private IProxyConfiguration? _proxyConfiguration;
 
     public override string Name => nameof(GenericRandomErrorPlugin);
 
-    private readonly Random _random;
+    private readonly Random _random = new();
 
-    public GenericRandomErrorPlugin()
+    public GenericRandomErrorPlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
     {
         _random = new Random();
     }
 
     // uses config to determine if a request should be failed
-    private GenericRandomErrorFailMode ShouldFail(ProxyRequestArgs e) => _random.Next(1, 100) <= _proxyConfiguration?.Rate ? GenericRandomErrorFailMode.Random : GenericRandomErrorFailMode.PassThru;
+    private GenericRandomErrorFailMode ShouldFail(ProxyRequestArgs e) => _random.Next(1, 100) <= Context.Configuration.Rate ? GenericRandomErrorFailMode.Random : GenericRandomErrorFailMode.PassThru;
 
     private void FailResponse(ProxyRequestArgs e, GenericRandomErrorFailMode failMode)
     {
@@ -97,7 +96,7 @@ private void UpdateProxyResponse(ProxyRequestArgs e, GenericErrorResponse error)
             var filePath = Path.Combine(Path.GetDirectoryName(_configuration.ErrorsFile) ?? "", ProxyUtils.ReplacePathTokens(body.Trim('"').Substring(1)));
             if (!File.Exists(filePath))
             {
-                _logger?.LogError("File {filePath} not found. Serving file path in the mock response", (string?)filePath);
+                Logger.LogError("File {filePath} not found. Serving file path in the mock response", (string?)filePath);
                 session.GenericResponse(body, statusCode, headers.Select(h => new HttpHeader(h.Name, h.Value)));
             }
             else
@@ -110,34 +109,23 @@ private void UpdateProxyResponse(ProxyRequestArgs e, GenericErrorResponse error)
         {
             session.GenericResponse(body, statusCode, headers.Select(h => new HttpHeader(h.Name, h.Value)));
         }
-        _logger?.LogRequest(new[] { $"{error.StatusCode} {statusCode.ToString()}" }, MessageType.Chaos, new LoggingContext(e.Session));
+        Logger.LogRequest([$"{error.StatusCode} {statusCode.ToString()}"], MessageType.Chaos, new LoggingContext(e.Session));
     }
 
     // throttle requests per host
     private string BuildThrottleKey(Request r) => r.RequestUri.Host;
 
-    public override void Register(IPluginEvents pluginEvents,
-                         IProxyContext context,
-                         ISet<UrlToWatch> urlsToWatch,
-                         IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        _proxyConfiguration = context.Configuration;
+        ConfigSection?.Bind(_configuration);
+        _configuration.ErrorsFile = Path.GetFullPath(ProxyUtils.ReplacePathTokens(_configuration.ErrorsFile ?? string.Empty), Path.GetDirectoryName(Context.Configuration.ConfigFile ?? string.Empty) ?? string.Empty);
 
-        configSection?.Bind(_configuration);
-        _configuration.ErrorsFile = Path.GetFullPath(ProxyUtils.ReplacePathTokens(_configuration.ErrorsFile ?? string.Empty), Path.GetDirectoryName(_proxyConfiguration?.ConfigFile ?? string.Empty) ?? string.Empty);
+        _loader = new GenericErrorResponsesLoader(Logger, _configuration);
 
-        _loader = new GenericErrorResponsesLoader(_logger!, _configuration);
-
-        pluginEvents.Init += OnInit;
-        pluginEvents.BeforeRequest += OnRequest;
-
-        // needed to get the failure rate configuration
-        // must keep reference of the whole config rather than just rate
-        // because rate is an int and can be set through command line args
-        // which is done after plugins have been registered
-        _proxyConfiguration = context.Configuration;
+        PluginEvents.Init += OnInit;
+        PluginEvents.BeforeRequest += OnRequest;
     }
 
     private void OnInit(object? sender, InitArgs e)
@@ -149,12 +137,12 @@ private Task OnRequest(object? sender, ProxyRequestArgs e)
     {
         var state = e.ResponseState;
         if (!e.ResponseState.HasBeenSet
-            && _urlsToWatch is not null
-            && e.ShouldExecute(_urlsToWatch))
+            && UrlsToWatch is not null
+            && e.ShouldExecute(UrlsToWatch))
         {
             var failMode = ShouldFail(e);
 
-            if (failMode == GenericRandomErrorFailMode.PassThru && _proxyConfiguration?.Rate != 100)
+            if (failMode == GenericRandomErrorFailMode.PassThru && Context.Configuration?.Rate != 100)
             {
                 return Task.CompletedTask;
             }
diff --git a/dev-proxy-plugins/RandomErrors/GraphRandomErrorPlugin.cs b/dev-proxy-plugins/RandomErrors/GraphRandomErrorPlugin.cs
index a0bf0cee..992dc702 100644
--- a/dev-proxy-plugins/RandomErrors/GraphRandomErrorPlugin.cs
+++ b/dev-proxy-plugins/RandomErrors/GraphRandomErrorPlugin.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
 using Microsoft.DevProxy.Abstractions;
 using System.CommandLine;
 using System.CommandLine.Invocation;
@@ -30,7 +31,6 @@ public class GraphRandomErrorPlugin : BaseProxyPlugin
 {
     private static readonly string _allowedErrorsOptionName = "--allowed-errors";
     private readonly GraphRandomErrorConfiguration _configuration = new();
-    private IProxyConfiguration? _proxyConfiguration;
 
     public override string Name => nameof(GraphRandomErrorPlugin);
 
@@ -85,15 +85,14 @@ public class GraphRandomErrorPlugin : BaseProxyPlugin
             }
         }
     };
-    private readonly Random _random;
+    private readonly Random _random = new();
 
-    public GraphRandomErrorPlugin()
+    public GraphRandomErrorPlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
     {
-        _random = new Random();
     }
 
     // uses config to determine if a request should be failed
-    private GraphRandomErrorFailMode ShouldFail(ProxyRequestArgs e) => _random.Next(1, 100) <= _proxyConfiguration?.Rate ? GraphRandomErrorFailMode.Random : GraphRandomErrorFailMode.PassThru;
+    private GraphRandomErrorFailMode ShouldFail(ProxyRequestArgs e) => _random.Next(1, 100) <= Context.Configuration.Rate ? GraphRandomErrorFailMode.Random : GraphRandomErrorFailMode.PassThru;
 
     private void FailResponse(ProxyRequestArgs e)
     {
@@ -194,7 +193,7 @@ private void UpdateProxyResponse(ProxyRequestArgs e, HttpStatusCode errorStatus)
             }),
             ProxyUtils.JsonSerializerOptions
         );
-        _logger?.LogRequest(new[] { $"{(int)errorStatus} {errorStatus.ToString()}" }, MessageType.Chaos, new LoggingContext(e.Session));
+        Logger.LogRequest(new[] { $"{(int)errorStatus} {errorStatus.ToString()}" }, MessageType.Chaos, new LoggingContext(e.Session));
         session.GenericResponse(body ?? string.Empty, errorStatus, headers.Select(h => new HttpHeader(h.Name, h.Value)));
     }
 
@@ -210,7 +209,7 @@ private void UpdateProxyBatchResponse(ProxyRequestArgs ev, GraphBatchResponsePay
         var headers = ProxyUtils.BuildGraphResponseHeaders(request, requestId, requestDate);
 
         string body = JsonSerializer.Serialize(response, ProxyUtils.JsonSerializerOptions);
-        _logger?.LogRequest(new[] { $"{(int)errorStatus} {errorStatus.ToString()}" }, MessageType.Chaos, new LoggingContext(ev.Session));
+        Logger.LogRequest(new[] { $"{(int)errorStatus} {errorStatus.ToString()}" }, MessageType.Chaos, new LoggingContext(ev.Session));
         session.GenericResponse(body, errorStatus, headers.Select(h => new HttpHeader(h.Name, h.Value)));
     }
 
@@ -228,22 +227,13 @@ public override Option[] GetOptions()
         return [_allowedErrors];
     }
 
-    public override void Register(IPluginEvents pluginEvents,
-                         IProxyContext context,
-                         ISet<UrlToWatch> urlsToWatch,
-                         IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        configSection?.Bind(_configuration);
-        pluginEvents.OptionsLoaded += OnOptionsLoaded;
-        pluginEvents.BeforeRequest += OnRequest;
-
-        // needed to get the failure rate configuration
-        // must keep reference of the whole config rather than just rate
-        // because rate is an int and can be set through command line args
-        // which is done after plugins have been registered
-        _proxyConfiguration = context.Configuration;
+        ConfigSection?.Bind(_configuration);
+        PluginEvents.OptionsLoaded += OnOptionsLoaded;
+        PluginEvents.BeforeRequest += OnRequest;
     }
 
     private void OnOptionsLoaded(object? sender, OptionsLoadedArgs e)
@@ -268,12 +258,12 @@ private Task OnRequest(object? sender, ProxyRequestArgs e)
     {
         var state = e.ResponseState;
         if (!e.ResponseState.HasBeenSet
-            && _urlsToWatch is not null
-            && e.ShouldExecute(_urlsToWatch))
+            && UrlsToWatch is not null
+            && e.ShouldExecute(UrlsToWatch))
         {
             var failMode = ShouldFail(e);
 
-            if (failMode == GraphRandomErrorFailMode.PassThru && _proxyConfiguration?.Rate != 100)
+            if (failMode == GraphRandomErrorFailMode.PassThru && Context.Configuration.Rate != 100)
             {
                 return Task.CompletedTask;
             }
diff --git a/dev-proxy-plugins/RandomErrors/LatencyPlugin.cs b/dev-proxy-plugins/RandomErrors/LatencyPlugin.cs
index d30761e8..82d6d929 100644
--- a/dev-proxy-plugins/RandomErrors/LatencyPlugin.cs
+++ b/dev-proxy-plugins/RandomErrors/LatencyPlugin.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
 using Microsoft.DevProxy.Abstractions;
 
 namespace Microsoft.DevProxy.Plugins.RandomErrors;
@@ -17,31 +18,27 @@ public class LatencyPlugin : BaseProxyPlugin
     private readonly LatencyConfiguration _configuration = new();
 
     public override string Name => nameof(LatencyPlugin);
-    private readonly Random _random;
+    private readonly Random _random = new();
 
-    public LatencyPlugin()
+    public LatencyPlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
     {
-        _random = new Random();
     }
 
-    public override void Register(IPluginEvents pluginEvents,
-                         IProxyContext context,
-                         ISet<UrlToWatch> urlsToWatch,
-                         IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        configSection?.Bind(_configuration);
-        pluginEvents.BeforeRequest += OnRequest;
+        ConfigSection?.Bind(_configuration);
+        PluginEvents.BeforeRequest += OnRequest;
     }
 
     private async Task OnRequest(object? sender, ProxyRequestArgs e)
     {
-        if (_urlsToWatch is not null
-            && e.ShouldExecute(_urlsToWatch))
+        if (UrlsToWatch is not null
+            && e.ShouldExecute(UrlsToWatch))
         {
             var delay = _random.Next(_configuration.MinMs, _configuration.MaxMs);
-            _logger?.LogRequest(new[] { $"Delaying request for {delay}ms" }, MessageType.Chaos, new LoggingContext(e.Session));
+            Logger.LogRequest([$"Delaying request for {delay}ms"], MessageType.Chaos, new LoggingContext(e.Session));
             await Task.Delay(delay);
         }
     }
diff --git a/dev-proxy-plugins/RequestLogs/ApiCenterOnboardingPlugin.cs b/dev-proxy-plugins/RequestLogs/ApiCenterOnboardingPlugin.cs
index 7379d61f..b9fb783a 100644
--- a/dev-proxy-plugins/RequestLogs/ApiCenterOnboardingPlugin.cs
+++ b/dev-proxy-plugins/RequestLogs/ApiCenterOnboardingPlugin.cs
@@ -64,30 +64,31 @@ public class ApiCenterOnboardingPlugin : BaseReportingPlugin
         PropertyNamingPolicy = JsonNamingPolicy.CamelCase
     };
 
+    public ApiCenterOnboardingPlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     public override string Name => nameof(ApiCenterOnboardingPlugin);
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        configSection?.Bind(_configuration);
+        ConfigSection?.Bind(_configuration);
 
         if (string.IsNullOrEmpty(_configuration.SubscriptionId))
         {
-            _logger?.LogError("Specify SubscriptionId in the {plugin} configuration. The {plugin} will not be used.", Name, Name);
+            Logger.LogError("Specify SubscriptionId in the {plugin} configuration. The {plugin} will not be used.", Name, Name);
             return;
         }
         if (string.IsNullOrEmpty(_configuration.ResourceGroupName))
         {
-            _logger?.LogError("Specify ResourceGroupName in the {plugin} configuration. The {plugin} will not be used.", Name, Name);
+            Logger.LogError("Specify ResourceGroupName in the {plugin} configuration. The {plugin} will not be used.", Name, Name);
             return;
         }
         if (string.IsNullOrEmpty(_configuration.ServiceName))
         {
-            _logger?.LogError("Specify ServiceName in the {plugin} configuration. The {plugin} will not be used.", Name, Name);
+            Logger.LogError("Specify ServiceName in the {plugin} configuration. The {plugin} will not be used.", Name, Name);
             return;
         }
 
@@ -109,7 +110,7 @@ public class ApiCenterOnboardingPlugin : BaseReportingPlugin
             _configuration.WorkspaceName = Environment.GetEnvironmentVariable(_configuration.WorkspaceName.Substring(1)) ?? _configuration.WorkspaceName;
         }
 
-        if (_logger?.LogLevel == LogLevel.Debug)
+        if (Logger.IsEnabled(LogLevel.Debug) == true)
         {
             var consoleListener = AzureEventSourceListener.CreateConsoleLogger(EventLevel.Verbose);
         }
@@ -119,39 +120,39 @@ public class ApiCenterOnboardingPlugin : BaseReportingPlugin
             InnerHandler = new HttpClientHandler()
         };
 
-        _logger?.LogDebug("Plugin {plugin} checking Azure auth...", Name);
+        Logger.LogDebug("Plugin {plugin} checking Azure auth...", Name);
         try
         {
             _ = authenticationHandler.GetAccessToken(CancellationToken.None).Result;
         }
         catch (Exception ex)
         {
-            _logger?.LogError(ex, "Failed to authenticate with Azure. The {plugin} will not be used.", Name);
+            Logger.LogError(ex, "Failed to authenticate with Azure. The {plugin} will not be used.", Name);
             return;
         }
-        _logger?.LogDebug("Plugin {plugin} auth confirmed...", Name);
+        Logger.LogDebug("Plugin {plugin} auth confirmed...", Name);
 
         _httpClient = new HttpClient(authenticationHandler);
 
-        pluginEvents.AfterRecordingStop += AfterRecordingStop;
+        PluginEvents.AfterRecordingStop += AfterRecordingStop;
     }
 
     private async Task AfterRecordingStop(object sender, RecordingArgs e)
     {
         if (!e.RequestLogs.Any())
         {
-            _logger?.LogDebug("No requests to process");
+            Logger.LogDebug("No requests to process");
             return;
         }
 
-        _logger?.LogInformation("Checking if recorded API requests belong to APIs in API Center...");
+        Logger.LogInformation("Checking if recorded API requests belong to APIs in API Center...");
 
         Debug.Assert(_httpClient is not null);
 
         var apis = await LoadApisFromApiCenter();
         if (apis == null || !apis.Value.Any())
         {
-            _logger?.LogInformation("No APIs found in API Center");
+            Logger.LogInformation("No APIs found in API Center");
             return;
         }
 
@@ -174,13 +175,13 @@ private async Task AfterRecordingStop(object sender, RecordingArgs e)
         {
             var (method, url) = request;
 
-            _logger?.LogDebug("Processing request {method} {url}...", method, url);
+            Logger.LogDebug("Processing request {method} {url}...", method, url);
 
             var apiDefinition = apiDefinitions.FirstOrDefault(x => url.StartsWith(x.Key, StringComparison.OrdinalIgnoreCase)).Value;
             if (apiDefinition is null ||
                 apiDefinition.Id is null)
             {
-                _logger?.LogDebug("No matching API definition not found for {url}. Adding new API...", url);
+                Logger.LogDebug("No matching API definition not found for {url}. Adding new API...", url);
                 newApis.Add((method, url));
                 continue;
             }
@@ -189,7 +190,7 @@ private async Task AfterRecordingStop(object sender, RecordingArgs e)
 
             if (apiDefinition.Definition is null)
             {
-                _logger?.LogDebug("API definition not found for {url} so nothing to compare to. Adding new API...", url);
+                Logger.LogDebug("API definition not found for {url} so nothing to compare to. Adding new API...", url);
                 newApis.Add(new(method, url));
                 continue;
             }
@@ -197,7 +198,7 @@ private async Task AfterRecordingStop(object sender, RecordingArgs e)
             var pathItem = FindMatchingPathItem(url, apiDefinition.Definition);
             if (pathItem is null)
             {
-                _logger?.LogDebug("No matching path found for {url}. Adding new API...", url);
+                Logger.LogDebug("No matching path found for {url}. Adding new API...", url);
                 newApis.Add(new(method, url));
                 continue;
             }
@@ -205,7 +206,7 @@ private async Task AfterRecordingStop(object sender, RecordingArgs e)
             var operation = pathItem.Operations.FirstOrDefault(x => x.Key.ToString().Equals(method, StringComparison.OrdinalIgnoreCase)).Value;
             if (operation is null)
             {
-                _logger?.LogDebug("No matching operation found for {method} {url}. Adding new API...", method, url);
+                Logger.LogDebug("No matching operation found for {method} {url}. Adding new API...", method, url);
 
                 newApis.Add(new(method, url));
                 continue;
@@ -221,7 +222,7 @@ private async Task AfterRecordingStop(object sender, RecordingArgs e)
 
         if (!newApis.Any())
         {
-            _logger?.LogInformation("No new APIs found");
+            Logger.LogInformation("No new APIs found");
             StoreReport(new ApiCenterOnboardingPluginReport
             {
                 ExistingApis = existingApis.ToArray(),
@@ -256,7 +257,7 @@ private async Task AfterRecordingStop(object sender, RecordingArgs e)
             newApisMessageChunks.AddRange(apiPerHost.Select(a => $"  {a.method} {a.url}"));
         }
 
-        _logger?.LogInformation(string.Join(Environment.NewLine, newApisMessageChunks));
+        Logger.LogInformation(string.Join(Environment.NewLine, newApisMessageChunks));
 
         if (!_configuration.CreateApicEntryForNewApis)
         {
@@ -271,7 +272,7 @@ async Task CreateApisInApiCenter(IEnumerable<IGrouping<string, (string method, s
     {
         Debug.Assert(_httpClient is not null);
 
-        _logger?.LogInformation("{newLine}Creating new API entries in API Center...", Environment.NewLine);
+        Logger.LogInformation("{newLine}Creating new API entries in API Center...", Environment.NewLine);
 
         foreach (var apiPerHost in apisPerHost)
         {
@@ -287,7 +288,7 @@ async Task CreateApisInApiCenter(IEnumerable<IGrouping<string, (string method, s
 
             if (!generatedOpenApiSpecs.TryGetValue(schemeAndHost, out var openApiSpecFilePath))
             {
-                _logger?.LogDebug("No OpenAPI spec found for {host}", schemeAndHost);
+                Logger.LogDebug("No OpenAPI spec found for {host}", schemeAndHost);
                 continue;
             }
 
@@ -317,7 +318,7 @@ async Task CreateApisInApiCenter(IEnumerable<IGrouping<string, (string method, s
 
         // trim to 50 chars which is max length for API name
         var apiName = MaxLength($"new-{schemeAndHost.Replace(".", "-").Replace("http://", "").Replace("https://", "")}-{DateTimeOffset.UtcNow.ToUnixTimeSeconds()}", 50);
-        _logger?.LogInformation("  Creating API {apiName} for {host}...", apiName, schemeAndHost);
+        Logger.LogInformation("  Creating API {apiName} for {host}...", apiName, schemeAndHost);
 
         var title = $"New APIs: {schemeAndHost}";
         var description = new List<string>(["New APIs discovered by Dev Proxy", ""]);
@@ -336,14 +337,14 @@ async Task CreateApisInApiCenter(IEnumerable<IGrouping<string, (string method, s
         var res = await _httpClient.PutAsync($"https://management.azure.com/subscriptions/{_configuration.SubscriptionId}/resourceGroups/{_configuration.ResourceGroupName}/providers/Microsoft.ApiCenter/services/{_configuration.ServiceName}/workspaces/{_configuration.WorkspaceName}/apis/{apiName}?api-version=2024-03-01", content);
         if (res.IsSuccessStatusCode)
         {
-            _logger?.LogDebug("API created successfully");
+            Logger.LogDebug("API created successfully");
         }
         else
         {
-            _logger?.LogError("Failed to create API {apiName} for {host}", apiName, schemeAndHost);
+            Logger.LogError("Failed to create API {apiName} for {host}", apiName, schemeAndHost);
         }
         var resContent = await res.Content.ReadAsStringAsync();
-        _logger?.LogDebug(resContent);
+        Logger.LogDebug(resContent);
 
         if (res.IsSuccessStatusCode)
         {
@@ -359,7 +360,7 @@ async Task CreateApisInApiCenter(IEnumerable<IGrouping<string, (string method, s
     {
         Debug.Assert(_httpClient is not null);
 
-        _logger?.LogDebug("  Creating API version for {api}...", apiId);
+        Logger.LogDebug("  Creating API version for {api}...", apiId);
 
         var payload = new
         {
@@ -373,14 +374,14 @@ async Task CreateApisInApiCenter(IEnumerable<IGrouping<string, (string method, s
         var res = await _httpClient.PutAsync($"https://management.azure.com{apiId}/versions/v1-0?api-version=2024-03-01", content);
         if (res.IsSuccessStatusCode)
         {
-            _logger?.LogDebug("API version created successfully");
+            Logger.LogDebug("API version created successfully");
         }
         else
         {
-            _logger?.LogError("Failed to create API version for {api}", apiId.Substring(apiId.LastIndexOf('/')));
+            Logger.LogError("Failed to create API version for {api}", apiId.Substring(apiId.LastIndexOf('/')));
         }
         var resContent = await res.Content.ReadAsStringAsync();
-        _logger?.LogDebug(resContent);
+        Logger.LogDebug(resContent);
 
         if (res.IsSuccessStatusCode)
         {
@@ -396,7 +397,7 @@ async Task CreateApisInApiCenter(IEnumerable<IGrouping<string, (string method, s
     {
         Debug.Assert(_httpClient is not null);
 
-        _logger?.LogDebug("  Creating API definition for {api}...", apiVersionId);
+        Logger.LogDebug("  Creating API definition for {api}...", apiVersionId);
 
         var payload = new
         {
@@ -409,14 +410,14 @@ async Task CreateApisInApiCenter(IEnumerable<IGrouping<string, (string method, s
         var res = await _httpClient.PutAsync($"https://management.azure.com{apiVersionId}/definitions/openapi?api-version=2024-03-01", content);
         if (res.IsSuccessStatusCode)
         {
-            _logger?.LogDebug("API definition created successfully");
+            Logger.LogDebug("API definition created successfully");
         }
         else
         {
-            _logger?.LogError("Failed to create API definition for {apiVersion}", apiVersionId);
+            Logger.LogError("Failed to create API definition for {apiVersion}", apiVersionId);
         }
         var resContent = await res.Content.ReadAsStringAsync();
-        _logger?.LogDebug(resContent);
+        Logger.LogDebug(resContent);
 
         if (res.IsSuccessStatusCode)
         {
@@ -432,7 +433,7 @@ async Task ImportApiDefinition(string apiDefinitionId, string openApiSpecFilePat
     {
         Debug.Assert(_httpClient is not null);
 
-        _logger?.LogDebug("  Importing API definition for {api}...", apiDefinitionId);
+        Logger.LogDebug("  Importing API definition for {api}...", apiDefinitionId);
 
         var openApiSpec = File.ReadAllText(openApiSpecFilePath);
         var payload = new
@@ -449,11 +450,11 @@ async Task ImportApiDefinition(string apiDefinitionId, string openApiSpecFilePat
         var res = await _httpClient.PostAsync($"https://management.azure.com{apiDefinitionId}/importSpecification?api-version=2024-03-01", content);
         if (res.IsSuccessStatusCode)
         {
-            _logger?.LogDebug("API definition imported successfully");
+            Logger.LogDebug("API definition imported successfully");
         }
         else
         {
-            _logger?.LogError("Failed to import API definition for {apiDefinition}. Status: {status}, reason: {reason}", apiDefinitionId, res.StatusCode, res.ReasonPhrase);
+            Logger.LogError("Failed to import API definition for {apiDefinition}. Status: {status}, reason: {reason}", apiDefinitionId, res.StatusCode, res.ReasonPhrase);
         }
     }
 
@@ -461,7 +462,7 @@ async Task ImportApiDefinition(string apiDefinitionId, string openApiSpecFilePat
     {
         Debug.Assert(_httpClient is not null);
 
-        _logger?.LogInformation("Loading APIs from API Center...");
+        Logger.LogInformation("Loading APIs from API Center...");
 
         var res = await _httpClient.GetStringAsync($"https://management.azure.com/subscriptions/{_configuration.SubscriptionId}/resourceGroups/{_configuration.ResourceGroupName}/providers/Microsoft.ApiCenter/services/{_configuration.ServiceName}/workspaces/{_configuration.WorkspaceName}/apis?api-version=2024-03-01");
         return JsonSerializer.Deserialize<Collection<Api>>(res, _jsonSerializerOptions);
@@ -471,11 +472,11 @@ async Task ImportApiDefinition(string apiDefinitionId, string openApiSpecFilePat
     {
         foreach (var server in openApiDocument.Servers)
         {
-            _logger?.LogDebug("Checking server URL {serverUrl}...", server.Url);
+            Logger.LogDebug("Checking server URL {serverUrl}...", server.Url);
 
             if (!requestUrl.StartsWith(server.Url, StringComparison.OrdinalIgnoreCase))
             {
-                _logger?.LogDebug("Request URL {requestUrl} does not match server URL {serverUrl}", requestUrl, server.Url);
+                Logger.LogDebug("Request URL {requestUrl} does not match server URL {serverUrl}", requestUrl, server.Url);
                 continue;
             }
 
@@ -487,13 +488,13 @@ async Task ImportApiDefinition(string apiDefinitionId, string openApiSpecFilePat
             foreach (var path in openApiDocument.Paths)
             {
                 var urlPathFromSpec = path.Key;
-                _logger?.LogDebug("Checking path {urlPath}...", urlPathFromSpec);
+                Logger.LogDebug("Checking path {urlPath}...", urlPathFromSpec);
 
                 // check if path contains parameters. If it does,
                 // replace them with regex
                 if (urlPathFromSpec.Contains('{'))
                 {
-                    _logger?.LogDebug("Path {urlPath} contains parameters and will be converted to Regex", urlPathFromSpec);
+                    Logger.LogDebug("Path {urlPath} contains parameters and will be converted to Regex", urlPathFromSpec);
 
                     // force replace all parameters with regex
                     // this is more robust than replacing parameters by name
@@ -503,27 +504,27 @@ async Task ImportApiDefinition(string apiDefinitionId, string openApiSpecFilePat
                     // care about the parameter anyway here
                     urlPathFromSpec = Regex.Replace(urlPathFromSpec, @"\{[^}]+\}", $"([^/]+)");
 
-                    _logger?.LogDebug("Converted path to Regex: {urlPath}", urlPathFromSpec);
+                    Logger.LogDebug("Converted path to Regex: {urlPath}", urlPathFromSpec);
                     var regex = new Regex($"^{urlPathFromSpec}$");
                     if (regex.IsMatch(urlPathFromRequest))
                     {
-                        _logger?.LogDebug("Regex matches {requestUrl}", urlPathFromRequest);
+                        Logger.LogDebug("Regex matches {requestUrl}", urlPathFromRequest);
 
                         return path.Value;
                     }
 
-                    _logger?.LogDebug("Regex does not match {requestUrl}", urlPathFromRequest);
+                    Logger.LogDebug("Regex does not match {requestUrl}", urlPathFromRequest);
                 }
                 else
                 {
                     if (urlPathFromRequest.Equals(urlPathFromSpec, StringComparison.OrdinalIgnoreCase))
                     {
-                        _logger?.LogDebug("{requestUrl} matches {urlPath}", requestUrl, urlPathFromSpec);
+                        Logger.LogDebug("{requestUrl} matches {urlPath}", requestUrl, urlPathFromSpec);
 
                         return path.Value;
                     }
 
-                    _logger?.LogDebug("{requestUrl} doesn't match {urlPath}", requestUrl, urlPathFromSpec);
+                    Logger.LogDebug("{requestUrl} doesn't match {urlPath}", requestUrl, urlPathFromSpec);
                 }
             }
         }
@@ -533,7 +534,7 @@ async Task ImportApiDefinition(string apiDefinitionId, string openApiSpecFilePat
 
     async Task<Dictionary<string, ApiDefinition>> LoadApiDefinitions(Api[] apis)
     {
-        _logger?.LogInformation("Loading API definitions from API Center...");
+        Logger.LogInformation("Loading API definitions from API Center...");
 
         // key is the runtime URI, value is the API definition
         var apiDefinitions = new Dictionary<string, ApiDefinition>();
@@ -542,7 +543,7 @@ async Task ImportApiDefinition(string apiDefinitionId, string openApiSpecFilePat
         {
             Debug.Assert(api.Id is not null);
 
-            _logger?.LogDebug("Loading API definitions for {apiName}...", api.Id);
+            Logger.LogDebug("Loading API definitions for {apiName}...", api.Id);
 
             // load definitions from deployments
             var deployments = await LoadApiDeployments(api.Id);
@@ -555,7 +556,7 @@ async Task ImportApiDefinition(string apiDefinitionId, string openApiSpecFilePat
 
                     if (!deployment.Properties.Server.RuntimeUri.Any())
                     {
-                        _logger?.LogDebug("No runtime URIs found for deployment {deploymentName}", deployment.Name);
+                        Logger.LogDebug("No runtime URIs found for deployment {deploymentName}", deployment.Name);
                         continue;
                     }
 
@@ -570,7 +571,7 @@ async Task ImportApiDefinition(string apiDefinitionId, string openApiSpecFilePat
             }
             else
             {
-                _logger?.LogDebug("No deployments found for API {api}", api.Id);
+                Logger.LogDebug("No deployments found for API {api}", api.Id);
             }
 
             // load definitions from versions
@@ -592,13 +593,13 @@ async Task ImportApiDefinition(string apiDefinitionId, string openApiSpecFilePat
 
                             if (definition.Definition is null)
                             {
-                                _logger?.LogDebug("API definition not found for {definitionId}", definition.Id);
+                                Logger.LogDebug("API definition not found for {definitionId}", definition.Id);
                                 continue;
                             }
 
                             if (!definition.Definition.Servers.Any())
                             {
-                                _logger?.LogDebug("No servers found for API definition {definitionId}", definition.Id);
+                                Logger.LogDebug("No servers found for API definition {definitionId}", definition.Id);
                                 continue;
                             }
 
@@ -610,13 +611,13 @@ async Task ImportApiDefinition(string apiDefinitionId, string openApiSpecFilePat
                     }
                     else
                     {
-                        _logger?.LogDebug("No definitions found for version {versionId}", version.Id);
+                        Logger.LogDebug("No definitions found for version {versionId}", version.Id);
                     }
                 }
             }
             else
             {
-                _logger?.LogDebug("No versions found for API {api}", api.Id);
+                Logger.LogDebug("No versions found for API {api}", api.Id);
             }
         }
 
@@ -627,7 +628,7 @@ async Task ImportApiDefinition(string apiDefinitionId, string openApiSpecFilePat
     {
         Debug.Assert(_httpClient is not null);
 
-        _logger?.LogDebug("Loading API definitions for version {id}...", versionId);
+        Logger.LogDebug("Loading API definitions for version {id}...", versionId);
 
         var res = await _httpClient.GetStringAsync($"https://management.azure.com{versionId}/definitions?api-version=2024-03-01");
         return JsonSerializer.Deserialize<Collection<ApiDefinition>>(res, _jsonSerializerOptions);
@@ -637,7 +638,7 @@ async Task ImportApiDefinition(string apiDefinitionId, string openApiSpecFilePat
     {
         Debug.Assert(_httpClient is not null);
 
-        _logger?.LogDebug("Loading API versions for {apiName}...", apiId);
+        Logger.LogDebug("Loading API versions for {apiName}...", apiId);
 
         var res = await _httpClient.GetStringAsync($"https://management.azure.com{apiId}/versions?api-version=2024-03-01");
         return JsonSerializer.Deserialize<Collection<ApiVersion>>(res, _jsonSerializerOptions);
@@ -647,7 +648,7 @@ async Task ImportApiDefinition(string apiDefinitionId, string openApiSpecFilePat
     {
         Debug.Assert(_httpClient is not null);
 
-        _logger?.LogDebug("Loading API deployments for {apiName}...", apiId);
+        Logger.LogDebug("Loading API deployments for {apiName}...", apiId);
 
         var res = await _httpClient.GetStringAsync($"https://management.azure.com{apiId}/deployments?api-version=2024-03-01");
         return JsonSerializer.Deserialize<Collection<ApiDeployment>>(res, _jsonSerializerOptions);
@@ -659,24 +660,24 @@ async Task EnsureApiDefinition(ApiDefinition apiDefinition)
 
         if (apiDefinition.Definition is not null)
         {
-            _logger?.LogDebug("API definition already loaded for {apiDefinitionId}", apiDefinition.Id);
+            Logger.LogDebug("API definition already loaded for {apiDefinitionId}", apiDefinition.Id);
             return;
         }
 
-        _logger?.LogDebug("Loading API definition for {apiDefinitionId}...", apiDefinition.Id);
+        Logger.LogDebug("Loading API definition for {apiDefinitionId}...", apiDefinition.Id);
 
         var res = await _httpClient.GetStringAsync($"https://management.azure.com{apiDefinition.Id}?api-version=2024-03-01");
         var definition = JsonSerializer.Deserialize<ApiDefinition>(res, _jsonSerializerOptions);
         if (definition is null)
         {
-            _logger?.LogError("Failed to deserialize API definition for {apiDefinitionId}", apiDefinition.Id);
+            Logger.LogError("Failed to deserialize API definition for {apiDefinitionId}", apiDefinition.Id);
             return;
         }
 
         apiDefinition.Properties = definition.Properties;
         if (apiDefinition.Properties?.Specification?.Name != "openapi")
         {
-            _logger?.LogDebug("API definition is not OpenAPI for {apiDefinitionId}", apiDefinition.Id);
+            Logger.LogDebug("API definition is not OpenAPI for {apiDefinitionId}", apiDefinition.Id);
             return;
         }
 
@@ -684,13 +685,13 @@ async Task EnsureApiDefinition(ApiDefinition apiDefinition)
         var exportResult = await definitionRes.Content.ReadFromJsonAsync<ApiSpecExportResult>();
         if (exportResult is null)
         {
-            _logger?.LogError("Failed to deserialize exported API definition for {apiDefinitionId}", apiDefinition.Id);
+            Logger.LogError("Failed to deserialize exported API definition for {apiDefinitionId}", apiDefinition.Id);
             return;
         }
 
         if (exportResult.Format != ApiSpecExportResultFormat.Inline)
         {
-            _logger?.LogDebug("API definition is not inline for {apiDefinitionId}", apiDefinition.Id);
+            Logger.LogDebug("API definition is not inline for {apiDefinitionId}", apiDefinition.Id);
             return;
         }
 
@@ -700,7 +701,7 @@ async Task EnsureApiDefinition(ApiDefinition apiDefinition)
         }
         catch (Exception ex)
         {
-            _logger?.LogError(ex, "Failed to parse OpenAPI document for {apiDefinitionId}", apiDefinition.Id);
+            Logger.LogError(ex, "Failed to parse OpenAPI document for {apiDefinitionId}", apiDefinition.Id);
             return;
         }
     }
diff --git a/dev-proxy-plugins/RequestLogs/ApiCenterProductionVersionPlugin.cs b/dev-proxy-plugins/RequestLogs/ApiCenterProductionVersionPlugin.cs
index 5b44e173..bd1eb4f4 100644
--- a/dev-proxy-plugins/RequestLogs/ApiCenterProductionVersionPlugin.cs
+++ b/dev-proxy-plugins/RequestLogs/ApiCenterProductionVersionPlugin.cs
@@ -73,30 +73,31 @@ public class ApiCenterProductionVersionPlugin : BaseReportingPlugin
         PropertyNamingPolicy = JsonNamingPolicy.CamelCase
     };
 
+    public ApiCenterProductionVersionPlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     public override string Name => nameof(ApiCenterProductionVersionPlugin);
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        configSection?.Bind(_configuration);
+        ConfigSection?.Bind(_configuration);
 
         if (string.IsNullOrEmpty(_configuration.SubscriptionId))
         {
-            _logger?.LogError("Specify SubscriptionId in the ApiCenterProductionVersionPlugin configuration. The ApiCenterProductionVersionPlugin will not be used.");
+            Logger.LogError("Specify SubscriptionId in the ApiCenterProductionVersionPlugin configuration. The ApiCenterProductionVersionPlugin will not be used.");
             return;
         }
         if (string.IsNullOrEmpty(_configuration.ResourceGroupName))
         {
-            _logger?.LogError("Specify ResourceGroupName in the ApiCenterProductionVersionPlugin configuration. The ApiCenterProductionVersionPlugin will not be used.");
+            Logger.LogError("Specify ResourceGroupName in the ApiCenterProductionVersionPlugin configuration. The ApiCenterProductionVersionPlugin will not be used.");
             return;
         }
         if (string.IsNullOrEmpty(_configuration.ServiceName))
         {
-            _logger?.LogError("Specify ServiceName in the ApiCenterProductionVersionPlugin configuration. The ApiCenterProductionVersionPlugin will not be used.");
+            Logger.LogError("Specify ServiceName in the ApiCenterProductionVersionPlugin configuration. The ApiCenterProductionVersionPlugin will not be used.");
             return;
         }
 
@@ -118,7 +119,7 @@ public class ApiCenterProductionVersionPlugin : BaseReportingPlugin
             _configuration.WorkspaceName = Environment.GetEnvironmentVariable(_configuration.WorkspaceName.Substring(1)) ?? _configuration.WorkspaceName;
         }
 
-        if (_logger?.LogLevel == LogLevel.Debug)
+        if (Logger.IsEnabled(LogLevel.Debug) == true)
         {
             var consoleListener = AzureEventSourceListener.CreateConsoleLogger(EventLevel.Verbose);
         }
@@ -128,7 +129,7 @@ public class ApiCenterProductionVersionPlugin : BaseReportingPlugin
             InnerHandler = new HttpClientHandler()
         };
         
-        _logger?.LogDebug("Plugin {plugin} checking Azure auth...", Name);
+        Logger.LogDebug("Plugin {plugin} checking Azure auth...", Name);
         
         try
         {
@@ -136,14 +137,14 @@ public class ApiCenterProductionVersionPlugin : BaseReportingPlugin
         }
         catch (Exception ex)
         {
-            _logger?.LogError(ex, "Failed to authenticate with Azure. The {plugin} will not be used.", Name);
+            Logger.LogError(ex, "Failed to authenticate with Azure. The {plugin} will not be used.", Name);
             return;
         }
-        _logger?.LogDebug("Plugin {plugin} auth confirmed...", Name);
+        Logger.LogDebug("Plugin {plugin} auth confirmed...", Name);
 
         _httpClient = new HttpClient(authenticationHandler);
 
-        pluginEvents.AfterRecordingStop += AfterRecordingStop;
+        PluginEvents.AfterRecordingStop += AfterRecordingStop;
     }
 
     private async Task AfterRecordingStop(object sender, RecordingArgs e)
@@ -155,18 +156,18 @@ private async Task AfterRecordingStop(object sender, RecordingArgs e)
             );
         if (!interceptedRequests.Any())
         {
-            _logger?.LogDebug("No requests to process");
+            Logger.LogDebug("No requests to process");
             return;
         }
 
-        _logger?.LogInformation("Checking if recorded API requests use production APIs as defined in API Center...");
+        Logger.LogInformation("Checking if recorded API requests use production APIs as defined in API Center...");
 
         Debug.Assert(_httpClient is not null);
 
         var apisFromApiCenter = await LoadApisFromApiCenter();
         if (apisFromApiCenter == null || !apisFromApiCenter.Value.Any())
         {
-            _logger?.LogInformation("No APIs found in API Center");
+            Logger.LogInformation("No APIs found in API Center");
             return;
         }
 
@@ -176,7 +177,7 @@ private async Task AfterRecordingStop(object sender, RecordingArgs e)
             var apiVersionsFromApiCenter = await LoadApiVersionsFromApiCenter(api);
             if (apiVersionsFromApiCenter == null || !apiVersionsFromApiCenter.Value.Any())
             {
-                _logger?.LogInformation("No versions found for {api}", api.Properties?.Title);
+                Logger.LogInformation("No versions found for {api}", api.Properties?.Title);
                 continue;
             }
 
@@ -188,7 +189,7 @@ private async Task AfterRecordingStop(object sender, RecordingArgs e)
                 var definitionsFromApiCenter = await LoadApiDefinitionsForVersion(versionFromApiCenter.Id);
                 if (definitionsFromApiCenter is null || !definitionsFromApiCenter.Value.Any())
                 {
-                    _logger?.LogDebug("No definitions found for version {versionId}", versionFromApiCenter.Id);
+                    Logger.LogDebug("No definitions found for version {versionId}", versionFromApiCenter.Id);
                     continue;
                 }
 
@@ -201,13 +202,13 @@ private async Task AfterRecordingStop(object sender, RecordingArgs e)
 
                     if (definitionFromApiCenter.Definition is null)
                     {
-                        _logger?.LogDebug("API definition not found for {definitionId}", definitionFromApiCenter.Id);
+                        Logger.LogDebug("API definition not found for {definitionId}", definitionFromApiCenter.Id);
                         continue;
                     }
 
                     if (!definitionFromApiCenter.Definition.Servers.Any())
                     {
-                        _logger?.LogDebug("No servers found for API definition {definitionId}", definitionFromApiCenter.Id);
+                        Logger.LogDebug("No servers found for API definition {definitionId}", definitionFromApiCenter.Id);
                         continue;
                     }
 
@@ -219,7 +220,7 @@ private async Task AfterRecordingStop(object sender, RecordingArgs e)
 
                 if (!apiUrls.Any())
                 {
-                    _logger?.LogDebug("No URLs found for version {versionId}", versionFromApiCenter.Id);
+                    Logger.LogDebug("No URLs found for version {versionId}", versionFromApiCenter.Id);
                     continue;
                 }
 
@@ -234,7 +235,7 @@ private async Task AfterRecordingStop(object sender, RecordingArgs e)
 
             if (!versions.Any())
             {
-                _logger?.LogInformation("No versions found for {api}", api.Properties?.Title);
+                Logger.LogInformation("No versions found for {api}", api.Properties?.Title);
                 continue;
             }
 
@@ -245,7 +246,7 @@ private async Task AfterRecordingStop(object sender, RecordingArgs e)
             });
         }
 
-        _logger?.LogInformation("Analyzing recorded requests...");
+        Logger.LogInformation("Analyzing recorded requests...");
 
         var report = new ApiCenterProductionVersionPluginReport();
 
@@ -293,7 +294,7 @@ private async Task AfterRecordingStop(object sender, RecordingArgs e)
                     string.Format("Request {0} uses API version {1} which is defined as {2}. Upgrade to a production version of the API. Recommended versions: {3}", methodAndUrlString, apiInformation.Versions.First(v => v.LifecycleStage == lifecycleStage).Title, lifecycleStage, string.Join(", ", productionVersions)) :
                     string.Format("Request {0} uses API version {1} which is defined as {2}.", methodAndUrlString, apiInformation.Versions.First(v => v.LifecycleStage == lifecycleStage).Title, lifecycleStage);
 
-                _logger?.LogWarning(recommendation);
+                Logger.LogWarning(recommendation);
                 report.Add(new()
                 {
                     Method = methodAndUrl[0],
@@ -320,7 +321,7 @@ private async Task AfterRecordingStop(object sender, RecordingArgs e)
     {
         Debug.Assert(_httpClient is not null);
 
-        _logger?.LogDebug("Loading API definitions for version {id}...", versionId);
+        Logger.LogDebug("Loading API definitions for version {id}...", versionId);
 
         var res = await _httpClient.GetStringAsync($"https://management.azure.com{versionId}/definitions?api-version=2024-03-01");
         return JsonSerializer.Deserialize<Collection<ApiDefinition>>(res, _jsonSerializerOptions);
@@ -332,24 +333,24 @@ async Task EnsureApiDefinition(ApiDefinition apiDefinition)
 
         if (apiDefinition.Definition is not null)
         {
-            _logger?.LogDebug("API definition already loaded for {apiDefinitionId}", apiDefinition.Id);
+            Logger.LogDebug("API definition already loaded for {apiDefinitionId}", apiDefinition.Id);
             return;
         }
 
-        _logger?.LogDebug("Loading API definition for {apiDefinitionId}...", apiDefinition.Id);
+        Logger.LogDebug("Loading API definition for {apiDefinitionId}...", apiDefinition.Id);
 
         var res = await _httpClient.GetStringAsync($"https://management.azure.com{apiDefinition.Id}?api-version=2024-03-01");
         var definition = JsonSerializer.Deserialize<ApiDefinition>(res, _jsonSerializerOptions);
         if (definition is null)
         {
-            _logger?.LogError("Failed to deserialize API definition for {apiDefinitionId}", apiDefinition.Id);
+            Logger.LogError("Failed to deserialize API definition for {apiDefinitionId}", apiDefinition.Id);
             return;
         }
 
         apiDefinition.Properties = definition.Properties;
         if (apiDefinition.Properties?.Specification?.Name != "openapi")
         {
-            _logger?.LogDebug("API definition is not OpenAPI for {apiDefinitionId}", apiDefinition.Id);
+            Logger.LogDebug("API definition is not OpenAPI for {apiDefinitionId}", apiDefinition.Id);
             return;
         }
 
@@ -357,13 +358,13 @@ async Task EnsureApiDefinition(ApiDefinition apiDefinition)
         var exportResult = await definitionRes.Content.ReadFromJsonAsync<ApiSpecExportResult>();
         if (exportResult is null)
         {
-            _logger?.LogError("Failed to deserialize exported API definition for {apiDefinitionId}", apiDefinition.Id);
+            Logger.LogError("Failed to deserialize exported API definition for {apiDefinitionId}", apiDefinition.Id);
             return;
         }
 
         if (exportResult.Format != ApiSpecExportResultFormat.Inline)
         {
-            _logger?.LogDebug("API definition is not inline for {apiDefinitionId}", apiDefinition.Id);
+            Logger.LogDebug("API definition is not inline for {apiDefinitionId}", apiDefinition.Id);
             return;
         }
 
@@ -373,7 +374,7 @@ async Task EnsureApiDefinition(ApiDefinition apiDefinition)
         }
         catch (Exception ex)
         {
-            _logger?.LogError(ex, "Failed to parse OpenAPI document for {apiDefinitionId}", apiDefinition.Id);
+            Logger.LogError(ex, "Failed to parse OpenAPI document for {apiDefinitionId}", apiDefinition.Id);
             return;
         }
     }
@@ -383,11 +384,11 @@ async Task EnsureApiDefinition(ApiDefinition apiDefinition)
         var apiInformation = apisInformation?.FirstOrDefault(a => a.Versions.Any(v => v.Urls.Any(u => requestUrl.StartsWith(u))));
         if (apiInformation is null)
         {
-            _logger?.LogDebug("No matching API found for {request}", requestUrl);
+            Logger.LogDebug("No matching API found for {request}", requestUrl);
         }
         else
         {
-            _logger?.LogDebug("Found matching API information for {request}", requestUrl);
+            Logger.LogDebug("Found matching API information for {request}", requestUrl);
         }
 
         return apiInformation;
@@ -404,7 +405,7 @@ async Task EnsureApiDefinition(ApiDefinition apiDefinition)
             // check URL
             if (requestUrl.Contains(apiVersion.Name) || requestUrl.Contains(apiVersion.Title))
             {
-                _logger?.LogDebug("Version {version} found in URL {url}", $"{apiVersion.Name}/{apiVersion.Title}", requestUrl);
+                Logger.LogDebug("Version {version} found in URL {url}", $"{apiVersion.Name}/{apiVersion.Title}", requestUrl);
                 version = apiVersion;
                 break;
             }
@@ -417,7 +418,7 @@ async Task EnsureApiDefinition(ApiDefinition apiDefinition)
             );
             if (header is not null)
             {
-                _logger?.LogDebug("Version {version} found in header {header}", $"{apiVersion.Name}/{apiVersion.Title}", header.Name);
+                Logger.LogDebug("Version {version} found in header {header}", $"{apiVersion.Name}/{apiVersion.Title}", header.Name);
                 version = apiVersion;
                 break;
             }
@@ -425,7 +426,7 @@ async Task EnsureApiDefinition(ApiDefinition apiDefinition)
 
         if (version is null)
         {
-            _logger?.LogDebug("No matching version found for {request}", requestUrl);
+            Logger.LogDebug("No matching version found for {request}", requestUrl);
             return null;
         }
 
@@ -436,7 +437,7 @@ async Task EnsureApiDefinition(ApiDefinition apiDefinition)
     {
         Debug.Assert(_httpClient is not null);
 
-        _logger?.LogDebug("Loading versions for {api}...", api.Properties?.Title);
+        Logger.LogDebug("Loading versions for {api}...", api.Properties?.Title);
 
         var res = await _httpClient.GetStringAsync($"https://management.azure.com{api.Id}/versions?api-version=2024-03-01");
         return JsonSerializer.Deserialize<Collection<ApiVersion>>(res, _jsonSerializerOptions);
@@ -446,7 +447,7 @@ async Task EnsureApiDefinition(ApiDefinition apiDefinition)
     {
         Debug.Assert(_httpClient is not null);
 
-        _logger?.LogInformation("Loading APIs from API Center...");
+        Logger.LogInformation("Loading APIs from API Center...");
 
         var res = await _httpClient.GetStringAsync($"https://management.azure.com/subscriptions/{_configuration.SubscriptionId}/resourceGroups/{_configuration.ResourceGroupName}/providers/Microsoft.ApiCenter/services/{_configuration.ServiceName}/workspaces/{_configuration.WorkspaceName}/apis?api-version=2024-03-01");
         return JsonSerializer.Deserialize<Collection<Api>>(res, _jsonSerializerOptions);
@@ -456,7 +457,7 @@ async Task EnsureApiDefinition(ApiDefinition apiDefinition)
     {
         Debug.Assert(_httpClient is not null);
 
-        _logger?.LogDebug("Loading API deployments for {api}...", api.Properties?.Title);
+        Logger.LogDebug("Loading API deployments for {api}...", api.Properties?.Title);
 
         var res = await _httpClient.GetStringAsync($"https://management.azure.com{api.Id}/deployments?api-version=2024-03-01");
         return JsonSerializer.Deserialize<Collection<ApiDeployment>>(res, _jsonSerializerOptions);
diff --git a/dev-proxy-plugins/RequestLogs/ExecutionSummaryPlugin.cs b/dev-proxy-plugins/RequestLogs/ExecutionSummaryPlugin.cs
index fa72b845..a915aa99 100644
--- a/dev-proxy-plugins/RequestLogs/ExecutionSummaryPlugin.cs
+++ b/dev-proxy-plugins/RequestLogs/ExecutionSummaryPlugin.cs
@@ -5,6 +5,7 @@
 using Microsoft.DevProxy.Abstractions;
 using System.CommandLine;
 using System.CommandLine.Invocation;
+using Microsoft.Extensions.Logging;
 
 namespace Microsoft.DevProxy.Plugins.RequestLogs;
 
@@ -36,6 +37,10 @@ public class ExecutionSummaryPlugin : BaseReportingPlugin
     private const string _requestsInterceptedMessage = "Requests intercepted";
     private const string _requestsPassedThroughMessage = "Requests passed through";
 
+    public ExecutionSummaryPlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     public override Option[] GetOptions()
     {
         var groupBy = new Option<SummaryGroupBy?>(_groupByOptionName, "Specifies how the information should be grouped in the summary. Available options: `url` (default), `messageType`.")
@@ -53,17 +58,14 @@ public override Option[] GetOptions()
         return [groupBy];
     }
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        configSection?.Bind(_configuration);
+        ConfigSection?.Bind(_configuration);
 
-        pluginEvents.OptionsLoaded += OnOptionsLoaded;
-        pluginEvents.AfterRecordingStop += AfterRecordingStop;
+        PluginEvents.OptionsLoaded += OnOptionsLoaded;
+        PluginEvents.AfterRecordingStop += AfterRecordingStop;
     }
 
     private void OnOptionsLoaded(object? sender, OptionsLoadedArgs e)
diff --git a/dev-proxy-plugins/RequestLogs/MinimalPermissionsGuidancePlugin.cs b/dev-proxy-plugins/RequestLogs/MinimalPermissionsGuidancePlugin.cs
index 09be4a1a..212032f3 100644
--- a/dev-proxy-plugins/RequestLogs/MinimalPermissionsGuidancePlugin.cs
+++ b/dev-proxy-plugins/RequestLogs/MinimalPermissionsGuidancePlugin.cs
@@ -36,6 +36,11 @@ public class MinimalPermissionsGuidancePlugin : BaseReportingPlugin
     public override string Name => nameof(MinimalPermissionsGuidancePlugin);
 
     public override void Register(IPluginEvents pluginEvents,
+
+    public override void Register()
+    {
+        base.Register();
+
                             IProxyContext context,
                             ISet<UrlToWatch> urlsToWatch,
                             IConfigurationSection? configSection = null)
@@ -137,14 +142,14 @@ private async Task AfterRecordingStop(object? sender, RecordingArgs e)
 
         var report = new MinimalPermissionsGuidancePluginReport();
 
-        _logger?.LogWarning("This plugin is in preview and may not return the correct results.\r\nPlease review the permissions and test your app before using them in production.\r\nIf you have any feedback, please open an issue at https://aka.ms/devproxy/issue.\r\n");
+        Logger.LogWarning("This plugin is in preview and may not return the correct results.\r\nPlease review the permissions and test your app before using them in production.\r\nIf you have any feedback, please open an issue at https://aka.ms/devproxy/issue.\r\n");
 
         if (delegatedEndpoints.Count > 0)
         {
             var delegatedPermissionsInfo = new MinimalPermissionsInfo();
             report.DelegatedPermissions = delegatedPermissionsInfo;
 
-            _logger?.LogInformation("Evaluating delegated permissions for:\r\n{endpoints}\r\n", string.Join(Environment.NewLine, delegatedEndpoints.Select(e => $"- {e.method} {e.url}")));
+            Logger.LogInformation("Evaluating delegated permissions for:\r\n{endpoints}\r\n", string.Join(Environment.NewLine, delegatedEndpoints.Select(e => $"- {e.method} {e.url}")));
 
             await EvaluateMinimalScopes(delegatedEndpoints, scopesToEvaluate, PermissionsType.Delegated, delegatedPermissionsInfo);
         }
@@ -154,7 +159,7 @@ private async Task AfterRecordingStop(object? sender, RecordingArgs e)
             var applicationPermissionsInfo = new MinimalPermissionsInfo();
             report.ApplicationPermissions = applicationPermissionsInfo;
 
-            _logger?.LogInformation("Evaluating application permissions for:\r\n{applicationPermissions}\r\n", string.Join(Environment.NewLine, applicationEndpoints.Select(e => $"- {e.method} {e.url}")));
+            Logger.LogInformation("Evaluating application permissions for:\r\n{applicationPermissions}\r\n", string.Join(Environment.NewLine, applicationEndpoints.Select(e => $"- {e.method} {e.url}")));
 
             await EvaluateMinimalScopes(applicationEndpoints, rolesToEvaluate, PermissionsType.Application, applicationPermissionsInfo);
         }
@@ -277,12 +282,12 @@ private async Task EvaluateMinimalScopes(IEnumerable<(string method, string url)
             var url = $"https://graphexplorerapi-staging.azurewebsites.net/permissions?scopeType={GetScopeTypeString(scopeType)}";
             using var client = new HttpClient();
             var stringPayload = JsonSerializer.Serialize(payload, ProxyUtils.JsonSerializerOptions);
-            _logger?.LogDebug(string.Format("Calling {0} with payload{1}{2}", url, Environment.NewLine, stringPayload));
+            Logger.LogDebug(string.Format("Calling {0} with payload{1}{2}", url, Environment.NewLine, stringPayload));
 
             var response = await client.PostAsJsonAsync(url, payload);
             var content = await response.Content.ReadAsStringAsync();
 
-            _logger?.LogDebug(string.Format("Response:{0}{1}", Environment.NewLine, content));
+            Logger.LogDebug(string.Format("Response:{0}{1}", Environment.NewLine, content));
 
             var resultsAndErrors = JsonSerializer.Deserialize<ResultsAndErrors>(content, ProxyUtils.JsonSerializerOptions);
             var minimalPermissions = resultsAndErrors?.Results?.Select(p => p.Value).ToArray() ?? Array.Empty<string>();
@@ -298,12 +303,12 @@ private async Task EvaluateMinimalScopes(IEnumerable<(string method, string url)
             }
             if (errors.Any())
             {
-                _logger?.LogError("Couldn't determine minimal permissions for the following URLs: {errors}", string.Join(", ", errors));
+                Logger.LogError("Couldn't determine minimal permissions for the following URLs: {errors}", string.Join(", ", errors));
             }
         }
         catch (Exception ex)
         {
-            _logger?.LogError(ex, "An error has occurred while retrieving minimal permissions: {message}", ex.Message);
+            Logger.LogError(ex, "An error has occurred while retrieving minimal permissions: {message}", ex.Message);
         }
     }
 
diff --git a/dev-proxy-plugins/RequestLogs/MinimalPermissionsPlugin.cs b/dev-proxy-plugins/RequestLogs/MinimalPermissionsPlugin.cs
index 01c2e44d..ce1edc72 100644
--- a/dev-proxy-plugins/RequestLogs/MinimalPermissionsPlugin.cs
+++ b/dev-proxy-plugins/RequestLogs/MinimalPermissionsPlugin.cs
@@ -7,7 +7,6 @@
 using Microsoft.Extensions.Logging;
 using System.Net.Http.Json;
 using System.Text.Json;
-using System.Text.Json.Serialization;
 
 namespace Microsoft.DevProxy.Plugins.RequestLogs;
 
@@ -30,16 +29,17 @@ public class MinimalPermissionsPlugin : BaseReportingPlugin
     public override string Name => nameof(MinimalPermissionsPlugin);
     private MinimalPermissionsPluginConfiguration _configuration = new();
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public MinimalPermissionsPlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+    }
+
+    public override void Register()
+    {
+        base.Register();
 
-        configSection?.Bind(_configuration);
+        ConfigSection?.Bind(_configuration);
 
-        pluginEvents.AfterRecordingStop += AfterRecordingStop;
+        PluginEvents.AfterRecordingStop += AfterRecordingStop;
     }
 
     private async Task AfterRecordingStop(object? sender, RecordingArgs e)
@@ -86,13 +86,13 @@ private async Task AfterRecordingStop(object? sender, RecordingArgs e)
 
         if (!endpoints.Any())
         {
-            _logger?.LogInformation("No requests to Microsoft Graph endpoints recorded. Will not retrieve minimal permissions.");
+            Logger.LogInformation("No requests to Microsoft Graph endpoints recorded. Will not retrieve minimal permissions.");
             return;
         }
 
-        _logger?.LogInformation("Retrieving minimal permissions for:\r\n{endpoints}\r\n", string.Join(Environment.NewLine, endpoints.Select(e => $"- {e.method} {e.url}")));
+        Logger.LogInformation("Retrieving minimal permissions for:\r\n{endpoints}\r\n", string.Join(Environment.NewLine, endpoints.Select(e => $"- {e.method} {e.url}")));
 
-        _logger?.LogWarning("This plugin is in preview and may not return the correct results.\r\nPlease review the permissions and test your app before using them in production.\r\nIf you have any feedback, please open an issue at https://aka.ms/devproxy/issue.\r\n");
+        Logger.LogWarning("This plugin is in preview and may not return the correct results.\r\nPlease review the permissions and test your app before using them in production.\r\nIf you have any feedback, please open an issue at https://aka.ms/devproxy/issue.\r\n");
 
         var report = await DetermineMinimalScopes(endpoints);
         if (report is not null)
@@ -154,12 +154,12 @@ private string GetScopeTypeString()
             var url = $"https://graphexplorerapi-staging.azurewebsites.net/permissions?scopeType={GetScopeTypeString()}";
             using var client = new HttpClient();
             var stringPayload = JsonSerializer.Serialize(payload, ProxyUtils.JsonSerializerOptions);
-            _logger?.LogDebug("Calling {url} with payload\r\n{stringPayload}", url, stringPayload);
+            Logger.LogDebug("Calling {url} with payload\r\n{stringPayload}", url, stringPayload);
 
             var response = await client.PostAsJsonAsync(url, payload);
             var content = await response.Content.ReadAsStringAsync();
 
-            _logger?.LogDebug("Response:\r\n{content}", content);
+            Logger.LogDebug("Response:\r\n{content}", content);
 
             var resultsAndErrors = JsonSerializer.Deserialize<ResultsAndErrors>(content, ProxyUtils.JsonSerializerOptions);
             var minimalScopes = resultsAndErrors?.Results?.Select(p => p.Value).ToArray() ?? Array.Empty<string>();
@@ -167,11 +167,11 @@ private string GetScopeTypeString()
 
             if (minimalScopes.Any())
             {
-                _logger?.LogInformation("Minimal permissions:\r\n{permissions}", string.Join(", ", minimalScopes));
+                Logger.LogInformation("Minimal permissions:\r\n{permissions}", string.Join(", ", minimalScopes));
             }
             if (errors.Any())
             {
-                _logger?.LogError("Couldn't determine minimal permissions for the following URLs:\r\n{errors}", string.Join(Environment.NewLine, errors));
+                Logger.LogError("Couldn't determine minimal permissions for the following URLs:\r\n{errors}", string.Join(Environment.NewLine, errors));
             }
 
             return new MinimalPermissionsPluginReport
@@ -184,7 +184,7 @@ private string GetScopeTypeString()
         }
         catch (Exception ex)
         {
-            _logger?.LogError(ex, "An error has occurred while retrieving minimal permissions:");
+            Logger.LogError(ex, "An error has occurred while retrieving minimal permissions:");
             return null;
         }
     }
diff --git a/dev-proxy-plugins/RequestLogs/MockGeneratorPlugin.cs b/dev-proxy-plugins/RequestLogs/MockGeneratorPlugin.cs
index 4b576518..f8801457 100644
--- a/dev-proxy-plugins/RequestLogs/MockGeneratorPlugin.cs
+++ b/dev-proxy-plugins/RequestLogs/MockGeneratorPlugin.cs
@@ -12,25 +12,26 @@ namespace Microsoft.DevProxy.Plugins.RequestLogs;
 
 public class MockGeneratorPlugin : BaseReportingPlugin
 {
+    public MockGeneratorPlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     public override string Name => nameof(MockGeneratorPlugin);
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        pluginEvents.AfterRecordingStop += AfterRecordingStop;
+        PluginEvents.AfterRecordingStop += AfterRecordingStop;
     }
 
     private Task AfterRecordingStop(object? sender, RecordingArgs e)
     {
-        _logger?.LogInformation("Creating mocks from recorded requests...");
+        Logger.LogInformation("Creating mocks from recorded requests...");
 
         if (!e.RequestLogs.Any())
         {
-            _logger?.LogDebug("No requests to process");
+            Logger.LogDebug("No requests to process");
             return Task.CompletedTask;
         }
 
@@ -47,7 +48,7 @@ private Task AfterRecordingStop(object? sender, RecordingArgs e)
             }
 
             var methodAndUrlString = request.MessageLines.First();
-            _logger?.LogDebug("Processing request {methodAndUrlString}...", methodAndUrlString);
+            Logger.LogDebug("Processing request {methodAndUrlString}...", methodAndUrlString);
 
             var (method, url) = GetMethodAndUrl(methodAndUrlString);
             var response = request.Context.Session.HttpClient.Response;
@@ -71,28 +72,28 @@ private Task AfterRecordingStop(object? sender, RecordingArgs e)
             // skip mock if it's 200 but has no body
             if (mock.Response.StatusCode == 200 && mock.Response.Body is null)
             {
-                _logger?.LogDebug("Skipping mock with 200 response code and no body");
+                Logger.LogDebug("Skipping mock with 200 response code and no body");
                 continue;
             }
 
             mocks.Add(mock);
-            _logger?.LogDebug("Added mock for {method} {url}", mock.Request.Method, mock.Request.Url);
+            Logger.LogDebug("Added mock for {method} {url}", mock.Request.Method, mock.Request.Url);
         }
 
-        _logger?.LogDebug("Sorting mocks...");
+        Logger.LogDebug("Sorting mocks...");
         // sort mocks descending by url length so that most specific mocks are first
         mocks.Sort((a, b) => b.Request!.Url.CompareTo(a.Request!.Url));
 
         var mocksFile = new MockResponseConfiguration { Mocks = mocks };
 
-        _logger?.LogDebug("Serializing mocks...");
+        Logger.LogDebug("Serializing mocks...");
         var mocksFileJson = JsonSerializer.Serialize(mocksFile, ProxyUtils.JsonSerializerOptions);
         var fileName = $"mocks-{DateTime.Now:yyyyMMddHHmmss}.json";
 
-        _logger?.LogDebug("Writing mocks to {fileName}...", fileName);
+        Logger.LogDebug("Writing mocks to {fileName}...", fileName);
         File.WriteAllText(fileName, mocksFileJson);
 
-        _logger?.LogInformation("Created mock file {fileName} with {mocksCount} mocks", fileName, mocks.Count);
+        Logger.LogInformation("Created mock file {fileName} with {mocksCount} mocks", fileName, mocks.Count);
 
         StoreReport(fileName, e);
 
@@ -107,48 +108,48 @@ private Task AfterRecordingStop(object? sender, RecordingArgs e)
     /// <returns>Response body or @filename for binary responses</returns>
     private async Task<dynamic?> GetResponseBody(SessionEventArgs session)
     {
-        _logger?.LogDebug("Getting response body...");
+        Logger.LogDebug("Getting response body...");
 
         var response = session.HttpClient.Response;
         if (response.ContentType is null || !response.HasBody)
         {
-            _logger?.LogDebug("Response has no content-type set or has no body. Skipping");
+            Logger.LogDebug("Response has no content-type set or has no body. Skipping");
             return null;
         }
 
         if (response.ContentType.Contains("application/json"))
         {
-            _logger?.LogDebug("Response is JSON");
+            Logger.LogDebug("Response is JSON");
 
             try
             {
-                _logger?.LogDebug("Reading response body as string...");
+                Logger.LogDebug("Reading response body as string...");
                 var body = response.IsBodyRead ? response.BodyString : await session.GetResponseBodyAsString();
-                _logger?.LogDebug("Body: {body}", body);
-                _logger?.LogDebug("Deserializing response body...");
+                Logger.LogDebug("Body: {body}", body);
+                Logger.LogDebug("Deserializing response body...");
                 return JsonSerializer.Deserialize<dynamic>(body, ProxyUtils.JsonSerializerOptions);
             }
             catch (Exception ex)
             {
-                _logger?.LogError(ex, "Error reading response body");
+                Logger.LogError(ex, "Error reading response body");
                 return null;
             }
         }
 
-        _logger?.LogDebug("Response is binary");
+        Logger.LogDebug("Response is binary");
         // assume body is binary
         try
         {
             var filename = $"response-{Guid.NewGuid()}.bin";
-            _logger?.LogDebug("Reading response body as bytes...");
+            Logger.LogDebug("Reading response body as bytes...");
             var body = await session.GetResponseBody();
-            _logger?.LogDebug("Writing response body to {filename}...", filename);
+            Logger.LogDebug("Writing response body to {filename}...", filename);
             File.WriteAllBytes(filename, body);
             return $"@{filename}";
         }
         catch (Exception ex)
         {
-            _logger?.LogError(ex, "Error reading response body");
+            Logger.LogError(ex, "Error reading response body");
             return null;
         }
     }
diff --git a/dev-proxy-plugins/RequestLogs/OpenApiSpecGeneratorPlugin.cs b/dev-proxy-plugins/RequestLogs/OpenApiSpecGeneratorPlugin.cs
index facca3b9..8947fbe0 100644
--- a/dev-proxy-plugins/RequestLogs/OpenApiSpecGeneratorPlugin.cs
+++ b/dev-proxy-plugins/RequestLogs/OpenApiSpecGeneratorPlugin.cs
@@ -276,27 +276,28 @@ public class OpenApiSpecGeneratorPlugin : BaseReportingPlugin
         "apikey"
     ];
 
+    public OpenApiSpecGeneratorPlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     public override string Name => nameof(OpenApiSpecGeneratorPlugin);
     public static readonly string GeneratedOpenApiSpecsKey = "GeneratedOpenApiSpecs";
 
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        pluginEvents.AfterRecordingStop += AfterRecordingStop;
+        PluginEvents.AfterRecordingStop += AfterRecordingStop;
     }
 
     private Task AfterRecordingStop(object? sender, RecordingArgs e)
     {
-        _logger?.LogInformation("Creating OpenAPI spec from recorded requests...");
+        Logger.LogInformation("Creating OpenAPI spec from recorded requests...");
 
         if (!e.RequestLogs.Any())
         {
-            _logger?.LogDebug("No requests to process");
+            Logger.LogDebug("No requests to process");
             return Task.CompletedTask;
         }
 
@@ -312,7 +313,7 @@ private Task AfterRecordingStop(object? sender, RecordingArgs e)
             }
 
             var methodAndUrlString = request.MessageLines.First();
-            _logger?.LogDebug("Processing request {methodAndUrlString}...", methodAndUrlString);
+            Logger.LogDebug("Processing request {methodAndUrlString}...", methodAndUrlString);
 
             try
             {
@@ -324,11 +325,11 @@ private Task AfterRecordingStop(object? sender, RecordingArgs e)
             }
             catch (Exception ex)
             {
-                _logger?.LogError(ex, "Error processing request {methodAndUrl}", methodAndUrlString);
+                Logger.LogError(ex, "Error processing request {methodAndUrl}", methodAndUrlString);
             }
         }
 
-        _logger?.LogDebug("Serializing OpenAPI docs...");
+        Logger.LogDebug("Serializing OpenAPI docs...");
         var generatedOpenApiSpecs = new Dictionary<string, string>();
         foreach (var openApiDoc in openApiDocs)
         {
@@ -336,12 +337,12 @@ private Task AfterRecordingStop(object? sender, RecordingArgs e)
             var fileName = GetFileNameFromServerUrl(server.Url);
             var docString = openApiDoc.SerializeAsJson(OpenApiSpecVersion.OpenApi3_0);
 
-            _logger?.LogDebug("  Writing OpenAPI spec to {fileName}...", fileName);
+            Logger.LogDebug("  Writing OpenAPI spec to {fileName}...", fileName);
             File.WriteAllText(fileName, docString);
 
             generatedOpenApiSpecs.Add(server.Url, fileName);
 
-            _logger?.LogInformation("Created OpenAPI spec file {fileName}", fileName);
+            Logger.LogInformation("Created OpenAPI spec file {fileName}", fileName);
         }
 
         StoreReport(new OpenApiSpecGeneratorPluginReport(
@@ -478,17 +479,17 @@ private void SetRequestBody(OpenApiOperation operation, Request request)
     {
         if (!request.HasBody)
         {
-            _logger?.LogDebug("  Request has no body");
+            Logger.LogDebug("  Request has no body");
             return;
         }
 
         if (request.ContentType is null)
         {
-            _logger?.LogDebug("  Request has no content type");
+            Logger.LogDebug("  Request has no content type");
             return;
         }
 
-        _logger?.LogDebug("  Processing request body...");
+        Logger.LogDebug("  Processing request body...");
         operation.RequestBody = new OpenApiRequestBody
         {
             Content = new Dictionary<string, OpenApiMediaType>
@@ -509,23 +510,23 @@ private void SetParametersFromRequestHeaders(OpenApiOperation operation, HeaderC
         if (headers is null ||
             !headers.Any())
         {
-            _logger?.LogDebug("  Request has no headers");
+            Logger.LogDebug("  Request has no headers");
             return;
         }
 
-        _logger?.LogDebug("  Processing request headers...");
+        Logger.LogDebug("  Processing request headers...");
         foreach (var header in headers)
         {
             var lowerCaseHeaderName = header.Name.ToLowerInvariant();
             if (standardHeaders.Contains(lowerCaseHeaderName))
             {
-                _logger?.LogDebug("    Skipping standard header {headerName}", header.Name);
+                Logger.LogDebug("    Skipping standard header {headerName}", header.Name);
                 continue;
             }
 
             if (authHeaders.Contains(lowerCaseHeaderName))
             {
-                _logger?.LogDebug("    Skipping auth header {headerName}", header.Name);
+                Logger.LogDebug("    Skipping auth header {headerName}", header.Name);
                 continue;
             }
 
@@ -536,7 +537,7 @@ private void SetParametersFromRequestHeaders(OpenApiOperation operation, HeaderC
                 Required = false,
                 Schema = new OpenApiSchema { Type = "string" }
             });
-            _logger?.LogDebug("    Added header {headerName}", header.Name);
+            Logger.LogDebug("    Added header {headerName}", header.Name);
         }
     }
 
@@ -545,11 +546,11 @@ private void SetParametersFromQueryString(OpenApiOperation operation, NameValueC
         if (queryParams.AllKeys is null ||
             !queryParams.AllKeys.Any())
         {
-            _logger?.LogDebug("  Request has no query string parameters");
+            Logger.LogDebug("  Request has no query string parameters");
             return;
         }
 
-        _logger?.LogDebug("  Processing query string parameters...");
+        Logger.LogDebug("  Processing query string parameters...");
         var dictionary = (queryParams.AllKeys as string[]).ToDictionary(k => k, k => queryParams[k] as object);
 
         foreach (var parameter in dictionary)
@@ -561,7 +562,7 @@ private void SetParametersFromQueryString(OpenApiOperation operation, NameValueC
                 Required = false,
                 Schema = new OpenApiSchema { Type = "string" }
             });
-            _logger?.LogDebug("    Added query string parameter {parameterKey}", parameter.Key);
+            Logger.LogDebug("    Added query string parameter {parameterKey}", parameter.Key);
         }
     }
 
@@ -569,11 +570,11 @@ private void SetResponseFromSession(OpenApiOperation operation, Response respons
     {
         if (response is null)
         {
-            _logger?.LogDebug("  No response to process");
+            Logger.LogDebug("  No response to process");
             return;
         }
 
-        _logger?.LogDebug("  Processing response...");
+        Logger.LogDebug("  Processing response...");
 
         var openApiResponse = new OpenApiResponse
         {
@@ -582,7 +583,7 @@ private void SetResponseFromSession(OpenApiOperation operation, Response respons
         var responseCode = response.StatusCode.ToString();
         if (response.HasBody)
         {
-            _logger?.LogDebug("    Response has body");
+            Logger.LogDebug("    Response has body");
 
             openApiResponse.Content.Add(response.ContentType, new OpenApiMediaType
             {
@@ -591,31 +592,31 @@ private void SetResponseFromSession(OpenApiOperation operation, Response respons
         }
         else
         {
-            _logger?.LogDebug("    Response doesn't have body");
+            Logger.LogDebug("    Response doesn't have body");
         }
 
         if (response.Headers is not null && response.Headers.Any())
         {
-            _logger?.LogDebug("    Response has headers");
+            Logger.LogDebug("    Response has headers");
 
             foreach (var header in response.Headers)
             {
                 var lowerCaseHeaderName = header.Name.ToLowerInvariant();
                 if (standardHeaders.Contains(lowerCaseHeaderName))
                 {
-                    _logger?.LogDebug("    Skipping standard header {headerName}", header.Name);
+                    Logger.LogDebug("    Skipping standard header {headerName}", header.Name);
                     continue;
                 }
 
                 if (authHeaders.Contains(lowerCaseHeaderName))
                 {
-                    _logger?.LogDebug("    Skipping auth header {headerName}", header.Name);
+                    Logger.LogDebug("    Skipping auth header {headerName}", header.Name);
                     continue;
                 }
 
                 if (openApiResponse.Headers.ContainsKey(header.Name))
                 {
-                    _logger?.LogDebug("    Header {headerName} already exists in response", header.Name);
+                    Logger.LogDebug("    Header {headerName} already exists in response", header.Name);
                     continue;
                 }
 
@@ -623,12 +624,12 @@ private void SetResponseFromSession(OpenApiOperation operation, Response respons
                 {
                     Schema = new OpenApiSchema { Type = "string" }
                 });
-                _logger?.LogDebug("    Added header {headerName}", header.Name);
+                Logger.LogDebug("    Added header {headerName}", header.Name);
             }
         }
         else
         {
-            _logger?.LogDebug("    Response doesn't have headers");
+            Logger.LogDebug("    Response doesn't have headers");
         }
 
         operation.Responses.Add(responseCode, openApiResponse);
@@ -638,13 +639,13 @@ private void SetResponseFromSession(OpenApiOperation operation, Response respons
     {
         if (contentType is null)
         {
-            _logger?.LogDebug("  No content type to process");
+            Logger.LogDebug("  No content type to process");
             return null;
         }
 
         if (contentType.StartsWith("application/json"))
         {
-            _logger?.LogDebug("    Processing JSON body...");
+            Logger.LogDebug("    Processing JSON body...");
             return GetSchemaFromJsonString(body);
         }
 
@@ -658,7 +659,7 @@ private void AddOrMergePathItem(IList<OpenApiDocument> openApiDocs, OpenApiPathI
 
         if (openApiDoc is null)
         {
-            _logger?.LogDebug("  Creating OpenAPI spec for {serverUrl}...", serverUrl);
+            Logger.LogDebug("  Creating OpenAPI spec for {serverUrl}...", serverUrl);
 
             openApiDoc = new OpenApiDocument
             {
@@ -682,19 +683,19 @@ private void AddOrMergePathItem(IList<OpenApiDocument> openApiDocs, OpenApiPathI
         }
         else
         {
-            _logger?.LogDebug("  Found OpenAPI spec for {serverUrl}...", serverUrl);
+            Logger.LogDebug("  Found OpenAPI spec for {serverUrl}...", serverUrl);
         }
 
         if (!openApiDoc.Paths.ContainsKey(parametrizedPath))
         {
-            _logger?.LogDebug("  Adding path {parametrizedPath} to OpenAPI spec...", parametrizedPath);
+            Logger.LogDebug("  Adding path {parametrizedPath} to OpenAPI spec...", parametrizedPath);
 
             openApiDoc.Paths.Add(parametrizedPath, pathItem);
             // since we've just added the path, we're done
             return;
         }
 
-        _logger?.LogDebug("  Merging path {parametrizedPath} into OpenAPI spec...", parametrizedPath);
+        Logger.LogDebug("  Merging path {parametrizedPath} into OpenAPI spec...", parametrizedPath);
         var path = openApiDoc.Paths[parametrizedPath];
         var operation = pathItem.Operations.First();
         AddOrMergeOperation(path, operation.Key, operation.Value);
@@ -704,14 +705,14 @@ private void AddOrMergeOperation(OpenApiPathItem pathItem, OperationType operati
     {
         if (!pathItem.Operations.ContainsKey(operationType))
         {
-            _logger?.LogDebug("    Adding operation {operationType} to path...", operationType);
+            Logger.LogDebug("    Adding operation {operationType} to path...", operationType);
 
             pathItem.AddOperation(operationType, apiOperation);
             // since we've just added the operation, we're done
             return;
         }
 
-        _logger?.LogDebug("    Merging operation {operationType} into path...", operationType);
+        Logger.LogDebug("    Merging operation {operationType} into path...", operationType);
 
         var operation = pathItem.Operations[operationType];
 
@@ -724,23 +725,23 @@ private void AddOrMergeParameters(OpenApiOperation operation, IList<OpenApiParam
     {
         if (parameters is null || !parameters.Any())
         {
-            _logger?.LogDebug("    No parameters to process");
+            Logger.LogDebug("    No parameters to process");
             return;
         }
 
-        _logger?.LogDebug("    Processing parameters for operation...");
+        Logger.LogDebug("    Processing parameters for operation...");
 
         foreach (var parameter in parameters)
         {
             var paramFromOperation = operation.Parameters.FirstOrDefault(p => p.Name == parameter.Name && p.In == parameter.In);
             if (paramFromOperation is null)
             {
-                _logger?.LogDebug("      Adding parameter {parameterName} to operation...", parameter.Name);
+                Logger.LogDebug("      Adding parameter {parameterName} to operation...", parameter.Name);
                 operation.Parameters.Add(parameter);
                 continue;
             }
 
-            _logger?.LogDebug("      Merging parameter {parameterName}...", parameter.Name);
+            Logger.LogDebug("      Merging parameter {parameterName}...", parameter.Name);
             MergeSchema(parameter?.Schema, paramFromOperation?.Schema);
         }
     }
@@ -749,25 +750,25 @@ private void MergeSchema(OpenApiSchema? source, OpenApiSchema? target)
     {
         if (source is null || target is null)
         {
-            _logger?.LogDebug("        Source or target is null. Skipping...");
+            Logger.LogDebug("        Source or target is null. Skipping...");
             return;
         }
 
         if (source.Type != "object" || target.Type != "object")
         {
-            _logger?.LogDebug("        Source or target schema is not an object. Skipping...");
+            Logger.LogDebug("        Source or target schema is not an object. Skipping...");
             return;
         }
 
         if (source.Properties is null || !source.Properties.Any())
         {
-            _logger?.LogDebug("        Source has no properties. Skipping...");
+            Logger.LogDebug("        Source has no properties. Skipping...");
             return;
         }
 
         if (target.Properties is null || !target.Properties.Any())
         {
-            _logger?.LogDebug("        Target has no properties. Skipping...");
+            Logger.LogDebug("        Target has no properties. Skipping...");
             return;
         }
 
@@ -776,18 +777,18 @@ private void MergeSchema(OpenApiSchema? source, OpenApiSchema? target)
             var propertyFromTarget = target.Properties.FirstOrDefault(p => p.Key == property.Key);
             if (propertyFromTarget.Value is null)
             {
-                _logger?.LogDebug("        Adding property {propertyKey} to schema...", property.Key);
+                Logger.LogDebug("        Adding property {propertyKey} to schema...", property.Key);
                 target.Properties.Add(property);
                 continue;
             }
 
             if (property.Value.Type != "object")
             {
-                _logger?.LogDebug("        Property already found but is not an object. Skipping...");
+                Logger.LogDebug("        Property already found but is not an object. Skipping...");
                 continue;
             }
 
-            _logger?.LogDebug("        Merging property {propertyKey}...", property.Key);
+            Logger.LogDebug("        Merging property {propertyKey}...", property.Key);
             MergeSchema(property.Value, propertyFromTarget.Value);
         }
     }
@@ -796,7 +797,7 @@ private void AddOrMergeRequestBody(OpenApiOperation operation, OpenApiRequestBod
     {
         if (requestBody is null || !requestBody.Content.Any())
         {
-            _logger?.LogDebug("    No request body to process");
+            Logger.LogDebug("    No request body to process");
             return;
         }
 
@@ -806,14 +807,14 @@ private void AddOrMergeRequestBody(OpenApiOperation operation, OpenApiRequestBod
 
         if (bodyFromOperation is null)
         {
-            _logger?.LogDebug("    Adding request body to operation...");
+            Logger.LogDebug("    Adding request body to operation...");
 
             operation.RequestBody.Content.Add(requestBody.Content.FirstOrDefault());
             // since we've just added the request body, we're done
             return;
         }
 
-        _logger?.LogDebug("    Merging request body into operation...");
+        Logger.LogDebug("    Merging request body into operation...");
         MergeSchema(bodyFromOperation.Schema, requestBody.Content.FirstOrDefault().Value.Schema);
     }
 
@@ -821,7 +822,7 @@ private void AddOrMergeResponse(OpenApiOperation operation, OpenApiResponses api
     {
         if (apiResponses is null)
         {
-            _logger?.LogDebug("    No response to process");
+            Logger.LogDebug("    No response to process");
             return;
         }
 
@@ -833,7 +834,7 @@ private void AddOrMergeResponse(OpenApiOperation operation, OpenApiResponses api
 
         if (responseFromOperation is null)
         {
-            _logger?.LogDebug("    Adding response {apiResponseStatusCode} to operation...", apiResponseStatusCode);
+            Logger.LogDebug("    Adding response {apiResponseStatusCode} to operation...", apiResponseStatusCode);
 
             operation.Responses.Add(apiResponseStatusCode, apiResponse);
             // since we've just added the response, we're done
@@ -842,7 +843,7 @@ private void AddOrMergeResponse(OpenApiOperation operation, OpenApiResponses api
 
         if (!apiResponse.Content.Any())
         {
-            _logger?.LogDebug("    No response content to process");
+            Logger.LogDebug("    No response content to process");
             return;
         }
 
@@ -852,14 +853,14 @@ private void AddOrMergeResponse(OpenApiOperation operation, OpenApiResponses api
 
         if (contentFromOperation is null)
         {
-            _logger?.LogDebug("    Adding response {apiResponseContentType} to {apiResponseStatusCode} to response...", apiResponseContentType, apiResponseStatusCode);
+            Logger.LogDebug("    Adding response {apiResponseContentType} to {apiResponseStatusCode} to response...", apiResponseContentType, apiResponseStatusCode);
 
             responseFromOperation.Content.Add(apiResponse.Content.First());
             // since we've just added the content, we're done
             return;
         }
 
-        _logger?.LogDebug("    Merging response {apiResponseStatusCode}/{apiResponseContentType} into operation...", apiResponseStatusCode, apiResponseContentType);
+        Logger.LogDebug("    Merging response {apiResponseStatusCode}/{apiResponseContentType} into operation...", apiResponseStatusCode, apiResponseContentType);
         MergeSchema(contentFromOperation.Schema, apiResponse.Content.First().Value.Schema);
     }
 
diff --git a/dev-proxy/CertificateDiskCache.cs b/dev-proxy/CertificateDiskCache.cs
index 65e56684..7a7de41b 100644
--- a/dev-proxy/CertificateDiskCache.cs
+++ b/dev-proxy/CertificateDiskCache.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
 using System.Security.Cryptography.X509Certificates;
 using Titanium.Web.Proxy.Helpers;
 using Titanium.Web.Proxy.Network;
diff --git a/dev-proxy/ConsoleLogger.cs b/dev-proxy/ConsoleLogger.cs
deleted file mode 100644
index b0099020..00000000
--- a/dev-proxy/ConsoleLogger.cs
+++ /dev/null
@@ -1,380 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-using System.Text;
-using Microsoft.DevProxy.Abstractions;
-using Microsoft.Extensions.Logging;
-
-namespace Microsoft.DevProxy;
-
-public class ConsoleLogger : IProxyLogger
-{
-    private readonly ConsoleColor _color;
-    private readonly LabelMode _labelMode;
-    private readonly PluginEvents _pluginEvents;
-    private const string _boxTopLeft = "\u256d ";
-    private const string _boxLeft = "\u2502 ";
-    private const string _boxBottomLeft = "\u2570 ";
-    // used to align single-line messages
-    private const string _boxSpacing = "  ";
-
-    public static readonly object ConsoleLock = new object();
-
-    public LogLevel LogLevel { get; set; }
-
-    public ConsoleLogger(ProxyConfiguration configuration, PluginEvents pluginEvents)
-    {
-        // needed to properly required rounded corners in the box
-        Console.OutputEncoding = Encoding.UTF8;
-        _color = Console.ForegroundColor;
-        _labelMode = configuration.LabelMode;
-        _pluginEvents = pluginEvents;
-        LogLevel = configuration.LogLevel;
-    }
-
-    private void WriteLog(string message)
-    {
-        Console.WriteLine(message);
-    }
-
-    private void WriteWarning(string message)
-    {
-        Console.ForegroundColor = ConsoleColor.Yellow;
-        Console.Error.WriteLine($"  WARNING: {message}");
-        Console.ForegroundColor = _color;
-    }
-
-    private void WriteError(string message)
-    {
-        Console.ForegroundColor = ConsoleColor.Red;
-        Console.Error.WriteLine(message);
-        Console.ForegroundColor = _color;
-    }
-
-    private void WriteDebug(string message)
-    {
-        Console.ForegroundColor = ConsoleColor.Gray;
-        Console.Error.WriteLine($"[{DateTime.Now}] {message}");
-        Console.ForegroundColor = _color;
-    }
-
-    public void LogRequest(string[] message, MessageType messageType, LoggingContext? context = null)
-    {
-        var method = context?.Session.HttpClient.Request.Method;
-        var url = context?.Session.HttpClient.Request.Url;
-        LogRequest(message, messageType, method, url, context);
-    }
-
-    public void LogRequest(string[] message, MessageType messageType, string method, string url)
-    {
-        LogRequest(message, messageType, method, url, null);
-    }
-
-    private void LogRequest(string[] message, MessageType messageType, string? method, string? url, LoggingContext? context = null)
-    {
-        var messageLines = new List<string>(message);
-
-        // don't log intercepted response to console
-        if (messageType != MessageType.InterceptedResponse)
-        {
-            // add request context information to the message for messages
-            // that are not intercepted requests and have a context
-            if (messageType != MessageType.InterceptedRequest &&
-                method is not null &&
-                url is not null)
-            {
-                messageLines.Add($"{method} {url}");
-            }
-
-            lock (ConsoleLock)
-            {
-                switch (_labelMode)
-                {
-                    case LabelMode.Text:
-                        WriteBoxedWithInvertedLabels(messageLines.ToArray(), messageType);
-                        break;
-                    case LabelMode.Icon:
-                        WriteBoxedWithAsciiIcons(messageLines.ToArray(), messageType);
-                        break;
-                    case LabelMode.NerdFont:
-                        WriteBoxedWithNerdFontIcons(messageLines.ToArray(), messageType);
-                        break;
-                }
-            }
-        }
-
-        _pluginEvents.RaiseRequestLogged(new RequestLogArgs(new RequestLog(message, messageType, context)));
-    }
-
-    public void WriteBoxedWithInvertedLabels(string[] message, MessageType messageType)
-    {
-        const string labelSpacing = "  ";
-        const string interceptedRequest = "request";
-        const string passedThrough = "api";
-        const string chaos = "chaos";
-        const string warning = "warning";
-        const string mock = "mock";
-        const string normal = "log";
-        const string fail = "fail";
-        const string tip = "tip";
-        var allLabels = new[] { interceptedRequest, passedThrough, chaos, warning, mock, normal, fail, tip };
-        var maxLabelLength = allLabels.Max(l => l.Length);
-        var noLabelSpacing = new string(' ', maxLabelLength + 2);
-
-        var label = normal;
-        var fgColor = Console.ForegroundColor;
-        var bgColor = Console.BackgroundColor;
-
-        switch (messageType)
-        {
-            case MessageType.InterceptedRequest:
-                label = interceptedRequest;
-                bgColor = ConsoleColor.DarkGray;
-                break;
-            case MessageType.PassedThrough:
-                label = passedThrough;
-                fgColor = ConsoleColor.Black;
-                bgColor = ConsoleColor.Gray;
-                break;
-            case MessageType.Chaos:
-                label = chaos;
-                fgColor = ConsoleColor.White;
-                bgColor = ConsoleColor.DarkRed;
-                break;
-            case MessageType.Warning:
-                label = warning;
-                fgColor = ConsoleColor.Black;
-                bgColor = ConsoleColor.Yellow;
-                break;
-            case MessageType.Mocked:
-                label = mock;
-                fgColor = ConsoleColor.Black;
-                bgColor = ConsoleColor.DarkYellow;
-                break;
-            case MessageType.Failed:
-                label = fail;
-                fgColor = ConsoleColor.Black;
-                bgColor = ConsoleColor.Red;
-                break;
-            case MessageType.Tip:
-                label = tip;
-                fgColor = ConsoleColor.White;
-                bgColor = ConsoleColor.Blue;
-                break;
-            case MessageType.Normal:
-                label = normal;
-                break;
-        }
-
-        var leadingSpaces = new string(' ', maxLabelLength - label.Length);
-
-        if (message.Length == 1)
-        {
-            // no need to box a single line message
-            Console.Write(leadingSpaces);
-            Console.ForegroundColor = fgColor;
-            Console.BackgroundColor = bgColor;
-            Console.Write($" {label} ");
-            Console.ResetColor();
-            Console.WriteLine($"{labelSpacing}{_boxSpacing}{message[0]}");
-        }
-        else
-        {
-            for (var i = 0; i < message.Length; i++)
-            {
-                if (i == 0)
-                {
-                    // print label and top of the box
-                    Console.Write(leadingSpaces);
-                    Console.ForegroundColor = fgColor;
-                    Console.BackgroundColor = bgColor;
-                    Console.Write($" {label} ");
-                    Console.ResetColor();
-                    Console.WriteLine($"{labelSpacing}{_boxTopLeft}{message[i]}");
-                }
-                else if (i < message.Length - 1)
-                {
-                    // print middle of the box
-                    Console.WriteLine($"{noLabelSpacing}{labelSpacing}{_boxLeft}{message[i]}");
-                }
-                else
-                {
-                    // print end of the box
-                    Console.WriteLine($"{noLabelSpacing}{labelSpacing}{_boxBottomLeft}{message[i]}");
-                }
-            }
-        }
-    }
-
-    public void WriteBoxedWithAsciiIcons(string[] message, MessageType messageType)
-    {
-        const string iconSpacing = "  ";
-        const string noIconSpacing = "   ";
-
-        // Set the icon based on the provided message type, using this switch statement
-        var icon = messageType switch
-        {
-            MessageType.InterceptedRequest => "← ←",
-            MessageType.PassedThrough => "↑ ↑",
-            MessageType.Chaos => "× →",
-            MessageType.Warning => "/!\\",
-            MessageType.Mocked => "o →",
-            MessageType.Failed => "! →",
-            MessageType.Tip => "(i)",
-            MessageType.Normal => "   ",
-            _ => "   "
-        };
-        // Set the foreground color based on the provided message type, using this switch statement
-        var fgColor = messageType switch
-        {
-            MessageType.PassedThrough => ConsoleColor.Gray,
-            MessageType.Chaos => ConsoleColor.DarkRed,
-            MessageType.Warning => ConsoleColor.Yellow,
-            MessageType.Mocked => ConsoleColor.DarkYellow,
-            MessageType.Failed => ConsoleColor.Red,
-            MessageType.Tip => ConsoleColor.Blue,
-            _ => Console.ForegroundColor
-        };
-
-        Console.ForegroundColor = fgColor;
-
-        if (message.Length == 1)
-        {
-            // no need to box a single line message
-            Console.WriteLine($"{icon}{iconSpacing}{_boxSpacing}{message[0]}");
-        }
-        else
-        {
-            for (var i = 0; i < message.Length; i++)
-            {
-                if (i == 0)
-                {
-                    // print label and top of the box
-                    Console.WriteLine($"{icon}{iconSpacing}{_boxTopLeft}{message[i]}");
-                }
-                else if (i < message.Length - 1)
-                {
-                    // print middle of the box
-                    Console.WriteLine($"{noIconSpacing}{iconSpacing}{_boxLeft}{message[i]}");
-                }
-                else
-                {
-                    // print end of the box
-                    Console.WriteLine($"{noIconSpacing}{iconSpacing}{_boxBottomLeft}{message[i]}");
-                }
-            }
-        }
-
-        Console.ResetColor();
-    }
-
-    public void WriteBoxedWithNerdFontIcons(string[] message, MessageType messageType)
-    {
-        const string iconSpacing = "  ";
-        const string noIconSpacing = " ";
-
-        // Set the icon based on the provided message type, using this switch statement
-        var icon = messageType switch
-        {
-            MessageType.InterceptedRequest => "\uf441",
-            MessageType.PassedThrough => "\ue33c",
-            MessageType.Chaos => "\uf188",
-            MessageType.Warning => "\uf421",
-            MessageType.Mocked => "\uf064",
-            MessageType.Failed => "\uf65b",
-            MessageType.Tip => "\ufbe6",
-            _ => " "
-        };
-        // Set the foreground color based on the provided message type, using this switch statement
-        var fgColor = messageType switch
-        {
-            MessageType.PassedThrough => ConsoleColor.Gray,
-            MessageType.Chaos => ConsoleColor.DarkRed,
-            MessageType.Warning => ConsoleColor.Yellow,
-            MessageType.Mocked => ConsoleColor.DarkYellow,
-            MessageType.Failed => ConsoleColor.Red,
-            MessageType.Tip => ConsoleColor.Blue,
-            _ => Console.ForegroundColor
-        };
-
-        Console.ForegroundColor = fgColor;
-
-        if (message.Length == 1)
-        {
-            // no need to box a single line message
-            Console.WriteLine($"{icon}{iconSpacing}{_boxSpacing}{message[0]}");
-        }
-        else
-        {
-            for (var i = 0; i < message.Length; i++)
-            {
-                if (i == 0)
-                {
-                    // print label and top of the box
-                    Console.WriteLine($"{icon}{iconSpacing}{_boxTopLeft}{message[i]}");
-                }
-                else if (i < message.Length - 1)
-                {
-                    // print middle of the box
-                    Console.WriteLine($"{noIconSpacing}{iconSpacing}{_boxLeft}{message[i]}");
-                }
-                else
-                {
-                    // print end of the box
-                    Console.WriteLine($"{noIconSpacing}{iconSpacing}{_boxBottomLeft}{message[i]}");
-                }
-            }
-        }
-
-        Console.ResetColor();
-    }
-
-    public object Clone()
-    {
-        return new ConsoleLogger(new ProxyConfiguration
-        {
-            LabelMode = _labelMode,
-            LogLevel = LogLevel
-        }, _pluginEvents);
-    }
-
-    /// <inheritdoc/>
-    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
-    {
-        if (!IsEnabled(logLevel))
-        {
-            return;
-        }
-
-        var message = formatter(state, exception);
-        // temporary fix to log exceptions
-        // long term we should move this to the formatter
-        if (exception is not null)
-        {
-            message += Environment.NewLine + exception;
-        }
-        message = message.ReplaceLineEndings();
-        switch (logLevel)
-        {
-            case LogLevel.Debug:
-                WriteDebug(message);
-                break;
-            case LogLevel.Information:
-                WriteLog(message);
-                break;
-            case LogLevel.Warning:
-                WriteWarning(message);
-                break;
-            case LogLevel.Error:
-                WriteError(message);
-                break;
-        }
-        
-    }
-
-    /// <inheritdoc/>
-    public bool IsEnabled(LogLevel logLevelToTest) => logLevelToTest >= LogLevel; // only log if the log level is greater than or equal to the current log level
-
-    /// <inheritdoc/>
-    public IDisposable? BeginScope<TState>(TState state) where TState : notnull => default!;
-}
diff --git a/dev-proxy/Logging/ILoggerBuilderExtensions.cs b/dev-proxy/Logging/ILoggerBuilderExtensions.cs
new file mode 100644
index 00000000..32da8605
--- /dev/null
+++ b/dev-proxy/Logging/ILoggerBuilderExtensions.cs
@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using Microsoft.DevProxy.Abstractions;
+using Microsoft.DevProxy.Logging;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Microsoft.Extensions.Logging;
+
+public static class ILoggerBuilderExtensions
+{
+    public static ILoggingBuilder AddRequestLogger(this ILoggingBuilder builder, PluginEvents pluginEvents)
+    {
+        builder.Services.AddSingleton<ILoggerProvider, RequestLoggerProvider>(provider =>
+        {
+            return new RequestLoggerProvider(pluginEvents);
+        });
+
+        return builder;
+    }
+}
diff --git a/dev-proxy/Logging/ProxyConsoleFormatter.cs b/dev-proxy/Logging/ProxyConsoleFormatter.cs
new file mode 100644
index 00000000..91234205
--- /dev/null
+++ b/dev-proxy/Logging/ProxyConsoleFormatter.cs
@@ -0,0 +1,397 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Text;
+using Microsoft.DevProxy.Abstractions;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Logging.Console;
+using Microsoft.Extensions.Options;
+
+namespace Microsoft.DevProxy.Logging;
+
+public class ProxyConsoleFormatter : ConsoleFormatter
+{
+    private ProxyConsoleFormatterOptions _options { get; }
+    private const string _boxTopLeft = "\u256d ";
+    private const string _boxLeft = "\u2502 ";
+    private const string _boxBottomLeft = "\u2570 ";
+    // used to align single-line messages
+    private const string _boxSpacing = "  ";
+    const string _defaultForegroundColor = "\x1B[39m\x1B[22m";
+    const string _defaultBackgroundColor = "\x1B[49m";
+
+
+    public ProxyConsoleFormatter(IOptions<ProxyConsoleFormatterOptions> options) : base("devproxy")
+    {
+        // needed to properly required rounded corners in the box
+        Console.OutputEncoding = Encoding.UTF8;
+        _options = options.Value;
+    }
+
+    public override void Write<TState>(in LogEntry<TState> logEntry, IExternalScopeProvider? scopeProvider, TextWriter textWriter)
+    {
+        if (logEntry.State is RequestLog requestLog)
+        {
+            LogRequest(requestLog, scopeProvider, textWriter);
+        }
+        else
+        {
+            LogMessage(logEntry, scopeProvider, textWriter);
+        }
+    }
+
+    private void LogRequest(RequestLog requestLog, IExternalScopeProvider? scopeProvider, TextWriter textWriter)
+    {
+        var (message, messageType, _, method, url) = requestLog;
+
+        // don't log intercepted response to console
+        if (messageType == MessageType.InterceptedResponse)
+        {
+            return;
+        }
+
+        var messageLines = new List<string>(message);
+
+        // add request context information to the message for messages
+        // that are not intercepted requests and have a context
+        if (messageType != MessageType.InterceptedRequest &&
+            method is not null &&
+            url is not null)
+        {
+            messageLines.Add($"{method} {url}");
+        }
+
+        Action<string[], MessageType, TextWriter> writer = _options.LabelMode switch
+        {
+            LabelMode.Text => WriteBoxedWithInvertedLabels,
+            LabelMode.Icon => WriteBoxedWithAsciiIcons,
+            LabelMode.NerdFont => WriteBoxedWithNerdFontIcons,
+            _ => WriteBoxedWithInvertedLabels
+        };
+
+        writer(messageLines.ToArray(), messageType, textWriter);
+    }
+
+    private void LogMessage<TState>(in LogEntry<TState> logEntry, IExternalScopeProvider? scopeProvider, TextWriter textWriter)
+    {
+        // regular messages
+        var logLevel = logEntry.LogLevel;
+        var message = logEntry.Formatter(logEntry.State, logEntry.Exception);
+        var timestamp = DateTime.Now.ToString();
+
+        Action<string?, TextWriter> writer = logLevel switch
+        {
+            LogLevel.Information => WriteInformation,
+            LogLevel.Warning => WriteWarning,
+            LogLevel.Error => WriteError,
+            LogLevel.Debug => WriteDebug,
+            LogLevel.Trace => WriteInformation,
+            LogLevel.Critical => WriteInformation,
+            LogLevel.None => WriteInformation,
+            _ => WriteInformation
+        };
+        writer(message, textWriter);
+        
+        if (logEntry.Exception is not null)
+        {
+            textWriter.Write($" Exception Details: {logEntry.Exception}");
+        }
+
+        if (_options.IncludeScopes && scopeProvider is not null)
+        {
+            scopeProvider.ForEachScope((scope, state) =>
+            {
+                state.Write(" => ");
+                state.Write(scope);
+            }, textWriter);
+        }
+        textWriter.WriteLine();
+    }
+
+    private void WriteInformation(string? message, TextWriter writer)
+    {
+        writer.Write(message);
+    }
+
+    private void WriteWarning(string? message, TextWriter writer)
+    {
+        writer.Write(GetForegroundColorEscapeCode(ConsoleColor.Yellow));
+        writer.Write($"  WARNING: {message}");
+        writer.ResetColor();
+    }
+
+    private void WriteError(string? message, TextWriter writer)
+    {
+        writer.Write(GetForegroundColorEscapeCode(ConsoleColor.Red));
+        writer.Write(message);
+        writer.ResetColor();
+    }
+
+    private void WriteDebug(string? message, TextWriter writer)
+    {
+        writer.Write(GetForegroundColorEscapeCode(ConsoleColor.Gray));
+        writer.Write($"[{DateTime.Now}] {message}");
+        writer.ResetColor();   
+    }
+
+    private void WriteBoxedWithInvertedLabels(string[] message, MessageType messageType, TextWriter textWriter)
+    {
+        const string labelSpacing = "  ";
+        const string interceptedRequest = "request";
+        const string passedThrough = "api";
+        const string chaos = "chaos";
+        const string warning = "warning";
+        const string mock = "mock";
+        const string normal = "log";
+        const string fail = "fail";
+        const string tip = "tip";
+        var allLabels = new[] { interceptedRequest, passedThrough, chaos, warning, mock, normal, fail, tip };
+        var maxLabelLength = allLabels.Max(l => l.Length);
+        var noLabelSpacing = new string(' ', maxLabelLength + 2);
+
+        var label = normal;
+        var fgColor = Console.ForegroundColor;
+        var bgColor = Console.BackgroundColor;
+
+        switch (messageType)
+        {
+            case MessageType.InterceptedRequest:
+                label = interceptedRequest;
+                bgColor = ConsoleColor.DarkGray;
+                break;
+            case MessageType.PassedThrough:
+                label = passedThrough;
+                fgColor = ConsoleColor.Black;
+                bgColor = ConsoleColor.Gray;
+                break;
+            case MessageType.Chaos:
+                label = chaos;
+                fgColor = ConsoleColor.White;
+                bgColor = ConsoleColor.DarkRed;
+                break;
+            case MessageType.Warning:
+                label = warning;
+                fgColor = ConsoleColor.Black;
+                bgColor = ConsoleColor.Yellow;
+                break;
+            case MessageType.Mocked:
+                label = mock;
+                fgColor = ConsoleColor.Black;
+                bgColor = ConsoleColor.DarkYellow;
+                break;
+            case MessageType.Failed:
+                label = fail;
+                fgColor = ConsoleColor.Black;
+                bgColor = ConsoleColor.Red;
+                break;
+            case MessageType.Tip:
+                label = tip;
+                fgColor = ConsoleColor.White;
+                bgColor = ConsoleColor.Blue;
+                break;
+            case MessageType.Normal:
+                label = normal;
+                break;
+        }
+
+        var leadingSpaces = new string(' ', maxLabelLength - label.Length);
+
+        if (message.Length == 1)
+        {
+            // no need to box a single line message
+            textWriter.Write(leadingSpaces);
+            textWriter.Write(GetForegroundColorEscapeCode(fgColor));
+            textWriter.Write(GetBackgroundColorEscapeCode(bgColor));
+            textWriter.Write($" {label} ");
+            textWriter.ResetColor();
+            textWriter.WriteLine($"{labelSpacing}{_boxSpacing}{message[0]}");
+        }
+        else
+        {
+            for (var i = 0; i < message.Length; i++)
+            {
+                if (i == 0)
+                {
+                    // print label and top of the box
+                    textWriter.Write(leadingSpaces);
+                    textWriter.Write(GetForegroundColorEscapeCode(fgColor));
+                    textWriter.Write(GetBackgroundColorEscapeCode(bgColor));
+                    textWriter.Write($" {label} ");
+                    textWriter.ResetColor();
+                    textWriter.WriteLine($"{labelSpacing}{_boxTopLeft}{message[i]}");
+                }
+                else if (i < message.Length - 1)
+                {
+                    // print middle of the box
+                    textWriter.WriteLine($"{noLabelSpacing}{labelSpacing}{_boxLeft}{message[i]}");
+                }
+                else
+                {
+                    // print end of the box
+                    textWriter.WriteLine($"{noLabelSpacing}{labelSpacing}{_boxBottomLeft}{message[i]}");
+                }
+            }
+        }
+    }
+
+    private void WriteBoxedWithAsciiIcons(string[] message, MessageType messageType, TextWriter textWriter)
+    {
+        const string iconSpacing = "  ";
+        const string noIconSpacing = "   ";
+
+        // Set the icon based on the provided message type, using this switch statement
+        var icon = messageType switch
+        {
+            MessageType.InterceptedRequest => "← ←",
+            MessageType.PassedThrough => "↑ ↑",
+            MessageType.Chaos => "× →",
+            MessageType.Warning => "/!\\",
+            MessageType.Mocked => "o →",
+            MessageType.Failed => "! →",
+            MessageType.Tip => "(i)",
+            MessageType.Normal => "   ",
+            _ => "   "
+        };
+        // Set the foreground color based on the provided message type, using this switch statement
+        var fgColor = messageType switch
+        {
+            MessageType.PassedThrough => ConsoleColor.Gray,
+            MessageType.Chaos => ConsoleColor.DarkRed,
+            MessageType.Warning => ConsoleColor.Yellow,
+            MessageType.Mocked => ConsoleColor.DarkYellow,
+            MessageType.Failed => ConsoleColor.Red,
+            MessageType.Tip => ConsoleColor.Blue,
+            _ => Console.ForegroundColor
+        };
+
+        textWriter.Write(GetForegroundColorEscapeCode(fgColor));
+
+        if (message.Length == 1)
+        {
+            // no need to box a single line message
+            textWriter.WriteLine($"{icon}{iconSpacing}{_boxSpacing}{message[0]}");
+        }
+        else
+        {
+            for (var i = 0; i < message.Length; i++)
+            {
+                if (i == 0)
+                {
+                    // print label and top of the box
+                    textWriter.WriteLine($"{icon}{iconSpacing}{_boxTopLeft}{message[i]}");
+                }
+                else if (i < message.Length - 1)
+                {
+                    // print middle of the box
+                    textWriter.WriteLine($"{noIconSpacing}{iconSpacing}{_boxLeft}{message[i]}");
+                }
+                else
+                {
+                    // print end of the box
+                    textWriter.WriteLine($"{noIconSpacing}{iconSpacing}{_boxBottomLeft}{message[i]}");
+                }
+            }
+        }
+
+        textWriter.ResetColor();
+    }
+
+    private void WriteBoxedWithNerdFontIcons(string[] message, MessageType messageType, TextWriter textWriter)
+    {
+        const string iconSpacing = "  ";
+        const string noIconSpacing = " ";
+
+        // Set the icon based on the provided message type, using this switch statement
+        var icon = messageType switch
+        {
+            MessageType.InterceptedRequest => "\uf441",
+            MessageType.PassedThrough => "\ue33c",
+            MessageType.Chaos => "\uf188",
+            MessageType.Warning => "\uf421",
+            MessageType.Mocked => "\uf064",
+            MessageType.Failed => "\uf65b",
+            MessageType.Tip => "\ufbe6",
+            _ => " "
+        };
+        // Set the foreground color based on the provided message type, using this switch statement
+        var fgColor = messageType switch
+        {
+            MessageType.PassedThrough => ConsoleColor.Gray,
+            MessageType.Chaos => ConsoleColor.DarkRed,
+            MessageType.Warning => ConsoleColor.Yellow,
+            MessageType.Mocked => ConsoleColor.DarkYellow,
+            MessageType.Failed => ConsoleColor.Red,
+            MessageType.Tip => ConsoleColor.Blue,
+            _ => Console.ForegroundColor
+        };
+
+        textWriter.Write(GetForegroundColorEscapeCode(fgColor));
+
+        if (message.Length == 1)
+        {
+            // no need to box a single line message
+            textWriter.WriteLine($"{icon}{iconSpacing}{_boxSpacing}{message[0]}");
+        }
+        else
+        {
+            for (var i = 0; i < message.Length; i++)
+            {
+                if (i == 0)
+                {
+                    // print label and top of the box
+                    textWriter.WriteLine($"{icon}{iconSpacing}{_boxTopLeft}{message[i]}");
+                }
+                else if (i < message.Length - 1)
+                {
+                    // print middle of the box
+                    textWriter.WriteLine($"{noIconSpacing}{iconSpacing}{_boxLeft}{message[i]}");
+                }
+                else
+                {
+                    // print end of the box
+                    textWriter.WriteLine($"{noIconSpacing}{iconSpacing}{_boxBottomLeft}{message[i]}");
+                }
+            }
+        }
+
+        textWriter.ResetColor();
+    }
+
+    static string GetForegroundColorEscapeCode(ConsoleColor color) =>
+        color switch
+        {
+            ConsoleColor.Black => "\x1B[30m",
+            ConsoleColor.DarkRed => "\x1B[31m",
+            ConsoleColor.DarkGreen => "\x1B[32m",
+            ConsoleColor.DarkYellow => "\x1B[33m",
+            ConsoleColor.DarkBlue => "\x1B[34m",
+            ConsoleColor.DarkMagenta => "\x1B[35m",
+            ConsoleColor.DarkCyan => "\x1B[36m",
+            ConsoleColor.Gray => "\x1B[37m",
+            ConsoleColor.Red => "\x1B[1m\x1B[31m",
+            ConsoleColor.Green => "\x1B[1m\x1B[32m",
+            ConsoleColor.Yellow => "\x1B[1m\x1B[33m",
+            ConsoleColor.Blue => "\x1B[1m\x1B[34m",
+            ConsoleColor.Magenta => "\x1B[1m\x1B[35m",
+            ConsoleColor.Cyan => "\x1B[1m\x1B[36m",
+            ConsoleColor.White => "\x1B[1m\x1B[37m",
+
+            _ => _defaultForegroundColor
+        };
+
+    static string GetBackgroundColorEscapeCode(ConsoleColor color) =>
+        color switch
+        {
+            ConsoleColor.Black => "\x1B[40m",
+            ConsoleColor.DarkRed => "\x1B[41m",
+            ConsoleColor.DarkGreen => "\x1B[42m",
+            ConsoleColor.DarkYellow => "\x1B[43m",
+            ConsoleColor.DarkBlue => "\x1B[44m",
+            ConsoleColor.DarkMagenta => "\x1B[45m",
+            ConsoleColor.DarkCyan => "\x1B[46m",
+            ConsoleColor.Gray => "\x1B[47m",
+
+            _ => _defaultBackgroundColor
+        };
+}
\ No newline at end of file
diff --git a/dev-proxy/Logging/ProxyConsoleFormatterOptions.cs b/dev-proxy/Logging/ProxyConsoleFormatterOptions.cs
new file mode 100644
index 00000000..2102c7c3
--- /dev/null
+++ b/dev-proxy/Logging/ProxyConsoleFormatterOptions.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using Microsoft.DevProxy.Abstractions;
+using Microsoft.Extensions.Logging.Console;
+
+namespace Microsoft.DevProxy.Logging;
+
+public class ProxyConsoleFormatterOptions : ConsoleFormatterOptions
+{
+    public LabelMode LabelMode { get; set; } = LabelMode.Text;
+}
\ No newline at end of file
diff --git a/dev-proxy/Logging/RequestLogger.cs b/dev-proxy/Logging/RequestLogger.cs
new file mode 100644
index 00000000..6684a5b3
--- /dev/null
+++ b/dev-proxy/Logging/RequestLogger.cs
@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using Microsoft.DevProxy.Abstractions;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.DevProxy.Logging;
+
+public class RequestLogger : ILogger
+{
+    private readonly PluginEvents _pluginEvents;
+
+    public RequestLogger(PluginEvents pluginEvents)
+    {
+        _pluginEvents = pluginEvents;
+    }
+
+    public IDisposable? BeginScope<TState>(TState state) where TState : notnull => default;
+
+    public bool IsEnabled(LogLevel logLevel) => true;
+
+    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+    {
+        if (state is RequestLog requestLog)
+        {
+            _pluginEvents.RaiseRequestLogged(new RequestLogArgs(requestLog));
+        }
+    }
+}
\ No newline at end of file
diff --git a/dev-proxy/Logging/RequestLoggerProvider.cs b/dev-proxy/Logging/RequestLoggerProvider.cs
new file mode 100644
index 00000000..79b65bc6
--- /dev/null
+++ b/dev-proxy/Logging/RequestLoggerProvider.cs
@@ -0,0 +1,25 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Collections.Concurrent;
+using Microsoft.DevProxy.Abstractions;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.DevProxy.Logging;
+
+public class RequestLoggerProvider : ILoggerProvider
+{
+    private readonly PluginEvents _pluginEvents;
+    private readonly ConcurrentDictionary<string, RequestLogger> _loggers = new();
+
+    public RequestLoggerProvider(PluginEvents pluginEvents)
+    {
+        _pluginEvents = pluginEvents;
+    }
+
+    public ILogger CreateLogger(string categoryName) =>
+        _loggers.GetOrAdd(categoryName, name => new RequestLogger(_pluginEvents));
+
+
+    public void Dispose() => _loggers.Clear();
+}
\ No newline at end of file
diff --git a/dev-proxy/Logging/TextWriterExtensions.cs b/dev-proxy/Logging/TextWriterExtensions.cs
new file mode 100644
index 00000000..50bf5fbc
--- /dev/null
+++ b/dev-proxy/Logging/TextWriterExtensions.cs
@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace System.IO;
+
+public static class TextWriterExtensions
+{
+    const string _defaultForegroundColor = "\x1B[39m\x1B[22m";
+    const string _defaultBackgroundColor = "\x1B[49m";
+
+    public static void ResetColor(this TextWriter writer)
+    {
+        writer.Write(_defaultForegroundColor);
+        writer.Write(_defaultBackgroundColor);
+    }
+}
diff --git a/dev-proxy/MSGraphDbCommandHandler.cs b/dev-proxy/MSGraphDbCommandHandler.cs
index 1820aa56..0dc41414 100644
--- a/dev-proxy/MSGraphDbCommandHandler.cs
+++ b/dev-proxy/MSGraphDbCommandHandler.cs
@@ -3,14 +3,15 @@
 
 using System.CommandLine.Invocation;
 using Microsoft.DevProxy.Abstractions;
+using Microsoft.Extensions.Logging;
 
 namespace Microsoft.DevProxy;
 
 public class MSGraphDbCommandHandler : ICommandHandler
 {
-    private readonly IProxyLogger _logger;
+    private readonly ILogger _logger;
 
-    public MSGraphDbCommandHandler(IProxyLogger logger)
+    public MSGraphDbCommandHandler(ILogger logger)
     {
         _logger = logger;
     }
diff --git a/dev-proxy/PluginLoader.cs b/dev-proxy/PluginLoader.cs
index 93eacbc3..48841899 100644
--- a/dev-proxy/PluginLoader.cs
+++ b/dev-proxy/PluginLoader.cs
@@ -22,7 +22,10 @@ public PluginLoaderResult(ISet<UrlToWatch> urlsToWatch, IEnumerable<IProxyPlugin
 
 internal class PluginLoader
 {
-    public PluginLoader(IProxyLogger logger)
+    private PluginConfig? _pluginConfig;
+    private ILogger _logger;
+
+    public PluginLoader(ILogger logger)
     {
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
     }
@@ -80,15 +83,22 @@ public PluginLoaderResult LoadPlugins(IPluginEvents pluginEvents, IProxyContext
             : throw new InvalidDataException("No plugins were loaded");
     }
 
-    private IProxyPlugin CreatePlugin(Assembly assembly, PluginReference h)
+    private IProxyPlugin CreatePlugin(
+        Assembly assembly,
+        PluginReference pluginReference,
+        IPluginEvents pluginEvents,
+        IProxyContext context,
+        ISet<UrlToWatch> urlsToWatch,
+        IConfigurationSection? configSection = null
+    )
     {
         foreach (Type type in assembly.GetTypes())
         {
             if (type.Name == h.Name &&
                 typeof(IProxyPlugin).IsAssignableFrom(type))
             {
-                IProxyPlugin? result = Activator.CreateInstance(type) as IProxyPlugin;
-                if (result is not null && result.Name == h.Name)
+                IProxyPlugin? result = Activator.CreateInstance(type, [pluginEvents, context, _logger, urlsToWatch, configSection]) as IProxyPlugin;
+                if (result is not null && result.Name == pluginReference.Name)
                 {
                     return result;
                 }
@@ -97,7 +107,7 @@ private IProxyPlugin CreatePlugin(Assembly assembly, PluginReference h)
 
         string availableTypes = string.Join(",", assembly.GetTypes().Select(t => t.FullName));
         throw new ApplicationException(
-            $"Can't find plugin {h.Name} which implements IProxyPlugin in {assembly} from {AppContext.BaseDirectory}.\r\n" +
+            $"Can't find plugin {pluginReference.Name} which implements IProxyPlugin in {assembly} from {AppContext.BaseDirectory}.\r\n" +
             $"Available types: {availableTypes}");
     }
 
@@ -116,9 +126,6 @@ public static UrlToWatch ConvertToRegex(string stringMatcher)
         );
     }
 
-    private PluginConfig? _pluginConfig;
-    private IProxyLogger _logger;
-
     private PluginConfig PluginConfig
     {
         get
diff --git a/dev-proxy/PresetGetCommandHandler.cs b/dev-proxy/PresetGetCommandHandler.cs
index f5cb5090..750464a7 100644
--- a/dev-proxy/PresetGetCommandHandler.cs
+++ b/dev-proxy/PresetGetCommandHandler.cs
@@ -28,7 +28,7 @@ class GitHubTreeItem
 
 public static class PresetGetCommandHandler
 {
-    public static async Task DownloadPreset(string presetId, IProxyLogger logger)
+    public static async Task DownloadPreset(string presetId, ILogger logger)
     {
         try
         {
@@ -106,7 +106,7 @@ public static async Task DownloadPreset(string presetId, IProxyLogger logger)
     /// </remarks>
     /// <param name="presetFolder">Full path to the folder with preset files</param>
     /// <returns>Array of files that can be used to start proxy with</returns>
-    private static ProxyPresetInfo GetPresetInfo(string presetFolder, IProxyLogger logger)
+    private static ProxyPresetInfo GetPresetInfo(string presetFolder, ILogger logger)
     {
         var presetInfo = new ProxyPresetInfo();
 
@@ -162,7 +162,7 @@ private static string GetTargetFolderPath(string appFolder, string presetId)
         return newFolder;
     }
 
-    private static async Task<string[]> GetFilesToDownload(string sampleFolderName, IProxyLogger logger)
+    private static async Task<string[]> GetFilesToDownload(string sampleFolderName, ILogger logger)
     {
         logger.LogDebug("Getting list of files in Dev Proxy samples repo...");
         var url = $"https://api.github.com/repos/pnp/proxy-samples/git/trees/main?recursive=1";
@@ -199,7 +199,7 @@ private static async Task<string[]> GetFilesToDownload(string sampleFolderName,
         }
     }
 
-    private static async Task DownloadFile(string filePath, string targetFolderPath, string presetId, IProxyLogger logger)
+    private static async Task DownloadFile(string filePath, string targetFolderPath, string presetId, ILogger logger)
     {
         var url = $"https://raw.githubusercontent.com/pnp/proxy-samples/main/{filePath.Replace("#", "%23")}";
         logger.LogDebug("Downloading file {filePath}...", filePath);
diff --git a/dev-proxy/Program.cs b/dev-proxy/Program.cs
index 9f33b265..1f2e5c6c 100644
--- a/dev-proxy/Program.cs
+++ b/dev-proxy/Program.cs
@@ -3,17 +3,38 @@
 
 using Microsoft.DevProxy;
 using Microsoft.DevProxy.Abstractions;
+using Microsoft.DevProxy.Logging;
 using Microsoft.Extensions.Logging;
 using System.CommandLine;
 
 PluginEvents pluginEvents = new PluginEvents();
-IProxyLogger logger = new ConsoleLogger(ProxyCommandHandler.Configuration, pluginEvents);
-// set the log level if specified through args
-if (ProxyHost.LogLevel is not null)
+
+ILogger BuildLogger()
 {
-    logger.LogLevel = ProxyHost.LogLevel.Value;
+    var formatterOptions = new ProxyConsoleFormatterOptions
+    {
+        LabelMode = ProxyCommandHandler.Configuration.LabelMode
+    };
+
+    var loggerFactory = LoggerFactory.Create(builder =>
+    {
+        builder
+            .AddConsole(options =>
+            {
+                options.FormatterName = "devproxy";
+            })
+            .AddConsoleFormatter<ProxyConsoleFormatter, ProxyConsoleFormatterOptions>(options => {
+                options.LabelMode = formatterOptions.LabelMode;
+            })
+            .AddRequestLogger(pluginEvents)
+            .AddFilter("Default", ProxyHost.LogLevel ?? ProxyCommandHandler.Configuration.LogLevel);
+    });
+    return loggerFactory.CreateLogger("devproxy");
 }
-IProxyContext context = new ProxyContext(logger, ProxyCommandHandler.Configuration, ProxyEngine.Certificate);
+
+var logger = BuildLogger();
+
+IProxyContext context = new ProxyContext(ProxyCommandHandler.Configuration, ProxyEngine.Certificate);
 ProxyHost proxyHost = new();
 
 // this is where the root command is created which contains all commands and subcommands
@@ -21,7 +42,7 @@
 
 // store the global options that are created automatically for us
 // rootCommand doesn't return the global options, so we have to store them manually
-string[] globalOptions = { "--version", "--help", "-h", "/h", "-?", "/?" };
+string[] globalOptions = ["--version", "--help", "-h", "/h", "-?", "/?"];
 
 // check if any of the global options are present
 var hasGlobalOption = args.Any(arg => globalOptions.Contains(arg));
diff --git a/dev-proxy/ProxyCommandHandler.cs b/dev-proxy/ProxyCommandHandler.cs
index 8d82196d..6769b533 100755
--- a/dev-proxy/ProxyCommandHandler.cs
+++ b/dev-proxy/ProxyCommandHandler.cs
@@ -14,12 +14,12 @@ public class ProxyCommandHandler : ICommandHandler
     private readonly PluginEvents _pluginEvents;
     private readonly Option[] _options;
     private readonly ISet<UrlToWatch> _urlsToWatch;
-    private readonly IProxyLogger _logger;
+    private readonly ILogger _logger;
 
     public ProxyCommandHandler(PluginEvents pluginEvents,
                                Option[] options,
                                ISet<UrlToWatch> urlsToWatch,
-                               IProxyLogger logger)
+                               ILogger logger)
     {
         _pluginEvents = pluginEvents ?? throw new ArgumentNullException(nameof(pluginEvents));
         _options = options ?? throw new ArgumentNullException(nameof(options));
@@ -44,11 +44,6 @@ public async Task<int> InvokeAsync(InvocationContext context)
         {
             Configuration.IPAddress = ipAddress;
         }
-        var logLevel = context.ParseResult.GetValueForOption<LogLevel?>(ProxyHost.LogLevelOptionName, _options);
-        if (logLevel is not null)
-        {
-            _logger.LogLevel = logLevel.Value;
-        }
         var record = context.ParseResult.GetValueForOption<bool?>(ProxyHost.RecordOptionName, _options);
         if (record is not null)
         {
diff --git a/dev-proxy/ProxyContext.cs b/dev-proxy/ProxyContext.cs
index ac8145ea..0ffa741e 100644
--- a/dev-proxy/ProxyContext.cs
+++ b/dev-proxy/ProxyContext.cs
@@ -8,13 +8,11 @@ namespace Microsoft.DevProxy;
 
 internal class ProxyContext : IProxyContext
 {
-    public IProxyLogger Logger { get; }
     public IProxyConfiguration Configuration { get; }
     public X509Certificate2? Certificate { get; }
 
-    public ProxyContext(IProxyLogger logger, IProxyConfiguration configuration, X509Certificate2? certificate)
+    public ProxyContext(IProxyConfiguration configuration, X509Certificate2? certificate)
     {
-        Logger = logger ?? throw new ArgumentNullException(nameof(logger));
         Configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
         Certificate = certificate;
     }
diff --git a/dev-proxy/ProxyEngine.cs b/dev-proxy/ProxyEngine.cs
index 4229e20c..2315fac3 100755
--- a/dev-proxy/ProxyEngine.cs
+++ b/dev-proxy/ProxyEngine.cs
@@ -24,7 +24,7 @@ enum ToggleSystemProxyAction
 public class ProxyEngine
 {
     private readonly PluginEvents _pluginEvents;
-    private readonly IProxyLogger _logger;
+    private readonly ILogger _logger;
     private readonly ProxyConfiguration _config;
     private static ProxyServer? _proxyServer;
     private ExplicitProxyEndPoint? _explicitEndPoint;
@@ -58,7 +58,7 @@ static ProxyEngine()
         _proxyServer.CertificateManager.CreateRootCertificate();
     }
 
-    public ProxyEngine(ProxyConfiguration config, ISet<UrlToWatch> urlsToWatch, PluginEvents pluginEvents, IProxyLogger logger)
+    public ProxyEngine(ProxyConfiguration config, ISet<UrlToWatch> urlsToWatch, PluginEvents pluginEvents, ILogger logger)
     {
         _config = config ?? throw new ArgumentNullException(nameof(config));
         _urlsToWatch = urlsToWatch ?? throw new ArgumentNullException(nameof(urlsToWatch));
@@ -293,7 +293,7 @@ await _pluginEvents.RaiseRecordingStopped(new RecordingArgs(clonedLogs)
 
     private void PrintRecordingIndicator()
     {
-        lock (ConsoleLogger.ConsoleLock)
+        lock (consoleLock)
         {
             if (_isRecording)
             {
diff --git a/dev-proxy/ProxyHost.cs b/dev-proxy/ProxyHost.cs
index 4f29ad50..623f46e1 100755
--- a/dev-proxy/ProxyHost.cs
+++ b/dev-proxy/ProxyHost.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT License.
 
 using Microsoft.DevProxy.Abstractions;
-using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using System.CommandLine;
 using System.Net;
@@ -261,7 +260,7 @@ public ProxyHost()
         ProxyCommandHandler.Configuration.ConfigFile = ConfigFile;
     }
 
-    public RootCommand GetRootCommand(IProxyLogger logger)
+    public RootCommand GetRootCommand(ILogger logger)
     {
         var command = new RootCommand {
             _portOption,
@@ -311,7 +310,7 @@ public RootCommand GetRootCommand(IProxyLogger logger)
         return command;
     }
 
-    public ProxyCommandHandler GetCommandHandler(PluginEvents pluginEvents, Option[] optionsFromPlugins, ISet<UrlToWatch> urlsToWatch, IProxyLogger logger) => new ProxyCommandHandler(
+    public ProxyCommandHandler GetCommandHandler(PluginEvents pluginEvents, Option[] optionsFromPlugins, ISet<UrlToWatch> urlsToWatch, ILogger logger) => new ProxyCommandHandler(
         pluginEvents,
         new Option[] {
             _portOption,
diff --git a/dev-proxy/dev-proxy.csproj b/dev-proxy/dev-proxy.csproj
index 2cbd5017..bfc83a1a 100644
--- a/dev-proxy/dev-proxy.csproj
+++ b/dev-proxy/dev-proxy.csproj
@@ -34,6 +34,7 @@
     <PackageReference Include="Microsoft.Extensions.Configuration" Version="8.0.0" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="8.0.1" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="8.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="8.0.0" />
     <PackageReference Include="Microsoft.IdentityModel.Protocols.OpenIdConnect" Version="7.5.2" />
     <PackageReference Include="Microsoft.OpenApi.Readers" Version="1.6.14" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />

From a1f952ce937870d58d5897bc5a41986c345efe7f Mon Sep 17 00:00:00 2001
From: waldekmastykarz <waldek@mastykarz.nl>
Date: Wed, 8 May 2024 10:40:44 +0200
Subject: [PATCH 2/3] Prints grouped log messages to console

---
 dev-proxy-abstractions/IProxyLogger.cs        |   4 +-
 dev-proxy/Logging/AnsiParser.cs               |  51 +++
 dev-proxy/Logging/ILoggerExtensions.cs        |  15 +
 dev-proxy/Logging/ProxyConsoleFormatter.cs    | 395 ++++++------------
 .../Logging/ProxyConsoleFormatterOptions.cs   |  12 -
 dev-proxy/Logging/TextWriterExtensions.cs     |  26 +-
 dev-proxy/Program.cs                          |  13 +-
 dev-proxy/ProxyEngine.cs                      |  14 +-
 dev-proxy/devproxyrc.json                     |   1 -
 9 files changed, 236 insertions(+), 295 deletions(-)
 create mode 100644 dev-proxy/Logging/AnsiParser.cs
 create mode 100644 dev-proxy/Logging/ILoggerExtensions.cs
 delete mode 100644 dev-proxy/Logging/ProxyConsoleFormatterOptions.cs

diff --git a/dev-proxy-abstractions/IProxyLogger.cs b/dev-proxy-abstractions/IProxyLogger.cs
index 76967516..a335f3d5 100644
--- a/dev-proxy-abstractions/IProxyLogger.cs
+++ b/dev-proxy-abstractions/IProxyLogger.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT License.
 using Titanium.Web.Proxy.EventArguments;
 using Microsoft.Extensions.Logging;
-using System.Text.Json.Serialization;
 
 namespace Microsoft.DevProxy.Abstractions;
 
@@ -16,7 +15,8 @@ public enum MessageType
     Failed,
     Chaos,
     Mocked,
-    InterceptedResponse
+    InterceptedResponse,
+    FinishedProcessingRequest
 }
 
 public class LoggingContext
diff --git a/dev-proxy/Logging/AnsiParser.cs b/dev-proxy/Logging/AnsiParser.cs
new file mode 100644
index 00000000..02d9fc86
--- /dev/null
+++ b/dev-proxy/Logging/AnsiParser.cs
@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License
+
+// from https://github.com/dotnet/runtime/blob/e1c671760e23de03ee4be74eeb26831813488100/src/libraries/Microsoft.Extensions.Logging.Console/src/AnsiParser.cs
+
+namespace Microsoft.DevProxy.Logging;
+
+internal static class AnsiParser
+{
+  internal const string DefaultForegroundColor = "\x1B[39m\x1B[22m"; // reset to default foreground color
+  internal const string DefaultBackgroundColor = "\x1B[49m"; // reset to the background color
+
+  internal static string GetForegroundColorEscapeCode(ConsoleColor color)
+  {
+    return color switch
+    {
+      ConsoleColor.Black => "\x1B[30m",
+      ConsoleColor.DarkRed => "\x1B[31m",
+      ConsoleColor.DarkGreen => "\x1B[32m",
+      ConsoleColor.DarkYellow => "\x1B[33m",
+      ConsoleColor.DarkBlue => "\x1B[34m",
+      ConsoleColor.DarkMagenta => "\x1B[35m",
+      ConsoleColor.DarkCyan => "\x1B[36m",
+      ConsoleColor.Gray => "\x1B[37m",
+      ConsoleColor.Red => "\x1B[1m\x1B[31m",
+      ConsoleColor.Green => "\x1B[1m\x1B[32m",
+      ConsoleColor.Yellow => "\x1B[1m\x1B[33m",
+      ConsoleColor.Blue => "\x1B[1m\x1B[34m",
+      ConsoleColor.Magenta => "\x1B[1m\x1B[35m",
+      ConsoleColor.Cyan => "\x1B[1m\x1B[36m",
+      ConsoleColor.White => "\x1B[1m\x1B[37m",
+      _ => DefaultForegroundColor // default foreground color
+    };
+  }
+
+  internal static string GetBackgroundColorEscapeCode(ConsoleColor color)
+  {
+    return color switch
+    {
+      ConsoleColor.Black => "\x1B[40m",
+      ConsoleColor.DarkRed => "\x1B[41m",
+      ConsoleColor.DarkGreen => "\x1B[42m",
+      ConsoleColor.DarkYellow => "\x1B[43m",
+      ConsoleColor.DarkBlue => "\x1B[44m",
+      ConsoleColor.DarkMagenta => "\x1B[45m",
+      ConsoleColor.DarkCyan => "\x1B[46m",
+      ConsoleColor.Gray => "\x1B[47m",
+      _ => DefaultBackgroundColor // Use default background color
+    };
+  }
+}
\ No newline at end of file
diff --git a/dev-proxy/Logging/ILoggerExtensions.cs b/dev-proxy/Logging/ILoggerExtensions.cs
new file mode 100644
index 00000000..582dddfa
--- /dev/null
+++ b/dev-proxy/Logging/ILoggerExtensions.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License
+
+namespace Microsoft.Extensions.Logging;
+
+public static class ILoggerExtensions
+{
+    public static IDisposable? BeginScope(this ILogger logger, string method, string url, int requestId) =>
+      logger.BeginScope(new Dictionary<string, object>
+      {
+          { nameof(method), method },
+          { nameof(url), url },
+          { nameof(requestId), requestId }
+      });
+}
\ No newline at end of file
diff --git a/dev-proxy/Logging/ProxyConsoleFormatter.cs b/dev-proxy/Logging/ProxyConsoleFormatter.cs
index 91234205..72b00d52 100644
--- a/dev-proxy/Logging/ProxyConsoleFormatter.cs
+++ b/dev-proxy/Logging/ProxyConsoleFormatter.cs
@@ -12,17 +12,29 @@ namespace Microsoft.DevProxy.Logging;
 
 public class ProxyConsoleFormatter : ConsoleFormatter
 {
-    private ProxyConsoleFormatterOptions _options { get; }
     private const string _boxTopLeft = "\u256d ";
     private const string _boxLeft = "\u2502 ";
     private const string _boxBottomLeft = "\u2570 ";
     // used to align single-line messages
     private const string _boxSpacing = "  ";
-    const string _defaultForegroundColor = "\x1B[39m\x1B[22m";
-    const string _defaultBackgroundColor = "\x1B[49m";
-
-
-    public ProxyConsoleFormatter(IOptions<ProxyConsoleFormatterOptions> options) : base("devproxy")
+    private Dictionary<int, List<RequestLog>> _requestLogs = new();
+    private ConsoleFormatterOptions _options;
+    const string labelSpacing = "  ";
+    const string interceptedRequest = "request";
+    const string passedThrough = "api";
+    const string chaos = "chaos";
+    const string warning = "warning";
+    const string mock = "mock";
+    const string normal = "log";
+    const string fail = "fail";
+    const string tip = "tip";
+    const string error = "error";
+    const string info = "info";
+    private readonly static string[] allLabels = [interceptedRequest, passedThrough, chaos, warning, mock, normal, fail, tip];
+    private readonly static int maxLabelLength = allLabels.Max(l => l.Length);
+    private readonly static string noLabelSpacing = new string(' ', maxLabelLength + 2);
+
+    public ProxyConsoleFormatter(IOptions<ConsoleFormatterOptions> options) : base("devproxy")
     {
         // needed to properly required rounded corners in the box
         Console.OutputEncoding = Encoding.UTF8;
@@ -43,7 +55,7 @@ public override void Write<TState>(in LogEntry<TState> logEntry, IExternalScopeP
 
     private void LogRequest(RequestLog requestLog, IExternalScopeProvider? scopeProvider, TextWriter textWriter)
     {
-        var (message, messageType, _, method, url) = requestLog;
+        var messageType = requestLog.MessageType;
 
         // don't log intercepted response to console
         if (messageType == MessageType.InterceptedResponse)
@@ -51,26 +63,48 @@ private void LogRequest(RequestLog requestLog, IExternalScopeProvider? scopeProv
             return;
         }
 
-        var messageLines = new List<string>(message);
+        var requestId = GetRequestIdScope(scopeProvider);
 
-        // add request context information to the message for messages
-        // that are not intercepted requests and have a context
-        if (messageType != MessageType.InterceptedRequest &&
-            method is not null &&
-            url is not null)
+        if (requestId is not null)
         {
-            messageLines.Add($"{method} {url}");
+            if (messageType == MessageType.FinishedProcessingRequest)
+            {
+                var lastMessage = _requestLogs[requestId.Value].Last();
+                // log all request logs for the request
+                foreach (var log in _requestLogs[requestId.Value])
+                {
+                    WriteLogMessageBoxedWithInvertedLabels(log.MessageLines, log.MessageType, textWriter, log == lastMessage);
+                }
+                _requestLogs.Remove(requestId.Value);
+            }
+            else
+            {
+                // buffer request logs until the request is finished processing
+                if (!_requestLogs.ContainsKey(requestId.Value))
+                {
+                    _requestLogs[requestId.Value] = new();
+                }
+                _requestLogs[requestId.Value].Add(requestLog);
+            }
         }
+    }
 
-        Action<string[], MessageType, TextWriter> writer = _options.LabelMode switch
+    private int? GetRequestIdScope(IExternalScopeProvider? scopeProvider)
+    {
+        int? requestId = null;
+
+        scopeProvider?.ForEachScope((scope, state) =>
         {
-            LabelMode.Text => WriteBoxedWithInvertedLabels,
-            LabelMode.Icon => WriteBoxedWithAsciiIcons,
-            LabelMode.NerdFont => WriteBoxedWithNerdFontIcons,
-            _ => WriteBoxedWithInvertedLabels
-        };
+            if (scope is Dictionary<string, object> dictionary)
+            {
+                if (dictionary.TryGetValue(nameof(requestId), out var req))
+                {
+                    requestId = (int)req;
+                }
+            }
+        }, "");
 
-        writer(messageLines.ToArray(), messageType, textWriter);
+        return requestId;
     }
 
     private void LogMessage<TState>(in LogEntry<TState> logEntry, IExternalScopeProvider? scopeProvider, TextWriter textWriter)
@@ -78,21 +112,9 @@ private void LogMessage<TState>(in LogEntry<TState> logEntry, IExternalScopeProv
         // regular messages
         var logLevel = logEntry.LogLevel;
         var message = logEntry.Formatter(logEntry.State, logEntry.Exception);
-        var timestamp = DateTime.Now.ToString();
 
-        Action<string?, TextWriter> writer = logLevel switch
-        {
-            LogLevel.Information => WriteInformation,
-            LogLevel.Warning => WriteWarning,
-            LogLevel.Error => WriteError,
-            LogLevel.Debug => WriteDebug,
-            LogLevel.Trace => WriteInformation,
-            LogLevel.Critical => WriteInformation,
-            LogLevel.None => WriteInformation,
-            _ => WriteInformation
-        };
-        writer(message, textWriter);
-        
+        WriteMessageBoxedWithInvertedLabels(message, logLevel, textWriter);
+
         if (logEntry.Exception is not null)
         {
             textWriter.Write($" Exception Details: {logEntry.Exception}");
@@ -109,47 +131,44 @@ private void LogMessage<TState>(in LogEntry<TState> logEntry, IExternalScopeProv
         textWriter.WriteLine();
     }
 
-    private void WriteInformation(string? message, TextWriter writer)
+    private void WriteMessageBoxedWithInvertedLabels(string? message, LogLevel logLevel, TextWriter textWriter)
     {
-        writer.Write(message);
-    }
+        var label = normal;
+        var fgColor = Console.ForegroundColor;
+        var bgColor = Console.BackgroundColor;
 
-    private void WriteWarning(string? message, TextWriter writer)
-    {
-        writer.Write(GetForegroundColorEscapeCode(ConsoleColor.Yellow));
-        writer.Write($"  WARNING: {message}");
-        writer.ResetColor();
-    }
+        switch (logLevel)
+        {
+            case LogLevel.Information:
+                label = info;
+                fgColor = ConsoleColor.Blue;
+                break;
+            case LogLevel.Warning:
+                label = warning;
+                bgColor = ConsoleColor.DarkYellow;
+                break;
+            case LogLevel.Error:
+                label = error;
+                bgColor = ConsoleColor.DarkRed;
+                break;
+            case LogLevel.Debug:
+                label = "debug";
+                fgColor = ConsoleColor.Gray;
+                break;
+        }
 
-    private void WriteError(string? message, TextWriter writer)
-    {
-        writer.Write(GetForegroundColorEscapeCode(ConsoleColor.Red));
-        writer.Write(message);
-        writer.ResetColor();
-    }
+        var leadingSpaces = new string(' ', maxLabelLength - label.Length);
 
-    private void WriteDebug(string? message, TextWriter writer)
-    {
-        writer.Write(GetForegroundColorEscapeCode(ConsoleColor.Gray));
-        writer.Write($"[{DateTime.Now}] {message}");
-        writer.ResetColor();   
+        if (message is not null)
+        {
+            textWriter.Write(leadingSpaces);
+            textWriter.WriteColoredMessage($" {label} ", bgColor, fgColor);
+            textWriter.Write($"{labelSpacing}{_boxSpacing}{message}");
+        }
     }
 
-    private void WriteBoxedWithInvertedLabels(string[] message, MessageType messageType, TextWriter textWriter)
+    private void WriteLogMessageBoxedWithInvertedLabels(string[] message, MessageType messageType, TextWriter textWriter, bool lastMessage = false)
     {
-        const string labelSpacing = "  ";
-        const string interceptedRequest = "request";
-        const string passedThrough = "api";
-        const string chaos = "chaos";
-        const string warning = "warning";
-        const string mock = "mock";
-        const string normal = "log";
-        const string fail = "fail";
-        const string tip = "tip";
-        var allLabels = new[] { interceptedRequest, passedThrough, chaos, warning, mock, normal, fail, tip };
-        var maxLabelLength = allLabels.Max(l => l.Length);
-        var noLabelSpacing = new string(' ', maxLabelLength + 2);
-
         var label = normal;
         var fgColor = Console.ForegroundColor;
         var bgColor = Console.BackgroundColor;
@@ -158,37 +177,31 @@ private void WriteBoxedWithInvertedLabels(string[] message, MessageType messageT
         {
             case MessageType.InterceptedRequest:
                 label = interceptedRequest;
-                bgColor = ConsoleColor.DarkGray;
+                fgColor = ConsoleColor.Gray;
                 break;
             case MessageType.PassedThrough:
                 label = passedThrough;
-                fgColor = ConsoleColor.Black;
                 bgColor = ConsoleColor.Gray;
                 break;
             case MessageType.Chaos:
                 label = chaos;
-                fgColor = ConsoleColor.White;
                 bgColor = ConsoleColor.DarkRed;
                 break;
             case MessageType.Warning:
                 label = warning;
-                fgColor = ConsoleColor.Black;
-                bgColor = ConsoleColor.Yellow;
+                bgColor = ConsoleColor.DarkYellow;
                 break;
             case MessageType.Mocked:
                 label = mock;
-                fgColor = ConsoleColor.Black;
-                bgColor = ConsoleColor.DarkYellow;
+                bgColor = ConsoleColor.DarkMagenta;
                 break;
             case MessageType.Failed:
                 label = fail;
-                fgColor = ConsoleColor.Black;
-                bgColor = ConsoleColor.Red;
+                bgColor = ConsoleColor.DarkRed;
                 break;
             case MessageType.Tip:
                 label = tip;
-                fgColor = ConsoleColor.White;
-                bgColor = ConsoleColor.Blue;
+                bgColor = ConsoleColor.DarkBlue;
                 break;
             case MessageType.Normal:
                 label = normal;
@@ -197,201 +210,47 @@ private void WriteBoxedWithInvertedLabels(string[] message, MessageType messageT
 
         var leadingSpaces = new string(' ', maxLabelLength - label.Length);
 
-        if (message.Length == 1)
-        {
-            // no need to box a single line message
-            textWriter.Write(leadingSpaces);
-            textWriter.Write(GetForegroundColorEscapeCode(fgColor));
-            textWriter.Write(GetBackgroundColorEscapeCode(bgColor));
-            textWriter.Write($" {label} ");
-            textWriter.ResetColor();
-            textWriter.WriteLine($"{labelSpacing}{_boxSpacing}{message[0]}");
-        }
-        else
+        switch (messageType)
         {
-            for (var i = 0; i < message.Length; i++)
-            {
-                if (i == 0)
+            case MessageType.InterceptedRequest:
+                // always one line (method + URL)
+                // print label and top of the box
+                textWriter.WriteLine();
+                textWriter.Write(leadingSpaces);
+                textWriter.WriteColoredMessage($" {label} ", bgColor, fgColor);
+                textWriter.WriteLine($"{labelSpacing}{_boxTopLeft}{message[0]}");
+                break;
+            default:
+                if (message.Length == 1)
                 {
-                    // print label and top of the box
                     textWriter.Write(leadingSpaces);
-                    textWriter.Write(GetForegroundColorEscapeCode(fgColor));
-                    textWriter.Write(GetBackgroundColorEscapeCode(bgColor));
-                    textWriter.Write($" {label} ");
-                    textWriter.ResetColor();
-                    textWriter.WriteLine($"{labelSpacing}{_boxTopLeft}{message[i]}");
-                }
-                else if (i < message.Length - 1)
-                {
-                    // print middle of the box
-                    textWriter.WriteLine($"{noLabelSpacing}{labelSpacing}{_boxLeft}{message[i]}");
+                    textWriter.WriteColoredMessage($" {label} ", bgColor, fgColor);
+                    textWriter.WriteLine($"{labelSpacing}{(lastMessage ? _boxBottomLeft : _boxLeft)}{message[0]}");
                 }
                 else
                 {
-                    // print end of the box
-                    textWriter.WriteLine($"{noLabelSpacing}{labelSpacing}{_boxBottomLeft}{message[i]}");
+                    for (var i = 0; i < message.Length; i++)
+                    {
+                        if (i == 0)
+                        {
+                            // print label and middle of the box
+                            textWriter.Write(leadingSpaces);
+                            textWriter.WriteColoredMessage($" {label} ", bgColor, fgColor);
+                            textWriter.WriteLine($"{labelSpacing}{_boxLeft}{message[i]}");
+                        }
+                        else if (i < message.Length - 1)
+                        {
+                            // print middle of the box
+                            textWriter.WriteLine($"{noLabelSpacing}{labelSpacing}{_boxLeft}{message[i]}");
+                        }
+                        else
+                        {
+                            // print end of the box
+                            textWriter.WriteLine($"{noLabelSpacing}{labelSpacing}{(lastMessage ? _boxBottomLeft : _boxLeft)}{message[i]}");
+                        }
+                    }
                 }
-            }
-        }
-    }
-
-    private void WriteBoxedWithAsciiIcons(string[] message, MessageType messageType, TextWriter textWriter)
-    {
-        const string iconSpacing = "  ";
-        const string noIconSpacing = "   ";
-
-        // Set the icon based on the provided message type, using this switch statement
-        var icon = messageType switch
-        {
-            MessageType.InterceptedRequest => "← ←",
-            MessageType.PassedThrough => "↑ ↑",
-            MessageType.Chaos => "× →",
-            MessageType.Warning => "/!\\",
-            MessageType.Mocked => "o →",
-            MessageType.Failed => "! →",
-            MessageType.Tip => "(i)",
-            MessageType.Normal => "   ",
-            _ => "   "
-        };
-        // Set the foreground color based on the provided message type, using this switch statement
-        var fgColor = messageType switch
-        {
-            MessageType.PassedThrough => ConsoleColor.Gray,
-            MessageType.Chaos => ConsoleColor.DarkRed,
-            MessageType.Warning => ConsoleColor.Yellow,
-            MessageType.Mocked => ConsoleColor.DarkYellow,
-            MessageType.Failed => ConsoleColor.Red,
-            MessageType.Tip => ConsoleColor.Blue,
-            _ => Console.ForegroundColor
-        };
-
-        textWriter.Write(GetForegroundColorEscapeCode(fgColor));
-
-        if (message.Length == 1)
-        {
-            // no need to box a single line message
-            textWriter.WriteLine($"{icon}{iconSpacing}{_boxSpacing}{message[0]}");
-        }
-        else
-        {
-            for (var i = 0; i < message.Length; i++)
-            {
-                if (i == 0)
-                {
-                    // print label and top of the box
-                    textWriter.WriteLine($"{icon}{iconSpacing}{_boxTopLeft}{message[i]}");
-                }
-                else if (i < message.Length - 1)
-                {
-                    // print middle of the box
-                    textWriter.WriteLine($"{noIconSpacing}{iconSpacing}{_boxLeft}{message[i]}");
-                }
-                else
-                {
-                    // print end of the box
-                    textWriter.WriteLine($"{noIconSpacing}{iconSpacing}{_boxBottomLeft}{message[i]}");
-                }
-            }
-        }
-
-        textWriter.ResetColor();
-    }
-
-    private void WriteBoxedWithNerdFontIcons(string[] message, MessageType messageType, TextWriter textWriter)
-    {
-        const string iconSpacing = "  ";
-        const string noIconSpacing = " ";
-
-        // Set the icon based on the provided message type, using this switch statement
-        var icon = messageType switch
-        {
-            MessageType.InterceptedRequest => "\uf441",
-            MessageType.PassedThrough => "\ue33c",
-            MessageType.Chaos => "\uf188",
-            MessageType.Warning => "\uf421",
-            MessageType.Mocked => "\uf064",
-            MessageType.Failed => "\uf65b",
-            MessageType.Tip => "\ufbe6",
-            _ => " "
-        };
-        // Set the foreground color based on the provided message type, using this switch statement
-        var fgColor = messageType switch
-        {
-            MessageType.PassedThrough => ConsoleColor.Gray,
-            MessageType.Chaos => ConsoleColor.DarkRed,
-            MessageType.Warning => ConsoleColor.Yellow,
-            MessageType.Mocked => ConsoleColor.DarkYellow,
-            MessageType.Failed => ConsoleColor.Red,
-            MessageType.Tip => ConsoleColor.Blue,
-            _ => Console.ForegroundColor
-        };
-
-        textWriter.Write(GetForegroundColorEscapeCode(fgColor));
-
-        if (message.Length == 1)
-        {
-            // no need to box a single line message
-            textWriter.WriteLine($"{icon}{iconSpacing}{_boxSpacing}{message[0]}");
-        }
-        else
-        {
-            for (var i = 0; i < message.Length; i++)
-            {
-                if (i == 0)
-                {
-                    // print label and top of the box
-                    textWriter.WriteLine($"{icon}{iconSpacing}{_boxTopLeft}{message[i]}");
-                }
-                else if (i < message.Length - 1)
-                {
-                    // print middle of the box
-                    textWriter.WriteLine($"{noIconSpacing}{iconSpacing}{_boxLeft}{message[i]}");
-                }
-                else
-                {
-                    // print end of the box
-                    textWriter.WriteLine($"{noIconSpacing}{iconSpacing}{_boxBottomLeft}{message[i]}");
-                }
-            }
+                break;
         }
-
-        textWriter.ResetColor();
     }
-
-    static string GetForegroundColorEscapeCode(ConsoleColor color) =>
-        color switch
-        {
-            ConsoleColor.Black => "\x1B[30m",
-            ConsoleColor.DarkRed => "\x1B[31m",
-            ConsoleColor.DarkGreen => "\x1B[32m",
-            ConsoleColor.DarkYellow => "\x1B[33m",
-            ConsoleColor.DarkBlue => "\x1B[34m",
-            ConsoleColor.DarkMagenta => "\x1B[35m",
-            ConsoleColor.DarkCyan => "\x1B[36m",
-            ConsoleColor.Gray => "\x1B[37m",
-            ConsoleColor.Red => "\x1B[1m\x1B[31m",
-            ConsoleColor.Green => "\x1B[1m\x1B[32m",
-            ConsoleColor.Yellow => "\x1B[1m\x1B[33m",
-            ConsoleColor.Blue => "\x1B[1m\x1B[34m",
-            ConsoleColor.Magenta => "\x1B[1m\x1B[35m",
-            ConsoleColor.Cyan => "\x1B[1m\x1B[36m",
-            ConsoleColor.White => "\x1B[1m\x1B[37m",
-
-            _ => _defaultForegroundColor
-        };
-
-    static string GetBackgroundColorEscapeCode(ConsoleColor color) =>
-        color switch
-        {
-            ConsoleColor.Black => "\x1B[40m",
-            ConsoleColor.DarkRed => "\x1B[41m",
-            ConsoleColor.DarkGreen => "\x1B[42m",
-            ConsoleColor.DarkYellow => "\x1B[43m",
-            ConsoleColor.DarkBlue => "\x1B[44m",
-            ConsoleColor.DarkMagenta => "\x1B[45m",
-            ConsoleColor.DarkCyan => "\x1B[46m",
-            ConsoleColor.Gray => "\x1B[47m",
-
-            _ => _defaultBackgroundColor
-        };
 }
\ No newline at end of file
diff --git a/dev-proxy/Logging/ProxyConsoleFormatterOptions.cs b/dev-proxy/Logging/ProxyConsoleFormatterOptions.cs
deleted file mode 100644
index 2102c7c3..00000000
--- a/dev-proxy/Logging/ProxyConsoleFormatterOptions.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-using Microsoft.DevProxy.Abstractions;
-using Microsoft.Extensions.Logging.Console;
-
-namespace Microsoft.DevProxy.Logging;
-
-public class ProxyConsoleFormatterOptions : ConsoleFormatterOptions
-{
-    public LabelMode LabelMode { get; set; } = LabelMode.Text;
-}
\ No newline at end of file
diff --git a/dev-proxy/Logging/TextWriterExtensions.cs b/dev-proxy/Logging/TextWriterExtensions.cs
index 50bf5fbc..e3e1a85b 100644
--- a/dev-proxy/Logging/TextWriterExtensions.cs
+++ b/dev-proxy/Logging/TextWriterExtensions.cs
@@ -1,5 +1,7 @@
 // Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
+// Licensed under the MIT License
+
+using Microsoft.DevProxy.Logging;
 
 namespace System.IO;
 
@@ -13,4 +15,26 @@ public static void ResetColor(this TextWriter writer)
         writer.Write(_defaultForegroundColor);
         writer.Write(_defaultBackgroundColor);
     }
+
+    public static void WriteColoredMessage(this TextWriter textWriter, string message, ConsoleColor? background, ConsoleColor? foreground)
+    {
+        // Order: backgroundcolor, foregroundcolor, Message, reset foregroundcolor, reset backgroundcolor
+        if (background.HasValue)
+        {
+            textWriter.Write(AnsiParser.GetBackgroundColorEscapeCode(background.Value));
+        }
+        if (foreground.HasValue)
+        {
+            textWriter.Write(AnsiParser.GetForegroundColorEscapeCode(foreground.Value));
+        }
+        textWriter.Write(message);
+        if (foreground.HasValue)
+        {
+            textWriter.Write(AnsiParser.DefaultForegroundColor); // reset to default foreground color
+        }
+        if (background.HasValue)
+        {
+            textWriter.Write(AnsiParser.DefaultBackgroundColor); // reset to the background color
+        }
+    }
 }
diff --git a/dev-proxy/Program.cs b/dev-proxy/Program.cs
index 1f2e5c6c..b01402f5 100644
--- a/dev-proxy/Program.cs
+++ b/dev-proxy/Program.cs
@@ -5,29 +5,24 @@
 using Microsoft.DevProxy.Abstractions;
 using Microsoft.DevProxy.Logging;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Console;
 using System.CommandLine;
 
 PluginEvents pluginEvents = new PluginEvents();
 
 ILogger BuildLogger()
 {
-    var formatterOptions = new ProxyConsoleFormatterOptions
-    {
-        LabelMode = ProxyCommandHandler.Configuration.LabelMode
-    };
-
     var loggerFactory = LoggerFactory.Create(builder =>
     {
         builder
             .AddConsole(options =>
             {
                 options.FormatterName = "devproxy";
+                options.LogToStandardErrorThreshold = LogLevel.Warning;
             })
-            .AddConsoleFormatter<ProxyConsoleFormatter, ProxyConsoleFormatterOptions>(options => {
-                options.LabelMode = formatterOptions.LabelMode;
-            })
+            .AddConsoleFormatter<ProxyConsoleFormatter, ConsoleFormatterOptions>()
             .AddRequestLogger(pluginEvents)
-            .AddFilter("Default", ProxyHost.LogLevel ?? ProxyCommandHandler.Configuration.LogLevel);
+            .SetMinimumLevel(ProxyHost.LogLevel ?? ProxyCommandHandler.Configuration.LogLevel);
     });
     return loggerFactory.CreateLogger("devproxy");
 }
diff --git a/dev-proxy/ProxyEngine.cs b/dev-proxy/ProxyEngine.cs
index 2315fac3..3880b195 100755
--- a/dev-proxy/ProxyEngine.cs
+++ b/dev-proxy/ProxyEngine.cs
@@ -528,6 +528,8 @@ async Task OnRequest(object sender, SessionEventArgs e)
                 await e.GetRequestBodyAsString();
             }
 
+            using var scope = _logger.BeginScope(e.HttpClient.Request.Method, e.HttpClient.Request.Url, e.GetHashCode());
+
             e.UserData = e.HttpClient.Request;
             _logger.LogRequest(new[] { $"{e.HttpClient.Request.Method} {e.HttpClient.Request.Url}" }, MessageType.InterceptedRequest, new LoggingContext(e));
             await HandleRequest(e, proxyRequestArgs);
@@ -541,7 +543,7 @@ private async Task HandleRequest(SessionEventArgs e, ProxyRequestArgs proxyReque
         // We only need to set the proxy header if the proxy has not set a response and the request is going to be sent to the target.
         if (!proxyRequestArgs.ResponseState.HasBeenSet)
         {
-            _logger?.LogRequest(new[] { "Passed through" }, MessageType.PassedThrough, new LoggingContext(e));
+            _logger?.LogRequest(["Passed through"], MessageType.PassedThrough, new LoggingContext(e));
             AddProxyHeader(e.HttpClient.Request);
         }
     }
@@ -567,6 +569,8 @@ async Task OnBeforeResponse(object sender, SessionEventArgs e)
                 return;
             }
 
+            using var scope = _logger.BeginScope(e.HttpClient.Request.Method, e.HttpClient.Request.Url, e.GetHashCode());
+
             // necessary to make the response body available to plugins
             e.HttpClient.Response.KeepBody = true;
             if (e.HttpClient.Response.HasBody)
@@ -598,8 +602,13 @@ async Task OnAfterResponse(object sender, SessionEventArgs e)
             // of mocked requests available to plugins
             e.HttpClient.Response.KeepBody = true;
 
-            _logger.LogRequest([$"{e.HttpClient.Request.Method} {e.HttpClient.Request.Url}"], MessageType.InterceptedResponse, new LoggingContext(e));
+            using var scope = _logger.BeginScope(e.HttpClient.Request.Method, e.HttpClient.Request.Url, e.GetHashCode());
+
+            var message = $"{e.HttpClient.Request.Method} {e.HttpClient.Request.Url}";
+            _logger.LogRequest([message], MessageType.InterceptedResponse, new LoggingContext(e));
             await _pluginEvents.RaiseProxyAfterResponse(proxyResponseArgs, _exceptionHandler);
+            _logger.LogRequest([message], MessageType.FinishedProcessingRequest, new LoggingContext(e));
+
             // clean up
             _pluginData.Remove(e.GetHashCode());
         }
@@ -626,6 +635,7 @@ Task OnCertificateSelection(object sender, CertificateSelectionEventArgs e)
 
     private void PrintHotkeys()
     {
+        Console.WriteLine("");
         Console.WriteLine("Hotkeys: issue (w)eb request, (r)ecord, (s)top recording, (c)lear screen");
         Console.WriteLine("Press CTRL+C to stop Dev Proxy");
         Console.WriteLine("");
diff --git a/dev-proxy/devproxyrc.json b/dev-proxy/devproxyrc.json
index 0f18cbda..d0028d25 100644
--- a/dev-proxy/devproxyrc.json
+++ b/dev-proxy/devproxyrc.json
@@ -20,7 +20,6 @@
     "errorsFile": "devproxy-errors.json"
   },
   "rate": 50,
-  "labelMode": "text",
   "logLevel": "information",
   "newVersionNotification": "stable"
 }
\ No newline at end of file

From e7be38edb48ecf2930ad2bc81eedcc430f122661 Mon Sep 17 00:00:00 2001
From: waldekmastykarz <waldek@mastykarz.nl>
Date: Wed, 22 May 2024 15:47:21 +0200
Subject: [PATCH 3/3] Code fixes

---
 dev-proxy-abstractions/BaseReportingPlugin.cs |   7 +
 dev-proxy-abstractions/MSGraphDbUtils.cs      |   6 +-
 dev-proxy-plugins/Reporters/BaseReporter.cs   |  25 +--
 dev-proxy-plugins/Reporters/JsonReporter.cs   |  17 +-
 .../Reporters/MarkdownReporter.cs             |  11 +-
 .../Reporters/PlainTextReporter.cs            |  11 +-
 .../ApiCenterProductionVersionPlugin.cs       |   2 +-
 .../MinimalPermissionsGuidancePlugin.cs       |  12 +-
 .../RequestLogs/MinimalPermissionsPlugin.cs   |   1 +
 dev-proxy/Logging/ProxyConsoleFormatter.cs    | 165 ++++++++----------
 dev-proxy/PluginLoader.cs                     |  10 +-
 dev-proxy/ProxyEngine.cs                      |   1 +
 12 files changed, 140 insertions(+), 128 deletions(-)

diff --git a/dev-proxy-abstractions/BaseReportingPlugin.cs b/dev-proxy-abstractions/BaseReportingPlugin.cs
index 6eeb1950..02f1f7c1 100644
--- a/dev-proxy-abstractions/BaseReportingPlugin.cs
+++ b/dev-proxy-abstractions/BaseReportingPlugin.cs
@@ -1,10 +1,17 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+
 namespace Microsoft.DevProxy.Abstractions;
 
 public abstract class BaseReportingPlugin : BaseProxyPlugin
 {
+    protected BaseReportingPlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     protected virtual void StoreReport(object report, ProxyEventArgsBase e)
     {
         if (report is null)
diff --git a/dev-proxy-abstractions/MSGraphDbUtils.cs b/dev-proxy-abstractions/MSGraphDbUtils.cs
index 9f4d8e6b..648f7b21 100644
--- a/dev-proxy-abstractions/MSGraphDbUtils.cs
+++ b/dev-proxy-abstractions/MSGraphDbUtils.cs
@@ -118,20 +118,20 @@ private static void FillData(SqliteConnection dbConnection, ILogger logger)
 
             foreach (var path in document.Paths)
             {
-                logger.LogDebug("Endpoint {graphVersion}{key}...", graphVersion, path.Key);
+                logger.LogTrace("Endpoint {graphVersion}{key}...", graphVersion, path.Key);
 
                 // Get the GET operation for this path
                 var getOperation = path.Value.Operations.FirstOrDefault(o => o.Key == OperationType.Get).Value;
                 if (getOperation == null)
                 {
-                    logger.LogDebug("No GET operation found for {graphVersion}{key}", graphVersion, path.Key);
+                    logger.LogTrace("No GET operation found for {graphVersion}{key}", graphVersion, path.Key);
                     continue;
                 }
 
                 // Check if the GET operation has a $select parameter
                 var hasSelect = getOperation.Parameters.Any(p => p.Name == "$select");
 
-                logger.LogDebug("Inserting endpoint {graphVersion}{key} with hasSelect={hasSelect}...", graphVersion, path.Key, hasSelect);
+                logger.LogTrace("Inserting endpoint {graphVersion}{key} with hasSelect={hasSelect}...", graphVersion, path.Key, hasSelect);
                 insertEndpoint.Parameters["@path"].Value = path.Key;
                 insertEndpoint.Parameters["@graphVersion"].Value = graphVersion;
                 insertEndpoint.Parameters["@hasSelect"].Value = hasSelect;
diff --git a/dev-proxy-plugins/Reporters/BaseReporter.cs b/dev-proxy-plugins/Reporters/BaseReporter.cs
index 8ce38a15..0b9ac39a 100644
--- a/dev-proxy-plugins/Reporters/BaseReporter.cs
+++ b/dev-proxy-plugins/Reporters/BaseReporter.cs
@@ -9,16 +9,17 @@ namespace Microsoft.DevProxy.Plugins.Reporters;
 
 public abstract class BaseReporter : BaseProxyPlugin
 {
+    protected BaseReporter(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     public virtual string FileExtension => throw new NotImplementedException();
 
-    public override void Register(IPluginEvents pluginEvents,
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
+    public override void Register()
     {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
+        base.Register();
 
-        pluginEvents.AfterRecordingStop += AfterRecordingStop;
+        PluginEvents.AfterRecordingStop += AfterRecordingStop;
     }
 
     protected abstract string? GetReport(KeyValuePair<string, object> report);
@@ -29,32 +30,32 @@ protected virtual Task AfterRecordingStop(object sender, RecordingArgs e)
             e.GlobalData[ProxyUtils.ReportsKey] is not Dictionary<string, object> reports ||
             !reports.Any())
         {
-            _logger?.LogDebug("No reports found");
+            Logger.LogDebug("No reports found");
             return Task.CompletedTask;
         }
 
         foreach (var report in reports)
         {
-            _logger?.LogDebug("Transforming report {reportKey}...", report.Key);
+            Logger.LogDebug("Transforming report {reportKey}...", report.Key);
 
             var reportContents = GetReport(report);
 
             if (string.IsNullOrEmpty(reportContents))
             {
-                _logger?.LogDebug("Report {reportKey} is empty, ignore", report.Key);
+                Logger.LogDebug("Report {reportKey} is empty, ignore", report.Key);
                 continue;
             }
 
             var fileName = $"{report.Key}_{Name}{FileExtension}";
-            _logger?.LogDebug("File name for report {report}: {fileName}", report.Key, fileName);
+            Logger.LogDebug("File name for report {report}: {fileName}", report.Key, fileName);
 
             if (File.Exists(fileName))
             {
-                _logger?.LogDebug("File {fileName} already exists, appending timestamp", fileName);
+                Logger.LogDebug("File {fileName} already exists, appending timestamp", fileName);
                 fileName = $"{report.Key}_{Name}_{DateTime.Now:yyyyMMddHHmmss}{FileExtension}";
             }
 
-            _logger?.LogDebug("Writing report {reportKey} to {fileName}...", report.Key, fileName);
+            Logger.LogDebug("Writing report {reportKey} to {fileName}...", report.Key, fileName);
             File.WriteAllText(fileName, reportContents);
         }
 
diff --git a/dev-proxy-plugins/Reporters/JsonReporter.cs b/dev-proxy-plugins/Reporters/JsonReporter.cs
index 6392932b..8af6dff2 100644
--- a/dev-proxy-plugins/Reporters/JsonReporter.cs
+++ b/dev-proxy-plugins/Reporters/JsonReporter.cs
@@ -4,6 +4,7 @@
 using System.Text.Json;
 using Microsoft.DevProxy.Abstractions;
 using Microsoft.DevProxy.Plugins.RequestLogs;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 
 namespace Microsoft.DevProxy.Plugins.Reporters;
@@ -19,37 +20,41 @@ public class JsonReporter : BaseReporter
         { typeof(ExecutionSummaryPluginReportByMessageType), TransformExecutionSummary },
     };
 
+    public JsonReporter(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     protected override string GetReport(KeyValuePair<string, object> report)
     {
-        _logger?.LogDebug("Serializing report {reportKey}...", report.Key);
+        Logger.LogDebug("Serializing report {reportKey}...", report.Key);
 
         var reportData = report.Value;
         var reportType = reportData.GetType();
 
         if (_transformers.TryGetValue(reportType, out var transform))
         {
-            _logger?.LogDebug("Transforming {reportType} using {transform}...", reportType.Name, transform.Method.Name);
+            Logger.LogDebug("Transforming {reportType} using {transform}...", reportType.Name, transform.Method.Name);
             reportData = transform(reportData);
         }
         else
         {
-            _logger?.LogDebug("No transformer found for {reportType}", reportType.Name);
+            Logger.LogDebug("No transformer found for {reportType}", reportType.Name);
         }
 
         if (reportData is string strVal)
         {
-            _logger?.LogDebug("{reportKey} is a string. Checking if it's JSON...", report.Key);
+            Logger.LogDebug("{reportKey} is a string. Checking if it's JSON...", report.Key);
 
             try
             {
                 JsonSerializer.Deserialize<object>(strVal);
-                _logger?.LogDebug("{reportKey} is already JSON, ignore", report.Key);
+                Logger.LogDebug("{reportKey} is already JSON, ignore", report.Key);
                 // already JSON, ignore
                 return strVal;
             }
             catch
             {
-                _logger?.LogDebug("{reportKey} is not JSON, serializing...", report.Key);
+                Logger.LogDebug("{reportKey} is not JSON, serializing...", report.Key);
             }
         }
 
diff --git a/dev-proxy-plugins/Reporters/MarkdownReporter.cs b/dev-proxy-plugins/Reporters/MarkdownReporter.cs
index 01e29a33..5533fd70 100644
--- a/dev-proxy-plugins/Reporters/MarkdownReporter.cs
+++ b/dev-proxy-plugins/Reporters/MarkdownReporter.cs
@@ -4,6 +4,7 @@
 using System.Text;
 using Microsoft.DevProxy.Abstractions;
 using Microsoft.DevProxy.Plugins.RequestLogs;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 
 namespace Microsoft.DevProxy.Plugins.Reporters;
@@ -27,21 +28,25 @@ public class MarkdownReporter : BaseReporter
     private const string _requestsInterceptedMessage = "Requests intercepted";
     private const string _requestsPassedThroughMessage = "Requests passed through";
 
+    public MarkdownReporter(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     protected override string? GetReport(KeyValuePair<string, object> report)
     {
-        _logger?.LogDebug("Transforming {report}...", report.Key);
+        Logger.LogDebug("Transforming {report}...", report.Key);
 
         var reportType = report.Value.GetType();
 
         if (_transformers.TryGetValue(reportType, out var transform))
         {
-            _logger?.LogDebug("Transforming {reportType} using {transform}...", reportType.Name, transform.Method.Name);
+            Logger.LogDebug("Transforming {reportType} using {transform}...", reportType.Name, transform.Method.Name);
 
             return transform(report.Value);
         }
         else
         {
-            _logger?.LogDebug("No transformer found for {reportType}", reportType.Name);
+            Logger.LogDebug("No transformer found for {reportType}", reportType.Name);
             return null;
         }
     }
diff --git a/dev-proxy-plugins/Reporters/PlainTextReporter.cs b/dev-proxy-plugins/Reporters/PlainTextReporter.cs
index 2256c9a3..a53a1ee9 100644
--- a/dev-proxy-plugins/Reporters/PlainTextReporter.cs
+++ b/dev-proxy-plugins/Reporters/PlainTextReporter.cs
@@ -4,6 +4,7 @@
 using System.Text;
 using Microsoft.DevProxy.Abstractions;
 using Microsoft.DevProxy.Plugins.RequestLogs;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 
 namespace Microsoft.DevProxy.Plugins.Reporters;
@@ -27,21 +28,25 @@ public class PlainTextReporter : BaseReporter
     private const string _requestsInterceptedMessage = "Requests intercepted";
     private const string _requestsPassedThroughMessage = "Requests passed through";
 
+    public PlainTextReporter(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
+
     protected override string? GetReport(KeyValuePair<string, object> report)
     {
-        _logger?.LogDebug("Transforming {report}...", report.Key);
+        Logger.LogDebug("Transforming {report}...", report.Key);
 
         var reportType = report.Value.GetType();
 
         if (_transformers.TryGetValue(reportType, out var transform))
         {
-            _logger?.LogDebug("Transforming {reportType} using {transform}...", reportType.Name, transform.Method);
+            Logger.LogDebug("Transforming {reportType} using {transform}...", reportType.Name, transform.Method);
 
             return transform(report.Value);
         }
         else
         {
-            _logger?.LogDebug("No transformer found for {reportType}", reportType.Name);
+            Logger.LogDebug("No transformer found for {reportType}", reportType.Name);
             return null;
         }
     }
diff --git a/dev-proxy-plugins/RequestLogs/ApiCenterProductionVersionPlugin.cs b/dev-proxy-plugins/RequestLogs/ApiCenterProductionVersionPlugin.cs
index bd1eb4f4..dfeeb8eb 100644
--- a/dev-proxy-plugins/RequestLogs/ApiCenterProductionVersionPlugin.cs
+++ b/dev-proxy-plugins/RequestLogs/ApiCenterProductionVersionPlugin.cs
@@ -256,7 +256,7 @@ private async Task AfterRecordingStop(object sender, RecordingArgs e)
             var methodAndUrl = methodAndUrlString.Split(' ');
             if (methodAndUrl[0] == "OPTIONS")
             {
-                _logger?.LogDebug("Skipping OPTIONS request {request}", methodAndUrl[1]);
+                Logger.LogDebug("Skipping OPTIONS request {request}", methodAndUrl[1]);
                 continue;
             }
 
diff --git a/dev-proxy-plugins/RequestLogs/MinimalPermissionsGuidancePlugin.cs b/dev-proxy-plugins/RequestLogs/MinimalPermissionsGuidancePlugin.cs
index 212032f3..49883c11 100644
--- a/dev-proxy-plugins/RequestLogs/MinimalPermissionsGuidancePlugin.cs
+++ b/dev-proxy-plugins/RequestLogs/MinimalPermissionsGuidancePlugin.cs
@@ -35,19 +35,15 @@ public class MinimalPermissionsGuidancePlugin : BaseReportingPlugin
 {
     public override string Name => nameof(MinimalPermissionsGuidancePlugin);
 
-    public override void Register(IPluginEvents pluginEvents,
+    public MinimalPermissionsGuidancePlugin(IPluginEvents pluginEvents, IProxyContext context, ILogger logger, ISet<UrlToWatch> urlsToWatch, IConfigurationSection? configSection = null) : base(pluginEvents, context, logger, urlsToWatch, configSection)
+    {
+    }
 
     public override void Register()
     {
         base.Register();
 
-                            IProxyContext context,
-                            ISet<UrlToWatch> urlsToWatch,
-                            IConfigurationSection? configSection = null)
-    {
-        base.Register(pluginEvents, context, urlsToWatch, configSection);
-
-        pluginEvents.AfterRecordingStop += AfterRecordingStop;
+        PluginEvents.AfterRecordingStop += AfterRecordingStop;
     }
 
     private async Task AfterRecordingStop(object? sender, RecordingArgs e)
diff --git a/dev-proxy-plugins/RequestLogs/MinimalPermissionsPlugin.cs b/dev-proxy-plugins/RequestLogs/MinimalPermissionsPlugin.cs
index ce1edc72..f331d43f 100644
--- a/dev-proxy-plugins/RequestLogs/MinimalPermissionsPlugin.cs
+++ b/dev-proxy-plugins/RequestLogs/MinimalPermissionsPlugin.cs
@@ -7,6 +7,7 @@
 using Microsoft.Extensions.Logging;
 using System.Net.Http.Json;
 using System.Text.Json;
+using System.Text.Json.Serialization;
 
 namespace Microsoft.DevProxy.Plugins.RequestLogs;
 
diff --git a/dev-proxy/Logging/ProxyConsoleFormatter.cs b/dev-proxy/Logging/ProxyConsoleFormatter.cs
index 72b00d52..da5cce9d 100644
--- a/dev-proxy/Logging/ProxyConsoleFormatter.cs
+++ b/dev-proxy/Logging/ProxyConsoleFormatter.cs
@@ -17,22 +17,11 @@ public class ProxyConsoleFormatter : ConsoleFormatter
     private const string _boxBottomLeft = "\u2570 ";
     // used to align single-line messages
     private const string _boxSpacing = "  ";
-    private Dictionary<int, List<RequestLog>> _requestLogs = new();
+    private Dictionary<int, List<RequestLog>> _requestLogs = [];
     private ConsoleFormatterOptions _options;
-    const string labelSpacing = "  ";
-    const string interceptedRequest = "request";
-    const string passedThrough = "api";
-    const string chaos = "chaos";
-    const string warning = "warning";
-    const string mock = "mock";
-    const string normal = "log";
-    const string fail = "fail";
-    const string tip = "tip";
-    const string error = "error";
-    const string info = "info";
-    private readonly static string[] allLabels = [interceptedRequest, passedThrough, chaos, warning, mock, normal, fail, tip];
-    private readonly static int maxLabelLength = allLabels.Max(l => l.Length);
-    private readonly static string noLabelSpacing = new string(' ', maxLabelLength + 2);
+    const string labelSpacing = " ";
+    // label length + 2
+    private readonly static string noLabelSpacing = new string(' ', 4 + 2);
 
     public ProxyConsoleFormatter(IOptions<ConsoleFormatterOptions> options) : base("devproxy")
     {
@@ -133,82 +122,20 @@ private void LogMessage<TState>(in LogEntry<TState> logEntry, IExternalScopeProv
 
     private void WriteMessageBoxedWithInvertedLabels(string? message, LogLevel logLevel, TextWriter textWriter)
     {
-        var label = normal;
-        var fgColor = Console.ForegroundColor;
-        var bgColor = Console.BackgroundColor;
-
-        switch (logLevel)
-        {
-            case LogLevel.Information:
-                label = info;
-                fgColor = ConsoleColor.Blue;
-                break;
-            case LogLevel.Warning:
-                label = warning;
-                bgColor = ConsoleColor.DarkYellow;
-                break;
-            case LogLevel.Error:
-                label = error;
-                bgColor = ConsoleColor.DarkRed;
-                break;
-            case LogLevel.Debug:
-                label = "debug";
-                fgColor = ConsoleColor.Gray;
-                break;
-        }
-
-        var leadingSpaces = new string(' ', maxLabelLength - label.Length);
+        var label = GetLogLevelString(logLevel);
+        var (bgColor, fgColor) = GetLogLevelColor(logLevel);
 
         if (message is not null)
         {
-            textWriter.Write(leadingSpaces);
             textWriter.WriteColoredMessage($" {label} ", bgColor, fgColor);
-            textWriter.Write($"{labelSpacing}{_boxSpacing}{message}");
+            textWriter.Write($"{labelSpacing}{_boxSpacing}{(logLevel == LogLevel.Debug ? $"[{DateTime.Now}] " : "")}{message}");
         }
     }
 
     private void WriteLogMessageBoxedWithInvertedLabels(string[] message, MessageType messageType, TextWriter textWriter, bool lastMessage = false)
     {
-        var label = normal;
-        var fgColor = Console.ForegroundColor;
-        var bgColor = Console.BackgroundColor;
-
-        switch (messageType)
-        {
-            case MessageType.InterceptedRequest:
-                label = interceptedRequest;
-                fgColor = ConsoleColor.Gray;
-                break;
-            case MessageType.PassedThrough:
-                label = passedThrough;
-                bgColor = ConsoleColor.Gray;
-                break;
-            case MessageType.Chaos:
-                label = chaos;
-                bgColor = ConsoleColor.DarkRed;
-                break;
-            case MessageType.Warning:
-                label = warning;
-                bgColor = ConsoleColor.DarkYellow;
-                break;
-            case MessageType.Mocked:
-                label = mock;
-                bgColor = ConsoleColor.DarkMagenta;
-                break;
-            case MessageType.Failed:
-                label = fail;
-                bgColor = ConsoleColor.DarkRed;
-                break;
-            case MessageType.Tip:
-                label = tip;
-                bgColor = ConsoleColor.DarkBlue;
-                break;
-            case MessageType.Normal:
-                label = normal;
-                break;
-        }
-
-        var leadingSpaces = new string(' ', maxLabelLength - label.Length);
+        var label = GetMessageTypeString(messageType);
+        var (bgColor, fgColor) = GetMessageTypeColor(messageType);
 
         switch (messageType)
         {
@@ -216,16 +143,14 @@ private void WriteLogMessageBoxedWithInvertedLabels(string[] message, MessageTyp
                 // always one line (method + URL)
                 // print label and top of the box
                 textWriter.WriteLine();
-                textWriter.Write(leadingSpaces);
                 textWriter.WriteColoredMessage($" {label} ", bgColor, fgColor);
-                textWriter.WriteLine($"{labelSpacing}{_boxTopLeft}{message[0]}");
+                textWriter.WriteLine($"{(label.Length < 4 ? " " : "")}{labelSpacing}{_boxTopLeft}{message[0]}");
                 break;
             default:
                 if (message.Length == 1)
                 {
-                    textWriter.Write(leadingSpaces);
                     textWriter.WriteColoredMessage($" {label} ", bgColor, fgColor);
-                    textWriter.WriteLine($"{labelSpacing}{(lastMessage ? _boxBottomLeft : _boxLeft)}{message[0]}");
+                    textWriter.WriteLine($"{(label.Length < 4 ? " " : "")}{labelSpacing}{(lastMessage ? _boxBottomLeft : _boxLeft)}{message[0]}");
                 }
                 else
                 {
@@ -234,9 +159,8 @@ private void WriteLogMessageBoxedWithInvertedLabels(string[] message, MessageTyp
                         if (i == 0)
                         {
                             // print label and middle of the box
-                            textWriter.Write(leadingSpaces);
                             textWriter.WriteColoredMessage($" {label} ", bgColor, fgColor);
-                            textWriter.WriteLine($"{labelSpacing}{_boxLeft}{message[i]}");
+                            textWriter.WriteLine($"{(label.Length < 4 ? " " : "")}{labelSpacing}{_boxLeft}{message[i]}");
                         }
                         else if (i < message.Length - 1)
                         {
@@ -253,4 +177,69 @@ private void WriteLogMessageBoxedWithInvertedLabels(string[] message, MessageTyp
                 break;
         }
     }
+
+    // from https://github.com/dotnet/runtime/blob/198a2596229f69b8e02902bfb4ffc2a30be3b339/src/libraries/Microsoft.Extensions.Logging.Console/src/SimpleConsoleFormatter.cs#L154
+    private static string GetLogLevelString(LogLevel logLevel)
+    {
+        return logLevel switch
+        {
+            LogLevel.Trace => "trce",
+            LogLevel.Debug => "dbug",
+            LogLevel.Information => "info",
+            LogLevel.Warning => "warn",
+            LogLevel.Error => "fail",
+            LogLevel.Critical => "crit",
+            _ => throw new ArgumentOutOfRangeException(nameof(logLevel))
+        };
+    }
+
+    private static (ConsoleColor bg, ConsoleColor fg) GetLogLevelColor(LogLevel logLevel)
+    {
+        var fgColor = Console.ForegroundColor;
+        var bgColor = Console.BackgroundColor;
+
+        return logLevel switch
+        {
+            LogLevel.Information => (bgColor, ConsoleColor.Blue),
+            LogLevel.Warning => (ConsoleColor.DarkYellow, fgColor),
+            LogLevel.Error => (ConsoleColor.DarkRed, fgColor),
+            LogLevel.Debug => (bgColor, ConsoleColor.Gray),
+            LogLevel.Trace => (bgColor, ConsoleColor.Gray),
+            _ => (bgColor, fgColor)
+        };
+    }
+
+    private static string GetMessageTypeString(MessageType messageType)
+    {
+        return messageType switch
+        {
+            MessageType.InterceptedRequest => "req",
+            MessageType.InterceptedResponse => "res",
+            MessageType.PassedThrough => "api",
+            MessageType.Chaos => "oops",
+            MessageType.Warning => "warn",
+            MessageType.Mocked => "mock",
+            MessageType.Failed => "fail",
+            MessageType.Tip => "tip",
+            _ => "    "
+        };
+    }
+
+    private static (ConsoleColor bg, ConsoleColor fg) GetMessageTypeColor(MessageType messageType)
+    {
+        var fgColor = Console.ForegroundColor;
+        var bgColor = Console.BackgroundColor;
+
+        return messageType switch
+        {
+            MessageType.InterceptedRequest => (bgColor, ConsoleColor.Gray),
+            MessageType.PassedThrough => (ConsoleColor.Gray, fgColor),
+            MessageType.Chaos => (ConsoleColor.DarkRed, fgColor),
+            MessageType.Warning => (ConsoleColor.DarkYellow, fgColor),
+            MessageType.Mocked => (ConsoleColor.DarkMagenta, fgColor),
+            MessageType.Failed => (ConsoleColor.DarkRed, fgColor),
+            MessageType.Tip => (ConsoleColor.DarkBlue, fgColor),
+            _ => (bgColor, fgColor)
+        };
+    }
 }
\ No newline at end of file
diff --git a/dev-proxy/PluginLoader.cs b/dev-proxy/PluginLoader.cs
index 48841899..af3e36e4 100644
--- a/dev-proxy/PluginLoader.cs
+++ b/dev-proxy/PluginLoader.cs
@@ -65,14 +65,16 @@ public PluginLoaderResult LoadPlugins(IPluginEvents pluginEvents, IProxyContext
                     globallyWatchedUrls.AddRange(pluginUrlsList);
                 }
 
-                var plugin = CreatePlugin(assembly, h);
-                _logger?.LogDebug("Registering plugin {pluginName}...", plugin.Name);
-                plugin.Register(
+                var plugin = CreatePlugin(
+                    assembly,
+                    h,
                     pluginEvents,
                     proxyContext,
                     (pluginUrls != null && pluginUrls.Any()) ? pluginUrls : defaultUrlsToWatch,
                     h.ConfigSection is null ? null : Configuration.GetSection(h.ConfigSection)
                 );
+                _logger?.LogDebug("Registering plugin {pluginName}...", plugin.Name);
+                plugin.Register();
                 _logger?.LogDebug("Plugin {pluginName} registered.", plugin.Name);
                 plugins.Add(plugin);
             }
@@ -94,7 +96,7 @@ public PluginLoaderResult LoadPlugins(IPluginEvents pluginEvents, IProxyContext
     {
         foreach (Type type in assembly.GetTypes())
         {
-            if (type.Name == h.Name &&
+            if (type.Name == pluginReference.Name &&
                 typeof(IProxyPlugin).IsAssignableFrom(type))
             {
                 IProxyPlugin? result = Activator.CreateInstance(type, [pluginEvents, context, _logger, urlsToWatch, configSection]) as IProxyPlugin;
diff --git a/dev-proxy/ProxyEngine.cs b/dev-proxy/ProxyEngine.cs
index 3880b195..f64ab22c 100755
--- a/dev-proxy/ProxyEngine.cs
+++ b/dev-proxy/ProxyEngine.cs
@@ -36,6 +36,7 @@ public class ProxyEngine
     private Dictionary<string, object> _globalData = new() {
         { ProxyUtils.ReportsKey, new Dictionary<string, object>() }
     };
+    private static readonly object consoleLock = new object();
 
     private bool _isRecording = false;
     private List<RequestLog> _requestLogs = new List<RequestLog>();