Memory Mode: Adding 2nd part support for synchronous instruments - exponential histogram

exporters/common/src/main/java/io/opentelemetry/exporter/internal/marshal/MarshalerUtil.java

@@ -8,6 +8,7 @@
 import io.opentelemetry.api.trace.SpanId;
 import io.opentelemetry.api.trace.TraceId;
 import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
+import io.opentelemetry.sdk.internal.DynamicPrimitiveLongList;
 import io.opentelemetry.sdk.resources.Resource;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -128,6 +129,31 @@ public static int sizeRepeatedUInt64(ProtoFieldInfo field, long[] values) {
     return field.getTagSize() + CodedOutputStream.computeUInt32SizeNoTag(payloadSize) + payloadSize;
   }
 
+  /**
+   * Returns the size of a repeated uint64 field.
+   *
+   * <p>Packed repeated fields contain the tag, an integer representing the incoming payload size,
+   * and an actual payload of repeated varints.
+   *
+   * <p>NOTE: This method has the same logic as {@link #sizeRepeatedUInt64(ProtoFieldInfo, long[])}
+   * )} but instead of using a primitive array it uses {@link DynamicPrimitiveLongList} to avoid
+   * boxing/unboxing
+   */
+  public static int sizeRepeatedUInt64(ProtoFieldInfo field, DynamicPrimitiveLongList values) {
+    if (values.isEmpty()) {
+      return 0;
+    }
+
+    int payloadSize = 0;
+    for (int i = 0; i < values.size(); i++) {
+      long v = values.getLong(i);
+      payloadSize += CodedOutputStream.computeUInt64SizeNoTag(v);
+    }
+
+    // tag size + payload indicator size + actual payload size
+    return field.getTagSize() + CodedOutputStream.computeUInt32SizeNoTag(payloadSize) + payloadSize;
+  }
+
   /** Returns the size of a repeated double field. */
   public static int sizeRepeatedDouble(ProtoFieldInfo field, List<Double> values) {
     // Same as fixed64.

exporters/common/src/main/java/io/opentelemetry/exporter/internal/marshal/Serializer.java

@@ -5,6 +5,7 @@
 
 package io.opentelemetry.exporter.internal.marshal;
 
+import io.opentelemetry.sdk.internal.DynamicPrimitiveLongList;
 import java.io.IOException;
 import java.util.List;
 import javax.annotation.Nullable;
@@ -191,6 +192,7 @@ public void serializeMessage(ProtoFieldInfo field, Marshaler message) throws IOE
     writeEndMessage();
   }
 
+  @SuppressWarnings("SameParameterValue")
   protected abstract void writeStartRepeatedPrimitive(
       ProtoFieldInfo field, int protoSizePerElement, int numElements) throws IOException;
 
@@ -243,6 +245,32 @@ public void serializeRepeatedUInt64(ProtoFieldInfo field, long[] values) throws
     writeEndRepeatedVarint();
   }
 
+  /**
+   * Serializes a {@code repeated uint64} field.
+   *
+   * <p>NOTE: This is the same as {@link #serializeRepeatedUInt64(ProtoFieldInfo, long[])} but
+   * instead of taking a primitive array it takes a {@link DynamicPrimitiveLongList} as input.
+   */
+  public void serializeRepeatedUInt64(ProtoFieldInfo field, DynamicPrimitiveLongList values)
+      throws IOException {
+    if (values.isEmpty()) {
+      return;
+    }
+
+    int payloadSize = 0;
+    for (int i = 0; i < values.size(); i++) {
+      long v = values.getLong(i);
+      payloadSize += CodedOutputStream.computeUInt64SizeNoTag(v);
+    }
+
+    writeStartRepeatedVarint(field, payloadSize);
+    for (int i = 0; i < values.size(); i++) {
+      long value = values.getLong(i);
+      writeUInt64Value(value);
+    }
+    writeEndRepeatedVarint();
+  }
+
   /** Serializes a {@code repeated double} field. */
   public void serializeRepeatedDouble(ProtoFieldInfo field, List<Double> values)
       throws IOException {

exporters/otlp/common/src/main/java/io/opentelemetry/exporter/internal/otlp/metrics/ExponentialHistogramBucketsMarshaler.java

@@ -9,6 +9,7 @@
 import io.opentelemetry.exporter.internal.marshal.MarshalerWithSize;
 import io.opentelemetry.exporter.internal.marshal.Serializer;
 import io.opentelemetry.proto.metrics.v1.internal.ExponentialHistogramDataPoint;
+import io.opentelemetry.sdk.internal.DynamicPrimitiveLongList;
 import io.opentelemetry.sdk.internal.PrimitiveLongList;
 import io.opentelemetry.sdk.metrics.data.ExponentialHistogramBuckets;
 import java.io.IOException;
@@ -35,16 +36,29 @@ private ExponentialHistogramBucketsMarshaler(int offset, List<Long> counts) {
   @Override
   protected void writeTo(Serializer output) throws IOException {
     output.serializeSInt32(ExponentialHistogramDataPoint.Buckets.OFFSET, offset);
-    output.serializeRepeatedUInt64(
-        ExponentialHistogramDataPoint.Buckets.BUCKET_COUNTS, PrimitiveLongList.toArray(counts));
+    if (counts instanceof DynamicPrimitiveLongList) {
+      output.serializeRepeatedUInt64(
+          ExponentialHistogramDataPoint.Buckets.BUCKET_COUNTS, (DynamicPrimitiveLongList) counts);
+    } else {
+      output.serializeRepeatedUInt64(
+          ExponentialHistogramDataPoint.Buckets.BUCKET_COUNTS, PrimitiveLongList.toArray(counts));
+    }
   }
 
   private static int calculateSize(int offset, List<Long> counts) {
     int size = 0;
     size += MarshalerUtil.sizeSInt32(ExponentialHistogramDataPoint.Buckets.OFFSET, offset);
-    size +=
-        MarshalerUtil.sizeRepeatedUInt64(
-            ExponentialHistogramDataPoint.Buckets.BUCKET_COUNTS, PrimitiveLongList.toArray(counts));
+    if (counts instanceof DynamicPrimitiveLongList) {
+      size +=
+          MarshalerUtil.sizeRepeatedUInt64(
+              ExponentialHistogramDataPoint.Buckets.BUCKET_COUNTS,
+              (DynamicPrimitiveLongList) counts);
+    } else {
+      size +=
+          MarshalerUtil.sizeRepeatedUInt64(
+              ExponentialHistogramDataPoint.Buckets.BUCKET_COUNTS,
+              PrimitiveLongList.toArray(counts));
+    }
     return size;
   }
 }

exporters/otlp/common/src/test/java/io/opentelemetry/exporter/internal/otlp/metrics/MetricsRequestMarshalerTest.java

@@ -40,6 +40,7 @@
 import io.opentelemetry.proto.metrics.v1.Summary;
 import io.opentelemetry.proto.metrics.v1.SummaryDataPoint;
 import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
+import io.opentelemetry.sdk.internal.DynamicPrimitiveLongList;
 import io.opentelemetry.sdk.metrics.data.AggregationTemporality;
 import io.opentelemetry.sdk.metrics.data.ExponentialHistogramPointData;
 import io.opentelemetry.sdk.metrics.data.HistogramPointData;
@@ -61,6 +62,8 @@
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryPointData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableValueAtQuantile;
+import io.opentelemetry.sdk.metrics.internal.data.MutableExponentialHistogramBuckets;
+import io.opentelemetry.sdk.metrics.internal.data.MutableExponentialHistogramPointData;
 import io.opentelemetry.sdk.resources.Resource;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -508,6 +511,105 @@ void exponentialHistogramDataPoints() {
                 .build());
   }
 
+  @SuppressWarnings("PointlessArithmeticExpression")
+  @Test
+  void exponentialHistogramReusableDataPoints() {
+    assertThat(
+            toExponentialHistogramDataPoints(
+                ImmutableList.of(
+                    new MutableExponentialHistogramPointData()
+                        .set(
+                            0,
+                            123.4,
+                            1,
+                            /* hasMin= */ false,
+                            0,
+                            /* hasMax= */ false,
+                            0,
+                            new MutableExponentialHistogramBuckets()
+                                .set(0, 0, 0, DynamicPrimitiveLongList.empty()),
+                            new MutableExponentialHistogramBuckets()
+                                .set(0, 0, 0, DynamicPrimitiveLongList.empty()),
+                            123,
+                            456,
+                            Attributes.empty(),
+                            Collections.emptyList()),
+                    new MutableExponentialHistogramPointData()
+                        .set(
+                            0,
+                            123.4,
+                            1,
+                            /* hasMin= */ true,
+                            3.3,
+                            /* hasMax= */ true,
+                            80.1,
+                            new MutableExponentialHistogramBuckets()
+                                .set(0, 1, 1 + 0 + 2, DynamicPrimitiveLongList.of(1L, 0L, 2L)),
+                            new MutableExponentialHistogramBuckets()
+                                .set(0, 0, 0, DynamicPrimitiveLongList.empty()),
+                            123,
+                            456,
+                            Attributes.of(stringKey("key"), "value"),
+                            ImmutableList.of(
+                                ImmutableDoubleExemplarData.create(
+                                    Attributes.of(stringKey("test"), "value"),
+                                    2,
+                                    SpanContext.create(
+                                        "00000000000000000000000000000001",
+                                        "0000000000000002",
+                                        TraceFlags.getDefault(),
+                                        TraceState.getDefault()),
+                                    1.5))))))
+        .containsExactly(
+            ExponentialHistogramDataPoint.newBuilder()
+                .setStartTimeUnixNano(123)
+                .setTimeUnixNano(456)
+                .setCount(1)
+                .setScale(0)
+                .setSum(123.4)
+                .setZeroCount(1)
+                .setPositive(
+                    ExponentialHistogramDataPoint.Buckets.newBuilder().setOffset(0)) // no buckets
+                .setNegative(
+                    ExponentialHistogramDataPoint.Buckets.newBuilder().setOffset(0)) // no buckets
+                .build(),
+            ExponentialHistogramDataPoint.newBuilder()
+                .setStartTimeUnixNano(123)
+                .setTimeUnixNano(456)
+                .setCount(4) // Counts in positive, negative, and zero count.
+                .addAllAttributes(
+                    singletonList(
+                        KeyValue.newBuilder().setKey("key").setValue(stringValue("value")).build()))
+                .setScale(0)
+                .setSum(123.4)
+                .setMin(3.3)
+                .setMax(80.1)
+                .setZeroCount(1)
+                .setPositive(
+                    ExponentialHistogramDataPoint.Buckets.newBuilder()
+                        .setOffset(1)
+                        .addBucketCounts(1)
+                        .addBucketCounts(0)
+                        .addBucketCounts(2))
+                .setNegative(
+                    ExponentialHistogramDataPoint.Buckets.newBuilder().setOffset(0)) // no buckets
+                .addExemplars(
+                    Exemplar.newBuilder()
+                        .setTimeUnixNano(2)
+                        .addFilteredAttributes(
+                            KeyValue.newBuilder()
+                                .setKey("test")
+                                .setValue(stringValue("value"))
+                                .build())
+                        .setSpanId(ByteString.copyFrom(new byte[] {0, 0, 0, 0, 0, 0, 0, 2}))
+                        .setTraceId(
+                            ByteString.copyFrom(
+                                new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}))
+                        .setAsDouble(1.5)
+                        .build())
+                .build());
+  }
+
   @Test
   void toProtoMetric_monotonic() {
     assertThat(