ASP.NET Core 中简单使用 HttpClient 集成 Elasticsearch 实现日志记录与查询

{
  "Elasticsearch":{
    "Url":"https://es-host:9200",
    "Username":"username",
    "Password":"password"
},
"Logging":{
    "LogLevel":{
      "Default":"Information"
    }
},
"AllowedHosts":"*"
}

public classElasticsearchService
{
    privatereadonly HttpClient _client;
    privatereadonly JsonSerializerOptions _jsonOptions = new(JsonSerializerDefaults.Web);

    public ElasticsearchService(HttpClient client, IConfiguration config)
    {
        var uri = config["Elasticsearch:Url"];
        var username = config["Elasticsearch:Username"];
        var password = config["Elasticsearch:Password"];

        client.BaseAddress = new Uri(uri);
        var byteArray = Encoding.ASCII.GetBytes($"{username}:{password}");
        client.DefaultRequestHeaders.Authorization =
            new AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));

        _client = client;
    }

    public async Task<bool> IndexAsync<T>(T document, string indexName, string? id = null)
    {
        var url = id != null ? $"/{indexName}/_doc/{id}" : $"/{indexName}/_doc";
        var content = new StringContent(JsonSerializer.Serialize(document, _jsonOptions), Encoding.UTF8, "application/json");

        var response = await _client.PostAsync(url, content);
        return response.IsSuccessStatusCode;
    }

    public async Task<List<T>> SearchAsync<T>(object query, string indexName)
    {
        var content = new StringContent(JsonSerializer.Serialize(query, _jsonOptions), Encoding.UTF8, "application/json");

        var response = await _client.PostAsync($"/{indexName}/_search", content);
        response.EnsureSuccessStatusCode();

        var json = await response.Content.ReadAsStringAsync();
        usingvar doc = JsonDocument.Parse(json);

        var hits = doc.RootElement.GetProperty("hits").GetProperty("hits");
        var result = new List<T>();

        foreach (var hit in hits.EnumerateArray())
        {
            var source = hit.GetProperty("_source").GetRawText();
            var obj = JsonSerializer.Deserialize<T>(source, _jsonOptions);
            if (obj != null) result.Add(obj);
        }

        return result;
    }
}

builder.Services.AddHttpClient<ElasticsearchService>();

public classApiLogEntity
{
    publicstring Name { get; set; }
    publicstring Ip { get; set; }
    publicstring Url { get; set; }
    publicstring ReqMethod { get; set; }
    public DateTime OpTime { get; set; }
    publicstring Account { get; set; }
    publicint StatusCode { get; set; }
    publicstring ResponseBody { get; set; }
}

public classRequestLoggingMiddleware
{
    privatereadonly RequestDelegate _next;
    privatereadonly ILogger<RequestLoggingMiddleware> _logger;
    privatereadonly ElasticsearchService _esService;

    public RequestLoggingMiddleware(RequestDelegate next, ILogger<RequestLoggingMiddleware> logger, ElasticsearchService esService)
    {
        _next = next;
        _logger = logger;
        _esService = esService;
    }

    public async Task Invoke(HttpContext context)
    {
        // 判断是否启用日志记录
        if (!App.Configuration["AppLogEntity"].ToBool())
        {
            await _next(context);
            return;
        }

        var request = context.Request;

        if (!request.Path.Value.Contains("api"))
        {
            await _next(context);
            return;
        }

        request.EnableBuffering();
        var originalBodyStream = context.Response.Body;
        awaitusingvar responseBody = new MemoryStream();
        context.Response.Body = responseBody;

        try
        {
            await _next(context);

            context.Response.Body.Seek(0, SeekOrigin.Begin);
            var responseText = awaitnew StreamReader(context.Response.Body).ReadToEndAsync();
            context.Response.Body.Seek(0, SeekOrigin.Begin);

            var entity = new ApiLogEntity
            {
                Name = Environment.MachineName,
                Ip = context.Connection.RemoteIpAddress?.ToString(),
                Url = request.Path + request.QueryString,
                ReqMethod = request.Method,
                OpTime = DateTime.Now,
                Account = "wx-" + App.User.FindFirst("UserID")?.Value,
                StatusCode = context.Response.StatusCode,
                ResponseBody = responseText
            };

            await _esService.IndexAsync(entity, "jltlogs");
        }
        finally
        {
            await responseBody.CopyToAsync(originalBodyStream);
            context.Response.Body = originalBodyStream;
        }
    }
}

app.UseMiddleware<RequestLoggingMiddleware>();

{
  "title": "Test Document",
  "description": "Elasticsearch integration with HttpClient"
}