Logs: Add log record pooling

src/OpenTelemetry.Exporter.InMemory/InMemoryExporterLoggingExtensions.cs

@@ -42,9 +42,17 @@ private static ExportResult ExportLogRecord(in Batch<LogRecord> batch, ICollecti
 
             foreach (var log in batch)
             {
-                log.BufferLogScopes();
+                log.Buffer();
 
-                exportedItems.Add(log);
+                LogRecord copy = new()
+                {
+                    Data = log.Data,
+                    State = log.State,
+                    StateValues = log.StateValues == null ? null : new List<KeyValuePair<string, object>>(log.StateValues),
+                    BufferedScopes = log.BufferedScopes == null ? null : new List<object>(log.BufferedScopes),
+                };
+
+                exportedItems.Add(copy);
             }
 
             return ExportResult.Success;

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

@@ -7,6 +7,8 @@ OpenTelemetry.Logs.LogRecord.Timestamp.set -> void
 OpenTelemetry.Logs.LogRecord.TraceFlags.set -> void
 OpenTelemetry.Logs.LogRecord.TraceId.set -> void
 OpenTelemetry.Logs.LogRecord.TraceState.set -> void
+OpenTelemetry.Logs.LogRecordPool
 OpenTelemetry.Logs.OpenTelemetryLoggerProvider.ForceFlush(int timeoutMilliseconds = -1) -> bool
 OpenTelemetry.Logs.OpenTelemetryLoggerProvider.OpenTelemetryLoggerProvider() -> void
-OpenTelemetry.Logs.OpenTelemetryLoggerProvider.OpenTelemetryLoggerProvider(System.Action<OpenTelemetry.Logs.OpenTelemetryLoggerOptions!>! configure) -> void
+OpenTelemetry.Logs.OpenTelemetryLoggerProvider.OpenTelemetryLoggerProvider(System.Action<OpenTelemetry.Logs.OpenTelemetryLoggerOptions!>! configure) -> void
+static OpenTelemetry.Logs.LogRecordPool.Resize(int capacity) -> void

src/OpenTelemetry/.publicApi/net6.0/PublicAPI.Unshipped.txt

@@ -7,6 +7,8 @@ OpenTelemetry.Logs.LogRecord.Timestamp.set -> void
 OpenTelemetry.Logs.LogRecord.TraceFlags.set -> void
 OpenTelemetry.Logs.LogRecord.TraceId.set -> void
 OpenTelemetry.Logs.LogRecord.TraceState.set -> void
+OpenTelemetry.Logs.LogRecordPool
 OpenTelemetry.Logs.OpenTelemetryLoggerProvider.ForceFlush(int timeoutMilliseconds = -1) -> bool
 OpenTelemetry.Logs.OpenTelemetryLoggerProvider.OpenTelemetryLoggerProvider() -> void
-OpenTelemetry.Logs.OpenTelemetryLoggerProvider.OpenTelemetryLoggerProvider(System.Action<OpenTelemetry.Logs.OpenTelemetryLoggerOptions!>! configure) -> void
+OpenTelemetry.Logs.OpenTelemetryLoggerProvider.OpenTelemetryLoggerProvider(System.Action<OpenTelemetry.Logs.OpenTelemetryLoggerOptions!>! configure) -> void
+static OpenTelemetry.Logs.LogRecordPool.Resize(int capacity) -> void

src/OpenTelemetry/.publicApi/netstandard2.0/PublicAPI.Unshipped.txt

@@ -7,6 +7,8 @@ OpenTelemetry.Logs.LogRecord.Timestamp.set -> void
 OpenTelemetry.Logs.LogRecord.TraceFlags.set -> void
 OpenTelemetry.Logs.LogRecord.TraceId.set -> void
 OpenTelemetry.Logs.LogRecord.TraceState.set -> void
+OpenTelemetry.Logs.LogRecordPool
 OpenTelemetry.Logs.OpenTelemetryLoggerProvider.ForceFlush(int timeoutMilliseconds = -1) -> bool
 OpenTelemetry.Logs.OpenTelemetryLoggerProvider.OpenTelemetryLoggerProvider() -> void
-OpenTelemetry.Logs.OpenTelemetryLoggerProvider.OpenTelemetryLoggerProvider(System.Action<OpenTelemetry.Logs.OpenTelemetryLoggerOptions!>! configure) -> void
+OpenTelemetry.Logs.OpenTelemetryLoggerProvider.OpenTelemetryLoggerProvider(System.Action<OpenTelemetry.Logs.OpenTelemetryLoggerOptions!>! configure) -> void
+static OpenTelemetry.Logs.LogRecordPool.Resize(int capacity) -> void

src/OpenTelemetry/.publicApi/netstandard2.1/PublicAPI.Unshipped.txt

@@ -7,6 +7,8 @@ OpenTelemetry.Logs.LogRecord.Timestamp.set -> void
 OpenTelemetry.Logs.LogRecord.TraceFlags.set -> void
 OpenTelemetry.Logs.LogRecord.TraceId.set -> void
 OpenTelemetry.Logs.LogRecord.TraceState.set -> void
+OpenTelemetry.Logs.LogRecordPool
 OpenTelemetry.Logs.OpenTelemetryLoggerProvider.ForceFlush(int timeoutMilliseconds = -1) -> bool
 OpenTelemetry.Logs.OpenTelemetryLoggerProvider.OpenTelemetryLoggerProvider() -> void
-OpenTelemetry.Logs.OpenTelemetryLoggerProvider.OpenTelemetryLoggerProvider(System.Action<OpenTelemetry.Logs.OpenTelemetryLoggerOptions!>! configure) -> void
+OpenTelemetry.Logs.OpenTelemetryLoggerProvider.OpenTelemetryLoggerProvider(System.Action<OpenTelemetry.Logs.OpenTelemetryLoggerOptions!>! configure) -> void
+static OpenTelemetry.Logs.LogRecordPool.Resize(int capacity) -> void

src/OpenTelemetry/Batch.cs

@@ -22,6 +22,7 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using OpenTelemetry.Internal;
+using OpenTelemetry.Logs;
 
 namespace OpenTelemetry
 {
@@ -90,7 +91,11 @@ public void Dispose()
                 // Drain anything left in the batch.
                 while (this.circularBuffer.RemovedCount < this.targetCount)
                 {
-                    this.circularBuffer.Read();
+                    T item = this.circularBuffer.Read();
+                    if (typeof(T) == typeof(LogRecord))
+                    {
+                        LogRecordSharedPool.Current.Return((LogRecord)(object)item);
+                    }
                 }
             }
         }
@@ -140,6 +145,29 @@ public struct Enumerator : IEnumerator<T>
                 return false;
             };
 
+            private static readonly BatchEnumeratorMoveNextFunc MoveNextCircularBufferLogRecord = (ref Enumerator enumerator) =>
+            {
+                var circularBuffer = enumerator.circularBuffer;
+
+                var currentItem = enumerator.Current;
+                if (currentItem != null)
+                {
+                    if (typeof(T) == typeof(LogRecord))
+                    {
+                        LogRecordSharedPool.Current.Return((LogRecord)(object)currentItem);
+                    }
+                }
+
+                if (circularBuffer!.RemovedCount < enumerator.targetCount)
+                {
+                    enumerator.current = circularBuffer.Read();
+                    return true;
+                }
+
+                enumerator.current = null;
+                return false;
+            };
+
             private static readonly BatchEnumeratorMoveNextFunc MoveNextArray = (ref Enumerator enumerator) =>
             {
                 var items = enumerator.items;
@@ -179,7 +207,7 @@ internal Enumerator(CircularBuffer<T> circularBuffer, long targetCount)
                 this.circularBuffer = circularBuffer;
                 this.targetCount = targetCount;
                 this.itemIndex = 0;
-                this.moveNextFunc = MoveNextCircularBuffer;
+                this.moveNextFunc = typeof(T) == typeof(LogRecord) ? MoveNextCircularBufferLogRecord : MoveNextCircularBuffer;
             }
 
             internal Enumerator(T[] items, long targetCount)
@@ -201,6 +229,15 @@ internal Enumerator(T[] items, long targetCount)
             /// <inheritdoc/>
             public void Dispose()
             {
+                if (typeof(T) == typeof(LogRecord))
+                {
+                    var currentItem = this.current;
+                    if (currentItem != null)
+                    {
+                        LogRecordSharedPool.Current.Return((LogRecord)(object)currentItem);
+                        this.current = null;
+                    }
+                }
             }
 
             /// <inheritdoc/>

src/OpenTelemetry/BatchExportProcessor.cs

@@ -18,6 +18,7 @@
 
 using System;
 using System.Diagnostics;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using OpenTelemetry.Internal;
 
@@ -95,8 +96,8 @@ protected BatchExportProcessor(
         /// </summary>
         internal long ProcessedCount => this.circularBuffer.RemovedCount;
 
-        /// <inheritdoc/>
-        protected override void OnExport(T data)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal bool TryExport(T data)
         {
             if (this.circularBuffer.TryAdd(data, maxSpinCount: 50000))
             {
@@ -111,11 +112,19 @@ protected override void OnExport(T data)
                     }
                 }
 
-                return; // enqueue succeeded
+                return true; // enqueue succeeded
             }
 
             // either the queue is full or exceeded the spin limit, drop the item on the floor
             Interlocked.Increment(ref this.droppedCount);
+
+            return false;
+        }
+
+        /// <inheritdoc/>
+        protected override void OnExport(T data)
+        {
+            this.TryExport(data);
         }
 
         /// <inheritdoc/>

src/OpenTelemetry/CompositeProcessor.cs

@@ -26,7 +26,7 @@ namespace OpenTelemetry
 {
     public class CompositeProcessor<T> : BaseProcessor<T>
     {
-        private readonly DoublyLinkedListNode head;
+        internal readonly DoublyLinkedListNode Head;
         private DoublyLinkedListNode tail;
         private bool disposed;
 
@@ -40,8 +40,8 @@ public CompositeProcessor(IEnumerable<BaseProcessor<T>> processors)
                 throw new ArgumentException($"'{iter}' is null or empty", nameof(iter));
             }
 
-            this.head = new DoublyLinkedListNode(iter.Current);
-            this.tail = this.head;
+            this.Head = new DoublyLinkedListNode(iter.Current);
+            this.tail = this.Head;
 
             while (iter.MoveNext())
             {
@@ -66,7 +66,7 @@ public CompositeProcessor<T> AddProcessor(BaseProcessor<T> processor)
         /// <inheritdoc/>
         public override void OnEnd(T data)
         {
-            for (var cur = this.head; cur != null; cur = cur.Next)
+            for (var cur = this.Head; cur != null; cur = cur.Next)
             {
                 cur.Value.OnEnd(data);
             }
@@ -75,7 +75,7 @@ public override void OnEnd(T data)
         /// <inheritdoc/>
         public override void OnStart(T data)
         {
-            for (var cur = this.head; cur != null; cur = cur.Next)
+            for (var cur = this.Head; cur != null; cur = cur.Next)
             {
                 cur.Value.OnStart(data);
             }
@@ -85,7 +85,7 @@ internal override void SetParentProvider(BaseProvider parentProvider)
         {
             base.SetParentProvider(parentProvider);
 
-            for (var cur = this.head; cur != null; cur = cur.Next)
+            for (var cur = this.Head; cur != null; cur = cur.Next)
             {
                 cur.Value.SetParentProvider(parentProvider);
             }
@@ -99,7 +99,7 @@ protected override bool OnForceFlush(int timeoutMilliseconds)
                 ? null
                 : Stopwatch.StartNew();
 
-            for (var cur = this.head; cur != null; cur = cur.Next)
+            for (var cur = this.Head; cur != null; cur = cur.Next)
             {
                 if (sw == null)
                 {
@@ -125,7 +125,7 @@ protected override bool OnShutdown(int timeoutMilliseconds)
                 ? null
                 : Stopwatch.StartNew();
 
-            for (var cur = this.head; cur != null; cur = cur.Next)
+            for (var cur = this.Head; cur != null; cur = cur.Next)
             {
                 if (sw == null)
                 {
@@ -150,7 +150,7 @@ protected override void Dispose(bool disposing)
             {
                 if (disposing)
                 {
-                    for (var cur = this.head; cur != null; cur = cur.Next)
+                    for (var cur = this.Head; cur != null; cur = cur.Next)
                     {
                         try
                         {
@@ -169,7 +169,7 @@ protected override void Dispose(bool disposing)
             base.Dispose(disposing);
         }
 
-        private class DoublyLinkedListNode
+        internal sealed class DoublyLinkedListNode
         {
             public readonly BaseProcessor<T> Value;
 

src/OpenTelemetry/Logs/BatchLogRecordExportProcessor.cs

@@ -57,9 +57,14 @@ public override void OnEnd(LogRecord data)
             // happen here.
             Debug.Assert(data != null, "LogRecord was null.");
 
-            data!.BufferLogScopes();
+            data!.Buffer();
 
-            base.OnEnd(data);
+            LogRecordSharedPool.Current.TrackReference(data);
+
+            if (!this.TryExport(data))
+            {
+                LogRecordSharedPool.Current.Return(data);
+            }
         }
     }
 }

src/OpenTelemetry/Logs/LogRecord.cs

@@ -30,15 +30,21 @@ namespace OpenTelemetry.Logs
     public sealed class LogRecord
     {
         internal LogRecordData Data;
+        internal List<KeyValuePair<string, object?>>? AttributeStorage;
+        internal List<object?>? BufferedScopes;
+        internal int PoolReferenceCount = int.MaxValue;
 
         private static readonly Action<object?, List<object?>> AddScopeToBufferedList = (object? scope, List<object?> state) =>
         {
             state.Add(scope);
         };
 
-        private List<object?>? bufferedScopes;
+        internal LogRecord()
+        {
+        }
 
         // Note: Some users are calling this with reflection. Try not to change the signature to be nice.
+        [Obsolete("Call LogRecordPool.Rent instead.")]
         internal LogRecord(
             IExternalScopeProvider? scopeProvider,
             DateTime timestamp,
@@ -191,9 +197,9 @@ public void ForEachScope<TState>(Action<LogRecordScope, TState> callback, TState
 
             var forEachScopeState = new ScopeForEachState<TState>(callback, state);
 
-            if (this.bufferedScopes != null)
+            if (this.BufferedScopes != null)
             {
-                foreach (object? scope in this.bufferedScopes)
+                foreach (object? scope in this.BufferedScopes)
                 {
                     ScopeForEachState<TState>.ForEachScope(scope, forEachScopeState);
                 }
@@ -213,22 +219,46 @@ internal ref LogRecordData GetDataRef()
             return ref this.Data;
         }
 
+        internal void Buffer()
+        {
+            this.BufferLogStateValues();
+            this.BufferLogScopes();
+        }
+
+        /// <summary>
+        /// Buffers the state values attached to the log into a list so that
+        /// they can be safely processed after the log message lifecycle has
+        /// ended.
+        /// </summary>
+        private void BufferLogStateValues()
+        {
+            var stateValues = this.StateValues;
+            if (stateValues == null || stateValues == this.AttributeStorage)
+            {
+                return;
+            }
+
+            var attributeStorage = this.AttributeStorage ??= new List<KeyValuePair<string, object?>>(stateValues.Count);
+            attributeStorage.AddRange(stateValues);
+            this.StateValues = attributeStorage;
+        }
+
         /// <summary>
         /// Buffers the scopes attached to the log into a list so that they can
         /// be safely processed after the log message lifecycle has ended.
         /// </summary>
-        internal void BufferLogScopes()
+        private void BufferLogScopes()
         {
-            if (this.ScopeProvider == null || this.bufferedScopes != null)
+            if (this.ScopeProvider == null)
             {
                 return;
             }
 
-            List<object?> scopes = new List<object?>();
+            List<object?> scopes = this.BufferedScopes ??= new List<object?>(16);
 
-            this.ScopeProvider?.ForEachScope(AddScopeToBufferedList, scopes);
+            this.ScopeProvider.ForEachScope(AddScopeToBufferedList, scopes);
 
-            this.bufferedScopes = scopes;
+            this.ScopeProvider = null;
         }
 
         private readonly struct ScopeForEachState<TState>