* Separate SinkOptions methods also for audit sink (config extensions and ctor).

* Implemented reading SinkOptions for config systems Microsoft.Extensions.Configuration and  System.Configuration.
* Added some basic integration tests for reading SinkOptions from config.

Author: ckadluba

src/Serilog.Sinks.MSSqlServer/Configuration/Extensions/Hybrid/LoggerConfigurationMSSqlServerExtensions.cs

@@ -44,7 +44,7 @@ public static class LoggerConfigurationMSSqlServerExtensions
         /// https://gist.github.com/mivano/10429656
         /// or use the autoCreateSqlTable option.
         ///
-        /// Note: this is the legacy version of the extension method. Please use the new one using SinkOptions instead of separate parameters.
+        /// Note: this is the legacy version of the extension method. Please use the new one using SinkOptions instead.
         /// 
         /// </summary>
         /// <param name="loggerConfiguration">The logger configuration.</param>
@@ -74,9 +74,12 @@ public static LoggerConfiguration MSSqlServer(
             bool autoCreateSqlTable = false,
             ColumnOptions columnOptions = null,
             IConfigurationSection columnOptionsSection = null,
-            string schemaName = "dbo",
+            string schemaName = MSSqlServerSink.DefaultSchemaName,
             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(
@@ -161,7 +164,7 @@ internal static LoggerConfiguration MSSqlServerInternal(
             {
                 connectionString = applySystemConfiguration.GetConnectionString(connectionString);
                 columnOptions = applySystemConfiguration.ConfigureColumnOptions(serviceConfigSection, columnOptions);
-                // TODO get sink options from System.Config
+                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.");
@@ -189,6 +192,9 @@ internal static LoggerConfiguration MSSqlServerInternal(
 
         /// <summary>
         /// Adds a sink that writes log events to a table in a MSSqlServer database.
+        ///
+        /// Note: this is the legacy version of the extension method. Please use the new one using SinkOptions instead.
+        /// 
         /// </summary>
         /// <param name="loggerAuditSinkConfiguration">The logger configuration.</param>
         /// <param name="connectionString">The connection string to the database where to store the events.</param>
@@ -201,8 +207,6 @@ internal static LoggerConfiguration MSSqlServerInternal(
         /// <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>
-        /// <param name="sinkOptions">Supplies additional settings for the sink</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(
@@ -215,23 +219,62 @@ public static LoggerConfiguration MSSqlServer(
             bool autoCreateSqlTable = false,
             ColumnOptions columnOptions = null,
             IConfigurationSection columnOptionsSection = null,
-            string schemaName = "dbo",
-            ITextFormatter logEventFormatter = null,
-            SinkOptions sinkOptions = null,
-            IConfigurationSection sinkOptionsSection = null) =>
-            loggerAuditSinkConfiguration.MSSqlServerInternal(
+            string schemaName = MSSqlServerSink.DefaultSchemaName,
+            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, null, null, autoCreateSqlTable, schemaName);
+
+            return loggerAuditSinkConfiguration.MSSqlServer(
                 connectionString: connectionString,
-                tableName: tableName,
+                sinkOptions: sinkOptions,
                 appConfiguration: appConfiguration,
                 restrictedToMinimumLevel: restrictedToMinimumLevel,
                 formatProvider: formatProvider,
-                autoCreateSqlTable: autoCreateSqlTable,
                 columnOptions: columnOptions,
                 columnOptionsSection: columnOptionsSection,
-                schemaName: schemaName,
                 logEventFormatter: logEventFormatter,
+                sinkOptionsSection: null);
+        }
+
+        /// <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="sinkOptions">Supplies additional settings for the sink</param>
+        /// <param name="sinkOptionsSection">A config section defining 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>
+        /// <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,
+            IConfigurationSection sinkOptionsSection = null,
+            IConfiguration appConfiguration = null,
+            LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
+            IFormatProvider formatProvider = null,
+            ColumnOptions columnOptions = null,
+            IConfigurationSection columnOptionsSection = null,
+            ITextFormatter logEventFormatter = null) =>
+            loggerAuditSinkConfiguration.MSSqlServerInternal(
+                connectionString: connectionString,
                 sinkOptions: sinkOptions,
                 sinkOptionsSection: sinkOptionsSection,
+                appConfiguration: appConfiguration,
+                restrictedToMinimumLevel: restrictedToMinimumLevel,
+                formatProvider: formatProvider,
+                columnOptions: columnOptions,
+                columnOptionsSection: columnOptionsSection,
+                logEventFormatter: logEventFormatter,
                 applySystemConfiguration: new ApplySystemConfiguration(),
                 applyMicrosoftExtensionsConfiguration: new ApplyMicrosoftExtensionsConfiguration(),
                 auditSinkFactory: new MSSqlServerAuditSinkFactory());
@@ -240,56 +283,51 @@ public static LoggerConfiguration MSSqlServer(
         internal static LoggerConfiguration MSSqlServerInternal(
             this LoggerAuditSinkConfiguration loggerAuditSinkConfiguration,
             string connectionString,
-            string tableName,
+            SinkOptions sinkOptions = null,
+            IConfigurationSection sinkOptionsSection = null,
             IConfiguration appConfiguration = null,
             LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
             IFormatProvider formatProvider = null,
-            bool autoCreateSqlTable = false,
             ColumnOptions columnOptions = null,
             IConfigurationSection columnOptionsSection = null,
-            string schemaName = "dbo",
             ITextFormatter logEventFormatter = null,
-            SinkOptions sinkOptions = null,
-            IConfigurationSection sinkOptionsSection = null,
             IApplySystemConfiguration applySystemConfiguration = null,
             IApplyMicrosoftExtensionsConfiguration applyMicrosoftExtensionsConfiguration = null,
             IMSSqlServerAuditSinkFactory auditSinkFactory = null)
         {
             if (loggerAuditSinkConfiguration == null)
                 throw new ArgumentNullException(nameof(loggerAuditSinkConfiguration));
 
-            var colOpts = columnOptions ?? new ColumnOptions();
-            var connStr = connectionString;
-            var sinkOpts = sinkOptions ?? new SinkOptions();
+            sinkOptions = sinkOptions ?? new SinkOptions();
+            columnOptions = columnOptions ?? new ColumnOptions();
 
             var serviceConfigSection = applySystemConfiguration.GetSinkConfigurationSection(AppConfigSectionName);
             if (serviceConfigSection != null)
             {
-                connStr = applySystemConfiguration.GetConnectionString(connStr);
-                colOpts = applySystemConfiguration.ConfigureColumnOptions(serviceConfigSection, colOpts);
-                // TODO get sink options from config
+                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)
             {
-                connStr = applyMicrosoftExtensionsConfiguration.GetConnectionString(connStr, appConfiguration);
+                connectionString = applyMicrosoftExtensionsConfiguration.GetConnectionString(connectionString, appConfiguration);
             }
 
             if (columnOptionsSection != null)
             {
-                colOpts = applyMicrosoftExtensionsConfiguration.ConfigureColumnOptions(colOpts, columnOptionsSection);
+                columnOptions = applyMicrosoftExtensionsConfiguration.ConfigureColumnOptions(columnOptions, columnOptionsSection);
             }
 
             if (sinkOptionsSection != null)
             {
-                sinkOpts = applyMicrosoftExtensionsConfiguration.ConfigureSinkOptions(sinkOpts, sinkOptionsSection);
+                sinkOptions = applyMicrosoftExtensionsConfiguration.ConfigureSinkOptions(sinkOptions, sinkOptionsSection);
             }
 
-            var auditSink = auditSinkFactory.Create(connStr, tableName, formatProvider, autoCreateSqlTable,
-                colOpts, schemaName, logEventFormatter, sinkOpts);
+            var auditSink = auditSinkFactory.Create(connectionString, sinkOptions, formatProvider, columnOptions, logEventFormatter);
 
             return loggerAuditSinkConfiguration.Sink(auditSink, restrictedToMinimumLevel);
         }

src/Serilog.Sinks.MSSqlServer/Configuration/Extensions/Microsoft.Extensions.Configuration/LoggerConfigurationMSSqlServerExtensions.cs

@@ -36,7 +36,7 @@ public static partial class LoggerConfigurationMSSqlServerExtensions
         /// https://gist.github.com/mivano/10429656
         /// or use the autoCreateSqlTable option.
         ///
-        /// Note: this is the legacy version of the extension method. Please use the new one using SinkOptions instead of separate parameters.
+        /// Note: this is the legacy version of the extension method. Please use the new one using SinkOptions instead.
         /// 
         /// </summary>
         /// <param name="loggerConfiguration">The logger configuration.</param>
@@ -66,9 +66,12 @@ public static LoggerConfiguration MSSqlServer(
             bool autoCreateSqlTable = false,
             ColumnOptions columnOptions = null,
             IConfigurationSection columnOptionsSection = null,
-            string schemaName = "dbo",
+            string schemaName = MSSqlServerSink.DefaultSchemaName,
             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(
@@ -104,7 +107,7 @@ public static LoggerConfiguration MSSqlServer(
         public static LoggerConfiguration MSSqlServer(
             this LoggerSinkConfiguration loggerConfiguration,
             string connectionString,
-            SinkOptions sinkOptions,
+            SinkOptions sinkOptions = null,
             IConfiguration appConfiguration = null,
             LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
             IFormatProvider formatProvider = null,
@@ -132,6 +135,9 @@ public static LoggerConfiguration MSSqlServer(
 
         /// <summary>
         /// Adds a sink that writes log events to a table in a MSSqlServer database.
+        ///
+        /// Note: this is the legacy version of the extension method. Please use the new one using SinkOptions instead.
+        /// 
         /// </summary>
         /// <param name="loggerAuditSinkConfiguration">The logger configuration.</param>
         /// <param name="connectionString">The connection string to the database where to store the events.</param>
@@ -144,8 +150,6 @@ public static LoggerConfiguration MSSqlServer(
         /// <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>
-        /// <param name="sinkOptions">Supplies additional settings for the sink</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(
@@ -158,22 +162,66 @@ public static LoggerConfiguration MSSqlServer(
             bool autoCreateSqlTable = false,
             ColumnOptions columnOptions = null,
             IConfigurationSection columnOptionsSection = null,
-            string schemaName = "dbo",
-            ITextFormatter logEventFormatter = null,
+            string schemaName = MSSqlServerSink.DefaultSchemaName,
+            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, null, null, autoCreateSqlTable, schemaName);
+
+            return loggerAuditSinkConfiguration.MSSqlServer(
+                connectionString: connectionString,
+                sinkOptions: sinkOptions,
+                appConfiguration: appConfiguration,
+                restrictedToMinimumLevel: restrictedToMinimumLevel,
+                formatProvider: formatProvider,
+                columnOptions: columnOptions,
+                columnOptionsSection: columnOptionsSection,
+                logEventFormatter: logEventFormatter,
+                sinkOptionsSection: null);
+        }
+
+        /// <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="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 LoggerAuditSinkConfiguration loggerAuditSinkConfiguration,
+            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 (loggerAuditSinkConfiguration == null)
                 throw new ArgumentNullException(nameof(loggerAuditSinkConfiguration));
 
+            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);
 
             IMSSqlServerAuditSinkFactory auditSinkFactory = new MSSqlServerAuditSinkFactory();
-            var auditSink = auditSinkFactory.Create(connectionString, tableName, formatProvider, autoCreateSqlTable,
-                columnOptions, schemaName, logEventFormatter, sinkOptions);
+            var auditSink = auditSinkFactory.Create(connectionString, sinkOptions, formatProvider, columnOptions, logEventFormatter);
 
             return loggerAuditSinkConfiguration.Sink(auditSink, restrictedToMinimumLevel);
         }