/// <summary>
/// Adds a sink that sends log events to Datadog.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <param name="apiKey">Your Datadog API key.</param>
/// <param name="source">The integration name.</param>
/// <param name="service">The service name.</param>
/// <param name="host">The host name.</param>
/// <param name="tags">Custom tags.</param>
/// <param name="configuration">The Datadog logs client configuration.</param>
/// <param name="configurationSection">A config section defining the datadog configuration.</param>
/// <param name="logLevel">The minimum log level for the sink.</param>
/// <param name="batchSizeLimit">The maximum number of events to emit in a single batch.</param>
/// <param name="batchPeriod">The time to wait before emitting a new event batch.</param>
/// <param name="queueLimit">
/// Maximum number of events to hold in the sink's internal queue, or <c>null</c>
/// for an unbounded queue. The default is <c>10000</c>
/// </param>
/// <param name="exceptionHandler">This function is called when an exception occurs when using
/// DatadogConfiguration.UseTCP=false (the default configuration)</param>
/// <returns>Logger configuration</returns>
/// <exception cref="ArgumentNullException">A required parameter is null.</exception>
public static LoggerConfiguration DatadogLogs(
this LoggerSinkConfiguration loggerConfiguration,
string apiKey,
string source = null,
string service = null,
string host = null,
string[] tags = null,
DatadogConfiguration configuration = null,
IConfigurationSection configurationSection = null,
LogEventLevel logLevel = LevelAlias.Minimum,
int?batchSizeLimit = null,
TimeSpan?batchPeriod = null,
int?queueLimit = null,
Action <Exception> exceptionHandler = null)
{
if (loggerConfiguration == null)
{
throw new ArgumentNullException(nameof(loggerConfiguration));
}
if (string.IsNullOrWhiteSpace(apiKey))
{
throw new ArgumentNullException(nameof(apiKey));
}
var config = ApplyMicrosoftExtensionsConfiguration.ConfigureDatadogConfiguration(configuration, configurationSection);
var sink = DatadogSink.Create(apiKey, source, service, host, tags, config, batchSizeLimit, batchPeriod, queueLimit, exceptionHandler);
return(loggerConfiguration.Sink(sink, logLevel));
}
/// <summary>
/// Adds a sink that writes log events to a table in a MSSqlServer database.
/// </summary>
/// <param name="loggerAuditSinkConfiguration">The logger configuration.</param>
/// <param name="connectionString">The connection string to the database where to store the events.</param>
/// <param name="tableName">Name of the table to store the events in.</param>
/// <param name="appConfiguration">Additional application-level configuration. Required if connectionString is a name.</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>
/// <param name="autoCreateSqlTable">Create log table with the provided name on destination sql server.</param>
/// <param name="columnOptions">An externally-modified group of column settings</param>
/// <param name="columnOptionsSection">A config section defining various column settings</param>
/// <param name="schemaName">Name of the schema for the table to store the data in. The default is 'dbo'.</param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
/// <exception cref="ArgumentNullException">A required parameter is null.</exception>
public static LoggerConfiguration MSSqlServer(
this LoggerAuditSinkConfiguration loggerAuditSinkConfiguration,
string connectionString,
string tableName,
IConfiguration appConfiguration = null,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
IFormatProvider formatProvider = null,
bool autoCreateSqlTable = false,
ColumnOptions columnOptions = null,
IConfigurationSection columnOptionsSection = null,
string schemaName = "dbo"
)
{
if (loggerAuditSinkConfiguration == null)
{
throw new ArgumentNullException("loggerAuditSinkConfiguration");
}
var connectionStr = ApplyMicrosoftExtensionsConfiguration.GetConnectionString(connectionString, appConfiguration);
var colOpts = ApplyMicrosoftExtensionsConfiguration.ConfigureColumnOptions(columnOptions, columnOptionsSection);
return(loggerAuditSinkConfiguration.Sink(
new MSSqlServerAuditSink(
connectionString,
tableName,
formatProvider,
autoCreateSqlTable,
columnOptions,
schemaName
),
restrictedToMinimumLevel));
}
/// <summary>
/// Adds a sink that writes log events to a table in a MSSqlServer database.
/// Create a database and execute the table creation script found here
/// https://gist.github.com/mivano/10429656
/// or use the autoCreateSqlTable option.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <param name="connectionString">The connection string to the database where to store the events.</param>
/// <param name="tableName">Name of the table to store the events in.</param>
/// <param name="appConfiguration">Additional application-level configuration. Required if connectionString is a name.</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>
/// <param name="autoCreateSqlTable">Create log table with the provided name on destination sql server.</param>
/// <param name="columnOptions">An externally-modified group of column settings</param>
/// <param name="columnOptionsSection">A config section defining various column settings</param>
/// <param name="schemaName">Name of the schema for the table to store the data in. The default is 'dbo'.</param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
/// <exception cref="ArgumentNullException">A required parameter is null.</exception>
public static LoggerConfiguration MSSqlServer(
this LoggerSinkConfiguration loggerConfiguration,
string connectionString,
string tableName,
IConfiguration appConfiguration = null,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
int batchPostingLimit = MSSqlServerSink.DefaultBatchPostingLimit,
TimeSpan?period = null,
IFormatProvider formatProvider = null,
bool autoCreateSqlTable = false,
ColumnOptions columnOptions = null,
IConfigurationSection columnOptionsSection = null,
string schemaName = "dbo"
)
{
if (loggerConfiguration == null)
{
throw new ArgumentNullException("loggerConfiguration");
}
var defaultedPeriod = period ?? MSSqlServerSink.DefaultPeriod;
var colOpts = columnOptions ?? new ColumnOptions();
var connStr = connectionString;
if (ConfigurationManager.GetSection(AppConfigSectionName) is MSSqlServerConfigurationSection serviceConfigSection)
{
colOpts = ApplySystemConfiguration.ConfigureColumnOptions(serviceConfigSection, colOpts);
connStr = ApplySystemConfiguration.GetConnectionString(connStr);
if (appConfiguration != null || columnOptionsSection != null)
{
SelfLog.WriteLine("Warning: Both System.Configuration (app.config or web.config) and Microsoft.Extensions.Configuration are being applied to the MSSQLServer sink.");
}
}
if (appConfiguration != null || columnOptionsSection != null)
{
connStr = ApplyMicrosoftExtensionsConfiguration.GetConnectionString(connStr, appConfiguration);
colOpts = ApplyMicrosoftExtensionsConfiguration.ConfigureColumnOptions(colOpts, columnOptionsSection);
}
return(loggerConfiguration.Sink(
new MSSqlServerSink(
connStr,
tableName,
batchPostingLimit,
defaultedPeriod,
formatProvider,
autoCreateSqlTable,
colOpts,
schemaName
),
restrictedToMinimumLevel));
}
private static void ReadConfiguration(
ref string connectionString,
ref MSSqlServerSinkOptions sinkOptions,
IConfiguration appConfiguration,
ref ColumnOptions columnOptions,
IConfigurationSection columnOptionsSection,
IConfigurationSection sinkOptionsSection)
{
sinkOptions = sinkOptions ?? new MSSqlServerSinkOptions();
columnOptions = columnOptions ?? new ColumnOptions();
IApplyMicrosoftExtensionsConfiguration microsoftExtensionsConfiguration = new ApplyMicrosoftExtensionsConfiguration();
connectionString = microsoftExtensionsConfiguration.GetConnectionString(connectionString, appConfiguration);
columnOptions = microsoftExtensionsConfiguration.ConfigureColumnOptions(columnOptions, columnOptionsSection);
sinkOptions = microsoftExtensionsConfiguration.ConfigureSinkOptions(sinkOptions, sinkOptionsSection);
}
public void GetConfigurationStringCallsAttachedConfigurationStringProvider()
{
// Arrange
const string connectionStringName = "TestConnectionStringName";
const string expectedResult = "TestConnectionString";
var configurationMock = new Mock <IConfiguration>();
var connectionStringProviderMock = new Mock <IMicrosoftExtensionsConnectionStringProvider>();
connectionStringProviderMock.Setup(p => p.GetConnectionString(It.IsAny <string>(), It.IsAny <IConfiguration>())).Returns(expectedResult);
var sut = new ApplyMicrosoftExtensionsConfiguration(connectionStringProviderMock.Object, null, null);
// Act
var result = sut.GetConnectionString(connectionStringName, configurationMock.Object);
// Assert
connectionStringProviderMock.Verify(p => p.GetConnectionString(connectionStringName, configurationMock.Object), Times.Once);
Assert.Equal(expectedResult, result);
}
public void ConfigureSinkOptionsCallsAttachedSinkOptionsProvider()
{
// Arrange
var inputSinkOptions = new SinkOptions();
var expectedResult = new SinkOptions();
var configurationSectionMock = new Mock <IConfigurationSection>();
var sinkOptionsProviderMock = new Mock <IMicrosoftExtensionsSinkOptionsProvider>();
sinkOptionsProviderMock.Setup(p => p.ConfigureSinkOptions(It.IsAny <SinkOptions>(), It.IsAny <IConfigurationSection>()))
.Returns(expectedResult);
var sut = new ApplyMicrosoftExtensionsConfiguration(null, null, sinkOptionsProviderMock.Object);
// Act
var result = sut.ConfigureSinkOptions(inputSinkOptions, configurationSectionMock.Object);
// Assert
sinkOptionsProviderMock.Verify(p => p.ConfigureSinkOptions(inputSinkOptions, configurationSectionMock.Object), Times.Once);
Assert.Same(expectedResult, result);
}
/// <summary>
/// Adds a sink that writes log events to a table in a MSSqlServer database.
/// Create a database and execute the table creation script found here
/// https://gist.github.com/mivano/10429656
/// or use the autoCreateSqlTable option.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <param name="connectionString">The connection string to the database where to store the events.</param>
/// <param name="tableName">Name of the table to store the events in.</param>
/// <param name="appConfiguration">Additional application-level configuration. Required if connectionString is a name.</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>
/// <param name="autoCreateSqlTable">Create log table with the provided name on destination sql server.</param>
/// <param name="columnOptions">An externally-modified group of column settings</param>
/// <param name="columnOptionsSection">A config section defining various column settings</param>
/// <param name="schemaName">Name of the schema for the table to store the data in. The default is 'dbo'.</param>
/// <param name="logEventFormatter">Supplies custom formatter for the LogEvent column, or null</param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
/// <exception cref="ArgumentNullException">A required parameter is null.</exception>
public static LoggerConfiguration MSSqlServer(
this LoggerSinkConfiguration loggerConfiguration,
string connectionString,
string tableName,
IConfiguration appConfiguration = null,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
int batchPostingLimit = MSSqlServerSink.DefaultBatchPostingLimit,
TimeSpan?period = null,
IFormatProvider formatProvider = null,
bool autoCreateSqlTable = false,
ColumnOptions columnOptions = null,
IConfigurationSection columnOptionsSection = null,
string schemaName = "dbo",
ITextFormatter logEventFormatter = null)
{
if (loggerConfiguration == null)
{
throw new ArgumentNullException(nameof(loggerConfiguration));
}
var defaultedPeriod = period ?? MSSqlServerSink.DefaultPeriod;
var connectionStr = ApplyMicrosoftExtensionsConfiguration.GetConnectionString(connectionString, appConfiguration);
var colOpts = ApplyMicrosoftExtensionsConfiguration.ConfigureColumnOptions(columnOptions, columnOptionsSection);
return(loggerConfiguration.Sink(
new MSSqlServerSink(
connectionStr,
tableName,
batchPostingLimit,
defaultedPeriod,
formatProvider,
autoCreateSqlTable,
colOpts,
schemaName,
logEventFormatter),
restrictedToMinimumLevel));
}
/// <summary>
/// Adds a sink that sends log events to Datadog.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <param name="apiKey">Your Datadog API key.</param>
/// <param name="source">The integration name.</param>
/// <param name="service">The service name.</param>
/// <param name="host">The host name.</param>
/// <param name="tags">Custom tags.</param>
/// <param name="configuration">The Datadog logs client configuration.</param>
/// <param name="configurationSection">A config section defining the datadog configuration.</param>
/// <returns>Logger configuration</returns>
/// <exception cref="ArgumentNullException">A required parameter is null.</exception>
public static LoggerConfiguration DatadogLogs(
this LoggerSinkConfiguration loggerConfiguration,
string apiKey,
string source = null,
string service = null,
string host = null,
string[] tags = null,
DatadogConfiguration configuration = null,
IConfigurationSection configurationSection = null,
LogEventLevel logLevel = LevelAlias.Minimum)
{
if (loggerConfiguration == null)
{
throw new ArgumentNullException(nameof(loggerConfiguration));
}
if (string.IsNullOrWhiteSpace(apiKey))
{
throw new ArgumentNullException(nameof(apiKey));
}
var config = ApplyMicrosoftExtensionsConfiguration.ConfigureDatadogConfiguration(configuration, configurationSection);
return(loggerConfiguration.Sink(new DatadogSink(apiKey, source, service, host, tags, config), logLevel));
}
