public RollingFileSink(string path, ITextFormatter textFormatter, long?fileSizeLimitBytes, int?retainedFileCountLimit, Encoding encoding, bool buffered, bool shared, RollingInterval rollingInterval, bool rollOnFileSizeLimit) { if (path == null) { throw new ArgumentNullException(nameof(path)); } if (fileSizeLimitBytes.HasValue && fileSizeLimitBytes < 0) { throw new ArgumentException("Negative value provided; file size limit must be non-negative"); } if (retainedFileCountLimit.HasValue && retainedFileCountLimit < 1) { throw new ArgumentException("Zero or negative value provided; retained file count limit must be at least 1"); } _roller = new PathRoller(path, rollingInterval); _textFormatter = textFormatter; _fileSizeLimitBytes = fileSizeLimitBytes; _retainedFileCountLimit = retainedFileCountLimit; _encoding = encoding; _buffered = buffered; _shared = shared; _rollOnFileSizeLimit = rollOnFileSizeLimit; }
public PathRoller(string path, RollingInterval interval) { if (path == null) { throw new ArgumentNullException(nameof(path)); } _interval = interval; _periodFormat = interval.GetFormat(); var pathDirectory = Path.GetDirectoryName(path); if (string.IsNullOrEmpty(pathDirectory)) { pathDirectory = Directory.GetCurrentDirectory(); } _directory = Path.GetFullPath(pathDirectory); _filenamePrefix = Path.GetFileNameWithoutExtension(path); _filenameSuffix = Path.GetExtension(path); _filenameMatcher = new Regex( "^" + Regex.Escape(_filenamePrefix) + "(?<" + PeriodMatchGroup + ">\\d{" + _periodFormat.Length + "})" + "(?<" + SequenceNumberMatchGroup + ">_[0-9]{3,}){0,1}" + Regex.Escape(_filenameSuffix) + "$"); DirectorySearchPattern = $"{_filenamePrefix}*{_filenameSuffix}"; }
/// <summary>Use Serilog as the logger. /// </summary> /// <returns></returns> public static Configuration UseSerilog(this Configuration configuration, string defaultLoggerName = "default", string defaultLoggerFileName = "default", string defaultLoggerFileExtensions = "-.log", string contextPropertyName = "logger", string defaultLoggerConsoleOutputTemplate = "{Timestamp:yyyy-MM-dd HH:mm:ss.fff} [{Level:u3}] - {Message:lj}{NewLine}{Exception}", string defaultLoggerFileOutputTemplate = "{Timestamp:yyyy-MM-dd HH:mm:ss.fff} [{Level:u3}] [{logger}] - {Message:lj}{NewLine}{Exception}", bool defaultLoggerFileBuffered = true, long?defaultLoggerFileSizeLimitBytes = null, RollingInterval defaultLoggerFileRollingInterval = RollingInterval.Day, bool defaultLoggerFileRollOnFileSizeLimit = true, int?defaultLoggerFileRetainedFileCountLimit = null, int?defaultLoggerFileFlushToDiskIntervalSenconds = 1, LogEventLevel consoleMinimumLevel = LogEventLevel.Information, LogEventLevel fileMinimumLevel = LogEventLevel.Information) { return(UseSerilog(configuration, new SerilogLoggerFactory( defaultLoggerName, defaultLoggerFileName, defaultLoggerFileExtensions, contextPropertyName, defaultLoggerConsoleOutputTemplate, defaultLoggerFileOutputTemplate, defaultLoggerFileBuffered, defaultLoggerFileSizeLimitBytes, defaultLoggerFileRollingInterval, defaultLoggerFileRollOnFileSizeLimit, defaultLoggerFileRetainedFileCountLimit, defaultLoggerFileFlushToDiskIntervalSenconds, consoleMinimumLevel, fileMinimumLevel))); }
/// <summary> /// /// </summary> /// <param name="filePath">Absolute or relative path to the log file.</param> /// <param name="rollingInterval">Interval, after which the logs will be rotated.</param> /// <param name="innerLogger">Inner logger that will possibly log to some other place.</param> public FileLogger(string filePath, RollingInterval rollingInterval, LoggerBase innerLogger = null) : base(innerLogger) { _logger = new LoggerConfiguration() .MinimumLevel.Debug() .WriteTo.File(filePath, rollingInterval: rollingInterval) .CreateLogger(); }
public static LoggerConfiguration ConfigueRollingFile(this LoggerSinkConfiguration configuration, ITextFormatter formatter, bool shared = true, bool buffered = false, int retainedFileCountLimit = 31, int fileSizeLimitBytes = 1073741824, LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum, string path = null, RollingInterval rollingInterval = RollingInterval.Day) { return(configuration.File(formatter, path ?? Path.Combine( #if NETFULL AppDomain.CurrentDomain.BaseDirectory #else AppContext.BaseDirectory #endif , "logs", "log.log"), restrictedToMinimumLevel: restrictedToMinimumLevel, fileSizeLimitBytes: fileSizeLimitBytes, retainedFileCountLimit: retainedFileCountLimit, shared: shared, buffered: buffered, rollOnFileSizeLimit: true, rollingInterval: rollingInterval )); }
public static DateTime?GetCurrentCheckpoint(this RollingInterval interval, DateTime instant) { switch (interval) { case RollingInterval.Infinite: return(null); case RollingInterval.Year: return(new DateTime(instant.Year, 1, 1, 0, 0, 0, instant.Kind)); case RollingInterval.Month: return(new DateTime(instant.Year, instant.Month, 1, 0, 0, 0, instant.Kind)); case RollingInterval.Day: return(new DateTime(instant.Year, instant.Month, instant.Day, 0, 0, 0, instant.Kind)); case RollingInterval.Hour: return(new DateTime(instant.Year, instant.Month, instant.Day, instant.Hour, 0, 0, instant.Kind)); case RollingInterval.Minute: return(new DateTime(instant.Year, instant.Month, instant.Day, instant.Hour, instant.Minute, 0, instant.Kind)); default: throw new ArgumentException("Invalid rolling interval"); } }
/// <summary> /// Write log events to the specified file. /// </summary> /// <param name="sinkConfiguration">Logger sink configuration.</param> /// <param name="formatter">A formatter, such as <see cref="JsonFormatter"/>, to convert the log events into /// text for the file. If control of regular text formatting is required, use the other /// overload of <see cref="File(LoggerSinkConfiguration, string, LogEventLevel, string, IFormatProvider, long?, LoggingLevelSwitch, bool, bool, TimeSpan?, RollingInterval, bool, int?, Encoding, FileLifecycleHooks)"/> /// and specify the outputTemplate parameter instead. /// </param> /// <param name="path">Path to the file.</param> /// <param name="restrictedToMinimumLevel">The minimum level for /// events passed through the sink. Ignored when <paramref name="levelSwitch"/> is specified.</param> /// <param name="levelSwitch">A switch allowing the pass-through minimum level /// to be changed at runtime.</param> /// <param name="fileSizeLimitBytes">The approximate maximum size, in bytes, to which a log file will be allowed to grow. /// For unrestricted growth, pass null. The default is 1 GB. To avoid writing partial events, the last event within the limit /// will be written in full even if it exceeds the limit.</param> /// <param name="buffered">Indicates if flushing to the output file can be buffered or not. The default /// is false.</param> /// <param name="shared">Allow the log file to be shared by multiple processes. The default is false.</param> /// <param name="flushToDiskInterval">If provided, a full disk flush will be performed periodically at the specified interval.</param> /// <param name="rollingInterval">The interval at which logging will roll over to a new file.</param> /// <param name="rollOnFileSizeLimit">If <code>true</code>, a new file will be created when the file size limit is reached. Filenames /// will have a number appended in the format <code>_NNN</code>, with the first filename given no number.</param> /// <param name="retainedFileCountLimit">The maximum number of log files that will be retained, /// including the current log file. For unlimited retention, pass null. The default is 31.</param> /// <param name="encoding">Character encoding used to write the text file. The default is UTF-8 without BOM.</param> /// <param name="hooks">Optionally enables hooking into log file lifecycle events.</param> /// <returns>Configuration object allowing method chaining.</returns> public static LoggerConfiguration File( this LoggerSinkConfiguration sinkConfiguration, ITextFormatter formatter, string path, LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum, long?fileSizeLimitBytes = DefaultFileSizeLimitBytes, LoggingLevelSwitch levelSwitch = null, bool buffered = false, bool shared = false, TimeSpan?flushToDiskInterval = null, RollingInterval rollingInterval = RollingInterval.Infinite, bool rollOnFileSizeLimit = false, int?retainedFileCountLimit = DefaultRetainedFileCountLimit, Encoding encoding = null, FileLifecycleHooks hooks = null) { if (sinkConfiguration == null) { throw new ArgumentNullException(nameof(sinkConfiguration)); } if (formatter == null) { throw new ArgumentNullException(nameof(formatter)); } if (path == null) { throw new ArgumentNullException(nameof(path)); } return(ConfigureFile(sinkConfiguration.Sink, formatter, path, restrictedToMinimumLevel, fileSizeLimitBytes, levelSwitch, buffered, false, shared, flushToDiskInterval, encoding, rollingInterval, rollOnFileSizeLimit, retainedFileCountLimit, hooks)); }
/// <summary> /// Gets the next check point as <see cref="DateTime"/>. /// </summary> /// <param name="interval">The interval.</param> /// <param name="dateTime">The date time.</param> /// <returns>The next check point as <see cref="DateTime"/>.</returns> public static DateTime?GetNextCheckpoint(this RollingInterval interval, DateTime dateTime) { var current = GetCurrentCheckpoint(interval, dateTime); if (current is null) { return(null); } // ReSharper disable once SwitchStatementHandlesSomeKnownEnumValuesWithDefault switch (interval) { case RollingInterval.Year: return(current.Value.AddYears(1)); case RollingInterval.Month: return(current.Value.AddMonths(1)); case RollingInterval.Day: return(current.Value.AddDays(1)); case RollingInterval.Hour: return(current.Value.AddHours(1)); case RollingInterval.Minute: return(current.Value.AddMinutes(5)); default: throw new ArgumentException("Invalid rolling interval"); } }
/// <summary> /// Initializes a new instance of the <see cref="AmazonS3Sink" /> class. /// </summary> /// <param name="formatter">The formatter.</param> /// <param name="path">The path.</param> /// <param name="fileSizeLimitBytes">The file size limit bytes.</param> /// <param name="buffered">if set to <c>true</c> [buffered].</param> /// <param name="encoding">The encoding.</param> /// <param name="rollingInterval">The rolling interval.</param> /// <param name="retainedFileCountLimit">The retained file count limit.</param> /// <param name="hooks">The hooks.</param> /// <param name="bucketName">The Amazon S3 bucket name.</param> /// <param name="endpoint">The Amazon S3 endpoint.</param> /// <param name="awsAccessKeyId">The Amazon S3 access key id.</param> /// <param name="awsSecretAccessKey">The Amazon S3 secret access key.</param> /// <returns>A <see cref="LoggerConfiguration" /> to use with Serilog.</returns> /// <exception cref="ArgumentNullException"> /// addSink /// or /// formatter /// or /// path /// </exception> /// <exception cref="ArgumentException"> /// Negative value provided; file size limit must be non-negative. - fileSizeLimitBytes /// or /// At least one file must be retained. - retainedFileCountLimit /// or /// Buffered writes are not available when file sharing is enabled. - buffered /// or /// File lifecycle hooks are not currently supported for shared log files. - hooks /// </exception> public AmazonS3Sink( ITextFormatter formatter, string path, long?fileSizeLimitBytes, bool buffered, Encoding encoding, RollingInterval rollingInterval, int?retainedFileCountLimit, FileLifecycleHooks hooks, string bucketName, RegionEndpoint endpoint, string awsAccessKeyId, string awsSecretAccessKey) { if (string.IsNullOrWhiteSpace(path)) { throw new ArgumentNullException(nameof(path)); } if (string.IsNullOrWhiteSpace(bucketName)) { throw new ArgumentNullException(nameof(bucketName)); } if (string.IsNullOrWhiteSpace(awsAccessKeyId)) { throw new ArgumentNullException(nameof(awsAccessKeyId)); } if (string.IsNullOrWhiteSpace(awsSecretAccessKey)) { throw new ArgumentNullException(nameof(awsSecretAccessKey)); } if (fileSizeLimitBytes.HasValue && fileSizeLimitBytes < 0) { throw new ArgumentException("Negative value provided; file size limit must be non-negative."); } if (retainedFileCountLimit.HasValue && retainedFileCountLimit < 1) { throw new ArgumentException( "Zero or negative value provided; retained file count limit must be at least 1."); } this.sink = new RollingFileSink( path, formatter, fileSizeLimitBytes, retainedFileCountLimit, encoding, buffered, rollingInterval, true, hooks, bucketName, endpoint, awsAccessKeyId, awsSecretAccessKey); }
public static string GetFormat(this RollingInterval interval) { switch (interval) { case RollingInterval.Infinite: return(""); case RollingInterval.Year: return("yyyy"); case RollingInterval.Month: return("yyyyMM"); case RollingInterval.Day: return("yyyyMMdd"); case RollingInterval.Hour: return("yyyyMMddHH"); case RollingInterval.Minute: return("yyyyMMddHHmm"); default: throw new ArgumentException("Invalid rolling interval"); } }
public static DateTime?GetNextCheckpoint(this RollingInterval interval, DateTime instant) { var current = GetCurrentCheckpoint(interval, instant); if (current == null) { return(null); } switch (interval) { case RollingInterval.Year: return(current.Value.AddYears(1)); case RollingInterval.Month: return(current.Value.AddMonths(1)); case RollingInterval.Day: return(current.Value.AddDays(1)); case RollingInterval.Hour: return(current.Value.AddHours(1)); case RollingInterval.Minute: return(current.Value.AddMinutes(1)); default: throw new ArgumentException("Invalid rolling interval"); } }
private string FormatDate(DateTime dateTime, RollingInterval rollingInterval) { switch (rollingInterval) { case RollingInterval.Infinite: return(""); case RollingInterval.Year: return(dateTime.ToString("yyyy")); case RollingInterval.Month: return(dateTime.ToString("yyyyMM")); case RollingInterval.Day: return(dateTime.ToString("yyyyMMdd")); case RollingInterval.Hour: return(dateTime.ToString("yyyyMMddhh")); case RollingInterval.Minute: return(dateTime.ToString("yyyyMMddhhmm")); default: return(dateTime.ToString("yyyyMMdd")); } }
public string Format(DateTime dateTime, string name, RollingInterval rollingInterval) { var date = FormatDate(dateTime, rollingInterval); var trimmedName = name.Trim('-'); // Trim for back compatibility with prefixes containing dash on start return($"{date}{DateAndNameDelimiter}{trimmedName}.log"); }
/// <remarks> /// Used in config - If renamed or moved to other assembly the config file also has be updated. /// </remarks> public static LoggerConfiguration File(this LoggerSinkConfiguration configuration, ITextFormatter formatter, string path, LogEventLevel restrictedToMinimumLevel = LogEventLevel.Verbose, LoggingLevelSwitch levelSwitch = null, long?fileSizeLimitBytes = 1073741824, TimeSpan?flushToDiskInterval = null, RollingInterval rollingInterval = RollingInterval.Infinite, bool rollOnFileSizeLimit = false, int?retainedFileCountLimit = 31, Encoding encoding = null ) { return(configuration.Async( asyncConfiguration => asyncConfiguration.Map(AppDomainId, (_, mapConfiguration) => mapConfiguration.File( formatter, path, restrictedToMinimumLevel, fileSizeLimitBytes, levelSwitch, buffered: true, shared: false, flushToDiskInterval, rollingInterval, rollOnFileSizeLimit, retainedFileCountLimit, encoding), sinkMapCountLimit: 0) )); }
/// <summary> /// Write log events to the specified file. /// </summary> /// <param name="sinkConfiguration">Logger sink configuration.</param> /// <param name="path">Path to the file.</param> /// <param name="restrictedToMinimumLevel">The minimum level for /// events passed through the sink. Ignored when <paramref name="levelSwitch"/> is specified.</param> /// <param name="levelSwitch">A switch allowing the pass-through minimum level /// to be changed at runtime.</param> /// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param> /// <param name="outputTemplate">A message template describing the format used to write to the sink. /// the default is "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}".</param> /// <param name="fileSizeLimitBytes">The approximate maximum size, in bytes, to which a log file will be allowed to grow. /// For unrestricted growth, pass null. The default is 1 GB. To avoid writing partial events, the last event within the limit /// will be written in full even if it exceeds the limit.</param> /// <param name="buffered">Indicates if flushing to the output file can be buffered or not. The default /// is false.</param> /// <param name="shared">Allow the log file to be shared by multiple processes. The default is false.</param> /// <param name="flushToDiskInterval">If provided, a full disk flush will be performed periodically at the specified interval.</param> /// <param name="rollingInterval">The interval at which logging will roll over to a new file.</param> /// <param name="rollOnFileSizeLimit">If <code>true</code>, a new file will be created when the file size limit is reached. Filenames /// will have a number appended in the format <code>_NNN</code>, with the first filename given no number.</param> /// <param name="retainedFileCountLimit">The maximum number of log files that will be retained, /// including the current log file. For unlimited retention, pass null. The default is 31.</param> /// <param name="encoding">Character encoding used to write the text file. The default is UTF-8 without BOM.</param> /// <returns>Configuration object allowing method chaining.</returns> /// <remarks>The file will be written using the UTF-8 character set.</remarks> public static LoggerConfiguration File( this LoggerSinkConfiguration sinkConfiguration, string path, LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum, string outputTemplate = DefaultOutputTemplate, IFormatProvider formatProvider = null, long?fileSizeLimitBytes = DefaultFileSizeLimitBytes, LoggingLevelSwitch levelSwitch = null, bool buffered = false, bool shared = false, TimeSpan?flushToDiskInterval = null, RollingInterval rollingInterval = RollingInterval.Infinite, bool rollOnFileSizeLimit = false, int?retainedFileCountLimit = DefaultRetainedFileCountLimit, Encoding encoding = null) { if (sinkConfiguration == null) { throw new ArgumentNullException(nameof(sinkConfiguration)); } if (path == null) { throw new ArgumentNullException(nameof(path)); } if (outputTemplate == null) { throw new ArgumentNullException(nameof(outputTemplate)); } var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider); return(File(sinkConfiguration, formatter, path, restrictedToMinimumLevel, fileSizeLimitBytes, levelSwitch, buffered, shared, flushToDiskInterval, rollingInterval, rollOnFileSizeLimit, retainedFileCountLimit, encoding)); }
public static void Main(string[] args) { const int retainedFileCountLimit = 5; // The maximum number of log files that will be retained (default is 31) const long fileSizeLimitBytes = 1L * 1024 * 1024; // 1MB (size is in bytes & default is 1 GB) const string defaultOutputTemplate = "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}"; const RollingInterval rollingInterval = RollingInterval.Infinite; const bool rollOnFileSizeLimit = true; Log.Logger = new LoggerConfiguration() //.ReadFrom.Configuration(IConfiguration) .Enrich.FromLogContext() .WriteTo.File(new RenderedCompactJsonFormatter(), "Logs\\moviesapi.ndjson", LogEventLevel.Debug, fileSizeLimitBytes, null, false, false, null, rollingInterval, rollOnFileSizeLimit, retainedFileCountLimit, null) .WriteTo.File("Logs\\moviesapi.txt", LogEventLevel.Debug, defaultOutputTemplate, null, fileSizeLimitBytes, null, false, false) .WriteTo.Console() .CreateLogger(); try { Log.Information("Starting up application"); CreateHostBuilder(args).Build().Run(); } catch (Exception ex) { Log.Fatal(ex, "Application start-up failed"); } finally { Log.CloseAndFlush(); } }
/// <summary>Add a file logger. /// </summary> /// <param name="loggerName"></param> /// <param name="loggerFileName"></param> /// <param name="contextPropertyName"></param> /// <param name="defaultLoggerFileExtensions"></param> /// <param name="defaultLoggerFileOutputTemplate"></param> /// <param name="defaultLoggerFileBuffered"></param> /// <param name="defaultLoggerFileSizeLimitBytes"></param> /// <param name="defaultLoggerFileRollingInterval"></param> /// <param name="defaultLoggerFileRollOnFileSizeLimit"></param> /// <param name="defaultLoggerFileRetainedFileCountLimit"></param> /// <param name="defaultLoggerFileFlushToDiskIntervalSenconds"></param> /// <param name="minimumLevel"></param> /// <returns></returns> public SerilogLoggerFactory AddFileLogger(string loggerName, string loggerFileName, string contextPropertyName = "logger", string defaultLoggerFileExtensions = "-.log", string defaultLoggerFileOutputTemplate = "{Timestamp:yyyy-MM-dd HH:mm:ss.fff} [{Level:u3}] [{logger}] - {Message:lj}{NewLine}{Exception}", bool defaultLoggerFileBuffered = true, long?defaultLoggerFileSizeLimitBytes = null, RollingInterval defaultLoggerFileRollingInterval = RollingInterval.Day, bool defaultLoggerFileRollOnFileSizeLimit = true, int?defaultLoggerFileRetainedFileCountLimit = null, int?defaultLoggerFileFlushToDiskIntervalSenconds = 1, LogEventLevel minimumLevel = LogEventLevel.Information) { var defaultLoggerFileFlushToDiskInterval = defaultLoggerFileFlushToDiskIntervalSenconds != null ? new TimeSpan(defaultLoggerFileFlushToDiskIntervalSenconds.Value * 1000 * 10000) : default(TimeSpan?); _loggerDict.TryAdd(loggerName, new SerilogLogger(contextPropertyName, new LoggerConfiguration() .MinimumLevel.Verbose() .WriteTo.File(loggerFileName + defaultLoggerFileExtensions, restrictedToMinimumLevel: minimumLevel, outputTemplate: defaultLoggerFileOutputTemplate, buffered: defaultLoggerFileBuffered, fileSizeLimitBytes: defaultLoggerFileSizeLimitBytes, rollingInterval: defaultLoggerFileRollingInterval, rollOnFileSizeLimit: defaultLoggerFileRollOnFileSizeLimit, retainedFileCountLimit: defaultLoggerFileRetainedFileCountLimit, flushToDiskInterval: defaultLoggerFileFlushToDiskInterval) .CreateLogger())); return(this); }
/// <summary> /// Initializes a new instance of the <see cref="RollingFileSink" /> class. /// </summary> /// <param name="path">The path.</param> /// <param name="textFormatter">The text formatter.</param> /// <param name="fileSizeLimitBytes">The file size limit bytes.</param> /// <param name="retainedFileCountLimit">The retained file count limit.</param> /// <param name="encoding">The encoding.</param> /// <param name="buffered">if set to <c>true</c> [buffered].</param> /// <param name="rollingInterval">The rolling interval.</param> /// <param name="rollOnFileSizeLimit">if set to <c>true</c> [roll on file size limit].</param> /// <param name="fileLifecycleHooks">The file lifecycle hooks.</param> /// <param name="bucketName">The Amazon S3 bucket name.</param> /// <param name="endpoint">The Amazon S3 endpoint.</param> /// <param name="awsAccessKeyId">The Amazon S3 access key id.</param> /// <param name="awsSecretAccessKey">The Amazon S3 access key.</param> /// <exception cref="ArgumentNullException">An <see cref="ArgumentNullException" /> thrown when the path is null.</exception> /// <exception cref="ArgumentException"> /// Negative value provided; file size limit must be non-negative. /// or /// Zero or negative value provided; retained file count limit must be at least 1. /// </exception> public RollingFileSink( string path, ITextFormatter textFormatter, long?fileSizeLimitBytes, int?retainedFileCountLimit, Encoding encoding, bool buffered, RollingInterval rollingInterval, bool rollOnFileSizeLimit, FileLifecycleHooks fileLifecycleHooks, string bucketName, RegionEndpoint endpoint, string awsAccessKeyId, string awsSecretAccessKey) { if (string.IsNullOrWhiteSpace(path)) { throw new ArgumentNullException(nameof(path)); } if (string.IsNullOrWhiteSpace(bucketName)) { throw new ArgumentNullException(nameof(bucketName)); } if (string.IsNullOrWhiteSpace(awsAccessKeyId)) { throw new ArgumentNullException(nameof(awsAccessKeyId)); } if (string.IsNullOrWhiteSpace(awsSecretAccessKey)) { throw new ArgumentNullException(nameof(awsSecretAccessKey)); } if (fileSizeLimitBytes.HasValue && fileSizeLimitBytes < 0) { throw new ArgumentException("Negative value provided; file size limit must be non-negative."); } if (retainedFileCountLimit.HasValue && retainedFileCountLimit < 1) { throw new ArgumentException( "Zero or negative value provided; retained file count limit must be at least 1."); } this.bucketName = bucketName; this.awsAccessKeyId = awsAccessKeyId; this.awsSecretAccessKey = awsSecretAccessKey; this.endpoint = endpoint; this.pathRoller = new PathRoller(path, rollingInterval); this.textFormatter = textFormatter; this.fileSizeLimitBytes = fileSizeLimitBytes; this.retainedFileCountLimit = retainedFileCountLimit; this.encoding = encoding; this.buffered = buffered; this.rollOnFileSizeLimit = rollOnFileSizeLimit; this.fileLifecycleHooks = fileLifecycleHooks; }
public void ConvertInterval(BufferRollingInterval input, RollingInterval want) { // Act var got = input.ToRollingInterval(); // Assert got.ShouldBe(want); }
public SerilogServiceLoggerFactory(string logFilePath, RollingInterval fileRollingInterval) { _serilogLogger = new LoggerConfiguration() .MinimumLevel.Debug() .WriteTo.Console() .WriteTo.File(logFilePath, rollingInterval: fileRollingInterval) .CreateLogger(); }
public FileWriter(IOptions <PipaslotLoggerOptions> options, string name, RollingInterval rollingInterval, IFileNameFormatter fileNameFormatter, QueueFormatter formatter) { _options = options; _name = name; _formatter = formatter; _rollingInterval = rollingInterval; _fileNameFormatter = fileNameFormatter; }
/// <summary> /// /// </summary> public SeriLog() { FileName = System.AppDomain.CurrentDomain.FriendlyName; SplitFileByLogEventLevel = true; rollingInterval = RollingInterval.Minute; FilePath = "logs\\"; outputTemplate = "Date : {Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz}{NewLine}{Message:lj}{NewLine}======================================================================================================{NewLine}"; }
public LoggerFactory(StrategyMode strategyMode, string logConfigFileName, RollingInterval rollingInterval) { var config = ReadConfig(GetConfigPath(), logConfigFileName); this._logConfig = JsonConvert.DeserializeObject <LogConfiguration>(config); this._logPath = GetLogPath(strategyMode, this._logConfig); this._rollingInterval = rollingInterval; }
/// <summary> /// LogRecord single message with specified log level and class or methods. Useful when you need separate specific procedure /// </summary> public static void AddTreeLogger(this ILoggingBuilder builder, string name, RollingInterval rollingInterval, params string[] namespaceOrClass) { builder.AddPipaslotLoggerProvider(); builder.Services.AddSingleton(s => { var logWriterFactory = s.GetService <IFileWriterFactory>(); var writer = logWriterFactory.Create(name, rollingInterval); return(new Pipe(writer, new TreeQueueFilter(namespaceOrClass))); }); }
public void NextIntervalTests(RollingInterval interval, DateTime instant, DateTime?currentCheckpoint, DateTime?nextCheckpoint) { var current = interval.GetCurrentCheckpoint(instant); Assert.Equal(currentCheckpoint, current); var next = interval.GetNextCheckpoint(instant); Assert.Equal(nextCheckpoint, next); }
public LoggerFactory(StrategyMode strategyMode, LogConfiguration logConfig, RollingInterval rollingInterval, string identifierPlaceHolder, string searchStringTemplate, List <string> indentifierValues) { this._logConfig = logConfig; this._logPath = GetLogPath(strategyMode, logConfig); this._rollingInterval = rollingInterval; this._identifierPlaceHolder = identifierPlaceHolder; this._searchStringTemplate = searchStringTemplate; this._indentifierValues = indentifierValues; }
/// <summary> Initializes a new instance of the <see cref="RollingFileSink" /> class. </summary> /// <exception cref="ArgumentNullException"> /// An <see cref="ArgumentNullException" /> thrown /// when the path is null. /// </exception> /// <exception cref="ArgumentException"> /// Negative value provided; file size limit must be /// non-negative. or Zero or negative value provided; /// retained file count limit must be at least 1. /// </exception> /// <param name="path"> The path. </param> /// <param name="textFormatter"> The text formatter. </param> /// <param name="fileSizeLimitBytes"> The file size limit bytes. </param> /// <param name="retainedFileCountLimit"> The retained file count limit. </param> /// <param name="encoding"> The encoding. </param> /// <param name="buffered"> if set to <c>true</c> [buffered]. </param> /// <param name="rollingInterval"> The rolling interval. </param> /// <param name="rollOnFileSizeLimit"> if set to <c>true</c> [roll on file size limit]. </param> /// <param name="fileLifecycleHooks"> The file lifecycle hooks. </param> /// <param name="bucketName"> The Amazon S3 bucket name. </param> /// <param name="endpoint"> The Amazon S3 endpoint. </param> /// <param name="autoUploadEvents"> Automatically upload all events immediately. </param> /// <param name="failureCallback"> (Optional) The failure callback. </param> /// <param name="bucketPath"> (Optional) The Amazon S3 bucket path. </param> public RollingFileSink( string path, ITextFormatter textFormatter, long?fileSizeLimitBytes, int?retainedFileCountLimit, Encoding encoding, bool buffered, RollingInterval rollingInterval, bool rollOnFileSizeLimit, FileLifecycleHooks fileLifecycleHooks, string bucketName, RegionEndpoint endpoint, bool autoUploadEvents, Action <Exception> failureCallback = null, string bucketPath = null) { if (string.IsNullOrWhiteSpace(path)) { throw new ArgumentNullException(nameof(path)); } if (string.IsNullOrWhiteSpace(bucketName)) { throw new ArgumentNullException(nameof(bucketName)); } if (fileSizeLimitBytes.HasValue && fileSizeLimitBytes < 0) { throw new ArgumentException("Negative value provided; file size limit must be non-negative."); } if (retainedFileCountLimit.HasValue && retainedFileCountLimit < 1) { throw new ArgumentException( "Zero or negative value provided; retained file count limit must be at least 1."); } if (failureCallback != null) { this.FailureCallback = failureCallback; } this.bucketName = bucketName; this.endpoint = endpoint; this.pathRoller = new PathRoller(path, rollingInterval); this.textFormatter = textFormatter; this.fileSizeLimitBytes = fileSizeLimitBytes; this.retainedFileCountLimit = retainedFileCountLimit; this.encoding = encoding; this.buffered = buffered; this.rollOnFileSizeLimit = rollOnFileSizeLimit; this.fileLifecycleHooks = fileLifecycleHooks; this.autoUploadEvents = autoUploadEvents; this.bucketPath = bucketPath; }
public LoggerFactory(StrategyMode strategyMode, string logConfigFileName, RollingInterval rollingInterval, string identifierPlaceHolder, string searchStringTemplate, List <string> indentifierValues) { var config = ReadConfig(GetConfigPath(), logConfigFileName); this._logConfig = JsonConvert.DeserializeObject <LogConfiguration>(config); this._logPath = GetLogPath(strategyMode, this._logConfig); this._rollingInterval = rollingInterval; this._identifierPlaceHolder = identifierPlaceHolder; this._searchStringTemplate = searchStringTemplate; this._indentifierValues = indentifierValues; }
public static LoggerConfiguration AddFileLoggerFilePerLevel(this LoggerConfiguration conf, string rootDirectory, string filename, LogEventLevel restrictedToMinimumLevel = LogEventLevel.Verbose, string outputTemplate = "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}{NewLine}", IFormatProvider formatProvider = null, long?fileSizeLimitBytes = 1073741824L, LoggingLevelSwitch levelSwitch = null, bool buffered = false, bool shared = false, TimeSpan?flushToDiskInterval = null, RollingInterval rollingInterval = RollingInterval.Infinite, bool rollOnFileSizeLimit = false, int?retainedFileCountLimit = 31, Encoding encoding = null, FileLifecycleHooks hooks = null, TimeSpan?retainedFileTimeLimit = null) { conf = conf .WriteTo.Logger(lc => lc .Filter.ByIncludingOnly(m => m.Level == global::Serilog.Events.LogEventLevel.Verbose) .WriteTo.File(CombinePath(rootDirectory, "Verbose", filename), restrictedToMinimumLevel, outputTemplate, formatProvider, fileSizeLimitBytes, levelSwitch, buffered, shared, flushToDiskInterval, rollingInterval, rollOnFileSizeLimit, retainedFileCountLimit, encoding, hooks, retainedFileTimeLimit) ) .WriteTo.Logger(lc => lc .Filter.ByIncludingOnly(m => m.Level == global::Serilog.Events.LogEventLevel.Debug) .WriteTo.File(CombinePath(rootDirectory, "Debug", filename), restrictedToMinimumLevel, outputTemplate, formatProvider, fileSizeLimitBytes, levelSwitch, buffered, shared, flushToDiskInterval, rollingInterval, rollOnFileSizeLimit, retainedFileCountLimit, encoding, hooks, retainedFileTimeLimit) ) .WriteTo.Logger(lc => lc .Filter.ByIncludingOnly(m => m.Level == global::Serilog.Events.LogEventLevel.Information) .WriteTo.File(CombinePath(rootDirectory, "Info", filename), restrictedToMinimumLevel, outputTemplate, formatProvider, fileSizeLimitBytes, levelSwitch, buffered, shared, flushToDiskInterval, rollingInterval, rollOnFileSizeLimit, retainedFileCountLimit, encoding, hooks, retainedFileTimeLimit) ) .WriteTo.Logger(lc => lc .Filter.ByIncludingOnly(m => m.Level == global::Serilog.Events.LogEventLevel.Warning) .WriteTo.File(CombinePath(rootDirectory, "Warn", filename), restrictedToMinimumLevel, outputTemplate, formatProvider, fileSizeLimitBytes, levelSwitch, buffered, shared, flushToDiskInterval, rollingInterval, rollOnFileSizeLimit, retainedFileCountLimit, encoding, hooks, retainedFileTimeLimit) ) .WriteTo.Logger(lc => lc .Filter.ByIncludingOnly(m => m.Level == global::Serilog.Events.LogEventLevel.Error) .WriteTo.File(CombinePath(rootDirectory, "Error", filename), restrictedToMinimumLevel, outputTemplate, formatProvider, fileSizeLimitBytes, levelSwitch, buffered, shared, flushToDiskInterval, rollingInterval, rollOnFileSizeLimit, retainedFileCountLimit, encoding, hooks, retainedFileTimeLimit) ) .WriteTo.Logger(lc => lc .Filter.ByIncludingOnly(m => m.Level == global::Serilog.Events.LogEventLevel.Fatal) .WriteTo.File(CombinePath(rootDirectory, "Fatal", filename), restrictedToMinimumLevel, outputTemplate, formatProvider, fileSizeLimitBytes, levelSwitch, buffered, shared, flushToDiskInterval, rollingInterval, rollOnFileSizeLimit, retainedFileCountLimit, encoding, hooks, retainedFileTimeLimit) ); return(conf); }
public FileSinkOptions AddStrategy( string strategyName, string fileName, PathType pathType = PathType.Relative, TimeSpan?flushToDiskInterval = null, RollingInterval rollingInterval = RollingInterval.Infinite, List <string> namespaceList = null, string outputTemplate = null) { if (string.IsNullOrWhiteSpace(strategyName)) { throw new ArgumentNullException(nameof(strategyName)); } if (string.IsNullOrWhiteSpace(fileName)) { throw new ArgumentNullException(nameof(fileName)); } var u = $"{_registeredPath}-{pathType.GetName()}"; if (_registeredPath.Contains(u)) { throw new ArgumentException("Multiple definitions"); } if (string.IsNullOrWhiteSpace(outputTemplate)) { outputTemplate = RealDefaultOutputTemplate; } if (namespaceList == null || !namespaceList.Any()) { namespaceList = new List <string> { "*" } } ; OutputOptionsInternal.Add( strategyName, new OutputOptions { Path = fileName, Template = outputTemplate, PathType = pathType, FlushToDiskInterval = flushToDiskInterval, Rolling = rollingInterval, Navigators = namespaceList }); _registeredPath.Add(u); return(this); } #endregion }