fix: use ConfigureAwait(false) on all awaits

gnjack · joelfoliveira · commit 1bc8d2c6e2d5 · 2024-05-08T11:29:13.000+01:00
diff --git a/src/KafkaFlow/Batching/BatchConsumeMiddleware.cs b/src/KafkaFlow/Batching/BatchConsumeMiddleware.cs
@@ -38,7 +38,7 @@ public BatchConsumeMiddleware(
 
     public async Task Invoke(IMessageContext context, MiddlewareDelegate next)
     {
-        await _dispatchSemaphore.WaitAsync();
+        await _dispatchSemaphore.WaitAsync().ConfigureAwait(false);
 
         try
         {
@@ -59,7 +59,7 @@ public async Task Invoke(IMessageContext context, MiddlewareDelegate next)
 
         if (_batch.Count >= _batchSize)
         {
-            await this.TriggerDispatchAndWaitAsync();
+            await this.TriggerDispatchAndWaitAsync().ConfigureAwait(false);
         }
     }
 
@@ -72,11 +72,11 @@ public void Dispose()
 
     private async Task TriggerDispatchAndWaitAsync()
     {
-        await _dispatchSemaphore.WaitAsync();
+        await _dispatchSemaphore.WaitAsync().ConfigureAwait(false);
         _dispatchTokenSource?.Cancel();
         _dispatchSemaphore.Release();
 
-        await (_dispatchTask ?? Task.CompletedTask);
+        await (_dispatchTask ?? Task.CompletedTask).ConfigureAwait(false);
     }
 
     private void ScheduleExecution(IMessageContext context, MiddlewareDelegate next)
@@ -92,7 +92,7 @@ private void ScheduleExecution(IMessageContext context, MiddlewareDelegate next)
 
     private async Task DispatchAsync(IMessageContext context, MiddlewareDelegate next)
     {
-        await _dispatchSemaphore.WaitAsync();
+        await _dispatchSemaphore.WaitAsync().ConfigureAwait(false);
 
         _dispatchTokenSource.Dispose();
         _dispatchTokenSource = null;
diff --git a/src/KafkaFlow/Clusters/ClusterManager.cs b/src/KafkaFlow/Clusters/ClusterManager.cs
@@ -85,7 +85,7 @@ public async Task<IEnumerable<TopicPartitionOffset>> GetConsumerGroupOffsetsAsyn
 
         foreach (var name in topicsName)
         {
-            topicsMetadata.Add((name, await this.GetTopicMetadataAsync(name)));
+            topicsMetadata.Add((name, await this.GetTopicMetadataAsync(name).ConfigureAwait(false)));
         }
 
         var topics =
@@ -98,7 +98,7 @@ public async Task<IEnumerable<TopicPartitionOffset>> GetConsumerGroupOffsetsAsyn
                 .ToList();
 
         var result = await _lazyAdminClient.Value.ListConsumerGroupOffsetsAsync(
-            new[] { new ConsumerGroupTopicPartitions(consumerGroup, topics) });
+            new[] { new ConsumerGroupTopicPartitions(consumerGroup, topics) }).ConfigureAwait(false);
 
         if (!result.Any())
         {
@@ -125,7 +125,7 @@ public async Task CreateIfNotExistsAsync(IEnumerable<TopicConfiguration> configu
                     })
                 .ToArray();
 
-            await _lazyAdminClient.Value.CreateTopicsAsync(topics);
+            await _lazyAdminClient.Value.CreateTopicsAsync(topics).ConfigureAwait(false);
         }
         catch (CreateTopicsException exception)
         {
diff --git a/src/KafkaFlow/Consumers/Consumer.cs b/src/KafkaFlow/Consumers/Consumer.cs
@@ -163,7 +163,7 @@ public async ValueTask<ConsumeResult<byte[], byte[]>> ConsumeAsync(CancellationT
             try
             {
                 this.EnsureConsumer();
-                await _flowManager.BlockHeartbeat(cancellationToken);
+                await _flowManager.BlockHeartbeat(cancellationToken).ConfigureAwait(false);
                 return _consumer.Consume(cancellationToken);
             }
             catch (OperationCanceledException)
@@ -176,7 +176,7 @@ public async ValueTask<ConsumeResult<byte[], byte[]>> ConsumeAsync(CancellationT
                     "Max Poll Interval Exceeded",
                     new { this.Configuration.ConsumerName });
 
-                await _maxPollIntervalExceeded.FireAsync();
+                await _maxPollIntervalExceeded.FireAsync().ConfigureAwait(false);
             }
             catch (KafkaException ex) when (ex.Error.IsFatal)
             {
@@ -187,7 +187,7 @@ public async ValueTask<ConsumeResult<byte[], byte[]>> ConsumeAsync(CancellationT
 
                 this.InvalidateConsumer();
 
-                await Task.Delay(5000, cancellationToken);
+                await Task.Delay(5000, cancellationToken).ConfigureAwait(false);
             }
             catch (Exception ex)
             {
diff --git a/src/KafkaFlow/Consumers/ConsumerManager.cs b/src/KafkaFlow/Consumers/ConsumerManager.cs
@@ -70,14 +70,14 @@ private void StartEvaluateWorkerCountTimer() => _evaluateWorkersCountTimer?.Chan
 
     private async Task EvaluateWorkersCountAsync()
     {
-        var newWorkersCount = await this.CalculateWorkersCount(this.Consumer.Assignment);
+        var newWorkersCount = await this.CalculateWorkersCount(this.Consumer.Assignment).ConfigureAwait(false);
 
         if (newWorkersCount == this.WorkerPool.CurrentWorkersCount)
         {
             return;
         }
 
-        await this.ChangeWorkersCountAsync(newWorkersCount);
+        await this.ChangeWorkersCountAsync(newWorkersCount).ConfigureAwait(false);
     }
 
     private async Task ChangeWorkersCountAsync(int workersCount)
@@ -86,10 +86,10 @@ private async Task ChangeWorkersCountAsync(int workersCount)
         {
             this.StopEvaluateWorkerCountTimer();
 
-            await this.Feeder.StopAsync();
-            await this.WorkerPool.StopAsync();
+            await this.Feeder.StopAsync().ConfigureAwait(false);
+            await this.WorkerPool.StopAsync().ConfigureAwait(false);
 
-            await this.WorkerPool.StartAsync(this.Consumer.Assignment, workersCount);
+            await this.WorkerPool.StartAsync(this.Consumer.Assignment, workersCount).ConfigureAwait(false);
             this.Feeder.Start();
 
             this.StartEvaluateWorkerCountTimer();
@@ -155,7 +155,8 @@ private async Task<int> CalculateWorkersCount(IEnumerable<Confluent.Kafka.TopicP
                                     .Select(x => x.Partition.Value)
                                     .ToList()))
                         .ToList()),
-                _dependencyResolver);
+                _dependencyResolver)
+                .ConfigureAwait(false);
         }
         catch (Exception e)
         {
diff --git a/src/KafkaFlow/Consumers/ConsumerWorker.cs b/src/KafkaFlow/Consumers/ConsumerWorker.cs
@@ -75,19 +75,20 @@ public Task StartAsync(CancellationToken stopCancellationToken)
 
                 try
                 {
-                    await foreach (var context in _messagesBuffer.Reader.ReadAllItemsAsync(stopCancellationToken))
+                    await foreach (var context in _messagesBuffer.Reader.ReadAllItemsAsync(stopCancellationToken).ConfigureAwait(false))
                     {
                         currentContext = context;
 
                         await this
                             .ProcessMessageAsync(context, stopCancellationToken)
-                            .WithCancellation(stopCancellationToken, true);
+                            .WithCancellation(stopCancellationToken, true)
+                            .ConfigureAwait(false);
                     }
                 }
                 catch (OperationCanceledException)
                 {
                     currentContext?.ConsumerContext.Discard();
-                    await this.DiscardBufferedContextsAsync();
+                    await this.DiscardBufferedContextsAsync().ConfigureAwait(false);
                 }
                 catch (Exception ex)
                 {
@@ -101,13 +102,13 @@ await this
 
     public async Task StopAsync()
     {
-        await _workerStoppingEvent.FireAsync();
+        await _workerStoppingEvent.FireAsync().ConfigureAwait(false);
 
         _messagesBuffer.Writer.TryComplete();
 
-        await _backgroundTask;
+        await _backgroundTask.ConfigureAwait(false);
 
-        await _workerStoppedEvent.FireAsync();
+        await _workerStoppedEvent.FireAsync().ConfigureAwait(false);
     }
 
     public void Dispose()
@@ -118,7 +119,7 @@ public void Dispose()
 
     private async Task DiscardBufferedContextsAsync()
     {
-        await foreach (var context in _messagesBuffer.Reader.ReadAllItemsAsync(CancellationToken.None))
+        await foreach (var context in _messagesBuffer.Reader.ReadAllItemsAsync(CancellationToken.None).ConfigureAwait(false))
         {
             context.ConsumerContext.Discard();
         }
@@ -130,29 +131,29 @@ private async Task ProcessMessageAsync(IMessageContext context, CancellationToke
         {
             try
             {
-                await _globalEvents.FireMessageConsumeStartedAsync(new MessageEventContext(context));
+                await _globalEvents.FireMessageConsumeStartedAsync(new MessageEventContext(context)).ConfigureAwait(false);
 
                 _ = context.ConsumerContext.Completion.ContinueWith(
                     async task =>
                     {
                         if (task.IsFaulted)
                         {
-                            await _globalEvents.FireMessageConsumeErrorAsync(new MessageErrorEventContext(context, task.Exception));
+                            await _globalEvents.FireMessageConsumeErrorAsync(new MessageErrorEventContext(context, task.Exception)).ConfigureAwait(false);
                         }
 
-                        await _globalEvents.FireMessageConsumeCompletedAsync(new MessageEventContext(context));
+                        await _globalEvents.FireMessageConsumeCompletedAsync(new MessageEventContext(context)).ConfigureAwait(false);
                     },
                     CancellationToken.None);
 
-                await _middlewareExecutor.Execute(context, _ => Task.CompletedTask);
+                await _middlewareExecutor.Execute(context, _ => Task.CompletedTask).ConfigureAwait(false);
             }
             catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
             {
                 context.ConsumerContext.ShouldStoreOffset = false;
             }
             catch (Exception ex)
             {
-                await _globalEvents.FireMessageConsumeErrorAsync(new MessageErrorEventContext(context, ex));
+                await _globalEvents.FireMessageConsumeErrorAsync(new MessageErrorEventContext(context, ex)).ConfigureAwait(false);
 
                 _logHandler.Error(
                     "Error processing message",
@@ -172,7 +173,7 @@ private async Task ProcessMessageAsync(IMessageContext context, CancellationToke
                     context.ConsumerContext.Complete();
                 }
 
-                await _workerProcessingEnded.FireAsync(context);
+                await _workerProcessingEnded.FireAsync(context).ConfigureAwait(false);
             }
         }
         catch (Exception ex)
diff --git a/src/KafkaFlow/Consumers/ConsumerWorkerPool.cs b/src/KafkaFlow/Consumers/ConsumerWorkerPool.cs
@@ -63,7 +63,7 @@ public async Task StartAsync(IReadOnlyCollection<TopicPartition> partitions, int
                 new NullOffsetManager() :
                 new OffsetManager(_offsetCommitter, partitions);
 
-            await _offsetCommitter.StartAsync();
+            await _offsetCommitter.StartAsync().ConfigureAwait(false);
 
             this.CurrentWorkersCount = workersCount;
 
@@ -94,7 +94,8 @@ await Task.WhenAll(
                             _workers.Add(worker);
 
                             return worker.StartAsync(_stopCancellationTokenSource.Token);
-                        }));
+                        }))
+                .ConfigureAwait(false);
 
             _distributionStrategy = _distributionStrategyFactory(_consumerDependencyResolver);
             _distributionStrategy.Initialize(_workers.AsReadOnly());
@@ -129,24 +130,25 @@ public async Task StopAsync()
             _stopCancellationTokenSource.CancelAfter(_consumer.Configuration.WorkerStopTimeout);
         }
 
-        await Task.WhenAll(currentWorkers.Select(x => x.StopAsync()));
+        await Task.WhenAll(currentWorkers.Select(x => x.StopAsync())).ConfigureAwait(false);
         await _offsetManager
             .WaitContextsCompletionAsync()
-            .WithCancellation(_stopCancellationTokenSource.Token, false);
+            .WithCancellation(_stopCancellationTokenSource.Token, false)
+            .ConfigureAwait(false);
 
         currentWorkers.ForEach(worker => worker.Dispose());
         _stopCancellationTokenSource?.Dispose();
 
         _offsetManager = null;
 
-        await _workerPoolStoppedSubject.FireAsync();
+        await _workerPoolStoppedSubject.FireAsync().ConfigureAwait(false);
 
-        await _offsetCommitter.StopAsync();
+        await _offsetCommitter.StopAsync().ConfigureAwait(false);
     }
 
     public async Task EnqueueAsync(ConsumeResult<byte[], byte[]> message, CancellationToken stopCancellationToken)
     {
-        await _startedTaskSource.Task;
+        await _startedTaskSource.Task.ConfigureAwait(false);
 
         var worker = (IConsumerWorker)await _distributionStrategy
             .GetWorkerAsync(
@@ -155,7 +157,7 @@ public async Task EnqueueAsync(ConsumeResult<byte[], byte[]> message, Cancellati
                     message.Topic,
                     message.Partition.Value,
                     message.Message.Key,
-                    stopCancellationToken));
+                    stopCancellationToken)).ConfigureAwait(false);
 
         if (worker is null)
         {
@@ -166,7 +168,7 @@ public async Task EnqueueAsync(ConsumeResult<byte[], byte[]> message, Cancellati
 
         _offsetManager.Enqueue(context.ConsumerContext);
 
-        await worker.EnqueueAsync(context);
+        await worker.EnqueueAsync(context).ConfigureAwait(false);
     }
 
     private MessageContext CreateMessageContext(ConsumeResult<byte[], byte[]> message, IConsumerWorker worker)
diff --git a/src/KafkaFlow/Consumers/WorkerPoolFeeder.cs b/src/KafkaFlow/Consumers/WorkerPoolFeeder.cs
@@ -72,6 +72,6 @@ public async Task StopAsync()
             _stopTokenSource.Dispose();
         }
 
-        await (_feederTask ?? Task.CompletedTask);
+        await (_feederTask ?? Task.CompletedTask).ConfigureAwait(false);
     }
 }
diff --git a/src/KafkaFlow/Consumers/WorkersBalancers/ConsumerLagWorkerBalancer.cs b/src/KafkaFlow/Consumers/WorkersBalancers/ConsumerLagWorkerBalancer.cs
@@ -41,7 +41,7 @@ public ConsumerLagWorkerBalancer(
 
     public async Task<int> GetWorkersCountAsync(WorkersCountContext context)
     {
-        var workers = await this.CalculateAsync(context);
+        var workers = await this.CalculateAsync(context).ConfigureAwait(false);
 
         _logHandler.Info(
             "New workers count calculated",
@@ -97,13 +97,14 @@ private async Task<int> CalculateAsync(WorkersCountContext context)
                 return DefaultWorkersCount;
             }
 
-            var topicsMetadata = await this.GetTopicsMetadataAsync(context);
+            var topicsMetadata = await this.GetTopicsMetadataAsync(context).ConfigureAwait(false);
 
             var lastOffsets = this.GetPartitionsLastOffset(context.ConsumerName, topicsMetadata);
 
             var partitionsOffset = await _clusterManager.GetConsumerGroupOffsetsAsync(
                 context.ConsumerGroupId,
-                context.AssignedTopicsPartitions.Select(t => t.Name));
+                context.AssignedTopicsPartitions.Select(t => t.Name))
+                .ConfigureAwait(false);
 
             var partitionsLag = CalculatePartitionsLag(lastOffsets, partitionsOffset);
             var instanceLag = CalculateMyPartitionsLag(context, partitionsLag);
@@ -156,7 +157,7 @@ private async Task<int> CalculateAsync(WorkersCountContext context)
 
         foreach (var topic in context.AssignedTopicsPartitions)
         {
-            topicsMetadata.Add((topic.Name, await _clusterManager.GetTopicMetadataAsync(topic.Name)));
+            topicsMetadata.Add((topic.Name, await _clusterManager.GetTopicMetadataAsync(topic.Name).ConfigureAwait(false)));
         }
 
         return topicsMetadata;
diff --git a/src/KafkaFlow/Extensions/ChannelExtensions.cs b/src/KafkaFlow/Extensions/ChannelExtensions.cs
@@ -11,7 +11,7 @@ public static async IAsyncEnumerable<T> ReadAllItemsAsync<T>(
         this ChannelReader<T> reader,
         [EnumeratorCancellation] CancellationToken cancellationToken = default)
     {
-        while (await reader.WaitToReadAsync(cancellationToken))
+        while (await reader.WaitToReadAsync(cancellationToken).ConfigureAwait(false))
         {
             while (reader.TryRead(out var item))
             {
diff --git a/src/KafkaFlow/Extensions/TaskExtensions.cs b/src/KafkaFlow/Extensions/TaskExtensions.cs
@@ -21,7 +21,7 @@ public static async Task WithCancellation(
             return;
         }
 
-        await Task.WhenAny(task, tcs.Task);
+        await Task.WhenAny(task, tcs.Task).ConfigureAwait(false);
 
         void TrySetResult()
         {
diff --git a/src/KafkaFlow/KafkaBus.cs b/src/KafkaFlow/KafkaBus.cs
@@ -48,7 +48,7 @@ public async Task StartAsync(CancellationToken stopCancellationToken = default)
 
         foreach (var cluster in _configuration.Clusters)
         {
-            await this.CreateMissingClusterTopics(cluster);
+            await this.CreateMissingClusterTopics(cluster).ConfigureAwait(false);
 
             foreach (var consumerConfiguration in cluster.Consumers)
             {
@@ -101,6 +101,7 @@ private async Task CreateMissingClusterTopics(ClusterConfiguration cluster)
         }
 
         await _clusterManagerAccessor[cluster.Name].CreateIfNotExistsAsync(
-            cluster.TopicsToCreateIfNotExist);
+            cluster.TopicsToCreateIfNotExist)
+            .ConfigureAwait(false);
     }
 }
diff --git a/src/KafkaFlow/Middlewares/ConsumerThrottling/ConsumerThrottlingThreshold.cs b/src/KafkaFlow/Middlewares/ConsumerThrottling/ConsumerThrottlingThreshold.cs
@@ -21,7 +21,7 @@ public async Task<bool> TryExecuteActionAsync(long metricValue)
             return false;
         }
 
-        await _action.ExecuteAsync();
+        await _action.ExecuteAsync().ConfigureAwait(false);
 
         return true;
     }
diff --git a/src/KafkaFlow/Middlewares/Serializer/DeserializerConsumerMiddleware.cs b/src/KafkaFlow/Middlewares/Serializer/DeserializerConsumerMiddleware.cs
@@ -53,7 +53,7 @@ public async Task Invoke(IMessageContext context, MiddlewareDelegate next)
             return;
         }
 
-        var messageType = await _typeResolver.OnConsumeAsync(context);
+        var messageType = await _typeResolver.OnConsumeAsync(context).ConfigureAwait(false);
 
         if (messageType is null)
         {
diff --git a/src/KafkaFlow/Middlewares/Serializer/SerializerProducerMiddleware.cs b/src/KafkaFlow/Middlewares/Serializer/SerializerProducerMiddleware.cs
diff --git a/src/KafkaFlow/Producers/MessageProducer.cs b/src/KafkaFlow/Producers/MessageProducer.cs

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public BatchConsumeMiddleware(`
`38`	`38`
`39`	`39`	`public async Task Invoke(IMessageContext context, MiddlewareDelegate next)`
`40`	`40`	`{`
`41`		`- await _dispatchSemaphore.WaitAsync();`
	`41`	`+ await _dispatchSemaphore.WaitAsync().ConfigureAwait(false);`
`42`	`42`
`43`	`43`	`try`
`44`	`44`	`{`
`@@ -59,7 +59,7 @@ public async Task Invoke(IMessageContext context, MiddlewareDelegate next)`
`59`	`59`
`60`	`60`	`if (_batch.Count >= _batchSize)`
`61`	`61`	`{`
`62`		`- await this.TriggerDispatchAndWaitAsync();`
	`62`	`+ await this.TriggerDispatchAndWaitAsync().ConfigureAwait(false);`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
`@@ -72,11 +72,11 @@ public void Dispose()`
`72`	`72`
`73`	`73`	`private async Task TriggerDispatchAndWaitAsync()`
`74`	`74`	`{`
`75`		`- await _dispatchSemaphore.WaitAsync();`
	`75`	`+ await _dispatchSemaphore.WaitAsync().ConfigureAwait(false);`
`76`	`76`	`_dispatchTokenSource?.Cancel();`
`77`	`77`	`_dispatchSemaphore.Release();`
`78`	`78`
`79`		`- await (_dispatchTask ?? Task.CompletedTask);`
	`79`	`+ await (_dispatchTask ?? Task.CompletedTask).ConfigureAwait(false);`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`private void ScheduleExecution(IMessageContext context, MiddlewareDelegate next)`
`@@ -92,7 +92,7 @@ private void ScheduleExecution(IMessageContext context, MiddlewareDelegate next)`
`92`	`92`
`93`	`93`	`private async Task DispatchAsync(IMessageContext context, MiddlewareDelegate next)`
`94`	`94`	`{`
`95`		`- await _dispatchSemaphore.WaitAsync();`
	`95`	`+ await _dispatchSemaphore.WaitAsync().ConfigureAwait(false);`
`96`	`96`
`97`	`97`	`_dispatchTokenSource.Dispose();`
`98`	`98`	`_dispatchTokenSource = null;`
Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ public async Task<IEnumerable<TopicPartitionOffset>> GetConsumerGroupOffsetsAsyn`
`85`	`85`
`86`	`86`	`foreach (var name in topicsName)`
`87`	`87`	`{`
`88`		`- topicsMetadata.Add((name, await this.GetTopicMetadataAsync(name)));`
	`88`	`+ topicsMetadata.Add((name, await this.GetTopicMetadataAsync(name).ConfigureAwait(false)));`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`var topics =`
`@@ -98,7 +98,7 @@ public async Task<IEnumerable<TopicPartitionOffset>> GetConsumerGroupOffsetsAsyn`
`98`	`98`	`.ToList();`
`99`	`99`
`100`	`100`	`var result = await _lazyAdminClient.Value.ListConsumerGroupOffsetsAsync(`
`101`		`- new[] { new ConsumerGroupTopicPartitions(consumerGroup, topics) });`
	`101`	`+ new[] { new ConsumerGroupTopicPartitions(consumerGroup, topics) }).ConfigureAwait(false);`
`102`	`102`
`103`	`103`	`if (!result.Any())`
`104`	`104`	`{`
`@@ -125,7 +125,7 @@ public async Task CreateIfNotExistsAsync(IEnumerable<TopicConfiguration> configu`
`125`	`125`	`})`
`126`	`126`	`.ToArray();`
`127`	`127`
`128`		`- await _lazyAdminClient.Value.CreateTopicsAsync(topics);`
	`128`	`+ await _lazyAdminClient.Value.CreateTopicsAsync(topics).ConfigureAwait(false);`
`129`	`129`	`}`
`130`	`130`	`catch (CreateTopicsException exception)`
`131`	`131`	`{`
Original file line number	Diff line number	Diff line change
`@@ -163,7 +163,7 @@ public async ValueTask<ConsumeResult<byte[], byte[]>> ConsumeAsync(CancellationT`
`163`	`163`	`try`
`164`	`164`	`{`
`165`	`165`	`this.EnsureConsumer();`
`166`		`- await _flowManager.BlockHeartbeat(cancellationToken);`
	`166`	`+ await _flowManager.BlockHeartbeat(cancellationToken).ConfigureAwait(false);`
`167`	`167`	`return _consumer.Consume(cancellationToken);`
`168`	`168`	`}`
`169`	`169`	`catch (OperationCanceledException)`
`@@ -176,7 +176,7 @@ public async ValueTask<ConsumeResult<byte[], byte[]>> ConsumeAsync(CancellationT`
`176`	`176`	`"Max Poll Interval Exceeded",`
`177`	`177`	`new { this.Configuration.ConsumerName });`
`178`	`178`
`179`		`- await _maxPollIntervalExceeded.FireAsync();`
	`179`	`+ await _maxPollIntervalExceeded.FireAsync().ConfigureAwait(false);`
`180`	`180`	`}`
`181`	`181`	`catch (KafkaException ex) when (ex.Error.IsFatal)`
`182`	`182`	`{`
`@@ -187,7 +187,7 @@ public async ValueTask<ConsumeResult<byte[], byte[]>> ConsumeAsync(CancellationT`
`187`	`187`
`188`	`188`	`this.InvalidateConsumer();`
`189`	`189`
`190`		`- await Task.Delay(5000, cancellationToken);`
	`190`	`+ await Task.Delay(5000, cancellationToken).ConfigureAwait(false);`
`191`	`191`	`}`
`192`	`192`	`catch (Exception ex)`
`193`	`193`	`{`
Original file line number	Diff line number	Diff line change
`@@ -70,14 +70,14 @@ private void StartEvaluateWorkerCountTimer() => _evaluateWorkersCountTimer?.Chan`
`70`	`70`
`71`	`71`	`private async Task EvaluateWorkersCountAsync()`
`72`	`72`	`{`
`73`		`- var newWorkersCount = await this.CalculateWorkersCount(this.Consumer.Assignment);`
	`73`	`+ var newWorkersCount = await this.CalculateWorkersCount(this.Consumer.Assignment).ConfigureAwait(false);`
`74`	`74`
`75`	`75`	`if (newWorkersCount == this.WorkerPool.CurrentWorkersCount)`
`76`	`76`	`{`
`77`	`77`	`return;`
`78`	`78`	`}`
`79`	`79`
`80`		`- await this.ChangeWorkersCountAsync(newWorkersCount);`
	`80`	`+ await this.ChangeWorkersCountAsync(newWorkersCount).ConfigureAwait(false);`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`private async Task ChangeWorkersCountAsync(int workersCount)`
`@@ -86,10 +86,10 @@ private async Task ChangeWorkersCountAsync(int workersCount)`
`86`	`86`	`{`
`87`	`87`	`this.StopEvaluateWorkerCountTimer();`
`88`	`88`
`89`		`- await this.Feeder.StopAsync();`
`90`		`- await this.WorkerPool.StopAsync();`
	`89`	`+ await this.Feeder.StopAsync().ConfigureAwait(false);`
	`90`	`+ await this.WorkerPool.StopAsync().ConfigureAwait(false);`
`91`	`91`
`92`		`- await this.WorkerPool.StartAsync(this.Consumer.Assignment, workersCount);`
	`92`	`+ await this.WorkerPool.StartAsync(this.Consumer.Assignment, workersCount).ConfigureAwait(false);`
`93`	`93`	`this.Feeder.Start();`
`94`	`94`
`95`	`95`	`this.StartEvaluateWorkerCountTimer();`
`@@ -155,7 +155,8 @@ private async Task<int> CalculateWorkersCount(IEnumerable<Confluent.Kafka.TopicP`
`155`	`155`	`.Select(x => x.Partition.Value)`
`156`	`156`	`.ToList()))`
`157`	`157`	`.ToList()),`
`158`		`- _dependencyResolver);`
	`158`	`+ _dependencyResolver)`
	`159`	`+ .ConfigureAwait(false);`
`159`	`160`	`}`
`160`	`161`	`catch (Exception e)`
`161`	`162`	`{`
Original file line number	Diff line number	Diff line change
`@@ -75,19 +75,20 @@ public Task StartAsync(CancellationToken stopCancellationToken)`
`75`	`75`
`76`	`76`	`try`
`77`	`77`	`{`
`78`		`- await foreach (var context in _messagesBuffer.Reader.ReadAllItemsAsync(stopCancellationToken))`
	`78`	`+ await foreach (var context in _messagesBuffer.Reader.ReadAllItemsAsync(stopCancellationToken).ConfigureAwait(false))`
`79`	`79`	`{`
`80`	`80`	`currentContext = context;`
`81`	`81`
`82`	`82`	`await this`
`83`	`83`	`.ProcessMessageAsync(context, stopCancellationToken)`
`84`		`- .WithCancellation(stopCancellationToken, true);`
	`84`	`+ .WithCancellation(stopCancellationToken, true)`
	`85`	`+ .ConfigureAwait(false);`
`85`	`86`	`}`
`86`	`87`	`}`
`87`	`88`	`catch (OperationCanceledException)`
`88`	`89`	`{`
`89`	`90`	`currentContext?.ConsumerContext.Discard();`
`90`		`- await this.DiscardBufferedContextsAsync();`
	`91`	`+ await this.DiscardBufferedContextsAsync().ConfigureAwait(false);`
`91`	`92`	`}`
`92`	`93`	`catch (Exception ex)`
`93`	`94`	`{`
`@@ -101,13 +102,13 @@ await this`
`101`	`102`
`102`	`103`	`public async Task StopAsync()`
`103`	`104`	`{`
`104`		`- await _workerStoppingEvent.FireAsync();`
	`105`	`+ await _workerStoppingEvent.FireAsync().ConfigureAwait(false);`
`105`	`106`
`106`	`107`	`_messagesBuffer.Writer.TryComplete();`
`107`	`108`
`108`		`- await _backgroundTask;`
	`109`	`+ await _backgroundTask.ConfigureAwait(false);`
`109`	`110`
`110`		`- await _workerStoppedEvent.FireAsync();`
	`111`	`+ await _workerStoppedEvent.FireAsync().ConfigureAwait(false);`
`111`	`112`	`}`
`112`	`113`
`113`	`114`	`public void Dispose()`
`@@ -118,7 +119,7 @@ public void Dispose()`
`118`	`119`
`119`	`120`	`private async Task DiscardBufferedContextsAsync()`
`120`	`121`	`{`
`121`		`- await foreach (var context in _messagesBuffer.Reader.ReadAllItemsAsync(CancellationToken.None))`
	`122`	`+ await foreach (var context in _messagesBuffer.Reader.ReadAllItemsAsync(CancellationToken.None).ConfigureAwait(false))`
`122`	`123`	`{`
`123`	`124`	`context.ConsumerContext.Discard();`
`124`	`125`	`}`
`@@ -130,29 +131,29 @@ private async Task ProcessMessageAsync(IMessageContext context, CancellationToke`
`130`	`131`	`{`
`131`	`132`	`try`
`132`	`133`	`{`
`133`		`- await _globalEvents.FireMessageConsumeStartedAsync(new MessageEventContext(context));`
	`134`	`+ await _globalEvents.FireMessageConsumeStartedAsync(new MessageEventContext(context)).ConfigureAwait(false);`
`134`	`135`
`135`	`136`	`_ = context.ConsumerContext.Completion.ContinueWith(`
`136`	`137`	`async task =>`
`137`	`138`	`{`
`138`	`139`	`if (task.IsFaulted)`
`139`	`140`	`{`
`140`		`- await _globalEvents.FireMessageConsumeErrorAsync(new MessageErrorEventContext(context, task.Exception));`
	`141`	`+ await _globalEvents.FireMessageConsumeErrorAsync(new MessageErrorEventContext(context, task.Exception)).ConfigureAwait(false);`
`141`	`142`	`}`
`142`	`143`
`143`		`- await _globalEvents.FireMessageConsumeCompletedAsync(new MessageEventContext(context));`
	`144`	`+ await _globalEvents.FireMessageConsumeCompletedAsync(new MessageEventContext(context)).ConfigureAwait(false);`
`144`	`145`	`},`
`145`	`146`	`CancellationToken.None);`
`146`	`147`
`147`		`- await _middlewareExecutor.Execute(context, _ => Task.CompletedTask);`
	`148`	`+ await _middlewareExecutor.Execute(context, _ => Task.CompletedTask).ConfigureAwait(false);`
`148`	`149`	`}`
`149`	`150`	`catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)`
`150`	`151`	`{`
`151`	`152`	`context.ConsumerContext.ShouldStoreOffset = false;`
`152`	`153`	`}`
`153`	`154`	`catch (Exception ex)`
`154`	`155`	`{`
`155`		`- await _globalEvents.FireMessageConsumeErrorAsync(new MessageErrorEventContext(context, ex));`
	`156`	`+ await _globalEvents.FireMessageConsumeErrorAsync(new MessageErrorEventContext(context, ex)).ConfigureAwait(false);`
`156`	`157`
`157`	`158`	`_logHandler.Error(`
`158`	`159`	`"Error processing message",`
`@@ -172,7 +173,7 @@ private async Task ProcessMessageAsync(IMessageContext context, CancellationToke`
`172`	`173`	`context.ConsumerContext.Complete();`
`173`	`174`	`}`
`174`	`175`
`175`		`- await _workerProcessingEnded.FireAsync(context);`
	`176`	`+ await _workerProcessingEnded.FireAsync(context).ConfigureAwait(false);`
`176`	`177`	`}`
`177`	`178`	`}`
`178`	`179`	`catch (Exception ex)`
Original file line number	Diff line number	Diff line change
`@@ -72,6 +72,6 @@ public async Task StopAsync()`
`72`	`72`	`_stopTokenSource.Dispose();`
`73`	`73`	`}`
`74`	`74`
`75`		`- await (_feederTask ?? Task.CompletedTask);`
	`75`	`+ await (_feederTask ?? Task.CompletedTask).ConfigureAwait(false);`
`76`	`76`	`}`
`77`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ public static async IAsyncEnumerable<T> ReadAllItemsAsync<T>(`
`11`	`11`	`this ChannelReader<T> reader,`
`12`	`12`	`[EnumeratorCancellation] CancellationToken cancellationToken = default)`
`13`	`13`	`{`
`14`		`- while (await reader.WaitToReadAsync(cancellationToken))`
	`14`	`+ while (await reader.WaitToReadAsync(cancellationToken).ConfigureAwait(false))`
`15`	`15`	`{`
`16`	`16`	`while (reader.TryRead(out var item))`
`17`	`17`	`{`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ public static async Task WithCancellation(`
`21`	`21`	`return;`
`22`	`22`	`}`
`23`	`23`
`24`		`- await Task.WhenAny(task, tcs.Task);`
	`24`	`+ await Task.WhenAny(task, tcs.Task).ConfigureAwait(false);`
`25`	`25`
`26`	`26`	`void TrySetResult()`
`27`	`27`	`{`