Issue-223 - Remove ConfigureAwait (#273)

huntharo · web-flow · commit fd1979b70234 · 2025-04-08T20:18:53.000-04:00
- Turns out this is actually only needed in library code
diff --git a/src/PwrDrvr.LambdaDispatch.Extension/Function.cs b/src/PwrDrvr.LambdaDispatch.Extension/Function.cs
@@ -64,14 +64,14 @@ private static async Task Main()
 
         _logger.LogDebug("Lambda Extension Registering");
         // The Extension API will not return so we cannot await this
-        await RegisterLambdaExtension().ConfigureAwait(false);
+        await RegisterLambdaExtension();
         _logger.LogDebug("Lambda Extension Registered");
 
         if (!_staticResponse)
         {
             _logger.LogDebug("Contained App - Skipping Startup, Waiting for Healthy");
             // Wait for the health endpoint to return OK
-            await AwaitChildAppHealthy().ConfigureAwait(false);
+            await AwaitChildAppHealthy();
             _logger.LogInformation("Contained App - Healthy");
         }
         else
@@ -80,7 +80,7 @@ private static async Task Main()
         }
 #if !SKIP_METRICS
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-        Task.Run(() => MetricsRegistry.PrintMetrics(ctsShutdown.Token)).ConfigureAwait(false);
+        Task.Run(() => MetricsRegistry.PrintMetrics(ctsShutdown.Token));
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
 #endif
         Func<WaiterRequest, ILambdaContext, Task<WaiterResponse>> handler = FunctionHandler;
@@ -133,14 +133,14 @@ private static async Task RegisterLambdaExtension()
             var execName = Path.GetFileName(Process.GetCurrentProcess().MainModule?.FileName ?? "lambda-dispatch");
             _logger.LogInformation("Registering Lambda Extension with name: {}", execName);
             registerRequest.Headers.Add("Lambda-Extension-Name", execName);
-            var registerResponse = await client.SendAsync(registerRequest).ConfigureAwait(false);
+            var registerResponse = await client.SendAsync(registerRequest);
             if (!registerResponse.IsSuccessStatusCode)
             {
                 throw new Exception($"Failed to register extension: {registerResponse.StatusCode}");
             }
             var extensionId = registerResponse.Headers.GetValues("Lambda-Extension-Identifier").FirstOrDefault();
             // Discard the response body
-            await registerResponse.Content.CopyToAsync(Stream.Null).ConfigureAwait(false);
+            await registerResponse.Content.CopyToAsync(Stream.Null);
             if (string.IsNullOrEmpty(extensionId))
             {
                 throw new Exception($"Failed to get extension id");
@@ -153,7 +153,7 @@ private static async Task RegisterLambdaExtension()
                 {
                     var nextEventRequest = new HttpRequestMessage(HttpMethod.Get, nextEventUrl);
                     nextEventRequest.Headers.Add("Lambda-Extension-Identifier", extensionId);
-                    var nextEventResponse = await client.SendAsync(nextEventRequest).ConfigureAwait(false);
+                    var nextEventResponse = await client.SendAsync(nextEventRequest);
                     if (!nextEventResponse.IsSuccessStatusCode)
                     {
                         throw new Exception($"Failed to get next event: {nextEventResponse.StatusCode}");
@@ -196,7 +196,7 @@ private static async Task AwaitChildAppHealthy()
         {
             try
             {
-                var response = await client.GetAsync(healthCheckUrl).ConfigureAwait(false);
+                var response = await client.GetAsync(healthCheckUrl);
                 if (response.StatusCode == HttpStatusCode.OK)
                 {
                     _logger.LogInformation("Contained App - Got OK result");
@@ -209,7 +209,7 @@ private static async Task AwaitChildAppHealthy()
                 _logger.LogDebug("Contained App - Healthcheck failed");
             }
 
-            await Task.Delay(250).ConfigureAwait(false); // Wait for a second before polling again
+            await Task.Delay(250); // Wait for a second before polling again
         }
         while (true);
 
@@ -302,7 +302,7 @@ public static async Task<WaiterResponse> FunctionHandler(WaiterRequest request,
                                 _logger.LogDebug("Getting request from Router");
 
                                 (var outerStatus, var receivedRequest, var requestForResponse, var requestStreamForResponse, var duplexContent)
-                                    = await reverseRequester.GetRequest(channelId).ConfigureAwait(false);
+                                    = await reverseRequester.GetRequest(channelId);
 
                                 lastWakeupTime = DateTime.Now;
 
@@ -361,7 +361,7 @@ public static async Task<WaiterResponse> FunctionHandler(WaiterRequest request,
                                     {
                                         // Return after headers are received
                                         _logger.LogDebug("Sending request to Contained App");
-                                        using var response = await appHttpClient.SendAsync(receivedRequest, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false);
+                                        using var response = await appHttpClient.SendAsync(receivedRequest, HttpCompletionOption.ResponseHeadersRead);
 
                                         _logger.LogDebug("Got response from Contained App");
 
@@ -371,23 +371,23 @@ public static async Task<WaiterResponse> FunctionHandler(WaiterRequest request,
                                         }
 
                                         // Send the response back
-                                        await reverseRequester.SendResponse(response, requestForResponse, requestStreamForResponse, duplexContent, channelId).ConfigureAwait(false);
+                                        await reverseRequester.SendResponse(response, requestForResponse, requestStreamForResponse, duplexContent, channelId);
                                     }
                                     else
                                     {
                                         // NOTE: Static response is only for testing
                                         // Read the bytes off the request body, if any
                                         if (receivedRequest.Content != null)
                                         {
-                                            await receivedRequest.Content.CopyToAsync(Stream.Null).ConfigureAwait(false);
+                                            await receivedRequest.Content.CopyToAsync(Stream.Null);
                                         }
 
                                         using var response = new HttpResponseMessage(System.Net.HttpStatusCode.OK)
                                         {
                                             Content = new StringContent($"Hello from LambdaLB")
                                         };
 
-                                        await reverseRequester.SendResponse(response, requestForResponse, requestStreamForResponse, duplexContent, channelId).ConfigureAwait(false);
+                                        await reverseRequester.SendResponse(response, requestForResponse, requestStreamForResponse, duplexContent, channelId);
                                     }
 
 #if !SKIP_METRICS
@@ -407,7 +407,7 @@ public static async Task<WaiterResponse> FunctionHandler(WaiterRequest request,
                                         {
                                             Content = new StringContent(ex.Message)
                                         };
-                                        await reverseRequester.SendResponse(response, requestForResponse, requestStreamForResponse, duplexContent, channelId).ConfigureAwait(false);
+                                        await reverseRequester.SendResponse(response, requestForResponse, requestStreamForResponse, duplexContent, channelId);
                                     }
                                     catch (Exception ex2)
                                     {
@@ -517,7 +517,7 @@ public static async Task<WaiterResponse> FunctionHandler(WaiterRequest request,
                 {
                     try
                     {
-                        var completedTask = await Task.WhenAny(tcsShutdown.Task, Task.Delay(TimeSpan.FromSeconds(5), pingCts.Token)).ConfigureAwait(false);
+                        var completedTask = await Task.WhenAny(tcsShutdown.Task, Task.Delay(TimeSpan.FromSeconds(5), pingCts.Token));
 
                         if (completedTask == tcsShutdown.Task)
                         {
diff --git a/src/PwrDrvr.LambdaDispatch.Extension/HttpDuplexContent.cs b/src/PwrDrvr.LambdaDispatch.Extension/HttpDuplexContent.cs
@@ -32,7 +32,7 @@ protected override async Task SerializeToStreamAsync(Stream stream, TransportCon
     stream.Flush();
     _waitForCompletion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
     _waitForStream.SetResult(stream);
-    await _waitForCompletion.Task.ConfigureAwait(false);
+    await _waitForCompletion.Task;
   }
 
   public Task<Stream> WaitForStreamAsync()
diff --git a/src/PwrDrvr.LambdaDispatch.Extension/HttpReverseRequester.cs b/src/PwrDrvr.LambdaDispatch.Extension/HttpReverseRequester.cs
@@ -147,10 +147,10 @@ public ValueTask DisposeAsync()
     // Read the Response before sending the Request
     // TODO: We can await the pair of the Response or Request closing to avoid deadlocks
     //
-    var response = await _client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false);
+    var response = await _client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
 
     // Get the stream that we can write the response to
-    Stream requestStreamForResponse = await duplexContent.WaitForStreamAsync().ConfigureAwait(false);
+    Stream requestStreamForResponse = await duplexContent.WaitForStreamAsync();
     if (response.StatusCode != HttpStatusCode.OK)
     {
       _logger.LogWarning("CLOSING - Got a {status} on the outer request LambdaId: {id}, ChannelId: {channelId}", response.StatusCode, _id, channelId);
@@ -173,7 +173,7 @@ public ValueTask DisposeAsync()
     var headerBuffer = ArrayPool<byte>.Shared.Rent(32 * 1024);
     try
     {
-      var requestStream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
+      var requestStream = await response.Content.ReadAsStreamAsync();
 
       // Read up to max headers size of data
       // Read until we fill the bufer OR we get an EOF
@@ -189,7 +189,7 @@ public ValueTask DisposeAsync()
           break;
         }
 
-        var bytesRead = await requestStream.ReadAsync(headerBuffer, totalBytesRead, headerBuffer.Length - totalBytesRead).ConfigureAwait(false);
+        var bytesRead = await requestStream.ReadAsync(headerBuffer, totalBytesRead, headerBuffer.Length - totalBytesRead);
         if (bytesRead == 0)
         {
           // Done reading
@@ -445,12 +445,12 @@ public async Task SendResponse(HttpResponseMessage response, HttpRequestMessage
       offset += endOfHeadersBytes.Length;
 
       // Write the headers to the stream
-      await requestStreamForResponse.WriteAsync(headerBuffer.AsMemory(0, offset)).ConfigureAwait(false);
+      await requestStreamForResponse.WriteAsync(headerBuffer.AsMemory(0, offset));
 
       // Copy the body from the request to the response
       // NOTE: CopyToAsync will only start sending when EOF is read on the response stream
 #if false
-      await response.Content.CopyToAsync(requestStreamForResponse).ConfigureAwait(false);
+      await response.Content.CopyToAsync(requestStreamForResponse);
 #else
       var bytes = ArrayPool<byte>.Shared.Rent(128 * 1024);
       try
@@ -469,7 +469,7 @@ public async Task SendResponse(HttpResponseMessage response, HttpRequestMessage
         ArrayPool<byte>.Shared.Return(bytes);
       }
 #endif
-      await requestStreamForResponse.FlushAsync().ConfigureAwait(false);
+      await requestStreamForResponse.FlushAsync();
       requestStreamForResponse.Close();
       duplexContent.Complete();
     }
@@ -504,7 +504,7 @@ public async Task CloseInstance()
       request.Headers.Host = $"lambdadispatch.local:{_uri.Port}";
       request.Headers.Add("X-Lambda-Id", _id);
 
-      using var response = await _client.SendAsync(request).ConfigureAwait(false);
+      using var response = await _client.SendAsync(request);
 
       if (response.StatusCode != HttpStatusCode.OK)
       {
@@ -539,7 +539,7 @@ public async Task<bool> Ping()
       request.Headers.Host = $"lambdadispatch.local:{_uri.Port}";
       request.Headers.Add("X-Lambda-Id", _id);
 
-      using var response = await _client.SendAsync(request).ConfigureAwait(false);
+      using var response = await _client.SendAsync(request);
 
       if (response.StatusCode != HttpStatusCode.OK)
       {
diff --git a/src/PwrDrvr.LambdaDispatch.Router/Dispatcher.cs b/src/PwrDrvr.LambdaDispatch.Router/Dispatcher.cs
@@ -194,7 +194,7 @@ public async Task AddRequest(HttpRequest incomingRequest, HttpResponse incomingR
         }
 
         // TODO: If we want to cancel we need to pass a token in here
-        runRequestResult = await lambdaConnection.RunRequest(incomingRequest, incomingResponse, accessLogProps, debugMode).ConfigureAwait(false);
+        runRequestResult = await lambdaConnection.RunRequest(incomingRequest, incomingResponse, accessLogProps, debugMode);
         accessLogProps.StatusCode = incomingResponse.StatusCode;
 
         if (debugMode)
@@ -770,7 +770,7 @@ private bool TryBackgroundDispatchOne(PendingRequest pendingRequest, ILambdaConn
               "-"
               );
         }
-      }).ConfigureAwait(false);
+      });
 
       return startedRequest;
     }
diff --git a/src/PwrDrvr.LambdaDispatch.Router/LambdaConnection.cs b/src/PwrDrvr.LambdaDispatch.Router/LambdaConnection.cs
@@ -238,7 +238,7 @@ private async Task<long> ProxyRequestToLambda(HttpRequest incomingRequest, Acces
       offset += 2;
 
       // Send the headers to the Lambda
-      await Response.BodyWriter.WriteAsync(headerBuffer.AsMemory(0, offset), CTS.Token).ConfigureAwait(false);
+      await Response.BodyWriter.WriteAsync(headerBuffer.AsMemory(0, offset), CTS.Token);
 
       if (debugMode)
       {
@@ -353,14 +353,14 @@ private async Task<long> ProxyRequestToLambda(HttpRequest incomingRequest, Acces
           ArrayPool<byte>.Shared.Return(bytes);
         }
 
-        await incomingRequest.BodyReader.CompleteAsync().ConfigureAwait(false);
+        await incomingRequest.BodyReader.CompleteAsync();
 
         _logger.LogDebug("Finished sending incoming request body to Lambda");
       }
 
       // Mark that the Request has been sent on the LambdaInstances
-      await Response.BodyWriter.CompleteAsync().ConfigureAwait(false);
-      await Response.CompleteAsync().ConfigureAwait(false);
+      await Response.BodyWriter.CompleteAsync();
+      await Response.CompleteAsync();
 
       // Get the response from the lambda request and relay it back to the caller
       _logger.LogDebug("Finished sending entire request to Lambda");
@@ -444,7 +444,7 @@ public async Task<RunRequestResult> RunRequest(HttpRequest incomingRequest, Http
       // Wait for both to finish
       // This allows us to continue sending request body while receiving
       // and relaying the response body (duplex)
-      var completedTask = await Task.WhenAny(proxyRequestTask, proxyResponseTask).ConfigureAwait(false);
+      var completedTask = await Task.WhenAny(proxyRequestTask, proxyResponseTask);
       if (completedTask.Exception != null)
       {
         _logger.LogError(completedTask.Exception, "{Method} {Url} {Protocol} {RemoteIP} {UserAgent} - {} Status - {} Bytes Received - {} Bytes Sent - RUNREQUEST - EXCEPTION",
@@ -464,14 +464,14 @@ public async Task<RunRequestResult> RunRequest(HttpRequest incomingRequest, Http
       {
         // ProxyRequestToLambda finished first
         // Wait for RelayResponseFromLambda to finish
-        totalBytesWritten = await proxyResponseTask.ConfigureAwait(false);
+        totalBytesWritten = await proxyResponseTask;
         totalBytesRead = completedTask.Result;
       }
       else
       {
         // RelayResponseFromLambda finished first
         // Wait for ProxyRequestToLambda to finish
-        totalBytesRead = await proxyRequestTask.ConfigureAwait(false);
+        totalBytesRead = await proxyRequestTask;
         totalBytesWritten = completedTask.Result;
       }
     }
@@ -555,7 +555,7 @@ public async Task<RunRequestResult> RunRequest(HttpRequest incomingRequest, Http
 
       try
       {
-        await incomingResponse.CompleteAsync().ConfigureAwait(false);
+        await incomingResponse.CompleteAsync();
       }
       catch { }
 
@@ -595,7 +595,7 @@ private async Task<long> RelayResponseFromLambda(HttpResponse incomingResponse,
           break;
         }
 
-        var bytesRead = await Request.Body.ReadAsync(headerBuffer.AsMemory(totalBytesRead, headerBuffer.Length - totalBytesRead), CTS.Token).ConfigureAwait(false);
+        var bytesRead = await Request.Body.ReadAsync(headerBuffer.AsMemory(totalBytesRead, headerBuffer.Length - totalBytesRead), CTS.Token);
         if (bytesRead == 0)
         {
           // Done reading
@@ -734,7 +734,7 @@ private async Task<long> RelayResponseFromLambda(HttpResponse incomingResponse,
         // There are bytes left in the buffer
         // Copy them to the response
         totalBodyBytesRead += totalBytesRead - startOfNextLine;
-        await incomingResponse.BodyWriter.WriteAsync(headerBuffer.AsMemory(startOfNextLine, totalBytesRead - startOfNextLine), CTS.Token).ConfigureAwait(false);
+        await incomingResponse.BodyWriter.WriteAsync(headerBuffer.AsMemory(startOfNextLine, totalBytesRead - startOfNextLine), CTS.Token);
         totalBodyBytesWritten += totalBytesRead - startOfNextLine;
       }
     }
@@ -785,7 +785,7 @@ private async Task<long> RelayResponseFromLambda(HttpResponse incomingResponse,
       {
         try
         {
-          bytesRead = await responseStream.ReadAsync(bytes, CTS.Token).ConfigureAwait(false);
+          bytesRead = await responseStream.ReadAsync(bytes, CTS.Token);
         }
         catch (Exception ex)
         {
@@ -809,7 +809,7 @@ private async Task<long> RelayResponseFromLambda(HttpResponse incomingResponse,
 
         try
         {
-          await incomingResponse.Body.WriteAsync(bytes.AsMemory(0, bytesRead), CTS.Token).ConfigureAwait(false);
+          await incomingResponse.Body.WriteAsync(bytes.AsMemory(0, bytesRead), CTS.Token);
           totalBodyBytesWritten += bytesRead;
         }
         catch (Exception ex)
diff --git a/src/PwrDrvr.LambdaDispatch.Router/LambdaInstanceManager.cs b/src/PwrDrvr.LambdaDispatch.Router/LambdaInstanceManager.cs
@@ -204,7 +204,7 @@ public async Task<AddConnectionResult> AddConnectionForLambda(HttpRequest reques
     {
       // Add the connection to the instance
       // The instance will eventually get rebalanced in the least outstanding queue
-      var result = await instance.AddConnection(request, response, channelId, dispatchMode).ConfigureAwait(false);
+      var result = await instance.AddConnection(request, response, channelId, dispatchMode);
 
       if (result.WasRejected || result.Connection == null)
       {
diff --git a/src/PwrDrvr.LambdaDispatch.Router/LeastOutstandingQueue.cs b/src/PwrDrvr.LambdaDispatch.Router/LeastOutstandingQueue.cs
@@ -392,7 +392,7 @@ private async Task RebalanceQueue()
       // Wait for a short period before checking again
       try
       {
-        await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationTokenSource.Token).ConfigureAwait(false);
+        await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationTokenSource.Token);
       }
       catch (TaskCanceledException)
       {
@@ -443,7 +443,7 @@ private async Task LogQueueSizes()
       // Wait a bit
       try
       {
-        await Task.Delay(TimeSpan.FromSeconds(10), cancellationTokenSource.Token).ConfigureAwait(false);
+        await Task.Delay(TimeSpan.FromSeconds(10), cancellationTokenSource.Token);
       }
       catch (TaskCanceledException)
       {
diff --git a/src/PwrDrvr.LambdaDispatch.Router/MetricsRegistry.cs b/src/PwrDrvr.LambdaDispatch.Router/MetricsRegistry.cs
@@ -297,8 +297,8 @@ public async Task PrintMetrics()
   {
     while (true)
     {
-      await Task.WhenAll(this.Metrics.ReportRunner.RunAllAsync()).ConfigureAwait(false);
-      await Task.Delay(TimeSpan.FromSeconds(5)).ConfigureAwait(false);
+      await Task.WhenAll(this.Metrics.ReportRunner.RunAllAsync());
+      await Task.Delay(TimeSpan.FromSeconds(5));
     }
   }
 }
diff --git a/src/PwrDrvr.LambdaDispatch.Router/Startup.cs b/src/PwrDrvr.LambdaDispatch.Router/Startup.cs
@@ -54,7 +54,7 @@ public void ConfigureServices(IServiceCollection services)
 #if !SKIP_METRICS
         if (_config.LogPeriodicMetrics)
         {
-            Task.Run(metricsRegistry.PrintMetrics).ConfigureAwait(false);
+            Task.Run(metricsRegistry.PrintMetrics);
         }
 #endif
     }
diff --git a/test/PwrDrvr.LambdaDispatch.Router.TestClient/Program.cs b/test/PwrDrvr.LambdaDispatch.Router.TestClient/Program.cs

Original file line number	Diff line number	Diff line change
`@@ -64,14 +64,14 @@ private static async Task Main()`
`64`	`64`
`65`	`65`	`_logger.LogDebug("Lambda Extension Registering");`
`66`	`66`	`// The Extension API will not return so we cannot await this`
`67`		`- await RegisterLambdaExtension().ConfigureAwait(false);`
	`67`	`+ await RegisterLambdaExtension();`
`68`	`68`	`_logger.LogDebug("Lambda Extension Registered");`
`69`	`69`
`70`	`70`	`if (!_staticResponse)`
`71`	`71`	`{`
`72`	`72`	`_logger.LogDebug("Contained App - Skipping Startup, Waiting for Healthy");`
`73`	`73`	`// Wait for the health endpoint to return OK`
`74`		`- await AwaitChildAppHealthy().ConfigureAwait(false);`
	`74`	`+ await AwaitChildAppHealthy();`
`75`	`75`	`_logger.LogInformation("Contained App - Healthy");`
`76`	`76`	`}`
`77`	`77`	`else`
`@@ -80,7 +80,7 @@ private static async Task Main()`
`80`	`80`	`}`
`81`	`81`	`#if !SKIP_METRICS`
`82`	`82`	`#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed`
`83`		`- Task.Run(() => MetricsRegistry.PrintMetrics(ctsShutdown.Token)).ConfigureAwait(false);`
	`83`	`+ Task.Run(() => MetricsRegistry.PrintMetrics(ctsShutdown.Token));`
`84`	`84`	`#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed`
`85`	`85`	`#endif`
`86`	`86`	`Func<WaiterRequest, ILambdaContext, Task<WaiterResponse>> handler = FunctionHandler;`
`@@ -133,14 +133,14 @@ private static async Task RegisterLambdaExtension()`
`133`	`133`	`var execName = Path.GetFileName(Process.GetCurrentProcess().MainModule?.FileName ?? "lambda-dispatch");`
`134`	`134`	`_logger.LogInformation("Registering Lambda Extension with name: {}", execName);`
`135`	`135`	`registerRequest.Headers.Add("Lambda-Extension-Name", execName);`
`136`		`- var registerResponse = await client.SendAsync(registerRequest).ConfigureAwait(false);`
	`136`	`+ var registerResponse = await client.SendAsync(registerRequest);`
`137`	`137`	`if (!registerResponse.IsSuccessStatusCode)`
`138`	`138`	`{`
`139`	`139`	`throw new Exception($"Failed to register extension: {registerResponse.StatusCode}");`
`140`	`140`	`}`
`141`	`141`	`var extensionId = registerResponse.Headers.GetValues("Lambda-Extension-Identifier").FirstOrDefault();`
`142`	`142`	`// Discard the response body`
`143`		`- await registerResponse.Content.CopyToAsync(Stream.Null).ConfigureAwait(false);`
	`143`	`+ await registerResponse.Content.CopyToAsync(Stream.Null);`
`144`	`144`	`if (string.IsNullOrEmpty(extensionId))`
`145`	`145`	`{`
`146`	`146`	`throw new Exception($"Failed to get extension id");`
`@@ -153,7 +153,7 @@ private static async Task RegisterLambdaExtension()`
`153`	`153`	`{`
`154`	`154`	`var nextEventRequest = new HttpRequestMessage(HttpMethod.Get, nextEventUrl);`
`155`	`155`	`nextEventRequest.Headers.Add("Lambda-Extension-Identifier", extensionId);`
`156`		`- var nextEventResponse = await client.SendAsync(nextEventRequest).ConfigureAwait(false);`
	`156`	`+ var nextEventResponse = await client.SendAsync(nextEventRequest);`
`157`	`157`	`if (!nextEventResponse.IsSuccessStatusCode)`
`158`	`158`	`{`
`159`	`159`	`throw new Exception($"Failed to get next event: {nextEventResponse.StatusCode}");`
`@@ -196,7 +196,7 @@ private static async Task AwaitChildAppHealthy()`
`196`	`196`	`{`
`197`	`197`	`try`
`198`	`198`	`{`
`199`		`- var response = await client.GetAsync(healthCheckUrl).ConfigureAwait(false);`
	`199`	`+ var response = await client.GetAsync(healthCheckUrl);`
`200`	`200`	`if (response.StatusCode == HttpStatusCode.OK)`
`201`	`201`	`{`
`202`	`202`	`_logger.LogInformation("Contained App - Got OK result");`
`@@ -209,7 +209,7 @@ private static async Task AwaitChildAppHealthy()`
`209`	`209`	`_logger.LogDebug("Contained App - Healthcheck failed");`
`210`	`210`	`}`
`211`	`211`
`212`		`- await Task.Delay(250).ConfigureAwait(false); // Wait for a second before polling again`
	`212`	`+ await Task.Delay(250); // Wait for a second before polling again`
`213`	`213`	`}`
`214`	`214`	`while (true);`
`215`	`215`
`@@ -302,7 +302,7 @@ public static async Task<WaiterResponse> FunctionHandler(WaiterRequest request,`
`302`	`302`	`_logger.LogDebug("Getting request from Router");`
`303`	`303`
`304`	`304`	`(var outerStatus, var receivedRequest, var requestForResponse, var requestStreamForResponse, var duplexContent)`
`305`		`- = await reverseRequester.GetRequest(channelId).ConfigureAwait(false);`
	`305`	`+ = await reverseRequester.GetRequest(channelId);`
`306`	`306`
`307`	`307`	`lastWakeupTime = DateTime.Now;`
`308`	`308`
`@@ -361,7 +361,7 @@ public static async Task<WaiterResponse> FunctionHandler(WaiterRequest request,`
`361`	`361`	`{`
`362`	`362`	`// Return after headers are received`
`363`	`363`	`_logger.LogDebug("Sending request to Contained App");`
`364`		`- using var response = await appHttpClient.SendAsync(receivedRequest, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false);`
	`364`	`+ using var response = await appHttpClient.SendAsync(receivedRequest, HttpCompletionOption.ResponseHeadersRead);`
`365`	`365`
`366`	`366`	`_logger.LogDebug("Got response from Contained App");`
`367`	`367`
`@@ -371,23 +371,23 @@ public static async Task<WaiterResponse> FunctionHandler(WaiterRequest request,`
`371`	`371`	`}`
`372`	`372`
`373`	`373`	`// Send the response back`
`374`		`- await reverseRequester.SendResponse(response, requestForResponse, requestStreamForResponse, duplexContent, channelId).ConfigureAwait(false);`
	`374`	`+ await reverseRequester.SendResponse(response, requestForResponse, requestStreamForResponse, duplexContent, channelId);`
`375`	`375`	`}`
`376`	`376`	`else`
`377`	`377`	`{`
`378`	`378`	`// NOTE: Static response is only for testing`
`379`	`379`	`// Read the bytes off the request body, if any`
`380`	`380`	`if (receivedRequest.Content != null)`
`381`	`381`	`{`
`382`		`- await receivedRequest.Content.CopyToAsync(Stream.Null).ConfigureAwait(false);`
	`382`	`+ await receivedRequest.Content.CopyToAsync(Stream.Null);`
`383`	`383`	`}`
`384`	`384`
`385`	`385`	`using var response = new HttpResponseMessage(System.Net.HttpStatusCode.OK)`
`386`	`386`	`{`
`387`	`387`	`Content = new StringContent($"Hello from LambdaLB")`
`388`	`388`	`};`
`389`	`389`
`390`		`- await reverseRequester.SendResponse(response, requestForResponse, requestStreamForResponse, duplexContent, channelId).ConfigureAwait(false);`
	`390`	`+ await reverseRequester.SendResponse(response, requestForResponse, requestStreamForResponse, duplexContent, channelId);`
`391`	`391`	`}`
`392`	`392`
`393`	`393`	`#if !SKIP_METRICS`
`@@ -407,7 +407,7 @@ public static async Task<WaiterResponse> FunctionHandler(WaiterRequest request,`
`407`	`407`	`{`
`408`	`408`	`Content = new StringContent(ex.Message)`
`409`	`409`	`};`
`410`		`- await reverseRequester.SendResponse(response, requestForResponse, requestStreamForResponse, duplexContent, channelId).ConfigureAwait(false);`
	`410`	`+ await reverseRequester.SendResponse(response, requestForResponse, requestStreamForResponse, duplexContent, channelId);`
`411`	`411`	`}`
`412`	`412`	`catch (Exception ex2)`
`413`	`413`	`{`
`@@ -517,7 +517,7 @@ public static async Task<WaiterResponse> FunctionHandler(WaiterRequest request,`
`517`	`517`	`{`
`518`	`518`	`try`
`519`	`519`	`{`
`520`		`- var completedTask = await Task.WhenAny(tcsShutdown.Task, Task.Delay(TimeSpan.FromSeconds(5), pingCts.Token)).ConfigureAwait(false);`
	`520`	`+ var completedTask = await Task.WhenAny(tcsShutdown.Task, Task.Delay(TimeSpan.FromSeconds(5), pingCts.Token));`
`521`	`521`
`522`	`522`	`if (completedTask == tcsShutdown.Task)`
`523`	`523`	`{`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ protected override async Task SerializeToStreamAsync(Stream stream, TransportCon`
`32`	`32`	`stream.Flush();`
`33`	`33`	`_waitForCompletion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);`
`34`	`34`	`_waitForStream.SetResult(stream);`
`35`		`- await _waitForCompletion.Task.ConfigureAwait(false);`
	`35`	`+ await _waitForCompletion.Task;`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`public Task<Stream> WaitForStreamAsync()`
Original file line number	Diff line number	Diff line change
`@@ -194,7 +194,7 @@ public async Task AddRequest(HttpRequest incomingRequest, HttpResponse incomingR`
`194`	`194`	`}`
`195`	`195`
`196`	`196`	`// TODO: If we want to cancel we need to pass a token in here`
`197`		`- runRequestResult = await lambdaConnection.RunRequest(incomingRequest, incomingResponse, accessLogProps, debugMode).ConfigureAwait(false);`
	`197`	`+ runRequestResult = await lambdaConnection.RunRequest(incomingRequest, incomingResponse, accessLogProps, debugMode);`
`198`	`198`	`accessLogProps.StatusCode = incomingResponse.StatusCode;`
`199`	`199`
`200`	`200`	`if (debugMode)`
`@@ -770,7 +770,7 @@ private bool TryBackgroundDispatchOne(PendingRequest pendingRequest, ILambdaConn`
`770`	`770`	`"-"`
`771`	`771`	`);`
`772`	`772`	`}`
`773`		`- }).ConfigureAwait(false);`
	`773`	`+ });`
`774`	`774`
`775`	`775`	`return startedRequest;`
`776`	`776`	`}`
Original file line number	Diff line number	Diff line change
`@@ -238,7 +238,7 @@ private async Task<long> ProxyRequestToLambda(HttpRequest incomingRequest, Acces`
`238`	`238`	`offset += 2;`
`239`	`239`
`240`	`240`	`// Send the headers to the Lambda`
`241`		`- await Response.BodyWriter.WriteAsync(headerBuffer.AsMemory(0, offset), CTS.Token).ConfigureAwait(false);`
	`241`	`+ await Response.BodyWriter.WriteAsync(headerBuffer.AsMemory(0, offset), CTS.Token);`
`242`	`242`
`243`	`243`	`if (debugMode)`
`244`	`244`	`{`
`@@ -353,14 +353,14 @@ private async Task<long> ProxyRequestToLambda(HttpRequest incomingRequest, Acces`
`353`	`353`	`ArrayPool<byte>.Shared.Return(bytes);`
`354`	`354`	`}`
`355`	`355`
`356`		`- await incomingRequest.BodyReader.CompleteAsync().ConfigureAwait(false);`
	`356`	`+ await incomingRequest.BodyReader.CompleteAsync();`
`357`	`357`
`358`	`358`	`_logger.LogDebug("Finished sending incoming request body to Lambda");`
`359`	`359`	`}`
`360`	`360`
`361`	`361`	`// Mark that the Request has been sent on the LambdaInstances`
`362`		`- await Response.BodyWriter.CompleteAsync().ConfigureAwait(false);`
`363`		`- await Response.CompleteAsync().ConfigureAwait(false);`
	`362`	`+ await Response.BodyWriter.CompleteAsync();`
	`363`	`+ await Response.CompleteAsync();`
`364`	`364`
`365`	`365`	`// Get the response from the lambda request and relay it back to the caller`
`366`	`366`	`_logger.LogDebug("Finished sending entire request to Lambda");`
`@@ -444,7 +444,7 @@ public async Task<RunRequestResult> RunRequest(HttpRequest incomingRequest, Http`
`444`	`444`	`// Wait for both to finish`
`445`	`445`	`// This allows us to continue sending request body while receiving`
`446`	`446`	`// and relaying the response body (duplex)`
`447`		`- var completedTask = await Task.WhenAny(proxyRequestTask, proxyResponseTask).ConfigureAwait(false);`
	`447`	`+ var completedTask = await Task.WhenAny(proxyRequestTask, proxyResponseTask);`
`448`	`448`	`if (completedTask.Exception != null)`
`449`	`449`	`{`
`450`	`450`	`_logger.LogError(completedTask.Exception, "{Method} {Url} {Protocol} {RemoteIP} {UserAgent} - {} Status - {} Bytes Received - {} Bytes Sent - RUNREQUEST - EXCEPTION",`
`@@ -464,14 +464,14 @@ public async Task<RunRequestResult> RunRequest(HttpRequest incomingRequest, Http`
`464`	`464`	`{`
`465`	`465`	`// ProxyRequestToLambda finished first`
`466`	`466`	`// Wait for RelayResponseFromLambda to finish`
`467`		`- totalBytesWritten = await proxyResponseTask.ConfigureAwait(false);`
	`467`	`+ totalBytesWritten = await proxyResponseTask;`
`468`	`468`	`totalBytesRead = completedTask.Result;`
`469`	`469`	`}`
`470`	`470`	`else`
`471`	`471`	`{`
`472`	`472`	`// RelayResponseFromLambda finished first`
`473`	`473`	`// Wait for ProxyRequestToLambda to finish`
`474`		`- totalBytesRead = await proxyRequestTask.ConfigureAwait(false);`
	`474`	`+ totalBytesRead = await proxyRequestTask;`
`475`	`475`	`totalBytesWritten = completedTask.Result;`
`476`	`476`	`}`
`477`	`477`	`}`
`@@ -555,7 +555,7 @@ public async Task<RunRequestResult> RunRequest(HttpRequest incomingRequest, Http`
`555`	`555`
`556`	`556`	`try`
`557`	`557`	`{`
`558`		`- await incomingResponse.CompleteAsync().ConfigureAwait(false);`
	`558`	`+ await incomingResponse.CompleteAsync();`
`559`	`559`	`}`
`560`	`560`	`catch { }`
`561`	`561`
`@@ -595,7 +595,7 @@ private async Task<long> RelayResponseFromLambda(HttpResponse incomingResponse,`
`595`	`595`	`break;`
`596`	`596`	`}`
`597`	`597`
`598`		`- var bytesRead = await Request.Body.ReadAsync(headerBuffer.AsMemory(totalBytesRead, headerBuffer.Length - totalBytesRead), CTS.Token).ConfigureAwait(false);`
	`598`	`+ var bytesRead = await Request.Body.ReadAsync(headerBuffer.AsMemory(totalBytesRead, headerBuffer.Length - totalBytesRead), CTS.Token);`
`599`	`599`	`if (bytesRead == 0)`
`600`	`600`	`{`
`601`	`601`	`// Done reading`
`@@ -734,7 +734,7 @@ private async Task<long> RelayResponseFromLambda(HttpResponse incomingResponse,`
`734`	`734`	`// There are bytes left in the buffer`
`735`	`735`	`// Copy them to the response`
`736`	`736`	`totalBodyBytesRead += totalBytesRead - startOfNextLine;`
`737`		`- await incomingResponse.BodyWriter.WriteAsync(headerBuffer.AsMemory(startOfNextLine, totalBytesRead - startOfNextLine), CTS.Token).ConfigureAwait(false);`
	`737`	`+ await incomingResponse.BodyWriter.WriteAsync(headerBuffer.AsMemory(startOfNextLine, totalBytesRead - startOfNextLine), CTS.Token);`
`738`	`738`	`totalBodyBytesWritten += totalBytesRead - startOfNextLine;`
`739`	`739`	`}`
`740`	`740`	`}`
`@@ -785,7 +785,7 @@ private async Task<long> RelayResponseFromLambda(HttpResponse incomingResponse,`
`785`	`785`	`{`
`786`	`786`	`try`
`787`	`787`	`{`
`788`		`- bytesRead = await responseStream.ReadAsync(bytes, CTS.Token).ConfigureAwait(false);`
	`788`	`+ bytesRead = await responseStream.ReadAsync(bytes, CTS.Token);`
`789`	`789`	`}`
`790`	`790`	`catch (Exception ex)`
`791`	`791`	`{`
`@@ -809,7 +809,7 @@ private async Task<long> RelayResponseFromLambda(HttpResponse incomingResponse,`
`809`	`809`
`810`	`810`	`try`
`811`	`811`	`{`
`812`		`- await incomingResponse.Body.WriteAsync(bytes.AsMemory(0, bytesRead), CTS.Token).ConfigureAwait(false);`
	`812`	`+ await incomingResponse.Body.WriteAsync(bytes.AsMemory(0, bytesRead), CTS.Token);`
`813`	`813`	`totalBodyBytesWritten += bytesRead;`
`814`	`814`	`}`
`815`	`815`	`catch (Exception ex)`
Original file line number	Diff line number	Diff line change
`@@ -204,7 +204,7 @@ public async Task<AddConnectionResult> AddConnectionForLambda(HttpRequest reques`
`204`	`204`	`{`
`205`	`205`	`// Add the connection to the instance`
`206`	`206`	`// The instance will eventually get rebalanced in the least outstanding queue`
`207`		`- var result = await instance.AddConnection(request, response, channelId, dispatchMode).ConfigureAwait(false);`
	`207`	`+ var result = await instance.AddConnection(request, response, channelId, dispatchMode);`
`208`	`208`
`209`	`209`	`if (result.WasRejected \|\| result.Connection == null)`
`210`	`210`	`{`
Original file line number	Diff line number	Diff line change
`@@ -392,7 +392,7 @@ private async Task RebalanceQueue()`
`392`	`392`	`// Wait for a short period before checking again`
`393`	`393`	`try`
`394`	`394`	`{`
`395`		`- await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationTokenSource.Token).ConfigureAwait(false);`
	`395`	`+ await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationTokenSource.Token);`
`396`	`396`	`}`
`397`	`397`	`catch (TaskCanceledException)`
`398`	`398`	`{`
`@@ -443,7 +443,7 @@ private async Task LogQueueSizes()`
`443`	`443`	`// Wait a bit`
`444`	`444`	`try`
`445`	`445`	`{`
`446`		`- await Task.Delay(TimeSpan.FromSeconds(10), cancellationTokenSource.Token).ConfigureAwait(false);`
	`446`	`+ await Task.Delay(TimeSpan.FromSeconds(10), cancellationTokenSource.Token);`
`447`	`447`	`}`
`448`	`448`	`catch (TaskCanceledException)`
`449`	`449`	`{`
Original file line number	Diff line number	Diff line change
`@@ -297,8 +297,8 @@ public async Task PrintMetrics()`
`297`	`297`	`{`
`298`	`298`	`while (true)`
`299`	`299`	`{`
`300`		`- await Task.WhenAll(this.Metrics.ReportRunner.RunAllAsync()).ConfigureAwait(false);`
`301`		`- await Task.Delay(TimeSpan.FromSeconds(5)).ConfigureAwait(false);`
	`300`	`+ await Task.WhenAll(this.Metrics.ReportRunner.RunAllAsync());`
	`301`	`+ await Task.Delay(TimeSpan.FromSeconds(5));`
`302`	`302`	`}`
`303`	`303`	`}`
`304`	`304`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ public void ConfigureServices(IServiceCollection services)`
`54`	`54`	`#if !SKIP_METRICS`
`55`	`55`	`if (_config.LogPeriodicMetrics)`
`56`	`56`	`{`
`57`		`- Task.Run(metricsRegistry.PrintMetrics).ConfigureAwait(false);`
	`57`	`+ Task.Run(metricsRegistry.PrintMetrics);`
`58`	`58`	`}`
`59`	`59`	`#endif`
`60`	`60`	`}`