public void MSSqlServerCallsSinkFactoryWithSinkOptionsFromSystemConfig()
{
// Arrange
var configSinkOptions = new SinkOptions();
_applySystemConfigurationMock.Setup(c => c.GetSinkConfigurationSection(It.IsAny <string>()))
.Returns(new MSSqlServerConfigurationSection());
_applySystemConfigurationMock.Setup(c => c.ConfigureSinkOptions(It.IsAny <MSSqlServerConfigurationSection>(), It.IsAny <SinkOptions>()))
.Returns(configSinkOptions);
var sinkFactoryMock = new Mock <IMSSqlServerSinkFactory>();
// Act
_loggerConfiguration.WriteTo.MSSqlServerInternal(
configSectionName: "TestConfigSectionName",
connectionString: "TestConnectionString",
sinkOptions: new SinkOptions {
TableName = "TestTableName"
},
columnOptions: new Serilog.Sinks.MSSqlServer.ColumnOptions(),
applySystemConfiguration: _applySystemConfigurationMock.Object,
sinkFactory: sinkFactoryMock.Object);
// Assert
sinkFactoryMock.Verify(f => f.Create(It.IsAny <string>(), configSinkOptions,
It.IsAny <IFormatProvider>(), It.IsAny <Serilog.Sinks.MSSqlServer.ColumnOptions>(), It.IsAny <ITextFormatter>()), Times.Once);
}
public void MSSqlServerAuditCallsSinkFactoryWithSuppliedParameters()
{
// Arrange
const string connectionString = "TestConnectionString";
var sinkOptions = new SinkOptions();
var columnOptions = new Serilog.Sinks.MSSqlServer.ColumnOptions();
var formatProviderMock = new Mock <IFormatProvider>();
var logEventFormatterMock = new Mock <ITextFormatter>();
var auditSinkFactoryMock = new Mock <IMSSqlServerAuditSinkFactory>();
// Act
_loggerConfiguration.AuditTo.MSSqlServerInternal(
connectionString: connectionString,
sinkOptions: sinkOptions,
columnOptions: columnOptions,
formatProvider: formatProviderMock.Object,
logEventFormatter: logEventFormatterMock.Object,
applySystemConfiguration: _applySystemConfigurationMock.Object,
applyMicrosoftExtensionsConfiguration: _applyMicrosoftExtensionsConfigurationMock.Object,
auditSinkFactory: auditSinkFactoryMock.Object);
// Assert
auditSinkFactoryMock.Verify(f => f.Create(connectionString, sinkOptions,
formatProviderMock.Object, columnOptions, logEventFormatterMock.Object), Times.Once);
}
private static void ValidateParameters(SinkOptions sinkOptions)
{
if (sinkOptions?.TableName == null)
{
throw new InvalidOperationException("Table name must be specified!");
}
}
public MSSqlServerAuditSinkTests()
{
_sinkOptions = new SinkOptions
{
TableName = _tableName,
SchemaName = _schemaName
};
_columnOptions = new Serilog.Sinks.MSSqlServer.ColumnOptions();
_dataTable = new DataTable(_tableName);
_dataTableCreatorMock = new Mock <IDataTableCreator>();
_dataTableCreatorMock.Setup(d => d.CreateDataTable())
.Returns(_dataTable);
_sqlTableCreatorMock = new Mock <ISqlTableCreator>();
_sqlLogEventWriter = new Mock <ISqlLogEventWriter>();
_sinkDependencies = new SinkDependencies
{
DataTableCreator = _dataTableCreatorMock.Object,
SqlTableCreator = _sqlTableCreatorMock.Object,
SqlLogEventWriter = _sqlLogEventWriter.Object
};
}
public SinkDependenciesFactoryTests()
{
_sinkOptions = new SinkOptions {
TableName = "LogEvents"
};
_columnOptions = new Serilog.Sinks.MSSqlServer.ColumnOptions();
}
// Internal overload with parameters used by tests to override the config section and inject mocks
internal static LoggerConfiguration MSSqlServerInternal(
this LoggerAuditSinkConfiguration loggerAuditSinkConfiguration,
string connectionString,
SinkOptions sinkOptions = null,
IConfigurationSection sinkOptionsSection = null,
IConfiguration appConfiguration = null,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
IFormatProvider formatProvider = null,
ColumnOptions columnOptions = null,
IConfigurationSection columnOptionsSection = null,
ITextFormatter logEventFormatter = null,
IApplySystemConfiguration applySystemConfiguration = null,
IApplyMicrosoftExtensionsConfiguration applyMicrosoftExtensionsConfiguration = null,
IMSSqlServerAuditSinkFactory auditSinkFactory = null)
{
if (loggerAuditSinkConfiguration == null)
{
throw new ArgumentNullException(nameof(loggerAuditSinkConfiguration));
}
ReadConfiguration(ref connectionString, ref sinkOptions, sinkOptionsSection, appConfiguration,
ref columnOptions, columnOptionsSection, applySystemConfiguration, applyMicrosoftExtensionsConfiguration);
var auditSink = auditSinkFactory.Create(connectionString, sinkOptions, formatProvider, columnOptions, logEventFormatter);
return(loggerAuditSinkConfiguration.Sink(auditSink, restrictedToMinimumLevel));
}
public static LoggerConfiguration MSSqlServer(
this LoggerSinkConfiguration loggerConfiguration,
string connectionString,
string tableName,
string schemaName = MSSqlServerSink.DefaultSchemaName,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
int batchPostingLimit = MSSqlServerSink.DefaultBatchPostingLimit,
TimeSpan?period = null,
IFormatProvider formatProvider = null,
bool autoCreateSqlTable = false,
ColumnOptions columnOptions = null,
ITextFormatter logEventFormatter = null)
{
// Do not add new parameters here. This interface is considered legacy and will be deprecated in the future.
// For adding new input parameters use the SinkOptions class and the method overload that accepts SinkOptions.
var sinkOptions = new SinkOptions(tableName, batchPostingLimit, period, autoCreateSqlTable, schemaName);
return(loggerConfiguration.MSSqlServer(
connectionString: connectionString,
sinkOptions: sinkOptions,
restrictedToMinimumLevel: restrictedToMinimumLevel,
formatProvider: formatProvider,
columnOptions: columnOptions,
logEventFormatter: logEventFormatter));
}
public void MSSqlServerCallsSinkFactoryWithSuppliedParameters()
{
// Arrange
var sinkOptions = new SinkOptions {
TableName = "TestTableName"
};
var columnOptions = new Serilog.Sinks.MSSqlServer.ColumnOptions();
var formatProviderMock = new Mock <IFormatProvider>();
var logEventFormatterMock = new Mock <ITextFormatter>();
var sinkFactoryMock = new Mock <IMSSqlServerSinkFactory>();
_applySystemConfigurationMock.Setup(c => c.GetConnectionString(It.IsAny <string>()))
.Returns <string>(c => c);
// Act
_loggerConfiguration.WriteTo.MSSqlServerInternal(
configSectionName: "TestConfigSectionName",
connectionString: "TestConnectionString",
sinkOptions: sinkOptions,
columnOptions: columnOptions,
formatProvider: formatProviderMock.Object,
logEventFormatter: logEventFormatterMock.Object,
applySystemConfiguration: _applySystemConfigurationMock.Object,
sinkFactory: sinkFactoryMock.Object);
// Assert
sinkFactoryMock.Verify(f => f.Create(It.IsAny <string>(), sinkOptions, formatProviderMock.Object,
columnOptions, logEventFormatterMock.Object), Times.Once);
}
public Logger CreateDefault()
{
var config = ConfigurationHelper.GetConfiguration();
var telemetryConfiguration = TelemetryConfiguration.CreateDefault();
telemetryConfiguration.InstrumentationKey =
config.GetValue <string>(ConfigurationKeys.ApplicationInsightsInstrumentationKey);
var logDb = config.GetConnectionString(ConfigurationKeys.SystemSqlConnectionStringName);
var sinkOpts = new SinkOptions
{
SchemaName = Constants.Log.LogSchemaName,
TableName = Constants.Log.LogTableName
};
return(new LoggerConfiguration()
.ReadFrom.Configuration(config)
.Enrich.WithMachineName()
.Enrich.WithProcessId()
.Enrich.FromLogContext()
.WriteTo.ApplicationInsights(telemetryConfiguration, TelemetryConverter.Traces)
.WriteTo.MSSqlServer(logDb, sinkOpts)
.WriteTo.Console()
.CreateLogger());
}
/// <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="sinkOptions">Supplies additional settings for the sink</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="columnOptions">An externally-modified group of column settings</param>
/// <param name="columnOptionsSection">A config section defining various column settings</param>
/// <param name="logEventFormatter">Supplies custom formatter for the LogEvent column, or null</param>
/// <param name="sinkOptionsSection">A config section defining additional settings for the sink</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,
SinkOptions sinkOptions = null,
IConfiguration appConfiguration = null,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
IFormatProvider formatProvider = null,
ColumnOptions columnOptions = null,
IConfigurationSection columnOptionsSection = null,
ITextFormatter logEventFormatter = null,
IConfigurationSection sinkOptionsSection = null)
{
if (loggerConfiguration == null)
{
throw new ArgumentNullException(nameof(loggerConfiguration));
}
ReadConfiguration(ref connectionString, ref sinkOptions, appConfiguration, ref columnOptions,
columnOptionsSection, sinkOptionsSection);
IMSSqlServerSinkFactory sinkFactory = new MSSqlServerSinkFactory();
var sink = sinkFactory.Create(connectionString, sinkOptions, formatProvider, columnOptions, logEventFormatter);
return(loggerConfiguration.Sink(sink, restrictedToMinimumLevel));
}
private void CreateTable(SinkOptions sinkOptions, SinkDependencies sinkDependencies)
{
if (sinkOptions.AutoCreateSqlTable)
{
sinkDependencies.SqlTableCreator.CreateTable(_eventTable);
}
}
private void ReadTableOptions(MSSqlServerConfigurationSection config, SinkOptions sinkOptions)
{
SetProperty.IfProvided <string>(config.TableName, nameof(config.TableName.Value), value => sinkOptions.TableName = value);
SetProperty.IfProvided <string>(config.SchemaName, nameof(config.SchemaName.Value), value => sinkOptions.SchemaName = value);
SetProperty.IfProvided <bool>(config.AutoCreateSqlTable, nameof(config.AutoCreateSqlTable.Value),
value => sinkOptions.AutoCreateSqlTable = value);
}
public void MSSqlServerAuditCallsSinkFactoryWithSinkOptionsFromMicrosoftConfigExtensions()
{
// Arrange
var configSinkOptions = new SinkOptions();
var sinkOptionsSectionMock = new Mock <IConfigurationSection>();
_applyMicrosoftExtensionsConfigurationMock.Setup(c => c.ConfigureSinkOptions(It.IsAny <SinkOptions>(), It.IsAny <IConfigurationSection>()))
.Returns(configSinkOptions);
var auditSinkFactoryMock = new Mock <IMSSqlServerAuditSinkFactory>();
// Act
_loggerConfiguration.AuditTo.MSSqlServerInternal(
connectionString: "TestConnectionString",
sinkOptions: new SinkOptions {
TableName = "TestTableName"
},
sinkOptionsSection: sinkOptionsSectionMock.Object,
applySystemConfiguration: _applySystemConfigurationMock.Object,
applyMicrosoftExtensionsConfiguration: _applyMicrosoftExtensionsConfigurationMock.Object,
auditSinkFactory: auditSinkFactoryMock.Object);
// Assert
auditSinkFactoryMock.Verify(f => f.Create(It.IsAny <string>(), configSinkOptions, It.IsAny <IFormatProvider>(),
It.IsAny <Serilog.Sinks.MSSqlServer.ColumnOptions>(), It.IsAny <ITextFormatter>()), Times.Once);
}
/// <summary>
/// Construct a sink posting to the specified database.
/// </summary>
/// <param name="connectionString">Connection string to access the database.</param>
/// <param name="sinkOptions">Supplies additional options for the sink</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <param name="columnOptions">Options that pertain to columns</param>
/// <param name="logEventFormatter">Supplies custom formatter for the LogEvent column, or null</param>
public MSSqlServerSink(
string connectionString,
SinkOptions sinkOptions,
IFormatProvider formatProvider = null,
ColumnOptions columnOptions = null,
ITextFormatter logEventFormatter = null)
: this(sinkOptions, SinkDependenciesFactory.Create(connectionString, sinkOptions, formatProvider, columnOptions, logEventFormatter))
{
}
private static void CreateTable(SinkOptions sinkOptions, SinkDependencies sinkDependencies)
{
if (sinkOptions.AutoCreateSqlTable)
{
using (var eventTable = sinkDependencies.DataTableCreator.CreateDataTable())
{
sinkDependencies.SqlTableCreator.CreateTable(eventTable);
}
}
}
public void InitializesDefaultedPropertiesWithDefaultsWhenCalledWithParameters()
{
// Act
var sut = new SinkOptions("TestTableName", null, null, true, null);
// Assert
Assert.Equal(MSSqlServerSink.DefaultSchemaName, sut.SchemaName);
Assert.Equal(MSSqlServerSink.DefaultBatchPostingLimit, sut.BatchPostingLimit);
Assert.Equal(MSSqlServerSink.DefaultPeriod, sut.BatchPeriod);
}
private static void ValidateParameters(SinkOptions sinkOptions, ColumnOptions columnOptions)
{
if (sinkOptions?.TableName == null)
{
throw new InvalidOperationException("Table name must be specified!");
}
if (columnOptions.DisableTriggers)
{
throw new NotSupportedException($"The {nameof(ColumnOptions.DisableTriggers)} option is not supported for auditing.");
}
}
// Internal constructor with injectable dependencies for better testability
internal MSSqlServerAuditSink(
SinkOptions sinkOptions,
ColumnOptions columnOptions,
SinkDependencies sinkDependencies)
{
ValidateParameters(sinkOptions, columnOptions);
CheckSinkDependencies(sinkDependencies);
_sqlLogEventWriter = sinkDependencies.SqlLogEventWriter;
CreateTable(sinkOptions, sinkDependencies);
}
public MSSqlServerSink Create(
string connectionString,
SinkOptions sinkOptions,
IFormatProvider formatProvider,
ColumnOptions columnOptions,
ITextFormatter logEventFormatter) =>
new MSSqlServerSink(
connectionString,
sinkOptions,
formatProvider,
columnOptions,
logEventFormatter);
// Internal constructor with injectable dependencies for better testability
internal MSSqlServerSink(
SinkOptions sinkOptions,
SinkDependencies sinkDependencies)
: base(sinkOptions?.BatchPostingLimit ?? DefaultBatchPostingLimit, sinkOptions?.BatchPeriod ?? DefaultPeriod)
{
ValidateParameters(sinkOptions);
CheckSinkDependencies(sinkDependencies);
_sqlBulkBatchWriter = sinkDependencies.SqlBulkBatchWriter;
_eventTable = sinkDependencies.DataTableCreator.CreateDataTable();
CreateTable(sinkOptions, sinkDependencies);
}
public SinkOptions ConfigureSinkOptions(SinkOptions sinkOptions, IConfigurationSection config)
{
if (config == null)
{
return(sinkOptions);
}
ReadTableOptions(config, sinkOptions);
ReadBatchSettings(config, sinkOptions);
ReadAzureManagedIdentitiesOptions(config, sinkOptions);
return(sinkOptions);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
//services.AddCors();
services.AddControllers()
.AddNewtonsoftJson(x => x.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore)
.AddFluentValidation();
services.AddDbContext <ShopContext>(x => x.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
services.AddScoped <IUnitOfWork, UnitOfWork>();
services.AddScoped <ICustomerRepository, CustomerRepository>();
services.AddScoped <IOrderRepository, OrderRepository>();
services.AddScoped <IProductRepository, ProductRepository>();
services.AddTransient <IValidator <CustomerUpdateDto>, CustomerUpdateValidator>();
services.AddApplication();
services.AddAuth().AddSwaggerAuth();
services.AddCors(confg =>
confg.AddPolicy("AllowAll",
p => p.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader()));
services.AddSingleton <Serilog.ILogger>(x => {
var connectionString = Configuration["Serilog:DefaultConnection"];
var tableName = Configuration["Serilog:TableName"];
var sqlLoggerOptions = new SinkOptions
{
AutoCreateSqlTable = true,
SchemaName = "Logger",
TableName = tableName,
BatchPostingLimit = 1
};
return(new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.MSSqlServer(connectionString, sqlLoggerOptions)
.CreateLogger());
});
//Infra
//Domain
}
public void InitializeWithDisableTriggersThrows()
{
// Arrange
var sinkOptions = new SinkOptions {
TableName = "TestTableName"
};
var columnOptions = new Serilog.Sinks.MSSqlServer.ColumnOptions {
DisableTriggers = true
};
// Act + assert
Assert.Throws <NotSupportedException>(() =>
new MSSqlServerAuditSink(sinkOptions, columnOptions, _sinkDependencies));
}
public void ConfigureSinkOptionsCalledWithConfigSectionNullReturnsUnchangedSinkOptions()
{
// Arrange
var sinkOptions = new SinkOptions {
UseAzureManagedIdentity = true
};
var sut = new MicrosoftExtensionsSinkOptionsProvider();
// Act
var result = sut.ConfigureSinkOptions(sinkOptions, null);
// Assert
Assert.True(result.UseAzureManagedIdentity);
}
private static void ReadConfiguration(
ref string connectionString,
ref SinkOptions sinkOptions,
IConfiguration appConfiguration,
ref ColumnOptions columnOptions,
IConfigurationSection columnOptionsSection,
IConfigurationSection sinkOptionsSection)
{
sinkOptions = sinkOptions ?? new SinkOptions();
columnOptions = columnOptions ?? new ColumnOptions();
IApplyMicrosoftExtensionsConfiguration microsoftExtensionsConfiguration = new ApplyMicrosoftExtensionsConfiguration();
connectionString = microsoftExtensionsConfiguration.GetConnectionString(connectionString, appConfiguration);
columnOptions = microsoftExtensionsConfiguration.ConfigureColumnOptions(columnOptions, columnOptionsSection);
sinkOptions = microsoftExtensionsConfiguration.ConfigureSinkOptions(sinkOptions, sinkOptionsSection);
}
/// <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="loggerAuditSinkConfiguration">The logger configuration.</param>
/// <param name="connectionString">The connection string to the database where to store the events.</param>
/// <param name="sinkOptions">Supplies additional settings for the sink</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="columnOptions"></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 LoggerAuditSinkConfiguration loggerAuditSinkConfiguration,
string connectionString,
SinkOptions sinkOptions = null,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
IFormatProvider formatProvider = null,
ColumnOptions columnOptions = null,
ITextFormatter logEventFormatter = null) =>
loggerAuditSinkConfiguration.MSSqlServerInternal(
configSectionName: AppConfigSectionName,
connectionString: connectionString,
sinkOptions: sinkOptions,
restrictedToMinimumLevel: restrictedToMinimumLevel,
formatProvider: formatProvider,
columnOptions: columnOptions,
logEventFormatter: logEventFormatter,
applySystemConfiguration: new ApplySystemConfiguration(),
auditSinkFactory: new MSSqlServerAuditSinkFactory());
public void InitializesPropertiesWithParameterValues()
{
// Arrange
const string tableName = "TestTableName";
const int batchPostingLimit = 23;
const string schemaName = "TestSchemaName";
var batchPeriod = new TimeSpan(0, 3, 23);
// Act
var sut = new SinkOptions(tableName, batchPostingLimit, batchPeriod, true, schemaName);
// Assert
Assert.Equal(tableName, sut.TableName);
Assert.Equal(batchPostingLimit, sut.BatchPostingLimit);
Assert.Equal(batchPeriod, sut.BatchPeriod);
Assert.True(sut.AutoCreateSqlTable);
Assert.Equal(schemaName, sut.SchemaName);
}
public void ConfigureSinkOptionsCallsAttachedSinkOptionsProvider()
{
// Arrange
var inputConfigSection = new MSSqlServerConfigurationSection();
var inputSinkOptions = new SinkOptions();
var expectedResult = new SinkOptions();
var sinkOptionsProviderMock = new Mock <ISystemConfigurationSinkOptionsProvider>();
sinkOptionsProviderMock.Setup(p => p.ConfigureSinkOptions(It.IsAny <MSSqlServerConfigurationSection>(), It.IsAny <SinkOptions>()))
.Returns(expectedResult);
var sut = new ApplySystemConfiguration(null, null, sinkOptionsProviderMock.Object);
// Act
var result = sut.ConfigureSinkOptions(inputConfigSection, inputSinkOptions);
// Assert
sinkOptionsProviderMock.Verify(p => p.ConfigureSinkOptions(inputConfigSection, inputSinkOptions), Times.Once);
Assert.Same(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);
}
private static void ReadConfiguration(
ref string connectionString,
ref SinkOptions sinkOptions,
IConfigurationSection sinkOptionsSection,
IConfiguration appConfiguration,
ref ColumnOptions columnOptions,
IConfigurationSection columnOptionsSection,
IApplySystemConfiguration applySystemConfiguration,
IApplyMicrosoftExtensionsConfiguration applyMicrosoftExtensionsConfiguration)
{
sinkOptions = sinkOptions ?? new SinkOptions();
columnOptions = columnOptions ?? new ColumnOptions();
var serviceConfigSection = applySystemConfiguration.GetSinkConfigurationSection(AppConfigSectionName);
if (serviceConfigSection != null)
{
connectionString = applySystemConfiguration.GetConnectionString(connectionString);
columnOptions = applySystemConfiguration.ConfigureColumnOptions(serviceConfigSection, columnOptions);
sinkOptions = applySystemConfiguration.ConfigureSinkOptions(serviceConfigSection, sinkOptions);
if (appConfiguration != null || columnOptionsSection != null || sinkOptionsSection != 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)
{
connectionString = applyMicrosoftExtensionsConfiguration.GetConnectionString(connectionString, appConfiguration);
}
if (columnOptionsSection != null)
{
columnOptions = applyMicrosoftExtensionsConfiguration.ConfigureColumnOptions(columnOptions, columnOptionsSection);
}
if (sinkOptionsSection != null)
{
sinkOptions = applyMicrosoftExtensionsConfiguration.ConfigureSinkOptions(sinkOptions, sinkOptionsSection);
}
}