Support enrichment of LogRecords.

Author: CodeBlanch

src/OpenTelemetry/.publicApi/Stable/PublicAPI.Unshipped.txt

@@ -1,3 +1,5 @@
+OpenTelemetry.Logs.LogRecord.AddAttribute(System.Collections.Generic.KeyValuePair<string!, object?> attribute) -> void
+OpenTelemetry.Logs.LogRecord.AddAttributes(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string!, object?>>! attributes) -> void
 OpenTelemetry.OpenTelemetryBuilderSdkExtensions
 OpenTelemetry.Trace.ActivityExportProcessorOptions
 OpenTelemetry.Trace.ActivityExportProcessorOptions.ActivityExportProcessorOptions() -> void

src/OpenTelemetry/Logs/LogRecord.cs

@@ -21,6 +21,7 @@ public sealed class LogRecord
     internal IReadOnlyList<KeyValuePair<string, object?>>? AttributeData;
     internal List<KeyValuePair<string, object?>>? AttributeStorage;
     internal List<object?>? ScopeStorage;
+    internal LogRecordEnrichedAttributes? EnrichedAttributeStorage;
     internal LogRecordSource Source = LogRecordSource.CreatedManually;
     internal int PoolReferenceCount = int.MaxValue;
 
@@ -445,6 +446,30 @@ public void ForEachScope<TState>(Action<LogRecordScope, TState> callback, TState
         }
     }
 
+    /// <summary>
+    /// Add an attribute to the <see cref="LogRecord"/>.
+    /// </summary>
+    /// <param name="attribute">Attribute to add.</param>
+    public void AddAttribute(KeyValuePair<string, object?> attribute)
+    {
+        var enrichedAttributes = this.EnsureEnrichedAttributes();
+
+        enrichedAttributes.Add(attribute);
+    }
+
+    /// <summary>
+    /// Add attributes to the <see cref="LogRecord"/>.
+    /// </summary>
+    /// <param name="attributes">Attributes to add.</param>
+    public void AddAttributes(IEnumerable<KeyValuePair<string, object?>> attributes)
+    {
+        Guard.ThrowIfNull(attributes);
+
+        var enrichedAttributes = this.EnsureEnrichedAttributes();
+
+        enrichedAttributes.Add(attributes);
+    }
+
     /// <summary>
     /// Gets a reference to the <see cref="LogRecordData"/> for the log message.
     /// </summary>
@@ -544,6 +569,20 @@ private void BufferLogScopes()
         this.ILoggerData.BufferedScopes = scopeStorage;
     }
 
+    private LogRecordEnrichedAttributes EnsureEnrichedAttributes()
+    {
+        if (this.Attributes is not LogRecordEnrichedAttributes enrichedAttributes)
+        {
+            enrichedAttributes = this.EnrichedAttributeStorage ??= new();
+
+            enrichedAttributes.Reset(this.Attributes);
+
+            this.Attributes = enrichedAttributes;
+        }
+
+        return enrichedAttributes;
+    }
+
     internal struct LogRecordILoggerData
     {
         public string? TraceState;

src/OpenTelemetry/Logs/LogRecordEnrichedAttributes.cs

@@ -0,0 +1,69 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using System.Collections;
+using System.Diagnostics;
+
+using OpenTelemetry.Internal;
+
+namespace OpenTelemetry.Logs;
+
+internal sealed class LogRecordEnrichedAttributes : IReadOnlyList<KeyValuePair<string, object?>>
+{
+    private readonly List<KeyValuePair<string, object?>> enrichedAttributes = new();
+    private IReadOnlyList<KeyValuePair<string, object?>> initialAttributes;
+
+    public LogRecordEnrichedAttributes()
+    {
+        this.initialAttributes = Array.Empty<KeyValuePair<string, object?>>();
+    }
+
+    public int Count => this.initialAttributes.Count + this.enrichedAttributes.Count;
+
+    public KeyValuePair<string, object?> this[int index]
+    {
+        get
+        {
+            Guard.ThrowIfNegative(index);
+
+            var initialAttributes = this.initialAttributes;
+
+            var count = initialAttributes.Count;
+            if (index < count)
+            {
+                return initialAttributes[index];
+            }
+
+            return this.enrichedAttributes[index - count];
+        }
+    }
+
+    public void Reset(IReadOnlyList<KeyValuePair<string, object?>>? initialAttributes)
+    {
+        this.initialAttributes = initialAttributes ?? Array.Empty<KeyValuePair<string, object?>>();
+        this.enrichedAttributes.Clear();
+    }
+
+    public void Add(KeyValuePair<string, object?> attribute)
+    {
+        this.enrichedAttributes.Add(attribute);
+    }
+
+    public void Add(IEnumerable<KeyValuePair<string, object?>> attributes)
+    {
+        Debug.Assert(attributes != null, "attributes was null");
+
+        this.enrichedAttributes.AddRange(attributes);
+    }
+
+    public IEnumerator<KeyValuePair<string, object?>> GetEnumerator()
+    {
+        for (var i = 0; i < this.Count; i++)
+        {
+            yield return this[i];
+        }
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+        => this.GetEnumerator();
+}

src/Shared/Guard.cs

@@ -39,6 +39,11 @@ namespace System.Diagnostics.CodeAnalysis
     internal sealed class NotNullAttribute : Attribute
     {
     }
+
+    [AttributeUsage(AttributeTargets.Method, Inherited = false)]
+    internal sealed class DoesNotReturnAttribute : Attribute
+    {
+    }
 }
 #endif
 
@@ -115,6 +120,16 @@ public static void ThrowIfZero(int value, string message = "Must not be zero", [
             }
         }
 
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ThrowIfNegative(int value, [CallerArgumentExpression("value")] string? paramName = null)
+        {
+            if (value < 0)
+            {
+                ThrowNegative(paramName);
+            }
+        }
+
         /// <summary>
         /// Throw an exception if the value is not considered a valid timeout.
         /// </summary>
@@ -199,5 +214,9 @@ private static void Range<T>(T value, string? paramName, T min, T max, string? m
                 throw new ArgumentOutOfRangeException(paramName, value, exMessage);
             }
         }
+
+        [DoesNotReturn]
+        private static void ThrowNegative(string? paramName) =>
+            throw new ArgumentOutOfRangeException(paramName, "Must be a non-negative value");
     }
 }