/// <summary>
/// Adds a sink that sends log events via email.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <param name="fromEmail">The email address emails will be sent from</param>
/// <param name="toEmail">The email address emails will be sent to</param>
/// <param name="mailServer">The SMTP email server to use</param>
/// <param name="networkCredential">The network credentials to use to authenticate with mailServer</param>
/// <param name="outputTemplate">A message template describing the format used to write to the sink.
/// the default is "{Timestamp} [{Level}] {Message:l}{NewLine:l}{Exception:l}".</param>
/// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
/// <param name="batchPostingLimit">The maximum number of events to post in a single batch.</param>
/// <param name="period">The time to wait between checking for event batches.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
/// <exception cref="ArgumentNullException">A required parameter is null.</exception>
public static LoggerConfiguration Email(
this LoggerSinkConfiguration loggerConfiguration,
string fromEmail,
string toEmail,
string mailServer,
ICredentialsByHost networkCredential,
string outputTemplate = DefaultOutputTemplate,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
int batchPostingLimit = EmailSink.DefaultBatchPostingLimit,
TimeSpan? period = null,
IFormatProvider formatProvider = null)
{
if (loggerConfiguration == null) throw new ArgumentNullException("loggerConfiguration");
if (fromEmail == null) throw new ArgumentNullException("fromEmail");
if (toEmail == null) throw new ArgumentNullException("toEmail");
if (mailServer == null) throw new ArgumentNullException("mailServer");
var defaultedPeriod = period ?? EmailSink.DefaultPeriod;
var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
return loggerConfiguration.Sink(
new EmailSink(fromEmail, toEmail, mailServer, networkCredential, batchPostingLimit, defaultedPeriod, formatter),
restrictedToMinimumLevel);
}
public void LowercaseFormatSpecifierIsSupportedForStrings()
{
var formatter = new MessageTemplateTextFormatter("{Name:w}", CultureInfo.InvariantCulture);
var evt = DelegatingSink.GetLogEvent(l => l.Information("{Name}", "Nick"));
var sw = new StringWriter();
formatter.Format(evt, sw);
Assert.AreEqual("nick", sw.ToString());
}
public void MessageTemplatesContainingFormatStringPropertiesRenderCorrectly()
{
var formatter = new MessageTemplateTextFormatter("{Message:l}", CultureInfo.InvariantCulture);
var evt = DelegatingSink.GetLogEvent(l => l.Information("{Message}", "Hello, world!"));
var sw = new StringWriter();
formatter.Format(evt, sw);
Assert.AreEqual("\"Hello, world!\"", sw.ToString());
}
public void DefaultLevelLengthIsFullText()
{
var formatter = new MessageTemplateTextFormatter("{Level}", CultureInfo.InvariantCulture);
var evt = DelegatingSink.GetLogEvent(l => l.Information("Hello"));
var sw = new StringWriter();
formatter.Format(evt, sw);
Assert.Equal("Information", sw.ToString());
}
public void AppliesCustomFormatterToEnums()
{
var formatter = new MessageTemplateTextFormatter("{Message}", new SizeFormatter(CultureInfo.InvariantCulture));
var evt = DelegatingSink.GetLogEvent(l => l.Information("Size {Size}", Size.Large));
var sw = new StringWriter();
formatter.Format(evt, sw);
Assert.Equal("Size Huge", sw.ToString());
}
public void AligmentAndWidthCanBeCombined()
{
var formatter = new MessageTemplateTextFormatter("{Level,5:w3}", CultureInfo.InvariantCulture);
var evt = DelegatingSink.GetLogEvent(l => l.Information("Hello"));
var sw = new StringWriter();
formatter.Format(evt, sw);
Assert.Equal(" inf", sw.ToString());
}
public static LoggerConfiguration Debug(this LoggerSinkConfiguration loggerConfiguration,
string outputTemplate = DefaultOutputTemplate,
IFormatProvider formatProvider = null)
{
Guard.ArgumentNotNull(() => loggerConfiguration, loggerConfiguration);
var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
return loggerConfiguration.Sink(new DebugLogSink(formatter));
}
public void ConfigureLogger()
{
var formatter = new MessageTemplateTextFormatter("${date} [${threadid}] ${level} ${logger} ${ndc} - ${message}${newline}", null);
var channelFactory = Substitute.For<ChannelFactory>();
_channel = Substitute.For<IEventChannel>();
channelFactory.Create("localhost", 8765, 1).Returns(_channel);
_sink = new BrowserConsoleSink(true, 8765, 1, formatter,false, channelFactory);
}
public void UsesFormatProvider()
{
var french = CultureInfo.GetCultureInfo("fr-FR");
var formatter = new MessageTemplateTextFormatter("{Message:l}", french);
var evt = DelegatingSink.GetLogEvent(l => l.Information("{0}", 12.345));
var sw = new StringWriter();
formatter.Format(evt, sw);
Assert.AreEqual("12,345", sw.ToString());
}
public static LoggerConfiguration RollingFileAsText(this LoggerSinkConfiguration sinkConfiguration, string pathFormat, LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum)
{
if (sinkConfiguration == null)
throw new ArgumentNullException("sinkConfiguration");
var formatter = new MessageTemplateTextFormatter(DefaultOutputTemplate, null);
var sink = new RollingFileSink(pathFormat, formatter, DefaultFileSizeLimitBytes, DefaultRetainedFileCountLimit);
return sinkConfiguration.Sink(sink, restrictedToMinimumLevel);
}
private const int DefaultRetainedFileCountLimit = 31; // A long month of logs
/// <summary>
/// Writes log events to <see cref="IOutput" />.
/// </summary>
/// <param name="sinkConfiguration">Logger sink configuration.</param>
/// <param name="factory"></param>
/// <param name="outputLogFilterProvider"></param>
/// <param name="restrictedToMinimumLevel">
/// The minimum level for
/// events passed through the sink.
/// </param>
/// <param name="outputTemplate">
/// A message template describing the format used to write to the sink.
/// the default is "{Timestamp} [{Level}] {Message}{NewLine}{Exception}".
/// </param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <returns>Configuration object allowing method chaining.</returns>
public static LoggerConfiguration OutputModule(this LoggerSinkConfiguration sinkConfiguration,
Func<IOutput> factory, Func<IOutputLogFilter> outputLogFilterProvider = null, LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
string outputTemplate = DefaultConsoleOutputTemplate, IFormatProvider formatProvider = null)
{
if (sinkConfiguration == null) throw new ArgumentNullException("sinkConfiguration");
if (outputTemplate == null) throw new ArgumentNullException("outputTemplate");
var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
return sinkConfiguration.Sink(new OutputSink(factory, formatter, outputLogFilterProvider), restrictedToMinimumLevel);
}
public static LoggerConfiguration RedisStreamSink(
this LoggerSinkConfiguration loggerConfiguration,
RedisStreamSinkConfiguration redisStreamSinkConfiguration,
string outputTemplate = DefaultOutputTemplate,
IFormatProvider formatProvider = null)
{
var formatter = new Serilog.Formatting.Display.MessageTemplateTextFormatter(outputTemplate, formatProvider);
return(loggerConfiguration.Sink(new RedisStreamSink(redisStreamSinkConfiguration, formatter)));
}
// for testing
internal BrowserConsoleSink(bool active, int port, int buffer, MessageTemplateTextFormatter formatter, bool logProperties, ChannelFactory channelFactory)
{
Active = active;
Port = port;
Buffer = buffer;
LogProperties = logProperties;
Formatter = formatter;
CreateChannel(channelFactory);
}
/// <summary>
/// Writes log events to <see cref="System.Console"/>.
/// </summary>
/// <param name="sinkConfiguration">Logger sink configuration.</param>
/// <param name="restrictedToMinimumLevel">The minimum level for
/// events passed through the sink.</param>
/// <param name="outputTemplate">A message template describing the format used to write to the sink.
/// the default is "{Timestamp} [{Level}] {Message:l}{NewLine:l}{Exception:l}".</param>
/// <returns>Configuration object allowing method chaining.</returns>
public static LoggerConfiguration Console(
this LoggerSinkConfiguration sinkConfiguration,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
string outputTemplate = DefaultConsoleOutputTemplate)
{
if (sinkConfiguration == null) throw new ArgumentNullException("sinkConfiguration");
if (outputTemplate == null) throw new ArgumentNullException("outputTemplate");
var formatter = new MessageTemplateTextFormatter(outputTemplate);
return sinkConfiguration.Sink(new ConsoleSink(formatter), restrictedToMinimumLevel);
}
/// <summary>
/// Writes log events to <see cref="System.Diagnostics.Debug"/>.
/// </summary>
/// <param name="sinkConfiguration">Logger sink configuration.</param>
/// <param name="restrictedToMinimumLevel">The minimum level for events passed through the sink.</param>
/// <param name="outputTemplate">A message template describing the format used to write to the sink.the default is "{Timestamp} [{Level}] {Message}{NewLine}{Exception}".</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <returns>Configuration object allowing method chaining.</returns>
public static LoggerConfiguration Debug(this LoggerSinkConfiguration sinkConfiguration,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
string outputTemplate = DefaultOutputTemplate,
IFormatProvider formatProvider = null)
{
if (sinkConfiguration == null)
throw new ArgumentNullException(nameof(sinkConfiguration));
if (outputTemplate == null)
throw new ArgumentNullException(nameof(outputTemplate));
var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
return sinkConfiguration.Sink(new DebugSink(formatter), restrictedToMinimumLevel);
}
/// <summary>
/// Use Server Side Event to broadcast logs to a debugging browser console.
/// </summary>
/// <param name="sinkConfiguration">Logger sink configuration.</param>
/// <param name="restrictedToMinimumLevel">The minimum level for
/// events passed through the sink. Ignored when <paramref name="levelSwitch"/> is specified.</param>
/// <param name="active">Activate or not the logging (default: false)</param>
/// <param name="port">Port on which the browser should connect (default: 8082)</param>
/// <param name="buffer">Size of the buffer (default: 100)</param>
/// <param name="outputTemplate">The template used to format the message (default: "{Timestamp:yyyy-MM-dd HH:mm:ss} [{Level}] {Message}{NewLine}{Exception}")</param>
/// <param name="formatProvider">Format provider that should be used when formating the message (default: null)</param>
/// <param name="logProperties">Enable logging of meta-properties (default: false)</param>
/// <returns>Configuration object allowing method chaining.</returns>
public static LoggerConfiguration BrowserConsole(
this LoggerSinkConfiguration sinkConfiguration,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
bool active = false,
int port = 8082,
int buffer = 100,
string outputTemplate = DefaultOutputTemplate,
IFormatProvider formatProvider = null,
bool logProperties = false)
{
var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
return sinkConfiguration.Sink(new BrowserConsoleSink(active, port, buffer, formatter, logProperties), restrictedToMinimumLevel);
}
public static LoggerConfiguration TraceSource(
this LoggerSinkConfiguration sinkConfiguration,
string traceSourceName,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
string outputTemplate = DefaultOutputTemplate,
IFormatProvider formatProvider = null)
{
if (string.IsNullOrWhiteSpace(traceSourceName)) throw new ArgumentNullException("traceSourceName");
if (sinkConfiguration == null) throw new ArgumentNullException("sinkConfiguration");
if (outputTemplate == null) throw new ArgumentNullException("outputTemplate");
var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
return sinkConfiguration.Sink(new TraceSourceSink(formatter, traceSourceName), restrictedToMinimumLevel);
}
/// <summary>
/// Adds a sink that writes log events to the output of an xUnit test.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <param name="testOutputHelper">Xunit <see cref="TestOutputHelper"/> that writes to test output</param>
/// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
/// <param name="outputTemplate">Message template describing the output format.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
/// <exception cref="ArgumentNullException">A required parameter is null.</exception>
public static LoggerConfiguration XunitTestOutput(
this LoggerSinkConfiguration loggerConfiguration,
ITestOutputHelper testOutputHelper,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
string outputTemplate = DefaultOutputTemplate,
IFormatProvider formatProvider = null)
{
if (loggerConfiguration == null) throw new ArgumentNullException("loggerConfiguration");
if (testOutputHelper == null) throw new ArgumentNullException("testOutputHelper");
if (outputTemplate == null) throw new ArgumentNullException("outputTemplate");
var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
return loggerConfiguration.Sink(new XUnitTestOutputSink(testOutputHelper, formatter), restrictedToMinimumLevel);
}
/// <summary>
/// Adds a sink that writes log events to the Windows event log.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <param name="source">The source name by which the application is registered on the local computer. </param>
/// <param name="logName">The name of the log the source's entries are written to. Possible values include Application, System, or a custom event log. </param>
/// <param name="machineName">The name of the machine hosting the event log written to. The local machine by default.</param>
/// <param name="outputTemplate">A message template describing the format used to write to the sink. The default is "{Timestamp} [{Level}] {Message:l}{NewLine:l}{Exception:l}".</param>
/// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
/// <exception cref="ArgumentNullException">A required parameter is null.</exception>
public static LoggerConfiguration EventLog(
this LoggerSinkConfiguration loggerConfiguration,
string source,
string logName = null,
string machineName = ".",
string outputTemplate = DefaultOutputTemplate,
IFormatProvider formatProvider = null,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum
)
{
if (loggerConfiguration == null) throw new ArgumentNullException("loggerConfiguration");
var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
return loggerConfiguration.Sink(new EventLogSink(source, logName, formatter, machineName), restrictedToMinimumLevel);
}
/// <summary>
/// Adds a sink that sends log events via datadog.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <param name="datadogConfiguration">The configuration used for writing events to datadog.</param>
/// <param name="outputTemplate">A message template describing the format used to write to the sink.
/// the default is "{Timestamp} [{Level}] {Message}{NewLine}{Exception}".</param>
/// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
/// <param name="batchPostingLimit">The maximum number of events to post in a single batch.</param>
/// <param name="period">The time to wait between checking for event batches.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <returns>Logger configuration, allowing datadogConfiguration to continue.</returns>
/// <exception cref="ArgumentNullException">A required parameter is null.</exception>
public static LoggerConfiguration Datadog(
this LoggerSinkConfiguration loggerConfiguration,
DatadogConfiguration datadogConfiguration,
string outputTemplate = DefaultOutputTemplate,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
int batchPostingLimit = DatadogSink.DefaultBatchPostingLimit,
TimeSpan? period = null,
IFormatProvider formatProvider = null)
{
if (datadogConfiguration == null) throw new ArgumentNullException("datadogConfiguration");
var defaultedPeriod = period ?? DatadogSink.DefaultPeriod;
var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
var datadogSink = new DatadogSink(datadogConfiguration, batchPostingLimit, defaultedPeriod, formatter);
return loggerConfiguration.Sink(datadogSink, restrictedToMinimumLevel);
}
public void Should_send_an_sse_message_when_receiving_a_logging_event()
{
// given
var channelFactory = Substitute.For<ChannelFactory>();
_channel = Substitute.For<IEventChannel>();
channelFactory.Create(Arg.Any<string>(), 8765, 1).Returns(_channel);
var messageTemplateTextFormatter = new MessageTemplateTextFormatter(BrowserConsoleLoggerConfigurationExtensions.DefaultOutputTemplate, null);
var sink = new BrowserConsoleSink(true, 8765, 1, messageTemplateTextFormatter, false, channelFactory);
var logEvent = new LogEvent(
new DateTimeOffset(new DateTime(2010, 10, 12)),
LogEventLevel.Information,
null,
GenerateMessageTemplate("Everything's fine with Serilog"),
new List<LogEventProperty>() { new LogEventProperty("test", new ScalarValue("value"))});
// when
sink.Emit(logEvent);
// then
_channel.Received().Send(Arg.Is<ServerSentEvent>(evt => evt.ToString().Contains("Everything's fine with Serilog")), Arg.Any<CancellationToken>());
}
/// <summary>
/// Write log events to a series of files. Each file will be named according to
/// the date of the first log entry written to it. Only simple date-based rolling is
/// currently supported.
/// </summary>
/// <param name="sinkConfiguration">Logger sink configuration.</param>
/// <param name="pathFormat">.NET format string describing the location of the log files,
/// with {0} in the place of the file date. E.g. "Logs\myapp-{0}.log" will result in log
/// files such as "Logs\myapp-2013-10-20.log", "Logs\myapp-2013-10-21.log" and so on.</param>
/// <param name="restrictedToMinimumLevel">The minimum level for
/// events passed through the sink.</param>
/// <param name="outputTemplate">A message template describing the format used to write to the sink.
/// the default is "{Timestamp} [{Level}] {Message:l}{NewLine:l}{Exception:l}".</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <returns>Configuration object allowing method chaining.</returns>
public static LoggerConfiguration RollingFile(
this LoggerSinkConfiguration sinkConfiguration,
string pathFormat,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
string outputTemplate = DefaultOutputTemplate,
IFormatProvider formatProvider = null)
{
if (sinkConfiguration == null) throw new ArgumentNullException("sinkConfiguration");
if (outputTemplate == null) throw new ArgumentNullException("outputTemplate");
var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
return sinkConfiguration.Sink(new RollingFileSink(pathFormat, formatter), restrictedToMinimumLevel);
}
/// <summary>
/// Write log events to a series of files. Each file will be named according to
/// the date of the first log entry written to it. Only simple date-based rolling is
/// currently supported.
/// </summary>
/// <param name="pathFormat">.NET format string describing the location of the log files,
/// with {0} in the place of the file date. E.g. "Logs\myapp-{0}.log" will result in log
/// files such as "Logs\myapp-2013-10-20.log", "Logs\myapp-2013-10-21.log" and so on.</param>
/// <param name="restrictedToMinimumLevel">The minimum level for
/// events passed through the sink.</param>
/// <param name="outputTemplate">A message template describing the format used to write to the sink.
/// the default is "{TimeStamp} [{Level}] {Message:l}{NewLine:l}{Exception:l}".</param>
/// <returns>Configuration object allowing method chaining.</returns>
public LoggerConfiguration WithRollingFileSink(
string pathFormat,
LogEventLevel restrictedToMinimumLevel = LogEventLevel.Minimum,
string outputTemplate = DefaultOutputTemplate)
{
var formatter = new MessageTemplateTextFormatter(outputTemplate);
return WithSink(new RollingFileSink(pathFormat, formatter), restrictedToMinimumLevel);
}
/// <summary>
/// Write log events to a series of files. Each file will be named according to
/// the date of the first log entry written to it. Only simple date-based rolling is
/// currently supported.
/// </summary>
/// <param name="sinkConfiguration">Logger sink configuration.</param>
/// <param name="pathFormat">String describing the location of the log files,
/// with {Date} in the place of the file date. E.g. "Logs\myapp-{Date}.log" will result in log
/// files such as "Logs\myapp-2013-10-20.log", "Logs\myapp-2013-10-21.log" and so on.</param>
/// <param name="restrictedToMinimumLevel">The minimum level for
/// events passed through the sink.</param>
/// <param name="outputTemplate">A message template describing the format used to write to the sink.
/// the default is "{Timestamp} [{Level}] {Message}{NewLine}{Exception}".</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <param name="fileSizeLimitBytes">The maximum size, in bytes, to which any single log file will be allowed to grow.
/// For unrestricted growth, pass null. The default is 1 GB.</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>
/// <returns>Configuration object allowing method chaining.</returns>
/// <remarks>The file will be written using the UTF-8 character set.</remarks>
public static LoggerConfiguration RollingFile(
this LoggerSinkConfiguration sinkConfiguration,
string pathFormat,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
string outputTemplate = DefaultOutputTemplate,
IFormatProvider formatProvider = null,
long? fileSizeLimitBytes = DefaultFileSizeLimitBytes,
int? retainedFileCountLimit = DefaultRetainedFileCountLimit)
{
if (sinkConfiguration == null) throw new ArgumentNullException("sinkConfiguration");
if (outputTemplate == null) throw new ArgumentNullException("outputTemplate");
var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
var sink = new RollingFileSink(pathFormat, formatter, fileSizeLimitBytes, retainedFileCountLimit);
return sinkConfiguration.Sink(sink, restrictedToMinimumLevel);
}
/// <summary>
/// Adds a sink that sends log events via email.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <param name="connectionInfo">The connection info used for </param>
/// <param name="outputTemplate">A message template describing the format used to write to the sink.
/// the default is "{Timestamp} [{Level}] {Message}{NewLine}{Exception}".</param>
/// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
/// <param name="batchPostingLimit">The maximum number of events to post in a single batch.</param>
/// <param name="period">The time to wait between checking for event batches.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
/// <exception cref="ArgumentNullException">A required parameter is null.</exception>
public static LoggerConfiguration Email(
this LoggerSinkConfiguration loggerConfiguration,
EmailConnectionInfo connectionInfo,
string outputTemplate = DefaultOutputTemplate,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
int batchPostingLimit = EmailSink.DefaultBatchPostingLimit,
TimeSpan? period = null,
IFormatProvider formatProvider = null)
{
if (connectionInfo == null) throw new ArgumentNullException("connectionInfo");
var defaultedPeriod = period ?? EmailSink.DefaultPeriod;
var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
return loggerConfiguration.Sink(
new EmailSink(connectionInfo, batchPostingLimit, defaultedPeriod, formatter),
restrictedToMinimumLevel);
}
/// <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.</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} [{Level}] {Message}{NewLine}{Exception}".</param>
/// <param name="fileSizeLimitBytes">The maximum size, in bytes, to which a log file will be allowed to grow.
/// For unrestricted growth, pass null. The default is 1 GB.</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)
{
if (sinkConfiguration == null) throw new ArgumentNullException("sinkConfiguration");
if (outputTemplate == null) throw new ArgumentNullException("outputTemplate");
var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
FileSink sink;
try
{
sink = new FileSink(path, formatter, fileSizeLimitBytes);
}
catch (ArgumentException)
{
throw;
}
catch (Exception ex)
{
SelfLog.WriteLine("Unable to open file sink for {0}: {1}", path, ex);
return sinkConfiguration.Sink(new NullSink());
}
return sinkConfiguration.Sink(sink, restrictedToMinimumLevel);
}
public void Should_send_a_multiline_sse_message_received_logging_event_for_an_exception()
{
// given
var channelFactory = Substitute.For<ChannelFactory>();
_channel = Substitute.For<IEventChannel>();
channelFactory.Create(Arg.Any<string>(), 8765, 1).Returns(_channel);
var messageTemplateTextFormatter = new MessageTemplateTextFormatter(BrowserConsoleLoggerConfigurationExtensions.DefaultOutputTemplate, null);
var sink = new BrowserConsoleSink(true, 8765, 1, messageTemplateTextFormatter, false, channelFactory);
var logEvent = new LogEvent(
new DateTimeOffset(new DateTime(2010, 10, 12)),
LogEventLevel.Fatal,
new Exception("Message of the exception"),
GenerateMessageTemplate("Displaying of an exception"),
new List<LogEventProperty>() { new LogEventProperty("test", new ScalarValue("value")) });
// when
sink.Emit(logEvent);
// then
var lineSeparator = new string[] { "\r\n" };
_channel.Received().Send(
Arg.Is<ServerSentEvent>(
evt => evt.ToString()
.Split(lineSeparator, StringSplitOptions.RemoveEmptyEntries)
.Skip(1)
.All(l => l.StartsWith("data:"))
), Arg.Any<CancellationToken>());
}
/// <summary>
/// A sink that puts log events into a provided Azure Event Hub.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <param name="eventHubClient">The Event Hub to use to insert the log entries to.</param>
/// <param name="partitionKey">The partition key used to group log events in the Event Hub.</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} [{Level}] {Message}{NewLine}{Exception}".</param>
/// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
/// <param name="writeInBatches">Use a periodic batching sink, as opposed to a synchronous one-at-a-time sink; this alters the partition
/// key used for the events so is not enabled by default.</param>
/// <param name="batchPostingLimit">The maximum number of events to post in a single batch.</param>
/// <param name="period">The time to wait between checking for event batches.</param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
/// <exception cref="ArgumentNullException">A required parameter is null.</exception>
public static LoggerConfiguration AzureEventHub(
this LoggerSinkConfiguration loggerConfiguration,
EventHubClient eventHubClient,
string partitionKey = null,
string outputTemplate = DefaultOutputTemplate,
IFormatProvider formatProvider = null,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
bool writeInBatches = false,
TimeSpan? period = null,
int? batchPostingLimit = null
)
{
if (loggerConfiguration == null)
throw new ArgumentNullException("loggerConfiguration");
if (eventHubClient == null)
throw new ArgumentNullException("eventHubClient");
if (outputTemplate == null)
throw new ArgumentNullException("outputTemplate");
var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
var sink = writeInBatches ?
(ILogEventSink) new AzureEventHubBatchingSink(
eventHubClient,
partitionKey ?? DefaultPartitionKey,
formatter,
batchPostingLimit ?? DefaultBatchPostingLimit,
period ?? DefaultPeriod) :
new AzureEventHubSink(
eventHubClient,
partitionKey ?? DefaultPartitionKey,
formatter);
return loggerConfiguration.Sink(sink, restrictedToMinimumLevel);
}
public DebugLogSink(MessageTemplateTextFormatter formatter)
{
this.formatter = formatter;
}
/// <summary>
/// Write log events to the provided <see cref="TextWriter"/>.
/// </summary>
/// <param name="textWriter">The text writer to write log events to.</param>
/// <param name="outputTemplate">Message template describing the output format.</param>
/// <param name="restrictedToMinimumLevel">The minimum level for
/// events passed through the sink.</param>
/// <returns>Configuration object allowing method chaining.</returns>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <exception cref="ArgumentNullException"></exception>
public LoggerConfiguration TextWriter(
TextWriter textWriter,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
string outputTemplate = DefaultOutputTemplate,
IFormatProvider formatProvider = null)
{
if (textWriter == null) throw new ArgumentNullException("textWriter");
if (outputTemplate == null) throw new ArgumentNullException("outputTemplate");
var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
var sink = new TextWriterSink(textWriter, formatter);
return Sink(sink);
}
public TraceSourceSink(MessageTemplateTextFormatter formatter, string traceSourceName)
{
_formatter = formatter;
_source = new TraceSource(traceSourceName);
}