Merge branch 'release/v7.1.0'

Jaben · Jaben · commit 58fc6bc55113 · 2025-10-04T13:25:59.000-04:00
diff --git a/.gitignore b/.gitignore
@@ -244,4 +244,5 @@ ModelManifest.xml
 # FAKE - F# Make
 .fake/
 
-.idea
+.idea
+.serena
diff --git a/CHANGES.md b/CHANGES.md
@@ -1,2 +1,11 @@
+7.1.0
+ * Fixed: Guid to BsonValue mapping error (#91)
+ * Fixed: RollingInterval collection naming with proper formatting (#95)
+ * Fixed: Renamed SetRollingInternal to SetRollingInterval (#97)
+
+7.0.0
+ * Upgraded to MongoDB.Driver 3.0 fixing incompatibilities
+ * Dropped .NET Standard 2.0 support
+
 2.0.0
  * Moved the MongoDB sink from its [original location](https://github.com/serilog/serilog)
diff --git a/README.md b/README.md
@@ -87,7 +87,7 @@ var log = new LoggerConfiguration()
 		
 		// sink will use the IMongoDatabase instance provided
 		cfg.SetMongoDatabase(mongoDbInstance);
-		cfg.SetRollingInternal(RollingInterval.Month);
+		cfg.SetRollingInterval(RollingInterval.Month);
     })
 	.CreateLogger();
 ```
diff --git a/src/Serilog.Sinks.MongoDB/Helpers/MongoDbDocumentHelpers.cs b/src/Serilog.Sinks.MongoDB/Helpers/MongoDbDocumentHelpers.cs
@@ -56,12 +56,16 @@ internal static string SanitizedElementName(this string? name)
 
         if (value is ScalarValue scalar)
         {
+            if (scalar.Value is null) return null;
+
             if (scalar.Value is Uri uri) return BsonValue.Create(uri.ToString());
 
             if (scalar.Value is TimeSpan ts) return BsonValue.Create(ts.ToString());
 
             if (scalar.Value is DateTimeOffset dto) return BsonValue.Create(dto.ToString());
 
+            if (scalar.Value is Guid guid) return BsonValue.Create(guid.ToString());
+
             return BsonValue.Create(scalar.Value);
         }
 
diff --git a/src/Serilog.Sinks.MongoDB/LoggerConfigurationMongoDBExtensions.cs b/src/Serilog.Sinks.MongoDB/LoggerConfigurationMongoDBExtensions.cs
@@ -68,7 +68,7 @@ public static LoggerConfiguration MongoDBBson(
                 cappedMaxSizeMb ?? MongoDBSinkDefaults.CappedCollectionMaxSizeMb,
                 cappedMaxDocuments);
 
-        if (rollingInterval.HasValue) cfg.SetRollingInternal(rollingInterval.Value);
+        if (rollingInterval.HasValue) cfg.SetRollingInterval(rollingInterval.Value);
 
         cfg.Validate();
 
diff --git a/src/Serilog.Sinks.MongoDB/Serilog.Sinks.MongoDB.csproj b/src/Serilog.Sinks.MongoDB/Serilog.Sinks.MongoDB.csproj
@@ -9,7 +9,7 @@
 	</PropertyGroup>
 
 	<PropertyGroup>
-		<PackageVersion>7.0.0</PackageVersion>
+		<PackageVersion>7.1.0</PackageVersion>
 		<Authors>Kiran Makkapati, Jaben Cargman, Serilog Contributors</Authors>
 		<Copyright>Copyright © Serilog Contributors 2014-2022</Copyright>
 		<Description>The MongoDB sink for Serilog</Description>
@@ -20,7 +20,7 @@
 		<PackageTags>serilog, mongodb</PackageTags>
 		<PackageReadmeFile>README.md</PackageReadmeFile>
 		<PackageReleaseNotes>
-			v7.0 - Upgraded to MongoDB.Driver to version 3.0 fixing incompatibilities.
+			v7.1 - Bug fixes: Guid to BsonValue mapping (#91), RollingInterval collection naming (#95), SetRollingInterval method name correction (#97).
 		</PackageReleaseNotes>
     </PropertyGroup>
 
diff --git a/src/Serilog.Sinks.MongoDB/Sinks/MongoDB/MongoDBSinkBase.cs b/src/Serilog.Sinks.MongoDB/Sinks/MongoDB/MongoDBSinkBase.cs
@@ -71,14 +71,16 @@ protected static IMongoDatabase GetVerifiedMongoDatabaseFromConfiguration(
                             ?? new MongoClient(configuration.MongoUrl).GetDatabase(
                                 configuration.MongoUrl!.DatabaseName);
 
+        var collectionName = configuration.RollingInterval.GetCollectionName(configuration.CollectionName);
+
         // connection attempt
         mongoDatabase.VerifyCollectionExists(
-            configuration.CollectionName,
+            collectionName,
             configuration.CollectionCreationOptions);
 
         // setup TTL if desired
         mongoDatabase.VerifyExpireTTLSetup(
-            configuration.CollectionName,
+            collectionName,
             configuration.ExpireTTL);
 
         return mongoDatabase;
diff --git a/src/Serilog.Sinks.MongoDB/Sinks/MongoDB/MongoDBSinkConfiguration.cs b/src/Serilog.Sinks.MongoDB/Sinks/MongoDB/MongoDBSinkConfiguration.cs
@@ -71,7 +71,7 @@ public void Validate()
     ///     Set the RollingInterval. (Default: RollingInterval.Infinite)
     /// </summary>
     /// <param name="rollingInterval"></param>
-    public void SetRollingInternal(RollingInterval rollingInterval)
+    public void SetRollingInterval(RollingInterval rollingInterval)
     {
         this.RollingInterval = rollingInterval;
     }
diff --git a/test/Serilog.Sinks.MongoDB.Tests/LoggerConfigurationMongoDBExtensionsTests.cs b/test/Serilog.Sinks.MongoDB.Tests/LoggerConfigurationMongoDBExtensionsTests.cs
@@ -2,17 +2,26 @@
 
 using Microsoft.Extensions.Configuration;
 
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
 using MongoDB.Driver;
 
+using NUnit.Framework;
+
 using Serilog.Helpers;
 
 namespace Serilog.Sinks.MongoDB.Tests;
 
-using NUnit.Framework;
-
 [TestFixture]
 public class LoggerConfigurationMongoDbExtensionsTests
 {
+    [OneTimeSetUp]
+    public void SetupMongo()
+    {
+        BsonSerializer.TryRegisterSerializer(new GuidSerializer(GuidRepresentation.Standard));
+    }
+
     private const string MongoConnectionString = "mongodb://localhost:27017";
 
     private const string MongoDatabaseName = "mongodb-sink";
@@ -29,14 +38,13 @@ private static void TestCollectionAndDocumentExists(RollingInterval? rollingInte
         const string Message = "some message logged into mongodb";
 
         using (var logger = new LoggerConfiguration()
-                   .WriteTo.MongoDBBson(
-                       configuration =>
-                       {
-                           configuration.SetMongoDatabase(mongoDatabase);
-                           if (rollingInterval is not null)
-                               configuration.SetRollingInternal(rollingInterval.Value);
-                           configuration.SetCollectionName(MongoCollectionName);
-                       }).CreateLogger())
+                   .WriteTo.MongoDBBson(configuration =>
+                   {
+                       configuration.SetMongoDatabase(mongoDatabase);
+                       if (rollingInterval is not null)
+                           configuration.SetRollingInterval(rollingInterval.Value);
+                       configuration.SetCollectionName(MongoCollectionName);
+                   }).CreateLogger())
         {
             logger.Information(Message);
         }
diff --git a/test/Serilog.Sinks.MongoDB.Tests/LoggerWithTraceIdTests.cs b/test/Serilog.Sinks.MongoDB.Tests/LoggerWithTraceIdTests.cs
@@ -2,6 +2,9 @@
 
 using Microsoft.Extensions.Configuration;
 
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
 using MongoDB.Driver;
 
 using Serilog.Helpers;
@@ -14,6 +17,12 @@ namespace Serilog.Sinks.MongoDB.Tests;
 [TestFixture]
 public class LoggerWithTraceIdTests
 {
+    [OneTimeSetUp]
+    public void SetupMongo()
+    {
+        BsonSerializer.TryRegisterSerializer(new GuidSerializer(GuidRepresentation.Standard));
+    }
+
     private const string MongoConnectionString = "mongodb://localhost:27017";
 
     private const string MongoDatabaseName = "mongodb-sink";
diff --git a/test/Serilog.Sinks.MongoDB.Tests/MongoDbDocumentHelpersTests.cs b/test/Serilog.Sinks.MongoDB.Tests/MongoDbDocumentHelpersTests.cs
@@ -0,0 +1,163 @@
+using FluentAssertions;
+using MongoDB.Bson;
+using NUnit.Framework;
+using Serilog.Events;
+using Serilog.Helpers;
+using System;
+
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
+
+namespace Serilog.Sinks.MongoDB.Tests;
+
+[TestFixture]
+public class MongoDbDocumentHelpersTests
+{
+    [OneTimeSetUp]
+    public void SetupMongo()
+    {
+        BsonSerializer.TryRegisterSerializer(new GuidSerializer(GuidRepresentation.Standard));
+    }
+
+    [Test]
+    public void ToBsonValue_WithGuid_ShouldConvertToStringBsonValue()
+    {
+        // Arrange
+        var guid = Guid.NewGuid();
+        var scalarValue = new ScalarValue(guid);
+
+        // Act
+        var result = scalarValue.ToBsonValue();
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Should().BeOfType<BsonString>();
+        result.AsString.Should().Be(guid.ToString());
+    }
+
+    [Test]
+    public void ToBsonValue_WithEmptyGuid_ShouldConvertToStringBsonValue()
+    {
+        // Arrange
+        var guid = Guid.Empty;
+        var scalarValue = new ScalarValue(guid);
+
+        // Act
+        var result = scalarValue.ToBsonValue();
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Should().BeOfType<BsonString>();
+        result.AsString.Should().Be(guid.ToString());
+    }
+
+    [Test]
+    public void ToBsonValue_WithNullableGuid_ShouldConvertToStringBsonValue()
+    {
+        // Arrange
+        Guid? guid = Guid.NewGuid();
+        var scalarValue = new ScalarValue(guid);
+
+        // Act
+        var result = scalarValue.ToBsonValue();
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Should().BeOfType<BsonString>();
+        result.AsString.Should().Be(guid.ToString());
+    }
+
+    [Test]
+    public void ToBsonValue_WithNullGuid_ShouldReturnNull()
+    {
+        // Arrange
+        Guid? guid = null;
+        var scalarValue = new ScalarValue(guid);
+
+        // Act
+        var result = scalarValue.ToBsonValue();
+
+        // Assert
+        result.Should().BeNull();
+    }
+
+    [Test]
+    public void ToBsonValue_WithUri_ShouldConvertToStringBsonValue()
+    {
+        // Arrange
+        var uri = new Uri("https://example.com");
+        var scalarValue = new ScalarValue(uri);
+
+        // Act
+        var result = scalarValue.ToBsonValue();
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Should().BeOfType<BsonString>();
+        result.AsString.Should().Be(uri.ToString());
+    }
+
+    [Test]
+    public void ToBsonValue_WithTimeSpan_ShouldConvertToStringBsonValue()
+    {
+        // Arrange
+        var timeSpan = TimeSpan.FromMinutes(30);
+        var scalarValue = new ScalarValue(timeSpan);
+
+        // Act
+        var result = scalarValue.ToBsonValue();
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Should().BeOfType<BsonString>();
+        result.AsString.Should().Be(timeSpan.ToString());
+    }
+
+    [Test]
+    public void ToBsonValue_WithDateTimeOffset_ShouldConvertToStringBsonValue()
+    {
+        // Arrange
+        var dateTimeOffset = DateTimeOffset.Now;
+        var scalarValue = new ScalarValue(dateTimeOffset);
+
+        // Act
+        var result = scalarValue.ToBsonValue();
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Should().BeOfType<BsonString>();
+        result.AsString.Should().Be(dateTimeOffset.ToString());
+    }
+
+    [Test]
+    public void ToBsonValue_WithString_ShouldConvertToStringBsonValue()
+    {
+        // Arrange
+        var stringValue = "test string";
+        var scalarValue = new ScalarValue(stringValue);
+
+        // Act
+        var result = scalarValue.ToBsonValue();
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Should().BeOfType<BsonString>();
+        result.AsString.Should().Be(stringValue);
+    }
+
+    [Test]
+    public void ToBsonValue_WithInteger_ShouldConvertToInt32BsonValue()
+    {
+        // Arrange
+        var intValue = 42;
+        var scalarValue = new ScalarValue(intValue);
+
+        // Act
+        var result = scalarValue.ToBsonValue();
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Should().BeOfType<BsonInt32>();
+        result.AsInt32.Should().Be(intValue);
+    }
+}

-Original file line number
+Diff line change
 # FAKE - F# Make
 .fake/
 -.idea
 +.idea
 +.serena
Original file line number	Diff line number	Diff line change
`@@ -56,12 +56,16 @@ internal static string SanitizedElementName(this string? name)`
`56`	`56`
`57`	`57`	`if (value is ScalarValue scalar)`
`58`	`58`	`{`
	`59`	`+ if (scalar.Value is null) return null;`
	`60`	`+`
`59`	`61`	`if (scalar.Value is Uri uri) return BsonValue.Create(uri.ToString());`
`60`	`62`
`61`	`63`	`if (scalar.Value is TimeSpan ts) return BsonValue.Create(ts.ToString());`
`62`	`64`
`63`	`65`	`if (scalar.Value is DateTimeOffset dto) return BsonValue.Create(dto.ToString());`
`64`	`66`
	`67`	`+ if (scalar.Value is Guid guid) return BsonValue.Create(guid.ToString());`
	`68`	`+`
`65`	`69`	`return BsonValue.Create(scalar.Value);`
`66`	`70`	`}`
`67`	`71`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ public void Validate()`
`71`	`71`	`/// Set the RollingInterval. (Default: RollingInterval.Infinite)`
`72`	`72`	`/// </summary>`
`73`	`73`	`/// <param name="rollingInterval"></param>`
`74`		`- public void SetRollingInternal(RollingInterval rollingInterval)`
	`74`	`+ public void SetRollingInterval(RollingInterval rollingInterval)`
`75`	`75`	`{`
`76`	`76`	`this.RollingInterval = rollingInterval;`
`77`	`77`	`}`