public async Task InvokeAsync(HttpContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var start = Stopwatch.GetTimestamp();
var collectior = _diagnosticContext.BeginCollection();
try
{
await _next(context);
var elapsedMs = GetElapsedMilliseconds(start, Stopwatch.GetTimestamp());
var statusCode = context.Response.StatusCode;
LogCompletion(context, collectior, statusCode, elapsedMs, null);
}
catch (System.Exception ex)
when(LogCompletion(context, collectior, 500, GetElapsedMilliseconds(start, Stopwatch.GetTimestamp()), ex))
{
}
finally
{
collectior.Dispose();
}
}
// ReSharper disable once UnusedMember.Global
public async Task Invoke(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
var start = Stopwatch.GetTimestamp();
var collector = _diagnosticContext.BeginCollection();
try
{
await _next(httpContext);
var elapsedMs = GetElapsedMilliseconds(start, Stopwatch.GetTimestamp());
var statusCode = httpContext.Response.StatusCode;
LogCompletion(httpContext, collector, statusCode, elapsedMs, null);
}
catch (Exception ex)
// Never caught, because `LogCompletion()` returns false. This ensures e.g. the developer exception page is still
// shown, although it does also mean we see a duplicate "unhandled exception" event from ASP.NET Core.
when(LogCompletion(httpContext, collector, 500, GetElapsedMilliseconds(start, Stopwatch.GetTimestamp()), ex))
{
}
finally
{
collector.Dispose();
}
}
public LogScope(global::Serilog.ILogger logger, DiagnosticContext diagnosticContext, LogEventLevel level, string messageTemplate,
object[] propertyValues, IEnumerable <LogProperty> logProperties)
{
_logger = logger.NotNull(nameof(logger));
_collector = diagnosticContext.BeginCollection();
_level = level;
_messageTemplate = messageTemplate.NotNull(nameof(messageTemplate));
_propertyValues = propertyValues;
_logProperties = logProperties;
}
public void ExistingPropertiesCanBeUpdated()
{
var dc = new DiagnosticContext(Some.Logger());
var collector = dc.BeginCollection();
dc.Set("name", 10);
dc.Set("name", 20);
Assert.True(collector.TryComplete(out var properties));
var prop = Assert.Single(properties);
var scalar = Assert.IsType <ScalarValue>(prop.Value);
Assert.Equal(20, scalar.Value);
}
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var stopwatch = Stopwatch.StartNew();
using (var collector = _diagnosticContext.BeginCollection())
{
var response = await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
LogCompletion(request, collector, response.StatusCode, stopwatch.ElapsedTicks);
return(response);
}
}
public async Task PropertiesAreCollectedInAnActiveContext()
{
var dc = new DiagnosticContext(Some.Logger());
var collector = dc.BeginCollection();
dc.Set(Some.String("first"), Some.Int32());
await Task.Delay(TimeSpan.FromMilliseconds(10));
dc.Set(Some.String("second"), Some.Int32());
Assert.True(collector.TryComplete(out var properties));
Assert.Equal(2, properties.Count());
Assert.False(collector.TryComplete(out _));
collector.Dispose();
dc.Set(Some.String("third"), Some.Int32());
Assert.False(collector.TryComplete(out _));
}
public virtual async Task InvokeAsyncBase(HttpContext context, AutoWrapperMembers awm)
{
if (awm.IsSwagger(context, _options.SwaggerPath) || !awm.IsApi(context) || awm.IsExclude(context, _options.ExcludePaths))
{
await _next(context);
}
else
{
(int statusCode, string response)finalResponse = (context.Response.StatusCode, string.Empty);
var collector = _diagnosticContext.BeginCollection();
var stopWatch = Stopwatch.StartNew();
var requestBody = await awm.GetRequestBodyAsync(context.Request);
Exception ex = null;
var originalResponseBodyStream = context.Response.Body;
bool isRequestOk = false;
string responseBodyAsText = null;
using var memoryStream = new MemoryStream();
try
{
context.Response.Body = memoryStream;
await _next.Invoke(context);
isRequestOk = awm.IsRequestSuccessful(context.Response.StatusCode);
if (context.Response.HasStarted)
{
LogResponseHasStartedError(context, requestBody, responseBodyAsText, stopWatch, isRequestOk, ex);
return;
}
var endpoint = context.GetEndpoint();
if (endpoint?.Metadata?.GetMetadata <AutoWrapIgnoreAttribute>() is object)
{
await awm.RevertResponseBodyStreamAsync(memoryStream, originalResponseBodyStream);
return;
}
responseBodyAsText = await awm.ReadResponseBodyStreamAsync(memoryStream);
context.Response.Body = originalResponseBodyStream;
if (context.Response.StatusCode != Status304NotModified &&
context.Response.StatusCode != Status204NoContent)
{
if (!_options.IsApiOnly &&
(responseBodyAsText.IsHtml() &&
!_options.BypassHTMLValidation) &&
context.Response.StatusCode == Status200OK)
{
context.Response.StatusCode = Status404NotFound;
}
if (!context.Request.Path.StartsWithSegments(new PathString(_options.WrapWhenApiPathStartsWith)) &&
(responseBodyAsText.IsHtml() &&
!_options.BypassHTMLValidation) &&
context.Response.StatusCode == Status200OK)
{
if (memoryStream.Length > 0)
{
await awm.HandleNotApiRequestAsync(context);
}
return;
}
isRequestOk = awm.IsRequestSuccessful(context.Response.StatusCode);
if (isRequestOk)
{
if (_options.IgnoreWrapForOkRequests)
{
await awm.WrapIgnoreAsync(context, responseBodyAsText);
}
else
{
finalResponse = await awm.HandleSuccessfulRequestAsync(context, responseBodyAsText,
context.Response.StatusCode);
}
}
else
{
if (_options.UseApiProblemDetailsException)
{
finalResponse = await awm.HandleProblemDetailsExceptionAsync(context, _executor, responseBodyAsText);
return;
}
finalResponse = await awm.HandleUnsuccessfulRequestAsync(context, responseBodyAsText,
context.Response.StatusCode);
}
}
}
catch (Exception exception)
{
ex = exception;
if (context.Response.HasStarted)
{
LogResponseHasStartedError(context, requestBody, responseBodyAsText, stopWatch, isRequestOk,
ex);
return;
}
if (_options.UseApiProblemDetailsException)
{
finalResponse = await awm.HandleProblemDetailsExceptionAsync(context, _executor, null, exception);
}
else
{
finalResponse = await awm.HandleExceptionAsync(context, exception);
}
responseBodyAsText = await awm.ReadResponseBodyStreamAsync(memoryStream);
await awm.RevertResponseBodyStreamAsync(memoryStream, originalResponseBodyStream);
}
finally
{
if (string.IsNullOrWhiteSpace(finalResponse.response))
{
finalResponse.response = responseBodyAsText;
}
LogHttpRequest(context, collector, requestBody, finalResponse.response, finalResponse.statusCode, stopWatch, isRequestOk, ex);
}
}
}