Support custom LogEventPropertyValue values in direct log submission (#8034)

## Summary of changes

Handle the case where a customer is using a custom
`LogEventPropertyValue` implementation and direct log submission

## Reason for change

#8010 handled a case where we were generating invalid JSON by dropping
the offending value. This PR adds support for serializing the value as a
string instead.

## Implementation details

Ducktyped `LogEventPropertyValue` and called its `Render` method with a
cached `StringBuilder` to get the value, then use the same mechanisms

## Test coverage

Should be covered by the tests added in #8010

## Other details

Author: andrewlock

tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/Logging/Serilog/DirectSubmission/Formatting/ILogEventPropertyValue.cs

@@ -0,0 +1,19 @@
+// <copyright file="ILogEventPropertyValue.cs" company="Datadog">
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc.
+// </copyright>
+
+#nullable enable
+using System;
+using System.IO;
+
+namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.Serilog.DirectSubmission.Formatting;
+
+/// <summary>
+/// Duck type for LogEventPropertyValue
+/// https://github.com/serilog/serilog/blob/5e93d5045585095ebcb71ef340d6accd61f01670/src/Serilog/Events/LogEventPropertyValue.cs
+/// </summary>
+internal interface ILogEventPropertyValue
+{
+    void Render(TextWriter output, string? format, IFormatProvider? formatProvider);
+}

tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/Logging/Serilog/DirectSubmission/Formatting/SerilogLogFormatter.cs

@@ -5,11 +5,13 @@
 #nullable enable
 
 using System.Collections;
+using System.IO;
 using System.Text;
 using Datadog.Trace.DuckTyping;
 using Datadog.Trace.Logging;
 using Datadog.Trace.Logging.DirectSubmission;
 using Datadog.Trace.Logging.DirectSubmission.Formatting;
+using Datadog.Trace.Util;
 using Datadog.Trace.Vendors.Newtonsoft.Json;
 using Datadog.Trace.Vendors.Serilog.Events;
 
@@ -107,6 +109,18 @@ private static void FormatLogEventPropertyValue(JsonTextWriter writer, object va
                 return;
             }
 
+            if (value.TryDuckCast<ILogEventPropertyValue>(out var propertyValue))
+            {
+                // This is likely an edge case, so we just write the value as a string and then embed that in the JSON
+                var sb = StringBuilderCache.Acquire();
+                var stringWriter = new StringWriter(sb);
+                propertyValue.Render(stringWriter, null, null);
+                var stringValue = stringWriter.ToString();
+                StringBuilderCache.Release(sb);
+                LogFormatter.WriteValue(writer, stringValue);
+                return;
+            }
+
             // Always write null for unknown types to maintain valid JSON
             LogFormatter.WriteValue(writer, value: null);
 

tracer/src/Datadog.Trace/Logging/DirectSubmission/Sink/DirectSubmissionLogSink.cs

@@ -100,7 +100,15 @@ protected override async Task<bool> EmitBatch(Queue<DirectSubmissionLogEvent> ev
                         _logStringBuilder.Capacity = InitialBuilderSizeBytes;
                     }
 
-                    log.Format(_logStringBuilder, _formatter);
+                    try
+                    {
+                        log.Format(_logStringBuilder, _formatter);
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.Error(ex, "Log dropped due to an error during serialization");
+                        continue;
+                    }
 
                     // would be nice to avoid this, but can't see a way without direct UTF8 serialization (System.Text.Json)
                     // Currently a rogue giant message still pays the serialization cost but is then thrown away