Merge pull request #70 from JanEggers/msExtensions

initial version of ms.extensions.logging and di

MQTTnet.Core/Adapter/IMqttCommunicationAdapterFactory.cs

@@ -0,0 +1,12 @@
+using MQTTnet.Core.Client;
+using MQTTnet.Core.Channel;
+
+namespace MQTTnet.Core.Adapter
+{
+    public interface IMqttCommunicationAdapterFactory
+    {
+        IMqttCommunicationAdapter CreateClientMqttCommunicationAdapter(IMqttClientOptions options);
+
+        IMqttCommunicationAdapter CreateServerMqttCommunicationAdapter(IMqttCommunicationChannel channel);
+    }
+}

MQTTnet.Core/Adapter/MqttChannelCommunicationAdapter.cs

@@ -4,23 +4,23 @@ using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Channel;
-using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
 using MQTTnet.Core.Internal;
 using MQTTnet.Core.Packets;
 using MQTTnet.Core.Serializer;
+using Microsoft.Extensions.Logging;
 
 namespace MQTTnet.Core.Adapter
 {
     public class MqttChannelCommunicationAdapter : IMqttCommunicationAdapter
     {
-        private readonly MqttNetTrace _trace;
+        private readonly ILogger<MqttChannelCommunicationAdapter> _logger;
         private readonly IMqttCommunicationChannel _channel;
         private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
 
-        public MqttChannelCommunicationAdapter(IMqttCommunicationChannel channel, IMqttPacketSerializer serializer, MqttNetTrace trace)
+        public MqttChannelCommunicationAdapter(IMqttCommunicationChannel channel, IMqttPacketSerializer serializer, ILogger<MqttChannelCommunicationAdapter> logger)
         {
-            _trace = trace ?? throw new ArgumentNullException(nameof(trace));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
             _channel = channel ?? throw new ArgumentNullException(nameof(channel));
             PacketSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
         }
@@ -96,7 +96,7 @@ namespace MQTTnet.Core.Adapter
                         continue;
                     }
 
-                    _trace.Information(nameof(MqttChannelCommunicationAdapter), "TX >>> {0} [Timeout={1}]", packet, timeout);
+                    _logger.LogInformation("TX >>> {0} [Timeout={1}]", packet, timeout);
 
                     var writeBuffer = PacketSerializer.Serialize(packet);
                     await _channel.SendStream.WriteAsync(writeBuffer, 0, writeBuffer.Length, cancellationToken).ConfigureAwait(false);
@@ -162,7 +162,7 @@ namespace MQTTnet.Core.Adapter
                     throw new MqttProtocolViolationException("Received malformed packet.");
                 }
 
-                _trace.Information(nameof(MqttChannelCommunicationAdapter), "RX <<< {0}", packet);
+                _logger.LogInformation("RX <<< {0}", packet);
                 return packet;
             }
             catch (TaskCanceledException)

MQTTnet.Core/Client/IMqttClientFactory.cs

@@ -1,12 +1,11 @@
-using MQTTnet.Core.Diagnostics;
-using MQTTnet.Core.ManagedClient;
+using MQTTnet.Core.ManagedClient;
 
 namespace MQTTnet.Core.Client
 {
     public interface IMqttClientFactory
     {
-        IMqttClient CreateMqttClient(IMqttNetTraceHandler traceHandler = null);
+        IMqttClient CreateMqttClient();
 
-        ManagedMqttClient CreateManagedMqttClient(IMqttNetTraceHandler traceHandler = null);
+        ManagedMqttClient CreateManagedMqttClient();
     }
 }

MQTTnet.Core/Client/IMqttCommunicationAdapterFactory.cs

@@ -1,9 +0,0 @@
-using MQTTnet.Core.Adapter;
-
-namespace MQTTnet.Core.Client
-{
-    public interface IMqttCommunicationAdapterFactory
-    {
-        IMqttCommunicationAdapter CreateMqttCommunicationAdapter(IMqttClientOptions options);
-    }
-}

MQTTnet.Core/Client/MqttClient.cs

@@ -4,11 +4,11 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Adapter;
-using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
 using MQTTnet.Core.Internal;
 using MQTTnet.Core.Packets;
 using MQTTnet.Core.Protocol;
+using Microsoft.Extensions.Logging;
 
 namespace MQTTnet.Core.Client
 {
@@ -16,21 +16,21 @@ namespace MQTTnet.Core.Client
     {
         private readonly HashSet<ushort> _unacknowledgedPublishPackets = new HashSet<ushort>();
         private readonly MqttPacketDispatcher _packetDispatcher;
-        private readonly IMqttCommunicationAdapterFactory _communicationChannelFactory;
-        private readonly MqttNetTrace _trace;
+        private readonly IMqttCommunicationAdapterFactory _communicationAdapterFactory;
+        private readonly ILogger<MqttClient> _logger;
 
         private IMqttClientOptions _options;
         private bool _isReceivingPackets;
         private int _latestPacketIdentifier;
         private CancellationTokenSource _cancellationTokenSource;
         private IMqttCommunicationAdapter _adapter;
+        private IDisposable _scopeHandle;
 
-        public MqttClient(IMqttCommunicationAdapterFactory communicationChannelFactory, MqttNetTrace trace)
+        public MqttClient(IMqttCommunicationAdapterFactory communicationAdapterFactory, ILogger<MqttClient> logger, MqttPacketDispatcher packetDispatcher)
         {
-            _trace = trace ?? throw new ArgumentNullException(nameof(trace));
-            _communicationChannelFactory = communicationChannelFactory ?? throw new ArgumentNullException(nameof(communicationChannelFactory));
-
-            _packetDispatcher = new MqttPacketDispatcher(trace);
+            _communicationAdapterFactory = communicationAdapterFactory ?? throw new ArgumentNullException(nameof(communicationAdapterFactory));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _packetDispatcher = packetDispatcher ?? throw new ArgumentNullException(nameof(packetDispatcher));
         }
 
         public event EventHandler<MqttClientConnectedEventArgs> Connected;
@@ -52,16 +52,17 @@ namespace MQTTnet.Core.Client
                 _latestPacketIdentifier = 0;
                 _packetDispatcher.Reset();
 
-                _adapter = _communicationChannelFactory.CreateMqttCommunicationAdapter(options);
+                _adapter = _communicationAdapterFactory.CreateClientMqttCommunicationAdapter(options);
 
-                _trace.Verbose(nameof(MqttClient), "Trying to connect with server.");
+                _scopeHandle = _logger.BeginScope(options.ClientId);
+                _logger.LogTrace("Trying to connect with server.");
                 await _adapter.ConnectAsync(_options.DefaultCommunicationTimeout).ConfigureAwait(false);
-                _trace.Verbose(nameof(MqttClient), "Connection with server established.");
+                _logger.LogTrace("Connection with server established.");
 
                 await SetupIncomingPacketProcessingAsync();
                 var connectResponse = await AuthenticateAsync(options.WillMessage);
 
-                _trace.Verbose(nameof(MqttClient), "MQTT connection with server established.");
+                _logger.LogTrace("MQTT connection with server established.");
 
                 if (_options.KeepAlivePeriod != TimeSpan.Zero)
                 {
@@ -93,6 +94,7 @@ namespace MQTTnet.Core.Client
             finally
             {
                 await DisconnectInternalAsync().ConfigureAwait(false);
+                _scopeHandle.Dispose();
             }
         }
 
@@ -246,11 +248,11 @@ namespace MQTTnet.Core.Client
             try
             {
                 await _adapter.DisconnectAsync(_options.DefaultCommunicationTimeout).ConfigureAwait(false);
-                _trace.Information(nameof(MqttClient), "Disconnected from adapter.");
+                _logger.LogInformation("Disconnected from adapter.");
             }
             catch (Exception exception)
             {
-                _trace.Warning(nameof(MqttClient), exception, "Error while disconnecting from adapter.");
+                _logger.LogWarning(new EventId(), exception, "Error while disconnecting from adapter.");
             }
             finally
             {
@@ -262,7 +264,7 @@ namespace MQTTnet.Core.Client
         {
             try
             {
-                _trace.Information(nameof(MqttClient), "Received <<< {0}", packet);
+                _logger.LogInformation("Received <<< {0}", packet);
 
                 if (packet is MqttPingReqPacket)
                 {
@@ -292,7 +294,7 @@ namespace MQTTnet.Core.Client
             }
             catch (Exception exception)
             {
-                _trace.Error(nameof(MqttClient), exception, "Unhandled exception while processing received packet.");
+                _logger.LogError(new EventId(), exception, "Unhandled exception while processing received packet.");
             }
         }
 
@@ -305,7 +307,7 @@ namespace MQTTnet.Core.Client
             }
             catch (Exception exception)
             {
-                _trace.Error(nameof(MqttClient), exception, "Unhandled exception while handling application message.");
+                _logger.LogError(new EventId(), exception, "Unhandled exception while handling application message.");
             }
         }
 
@@ -369,7 +371,7 @@ namespace MQTTnet.Core.Client
 
         private async Task SendKeepAliveMessagesAsync(CancellationToken cancellationToken)
         {
-            _trace.Information(nameof(MqttClient), "Start sending keep alive packets.");
+            _logger.LogInformation("Start sending keep alive packets.");
 
             try
             {
@@ -394,23 +396,23 @@ namespace MQTTnet.Core.Client
                     return;
                 }
 
-                _trace.Warning(nameof(MqttClient), exception, "MQTT communication exception while sending/receiving keep alive packets.");
+                _logger.LogWarning(new EventId(), exception, "MQTT communication exception while sending/receiving keep alive packets.");
                 await DisconnectInternalAsync().ConfigureAwait(false);
             }
             catch (Exception exception)
             {
-                _trace.Warning(nameof(MqttClient), exception, "Unhandled exception while sending/receiving keep alive packets.");
+                _logger.LogWarning(new EventId(), exception, "Unhandled exception while sending/receiving keep alive packets.");
                 await DisconnectInternalAsync().ConfigureAwait(false);
             }
             finally
             {
-                _trace.Information(nameof(MqttClient), "Stopped sending keep alive packets.");
+                _logger.LogInformation("Stopped sending keep alive packets.");
             }
         }
 
         private async Task ReceivePackets(CancellationToken cancellationToken)
         {
-            _trace.Information(nameof(MqttClient), "Start receiving packets.");
+            _logger.LogInformation("Start receiving packets.");
 
             try
             {
@@ -437,17 +439,17 @@ namespace MQTTnet.Core.Client
                     return;
                 }
 
-                _trace.Warning(nameof(MqttClient), exception, "MQTT communication exception while receiving packets.");
+                _logger.LogWarning(new EventId(), exception, "MQTT communication exception while receiving packets.");
                 await DisconnectInternalAsync().ConfigureAwait(false);
             }
             catch (Exception exception)
             {
-                _trace.Error(nameof(MqttClient), exception, "Unhandled exception while receiving packets.");
+                _logger.LogError(new EventId(), exception, "Unhandled exception while receiving packets.");
                 await DisconnectInternalAsync().ConfigureAwait(false);
             }
             finally
             {
-                _trace.Information(nameof(MqttClient), "Stopped receiving packets.");
+                _logger.LogInformation(nameof(MqttClient), "Stopped receiving packets.");
             }
         }
 

MQTTnet.Core/Client/MqttPacketDispatcher.cs

@@ -1,10 +1,10 @@
 using System;
+using System.Collections.Concurrent;
 using System.Threading.Tasks;
-using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
 using MQTTnet.Core.Internal;
 using MQTTnet.Core.Packets;
-using System.Collections.Concurrent;
+using Microsoft.Extensions.Logging;
 
 namespace MQTTnet.Core.Client
 {
@@ -12,11 +12,11 @@ namespace MQTTnet.Core.Client
     {
         private readonly ConcurrentDictionary<Type, TaskCompletionSource<MqttBasePacket>> _packetByResponseType = new ConcurrentDictionary<Type, TaskCompletionSource<MqttBasePacket>>();
         private readonly ConcurrentDictionary<Type, ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>> _packetByResponseTypeAndIdentifier = new ConcurrentDictionary<Type, ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>>();
-        private readonly MqttNetTrace _trace;
+        private readonly ILogger<MqttPacketDispatcher> _logger;
 
-        public MqttPacketDispatcher(MqttNetTrace trace)
+        public MqttPacketDispatcher(ILogger<MqttPacketDispatcher> logger)
         {
-            _trace = trace ?? throw new ArgumentNullException(nameof(trace));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
 
         public async Task<MqttBasePacket> WaitForPacketAsync(MqttBasePacket request, Type responseType, TimeSpan timeout)
@@ -30,7 +30,7 @@ namespace MQTTnet.Core.Client
             }
             catch (MqttCommunicationTimedOutException)
             {
-                _trace.Warning(nameof(MqttPacketDispatcher), "Timeout while waiting for packet of type '{0}'.", responseType.Name);
+                _logger.LogWarning("Timeout while waiting for packet of type '{0}'.", responseType.Name);
                 throw;
             }
             finally

MQTTnet.Core/Diagnostics/IMqttNetTraceHandler.cs

@@ -1,9 +0,0 @@
-namespace MQTTnet.Core.Diagnostics
-{
-    public interface IMqttNetTraceHandler
-    {
-        bool IsEnabled { get; }
-
-        void HandleTraceMessage(MqttNetTraceMessage traceMessage);
-    }
-}

MQTTnet.Core/Diagnostics/MqttNetLogger.cs

@@ -0,0 +1,49 @@
+using System;
+using Microsoft.Extensions.Logging;
+
+namespace MQTTnet.Core.Diagnostics
+{
+    public class MqttNetLogger : ILogger
+    {
+        private readonly string _categoryName;
+        private readonly MqttNetTrace _mqttNetTrace;
+
+        public MqttNetLogger(string categoryName, MqttNetTrace mqttNetTrace)
+        {
+            _categoryName = categoryName;
+            _mqttNetTrace = mqttNetTrace;
+        }
+
+        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+        {
+            if (formatter == null)
+            {
+                throw new ArgumentNullException(nameof(formatter));
+            }
+
+            var message = formatter(state, exception);
+
+            var traceMessage = new MqttNetTraceMessage(DateTime.Now, Environment.CurrentManagedThreadId, _categoryName, logLevel, message, exception);
+            _mqttNetTrace.Publish(traceMessage);
+        }
+
+        public bool IsEnabled(LogLevel logLevel)
+        {
+            return true;
+        }
+
+        //not supported: async local requires netstandard1.3
+        //for implementation see https://github.com/aspnet/Logging/blob/dev/src/Microsoft.Extensions.Logging.Console/ConsoleLogScope.cs
+        public IDisposable BeginScope<TState>(TState state)
+        {
+            return new DisposableScope();
+        }
+
+        private class DisposableScope : IDisposable
+        {
+            public void Dispose()
+            {
+            }
+        }
+    }
+}

MQTTnet.Core/Diagnostics/MqttNetTrace.cs

@@ -1,77 +1,33 @@
 using System;
+using System.Collections.Concurrent;
+using Microsoft.Extensions.Logging;
 
 namespace MQTTnet.Core.Diagnostics
 {
-    public sealed class MqttNetTrace : IMqttNetTraceHandler
+    public class MqttNetTrace : ILoggerProvider
     {
-        private readonly IMqttNetTraceHandler _traceHandler;
+        private readonly ConcurrentDictionary<string, MqttNetLogger> _loggers = new ConcurrentDictionary<string, MqttNetLogger>();
 
-        public MqttNetTrace(IMqttNetTraceHandler customTraceHandler = null)
-        {
-            _traceHandler = customTraceHandler ?? this;
-        }
-        
         public static event EventHandler<MqttNetTraceMessagePublishedEventArgs> TraceMessagePublished;
 
-        public bool IsEnabled => TraceMessagePublished != null;
-
-        public void Verbose(string source, string message, params object[] parameters)
+        public void Publish(MqttNetTraceMessage msg)
         {
-            Publish(source, MqttNetTraceLevel.Verbose, null, message, parameters);
+            TraceMessagePublished?.Invoke(this, new MqttNetTraceMessagePublishedEventArgs(msg));
         }
 
-        public void Information(string source, string message, params object[] parameters)
+        public void Dispose()
         {
-            Publish(source, MqttNetTraceLevel.Information, null, message, parameters);
+            TraceMessagePublished = null;
         }
 
-        public void Warning(string source, string message, params object[] parameters)
+        public ILogger CreateLogger(string categoryName)
         {
-            Publish(source, MqttNetTraceLevel.Warning, null, message, parameters);
+            return _loggers.GetOrAdd(categoryName, CreateLoggerImplementation);
         }
 
-        public void Warning(string source, Exception exception, string message, params object[] parameters)
+        private MqttNetLogger CreateLoggerImplementation(string categoryName)
         {
-            Publish(source, MqttNetTraceLevel.Warning, exception, message, parameters);
-        }
-
-        public void Error(string source, string message, params object[] parameters)
-        {
-            Publish(source, MqttNetTraceLevel.Error, null, message, parameters);
-        }
-
-        public void Error(string source, Exception exception, string message, params object[] parameters)
-        {
-            Publish(source, MqttNetTraceLevel.Error, exception, message, parameters);
-        }
-
-        public void HandleTraceMessage(MqttNetTraceMessage mqttNetTraceMessage)
-        {
-            TraceMessagePublished?.Invoke(this, new MqttNetTraceMessagePublishedEventArgs(mqttNetTraceMessage));
-        }
-
-        private void Publish(string source, MqttNetTraceLevel traceLevel, Exception exception, string message, params object[] parameters)
-        {
-            if (!_traceHandler.IsEnabled)
-            {
-                return;
-            }
-
-            var now = DateTime.Now;
-            if (parameters?.Length > 0)
-            {
-                try
-                {
-                    message = string.Format(message, parameters);
-                }
-                catch (Exception formatException)
-                {
-                    Error(nameof(MqttNetTrace), formatException, "Error while tracing message: " + message);
-                    return;
-                }
-            }
-
-            _traceHandler.HandleTraceMessage(new MqttNetTraceMessage(now, Environment.CurrentManagedThreadId, source, traceLevel, message, exception));
+            return new MqttNetLogger(categoryName, this);
         }
     }
 }

MQTTnet.Core/Diagnostics/MqttNetTraceLevel.cs

@@ -1,10 +0,0 @@
-namespace MQTTnet.Core.Diagnostics
-{
-    public enum MqttNetTraceLevel
-    {
-        Verbose,
-        Information,
-        Warning,
-        Error
-    }
-}

MQTTnet.Core/Diagnostics/MqttTraceMessage.cs

@@ -1,10 +1,11 @@
 using System;
+using Microsoft.Extensions.Logging;
 
 namespace MQTTnet.Core.Diagnostics
 {
     public sealed class MqttNetTraceMessage
     {
-        public MqttNetTraceMessage(DateTime timestamp, int threadId, string source, MqttNetTraceLevel level, string message, Exception exception)
+        public MqttNetTraceMessage(DateTime timestamp, int threadId, string source, LogLevel level, string message, Exception exception)
         {
             Timestamp = timestamp;
             ThreadId = threadId;
@@ -20,7 +21,7 @@ namespace MQTTnet.Core.Diagnostics
 
         public string Source { get; }
 
-        public MqttNetTraceLevel Level { get; }
+        public LogLevel Level { get; }
 
         public string Message { get; }
 

MQTTnet.Core/MQTTnet.Core.csproj

@@ -22,4 +22,10 @@
     <PackageLicenseUrl></PackageLicenseUrl>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="1.1.2" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="1.1.2" />
+    <PackageReference Include="System.Threading" Version="4.3.0" />
+  </ItemGroup>
+
 </Project>

MQTTnet.Core/ManagedClient/ManagedMqttClient.cs

@@ -5,10 +5,10 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Client;
-using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
 using MQTTnet.Core.Packets;
 using MQTTnet.Core.Protocol;
+using Microsoft.Extensions.Logging;
 
 namespace MQTTnet.Core.ManagedClient
 {
@@ -19,7 +19,7 @@ namespace MQTTnet.Core.ManagedClient
         private readonly HashSet<TopicFilter> _subscriptions = new HashSet<TopicFilter>();
 
         private readonly IMqttClient _mqttClient;
-        private readonly MqttNetTrace _trace;
+        private readonly ILogger<ManagedMqttClient> _logger;
 
         private CancellationTokenSource _connectionCancellationToken;
         private CancellationTokenSource _publishingCancellationToken;
@@ -27,12 +27,11 @@ namespace MQTTnet.Core.ManagedClient
         private IManagedMqttClientOptions _options;
         private bool _subscriptionsNotPushed;
         
-        public ManagedMqttClient(IMqttCommunicationAdapterFactory communicationChannelFactory, MqttNetTrace trace)
+        public ManagedMqttClient(ILogger<ManagedMqttClient> logger, IMqttClient mqttClient)
         {
-            if (communicationChannelFactory == null) throw new ArgumentNullException(nameof(communicationChannelFactory));
-            _trace = trace ?? throw new ArgumentNullException(nameof(trace));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _mqttClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
 
-            _mqttClient = new MqttClient(communicationChannelFactory, _trace);
             _mqttClient.Connected += OnConnected;
             _mqttClient.Disconnected += OnDisconnected;
             _mqttClient.ApplicationMessageReceived += OnApplicationMessageReceived;
@@ -77,7 +76,7 @@ namespace MQTTnet.Core.ManagedClient
             Task.Factory.StartNew(() => MaintainConnectionAsync(_connectionCancellationToken.Token), _connectionCancellationToken.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default).ConfigureAwait(false);
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
 
-            _trace.Information(nameof(ManagedMqttClient), "Started");
+            _logger.LogInformation("Started");
         }
 
         public Task StopAsync()
@@ -179,16 +178,16 @@ namespace MQTTnet.Core.ManagedClient
             }
             catch (MqttCommunicationException exception)
             {
-                _trace.Warning(nameof(ManagedMqttClient), exception, "Communication exception while maintaining connection.");
+                _logger.LogWarning(new EventId(), exception, "Communication exception while maintaining connection.");
             }
             catch (Exception exception)
             {
-                _trace.Error(nameof(ManagedMqttClient), exception, "Unhandled exception while maintaining connection.");
+                _logger.LogError(new EventId(), exception, "Unhandled exception while maintaining connection.");
             }
             finally
             {
                 await _mqttClient.DisconnectAsync().ConfigureAwait(false);
-                _trace.Information(nameof(ManagedMqttClient), "Stopped");
+                _logger.LogInformation("Stopped");
             }
         }
 
@@ -217,7 +216,7 @@ namespace MQTTnet.Core.ManagedClient
             }
             finally
             {
-                _trace.Information(nameof(ManagedMqttClient), "Stopped publishing messages");
+                _logger.LogInformation("Stopped publishing messages");
             }
         }
 
@@ -229,7 +228,7 @@ namespace MQTTnet.Core.ManagedClient
             }
             catch (MqttCommunicationException exception)
             {
-                _trace.Warning(nameof(ManagedMqttClient), exception, "Publishing application message failed.");
+                _logger.LogWarning(new EventId(), exception, "Publishing application message failed.");
 
                 if (message.QualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
                 {
@@ -238,13 +237,13 @@ namespace MQTTnet.Core.ManagedClient
             }
             catch (Exception exception)
             {
-                _trace.Error(nameof(ManagedMqttClient), exception, "Unhandled exception while publishing queued application message.");
+                _logger.LogError(new EventId(), exception, "Unhandled exception while publishing queued application message.");
             }
         }
 
         private async Task PushSubscriptionsAsync()
         {
-            _trace.Information(nameof(ManagedMqttClient), "Synchronizing subscriptions");
+            _logger.LogInformation(nameof(ManagedMqttClient), "Synchronizing subscriptions");
 
             List<TopicFilter> subscriptions;
             lock (_subscriptions)
@@ -264,7 +263,7 @@ namespace MQTTnet.Core.ManagedClient
             }
             catch (Exception exception)
             {
-                _trace.Warning(nameof(ManagedMqttClient), exception, "Synchronizing subscriptions failed");
+                _logger.LogWarning(new EventId(), exception, "Synchronizing subscriptions failed");
                 _subscriptionsNotPushed = true;
             }
         }

MQTTnet.Core/Server/IMqttClientSesssionFactory.cs

@@ -0,0 +1,7 @@
+namespace MQTTnet.Core.Server
+{
+    public interface IMqttClientSesssionFactory
+    {
+        MqttClientSession CreateClientSession(string sessionId, MqttClientSessionsManager mqttClientSessionsManager);
+    }
+}

MQTTnet.Core/Server/IMqttServerFactory.cs

@@ -1,9 +1,7 @@
-using MQTTnet.Core.Diagnostics;
-
-namespace MQTTnet.Core.Server
+namespace MQTTnet.Core.Server
 {
     public interface IMqttServerFactory
     {
-        IMqttServer CreateMqttServer(MqttServerOptions options, IMqttNetTraceHandler traceHandler = null);
+        IMqttServer CreateMqttServer();
     }
 }

MQTTnet.Core/Server/MqttClientPendingMessagesQueue.cs

@@ -3,10 +3,10 @@ using System.Collections.Concurrent;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Adapter;
-using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
 using MQTTnet.Core.Packets;
 using MQTTnet.Core.Protocol;
+using Microsoft.Extensions.Logging;
 
 namespace MQTTnet.Core.Server
 {
@@ -15,11 +15,11 @@ namespace MQTTnet.Core.Server
         private readonly BlockingCollection<MqttPublishPacket> _pendingPublishPackets = new BlockingCollection<MqttPublishPacket>();
         private readonly MqttClientSession _session;
         private readonly MqttServerOptions _options;
-        private readonly MqttNetTrace _trace;
+        private readonly ILogger<MqttClientPendingMessagesQueue> _logger;
 
-        public MqttClientPendingMessagesQueue(MqttServerOptions options, MqttClientSession session, MqttNetTrace trace)
+        public MqttClientPendingMessagesQueue(MqttServerOptions options, MqttClientSession session, ILogger<MqttClientPendingMessagesQueue> logger)
         {
-            _trace = trace ?? throw new ArgumentNullException(nameof(trace));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
             _session = session ?? throw new ArgumentNullException(nameof(session));
             _options = options ?? throw new ArgumentNullException(nameof(options));
         }
@@ -52,7 +52,7 @@ namespace MQTTnet.Core.Server
             }
             catch (Exception exception)
             {
-                _trace.Error(nameof(MqttClientPendingMessagesQueue), exception, "Unhandled exception while sending pending publish packets.");
+                _logger.LogError(new EventId(), exception, "Unhandled exception while sending pending publish packets.");
             }
         }
 
@@ -68,18 +68,18 @@ namespace MQTTnet.Core.Server
             {
                 if (exception is MqttCommunicationTimedOutException)
                 {
-                    _trace.Warning(nameof(MqttClientPendingMessagesQueue), exception, "Sending publish packet failed due to timeout.");
+                    _logger.LogWarning(new EventId(), exception, "Sending publish packet failed due to timeout.");
                 }
                 else if (exception is MqttCommunicationException)
                 {
-                    _trace.Warning(nameof(MqttClientPendingMessagesQueue), exception, "Sending publish packet failed due to communication exception.");
+                    _logger.LogWarning(new EventId(), exception, "Sending publish packet failed due to communication exception.");
                 }
                 if (exception is OperationCanceledException)
                 {
                 }
                 else
                 {
-                    _trace.Error(nameof(MqttClientPendingMessagesQueue), exception, "Sending publish packet failed.");
+                    _logger.LogError(new EventId(), exception, "Sending publish packet failed.");
                 }
 
                 if (packet.QualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)

MQTTnet.Core/Server/MqttClientRetainedMessagesManager.cs

@@ -2,21 +2,22 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Packets;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 
 namespace MQTTnet.Core.Server
 {
     public sealed class MqttClientRetainedMessagesManager
     {
         private readonly Dictionary<string, MqttApplicationMessage> _retainedMessages = new Dictionary<string, MqttApplicationMessage>();
-        private readonly MqttNetTrace _trace;
+        private readonly ILogger<MqttClientRetainedMessagesManager> _logger;
         private readonly MqttServerOptions _options;
 
-        public MqttClientRetainedMessagesManager(MqttServerOptions options, MqttNetTrace trace)
+        public MqttClientRetainedMessagesManager(IOptions<MqttServerOptions> options, ILogger<MqttClientRetainedMessagesManager> logger)
         {
-            _trace = trace ?? throw new ArgumentNullException(nameof(trace));
-            _options = options ?? throw new ArgumentNullException(nameof(options));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _options = options.Value ?? throw new ArgumentNullException(nameof(options));
         }
 
         public async Task LoadMessagesAsync()
@@ -40,7 +41,7 @@ namespace MQTTnet.Core.Server
             }
             catch (Exception exception)
             {
-                _trace.Error(nameof(MqttClientRetainedMessagesManager), exception, "Unhandled exception while loading retained messages.");
+                _logger.LogError(new EventId(), exception, "Unhandled exception while loading retained messages.");
             }
         }
 
@@ -54,12 +55,12 @@ namespace MQTTnet.Core.Server
                 if (applicationMessage.Payload?.Any() == false)
                 {
                     _retainedMessages.Remove(applicationMessage.Topic);
-                    _trace.Information(nameof(MqttClientRetainedMessagesManager), "Client '{0}' cleared retained message for topic '{1}'.", clientId, applicationMessage.Topic);
+                    _logger.LogInformation("Client '{0}' cleared retained message for topic '{1}'.", clientId, applicationMessage.Topic);
                 }
                 else
                 {
                     _retainedMessages[applicationMessage.Topic] = applicationMessage;
-                    _trace.Information(nameof(MqttClientRetainedMessagesManager), "Client '{0}' updated retained message for topic '{1}'.", clientId, applicationMessage.Topic);
+                    _logger.LogInformation("Client '{0}' updated retained message for topic '{1}'.", clientId, applicationMessage.Topic);
                 }
 
                 allRetainedMessages = new List<MqttApplicationMessage>(_retainedMessages.Values);
@@ -75,7 +76,7 @@ namespace MQTTnet.Core.Server
             }
             catch (Exception exception)
             {
-                _trace.Error(nameof(MqttClientRetainedMessagesManager), exception, "Unhandled exception while saving retained messages.");
+                _logger.LogError(new EventId(), exception, "Unhandled exception while saving retained messages.");
             }
         }
 

MQTTnet.Core/Server/MqttClientSession.cs

@@ -3,12 +3,12 @@ using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Adapter;
-using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
 using MQTTnet.Core.Internal;
 using MQTTnet.Core.Packets;
 using MQTTnet.Core.Protocol;
 using MQTTnet.Core.Serializer;
+using Microsoft.Extensions.Logging;
 
 namespace MQTTnet.Core.Server
 {
@@ -20,19 +20,20 @@ namespace MQTTnet.Core.Server
         private readonly MqttClientSessionsManager _mqttClientSessionsManager;
         private readonly MqttClientPendingMessagesQueue _pendingMessagesQueue;
         private readonly MqttServerOptions _options;
-        private readonly MqttNetTrace _trace;
+        private readonly ILogger<MqttClientSession> _logger;
 
         private IMqttCommunicationAdapter _adapter;
         private CancellationTokenSource _cancellationTokenSource;
         private MqttApplicationMessage _willMessage;
 
-        public MqttClientSession(string clientId, MqttServerOptions options, MqttClientSessionsManager mqttClientSessionsManager, MqttNetTrace trace)
+        public MqttClientSession(string clientId, MqttClientSessionsManager mqttClientSessionsManager, ILogger<MqttClientSession> logger, ILogger<MqttClientPendingMessagesQueue> msgQueueLogger)
         {
-            _trace = trace ?? throw new ArgumentNullException(nameof(trace));
             ClientId = clientId;
-            _options = options ?? throw new ArgumentNullException(nameof(options));
+            _options = mqttClientSessionsManager.Options;
             _mqttClientSessionsManager = mqttClientSessionsManager ?? throw new ArgumentNullException(nameof(mqttClientSessionsManager));
-            _pendingMessagesQueue = new MqttClientPendingMessagesQueue(options, this, trace);
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+
+            _pendingMessagesQueue = new MqttClientPendingMessagesQueue(mqttClientSessionsManager.Options, this, msgQueueLogger);
         }
 
         public string ClientId { get; }
@@ -60,11 +61,11 @@ namespace MQTTnet.Core.Server
             }
             catch (MqttCommunicationException exception)
             {
-                _trace.Warning(nameof(MqttClientSession), exception, "Client '{0}': Communication exception while processing client packets.", ClientId);
+                _logger.LogWarning(new EventId(), exception, "Client '{0}': Communication exception while processing client packets.", ClientId);
             }
             catch (Exception exception)
             {
-                _trace.Error(nameof(MqttClientSession), exception, "Client '{0}': Unhandled exception while processing client packets.", ClientId);
+                _logger.LogError(new EventId(), exception, "Client '{0}': Unhandled exception while processing client packets.", ClientId);
             }
         }
 
@@ -81,7 +82,7 @@ namespace MQTTnet.Core.Server
 
             _adapter = null;
 
-            _trace.Information(nameof(MqttClientSession), "Client '{0}': Disconnected.", ClientId);
+            _logger.LogInformation("Client '{0}': Disconnected.", ClientId);
         }
 
         public void EnqueuePublishPacket(MqttPublishPacket publishPacket)
@@ -94,7 +95,7 @@ namespace MQTTnet.Core.Server
             }
 
             _pendingMessagesQueue.Enqueue(publishPacket);
-            _trace.Verbose(nameof(MqttClientSession), "Client '{0}': Enqueued pending publish packet.", ClientId);
+            _logger.LogTrace("Client '{0}': Enqueued pending publish packet.", ClientId);
         }
 
         public void Dispose()
@@ -118,12 +119,12 @@ namespace MQTTnet.Core.Server
             }
             catch (MqttCommunicationException exception)
             {
-                _trace.Warning(nameof(MqttClientSession), exception, "Client '{0}': Communication exception while processing client packets.", ClientId);
+                _logger.LogWarning(new EventId(), exception, "Client '{0}': Communication exception while processing client packets.", ClientId);
                 Stop();
             }
             catch (Exception exception)
             {
-                _trace.Error(nameof(MqttClientSession), exception, "Client '{0}': Unhandled exception while processing client packets.", ClientId);
+                _logger.LogError(new EventId(), exception, "Client '{0}': Unhandled exception while processing client packets.", ClientId);
                 Stop();
             }
         }
@@ -165,7 +166,7 @@ namespace MQTTnet.Core.Server
             }
             else
             {
-                _trace.Warning(nameof(MqttClientSession), "Client '{0}': Received not supported packet ({1}). Closing connection.", ClientId, packet);
+                _logger.LogWarning("Client '{0}': Received not supported packet ({1}). Closing connection.", ClientId, packet);
                 Stop();
             }
         }

MQTTnet.Core/Server/MqttClientSessionsManager.cs

@@ -4,26 +4,28 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Adapter;
-using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
 using MQTTnet.Core.Internal;
 using MQTTnet.Core.Packets;
 using MQTTnet.Core.Protocol;
 using MQTTnet.Core.Serializer;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 
 namespace MQTTnet.Core.Server
 {
     public sealed class MqttClientSessionsManager
     {
         private readonly Dictionary<string, MqttClientSession> _clientSessions = new Dictionary<string, MqttClientSession>();
-        private readonly MqttServerOptions _options;
-        private readonly MqttNetTrace _trace;
+        private readonly ILogger<MqttClientSessionsManager> _logger;
+        private readonly IMqttClientSesssionFactory _mqttClientSesssionFactory;
 
-        public MqttClientSessionsManager(MqttServerOptions options, MqttNetTrace trace)
+        public MqttClientSessionsManager(IOptions<MqttServerOptions> options, ILogger<MqttClientSessionsManager> logger, MqttClientRetainedMessagesManager retainedMessagesManager, IMqttClientSesssionFactory mqttClientSesssionFactory)
         {
-            _trace = trace ?? throw new ArgumentNullException(nameof(trace));
-            _options = options ?? throw new ArgumentNullException(nameof(options));
-            RetainedMessagesManager = new MqttClientRetainedMessagesManager(options, trace);
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            Options = options.Value ?? throw new ArgumentNullException(nameof(options));
+            RetainedMessagesManager = retainedMessagesManager ?? throw new ArgumentNullException(nameof(options));
+            _mqttClientSesssionFactory = mqttClientSesssionFactory ?? throw new ArgumentNullException(nameof(mqttClientSesssionFactory));
         }
 
         public event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
@@ -31,13 +33,14 @@ namespace MQTTnet.Core.Server
         public event EventHandler<MqttClientDisconnectedEventArgs> ClientDisconnected;
 
         public MqttClientRetainedMessagesManager RetainedMessagesManager { get; }
+        public MqttServerOptions Options { get; }
 
         public async Task RunClientSessionAsync(IMqttCommunicationAdapter clientAdapter)
         {
             var clientId = string.Empty;
             try
             {
-                if (!(await clientAdapter.ReceivePacketAsync(_options.DefaultCommunicationTimeout, CancellationToken.None).ConfigureAwait(false) is MqttConnectPacket connectPacket))
+                if (!(await clientAdapter.ReceivePacketAsync(Options.DefaultCommunicationTimeout, CancellationToken.None).ConfigureAwait(false) is MqttConnectPacket connectPacket))
                 {
                     throw new MqttProtocolViolationException("The first packet from a client must be a 'CONNECT' packet [MQTT-3.1.0-1].");
                 }
@@ -50,7 +53,7 @@ namespace MQTTnet.Core.Server
                 var connectReturnCode = ValidateConnection(connectPacket);
                 if (connectReturnCode != MqttConnectReturnCode.ConnectionAccepted)
                 {
-                    await clientAdapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, CancellationToken.None, new MqttConnAckPacket
+                    await clientAdapter.SendPacketsAsync(Options.DefaultCommunicationTimeout, CancellationToken.None, new MqttConnAckPacket
                     {
                         ConnectReturnCode = connectReturnCode
                     }).ConfigureAwait(false);
@@ -60,7 +63,7 @@ namespace MQTTnet.Core.Server
 
                 var clientSession = GetOrCreateClientSession(connectPacket);
 
-                await clientAdapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, CancellationToken.None, new MqttConnAckPacket
+                await clientAdapter.SendPacketsAsync(Options.DefaultCommunicationTimeout, CancellationToken.None, new MqttConnAckPacket
                 {
                     ConnectReturnCode = connectReturnCode,
                     IsSessionPresent = clientSession.IsExistingSession
@@ -72,17 +75,20 @@ namespace MQTTnet.Core.Server
                     ProtocolVersion = clientAdapter.PacketSerializer.ProtocolVersion
                 }));
 
-                await clientSession.Session.RunAsync(connectPacket.WillMessage, clientAdapter).ConfigureAwait(false);
+                using (_logger.BeginScope(clientId))
+                {
+                    await clientSession.Session.RunAsync(connectPacket.WillMessage, clientAdapter).ConfigureAwait(false);
+                }
             }
             catch (Exception exception)
             {
-                _trace.Error(nameof(MqttServer), exception, exception.Message);
+                _logger.LogError(new EventId(), exception, exception.Message);
             }
             finally
             {
                 try
                 {
-                    await clientAdapter.DisconnectAsync(_options.DefaultCommunicationTimeout).ConfigureAwait(false);
+                    await clientAdapter.DisconnectAsync(Options.DefaultCommunicationTimeout).ConfigureAwait(false);
                 }
                 catch (Exception)
                 {
@@ -126,7 +132,7 @@ namespace MQTTnet.Core.Server
             }
             catch (Exception exception)
             {
-                _trace.Error(nameof(MqttClientSessionsManager), exception, "Error while processing application message");
+                _logger.LogError(new EventId(), exception, "Error while processing application message");
             }
 
             lock (_clientSessions)
@@ -140,9 +146,9 @@ namespace MQTTnet.Core.Server
 
         private MqttConnectReturnCode ValidateConnection(MqttConnectPacket connectPacket)
         {
-            if (_options.ConnectionValidator != null)
+            if (Options.ConnectionValidator != null)
             {
-                return _options.ConnectionValidator(connectPacket);
+                return Options.ConnectionValidator(connectPacket);
             }
 
             return MqttConnectReturnCode.ConnectionAccepted;
@@ -160,11 +166,11 @@ namespace MQTTnet.Core.Server
                         _clientSessions.Remove(connectPacket.ClientId);
                         clientSession.Dispose();
                         clientSession = null;
-                        _trace.Verbose(nameof(MqttClientSessionsManager), "Disposed existing session of client '{0}'.", connectPacket.ClientId);
+                        _logger.LogTrace("Disposed existing session of client '{0}'.", connectPacket.ClientId);
                     }
                     else
                     {
-                        _trace.Verbose(nameof(MqttClientSessionsManager), "Reusing existing session of client '{0}'.", connectPacket.ClientId);
+                        _logger.LogTrace("Reusing existing session of client '{0}'.", connectPacket.ClientId);
                     }
                 }
 
@@ -173,10 +179,10 @@ namespace MQTTnet.Core.Server
                 {
                     isExistingSession = false;
 
-                    clientSession = new MqttClientSession(connectPacket.ClientId, _options, this, _trace);
+                    clientSession = _mqttClientSesssionFactory.CreateClientSession(connectPacket.ClientId, this);
                     _clientSessions[connectPacket.ClientId] = clientSession;
 
-                    _trace.Verbose(nameof(MqttClientSessionsManager), "Created a new session for client '{0}'.", connectPacket.ClientId);
+                    _logger.LogTrace("Created a new session for client '{0}'.", connectPacket.ClientId);
                 }
 
                 return new GetOrCreateClientSessionResult { IsExistingSession = isExistingSession, Session = clientSession };

MQTTnet.Core/Server/MqttServer.cs

@@ -3,26 +3,33 @@ using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Adapter;
-using MQTTnet.Core.Diagnostics;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using System.Linq;
 
 namespace MQTTnet.Core.Server
 {
     public sealed class MqttServer : IMqttServer
     {
-        private readonly MqttNetTrace _trace;
+        private readonly ILogger<MqttServer> _logger;
         private readonly MqttClientSessionsManager _clientSessionsManager;
         private readonly ICollection<IMqttServerAdapter> _adapters;
         private readonly MqttServerOptions _options;
 
         private CancellationTokenSource _cancellationTokenSource;
 
-        public MqttServer(MqttServerOptions options, ICollection<IMqttServerAdapter> adapters, MqttNetTrace trace)
+        public MqttServer(IOptions<MqttServerOptions> options, IEnumerable<IMqttServerAdapter> adapters, ILogger<MqttServer> logger, MqttClientSessionsManager clientSessionsManager)
         {
-            _trace = trace ?? throw new ArgumentNullException(nameof(trace));
-            _options = options ?? throw new ArgumentNullException(nameof(options));
-            _adapters = adapters ?? throw new ArgumentNullException(nameof(adapters));
+            _options = options.Value ?? throw new ArgumentNullException(nameof(options));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _clientSessionsManager = clientSessionsManager ?? throw new ArgumentNullException(nameof(clientSessionsManager));
+
+            if (adapters == null)
+            {
+                throw new ArgumentNullException(nameof(adapters));
+            }            
+            _adapters = adapters.ToList();
 
-            _clientSessionsManager = new MqttClientSessionsManager(options, trace);
             _clientSessionsManager.ApplicationMessageReceived += (s, e) => ApplicationMessageReceived?.Invoke(s, e);
             _clientSessionsManager.ClientConnected += OnClientConnected;
             _clientSessionsManager.ClientDisconnected += OnClientDisconnected;
@@ -59,7 +66,7 @@ namespace MQTTnet.Core.Server
                 await adapter.StartAsync(_options);
             }
 
-            _trace.Information(nameof(MqttServer), "Started.");
+            _logger.LogInformation("Started.");
         }
 
         public async Task StopAsync()
@@ -76,7 +83,7 @@ namespace MQTTnet.Core.Server
 
             _clientSessionsManager.Clear();
 
-            _trace.Information(nameof(MqttServer), "Stopped.");
+            _logger.LogInformation("Stopped.");
         }
 
         private void OnClientAccepted(object sender, MqttServerAdapterClientAcceptedEventArgs eventArgs)
@@ -86,13 +93,13 @@ namespace MQTTnet.Core.Server
 
         private void OnClientConnected(object sender, MqttClientConnectedEventArgs eventArgs)
         {
-            _trace.Information(nameof(MqttServer), "Client '{0}': Connected.", eventArgs.Client.ClientId);
+            _logger.LogInformation("Client '{0}': Connected.", eventArgs.Client.ClientId);
             ClientConnected?.Invoke(this, eventArgs);
         }
 
         private void OnClientDisconnected(object sender, MqttClientDisconnectedEventArgs eventArgs)
         {
-            _trace.Information(nameof(MqttServer), "Client '{0}': Disconnected.", eventArgs.Client.ClientId);
+            _logger.LogInformation("Client '{0}': Disconnected.", eventArgs.Client.ClientId);
             ClientDisconnected?.Invoke(this, eventArgs);
         }
     }