Add option to exception handler middleware to not log error

JamesNK · JamesNK · commit 756cde2ebd58 · 2025-05-27T11:41:29.000+08:00
diff --git a/src/Middleware/Diagnostics/src/DeveloperExceptionPage/DeveloperExceptionPageMiddlewareImpl.cs b/src/Middleware/Diagnostics/src/DeveloperExceptionPage/DeveloperExceptionPageMiddlewareImpl.cs
@@ -115,6 +115,8 @@ public async Task Invoke(HttpContext context)
         }
         catch (Exception ex)
         {
+            DiagnosticsTelemetry.AddMetricsTags(context, ex);
+
             var exceptionName = ex.GetType().FullName!;
 
             if ((ex is OperationCanceledException || ex is IOException) && context.RequestAborted.IsCancellationRequested)
@@ -135,7 +137,7 @@ public async Task Invoke(HttpContext context)
                 return;
             }
 
-            DiagnosticsTelemetry.ReportUnhandledException(_logger, context, ex);
+            _logger.UnhandledException(ex);
 
             if (context.Response.HasStarted)
             {
diff --git a/src/Middleware/Diagnostics/src/DiagnosticsTelemetry.cs b/src/Middleware/Diagnostics/src/DiagnosticsTelemetry.cs
@@ -3,16 +3,13 @@
 
 using Microsoft.AspNetCore.Http.Features;
 using Microsoft.AspNetCore.Http;
-using Microsoft.Extensions.Logging;
 
 namespace Microsoft.AspNetCore.Diagnostics;
 
 internal static class DiagnosticsTelemetry
 {
-    public static void ReportUnhandledException(ILogger logger, HttpContext context, Exception ex)
+    public static void AddMetricsTags(HttpContext context, Exception ex)
     {
-        logger.UnhandledException(ex);
-
         if (context.Features.Get<IHttpMetricsTagsFeature>() is { } tagsFeature)
         {
             // Multiple exception middleware could be registered that have already added the tag.
diff --git a/src/Middleware/Diagnostics/src/ExceptionHandler/ExceptionHandlerMiddlewareImpl.cs b/src/Middleware/Diagnostics/src/ExceptionHandler/ExceptionHandlerMiddlewareImpl.cs
@@ -112,10 +112,13 @@ static async Task Awaited(ExceptionHandlerMiddlewareImpl middleware, HttpContext
 
     private async Task HandleException(HttpContext context, ExceptionDispatchInfo edi)
     {
+        DiagnosticsTelemetry.AddMetricsTags(context, edi.SourceException);
+
         var exceptionName = edi.SourceException.GetType().FullName!;
 
         if ((edi.SourceException is OperationCanceledException || edi.SourceException is IOException) && context.RequestAborted.IsCancellationRequested)
         {
+            // Don't log unhandled exception for aborted request.
             _logger.RequestAbortedException();
 
             if (!context.Response.HasStarted)
@@ -127,11 +130,10 @@ private async Task HandleException(HttpContext context, ExceptionDispatchInfo ed
             return;
         }
 
-        DiagnosticsTelemetry.ReportUnhandledException(_logger, context, edi.SourceException);
-
         // We can't do anything if the response has already started, just abort.
         if (context.Response.HasStarted)
         {
+            _logger.UnhandledException(edi.SourceException);
             _logger.ResponseStartedErrorHandler();
 
             _metrics.RequestException(exceptionName, ExceptionResult.Skipped, handler: null);
@@ -168,52 +170,73 @@ private async Task HandleException(HttpContext context, ExceptionDispatchInfo ed
             context.Response.StatusCode = _options.StatusCodeSelector?.Invoke(edi.SourceException) ?? DefaultStatusCode;
             context.Response.OnStarting(_clearCacheHeadersDelegate, context.Response);
 
-            string? handler = null;
-            var handled = false;
+            string? handlerTag = null;
+            var handler = Handler.None;
             foreach (var exceptionHandler in _exceptionHandlers)
             {
-                handled = await exceptionHandler.TryHandleAsync(context, edi.SourceException, context.RequestAborted);
-                if (handled)
+                if (await exceptionHandler.TryHandleAsync(context, edi.SourceException, context.RequestAborted))
                 {
-                    handler = exceptionHandler.GetType().FullName;
+                    handler = Handler.IExceptionHandler;
+                    handlerTag = exceptionHandler.GetType().FullName;
                     break;
                 }
             }
 
-            if (!handled)
+            if (handler == Handler.None)
             {
                 if (_options.ExceptionHandler is not null)
                 {
                     await _options.ExceptionHandler!(context);
+
+                    // If the response has started, assume exception handler was successful.
+                    if (context.Response.HasStarted)
+                    {
+                        handler = Handler.ExceptionHandler;
+                        if (_options.ExceptionHandlingPath.HasValue)
+                        {
+                            handlerTag = _options.ExceptionHandlingPath.Value;
+                        }
+                    }
                 }
                 else
                 {
-                    handled = await _problemDetailsService!.TryWriteAsync(new()
+                    if (await _problemDetailsService!.TryWriteAsync(new()
                     {
                         HttpContext = context,
                         AdditionalMetadata = exceptionHandlerFeature.Endpoint?.Metadata,
                         ProblemDetails = { Status = context.Response.StatusCode },
                         Exception = edi.SourceException,
-                    });
-                    if (handled)
+                    }))
                     {
-                        handler = _problemDetailsService.GetType().FullName;
+                        handler = Handler.IProblemDetailsService;
+                        handlerTag = _problemDetailsService.GetType().FullName;
                     }
                 }
             }
-            // If the response has already started, assume exception handler was successful.
-            if (context.Response.HasStarted || handled || _options.StatusCodeSelector != null || context.Response.StatusCode != StatusCodes.Status404NotFound || _options.AllowStatusCode404Response)
+
+            if (handler != Handler.None || _options.StatusCodeSelector != null || context.Response.StatusCode != StatusCodes.Status404NotFound || _options.AllowStatusCode404Response)
             {
-                const string eventName = "Microsoft.AspNetCore.Diagnostics.HandledException";
-                if (_diagnosticListener.IsEnabled() && _diagnosticListener.IsEnabled(eventName))
+                // Customers with an IExceptionHandler that reports it handled the exception could do their own logging.
+                // Don't log IExceptionHandler handled exceptions if SuppressLoggingIExceptionHandler is set to true.
+                // Note: Microsoft.AspNetCore.Diagnostics.HandledException is used by AppInsights to log errors so it's also skipped.
+                if (handler != Handler.IExceptionHandler || !_options.SuppressLoggingIExceptionHandler)
                 {
-                    WriteDiagnosticEvent(_diagnosticListener, eventName, new { httpContext = context, exception = edi.SourceException });
+                    const string eventName = "Microsoft.AspNetCore.Diagnostics.HandledException";
+                    if (_diagnosticListener.IsEnabled() && _diagnosticListener.IsEnabled(eventName))
+                    {
+                        WriteDiagnosticEvent(_diagnosticListener, eventName, new { httpContext = context, exception = edi.SourceException });
+                    }
+
+                    _logger.UnhandledException(edi.SourceException);
                 }
 
-                _metrics.RequestException(exceptionName, ExceptionResult.Handled, handler);
+                _metrics.RequestException(exceptionName, ExceptionResult.Handled, handlerTag);
                 return;
             }
 
+            // Log original unhandled exception before it is wrapped.
+            _logger.UnhandledException(edi.SourceException);
+
             edi = ExceptionDispatchInfo.Capture(new InvalidOperationException($"The exception handler configured on {nameof(ExceptionHandlerOptions)} produced a 404 status response. " +
                 $"This {nameof(InvalidOperationException)} containing the original exception was thrown since this is often due to a misconfigured {nameof(ExceptionHandlerOptions.ExceptionHandlingPath)}. " +
                 $"If the exception handler is expected to return 404 status responses then set {nameof(ExceptionHandlerOptions.AllowStatusCode404Response)} to true.", edi.SourceException));
@@ -222,6 +245,9 @@ private async Task HandleException(HttpContext context, ExceptionDispatchInfo ed
         {
             // Suppress secondary exceptions, re-throw the original.
             _logger.ErrorHandlerException(ex2);
+
+            // There was an error handling the exception. Log original unhandled exception.
+            _logger.UnhandledException(edi.SourceException);
         }
         finally
         {
@@ -259,4 +285,12 @@ private static Task ClearCacheHeaders(object state)
         headers.ETag = default;
         return Task.CompletedTask;
     }
+
+    private enum Handler
+    {
+        None,
+        IExceptionHandler,
+        IProblemDetailsService,
+        ExceptionHandler
+    }
 }
diff --git a/src/Middleware/Diagnostics/src/ExceptionHandler/ExceptionHandlerOptions.cs b/src/Middleware/Diagnostics/src/ExceptionHandler/ExceptionHandlerOptions.cs
@@ -40,10 +40,16 @@ public class ExceptionHandlerOptions
     public bool AllowStatusCode404Response { get; set; }
 
     /// <summary>
-    /// Gets or sets a delegate used to map an exception to a http status code.
+    /// Gets or sets a delegate used to map an exception to an HTTP status code.
     /// </summary>
     /// <remarks>
     /// If <see cref="StatusCodeSelector"/> is <c>null</c>, the default exception status code 500 is used.
     /// </remarks>
     public Func<Exception, int>? StatusCodeSelector { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value that determines if the exception handler middleware should suppress logging
+    /// if the exception was handled by a <see cref="IExceptionHandler"/> registered in the DI container.
+    /// </summary>
+    public bool SuppressLoggingIExceptionHandler { get; set; }
 }
diff --git a/src/Middleware/Diagnostics/src/PublicAPI.Unshipped.txt b/src/Middleware/Diagnostics/src/PublicAPI.Unshipped.txt
@@ -1,4 +1,6 @@
 #nullable enable
 Microsoft.AspNetCore.Builder.StatusCodePagesOptions.CreateScopeForErrors.get -> bool
 Microsoft.AspNetCore.Builder.StatusCodePagesOptions.CreateScopeForErrors.set -> void
-static Microsoft.AspNetCore.Builder.StatusCodePagesExtensions.UseStatusCodePagesWithReExecute(this Microsoft.AspNetCore.Builder.IApplicationBuilder! app, string! pathFormat, bool createScopeForErrors, string? queryFormat = null) -> Microsoft.AspNetCore.Builder.IApplicationBuilder!
+static Microsoft.AspNetCore.Builder.StatusCodePagesExtensions.UseStatusCodePagesWithReExecute(this Microsoft.AspNetCore.Builder.IApplicationBuilder! app, string! pathFormat, bool createScopeForErrors, string? queryFormat = null) -> Microsoft.AspNetCore.Builder.IApplicationBuilder!
+Microsoft.AspNetCore.Builder.ExceptionHandlerOptions.SuppressLoggingIExceptionHandler.get -> bool
+Microsoft.AspNetCore.Builder.ExceptionHandlerOptions.SuppressLoggingIExceptionHandler.set -> void
diff --git a/src/Middleware/Diagnostics/test/UnitTests/ExceptionHandlerMiddlewareTest.cs b/src/Middleware/Diagnostics/test/UnitTests/ExceptionHandlerMiddlewareTest.cs
@@ -22,6 +22,7 @@
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Logging.Testing;
 using Microsoft.Extensions.Options;
 using Moq;
 
@@ -81,6 +82,7 @@ public async Task ExceptionIsSetOnProblemDetailsContext()
     public async Task Invoke_ExceptionThrownResultsInClearedRouteValuesAndEndpoint()
     {
         // Arrange
+        var sink = new TestSink();
         var httpContext = CreateHttpContext();
         httpContext.SetEndpoint(new Endpoint((_) => Task.CompletedTask, new EndpointMetadataCollection(), "Test"));
         httpContext.Request.RouteValues["John"] = "Doe";
@@ -92,10 +94,39 @@ public async Task Invoke_ExceptionThrownResultsInClearedRouteValuesAndEndpoint()
                 Assert.Null(context.GetEndpoint());
                 return Task.CompletedTask;
             });
-        var middleware = CreateMiddleware(_ => throw new InvalidOperationException(), optionsAccessor);
+        var middleware = CreateMiddleware(_ => throw new InvalidOperationException(), optionsAccessor, loggerFactory: new TestLoggerFactory(sink, true));
 
         // Act & Assert
         await middleware.Invoke(httpContext);
+
+        Assert.Collection(sink.Writes, w => Assert.Equal("UnhandledException", w.EventId.Name));
+    }
+
+    [Fact]
+    public async Task Invoke_HasExceptionHandler_SuppressIExceptionHandlerLogging_HasLogs()
+    {
+        // Arrange
+        var sink = new TestSink();
+        var httpContext = CreateHttpContext();
+
+        var optionsAccessor = CreateOptionsAccessor(
+            exceptionHandler: context =>
+            {
+                context.Features.Set<IHttpResponseFeature>(new TestHttpResponseFeature());
+                return Task.CompletedTask;
+            },
+            suppressLoggingHandlingException: true);
+        var middleware = CreateMiddleware(_ => throw new InvalidOperationException(), optionsAccessor, loggerFactory: new TestLoggerFactory(sink, true));
+
+        // Act & Assert
+        await middleware.Invoke(httpContext);
+
+        Assert.Collection(sink.Writes, w => Assert.Equal("UnhandledException", w.EventId.Name));
+    }
+
+    private sealed class TestHttpResponseFeature : HttpResponseFeature
+    {
+        public override bool HasStarted => true;
     }
 
     [Fact]
@@ -126,6 +157,7 @@ public async Task Invoke_ExceptionHandlerCaptureRouteValuesAndEndpoint()
     public async Task IExceptionHandlers_CallNextIfNotHandled()
     {
         // Arrange
+        var sink = new TestSink();
         var httpContext = CreateHttpContext();
 
         var optionsAccessor = CreateOptionsAccessor();
@@ -137,14 +169,49 @@ public async Task IExceptionHandlers_CallNextIfNotHandled()
             new TestExceptionHandler(true, "3"),
         };
 
-        var middleware = CreateMiddleware(_ => throw new InvalidOperationException(), optionsAccessor, exceptionHandlers);
+        var middleware = CreateMiddleware(_ => throw new InvalidOperationException(), optionsAccessor, exceptionHandlers, loggerFactory: new TestLoggerFactory(sink, true));
 
         // Act & Assert
         await middleware.Invoke(httpContext);
 
         Assert.True(httpContext.Items.ContainsKey("1"));
         Assert.True(httpContext.Items.ContainsKey("2"));
         Assert.True(httpContext.Items.ContainsKey("3"));
+
+        Assert.Collection(sink.Writes, w => Assert.Equal("UnhandledException", w.EventId.Name));
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task IExceptionHandlers_SuppressLogging_TestLogs(bool suppressedLogs)
+    {
+        // Arrange
+        var sink = new TestSink();
+        var httpContext = CreateHttpContext();
+
+        var optionsAccessor = CreateOptionsAccessor(suppressLoggingHandlingException: suppressedLogs);
+
+        var exceptionHandlers = new List<IExceptionHandler>
+        {
+            new TestExceptionHandler(true, "1")
+        };
+
+        var middleware = CreateMiddleware(_ => throw new InvalidOperationException(), optionsAccessor, exceptionHandlers, loggerFactory: new TestLoggerFactory(sink, true));
+
+        // Act & Assert
+        await middleware.Invoke(httpContext);
+
+        Assert.True(httpContext.Items.ContainsKey("1"));
+
+        if (suppressedLogs)
+        {
+            Assert.Empty(sink.Writes);
+        }
+        else
+        {
+            Assert.Collection(sink.Writes, w => Assert.Equal("UnhandledException", w.EventId.Name));
+        }
     }
 
     [Fact]
@@ -445,6 +512,32 @@ public async Task Metrics_ExceptionThrown_Unhandled_Reported()
             m => AssertRequestException(m, "System.InvalidOperationException", "unhandled"));
     }
 
+    [Fact]
+    public async Task Metrics_ExceptionThrown_ErrorPathHandled_Reported()
+    {
+        // Arrange
+        var httpContext = CreateHttpContext();
+        var optionsAccessor = CreateOptionsAccessor(
+            exceptionHandler: context =>
+            {
+                context.Features.Set<IHttpResponseFeature>(new TestHttpResponseFeature());
+                return Task.CompletedTask;
+            },
+            exceptionHandlingPath: "/error");
+        var meterFactory = new TestMeterFactory();
+        var middleware = CreateMiddleware(_ => throw new InvalidOperationException(), optionsAccessor, meterFactory: meterFactory);
+        var meter = meterFactory.Meters.Single();
+
+        using var diagnosticsRequestExceptionCollector = new MetricCollector<long>(meterFactory, DiagnosticsMetrics.MeterName, "aspnetcore.diagnostics.exceptions");
+
+        // Act
+        await middleware.Invoke(httpContext);
+
+        // Assert
+        Assert.Collection(diagnosticsRequestExceptionCollector.GetMeasurementSnapshot(),
+            m => AssertRequestException(m, "System.InvalidOperationException", "handled", "/error"));
+    }
+
     private static void AssertRequestException(CollectedMeasurement<long> measurement, string exceptionName, string result, string handler = null)
     {
         Assert.Equal(1, measurement.Value);
@@ -490,14 +583,19 @@ private HttpContext CreateHttpContext()
 
     private IOptions<ExceptionHandlerOptions> CreateOptionsAccessor(
         RequestDelegate exceptionHandler = null,
-        string exceptionHandlingPath = null)
+        string exceptionHandlingPath = null,
+        bool? suppressLoggingHandlingException = null)
     {
         exceptionHandler ??= c => Task.CompletedTask;
         var options = new ExceptionHandlerOptions()
         {
             ExceptionHandler = exceptionHandler,
             ExceptionHandlingPath = exceptionHandlingPath,
         };
+        if (suppressLoggingHandlingException != null)
+        {
+            options.SuppressLoggingIExceptionHandler = suppressLoggingHandlingException.Value;
+        }
         var optionsAccessor = Mock.Of<IOptions<ExceptionHandlerOptions>>(o => o.Value == options);
         return optionsAccessor;
     }
@@ -506,14 +604,15 @@ private ExceptionHandlerMiddlewareImpl CreateMiddleware(
         RequestDelegate next,
         IOptions<ExceptionHandlerOptions> options,
         IEnumerable<IExceptionHandler> exceptionHandlers = null,
-        IMeterFactory meterFactory = null)
+        IMeterFactory meterFactory = null,
+        ILoggerFactory loggerFactory = null)
     {
         next ??= c => Task.CompletedTask;
         var listener = new DiagnosticListener("Microsoft.AspNetCore");
 
         var middleware = new ExceptionHandlerMiddlewareImpl(
             next,
-            NullLoggerFactory.Instance,
+            loggerFactory ?? NullLoggerFactory.Instance,
             options,
             listener,
             exceptionHandlers ?? Enumerable.Empty<IExceptionHandler>(),

Original file line number	Diff line number	Diff line change
`@@ -115,6 +115,8 @@ public async Task Invoke(HttpContext context)`
`115`	`115`	`}`
`116`	`116`	`catch (Exception ex)`
`117`	`117`	`{`
	`118`	`+ DiagnosticsTelemetry.AddMetricsTags(context, ex);`
	`119`	`+`
`118`	`120`	`var exceptionName = ex.GetType().FullName!;`
`119`	`121`
`120`	`122`	`if ((ex is OperationCanceledException \|\| ex is IOException) && context.RequestAborted.IsCancellationRequested)`
`@@ -135,7 +137,7 @@ public async Task Invoke(HttpContext context)`
`135`	`137`	`return;`
`136`	`138`	`}`
`137`	`139`
`138`		`- DiagnosticsTelemetry.ReportUnhandledException(_logger, context, ex);`
	`140`	`+ _logger.UnhandledException(ex);`
`139`	`141`
`140`	`142`	`if (context.Response.HasStarted)`
`141`	`143`	`{`
Original file line number	Diff line number	Diff line change
`@@ -3,16 +3,13 @@`
`3`	`3`
`4`	`4`	`using Microsoft.AspNetCore.Http.Features;`
`5`	`5`	`using Microsoft.AspNetCore.Http;`
`6`		`-using Microsoft.Extensions.Logging;`
`7`	`6`
`8`	`7`	`namespace Microsoft.AspNetCore.Diagnostics;`
`9`	`8`
`10`	`9`	`internal static class DiagnosticsTelemetry`
`11`	`10`	`{`
`12`		`- public static void ReportUnhandledException(ILogger logger, HttpContext context, Exception ex)`
	`11`	`+ public static void AddMetricsTags(HttpContext context, Exception ex)`
`13`	`12`	`{`
`14`		`- logger.UnhandledException(ex);`
`15`		`-`
`16`	`13`	`if (context.Features.Get<IHttpMetricsTagsFeature>() is { } tagsFeature)`
`17`	`14`	`{`
`18`	`15`	`// Multiple exception middleware could be registered that have already added the tag.`
Original file line number	Diff line number	Diff line change
`@@ -112,10 +112,13 @@ static async Task Awaited(ExceptionHandlerMiddlewareImpl middleware, HttpContext`
`112`	`112`
`113`	`113`	`private async Task HandleException(HttpContext context, ExceptionDispatchInfo edi)`
`114`	`114`	`{`
	`115`	`+ DiagnosticsTelemetry.AddMetricsTags(context, edi.SourceException);`
	`116`	`+`
`115`	`117`	`var exceptionName = edi.SourceException.GetType().FullName!;`
`116`	`118`
`117`	`119`	`if ((edi.SourceException is OperationCanceledException \|\| edi.SourceException is IOException) && context.RequestAborted.IsCancellationRequested)`
`118`	`120`	`{`
	`121`	`+ // Don't log unhandled exception for aborted request.`
`119`	`122`	`_logger.RequestAbortedException();`
`120`	`123`
`121`	`124`	`if (!context.Response.HasStarted)`
`@@ -127,11 +130,10 @@ private async Task HandleException(HttpContext context, ExceptionDispatchInfo ed`
`127`	`130`	`return;`
`128`	`131`	`}`
`129`	`132`
`130`		`- DiagnosticsTelemetry.ReportUnhandledException(_logger, context, edi.SourceException);`
`131`		`-`
`132`	`133`	`// We can't do anything if the response has already started, just abort.`
`133`	`134`	`if (context.Response.HasStarted)`
`134`	`135`	`{`
	`136`	`+ _logger.UnhandledException(edi.SourceException);`
`135`	`137`	`_logger.ResponseStartedErrorHandler();`
`136`	`138`
`137`	`139`	`_metrics.RequestException(exceptionName, ExceptionResult.Skipped, handler: null);`
`@@ -168,52 +170,73 @@ private async Task HandleException(HttpContext context, ExceptionDispatchInfo ed`
`168`	`170`	`context.Response.StatusCode = _options.StatusCodeSelector?.Invoke(edi.SourceException) ?? DefaultStatusCode;`
`169`	`171`	`context.Response.OnStarting(_clearCacheHeadersDelegate, context.Response);`
`170`	`172`
`171`		`- string? handler = null;`
`172`		`- var handled = false;`
	`173`	`+ string? handlerTag = null;`
	`174`	`+ var handler = Handler.None;`
`173`	`175`	`foreach (var exceptionHandler in _exceptionHandlers)`
`174`	`176`	`{`
`175`		`- handled = await exceptionHandler.TryHandleAsync(context, edi.SourceException, context.RequestAborted);`
`176`		`- if (handled)`
	`177`	`+ if (await exceptionHandler.TryHandleAsync(context, edi.SourceException, context.RequestAborted))`
`177`	`178`	`{`
`178`		`- handler = exceptionHandler.GetType().FullName;`
	`179`	`+ handler = Handler.IExceptionHandler;`
	`180`	`+ handlerTag = exceptionHandler.GetType().FullName;`
`179`	`181`	`break;`
`180`	`182`	`}`
`181`	`183`	`}`
`182`	`184`
`183`		`- if (!handled)`
	`185`	`+ if (handler == Handler.None)`
`184`	`186`	`{`
`185`	`187`	`if (_options.ExceptionHandler is not null)`
`186`	`188`	`{`
`187`	`189`	`await _options.ExceptionHandler!(context);`
	`190`	`+`
	`191`	`+ // If the response has started, assume exception handler was successful.`
	`192`	`+ if (context.Response.HasStarted)`
	`193`	`+ {`
	`194`	`+ handler = Handler.ExceptionHandler;`
	`195`	`+ if (_options.ExceptionHandlingPath.HasValue)`
	`196`	`+ {`
	`197`	`+ handlerTag = _options.ExceptionHandlingPath.Value;`
	`198`	`+ }`
	`199`	`+ }`
`188`	`200`	`}`
`189`	`201`	`else`
`190`	`202`	`{`
`191`		`- handled = await _problemDetailsService!.TryWriteAsync(new()`
	`203`	`+ if (await _problemDetailsService!.TryWriteAsync(new()`
`192`	`204`	`{`
`193`	`205`	`HttpContext = context,`
`194`	`206`	`AdditionalMetadata = exceptionHandlerFeature.Endpoint?.Metadata,`
`195`	`207`	`ProblemDetails = { Status = context.Response.StatusCode },`
`196`	`208`	`Exception = edi.SourceException,`
`197`		`- });`
`198`		`- if (handled)`
	`209`	`+ }))`
`199`	`210`	`{`
`200`		`- handler = _problemDetailsService.GetType().FullName;`
	`211`	`+ handler = Handler.IProblemDetailsService;`
	`212`	`+ handlerTag = _problemDetailsService.GetType().FullName;`
`201`	`213`	`}`
`202`	`214`	`}`
`203`	`215`	`}`
`204`		`- // If the response has already started, assume exception handler was successful.`
`205`		`- if (context.Response.HasStarted \|\| handled \|\| _options.StatusCodeSelector != null \|\| context.Response.StatusCode != StatusCodes.Status404NotFound \|\| _options.AllowStatusCode404Response)`
	`216`	`+`
	`217`	`+ if (handler != Handler.None \|\| _options.StatusCodeSelector != null \|\| context.Response.StatusCode != StatusCodes.Status404NotFound \|\| _options.AllowStatusCode404Response)`
`206`	`218`	`{`
`207`		`- const string eventName = "Microsoft.AspNetCore.Diagnostics.HandledException";`
`208`		`- if (_diagnosticListener.IsEnabled() && _diagnosticListener.IsEnabled(eventName))`
	`219`	`+ // Customers with an IExceptionHandler that reports it handled the exception could do their own logging.`
	`220`	`+ // Don't log IExceptionHandler handled exceptions if SuppressLoggingIExceptionHandler is set to true.`
	`221`	`+ // Note: Microsoft.AspNetCore.Diagnostics.HandledException is used by AppInsights to log errors so it's also skipped.`
	`222`	`+ if (handler != Handler.IExceptionHandler \|\| !_options.SuppressLoggingIExceptionHandler)`
`209`	`223`	`{`
`210`		`- WriteDiagnosticEvent(_diagnosticListener, eventName, new { httpContext = context, exception = edi.SourceException });`
	`224`	`+ const string eventName = "Microsoft.AspNetCore.Diagnostics.HandledException";`
	`225`	`+ if (_diagnosticListener.IsEnabled() && _diagnosticListener.IsEnabled(eventName))`
	`226`	`+ {`
	`227`	`+ WriteDiagnosticEvent(_diagnosticListener, eventName, new { httpContext = context, exception = edi.SourceException });`
	`228`	`+ }`
	`229`	`+`
	`230`	`+ _logger.UnhandledException(edi.SourceException);`
`211`	`231`	`}`
`212`	`232`
`213`		`- _metrics.RequestException(exceptionName, ExceptionResult.Handled, handler);`
	`233`	`+ _metrics.RequestException(exceptionName, ExceptionResult.Handled, handlerTag);`
`214`	`234`	`return;`
`215`	`235`	`}`
`216`	`236`
	`237`	`+ // Log original unhandled exception before it is wrapped.`
	`238`	`+ _logger.UnhandledException(edi.SourceException);`
	`239`	`+`
`217`	`240`	`edi = ExceptionDispatchInfo.Capture(new InvalidOperationException($"The exception handler configured on {nameof(ExceptionHandlerOptions)} produced a 404 status response. " +`
`218`	`241`	`$"This {nameof(InvalidOperationException)} containing the original exception was thrown since this is often due to a misconfigured {nameof(ExceptionHandlerOptions.ExceptionHandlingPath)}. " +`
`219`	`242`	`$"If the exception handler is expected to return 404 status responses then set {nameof(ExceptionHandlerOptions.AllowStatusCode404Response)} to true.", edi.SourceException));`
`@@ -222,6 +245,9 @@ private async Task HandleException(HttpContext context, ExceptionDispatchInfo ed`
`222`	`245`	`{`
`223`	`246`	`// Suppress secondary exceptions, re-throw the original.`
`224`	`247`	`_logger.ErrorHandlerException(ex2);`
	`248`	`+`
	`249`	`+ // There was an error handling the exception. Log original unhandled exception.`
	`250`	`+ _logger.UnhandledException(edi.SourceException);`
`225`	`251`	`}`
`226`	`252`	`finally`
`227`	`253`	`{`
`@@ -259,4 +285,12 @@ private static Task ClearCacheHeaders(object state)`
`259`	`285`	`headers.ETag = default;`
`260`	`286`	`return Task.CompletedTask;`
`261`	`287`	`}`
	`288`	`+`
	`289`	`+ private enum Handler`
	`290`	`+ {`
	`291`	`+ None,`
	`292`	`+ IExceptionHandler,`
	`293`	`+ IProblemDetailsService,`
	`294`	`+ ExceptionHandler`
	`295`	`+ }`
`262`	`296`	`}`