Refactor logger. (#1247)

Tests/MQTTnet.Core.Tests/Client/LowLevelMqttClient_Tests.cs

@@ -1,18 +1,18 @@
 using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Client.Options;
-using MQTTnet.LowLevelClient;
-using MQTTnet.Packets;
-using MQTTnet.Protocol;
-using MQTTnet.Tests.Mockups;
 using System.Collections.Generic;
 using System.Net.Sockets;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Client.Options;
 using MQTTnet.Exceptions;
+using MQTTnet.LowLevelClient;
+using MQTTnet.Packets;
+using MQTTnet.Protocol;
+using MQTTnet.Tests.Mockups;
 
-namespace MQTTnet.Tests
+namespace MQTTnet.Tests.Client
 {
     [TestClass]
     public class LowLevelMqttClient_Tests

Tests/MQTTnet.Core.Tests/Client/ManagedMqttClient_Tests.cs

@@ -1,19 +1,20 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
 using MQTTnet.Client.Connecting;
 using MQTTnet.Client.Options;
 using MQTTnet.Client.Receiving;
 using MQTTnet.Diagnostics;
+using MQTTnet.Diagnostics.Logger;
 using MQTTnet.Extensions.ManagedClient;
 using MQTTnet.Server;
 using MQTTnet.Tests.Mockups;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 
-namespace MQTTnet.Tests
+namespace MQTTnet.Tests.Client
 {
     [TestClass]
     public class ManagedMqttClient_Tests
@@ -92,7 +93,7 @@ namespace MQTTnet.Tests
             {
                 var server = await testEnvironment.StartServer();
 
-                var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetLogger());
+                var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetEventLogger());
                 var clientOptions = new MqttClientOptionsBuilder()
                     .WithTcpServer("localhost", testEnvironment.ServerPort);
 
@@ -122,7 +123,7 @@ namespace MQTTnet.Tests
 
                 await testEnvironment.StartServer();
 
-                var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetLogger());
+                var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetEventLogger());
                 var clientOptions = new MqttClientOptionsBuilder()
                     .WithTcpServer("localhost", testEnvironment.ServerPort);
                 var storage = new ManagedMqttClientTestStorage();
@@ -303,17 +304,17 @@ namespace MQTTnet.Tests
                 });
 
                 // Wait a bit for the retained message to be available
-                await Task.Delay(500);
+                await Task.Delay(1000);
 
                 await sendingClient.DisconnectAsync();
 
                 // Now use the managed client and check if subscriptions get cleared properly.
 
                 var clientOptions = new MqttClientOptionsBuilder()
-                   .WithTcpServer("localhost", testEnvironment.ServerPort);
+                   .WithTcpServer("127.0.0.1", testEnvironment.ServerPort);
 
                 var receivedManagedMessages = new List<MqttApplicationMessage>();
-                var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetLogger());
+                var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetEventLogger());
                 managedClient.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(c =>
                 {
                     receivedManagedMessages.Add(c.ApplicationMessage);
@@ -326,7 +327,7 @@ namespace MQTTnet.Tests
                   .WithAutoReconnectDelay(TimeSpan.FromSeconds(1))
                   .Build());
 
-                await Task.Delay(500);
+                await Task.Delay(1000);
 
                 Assert.AreEqual(1, receivedManagedMessages.Count);
 
@@ -431,7 +432,7 @@ namespace MQTTnet.Tests
             // at connection check intervals
             managedOptions.ConnectionCheckInterval = connectionCheckInterval ?? TimeSpan.FromSeconds(0.1);
 
-            var managedClient = new ManagedMqttClient(underlyingClient ?? testEnvironment.CreateClient(), new MqttNetLogger());
+            var managedClient = new ManagedMqttClient(underlyingClient ?? testEnvironment.CreateClient(), new MqttNetEventLogger());
 
             var connected = GetConnectedTask(managedClient);
 

Tests/MQTTnet.Core.Tests/Client/MqttClientOptionsBuilder_Tests.cs

@@ -4,7 +4,7 @@ using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client.Options;
 using MQTTnet.Extensions;
 
-namespace MQTTnet.Tests
+namespace MQTTnet.Tests.Client
 {
     [TestClass]
     public class MqttClientOptionsBuilder_Tests

Tests/MQTTnet.Core.Tests/Client/MqttClient_Tests.cs

@@ -1,13 +1,3 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Client;
-using MQTTnet.Client.Connecting;
-using MQTTnet.Client.Disconnecting;
-using MQTTnet.Client.Options;
-using MQTTnet.Client.Subscribing;
-using MQTTnet.Exceptions;
-using MQTTnet.Protocol;
-using MQTTnet.Server;
-using MQTTnet.Tests.Mockups;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -15,11 +5,21 @@ using System.Net.Sockets;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Client;
+using MQTTnet.Client.Connecting;
+using MQTTnet.Client.Disconnecting;
+using MQTTnet.Client.Options;
 using MQTTnet.Client.Receiving;
+using MQTTnet.Client.Subscribing;
+using MQTTnet.Exceptions;
 using MQTTnet.Formatter;
 using MQTTnet.Packets;
+using MQTTnet.Protocol;
+using MQTTnet.Server;
+using MQTTnet.Tests.Mockups;
 
-namespace MQTTnet.Tests
+namespace MQTTnet.Tests.Client
 {
     [TestClass]
     public class Client_Tests

Tests/MQTTnet.Core.Tests/Factory/MqttFactory_Tests.cs

@@ -0,0 +1,154 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Diagnostics.Logger;
+using MQTTnet.Extensions.ManagedClient;
+
+namespace MQTTnet.Tests.Factory
+{
+    [TestClass]
+    public sealed class MqttFactory_Tests : BaseTestClass
+    {
+        [TestMethod]
+        public async Task Create_Managed_Client_With_Logger()
+        {
+            var factory = new MqttFactory();
+
+            // This test compares
+            // 1. correct logID
+            var logId = "logId";
+            var hasInvalidLogId = false;
+
+            // 2. if the total log calls are the same for global and local
+            //var globalLogCount = 0;
+            var localLogCount = 0;
+
+            var logger = new MqttNetEventLogger(logId);
+            logger.LogMessagePublished += (s, e) =>
+            {
+                if (e.LogMessage.LogId != logId)
+                {
+                    hasInvalidLogId = true;
+                }
+
+                Interlocked.Increment(ref localLogCount);
+            };
+
+            var managedClient = factory.CreateManagedMqttClient(logger);
+            try
+            {
+                var clientOptions = new ManagedMqttClientOptionsBuilder();
+
+                clientOptions.WithClientOptions(o => o.WithTcpServer("this_is_an_invalid_host").WithCommunicationTimeout(TimeSpan.FromSeconds(1)));
+
+                // try connect to get some log entries
+                await managedClient.StartAsync(clientOptions.Build());
+
+                // wait at least connect timeout or we have some log messages
+                var tcs = new TaskCompletionSource<object>();
+                managedClient.ConnectingFailedHandler = new ConnectingFailedHandlerDelegate(e => tcs.TrySetResult(null));
+                await Task.WhenAny(Task.Delay(managedClient.Options.ClientOptions.CommunicationTimeout), tcs.Task);
+            }
+            finally
+            {
+                await managedClient.StopAsync();
+            }
+
+            await Task.Delay(500);
+
+            Assert.IsFalse(hasInvalidLogId);
+            Assert.AreNotEqual(0, localLogCount);
+        }
+
+        [TestMethod]
+        public void Create_ApplicationMessageBuilder()
+        {
+            var factory = new MqttFactory();
+            var builder = factory.CreateApplicationMessageBuilder();
+            
+            Assert.IsNotNull(builder);
+        }
+        
+        [TestMethod]
+        public void Create_ClientOptionsBuilder()
+        {
+            var factory = new MqttFactory();
+            var builder = factory.CreateClientOptionsBuilder();
+            
+            Assert.IsNotNull(builder);
+        }
+        
+        [TestMethod]
+        public void Create_ServerOptionsBuilder()
+        {
+            var factory = new MqttFactory();
+            var builder = factory.CreateServerOptionsBuilder();
+            
+            Assert.IsNotNull(builder);
+        }
+        
+        [TestMethod]
+        public void Create_SubscribeOptionsBuilder()
+        {
+            var factory = new MqttFactory();
+            var builder = factory.CreateSubscribeOptionsBuilder();
+            
+            Assert.IsNotNull(builder);
+        }
+        
+        [TestMethod]
+        public void Create_UnsubscribeOptionsBuilder()
+        {
+            var factory = new MqttFactory();
+            var builder = factory.CreateUnsubscribeOptionsBuilder();
+            
+            Assert.IsNotNull(builder);
+        }
+        
+        [TestMethod]
+        public void Create_TopicFilterBuilder()
+        {
+            var factory = new MqttFactory();
+            var builder = factory.CreateTopicFilterBuilder();
+            
+            Assert.IsNotNull(builder);
+        }
+        
+        [TestMethod]
+        public void Create_MqttServer()
+        {
+            var factory = new MqttFactory();
+            var server = factory.CreateMqttServer();
+            
+            Assert.IsNotNull(server);
+        }
+        
+        [TestMethod]
+        public void Create_MqttClient()
+        {
+            var factory = new MqttFactory();
+            var client = factory.CreateMqttClient();
+            
+            Assert.IsNotNull(client);
+        }
+        
+        [TestMethod]
+        public void Create_LowLevelMqttClient()
+        {
+            var factory = new MqttFactory();
+            var client = factory.CreateLowLevelMqttClient();
+            
+            Assert.IsNotNull(client);
+        }
+        
+        [TestMethod]
+        public void Create_ManagedMqttClient()
+        {
+            var factory = new MqttFactory();
+            var client = factory.CreateManagedMqttClient();
+            
+            Assert.IsNotNull(client);
+        }
+    }
+}

Tests/MQTTnet.Core.Tests/Logger/Logger_Tests.cs

@@ -0,0 +1,62 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Diagnostics.Logger;
+
+namespace MQTTnet.Tests.Logger
+{
+    [TestClass]
+    public sealed class Logger_Tests : BaseTestClass
+    {
+        [TestMethod]
+        public void Log_Without_Source()
+        {
+            var logger = new MqttNetEventLogger();
+
+            MqttNetLogMessage logMessage = null;
+            logger.LogMessagePublished += (s, e) => { logMessage = e.LogMessage; };
+
+            logger.Publish(MqttNetLogLevel.Info, "SOURCE", "MESSAGE", new object[] { "ABC" }, new InvalidOperationException());
+
+            Assert.AreEqual(MqttNetLogLevel.Info, logMessage.Level);
+            Assert.AreEqual("SOURCE", logMessage.Source);
+            Assert.AreEqual("MESSAGE", logMessage.Message);
+            Assert.AreEqual("InvalidOperationException", logMessage.Exception.GetType().Name);
+        }
+
+        [TestMethod]
+        public void Root_Log_Messages()
+        {
+            var logger = new MqttNetEventLogger();
+            var childLogger = logger.WithSource("Source1");
+
+            var logMessagesCount = 0;
+
+            logger.LogMessagePublished += (s, e) => { logMessagesCount++; };
+
+            childLogger.Verbose("Verbose");
+            childLogger.Info("Info");
+            childLogger.Warning(null, "Warning");
+            childLogger.Error(null, "Error");
+
+            Assert.AreEqual(4, logMessagesCount);
+        }
+        
+        [TestMethod]
+        public void Use_Custom_Log_Id()
+        {
+            var logger = new MqttNetEventLogger("logId");
+            var childLogger = logger.WithSource("Source1");
+
+            logger.LogMessagePublished += (s, e) =>
+            {
+                Assert.AreEqual("logId", e.LogMessage.LogId);
+                Assert.AreEqual("Source1", e.LogMessage.Source);
+            };
+            
+            childLogger.Verbose("Verbose");
+            childLogger.Info("Info");
+            childLogger.Warning(null, "Warning");
+            childLogger.Error(null, "Error");
+        }
+    }
+}

Tests/MQTTnet.Core.Tests/Logger/SourceLogger_Tests.cs

@@ -0,0 +1,26 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Diagnostics.Logger;
+
+namespace MQTTnet.Tests.Logger
+{
+    [TestClass]
+    public sealed class SourceLogger_Tests : BaseTestClass
+    {
+        [TestMethod]
+        public void Log_With_Source()
+        {
+            MqttNetLogMessage logMessage = null;
+            
+            var logger = new MqttNetEventLogger();
+            logger.LogMessagePublished += (s, e) =>
+            {
+                logMessage = e.LogMessage;
+            };
+            
+            var sourceLogger = logger.WithSource("The_Source");
+            sourceLogger.Info("MESSAGE", null, null);
+         
+            Assert.AreEqual("The_Source", logMessage.Source);
+        }
+    }
+}

Tests/MQTTnet.Core.Tests/Mockups/TestEnvironment.cs

@@ -1,7 +1,6 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
 using MQTTnet.Client.Options;
-using MQTTnet.Diagnostics;
 using MQTTnet.Server;
 using System;
 using System.Collections.Generic;
@@ -9,6 +8,7 @@ using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using MQTTnet.Diagnostics.Logger;
 using MQTTnet.Extensions.Rpc;
 using MQTTnet.Extensions.Rpc.Options;
 using MQTTnet.Formatter;
@@ -36,9 +36,9 @@ namespace MQTTnet.Tests.Mockups
 
         public int ServerPort { get; set; } = 1888;
 
-        public MqttNetLogger ServerLogger { get; } = new MqttNetLogger("server");
+        public MqttNetEventLogger ServerLogger { get; } = new MqttNetEventLogger("server");
 
-        public MqttNetLogger ClientLogger { get; } = new MqttNetLogger("client");
+        public MqttNetEventLogger ClientLogger { get; } = new MqttNetEventLogger("client");
 
         public TestContext TestContext { get; }
 
@@ -191,19 +191,19 @@ namespace MQTTnet.Tests.Mockups
 
         public async Task<IMqttServer> StartServer(MqttServerOptionsBuilder options)
         {
-            CreateServer();
+            var server = CreateServer();
             
             options.WithDefaultEndpointPort(ServerPort);
             options.WithMaxPendingMessagesPerClient(int.MaxValue);
             
-            await Server.StartAsync(options.Build());
+            await server.StartAsync(options.Build());
 
-            return Server;
+            return server;
         }
         
         public async Task<IMqttServer> StartServer(Action<MqttServerOptionsBuilder> options)
         {
-            CreateServer();
+            var server = CreateServer();
 
             var optionsBuilder = Factory.CreateServerOptionsBuilder();
             optionsBuilder.WithDefaultEndpointPort(ServerPort);
@@ -211,9 +211,9 @@ namespace MQTTnet.Tests.Mockups
             
             options?.Invoke(optionsBuilder);
             
-            await Server.StartAsync(optionsBuilder.Build());
+            await server.StartAsync(optionsBuilder.Build());
 
-            return Server;
+            return server;
         }
         
         public TestApplicationMessageReceivedHandler CreateApplicationMessageHandler(IMqttClient mqttClient)

Tests/MQTTnet.Core.Tests/Mockups/TestLogger.cs

@@ -1,17 +1,12 @@
-using MQTTnet.Diagnostics;
-using System;
+using System;
+using MQTTnet.Diagnostics.Logger;
 
 namespace MQTTnet.Tests.Mockups
 {
-    public class TestLogger : IMqttNetLogger
+    public sealed class TestLogger : IMqttNetLogger
     {
         public event EventHandler<MqttNetLogMessagePublishedEventArgs> LogMessagePublished;
-
-        public IMqttNetScopedLogger CreateScopedLogger(string source)
-        {
-            return new MqttNetScopedLogger(this, source);
-        }
-
+        
         public void Publish(MqttNetLogLevel logLevel, string source, string message, object[] parameters, Exception exception)
         {
             LogMessagePublished?.Invoke(this, new MqttNetLogMessagePublishedEventArgs(new MqttNetLogMessage

Tests/MQTTnet.Core.Tests/MqttFactory_Tests.cs

@@ -1,81 +0,0 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Diagnostics;
-using MQTTnet.Extensions.ManagedClient;
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MQTTnet.Tests
-{
-    [TestClass]
-    public class MqttFactory_Tests
-    {
-        [TestMethod]
-        public async Task Create_Managed_Client_With_Logger()
-        {
-            var factory = new MqttFactory();
-
-            // This test compares
-            // 1. correct logID
-            var logId = "logId";
-            var hasInvalidLogId = false;
-
-            // 2. if the total log calls are the same for global and local
-            //var globalLogCount = 0;
-            var localLogCount = 0;
-
-            var logger = new MqttNetLogger(logId);
-
-            // TODO: This is commented out because it is affected by other tests.
-            //// we have a theoretical bug here if a concurrent test is also logging
-            //var globalLog = new EventHandler<MqttNetLogMessagePublishedEventArgs>((s, e) =>
-            //{
-            //    if (e.TraceMessage.LogId != logId)
-            //    {
-            //        invalidLogId = e.TraceMessage.LogId;
-            //    }
-
-            //    Interlocked.Increment(ref globalLogCount);
-            //});
-
-            //MqttNetGlobalLogger.LogMessagePublished += globalLog;
-
-            logger.LogMessagePublished += (s, e) =>
-            {
-                if (e.LogMessage.LogId != logId)
-                {
-                    hasInvalidLogId = true;
-                }
-
-                Interlocked.Increment(ref localLogCount);
-            };
-
-            var managedClient = factory.CreateManagedMqttClient(logger);
-            try
-            {
-                var clientOptions = new ManagedMqttClientOptionsBuilder();
-
-                clientOptions.WithClientOptions(o => o.WithTcpServer("this_is_an_invalid_host").WithCommunicationTimeout(TimeSpan.FromSeconds(1)));
-
-                // try connect to get some log entries
-                await managedClient.StartAsync(clientOptions.Build());
-
-                // wait at least connect timeout or we have some log messages
-                var tcs = new TaskCompletionSource<object>();
-                managedClient.ConnectingFailedHandler = new ConnectingFailedHandlerDelegate(e => tcs.TrySetResult(null));
-                await Task.WhenAny(Task.Delay(managedClient.Options.ClientOptions.CommunicationTimeout), tcs.Task);
-            }
-            finally
-            {
-                await managedClient.StopAsync();
-
-                //MqttNetGlobalLogger.LogMessagePublished -= globalLog;
-            }
-
-            await Task.Delay(500);
-
-            Assert.IsFalse(hasInvalidLogId);
-            Assert.AreNotEqual(0, localLogCount);
-        }
-    }
-}

Tests/MQTTnet.Core.Tests/MqttNetLogger_Tests.cs

@@ -1,68 +0,0 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Diagnostics;
-
-namespace MQTTnet.Tests
-{
-    [TestClass]
-    public class MqttNetLogger_Tests
-    {
-        [TestMethod]
-        public void Root_Log_Messages()
-        {
-            var logger = new MqttNetLogger();
-            var childLogger = logger.CreateScopedLogger("Source1");
-
-            var logMessagesCount = 0;
-
-            logger.LogMessagePublished += (s, e) =>
-            {
-                logMessagesCount++;
-            };
-
-            childLogger.Verbose("Verbose");
-            childLogger.Info("Info");
-            childLogger.Warning(null, "Warning");
-            childLogger.Error(null, "Error");
-
-            Assert.AreEqual(4, logMessagesCount);
-        }
-
-        [TestMethod]
-        public void Bubbling_Log_Messages()
-        {
-            var logger = new MqttNetLogger();
-            var childLogger = logger.CreateScopedLogger("Source1");
-
-            var logMessagesCount = 0;
-
-            logger.LogMessagePublished += (s, e) =>
-            {
-                logMessagesCount++;
-            };
-
-            childLogger.Verbose("Verbose");
-            childLogger.Info("Info");
-            childLogger.Warning(null, "Warning");
-            childLogger.Error(null, "Error");
-
-            Assert.AreEqual(4, logMessagesCount);
-        }
-
-        [TestMethod]
-        public void Set_Custom_Log_ID()
-        {
-            var logger = new MqttNetLogger("logId");
-            var childLogger = logger.CreateScopedLogger("Source1");
-
-            logger.LogMessagePublished += (s, e) =>
-            {
-                Assert.AreEqual("logId", e.LogMessage.LogId);
-            };
-
-            childLogger.Verbose("Verbose");
-            childLogger.Info("Info");
-            childLogger.Warning(null, "Warning");
-            childLogger.Error(null, "Error");
-        }
-    }
-}

Tests/MQTTnet.Core.Tests/MqttPacketSerializer_Tests.cs

@@ -7,6 +7,7 @@ using System.Threading;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Adapter;
 using MQTTnet.Diagnostics;
+using MQTTnet.Diagnostics.Logger;
 using MQTTnet.Exceptions;
 using MQTTnet.Formatter;
 using MQTTnet.Formatter.V3;
@@ -626,7 +627,7 @@ namespace MQTTnet.Tests
             using (var headerStream = new MemoryStream(buffer1.ToArray()))
             {
                 var channel = new TestMqttChannel(headerStream);
-                var adapter = new MqttChannelAdapter(channel, new MqttPacketFormatterAdapter(protocolVersion, writer), null, new MqttNetLogger());
+                var adapter = new MqttChannelAdapter(channel, new MqttPacketFormatterAdapter(protocolVersion, writer), null, new MqttNetEventLogger());
                 var receivedPacket = adapter.ReceivePacketAsync(CancellationToken.None).GetAwaiter().GetResult();
 
                 var buffer2 = serializer.Encode(receivedPacket);
@@ -656,7 +657,7 @@ namespace MQTTnet.Tests
             var buffer = serializer.Encode(packet);
             
             var channel = new TestMqttChannel(buffer.ToArray());
-            var adapter = new MqttChannelAdapter(channel, new MqttPacketFormatterAdapter(protocolVersion, writer), null, new MqttNetLogger());
+            var adapter = new MqttChannelAdapter(channel, new MqttPacketFormatterAdapter(protocolVersion, writer), null, new MqttNetEventLogger());
             return (TPacket)adapter.ReceivePacketAsync(CancellationToken.None).GetAwaiter().GetResult();
 
             //using (var headerStream = new MemoryStream(buffer1.ToArray()))
@@ -680,7 +681,7 @@ namespace MQTTnet.Tests
         MqttProtocolVersion DeserializeAndDetectVersion(MqttPacketFormatterAdapter packetFormatterAdapter, byte[] buffer)
         {
             var channel = new TestMqttChannel(buffer);
-            var adapter = new MqttChannelAdapter(channel, packetFormatterAdapter, null, new MqttNetLogger());
+            var adapter = new MqttChannelAdapter(channel, packetFormatterAdapter, null, new MqttNetEventLogger());
 
             adapter.ReceivePacketAsync(CancellationToken.None).GetAwaiter().GetResult();
             return packetFormatterAdapter.ProtocolVersion;