Remove dependency to Serilog and use logging abstraction LibLog.

Marfusios · Marfusios · commit 52179ebb9be1 · 2019-02-04T18:47:58.000+01:00
Websocket - add Name property for better logging.
Release version 2.0
diff --git a/.travis.yml b/.travis.yml
@@ -12,6 +12,6 @@ deploy:
   provider: script
   skip_cleanup: true
   script:
-    - cd src/Websocket.Client && dotnet pack /p:PackageVersion=1.0.$TRAVIS_BUILD_NUMBER -c Release && cd bin/Release && dotnet nuget push **/*.1.0.$TRAVIS_BUILD_NUMBER.nupkg -k $NUGET_API_KEY -s https://api.nuget.org/v3/index.json
+    - cd src/Websocket.Client && dotnet pack /p:PackageVersion=2.0.$TRAVIS_BUILD_NUMBER -c Release && cd bin/Release && dotnet nuget push **/*.2.0.$TRAVIS_BUILD_NUMBER.nupkg -k $NUGET_API_KEY -s https://api.nuget.org/v3/index.json
   on:
     branch: master
diff --git a/README.md b/README.md
@@ -11,7 +11,7 @@ This is a wrapper over native C# class `ClientWebSocket` with built-in reconnect
 * installation via NuGet ([Websocket.Client](https://www.nuget.org/packages/Websocket.Client))
 * targeting .NET Standard 2.0 (.NET Core, Linux/MacOS compatible)
 * reactive extensions ([Rx.NET](https://github.com/Reactive-Extensions/Rx.NET))
-* integrated logging ([Serilog](https://serilog.net/))
+* integrated logging abstraction ([LibLog](https://github.com/damianh/LibLog))
 
 ### Usage
 
diff --git a/Websocket.Client.sln.DotSettings b/Websocket.Client.sln.DotSettings
@@ -0,0 +1,2 @@
+﻿<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Bitmex/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
diff --git a/src/Websocket.Client/IWebsocketClient.cs b/src/Websocket.Client/IWebsocketClient.cs
@@ -35,6 +35,12 @@ public interface IWebsocketClient : IDisposable
         /// </summary>
         int ErrorReconnectTimeoutMs { get; set; }
 
+        /// <summary>
+        /// Get or set the name of the current websocket client instance.
+        /// For logging purpose (in case you use more parallel websocket clients and want to distinguish between them)
+        /// </summary>
+        string Name { get; set;}
+
         /// <summary>
         /// Returns true if Start() method was called at least once. False if not started or disposed
         /// </summary>
diff --git a/src/Websocket.Client/Websocket.Client.csproj b/src/Websocket.Client/Websocket.Client.csproj
@@ -3,11 +3,11 @@
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
     <PackageId>Websocket.Client</PackageId>
-    <Version>1.0.0</Version>
+    <Version>2.0.0</Version>
     <Authors>Mariusz Kotas</Authors>
     <Description>Client for websocket API with built-in reconnection and error handling</Description>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
-    <PackageReleaseNotes>Initial release</PackageReleaseNotes>
+    <PackageReleaseNotes>Release of version 2.0</PackageReleaseNotes>
     <Copyright>Copyright 2018 Mariusz Kotas. All rights reserved.</Copyright>
     <PackageTags>websockets websocket client</PackageTags>
     <PackageLicenseUrl>https://github.com/Marfusios/Websocket.Client/blob/master/LICENSE</PackageLicenseUrl>
@@ -17,12 +17,15 @@
     <RepositoryType>Git</RepositoryType>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <GenerateDocumentationFile>true</GenerateDocumentationFile> 
-    <AssemblyVersion>1.0.0.0</AssemblyVersion>
-    <FileVersion>1.0.0.0</FileVersion>
+    <AssemblyVersion>2.0.0.0</AssemblyVersion>
+    <FileVersion>2.0.0.0</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Serilog" Version="2.7.1" />
+    <PackageReference Include="LibLog" Version="5.0.5">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="System.Reactive" Version="4.0.0" />
   </ItemGroup>
 
diff --git a/src/Websocket.Client/WebsocketClient.cs b/src/Websocket.Client/WebsocketClient.cs
@@ -6,7 +6,7 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using Serilog;
+using Websocket.Client.Logging;
 
 namespace Websocket.Client
 {
@@ -15,6 +15,8 @@ namespace Websocket.Client
     /// </summary>
     public class WebsocketClient : IWebsocketClient
     {
+        private static readonly ILog Logger = LogProvider.GetCurrentClassLogger();
+
         private readonly Uri _url;
         private Timer _lastChanceTimer;
         private readonly Func<ClientWebSocket> _clientFactory;
@@ -23,8 +25,8 @@ public class WebsocketClient : IWebsocketClient
 
         private bool _disposing = false;
         private ClientWebSocket _client;
-        private CancellationTokenSource _cancelation;
-        private CancellationTokenSource _cancelationTotal;
+        private CancellationTokenSource _cancellation;
+        private CancellationTokenSource _cancellationTotal;
 
         private readonly Subject<string> _messageReceivedSubject = new Subject<string>();
         private readonly Subject<ReconnectionType> _reconnectionSubject = new Subject<ReconnectionType>();
@@ -50,12 +52,12 @@ public WebsocketClient(Uri url, Func<ClientWebSocket> clientFactory = null)
         public IObservable<string> MessageReceived => _messageReceivedSubject.AsObservable();
 
         /// <summary>
-        /// Stream for reconnection event (trigerred after the new connection) 
+        /// Stream for reconnection event (triggered after the new connection) 
         /// </summary>
         public IObservable<ReconnectionType> ReconnectionHappened => _reconnectionSubject.AsObservable();
 
         /// <summary>
-        /// Stream for disconnection event (trigerred after the connection was lost) 
+        /// Stream for disconnection event (triggered after the connection was lost) 
         /// </summary>
         public IObservable<DisconnectionType> DisconnectionHappened => _disconnectedSubject.AsObservable();
 
@@ -71,6 +73,12 @@ public WebsocketClient(Uri url, Func<ClientWebSocket> clientFactory = null)
         /// </summary>
         public int ErrorReconnectTimeoutMs { get; set; } = 60 * 1000;
 
+        /// <summary>
+        /// Get or set the name of the current websocket client instance.
+        /// For logging purpose (in case you use more parallel websocket clients and want to distinguish between them)
+        /// </summary>
+        public string Name { get; set;}
+
         /// <summary>
         /// Returns true if Start() method was called at least once. False if not started or disposed
         /// </summary>
@@ -87,21 +95,21 @@ public WebsocketClient(Uri url, Func<ClientWebSocket> clientFactory = null)
         public void Dispose()
         {
             _disposing = true;
-            Log.Debug(L("Disposing.."));
+            Logger.Debug(L("Disposing.."));
             try
             {
                 _lastChanceTimer?.Dispose();
-                _cancelation?.Cancel();
-                _cancelationTotal?.Cancel();
+                _cancellation?.Cancel();
+                _cancellationTotal?.Cancel();
                 _client?.Abort();
                 _client?.Dispose();
-                _cancelation?.Dispose();
-                _cancelationTotal?.Dispose();
+                _cancellation?.Dispose();
+                _cancellationTotal?.Dispose();
                 _messagesToSendQueue?.Dispose();
             }
             catch (Exception e)
             {
-                Log.Error(e, L($"Failed to dispose client, error: {e.Message}"));
+                Logger.Error(e, L($"Failed to dispose client, error: {e.Message}"));
             }
 
             IsStarted = false;
@@ -115,16 +123,16 @@ public async Task Start()
         {
             if (IsStarted)
             {
-                Log.Debug(L("Client already started, ignoring.."));
+                Logger.Debug(L("Client already started, ignoring.."));
                 return;
             }
             IsStarted = true;
 
-            Log.Debug(L("Starting.."));
-            _cancelation = new CancellationTokenSource();
-            _cancelationTotal = new CancellationTokenSource();
+            Logger.Debug(L("Starting.."));
+            _cancellation = new CancellationTokenSource();
+            _cancellationTotal = new CancellationTokenSource();
 
-            await StartClient(_url, _cancelation.Token, ReconnectionType.Initial).ConfigureAwait(false);
+            await StartClient(_url, _cancellation.Token, ReconnectionType.Initial).ConfigureAwait(false);
 
             StartBackgroundThreadForSending();
         }
@@ -164,7 +172,7 @@ public async Task Reconnect()
         {
             if (!IsStarted)
             {
-                Log.Debug(L("Client not started, ignoring reconnection.."));
+                Logger.Debug(L("Client not started, ignoring reconnection.."));
                 return;
             }
             await Reconnect(ReconnectionType.ByUser).ConfigureAwait(false);
@@ -174,15 +182,15 @@ private async Task SendFromQueue()
         {
             try
             {
-                foreach (var message in _messagesToSendQueue.GetConsumingEnumerable(_cancelationTotal.Token))
+                foreach (var message in _messagesToSendQueue.GetConsumingEnumerable(_cancellationTotal.Token))
                 {
                     try
                     {
                         await SendInternal(message).ConfigureAwait(false);
                     }
                     catch (Exception e)
                     {
-                        Log.Error(L($"Failed to send message: '{message}'. Error: {e.Message}"));
+                        Logger.Error(L($"Failed to send message: '{message}'. Error: {e.Message}"));
                     }
                 }
             }
@@ -192,7 +200,7 @@ private async Task SendFromQueue()
             }
             catch (Exception e)
             {
-                if (_cancelationTotal.IsCancellationRequested || _disposing)
+                if (_cancellationTotal.IsCancellationRequested || _disposing)
                 {
                     // disposing/canceling, do nothing and exit
                     return;
@@ -206,22 +214,22 @@ private async Task SendFromQueue()
         private void StartBackgroundThreadForSending()
         {
 #pragma warning disable 4014
-            Task.Factory.StartNew(_ => SendFromQueue(), TaskCreationOptions.LongRunning, _cancelationTotal.Token);
+            Task.Factory.StartNew(_ => SendFromQueue(), TaskCreationOptions.LongRunning, _cancellationTotal.Token);
 #pragma warning restore 4014
         }
 
         private async Task SendInternal(string message)
         {
-            Log.Verbose(L($"Sending:  {message}"));
+            Logger.Trace(L($"Sending:  {message}"));
             var buffer = Encoding.UTF8.GetBytes(message);
             var messageSegment = new ArraySegment<byte>(buffer);
             var client = await GetClient().ConfigureAwait(false);
-            await client.SendAsync(messageSegment, WebSocketMessageType.Text, true, _cancelation.Token).ConfigureAwait(false);
+            await client.SendAsync(messageSegment, WebSocketMessageType.Text, true, _cancellation.Token).ConfigureAwait(false);
         }
 
         private async Task StartClient(Uri uri, CancellationToken token, ReconnectionType type)
         {
-            DeactiveLastChance();
+            DeactivateLastChance();
             _client = _clientFactory();
             
             try
@@ -237,7 +245,7 @@ private async Task StartClient(Uri uri, CancellationToken token, ReconnectionTyp
             catch (Exception e)
             {
                 _disconnectedSubject.OnNext(DisconnectionType.Error);
-                Log.Error(e, L("Exception while connecting. " +
+                Logger.Error(e, L("Exception while connecting. " +
                                $"Waiting {ErrorReconnectTimeoutMs/1000} sec before next reconnection try."));
                 await Task.Delay(ErrorReconnectTimeoutMs, token).ConfigureAwait(false);
                 await Reconnect(ReconnectionType.Error).ConfigureAwait(false);
@@ -261,12 +269,12 @@ private async Task Reconnect(ReconnectionType type)
             if(type != ReconnectionType.Error)
                 _disconnectedSubject.OnNext(TranslateTypeToDisconnection(type));
 
-            Log.Debug(L("Reconnecting..."));
-            _cancelation.Cancel();
+            Logger.Debug(L("Reconnecting..."));
+            _cancellation.Cancel();
             await Task.Delay(1000).ConfigureAwait(false);
 
-            _cancelation = new CancellationTokenSource();
-            await StartClient(_url, _cancelation.Token, type).ConfigureAwait(false);
+            _cancellation = new CancellationTokenSource();
+            await StartClient(_url, _cancellation.Token, type).ConfigureAwait(false);
         }
 
         private async Task Listen(ClientWebSocket client, CancellationToken token)
@@ -290,7 +298,7 @@ private async Task Listen(ClientWebSocket client, CancellationToken token)
                     } while (!result.EndOfMessage);
 
                     var received = resultMessage.ToString();
-                    Log.Verbose(L($"Received:  {received}"));
+                    Logger.Trace(L($"Received:  {received}"));
                     _lastReceivedMsg = DateTime.UtcNow;
                     _messageReceivedSubject.OnNext(received);
 
@@ -302,7 +310,7 @@ private async Task Listen(ClientWebSocket client, CancellationToken token)
             }
             catch (Exception e)
             {
-                Log.Error(e, L("Error while listening to websocket stream"));
+                Logger.Error(e, L("Error while listening to websocket stream"));
             }
         }
 
@@ -312,7 +320,7 @@ private void ActivateLastChance()
             _lastChanceTimer = new Timer(LastChance, null, timerMs, timerMs);
         }
 
-        private void DeactiveLastChance()
+        private void DeactivateLastChance()
         {
             _lastChanceTimer?.Dispose();
             _lastChanceTimer = null;
@@ -324,9 +332,9 @@ private void LastChance(object state)
             var diffMs = Math.Abs(DateTime.UtcNow.Subtract(_lastReceivedMsg).TotalMilliseconds);
             if (diffMs > timeoutMs)
             {
-                Log.Debug(L($"Last message received more than {timeoutMs:F} ms ago. Hard restart.."));
+                Logger.Debug(L($"Last message received more than {timeoutMs:F} ms ago. Hard restart.."));
 
-                DeactiveLastChance();
+                DeactivateLastChance();
                 _client?.Abort();
                 _client?.Dispose();
 #pragma warning disable 4014
@@ -337,12 +345,13 @@ private void LastChance(object state)
 
         private string L(string msg)
         {
-            return $"[WEBSOCKET CLIENT] {msg}";
+            var name = Name ?? "CLIENT";
+            return $"[WEBSOCKET {name}] {msg}";
         }
 
         private DisconnectionType TranslateTypeToDisconnection(ReconnectionType type)
         {
-            // beaware enum indexes must correspond to each other
+            // beware enum indexes must correspond to each other
             return (DisconnectionType) type;
         }
     }
diff --git a/test_integration/Websocket.Client.Sample.NetFramework/Program.cs b/test_integration/Websocket.Client.Sample.NetFramework/Program.cs
@@ -1,7 +1,6 @@
 ﻿using System;
 using System.IO;
 using System.Reflection;
-using System.Runtime.Loader;
 using System.Threading;
 using System.Threading.Tasks;
 using Serilog;
@@ -18,7 +17,6 @@ static void Main(string[] args)
             InitLogging();
 
             AppDomain.CurrentDomain.ProcessExit += CurrentDomainOnProcessExit;
-            AssemblyLoadContext.Default.Unloading += DefaultOnUnloading;
             Console.CancelKeyPress += ConsoleOnCancelKeyPress;
 
             Console.WriteLine("|=======================|");
@@ -35,9 +33,14 @@ static void Main(string[] args)
             var url = new Uri("wss://www.bitmex.com/realtime");
             using (var client = new WebsocketClient(url))
             {
+                client.Name = "Bitmex";
                 client.ReconnectTimeoutMs = (int)TimeSpan.FromSeconds(30).TotalMilliseconds;
                 client.ReconnectionHappened.Subscribe(type =>
                     Log.Information($"Reconnection happened, type: {type}"));
+                client.DisconnectionHappened.Subscribe(type => 
+                    Log.Warning($"Disconnection happened, type: {type}"));
+
+                client.MessageReceived.Subscribe(msg => Log.Information($"Message received: {msg}"));
 
                 client.Start();
 
@@ -78,12 +81,6 @@ private static void CurrentDomainOnProcessExit(object sender, EventArgs eventArg
             ExitEvent.Set();
         }
 
-        private static void DefaultOnUnloading(AssemblyLoadContext assemblyLoadContext)
-        {
-            Log.Warning("Unloading process");
-            ExitEvent.Set();
-        }
-
         private static void ConsoleOnCancelKeyPress(object sender, ConsoleCancelEventArgs e)
         {
             Log.Warning("Canceling process");
diff --git a/test_integration/Websocket.Client.Sample.NetFramework/Websocket.Client.Sample.NetFramework.csproj b/test_integration/Websocket.Client.Sample.NetFramework/Websocket.Client.Sample.NetFramework.csproj
@@ -6,8 +6,8 @@
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <ProjectGuid>{56642A4E-B8CE-4399-9879-3E89C7C1FA3D}</ProjectGuid>
     <OutputType>Exe</OutputType>
-    <RootNamespace>Bitmex.Client.Websocket.Sample.NetFramework</RootNamespace>
-    <AssemblyName>Bitmex.Client.Websocket.Sample.NetFramework</AssemblyName>
+    <RootNamespace>Websocket.Client.Sample.NetFramework</RootNamespace>
+    <AssemblyName>Websocket.Client.Sample.NetFramework</AssemblyName>
     <TargetFrameworkVersion>v4.7.1</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
@@ -36,7 +36,7 @@
       <HintPath>..\..\packages\Newtonsoft.Json.11.0.2\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="Serilog, Version=2.0.0.0, Culture=neutral, PublicKeyToken=24c2f752a8e58a10, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\Serilog.2.5.0\lib\net46\Serilog.dll</HintPath>
+      <HintPath>..\..\packages\Serilog.2.8.0\lib\net46\Serilog.dll</HintPath>
     </Reference>
     <Reference Include="Serilog.Sinks.ColoredConsole, Version=3.0.1.0, Culture=neutral, PublicKeyToken=24c2f752a8e58a10, processorArchitecture=MSIL">
       <HintPath>..\..\packages\Serilog.Sinks.ColoredConsole.3.0.1\lib\net45\Serilog.Sinks.ColoredConsole.dll</HintPath>
diff --git a/test_integration/Websocket.Client.Sample.NetFramework/packages.config b/test_integration/Websocket.Client.Sample.NetFramework/packages.config
@@ -1,7 +1,7 @@
 ﻿<?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="Newtonsoft.Json" version="11.0.2" targetFramework="net471" />
-  <package id="Serilog" version="2.5.0" targetFramework="net471" />
+  <package id="Serilog" version="2.8.0" targetFramework="net471" />
   <package id="Serilog.Sinks.ColoredConsole" version="3.0.1" targetFramework="net471" />
   <package id="Serilog.Sinks.Console" version="3.1.1" targetFramework="net471" />
   <package id="Serilog.Sinks.File" version="4.0.0" targetFramework="net471" />
diff --git a/test_integration/Websocket.Client.Sample/Program.cs b/test_integration/Websocket.Client.Sample/Program.cs

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">`
	`2`	`+ <s:Boolean x:Key="/Default/UserDictionary/Words/=Bitmex/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`	`using System.Text;`
`7`	`7`	`using System.Threading;`
`8`	`8`	`using System.Threading.Tasks;`
`9`		`-using Serilog;`
	`9`	`+using Websocket.Client.Logging;`
`10`	`10`
`11`	`11`	`namespace Websocket.Client`
`12`	`12`	`{`
`@@ -15,6 +15,8 @@ namespace Websocket.Client`
`15`	`15`	`/// </summary>`
`16`	`16`	`public class WebsocketClient : IWebsocketClient`
`17`	`17`	`{`
	`18`	`+ private static readonly ILog Logger = LogProvider.GetCurrentClassLogger();`
	`19`	`+`
`18`	`20`	`private readonly Uri _url;`
`19`	`21`	`private Timer _lastChanceTimer;`
`20`	`22`	`private readonly Func<ClientWebSocket> _clientFactory;`
`@@ -23,8 +25,8 @@ public class WebsocketClient : IWebsocketClient`
`23`	`25`
`24`	`26`	`private bool _disposing = false;`
`25`	`27`	`private ClientWebSocket _client;`
`26`		`- private CancellationTokenSource _cancelation;`
`27`		`- private CancellationTokenSource _cancelationTotal;`
	`28`	`+ private CancellationTokenSource _cancellation;`
	`29`	`+ private CancellationTokenSource _cancellationTotal;`
`28`	`30`
`29`	`31`	`private readonly Subject<string> _messageReceivedSubject = new Subject<string>();`
`30`	`32`	`private readonly Subject<ReconnectionType> _reconnectionSubject = new Subject<ReconnectionType>();`
`@@ -50,12 +52,12 @@ public WebsocketClient(Uri url, Func<ClientWebSocket> clientFactory = null)`
`50`	`52`	`public IObservable<string> MessageReceived => _messageReceivedSubject.AsObservable();`
`51`	`53`
`52`	`54`	`/// <summary>`
`53`		`- /// Stream for reconnection event (trigerred after the new connection)`
	`55`	`+ /// Stream for reconnection event (triggered after the new connection)`
`54`	`56`	`/// </summary>`
`55`	`57`	`public IObservable<ReconnectionType> ReconnectionHappened => _reconnectionSubject.AsObservable();`
`56`	`58`
`57`	`59`	`/// <summary>`
`58`		`- /// Stream for disconnection event (trigerred after the connection was lost)`
	`60`	`+ /// Stream for disconnection event (triggered after the connection was lost)`
`59`	`61`	`/// </summary>`
`60`	`62`	`public IObservable<DisconnectionType> DisconnectionHappened => _disconnectedSubject.AsObservable();`
`61`	`63`
`@@ -71,6 +73,12 @@ public WebsocketClient(Uri url, Func<ClientWebSocket> clientFactory = null)`
`71`	`73`	`/// </summary>`
`72`	`74`	`public int ErrorReconnectTimeoutMs { get; set; } = 60 * 1000;`
`73`	`75`
	`76`	`+ /// <summary>`
	`77`	`+ /// Get or set the name of the current websocket client instance.`
	`78`	`+ /// For logging purpose (in case you use more parallel websocket clients and want to distinguish between them)`
	`79`	`+ /// </summary>`
	`80`	`+ public string Name { get; set;}`
	`81`	`+`
`74`	`82`	`/// <summary>`
`75`	`83`	`/// Returns true if Start() method was called at least once. False if not started or disposed`
`76`	`84`	`/// </summary>`
`@@ -87,21 +95,21 @@ public WebsocketClient(Uri url, Func<ClientWebSocket> clientFactory = null)`
`87`	`95`	`public void Dispose()`
`88`	`96`	`{`
`89`	`97`	`_disposing = true;`
`90`		`- Log.Debug(L("Disposing.."));`
	`98`	`+ Logger.Debug(L("Disposing.."));`
`91`	`99`	`try`
`92`	`100`	`{`
`93`	`101`	`_lastChanceTimer?.Dispose();`
`94`		`- _cancelation?.Cancel();`
`95`		`- _cancelationTotal?.Cancel();`
	`102`	`+ _cancellation?.Cancel();`
	`103`	`+ _cancellationTotal?.Cancel();`
`96`	`104`	`_client?.Abort();`
`97`	`105`	`_client?.Dispose();`
`98`		`- _cancelation?.Dispose();`
`99`		`- _cancelationTotal?.Dispose();`
	`106`	`+ _cancellation?.Dispose();`
	`107`	`+ _cancellationTotal?.Dispose();`
`100`	`108`	`_messagesToSendQueue?.Dispose();`
`101`	`109`	`}`
`102`	`110`	`catch (Exception e)`
`103`	`111`	`{`
`104`		`- Log.Error(e, L($"Failed to dispose client, error: {e.Message}"));`
	`112`	`+ Logger.Error(e, L($"Failed to dispose client, error: {e.Message}"));`
`105`	`113`	`}`
`106`	`114`
`107`	`115`	`IsStarted = false;`
`@@ -115,16 +123,16 @@ public async Task Start()`
`115`	`123`	`{`
`116`	`124`	`if (IsStarted)`
`117`	`125`	`{`
`118`		`- Log.Debug(L("Client already started, ignoring.."));`
	`126`	`+ Logger.Debug(L("Client already started, ignoring.."));`
`119`	`127`	`return;`
`120`	`128`	`}`
`121`	`129`	`IsStarted = true;`
`122`	`130`
`123`		`- Log.Debug(L("Starting.."));`
`124`		`- _cancelation = new CancellationTokenSource();`
`125`		`- _cancelationTotal = new CancellationTokenSource();`
	`131`	`+ Logger.Debug(L("Starting.."));`
	`132`	`+ _cancellation = new CancellationTokenSource();`
	`133`	`+ _cancellationTotal = new CancellationTokenSource();`
`126`	`134`
`127`		`- await StartClient(_url, _cancelation.Token, ReconnectionType.Initial).ConfigureAwait(false);`
	`135`	`+ await StartClient(_url, _cancellation.Token, ReconnectionType.Initial).ConfigureAwait(false);`
`128`	`136`
`129`	`137`	`StartBackgroundThreadForSending();`
`130`	`138`	`}`
`@@ -164,7 +172,7 @@ public async Task Reconnect()`
`164`	`172`	`{`
`165`	`173`	`if (!IsStarted)`
`166`	`174`	`{`
`167`		`- Log.Debug(L("Client not started, ignoring reconnection.."));`
	`175`	`+ Logger.Debug(L("Client not started, ignoring reconnection.."));`
`168`	`176`	`return;`
`169`	`177`	`}`
`170`	`178`	`await Reconnect(ReconnectionType.ByUser).ConfigureAwait(false);`
`@@ -174,15 +182,15 @@ private async Task SendFromQueue()`
`174`	`182`	`{`
`175`	`183`	`try`
`176`	`184`	`{`
`177`		`- foreach (var message in _messagesToSendQueue.GetConsumingEnumerable(_cancelationTotal.Token))`
	`185`	`+ foreach (var message in _messagesToSendQueue.GetConsumingEnumerable(_cancellationTotal.Token))`
`178`	`186`	`{`
`179`	`187`	`try`
`180`	`188`	`{`
`181`	`189`	`await SendInternal(message).ConfigureAwait(false);`
`182`	`190`	`}`
`183`	`191`	`catch (Exception e)`
`184`	`192`	`{`
`185`		`- Log.Error(L($"Failed to send message: '{message}'. Error: {e.Message}"));`
	`193`	`+ Logger.Error(L($"Failed to send message: '{message}'. Error: {e.Message}"));`
`186`	`194`	`}`
`187`	`195`	`}`
`188`	`196`	`}`
`@@ -192,7 +200,7 @@ private async Task SendFromQueue()`
`192`	`200`	`}`
`193`	`201`	`catch (Exception e)`
`194`	`202`	`{`
`195`		`- if (_cancelationTotal.IsCancellationRequested \|\| _disposing)`
	`203`	`+ if (_cancellationTotal.IsCancellationRequested \|\| _disposing)`
`196`	`204`	`{`
`197`	`205`	`// disposing/canceling, do nothing and exit`
`198`	`206`	`return;`
`@@ -206,22 +214,22 @@ private async Task SendFromQueue()`
`206`	`214`	`private void StartBackgroundThreadForSending()`
`207`	`215`	`{`
`208`	`216`	`#pragma warning disable 4014`
`209`		`- Task.Factory.StartNew(_ => SendFromQueue(), TaskCreationOptions.LongRunning, _cancelationTotal.Token);`
	`217`	`+ Task.Factory.StartNew(_ => SendFromQueue(), TaskCreationOptions.LongRunning, _cancellationTotal.Token);`
`210`	`218`	`#pragma warning restore 4014`
`211`	`219`	`}`
`212`	`220`
`213`	`221`	`private async Task SendInternal(string message)`
`214`	`222`	`{`
`215`		`- Log.Verbose(L($"Sending: {message}"));`
	`223`	`+ Logger.Trace(L($"Sending: {message}"));`
`216`	`224`	`var buffer = Encoding.UTF8.GetBytes(message);`
`217`	`225`	`var messageSegment = new ArraySegment<byte>(buffer);`
`218`	`226`	`var client = await GetClient().ConfigureAwait(false);`
`219`		`- await client.SendAsync(messageSegment, WebSocketMessageType.Text, true, _cancelation.Token).ConfigureAwait(false);`
	`227`	`+ await client.SendAsync(messageSegment, WebSocketMessageType.Text, true, _cancellation.Token).ConfigureAwait(false);`
`220`	`228`	`}`
`221`	`229`
`222`	`230`	`private async Task StartClient(Uri uri, CancellationToken token, ReconnectionType type)`
`223`	`231`	`{`
`224`		`- DeactiveLastChance();`
	`232`	`+ DeactivateLastChance();`
`225`	`233`	`_client = _clientFactory();`
`226`	`234`
`227`	`235`	`try`
`@@ -237,7 +245,7 @@ private async Task StartClient(Uri uri, CancellationToken token, ReconnectionTyp`
`237`	`245`	`catch (Exception e)`
`238`	`246`	`{`
`239`	`247`	`_disconnectedSubject.OnNext(DisconnectionType.Error);`
`240`		`- Log.Error(e, L("Exception while connecting. " +`
	`248`	`+ Logger.Error(e, L("Exception while connecting. " +`
`241`	`249`	`$"Waiting {ErrorReconnectTimeoutMs/1000} sec before next reconnection try."));`
`242`	`250`	`await Task.Delay(ErrorReconnectTimeoutMs, token).ConfigureAwait(false);`
`243`	`251`	`await Reconnect(ReconnectionType.Error).ConfigureAwait(false);`
`@@ -261,12 +269,12 @@ private async Task Reconnect(ReconnectionType type)`
`261`	`269`	`if(type != ReconnectionType.Error)`
`262`	`270`	`_disconnectedSubject.OnNext(TranslateTypeToDisconnection(type));`
`263`	`271`
`264`		`- Log.Debug(L("Reconnecting..."));`
`265`		`- _cancelation.Cancel();`
	`272`	`+ Logger.Debug(L("Reconnecting..."));`
	`273`	`+ _cancellation.Cancel();`
`266`	`274`	`await Task.Delay(1000).ConfigureAwait(false);`
`267`	`275`
`268`		`- _cancelation = new CancellationTokenSource();`
`269`		`- await StartClient(_url, _cancelation.Token, type).ConfigureAwait(false);`
	`276`	`+ _cancellation = new CancellationTokenSource();`
	`277`	`+ await StartClient(_url, _cancellation.Token, type).ConfigureAwait(false);`
`270`	`278`	`}`
`271`	`279`
`272`	`280`	`private async Task Listen(ClientWebSocket client, CancellationToken token)`
`@@ -290,7 +298,7 @@ private async Task Listen(ClientWebSocket client, CancellationToken token)`
`290`	`298`	`} while (!result.EndOfMessage);`
`291`	`299`
`292`	`300`	`var received = resultMessage.ToString();`
`293`		`- Log.Verbose(L($"Received: {received}"));`
	`301`	`+ Logger.Trace(L($"Received: {received}"));`
`294`	`302`	`_lastReceivedMsg = DateTime.UtcNow;`
`295`	`303`	`_messageReceivedSubject.OnNext(received);`
`296`	`304`
`@@ -302,7 +310,7 @@ private async Task Listen(ClientWebSocket client, CancellationToken token)`
`302`	`310`	`}`
`303`	`311`	`catch (Exception e)`
`304`	`312`	`{`
`305`		`- Log.Error(e, L("Error while listening to websocket stream"));`
	`313`	`+ Logger.Error(e, L("Error while listening to websocket stream"));`
`306`	`314`	`}`
`307`	`315`	`}`
`308`	`316`
`@@ -312,7 +320,7 @@ private void ActivateLastChance()`
`312`	`320`	`_lastChanceTimer = new Timer(LastChance, null, timerMs, timerMs);`
`313`	`321`	`}`
`314`	`322`
`315`		`- private void DeactiveLastChance()`
	`323`	`+ private void DeactivateLastChance()`
`316`	`324`	`{`
`317`	`325`	`_lastChanceTimer?.Dispose();`
`318`	`326`	`_lastChanceTimer = null;`
`@@ -324,9 +332,9 @@ private void LastChance(object state)`
`324`	`332`	`var diffMs = Math.Abs(DateTime.UtcNow.Subtract(_lastReceivedMsg).TotalMilliseconds);`
`325`	`333`	`if (diffMs > timeoutMs)`
`326`	`334`	`{`
`327`		`- Log.Debug(L($"Last message received more than {timeoutMs:F} ms ago. Hard restart.."));`
	`335`	`+ Logger.Debug(L($"Last message received more than {timeoutMs:F} ms ago. Hard restart.."));`
`328`	`336`
`329`		`- DeactiveLastChance();`
	`337`	`+ DeactivateLastChance();`
`330`	`338`	`_client?.Abort();`
`331`	`339`	`_client?.Dispose();`
`332`	`340`	`#pragma warning disable 4014`
`@@ -337,12 +345,13 @@ private void LastChance(object state)`
`337`	`345`
`338`	`346`	`private string L(string msg)`
`339`	`347`	`{`
`340`		`- return $"[WEBSOCKET CLIENT] {msg}";`
	`348`	`+ var name = Name ?? "CLIENT";`
	`349`	`+ return $"[WEBSOCKET {name}] {msg}";`
`341`	`350`	`}`
`342`	`351`
`343`	`352`	`private DisconnectionType TranslateTypeToDisconnection(ReconnectionType type)`
`344`	`353`	`{`
`345`		`- // beaware enum indexes must correspond to each other`
	`354`	`+ // beware enum indexes must correspond to each other`
`346`	`355`	`return (DisconnectionType) type;`
`347`	`356`	`}`
`348`	`357`	`}`