Merge branch 'dev'

Author: mivano

.editorconfig

@@ -0,0 +1,16 @@
+root = true
+
+[*]
+trim_trailing_whitespace = true
+insert_final_newline = true
+indent_style = space
+indent_size = 4
+
+[*.{csproj,json,config,yml}]
+indent_size = 2
+
+[*.sh]
+end_of_line = lf
+
+[*.{cmd, bat}]
+end_of_line = crlf

CHANGES.md

@@ -1,3 +1,6 @@
+5.2
+ * Support for Audit sink added (#118/#110).
+
 4.0.0
  * Serilog 2.0
  * [Documentation fix](https://github.com/serilog/serilog-sinks-mssqlserver/pull/32)

README.md

@@ -5,6 +5,8 @@ A Serilog sink that writes events to Microsoft SQL Server. While a NoSql store a
 **Package** - [Serilog.Sinks.MSSqlServer](http://nuget.org/packages/serilog.sinks.mssqlserver)
 | **Platforms** - .NET 4.5 and .NET Standard 2.0
 
+From version 5.2 and up, this sink also support the Audit capabilities.
+
 ## Configuration
 
 At minimum a connection string and table name are required.

src/Serilog.Sinks.MSSqlServer/LoggerConfigurationMSSqlServerExtensions.cs

@@ -64,11 +64,8 @@ public static LoggerConfiguration MSSqlServer(
 
             var defaultedPeriod = period ?? MSSqlServerSink.DefaultPeriod;
 
-            MSSqlServerConfigurationSection serviceConfigSection =
-               ConfigurationManager.GetSection("MSSqlServerSettingsSection") as MSSqlServerConfigurationSection;
-
             // If we have additional columns from config, load them as well
-            if (serviceConfigSection != null && serviceConfigSection.Columns.Count > 0)
+            if (ConfigurationManager.GetSection("MSSqlServerSettingsSection") is MSSqlServerConfigurationSection serviceConfigSection && serviceConfigSection.Columns.Count > 0)
             {
                 if (columnOptions == null)
                 {
@@ -93,6 +90,57 @@ public static LoggerConfiguration MSSqlServer(
                 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="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="schemaName">Name of the schema for the table to store the data in. The default is 'dbo'.</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"></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,
+                                                      LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
+                                                      IFormatProvider formatProvider = null,
+                                                      bool autoCreateSqlTable = false,
+                                                      ColumnOptions columnOptions = null,
+                                                      string schemaName = "dbo")
+        {
+            if (loggerAuditSinkConfiguration == null) throw new ArgumentNullException("loggerAuditSinkConfiguration");
+
+            // If we have additional columns from config, load them as well
+            if (ConfigurationManager.GetSection("MSSqlServerSettingsSection") is MSSqlServerConfigurationSection serviceConfigSection && serviceConfigSection.Columns.Count > 0)
+            {
+                if (columnOptions == null)
+                {
+                    columnOptions = new ColumnOptions();
+                }
+                GenerateDataColumnsFromConfig(serviceConfigSection, columnOptions);
+            }
+
+            connectionString = GetConnectionString(connectionString);
+
+            return loggerAuditSinkConfiguration.Sink(
+                new MSSqlServerAuditSink(
+                    connectionString,
+                    tableName,
+                    formatProvider,
+                    autoCreateSqlTable,
+                    columnOptions,
+                    schemaName
+                    ),
+                restrictedToMinimumLevel);
+        }
+
         /// <summary>
         /// Examine if supplied connection string is a reference to an item in the "ConnectionStrings" section of web.config
         /// If it is, return the ConnectionStrings item, if not, return string as supplied.
@@ -101,7 +149,7 @@ public static LoggerConfiguration MSSqlServer(
         /// <remarks>Pulled from review of Entity Framework 6 methodology for doing the same</remarks>
         private static string GetConnectionString(string nameOrConnectionString)
         {
-            
+
             // If there is an `=`, we assume this is a raw connection string not a named value
             // If there are no `=`, attempt to pull the named value from config
             if (nameOrConnectionString.IndexOf('=') < 0)
@@ -140,48 +188,48 @@ private static void GenerateDataColumnsFromConfig(MSSqlServerConfigurationSectio
                 switch (c.DataType)
                 {
                     case "bigint":
-                        dataType = Type.GetType("System.Int64");
+                        dataType = typeof(long);
                         break;
                     case "bit":
-                        dataType = Type.GetType("System.Boolean");
+                        dataType = typeof(bool);
                         break;
                     case "char":
                     case "nchar":
                     case "ntext":
                     case "nvarchar":
                     case "text":
                     case "varchar":
-                        dataType = Type.GetType("System.String");
+                        dataType = typeof(string);
                         break;
                     case "date":
                     case "datetime":
                     case "datetime2":
                     case "smalldatetime":
-                        dataType = Type.GetType("System.DateTime");
+                        dataType = typeof(DateTime);
                         break;
                     case "decimal":
                     case "money":
                     case "numeric":
                     case "smallmoney":
-                        dataType = Type.GetType("System.Decimal");
+                        dataType = typeof(Decimal);
                         break;
                     case "float":
-                        dataType = Type.GetType("System.Double");
+                        dataType = typeof(double);
                         break;
                     case "int":
-                        dataType = Type.GetType("System.Int32");
+                        dataType = typeof(int);
                         break;
                     case "real":
-                        dataType = Type.GetType("System.Single");
+                        dataType = typeof(float);
                         break;
                     case "smallint":
-                        dataType = Type.GetType("System.Int16");
+                        dataType = typeof(short);
                         break;
                     case "time":
-                        dataType = Type.GetType("System.TimeSpan");
+                        dataType = typeof(TimeSpan);
                         break;
                     case "uniqueidentifier":
-                        dataType = Type.GetType("System.Guid");
+                        dataType = typeof(Guid);
                         break;
                 }
                 column.DataType = dataType;

src/Serilog.Sinks.MSSqlServer/Serilog.Sinks.MSSqlServer.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <Description>A Serilog sink that writes events to Microsoft SQL Server</Description>
-    <VersionPrefix>5.1.1</VersionPrefix>
+    <VersionPrefix>5.1.2</VersionPrefix>
     <Authors>Michiel van Oudheusden;Serilog Contributors</Authors>
     <TargetFrameworks>netstandard2.0;net45;net452</TargetFrameworks>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>

src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerAuditSink.cs

@@ -0,0 +1,144 @@
+// Copyright 2018 Serilog Contributors 
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Serilog.Core;
+using Serilog.Debugging;
+using Serilog.Events;
+using System;
+using System.Data;
+using System.Data.SqlClient;
+using System.Linq;
+using System.Text;
+
+namespace Serilog.Sinks.MSSqlServer
+{
+    /// <summary>
+    ///  Writes log events as rows in a table of MSSqlServer database using Audit logic, meaning that each row is synchronously committed
+    ///  and any errors that occur are propagated to the caller.
+    /// </summary>
+    public class MSSqlServerAuditSink : ILogEventSink, IDisposable
+    {
+        private readonly MSSqlServerSinkTraits _traits;
+
+        /// <summary>
+        ///     Construct a sink posting to the specified database.
+        /// </summary>
+        /// <param name="connectionString">Connection string to access the database.</param>
+        /// <param name="tableName">Name of the table to store the data in.</param>
+        /// <param name="schemaName">Name of the schema for the table to store the data in. The default is 'dbo'.</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">Options that pertain to columns</param>
+        public MSSqlServerAuditSink(
+            string connectionString,
+            string tableName,
+            IFormatProvider formatProvider,
+            bool autoCreateSqlTable = false,
+            ColumnOptions columnOptions = null,
+            string schemaName = "dbo"
+            )
+        {
+            if (columnOptions != null)
+            {
+                if (columnOptions.DisableTriggers)
+                    throw new NotSupportedException($"The {nameof(ColumnOptions.DisableTriggers)} option is not supported for auditing.");
+            }
+
+            _traits = new MSSqlServerSinkTraits(connectionString, tableName, schemaName, columnOptions, formatProvider, autoCreateSqlTable);
+            
+        }
+
+        /// <summary>Emit the provided log event to the sink.</summary>
+        /// <param name="logEvent">The log event to write.</param>
+        public void Emit(LogEvent logEvent)
+        {
+            try
+            {
+                using (SqlConnection connection = new SqlConnection(_traits.ConnectionString))
+                {
+                    connection.Open();
+                    using (SqlCommand command = connection.CreateCommand())
+                    {
+                        command.CommandType = CommandType.Text;
+
+                        StringBuilder fieldList = new StringBuilder($"INSERT INTO [{_traits.SchemaName}].[{_traits.TableName}] (");
+                        StringBuilder parameterList = new StringBuilder(") VALUES (");
+
+                        int index = 0;
+                        foreach (var field in _traits.GetColumnsAndValues(logEvent))
+                        {
+                            if (index != 0)
+                            {
+                                fieldList.Append(',');
+                                parameterList.Append(',');
+                            }
+
+                            fieldList.Append(field.Key);
+                            parameterList.Append("@P");
+                            parameterList.Append(index);
+
+                            SqlParameter parameter = new SqlParameter($"@P{index}", field.Value ?? DBNull.Value);                            
+
+                            // The default is SqlDbType.DateTime, which will truncate the DateTime value if the actual
+                            // type in the database table is datetime2. So we explicitly set it to DateTime2, which will
+                            // work both if the field in the table is datetime and datetime2, which is also consistent with 
+                            // the behavior of the non-audit sink.
+                            if (field.Value is DateTime)
+                                parameter.SqlDbType = SqlDbType.DateTime2;
+
+                            command.Parameters.Add(parameter);
+
+                            index++;
+                        }
+
+                        parameterList.Append(')');
+                        fieldList.Append(parameterList.ToString());
+
+                        command.CommandText = fieldList.ToString();
+
+                        command.ExecuteNonQuery();
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                SelfLog.WriteLine("Unable to write log event to the database due to following error: {1}", ex.Message);
+                throw;
+            }            
+        }
+
+        /// <summary>
+        /// Releases the unmanaged resources used by the Serilog.Sinks.MSSqlServer.MSSqlServerAuditSink and optionally
+        /// releases the managed resources.
+        /// </summary>
+        /// <param name="disposing">True to release both managed and unmanaged resources; false to release only unmanaged
+        ///                         resources.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                _traits.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+    }
+}