public async Task Process(RequestMetric metrics)
{
string str = $"Request with Id {metrics.RequestId} finished within {metrics.RequestTimeMs} ms.\n";
str += $" Id: {metrics.RequestId}\n";
str += $" Path: {metrics.RequestPath}\n";
str += $" FullPath: {metrics.RequestFullPath}\n";
str += $" Date: {metrics.RequestDate}\n";
str += $" ClientIP: {metrics.ClientIP}\n";
str += $" ResponseStatusCode: {metrics.ResponseStatusCode}\n";
str += $" ResponseContentType: {metrics.ResponseContentType}\n";
str += $" ResponseContentLength: {metrics.ResponseContentLength}\n";
str += $" RequestContentType: {metrics.RequestContentType}\n";
str += $" RequestContentLength: {metrics.RequestContentLength}\n";
foreach (MiddlewareMetric middlewareMetric in metrics.MiddlewareMetrics)
{
str += $"\n Middleware:\n";
str += $" MiddlewareIndex: {middlewareMetric.MiddlewareIndex}\n";
str += $" MiddlewareName: {middlewareMetric.MiddlewareName}\n";
str += $" MiddlewareTimeMs: {middlewareMetric.MiddlewareTimeMs}\n";
}
_logger.LogInformation(str);
}
public MiddlewareMetric(RequestMetric requestMetric, string requestMetricId, string id, string middlewareName, int middlewareIndex, long middlewareTimeMs)
{
RequestMetric = requestMetric;
RequestMetricId = requestMetricId;
Id = id;
MiddlewareName = middlewareName;
MiddlewareIndex = middlewareIndex;
MiddlewareTimeMs = middlewareTimeMs;
}
public async Task Process(RequestMetric metrics)
{
IServiceScope scope = _serviceProvider.CreateScope();
DataBaseContext _dataBaseContext = scope.ServiceProvider.GetRequiredService <DataBaseContext>();
await _dataBaseContext.AddAsync(metrics);
await _dataBaseContext.SaveChangesAsync();
foreach (MiddlewareMetric m in metrics.MiddlewareMetrics)
{
m.RequestMetricId = metrics.Id;
m.Id = null;
}
await _dataBaseContext.AddRangeAsync(metrics.MiddlewareMetrics);
await _dataBaseContext.SaveChangesAsync();
scope.Dispose();
}
public async Task Invoke(HttpContext context, ILogger <MetricsMiddleware> _logger)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
MemoryStream responseStream = new MemoryStream();
MemoryStream requestStream = new MemoryStream();
Stream responseStreamOrig = context.Response.Body;
Stream requestStreamOrig = context.Request.Body;
await requestStreamOrig.CopyToAsync(requestStream);
context.Request.Body = requestStream;
context.Response.Body = responseStream;
await next(context);
responseStream.Position = 0;
await responseStream.CopyToAsync(responseStreamOrig);
await responseStreamOrig.FlushAsync();
context.Response.ContentLength = responseStream.Length;
context.Request.ContentLength = requestStream.Length;
stopwatch.Stop();
List <MiddlewareMetric> metrics = new List <MiddlewareMetric>();
foreach (object key in context.Items.Keys)
{
if (key.ToString().StartsWith("mmw-") && key.ToString() != "mmw-index")
{
string str = key.ToString().Replace("mmw-", "");
int index = int.Parse(str.Substring(0, str.IndexOf("-")));
string name = str.Replace($"{index}-", "");
metrics.Add(new MiddlewareMetric(name, index, (long)context.Items[key]));
}
}
RequestMetric metric = new RequestMetric(
requestDate: DateTime.UtcNow,
requestFullPath: $"{context.Request.Scheme}://{context.Request.Host}{context.Request.Path}",
requestPath: context.Request.Path,
requestId: context.TraceIdentifier,
clientIP: context.Connection.RemoteIpAddress.ToString(),
requestTimeMs: stopwatch.ElapsedMilliseconds,
middlewareMetrics: metrics,
responseStatusCode: context.Response.StatusCode,
responseContentType: context.Response.ContentType,
responseContentLength: context.Response.ContentLength ?? 0,
requestContentType: context.Request.ContentType,
requestContentLength: context.Request.ContentLength ?? 0
);
new System.Threading.Thread(async() =>
{
try
{
await _processor.Process(metric);
}
catch (Exception ex)
{
_logger.LogError($"Error while processing metrics:\n{ex}");
}
}).Start();
}
