/// <summary>
/// Adds a durable sink that sends log events using HTTP POST over the network. A durable
/// sink will persist log events on disk before sending them over the network, thus
/// protecting against data loss after a system or process restart.
/// </summary>
/// <param name="sinkConfiguration">The logger configuration.</param>
/// <param name="requestUri">The URI the request is sent to.</param>
/// <param name="bufferPathFormat">
/// The path format for a set of files that will be used to buffer events until they can be
/// successfully sent over the network. Default value is "Buffer-{Date}.json". To use file
/// rotation that is on an 30 or 60 minute interval pass "Buffer-{Hour}.json" or
/// "Buffer-{HalfHour}.json".
/// </param>
/// <param name="bufferFileSizeLimitBytes">
/// The maximum size, in bytes, to which the buffer log file for a specific date will be
/// allowed to grow. By default no limit will be applied.
/// </param>
/// <param name="retainedBufferFileCountLimit">
/// The maximum number of buffer files that will be retained, including the current buffer
/// file. Under normal operation only 2 files will be kept, however if the log server is
/// unreachable, the number of files specified by <paramref name="retainedBufferFileCountLimit"/>
/// will be kept on the file system. For unlimited retention, pass null. Default value is 31.
/// </param>
/// <param name="batchPostingLimit">
/// The maximum number of events to post in a single batch. Default value is 1000.
/// </param>
/// <param name="period">
/// The time to wait between checking for event batches. Default value is 2 seconds.
/// </param>
/// <param name="textFormatter">
/// The formatter rendering individual log events into text, for example JSON. Default
/// value is <see cref="NormalRenderedTextFormatter"/>.
/// </param>
/// <param name="batchFormatter">
/// The formatter batching multiple log events into a payload that can be sent over the
/// network. Default value is <see cref="DefaultBatchFormatter"/>.
/// </param>
/// <param name="restrictedToMinimumLevel">
/// The minimum level for events passed through the sink. Default value is
/// <see cref="LevelAlias.Minimum"/>.
/// </param>
/// <param name="httpClient">
/// A custom <see cref="IHttpClient"/> implementation. Default value is
/// <see cref="HttpClient"/>.
/// </param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
public static LoggerConfiguration DurableHttp(
this LoggerSinkConfiguration sinkConfiguration,
string requestUri,
string bufferPathFormat = "Buffer-{Date}.json",
long?bufferFileSizeLimitBytes = null,
int?retainedBufferFileCountLimit = 31,
int batchPostingLimit = 1000,
TimeSpan?period = null,
ITextFormatter textFormatter = null,
IBatchFormatter batchFormatter = null,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
IHttpClient httpClient = null)
{
if (sinkConfiguration == null)
{
throw new ArgumentNullException(nameof(sinkConfiguration));
}
var sink = new DurableHttpSink(
requestUri,
bufferPathFormat,
bufferFileSizeLimitBytes,
retainedBufferFileCountLimit,
batchPostingLimit,
period ?? TimeSpan.FromSeconds(2),
textFormatter ?? new NormalRenderedTextFormatter(),
batchFormatter ?? new DefaultBatchFormatter(),
httpClient ?? new HttpClientWrapper());
return(sinkConfiguration.Sink(sink, restrictedToMinimumLevel));
}
/// <summary>
/// Initializes a new instance of the <see cref="TimeRolledDurableHttpSink"/> class.
/// </summary>
public TimeRolledDurableHttpSink(
string requestUri,
string bufferPathFormat,
long?bufferFileSizeLimitBytes,
bool bufferFileShared,
int?retainedBufferFileCountLimit,
int batchPostingLimit,
long batchSizeLimitBytes,
TimeSpan period,
ITextFormatter textFormatter,
IBatchFormatter batchFormatter,
IHttpClient httpClient)
{
if (bufferFileSizeLimitBytes < 0)
{
throw new ArgumentOutOfRangeException(nameof(bufferFileSizeLimitBytes), "Negative value provided; file size limit must be non-negative.");
}
shipper = new HttpLogShipper(
httpClient,
requestUri,
new TimeRolledBufferFiles(new DirectoryService(), bufferPathFormat),
batchPostingLimit,
batchSizeLimitBytes,
period,
batchFormatter);
sink = new RollingFileSink(
bufferPathFormat,
textFormatter,
bufferFileSizeLimitBytes,
retainedBufferFileCountLimit,
Encoding.UTF8,
shared: bufferFileShared);
}
/// <summary>
/// Initializes a new instance of the <see cref="DurableHttpSink"/> class.
/// </summary>
public DurableHttpSink(
string requestUri,
string bufferPathFormat,
long?bufferFileSizeLimitBytes,
int?retainedBufferFileCountLimit,
int batchPostingLimit,
TimeSpan period,
ITextFormatter textFormatter,
IBatchFormatter batchFormatter,
IHttpClient client)
{
if (bufferFileSizeLimitBytes.HasValue && bufferFileSizeLimitBytes < 0)
{
throw new ArgumentOutOfRangeException(nameof(bufferFileSizeLimitBytes), "Negative value provided; file size limit must be non-negative.");
}
shipper = new HttpLogShipper(
client,
requestUri,
bufferPathFormat,
batchPostingLimit,
period,
batchFormatter);
sink = new RollingFileSink(
bufferPathFormat,
textFormatter,
bufferFileSizeLimitBytes,
retainedBufferFileCountLimit,
Encoding.UTF8);
}
public FileSizeRolledDurableHttpSink(
string requestUri,
string bufferBaseFileName,
long?bufferFileSizeLimitBytes,
bool bufferFileShared,
int?retainedBufferFileCountLimit,
long?logEventLimitBytes,
int?logEventsInBatchLimit,
long?batchSizeLimitBytes,
TimeSpan period,
ITextFormatter textFormatter,
IBatchFormatter batchFormatter,
IHttpClient httpClient)
{
shipper = new HttpLogShipper(
httpClient,
requestUri,
new FileSizeRolledBufferFiles(new DirectoryService(), bufferBaseFileName),
logEventLimitBytes,
logEventsInBatchLimit,
batchSizeLimitBytes,
period,
batchFormatter);
sink = CreateFileSink(
bufferBaseFileName,
bufferFileSizeLimitBytes,
bufferFileShared,
retainedBufferFileCountLimit,
textFormatter);
}
/// <summary>
/// Adds a non durable sink that sends log events using HTTP POST over the network. A
/// non-durable sink will lose data after a system or process restart.
/// </summary>
/// <param name="sinkConfiguration">The logger configuration.</param>
/// <param name="requestUri">The URI the request is sent to.</param>
/// <param name="batchPostingLimit">
/// The maximum number of events to post in a single batch. Default value is 1000.
/// </param>
/// <param name="period">
/// The time to wait between checking for event batches. Default value is 2 seconds.
/// </param>
/// <param name="textFormatter">
/// The formatter rendering individual log events into text, for example JSON. Default
/// value is <see cref="NormalRenderedTextFormatter"/>.
/// </param>
/// <param name="batchFormatter">
/// The formatter batching multiple log events into a payload that can be sent over the
/// network. Default value is <see cref="DefaultBatchFormatter"/>.
/// </param>
/// <param name="restrictedToMinimumLevel">
/// The minimum level for events passed through the sink. Default value is
/// <see cref="LevelAlias.Minimum"/>.
/// </param>
/// <param name="httpClient">
/// A custom <see cref="IHttpClient"/> implementation. Default value is
/// <see cref="HttpClient"/>.
/// </param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
public static LoggerConfiguration Http(
this LoggerSinkConfiguration sinkConfiguration,
string requestUri,
int batchPostingLimit = 1000,
TimeSpan?period = null,
ITextFormatter textFormatter = null,
IBatchFormatter batchFormatter = null,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
IHttpClient httpClient = null)
{
if (sinkConfiguration == null)
{
throw new ArgumentNullException(nameof(sinkConfiguration));
}
var sink = new HttpSink(
requestUri,
batchPostingLimit,
period ?? TimeSpan.FromSeconds(2),
textFormatter ?? new NormalRenderedTextFormatter(),
batchFormatter ?? new DefaultBatchFormatter(),
httpClient ?? new HttpClientWrapper());
return(sinkConfiguration.Sink(sink, restrictedToMinimumLevel));
}
/// <summary>
/// Initializes a new instance of the <see cref="FileSizeRolledDurableHttpSink"/> class.
/// </summary>
public FileSizeRolledDurableHttpSink(
string requestUri,
string bufferBaseFileName,
long?bufferFileSizeLimitBytes,
int?retainedBufferFileCountLimit,
int batchPostingLimit,
TimeSpan period,
ITextFormatter textFormatter,
IBatchFormatter batchFormatter,
IHttpClient client)
{
if (bufferFileSizeLimitBytes.HasValue && bufferFileSizeLimitBytes < 0)
{
throw new ArgumentOutOfRangeException(nameof(bufferFileSizeLimitBytes), "Negative value provided; file size limit must be non-negative.");
}
shipper = new HttpLogShipper(
client,
requestUri,
new FileSizeRolledBufferFiles(new DirectoryService(), bufferBaseFileName),
batchPostingLimit,
period,
batchFormatter);
sink = new LoggerConfiguration()
.WriteTo.File(
textFormatter,
$"{bufferBaseFileName}-.json",
fileSizeLimitBytes: bufferFileSizeLimitBytes,
rollOnFileSizeLimit: true,
retainedFileCountLimit: retainedBufferFileCountLimit,
rollingInterval: RollingInterval.Day,
encoding: Encoding.UTF8)
.CreateLogger();
}
public static LoggerConfiguration DurableHttp(
this LoggerSinkConfiguration sinkConfiguration,
string requestUri,
string bufferPathFormat = "Buffer-{Date}.json",
long?bufferFileSizeLimitBytes = null,
int?retainedBufferFileCountLimit = 31,
int batchPostingLimit = 1000,
TimeSpan?period = null,
ITextFormatter textFormatter = null,
IBatchFormatter batchFormatter = null,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
IHttpClient httpClient = null)
{
return(DurableHttpUsingTimeRolledBuffers(
sinkConfiguration,
requestUri,
bufferPathFormat,
bufferFileSizeLimitBytes,
retainedBufferFileCountLimit,
batchPostingLimit,
period,
textFormatter,
batchFormatter,
restrictedToMinimumLevel,
httpClient));
}
/// <summary>
/// Adds a non-durable sink that sends log events using HTTP POST over the network. A
/// non-durable sink will lose data after a system or process restart.
/// </summary>
/// <param name="sinkConfiguration">The logger configuration.</param>
/// <param name="requestUri">The URI the request is sent to.</param>
/// <param name="batchPostingLimit">
/// The maximum number of events to post in a single batch. Default value is 1000.
/// </param>
/// <param name="queueLimit">
/// The maximum number of events stored in the queue in memory, waiting to be posted over
/// the network. Default value is infinitely.
/// </param>
/// <param name="period">
/// The time to wait between checking for event batches. Default value is 2 seconds.
/// </param>
/// <param name="textFormatter">
/// The formatter rendering individual log events into text, for example JSON. Default
/// value is <see cref="NormalRenderedTextFormatter"/>.
/// </param>
/// <param name="batchFormatter">
/// The formatter batching multiple log events into a payload that can be sent over the
/// network. Default value is <see cref="DefaultBatchFormatter"/>.
/// </param>
/// <param name="restrictedToMinimumLevel">
/// The minimum level for events passed through the sink. Default value is
/// <see cref="LevelAlias.Minimum"/>.
/// </param>
/// <param name="httpClient">
/// A custom <see cref="IHttpClient"/> implementation. Default value is
/// <see cref="HttpClient"/>.
/// </param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
public static LoggerConfiguration Http(
this LoggerSinkConfiguration sinkConfiguration,
string requestUri,
int batchPostingLimit = 1000,
int?queueLimit = null,
TimeSpan?period = null,
ITextFormatter textFormatter = null,
IBatchFormatter batchFormatter = null,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
IHttpClient httpClient = null)
{
if (sinkConfiguration == null)
{
throw new ArgumentNullException(nameof(sinkConfiguration));
}
// Default values
period = period ?? TimeSpan.FromSeconds(2);
textFormatter = textFormatter ?? new NormalRenderedTextFormatter();
batchFormatter = batchFormatter ?? new DefaultBatchFormatter();
httpClient = httpClient ?? new DefaultHttpClient();
var sink = queueLimit != null
? new HttpSink(requestUri, batchPostingLimit, queueLimit.Value, period.Value, textFormatter, batchFormatter, httpClient)
: new HttpSink(requestUri, batchPostingLimit, period.Value, textFormatter, batchFormatter, httpClient);
return(sinkConfiguration.Sink(sink, restrictedToMinimumLevel));
}
public HttpLogShipper(
IHttpClient client,
string requestUri,
string bufferBaseFilename,
int batchPostingLimit,
TimeSpan period,
IBatchFormatter batchFormatter)
{
if (bufferBaseFilename == null)
{
throw new ArgumentNullException(nameof(bufferBaseFilename));
}
if (batchPostingLimit <= 0)
{
throw new ArgumentException("batchPostingLimit must be 1 or greater", nameof(batchPostingLimit));
}
this.client = client ?? throw new ArgumentNullException(nameof(client));
this.requestUri = requestUri ?? throw new ArgumentNullException(nameof(requestUri));
this.batchPostingLimit = batchPostingLimit;
this.batchFormatter = batchFormatter ?? throw new ArgumentNullException(nameof(batchFormatter));
bookmarkFilename = Path.GetFullPath(bufferBaseFilename + ".bookmark");
logFolder = Path.GetDirectoryName(bookmarkFilename);
candidateSearchPath = Path.GetFileName(bufferBaseFilename) + "*.json";
connectionSchedule = new ExponentialBackoffConnectionSchedule(period);
timer = new PortableTimer(OnTick);
SetTimer();
}
public TencentCloudSink(string requestUri, int batchSizeLimit, TimeSpan period, int queueLimit, IHttpClient client, IBatchFormatter clsFormatter)
: base(batchSizeLimit, period, queueLimit)
{
this.requestUri = requestUri ?? throw new ArgumentNullException(nameof(requestUri));
this.clsFormatter = clsFormatter ?? throw new ArgumentNullException(nameof(clsFormatter));
this.client = client ?? throw new ArgumentNullException(nameof(client));
}
public HttpSink(
string requestUri,
int batchPostingLimit,
TimeSpan period,
ITextFormatter textFormatter,
IBatchFormatter batchFormatter,
IHttpClient client)
: base(batchPostingLimit, period)
{
this.requestUri = requestUri ?? throw new ArgumentNullException(nameof(requestUri));
this.textFormatter = textFormatter ?? throw new ArgumentNullException(nameof(textFormatter));
this.batchFormatter = batchFormatter ?? throw new ArgumentNullException(nameof(batchFormatter));
this.client = client ?? throw new ArgumentNullException(nameof(client));
}
public HttpLogShipper(
IHttpClient client,
string requestUri,
string bufferPathFormat,
int batchPostingLimit,
TimeSpan period,
IBatchFormatter batchFormatter)
{
if (bufferPathFormat == null)
{
throw new ArgumentNullException(nameof(bufferPathFormat));
}
if (bufferPathFormat != bufferPathFormat.Trim())
{
throw new ArgumentException("bufferPathFormat must not contain any leading or trailing whitespaces", nameof(bufferPathFormat));
}
if (batchPostingLimit <= 0)
{
throw new ArgumentException("batchPostingLimit must be 1 or greater", nameof(batchPostingLimit));
}
this.client = client ?? throw new ArgumentNullException(nameof(client));
this.requestUri = requestUri ?? throw new ArgumentNullException(nameof(requestUri));
this.batchPostingLimit = batchPostingLimit;
this.batchFormatter = batchFormatter ?? throw new ArgumentNullException(nameof(batchFormatter));
var bufferPathFormatMatch = BufferPathFormatRegex.Match(bufferPathFormat);
if (!bufferPathFormatMatch.Success)
{
throw new ArgumentException($"bufferPathFormat must include one of the date formats [{string.Join(", ", Enum.GetNames(typeof(DateFormats)))}]");
}
var prefix = bufferPathFormatMatch.Groups["prefix"];
var postfix = bufferPathFormatMatch.Groups["postfix"];
bookmarkFilename = Path.GetFullPath(prefix.Value.TrimEnd(new char[] { '-' }) + ".bookmark");
logFolder = Path.GetDirectoryName(bookmarkFilename);
candidateSearchPath = $"{Path.GetFileName(prefix.Value)}*{postfix.Value}";
connectionSchedule = new ExponentialBackoffConnectionSchedule(period);
timer = new PortableTimer(OnTick);
SetTimer();
}
/// <summary>
/// Adds a durable sink that sends log events using HTTP POST over the network. A durable
/// sink will persist log events on disk in buffer files before sending them over the
/// network, thus protecting against data loss after a system or process restart. The
/// buffer files will use a rolling behavior defined by the file size specified in
/// <paramref name="bufferFileSizeLimitBytes"/>, i.e. a new buffer file is created when
/// current has passed its limit. The maximum number of retained files is defined by
/// <paramref name="retainedBufferFileCountLimit"/>, and when that limit is reached the
/// oldest file is dropped to make room for a new.
/// </summary>
/// <param name="sinkConfiguration">The logger configuration.</param>
/// <param name="requestUri">The URI the request is sent to.</param>
/// <param name="bufferBaseFileName">
/// The relative or absolute path for a set of files that will be used to buffer events
/// until they can be successfully transmitted across the network. Individual files will be
/// created using the pattern "<paramref name="bufferBaseFileName"/>*.json", which should
/// not clash with any other file names in the same directory. Default value is "Buffer".
/// </param>
/// <param name="bufferFileSizeLimitBytes">
/// The approximate maximum size, in bytes, to which a buffer 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="bufferFileShared">
/// Allow the buffer file to be shared by multiple processes. Default value is false.
/// </param>
/// <param name="retainedBufferFileCountLimit">
/// The maximum number of buffer files that will be retained, including the current buffer
/// file. Under normal operation only 2 files will be kept, however if the log server is
/// unreachable, the number of files specified by
/// <paramref name="retainedBufferFileCountLimit"/> will be kept on the file system. For
/// unlimited retention, pass null. Default value is 31.
/// </param>
/// <param name="batchPostingLimit">
/// The maximum number of events to post in a single batch. Default value is 1000.
/// </param>
/// <param name="batchSizeLimitBytes">
/// The approximate maximum size, in bytes, for a single batch. The value is an
/// approximation because only the size of the log events are considered. The extra
/// characters added by the batch formatter, where the sequence of serialized log events
/// are transformed into a payload, are not considered. Please make sure to accommodate for
/// those. Default value is long.MaxValue.
/// </param>
/// <param name="period">
/// The time to wait between checking for event batches. Default value is 2 seconds.
/// </param>
/// <param name="textFormatter">
/// The formatter rendering individual log events into text, for example JSON. Default
/// value is <see cref="NormalRenderedTextFormatter"/>.
/// </param>
/// <param name="batchFormatter">
/// The formatter batching multiple log events into a payload that can be sent over the
/// network. Default value is <see cref="DefaultBatchFormatter"/>.
/// </param>
/// <param name="restrictedToMinimumLevel">
/// The minimum level for events passed through the sink. Default value is
/// <see cref="LevelAlias.Minimum"/>.
/// </param>
/// <param name="httpClient">
/// A custom <see cref="IHttpClient"/> implementation. Default value is
/// <see cref="HttpClient"/>.
/// </param>
/// <param name="configuration">
/// Configuration passed to <paramref name="httpClient"/>. Parameter is either manually
/// specified when configuring the sink in source code or automatically passed in when
/// configuring the sink using
/// <see href="https://www.nuget.org/packages/Serilog.Settings.Configuration">Serilog.Settings.Configuration</see>.
/// </param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
public static LoggerConfiguration DurableHttpUsingFileSizeRolledBuffers(
this LoggerSinkConfiguration sinkConfiguration,
string requestUri,
string bufferBaseFileName = "Buffer",
long?bufferFileSizeLimitBytes = ByteSize.GB,
bool bufferFileShared = false,
int?retainedBufferFileCountLimit = 31,
int batchPostingLimit = 1000,
long batchSizeLimitBytes = long.MaxValue,
TimeSpan?period = null,
ITextFormatter textFormatter = null,
IBatchFormatter batchFormatter = null,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
IHttpClient httpClient = null,
IConfiguration configuration = null)
{
if (sinkConfiguration == null)
{
throw new ArgumentNullException(nameof(sinkConfiguration));
}
// Default values
period ??= TimeSpan.FromSeconds(2);
textFormatter ??= new NormalRenderedTextFormatter();
batchFormatter ??= new DefaultBatchFormatter();
httpClient ??= new DefaultHttpClient();
httpClient.Configure(configuration);
var sink = new FileSizeRolledDurableHttpSink(
requestUri: requestUri,
bufferBaseFileName: bufferBaseFileName,
bufferFileSizeLimitBytes: bufferFileSizeLimitBytes,
bufferFileShared: bufferFileShared,
retainedBufferFileCountLimit: retainedBufferFileCountLimit,
batchPostingLimit: batchPostingLimit,
batchSizeLimitBytes: batchSizeLimitBytes,
period: period.Value,
textFormatter: textFormatter,
batchFormatter: batchFormatter,
httpClient: httpClient);
return(sinkConfiguration.Sink(sink, restrictedToMinimumLevel));
}
public TimeRolledDurableHttpSink(
string requestUri,
string bufferBaseFileName,
BufferRollingInterval bufferRollingInterval,
long?bufferFileSizeLimitBytes,
bool bufferFileShared,
int?retainedBufferFileCountLimit,
int batchPostingLimit,
long batchSizeLimitBytes,
TimeSpan period,
ITextFormatter textFormatter,
IBatchFormatter batchFormatter,
IHttpClient httpClient)
{
if (bufferFileSizeLimitBytes < 0)
{
throw new ArgumentOutOfRangeException(nameof(bufferFileSizeLimitBytes), "Negative value provided; file size limit must be non-negative.");
}
shipper = new HttpLogShipper(
httpClient,
requestUri,
new TimeRolledBufferFiles(new DirectoryService(), bufferBaseFileName),
batchPostingLimit,
batchSizeLimitBytes,
period,
batchFormatter);
sink = new LoggerConfiguration()
.WriteTo.File(
formatter: textFormatter,
path: $"{bufferBaseFileName}-.json",
fileSizeLimitBytes: bufferFileSizeLimitBytes,
shared: bufferFileShared,
rollingInterval: bufferRollingInterval.ToRollingInterval(),
rollOnFileSizeLimit: false,
retainedFileCountLimit: retainedBufferFileCountLimit)
.CreateLogger();
}
/// <summary>
/// Adds a durable sink that sends log events using HTTP POST over the network. A durable
/// sink will persist log events on disk in buffer files before sending them over the
/// network, thus protecting against data loss after a system or process restart. The
/// buffer files will use a rolling behavior defined by the file size specified in
/// <paramref name="bufferFileSizeLimitBytes"/>, i.e. a new buffer file is created when
/// current has passed its limit. The maximum number of retained files is defined by
/// <paramref name="retainedBufferFileCountLimit"/>, and when that limit is reached the
/// oldest file is dropped to make room for a new.
/// </summary>
/// <param name="sinkConfiguration">The logger configuration.</param>
/// <param name="requestUri">The URI the request is sent to.</param>
/// <param name="bufferBaseFileName">
/// The relative or absolute path for a set of files that will be used to buffer events
/// until they can be successfully transmitted across the network. Individual files will be
/// created using the pattern "<paramref name="bufferBaseFileName"/>*.json", which should
/// not clash with any other file names in the same directory. Default value is "Buffer".
/// </param>
/// <param name="bufferFileSizeLimitBytes">
/// The approximate maximum size, in bytes, to which a buffer 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="retainedBufferFileCountLimit">
/// The maximum number of buffer files that will be retained, including the current buffer
/// file. Under normal operation only 2 files will be kept, however if the log server is
/// unreachable, the number of files specified by <paramref name="retainedBufferFileCountLimit"/>
/// will be kept on the file system. For unlimited retention, pass null. Default value is 31.
/// </param>
/// <param name="batchPostingLimit">
/// The maximum number of events to post in a single batch. Default value is 1000.
/// </param>
/// <param name="period">
/// The time to wait between checking for event batches. Default value is 2 seconds.
/// </param>
/// <param name="textFormatter">
/// The formatter rendering individual log events into text, for example JSON. Default
/// value is <see cref="NormalRenderedTextFormatter"/>.
/// </param>
/// <param name="batchFormatter">
/// The formatter batching multiple log events into a payload that can be sent over the
/// network. Default value is <see cref="DefaultBatchFormatter"/>.
/// </param>
/// <param name="restrictedToMinimumLevel">
/// The minimum level for events passed through the sink. Default value is
/// <see cref="LevelAlias.Minimum"/>.
/// </param>
/// <param name="httpClient">
/// A custom <see cref="IHttpClient"/> implementation. Default value is
/// <see cref="HttpClient"/>.
/// </param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
public static LoggerConfiguration DurableElasticEcsLogstashUsingFileSizeRolledBuffers(
this LoggerSinkConfiguration sinkConfiguration,
string requestUri,
string bufferBaseFileName = "Buffer",
long?bufferFileSizeLimitBytes = 1024 * 1024 * 1024,
int?retainedBufferFileCountLimit = 31,
int batchPostingLimit = 1000,
TimeSpan?period = null,
ITextFormatter textFormatter = null,
IBatchFormatter batchFormatter = null,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
IHttpClient httpClient = null)
{
if (sinkConfiguration == null)
{
throw new ArgumentNullException(nameof(sinkConfiguration));
}
// Default values
period = period ?? TimeSpan.FromSeconds(2);
textFormatter = textFormatter ?? new NormalRenderedTextFormatter();
batchFormatter = batchFormatter ?? new DefaultBatchFormatter();
httpClient = httpClient ?? new DefaultHttpClient();
var sink = new FileSizeRolledDurableElasticEcsLogstashSink(
requestUri,
bufferBaseFileName,
bufferFileSizeLimitBytes,
retainedBufferFileCountLimit,
batchPostingLimit,
period.Value,
textFormatter,
batchFormatter,
httpClient);
return(sinkConfiguration.Sink(sink, restrictedToMinimumLevel));
}
/// <summary>
/// Adds a non-durable sink that sends log events using HTTP POST over the network. A
/// non-durable sink will lose data after a system or process restart.
/// </summary>
/// <param name="sinkConfiguration">The logger configuration.</param>
/// <param name="requestUri">The URI the request is sent to.</param>
/// <param name="batchPostingLimit">
/// The maximum number of events to post in a single batch. Default value is 1000.
/// </param>
/// <param name="batchSizeLimitBytes">
/// The approximate maximum size, in bytes, for a single batch. The value is an
/// approximation because only the size of the log events are considered. The extra
/// characters added by the batch formatter, where the sequence of serialized log events
/// are transformed into a payload, are not considered. Please make sure to accommodate for
/// those. Default value is long.MaxValue.
/// </param>
/// <param name="queueLimit">
/// The maximum number of events stored in the queue in memory, waiting to be posted over
/// the network. Default value is infinitely.
/// </param>
/// <param name="period">
/// The time to wait between checking for event batches. Default value is 2 seconds.
/// </param>
/// <param name="textFormatter">
/// The formatter rendering individual log events into text, for example JSON. Default
/// value is <see cref="NormalRenderedTextFormatter"/>.
/// </param>
/// <param name="batchFormatter">
/// The formatter batching multiple log events into a payload that can be sent over the
/// network. Default value is <see cref="DefaultBatchFormatter"/>.
/// </param>
/// <param name="restrictedToMinimumLevel">
/// The minimum level for events passed through the sink. Default value is
/// <see cref="LevelAlias.Minimum"/>.
/// </param>
/// <param name="httpClient">
/// A custom <see cref="IHttpClient"/> implementation. Default value is
/// <see cref="HttpClient"/>.
/// </param>
/// <param name="configuration">
/// Configuration passed to <paramref name="httpClient"/>. Parameter is either manually
/// specified when configuring the sink in source code or automatically passed in when
/// configuring the sink using
/// <see href="https://www.nuget.org/packages/Serilog.Settings.Configuration">Serilog.Settings.Configuration</see>.
/// </param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
public static LoggerConfiguration Http(
this LoggerSinkConfiguration sinkConfiguration,
string requestUri,
int batchPostingLimit = 1000,
long batchSizeLimitBytes = long.MaxValue,
int?queueLimit = null,
TimeSpan?period = null,
ITextFormatter textFormatter = null,
IBatchFormatter batchFormatter = null,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
IHttpClient httpClient = null,
IConfiguration configuration = null)
{
if (sinkConfiguration == null)
{
throw new ArgumentNullException(nameof(sinkConfiguration));
}
// Default values
period ??= TimeSpan.FromSeconds(2);
textFormatter ??= new NormalRenderedTextFormatter();
batchFormatter ??= new DefaultBatchFormatter();
httpClient ??= new DefaultHttpClient();
httpClient.Configure(configuration);
var sink = new HttpSink(
requestUri: requestUri,
batchPostingLimit: batchPostingLimit,
batchSizeLimitBytes: batchSizeLimitBytes,
queueLimit: queueLimit,
period: period.Value,
textFormatter: textFormatter,
batchFormatter: batchFormatter,
httpClient: httpClient);
return(sinkConfiguration.Sink(sink, restrictedToMinimumLevel));
}
public HttpLogShipper(
IHttpClient client,
string requestUri,
IBufferFiles bufferFiles,
int batchPostingLimit,
TimeSpan period,
IBatchFormatter batchFormatter)
{
if (batchPostingLimit <= 0)
{
throw new ArgumentException("batchPostingLimit must be 1 or greater", nameof(batchPostingLimit));
}
this.client = client ?? throw new ArgumentNullException(nameof(client));
this.requestUri = requestUri ?? throw new ArgumentNullException(nameof(requestUri));
this.bufferFiles = bufferFiles ?? throw new ArgumentNullException(nameof(bufferFiles));
this.batchPostingLimit = batchPostingLimit;
this.batchFormatter = batchFormatter ?? throw new ArgumentNullException(nameof(batchFormatter));
connectionSchedule = new ExponentialBackoffConnectionSchedule(period);
timer = new PortableTimer(OnTick);
SetTimer();
}
/// <summary>
/// Adds a durable sink that sends log events using HTTP POST over the network. A durable
/// sink will persist log events on disk in buffer files before sending them over the
/// network, thus protecting against data loss after a system or process restart. The
/// buffer files will use a rolling behavior defined by the file size specified in
/// <paramref name="bufferFileSizeLimitBytes"/>, i.e. a new buffer file is created when
/// current has passed its limit. The maximum number of retained files is defined by
/// <paramref name="retainedBufferFileCountLimit"/>, and when that limit is reached the
/// oldest file is dropped to make room for a new.
/// </summary>
/// <param name="sinkConfiguration">The logger configuration.</param>
/// <param name="requestUri">The URI the request is sent to.</param>
/// <param name="bufferBaseFileName">
/// The relative or absolute path for a set of files that will be used to buffer events
/// until they can be successfully transmitted across the network. Individual files will be
/// created using the pattern "<paramref name="bufferBaseFileName"/>*.json", which should
/// not clash with any other file names in the same directory. Default value is "Buffer".
/// </param>
/// <param name="bufferFileSizeLimitBytes">
/// The approximate maximum size, in bytes, to which a buffer 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="bufferFileShared">
/// Allow the buffer file to be shared by multiple processes. Default value is false.
/// </param>
/// <param name="retainedBufferFileCountLimit">
/// The maximum number of buffer files that will be retained, including the current buffer
/// file. Under normal operation only 2 files will be kept, however if the log server is
/// unreachable, the number of files specified by <paramref name="retainedBufferFileCountLimit"/>
/// will be kept on the file system. For unlimited retention, pass null. Default value is 31.
/// </param>
/// <param name="batchPostingLimit">
/// The maximum number of events to post in a single batch. Default value is 1000.
/// </param>
/// <param name="period">
/// The time to wait between checking for event batches. Default value is 2 seconds.
/// </param>
/// <param name="textFormatter">
/// The formatter rendering individual log events into text, for example JSON. Default
/// value is <see cref="NormalRenderedTextFormatter"/>.
/// </param>
/// <param name="batchFormatter">
/// The formatter batching multiple log events into a payload that can be sent over the
/// network. Default value is <see cref="DefaultBatchFormatter"/>.
/// </param>
/// <param name="restrictedToMinimumLevel">
/// The minimum level for events passed through the sink. Default value is
/// <see cref="LevelAlias.Minimum"/>.
/// </param>
/// <param name="httpClient">
/// A custom <see cref="IHttpClient"/> implementation. Default value is
/// <see cref="HttpClient"/>.
/// </param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
public static LoggerConfiguration Site24x7UsingFileSizeRolledBuffers(
this LoggerSinkConfiguration sinkConfiguration,
string requestUri,
string minimumLogLevel = null,
string bufferBaseFileName = "Buffer",
long?bufferFileSizeLimitBytes = 1024 * 1024 * 1024,
bool bufferFileShared = false,
int?retainedBufferFileCountLimit = 31,
int batchPostingLimit = 1000,
TimeSpan?period = null,
ITextFormatter textFormatter = null,
IBatchFormatter batchFormatter = null,
IHttpClient httpClient = null)
{
LogEventLevel restrictedToMinimumLevel = LogEventLevel.Verbose;
if (minimumLogLevel == null)
{
restrictedToMinimumLevel = LogEventLevel.Verbose;
}
else if (minimumLogLevel == "Debug")
{
restrictedToMinimumLevel = LogEventLevel.Debug;
}
else if (minimumLogLevel == "Information")
{
restrictedToMinimumLevel = LogEventLevel.Information;
}
else if (minimumLogLevel == "Warning")
{
restrictedToMinimumLevel = LogEventLevel.Warning;
}
else if (minimumLogLevel == "Error")
{
restrictedToMinimumLevel = LogEventLevel.Error;
}
else if (minimumLogLevel == "Fatal")
{
restrictedToMinimumLevel = LogEventLevel.Fatal;
}
else
{
restrictedToMinimumLevel = LogEventLevel.Verbose;
}
if (sinkConfiguration == null)
{
throw new ArgumentNullException(nameof(sinkConfiguration));
}
// Default values
period = period ?? TimeSpan.FromMilliseconds(1);
textFormatter = textFormatter ?? new NormalRenderedTextFormatter();
batchFormatter = batchFormatter ?? new DefaultBatchFormatter();
httpClient = httpClient ?? new DefaultHttpClient();
var sink = new FileSizeRolledDurableHttpSink(
requestUri: requestUri,
bufferBaseFileName: bufferBaseFileName,
bufferFileSizeLimitBytes: bufferFileSizeLimitBytes,
bufferFileShared: bufferFileShared,
retainedBufferFileCountLimit: retainedBufferFileCountLimit,
batchPostingLimit: batchPostingLimit,
period: period.Value,
textFormatter: textFormatter,
batchFormatter: batchFormatter,
httpClient: httpClient);
return(sinkConfiguration.Sink(sink, restrictedToMinimumLevel));
}
