[otlp] Expand array buffer / add tests to existing base buffer (open-telemetry#6013)

rajkumar-rangaraj · CodeBlanch · web-flow · commit be8209987b4c · 2024-12-10T12:42:08.000-08:00
Co-authored-by: Mikel Blanchard &lt;mblanchard@macrosssoftware.com&gt;
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/OpenTelemetryProtocolExporterEventSource.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/OpenTelemetryProtocolExporterEventSource.cs
@@ -220,6 +220,12 @@ public void GrpcRetryDelayParsingFailed(string grpcStatusDetailsHeader, string e
         this.WriteEvent(24, grpcStatusDetailsHeader, exception);
     }
 
+    [Event(25, Message = "The array tag buffer exceeded the maximum allowed size. The array tag value was replaced with 'TRUNCATED'", Level = EventLevel.Warning)]
+    public void ArrayBufferExceededMaxSize()
+    {
+        this.WriteEvent(25);
+    }
+
     void IConfigurationExtensionsLogger.LogInvalidConfigurationValue(string key, string value)
     {
         this.InvalidConfigurationValue(key, value);
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/Serializer/ProtobufOtlpLogSerializer.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/Serializer/ProtobufOtlpLogSerializer.cs
@@ -20,7 +20,7 @@ internal static class ProtobufOtlpLogSerializer
     [ThreadStatic]
     private static SerializationState? threadSerializationState;
 
-    internal static int WriteLogsData(byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, ExperimentalOptions experimentalOptions, Resources.Resource? resource, in Batch<LogRecord> logRecordBatch)
+    internal static int WriteLogsData(ref byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, ExperimentalOptions experimentalOptions, Resources.Resource? resource, in Batch<LogRecord> logRecordBatch)
     {
         writePosition = ProtobufSerializer.WriteTag(buffer, writePosition, ProtobufOtlpLogFieldNumberConstants.LogsData_Resource_Logs, ProtobufWireType.LEN);
         int logsDataLengthPosition = writePosition;
@@ -47,27 +47,27 @@ internal static int WriteLogsData(byte[] buffer, int writePosition, SdkLimitOpti
             logRecords.Add(logRecord);
         }
 
-        writePosition = TryWriteResourceLogs(buffer, writePosition, sdkLimitOptions, experimentalOptions, resource, ScopeLogsList);
+        writePosition = TryWriteResourceLogs(ref buffer, writePosition, sdkLimitOptions, experimentalOptions, resource, ScopeLogsList);
         ProtobufSerializer.WriteReservedLength(buffer, logsDataLengthPosition, writePosition - (logsDataLengthPosition + ReserveSizeForLength));
         ReturnLogRecordListToPool();
 
         return writePosition;
     }
 
-    internal static int TryWriteResourceLogs(byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, ExperimentalOptions experimentalOptions, Resources.Resource? resource, Dictionary<string, List<LogRecord>> scopeLogs)
+    internal static int TryWriteResourceLogs(ref byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, ExperimentalOptions experimentalOptions, Resources.Resource? resource, Dictionary<string, List<LogRecord>> scopeLogs)
     {
         try
         {
             writePosition = WriteResourceLogs(buffer, writePosition, sdkLimitOptions, experimentalOptions, resource, scopeLogs);
         }
-        catch (IndexOutOfRangeException)
+        catch (Exception ex) when (ex is IndexOutOfRangeException || ex is ArgumentException)
         {
             if (!ProtobufSerializer.IncreaseBufferSize(ref buffer, OtlpSignalType.Logs))
             {
                 throw;
             }
 
-            return TryWriteResourceLogs(buffer, writePosition, sdkLimitOptions, experimentalOptions, resource, scopeLogs);
+            return TryWriteResourceLogs(ref buffer, writePosition, sdkLimitOptions, experimentalOptions, resource, scopeLogs);
         }
 
         return writePosition;
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/Serializer/ProtobufOtlpMetricSerializer.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/Serializer/ProtobufOtlpMetricSerializer.cs
@@ -17,7 +17,7 @@ internal static class ProtobufOtlpMetricSerializer
 
     private delegate int WriteExemplarFunc(byte[] buffer, int writePosition, in Exemplar exemplar);
 
-    internal static int WriteMetricsData(byte[] buffer, int writePosition, Resources.Resource? resource, in Batch<Metric> batch)
+    internal static int WriteMetricsData(ref byte[] buffer, int writePosition, Resources.Resource? resource, in Batch<Metric> batch)
     {
         writePosition = ProtobufSerializer.WriteTag(buffer, writePosition, ProtobufOtlpMetricFieldNumberConstants.MetricsData_Resource_Metrics, ProtobufWireType.LEN);
         int mericsDataLengthPosition = writePosition;
@@ -35,27 +35,27 @@ internal static int WriteMetricsData(byte[] buffer, int writePosition, Resources
             metrics.Add(metric);
         }
 
-        writePosition = TryWriteResourceMetrics(buffer, writePosition, resource, ScopeMetricsList);
+        writePosition = TryWriteResourceMetrics(ref buffer, writePosition, resource, ScopeMetricsList);
         ProtobufSerializer.WriteReservedLength(buffer, mericsDataLengthPosition, writePosition - (mericsDataLengthPosition + ReserveSizeForLength));
         ReturnMetricListToPool();
 
         return writePosition;
     }
 
-    internal static int TryWriteResourceMetrics(byte[] buffer, int writePosition, Resources.Resource? resource, Dictionary<string, List<Metric>> scopeMetrics)
+    internal static int TryWriteResourceMetrics(ref byte[] buffer, int writePosition, Resources.Resource? resource, Dictionary<string, List<Metric>> scopeMetrics)
     {
         try
         {
             writePosition = WriteResourceMetrics(buffer, writePosition, resource, scopeMetrics);
         }
-        catch (IndexOutOfRangeException)
+        catch (Exception ex) when (ex is IndexOutOfRangeException || ex is ArgumentException)
         {
             if (!ProtobufSerializer.IncreaseBufferSize(ref buffer, OtlpSignalType.Metrics))
             {
                 throw;
             }
 
-            return TryWriteResourceMetrics(buffer, writePosition, resource, scopeMetrics);
+            return TryWriteResourceMetrics(ref buffer, writePosition, resource, scopeMetrics);
         }
 
         return writePosition;
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/Serializer/ProtobufOtlpTagWriter.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/Serializer/ProtobufOtlpTagWriter.cs
@@ -1,6 +1,7 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
+using System.Diagnostics;
 using OpenTelemetry.Internal;
 
 namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.Serializer;
@@ -61,7 +62,6 @@ protected override void WriteStringTag(ref OtlpTagWriterState state, string key,
 
     protected override void WriteArrayTag(ref OtlpTagWriterState state, string key, ref OtlpTagWriterArrayState value)
     {
-        // TODO: Expand OtlpTagWriterArrayState.Buffer on IndexOutOfRangeException.
         // Write KeyValue tag
         state.WritePosition = ProtobufSerializer.WriteStringWithTag(state.Buffer, state.WritePosition, ProtobufOtlpCommonFieldNumberConstants.KeyValue_Key, key);
 
@@ -95,18 +95,19 @@ internal struct OtlpTagWriterArrayState
         public int WritePosition;
     }
 
-    private sealed class OtlpArrayTagWriter : ArrayTagWriter<OtlpTagWriterArrayState>
+    internal sealed class OtlpArrayTagWriter : ArrayTagWriter<OtlpTagWriterArrayState>
     {
         [ThreadStatic]
-        private static byte[]? threadBuffer;
+        internal static byte[]? ThreadBuffer;
+        private const int MaxBufferSize = 2 * 1024 * 1024;
 
         public override OtlpTagWriterArrayState BeginWriteArray()
         {
-            threadBuffer ??= new byte[2048];
+            ThreadBuffer ??= new byte[2048];
 
             return new OtlpTagWriterArrayState
             {
-                Buffer = threadBuffer,
+                Buffer = ThreadBuffer,
                 WritePosition = 0,
             };
         }
@@ -149,5 +150,29 @@ public override void WriteStringValue(ref OtlpTagWriterArrayState state, ReadOnl
         public override void EndWriteArray(ref OtlpTagWriterArrayState state)
         {
         }
+
+        public override bool TryResize()
+        {
+            var buffer = ThreadBuffer;
+
+            Debug.Assert(buffer != null, "buffer was null");
+
+            if (buffer!.Length >= MaxBufferSize)
+            {
+                OpenTelemetryProtocolExporterEventSource.Log.ArrayBufferExceededMaxSize();
+                return false;
+            }
+
+            try
+            {
+                ThreadBuffer = new byte[buffer.Length * 2];
+                return true;
+            }
+            catch (OutOfMemoryException)
+            {
+                OpenTelemetryProtocolExporterEventSource.Log.BufferResizeFailedDueToMemory(nameof(OtlpArrayTagWriter));
+                return false;
+            }
+        }
     }
 }
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/Serializer/ProtobufOtlpTraceSerializer.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/Serializer/ProtobufOtlpTraceSerializer.cs
@@ -18,7 +18,7 @@ internal static class ProtobufOtlpTraceSerializer
     private static readonly Stack<List<Activity>> ActivityListPool = [];
     private static readonly Dictionary<string, List<Activity>> ScopeTracesList = [];
 
-    internal static int WriteTraceData(byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, Resources.Resource? resource, in Batch<Activity> batch)
+    internal static int WriteTraceData(ref byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, Resources.Resource? resource, in Batch<Activity> batch)
     {
         writePosition = ProtobufSerializer.WriteTag(buffer, writePosition, ProtobufOtlpTraceFieldNumberConstants.TracesData_Resource_Spans, ProtobufWireType.LEN);
         int resourceSpansScopeSpansLengthPosition = writePosition;
@@ -36,20 +36,20 @@ internal static int WriteTraceData(byte[] buffer, int writePosition, SdkLimitOpt
             activities.Add(activity);
         }
 
-        writePosition = TryWriteResourceSpans(buffer, writePosition, sdkLimitOptions, resource);
+        writePosition = TryWriteResourceSpans(ref buffer, writePosition, sdkLimitOptions, resource);
         ReturnActivityListToPool();
         ProtobufSerializer.WriteReservedLength(buffer, resourceSpansScopeSpansLengthPosition, writePosition - (resourceSpansScopeSpansLengthPosition + ReserveSizeForLength));
 
         return writePosition;
     }
 
-    internal static int TryWriteResourceSpans(byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, Resources.Resource? resource)
+    internal static int TryWriteResourceSpans(ref byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, Resources.Resource? resource)
     {
         try
         {
             writePosition = WriteResourceSpans(buffer, writePosition, sdkLimitOptions, resource);
         }
-        catch (IndexOutOfRangeException)
+        catch (Exception ex) when (ex is IndexOutOfRangeException || ex is ArgumentException)
         {
             // Attempt to increase the buffer size
             if (!ProtobufSerializer.IncreaseBufferSize(ref buffer, OtlpSignalType.Traces))
@@ -61,7 +61,7 @@ internal static int TryWriteResourceSpans(byte[] buffer, int writePosition, SdkL
             // The recursion depth is limited to a maximum of 7 calls, as the buffer size starts at ~732 KB
             // and doubles until it reaches the maximum size of 100 MB. This ensures the recursion remains safe
             // and avoids stack overflow.
-            return TryWriteResourceSpans(buffer, writePosition, sdkLimitOptions, resource);
+            return TryWriteResourceSpans(ref buffer, writePosition, sdkLimitOptions, resource);
         }
 
         return writePosition;
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/Serializer/ProtobufSerializer.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/Serializer/ProtobufSerializer.cs
@@ -321,6 +321,13 @@ internal static int WriteStringWithTag(byte[] buffer, int writePosition, int fie
         writePosition = WriteLength(buffer, writePosition, numberOfUtf8CharsInString);
 
 #if NETFRAMEWORK || NETSTANDARD2_0
+        if (buffer.Length - writePosition < numberOfUtf8CharsInString)
+        {
+            // Note: Validate there is enough space in the buffer to hold the
+            // string otherwise throw to trigger a resize of the buffer.
+            throw new IndexOutOfRangeException();
+        }
+
         unsafe
         {
             fixed (char* strPtr = &GetNonNullPinnableReference(value))
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpLogExporter.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpLogExporter.cs
@@ -72,7 +72,7 @@ public override ExportResult Export(in Batch<LogRecord> logRecordBatch)
 
         try
         {
-            int writePosition = ProtobufOtlpLogSerializer.WriteLogsData(this.buffer, this.startWritePosition, this.sdkLimitOptions, this.experimentalOptions, this.Resource, logRecordBatch);
+            int writePosition = ProtobufOtlpLogSerializer.WriteLogsData(ref this.buffer, this.startWritePosition, this.sdkLimitOptions, this.experimentalOptions, this.Resource, logRecordBatch);
 
             if (this.startWritePosition == GrpcStartWritePosition)
             {
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpMetricExporter.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpMetricExporter.cs
@@ -65,7 +65,7 @@ public override ExportResult Export(in Batch<Metric> metrics)
 
         try
         {
-            int writePosition = ProtobufOtlpMetricSerializer.WriteMetricsData(this.buffer, this.startWritePosition, this.Resource, metrics);
+            int writePosition = ProtobufOtlpMetricSerializer.WriteMetricsData(ref this.buffer, this.startWritePosition, this.Resource, metrics);
 
             if (this.startWritePosition == GrpcStartWritePosition)
             {
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpTraceExporter.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpTraceExporter.cs
@@ -68,7 +68,7 @@ public override ExportResult Export(in Batch<Activity> activityBatch)
 
         try
         {
-            int writePosition = ProtobufOtlpTraceSerializer.WriteTraceData(this.buffer, this.startWritePosition, this.sdkLimitOptions, this.Resource, activityBatch);
+            int writePosition = ProtobufOtlpTraceSerializer.WriteTraceData(ref this.buffer, this.startWritePosition, this.sdkLimitOptions, this.Resource, activityBatch);
 
             if (this.startWritePosition == GrpcStartWritePosition)
             {
diff --git a/src/Shared/TagWriter/ArrayTagWriter.cs b/src/Shared/TagWriter/ArrayTagWriter.cs
@@ -19,4 +19,6 @@ internal abstract class ArrayTagWriter<TArrayState>
     public abstract void WriteStringValue(ref TArrayState state, ReadOnlySpan<char> value);
 
     public abstract void EndWriteArray(ref TArrayState state);
+
+    public virtual bool TryResize() => false;
 }
diff --git a/src/Shared/TagWriter/TagWriter.cs b/src/Shared/TagWriter/TagWriter.cs
@@ -71,6 +71,10 @@ public bool TryWriteTag(
                 {
                     this.WriteArrayTagInternal(ref state, key, array, tagValueMaxLength);
                 }
+                catch (Exception ex) when (ex is IndexOutOfRangeException || ex is ArgumentException)
+                {
+                    throw;
+                }
                 catch
                 {
                     // If an exception is thrown when calling ToString
@@ -152,27 +156,49 @@ private void WriteArrayTagInternal(ref TTagState state, string key, Array array,
     {
         var arrayState = this.arrayWriter.BeginWriteArray();
 
-        // This switch ensures the values of the resultant array-valued tag are of the same type.
-        switch (array)
+        try
         {
-            case char[] charArray: this.WriteStructToArray(ref arrayState, charArray); break;
-            case string?[] stringArray: this.WriteStringsToArray(ref arrayState, stringArray, tagValueMaxLength); break;
-            case bool[] boolArray: this.WriteStructToArray(ref arrayState, boolArray); break;
-            case byte[] byteArray: this.WriteToArrayCovariant(ref arrayState, byteArray); break;
-            case short[] shortArray: this.WriteToArrayCovariant(ref arrayState, shortArray); break;
+            // This switch ensures the values of the resultant array-valued tag are of the same type.
+            switch (array)
+            {
+                case char[] charArray: this.WriteStructToArray(ref arrayState, charArray); break;
+                case string?[] stringArray: this.WriteStringsToArray(ref arrayState, stringArray, tagValueMaxLength); break;
+                case bool[] boolArray: this.WriteStructToArray(ref arrayState, boolArray); break;
+                case byte[] byteArray: this.WriteToArrayCovariant(ref arrayState, byteArray); break;
+                case short[] shortArray: this.WriteToArrayCovariant(ref arrayState, shortArray); break;
 #if NETFRAMEWORK
-            case int[]: this.WriteArrayTagIntNetFramework(ref arrayState, array, tagValueMaxLength); break;
-            case long[]: this.WriteArrayTagLongNetFramework(ref arrayState, array, tagValueMaxLength); break;
+                case int[]: this.WriteArrayTagIntNetFramework(ref arrayState, array, tagValueMaxLength); break;
+                case long[]: this.WriteArrayTagLongNetFramework(ref arrayState, array, tagValueMaxLength); break;
 #else
-            case int[] intArray: this.WriteToArrayCovariant(ref arrayState, intArray); break;
-            case long[] longArray: this.WriteToArrayCovariant(ref arrayState, longArray); break;
+                case int[] intArray: this.WriteToArrayCovariant(ref arrayState, intArray); break;
+                case long[] longArray: this.WriteToArrayCovariant(ref arrayState, longArray); break;
 #endif
-            case float[] floatArray: this.WriteStructToArray(ref arrayState, floatArray); break;
-            case double[] doubleArray: this.WriteStructToArray(ref arrayState, doubleArray); break;
-            default: this.WriteToArrayTypeChecked(ref arrayState, array, tagValueMaxLength); break;
+                case float[] floatArray: this.WriteStructToArray(ref arrayState, floatArray); break;
+                case double[] doubleArray: this.WriteStructToArray(ref arrayState, doubleArray); break;
+                default: this.WriteToArrayTypeChecked(ref arrayState, array, tagValueMaxLength); break;
+            }
+
+            this.arrayWriter.EndWriteArray(ref arrayState);
         }
+        catch (Exception ex) when (ex is IndexOutOfRangeException || ex is ArgumentException)
+        {
+            // If the array writer cannot be resized, TryResize should log a message to the event source, return false.
+            if (this.arrayWriter.TryResize())
+            {
+                this.WriteArrayTagInternal(ref state, key, array, tagValueMaxLength);
+                return;
+            }
+
+            // Drop the array value and set "TRUNCATED" as value for easier isolation.
+            // This is a best effort to avoid dropping the entire tag.
+            this.WriteStringTag(
+                ref state,
+                key,
+                "TRUNCATED".AsSpan());
 
-        this.arrayWriter.EndWriteArray(ref arrayState);
+            this.LogUnsupportedTagTypeAndReturnFalse(key, array!.GetType().ToString());
+            return;
+        }
 
         this.WriteArrayTag(ref state, key, ref arrayState);
     }
diff --git a/test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/Implementation/ExportClient/OtlpHttpTraceExportClientTests.cs b/test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/Implementation/ExportClient/OtlpHttpTraceExportClientTests.cs
@@ -181,7 +181,7 @@ void RunTest(Batch<Activity> batch)
     private static (byte[] Buffer, int ContentLength) CreateTraceExportRequest(SdkLimitOptions sdkOptions, in Batch<Activity> batch, Resource resource)
     {
         var buffer = new byte[4096];
-        var writePosition = ProtobufOtlpTraceSerializer.WriteTraceData(buffer, 0, sdkOptions, resource, batch);
+        var writePosition = ProtobufOtlpTraceSerializer.WriteTraceData(ref buffer, 0, sdkOptions, resource, batch);
         return (buffer, writePosition);
     }
 }
diff --git a/test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/Implementation/Serializer/OtlpArrayTagWriterTests.cs b/test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/Implementation/Serializer/OtlpArrayTagWriterTests.cs
diff --git a/test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/OtlpLogExporterTests.cs b/test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/OtlpLogExporterTests.cs
diff --git a/test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/OtlpMetricsExporterTests.cs b/test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/OtlpMetricsExporterTests.cs
diff --git a/test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/OtlpTraceExporterTests.cs b/test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/OtlpTraceExporterTests.cs

Original file line number	Diff line number	Diff line change
`@@ -220,6 +220,12 @@ public void GrpcRetryDelayParsingFailed(string grpcStatusDetailsHeader, string e`
`220`	`220`	`this.WriteEvent(24, grpcStatusDetailsHeader, exception);`
`221`	`221`	`}`
`222`	`222`
	`223`	`+ [Event(25, Message = "The array tag buffer exceeded the maximum allowed size. The array tag value was replaced with 'TRUNCATED'", Level = EventLevel.Warning)]`
	`224`	`+ public void ArrayBufferExceededMaxSize()`
	`225`	`+ {`
	`226`	`+ this.WriteEvent(25);`
	`227`	`+ }`
	`228`	`+`
`223`	`229`	`void IConfigurationExtensionsLogger.LogInvalidConfigurationValue(string key, string value)`
`224`	`230`	`{`
`225`	`231`	`this.InvalidConfigurationValue(key, value);`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ internal static class ProtobufOtlpLogSerializer`
`20`	`20`	`[ThreadStatic]`
`21`	`21`	`private static SerializationState? threadSerializationState;`
`22`	`22`
`23`		`- internal static int WriteLogsData(byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, ExperimentalOptions experimentalOptions, Resources.Resource? resource, in Batch<LogRecord> logRecordBatch)`
	`23`	`+ internal static int WriteLogsData(ref byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, ExperimentalOptions experimentalOptions, Resources.Resource? resource, in Batch<LogRecord> logRecordBatch)`
`24`	`24`	`{`
`25`	`25`	`writePosition = ProtobufSerializer.WriteTag(buffer, writePosition, ProtobufOtlpLogFieldNumberConstants.LogsData_Resource_Logs, ProtobufWireType.LEN);`
`26`	`26`	`int logsDataLengthPosition = writePosition;`
`@@ -47,27 +47,27 @@ internal static int WriteLogsData(byte[] buffer, int writePosition, SdkLimitOpti`
`47`	`47`	`logRecords.Add(logRecord);`
`48`	`48`	`}`
`49`	`49`
`50`		`- writePosition = TryWriteResourceLogs(buffer, writePosition, sdkLimitOptions, experimentalOptions, resource, ScopeLogsList);`
	`50`	`+ writePosition = TryWriteResourceLogs(ref buffer, writePosition, sdkLimitOptions, experimentalOptions, resource, ScopeLogsList);`
`51`	`51`	`ProtobufSerializer.WriteReservedLength(buffer, logsDataLengthPosition, writePosition - (logsDataLengthPosition + ReserveSizeForLength));`
`52`	`52`	`ReturnLogRecordListToPool();`
`53`	`53`
`54`	`54`	`return writePosition;`
`55`	`55`	`}`
`56`	`56`
`57`		`- internal static int TryWriteResourceLogs(byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, ExperimentalOptions experimentalOptions, Resources.Resource? resource, Dictionary<string, List<LogRecord>> scopeLogs)`
	`57`	`+ internal static int TryWriteResourceLogs(ref byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, ExperimentalOptions experimentalOptions, Resources.Resource? resource, Dictionary<string, List<LogRecord>> scopeLogs)`
`58`	`58`	`{`
`59`	`59`	`try`
`60`	`60`	`{`
`61`	`61`	`writePosition = WriteResourceLogs(buffer, writePosition, sdkLimitOptions, experimentalOptions, resource, scopeLogs);`
`62`	`62`	`}`
`63`		`- catch (IndexOutOfRangeException)`
	`63`	`+ catch (Exception ex) when (ex is IndexOutOfRangeException \|\| ex is ArgumentException)`
`64`	`64`	`{`
`65`	`65`	`if (!ProtobufSerializer.IncreaseBufferSize(ref buffer, OtlpSignalType.Logs))`
`66`	`66`	`{`
`67`	`67`	`throw;`
`68`	`68`	`}`
`69`	`69`
`70`		`- return TryWriteResourceLogs(buffer, writePosition, sdkLimitOptions, experimentalOptions, resource, scopeLogs);`
	`70`	`+ return TryWriteResourceLogs(ref buffer, writePosition, sdkLimitOptions, experimentalOptions, resource, scopeLogs);`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`return writePosition;`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ internal static class ProtobufOtlpMetricSerializer`
`17`	`17`
`18`	`18`	`private delegate int WriteExemplarFunc(byte[] buffer, int writePosition, in Exemplar exemplar);`
`19`	`19`
`20`		`- internal static int WriteMetricsData(byte[] buffer, int writePosition, Resources.Resource? resource, in Batch<Metric> batch)`
	`20`	`+ internal static int WriteMetricsData(ref byte[] buffer, int writePosition, Resources.Resource? resource, in Batch<Metric> batch)`
`21`	`21`	`{`
`22`	`22`	`writePosition = ProtobufSerializer.WriteTag(buffer, writePosition, ProtobufOtlpMetricFieldNumberConstants.MetricsData_Resource_Metrics, ProtobufWireType.LEN);`
`23`	`23`	`int mericsDataLengthPosition = writePosition;`
`@@ -35,27 +35,27 @@ internal static int WriteMetricsData(byte[] buffer, int writePosition, Resources`
`35`	`35`	`metrics.Add(metric);`
`36`	`36`	`}`
`37`	`37`
`38`		`- writePosition = TryWriteResourceMetrics(buffer, writePosition, resource, ScopeMetricsList);`
	`38`	`+ writePosition = TryWriteResourceMetrics(ref buffer, writePosition, resource, ScopeMetricsList);`
`39`	`39`	`ProtobufSerializer.WriteReservedLength(buffer, mericsDataLengthPosition, writePosition - (mericsDataLengthPosition + ReserveSizeForLength));`
`40`	`40`	`ReturnMetricListToPool();`
`41`	`41`
`42`	`42`	`return writePosition;`
`43`	`43`	`}`
`44`	`44`
`45`		`- internal static int TryWriteResourceMetrics(byte[] buffer, int writePosition, Resources.Resource? resource, Dictionary<string, List<Metric>> scopeMetrics)`
	`45`	`+ internal static int TryWriteResourceMetrics(ref byte[] buffer, int writePosition, Resources.Resource? resource, Dictionary<string, List<Metric>> scopeMetrics)`
`46`	`46`	`{`
`47`	`47`	`try`
`48`	`48`	`{`
`49`	`49`	`writePosition = WriteResourceMetrics(buffer, writePosition, resource, scopeMetrics);`
`50`	`50`	`}`
`51`		`- catch (IndexOutOfRangeException)`
	`51`	`+ catch (Exception ex) when (ex is IndexOutOfRangeException \|\| ex is ArgumentException)`
`52`	`52`	`{`
`53`	`53`	`if (!ProtobufSerializer.IncreaseBufferSize(ref buffer, OtlpSignalType.Metrics))`
`54`	`54`	`{`
`55`	`55`	`throw;`
`56`	`56`	`}`
`57`	`57`
`58`		`- return TryWriteResourceMetrics(buffer, writePosition, resource, scopeMetrics);`
	`58`	`+ return TryWriteResourceMetrics(ref buffer, writePosition, resource, scopeMetrics);`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`return writePosition;`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ internal static class ProtobufOtlpTraceSerializer`
`18`	`18`	`private static readonly Stack<List<Activity>> ActivityListPool = [];`
`19`	`19`	`private static readonly Dictionary<string, List<Activity>> ScopeTracesList = [];`
`20`	`20`
`21`		`- internal static int WriteTraceData(byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, Resources.Resource? resource, in Batch<Activity> batch)`
	`21`	`+ internal static int WriteTraceData(ref byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, Resources.Resource? resource, in Batch<Activity> batch)`
`22`	`22`	`{`
`23`	`23`	`writePosition = ProtobufSerializer.WriteTag(buffer, writePosition, ProtobufOtlpTraceFieldNumberConstants.TracesData_Resource_Spans, ProtobufWireType.LEN);`
`24`	`24`	`int resourceSpansScopeSpansLengthPosition = writePosition;`
`@@ -36,20 +36,20 @@ internal static int WriteTraceData(byte[] buffer, int writePosition, SdkLimitOpt`
`36`	`36`	`activities.Add(activity);`
`37`	`37`	`}`
`38`	`38`
`39`		`- writePosition = TryWriteResourceSpans(buffer, writePosition, sdkLimitOptions, resource);`
	`39`	`+ writePosition = TryWriteResourceSpans(ref buffer, writePosition, sdkLimitOptions, resource);`
`40`	`40`	`ReturnActivityListToPool();`
`41`	`41`	`ProtobufSerializer.WriteReservedLength(buffer, resourceSpansScopeSpansLengthPosition, writePosition - (resourceSpansScopeSpansLengthPosition + ReserveSizeForLength));`
`42`	`42`
`43`	`43`	`return writePosition;`
`44`	`44`	`}`
`45`	`45`
`46`		`- internal static int TryWriteResourceSpans(byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, Resources.Resource? resource)`
	`46`	`+ internal static int TryWriteResourceSpans(ref byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, Resources.Resource? resource)`
`47`	`47`	`{`
`48`	`48`	`try`
`49`	`49`	`{`
`50`	`50`	`writePosition = WriteResourceSpans(buffer, writePosition, sdkLimitOptions, resource);`
`51`	`51`	`}`
`52`		`- catch (IndexOutOfRangeException)`
	`52`	`+ catch (Exception ex) when (ex is IndexOutOfRangeException \|\| ex is ArgumentException)`
`53`	`53`	`{`
`54`	`54`	`// Attempt to increase the buffer size`
`55`	`55`	`if (!ProtobufSerializer.IncreaseBufferSize(ref buffer, OtlpSignalType.Traces))`
`@@ -61,7 +61,7 @@ internal static int TryWriteResourceSpans(byte[] buffer, int writePosition, SdkL`
`61`	`61`	`// The recursion depth is limited to a maximum of 7 calls, as the buffer size starts at ~732 KB`
`62`	`62`	`// and doubles until it reaches the maximum size of 100 MB. This ensures the recursion remains safe`
`63`	`63`	`// and avoids stack overflow.`
`64`		`- return TryWriteResourceSpans(buffer, writePosition, sdkLimitOptions, resource);`
	`64`	`+ return TryWriteResourceSpans(ref buffer, writePosition, sdkLimitOptions, resource);`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`return writePosition;`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ public override ExportResult Export(in Batch<LogRecord> logRecordBatch)`
`72`	`72`
`73`	`73`	`try`
`74`	`74`	`{`
`75`		`- int writePosition = ProtobufOtlpLogSerializer.WriteLogsData(this.buffer, this.startWritePosition, this.sdkLimitOptions, this.experimentalOptions, this.Resource, logRecordBatch);`
	`75`	`+ int writePosition = ProtobufOtlpLogSerializer.WriteLogsData(ref this.buffer, this.startWritePosition, this.sdkLimitOptions, this.experimentalOptions, this.Resource, logRecordBatch);`
`76`	`76`
`77`	`77`	`if (this.startWritePosition == GrpcStartWritePosition)`
`78`	`78`	`{`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ public override ExportResult Export(in Batch<Metric> metrics)`
`65`	`65`
`66`	`66`	`try`
`67`	`67`	`{`
`68`		`- int writePosition = ProtobufOtlpMetricSerializer.WriteMetricsData(this.buffer, this.startWritePosition, this.Resource, metrics);`
	`68`	`+ int writePosition = ProtobufOtlpMetricSerializer.WriteMetricsData(ref this.buffer, this.startWritePosition, this.Resource, metrics);`
`69`	`69`
`70`	`70`	`if (this.startWritePosition == GrpcStartWritePosition)`
`71`	`71`	`{`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ public override ExportResult Export(in Batch<Activity> activityBatch)`
`68`	`68`
`69`	`69`	`try`
`70`	`70`	`{`
`71`		`- int writePosition = ProtobufOtlpTraceSerializer.WriteTraceData(this.buffer, this.startWritePosition, this.sdkLimitOptions, this.Resource, activityBatch);`
	`71`	`+ int writePosition = ProtobufOtlpTraceSerializer.WriteTraceData(ref this.buffer, this.startWritePosition, this.sdkLimitOptions, this.Resource, activityBatch);`
`72`	`72`
`73`	`73`	`if (this.startWritePosition == GrpcStartWritePosition)`
`74`	`74`	`{`
Original file line number	Diff line number	Diff line change
`@@ -19,4 +19,6 @@ internal abstract class ArrayTagWriter<TArrayState>`
`19`	`19`	`public abstract void WriteStringValue(ref TArrayState state, ReadOnlySpan<char> value);`
`20`	`20`
`21`	`21`	`public abstract void EndWriteArray(ref TArrayState state);`
	`22`	`+`
	`23`	`+ public virtual bool TryResize() => false;`
`22`	`24`	`}`