public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
var operation = request.Headers.Action;
if (operation == null)
{
return(null);
}
var context = new LogCastContext
{
OperationName = operation.Substring(operation.LastIndexOf("/", StringComparison.OrdinalIgnoreCase) + 1)
};
var correlationId = _correlationIdProvider?.Invoke(request);
if (correlationId != null)
{
context.CorrelationId = correlationId;
}
var root = ApplyRequestMessage(context, request);
return(new CorrelationState <Root>(context, root));
}
public async Task Invoke(AppFunc next, IDictionary <string, object> environment)
{
if (next == null)
{
throw new ArgumentNullException(nameof(next));
}
if (environment == null)
{
throw new ArgumentNullException(nameof(environment));
}
using (var logContext = new LogCastContext())
{
var context = new OwinContext(environment);
var owinContextLogMap = OwinContextLogMapFactory(context, Logger);
using (new ElapsedLogger(Logger, context.Request.Method))
{
try
{
await next(environment);
}
catch (Exception exception)
{
Logger.Error(exception);
context.Response.StatusCode = 500;
}
owinContextLogMap.AfterNextHandler(logContext);
}
}
}
public override void Act()
{
using (new LogCastContext(CorrelationId, OperationName))
{
_current = CurrentContext;
}
}
private void ApplyResponseData(LogCastContext context, Root logEntry, HttpResponse httpResponse)
{
try
{
var response = new Response();
if (Options.LogResponseStatus)
{
response.Status = httpResponse.StatusCode;
}
if (Options.LogResponseHeaders)
{
response.Headers = CollectHeadersSafely(httpResponse.Headers);
}
if (Options.LogResponseBody)
{
throw new NotSupportedException();
}
if (logEntry == null)
{
logEntry = new Root();
context.Properties.Add(Root.FieldName, logEntry);
}
logEntry.Response = response;
}
catch (Exception ex)
{
Logger.Error("Failed to log http response data.", ex);
}
}
public override void Arrange()
{
base.Arrange();
CurrentContext = new LogCastContext(CorrelationId)
{
OperationName = OperationName
};
}
public override void Arrange()
{
CurrentContext = new LogCastContext();
OperationName = "test";
OperationDurationMs = 100;
base.Arrange();
}
public override void Act()
{
_before = CurrentContext;
using (new LogCastContext())
{
_current = CurrentContext;
}
_after = CurrentContext;
}
public virtual Response GetResponse(LogCastContext target, HttpResponseMessage responseMessage)
{
if (!Options.IsResponseLogged)
{
return(null);
}
return(PrepareResponseData(responseMessage));
}
public virtual Request GetRequest(LogCastContext target, HttpRequestMessage requestMessage)
{
if (!Options.IsRequestLogged)
{
return(null);
}
return(PrepareRequestData(requestMessage));
}
public void BeforeSend(LogCastDocument document, LogCastContext sourceContext)
{
var source = OperationContext.Current;
if (source != null)
{
Apply(document, source);
}
}
public void BeforeSend(LogCastDocument document, LogCastContext sourceContext)
{
var context = HttpContext.Current;
if (context != null)
{
Apply(document, context);
}
}
public void AfterNextHandler(LogCastContext logContext)
{
var root = new Root
{
Request = ExtractRequestData(_context, _requestBody),
Response = ExtractResponseData(_context, _responseBody)
};
logContext.Properties.Add(Root.FieldName, root);
}
protected IEnumerable <int> GetOperationDurationProperties(LogCastContext context, string operationName)
{
string properyName = $"durations.{operationName}.total";
return(context.Properties
.Where(property => property.Key == properyName)
.OfType <LogPropertyWithValue <int> >()
.Select(property => property.Value)
.ToArray());
}
public void then_logcast_context_logging_in_unit_test_throws_no_exceptions()
{
LogConfig.DisableAutoConfig = false;
using (var context = new LogCastContext())
{
var logger = LogManager.GetLogger();
logger.Info("My message");
context.Properties.Add(new LogProperty <int>("de", 34));
}
}
public LogCastDocument Create(LogCastContext context, IEnumerable <ILogDispatchInspector> dispatchInspectors)
{
// Many messages will have no properties so we create aggregator only when necessary
PropertyAccumulator accumulator = null;
if (!context.Properties.IsEmpty)
{
accumulator = new PropertyAccumulator();
accumulator.AddProperties(context.Properties);
}
var summaryBuilder = new ContextSummaryBuilder(context, _detailsFormatter, context.BranchHistory);
foreach (var message in context.PendingMessages)
{
if (message.Properties?.Length > 0)
{
if (accumulator == null)
{
accumulator = new PropertyAccumulator();
}
accumulator.AddProperties(message.Properties);
}
summaryBuilder.AddMessage(message);
}
var summary = summaryBuilder.Build();
var document = new LogCastDocument();
ApplyContext(document, context, summary);
// Apply properties after context so that client could override standard properties
accumulator?.Apply(document);
foreach (var inspector in dispatchInspectors)
{
inspector.BeforeSend(document, context);
}
document.AddProperty(Property.Durations.Name, Property.Durations.Total,
(int)context.Elapsed.TotalMilliseconds);
return(document);
}
private static void ApplyContext(LogCastDocument document, LogCastContext context, ContextSummary summary)
{
document.AddProperty(Property.Timestamp, context.StartedAt);
document.AddProperty(Property.CorrelationId, context.CorrelationId, true);
document.AddProperty(Property.OperationName, context.OperationName, true);
if (summary != null)
{
document.AddProperty(Property.LogLevel, summary.Level.ToString());
document.AddProperty(Property.LogLevelCode, (int)summary.Level);
document.AddProperty(Property.Message, summary.Message);
document.AddProperty(Property.Details, summary.Details);
document.AddProperty(Property.Durations.Name, Property.DefaultChildName, summary.Durations);
document.AddProperty(Property.LoggerName, summary.Loggers);
ApplyError(document, summary.Exceptions);
}
}
private bool SkipMessage(LogCastContext context)
{
if (_logDice == null)
{
return(false);
}
// When there's no context roll the dice per message
if (context == null)
{
return(!_logDice.Roll());
}
// When context is available roll the dice once per context
if (context.SuppressMessages == null)
{
context.SuppressMessages = !_logDice.Roll();
}
return(context.SuppressMessages == true);
}
protected virtual Root ApplyRequestMessage(LogCastContext target, Message requestMessage)
{
// Check is inside the method to allow overriding
if (!Options.IsRequestLogged)
{
return(null);
}
var request = new Request();
var root = new Root {
Request = request
};
try
{
if (Options.LogCallerAddress)
{
request.Caller = GetCallerAddress(requestMessage.Properties);
}
if (Options.LogRequestProperties)
{
request.Properties = CollectProperties(requestMessage.Properties);
}
if (Options.LogRequestHttpData)
{
request.HttpHeaders = CollectHttpRequestHeaders(requestMessage.Properties);
}
if (Options.LogRequestBody)
{
request.Body = requestMessage.ToString();
}
target.Properties.Add(Root.FieldName, root);
}
catch (Exception ex)
{
Logger.Error("Failed to log WCF request message data.", ex);
}
return(root);
}
public virtual async Task <Response> GetResponseAsync(LogCastContext target, HttpResponseMessage responseMessage)
{
if (!Options.IsResponseLogged)
{
return(await Task.FromResult <Response>(null));
}
var response = PrepareResponseData(responseMessage);
if (Options.LogResponseBody && responseMessage.Content != null)
{
if (IsMediaContent(responseMessage.Content))
{
response.Body = Property.Values.MediaDataPlaceholder;
}
else
{
response.Body = await ReadContentSafelyAsync(responseMessage.Content);
}
}
return(response);
}
public override void Arrange()
{
base.Arrange();
Request = Fixture.Create <HttpRequestMessage>();
ModelValue = Fixture.Create <int>();
CorrelationId = Fixture.Create <string>();
OperationName = Fixture.Create <string>();
MessageInspectorMock = new Mock <IHttpMessageInspector>(MockBehavior.Loose);
MessageInspectorMock
.Setup(_ => _.GetResponse(It.IsAny <LogCastContext>(), It.IsAny <HttpResponseMessage>()))
.Callback((LogCastContext c, HttpResponseMessage r) =>
{
Response = r;
LogCastContext = c;
});
Sut = new LogCastContextHandler(
GetCorrelationId,
GetOperationName,
MessageInspectorMock.Object);
}
private void OnBeginRequest(object sender, EventArgs e)
{
var app = (HttpApplication)sender;
var request = app.Request;
if (SkipRequest(request))
{
return;
}
var context = new LogCastContext
{
OperationName = GetOperationName(request),
CorrelationId = GetCorrelationId(request),
SuppressEmtpyContextMessages = true
};
var root = ApplyRequestData(context, request);
var correlationState = new CorrelationState <Root>(context, root);
app.Context.Items[CorrelationState <Root> .Key] = correlationState;
}
protected virtual void ApplyResponseMessage(LogCastContext target, [CanBeNull] Root logEntry, Message message)
{
// Check is inside the method to allow overriding
if (!Options.IsResponseLogged)
{
return;
}
try
{
var response = new Response();
if (Options.LogResponseProperties)
{
response.Properties = CollectProperties(message.Properties);
}
if (Options.LogResponseHttpData)
{
response.HttpHeaders = CollectHttpResponseHeaders(message.Properties);
}
if (Options.LogResponseBody)
{
response.Body = message.ToString();
}
if (logEntry == null)
{
logEntry = new Root();
target.Properties.Add(Root.FieldName, logEntry);
}
logEntry.Response = response;
}
catch (Exception ex)
{
Logger.Error("Failed to log WCF reply message data.", ex);
}
}
private Root ApplyRequestData(LogCastContext context, HttpRequest httpRequest)
{
var request = new Request();
var root = new Root {
Request = request
};
try
{
if (Options.LogRequestUri)
{
request.Uri = httpRequest.Url.ToString();
}
if (Options.LogRequestMethod)
{
request.Method = httpRequest.HttpMethod;
}
if (Options.LogRequestHeaders)
{
request.Headers = CollectHeadersSafely(httpRequest.Headers);
}
if (Options.LogRequestBody)
{
request.Body = RemoveSensitiveData(httpRequest.Form.ToString());
}
context.Properties.Add(Root.FieldName, root);
}
catch (Exception ex)
{
Logger.Error("Failed to log http request data.", ex);
}
return(root);
}
public void BeforeSend(LogCastDocument document, LogCastContext sourceContext)
{
Apply(document);
}
protected override async Task <HttpResponseMessage> SendAsync(
HttpRequestMessage request,
CancellationToken cancellationToken)
{
using (var context = new LogCastContext())
{
HttpResponseMessage response;
try
{
var correlationId = _correlationIdProvider?.Invoke(request);
if (correlationId != null)
{
context.CorrelationId = _correlationIdProvider(request);
}
var httpRoot = new Root();
if (MessageInspector != null)
{
httpRoot.Request = MessageInspector.UseGetRequestAsync
? await MessageInspector.GetRequestAsync(context, request)
: MessageInspector.GetRequest(context, request);
}
var operationName = _operationNameProvider?.Invoke(request);
if (operationName == DefaultOperationStrategy)
{
var routeInfo = httpRoot.Request?.Route;
operationName = routeInfo != null
? routeInfo.Template
: HttpMessageInspector.GetRouteData(request)?.Route?.RouteTemplate;
}
if (operationName != null)
{
context.OperationName = operationName;
}
response = await base.SendAsync(request, cancellationToken);
if (MessageInspector != null)
{
httpRoot.Response = MessageInspector.UseGetResponseAsync
? await MessageInspector.GetResponseAsync(context, response)
: MessageInspector.GetResponse(context, response);
}
if (httpRoot.HasData)
{
context.Properties.Add(Root.FieldName, httpRoot);
}
}
catch (Exception ex)
{
// This catch is only for exceptions raised in subsequent handlers. It doesn't catch action errors
Logger.Error(ex);
throw;
}
return(response);
}
}
public void OnContextClose(LogCastContext context)
{
CheckInitialized();
_client.Send(() => _documentFactory.Create(context, _dispatchInspectors));
}
public void OnContextOpen(LogCastContext context)
{
}
public void OnContextClose(LogCastContext context)
{
}
public CorrelationState(LogCastContext context, TRoot logEntry)
{
Context = context;
LogEntry = logEntry;
}
public override void Arrange()
{
base.Arrange();
LogCastContext = new LogCastContext();
Sut = new HttpMessageInspector(Options);
}
