Merge remote-tracking branch 'upstream/dev' into remove-duplicate-code-config-ext

Author: ckadluba

README.md

@@ -320,6 +320,7 @@ This is a `Collection<>` of `SqlColumn` objects that you create to define custom
 Each Standard Column in the `ColumnOptions.Store` list and any custom columns you add to the `AdditionalColumns` collection are `SqlColumn` objects with the following properties:
 
 * `ColumnName`
+* `PropertyName`
 * `DataType`
 * `AllowNull`
 * `DataLength`
@@ -329,6 +330,10 @@ Each Standard Column in the `ColumnOptions.Store` list and any custom columns yo
 
 Any valid SQL column name can be used. Standard Columns have default names assigned but these can be changed without affecting their special handling.
 
+### PropertyName
+
+The optional name of a Serilog property to use as the value for a custom column. If not provided, the property used is the one that has the same name as the specified ColumnName. It applies only to custom columns defined in `AdditionalColumns` and is ignored for standard columns.
+
 ### DataType
 
 This property can be set to nearly any value in the `System.Data.SqlDbType` enumeration. Unlike previous versions of this sink, SQL column types are fully supported end-to-end, including auto-table-creation. Earlier limitations imposed by the use of the .NET `DataColumn` object no longer apply. Most of the Standard Columns only support a limited subset of the SQL column types (and often just one type). Some of the special-case SQL column types are excluded such as `timestamp` and `udt`, and deprecated types like `text` and `image` are excluded. These are the supported SQL column data types:
@@ -482,7 +487,7 @@ var columnOptions = new ColumnOptions
     AdditionalColumns = new Collection<SqlColumn>
     {
         new SqlColumn
-            {ColumnName = "UserName", DataType = SqlDbType.NVarChar, DataLength = 64},
+            {ColumnName = "EnvironmentUserName", PropertyName = "UserName", DataType = SqlDbType.NVarChar, DataLength = 64},
 
         new SqlColumn
             {ColumnName = "UserId", DataType = SqlDbType.BigInt, NonClusteredIndex = true},
@@ -499,7 +504,7 @@ var log = new LoggerConfiguration()
     .CreateLogger();
 ```
 
-In this example, when a log event contains any of the properties `UserName`, `UserId`, and `RequestUri`, the property values would be written to the corresponding columns. The property names must match exactly (case-insensitive).
+In this example, when a log event contains any of the properties `UserName`, `UserId`, and `RequestUri`, the property values would be written to the corresponding columns. The property names must match exactly (case-insensitive).  In the case of `UserName`, that value would be written to the column named `EnvironmentUserName`.
 
 Unlike previous versions of the sink, Standard Column names are not reserved. If you remove the `Id` Standard Column from the `ColumnOptions.Store` list, you are free to create a new custom column called `Id` which the sink will treat like any other custom column fully under your control.
 
@@ -568,6 +573,7 @@ As the name suggests, `columnOptionSection` is an entire configuration section i
     "additionalColumns": [
         { "ColumnName": "EventType", "DataType": "int", "AllowNull": false },
         { "ColumnName": "Release", "DataType": "varchar", "DataLength": 32 },
+        { "ColumnName": "EnvironmentUserName", "PropertyName": "UserName", "DataType": "varchar", "DataLength": 50 },
         { "ColumnName": "All_SqlColumn_Defaults",
             "DataType": "varchar",
             "AllowNull": true,
@@ -632,6 +638,10 @@ Keys and values are case-sensitive. Case must match **_exactly_** as shown below
     </RemoveStandardColumns>
     <Columns>
       <add ColumnName="EventType" DataType="int"/>
+      <add ColumnName="EnvironmentUserName" 
+           PropertyName="UserName" 
+           DataType="varchar" 
+           DataLength="50" />
       <add ColumnName="Release"
            DataType="varchar"
            DataLength="64"

sample/WorkerServiceDemo/Worker.cs

@@ -21,7 +21,8 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
 
             while (!stoppingToken.IsCancellationRequested)
             {
-                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
+                _logger.LogInformation("Worker running at: {time}. CustomProperty1: {CustomProperty1}",
+                    DateTimeOffset.Now, "Value");
                 await Task.Delay(1000, stoppingToken);
             }
 

sample/WorkerServiceDemo/appsettings.json

@@ -18,7 +18,7 @@
             "tableName": "LogEvents",
             "autoCreateSqlTable": true,
             "useAzureManagedIdentity": false,
-            "azureServiceTokenProviderResource": "TestAzureServiceTokenProviderResource"
+            "azureServiceTokenProviderResource": "https://database.windpws.net/"
           },
           "restrictedToMinimumLevel": "Information",
           "columnOptionsSection": {
@@ -27,7 +27,14 @@
             "timeStamp": {
               "columnName": "Timestamp",
               "convertToUtc": false
-            }
+            },
+            "additionalColumns": [
+              {
+                "columnName": "AdditionalColumn1",
+                "propertyName": "CustomProperty1",
+                "dataType": "12"
+              }
+            ]
           },
           "logEventFormatter": "WorkerServiceDemo.CustomLogEventFormatter::Formatter, WorkerServiceDemo"
         }
@@ -38,21 +45,28 @@
         "Name": "MSSqlServer",
         "Args": {
           "connectionString": "Server=localhost;Database=LogTest;Integrated Security=SSPI;",
-          "tableName": "LogEventsAudit",
+          "restrictedToMinimumLevel": "Information",
+          "logEventFormatter": "WorkerServiceDemo.CustomLogEventFormatter::Formatter, WorkerServiceDemo",
+          "sinkOptionsSection": {
+            "tableName": "LogEventsAudit",
+            "autoCreateSqlTable": true,
+            "useAzureManagedIdentity": false,
+            "azureServiceTokenProviderResource": "https://database.windpws.net/"
+          },
           "columnOptionsSection": {
             "addStandardColumns": [ "LogEvent" ],
             "removeStandardColumns": [ "MessageTemplate", "Properties" ],
             "timeStamp": {
               "columnName": "Timestamp",
               "convertToUtc": false
-            }
-          },
-          "autoCreateSqlTable": true,
-          "restrictedToMinimumLevel": "Information",
-          "logEventFormatter": "WorkerServiceDemo.CustomLogEventFormatter::Formatter, WorkerServiceDemo",
-          "sinkOptionsSection": {
-            "useAzureManagedIdentity": false,
-            "azureServiceTokenProviderResource": "TestAuditAzureServiceTokenProviderResource"
+            },
+            "additionalColumns": [
+              {
+                "columnName": "AdditionalColumn1",
+                "propertyName": "CustomProperty1",
+                "dataType": "12"
+              }
+            ]
           }
         }
       }

src/Serilog.Sinks.MSSqlServer/Configuration/Implementations/System.Configuration/ColumnConfig.cs

@@ -1,4 +1,4 @@
-// Copyright 2015 Serilog Contributors
+// Copyright 2015 Serilog Contributors
 // 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -40,6 +40,13 @@ public virtual string ColumnName
             set { this[nameof(ColumnName)] = value; }
         }
 
+        [ConfigurationProperty("PropertyName")]
+        public virtual string PropertyName
+        {
+            get { return (string)this[nameof(PropertyName)]; }
+            set { this[nameof(PropertyName)] = value; }
+        }
+
         [ConfigurationProperty("DataType")]
         public string DataType
         {
@@ -75,6 +82,8 @@ internal SqlColumn AsSqlColumn()
             // inheritors can override IsRequired; config might not change the names of Standard Columns
             SetProperty.IfProvidedNotEmpty<string>(this, nameof(ColumnName), (val) => sqlColumn.ColumnName = val);
 
+            SetProperty.IfProvidedNotEmpty<string>(this, nameof(PropertyName), (val) => sqlColumn.PropertyName = val);
+
             SetProperty.IfProvidedNotEmpty<string>(this, nameof(DataType), (val) => sqlColumn.SetDataTypeFromConfigString(val));
 
             SetProperty.IfProvided<int>(this, nameof(DataLength), (val) => sqlColumn.DataLength = val);

src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerSinkTraits.cs

@@ -1,4 +1,4 @@
-// Copyright 2020 Serilog Contributors 
+// Copyright 2020 Serilog Contributors 
 // 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -37,7 +37,7 @@ internal class MSSqlServerSinkTraits : IDisposable
         public ColumnOptions ColumnOptions { get; }
         public IFormatProvider FormatProvider { get; }
         public ITextFormatter LogEventFormatter { get; }
-        public ISet<string> AdditionalColumnNames { get; }
+        public ISet<string> AdditionalColumnPropertyNames { get; }
         public DataTable EventTable { get; }
         public ISet<string> StandardColumnNames { get; }
 
@@ -82,10 +82,10 @@ internal MSSqlServerSinkTraits(
                 StandardColumnNames.Add(col.ColumnName);
             }
 
-            AdditionalColumnNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            AdditionalColumnPropertyNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
             if (ColumnOptions.AdditionalColumns != null)
                 foreach (var col in ColumnOptions.AdditionalColumns)
-                    AdditionalColumnNames.Add(col.ColumnName);
+                    AdditionalColumnPropertyNames.Add(col.PropertyName);
 
             if (ColumnOptions.Store.Contains(StandardColumn.LogEvent))
                 LogEventFormatter = logEventFormatter ?? new JsonLogEventFormatter(this);
@@ -163,7 +163,7 @@ private string RenderLogEventColumn(LogEvent logEvent)
         {
             if (ColumnOptions.LogEvent.ExcludeAdditionalProperties)
             {
-                var filteredProperties = logEvent.Properties.Where(p => !AdditionalColumnNames.Contains(p.Key));
+                var filteredProperties = logEvent.Properties.Where(p => !AdditionalColumnPropertyNames.Contains(p.Key));
                 logEvent = new LogEvent(logEvent.Timestamp, logEvent.Level, logEvent.Exception, logEvent.MessageTemplate, filteredProperties.Select(x => new LogEventProperty(x.Key, x.Value)));
             }
 
@@ -178,7 +178,7 @@ private string ConvertPropertiesToXmlStructure(IEnumerable<KeyValuePair<string,
             var options = ColumnOptions.Properties;
 
             if (options.ExcludeAdditionalProperties)
-                properties = properties.Where(p => !AdditionalColumnNames.Contains(p.Key));
+                properties = properties.Where(p => !AdditionalColumnPropertyNames.Contains(p.Key));
 
             if (options.PropertiesFilter != null)
             {
@@ -223,16 +223,20 @@ private string ConvertPropertiesToXmlStructure(IEnumerable<KeyValuePair<string,
         ///     Mapping values from properties which have a corresponding data row.
         ///     Matching is done based on Column name and property key
         ///     Standard columns are not mapped
-        /// </summary>        
+        /// </summary>
         /// <param name="properties"></param>
         private IEnumerable<KeyValuePair<string, object>> ConvertPropertiesToColumn(IReadOnlyDictionary<string, LogEventPropertyValue> properties)
         {
             foreach (var property in properties)
             {
-                if (!EventTable.Columns.Contains(property.Key) || StandardColumnNames.Contains(property.Key))
+                var additionalColumn = ColumnOptions
+                    .AdditionalColumns
+                    .FirstOrDefault(ac => ac.PropertyName == property.Key);
+
+                if (additionalColumn == null || StandardColumnNames.Contains(property.Key))
                     continue;
 
-                var columnName = property.Key;
+                var columnName = additionalColumn.ColumnName;
                 var columnType = EventTable.Columns[columnName].DataType;
 
                 if (!(property.Value is ScalarValue scalarValue))

src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/SqlColumn.cs

@@ -10,6 +10,7 @@ public class SqlColumn
     {
         private SqlDbType _dataType = SqlDbType.VarChar; // backwards-compatibility default
         private string _columnName = string.Empty;
+        private string _propertyName;
 
         /// <summary>
         /// Default constructor.
@@ -95,6 +96,16 @@ public SqlDbType DataType
         /// </summary>
         public bool NonClusteredIndex { get; set; } = false;
 
+        /// <summary>
+        /// The name of the Serilog property to use as the value when filling the DataTable.
+        /// If not specified, the ColumnName and PropertyName are the same.
+        /// </summary>
+        public string PropertyName
+        {
+            get => _propertyName ?? ColumnName;
+            set => _propertyName = value;
+        }
+
         // Set by the constructors of the Standard Column classes that inherit from this;
         // allows Standard Columns and user-defined columns to coexist but remain identifiable
         // and allows casting back to the Standard Column without a lot of switch gymnastics.
@@ -128,7 +139,7 @@ internal virtual DataColumn AsDataColumn()
         }
 
         /// <summary>
-        /// Configuration accepts DataType as a simple string ("nvarchar" for example) for ease-of-use. 
+        /// Configuration accepts DataType as a simple string ("nvarchar" for example) for ease-of-use.
         /// This converts to SqlDbType and stores it into the DataType property.
         /// </summary>
         internal void SetDataTypeFromConfigString(string requestedSqlType)

test/Serilog.Sinks.MSSqlServer.Tests/AdditionalPropertiesTests.cs

@@ -15,7 +15,7 @@ public AdditionalPropertiesTests(ITestOutputHelper output) : base(output)
         }
 
         [Fact]
-        public void CreatesTableWithTwoAdditionalProperties()
+        public void WritesLogEventWithColumnNamedProperties()
         {
             // Arrange
             const string additionalColumnName1 = "AdditionalColumn1";
@@ -24,24 +24,102 @@ public void CreatesTableWithTwoAdditionalProperties()
             {
                 AdditionalColumns = new List<SqlColumn>
                 {
-                    new SqlColumn(additionalColumnName1, SqlDbType.NVarChar, true, dataLength: 100),
-                    new SqlColumn(additionalColumnName2, SqlDbType.Int, true)
+                    new SqlColumn
+                    {
+                        ColumnName = additionalColumnName1,
+                        DataType = SqlDbType.NVarChar,
+                        AllowNull = true,
+                        DataLength = 100
+                    },
+                    new SqlColumn
+                    {
+                        ColumnName = additionalColumnName2,
+                        DataType = SqlDbType.Int,
+                        AllowNull = true
+                    }
                 }
             };
 
+            var messageTemplate = $"Hello {{{additionalColumnName1}}} from thread {{{additionalColumnName2}}}";
+            var property1Value = "PropertyValue1";
+            var property2Value = 2;
+            var expectedMessage = $"Hello \"{property1Value}\" from thread {property2Value}";
+
             // Act
-            using (var sink = new MSSqlServerSink(DatabaseFixture.LogEventsConnectionString,
-                sinkOptions: new SinkOptions
+            Log.Logger = new LoggerConfiguration()
+                .WriteTo.MSSqlServer(
+                    DatabaseFixture.LogEventsConnectionString,
+                    sinkOptions: new SinkOptions
+                    {
+                        TableName = DatabaseFixture.LogTableName,
+                        AutoCreateSqlTable = true
+                    },
+                    columnOptions: columnOptions)
+                .CreateLogger();
+            Log.Information(messageTemplate, property1Value, property2Value);
+            Log.CloseAndFlush();
+
+            // Assert
+            VerifyDatabaseColumnsWereCreated(columnOptions.AdditionalColumns);
+            VerifyLogMessageWasWritten(expectedMessage);
+            VerifyStringColumnWritten(additionalColumnName1, property1Value);
+            VerifyIntegerColumnWritten(additionalColumnName2, property2Value);
+        }
+
+        [Fact]
+        public void WritesLogEventWithCustomNamedProperties()
+        {
+            // Arrange
+            const string additionalColumn1Name = "AdditionalColumn1";
+            const string additionalProperty1Name = "AdditionalProperty1";
+            const string additionalColumn2Name = "AdditionalColumn2";
+            const string additionalProperty2Name = "AdditionalProperty2";
+            var columnOptions = new ColumnOptions
+            {
+                AdditionalColumns = new List<SqlColumn>
                 {
-                    TableName = DatabaseFixture.LogTableName,
-                    AutoCreateSqlTable = true
-                },
-                columnOptions: columnOptions,
-                formatProvider: null))
-            { }
+                    new SqlColumn
+                    {
+                        ColumnName = additionalColumn1Name,
+                        PropertyName = additionalProperty1Name,
+                        DataType = SqlDbType.NVarChar,
+                        AllowNull = true,
+                        DataLength = 100
+                    },
+                    new SqlColumn
+                    {
+                        ColumnName = additionalColumn2Name,
+                        PropertyName = additionalProperty2Name,
+                        DataType = SqlDbType.Int,
+                        AllowNull = true
+                    }
+                }
+            };
+
+            var messageTemplate = $"Hello {{{additionalProperty1Name}}} from thread {{{additionalProperty2Name}}}";
+            var property1Value = "PropertyValue1";
+            var property2Value = 2;
+            var expectedMessage = $"Hello \"{property1Value}\" from thread {property2Value}";
+
+            // Act
+            Log.Logger = new LoggerConfiguration()
+                .WriteTo.MSSqlServer(
+                    DatabaseFixture.LogEventsConnectionString,
+                    sinkOptions: new SinkOptions
+                    {
+                        TableName = DatabaseFixture.LogTableName,
+                        AutoCreateSqlTable = true
+                    },
+                    columnOptions: columnOptions)
+                .CreateLogger();
+            Log.Information(messageTemplate, property1Value, property2Value);
+            Log.CloseAndFlush();
 
             // Assert
             VerifyDatabaseColumnsWereCreated(columnOptions.AdditionalColumns);
+            VerifyLogMessageWasWritten(expectedMessage);
+            VerifyStringColumnWritten(additionalColumn1Name, property1Value);
+            VerifyIntegerColumnWritten(additionalColumn2Name, property2Value);
         }
     }
 }