Refactor logger. (#1247)

Tests/MQTTnet.Benchmarks/ChannelAdapterBenchmark.cs

@@ -1,22 +1,22 @@
 using BenchmarkDotNet.Attributes;
 using MQTTnet.Adapter;
-using MQTTnet.Diagnostics;
 using MQTTnet.Internal;
 using MQTTnet.Packets;
 using System;
 using System.IO;
 using System.Threading;
+using MQTTnet.Diagnostics.Logger;
 using MQTTnet.Formatter;
 
 namespace MQTTnet.Benchmarks
 {
     [MemoryDiagnoser]
-    public class ChannelAdapterBenchmark
+    public sealed class ChannelAdapterBenchmark
     {
-        private MqttChannelAdapter _channelAdapter;
-        private int _iterations;
-        private MemoryStream _stream;
-        private MqttPublishPacket _packet;
+        MqttChannelAdapter _channelAdapter;
+        int _iterations;
+        MemoryStream _stream;
+        MqttPublishPacket _packet;
 
         [GlobalSetup]
         public void Setup()
@@ -43,7 +43,7 @@ namespace MQTTnet.Benchmarks
 
             var channel = new TestMqttChannel(_stream);
             
-            _channelAdapter = new MqttChannelAdapter(channel, serializer, null, new MqttNetLogger());
+            _channelAdapter = new MqttChannelAdapter(channel, serializer, null, new MqttNetEventLogger());
         }
 
         [Benchmark]
@@ -72,7 +72,7 @@ namespace MQTTnet.Benchmarks
             _stream.Position = 0;
         }
 
-        private static byte[] Join(params ArraySegment<byte>[] chunks)
+        static byte[] Join(params ArraySegment<byte>[] chunks)
         {
             var buffer = new MemoryStream();
             foreach (var chunk in chunks)

Tests/MQTTnet.Benchmarks/Configurations/AllowNonOptimized.cs

@@ -1,6 +1,4 @@
-using System.Linq;
-using BenchmarkDotNet.Configs;
-using BenchmarkDotNet.Jobs;
+using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Validators;
 
 namespace MQTTnet.Benchmarks.Configurations

Tests/MQTTnet.Benchmarks/Configurations/RuntimeCompareConfig.cs

@@ -1,5 +1,4 @@
-using BenchmarkDotNet.Configs;
-using BenchmarkDotNet.Environments;
+using BenchmarkDotNet.Environments;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Toolchains.CsProj;
 

Tests/MQTTnet.Benchmarks/LoggerBenchmark.cs

@@ -1,6 +1,6 @@
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
-using MQTTnet.Diagnostics;
+using MQTTnet.Diagnostics.Logger;
 
 namespace MQTTnet.Benchmarks
 {
@@ -9,17 +9,29 @@ namespace MQTTnet.Benchmarks
     [MemoryDiagnoser]
     public class LoggerBenchmark
     {
-        MqttNetLogger _logger;
-        IMqttNetScopedLogger _childLogger;
+        MqttNetNullLogger _nullLogger;
+        MqttNetSourceLogger _sourceNullLogger;
+        
+        MqttNetEventLogger _eventLogger;
+        MqttNetSourceLogger _sourceEventLogger;
+        
+        MqttNetEventLogger _eventLoggerNoListener;
+        MqttNetSourceLogger _sourceEventLoggerNoListener;
+        
         bool _useHandler;
 
         [GlobalSetup]
         public void Setup()
         {
-            _logger = new MqttNetLogger();
-            _childLogger = _logger.CreateScopedLogger("child");
-
-            _logger.LogMessagePublished += OnLogMessagePublished;
+            _nullLogger = new MqttNetNullLogger();
+            _sourceNullLogger = _nullLogger.WithSource("Source");
+            
+            _eventLogger = new MqttNetEventLogger();
+            _eventLogger.LogMessagePublished += OnLogMessagePublished;
+            _sourceEventLogger = _eventLogger.WithSource("Source");
+            
+            _eventLoggerNoListener = new MqttNetEventLogger();
+            _sourceEventLoggerNoListener = _eventLoggerNoListener.WithSource("Source");
         }
 
         void OnLogMessagePublished(object sender, MqttNetLogMessagePublishedEventArgs eventArgs)
@@ -31,22 +43,44 @@ namespace MQTTnet.Benchmarks
         }
 
         [Benchmark]
-        public void Log_10000_Messages_NoHandler()
+        public void Log_10000_Messages_No_Listener()
         {
             _useHandler = false;
+            
             for (var i = 0; i < 10000; i++)
             {
-                _childLogger.Verbose("test log message {0}", "parameter");
+                _sourceEventLoggerNoListener.Verbose("test log message {0}", "parameter");
             }
         }
 
         [Benchmark]
-        public void Log_10000_Messages_WithHandler()
+        public void Log_10000_Messages_With_To_String()
         {
             _useHandler = true;
+            
             for (var i = 0; i < 10000; i++)
             {
-                _childLogger.Verbose("test log message {0}", "parameter");
+                _sourceEventLogger.Verbose("test log message {0}", "parameter");
+            }
+        }
+        
+        [Benchmark]
+        public void Log_10000_Messages_Without_To_String()
+        {
+            _useHandler = false;
+            
+            for (var i = 0; i < 10000; i++)
+            {
+                _sourceEventLogger.Verbose("test log message {0}", "parameter");
+            }
+        }
+        
+        [Benchmark]
+        public void Log_10000_Messages_With_NullLogger()
+        {
+            for (var i = 0; i < 10000; i++)
+            {
+                _sourceNullLogger.Verbose("test log message {0}", "parameter");
             }
         }
     }

Tests/MQTTnet.Benchmarks/MessageProcessingBenchmark.cs

@@ -11,9 +11,9 @@ namespace MQTTnet.Benchmarks
     [MemoryDiagnoser]
     public class MessageProcessingBenchmark
     {
-        private IMqttServer _mqttServer;
-        private IMqttClient _mqttClient;
-        private MqttApplicationMessage _message;
+        IMqttServer _mqttServer;
+        IMqttClient _mqttClient;
+        MqttApplicationMessage _message;
 
         [GlobalSetup]
         public void Setup()

Tests/MQTTnet.Benchmarks/MessageProcessingMqttConnectionContextBenchmark.cs

@@ -1,25 +1,20 @@
 using BenchmarkDotNet.Attributes;
 using MQTTnet.Client;
-
-
-using MQTTnet.AspNetCore;
-
 using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Hosting;
-using MQTTnet.Server;
-using MQTTnet.Diagnostics;
 using MQTTnet.AspNetCore.Client;
 using MQTTnet.AspNetCore.Extensions;
 using MQTTnet.Client.Options;
+using MQTTnet.Diagnostics.Logger;
 
 namespace MQTTnet.Benchmarks
 {
     [MemoryDiagnoser]
     public class MessageProcessingMqttConnectionContextBenchmark
     {
-        private IWebHost _host;
-        private IMqttClient _mqttClient;
-        private MqttApplicationMessage _message;
+        IWebHost _host;
+        IMqttClient _mqttClient;
+        MqttApplicationMessage _message;
 
         [GlobalSetup]
         public void Setup()
@@ -39,7 +34,7 @@ namespace MQTTnet.Benchmarks
                    .Build();
 
             var factory = new MqttFactory();
-            _mqttClient = factory.CreateMqttClient(new MqttNetLogger(), new MqttClientConnectionContextFactory());
+            _mqttClient = factory.CreateMqttClient(new MqttNetEventLogger(), new MqttClientConnectionContextFactory());
 
             _host.StartAsync().GetAwaiter().GetResult();
 

Tests/MQTTnet.Benchmarks/MqttTcpChannelBenchmark.cs

@@ -1,26 +1,26 @@
 using BenchmarkDotNet.Attributes;
 using MQTTnet.Channel;
 using MQTTnet.Client.Options;
-using MQTTnet.Diagnostics;
 using MQTTnet.Implementations;
 using MQTTnet.Server;
 using System.Threading;
 using System.Threading.Tasks;
+using MQTTnet.Diagnostics.Logger;
 
 namespace MQTTnet.Benchmarks
 {
     [MemoryDiagnoser]
-    public class MqttTcpChannelBenchmark
+    public sealed class MqttTcpChannelBenchmark
     {
-        private IMqttServer _mqttServer;
-        private IMqttChannel _serverChannel;
-        private IMqttChannel _clientChannel;
+        IMqttServer _mqttServer;
+        IMqttChannel _serverChannel;
+        IMqttChannel _clientChannel;
 
         [GlobalSetup]
         public void Setup()
         {
             var factory = new MqttFactory();
-            var tcpServer = new MqttTcpServerAdapter(new MqttNetLogger());
+            var tcpServer = new MqttTcpServerAdapter(new MqttNetEventLogger());
             tcpServer.ClientHandler += args =>
             {
                 _serverChannel =
@@ -31,7 +31,7 @@ namespace MQTTnet.Benchmarks
                 return Task.CompletedTask;
             };
 
-            _mqttServer = factory.CreateMqttServer(new[] { tcpServer }, new MqttNetLogger());
+            _mqttServer = factory.CreateMqttServer(new[] { tcpServer }, new MqttNetEventLogger());
 
             var serverOptions = new MqttServerOptionsBuilder().Build();
             _mqttServer.StartAsync(serverOptions).GetAwaiter().GetResult();
@@ -54,7 +54,7 @@ namespace MQTTnet.Benchmarks
             await Task.WhenAll(WriteAsync(iterations, size), ReadAsync(iterations, size));
         }
 
-        private async Task ReadAsync(int iterations, int size)
+        async Task ReadAsync(int iterations, int size)
         {
             await Task.Yield();
 
@@ -68,7 +68,7 @@ namespace MQTTnet.Benchmarks
             }
         }
 
-        private async Task WriteAsync(int iterations, int size)
+        async Task WriteAsync(int iterations, int size)
         {
             await Task.Yield();
 
@@ -78,4 +78,4 @@ namespace MQTTnet.Benchmarks
             }
         }
     }
-}
+}

Tests/MQTTnet.Benchmarks/Program.cs

@@ -1,7 +1,7 @@
 using System;
 using BenchmarkDotNet.Running;
 using MQTTnet.Benchmarks.Configurations;
-using MQTTnet.Diagnostics;
+using MQTTnet.Diagnostics.Runtime;
 
 namespace MQTTnet.Benchmarks
 {

Tests/MQTTnet.Benchmarks/SerializerBenchmark.cs

@@ -9,7 +9,7 @@ using MQTTnet.Channel;
 using MQTTnet.Formatter;
 using MQTTnet.Formatter.V3;
 using BenchmarkDotNet.Jobs;
-using MQTTnet.Diagnostics;
+using MQTTnet.Diagnostics.Logger;
 
 namespace MQTTnet.Benchmarks
 {
@@ -18,9 +18,9 @@ namespace MQTTnet.Benchmarks
     [MemoryDiagnoser]
     public class SerializerBenchmark
     {
-        private MqttBasePacket _packet;
-        private ArraySegment<byte> _serializedPacket;
-        private IMqttPacketFormatter _serializer;
+        MqttBasePacket _packet;
+        ArraySegment<byte> _serializedPacket;
+        IMqttPacketFormatter _serializer;
 
         [GlobalSetup]
         public void Setup()
@@ -49,7 +49,7 @@ namespace MQTTnet.Benchmarks
         {
             var channel = new BenchmarkMqttChannel(_serializedPacket);
             var fixedHeader = new byte[2];
-            var reader = new MqttChannelAdapter(channel, new MqttPacketFormatterAdapter(new MqttPacketWriter()), null, new MqttNetLogger());
+            var reader = new MqttChannelAdapter(channel, new MqttPacketFormatterAdapter(new MqttPacketWriter()), null, new MqttNetEventLogger());
 
             for (var i = 0; i < 10000; i++)
             {
@@ -59,10 +59,10 @@ namespace MQTTnet.Benchmarks
             }
         }
 
-        private class BenchmarkMqttChannel : IMqttChannel
+        class BenchmarkMqttChannel : IMqttChannel
         {
-            private readonly ArraySegment<byte> _buffer;
-            private int _position;
+            readonly ArraySegment<byte> _buffer;
+            int _position;
 
             public BenchmarkMqttChannel(ArraySegment<byte> buffer)
             {

Tests/MQTTnet.Benchmarks/TcpPipesBenchmark.cs

@@ -11,8 +11,8 @@ namespace MQTTnet.Benchmarks
     [MemoryDiagnoser]
     public class TcpPipesBenchmark
     {
-        private IDuplexPipe _client;
-        private IDuplexPipe _server;
+        IDuplexPipe _client;
+        IDuplexPipe _server;
 
         [GlobalSetup]
         public void Setup()
@@ -43,7 +43,7 @@ namespace MQTTnet.Benchmarks
             await Task.WhenAll(WriteAsync(iterations, size), ReadAsync(iterations, size));
         }
 
-        private async Task ReadAsync(int iterations, int size)
+        async Task ReadAsync(int iterations, int size)
         {
             await Task.Yield();
 
@@ -59,7 +59,7 @@ namespace MQTTnet.Benchmarks
             }
         }
 
-        private async Task WriteAsync(int iterations, int size)
+        async Task WriteAsync(int iterations, int size)
         {
             await Task.Yield();
 

Tests/MQTTnet.Benchmarks/TopicFilterComparerBenchmark.cs

@@ -1,6 +1,5 @@
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
-using MQTTnet.Server;
 using System;
 using MQTTnet.Server.Internal;
 
@@ -11,7 +10,7 @@ namespace MQTTnet.Benchmarks
     [MemoryDiagnoser]
     public class TopicFilterComparerBenchmark
     {
-        private static readonly char[] TopicLevelSeparator = { '/' };
+        static readonly char[] TopicLevelSeparator = { '/' };
 
         [GlobalSetup]
         public void Setup()
@@ -48,7 +47,7 @@ namespace MQTTnet.Benchmarks
             }
         }
 
-        private static bool LegacyMethodByStringSplit(string topic, string filter)
+        static bool LegacyMethodByStringSplit(string topic, string filter)
         {
             if (topic == null) throw new ArgumentNullException(nameof(topic));
             if (filter == null) throw new ArgumentNullException(nameof(filter));

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;

Tests/MQTTnet.TestApp.NetCore/ClientFlowTest.cs

@@ -2,7 +2,7 @@
 using System.Threading.Tasks;
 using MQTTnet.Client;
 using MQTTnet.Client.Options;
-using MQTTnet.Diagnostics;
+using MQTTnet.Diagnostics.Logger;
 
 namespace MQTTnet.TestApp.NetCore
 {
@@ -12,7 +12,7 @@ namespace MQTTnet.TestApp.NetCore
         {
             try
             {
-                var logger = new MqttNetLogger();
+                var logger = new MqttNetEventLogger();
                 MqttNetConsoleLogger.ForwardToConsole(logger);
                 
                 var factory = new MqttFactory(logger);

Tests/MQTTnet.TestApp.NetCore/ClientTest.cs

@@ -7,7 +7,7 @@ using MQTTnet.Protocol;
 using System;
 using System.Text;
 using System.Threading.Tasks;
-using MQTTnet.Diagnostics;
+using MQTTnet.Diagnostics.Logger;
 
 namespace MQTTnet.TestApp.NetCore
 {
@@ -17,7 +17,7 @@ namespace MQTTnet.TestApp.NetCore
         {
             try
             {
-                var logger = new MqttNetLogger();
+                var logger = new MqttNetEventLogger();
                 MqttNetConsoleLogger.ForwardToConsole(logger);
 
                 var factory = new MqttFactory(logger);

Tests/MQTTnet.TestApp.NetCore/MqttNetConsoleLogger.cs

@@ -1,6 +1,6 @@
-using MQTTnet.Diagnostics;
-using System;
+using System;
 using System.Text;
+using MQTTnet.Diagnostics.Logger;
 
 namespace MQTTnet.TestApp.NetCore
 {
@@ -8,7 +8,7 @@ namespace MQTTnet.TestApp.NetCore
     {
         static readonly object _lock = new object();
 
-        public static void ForwardToConsole(MqttNetLogger logger)
+        public static void ForwardToConsole(MqttNetEventLogger logger)
         {
             if (logger == null) throw new ArgumentNullException(nameof(logger));
             

Tests/MQTTnet.TestApp.NetCore/Program.cs

@@ -9,6 +9,7 @@ using System.Net.Security;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Client;
+using MQTTnet.Diagnostics.Runtime;
 
 namespace MQTTnet.TestApp.NetCore
 {

Tests/MQTTnet.TestApp.NetCore/ServerAndClientTest.cs

@@ -2,7 +2,7 @@
 using System.Threading.Tasks;
 using MQTTnet.Client;
 using MQTTnet.Client.Options;
-using MQTTnet.Diagnostics;
+using MQTTnet.Diagnostics.Logger;
 using MQTTnet.Server;
 
 namespace MQTTnet.TestApp.NetCore
@@ -11,7 +11,7 @@ namespace MQTTnet.TestApp.NetCore
     {
         public static async Task RunAsync()
         {
-            var logger = new MqttNetLogger();
+            var logger = new MqttNetEventLogger();
             MqttNetConsoleLogger.ForwardToConsole(logger);
 
             var factory = new MqttFactory(logger);

Tests/MQTTnet.TestApp.NetCore/ServerTest.cs

@@ -3,6 +3,7 @@ using System.Text;
 using System.Threading.Tasks;
 using MQTTnet.Client.Receiving;
 using MQTTnet.Diagnostics;
+using MQTTnet.Diagnostics.Logger;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
 using MQTTnet.Server.Internal;
@@ -22,7 +23,7 @@ namespace MQTTnet.TestApp.NetCore
 
         public static void RunEmptyServerWithLogging()
         {
-            var logger = new MqttNetLogger();
+            var logger = new MqttNetEventLogger();
             MqttNetConsoleLogger.ForwardToConsole(logger);
            
             var mqttFactory = new MqttFactory(logger);