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