/// <summary> /// Called after the operation has returned but before the reply message is sent. /// </summary> /// <param name="reply">The reply message. This value is null if the operation is one way.</param> /// <param name="correlationState"> /// The correlation object returned from the /// <see /// cref="M:System.ServiceModel.Dispatcher.IDispatchMessageInspector.AfterReceiveRequest(System.ServiceModel.Channels.Message@,System.ServiceModel.IClientChannel,System.ServiceModel.InstanceContext)" /> /// method. /// </param> public void BeforeSendReply(ref Message reply, object correlationState) { if (_tracer == null) { return; } TraceContext context = TraceContext.Create(Constants.TraceParameter.Name, _webServiceName) .Add(Constants.TraceParameter.Operation, _operationName); string eventName = _webServiceName + "." + _operationName; string message = string.Format(CultureInfo.CurrentCulture, InternalMessages.WebServiceResponse, eventName); _tracer.TraceStopPerformance(_serverSideStartTime, message, TraceEventType.HttpResponse, eventName, context); }
/// <summary> /// Traces the specified message and execution time. /// </summary> /// <param name="message">The optional message, or the caller member if not specified.</param> /// <param name="traceEventType">The optional event type.</param> /// <param name="traceEventName">The calling context.</param> /// <param name="context">The optional contextual trace parameters.</param> /// <remarks> /// If performance measure cannot be done in one method, consider using the /// TraceStartPerformance/TraceStopPerformance methods instead. /// </remarks> /// <code>using (logger.TracePerformance("service call")) {...}</code> public IDisposable TracePerformance(string message = null, TraceEventType traceEventType = TraceEventType.CodeBlock, [System.Runtime.CompilerServices.CallerMemberName] string traceEventName = null, TraceContext context = null) { DateTime startTime = HighResolutionDateTime.UtcNow; if (string.IsNullOrEmpty(message)) { message = string.Format(CultureInfo.CurrentCulture, InternalMessages.MethodCall, traceEventName ?? InternalMessages.EventUnknown); } return (new PerformanceWatch( elapsedTime => TraceInternal(TraceCategory.Performance, 0, traceEventType, traceEventName, startTime, elapsedTime, null, message, context))); }
/// <summary> /// Traces the specified exception. /// </summary> /// <param name="exception">The specified exception.</param> /// <param name="traceEventType">The optional event type.</param> /// <param name="errorCode">The specified code. Optional. By default it is assumed that this is a global level caught exception.</param> /// <param name="context">Trace contextual information.</param> /// <remarks>This is the preferred method to log exceptions caught at global level.</remarks> public void TraceException(Exception exception, TraceEventType traceEventType = TraceEventType.GlobalLevelCaughtError, int errorCode = ErrorCodes.GlobalLevelError, TraceContext context = null) { if (exception == null) { throw new ArgumentNullException(nameof(exception)); } var baseException = exception as BaseException; int realCode = baseException?.ErrorCode ?? errorCode; string message = exception.Message; // try to find our own exceptions supposed to be more meaningfull Exception innerException = GetInnerException(exception, 10); if (innerException != exception) { message += " : " + innerException.Message; var internalBaseException = innerException as BaseException; realCode = internalBaseException?.ErrorCode ?? realCode; } var loadException = innerException as ReflectionTypeLoadException; if (loadException != null) { foreach (var exceptionMessage in loadException.LoaderExceptions.Select(e => e.Message).Distinct()) { message += "\r\n- " + exceptionMessage; } } TraceContext traceContext = context ?? TraceContext.Create(Constants.TraceParameter.ErrorCode, realCode); TraceInternal(TraceCategory.Error, realCode, traceEventType, null, null, null, exception, message, traceContext); }
private void TraceInternal(TraceCategory traceCategory, int errorCode, TraceEventType traceEventType, string traceEventName, DateTime?traceDate, TimeSpan?elapsedTime, Exception exception, string message, TraceContext context) { if (_traceSource == null) { throw new InvalidOperationException("SetSource() must be called before."); } // if no date were specified use now DateTime creationDate = traceDate ?? HighResolutionDateTime.UtcNow; // mapping TraceCategory System.Diagnostics.TraceEventType System.Diagnostics.TraceEventType dotnetTraceEventType = CategoryMapper[traceCategory]; TraceEventData traceEvent = new TraceEventData { CreationDate = creationDate, ContextParameter = context?.ToString(), CorrelationId = GetCorrelationId(), SessionId = GetSessionId(), UserName = GetPrincipalId(), ElapsedTime = elapsedTime, ErrorCode = errorCode, RawException = exception, TraceCategory = traceCategory, TraceEventType = traceEventType, TraceEventName = traceEventName, TraceSourceName = _traceSourceName, TraceSourceType = _traceSourceType, Message = message, }; traceEvent.ComputeAutomaticProperties(); _traceSource.TraceData(dotnetTraceEventType, errorCode, traceEvent); }