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); }