Update

Author: JamesNK

src/Grpc.Net.Client/Internal/GrpcCall.cs

@@ -639,7 +639,7 @@ private async Task RunCall(HttpRequestMessage request, TimeSpan? timeout)
                 if (_responseTcs != null)
                 {
                     _responseTcs.TrySetException(resolvedException);
-                    
+
                     // Always observe cancellation-like exceptions.
                     if (IsCancellationOrDeadlineException(ex))
                     {

src/Grpc.Net.Client/Internal/Retry/HedgingCall.cs

@@ -202,10 +202,16 @@ private async Task StartCall(Action<GrpcCall<TRequest, TResponse>> startCallFunc
         {
             if (CommitedCallTask.IsCompletedSuccessfully() && CommitedCallTask.Result == call)
             {
+                // Ensure response task is created before waiting to the end.
+                // Allows cancellation exceptions to be observed in cleanup.
+                _ = GetResponseAsync();
+
                 // Wait until the commited call is finished and then clean up hedging call.
                 // Force yield here to prevent continuation running with any locks.
-                await CompatibilityHelpers.AwaitWithYieldAsync(call.CallTask).ConfigureAwait(false);
-                Cleanup();
+                var status = await CompatibilityHelpers.AwaitWithYieldAsync(call.CallTask).ConfigureAwait(false);
+
+                var observeExceptions = status.StatusCode is StatusCode.Cancelled or StatusCode.DeadlineExceeded;
+                Cleanup(observeExceptions);
             }
         }
     }

src/Grpc.Net.Client/Internal/Retry/RetryCall.cs

@@ -252,10 +252,16 @@ private async Task StartRetry(Action<GrpcCall<TRequest, TResponse>> startCallFun
             {
                 if (CommitedCallTask.Result is GrpcCall<TRequest, TResponse> call)
                 {
+                    // Ensure response task is created before waiting to the end.
+                    // Allows cancellation exceptions to be observed in cleanup.
+                    _ = GetResponseAsync();
+
                     // Wait until the commited call is finished and then clean up retry call.
                     // Force yield here to prevent continuation running with any locks.
-                    await CompatibilityHelpers.AwaitWithYieldAsync(call.CallTask).ConfigureAwait(false);
-                    Cleanup();
+                    var status = await CompatibilityHelpers.AwaitWithYieldAsync(call.CallTask).ConfigureAwait(false);
+
+                    var observeExceptions = status.StatusCode is StatusCode.Cancelled or StatusCode.DeadlineExceeded;
+                    Cleanup(observeExceptions);
                 }
             }
 

src/Grpc.Net.Client/Internal/Retry/RetryCallBase.cs

@@ -130,6 +130,11 @@ public Task<Metadata> GetResponseHeadersAsync()
             // ResponseHeadersAsync could be called inside a client interceptor when a call is wrapped.
             // Most people won't use the headers result. Observed exception to avoid unobserved exception event.
             _responseHeadersTask.ObserveException();
+
+            // If there was an error fetching response headers then it's likely the same error is reported
+            // by response TCS. The user is unlikely to observe both errors.
+            // Observed exception to avoid unobserved exception event.
+            _responseTask?.ObserveException();
         }
 
         return _responseHeadersTask;
@@ -387,7 +392,7 @@ protected void CommitCall(IGrpcCall<TRequest, TResponse> call, CommitReason comm
                 // A commited call that has already cleaned up is likely a StatusGrpcCall.
                 if (call.Disposed)
                 {
-                    Cleanup();
+                    Cleanup(observeExceptions: false);
                 }
             }
         }
@@ -449,19 +454,16 @@ protected virtual void Dispose(bool disposing)
 
         if (disposing)
         {
-            _responseTask?.ObserveException();
-            _responseHeadersTask?.ObserveException();
-
             if (CommitedCallTask.IsCompletedSuccessfully())
             {
                 CommitedCallTask.Result.Dispose();
             }
 
-            Cleanup();
+            Cleanup(observeExceptions: true);
         }
     }
 
-    protected void Cleanup()
+    protected void Cleanup(bool observeExceptions)
     {
         Channel.FinishActiveCall(this);
 
@@ -470,6 +472,12 @@ protected void Cleanup()
         CancellationTokenSource.Cancel();
 
         ClearRetryBuffer();
+
+        if (observeExceptions)
+        {
+            _responseTask?.ObserveException();
+            _responseHeadersTask?.ObserveException();
+        }
     }
 
     internal bool TryAddToRetryBuffer(ReadOnlyMemory<byte> message)

test/Grpc.Net.Client.Tests/Retry/RetryTests.cs

@@ -1072,14 +1072,35 @@ public enum ResponseHandleAction
         Nothing
     }
 
-    [Test]
-    //[TestCase(0, false, ResponseHandleAction.ResponseAsync)]
-    //[TestCase(0, true, ResponseHandleAction.ResponseAsync)]
-    [TestCase(0, false, ResponseHandleAction.ResponseHeadersAsync)]
-    //[TestCase(0, false, ResponseHandleAction.Dispose)]
-    //[TestCase(1, false, ResponseHandleAction.Nothing)]
-    public async Task AsyncUnaryCall_CallFailed_NoUnobservedExceptions(int expectedUnobservedExceptions, bool addClientInterceptor, ResponseHandleAction action)
+    public static object[] NoUnobservedExceptionsCases
+    {
+        get
+        {
+            var cases = new List<object[]>();
+            AddCases(0, addClientInterceptor: false, throwCancellationError: false, ResponseHandleAction.ResponseAsync);
+            AddCases(0, addClientInterceptor: true, throwCancellationError: false, ResponseHandleAction.ResponseAsync);
+            AddCases(0, addClientInterceptor: false, throwCancellationError: false, ResponseHandleAction.ResponseHeadersAsync);
+            AddCases(0, addClientInterceptor: false, throwCancellationError: false, ResponseHandleAction.Dispose);
+            AddCases(1, addClientInterceptor: false, throwCancellationError: false, ResponseHandleAction.Nothing);
+            AddCases(0, addClientInterceptor: false, throwCancellationError: true, ResponseHandleAction.Nothing);
+            return cases.ToArray();
+
+            void AddCases(int expectedUnobservedExceptions, bool addClientInterceptor, bool throwCancellationError, ResponseHandleAction action)
+            {
+                cases.Add(new object[] { expectedUnobservedExceptions, true, addClientInterceptor, throwCancellationError, action });
+                cases.Add(new object[] { expectedUnobservedExceptions, false, addClientInterceptor, throwCancellationError, action });
+            }
+        }
+    }
+
+    [TestCaseSource(nameof(NoUnobservedExceptionsCases))]
+    public async Task AsyncUnaryCall_CallFailed_NoUnobservedExceptions(int expectedUnobservedExceptions, bool isAsync, bool addClientInterceptor, bool throwCancellationError, ResponseHandleAction action)
     {
+        // Provoke the garbage collector to find the unobserved exception.
+        GC.Collect();
+        // Wait for any failed tasks to be garbage collected
+        GC.WaitForPendingFinalizers();
+
         // Arrange
         var services = new ServiceCollection();
         services.AddNUnitLogger();
@@ -1099,9 +1120,20 @@ public async Task AsyncUnaryCall_CallFailed_NoUnobservedExceptions(int expectedU
 
         try
         {
-            var httpClient = ClientTestHelpers.CreateTestClient(request =>
+            var httpClient = ClientTestHelpers.CreateTestClient(async request =>
             {
-                throw new Exception("Test error");
+                if (isAsync)
+                {
+                    await Task.Delay(50);
+                }
+                if (throwCancellationError)
+                {
+                    throw new OperationCanceledException();
+                }
+                else
+                {
+                    throw new Exception("Test error");
+                }
             });
             var serviceConfig = ServiceConfigHelpers.CreateRetryServiceConfig();
             CallInvoker invoker = HttpClientCallInvokerFactory.Create(httpClient, loggerFactory: loggerFactory, serviceConfig: serviceConfig);
@@ -1112,32 +1144,28 @@ public async Task AsyncUnaryCall_CallFailed_NoUnobservedExceptions(int expectedU
 
             // Act
             logger.LogDebug("Starting call");
-            var awaitedException = await MakeGrpcCallAsync(logger, invoker, action);
+            await MakeGrpcCallAsync(logger, invoker, action);
 
             logger.LogDebug("Waiting for finalizers");
-            // Provoke the garbage collector to find the unobserved exception.
-            GC.Collect();
-            // Wait for any failed tasks to be garbage collected
-            GC.WaitForPendingFinalizers();
+            for (var i = 0; i < 5; i++)
+            {
+                // Provoke the garbage collector to find the unobserved exception.
+                GC.Collect();
+                // Wait for any failed tasks to be garbage collected
+                GC.WaitForPendingFinalizers();
+
+                await Task.Delay(10);
+            }
 
             foreach (var exception in unobservedExceptions)
             {
                 logger.LogCritical(exception, "Unobserved task exception");
             }
 
             // Assert
-            try
-            {
-                Assert.AreEqual(expectedUnobservedExceptions, unobservedExceptions.Count);
-                logger.LogDebug("Expected number of observed exceptions");
-            }
-            catch
-            {
-                Assert.AreSame(unobservedExceptions.Single().InnerException, awaitedException);
-                logger.LogDebug("Observed exception was awaited by the test");
-            }
+            Assert.AreEqual(expectedUnobservedExceptions, unobservedExceptions.Count);
 
-            static async Task<Exception?> MakeGrpcCallAsync(ILogger logger, CallInvoker invoker, ResponseHandleAction action)
+            static async Task MakeGrpcCallAsync(ILogger logger, CallInvoker invoker, ResponseHandleAction action)
             {
                 var runTask = Task.Run(async () =>
                 {
@@ -1146,21 +1174,23 @@ public async Task AsyncUnaryCall_CallFailed_NoUnobservedExceptions(int expectedU
                     switch (action)
                     {
                         case ResponseHandleAction.ResponseAsync:
-                            return await ExceptionAssert.ThrowsAsync<RpcException>(() => call.ResponseAsync);
+                            await ExceptionAssert.ThrowsAsync<RpcException>(() => call.ResponseAsync);
+                            break;
                         case ResponseHandleAction.ResponseHeadersAsync:
-                            return await ExceptionAssert.ThrowsAsync<RpcException>(() => call.ResponseHeadersAsync);
+                            await ExceptionAssert.ThrowsAsync<RpcException>(() => call.ResponseHeadersAsync);
+                            break;
                         case ResponseHandleAction.Dispose:
                             await WaitForCallCompleteAsync(logger, call);
                             call.Dispose();
-                            return null;
+                            break;
                         default:
                             // Do nothing (but wait until call is finished)
                             await WaitForCallCompleteAsync(logger, call);
-                            return null;
+                            break;
                     }
                 });
 
-                return await runTask;
+                await runTask;
             }
         }
         finally