Feature/improve performance (#123)

* Set LogLevel to FailureOnly by default

* Refactor the WebsocketClient background tasks to use Threading Timer and SemaphoreSlim instead of the infinite async/await in order to have less overhead + reduce the interval of each to 100ms + offset both tasks to not run simultaneously in order to spread the overhead across more frames

* Remove Unity dependency from the WebsocketClient.cs

* move period and offset config to consts + increase update interval from 10x per second to 20x per second

Author: sierpinskid

Assets/Plugins/StreamChat/Core/Configs/IStreamClientConfig.cs

@@ -8,7 +8,11 @@ namespace StreamChat.Core.Configs
     public interface IStreamClientConfig
     {
         /// <summary>
-        /// What type of logs are being emitted.
+        /// What type of logs are being emitted. Available options:
+        /// FailureOnly - only errors will be logged. This option is recommended for production
+        /// All - all errors will be logged. This can be useful during development
+        /// Debug - This included All logs + some additional that can be useful for debugging
+        /// Disabled - no logs will be emitted. Not recommended in general - this could be only viable if you're capturing all of the thrown exceptions and handling the logging on your own.
         /// </summary>
         StreamLogLevel LogLevel { get; set; }
     }

Assets/Plugins/StreamChat/Core/Configs/StreamClientConfig.cs

@@ -7,6 +7,6 @@ public class StreamClientConfig : IStreamClientConfig
     {
         public static IStreamClientConfig Default { get; set; } = new StreamClientConfig();
 
-        public StreamLogLevel LogLevel { get; set; } = StreamLogLevel.All;
+        public StreamLogLevel LogLevel { get; set; } = StreamLogLevel.FailureOnly;
     }
 }

Assets/Plugins/StreamChat/Libs/Websockets/WebsocketClient.cs

@@ -31,9 +31,6 @@ public WebsocketClient(ILogs logs, Encoding encoding = default, bool isDebugMode
             _logs = logs ?? throw new ArgumentNullException(nameof(logs));
             _encoding = encoding ?? DefaultEncoding;
             _isDebugMode = isDebugMode;
-
-            var readBuffer = new byte[4 * 1024];
-            _bufferSegment = new ArraySegment<byte>(readBuffer);
         }
 
         public bool TryDequeueMessage(out string message) => _receiveQueue.TryDequeue(out message);
@@ -80,12 +77,8 @@ await TryDisposeResourcesAsync(WebSocketCloseStatus.NormalClosure,
                 return;
             }
 
-#pragma warning disable 4014
-            Task.Factory.StartNew(SendMessagesLoopAsync, _connectionCts.Token, TaskCreationOptions.LongRunning,
-                TaskScheduler.Default);
-            Task.Factory.StartNew(ReceiveMessagesLoopAsync, _connectionCts.Token, TaskCreationOptions.LongRunning,
-                TaskScheduler.Default);
-#pragma warning restore 4014
+            _backgroundSendTimer = new Timer(SendMessagesCallback, null, 0, UpdatePeriod);
+            _backgroundReceiveTimer = new Timer(ReceiveMessagesCallback, null, UpdatePeriodOffset, UpdatePeriod);
 
             Connected?.Invoke();
         }
@@ -135,6 +128,10 @@ public void Dispose()
             DisconnectAsync(WebSocketCloseStatus.NormalClosure, "WebSocket client is disposed")
                 .ContinueWith(_ => LogExceptionIfDebugMode(_.Exception), TaskContinuationOptions.OnlyOnFaulted);
         }
+        
+        private const int UpdatesPerSecond = 20;
+        private const int UpdatePeriod = 1000 / UpdatesPerSecond;
+        private const int UpdatePeriodOffset = UpdatePeriod / 2;
 
         private static Encoding DefaultEncoding { get; } = Encoding.UTF8;
 
@@ -150,20 +147,35 @@ public void Dispose()
         private readonly BlockingCollection<ArraySegment<byte>> _sendQueue =
             new BlockingCollection<ArraySegment<byte>>();
 
-        private readonly ArraySegment<byte> _bufferSegment;
+        private readonly ArraySegment<byte> _bufferSegment = new ArraySegment<byte>(new byte[4 * 1024]);
 
         private readonly ILogs _logs;
         private readonly Encoding _encoding;
         private readonly bool _isDebugMode;
 
+        private readonly SemaphoreSlim _backgroundSendSemaphore = new SemaphoreSlim(1);
+        private readonly SemaphoreSlim _backgroundReceiveSemaphore = new SemaphoreSlim(1);
+
+        private Timer _backgroundSendTimer;
+        private Timer _backgroundReceiveTimer;
+
         private Uri _uri;
         private ClientWebSocket _internalClient;
         private CancellationTokenSource _connectionCts;
 
-        // Runs on a background thread
-        private async Task SendMessagesLoopAsync()
+        private async void SendMessagesCallback(object state)
         {
-            while (IsConnected && _connectionCts != null &&  !_connectionCts.IsCancellationRequested)
+            if (!IsConnected || _connectionCts == null || _connectionCts.IsCancellationRequested)
+            {
+                return;
+            }
+
+            if (!_backgroundSendSemaphore.Wait(0))
+            {
+                return;
+            }
+
+            try
             {
                 while (_sendQueue.TryTake(out var msg))
                 {
@@ -185,45 +197,67 @@ private async Task SendMessagesLoopAsync()
                         _threadExceptionsLog.Enqueue(e);
                     }
                 }
-
-                await Task.Delay(1);
+            }
+            finally
+            {
+                _backgroundSendSemaphore.Release();
             }
         }
 
         // Runs on a background thread
-        private async Task ReceiveMessagesLoopAsync()
+        private async void ReceiveMessagesCallback(object state)
         {
-            while (IsConnected && _connectionCts != null && !_connectionCts.IsCancellationRequested)
+            if (!IsConnected || _connectionCts == null || _connectionCts.IsCancellationRequested)
             {
-                try
-                {
-                    var result = await TryReceiveSingleMessageAsync();
-                    if (!string.IsNullOrEmpty(result))
-                    {
-                        _receiveQueue.Enqueue(result);
-                        continue;
-                    }
-                }
-                catch (OperationCanceledException)
-                {
-                    return;
-                }
-                catch (WebSocketException webSocketException)
-                {
-                    _threadWebsocketExceptionsLog.Enqueue(webSocketException);
-                    return;
-                }
-                catch (Exception e)
+                return;
+            }
+
+            if (!_backgroundReceiveSemaphore.Wait(0))
+            {
+                return;
+            }
+
+            try
+            {
+                var result = await TryReceiveSingleMessageAsync();
+                if (!string.IsNullOrEmpty(result))
                 {
-                    _threadExceptionsLog.Enqueue(e);
+                    _receiveQueue.Enqueue(result);
                 }
-
-                await Task.Delay(1);
+            }
+            catch (OperationCanceledException)
+            {
+                return;
+            }
+            catch (WebSocketException webSocketException)
+            {
+                _threadWebsocketExceptionsLog.Enqueue(webSocketException);
+                return;
+            }
+            catch (Exception e)
+            {
+                _threadExceptionsLog.Enqueue(e);
+            }
+            finally
+            {
+                _backgroundReceiveSemaphore.Release();
             }
         }
 
         private async Task TryDisposeResourcesAsync(WebSocketCloseStatus closeStatus, string closeMessage)
         {
+            try
+            {
+                _backgroundReceiveTimer?.Dispose();
+                _backgroundReceiveTimer = null;
+                _backgroundSendTimer?.Dispose();
+                _backgroundSendTimer = null;
+            }
+            catch (Exception e)
+            {
+                LogExceptionIfDebugMode(e);
+            }
+
             try
             {
                 if (_connectionCts != null)