open-telemetry
/
opentelemetry-java
mirror of https://github.com/open-telemetry/opentelemetry-java.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Extract SummaryData interface for DoubleSummaryData (#4224) 

* Extract SummaryData interface for DoubleSummaryData

* ValueAtQuantile too

* javadoc
This commit is contained in:
Anuraag Agrawal 2022-03-04 17:20:21 +09:00 committed by GitHub
parent 17265d0b0d
commit cb80383df8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
25 changed files with 253 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
exporters/logging/src/test/java/io/opentelemetry/exporter/logging/LoggingMetricExporterTest.java
View File

@ -13,12 +13,12 @@ import io.opentelemetry.internal.testing.slf4j.SuppressLogger;
import io.opentelemetry.sdk.common.InstrumentationLibraryInfo;
import io.opentelemetry.sdk.metrics.data.AggregationTemporality;
import io.opentelemetry.sdk.metrics.data.DoublePointData;
import io.opentelemetry.sdk.metrics.data.DoubleSummaryData;
import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
import io.opentelemetry.sdk.metrics.data.LongPointData;
import io.opentelemetry.sdk.metrics.data.MetricData;
import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSumData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryPointData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableValueAtPercentile;
import io.opentelemetry.sdk.resources.Resource;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
@ -69,17 +69,17 @@ class LoggingMetricExporterTest {
"measureOne",
"A summarized test measure",
"ms",
DoubleSummaryData.create(
ImmutableSummaryData.create(
Collections.singletonList(
DoubleSummaryPointData.create(
ImmutableSummaryPointData.create(
nowEpochNanos,
nowEpochNanos + 245,
Attributes.of(stringKey("a"), "b", stringKey("c"), "d"),
1010,
50000,
Arrays.asList(
ValueAtPercentile.create(0.0, 25),
ValueAtPercentile.create(100.0, 433)))))),
ImmutableValueAtPercentile.create(0.0, 25),
ImmutableValueAtPercentile.create(100.0, 433)))))),
MetricData.createLongSum(
resource,
instrumentationLibraryInfo,

2
exporters/otlp/common/src/main/java/io/opentelemetry/exporter/internal/otlp/metrics/MetricMarshaler.java
View File

@ -49,7 +49,7 @@ final class MetricMarshaler extends MarshalerWithSize {
dataField = Metric.SUM;
break;
case SUMMARY:
dataMarshaler = SummaryMarshaler.create(metric.getDoubleSummaryData());
dataMarshaler = SummaryMarshaler.create(metric.getSummaryData());
dataField = Metric.SUMMARY;
break;
case HISTOGRAM:

8
exporters/otlp/common/src/main/java/io/opentelemetry/exporter/internal/otlp/metrics/SummaryDataPointMarshaler.java
View File

@ -10,7 +10,7 @@ import io.opentelemetry.exporter.internal.marshal.MarshalerWithSize;
import io.opentelemetry.exporter.internal.marshal.Serializer;
import io.opentelemetry.exporter.internal.otlp.KeyValueMarshaler;
import io.opentelemetry.proto.metrics.v1.internal.SummaryDataPoint;
import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
import io.opentelemetry.sdk.metrics.data.SummaryPointData;
import java.io.IOException;
import java.util.Collection;
@ -22,16 +22,16 @@ final class SummaryDataPointMarshaler extends MarshalerWithSize {
private final ValueAtQuantileMarshaler[] quantileValues;
private final KeyValueMarshaler[] attributes;
static SummaryDataPointMarshaler[] createRepeated(Collection<DoubleSummaryPointData> points) {
static SummaryDataPointMarshaler[] createRepeated(Collection<SummaryPointData> points) {
SummaryDataPointMarshaler[] marshalers = new SummaryDataPointMarshaler[points.size()];
int index = 0;
for (DoubleSummaryPointData point : points) {
for (SummaryPointData point : points) {
marshalers[index++] = SummaryDataPointMarshaler.create(point);
}
return marshalers;
}
static SummaryDataPointMarshaler create(DoubleSummaryPointData point) {
static SummaryDataPointMarshaler create(SummaryPointData point) {
ValueAtQuantileMarshaler[] quantileMarshalers =
ValueAtQuantileMarshaler.createRepeated(point.getPercentileValues());
KeyValueMarshaler[] attributeMarshalers =

4
exporters/otlp/common/src/main/java/io/opentelemetry/exporter/internal/otlp/metrics/SummaryMarshaler.java
View File

@ -9,13 +9,13 @@ import io.opentelemetry.exporter.internal.marshal.MarshalerUtil;
import io.opentelemetry.exporter.internal.marshal.MarshalerWithSize;
import io.opentelemetry.exporter.internal.marshal.Serializer;
import io.opentelemetry.proto.metrics.v1.internal.Summary;
import io.opentelemetry.sdk.metrics.data.DoubleSummaryData;
import io.opentelemetry.sdk.metrics.data.SummaryData;
import java.io.IOException;
final class SummaryMarshaler extends MarshalerWithSize {
private final SummaryDataPointMarshaler[] dataPoints;
static SummaryMarshaler create(DoubleSummaryData summary) {
static SummaryMarshaler create(SummaryData summary) {
SummaryDataPointMarshaler[] dataPointMarshalers =
SummaryDataPointMarshaler.createRepeated(summary.getPoints());
return new SummaryMarshaler(dataPointMarshalers);

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

@ -43,18 +43,19 @@ 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.DoublePointData;
import io.opentelemetry.sdk.metrics.data.DoubleSummaryData;
import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
import io.opentelemetry.sdk.metrics.data.HistogramPointData;
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.PointData;
import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
import io.opentelemetry.sdk.metrics.data.SummaryPointData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramPointData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSumData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryPointData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableValueAtPercentile;
import io.opentelemetry.sdk.metrics.internal.data.exponentialhistogram.ExponentialHistogramBuckets;
import io.opentelemetry.sdk.metrics.internal.data.exponentialhistogram.ExponentialHistogramData;
import io.opentelemetry.sdk.metrics.internal.data.exponentialhistogram.ExponentialHistogramPointData;
@ -271,13 +272,13 @@ class MetricsRequestMarshalerTest {
assertThat(
toSummaryDataPoints(
singletonList(
DoubleSummaryPointData.create(
ImmutableSummaryPointData.create(
123,
456,
KV_ATTR,
5,
14.2,
singletonList(ValueAtPercentile.create(0.0, 1.1))))))
singletonList(ImmutableValueAtPercentile.create(0.0, 1.1))))))
.containsExactly(
SummaryDataPoint.newBuilder()
.setStartTimeUnixNano(123)
@ -296,17 +297,17 @@ class MetricsRequestMarshalerTest {
assertThat(
toSummaryDataPoints(
ImmutableList.of(
DoubleSummaryPointData.create(
ImmutableSummaryPointData.create(
123, 456, Attributes.empty(), 7, 15.3, Collections.emptyList()),
DoubleSummaryPointData.create(
ImmutableSummaryPointData.create(
321,
654,
KV_ATTR,
9,
18.3,
ImmutableList.of(
ValueAtPercentile.create(0.0, 1.1),
ValueAtPercentile.create(100.0, 20.3))))))
ImmutableValueAtPercentile.create(0.0, 1.1),
ImmutableValueAtPercentile.create(100.0, 20.3))))))
.containsExactly(
SummaryDataPoint.newBuilder()
.setStartTimeUnixNano(123)
@ -679,17 +680,17 @@ class MetricsRequestMarshalerTest {
"name",
"description",
"1",
DoubleSummaryData.create(
ImmutableSummaryData.create(
singletonList(
DoubleSummaryPointData.create(
ImmutableSummaryPointData.create(
123,
456,
KV_ATTR,
5,
33d,
ImmutableList.of(
ValueAtPercentile.create(0, 1.1),
ValueAtPercentile.create(100.0, 20.3))))))))
ImmutableValueAtPercentile.create(0, 1.1),
ImmutableValueAtPercentile.create(100.0, 20.3))))))))
.isEqualTo(
Metric.newBuilder()
.setName("name")
@ -959,8 +960,7 @@ class MetricsRequestMarshalerTest {
.collect(Collectors.toList());
}
private static List<SummaryDataPoint> toSummaryDataPoints(
Collection<DoubleSummaryPointData> points) {
private static List<SummaryDataPoint> toSummaryDataPoints(Collection<SummaryPointData> points) {
return points.stream()
.map(
point ->

9
exporters/prometheus/src/main/java/io/opentelemetry/exporter/prometheus/MetricAdapter.java
View File

@ -12,7 +12,6 @@ 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.DoublePointData;
import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
import io.opentelemetry.sdk.metrics.data.ExemplarData;
import io.opentelemetry.sdk.metrics.data.HistogramPointData;
import io.opentelemetry.sdk.metrics.data.LongExemplarData;
@ -21,6 +20,7 @@ import io.opentelemetry.sdk.metrics.data.MetricData;
import io.opentelemetry.sdk.metrics.data.MetricDataType;
import io.opentelemetry.sdk.metrics.data.PointData;
import io.opentelemetry.sdk.metrics.data.SumData;
import io.opentelemetry.sdk.metrics.data.SummaryPointData;
import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
import io.opentelemetry.sdk.metrics.internal.data.exponentialhistogram.ExponentialHistogramData;
import io.prometheus.client.Collector;
@ -149,8 +149,7 @@ final class MetricAdapter {
longPoint.getEpochNanos()));
break;
case SUMMARY:
addSummarySamples(
(DoubleSummaryPointData) pointData, name, labelNames, labelValues, samples);
addSummarySamples((SummaryPointData) pointData, name, labelNames, labelValues, samples);
break;
case HISTOGRAM:
addHistogramSamples(
@ -164,7 +163,7 @@ final class MetricAdapter {
}
private static void addSummarySamples(
DoubleSummaryPointData doubleSummaryPoint,
SummaryPointData doubleSummaryPoint,
String name,
List<String> labelNames,
List<String> labelValues,
@ -291,7 +290,7 @@ final class MetricAdapter {
case LONG_SUM:
return metricData.getLongSumData().getPoints();
case SUMMARY:
return metricData.getDoubleSummaryData().getPoints();
return metricData.getSummaryData().getPoints();
case HISTOGRAM:
return metricData.getHistogramData().getPoints();
case EXPONENTIAL_HISTOGRAM:

7
exporters/prometheus/src/main/java/io/opentelemetry/exporter/prometheus/Serializer.java
View File

@ -26,7 +26,6 @@ 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.DoublePointData;
import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
import io.opentelemetry.sdk.metrics.data.ExemplarData;
import io.opentelemetry.sdk.metrics.data.HistogramPointData;
import io.opentelemetry.sdk.metrics.data.LongExemplarData;
@ -34,6 +33,7 @@ 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.metrics.data.PointData;
import io.opentelemetry.sdk.metrics.data.SummaryPointData;
import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
import java.io.BufferedWriter;
import java.io.IOException;
@ -152,7 +152,7 @@ abstract class Serializer {
writeHistogram(writer, name, (HistogramPointData) point);
break;
case SUMMARY:
writeSummary(writer, name, (DoubleSummaryPointData) point);
writeSummary(writer, name, (SummaryPointData) point);
break;
case EXPONENTIAL_HISTOGRAM:
throw new IllegalArgumentException("Can't happen");
@ -188,8 +188,7 @@ abstract class Serializer {
}
}
private void writeSummary(Writer writer, String name, DoubleSummaryPointData point)
throws IOException {
private void writeSummary(Writer writer, String name, SummaryPointData point) throws IOException {
writePoint(
writer, name + "_count", point.getCount(), point.getAttributes(), point.getEpochNanos());
writePoint(writer, name + "_sum", point.getSum(), point.getAttributes(), point.getEpochNanos());

26
exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/MetricAdapterTest.java
View File

@ -16,17 +16,17 @@ 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.DoublePointData;
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.LongPointData;
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.metrics.internal.data.ImmutableHistogramData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramPointData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSumData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryPointData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableValueAtPercentile;
import io.opentelemetry.sdk.resources.Resource;
import io.prometheus.client.Collector;
import io.prometheus.client.Collector.MetricFamilySamples;
@ -182,17 +182,17 @@ class MetricAdapterTest {
"instrument.name",
"description",
"1",
DoubleSummaryData.create(
ImmutableSummaryData.create(
Collections.singletonList(
DoubleSummaryPointData.create(
ImmutableSummaryPointData.create(
1633947011000000000L,
1633950672000000000L,
KP_VP_ATTR,
5,
7,
Arrays.asList(
ValueAtPercentile.create(0.9, 0.1),
ValueAtPercentile.create(0.99, 0.3))))));
ImmutableValueAtPercentile.create(0.9, 0.1),
ImmutableValueAtPercentile.create(0.99, 0.3))))));
private static final MetricData HISTOGRAM =
MetricData.createDoubleHistogram(
Resource.create(Attributes.of(stringKey("kr"), "vr")),
@ -430,13 +430,13 @@ class MetricAdapterTest {
"full_name",
MetricDataType.SUMMARY,
ImmutableList.of(
DoubleSummaryPointData.create(
ImmutableSummaryPointData.create(
1633939689000000000L,
1633943350000000000L,
KP_VP_ATTR,
9,
18.3,
ImmutableList.of(ValueAtPercentile.create(0.9, 1.1))))))
ImmutableList.of(ImmutableValueAtPercentile.create(0.9, 1.1))))))
.containsExactly(
new Sample(
"full_name_count",
@ -465,22 +465,22 @@ class MetricAdapterTest {
"full_name",
MetricDataType.SUMMARY,
ImmutableList.of(
DoubleSummaryPointData.create(
ImmutableSummaryPointData.create(
1633947011000000000L,
1633950672000000000L,
Attributes.empty(),
7,
15.3,
Collections.emptyList()),
DoubleSummaryPointData.create(
ImmutableSummaryPointData.create(
1633939689000000000L,
1633943350000000000L,
KP_VP_ATTR,
9,
18.3,
ImmutableList.of(
ValueAtPercentile.create(0.9, 1.1),
ValueAtPercentile.create(0.99, 12.3))))))
ImmutableValueAtPercentile.create(0.9, 1.1),
ImmutableValueAtPercentile.create(0.99, 12.3))))))
.containsExactly(
new Sample(
"full_name_count",

14
exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/SerializerTest.java
View File

@ -15,16 +15,16 @@ 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.DoublePointData;
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.LongPointData;
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.metrics.internal.data.ImmutableHistogramData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramPointData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSumData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryPointData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableValueAtPercentile;
import io.opentelemetry.sdk.resources.Resource;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
@ -172,17 +172,17 @@ class SerializerTest {
"instrument.name",
"description",
"1",
DoubleSummaryData.create(
ImmutableSummaryData.create(
Collections.singletonList(
DoubleSummaryPointData.create(
ImmutableSummaryPointData.create(
1633947011000000000L,
1633950672000000000L,
KP_VP_ATTR,
5,
7,
Arrays.asList(
ValueAtPercentile.create(0.9, 0.1),
ValueAtPercentile.create(0.99, 0.3))))));
ImmutableValueAtPercentile.create(0.9, 0.1),
ImmutableValueAtPercentile.create(0.99, 0.3))))));
private static final MetricData HISTOGRAM =
MetricData.createDoubleHistogram(
Resource.create(Attributes.of(stringKey("kr"), "vr")),

22
opencensus-shim/src/main/java/io/opentelemetry/opencensusshim/internal/metrics/MetricAdapter.java
View File

@ -24,8 +24,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.DoublePointData;
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.GaugeData;
import io.opentelemetry.sdk.metrics.data.HistogramData;
@ -33,11 +31,16 @@ import io.opentelemetry.sdk.metrics.data.HistogramPointData;
import io.opentelemetry.sdk.metrics.data.LongPointData;
import io.opentelemetry.sdk.metrics.data.MetricData;
import io.opentelemetry.sdk.metrics.data.SumData;
import io.opentelemetry.sdk.metrics.data.SummaryData;
import io.opentelemetry.sdk.metrics.data.SummaryPointData;
import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramPointData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSumData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryPointData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableValueAtPercentile;
import io.opentelemetry.sdk.resources.Resource;
import java.util.ArrayList;
import java.util.Collection;
@ -167,8 +170,8 @@ public final class MetricAdapter {
AggregationTemporality.DELTA, convertHistogramPoints(censusMetric));
}
static DoubleSummaryData convertSummary(Metric censusMetric) {
return DoubleSummaryData.create(convertSummaryPoints(censusMetric));
static SummaryData convertSummary(Metric censusMetric) {
return ImmutableSummaryData.create(convertSummaryPoints(censusMetric));
}
static Collection<LongPointData> convertLongPoints(Metric censusMetric) {
@ -243,14 +246,14 @@ public final class MetricAdapter {
return result;
}
static Collection<DoubleSummaryPointData> convertSummaryPoints(Metric censusMetric) {
List<DoubleSummaryPointData> result = new ArrayList<>();
static Collection<SummaryPointData> convertSummaryPoints(Metric censusMetric) {
List<SummaryPointData> result = new ArrayList<>();
for (TimeSeries ts : censusMetric.getTimeSeriesList()) {
long startTimestamp = mapTimestamp(ts.getStartTimestamp());
Attributes attributes =
mapAttributes(censusMetric.getMetricDescriptor().getLabelKeys(), ts.getLabelValues());
for (Point point : ts.getPoints()) {
DoubleSummaryPointData otelPoint =
SummaryPointData otelPoint =
point
.getValue()
.match(
@ -258,7 +261,7 @@ public final class MetricAdapter {
lv -> null,
distribution -> null,
summary ->
DoubleSummaryPointData.create(
ImmutableSummaryPointData.create(
startTimestamp,
mapTimestamp(point.getTimestamp()),
attributes,
@ -369,7 +372,8 @@ public final class MetricAdapter {
List<Summary.Snapshot.ValueAtPercentile> valueAtPercentiles) {
List<ValueAtPercentile> result = new ArrayList<>(valueAtPercentiles.size());
for (Summary.Snapshot.ValueAtPercentile censusValue : valueAtPercentiles) {
result.add(ValueAtPercentile.create(censusValue.getPercentile(), censusValue.getValue()));
result.add(
ImmutableValueAtPercentile.create(censusValue.getPercentile(), censusValue.getValue()));
}
return result;
}

4
opencensus-shim/src/test/java/io/opentelemetry/opencensusshim/internal/metrics/MetricAdapterTest.java
View File

@ -25,7 +25,7 @@ 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.metrics.internal.data.ImmutableValueAtPercentile;
import io.opentelemetry.sdk.resources.Resource;
import java.util.Arrays;
import java.util.Collections;
@ -301,7 +301,7 @@ class MetricAdapterTest {
.hasAttributes(Attributes.of(AttributeKey.stringKey("key1"), "value1"))
.hasCount(10)
.hasSum(5)
.hasPercentileValues(ValueAtPercentile.create(1.0, 200)));
.hasPercentileValues(ImmutableValueAtPercentile.create(1.0, 200)));
}
@Test

29
sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/DoubleSummaryDataAssert.java
View File

@ -1,29 +0,0 @@
/*
* Copyright The OpenTelemetry Authors
* SPDX-License-Identifier: Apache-2.0
*/
package io.opentelemetry.sdk.testing.assertj;
import io.opentelemetry.sdk.metrics.data.DoubleSummaryData;
import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
import org.assertj.core.api.AbstractAssert;
import org.assertj.core.api.AbstractIterableAssert;
import org.assertj.core.api.Assertions;
/** Assert on a {@link DoubleSummaryData} metric. */
public class DoubleSummaryDataAssert
extends AbstractAssert<DoubleSummaryDataAssert, DoubleSummaryData> {
protected DoubleSummaryDataAssert(DoubleSummaryData actual) {
super(actual, DoubleSummaryDataAssert.class);
}
/** Returns convenience API to assert against the {@code points} field. */
public AbstractIterableAssert<
?, ? extends Iterable<? extends DoubleSummaryPointData>, DoubleSummaryPointData, ?>
points() {
isNotNull();
return Assertions.assertThat(actual.getPoints());
}
}

19
sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/MetricAssertions.java
View File

@ -6,8 +6,6 @@
package io.opentelemetry.sdk.testing.assertj;
import io.opentelemetry.sdk.metrics.data.DoublePointData;
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.GaugeData;
import io.opentelemetry.sdk.metrics.data.HistogramData;
@ -16,6 +14,8 @@ import io.opentelemetry.sdk.metrics.data.LongPointData;
import io.opentelemetry.sdk.metrics.data.MetricData;
import io.opentelemetry.sdk.metrics.data.PointData;
import io.opentelemetry.sdk.metrics.data.SumData;
import io.opentelemetry.sdk.metrics.data.SummaryData;
import io.opentelemetry.sdk.metrics.data.SummaryPointData;
import io.opentelemetry.sdk.metrics.internal.data.exponentialhistogram.ExponentialHistogramBuckets;
import io.opentelemetry.sdk.metrics.internal.data.exponentialhistogram.ExponentialHistogramPointData;
import org.assertj.core.api.Assertions;
@ -28,6 +28,9 @@ public final class MetricAssertions extends Assertions {
}
/** Returns an assertion for {@link GaugeData}. */
// There is no real use case for passing in a GaugeData that is a lambda, if for some reason it is
// desired a cast will still work.
@SuppressWarnings("FunctionalInterfaceClash")
public static <T extends PointData> GaugeAssert<T> assertThat(GaugeData<T> metric) {
return new GaugeAssert<>(metric);
}
@ -37,9 +40,9 @@ public final class MetricAssertions extends Assertions {
return new HistogramAssert(metric);
}
/** Returns an assertion for {@link DoubleSummaryData}. */
public static DoubleSummaryDataAssert assertThat(DoubleSummaryData metric) {
return new DoubleSummaryDataAssert(metric);
/** Returns an assertion for {@link SummaryData}. */
public static SummaryDataAssert assertThat(SummaryData metric) {
return new SummaryDataAssert(metric);
}
/** Returns an assertion for {@link HistogramPointData}. */
@ -47,9 +50,9 @@ public final class MetricAssertions extends Assertions {
return new HistogramPointDataAssert(point);
}
/** Returns an assertion for {@link DoubleSummaryPointData}. */
public static DoubleSummaryPointDataAssert assertThat(DoubleSummaryPointData point) {
return new DoubleSummaryPointDataAssert(point);
/** Returns an assertion for {@link SummaryPointData}. */
public static SummaryPointDataAssert assertThat(SummaryPointData point) {
return new SummaryPointDataAssert(point);
}
/** Returns an assertion for {@link ExponentialHistogramPointData}. */

4
sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/MetricDataAssert.java
View File

@ -207,7 +207,7 @@ public class MetricDataAssert extends AbstractAssert<MetricDataAssert, MetricDat
*
* @return convenience API to assert against the {@code DoubleSummaryData}.
*/
public DoubleSummaryDataAssert hasDoubleSummary() {
public SummaryDataAssert hasDoubleSummary() {
isNotNull();
if (actual.getType() != MetricDataType.SUMMARY) {
failWithActualExpectedAndMessage(
@ -217,6 +217,6 @@ public class MetricDataAssert extends AbstractAssert<MetricDataAssert, MetricDat
MetricDataType.SUMMARY,
actual.getType());
}
return new DoubleSummaryDataAssert(actual.getDoubleSummaryData());
return new SummaryDataAssert(actual.getSummaryData());
}
}

28
sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/SummaryDataAssert.java Normal file
View File

@ -0,0 +1,28 @@
/*
* Copyright The OpenTelemetry Authors
* SPDX-License-Identifier: Apache-2.0
*/
package io.opentelemetry.sdk.testing.assertj;
import io.opentelemetry.sdk.metrics.data.SummaryData;
import io.opentelemetry.sdk.metrics.data.SummaryPointData;
import org.assertj.core.api.AbstractAssert;
import org.assertj.core.api.AbstractIterableAssert;
import org.assertj.core.api.Assertions;
/** Assert on a {@link SummaryData} metric. */
public class SummaryDataAssert extends AbstractAssert<SummaryDataAssert, SummaryData> {
protected SummaryDataAssert(SummaryData actual) {
super(actual, SummaryDataAssert.class);
}
/** Returns convenience API to assert against the {@code points} field. */
public AbstractIterableAssert<
?, ? extends Iterable<? extends SummaryPointData>, SummaryPointData, ?>
points() {
isNotNull();
return Assertions.assertThat(actual.getPoints());
}
}

16
sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/DoubleSummaryPointDataAssert.java → sdk/metrics-testing/src/main/java/io/opentelemetry/sdk/testing/assertj/SummaryPointDataAssert.java
View File

@ -5,33 +5,33 @@
package io.opentelemetry.sdk.testing.assertj;
import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
import io.opentelemetry.sdk.metrics.data.SummaryPointData;
import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
import org.assertj.core.api.Assertions;
/** Asserts for (deprecated) Summary points. */
public class DoubleSummaryPointDataAssert
extends AbstractPointDataAssert<DoubleSummaryPointDataAssert, DoubleSummaryPointData> {
protected DoubleSummaryPointDataAssert(DoubleSummaryPointData actual) {
super(actual, DoubleSummaryPointDataAssert.class);
public class SummaryPointDataAssert
extends AbstractPointDataAssert<SummaryPointDataAssert, SummaryPointData> {
protected SummaryPointDataAssert(SummaryPointData actual) {
super(actual, SummaryPointDataAssert.class);
}
/** Ensure the summary has seen the expected count of measurements. */
public DoubleSummaryPointDataAssert hasCount(long expected) {
public SummaryPointDataAssert hasCount(long expected) {
isNotNull();
Assertions.assertThat(actual.getCount()).as("count").isEqualTo(expected);
return this;
}
/** Ensure the summary has the expected sum across all observed measurements. */
public DoubleSummaryPointDataAssert hasSum(double expected) {
public SummaryPointDataAssert hasSum(double expected) {
isNotNull();
Assertions.assertThat(actual.getSum()).as("sum").isEqualTo(expected);
return this;
}
/** Ensure the summary has exactly, in any order, the given percentile values. */
public DoubleSummaryPointDataAssert hasPercentileValues(ValueAtPercentile... percentiles) {
public SummaryPointDataAssert hasPercentileValues(ValueAtPercentile... percentiles) {
isNotNull();
Assertions.assertThat(actual.getPercentileValues()).containsExactlyInAnyOrder(percentiles);
return this;

16
sdk/metrics-testing/src/test/java/io/opentelemetry/sdk/testing/assertj/MetricAssertionsTest.java
View File

@ -17,17 +17,19 @@ 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.DoublePointData;
import io.opentelemetry.sdk.metrics.data.DoubleSummaryData;
import io.opentelemetry.sdk.metrics.data.DoubleSummaryPointData;
import io.opentelemetry.sdk.metrics.data.HistogramPointData;
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.SummaryPointData;
import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramPointData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSumData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryPointData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableValueAtPercentile;
import io.opentelemetry.sdk.metrics.internal.data.exponentialhistogram.ExponentialHistogramData;
import io.opentelemetry.sdk.resources.Resource;
import java.util.Arrays;
@ -94,7 +96,7 @@ public class MetricAssertionsTest {
/* name= */ "summary",
/* description= */ "description",
/* unit= */ "unit",
DoubleSummaryData.create(
ImmutableSummaryData.create(
// Points
Collections.emptyList()));
@ -207,10 +209,10 @@ public class MetricAssertionsTest {
private static final LongPointData LONG_POINT_DATA_WITH_EXEMPLAR =
LongPointData.create(1, 2, Attributes.empty(), 3, Collections.singletonList(LONG_EXEMPLAR));
private static final ValueAtPercentile PERCENTILE_VALUE = ValueAtPercentile.create(0, 1);
private static final ValueAtPercentile PERCENTILE_VALUE = ImmutableValueAtPercentile.create(0, 1);
private static final DoubleSummaryPointData DOUBLE_SUMMARY_POINT_DATA =
DoubleSummaryPointData.create(
private static final SummaryPointData DOUBLE_SUMMARY_POINT_DATA =
ImmutableSummaryPointData.create(
1, 2, Attributes.empty(), 1, 2, Collections.singletonList(PERCENTILE_VALUE));
private static final HistogramPointData DOUBLE_HISTOGRAM_POINT_DATA =
@ -476,7 +478,7 @@ public class MetricAssertionsTest {
assertThatThrownBy(
() ->
assertThat(DOUBLE_SUMMARY_POINT_DATA)
.hasPercentileValues(ValueAtPercentile.create(1, 1)))
.hasPercentileValues(ImmutableValueAtPercentile.create(1, 1)))
.isInstanceOf(AssertionError.class);
}

9
sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/MetricData.java
View File

@ -9,6 +9,7 @@ import io.opentelemetry.sdk.common.InstrumentationLibraryInfo;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSumData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
import io.opentelemetry.sdk.metrics.internal.data.exponentialhistogram.ExponentialHistogramData;
import io.opentelemetry.sdk.resources.Resource;
import javax.annotation.concurrent.Immutable;
@ -119,7 +120,7 @@ public interface MetricData {
String name,
String description,
String unit,
DoubleSummaryData data) {
SummaryData data) {
return MetricDataImpl.create(
resource,
instrumentationLibraryInfo,
@ -295,11 +296,11 @@ public interface MetricData {
* @return the {@code DoubleSummaryData} if type is {@link MetricDataType#SUMMARY}, otherwise a
* default * empty data.
*/
default DoubleSummaryData getDoubleSummaryData() {
default SummaryData getSummaryData() {
if (getType() == MetricDataType.SUMMARY) {
return (DoubleSummaryData) getData();
return (SummaryData) getData();
}
return DoubleSummaryData.EMPTY;
return ImmutableSummaryData.empty();
}
/**

14
sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/SummaryData.java Normal file
View File

@ -0,0 +1,14 @@
/*
* Copyright The OpenTelemetry Authors
* SPDX-License-Identifier: Apache-2.0
*/
package io.opentelemetry.sdk.metrics.data;
/**
* A summary metric.
*
* <p>See:
* https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/datamodel.md#summary
*/
public interface SummaryData extends Data<SummaryPointData> {}

33
sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/SummaryPointData.java Normal file
View File

@ -0,0 +1,33 @@
/*
* Copyright The OpenTelemetry Authors
* SPDX-License-Identifier: Apache-2.0
*/
package io.opentelemetry.sdk.metrics.data;
import java.util.List;
/** A single data point that summarizes the values in a time series of numeric values. */
public interface SummaryPointData extends PointData {
/**
* The number of values that are being summarized.
*
* @return the number of values that are being summarized.
*/
long getCount();
/**
* The sum of all the values that are being summarized.
*
* @return the sum of the values that are being summarized.
*/
double getSum();
/**
* Percentile values in the summarization. Note: a percentile 0.0 represents the minimum value in
* the distribution.
*
* @return the percentiles values.
*/
List<ValueAtPercentile> getPercentileValues();
}

18
sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/ValueAtPercentile.java
View File

@ -5,29 +5,19 @@
package io.opentelemetry.sdk.metrics.data;
import com.google.auto.value.AutoValue;
import javax.annotation.concurrent.Immutable;
@Immutable
@AutoValue
public abstract class ValueAtPercentile {
public static ValueAtPercentile create(double percentile, double value) {
return new AutoValue_ValueAtPercentile(percentile, value);
}
ValueAtPercentile() {}
/** A value within a summary. */
public interface ValueAtPercentile {
/**
* The percentile of a distribution. Must be in the interval [0.0, 100.0].
*
* @return the percentile.
*/
public abstract double getPercentile();
double getPercentile();
/**
* The value at the given percentile of a distribution.
*
* @return the value at the percentile.
*/
public abstract double getValue();
double getValue();
}

25
sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/DoubleSummaryData.java → sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/data/ImmutableSummaryData.java
View File

@ -3,9 +3,11 @@
* SPDX-License-Identifier: Apache-2.0
*/
package io.opentelemetry.sdk.metrics.data;
package io.opentelemetry.sdk.metrics.internal.data;
import com.google.auto.value.AutoValue;
import io.opentelemetry.sdk.metrics.data.SummaryData;
import io.opentelemetry.sdk.metrics.data.SummaryPointData;
import java.util.Collection;
import java.util.Collections;
import javax.annotation.concurrent.Immutable;
@ -21,19 +23,24 @@ import javax.annotation.concurrent.Immutable;
*
* <p>Summary is considered a legacy metric type, and shouldn't be produced (by default) from
* instruments.
*
* <p>This class is internal and is hence not for public use. Its APIs are unstable and can change
* at any time
*/
@Immutable
@AutoValue
public abstract class DoubleSummaryData implements Data<DoubleSummaryPointData> {
public abstract class ImmutableSummaryData implements SummaryData {
static final DoubleSummaryData EMPTY = DoubleSummaryData.create(Collections.emptyList());
private static final ImmutableSummaryData EMPTY =
ImmutableSummaryData.create(Collections.emptyList());
DoubleSummaryData() {}
public static DoubleSummaryData create(Collection<DoubleSummaryPointData> points) {
return new AutoValue_DoubleSummaryData(points);
public static ImmutableSummaryData empty() {
return EMPTY;
}
@Override
public abstract Collection<DoubleSummaryPointData> getPoints();
ImmutableSummaryData() {}
public static ImmutableSummaryData create(Collection<SummaryPointData> points) {
return new AutoValue_ImmutableSummaryData(points);
}
}

42
sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/data/DoubleSummaryPointData.java → sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/data/ImmutableSummaryPointData.java
View File

@ -3,23 +3,27 @@
* SPDX-License-Identifier: Apache-2.0
*/
package io.opentelemetry.sdk.metrics.data;
package io.opentelemetry.sdk.metrics.internal.data;
import com.google.auto.value.AutoValue;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.sdk.metrics.data.SummaryPointData;
import io.opentelemetry.sdk.metrics.data.ValueAtPercentile;
import java.util.Collections;
import java.util.List;
import javax.annotation.concurrent.Immutable;
/**
* SummaryPoint is a single data point that summarizes the values in a time series of numeric
* values.
* A single data point that summarizes the values in a time series of numeric values.
*
* <p>This class is internal and is hence not for public use. Its APIs are unstable and can change
* at any time
*/
@Immutable
@AutoValue
public abstract class DoubleSummaryPointData implements PointData {
public abstract class ImmutableSummaryPointData implements SummaryPointData {
/**
* Creates a {@link DoubleSummaryPointData}.
* Creates a {@link SummaryPointData}.
*
* @param startEpochNanos (optional) The starting time for the period where this point was
* sampled.
@ -29,14 +33,14 @@ public abstract class DoubleSummaryPointData implements PointData {
* @param sum The sum of measuremnts being sumarized.
* @param percentileValues Calculations of percentile values from measurements.
*/
public static DoubleSummaryPointData create(
public static ImmutableSummaryPointData create(
long startEpochNanos,
long epochNanos,
Attributes attributes,
long count,
double sum,
List<ValueAtPercentile> percentileValues) {
return new AutoValue_DoubleSummaryPointData(
return new AutoValue_ImmutableSummaryPointData(
startEpochNanos,
epochNanos,
attributes,
@ -46,27 +50,5 @@ public abstract class DoubleSummaryPointData implements PointData {
percentileValues);
}
DoubleSummaryPointData() {}
/**
* The number of values that are being summarized.
*
* @return the number of values that are being summarized.
*/
public abstract long getCount();
/**
* The sum of all the values that are being summarized.
*
* @return the sum of the values that are being summarized.
*/
public abstract double getSum();
/**
* Percentile values in the summarization. Note: a percentile 0.0 represents the minimum value in
* the distribution.
*
* @return the percentiles values.
*/
public abstract List<ValueAtPercentile> getPercentileValues();
ImmutableSummaryPointData() {}
}

26
sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/data/ImmutableValueAtPercentile.java Normal file
View File

@ -0,0 +1,26 @@
/*
* 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.ValueAtPercentile;
import javax.annotation.concurrent.Immutable;
/**
* A summary metric value.
*
* <p>This class is internal and is hence not for public use. Its APIs are unstable and can change
* at any time
*/
@Immutable
@AutoValue
public abstract class ImmutableValueAtPercentile implements ValueAtPercentile {
public static ValueAtPercentile create(double percentile, double value) {
return new AutoValue_ImmutableValueAtPercentile(percentile, value);
}
ImmutableValueAtPercentile() {}
}

25
sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/data/MetricDataImplTest.java
View File

@ -16,6 +16,9 @@ import io.opentelemetry.sdk.metrics.internal.data.ImmutableGaugeData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableHistogramPointData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSumData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryPointData;
import io.opentelemetry.sdk.metrics.internal.data.ImmutableValueAtPercentile;
import io.opentelemetry.sdk.resources.Resource;
import java.util.Arrays;
import java.util.Collections;
@ -30,24 +33,24 @@ class MetricDataImplTest {
private static final double DOUBLE_VALUE = 1.234;
private static final AttributeKey<String> KEY = AttributeKey.stringKey("key");
private static final ValueAtPercentile MINIMUM_VALUE =
ValueAtPercentile.create(0.0, DOUBLE_VALUE);
ImmutableValueAtPercentile.create(0.0, DOUBLE_VALUE);
private static final ValueAtPercentile MAXIMUM_VALUE =
ValueAtPercentile.create(100.0, DOUBLE_VALUE);
ImmutableValueAtPercentile.create(100.0, DOUBLE_VALUE);
private static final LongPointData LONG_POINT =
LongPointData.create(START_EPOCH_NANOS, EPOCH_NANOS, Attributes.of(KEY, "value"), LONG_VALUE);
private static final DoublePointData DOUBLE_POINT =
DoublePointData.create(
START_EPOCH_NANOS, EPOCH_NANOS, Attributes.of(KEY, "value"), DOUBLE_VALUE);
private static final DoubleSummaryPointData SUMMARY_POINT =
DoubleSummaryPointData.create(
private static final SummaryPointData SUMMARY_POINT =
ImmutableSummaryPointData.create(
START_EPOCH_NANOS,
EPOCH_NANOS,
Attributes.of(KEY, "value"),
LONG_VALUE,
DOUBLE_VALUE,
Arrays.asList(
ValueAtPercentile.create(0.0, DOUBLE_VALUE),
ValueAtPercentile.create(100, DOUBLE_VALUE)));
ImmutableValueAtPercentile.create(0.0, DOUBLE_VALUE),
ImmutableValueAtPercentile.create(100, DOUBLE_VALUE)));
private static final ImmutableHistogramPointData HISTOGRAM_POINT =
ImmutableHistogramPointData.create(
START_EPOCH_NANOS,
@ -158,8 +161,8 @@ class MetricDataImplTest {
"metric_name",
"metric_description",
"ms",
DoubleSummaryData.create(Collections.singletonList(SUMMARY_POINT)));
assertThat(metricData.getDoubleSummaryData().getPoints()).containsExactly(SUMMARY_POINT);
ImmutableSummaryData.create(Collections.singletonList(SUMMARY_POINT)));
assertThat(metricData.getSummaryData().getPoints()).containsExactly(SUMMARY_POINT);
}
@Test
@ -220,13 +223,13 @@ class MetricDataImplTest {
"metric_name",
"metric_description",
"ms",
DoubleSummaryData.create(Collections.singletonList(SUMMARY_POINT)));
ImmutableSummaryData.create(Collections.singletonList(SUMMARY_POINT)));
assertThat(metricData.getDoubleGaugeData().getPoints()).isEmpty();
assertThat(metricData.getLongGaugeData().getPoints()).isEmpty();
assertThat(metricData.getDoubleSumData().getPoints()).isEmpty();
assertThat(metricData.getLongGaugeData().getPoints()).isEmpty();
assertThat(metricData.getSummaryData().getPoints()).containsExactly(SUMMARY_POINT);
assertThat(metricData.getHistogramData().getPoints()).isEmpty();
assertThat(metricData.getDoubleSummaryData().getPoints()).containsExactly(SUMMARY_POINT);
metricData =
MetricData.createDoubleGauge(
@ -240,7 +243,7 @@ class MetricDataImplTest {
assertThat(metricData.getLongGaugeData().getPoints()).isEmpty();
assertThat(metricData.getDoubleSumData().getPoints()).isEmpty();
assertThat(metricData.getLongGaugeData().getPoints()).isEmpty();
assertThat(metricData.getSummaryData().getPoints()).isEmpty();
assertThat(metricData.getHistogramData().getPoints()).isEmpty();
assertThat(metricData.getDoubleSummaryData().getPoints()).isEmpty();
}
}