/// <summary>
/// Set enricher
/// </summary>
/// <param name="enricher"></param>
public void SetEnricher(ILogEventEnricher enricher)
{
if (enricher != null)
{
LogEventEnricherManager.UpdateEnricher(enricher);
}
}
public async Task Invoke(HttpContext context, ILogEventEnricher logEventEnricher)
{
using (LogContext.Push(logEventEnricher))
{
await _next(context);
}
}
public ILogger ForContext(ILogEventEnricher enricher)
{
if (enricher == null)
{
return(this);
}
if (_frozen)
{
return(_cached.ForContext(enricher));
}
if (_reloadableLogger.CreateChild(
_root,
this,
_cached,
p => p.ForContext(enricher),
out var child,
out var newRoot,
out var newCached,
out var frozen))
{
Update(newRoot, newCached, frozen);
}
return(child);
}
internal Logger(
LoggingLevelSwitch levelSwitch,
ILogEventSink sink,
ILogEventEnricher enricher,
Action dispose = null,
LevelOverrideMap overrideMap = null)
: this(sink, enricher, dispose, levelSwitch, overrideMap)
{
}
public Logger(ILogEventEnricher enricher)
{
if (enricher is null)
{
throw new ArgumentNullException(nameof(enricher));
}
logger = new LoggerConfiguration().WriteTo.Console(outputTemplate: ConsoleTemplate).Enrich.With(enricher).Enrich.With(new ActivityEnrich()).CreateLogger();
}
internal static void UpdateEnricher(ILogEventEnricher enricher)
{
if (enricher == null)
{
throw new ArgumentNullException(nameof(enricher));
}
_enrichers.Add(enricher);
}
public ILogEventEnricher[] CreateAllEnrichers()
{
var enrichersList = new ILogEventEnricher[]
{
new ThreadIdEnricher(),
new EnvironmentEnricher(this._config)
};
return(enrichersList);
}
internal static string Resolve(ILogEventEnricher enricher)
{
var key = enricher.GetType().Name;
if (_values.ContainsKey(key))
{
return(_values[key]());
}
return(null);
}
private static ILogEventEnricher[] GetEnrichers()
{
var enrichers = new ILogEventEnricher[]
{
new MachineNameEnricher(),
new PropertyEnricher("ApplicationName", ConfigurationManager.AppSettings["Application.Name"]),
new PropertyEnricher("Environment", ConfigurationManager.AppSettings["Environment"])
};
return(enrichers);
}
/// <summary>
/// Create a logger that enriches log events via the provided enrichers.
/// </summary>
/// <param name="enricher">Enricher that applies in the context.</param>
/// <returns>A logger that will enrich log events as specified.</returns>
public Logger ForContext(ILogEventEnricher enricher)
{
if (enricher == null)
{
return(this); // No context here, so little point writing to SelfLog.
}
return(new Logger(
this,
enricher,
null,
_levelSwitch,
_overrideMap));
}
// The messageTemplateProcessor, sink and enricher are required. Argument checks are dropped because
// throwing from here breaks the logger's no-throw contract, and callers are all in this file anyway.
Logger(
ILogEventSink sink,
ILogEventEnricher enricher,
Action dispose = null,
LoggingLevelSwitch levelSwitch = null,
LevelOverrideMap overrideMap = null)
{
_sink = sink;
_dispose = dispose;
_levelSwitch = levelSwitch;
_overrideMap = overrideMap;
_enricher = enricher;
}
/// <summary>
/// Push an enricher onto the context, returning an <see cref="IDisposable"/>
/// that must later be used to remove the property, along with any others that
/// may have been pushed on top of it and not yet popped. The property must
/// be popped from the same thread/logical call context.
/// </summary>
/// <param name="enricher">An enricher to push onto the log context</param>
/// <returns>A token that must be disposed, in order, to pop properties back off the stack.</returns>
/// <exception cref="ArgumentNullException"></exception>
public static IDisposable Push(ILogEventEnricher enricher)
{
if (enricher == null)
{
throw new ArgumentNullException(nameof(enricher));
}
var stack = GetOrCreateEnricherStack();
var bookmark = new ContextStackBookmark(stack);
Enrichers = stack.Push(enricher);
return(bookmark);
}
public ILogger ForContext(ILogEventEnricher enricher)
{
if (enricher == null)
{
return(this);
}
if (_frozen)
{
return(_cached.ForContext(enricher));
}
return(new CachingReloadableLogger(_reloadableLogger, _root, this, p => p.ForContext(enricher)));
}
public ILogger ForContext(ILogEventEnricher enricher)
{
if (enricher == null)
{
return(this);
}
if (_frozen)
{
return(_logger.ForContext(enricher));
}
lock (_sync)
return(new CachingReloadableLogger(this, _logger, this, p => p.ForContext(enricher)));
}
public async Task <T> Send <T>(IRequest <T> command)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
var meta = new Metadata
{
AccessToken = _metadata.AccessToken,
TraceId = Guid.NewGuid().ToString()
};
var envelope = new MessageEnvelope
{
Meta = meta,
Payload = command
};
var diagnosticProperties = new ILogEventEnricher[]
{
new PropertyEnricher("ConnectionId", _hubConnection.ConnectionId),
new PropertyEnricher("TraceId", meta.TraceId),
new PropertyEnricher("CommandType", command.GetType().Name)
};
using (LogContext.Push(diagnosticProperties))
{
var result = await _retryPolicy.ExecuteAsync(async() =>
{
try
{
using (_logger.BeginTimedOperation(OperationDescription))
{
return(await SendInternal <T>(envelope));
}
}
catch (Exception ex)
{
var level = ex is UserException ? LogEventLevel.Warning : LogEventLevel.Error;
_logger.Write(level, ex, "[SignalRClient:{ConnectionId}:{TraceId}] {ErrorMessage}",
_hubConnection.ConnectionId,
envelope.Meta.TraceId,
ex.Message);
throw;
}
});
return(result);
}
}
public void User_Enricher_should_add_the_correct_user_id_property(string userID, string userName)
{
var enrichers = new ILogEventEnricher[]
{
new UserEnricher(new Enrichers.UserEnrichment()
{
GetUserID = () => userID,
GetUserName = () => userName
})
};
Logging.InitializeLogging(_config, enrichers, _sinks);
using (TestCorrelator.CreateContext())
{
Log.Error("Test Error");
TestCorrelator.GetLogEventsFromCurrentContext().ShouldHaveSingleItem().Properties["UserID"].ToString().Replace("\"", string.Empty).ShouldBe(userID);
}
}
public void User_Enricher_should_add_two_properties_with_expected_keys(string userID, string userName)
{
var enrichers = new ILogEventEnricher[]
{
new UserEnricher(new Enrichers.UserEnrichment()
{
GetUserID = () => userID,
GetUserName = () => userName
})
};
Logging.InitializeLogging(_config, enrichers, _sinks);
using (TestCorrelator.CreateContext())
{
Log.Error("Test Error");
TestCorrelator.GetLogEventsFromCurrentContext().ShouldHaveSingleItem().Properties.Keys.ShouldContain("UserName", "UserID");
}
}
public override Task OnDisconnected(bool stopCalled)
{
var props = new ILogEventEnricher[]
{
new PropertyEnricher("ConnectionId", Context.ConnectionId),
new PropertyEnricher("StopCalled", stopCalled)
};
using (LogContext.Push(props))
{
var removed = Connections.TryRemove(Context.ConnectionId, out GameHubConnection hubConnection);
if (!removed)
{
return(Task.CompletedTask);
}
_connectionsGauge.Write();
hubConnection.Dispose();
return(base.OnDisconnected(stopCalled));
}
}
public async Task <TResponse> Handle(CommandEnvelope <TCommand, TResponse> message,
RequestHandlerDelegate <TResponse> next)
{
var context = message.Context;
var diagnosticProperties = new ILogEventEnricher[]
{
new PropertyEnricher("TraceId", context.Metadata.TraceId),
new PropertyEnricher("UserId", context.UserId),
new PropertyEnricher("ConnectionId", context.Connection.Id),
new PropertyEnricher("CommandType", message.Command.GetType().Name)
};
using (LogContext.Push(diagnosticProperties))
{
try
{
_received.Increment();
_logger.Debug("[Handler:{TraceId}:{UserId}] Received {CommandType}: {@Command}",
context.Metadata.TraceId,
context.UserId,
message.Command.GetType().Name,
message.Command);
TResponse response;
using (_logger.BeginTimedOperation(OperationDescription))
{
response = await next.Invoke();
}
_logger.Debug("[Handler:{TraceId}:{UserId}] Handled {CommandType} successfully: {@Response}",
context.Metadata.TraceId,
context.UserId,
message.Command.GetType().Name,
response);
return(response);
}
finally
{
_processed.Increment();
}
}
}
public async Task Invoke(HttpContext httpContext)
{
var bodyStream = httpContext.Response.Body;
var responseBodyStream = new MemoryStream();
try
{
httpContext.Response.Body = responseBodyStream;
await _next(httpContext);
if (httpContext.Response?.StatusCode > 399)
{
responseBodyStream.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(responseBodyStream);
var responseContent = await reader.ReadToEndAsync();
var enrichers = new ILogEventEnricher[]
{
new PropertyEnricher(nameof(httpContext.Response.ContentType), httpContext.Response.ContentType),
new PropertyEnricher(nameof(httpContext.Response.StatusCode), httpContext.Response.StatusCode),
new PropertyEnricher("ResponseContent", responseContent)
};
using (LogContext.Push(enrichers))
{
Logger.Error($"Request processed with {httpContext.Response.StatusCode}.");
}
}
}
finally
{
responseBodyStream.Seek(0, SeekOrigin.Begin);
await responseBodyStream.CopyToAsync(bodyStream);
httpContext.Response.Body = bodyStream;
responseBodyStream.Dispose();
}
}
public async Task Handle(IBotNotification <IClientEvent> notification)
{
var context = notification.Context;
var @event = notification.Event;
_processed = _processed ??
context.Logger.CountOperation(ProcessedCounterName, resolution: ProcessedCounterResolution);
var diagnosticProperties = new ILogEventEnricher[]
{
new PropertyEnricher("ConnectionId", context.Connection.Id),
new PropertyEnricher("BotId", context.BotId),
new PropertyEnricher("UserId", context.UserId),
new PropertyEnricher("EventType", notification.Event.GetType().Name)
};
using (LogContext.Push(diagnosticProperties))
{
context.Logger.Debug("[Bot:{BotId}:{UserId}] Started to handle {EventType}.",
context.BotId,
context.UserId,
@event.GetType().Name);
try
{
using (context.Logger.BeginTimedOperation(OperationDescription))
{
await _next.Handle(notification);
}
}
finally
{
_processed.Increment();
context.Logger.Debug("[Bot:{BotId}:{UserId}] Finished to handle {EventType}.",
context.BotId,
context.UserId,
@event.GetType().Name);
}
}
}
public ILogger ForContext(ILogEventEnricher enricher)
{
throw new NotImplementedException();
}
internal static LoggerConfiguration With(LoggerEnrichmentConfiguration loggerEnrichmentConfiguration, ILogEventEnricher enricher)
{
return(loggerEnrichmentConfiguration.With(enricher));
}
public ILogger ForContext(ILogEventEnricher enricher)
{
return(this);
}
// .Enrich...
// =======
// expose `With(params ILogEventEnricher[] enrichers)` as if it was `With(ILogEventEnricher enricher)`
static LoggerConfiguration With(
LoggerEnrichmentConfiguration loggerEnrichmentConfiguration,
ILogEventEnricher enricher)
=> loggerEnrichmentConfiguration.With(enricher);
// IAuditLogger Members
public ILogger ForContext(ILogEventEnricher enricher)
{
return(_logger.ForContext(enricher));
}
/// <inheritdoc /> public ILogger ForContext(ILogEventEnricher enricher) => this;
public ILogger ForContext(ILogEventEnricher enricher)
{
return(new LoggerConfiguration().CreateLogger());
}
/// <summary>
/// Create a logger that enriches log events via the provided enrichers.
/// </summary>
/// <param name="logger">The logger</param>
/// <param name="enricher">Enricher that applies in the context.</param>
/// <returns>A logger that will enrich log events as specified.</returns>
public static ILog ForContext(this ILog logger, ILogEventEnricher enricher)
{
return((logger as SerilogLogger)?.ForContext(enricher));
}
internal ILog ForContext(ILogEventEnricher enricher)
{
return(new SerilogLogger(log.ForContext(enricher)));
}