Implement copy for in-memory log exporter.

src/OpenTelemetry.Exporter.InMemory/InMemoryExporter.cs

@@ -14,31 +14,29 @@
 // limitations under the License.
 // </copyright>
 
-using System;
 using System.Collections.Generic;
-using OpenTelemetry.Logs;
 
 namespace OpenTelemetry.Exporter
 {
     public class InMemoryExporter<T> : BaseExporter<T>
         where T : class
     {
         private readonly ICollection<T> exportedItems;
-        private readonly Func<Batch<T>, ExportResult> onExport;
-        private readonly bool isLogExporter;
+        private readonly ExportFunc onExport;
 
         public InMemoryExporter(ICollection<T> exportedItems)
         {
             this.exportedItems = exportedItems;
-            this.onExport = (Batch<T> batch) => this.DefaultExport(batch);
-            this.isLogExporter = typeof(T) == typeof(LogRecord);
+            this.onExport = (in Batch<T> batch) => this.DefaultExport(in batch);
         }
 
-        internal InMemoryExporter(Func<Batch<T>, ExportResult> exportFunc)
+        internal InMemoryExporter(ExportFunc exportFunc)
         {
             this.onExport = exportFunc;
         }
 
+        internal delegate ExportResult ExportFunc(in Batch<T> batch);
+
         public override ExportResult Export(in Batch<T> batch) => this.onExport(batch);
 
         private ExportResult DefaultExport(in Batch<T> batch)
@@ -50,11 +48,6 @@ private ExportResult DefaultExport(in Batch<T> batch)
 
             foreach (var data in batch)
             {
-                if (this.isLogExporter)
-                {
-                    LogRecordPool.TrackReference((LogRecord)(object)data);
-                }
-
                 this.exportedItems.Add(data);
             }
 

src/OpenTelemetry.Exporter.InMemory/InMemoryExporterLoggingExtensions.cs

@@ -27,7 +27,35 @@ public static OpenTelemetryLoggerOptions AddInMemoryExporter(this OpenTelemetryL
             Guard.ThrowIfNull(loggerOptions);
             Guard.ThrowIfNull(exportedItems);
 
-            return loggerOptions.AddProcessor(new SimpleLogRecordExportProcessor(new InMemoryExporter<LogRecord>(exportedItems)));
+            var logExporter = new InMemoryExporter<LogRecord>(
+                exportFunc: (in Batch<LogRecord> batch) => ExportLogRecord(in batch, exportedItems));
+
+            return loggerOptions.AddProcessor(new SimpleLogRecordExportProcessor(logExporter));
+        }
+
+        private static ExportResult ExportLogRecord(in Batch<LogRecord> batch, ICollection<LogRecord> exportedItems)
+        {
+            if (exportedItems == null)
+            {
+                return ExportResult.Failure;
+            }
+
+            foreach (var log in batch)
+            {
+                log.BufferLogScopes();
+
+                LogRecord copy = new()
+                {
+                    Data = log.Data,
+                    State = log.State,
+                    StateValues = log.StateValues,
+                    BufferedScopes = log.BufferedScopes,
+                };
+
+                exportedItems.Add(copy);
+            }
+
+            return ExportResult.Success;
         }
     }
 }

src/OpenTelemetry.Exporter.InMemory/InMemoryExporterMetricsExtensions.cs

@@ -145,7 +145,7 @@ private static MeterProviderBuilder AddInMemoryExporter(
             configureMetricReader?.Invoke(metricReaderOptions);
 
             var metricExporter = new InMemoryExporter<Metric>(
-                exportFunc: metricBatch => ExportMetricSnapshot(metricBatch, exportedItems));
+                exportFunc: (in Batch<Metric> metricBatch) => ExportMetricSnapshot(in metricBatch, exportedItems));
 
             var metricReader = PeriodicExportingMetricReaderHelper.CreatePeriodicExportingMetricReader(
                 metricExporter,

src/OpenTelemetry/Logs/LogRecord.cs

@@ -32,14 +32,13 @@ public sealed class LogRecord
         internal int PoolReferences = int.MaxValue;
         internal LogRecordData Data;
         internal List<KeyValuePair<string, object?>>? AttributeStorage;
+        internal List<object?>? BufferedScopes;
 
         private static readonly Action<object?, List<object?>> AddScopeToBufferedList = (object? scope, List<object?> state) =>
         {
             state.Add(scope);
         };
 
-        private List<object?>? bufferedScopes;
-
         internal LogRecord()
         {
         }
@@ -164,9 +163,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);
                 }
@@ -183,7 +182,7 @@ public void ForEachScope<TState>(Action<LogRecordScope, TState> callback, TState
         /// </summary>
         internal void BufferLogScopes()
         {
-            if (this.ScopeProvider == null || this.bufferedScopes != null)
+            if (this.ScopeProvider == null || this.BufferedScopes != null)
             {
                 return;
             }
@@ -192,7 +191,7 @@ internal void BufferLogScopes()
 
             this.ScopeProvider?.ForEachScope(AddScopeToBufferedList, scopes);
 
-            this.bufferedScopes = scopes;
+            this.BufferedScopes = scopes;
         }
 
         private readonly struct ScopeForEachState<TState>