fix: handle Guid to BsonValue mapping (#91)

Added explicit Guid to string conversion in ToBsonValue to prevent
ArgumentException when MongoDB.Driver attempts to map Guid types.

Also registered GuidSerializer with Standard representation in test
setup to ensure consistent Guid handling across test suite.

Fixes #91

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Jaben

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);
         }
 

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.SetRollingInterval(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);
         }

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";

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);
+    }
+}