private static void DumpThreadAborts(global::Serilog.ILogger logger, LogEventLevel level, Exception exception, ref string messageTemplate)
{
var dump = false;
if (IsTimeoutThreadAbortException(exception))
{
messageTemplate += "\r\nThe thread has been aborted, because the request has timed out.";
// dump if configured, or if stacktrace contains Monitor.ReliableEnter
dump = Current.Configs.CoreDebug().DumpOnTimeoutThreadAbort || IsMonitorEnterThreadAbortException(exception);
// dump if it is ok to dump (might have a cap on number of dump...)
dump &= MiniDump.OkToDump();
}
if (dump)
{
try
{
var dumped = MiniDump.Dump(withException: true);
messageTemplate += dumped
? "\r\nA minidump was created in App_Data/MiniDump"
: "\r\nFailed to create a minidump";
}
catch (Exception ex)
{
messageTemplate += "\r\nFailed to create a minidump";
//Log a new entry (as opposed to appending to same log entry)
logger.Write(level, ex, "Failed to create a minidump ({ExType}: {ExMessage})",
new object[] { ex.GetType().FullName, ex.Message });
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public SeriLogger()
{
if (this.logger == null)
{
this.logger = this.LoggerConfigurator.Service.GetLogger();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SerilogLogger"/> class.
/// </summary>
/// <param name="logger">The logger instance to use.</param>
/// <exception cref="ArgumentNullException">Argument <paramref name="logger"/> is <c>null</c>.</exception>
public SerilogLogger(global::Serilog.ILogger logger)
{
Ensure.Arg.NotNull(logger, nameof(logger));
_logger = logger;
_messageTemplateCache = new MessageTemplateCache();
}
public SerilogLogger(global::Serilog.ILogger logger)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
this.logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="SeriLogger"/> class.
/// </summary>
/// <param name="name">Name of the logger</param>
/// <exception cref="ActivationException">if there are errors resolving the service instance.</exception>
public SeriLogger(string name)
{
if (this.loggerConfigurator == null)
{
this.loggerConfigurator = ServiceLocator.Current.GetInstance <ILoggerConfigurator>();
}
this.logger = this.loggerConfigurator.GetLogger(name: name);
}
/// <summary>
/// Add Serilog to the logging pipeline.
/// </summary>
/// <param name="factory">The logger factory to configure.</param>
/// <param name="logger">The Serilog logger; if not supplied, the static Serilog.Log will be used.</param>
/// <returns>The logger factory.</returns>
public static ILoggerFactory AddSerilog(this ILoggerFactory factory, global::Serilog.ILogger logger)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
return(factory.AddSerilog(logger, false));
}
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;
}
/// <summary>
/// Configures log4net to log to Serilog.
/// </summary>
/// <param name="logger">The serilog logger (if left null Log.Logger will be used).</param>
public static void Configure(global::Serilog.ILogger logger = null)
{
var serilogAppender = new Log4net.Appender.Serilog.SerilogAppender(logger);
serilogAppender.ActivateOptions();
var loggerRepository = (log4net.Repository.Hierarchy.Hierarchy)log4net.LogManager.GetRepository();
loggerRepository.Root.AddAppender(serilogAppender);
loggerRepository.Configured = true;
}
public SerilogJsonLogViewer(
ILogger <SerilogJsonLogViewer> logger,
ILogViewerConfig logViewerConfig,
ILoggingConfiguration loggingConfiguration,
global::Serilog.ILogger serilogLog)
: base(logViewerConfig, serilogLog)
{
_logger = logger;
_logsPath = loggingConfiguration.LogDirectory;
}
/// <summary>
/// Add Serilog to the logging pipeline.
/// </summary>
/// <param name="factory">The logger factory to configure.</param>
/// <param name="logger">The Serilog logger; if not supplied, the static Serilog.Log will be used.</param>
/// <param name="dispose">When true, dispose <paramref name="logger"/> when the framework disposes the provider. If the
/// logger is not specified but <paramref name="dispose"/> is true, the Log.CloseAndFlush() method will be
/// called on the static Log class instead.</param>
/// <returns>The logger factory.</returns>
public static ILoggerFactory AddSerilog(this ILoggerFactory factory, global::Serilog.ILogger logger = null, bool dispose = false)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
factory.AddProvider(new SerilogLoggerProvider(logger, dispose));
return(factory);
}
public SerilogLogger(Type type)
{
_logger = Log.ForContext(type);
_map = new Dictionary <LogSeverityLevel, LogWriterProvider>
{
{ LogSeverityLevel.Verbose, e => _logger.Debug(e.ToString()) },
{ LogSeverityLevel.Debug, e => _logger.Debug(e.ToString()) },
{ LogSeverityLevel.Information, e => _logger.Information(e.ToString()) },
{ LogSeverityLevel.Warning, e => _logger.Warning(e.ToString()) },
{ LogSeverityLevel.Error, e => _logger.Error(e.ToString()) },
{ LogSeverityLevel.Critical, e => _logger.Fatal(e.ToString()) }
};
}
/// <summary>
/// Initializes a new instance of the <see cref="SerilogLoggerProvider"/> class.
/// </summary>
/// <remarks>
/// If <paramref name="logger"/> is <c>null</c>, the static <see cref="Log.Logger"/> is used.
/// </remarks>
/// <param name="logger">The <see cref="T:global::Serilog.ILogger"/> used.</param>
/// <param name="dispose">Whether to dispose the logger.</param>
public SerilogLoggerProvider(global::Serilog.ILogger logger, bool dispose = false)
{
if (logger == null)
{
_logger = Log.Logger;
_dispose = dispose ? new Action(Log.CloseAndFlush)
: null;
}
else
{
_logger = logger;
_dispose = dispose && logger is IDisposable
? new Action(() => ((IDisposable)_logger).Dispose())
: null;
}
}
public SerilogLogger(SerilogLoggerProvider provider, global::Serilog.ILogger logger = null, string name = null)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
_provider = provider;
_logger = logger;
// If a logger was passed, the provider has already added itself as an enricher
_logger = _logger ?? global::Serilog.Log.Logger.ForContext(new[] { provider });
if (name != null)
{
_logger = _logger.ForContext(Constants.SourceContextPropertyName, name);
}
}
/// <summary>
/// Construct a <see cref="SerilogLoggerProvider"/>.
/// </summary>
/// <param name="logger">A Serilog logger to pipe events through; if null, the static <see cref="Log"/> class will be used.</param>
/// <param name="dispose">If true, the provided logger or static log class will be disposed/closed when the provider is disposed.</param>
public SerilogLoggerProvider(global::Serilog.ILogger logger = null, bool dispose = false)
{
if (logger != null)
{
_logger = logger.ForContext(new[] { this });
}
if (dispose)
{
if (logger != null)
{
_dispose = () => (logger as IDisposable)?.Dispose();
}
else
{
_dispose = Log.CloseAndFlush;
}
}
}
protected SerilogLogViewerSourceBase(ILogViewerConfig logViewerConfig, ILogLevelLoader logLevelLoader, global::Serilog.ILogger serilogLog)
{
_logViewerConfig = logViewerConfig;
_logLevelLoader = logLevelLoader;
_serilogLog = serilogLog;
}
public SerilogAppender()
{
_Logger = null;
}
public SerilogLoggerProvider([NotNull] global::Serilog.LoggerConfiguration loggerConfiguration)
{
_logger = loggerConfiguration
.Enrich.With(this)
.CreateLogger();
}
protected SerilogLogViewerSourceBase(ILogViewerConfig logViewerConfig, global::Serilog.ILogger serilogLog)
{
_logViewerConfig = logViewerConfig;
_logLevelLoader = StaticServiceProvider.Instance.GetRequiredService <ILogLevelLoader>();
_serilogLog = serilogLog;
}
public SerilogLogger(global::Serilog.ILogger logger)
{
_Logger = logger;
}
public LoggerFactory(global::Serilog.ILogger logger)
{
_logger = logger;
}
public SerilogLogger(global::Serilog.ILogger logger, DiagnosticContext diagnosticContext)
: base(logger.ForContext <TSource>(), diagnosticContext)
{
}
public SerilogLogger()
{
this.logger = global::Serilog.Log.ForContext <T>();
}
public SerilogSmtpServerLoggingBridge(global::Serilog.ILogger serilog)
{
this._serilog = serilog.ForContext <global::SmtpServer.SmtpServer>();
}
public Logger(global::Serilog.ILogger logger)
{
this.logger = logger;
}
public SerilogLogger(LoggerConfiguration logConfig)
{
//Configure Serilog static global logger with config passed in
SerilogLog = logConfig.CreateLogger();
}
public SerilogService(global::Serilog.ILogger logger)
{
_logger = logger;
}
public GalaxySerilogLogger(global::Serilog.ILogger logger)
{
_logger = logger;
}
public SerilogAppender(global::Serilog.ILogger logger = null)
{
_Logger = logger;
}
public static IEnumerable <LogEventProperty> GetSerilogProperties(this LogEvent @event, global::Serilog.ILogger logger)
{
IReadOnlyList <LogProperty> eventProperties = @event.Properties;
var properties = new LogEventProperty[eventProperties.Count + 1];
for (int i = 0; i < eventProperties.Count; i++)
{
logger.BindProperty(eventProperties[i].Name, eventProperties[i].Value, true, out LogEventProperty logEventProperty);
properties[i] = logEventProperty;
}
properties[eventProperties.Count] = new LogEventProperty(
SerilogPropertyNames.EventId,
new ScalarValue(@event.Id));
return(properties);
}
internal LogAdapter(global::Serilog.ILogger logger)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public GalaxySerilogLogger(global::Serilog.ILogger logger, ILogConfigurations logConfigurations)
{
_logger = logger;
_logConfigurations = logConfigurations;
}
public SerilogLoggerFactory(global::Serilog.ILogger logger, DiagnosticContext diagnosticContext)
{
_diagnosticContext = diagnosticContext.NotNull(nameof(diagnosticContext));
_logger = logger.NotNull(nameof(logger));
}
public static void Register(global::Serilog.ILogger logger)
{
Locator.CurrentMutable.UseSerilogWithWrappingFullLogger(logger);
}
public SerilogLogger(global::Serilog.ILogger serilogLogger)
{
this.serilogLogger = serilogLogger;
}
public Logger(global::Serilog.ILogger serilog)
{
_serilog = serilog;
}
