如何抑制“执行请求时发生未处理的异常。” 使用 Serilog 记录消息

Question

当使用带有异常处理程序app.UseExceptionHandler / 委托（ 文档）的 app.UseExceptionHandler 实现我自己的异常处理程序时，我不希望 Microsoft 的异常处理程序中间件记录此错误：

执行请求时发生未处理的异常。

此异常消息使我的日志文件混乱，因为我自己负责使用适当的 LogLevel 记录异常。

这就是我注册自己的ErrorHandler的方式：

app.UseExceptionHandler(errorApp =>
                errorApp.Run(ErrorHandler));

如本期所述，以简单的方式过滤此确切消息，其他任何事情都是不可能的。

如何过滤这个确切的日志消息，而不是来自中间件的其他内容？

我在用：

• ASP.NET 内核 3.1
• Serilog 3.4.0

Answer 1

如上面提到的问题中所述，我们可以为此使用过滤器表达式。 不幸的是，该问题仅描述了已弃用的 package 的解决方案，并且正在过滤来自中间件的所有消息，而不仅仅是提到的消息。

1. 安装Serilog.Expressions package
2. 使用以下配置更新匹配的appsettings.json ：

  "Serilog": {
    "Using": [ "Serilog.Expressions" ],
    "Filter": [
      {
        "Name": "ByExcluding",
        "Args": {
          "expression": "@l='Error' and SourceContext='Microsoft.AspNetCore.Diagnostics.ExceptionHandlerMiddleware' and @mt='An unhandled exception has occurred while executing the request.'"
        }
      }
    ]
  }

3. 确保您具有从appsettings.json加载配置的匹配代码， 如文档所示，例如：

Log.Logger = new LoggerConfiguration()
                .ReadFrom.Configuration(configuration)
                .CreateLogger();

这样，您可以保留来自ExceptionHandlerMiddleware的所有其他消息，并且只需禁用冗余错误日志消息。

旁注：如果响应已经开始，我们的自定义异常处理程序将不会被执行——但会记录一个警告，异常将被重新抛出，稍后由另一个应用程序层记录——至少在我测试的应用程序中。 您可以通过在抛出异常之前在某处添加此代码来测试此行为（ context是当前的 HttpContext）：

 await context.Response.WriteAsync("fish");

Answer 2

我已经用我的程序中的自定义中间件替换了 app.UseExceptionHandler，它就像一个魅力。

启动.cs：

app.UseMiddleware<HttpExceptionMiddleware>();

HttpExceptionMiddleware.cs

using System.Text.Json;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.Net.Http.Headers;

internal class HttpExceptionMiddleware
{
    private readonly RequestDelegate next;

    public HttpExceptionMiddleware(RequestDelegate next)
    {
        this.next = next;
    }

    public async Task Invoke(HttpContext context)
    {
        try
        {
            await this.next.Invoke(context);
        }
        catch (HttpException e)
        {
            var response = context.Response;
            if (response.HasStarted)
            {
                throw;
            }
            response.StatusCode = (int) e.StatusCode;
            response.ContentType = "application/json; charset=utf-8";
            response.Headers[HeaderNames.CacheControl] = "no-cache";
            response.Headers[HeaderNames.Pragma] = "no-cache";
            response.Headers[HeaderNames.Expires] = "-1";
            response.Headers.Remove(HeaderNames.ETag);

            var bodyObj = new {
                Message = e.Message,
                Status = e.StatusCode.ToString()
            };
            var body = JsonSerializer.Serialize(bodyObj);
            await context.Response.WriteAsync(body);
        }
    }
}

HTTPException.cs

using System;
using System.Net;

public class HttpException : Exception
{
    public HttpStatusCode StatusCode { get; }

    public HttpException(HttpStatusCode statusCode)
    {
        this.StatusCode = statusCode;
    }

    public HttpException(int httpStatusCode)
        : this((HttpStatusCode) httpStatusCode)
    {
    }

    public HttpException(HttpStatusCode statusCode, string message)
        : base(message)
    {
        this.StatusCode = statusCode;
    }

    public HttpException(int httpStatusCode, string message)
        : this((HttpStatusCode) httpStatusCode, message)
    {
    }

    public HttpException(HttpStatusCode statusCode, string message, Exception inner)
        : base(message, inner)
    {
    }

    public HttpException(int httpStatusCode, string message, Exception inner)
        : this((HttpStatusCode) httpStatusCode, message, inner)
    {
    }
}