使用NLog给Asp.Net Core做请求监控的方法

public class DelegatingHandler1 : DelegatingHandler
  {
    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
      Trace.WriteLine("DelegatingHandler1 HashCode: " + this.GetHashCode());
      Trace.WriteLine("DelegatingHandler1 base InnerHandler HashCode: " + base.InnerHandler.GetHashCode());
      Trace.WriteLine("DelegatingHandler1 start");
      var response = await base.SendAsync(request, cancellationToken);
      Trace.WriteLine("DelegatingHandler1 end");
      return response;
    }
  }
  public class DelegatingHandler2 : DelegatingHandler
  {
    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
      Trace.WriteLine("DelegatingHandler2 HashCode: " + this.GetHashCode());
      Trace.WriteLine("DelegatingHandler2 base InnerHandler HashCode: " + base.InnerHandler.GetHashCode());
      Trace.WriteLine("DelegatingHandler2 start");
      var response = await base.SendAsync(request, cancellationToken);
      Trace.WriteLine("DelegatingHandler2 end");
      return response;
    }
  }
  public class DelegatingHandler3 : DelegatingHandler
  {
    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
      Trace.WriteLine("DelegatingHandler3 HashCode: " + this.GetHashCode());
      Trace.WriteLine("DelegatingHandler3 base InnerHandler HashCode: " + base.InnerHandler.GetHashCode());
      Trace.WriteLine("DelegatingHandler3 start");
      var response = await base.SendAsync(request, cancellationToken);
      Trace.WriteLine("DelegatingHandler3 end");
      return response;
    }
  }

public class WebApiApplication : System.Web.HttpApplication
  {
    protected void Application_Start()
    {
      AreaRegistration.RegisterAllAreas();
      GlobalConfiguration.Configure(WebApiConfig.Register);
      FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
      RouteConfig.RegisterRoutes(RouteTable.Routes);
      BundleConfig.RegisterBundles(BundleTable.Bundles);

      GlobalConfiguration.Configuration.MessageHandlers.Add(new DelegatingHandler1());
      GlobalConfiguration.Configuration.MessageHandlers.Add(new DelegatingHandler2());
      GlobalConfiguration.Configuration.MessageHandlers.Add(new DelegatingHandler3());
    }
  }

public class ValuesController : ApiController
  {
    // GET api/values
    public IEnumerable<string> Get()
    {
      Trace.WriteLine("/api/values");
      var handlers = this.RequestContext.Configuration.MessageHandlers;
      return new string[] { "value1", "value2" };
    }
  }

public class ApplicationInsight : DelegatingHandler
  {
    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
      var stopWatch = new Stopwatch();
      stopWatch.Start();

      var response = await base.SendAsync(request, cancellationToken);

      stopWatch.Stop();
      //停止计时器，并记录
    }
  }
  public partial class Startup
  {
    public void Configuration(IAppBuilder app)
    {
      GlobalConfiguration.Configuration.MessageHandlers.Add(new ApplicationInsight());
    }
  }

<targets>
  <!--黑洞 忽略的日志-->
  <target xsi:type="Null"
      name="blackhole" />
  <!--文件日志-->
  <target xsi:type="File"
    name="debughelper"
    fileName="${var:root}\Logs\debug_helper.log"
    layout="${longdate}|${event-properties:item=EventId.Id}|${logger}|${uppercase:${level}}|${message} ${exception}" />
  <!--apiinsight api 统计-->
  <target name="apiinsight" xsi:type="Database"
       dbProvider="MySql.Data.MySqlClient.MySqlConnection, MySql.Data"
       connectionString="${var:connectionString}"
       >
  </target>
  <!--日志-->
  <target name="log" xsi:type="Database"
     dbProvider="MySql.Data.MySqlClient.MySqlConnection, MySql.Data"
     connectionString="${var:connectionString}"
       >
  </target>
 </targets>

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
  //省略了其他配置

  //全局的 HttpContext
  app.UseGlobalHttpContext();

  //省略了其他配置

  LogManager.Configuration = new XmlLoggingConfiguration(Path.Combine(env.ContentRootPath, "nlog.config"));
  LogManager.Configuration.Variables["root"] = env.ContentRootPath;
  LogManager.Configuration.Variables["connectionString"] = Configuration.GetConnectionString("DefaultConnection");
}

[LayoutRenderer("apiinsight-start")]
  public class StartApiInsightRenderer : LayoutRenderer
  {
    protected override void Append(StringBuilder builder, LogEventInfo logEvent)
    {
      var httpContext = HttpContextProvider.Current;
      if (httpContext == null)
      {
        return;
      }
      var _apiInsightsKeys = httpContext.RequestServices.GetService<IApiInsightsKeys>();

      if (httpContext != null)
      {
        if (httpContext.Items.TryGetValue(_apiInsightsKeys.StartTimeName, out var start) == true)
        {
          builder.Append(start.ToString());
        }
      }
    }
  }

<rules>
  <!--需要记录的日志-->
  <logger name="Cheers.*" minlevel="Trace" writeTo="apiinsight" />
  <logger name="WebApp.*" minlevel="Info" writeTo="log" />
  <logger name="*" minlevel="Trace" maxlevel="Debug" writeTo="debughelper" />

  <!--忽略的日志-->
  <logger name="Microsoft.*" minlevel="Trace" writeTo="blackhole" final="true" />
 </rules>

public class ApiInsightMiddleware
  {
    private readonly RequestDelegate _next;
    private readonly IServiceProvider _serverProvider;
    private readonly IApiInsightsKeys _apiInsightsKeys;
    private readonly ILogger<ApiInsightMiddleware> _logger;
    private HttpContext _httpContext;

    public ApiInsightMiddleware(RequestDelegate next, IServiceProvider serviceProvider, ILogger<ApiInsightMiddleware> logger)
    {
      _next = next;
      _serverProvider = serviceProvider;
      _apiInsightsKeys = _serverProvider.GetService<IApiInsightsKeys>();
      _logger = logger;
    }

    public async Task Invoke(HttpContext httpContext)
    {
      _httpContext = httpContext;
      var flag = SetValues();

      await _next(httpContext);

      if (flag == true)
      {
        ApiInsight();
      }
    }
    //省略了其他的代码
  }

public static class HttpContextProvider
  {
    private static IHttpContextAccessor _accessor;
    private static IServiceScopeFactory _serviceScopeFactory;

    public static Microsoft.AspNetCore.Http.HttpContext Current
    {
      get
      {
        var context = _accessor"color: #ff0000">第一个中间件

在 Startup 的 Configure 方法中目前还没发现如何注册第一个中间件，因为 Configure 方法始终是在 IStartupFilter 这个接口之后执行的，这也提供了我们让自己的中间件成为第一个中间件的可能。可能这样做并不是特别有必要，甚至是没有意义的，但是实现的过程确实很有意思的。这里在 Startup 中的 方法 ConfigureService 注册我们的中间件。


  public void ConfigureServices(IServiceCollection services)
  {
    services.AddApiInsights();
    services.AddMvc();
  }


具体的


public static class ApiInsightsServiceCollectionExtensions
  {
    static readonly string stopWatchName = "__stopwatch__";
    static readonly string startTimeName = "__start__";

    /// <summary>
    ///   注册和 API 监控相关的服务，中间件
    /// </summary>
    /// <param name="services"></param>
    public static void AddApiInsights(this IServiceCollection services)
    {
      services.AddSingleton<IApiInsightsKeys>(
          new ApiInsightsKeys(stopWatchName, startTimeName)
        );
      services.FirstRegister<IStartupFilter, RequestApiInsightBeginStartupFilter>(ServiceCollectionServiceExtensions.AddTransient<IStartupFilter, RequestApiInsightBeginStartupFilter>);
      services.AddSingleton<IRequestIsAuthenticate, DefaultRequestIsAuthenticate>();
    }
  }


这里注册了三个服务
IApiInsightsKeys
定义了存储在 HttpContext.Item 中的键值对的名称


  public interface IApiInsightsKeys
  {
    string StopWatchName { get; }
    string StartTimeName { get; }
  }


IRequestIsAuthenticate


/// <summary>
  ///   验证请求用户是否已经认证
  /// </summary>
  public interface IRequestIsAuthenticate
  {
    /// <summary>
    ///   返回已经认证的 scheme
    /// </summary>
    /// <returns></returns>
    Task<string> IsAuthenticateAsync();
    /// <summary>
    ///   返回已经认证的 用户名
    /// </summary>
    /// <returns></returns>
    Task<string> AuthenticatedUserName();
  }


就验证而言可能不同的开发者使用的是不一样的验证方式，可能是基于 Asp.Net Core Authentication 中间件的认证方式，也可能是其他的比如自定义的 token，或者有一个单点登录的服务器，又或者是 session，其实 Asp.Net Core 的 Authentication 中间件也可以帮我们实现基于 restful 的token 认证。所以就把它定义出来了，并且默认的实现就是基于 Authentication 这个中间件的。
IStartupFilter
看到他是一个非常特殊的方式来注册的，自定义的 FirstRegister 这个方法，实际上 Asp.Net Core 内置有多个 IStartup 这样的服务，并且都是在 Startup 的 Configure 之前执行的，所以这里一定要用这个服务来让我们的中间件成为第一个中间件。FirstRegister 代码也很容易理解，由于在宿主启动之前，内部注册了多个 IStartup，并且最后会按先后顺序配置 IApplicationBuilder，所以我们只能让第一个 StartupFilter 的 IApplicationBuilder 就注册我们的中间件，通过改动 ServiceCollection 中服务的顺序可以实现。虽然不是很有必要，但是可以从中观察的 Startup 的 Configure方法 以及 接口StartupFilter （还有 IHostingStartup ）的执行顺序。


public class RequestApiInsightBeginStartupFilter : IStartupFilter
  {
    public Action<IApplicationBuilder> Configure(Action<IApplicationBuilder> next)
    {
      return builder =>
      {
        builder.UseMiddleware<RequestApiInsightBeginMiddleware>();
        next(builder);
      };
    }
  }


忽略的方法


  [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
  public class NoInsightAttribute : Attribute
  {
  }


在 ApiInsight 方法中会调用 IsIgnore 检测该方法是否打了标签 NoInsightAttribute，如果是那就忽略该方法，这里建议使用特性路由，原因有两点，第一特性路由不需要使用 IActionSelector 接口重新查找匹配的方法，第二，在 restful api 中，结合特性路由和 HttpMethodAttribute 标签可以使方法更简洁，相同的接口名称通过不同的请求方式达到不同的目的


private bool IsIgnore()
  {
    var actionDescriptor = GetSelectedActionDescriptor() as ControllerActionDescriptor;
    if (actionDescriptor == null)
    {
      return false;
    }
    else
    {
      var noInsight = actionDescriptor.MethodInfo.GetCustomAttribute<NoInsightAttribute>();
      return noInsight != null;
    }
  }


程序地址: https://github.com/cheesebar/ApiInsights 
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。