From 13fb460a5487326d2e297ced0495d3da6b332aed Mon Sep 17 00:00:00 2001 From: Beppe Catanese <1771700+gcatanese@users.noreply.github.com> Date: Thu, 24 Feb 2022 23:04:57 +0100 Subject: [PATCH 1/4] (4172) Vararg versions of AttributeBuilder.put (#4188) * Overload put with AttributeKey with String array * Use generic instead of String * Format and javadoc * Cast to type * New public method * File based view configuration (#4163) * Add experimental view config module * Rename view-config to metric-incubator * Switch naming from camelCase to snake_case * Extend with attribute key filter * Wire up to autoconfiguration * Use snakeyaml instead of jackson * PR feedback * PR feedback * Remove explicit okio dependency (#4187) * Deprecate PrometheusCollector (#4185) * Correct javadoc Co-authored-by: Anuraag Agrawal * Cast to type Co-authored-by: jack-berg <34418638+jack-berg@users.noreply.github.com> Co-authored-by: Anuraag Agrawal --- .../api/common/AttributesBuilder.java | 14 ++++++ .../api/common/AttributesTest.java | 46 +++++++++++++++++++ .../current_vs_latest/opentelemetry-api.txt | 4 +- .../sdk/resources/ResourceTest.java | 8 ++-- .../opentelemetry/sdk/trace/SdkSpanTest.java | 8 ++-- 5 files changed, 71 insertions(+), 9 deletions(-) diff --git a/api/all/src/main/java/io/opentelemetry/api/common/AttributesBuilder.java b/api/all/src/main/java/io/opentelemetry/api/common/AttributesBuilder.java index 9422eaf035f..a7fe1be0ee0 100644 --- a/api/all/src/main/java/io/opentelemetry/api/common/AttributesBuilder.java +++ b/api/all/src/main/java/io/opentelemetry/api/common/AttributesBuilder.java @@ -16,6 +16,7 @@ import static io.opentelemetry.api.common.AttributeKey.stringKey; import java.util.Arrays; +import java.util.List; import java.util.function.Predicate; /** A builder of {@link Attributes} supporting an arbitrary number of key-value pairs. */ @@ -100,6 +101,19 @@ default AttributesBuilder put(String key, String... value) { return put(stringArrayKey(key), Arrays.asList(value)); } + /** + * Puts a List attribute into this. + * + * @return this Builder + */ + @SuppressWarnings("unchecked") + default AttributesBuilder put(AttributeKey> key, T... value) { + if (value == null) { + return this; + } + return put(key, Arrays.asList(value)); + } + /** * Puts a Long array attribute into this. * diff --git a/api/all/src/test/java/io/opentelemetry/api/common/AttributesTest.java b/api/all/src/test/java/io/opentelemetry/api/common/AttributesTest.java index db9c84e83db..6726b539713 100644 --- a/api/all/src/test/java/io/opentelemetry/api/common/AttributesTest.java +++ b/api/all/src/test/java/io/opentelemetry/api/common/AttributesTest.java @@ -289,6 +289,52 @@ void builder() { assertThat(attributes).isEqualTo(wantAttributes); } + @Test + void builderWithAttributeKeyList() { + Attributes attributes = + Attributes.builder() + .put("string", "value1") + .put(longKey("long"), 10) + .put(stringArrayKey("anotherString"), "value1", "value2", "value3") + .put(longArrayKey("anotherLong"), 10L, 20L, 30L) + .put(booleanArrayKey("anotherBoolean"), true, false, true) + .build(); + + Attributes wantAttributes = + Attributes.of( + stringKey("string"), + "value1", + longKey("long"), + 10L, + stringArrayKey("anotherString"), + Arrays.asList("value1", "value2", "value3"), + longArrayKey("anotherLong"), + Arrays.asList(10L, 20L, 30L), + booleanArrayKey("anotherBoolean"), + Arrays.asList(true, false, true)); + assertThat(attributes).isEqualTo(wantAttributes); + + AttributesBuilder newAttributes = attributes.toBuilder(); + newAttributes.put("newKey", "newValue"); + assertThat(newAttributes.build()) + .isEqualTo( + Attributes.of( + stringKey("string"), + "value1", + longKey("long"), + 10L, + stringArrayKey("anotherString"), + Arrays.asList("value1", "value2", "value3"), + longArrayKey("anotherLong"), + Arrays.asList(10L, 20L, 30L), + booleanArrayKey("anotherBoolean"), + Arrays.asList(true, false, true), + stringKey("newKey"), + "newValue")); + // Original not mutated. + assertThat(attributes).isEqualTo(wantAttributes); + } + @Test void builder_arrayTypes() { Attributes attributes = diff --git a/docs/apidiffs/current_vs_latest/opentelemetry-api.txt b/docs/apidiffs/current_vs_latest/opentelemetry-api.txt index df26146497b..573eeb42ebe 100644 --- a/docs/apidiffs/current_vs_latest/opentelemetry-api.txt +++ b/docs/apidiffs/current_vs_latest/opentelemetry-api.txt @@ -1,2 +1,4 @@ Comparing source compatibility of against -No changes. \ No newline at end of file +***! MODIFIED INTERFACE: PUBLIC ABSTRACT io.opentelemetry.api.common.AttributesBuilder (not serializable) + === CLASS FILE FORMAT VERSION: 52.0 <- 52.0 + +++! NEW METHOD: PUBLIC(+) io.opentelemetry.api.common.AttributesBuilder put(io.opentelemetry.api.common.AttributeKey, java.lang.Object[]) diff --git a/sdk/common/src/test/java/io/opentelemetry/sdk/resources/ResourceTest.java b/sdk/common/src/test/java/io/opentelemetry/sdk/resources/ResourceTest.java index 24d7a88239a..892b4577685 100644 --- a/sdk/common/src/test/java/io/opentelemetry/sdk/resources/ResourceTest.java +++ b/sdk/common/src/test/java/io/opentelemetry/sdk/resources/ResourceTest.java @@ -148,10 +148,10 @@ void create_NullEmptyArray() { assertThat(resource.getAttributes().size()).isEqualTo(8); // Null arrays should be dropped - attributes.put(stringArrayKey("NullArrayStringKey"), null); - attributes.put(longArrayKey("NullArrayLongKey"), null); - attributes.put(doubleArrayKey("NullArrayDoubleKey"), null); - attributes.put(booleanArrayKey("NullArrayBooleanKey"), null); + attributes.put(stringArrayKey("NullArrayStringKey"), (String[]) null); + attributes.put(longArrayKey("NullArrayLongKey"), (Long[]) null); + attributes.put(doubleArrayKey("NullArrayDoubleKey"), (Double[]) null); + attributes.put(booleanArrayKey("NullArrayBooleanKey"), (Boolean[]) null); resource = Resource.create(attributes.build()); assertThat(resource.getAttributes()).isNotNull(); diff --git a/sdk/trace/src/test/java/io/opentelemetry/sdk/trace/SdkSpanTest.java b/sdk/trace/src/test/java/io/opentelemetry/sdk/trace/SdkSpanTest.java index 68c80b85b16..e0f68950cd7 100644 --- a/sdk/trace/src/test/java/io/opentelemetry/sdk/trace/SdkSpanTest.java +++ b/sdk/trace/src/test/java/io/opentelemetry/sdk/trace/SdkSpanTest.java @@ -535,10 +535,10 @@ void setAllAttributes() { .put(doubleArrayKey("ArrayDoubleKey"), Arrays.asList(0.1, 2.3, 4.5, 6.7, 8.9)) .put(booleanArrayKey("ArrayBooleanKey"), Arrays.asList(true, false, false, true)) // These should be dropped - .put(stringArrayKey("NullArrayStringKey"), null) - .put(longArrayKey("NullArrayLongKey"), null) - .put(doubleArrayKey("NullArrayDoubleKey"), null) - .put(booleanArrayKey("NullArrayBooleanKey"), null) + .put(stringArrayKey("NullArrayStringKey"), (String[]) null) + .put(longArrayKey("NullArrayLongKey"), (Long[]) null) + .put(doubleArrayKey("NullArrayDoubleKey"), (Double[]) null) + .put(booleanArrayKey("NullArrayBooleanKey"), (Boolean[]) null) // These should be maintained .put(longArrayKey("ArrayWithNullLongKey"), Arrays.asList(new Long[] {null})) .put(stringArrayKey("ArrayWithNullStringKey"), Arrays.asList(new String[] {null})) From 66520d1f3e72c9b0820c52443a3d126f83b01581 Mon Sep 17 00:00:00 2001 From: Anuraag Agrawal Date: Fri, 25 Feb 2022 12:01:35 +0900 Subject: [PATCH 2/4] Cleanup ExemplarData (#4205) --- .../otlp/metrics/ExemplarMarshaler.java | 44 +++++----- .../metrics/MetricsRequestMarshalerTest.java | 38 +++++--- .../exporter/prometheus/MetricAdapter.java | 22 +++-- .../exporter/prometheus/Serializer.java | 20 +++-- .../prometheus/MetricAdapterTest.java | 42 +++++++-- .../exporter/prometheus/SerializerTest.java | 12 ++- .../internal/metrics/MetricAdapter.java | 15 ++-- .../internal/metrics/MetricAdapterTest.java | 38 ++++---- .../testing/assertj/ExemplarDataAssert.java | 12 ++- .../testing/assertj/MetricAssertionsTest.java | 43 ++++++++- .../sdk/metrics/data/DoubleExemplarData.java | 14 ++- .../sdk/metrics/data/ExemplarData.java | 28 +++++- .../sdk/metrics/data/LongExemplarData.java | 14 ++- .../AbstractFixedSizeExemplarReservoir.java | 12 ++- .../aggregator/AggregatorHandleTest.java | 14 ++- ...bleExponentialHistogramAggregatorTest.java | 88 +++++++++++++++++-- .../DoubleHistogramAggregatorTest.java | 67 ++++++++++++-- .../DoubleLastValueAggregatorTest.java | 46 ++++++++-- .../aggregator/DoubleSumAggregatorTest.java | 46 +++++++++- .../LongLastValueAggregatorTest.java | 25 +++++- .../aggregator/LongSumAggregatorTest.java | 36 +++++++- 21 files changed, 535 insertions(+), 141 deletions(-) diff --git a/exporters/otlp/common/src/main/java/io/opentelemetry/exporter/internal/otlp/metrics/ExemplarMarshaler.java b/exporters/otlp/common/src/main/java/io/opentelemetry/exporter/internal/otlp/metrics/ExemplarMarshaler.java index 4a58cc23b41..6ca18c59b92 100644 --- a/exporters/otlp/common/src/main/java/io/opentelemetry/exporter/internal/otlp/metrics/ExemplarMarshaler.java +++ b/exporters/otlp/common/src/main/java/io/opentelemetry/exporter/internal/otlp/metrics/ExemplarMarshaler.java @@ -5,6 +5,7 @@ package io.opentelemetry.exporter.internal.otlp.metrics; +import io.opentelemetry.api.trace.SpanContext; import io.opentelemetry.exporter.internal.marshal.MarshalerUtil; import io.opentelemetry.exporter.internal.marshal.MarshalerWithSize; import io.opentelemetry.exporter.internal.marshal.ProtoFieldInfo; @@ -15,7 +16,6 @@ import io.opentelemetry.sdk.metrics.data.LongExemplarData; import java.io.IOException; import java.util.List; -import javax.annotation.Nullable; final class ExemplarMarshaler extends MarshalerWithSize { @@ -24,8 +24,7 @@ final class ExemplarMarshaler extends MarshalerWithSize { private final ExemplarData value; private final ProtoFieldInfo valueField; - @Nullable private final String spanId; - @Nullable private final String traceId; + private final SpanContext spanContext; private final KeyValueMarshaler[] filteredAttributeMarshalers; @@ -54,8 +53,7 @@ private static ExemplarMarshaler create(ExemplarData exemplar) { exemplar.getEpochNanos(), exemplar, valueField, - exemplar.getSpanId(), - exemplar.getTraceId(), + exemplar.getSpanContext(), attributeMarshalers); } @@ -63,17 +61,13 @@ private ExemplarMarshaler( long timeUnixNano, ExemplarData value, ProtoFieldInfo valueField, - @Nullable String spanId, - @Nullable String traceId, + SpanContext spanContext, KeyValueMarshaler[] filteredAttributeMarshalers) { - super( - calculateSize( - timeUnixNano, valueField, value, spanId, traceId, filteredAttributeMarshalers)); + super(calculateSize(timeUnixNano, valueField, value, spanContext, filteredAttributeMarshalers)); this.timeUnixNano = timeUnixNano; this.value = value; this.valueField = valueField; - this.spanId = spanId; - this.traceId = traceId; + this.spanContext = spanContext; this.filteredAttributeMarshalers = filteredAttributeMarshalers; } @@ -86,8 +80,12 @@ public void writeTo(Serializer output) throws IOException { } else { output.serializeDoubleOptional(valueField, ((DoubleExemplarData) value).getValue()); } - output.serializeSpanId(io.opentelemetry.proto.metrics.v1.internal.Exemplar.SPAN_ID, spanId); - output.serializeTraceId(io.opentelemetry.proto.metrics.v1.internal.Exemplar.TRACE_ID, traceId); + if (spanContext.isValid()) { + output.serializeSpanId( + io.opentelemetry.proto.metrics.v1.internal.Exemplar.SPAN_ID, spanContext.getSpanId()); + output.serializeTraceId( + io.opentelemetry.proto.metrics.v1.internal.Exemplar.TRACE_ID, spanContext.getTraceId()); + } output.serializeRepeatedMessage( io.opentelemetry.proto.metrics.v1.internal.Exemplar.FILTERED_ATTRIBUTES, filteredAttributeMarshalers); @@ -97,8 +95,7 @@ private static int calculateSize( long timeUnixNano, ProtoFieldInfo valueField, ExemplarData value, - @Nullable String spanId, - @Nullable String traceId, + SpanContext spanContext, KeyValueMarshaler[] filteredAttributeMarshalers) { int size = 0; size += @@ -109,12 +106,15 @@ private static int calculateSize( } else { size += MarshalerUtil.sizeDoubleOptional(valueField, ((DoubleExemplarData) value).getValue()); } - size += - MarshalerUtil.sizeSpanId( - io.opentelemetry.proto.metrics.v1.internal.Exemplar.SPAN_ID, spanId); - size += - MarshalerUtil.sizeTraceId( - io.opentelemetry.proto.metrics.v1.internal.Exemplar.TRACE_ID, traceId); + if (spanContext.isValid()) { + size += + MarshalerUtil.sizeSpanId( + io.opentelemetry.proto.metrics.v1.internal.Exemplar.SPAN_ID, spanContext.getSpanId()); + size += + MarshalerUtil.sizeTraceId( + io.opentelemetry.proto.metrics.v1.internal.Exemplar.TRACE_ID, + spanContext.getTraceId()); + } size += MarshalerUtil.sizeRepeatedMessage( io.opentelemetry.proto.metrics.v1.internal.Exemplar.FILTERED_ATTRIBUTES, diff --git a/exporters/otlp/common/src/test/java/io/opentelemetry/exporter/internal/otlp/metrics/MetricsRequestMarshalerTest.java b/exporters/otlp/common/src/test/java/io/opentelemetry/exporter/internal/otlp/metrics/MetricsRequestMarshalerTest.java index 7f7002a69b7..10c1694c80a 100644 --- a/exporters/otlp/common/src/test/java/io/opentelemetry/exporter/internal/otlp/metrics/MetricsRequestMarshalerTest.java +++ b/exporters/otlp/common/src/test/java/io/opentelemetry/exporter/internal/otlp/metrics/MetricsRequestMarshalerTest.java @@ -18,6 +18,9 @@ import com.google.protobuf.util.JsonFormat; import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.internal.OtelEncodingUtils; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.api.trace.TraceFlags; +import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.exporter.internal.marshal.Marshaler; import io.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest; import io.opentelemetry.proto.common.v1.AnyValue; @@ -92,8 +95,11 @@ void dataPoint_withDefaultValues() { LongExemplarData.create( Attributes.of(stringKey("test"), "value"), 2, - /*spanId=*/ "0000000000000002", - /*traceId=*/ "00000000000000000000000000000001", + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), 0)))))) .containsExactly( NumberDataPoint.newBuilder() @@ -131,8 +137,11 @@ void dataPoint_withDefaultValues() { DoubleExemplarData.create( Attributes.of(stringKey("test"), "value"), 2, - /*spanId=*/ "0000000000000002", - /*traceId=*/ "00000000000000000000000000000001", + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), 0)))))) .containsExactly( NumberDataPoint.newBuilder() @@ -174,8 +183,11 @@ void longDataPoints() { LongExemplarData.create( Attributes.of(stringKey("test"), "value"), 2, - /*spanId=*/ "0000000000000002", - /*traceId=*/ "00000000000000000000000000000001", + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), 1)))))) .containsExactly( NumberDataPoint.newBuilder() @@ -342,8 +354,11 @@ void histogramDataPoints() { DoubleExemplarData.create( Attributes.of(stringKey("test"), "value"), 2, - /*spanId=*/ "0000000000000002", - /*traceId=*/ "00000000000000000000000000000001", + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), 1.5)))))) .containsExactly( HistogramDataPoint.newBuilder() @@ -399,8 +414,11 @@ void exponentialHistogramDataPoints() { DoubleExemplarData.create( Attributes.of(stringKey("test"), "value"), 2, - /*spanId=*/ "0000000000000002", - /*traceId=*/ "00000000000000000000000000000001", + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), 1.5)))))) .containsExactly( ExponentialHistogramDataPoint.newBuilder() diff --git a/exporters/prometheus/src/main/java/io/opentelemetry/exporter/prometheus/MetricAdapter.java b/exporters/prometheus/src/main/java/io/opentelemetry/exporter/prometheus/MetricAdapter.java index e2ec2238a13..c21205f3172 100644 --- a/exporters/prometheus/src/main/java/io/opentelemetry/exporter/prometheus/MetricAdapter.java +++ b/exporters/prometheus/src/main/java/io/opentelemetry/exporter/prometheus/MetricAdapter.java @@ -8,12 +8,15 @@ import static io.prometheus.client.Collector.doubleToGoString; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanContext; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; +import io.opentelemetry.sdk.metrics.data.DoubleExemplarData; import io.opentelemetry.sdk.metrics.data.DoubleHistogramPointData; import io.opentelemetry.sdk.metrics.data.DoublePointData; import io.opentelemetry.sdk.metrics.data.DoubleSumData; import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData; import io.opentelemetry.sdk.metrics.data.ExemplarData; +import io.opentelemetry.sdk.metrics.data.LongExemplarData; import io.opentelemetry.sdk.metrics.data.LongPointData; import io.opentelemetry.sdk.metrics.data.LongSumData; import io.opentelemetry.sdk.metrics.data.MetricData; @@ -261,7 +264,7 @@ private static ExemplarData filterExemplars( Collection exemplars, double min, double max) { ExemplarData result = null; for (ExemplarData e : exemplars) { - double value = e.getValueAsDouble(); + double value = getExemplarValue(e); if (value <= max && value > min) { result = e; } @@ -324,17 +327,24 @@ private static Sample createSample( private static io.prometheus.client.exemplars.Exemplar toPrometheusExemplar( ExemplarData exemplar) { - if (exemplar.getSpanId() != null && exemplar.getTraceId() != null) { + SpanContext spanContext = exemplar.getSpanContext(); + if (spanContext.isValid()) { return new io.prometheus.client.exemplars.Exemplar( - exemplar.getValueAsDouble(), + getExemplarValue(exemplar), // Convert to ms for prometheus, truncate nanosecond precision. TimeUnit.NANOSECONDS.toMillis(exemplar.getEpochNanos()), "trace_id", - exemplar.getTraceId(), + spanContext.getTraceId(), "span_id", - exemplar.getSpanId()); + spanContext.getSpanId()); } - return new io.prometheus.client.exemplars.Exemplar(exemplar.getValueAsDouble()); + return new io.prometheus.client.exemplars.Exemplar(getExemplarValue(exemplar)); + } + + private static double getExemplarValue(ExemplarData exemplar) { + return exemplar instanceof DoubleExemplarData + ? ((DoubleExemplarData) exemplar).getValue() + : (double) ((LongExemplarData) exemplar).getValue(); } private MetricAdapter() {} diff --git a/exporters/prometheus/src/main/java/io/opentelemetry/exporter/prometheus/Serializer.java b/exporters/prometheus/src/main/java/io/opentelemetry/exporter/prometheus/Serializer.java index a85f3227a87..8ab17017bc1 100644 --- a/exporters/prometheus/src/main/java/io/opentelemetry/exporter/prometheus/Serializer.java +++ b/exporters/prometheus/src/main/java/io/opentelemetry/exporter/prometheus/Serializer.java @@ -23,10 +23,13 @@ import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.sdk.metrics.data.DoubleExemplarData; import io.opentelemetry.sdk.metrics.data.DoubleHistogramPointData; import io.opentelemetry.sdk.metrics.data.DoublePointData; import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData; import io.opentelemetry.sdk.metrics.data.ExemplarData; +import io.opentelemetry.sdk.metrics.data.LongExemplarData; import io.opentelemetry.sdk.metrics.data.LongPointData; import io.opentelemetry.sdk.metrics.data.MetricData; import io.opentelemetry.sdk.metrics.data.MetricDataType; @@ -414,19 +417,18 @@ void writeExemplar( Writer writer, Collection exemplars, double minExemplar, double maxExemplar) throws IOException { for (ExemplarData exemplar : exemplars) { - double value = exemplar.getValueAsDouble(); + double value = getExemplarValue(exemplar); if (value > minExemplar && value <= maxExemplar) { writer.write(" # {"); - String traceId = exemplar.getTraceId(); - String spanId = exemplar.getSpanId(); - if (traceId != null && spanId != null) { + SpanContext spanContext = exemplar.getSpanContext(); + if (spanContext.isValid()) { // NB: Output sorted to match prometheus client library even though it shouldn't matter. // OTel generally outputs in trace_id span_id order though so we can consider breaking // from reference implementation if it makes sense. writer.write("span_id=\""); - writer.write(spanId); + writer.write(spanContext.getSpanId()); writer.write("\",trace_id=\""); - writer.write(traceId); + writer.write(spanContext.getTraceId()); writer.write('"'); } writer.write("} "); @@ -444,4 +446,10 @@ void writeEof(Writer writer) throws IOException { writer.write("# EOF\n"); } } + + private static double getExemplarValue(ExemplarData exemplar) { + return exemplar instanceof DoubleExemplarData + ? ((DoubleExemplarData) exemplar).getValue() + : (double) ((LongExemplarData) exemplar).getValue(); + } } diff --git a/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/MetricAdapterTest.java b/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/MetricAdapterTest.java index 4bc18f5ca14..36c920da461 100644 --- a/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/MetricAdapterTest.java +++ b/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/MetricAdapterTest.java @@ -10,6 +10,9 @@ import com.google.common.collect.ImmutableList; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.api.trace.TraceFlags; +import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; import io.opentelemetry.sdk.metrics.data.DoubleGaugeData; @@ -213,8 +216,11 @@ class MetricAdapterTest { LongExemplarData.create( Attributes.empty(), TimeUnit.MILLISECONDS.toNanos(1L), - /* spanId= */ "span_id", - /* traceId= */ "trace_id", + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), /* value= */ 4)))))); @Test @@ -544,14 +550,20 @@ void toSamples_HistogramPoints() { LongExemplarData.create( Attributes.empty(), /*recordTime=*/ 0, - "other_span_id", - "other_trace_id", + SpanContext.create( + "00000000000000000000000000000004", + "0000000000000003", + TraceFlags.getDefault(), + TraceState.getDefault()), /*value=*/ 0), LongExemplarData.create( Attributes.empty(), /*recordTime=*/ TimeUnit.MILLISECONDS.toNanos(2), - "my_span_id", - "my_trace_id", + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), /*value=*/ 2))))); assertThat(result) .withRepresentation(new ExemplarFriendlyRepresentation()) @@ -575,14 +587,26 @@ void toSamples_HistogramPoints() { ImmutableList.of("kp", "le"), ImmutableList.of("vp", "1.0"), 4, - new Exemplar(0d, 0L, "trace_id", "other_trace_id", "span_id", "other_span_id"), + new Exemplar( + 0d, + 0L, + "trace_id", + "00000000000000000000000000000004", + "span_id", + "0000000000000003"), 1633943350000L), new Sample( "full_name_bucket", ImmutableList.of("kp", "le"), ImmutableList.of("vp", "+Inf"), 13, - new Exemplar(2d, 2L, "trace_id", "my_trace_id", "span_id", "my_span_id"), + new Exemplar( + 2d, + 2L, + "trace_id", + "00000000000000000000000000000001", + "span_id", + "0000000000000002"), 1633943350000L)); } @@ -719,7 +743,7 @@ void serialize() { + "# HELP instrument_name description\n" + "instrument_name_count{kp=\"vp\"} 2.0 1633950672.000\n" + "instrument_name_sum{kp=\"vp\"} 1.0 1633950672.000\n" - + "instrument_name_bucket{kp=\"vp\",le=\"+Inf\"} 2.0 1633950672.000 # {span_id=\"span_id\",trace_id=\"trace_id\"} 4.0 0.001\n" + + "instrument_name_bucket{kp=\"vp\",le=\"+Inf\"} 2.0 1633950672.000 # {span_id=\"0000000000000002\",trace_id=\"00000000000000000000000000000001\"} 4.0 0.001\n" + "# EOF\n"); } diff --git a/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/SerializerTest.java b/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/SerializerTest.java index 1527e1e4a7e..306e602c770 100644 --- a/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/SerializerTest.java +++ b/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/SerializerTest.java @@ -9,6 +9,9 @@ import static org.assertj.core.api.Assertions.assertThat; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.api.trace.TraceFlags; +import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; import io.opentelemetry.sdk.metrics.data.DoubleGaugeData; @@ -203,8 +206,11 @@ class SerializerTest { LongExemplarData.create( Attributes.empty(), TimeUnit.MILLISECONDS.toNanos(1L), - /* spanId= */ "span_id", - /* traceId= */ "trace_id", + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), /* value= */ 4)))))); private static final MetricData DOUBLE_GAUGE_NO_ATTRIBUTES = MetricData.createDoubleGauge( @@ -363,7 +369,7 @@ void openMetrics() { + "# HELP instrument_name description\n" + "instrument_name_count{kp=\"vp\"} 2.0 1633950672.000\n" + "instrument_name_sum{kp=\"vp\"} 1.0 1633950672.000\n" - + "instrument_name_bucket{kp=\"vp\",le=\"+Inf\"} 2.0 1633950672.000 # {span_id=\"span_id\",trace_id=\"trace_id\"} 4.0 0.001\n" + + "instrument_name_bucket{kp=\"vp\",le=\"+Inf\"} 2.0 1633950672.000 # {span_id=\"0000000000000002\",trace_id=\"00000000000000000000000000000001\"} 4.0 0.001\n" + "# TYPE instrument_name gauge\n" + "# HELP instrument_name description\n" + "instrument_name 7.0 1633950672.000\n" diff --git a/opencensus-shim/src/main/java/io/opentelemetry/opencensusshim/internal/metrics/MetricAdapter.java b/opencensus-shim/src/main/java/io/opentelemetry/opencensusshim/internal/metrics/MetricAdapter.java index 5d458f069c9..c945b68f1c5 100644 --- a/opencensus-shim/src/main/java/io/opentelemetry/opencensusshim/internal/metrics/MetricAdapter.java +++ b/opencensus-shim/src/main/java/io/opentelemetry/opencensusshim/internal/metrics/MetricAdapter.java @@ -17,6 +17,9 @@ import io.opencensus.metrics.export.TimeSeries; import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.common.AttributesBuilder; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.api.trace.TraceFlags; +import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; import io.opentelemetry.sdk.metrics.data.DoubleExemplarData; @@ -329,8 +332,7 @@ static List mapExemplars(List buckets) { private static ExemplarData mapExemplar(Exemplar exemplar) { // Look for trace/span id. - String spanId = null; - String traceId = null; + SpanContext spanContext = SpanContext.getInvalid(); if (exemplar.getAttachments().containsKey("SpanContext")) { // We need to use `io.opencensus.contrib.exemplar.util.AttachmentValueSpanContext` // The `toString` will be the following: @@ -340,15 +342,16 @@ private static ExemplarData mapExemplar(Exemplar exemplar) { Matcher m = OPENCENSUS_TRACE_ATTACHMENT_PATTERN.matcher(spanContextToString); if (m.matches()) { MatchResult mr = m.toMatchResult(); - traceId = mr.group(1); - spanId = mr.group(2); + String traceId = mr.group(1); + String spanId = mr.group(2); + spanContext = + SpanContext.create(traceId, spanId, TraceFlags.getDefault(), TraceState.getDefault()); } } return DoubleExemplarData.create( Attributes.empty(), mapTimestamp(exemplar.getTimestamp()), - spanId, - traceId, + spanContext, exemplar.getValue()); } diff --git a/opencensus-shim/src/test/java/io/opentelemetry/opencensusshim/internal/metrics/MetricAdapterTest.java b/opencensus-shim/src/test/java/io/opentelemetry/opencensusshim/internal/metrics/MetricAdapterTest.java index c23bb620cbd..9d32f2fa29a 100644 --- a/opencensus-shim/src/test/java/io/opentelemetry/opencensusshim/internal/metrics/MetricAdapterTest.java +++ b/opencensus-shim/src/test/java/io/opentelemetry/opencensusshim/internal/metrics/MetricAdapterTest.java @@ -6,7 +6,6 @@ package io.opentelemetry.opencensusshim.internal.metrics; import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; -import static org.assertj.core.api.Assertions.assertThat; import io.opencensus.common.Timestamp; import io.opencensus.metrics.LabelKey; @@ -22,6 +21,9 @@ import io.opencensus.metrics.export.Value; import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.api.trace.TraceFlags; +import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.sdk.metrics.data.DoubleExemplarData; import io.opentelemetry.sdk.metrics.data.ValueAtPercentile; import io.opentelemetry.sdk.resources.Resource; @@ -193,7 +195,7 @@ void convertHistogram() { exemplarAttachements.put( "SpanContext", AttachmentValue.AttachmentValueString.create( - "SpanContext{traceId=TraceId{traceId=1234}, spanId=SpanId{spanId=5678}, others=stuff}")); + "SpanContext{traceId=TraceId{traceId=00000000000000000000000000000001}, spanId=SpanId{spanId=0000000000000002}, others=stuff}")); Metric censusMetric = Metric.createWithOneTimeSeries( MetricDescriptor.create( @@ -245,13 +247,16 @@ void convertHistogram() { .hasBucketCounts(2, 6, 2) .hasExemplars( DoubleExemplarData.create( - Attributes.empty(), - 2000000, - /* spanId= */ null, - /* traceId= */ null, - 1.0), + Attributes.empty(), 2000000, SpanContext.getInvalid(), 1.0), DoubleExemplarData.create( - Attributes.empty(), 1000000, "5678", "1234", 4.0))); + Attributes.empty(), + 1000000, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 4.0))); } @Test @@ -306,7 +311,7 @@ void convertGaugeHistogram() { exemplarAttachements.put( "SpanContext", AttachmentValue.AttachmentValueString.create( - "SpanContext{traceId=TraceId{traceId=1234}, spanId=SpanId{spanId=5678}, others=stuff}")); + "SpanContext{traceId=TraceId{traceId=00000000000000000000000000000001}, spanId=SpanId{spanId=0000000000000002}, others=stuff}")); Metric censusMetric = Metric.createWithOneTimeSeries( MetricDescriptor.create( @@ -357,12 +362,15 @@ void convertGaugeHistogram() { .hasBucketCounts(2, 6, 2) .hasExemplars( DoubleExemplarData.create( - Attributes.empty(), - 2000000, - /* spanId= */ null, - /* traceId= */ null, - 1.0), + Attributes.empty(), 2000000, SpanContext.getInvalid(), 1.0), DoubleExemplarData.create( - Attributes.empty(), 1000000, "5678", "1234", 4.0))); + Attributes.empty(), + 1000000, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 4.0))); } } diff --git a/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/ExemplarDataAssert.java b/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/ExemplarDataAssert.java index 25ba786ff5b..846d81aabca 100644 --- a/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/ExemplarDataAssert.java +++ b/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/ExemplarDataAssert.java @@ -6,7 +6,9 @@ package io.opentelemetry.sdk.testing.assertj; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.sdk.metrics.data.DoubleExemplarData; import io.opentelemetry.sdk.metrics.data.ExemplarData; +import io.opentelemetry.sdk.metrics.data.LongExemplarData; import org.assertj.core.api.AbstractAssert; import org.assertj.core.api.Assertions; @@ -26,21 +28,25 @@ public ExemplarDataAssert hasEpochNanos(long expected) { /** Ensures the {@code spanId} field matches the expected value. */ public ExemplarDataAssert hasSpanId(String expected) { isNotNull(); - Assertions.assertThat(actual.getSpanId()).as("spanId").isEqualTo(expected); + Assertions.assertThat(actual.getSpanContext().getSpanId()).as("spanId").isEqualTo(expected); return this; } /** Ensures the {@code traceId} field matches the expected value. */ public ExemplarDataAssert hasTraceId(String expected) { isNotNull(); - Assertions.assertThat(actual.getTraceId()).as("traceId").isEqualTo(expected); + Assertions.assertThat(actual.getSpanContext().getTraceId()).as("traceId").isEqualTo(expected); return this; } /** Ensures the {@code value} field matches the expected value. */ public ExemplarDataAssert hasValue(double expected) { isNotNull(); - Assertions.assertThat(actual.getValueAsDouble()).as("value").isEqualTo(expected); + double value = + actual instanceof DoubleExemplarData + ? ((DoubleExemplarData) actual).getValue() + : ((LongExemplarData) actual).getValue(); + Assertions.assertThat(value).as("value").isEqualTo(expected); return this; } diff --git a/sdk/metrics-testing/src/test/java/io/opentelemetry/sdk/testing/assertj/MetricAssertionsTest.java b/sdk/metrics-testing/src/test/java/io/opentelemetry/sdk/testing/assertj/MetricAssertionsTest.java index f4101b4c48f..c4d0c2b10f6 100644 --- a/sdk/metrics-testing/src/test/java/io/opentelemetry/sdk/testing/assertj/MetricAssertionsTest.java +++ b/sdk/metrics-testing/src/test/java/io/opentelemetry/sdk/testing/assertj/MetricAssertionsTest.java @@ -10,6 +10,9 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.api.trace.TraceFlags; +import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; import io.opentelemetry.sdk.metrics.data.DoubleExemplarData; @@ -134,7 +137,15 @@ public class MetricAssertionsTest { Collections.emptyList())); private static final DoubleExemplarData DOUBLE_EXEMPLAR = - DoubleExemplarData.create(Attributes.empty(), 0, "span", "trace", 1.0); + DoubleExemplarData.create( + Attributes.empty(), + 0, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1.0); private static final DoublePointData DOUBLE_POINT_DATA = DoublePointData.create(1, 2, Attributes.empty(), 3.0, Collections.emptyList()); @@ -181,7 +192,15 @@ public class MetricAssertionsTest { Collections.emptyList())); private static final LongExemplarData LONG_EXEMPLAR = - LongExemplarData.create(Attributes.empty(), 0, "span", "trace", 1); + LongExemplarData.create( + Attributes.empty(), + 0, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); private static final LongPointData LONG_POINT_DATA = LongPointData.create(1, 2, Attributes.empty(), 3, Collections.emptyList()); @@ -346,7 +365,15 @@ void doublePoint_failing() { () -> assertThat(DOUBLE_POINT_DATA) .hasExemplars( - DoubleExemplarData.create(Attributes.empty(), 0, "span", "trace", 1.0))) + DoubleExemplarData.create( + Attributes.empty(), + 0, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1.0))) .isInstanceOf(AssertionError.class); } @@ -381,7 +408,15 @@ void longPoint_failing() { () -> assertThat(LONG_POINT_DATA) .hasExemplars( - LongExemplarData.create(Attributes.empty(), 0, "span", "trace", 1))) + LongExemplarData.create( + Attributes.empty(), + 0, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1))) .isInstanceOf(AssertionError.class); } diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/DoubleExemplarData.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/DoubleExemplarData.java index 2a382a84f2e..dee5abf1655 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/DoubleExemplarData.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/DoubleExemplarData.java @@ -7,7 +7,7 @@ import com.google.auto.value.AutoValue; import io.opentelemetry.api.common.Attributes; -import javax.annotation.Nullable; +import io.opentelemetry.api.trace.SpanContext; import javax.annotation.concurrent.Immutable; /** An {@link ExemplarData} with {@code double} measurements. */ @@ -21,18 +21,13 @@ public abstract class DoubleExemplarData implements ExemplarData { * @param filteredAttributes The set of {@link Attributes} not already associated with the {@link * PointData}. * @param recordTimeNanos The time when the sample qas recorded in nanoseconds. - * @param spanId (optional) The associated SpanId. - * @param traceId (optional) The associated TraceId. + * @param spanContext The associated span context. * @param value The value recorded. */ public static DoubleExemplarData create( - Attributes filteredAttributes, - long recordTimeNanos, - @Nullable String spanId, - @Nullable String traceId, - double value) { + Attributes filteredAttributes, long recordTimeNanos, SpanContext spanContext, double value) { return new AutoValue_DoubleExemplarData( - filteredAttributes, recordTimeNanos, spanId, traceId, value); + filteredAttributes, recordTimeNanos, spanContext, value); } DoubleExemplarData() {} @@ -41,6 +36,7 @@ public static DoubleExemplarData create( public abstract double getValue(); @Override + @Deprecated public final double getValueAsDouble() { return getValue(); } diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/ExemplarData.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/ExemplarData.java index 5ff43577815..dfcd7a82eb6 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/ExemplarData.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/ExemplarData.java @@ -6,6 +6,7 @@ package io.opentelemetry.sdk.metrics.data; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanContext; import javax.annotation.Nullable; import javax.annotation.concurrent.Immutable; @@ -27,27 +28,50 @@ public interface ExemplarData { /** Returns the timestamp in nanos when measurement was collected. */ long getEpochNanos(); + /** + * Returns the {@link SpanContext} associated with this exemplar. If the exemplar was not recorded + * inside a sampled trace, the {@link SpanContext} will be {@linkplain SpanContext#getInvalid() + * invalid}. + */ + SpanContext getSpanContext(); + /** * (Optional) Span ID of the exemplar trace. * *

Span ID may be {@code null} if the measurement is not recorded inside a trace or the trace * was not sampled. + * + * @deprecated Use {@link ExemplarData#getSpanContext()}. */ @Nullable - String getSpanId(); + @Deprecated + default String getSpanId() { + SpanContext spanContext = getSpanContext(); + return spanContext != null ? spanContext.getSpanId() : null; + } /** * (Optional) Trace ID of the exemplar trace. * *

Trace ID may be {@code null} if the measurement is not recorded inside a trace or if the * trace is not sampled. + * + * @deprecated Use {@link ExemplarData#getSpanContext()}. */ @Nullable - String getTraceId(); + @Deprecated + default String getTraceId() { + SpanContext spanContext = getSpanContext(); + return spanContext != null ? spanContext.getTraceId() : null; + } /** * Coerces this exemplar to a double value. * *

Note: This could create a loss of precision from {@code long} measurements. + * + * @deprecated Cast to {@link LongExemplarData} or {@link DoubleExemplarData} and call {@code + * getValue()}. */ + @Deprecated double getValueAsDouble(); } diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/LongExemplarData.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/LongExemplarData.java index fe51ea07e87..edef2167808 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/LongExemplarData.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/LongExemplarData.java @@ -7,6 +7,7 @@ import com.google.auto.value.AutoValue; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanContext; import javax.annotation.concurrent.Immutable; /** An {@link ExemplarData} with {@code long} measurements. */ @@ -20,18 +21,12 @@ public abstract class LongExemplarData implements ExemplarData { * @param filteredAttributes The set of {@link Attributes} not already associated with the {@link * PointData}. * @param recordTimeNanos The time when the sample qas recorded in nanoseconds. - * @param spanId (optional) The associated SpanId. - * @param traceId (optional) The associated TraceId. + * @param spanContext The associated span context. * @param value The value recorded. */ public static LongExemplarData create( - Attributes filteredAttributes, - long recordTimeNanos, - String spanId, - String traceId, - long value) { - return new AutoValue_LongExemplarData( - filteredAttributes, recordTimeNanos, spanId, traceId, value); + Attributes filteredAttributes, long recordTimeNanos, SpanContext spanContext, long value) { + return new AutoValue_LongExemplarData(filteredAttributes, recordTimeNanos, spanContext, value); } LongExemplarData() {} @@ -40,6 +35,7 @@ public static LongExemplarData create( public abstract long getValue(); @Override + @Deprecated public final double getValueAsDouble() { return (double) getValue(); } diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/exemplar/AbstractFixedSizeExemplarReservoir.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/exemplar/AbstractFixedSizeExemplarReservoir.java index 13b8d312950..6011e28814d 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/exemplar/AbstractFixedSizeExemplarReservoir.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/exemplar/AbstractFixedSizeExemplarReservoir.java @@ -8,6 +8,7 @@ import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.trace.Span; +import io.opentelemetry.api.trace.SpanContext; import io.opentelemetry.context.Context; import io.opentelemetry.sdk.common.Clock; import io.opentelemetry.sdk.metrics.data.DoubleExemplarData; @@ -94,8 +95,7 @@ public final List collectAndReset(Attributes pointAttributes) { private class ReservoirCell { private double value; @Nullable private Attributes attributes; - @Nullable private String spanId; - @Nullable private String traceId; + private SpanContext spanContext = SpanContext.getInvalid(); private long recordTime; synchronized void offerMeasurement(double value, Attributes attributes, Context context) { @@ -109,8 +109,7 @@ synchronized void offerMeasurement(double value, Attributes attributes, Context private void updateFromContext(Context context) { Span current = Span.fromContext(context); if (current.getSpanContext().isValid()) { - this.spanId = current.getSpanContext().getSpanId(); - this.traceId = current.getSpanContext().getTraceId(); + this.spanContext = current.getSpanContext(); } } @@ -120,11 +119,10 @@ synchronized ExemplarData getAndReset(Attributes pointAttributes) { if (attributes != null) { ExemplarData result = DoubleExemplarData.create( - filtered(attributes, pointAttributes), recordTime, spanId, traceId, value); + filtered(attributes, pointAttributes), recordTime, spanContext, value); this.attributes = null; this.value = 0; - this.spanId = null; - this.traceId = null; + this.spanContext = SpanContext.getInvalid(); this.recordTime = 0; return result; } diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/AggregatorHandleTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/AggregatorHandleTest.java index a0b5eadb4cf..72bfea0b783 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/AggregatorHandleTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/AggregatorHandleTest.java @@ -9,6 +9,9 @@ import com.google.common.util.concurrent.AtomicDouble; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.api.trace.TraceFlags; +import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.context.Context; import io.opentelemetry.sdk.metrics.data.DoubleExemplarData; import io.opentelemetry.sdk.metrics.data.ExemplarData; @@ -127,7 +130,16 @@ void testOfferMeasurementDoubleToExemplar() { void testGenerateExemplarsOnCollect() { TestAggregatorHandle testAggregator = new TestAggregatorHandle(reservoir); Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData result = DoubleExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData result = + DoubleExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); // We need to first record a value so that collect and reset does something. testAggregator.recordDouble(1.0, Attributes.empty(), Context.root()); Mockito.when(reservoir.collectAndReset(attributes)) diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleExponentialHistogramAggregatorTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleExponentialHistogramAggregatorTest.java index 69c0b1bd49b..b456914a9bd 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleExponentialHistogramAggregatorTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleExponentialHistogramAggregatorTest.java @@ -9,6 +9,9 @@ import com.google.common.collect.ImmutableList; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.api.trace.TraceFlags; +import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.context.Context; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; @@ -181,7 +184,16 @@ void testExemplarsInAccumulation() { new DoubleExponentialHistogramAggregator(() -> reservoir); Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData exemplar = DoubleExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData exemplar = + DoubleExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); List exemplars = Collections.singletonList(exemplar); Mockito.when(reservoir.collectAndReset(Attributes.empty())).thenReturn(exemplars); @@ -219,11 +231,28 @@ void testAccumulateData() { @Test void diffAccumulation() { Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData exemplar = DoubleExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData exemplar = + DoubleExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); List exemplars = Collections.singletonList(exemplar); List previousExemplars = Collections.singletonList( - DoubleExemplarData.create(attributes, 1L, "spanId", "traceId", 2)); + DoubleExemplarData.create( + attributes, + 1L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 2)); ExponentialHistogramAccumulation nextAccumulation = getTestAccumulation(exemplars, 0, 0, 1, 1, -1); @@ -241,11 +270,28 @@ void diffAccumulation() { @Test void diffDownScaledAccumulation() { Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData exemplar = DoubleExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData exemplar = + DoubleExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); List exemplars = Collections.singletonList(exemplar); List previousExemplars = Collections.singletonList( - DoubleExemplarData.create(attributes, 1L, "spanId", "traceId", 2)); + DoubleExemplarData.create( + attributes, + 1L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 2)); ExponentialHistogramAccumulation nextAccumulation = getTestAccumulation(exemplars, 1, 1, 100, -1, -100); @@ -260,11 +306,28 @@ void diffDownScaledAccumulation() { @Test void testMergeAccumulation() { Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData exemplar = DoubleExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData exemplar = + DoubleExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); List exemplars = Collections.singletonList(exemplar); List previousExemplars = Collections.singletonList( - DoubleExemplarData.create(attributes, 1L, "spanId", "traceId", 2)); + DoubleExemplarData.create( + attributes, + 1L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 2)); ExponentialHistogramAccumulation previousAccumulation = getTestAccumulation(previousExemplars, 0, 4.1, 100, 100, 10000, 1000000); ExponentialHistogramAccumulation nextAccumulation = @@ -366,7 +429,16 @@ void testDownScale() { @Test void testToMetricData() { Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData exemplar = DoubleExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData exemplar = + DoubleExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); @SuppressWarnings("unchecked") Supplier reservoirSupplier = Mockito.mock(Supplier.class); Mockito.when(reservoir.collectAndReset(Attributes.empty())) diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleHistogramAggregatorTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleHistogramAggregatorTest.java index 723cf13c01f..fcd819c1636 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleHistogramAggregatorTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleHistogramAggregatorTest.java @@ -9,6 +9,9 @@ import com.google.common.collect.ImmutableList; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.api.trace.TraceFlags; +import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.context.Context; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; @@ -65,7 +68,16 @@ void testRecordings() { @Test void testExemplarsInAccumulation() { Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData exemplar = DoubleExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData exemplar = + DoubleExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); List exemplars = Collections.singletonList(exemplar); Mockito.when(reservoir.collectAndReset(Attributes.empty())).thenReturn(exemplars); DoubleHistogramAggregator aggregator = @@ -103,11 +115,28 @@ void accumulateData() { @Test void mergeAccumulation() { Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData exemplar = DoubleExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData exemplar = + DoubleExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); List exemplars = Collections.singletonList(exemplar); List previousExemplars = Collections.singletonList( - DoubleExemplarData.create(attributes, 1L, "spanId", "traceId", 2)); + DoubleExemplarData.create( + attributes, + 1L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 2)); HistogramAccumulation previousAccumulation = HistogramAccumulation.create(2, new long[] {1, 1, 0}, previousExemplars); HistogramAccumulation nextAccumulation = @@ -120,11 +149,28 @@ void mergeAccumulation() { @Test void diffAccumulation() { Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData exemplar = DoubleExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData exemplar = + DoubleExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); List exemplars = Collections.singletonList(exemplar); List previousExemplars = Collections.singletonList( - DoubleExemplarData.create(attributes, 1L, "spanId", "traceId", 2)); + DoubleExemplarData.create( + attributes, + 1L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 2)); HistogramAccumulation previousAccumulation = HistogramAccumulation.create(2, new long[] {1, 1, 2}, previousExemplars); HistogramAccumulation nextAccumulation = @@ -159,7 +205,16 @@ void toMetricData() { @Test void toMetricDataWithExemplars() { Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData exemplar = DoubleExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData exemplar = + DoubleExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); HistogramAccumulation accumulation = HistogramAccumulation.create( 2, new long[] {1, 0, 0, 0}, Collections.singletonList(exemplar)); diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleLastValueAggregatorTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleLastValueAggregatorTest.java index 7cad502b83a..b5f10bf737b 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleLastValueAggregatorTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleLastValueAggregatorTest.java @@ -6,9 +6,11 @@ package io.opentelemetry.sdk.metrics.internal.aggregator; import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; -import static org.assertj.core.api.Assertions.assertThat; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.api.trace.TraceFlags; +import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; import io.opentelemetry.sdk.metrics.data.DoubleExemplarData; @@ -63,11 +65,28 @@ void toAccumulationAndReset() { @Test void mergeAccumulation() { Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData exemplar = DoubleExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData exemplar = + DoubleExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); List exemplars = Collections.singletonList(exemplar); List previousExemplars = Collections.singletonList( - DoubleExemplarData.create(attributes, 1L, "spanId", "traceId", 2)); + DoubleExemplarData.create( + attributes, + 1L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 2)); DoubleAccumulation result = aggregator.merge( DoubleAccumulation.create(1, previousExemplars), @@ -79,11 +98,28 @@ void mergeAccumulation() { @Test void diffAccumulation() { Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData exemplar = DoubleExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData exemplar = + DoubleExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); List exemplars = Collections.singletonList(exemplar); List previousExemplars = Collections.singletonList( - DoubleExemplarData.create(attributes, 1L, "spanId", "traceId", 2)); + DoubleExemplarData.create( + attributes, + 1L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 2)); DoubleAccumulation result = aggregator.diff( DoubleAccumulation.create(1, previousExemplars), diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleSumAggregatorTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleSumAggregatorTest.java index 3374dffa4c9..9ed3d58f02b 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleSumAggregatorTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleSumAggregatorTest.java @@ -8,6 +8,9 @@ import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.api.trace.TraceFlags; +import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.context.Context; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.common.InstrumentType; @@ -97,7 +100,16 @@ void toAccumulationAndReset() { @Test void testExemplarsInAccumulation() { Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData exemplar = DoubleExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData exemplar = + DoubleExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); List exemplars = Collections.singletonList(exemplar); Mockito.when(reservoir.collectAndReset(Attributes.empty())).thenReturn(exemplars); DoubleSumAggregator aggregator = @@ -118,11 +130,28 @@ void testExemplarsInAccumulation() { @Test void mergeAndDiff() { Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData exemplar = DoubleExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData exemplar = + DoubleExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); List exemplars = Collections.singletonList(exemplar); List previousExemplars = Collections.singletonList( - DoubleExemplarData.create(attributes, 1L, "spanId", "traceId", 2)); + DoubleExemplarData.create( + attributes, + 1L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 2)); for (InstrumentType instrumentType : InstrumentType.values()) { for (AggregationTemporality temporality : AggregationTemporality.values()) { DoubleSumAggregator aggregator = @@ -191,7 +220,16 @@ void toMetricData() { @Test void toMetricDataWithExemplars() { Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData exemplar = DoubleExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData exemplar = + DoubleExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); DoubleAccumulation accumulation = DoubleAccumulation.create(1, Collections.singletonList(exemplar)); assertThat( diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/LongLastValueAggregatorTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/LongLastValueAggregatorTest.java index e5a3fed3c3f..57649b9e87b 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/LongLastValueAggregatorTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/LongLastValueAggregatorTest.java @@ -8,6 +8,9 @@ import static org.assertj.core.api.Assertions.assertThat; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.api.trace.TraceFlags; +import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; import io.opentelemetry.sdk.metrics.data.ExemplarData; @@ -64,10 +67,28 @@ void toAccumulationAndReset() { @Test void mergeAccumulation() { Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData exemplar = LongExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData exemplar = + LongExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); List exemplars = Collections.singletonList(exemplar); List previousExemplars = - Collections.singletonList(LongExemplarData.create(attributes, 1L, "spanId", "traceId", 2)); + Collections.singletonList( + LongExemplarData.create( + attributes, + 1L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 2)); LongAccumulation result = aggregator.merge( LongAccumulation.create(1, previousExemplars), LongAccumulation.create(2, exemplars)); diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/LongSumAggregatorTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/LongSumAggregatorTest.java index 02e512b7d34..1b95276728a 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/LongSumAggregatorTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/LongSumAggregatorTest.java @@ -6,9 +6,11 @@ package io.opentelemetry.sdk.metrics.internal.aggregator; import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; -import static org.assertj.core.api.Assertions.assertThat; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.api.trace.TraceFlags; +import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.context.Context; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.common.InstrumentType; @@ -99,7 +101,16 @@ void toAccumulationAndReset() { @Test void testExemplarsInAccumulation() { Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData exemplar = DoubleExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData exemplar = + DoubleExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); List exemplars = Collections.singletonList(exemplar); Mockito.when(reservoir.collectAndReset(Attributes.empty())).thenReturn(exemplars); LongSumAggregator aggregator = @@ -120,7 +131,15 @@ void testExemplarsInAccumulation() { @Test void mergeAndDiff() { ExemplarData exemplar = - DoubleExemplarData.create(Attributes.empty(), 2L, "spanid", "traceid", 1); + DoubleExemplarData.create( + Attributes.empty(), + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); List exemplars = Collections.singletonList(exemplar); for (InstrumentType instrumentType : InstrumentType.values()) { for (AggregationTemporality temporality : AggregationTemporality.values()) { @@ -187,7 +206,16 @@ void toMetricData() { @Test void toMetricDataWithExemplars() { Attributes attributes = Attributes.builder().put("test", "value").build(); - ExemplarData exemplar = DoubleExemplarData.create(attributes, 2L, "spanid", "traceid", 1); + ExemplarData exemplar = + DoubleExemplarData.create( + attributes, + 2L, + SpanContext.create( + "00000000000000000000000000000001", + "0000000000000002", + TraceFlags.getDefault(), + TraceState.getDefault()), + 1); LongAccumulation accumulation = LongAccumulation.create(1, Collections.singletonList(exemplar)); assertThat( aggregator.toMetricData( From 69b00c3f3598d5cd762f467512132965acf21370 Mon Sep 17 00:00:00 2001 From: Anuraag Agrawal Date: Fri, 25 Feb 2022 14:08:34 +0900 Subject: [PATCH 3/4] Remove type-specific GaugeData (#4207) --- .../metrics/MetricsRequestMarshalerTest.java | 7 ++-- .../prometheus/MetricAdapterTest.java | 7 ++-- .../exporter/prometheus/SerializerTest.java | 11 +++--- .../internal/metrics/MetricAdapter.java | 12 +++--- .../testing/assertj/DoubleGaugeAssert.java | 26 ------------- .../sdk/testing/assertj/GaugeAssert.java | 24 ++++++++++++ .../testing/assertj/LongGaugeDataAssert.java | 26 ------------- .../sdk/testing/assertj/MetricAssertions.java | 15 +++----- .../sdk/testing/assertj/MetricDataAssert.java | 10 +++-- .../testing/assertj/MetricAssertionsTest.java | 7 ++-- .../sdk/metrics/data/DoubleGaugeData.java | 27 -------------- .../sdk/metrics/data/LongGaugeData.java | 28 -------------- .../sdk/metrics/data/MetricData.java | 19 ++++++---- .../aggregator/DoubleLastValueAggregator.java | 4 +- .../aggregator/LongLastValueAggregator.java | 4 +- .../internal/data/ImmutableGaugeData.java | 37 +++++++++++++++++++ .../metrics/internal/data/package-info.java | 10 +++++ .../sdk/metrics/data/MetricDataImplTest.java | 9 +++-- .../LongLastValueAggregatorTest.java | 4 +- 19 files changed, 124 insertions(+), 163 deletions(-) delete mode 100644 sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/DoubleGaugeAssert.java create mode 100644 sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/GaugeAssert.java delete mode 100644 sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/LongGaugeDataAssert.java delete mode 100644 sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/DoubleGaugeData.java delete mode 100644 sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/LongGaugeData.java create mode 100644 sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/data/ImmutableGaugeData.java create mode 100644 sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/data/package-info.java diff --git a/exporters/otlp/common/src/test/java/io/opentelemetry/exporter/internal/otlp/metrics/MetricsRequestMarshalerTest.java b/exporters/otlp/common/src/test/java/io/opentelemetry/exporter/internal/otlp/metrics/MetricsRequestMarshalerTest.java index 10c1694c80a..548613c049c 100644 --- a/exporters/otlp/common/src/test/java/io/opentelemetry/exporter/internal/otlp/metrics/MetricsRequestMarshalerTest.java +++ b/exporters/otlp/common/src/test/java/io/opentelemetry/exporter/internal/otlp/metrics/MetricsRequestMarshalerTest.java @@ -42,7 +42,6 @@ import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; import io.opentelemetry.sdk.metrics.data.DoubleExemplarData; -import io.opentelemetry.sdk.metrics.data.DoubleGaugeData; import io.opentelemetry.sdk.metrics.data.DoubleHistogramData; import io.opentelemetry.sdk.metrics.data.DoubleHistogramPointData; import io.opentelemetry.sdk.metrics.data.DoublePointData; @@ -53,12 +52,12 @@ import io.opentelemetry.sdk.metrics.data.ExponentialHistogramData; import io.opentelemetry.sdk.metrics.data.ExponentialHistogramPointData; import io.opentelemetry.sdk.metrics.data.LongExemplarData; -import io.opentelemetry.sdk.metrics.data.LongGaugeData; import io.opentelemetry.sdk.metrics.data.LongPointData; import io.opentelemetry.sdk.metrics.data.LongSumData; import io.opentelemetry.sdk.metrics.data.MetricData; import io.opentelemetry.sdk.metrics.data.PointData; import io.opentelemetry.sdk.metrics.data.ValueAtPercentile; +import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData; import io.opentelemetry.sdk.resources.Resource; import java.io.ByteArrayOutputStream; import java.io.IOException; @@ -614,7 +613,7 @@ void toProtoMetric_gauges() { "name", "description", "1", - LongGaugeData.create( + ImmutableGaugeData.create( singletonList(LongPointData.create(123, 456, KV_ATTR, 5)))))) .isEqualTo( Metric.newBuilder() @@ -645,7 +644,7 @@ void toProtoMetric_gauges() { "name", "description", "1", - DoubleGaugeData.create( + ImmutableGaugeData.create( singletonList(DoublePointData.create(123, 456, KV_ATTR, 5.1)))))) .isEqualTo( Metric.newBuilder() diff --git a/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/MetricAdapterTest.java b/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/MetricAdapterTest.java index 36c920da461..1a26a39c434 100644 --- a/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/MetricAdapterTest.java +++ b/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/MetricAdapterTest.java @@ -15,7 +15,6 @@ import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; -import io.opentelemetry.sdk.metrics.data.DoubleGaugeData; import io.opentelemetry.sdk.metrics.data.DoubleHistogramData; import io.opentelemetry.sdk.metrics.data.DoubleHistogramPointData; import io.opentelemetry.sdk.metrics.data.DoublePointData; @@ -23,12 +22,12 @@ import io.opentelemetry.sdk.metrics.data.DoubleSummaryData; import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData; import io.opentelemetry.sdk.metrics.data.LongExemplarData; -import io.opentelemetry.sdk.metrics.data.LongGaugeData; import io.opentelemetry.sdk.metrics.data.LongPointData; import io.opentelemetry.sdk.metrics.data.LongSumData; import io.opentelemetry.sdk.metrics.data.MetricData; import io.opentelemetry.sdk.metrics.data.MetricDataType; import io.opentelemetry.sdk.metrics.data.ValueAtPercentile; +import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData; import io.opentelemetry.sdk.resources.Resource; import io.prometheus.client.Collector; import io.prometheus.client.Collector.MetricFamilySamples; @@ -162,7 +161,7 @@ class MetricAdapterTest { "instrument.name", "description", "1", - DoubleGaugeData.create( + ImmutableGaugeData.create( Collections.singletonList( DoublePointData.create( 1633947011000000000L, 1633950672000000000L, KP_VP_ATTR, 5)))); @@ -173,7 +172,7 @@ class MetricAdapterTest { "instrument.name", "description", "1", - LongGaugeData.create( + ImmutableGaugeData.create( Collections.singletonList( LongPointData.create( 1633947011000000000L, 1633950672000000000L, KP_VP_ATTR, 5)))); diff --git a/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/SerializerTest.java b/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/SerializerTest.java index 306e602c770..5b69dbc4a15 100644 --- a/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/SerializerTest.java +++ b/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/SerializerTest.java @@ -14,7 +14,6 @@ import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; -import io.opentelemetry.sdk.metrics.data.DoubleGaugeData; import io.opentelemetry.sdk.metrics.data.DoubleHistogramData; import io.opentelemetry.sdk.metrics.data.DoubleHistogramPointData; import io.opentelemetry.sdk.metrics.data.DoublePointData; @@ -22,11 +21,11 @@ import io.opentelemetry.sdk.metrics.data.DoubleSummaryData; import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData; import io.opentelemetry.sdk.metrics.data.LongExemplarData; -import io.opentelemetry.sdk.metrics.data.LongGaugeData; import io.opentelemetry.sdk.metrics.data.LongPointData; import io.opentelemetry.sdk.metrics.data.LongSumData; import io.opentelemetry.sdk.metrics.data.MetricData; import io.opentelemetry.sdk.metrics.data.ValueAtPercentile; +import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData; import io.opentelemetry.sdk.resources.Resource; import java.io.ByteArrayOutputStream; import java.io.IOException; @@ -152,7 +151,7 @@ class SerializerTest { "instrument.name", "description", "1", - DoubleGaugeData.create( + ImmutableGaugeData.create( Collections.singletonList( DoublePointData.create( 1633947011000000000L, 1633950672000000000L, KP_VP_ATTR, 5)))); @@ -163,7 +162,7 @@ class SerializerTest { "instrument.name", "description", "1", - LongGaugeData.create( + ImmutableGaugeData.create( Collections.singletonList( LongPointData.create( 1633947011000000000L, 1633950672000000000L, KP_VP_ATTR, 5)))); @@ -219,7 +218,7 @@ class SerializerTest { "instrument.name", "description", "1", - DoubleGaugeData.create( + ImmutableGaugeData.create( Collections.singletonList( DoublePointData.create( 1633947011000000000L, 1633950672000000000L, Attributes.empty(), 7)))); @@ -230,7 +229,7 @@ class SerializerTest { "instrument.name", "description", "1", - DoubleGaugeData.create( + ImmutableGaugeData.create( Collections.singletonList( DoublePointData.create( 1633947011000000000L, diff --git a/opencensus-shim/src/main/java/io/opentelemetry/opencensusshim/internal/metrics/MetricAdapter.java b/opencensus-shim/src/main/java/io/opentelemetry/opencensusshim/internal/metrics/MetricAdapter.java index c945b68f1c5..8b176c30b9e 100644 --- a/opencensus-shim/src/main/java/io/opentelemetry/opencensusshim/internal/metrics/MetricAdapter.java +++ b/opencensus-shim/src/main/java/io/opentelemetry/opencensusshim/internal/metrics/MetricAdapter.java @@ -23,7 +23,6 @@ import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; import io.opentelemetry.sdk.metrics.data.DoubleExemplarData; -import io.opentelemetry.sdk.metrics.data.DoubleGaugeData; import io.opentelemetry.sdk.metrics.data.DoubleHistogramData; import io.opentelemetry.sdk.metrics.data.DoubleHistogramPointData; import io.opentelemetry.sdk.metrics.data.DoublePointData; @@ -31,11 +30,12 @@ import io.opentelemetry.sdk.metrics.data.DoubleSummaryData; import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData; import io.opentelemetry.sdk.metrics.data.ExemplarData; -import io.opentelemetry.sdk.metrics.data.LongGaugeData; +import io.opentelemetry.sdk.metrics.data.GaugeData; import io.opentelemetry.sdk.metrics.data.LongPointData; import io.opentelemetry.sdk.metrics.data.LongSumData; import io.opentelemetry.sdk.metrics.data.MetricData; import io.opentelemetry.sdk.metrics.data.ValueAtPercentile; +import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData; import io.opentelemetry.sdk.resources.Resource; import java.util.ArrayList; import java.util.Collection; @@ -137,12 +137,12 @@ public static MetricData convert(Resource otelResource, Metric censusMetric) { "Unknown OpenCensus metric type: " + censusMetric.getMetricDescriptor().getType()); } - static LongGaugeData convertLongGauge(Metric censusMetric) { - return LongGaugeData.create(convertLongPoints(censusMetric)); + static GaugeData convertLongGauge(Metric censusMetric) { + return ImmutableGaugeData.create(convertLongPoints(censusMetric)); } - static DoubleGaugeData convertDoubleGauge(Metric censusMetric) { - return DoubleGaugeData.create(convertDoublePoints(censusMetric)); + static GaugeData convertDoubleGauge(Metric censusMetric) { + return ImmutableGaugeData.create(convertDoublePoints(censusMetric)); } static LongSumData convertLongSum(Metric censusMetric) { diff --git a/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/DoubleGaugeAssert.java b/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/DoubleGaugeAssert.java deleted file mode 100644 index 103184f882a..00000000000 --- a/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/DoubleGaugeAssert.java +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.testing.assertj; - -import io.opentelemetry.sdk.metrics.data.DoubleGaugeData; -import io.opentelemetry.sdk.metrics.data.DoublePointData; -import org.assertj.core.api.AbstractAssert; -import org.assertj.core.api.AbstractIterableAssert; -import org.assertj.core.api.Assertions; - -/** Test assertions for {@link DoubleGaugeData}. */ -public class DoubleGaugeAssert extends AbstractAssert { - protected DoubleGaugeAssert(DoubleGaugeData actual) { - super(actual, DoubleGaugeAssert.class); - } - - public AbstractIterableAssert< - ?, ? extends Iterable, DoublePointData, ?> - points() { - isNotNull(); - return Assertions.assertThat(actual.getPoints()); - } -} diff --git a/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/GaugeAssert.java b/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/GaugeAssert.java new file mode 100644 index 00000000000..884d6d312a0 --- /dev/null +++ b/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/GaugeAssert.java @@ -0,0 +1,24 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.sdk.testing.assertj; + +import io.opentelemetry.sdk.metrics.data.GaugeData; +import io.opentelemetry.sdk.metrics.data.PointData; +import org.assertj.core.api.AbstractAssert; +import org.assertj.core.api.AbstractIterableAssert; +import org.assertj.core.api.Assertions; + +/** Test assertions for {@link GaugeData}. */ +public class GaugeAssert extends AbstractAssert, GaugeData> { + protected GaugeAssert(GaugeData actual) { + super(actual, GaugeAssert.class); + } + + public AbstractIterableAssert, T, ?> points() { + isNotNull(); + return Assertions.assertThat(actual.getPoints()); + } +} diff --git a/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/LongGaugeDataAssert.java b/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/LongGaugeDataAssert.java deleted file mode 100644 index f544a74c910..00000000000 --- a/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/LongGaugeDataAssert.java +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.testing.assertj; - -import io.opentelemetry.sdk.metrics.data.LongGaugeData; -import io.opentelemetry.sdk.metrics.data.LongPointData; -import org.assertj.core.api.AbstractAssert; -import org.assertj.core.api.AbstractIterableAssert; -import org.assertj.core.api.Assertions; - -/** Test assertions for {@link LongGaugeData}. */ -public class LongGaugeDataAssert extends AbstractAssert { - protected LongGaugeDataAssert(LongGaugeData actual) { - super(actual, LongGaugeDataAssert.class); - } - - /** Returns convenience API to assert against the {@code points} field. */ - public AbstractIterableAssert, LongPointData, ?> - points() { - isNotNull(); - return Assertions.assertThat(actual.getPoints()); - } -} diff --git a/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/MetricAssertions.java b/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/MetricAssertions.java index 36d83713877..b1a7fb2f1e8 100644 --- a/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/MetricAssertions.java +++ b/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/MetricAssertions.java @@ -5,7 +5,6 @@ package io.opentelemetry.sdk.testing.assertj; -import io.opentelemetry.sdk.metrics.data.DoubleGaugeData; import io.opentelemetry.sdk.metrics.data.DoubleHistogramData; import io.opentelemetry.sdk.metrics.data.DoubleHistogramPointData; import io.opentelemetry.sdk.metrics.data.DoublePointData; @@ -15,10 +14,11 @@ import io.opentelemetry.sdk.metrics.data.ExemplarData; import io.opentelemetry.sdk.metrics.data.ExponentialHistogramBuckets; import io.opentelemetry.sdk.metrics.data.ExponentialHistogramPointData; -import io.opentelemetry.sdk.metrics.data.LongGaugeData; +import io.opentelemetry.sdk.metrics.data.GaugeData; import io.opentelemetry.sdk.metrics.data.LongPointData; import io.opentelemetry.sdk.metrics.data.LongSumData; import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.metrics.data.PointData; import org.assertj.core.api.Assertions; /** Test assertions for data heading to exporters within the Metrics SDK. */ @@ -28,9 +28,9 @@ public static MetricDataAssert assertThat(MetricData metric) { return new MetricDataAssert(metric); } - /** Returns an assertion for {@link DoubleGaugeData}. */ - public static DoubleGaugeAssert assertThat(DoubleGaugeData metric) { - return new DoubleGaugeAssert(metric); + /** Returns an assertion for {@link GaugeData}. */ + public static GaugeAssert assertThat(GaugeData metric) { + return new GaugeAssert<>(metric); } /** Returns an assertion for {@link DoubleHistogramData}. */ @@ -79,11 +79,6 @@ public static LongPointDataAssert assertThat(LongPointData point) { return new LongPointDataAssert(point); } - /** Returns an assertion for {@link LongGaugeData}. */ - public static LongGaugeDataAssert assertThat(LongGaugeData metric) { - return new LongGaugeDataAssert(metric); - } - /** Returns an assertion for {@link LongSumData}. */ public static LongSumDataAssert assertThat(LongSumData metric) { return new LongSumDataAssert(metric); diff --git a/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/MetricDataAssert.java b/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/MetricDataAssert.java index 449ed902fe6..e6ce6ba7277 100644 --- a/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/MetricDataAssert.java +++ b/sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/MetricDataAssert.java @@ -6,6 +6,8 @@ package io.opentelemetry.sdk.testing.assertj; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; +import io.opentelemetry.sdk.metrics.data.DoublePointData; +import io.opentelemetry.sdk.metrics.data.LongPointData; import io.opentelemetry.sdk.metrics.data.MetricData; import io.opentelemetry.sdk.metrics.data.MetricDataType; import io.opentelemetry.sdk.resources.Resource; @@ -132,7 +134,7 @@ public ExponentialHistogramAssert hasExponentialHistogram() { * * @return convenience API to assert against the {@code DoubleGauge}. */ - public DoubleGaugeAssert hasDoubleGauge() { + public GaugeAssert hasDoubleGauge() { isNotNull(); if (actual.getType() != MetricDataType.DOUBLE_GAUGE) { failWithActualExpectedAndMessage( @@ -142,7 +144,7 @@ public DoubleGaugeAssert hasDoubleGauge() { MetricDataType.DOUBLE_GAUGE, actual.getType()); } - return new DoubleGaugeAssert(actual.getDoubleGaugeData()); + return new GaugeAssert<>(actual.getDoubleGaugeData()); } /** @@ -168,7 +170,7 @@ public DoubleSumDataAssert hasDoubleSum() { * * @return convenience API to assert against the {@code LongGauge}. */ - public LongGaugeDataAssert hasLongGauge() { + public GaugeAssert hasLongGauge() { isNotNull(); if (actual.getType() != MetricDataType.LONG_GAUGE) { failWithActualExpectedAndMessage( @@ -178,7 +180,7 @@ public LongGaugeDataAssert hasLongGauge() { MetricDataType.LONG_GAUGE, actual.getType()); } - return new LongGaugeDataAssert(actual.getLongGaugeData()); + return new GaugeAssert<>(actual.getLongGaugeData()); } /** diff --git a/sdk/metrics-testing/src/test/java/io/opentelemetry/sdk/testing/assertj/MetricAssertionsTest.java b/sdk/metrics-testing/src/test/java/io/opentelemetry/sdk/testing/assertj/MetricAssertionsTest.java index c4d0c2b10f6..e8556d8390c 100644 --- a/sdk/metrics-testing/src/test/java/io/opentelemetry/sdk/testing/assertj/MetricAssertionsTest.java +++ b/sdk/metrics-testing/src/test/java/io/opentelemetry/sdk/testing/assertj/MetricAssertionsTest.java @@ -16,7 +16,6 @@ import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; import io.opentelemetry.sdk.metrics.data.DoubleExemplarData; -import io.opentelemetry.sdk.metrics.data.DoubleGaugeData; import io.opentelemetry.sdk.metrics.data.DoubleHistogramData; import io.opentelemetry.sdk.metrics.data.DoubleHistogramPointData; import io.opentelemetry.sdk.metrics.data.DoublePointData; @@ -25,11 +24,11 @@ import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData; import io.opentelemetry.sdk.metrics.data.ExponentialHistogramData; import io.opentelemetry.sdk.metrics.data.LongExemplarData; -import io.opentelemetry.sdk.metrics.data.LongGaugeData; import io.opentelemetry.sdk.metrics.data.LongPointData; import io.opentelemetry.sdk.metrics.data.LongSumData; import io.opentelemetry.sdk.metrics.data.MetricData; import io.opentelemetry.sdk.metrics.data.ValueAtPercentile; +import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData; import io.opentelemetry.sdk.resources.Resource; import java.util.Arrays; import java.util.Collections; @@ -106,7 +105,7 @@ public class MetricAssertionsTest { /* name= */ "gauge", /* description= */ "description", /* unit= */ "unit", - DoubleGaugeData.create( + ImmutableGaugeData.create( // Points Collections.emptyList())); @@ -161,7 +160,7 @@ public class MetricAssertionsTest { /* name= */ "gauge", /* description= */ "description", /* unit= */ "unit", - LongGaugeData.create( + ImmutableGaugeData.create( // Points Collections.emptyList())); diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/DoubleGaugeData.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/DoubleGaugeData.java deleted file mode 100644 index bcadd5952e4..00000000000 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/DoubleGaugeData.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.metrics.data; - -import com.google.auto.value.AutoValue; -import java.util.Collection; -import java.util.Collections; -import javax.annotation.concurrent.Immutable; - -/** {@link GaugeData} recorded uses {@code double}s. */ -@Immutable -@AutoValue -public abstract class DoubleGaugeData implements GaugeData { - static final DoubleGaugeData EMPTY = DoubleGaugeData.create(Collections.emptyList()); - - public static DoubleGaugeData create(Collection points) { - return new AutoValue_DoubleGaugeData(points); - } - - DoubleGaugeData() {} - - @Override - public abstract Collection getPoints(); -} diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/LongGaugeData.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/LongGaugeData.java deleted file mode 100644 index bd86100bc1b..00000000000 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/LongGaugeData.java +++ /dev/null @@ -1,28 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.metrics.data; - -import com.google.auto.value.AutoValue; -import java.util.Collection; -import java.util.Collections; -import javax.annotation.concurrent.Immutable; - -/** {@link GaugeData} recorded uses {@code long}s. */ -@Immutable -@AutoValue -public abstract class LongGaugeData implements GaugeData { - - static final LongGaugeData EMPTY = LongGaugeData.create(Collections.emptyList()); - - public static LongGaugeData create(Collection points) { - return new AutoValue_LongGaugeData(points); - } - - LongGaugeData() {} - - @Override - public abstract Collection getPoints(); -} diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/MetricData.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/MetricData.java index d1759735646..007e0062402 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/MetricData.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/MetricData.java @@ -6,6 +6,7 @@ package io.opentelemetry.sdk.metrics.data; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; +import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData; import io.opentelemetry.sdk.resources.Resource; import javax.annotation.concurrent.Immutable; @@ -27,7 +28,7 @@ static MetricData createDoubleGauge( String name, String description, String unit, - DoubleGaugeData data) { + GaugeData data) { return MetricDataImpl.create( resource, instrumentationLibraryInfo, @@ -49,7 +50,7 @@ static MetricData createLongGauge( String name, String description, String unit, - LongGaugeData data) { + GaugeData data) { return MetricDataImpl.create( resource, instrumentationLibraryInfo, @@ -231,11 +232,12 @@ default boolean isEmpty() { * @return the {@code DoubleGaugeData} if type is {@link MetricDataType#DOUBLE_GAUGE}, otherwise a * default empty data. */ - default DoubleGaugeData getDoubleGaugeData() { + @SuppressWarnings("unchecked") + default GaugeData getDoubleGaugeData() { if (getType() == MetricDataType.DOUBLE_GAUGE) { - return (DoubleGaugeData) getData(); + return (GaugeData) getData(); } - return DoubleGaugeData.EMPTY; + return ImmutableGaugeData.empty(); } /** @@ -245,11 +247,12 @@ default DoubleGaugeData getDoubleGaugeData() { * @return the {@code LongGaugeData} if type is {@link MetricDataType#LONG_GAUGE}, otherwise a * default empty data. */ - default LongGaugeData getLongGaugeData() { + @SuppressWarnings("unchecked") + default GaugeData getLongGaugeData() { if (getType() == MetricDataType.LONG_GAUGE) { - return (LongGaugeData) getData(); + return (GaugeData) getData(); } - return LongGaugeData.EMPTY; + return ImmutableGaugeData.empty(); } /** diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleLastValueAggregator.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleLastValueAggregator.java index ac4b570ae8b..5503214de36 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleLastValueAggregator.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleLastValueAggregator.java @@ -8,10 +8,10 @@ import io.opentelemetry.api.common.Attributes; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; -import io.opentelemetry.sdk.metrics.data.DoubleGaugeData; import io.opentelemetry.sdk.metrics.data.ExemplarData; import io.opentelemetry.sdk.metrics.data.MetricData; import io.opentelemetry.sdk.metrics.exemplar.ExemplarReservoir; +import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData; import io.opentelemetry.sdk.metrics.internal.descriptor.MetricDescriptor; import io.opentelemetry.sdk.resources.Resource; import java.util.List; @@ -73,7 +73,7 @@ public MetricData toMetricData( descriptor.getName(), descriptor.getDescription(), descriptor.getUnit(), - DoubleGaugeData.create( + ImmutableGaugeData.create( MetricDataUtils.toDoublePointList( accumulationByLabels, (temporality == AggregationTemporality.CUMULATIVE) diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/aggregator/LongLastValueAggregator.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/aggregator/LongLastValueAggregator.java index 692f38a117b..613c0f65552 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/aggregator/LongLastValueAggregator.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/aggregator/LongLastValueAggregator.java @@ -9,9 +9,9 @@ import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; import io.opentelemetry.sdk.metrics.data.ExemplarData; -import io.opentelemetry.sdk.metrics.data.LongGaugeData; import io.opentelemetry.sdk.metrics.data.MetricData; import io.opentelemetry.sdk.metrics.exemplar.ExemplarReservoir; +import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData; import io.opentelemetry.sdk.metrics.internal.descriptor.MetricDescriptor; import io.opentelemetry.sdk.resources.Resource; import java.util.List; @@ -70,7 +70,7 @@ public MetricData toMetricData( descriptor.getName(), descriptor.getDescription(), descriptor.getUnit(), - LongGaugeData.create( + ImmutableGaugeData.create( MetricDataUtils.toLongPointList( accumulationByLabels, (temporality == AggregationTemporality.CUMULATIVE) diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/data/ImmutableGaugeData.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/data/ImmutableGaugeData.java new file mode 100644 index 00000000000..591ec4b2834 --- /dev/null +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/data/ImmutableGaugeData.java @@ -0,0 +1,37 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.sdk.metrics.internal.data; + +import com.google.auto.value.AutoValue; +import io.opentelemetry.sdk.metrics.data.DoublePointData; +import io.opentelemetry.sdk.metrics.data.GaugeData; +import io.opentelemetry.sdk.metrics.data.PointData; +import java.util.Collection; +import java.util.Collections; +import javax.annotation.concurrent.Immutable; + +/** {@link GaugeData} recorded uses {@code double}s. */ +@Immutable +@AutoValue +public abstract class ImmutableGaugeData implements GaugeData { + private static final ImmutableGaugeData EMPTY = + ImmutableGaugeData.create(Collections.emptyList()); + + // Type doesn't matter for an empty list. + @SuppressWarnings("unchecked") + public static ImmutableGaugeData empty() { + return (ImmutableGaugeData) EMPTY; + } + + public static ImmutableGaugeData create(Collection points) { + return new AutoValue_ImmutableGaugeData<>(points); + } + + ImmutableGaugeData() {} + + @Override + public abstract Collection getPoints(); +} diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/data/package-info.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/data/package-info.java new file mode 100644 index 00000000000..e6c6783a4ef --- /dev/null +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/data/package-info.java @@ -0,0 +1,10 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +/** The data format to model metrics for export. */ +@ParametersAreNonnullByDefault +package io.opentelemetry.sdk.metrics.internal.data; + +import javax.annotation.ParametersAreNonnullByDefault; diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/data/MetricDataImplTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/data/MetricDataImplTest.java index 167c1fee11e..27e87ab7c32 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/data/MetricDataImplTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/data/MetricDataImplTest.java @@ -12,6 +12,7 @@ import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.common.Attributes; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; +import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData; import io.opentelemetry.sdk.resources.Resource; import java.util.Arrays; import java.util.Collections; @@ -62,7 +63,7 @@ void metricData_Getters() { "metric_name", "metric_description", "ms", - DoubleGaugeData.create(Collections.emptyList())); + ImmutableGaugeData.create(Collections.emptyList())); assertThat(metricData.getName()).isEqualTo("metric_name"); assertThat(metricData.getDescription()).isEqualTo("metric_description"); assertThat(metricData.getUnit()).isEqualTo("ms"); @@ -87,7 +88,7 @@ void metricData_LongPoints() { "metric_name", "metric_description", "ms", - LongGaugeData.create(Collections.singletonList(LONG_POINT))); + ImmutableGaugeData.create(Collections.singletonList(LONG_POINT))); assertThat(metricData.isEmpty()).isFalse(); assertThat(metricData.getLongGaugeData().getPoints()).containsExactly(LONG_POINT); metricData = @@ -119,7 +120,7 @@ void metricData_DoublePoints() { "metric_name", "metric_description", "ms", - DoubleGaugeData.create(Collections.singletonList(DOUBLE_POINT))); + ImmutableGaugeData.create(Collections.singletonList(DOUBLE_POINT))); assertThat(metricData.isEmpty()).isFalse(); assertThat(metricData.getDoubleGaugeData().getPoints()).containsExactly(DOUBLE_POINT); metricData = @@ -231,7 +232,7 @@ void metricData_GetDefault() { "metric_name", "metric_description", "ms", - DoubleGaugeData.create(Collections.singletonList(DOUBLE_POINT))); + ImmutableGaugeData.create(Collections.singletonList(DOUBLE_POINT))); assertThat(metricData.getDoubleGaugeData().getPoints()).containsExactly(DOUBLE_POINT); assertThat(metricData.getLongGaugeData().getPoints()).isEmpty(); assertThat(metricData.getDoubleSumData().getPoints()).isEmpty(); diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/LongLastValueAggregatorTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/LongLastValueAggregatorTest.java index 57649b9e87b..4f7934ad0c9 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/LongLastValueAggregatorTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/LongLastValueAggregatorTest.java @@ -15,10 +15,10 @@ import io.opentelemetry.sdk.metrics.data.AggregationTemporality; import io.opentelemetry.sdk.metrics.data.ExemplarData; import io.opentelemetry.sdk.metrics.data.LongExemplarData; -import io.opentelemetry.sdk.metrics.data.LongGaugeData; import io.opentelemetry.sdk.metrics.data.LongPointData; import io.opentelemetry.sdk.metrics.data.MetricData; import io.opentelemetry.sdk.metrics.exemplar.ExemplarReservoir; +import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData; import io.opentelemetry.sdk.metrics.internal.descriptor.MetricDescriptor; import io.opentelemetry.sdk.resources.Resource; import java.util.Collections; @@ -120,7 +120,7 @@ void toMetricData() { "name", "description", "unit", - LongGaugeData.create( + ImmutableGaugeData.create( Collections.singletonList( LongPointData.create(2, 100, Attributes.empty(), 10))))); } From c053393c32201f7dea167ca5a366a95815dca69a Mon Sep 17 00:00:00 2001 From: James Moessis Date: Fri, 25 Feb 2022 16:39:50 +1100 Subject: [PATCH 4/4] optimise bucket comparison to fix slow test (#4204) --- .../DoubleExponentialHistogramBuckets.java | 31 ++++++++++++++----- ...bleExponentialHistogramAggregatorTest.java | 7 +++-- 2 files changed, 28 insertions(+), 10 deletions(-) diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleExponentialHistogramBuckets.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleExponentialHistogramBuckets.java index d8d26e9f269..7d24df3641c 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleExponentialHistogramBuckets.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleExponentialHistogramBuckets.java @@ -29,6 +29,7 @@ final class DoubleExponentialHistogramBuckets implements ExponentialHistogramBuc private ExponentialCounter counts; private int scale; private double scaleFactor; + private long totalCount; DoubleExponentialHistogramBuckets( int scale, int maxBuckets, ExponentialCounterFactory counterFactory) { @@ -36,6 +37,7 @@ final class DoubleExponentialHistogramBuckets implements ExponentialHistogramBuc this.counts = counterFactory.newCounter(maxBuckets); this.scale = scale; this.scaleFactor = computeScaleFactor(scale); + this.totalCount = 0; } // For copying @@ -44,6 +46,7 @@ final class DoubleExponentialHistogramBuckets implements ExponentialHistogramBuc this.counts = counterFactory.copy(buckets.counts); this.scale = buckets.scale; this.scaleFactor = buckets.scaleFactor; + this.totalCount = buckets.totalCount; } /** Returns a copy of this bucket. */ @@ -53,6 +56,7 @@ DoubleExponentialHistogramBuckets copy() { /** Resets all counters in this bucket set to zero, but preserves scale. */ public void clear() { + this.totalCount = 0; this.counts.clear(); } @@ -62,7 +66,11 @@ boolean record(double value) { throw new IllegalStateException("Illegal attempted recording of zero at bucket level."); } int index = valueToIndex(value); - return this.counts.increment(index, 1); + boolean recordingSuccessful = this.counts.increment(index, 1); + if (recordingSuccessful) { + totalCount++; + } + return recordingSuccessful; } @Override @@ -92,13 +100,6 @@ public List getBucketCounts() { @Override public long getTotalCount() { - if (counts.isEmpty()) { - return 0; - } - long totalCount = 0; - for (int i = counts.getIndexStart(); i <= counts.getIndexEnd(); i++) { - totalCount += counts.get(i); - } return totalCount; } @@ -219,6 +220,7 @@ private void mergeWith(DoubleExponentialHistogramBuckets other, boolean additive throw new IllegalStateException("Failed to merge exponential histogram buckets."); } } + this.totalCount += sign * other.totalCount; } int getScale() { @@ -306,7 +308,20 @@ public boolean equals(@Nullable Object obj) { * */ private boolean sameBucketCounts(DoubleExponentialHistogramBuckets other) { + if (this.totalCount != other.totalCount) { + return false; + } int min = Math.min(this.counts.getIndexStart(), other.counts.getIndexStart()); + + // This check is so we avoid iterating from Integer.MIN_VALUE. + // In this case, we can assume that those buckets are empty. + // We start iterating from the other bucket index instead. + // They still may be equal as it is possible for another set of buckets + // to be empty but have a higher start index. + if (min == Integer.MIN_VALUE) { + min = Math.max(this.counts.getIndexStart(), other.counts.getIndexStart()); + } + int max = Math.max(this.counts.getIndexEnd(), other.counts.getIndexEnd()); for (int idx = min; idx <= max; idx++) { if (this.counts.get(idx) != other.counts.get(idx)) { diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleExponentialHistogramAggregatorTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleExponentialHistogramAggregatorTest.java index b456914a9bd..8ad511ce579 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleExponentialHistogramAggregatorTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleExponentialHistogramAggregatorTest.java @@ -154,6 +154,7 @@ void testRecordingsAtLimits(DoubleExponentialHistogramAggregator aggregator) { assertThat(bucketCounts.get(bucketCounts.size() - 1)).isEqualTo(1); assertThat(bucketCounts.stream().filter(i -> i == 0).count()) .isEqualTo(bucketCounts.size() - 2); + assertThat(acc.getPositiveBuckets().getTotalCount()).isEqualTo(2); // With 320 buckets allowed, minimum scale is -3 assertThat(acc.getScale()).isEqualTo(-3); @@ -263,8 +264,8 @@ void diffAccumulation() { // Note: This test relies on implementation details of ExponentialCounter, specifically it // assumes that an Array of all zeros is the same as an empty counter array for negative // buckets. - assertThat(aggregator.diff(previousAccumulation, nextAccumulation)) - .isEqualTo(getTestAccumulation(exemplars, 0, 1)); + ExponentialHistogramAccumulation diff = aggregator.diff(previousAccumulation, nextAccumulation); + assertThat(diff).isEqualTo(getTestAccumulation(exemplars, 0, 1)); } @Test @@ -403,6 +404,7 @@ void testInsert1M() { ExponentialHistogramAccumulation acc = handle.accumulateThenReset(Attributes.empty()); assertThat(Objects.requireNonNull(acc).getScale()).isEqualTo(4); assertThat(acc.getPositiveBuckets().getBucketCounts().size()).isEqualTo(320); + assertThat(acc.getPositiveBuckets().getTotalCount()).isEqualTo(n); } @Test @@ -424,6 +426,7 @@ void testDownScale() { assertThat(acc.getSum()).isEqualTo(23.5); assertThat(buckets.getOffset()).isEqualTo(-1); assertThat(buckets.getBucketCounts()).isEqualTo(Arrays.asList(1L, 1L, 1L, 1L, 0L, 1L)); + assertThat(buckets.getTotalCount()).isEqualTo(5); } @Test