Log error when exception occurs during streaming (#42283)

Author: campersau

src/SignalR/server/Core/src/Internal/DefaultHubDispatcher.cs

@@ -474,13 +474,15 @@ private async Task StreamAsync(string invocationId, HubConnectionContext connect
         catch (ChannelClosedException ex)
         {
             // If the channel closes from an exception in the streaming method, grab the innerException for the error from the streaming method
+            Log.FailedStreaming(_logger, invocationId, descriptor.MethodExecutor.MethodInfo.Name, ex.InnerException ?? ex);
             error = ErrorMessageHelper.BuildErrorMessage("An error occurred on the server while streaming results.", ex.InnerException ?? ex, _enableDetailedErrors);
         }
         catch (Exception ex)
         {
             // If the streaming method was canceled we don't want to send a HubException message - this is not an error case
             if (!(ex is OperationCanceledException && streamCts.IsCancellationRequested))
             {
+                Log.FailedStreaming(_logger, invocationId, descriptor.MethodExecutor.MethodInfo.Name, ex);
                 error = ErrorMessageHelper.BuildErrorMessage("An error occurred on the server while streaming results.", ex, _enableDetailedErrors);
             }
         }

src/SignalR/server/Core/src/Internal/DefaultHubDispatcherLog.cs

@@ -105,4 +105,7 @@ public static void ClosingStreamWithBindingError(ILogger logger, CompletionMessa
 
     [LoggerMessage(24, LogLevel.Debug, "CompletionMessage for invocation ID '{InvocationId}' received unexpectedly.", EventName = "UnexpectedCompletion")]
     public static partial void UnexpectedCompletion(ILogger logger, string invocationId);
+
+    [LoggerMessage(25, LogLevel.Error, "Invocation ID {InvocationId}: Failed while sending stream items from hub method {HubMethod}.", EventName = "FailedStreaming")]
+    public static partial void FailedStreaming(ILogger logger, string invocationId, string hubMethod, Exception exception);
 }

src/SignalR/server/SignalR/test/HubConnectionHandlerTestUtils/Hubs.cs

@@ -691,6 +691,15 @@ public async IAsyncEnumerable<string> CounterAsyncEnumerable(int count)
         }
     }
 
+    public async IAsyncEnumerable<string> ExceptionAsyncEnumerable()
+    {
+        await Task.Yield();
+        throw new Exception("Exception from async enumerable");
+#pragma warning disable CS0162 // Unreachable code detected
+        yield break;
+#pragma warning restore CS0162 // Unreachable code detected
+    }
+
     public async Task<IAsyncEnumerable<string>> CounterAsyncEnumerableAsync(int count)
     {
         await Task.Yield();
@@ -719,6 +728,20 @@ public ChannelReader<int> ExceptionStream()
         return channel.Reader;
     }
 
+    public ChannelReader<int> ChannelClosedExceptionStream()
+    {
+        var channel = Channel.CreateUnbounded<int>();
+        channel.Writer.TryComplete(new ChannelClosedException("ChannelClosedException from channel"));
+        return channel.Reader;
+    }
+
+    public ChannelReader<int> ChannelClosedExceptionInnerExceptionStream()
+    {
+        var channel = Channel.CreateUnbounded<int>();
+        channel.Writer.TryComplete(new ChannelClosedException(new Exception("ChannelClosedException from channel")));
+        return channel.Reader;
+    }
+
     public ChannelReader<int> ThrowStream()
     {
         throw new Exception("Throw from hub method");

src/SignalR/server/SignalR/test/HubConnectionHandlerTests.cs

@@ -2066,16 +2066,28 @@ public async Task NonErrorCompletionSentWhenStreamCanceledFromClient()
     }
 
     [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public async Task ReceiveCorrectErrorFromStreamThrowing(bool detailedErrors)
+    [InlineData(nameof(StreamingHub.ExceptionAsyncEnumerable), "Exception: Exception from async enumerable")]
+    [InlineData(nameof(StreamingHub.ExceptionAsyncEnumerable), null)]
+    [InlineData(nameof(StreamingHub.ExceptionStream), "Exception: Exception from channel")]
+    [InlineData(nameof(StreamingHub.ExceptionStream), null)]
+    [InlineData(nameof(StreamingHub.ChannelClosedExceptionStream), "ChannelClosedException: ChannelClosedException from channel")]
+    [InlineData(nameof(StreamingHub.ChannelClosedExceptionStream), null)]
+    [InlineData(nameof(StreamingHub.ChannelClosedExceptionInnerExceptionStream), "Exception: ChannelClosedException from channel")]
+    [InlineData(nameof(StreamingHub.ChannelClosedExceptionInnerExceptionStream), null)]
+    public async Task ReceiveCorrectErrorFromStreamThrowing(string streamMethod, string detailedError)
     {
-        using (StartVerifiableLog())
+        bool ExpectedErrors(WriteContext writeContext)
+        {
+            return writeContext.LoggerName == "Microsoft.AspNetCore.SignalR.Internal.DefaultHubDispatcher" &&
+                   writeContext.EventId.Name == "FailedStreaming";
+        }
+
+        using (StartVerifiableLog(ExpectedErrors))
         {
             var serviceProvider = HubConnectionHandlerTestUtils.CreateServiceProvider(builder =>
             builder.AddSignalR(options =>
             {
-                options.EnableDetailedErrors = detailedErrors;
+                options.EnableDetailedErrors = detailedError != null;
             }), LoggerFactory);
             var connectionHandler = serviceProvider.GetService<HubConnectionHandler<StreamingHub>>();
 
@@ -2085,14 +2097,14 @@ public async Task ReceiveCorrectErrorFromStreamThrowing(bool detailedErrors)
 
                 await client.Connected.DefaultTimeout();
 
-                var messages = await client.StreamAsync(nameof(StreamingHub.ExceptionStream));
+                var messages = await client.StreamAsync(streamMethod);
 
                 Assert.Equal(1, messages.Count);
                 var completion = messages[0] as CompletionMessage;
                 Assert.NotNull(completion);
-                if (detailedErrors)
+                if (detailedError != null)
                 {
-                    Assert.Equal("An error occurred on the server while streaming results. Exception: Exception from channel", completion.Error);
+                    Assert.Equal($"An error occurred on the server while streaming results. {detailedError}", completion.Error);
                 }
                 else
                 {