Merge pull request #106 from nblumhardt/messagetemplate-renderings

Add `IncludedData.MessageTemplateRenderingsAttribute`

Author: nblumhardt

src/Serilog.Sinks.OpenTelemetry/Sinks/OpenTelemetry/IncludedData.cs

@@ -71,5 +71,10 @@ public enum IncludedData
     /// })
     /// </code>
     /// </remarks>
-    TemplateBody = 32
+    TemplateBody = 32,
+        
+    /// <summary>
+    /// Include pre-rendered values for any message template placeholders that use custom format specifiers, in <c>message_template.renderings</c>.
+    /// </summary>
+    MessageTemplateRenderingsAttribute = 64
 }

src/Serilog.Sinks.OpenTelemetry/Sinks/OpenTelemetry/LogRecordBuilder.cs

@@ -12,9 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// ReSharper disable PossibleMultipleEnumeration
+
+using System.Globalization;
 using OpenTelemetry.Proto.Common.V1;
 using OpenTelemetry.Proto.Logs.V1;
 using Serilog.Events;
+using Serilog.Parsing;
 using Serilog.Sinks.OpenTelemetry.Formatting;
 using Serilog.Sinks.OpenTelemetry.ProtocolHelpers;
 
@@ -137,5 +141,29 @@ static void ProcessIncludedFields(LogRecord logRecord, LogEvent logEvent, Includ
                 StringValue = PrimitiveConversions.Md5Hash(logEvent.MessageTemplate.Text)
             }));
         }
+
+        if ((includedFields & IncludedData.MessageTemplateRenderingsAttribute) != IncludedData.None)
+        {
+            var tokensWithFormat = logEvent.MessageTemplate.Tokens
+                .OfType<PropertyToken>()
+                .Where(pt => pt.Format != null);
+
+            // Better not to allocate an array in the 99.9% of cases where this is false
+            if (tokensWithFormat.Any())
+            {
+                var renderings = new ArrayValue();
+
+                foreach (var propertyToken in tokensWithFormat)
+                {
+                    var space = new StringWriter();
+                    propertyToken.Render(logEvent.Properties, space, CultureInfo.InvariantCulture);
+                    renderings.Values.Add(new AnyValue { StringValue = space.ToString() });
+                }
+                
+                logRecord.Attributes.Add(PrimitiveConversions.NewAttribute(
+                    SemanticConventions.AttributeMessageTemplateRenderings,
+                    new AnyValue { ArrayValue = renderings }));
+            }
+        }
     }
 }

src/Serilog.Sinks.OpenTelemetry/Sinks/OpenTelemetry/SemanticConventions.cs

@@ -31,6 +31,11 @@ static class SemanticConventions
     /// </summary>
     public const string AttributeMessageTemplateMD5Hash = "message_template.hash.md5";
 
+    /// <summary>
+    /// If any placeholders in the message template use custom format specifiers, an array containing a pre-rendered string for each such token.
+    /// </summary>
+    public const string AttributeMessageTemplateRenderings = "message_template.renderings";
+
     /// <summary>
     /// OpenTelemetry standard service name resource attribute.
     /// </summary>

test/Serilog.Sinks.OpenTelemetry.Tests/LogRecordBuilderTests.cs

@@ -161,11 +161,9 @@ public void IncludeTraceIdWhenActivityIsNull()
     [Fact]
     public void IncludeTraceIdAndSpanId()
     {
-        using var listener = new ActivityListener
-        {
-            ShouldListenTo = _ => true,
-            Sample = (ref ActivityCreationOptions<ActivityContext> _) => ActivitySamplingResult.AllData,
-        };
+        using var listener = new ActivityListener();
+        listener.ShouldListenTo = _ => true;
+        listener.Sample = (ref ActivityCreationOptions<ActivityContext> _) => ActivitySamplingResult.AllData;
 
         ActivitySource.AddActivityListener(listener);
 
@@ -187,11 +185,59 @@ public void IncludeTraceIdAndSpanId()
     [Fact]
     public void TemplateBodyIncludesMessageTemplateInBody()
     {
-        var messageTemplate = "Hello, {Name}";
+        const string messageTemplate = "Hello, {Name}";
         var properties = new List<LogEventProperty> { new("Name", new ScalarValue("World")) };
 
         var logRecord = LogRecordBuilder.ToLogRecord(Some.SerilogEvent(messageTemplate, properties), null, IncludedData.TemplateBody, new());
         Assert.NotNull(logRecord.Body);
         Assert.Equal(messageTemplate, logRecord.Body.StringValue);
     }
+    
+    [Fact]
+    public void NoRenderingsIncludedWhenNoneInTemplate()
+    {
+        var logEvent = Some.SerilogEvent(messageTemplate: "Hello, {Name}", properties: new [] { new LogEventProperty("Name", new ScalarValue("World"))});
+        
+        var logRecord = LogRecordBuilder.ToLogRecord(logEvent, null, IncludedData.MessageTemplateRenderingsAttribute, new());
+        
+        Assert.DoesNotContain(SemanticConventions.AttributeMessageTemplateRenderings, logRecord.Attributes.Select(a => a.Key));
+    }
+    
+    [Fact]
+    public void RenderingsIncludedWhenPresentInTemplate()
+    {
+        var logEvent = Some.SerilogEvent(messageTemplate: "{First:0} {Second} {Third:0.00}", properties: new []
+        {
+            new LogEventProperty("First", new ScalarValue(123.456)),
+            new LogEventProperty("Second", new ScalarValue(234.567)),
+            new LogEventProperty("Third", new ScalarValue(345.678))
+        });
+        
+        var logRecord = LogRecordBuilder.ToLogRecord(logEvent, null, IncludedData.MessageTemplateRenderingsAttribute, new());
+        
+        var expectedAttribute = new KeyValue { Key = SemanticConventions.AttributeMessageTemplateRenderings, Value = new()
+        {
+            ArrayValue = new ArrayValue {
+                Values =
+                {
+                    // Only values for tokens with format strings are included.
+                    new AnyValue{ StringValue = "123"},
+                    new AnyValue{ StringValue = "345.68"},
+                }
+            }
+        }};
+        Assert.Contains(expectedAttribute, logRecord.Attributes);
+    }
+    
+    [Fact]
+    public void RenderingsNotIncludedWhenIncludedDataDoesNotSpecifyThem()
+    {
+        var logEvent = Some.SerilogEvent(messageTemplate: "{First:0}", properties: new []
+        {
+            new LogEventProperty("First", new ScalarValue(123.456))
+        });
+        
+        var logRecord = LogRecordBuilder.ToLogRecord(logEvent, null, OpenTelemetrySinkOptions.DefaultIncludedData, new());
+        Assert.DoesNotContain(SemanticConventions.AttributeMessageTemplateRenderings, logRecord.Attributes.Select(a => a.Key));
+    }
 }

test/Serilog.Sinks.OpenTelemetry.Tests/PublicApiVisibilityTests.approved.txt

@@ -25,6 +25,7 @@ namespace Serilog.Sinks.OpenTelemetry
         SpanIdField = 8,
         SpecRequiredResourceAttributes = 16,
         TemplateBody = 32,
+        MessageTemplateRenderingsAttribute = 64,
     }
     public class OpenTelemetrySinkOptions
     {