From 1c40444da3e11d080d549c0c505ea50afffecffb Mon Sep 17 00:00:00 2001 From: Bogdan Drutu Date: Thu, 7 Jan 2021 16:29:45 -0800 Subject: [PATCH] Remove aggregation and merge functionality into aggregator (#2460) Signed-off-by: Bogdan Drutu --- .../AsynchronousInstrumentAccumulator.java | 4 +- .../sdk/metrics/InstrumentProcessor.java | 28 +++---- .../SynchronousInstrumentAccumulator.java | 2 +- .../sdk/metrics/ViewRegistry.java | 14 ++-- .../aggregation/AbstractAggregation.java | 22 ------ .../sdk/metrics/aggregation/Aggregation.java | 61 --------------- .../metrics/aggregation/CountAggregation.java | 61 --------------- .../DoubleLastValueAggregation.java | 72 ----------------- .../aggregation/DoubleSumAggregation.java | 56 ------------- .../ImmutableAggregationFactory.java | 49 ------------ .../aggregation/LongLastValueAggregation.java | 72 ----------------- .../aggregation/LongSumAggregation.java | 56 ------------- .../MinMaxSumCountAggregation.java | 65 ---------------- .../sdk/metrics/aggregator/Aggregator.java | 35 +++++++++ .../AggregatorFactory.java} | 29 ++++--- .../metrics/aggregator/CountAggregator.java | 33 ++++++++ .../aggregator/DoubleLastValueAggregator.java | 46 +++++++++++ .../DoubleMinMaxSumCountAggregator.java | 36 +++++++++ .../aggregator/DoubleSumAggregator.java | 30 +++++++ .../ImmutableAggregatorFactory.java | 50 ++++++++++++ .../aggregator/LongLastValueAggregator.java | 46 +++++++++++ .../LongMinMaxSumCountAggregator.java | 36 +++++++++ .../metrics/aggregator/LongSumAggregator.java | 30 +++++++ .../MetricDataUtils.java | 2 +- .../view/AggregationConfiguration.java | 13 ++-- .../sdk/metrics/SdkMeterProviderTest.java | 6 +- .../SynchronousInstrumentAccumulatorTest.java | 4 +- .../sdk/metrics/ViewRegistryTest.java | 38 ++++----- .../aggregation/CountAggregationTest.java | 57 -------------- .../aggregation/LastValueAggregationTest.java | 60 -------------- .../MinMaxSumCountAggregationTest.java | 59 -------------- .../aggregation/SumAggregationTest.java | 78 ------------------- .../aggregator/AggregatorFactoryTest.java | 49 ++++++++++++ .../aggregator/CountAggregatorTest.java | 42 ++++++++++ .../DoubleLastValueAggregatorTest.java | 40 ++++++++++ .../DoubleMinMaxSumCountAggregatorTest.java | 34 +++++++- .../aggregator/DoubleSumAggregatorTest.java | 38 +++++++++ .../LongLastValueAggregatorTest.java | 40 ++++++++++ .../LongMinMaxSumCountAggregatorTest.java | 34 +++++++- .../aggregator/LongSumAggregatorTest.java | 38 +++++++++ 40 files changed, 722 insertions(+), 843 deletions(-) delete mode 100644 sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/AbstractAggregation.java delete mode 100644 sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/Aggregation.java delete mode 100644 sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/CountAggregation.java delete mode 100644 sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/DoubleLastValueAggregation.java delete mode 100644 sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/DoubleSumAggregation.java delete mode 100644 sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/ImmutableAggregationFactory.java delete mode 100644 sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/LongLastValueAggregation.java delete mode 100644 sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/LongSumAggregation.java delete mode 100644 sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/MinMaxSumCountAggregation.java rename sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/{aggregation/AggregationFactory.java => aggregator/AggregatorFactory.java} (67%) create mode 100644 sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/ImmutableAggregatorFactory.java rename sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/{aggregation => aggregator}/MetricDataUtils.java (98%) delete mode 100644 sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregation/CountAggregationTest.java delete mode 100644 sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregation/LastValueAggregationTest.java delete mode 100644 sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregation/MinMaxSumCountAggregationTest.java delete mode 100644 sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregation/SumAggregationTest.java create mode 100644 sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/AggregatorFactoryTest.java diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/AsynchronousInstrumentAccumulator.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/AsynchronousInstrumentAccumulator.java index e3da04d967..abafd8cb66 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/AsynchronousInstrumentAccumulator.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/AsynchronousInstrumentAccumulator.java @@ -27,7 +27,7 @@ final class AsynchronousInstrumentAccumulator { return new AsynchronousInstrumentAccumulator(instrumentProcessor, () -> {}); } - Aggregator aggregator = instrumentProcessor.getAggregation().getAggregator(); + Aggregator aggregator = instrumentProcessor.getAggregator(); AsynchronousInstrument.DoubleResult result = (value, labels) -> instrumentProcessor.batch(labels, aggregator.accumulateDouble(value)); @@ -43,7 +43,7 @@ final class AsynchronousInstrumentAccumulator { return new AsynchronousInstrumentAccumulator(instrumentProcessor, () -> {}); } - Aggregator aggregator = instrumentProcessor.getAggregation().getAggregator(); + Aggregator aggregator = instrumentProcessor.getAggregator(); AsynchronousInstrument.LongResult result = (value, labels) -> instrumentProcessor.batch(labels, aggregator.accumulateLong(value)); diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/InstrumentProcessor.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/InstrumentProcessor.java index 62e7b3783b..005c451b69 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/InstrumentProcessor.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/InstrumentProcessor.java @@ -9,7 +9,7 @@ import io.opentelemetry.api.common.Labels; import io.opentelemetry.sdk.common.Clock; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.accumulation.Accumulation; -import io.opentelemetry.sdk.metrics.aggregation.Aggregation; +import io.opentelemetry.sdk.metrics.aggregator.Aggregator; import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; import io.opentelemetry.sdk.metrics.data.MetricData; import io.opentelemetry.sdk.resources.Resource; @@ -30,7 +30,7 @@ import java.util.Objects; */ final class InstrumentProcessor { private final InstrumentDescriptor descriptor; - private final Aggregation aggregation; + private final Aggregator aggregator; private final Resource resource; private final InstrumentationLibraryInfo instrumentationLibraryInfo; private final Clock clock; @@ -47,10 +47,10 @@ final class InstrumentProcessor { InstrumentDescriptor descriptor, MeterProviderSharedState meterProviderSharedState, MeterSharedState meterSharedState, - Aggregation aggregation) { + Aggregator aggregator) { return new InstrumentProcessor<>( descriptor, - aggregation, + aggregator, meterProviderSharedState.getResource(), meterSharedState.getInstrumentationLibraryInfo(), meterProviderSharedState.getClock(), @@ -66,10 +66,10 @@ final class InstrumentProcessor { InstrumentDescriptor descriptor, MeterProviderSharedState meterProviderSharedState, MeterSharedState meterSharedState, - Aggregation aggregation) { + Aggregator aggregator) { return new InstrumentProcessor<>( descriptor, - aggregation, + aggregator, meterProviderSharedState.getResource(), meterSharedState.getInstrumentationLibraryInfo(), meterProviderSharedState.getClock(), @@ -78,13 +78,13 @@ final class InstrumentProcessor { private InstrumentProcessor( InstrumentDescriptor descriptor, - Aggregation aggregation, + Aggregator aggregator, Resource resource, InstrumentationLibraryInfo instrumentationLibraryInfo, Clock clock, boolean delta) { this.descriptor = descriptor; - this.aggregation = aggregation; + this.aggregator = aggregator; this.resource = resource; this.instrumentationLibraryInfo = instrumentationLibraryInfo; this.clock = clock; @@ -106,7 +106,7 @@ final class InstrumentProcessor { accumulationMap.put(labelSet, accumulation); return; } - accumulationMap.put(labelSet, aggregation.merge(currentAccumulation, accumulation)); + accumulationMap.put(labelSet, aggregator.merge(currentAccumulation, accumulation)); } /** @@ -126,7 +126,7 @@ final class InstrumentProcessor { } MetricData metricData = - aggregation.toMetricData( + aggregator.toMetricData( resource, instrumentationLibraryInfo, descriptor, @@ -142,8 +142,8 @@ final class InstrumentProcessor { return metricData == null ? Collections.emptyList() : Collections.singletonList(metricData); } - Aggregation getAggregation() { - return this.aggregation; + Aggregator getAggregator() { + return this.aggregator; } /** @@ -174,7 +174,7 @@ final class InstrumentProcessor { if (!Objects.equals(descriptor, allLabels.descriptor)) { return false; } - if (!Objects.equals(aggregation, allLabels.aggregation)) { + if (!Objects.equals(aggregator, allLabels.aggregator)) { return false; } if (!Objects.equals(resource, allLabels.resource)) { @@ -192,7 +192,7 @@ final class InstrumentProcessor { @Override public int hashCode() { int result = descriptor != null ? descriptor.hashCode() : 0; - result = 31 * result + (aggregation != null ? aggregation.hashCode() : 0); + result = 31 * result + (aggregator != null ? aggregator.hashCode() : 0); result = 31 * result + (resource != null ? resource.hashCode() : 0); result = 31 * result diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/SynchronousInstrumentAccumulator.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/SynchronousInstrumentAccumulator.java index 6e34a8c04d..184c4d98fc 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/SynchronousInstrumentAccumulator.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/SynchronousInstrumentAccumulator.java @@ -26,7 +26,7 @@ final class SynchronousInstrumentAccumulator { aggregatorLabels = new ConcurrentHashMap<>(); collectLock = new ReentrantLock(); this.instrumentProcessor = instrumentProcessor; - this.aggregator = instrumentProcessor.getAggregation().getAggregator(); + this.aggregator = instrumentProcessor.getAggregator(); } AggregatorHandle bind(Labels labels) { diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/ViewRegistry.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/ViewRegistry.java index 47719ce081..53a741576d 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/ViewRegistry.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/ViewRegistry.java @@ -6,7 +6,7 @@ package io.opentelemetry.sdk.metrics; import io.opentelemetry.sdk.metrics.accumulation.Accumulation; -import io.opentelemetry.sdk.metrics.aggregation.AggregationFactory; +import io.opentelemetry.sdk.metrics.aggregator.AggregatorFactory; import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; import io.opentelemetry.sdk.metrics.common.InstrumentType; import io.opentelemetry.sdk.metrics.data.MetricData; @@ -40,16 +40,16 @@ final class ViewRegistry { new LinkedHashMap<>(); private static final AggregationConfiguration CUMULATIVE_SUM = AggregationConfiguration.create( - AggregationFactory.sum(), MetricData.AggregationTemporality.CUMULATIVE); + AggregatorFactory.sum(), MetricData.AggregationTemporality.CUMULATIVE); private static final AggregationConfiguration DELTA_SUMMARY = AggregationConfiguration.create( - AggregationFactory.minMaxSumCount(), MetricData.AggregationTemporality.DELTA); + AggregatorFactory.minMaxSumCount(), MetricData.AggregationTemporality.DELTA); private static final AggregationConfiguration CUMULATIVE_LAST_VALUE = AggregationConfiguration.create( - AggregationFactory.lastValue(), MetricData.AggregationTemporality.CUMULATIVE); + AggregatorFactory.lastValue(), MetricData.AggregationTemporality.CUMULATIVE); private static final AggregationConfiguration DELTA_LAST_VALUE = AggregationConfiguration.create( - AggregationFactory.lastValue(), MetricData.AggregationTemporality.DELTA); + AggregatorFactory.lastValue(), MetricData.AggregationTemporality.DELTA); private final ReentrantLock collectLock = new ReentrantLock(); private volatile EnumMap> @@ -96,13 +96,13 @@ final class ViewRegistry { descriptor, meterProviderSharedState, meterSharedState, - specification.getAggregationFactory().create(descriptor.getValueType())); + specification.getAggregatorFactory().create(descriptor.getValueType())); case DELTA: return InstrumentProcessor.getDeltaAllLabels( descriptor, meterProviderSharedState, meterSharedState, - specification.getAggregationFactory().create(descriptor.getValueType())); + specification.getAggregatorFactory().create(descriptor.getValueType())); } throw new IllegalStateException("unsupported Temporality: " + specification.getTemporality()); } diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/AbstractAggregation.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/AbstractAggregation.java deleted file mode 100644 index 2cdcb44735..0000000000 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/AbstractAggregation.java +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.metrics.aggregation; - -import io.opentelemetry.sdk.metrics.accumulation.Accumulation; -import io.opentelemetry.sdk.metrics.aggregator.Aggregator; - -abstract class AbstractAggregation implements Aggregation { - private final Aggregator aggregator; - - AbstractAggregation(Aggregator aggregator) { - this.aggregator = aggregator; - } - - @Override - public final Aggregator getAggregator() { - return aggregator; - } -} diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/Aggregation.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/Aggregation.java deleted file mode 100644 index e2e753ad5a..0000000000 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/Aggregation.java +++ /dev/null @@ -1,61 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.metrics.aggregation; - -import io.opentelemetry.api.common.Labels; -import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; -import io.opentelemetry.sdk.metrics.accumulation.Accumulation; -import io.opentelemetry.sdk.metrics.aggregator.Aggregator; -import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; -import io.opentelemetry.sdk.metrics.data.MetricData; -import io.opentelemetry.sdk.resources.Resource; -import java.util.Map; -import javax.annotation.Nullable; -import javax.annotation.concurrent.Immutable; - -/** - * {@link Aggregation} is the process of combining a certain set of recorded measurements for a - * given {@code Instrument} into the equivalent {@code MetricData}. - */ -@Immutable -public interface Aggregation { - - /** - * Returns an {@link Aggregator} that can be used to aggregate measurements and produce {@link - * Accumulation}. - * - * @return the {@link Aggregator} for this {@link Aggregation}. - */ - Aggregator getAggregator(); - - /** - * Returns the result of the merge of the given {@link Accumulation}s. - * - * @return the result of the merge of the given {@link Accumulation}s. - */ - T merge(T a1, T a2); - - /** - * Returns the {@link MetricData} that this {@code Aggregation} will produce. - * - * @param resource the Resource associated with the {@code Instrument}. - * @param instrumentationLibraryInfo the InstrumentationLibraryInfo associated with the {@code - * Instrument}. - * @param descriptor the InstrumentDescriptor of the {@code Instrument}. - * @param accumulationByLabels the map of Labels to Accumulation. - * @param startEpochNanos the startEpochNanos for the {@code Point}. - * @param epochNanos the epochNanos for the {@code Point}. - * @return the {@link MetricData.Type} that this {@code Aggregation} will produce. - */ - @Nullable - MetricData toMetricData( - Resource resource, - InstrumentationLibraryInfo instrumentationLibraryInfo, - InstrumentDescriptor descriptor, - Map accumulationByLabels, - long startEpochNanos, - long epochNanos); -} diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/CountAggregation.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/CountAggregation.java deleted file mode 100644 index de22f5dba6..0000000000 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/CountAggregation.java +++ /dev/null @@ -1,61 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.metrics.aggregation; - -import io.opentelemetry.api.common.Labels; -import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; -import io.opentelemetry.sdk.metrics.accumulation.LongAccumulation; -import io.opentelemetry.sdk.metrics.aggregator.Aggregator; -import io.opentelemetry.sdk.metrics.aggregator.CountAggregator; -import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; -import io.opentelemetry.sdk.metrics.data.MetricData; -import io.opentelemetry.sdk.resources.Resource; -import java.util.List; -import java.util.Map; -import javax.annotation.concurrent.Immutable; - -@Immutable -final class CountAggregation implements Aggregation { - static final CountAggregation INSTANCE = new CountAggregation(); - - private CountAggregation() {} - - @Override - public Aggregator getAggregator() { - return CountAggregator.getInstance(); - } - - @Override - public LongAccumulation merge(LongAccumulation a1, LongAccumulation a2) { - return LongAccumulation.create(a1.getValue() + a2.getValue()); - } - - @Override - public MetricData toMetricData( - Resource resource, - InstrumentationLibraryInfo instrumentationLibraryInfo, - InstrumentDescriptor descriptor, - Map accumulationByLabels, - long startEpochNanos, - long epochNanos) { - List points = - MetricDataUtils.toLongPointList(accumulationByLabels, startEpochNanos, epochNanos); - - return MetricData.createLongSum( - resource, - instrumentationLibraryInfo, - descriptor.getName(), - descriptor.getDescription(), - "1", - MetricData.LongSumData.create( - /* isMonotonic= */ true, MetricData.AggregationTemporality.CUMULATIVE, points)); - } - - @Override - public String toString() { - return getClass().getSimpleName(); - } -} diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/DoubleLastValueAggregation.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/DoubleLastValueAggregation.java deleted file mode 100644 index 29a11df04b..0000000000 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/DoubleLastValueAggregation.java +++ /dev/null @@ -1,72 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.metrics.aggregation; - -import io.opentelemetry.api.common.Labels; -import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; -import io.opentelemetry.sdk.metrics.accumulation.DoubleAccumulation; -import io.opentelemetry.sdk.metrics.aggregator.Aggregator; -import io.opentelemetry.sdk.metrics.aggregator.DoubleLastValueAggregator; -import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; -import io.opentelemetry.sdk.metrics.data.MetricData; -import io.opentelemetry.sdk.resources.Resource; -import java.util.List; -import java.util.Map; -import javax.annotation.concurrent.Immutable; - -@Immutable -final class DoubleLastValueAggregation extends AbstractAggregation { - static final DoubleLastValueAggregation INSTANCE = - new DoubleLastValueAggregation(DoubleLastValueAggregator.getInstance()); - - private DoubleLastValueAggregation(Aggregator aggregator) { - super(aggregator); - } - - @Override - public DoubleAccumulation merge(DoubleAccumulation a1, DoubleAccumulation a2) { - // TODO: Define the order between accumulation. - return a2; - } - - @Override - public MetricData toMetricData( - Resource resource, - InstrumentationLibraryInfo instrumentationLibraryInfo, - InstrumentDescriptor descriptor, - Map accumulationByLabels, - long startEpochNanos, - long epochNanos) { - List points = - MetricDataUtils.toDoublePointList(accumulationByLabels, startEpochNanos, epochNanos); - - switch (descriptor.getType()) { - case SUM_OBSERVER: - return MetricDataUtils.toDoubleSumMetricData( - resource, instrumentationLibraryInfo, descriptor, points, /* isMonotonic= */ true); - case UP_DOWN_SUM_OBSERVER: - return MetricDataUtils.toDoubleSumMetricData( - resource, instrumentationLibraryInfo, descriptor, points, /* isMonotonic= */ false); - case VALUE_OBSERVER: - return MetricData.createDoubleGauge( - resource, - instrumentationLibraryInfo, - descriptor.getName(), - descriptor.getDescription(), - descriptor.getUnit(), - MetricData.DoubleGaugeData.create(points)); - case COUNTER: - case UP_DOWN_COUNTER: - case VALUE_RECORDER: - } - return null; - } - - @Override - public String toString() { - return getClass().getSimpleName(); - } -} diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/DoubleSumAggregation.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/DoubleSumAggregation.java deleted file mode 100644 index cfb516c01e..0000000000 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/DoubleSumAggregation.java +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.metrics.aggregation; - -import io.opentelemetry.api.common.Labels; -import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; -import io.opentelemetry.sdk.metrics.accumulation.DoubleAccumulation; -import io.opentelemetry.sdk.metrics.aggregator.Aggregator; -import io.opentelemetry.sdk.metrics.aggregator.DoubleSumAggregator; -import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; -import io.opentelemetry.sdk.metrics.common.InstrumentType; -import io.opentelemetry.sdk.metrics.data.MetricData; -import io.opentelemetry.sdk.resources.Resource; -import java.util.List; -import java.util.Map; -import javax.annotation.concurrent.Immutable; - -@Immutable -final class DoubleSumAggregation extends AbstractAggregation { - static final DoubleSumAggregation INSTANCE = - new DoubleSumAggregation(DoubleSumAggregator.getInstance()); - - private DoubleSumAggregation(Aggregator aggregator) { - super(aggregator); - } - - @Override - public final DoubleAccumulation merge(DoubleAccumulation a1, DoubleAccumulation a2) { - return DoubleAccumulation.create(a1.getValue() + a2.getValue()); - } - - @Override - public MetricData toMetricData( - Resource resource, - InstrumentationLibraryInfo instrumentationLibraryInfo, - InstrumentDescriptor descriptor, - Map accumulationByLabels, - long startEpochNanos, - long epochNanos) { - List points = - MetricDataUtils.toDoublePointList(accumulationByLabels, startEpochNanos, epochNanos); - boolean isMonotonic = - descriptor.getType() == InstrumentType.COUNTER - || descriptor.getType() == InstrumentType.SUM_OBSERVER; - return MetricDataUtils.toDoubleSumMetricData( - resource, instrumentationLibraryInfo, descriptor, points, isMonotonic); - } - - @Override - public String toString() { - return getClass().getSimpleName(); - } -} diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/ImmutableAggregationFactory.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/ImmutableAggregationFactory.java deleted file mode 100644 index bb7158c79d..0000000000 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/ImmutableAggregationFactory.java +++ /dev/null @@ -1,49 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.metrics.aggregation; - -import io.opentelemetry.sdk.metrics.accumulation.Accumulation; -import io.opentelemetry.sdk.metrics.common.InstrumentValueType; -import javax.annotation.concurrent.Immutable; - -@Immutable -final class ImmutableAggregationFactory - implements AggregationFactory { - static final AggregationFactory SUM = - new ImmutableAggregationFactory<>(LongSumAggregation.INSTANCE, DoubleSumAggregation.INSTANCE); - - static final AggregationFactory COUNT = - new ImmutableAggregationFactory<>(CountAggregation.INSTANCE, CountAggregation.INSTANCE); - - static final AggregationFactory LAST_VALUE = - new ImmutableAggregationFactory<>( - LongLastValueAggregation.INSTANCE, DoubleLastValueAggregation.INSTANCE); - - static final AggregationFactory MIN_MAX_SUM_COUNT = - new ImmutableAggregationFactory<>( - MinMaxSumCountAggregation.LONG_INSTANCE, MinMaxSumCountAggregation.DOUBLE_INSTANCE); - - private final Aggregation longAggregation; - private final Aggregation doubleAggregation; - - private ImmutableAggregationFactory( - Aggregation longAggregation, Aggregation doubleAggregation) { - this.longAggregation = longAggregation; - this.doubleAggregation = doubleAggregation; - } - - @Override - @SuppressWarnings("unchecked") - public Aggregation create(InstrumentValueType instrumentValueType) { - switch (instrumentValueType) { - case LONG: - return (Aggregation) longAggregation; - case DOUBLE: - return (Aggregation) doubleAggregation; - } - throw new IllegalArgumentException("Invalid instrument value type"); - } -} diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/LongLastValueAggregation.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/LongLastValueAggregation.java deleted file mode 100644 index 8df9c66bbc..0000000000 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/LongLastValueAggregation.java +++ /dev/null @@ -1,72 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.metrics.aggregation; - -import io.opentelemetry.api.common.Labels; -import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; -import io.opentelemetry.sdk.metrics.accumulation.LongAccumulation; -import io.opentelemetry.sdk.metrics.aggregator.Aggregator; -import io.opentelemetry.sdk.metrics.aggregator.LongLastValueAggregator; -import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; -import io.opentelemetry.sdk.metrics.data.MetricData; -import io.opentelemetry.sdk.resources.Resource; -import java.util.List; -import java.util.Map; -import javax.annotation.concurrent.Immutable; - -@Immutable -final class LongLastValueAggregation extends AbstractAggregation { - static final LongLastValueAggregation INSTANCE = - new LongLastValueAggregation(LongLastValueAggregator.getInstance()); - - private LongLastValueAggregation(Aggregator aggregator) { - super(aggregator); - } - - @Override - public LongAccumulation merge(LongAccumulation a1, LongAccumulation a2) { - // TODO: Define the order between accumulation. - return a2; - } - - @Override - public MetricData toMetricData( - Resource resource, - InstrumentationLibraryInfo instrumentationLibraryInfo, - InstrumentDescriptor descriptor, - Map accumulationByLabels, - long startEpochNanos, - long epochNanos) { - List points = - MetricDataUtils.toLongPointList(accumulationByLabels, startEpochNanos, epochNanos); - - switch (descriptor.getType()) { - case SUM_OBSERVER: - return MetricDataUtils.toLongSumMetricData( - resource, instrumentationLibraryInfo, descriptor, points, /* isMonotonic= */ true); - case UP_DOWN_SUM_OBSERVER: - return MetricDataUtils.toLongSumMetricData( - resource, instrumentationLibraryInfo, descriptor, points, /* isMonotonic= */ false); - case VALUE_OBSERVER: - return MetricData.createLongGauge( - resource, - instrumentationLibraryInfo, - descriptor.getName(), - descriptor.getDescription(), - descriptor.getUnit(), - MetricData.LongGaugeData.create(points)); - case COUNTER: - case UP_DOWN_COUNTER: - case VALUE_RECORDER: - } - return null; - } - - @Override - public String toString() { - return getClass().getSimpleName(); - } -} diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/LongSumAggregation.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/LongSumAggregation.java deleted file mode 100644 index 761eb139d3..0000000000 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/LongSumAggregation.java +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.metrics.aggregation; - -import io.opentelemetry.api.common.Labels; -import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; -import io.opentelemetry.sdk.metrics.accumulation.LongAccumulation; -import io.opentelemetry.sdk.metrics.aggregator.Aggregator; -import io.opentelemetry.sdk.metrics.aggregator.LongSumAggregator; -import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; -import io.opentelemetry.sdk.metrics.common.InstrumentType; -import io.opentelemetry.sdk.metrics.data.MetricData; -import io.opentelemetry.sdk.resources.Resource; -import java.util.List; -import java.util.Map; -import javax.annotation.concurrent.Immutable; - -@Immutable -final class LongSumAggregation extends AbstractAggregation { - static final LongSumAggregation INSTANCE = - new LongSumAggregation(LongSumAggregator.getInstance()); - - private LongSumAggregation(Aggregator aggregator) { - super(aggregator); - } - - @Override - public LongAccumulation merge(LongAccumulation a1, LongAccumulation a2) { - return LongAccumulation.create(a1.getValue() + a2.getValue()); - } - - @Override - public MetricData toMetricData( - Resource resource, - InstrumentationLibraryInfo instrumentationLibraryInfo, - InstrumentDescriptor descriptor, - Map accumulationByLabels, - long startEpochNanos, - long epochNanos) { - List points = - MetricDataUtils.toLongPointList(accumulationByLabels, startEpochNanos, epochNanos); - boolean isMonotonic = - descriptor.getType() == InstrumentType.COUNTER - || descriptor.getType() == InstrumentType.SUM_OBSERVER; - return MetricDataUtils.toLongSumMetricData( - resource, instrumentationLibraryInfo, descriptor, points, isMonotonic); - } - - @Override - public String toString() { - return getClass().getSimpleName(); - } -} diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/MinMaxSumCountAggregation.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/MinMaxSumCountAggregation.java deleted file mode 100644 index 9ac6ae555b..0000000000 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/MinMaxSumCountAggregation.java +++ /dev/null @@ -1,65 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.metrics.aggregation; - -import io.opentelemetry.api.common.Labels; -import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; -import io.opentelemetry.sdk.metrics.accumulation.MinMaxSumCountAccumulation; -import io.opentelemetry.sdk.metrics.aggregator.Aggregator; -import io.opentelemetry.sdk.metrics.aggregator.DoubleMinMaxSumCountAggregator; -import io.opentelemetry.sdk.metrics.aggregator.LongMinMaxSumCountAggregator; -import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; -import io.opentelemetry.sdk.metrics.data.MetricData; -import io.opentelemetry.sdk.resources.Resource; -import java.util.List; -import java.util.Map; -import javax.annotation.concurrent.Immutable; - -@Immutable -final class MinMaxSumCountAggregation extends AbstractAggregation { - static final MinMaxSumCountAggregation LONG_INSTANCE = - new MinMaxSumCountAggregation(LongMinMaxSumCountAggregator.getInstance()); - static final MinMaxSumCountAggregation DOUBLE_INSTANCE = - new MinMaxSumCountAggregation(DoubleMinMaxSumCountAggregator.getInstance()); - - private MinMaxSumCountAggregation(Aggregator aggregator) { - super(aggregator); - } - - @Override - public MinMaxSumCountAccumulation merge( - MinMaxSumCountAccumulation a1, MinMaxSumCountAccumulation a2) { - return MinMaxSumCountAccumulation.create( - a1.getCount() + a2.getCount(), - a1.getSum() + a2.getSum(), - Math.min(a1.getMin(), a2.getMin()), - Math.max(a1.getMax(), a2.getMax())); - } - - @Override - public MetricData toMetricData( - Resource resource, - InstrumentationLibraryInfo instrumentationLibraryInfo, - InstrumentDescriptor descriptor, - Map accumulationByLabels, - long startEpochNanos, - long epochNanos) { - List points = - MetricDataUtils.toDoubleSummaryPointList(accumulationByLabels, startEpochNanos, epochNanos); - return MetricData.createDoubleSummary( - resource, - instrumentationLibraryInfo, - descriptor.getName(), - descriptor.getDescription(), - descriptor.getUnit(), - MetricData.DoubleSummaryData.create(points)); - } - - @Override - public String toString() { - return getClass().getSimpleName(); - } -} diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/Aggregator.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/Aggregator.java index 9e5f9a5e27..90afbcf787 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/Aggregator.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/Aggregator.java @@ -5,7 +5,14 @@ package io.opentelemetry.sdk.metrics.aggregator; +import io.opentelemetry.api.common.Labels; +import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.accumulation.Accumulation; +import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.resources.Resource; +import java.util.Map; +import javax.annotation.Nullable; import javax.annotation.concurrent.Immutable; /** @@ -53,4 +60,32 @@ public interface Aggregator { throw new UnsupportedOperationException( "This aggregator does not support recording double values."); } + + /** + * Returns the result of the merge of the given {@link Accumulation}s. + * + * @return the result of the merge of the given {@link Accumulation}s. + */ + T merge(T a1, T a2); + + /** + * Returns the {@link MetricData} that this {@code Aggregation} will produce. + * + * @param resource the Resource associated with the {@code Instrument}. + * @param instrumentationLibraryInfo the InstrumentationLibraryInfo associated with the {@code + * Instrument}. + * @param descriptor the InstrumentDescriptor of the {@code Instrument}. + * @param accumulationByLabels the map of Labels to Accumulation. + * @param startEpochNanos the startEpochNanos for the {@code Point}. + * @param epochNanos the epochNanos for the {@code Point}. + * @return the {@link MetricData.Type} that this {@code Aggregation} will produce. + */ + @Nullable + MetricData toMetricData( + Resource resource, + InstrumentationLibraryInfo instrumentationLibraryInfo, + InstrumentDescriptor descriptor, + Map accumulationByLabels, + long startEpochNanos, + long epochNanos); } diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/AggregationFactory.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/AggregatorFactory.java similarity index 67% rename from sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/AggregationFactory.java rename to sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/AggregatorFactory.java index 3a207a66c6..2e851bddaa 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/AggregationFactory.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/AggregatorFactory.java @@ -3,23 +3,22 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.sdk.metrics.aggregation; +package io.opentelemetry.sdk.metrics.aggregator; import io.opentelemetry.sdk.metrics.accumulation.Accumulation; -import io.opentelemetry.sdk.metrics.aggregator.AggregatorHandle; import io.opentelemetry.sdk.metrics.common.InstrumentValueType; import javax.annotation.concurrent.Immutable; -/** Factory class for {@link AggregatorHandle}. */ +/** Factory class for {@link Aggregator}. */ @Immutable -public interface AggregationFactory { +public interface AggregatorFactory { /** * Returns an {@code AggregationFactory} that calculates sum of recorded measurements. * * @return an {@code AggregationFactory} that calculates sum of recorded measurements. */ - static AggregationFactory sum() { - return ImmutableAggregationFactory.SUM; + static AggregatorFactory sum() { + return ImmutableAggregatorFactory.SUM; } /** @@ -29,8 +28,8 @@ public interface AggregationFactory { * @return an {@code AggregationFactory} that calculates count of recorded measurements (the * number of recorded * measurements). */ - static AggregationFactory count() { - return ImmutableAggregationFactory.COUNT; + static AggregatorFactory count() { + return ImmutableAggregatorFactory.COUNT; } /** @@ -40,8 +39,8 @@ public interface AggregationFactory { * @return an {@code AggregationFactory} that calculates the last value of all recorded * measurements. */ - static AggregationFactory lastValue() { - return ImmutableAggregationFactory.LAST_VALUE; + static AggregatorFactory lastValue() { + return ImmutableAggregatorFactory.LAST_VALUE; } /** @@ -52,15 +51,15 @@ public interface AggregationFactory { * @return an {@code AggregationFactory} that calculates a simple summary of all recorded * measurements. */ - static AggregationFactory minMaxSumCount() { - return ImmutableAggregationFactory.MIN_MAX_SUM_COUNT; + static AggregatorFactory minMaxSumCount() { + return ImmutableAggregatorFactory.MIN_MAX_SUM_COUNT; } /** - * Returns a new {@link Aggregation}. + * Returns a new {@link Aggregator}. * * @param instrumentValueType the type of recorded values for the {@code Instrument}. - * @return a new {@link Aggregation}. + * @return a new {@link Aggregator}. */ - Aggregation create(InstrumentValueType instrumentValueType); + Aggregator create(InstrumentValueType instrumentValueType); } diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/CountAggregator.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/CountAggregator.java index 80d7ff2c4f..b2132f8950 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/CountAggregator.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/CountAggregator.java @@ -5,7 +5,14 @@ package io.opentelemetry.sdk.metrics.aggregator; +import io.opentelemetry.api.common.Labels; +import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.accumulation.LongAccumulation; +import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.resources.Resource; +import java.util.List; +import java.util.Map; import java.util.concurrent.atomic.LongAdder; import javax.annotation.concurrent.ThreadSafe; @@ -39,6 +46,32 @@ public final class CountAggregator implements Aggregator { return LongAccumulation.create(1); } + @Override + public LongAccumulation merge(LongAccumulation a1, LongAccumulation a2) { + return LongAccumulation.create(a1.getValue() + a2.getValue()); + } + + @Override + public MetricData toMetricData( + Resource resource, + InstrumentationLibraryInfo instrumentationLibraryInfo, + InstrumentDescriptor descriptor, + Map accumulationByLabels, + long startEpochNanos, + long epochNanos) { + List points = + MetricDataUtils.toLongPointList(accumulationByLabels, startEpochNanos, epochNanos); + + return MetricData.createLongSum( + resource, + instrumentationLibraryInfo, + descriptor.getName(), + descriptor.getDescription(), + "1", + MetricData.LongSumData.create( + /* isMonotonic= */ true, MetricData.AggregationTemporality.CUMULATIVE, points)); + } + static final class Handle extends AggregatorHandle { private final LongAdder current = new LongAdder(); diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/DoubleLastValueAggregator.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/DoubleLastValueAggregator.java index 873a75cd20..b7ceb38b3e 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/DoubleLastValueAggregator.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/DoubleLastValueAggregator.java @@ -5,7 +5,14 @@ package io.opentelemetry.sdk.metrics.aggregator; +import io.opentelemetry.api.common.Labels; +import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.accumulation.DoubleAccumulation; +import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.resources.Resource; +import java.util.List; +import java.util.Map; import java.util.concurrent.atomic.AtomicReference; import javax.annotation.Nullable; import javax.annotation.concurrent.ThreadSafe; @@ -43,6 +50,45 @@ public final class DoubleLastValueAggregator implements Aggregator accumulationByLabels, + long startEpochNanos, + long epochNanos) { + List points = + MetricDataUtils.toDoublePointList(accumulationByLabels, startEpochNanos, epochNanos); + + switch (descriptor.getType()) { + case SUM_OBSERVER: + return MetricDataUtils.toDoubleSumMetricData( + resource, instrumentationLibraryInfo, descriptor, points, /* isMonotonic= */ true); + case UP_DOWN_SUM_OBSERVER: + return MetricDataUtils.toDoubleSumMetricData( + resource, instrumentationLibraryInfo, descriptor, points, /* isMonotonic= */ false); + case VALUE_OBSERVER: + return MetricData.createDoubleGauge( + resource, + instrumentationLibraryInfo, + descriptor.getName(), + descriptor.getDescription(), + descriptor.getUnit(), + MetricData.DoubleGaugeData.create(points)); + case COUNTER: + case UP_DOWN_COUNTER: + case VALUE_RECORDER: + } + return null; + } + static final class Handle extends AggregatorHandle { @Nullable private static final Double DEFAULT_VALUE = null; private final AtomicReference current = new AtomicReference<>(DEFAULT_VALUE); diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/DoubleMinMaxSumCountAggregator.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/DoubleMinMaxSumCountAggregator.java index 2c093393ed..68911d3f5b 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/DoubleMinMaxSumCountAggregator.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/DoubleMinMaxSumCountAggregator.java @@ -6,7 +6,14 @@ package io.opentelemetry.sdk.metrics.aggregator; import com.google.errorprone.annotations.concurrent.GuardedBy; +import io.opentelemetry.api.common.Labels; +import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.accumulation.MinMaxSumCountAccumulation; +import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.resources.Resource; +import java.util.List; +import java.util.Map; import java.util.concurrent.locks.ReentrantReadWriteLock; import javax.annotation.concurrent.ThreadSafe; @@ -37,6 +44,35 @@ public final class DoubleMinMaxSumCountAggregator return MinMaxSumCountAccumulation.create(1, value, value, value); } + @Override + public MinMaxSumCountAccumulation merge( + MinMaxSumCountAccumulation a1, MinMaxSumCountAccumulation a2) { + return MinMaxSumCountAccumulation.create( + a1.getCount() + a2.getCount(), + a1.getSum() + a2.getSum(), + Math.min(a1.getMin(), a2.getMin()), + Math.max(a1.getMax(), a2.getMax())); + } + + @Override + public MetricData toMetricData( + Resource resource, + InstrumentationLibraryInfo instrumentationLibraryInfo, + InstrumentDescriptor descriptor, + Map accumulationByLabels, + long startEpochNanos, + long epochNanos) { + List points = + MetricDataUtils.toDoubleSummaryPointList(accumulationByLabels, startEpochNanos, epochNanos); + return MetricData.createDoubleSummary( + resource, + instrumentationLibraryInfo, + descriptor.getName(), + descriptor.getDescription(), + descriptor.getUnit(), + MetricData.DoubleSummaryData.create(points)); + } + static final class Handle extends AggregatorHandle { private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); // The current value. This controls its own internal thread-safety via method access. Don't diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/DoubleSumAggregator.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/DoubleSumAggregator.java index baae868335..cd087ff299 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/DoubleSumAggregator.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/DoubleSumAggregator.java @@ -5,7 +5,15 @@ package io.opentelemetry.sdk.metrics.aggregator; +import io.opentelemetry.api.common.Labels; +import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.accumulation.DoubleAccumulation; +import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; +import io.opentelemetry.sdk.metrics.common.InstrumentType; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.resources.Resource; +import java.util.List; +import java.util.Map; import java.util.concurrent.atomic.DoubleAdder; public final class DoubleSumAggregator implements Aggregator { @@ -32,6 +40,28 @@ public final class DoubleSumAggregator implements Aggregator return DoubleAccumulation.create(value); } + @Override + public final DoubleAccumulation merge(DoubleAccumulation a1, DoubleAccumulation a2) { + return DoubleAccumulation.create(a1.getValue() + a2.getValue()); + } + + @Override + public MetricData toMetricData( + Resource resource, + InstrumentationLibraryInfo instrumentationLibraryInfo, + InstrumentDescriptor descriptor, + Map accumulationByLabels, + long startEpochNanos, + long epochNanos) { + List points = + MetricDataUtils.toDoublePointList(accumulationByLabels, startEpochNanos, epochNanos); + boolean isMonotonic = + descriptor.getType() == InstrumentType.COUNTER + || descriptor.getType() == InstrumentType.SUM_OBSERVER; + return MetricDataUtils.toDoubleSumMetricData( + resource, instrumentationLibraryInfo, descriptor, points, isMonotonic); + } + static final class Handle extends AggregatorHandle { private final DoubleAdder current = new DoubleAdder(); diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/ImmutableAggregatorFactory.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/ImmutableAggregatorFactory.java new file mode 100644 index 0000000000..0cdfc054a0 --- /dev/null +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/ImmutableAggregatorFactory.java @@ -0,0 +1,50 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.sdk.metrics.aggregator; + +import io.opentelemetry.sdk.metrics.accumulation.Accumulation; +import io.opentelemetry.sdk.metrics.common.InstrumentValueType; +import javax.annotation.concurrent.Immutable; + +@Immutable +final class ImmutableAggregatorFactory + implements AggregatorFactory { + static final AggregatorFactory SUM = + new ImmutableAggregatorFactory<>( + LongSumAggregator.getInstance(), DoubleSumAggregator.getInstance()); + + static final AggregatorFactory COUNT = + new ImmutableAggregatorFactory<>( + CountAggregator.getInstance(), CountAggregator.getInstance()); + + static final AggregatorFactory LAST_VALUE = + new ImmutableAggregatorFactory<>( + LongLastValueAggregator.getInstance(), DoubleLastValueAggregator.getInstance()); + + static final AggregatorFactory MIN_MAX_SUM_COUNT = + new ImmutableAggregatorFactory<>( + LongMinMaxSumCountAggregator.getInstance(), DoubleMinMaxSumCountAggregator.getInstance()); + + private final Aggregator longAggregator; + private final Aggregator doubleAggregator; + + private ImmutableAggregatorFactory(Aggregator longAggregator, Aggregator doubleAggregator) { + this.longAggregator = longAggregator; + this.doubleAggregator = doubleAggregator; + } + + @Override + @SuppressWarnings("unchecked") + public Aggregator create(InstrumentValueType instrumentValueType) { + switch (instrumentValueType) { + case LONG: + return (Aggregator) longAggregator; + case DOUBLE: + return (Aggregator) doubleAggregator; + } + throw new IllegalArgumentException("Invalid instrument value type"); + } +} diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/LongLastValueAggregator.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/LongLastValueAggregator.java index 5e6bb569e1..8ab7bacaa3 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/LongLastValueAggregator.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/LongLastValueAggregator.java @@ -5,7 +5,14 @@ package io.opentelemetry.sdk.metrics.aggregator; +import io.opentelemetry.api.common.Labels; +import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.accumulation.LongAccumulation; +import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.resources.Resource; +import java.util.List; +import java.util.Map; import java.util.concurrent.atomic.AtomicReference; import javax.annotation.Nullable; @@ -42,6 +49,45 @@ public final class LongLastValueAggregator implements Aggregator accumulationByLabels, + long startEpochNanos, + long epochNanos) { + List points = + MetricDataUtils.toLongPointList(accumulationByLabels, startEpochNanos, epochNanos); + + switch (descriptor.getType()) { + case SUM_OBSERVER: + return MetricDataUtils.toLongSumMetricData( + resource, instrumentationLibraryInfo, descriptor, points, /* isMonotonic= */ true); + case UP_DOWN_SUM_OBSERVER: + return MetricDataUtils.toLongSumMetricData( + resource, instrumentationLibraryInfo, descriptor, points, /* isMonotonic= */ false); + case VALUE_OBSERVER: + return MetricData.createLongGauge( + resource, + instrumentationLibraryInfo, + descriptor.getName(), + descriptor.getDescription(), + descriptor.getUnit(), + MetricData.LongGaugeData.create(points)); + case COUNTER: + case UP_DOWN_COUNTER: + case VALUE_RECORDER: + } + return null; + } + static final class Handle extends AggregatorHandle { private final AtomicReference current = new AtomicReference<>(DEFAULT_VALUE); diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/LongMinMaxSumCountAggregator.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/LongMinMaxSumCountAggregator.java index 44c17448c9..50b76049cf 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/LongMinMaxSumCountAggregator.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/LongMinMaxSumCountAggregator.java @@ -6,7 +6,14 @@ package io.opentelemetry.sdk.metrics.aggregator; import com.google.errorprone.annotations.concurrent.GuardedBy; +import io.opentelemetry.api.common.Labels; +import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.accumulation.MinMaxSumCountAccumulation; +import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.resources.Resource; +import java.util.List; +import java.util.Map; import java.util.concurrent.locks.ReentrantReadWriteLock; import javax.annotation.concurrent.ThreadSafe; @@ -35,6 +42,35 @@ public final class LongMinMaxSumCountAggregator implements Aggregator accumulationByLabels, + long startEpochNanos, + long epochNanos) { + List points = + MetricDataUtils.toDoubleSummaryPointList(accumulationByLabels, startEpochNanos, epochNanos); + return MetricData.createDoubleSummary( + resource, + instrumentationLibraryInfo, + descriptor.getName(), + descriptor.getDescription(), + descriptor.getUnit(), + MetricData.DoubleSummaryData.create(points)); + } + static final class Handle extends AggregatorHandle { private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); // The current value. This controls its own internal thread-safety via method access. Don't diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/LongSumAggregator.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/LongSumAggregator.java index 87017803ec..1df36457a9 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/LongSumAggregator.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/LongSumAggregator.java @@ -5,7 +5,15 @@ package io.opentelemetry.sdk.metrics.aggregator; +import io.opentelemetry.api.common.Labels; +import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.accumulation.LongAccumulation; +import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; +import io.opentelemetry.sdk.metrics.common.InstrumentType; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.resources.Resource; +import java.util.List; +import java.util.Map; import java.util.concurrent.atomic.LongAdder; public final class LongSumAggregator implements Aggregator { @@ -32,6 +40,28 @@ public final class LongSumAggregator implements Aggregator { return LongAccumulation.create(value); } + @Override + public LongAccumulation merge(LongAccumulation a1, LongAccumulation a2) { + return LongAccumulation.create(a1.getValue() + a2.getValue()); + } + + @Override + public MetricData toMetricData( + Resource resource, + InstrumentationLibraryInfo instrumentationLibraryInfo, + InstrumentDescriptor descriptor, + Map accumulationByLabels, + long startEpochNanos, + long epochNanos) { + List points = + MetricDataUtils.toLongPointList(accumulationByLabels, startEpochNanos, epochNanos); + boolean isMonotonic = + descriptor.getType() == InstrumentType.COUNTER + || descriptor.getType() == InstrumentType.SUM_OBSERVER; + return MetricDataUtils.toLongSumMetricData( + resource, instrumentationLibraryInfo, descriptor, points, isMonotonic); + } + static final class Handle extends AggregatorHandle { private final LongAdder current = new LongAdder(); diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/MetricDataUtils.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/MetricDataUtils.java similarity index 98% rename from sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/MetricDataUtils.java rename to sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/MetricDataUtils.java index 61c4c51b9e..c42ce93125 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregation/MetricDataUtils.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/aggregator/MetricDataUtils.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.sdk.metrics.aggregation; +package io.opentelemetry.sdk.metrics.aggregator; import io.opentelemetry.api.common.Labels; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; diff --git a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/view/AggregationConfiguration.java b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/view/AggregationConfiguration.java index 5eb4cb05d8..1fa5f03dec 100644 --- a/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/view/AggregationConfiguration.java +++ b/sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/view/AggregationConfiguration.java @@ -6,14 +6,13 @@ package io.opentelemetry.sdk.metrics.view; import com.google.auto.value.AutoValue; -import io.opentelemetry.sdk.metrics.aggregation.Aggregation; -import io.opentelemetry.sdk.metrics.aggregation.AggregationFactory; +import io.opentelemetry.sdk.metrics.aggregator.AggregatorFactory; import io.opentelemetry.sdk.metrics.data.MetricData; import javax.annotation.concurrent.Immutable; /** * An AggregationConfiguration describes how an aggregation should be performed. It includes both an - * {@link Aggregation} which implements what shape of aggregation is created (i.e. histogram, sum, + * {@code Aggregator} which implements what shape of aggregation is created (i.e. histogram, sum, * minMaxSumCount, etc), and a {@link MetricData.AggregationTemporality} which describes whether * aggregations should be reset with every collection interval, or continue to accumulate across * collection intervals. @@ -24,13 +23,13 @@ public abstract class AggregationConfiguration { /** Returns a new configuration with the provided options. */ public static AggregationConfiguration create( - AggregationFactory aggregationFactory, + AggregatorFactory aggregatorFactory, MetricData.AggregationTemporality aggregationTemporality) { - return new AutoValue_AggregationConfiguration(aggregationFactory, aggregationTemporality); + return new AutoValue_AggregationConfiguration(aggregatorFactory, aggregationTemporality); } - /** Returns the {@link Aggregation} that should be used for this View. */ - public abstract AggregationFactory getAggregationFactory(); + /** Returns the {@link AggregatorFactory} that should be used for this View. */ + public abstract AggregatorFactory getAggregatorFactory(); /** * Returns the {@link MetricData.AggregationTemporality} that should be used for this View (delta diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/SdkMeterProviderTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/SdkMeterProviderTest.java index 940f9573cc..5f6f5ded14 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/SdkMeterProviderTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/SdkMeterProviderTest.java @@ -18,7 +18,7 @@ import io.opentelemetry.api.metrics.LongUpDownCounter; import io.opentelemetry.api.metrics.LongValueRecorder; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.internal.TestClock; -import io.opentelemetry.sdk.metrics.aggregation.AggregationFactory; +import io.opentelemetry.sdk.metrics.aggregator.AggregatorFactory; import io.opentelemetry.sdk.metrics.common.InstrumentType; import io.opentelemetry.sdk.metrics.data.MetricData; import io.opentelemetry.sdk.metrics.view.AggregationConfiguration; @@ -148,7 +148,7 @@ public class SdkMeterProviderTest { registerViewForAllTypes( testMeterProvider, AggregationConfiguration.create( - AggregationFactory.count(), MetricData.AggregationTemporality.CUMULATIVE)); + AggregatorFactory.count(), MetricData.AggregationTemporality.CUMULATIVE)); LongCounter longCounter = testSdk.longCounterBuilder("testLongCounter").build(); longCounter.add(10, Labels.empty()); LongUpDownCounter longUpDownCounter = @@ -347,7 +347,7 @@ public class SdkMeterProviderTest { registerViewForAllTypes( testMeterProvider, AggregationConfiguration.create( - AggregationFactory.count(), MetricData.AggregationTemporality.CUMULATIVE)); + AggregatorFactory.count(), MetricData.AggregationTemporality.CUMULATIVE)); testSdk .longSumObserverBuilder("testLongSumObserver") .setUpdater(longResult -> longResult.observe(10, Labels.empty())) diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/SynchronousInstrumentAccumulatorTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/SynchronousInstrumentAccumulatorTest.java index 7da02cd455..4295788b20 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/SynchronousInstrumentAccumulatorTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/SynchronousInstrumentAccumulatorTest.java @@ -10,7 +10,7 @@ import static org.assertj.core.api.Assertions.assertThat; import io.opentelemetry.api.common.Labels; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.internal.TestClock; -import io.opentelemetry.sdk.metrics.aggregation.AggregationFactory; +import io.opentelemetry.sdk.metrics.aggregator.AggregatorFactory; import io.opentelemetry.sdk.metrics.aggregator.AggregatorHandle; import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; import io.opentelemetry.sdk.metrics.common.InstrumentType; @@ -35,7 +35,7 @@ public class SynchronousInstrumentAccumulatorTest { DESCRIPTOR, providerSharedState, meterSharedState, - AggregationFactory.count().create(DESCRIPTOR.getValueType()))); + AggregatorFactory.count().create(DESCRIPTOR.getValueType()))); AggregatorHandle aggregatorHandle = accumulator.bind(Labels.of("K", "V")); AggregatorHandle duplicateAggregatorHandle = accumulator.bind(Labels.of("K", "V")); try { diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/ViewRegistryTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/ViewRegistryTest.java index 80e4925fa3..7880c345eb 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/ViewRegistryTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/ViewRegistryTest.java @@ -9,7 +9,7 @@ import static org.assertj.core.api.Assertions.assertThat; import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.internal.TestClock; -import io.opentelemetry.sdk.metrics.aggregation.AggregationFactory; +import io.opentelemetry.sdk.metrics.aggregator.AggregatorFactory; import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; import io.opentelemetry.sdk.metrics.common.InstrumentType; import io.opentelemetry.sdk.metrics.common.InstrumentValueType; @@ -34,7 +34,7 @@ class ViewRegistryTest { AggregationConfiguration specification = AggregationConfiguration.create( - AggregationFactory.count(), MetricData.AggregationTemporality.CUMULATIVE); + AggregatorFactory.count(), MetricData.AggregationTemporality.CUMULATIVE); viewRegistry.registerView( InstrumentSelector.builder() .setInstrumentType(InstrumentType.COUNTER) @@ -47,7 +47,7 @@ class ViewRegistryTest { descriptor, providerSharedState, meterSharedState, - AggregationFactory.count().create(descriptor.getValueType())); + AggregatorFactory.count().create(descriptor.getValueType())); InstrumentProcessor result = viewRegistry.createBatcher(providerSharedState, meterSharedState, descriptor); @@ -72,7 +72,7 @@ class ViewRegistryTest { AggregationConfiguration specification = AggregationConfiguration.create( - AggregationFactory.count(), MetricData.AggregationTemporality.DELTA); + AggregatorFactory.count(), MetricData.AggregationTemporality.DELTA); viewRegistry.registerView( InstrumentSelector.builder() .setInstrumentType(InstrumentType.COUNTER) @@ -85,7 +85,7 @@ class ViewRegistryTest { descriptor, providerSharedState, meterSharedState, - AggregationFactory.count().create(descriptor.getValueType())); + AggregatorFactory.count().create(descriptor.getValueType())); InstrumentProcessor result = viewRegistry.createBatcher(providerSharedState, meterSharedState, descriptor); @@ -100,7 +100,7 @@ class ViewRegistryTest { void selection_onType() { AggregationConfiguration configuration = AggregationConfiguration.create( - AggregationFactory.sum(), MetricData.AggregationTemporality.DELTA); + AggregatorFactory.sum(), MetricData.AggregationTemporality.DELTA); ViewRegistry viewRegistry = new ViewRegistry(); viewRegistry.registerView( @@ -121,14 +121,14 @@ class ViewRegistryTest { "", "", "", InstrumentType.UP_DOWN_COUNTER, InstrumentValueType.LONG))) .isEqualTo( AggregationConfiguration.create( - AggregationFactory.sum(), MetricData.AggregationTemporality.CUMULATIVE)); + AggregatorFactory.sum(), MetricData.AggregationTemporality.CUMULATIVE)); } @Test void selection_onName() { AggregationConfiguration configuration = AggregationConfiguration.create( - AggregationFactory.sum(), MetricData.AggregationTemporality.DELTA); + AggregatorFactory.sum(), MetricData.AggregationTemporality.DELTA); ViewRegistry viewRegistry = new ViewRegistry(); viewRegistry.registerView( @@ -149,17 +149,17 @@ class ViewRegistryTest { "default", "", "", InstrumentType.COUNTER, InstrumentValueType.LONG))) .isEqualTo( AggregationConfiguration.create( - AggregationFactory.sum(), MetricData.AggregationTemporality.CUMULATIVE)); + AggregatorFactory.sum(), MetricData.AggregationTemporality.CUMULATIVE)); } @Test void selection_LastAddedViewWins() { AggregationConfiguration configuration1 = AggregationConfiguration.create( - AggregationFactory.sum(), MetricData.AggregationTemporality.DELTA); + AggregatorFactory.sum(), MetricData.AggregationTemporality.DELTA); AggregationConfiguration configuration2 = AggregationConfiguration.create( - AggregationFactory.count(), MetricData.AggregationTemporality.DELTA); + AggregatorFactory.count(), MetricData.AggregationTemporality.DELTA); ViewRegistry viewRegistry = new ViewRegistry(); viewRegistry.registerView( @@ -191,7 +191,7 @@ class ViewRegistryTest { void selection_regex() { AggregationConfiguration configuration1 = AggregationConfiguration.create( - AggregationFactory.sum(), MetricData.AggregationTemporality.DELTA); + AggregatorFactory.sum(), MetricData.AggregationTemporality.DELTA); ViewRegistry viewRegistry = new ViewRegistry(); viewRegistry.registerView( @@ -218,7 +218,7 @@ class ViewRegistryTest { "default", "", "", InstrumentType.UP_DOWN_COUNTER, InstrumentValueType.LONG))) .isEqualTo( AggregationConfiguration.create( - AggregationFactory.sum(), MetricData.AggregationTemporality.CUMULATIVE)); + AggregatorFactory.sum(), MetricData.AggregationTemporality.CUMULATIVE)); } @Test @@ -230,41 +230,41 @@ class ViewRegistryTest { "", "", "", InstrumentType.COUNTER, InstrumentValueType.LONG))) .isEqualTo( AggregationConfiguration.create( - AggregationFactory.sum(), MetricData.AggregationTemporality.CUMULATIVE)); + AggregatorFactory.sum(), MetricData.AggregationTemporality.CUMULATIVE)); assertThat( viewRegistry.chooseAggregation( InstrumentDescriptor.create( "", "", "", InstrumentType.UP_DOWN_COUNTER, InstrumentValueType.LONG))) .isEqualTo( AggregationConfiguration.create( - AggregationFactory.sum(), MetricData.AggregationTemporality.CUMULATIVE)); + AggregatorFactory.sum(), MetricData.AggregationTemporality.CUMULATIVE)); assertThat( viewRegistry.chooseAggregation( InstrumentDescriptor.create( "", "", "", InstrumentType.VALUE_RECORDER, InstrumentValueType.LONG))) .isEqualTo( AggregationConfiguration.create( - AggregationFactory.minMaxSumCount(), MetricData.AggregationTemporality.DELTA)); + AggregatorFactory.minMaxSumCount(), MetricData.AggregationTemporality.DELTA)); assertThat( viewRegistry.chooseAggregation( InstrumentDescriptor.create( "", "", "", InstrumentType.SUM_OBSERVER, InstrumentValueType.LONG))) .isEqualTo( AggregationConfiguration.create( - AggregationFactory.lastValue(), MetricData.AggregationTemporality.CUMULATIVE)); + AggregatorFactory.lastValue(), MetricData.AggregationTemporality.CUMULATIVE)); assertThat( viewRegistry.chooseAggregation( InstrumentDescriptor.create( "", "", "", InstrumentType.VALUE_OBSERVER, InstrumentValueType.LONG))) .isEqualTo( AggregationConfiguration.create( - AggregationFactory.lastValue(), MetricData.AggregationTemporality.DELTA)); + AggregatorFactory.lastValue(), MetricData.AggregationTemporality.DELTA)); assertThat( viewRegistry.chooseAggregation( InstrumentDescriptor.create( "", "", "", InstrumentType.UP_DOWN_SUM_OBSERVER, InstrumentValueType.LONG))) .isEqualTo( AggregationConfiguration.create( - AggregationFactory.lastValue(), MetricData.AggregationTemporality.CUMULATIVE)); + AggregatorFactory.lastValue(), MetricData.AggregationTemporality.CUMULATIVE)); } } diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregation/CountAggregationTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregation/CountAggregationTest.java deleted file mode 100644 index 1d515e79c4..0000000000 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregation/CountAggregationTest.java +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.metrics.aggregation; - -import static org.assertj.core.api.Assertions.assertThat; - -import io.opentelemetry.api.common.Labels; -import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; -import io.opentelemetry.sdk.metrics.accumulation.LongAccumulation; -import io.opentelemetry.sdk.metrics.aggregator.AggregatorHandle; -import io.opentelemetry.sdk.metrics.aggregator.CountAggregator; -import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; -import io.opentelemetry.sdk.metrics.common.InstrumentType; -import io.opentelemetry.sdk.metrics.common.InstrumentValueType; -import io.opentelemetry.sdk.metrics.data.MetricData; -import io.opentelemetry.sdk.resources.Resource; -import java.util.Collections; -import org.junit.jupiter.api.Test; - -class CountAggregationTest { - @Test - void toMetricData() { - Aggregation count = - AggregationFactory.count().create(InstrumentValueType.LONG); - AggregatorHandle aggregatorHandle = count.getAggregator().createHandle(); - aggregatorHandle.recordLong(10); - - MetricData metricData = - count.toMetricData( - Resource.getDefault(), - InstrumentationLibraryInfo.getEmpty(), - InstrumentDescriptor.create( - "name", - "description", - "unit", - InstrumentType.VALUE_RECORDER, - InstrumentValueType.LONG), - Collections.singletonMap(Labels.empty(), aggregatorHandle.accumulateThenReset()), - 0, - 100); - assertThat(metricData).isNotNull(); - assertThat(metricData.getUnit()).isEqualTo("1"); - assertThat(metricData.getType()).isEqualTo(MetricData.Type.LONG_SUM); - } - - @Test - void getAggregatorFactory() { - AggregationFactory count = AggregationFactory.count(); - assertThat(count.create(InstrumentValueType.LONG).getAggregator()) - .isInstanceOf(CountAggregator.getInstance().getClass()); - assertThat(count.create(InstrumentValueType.DOUBLE).getAggregator()) - .isInstanceOf(CountAggregator.getInstance().getClass()); - } -} diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregation/LastValueAggregationTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregation/LastValueAggregationTest.java deleted file mode 100644 index 51753edec4..0000000000 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregation/LastValueAggregationTest.java +++ /dev/null @@ -1,60 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.metrics.aggregation; - -import static org.assertj.core.api.Assertions.assertThat; - -import io.opentelemetry.api.common.Labels; -import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; -import io.opentelemetry.sdk.metrics.accumulation.LongAccumulation; -import io.opentelemetry.sdk.metrics.aggregator.AggregatorHandle; -import io.opentelemetry.sdk.metrics.aggregator.DoubleLastValueAggregator; -import io.opentelemetry.sdk.metrics.aggregator.LongLastValueAggregator; -import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; -import io.opentelemetry.sdk.metrics.common.InstrumentType; -import io.opentelemetry.sdk.metrics.common.InstrumentValueType; -import io.opentelemetry.sdk.metrics.data.MetricData; -import io.opentelemetry.sdk.resources.Resource; -import java.util.Collections; -import org.junit.jupiter.api.Test; - -class LastValueAggregationTest { - - @Test - void toMetricData() { - Aggregation lastValue = - AggregationFactory.lastValue().create(InstrumentValueType.LONG); - AggregatorHandle aggregatorHandle = lastValue.getAggregator().createHandle(); - aggregatorHandle.recordLong(10); - - MetricData metricData = - lastValue.toMetricData( - Resource.getDefault(), - InstrumentationLibraryInfo.getEmpty(), - InstrumentDescriptor.create( - "name", - "description", - "unit", - InstrumentType.VALUE_OBSERVER, - InstrumentValueType.LONG), - Collections.singletonMap(Labels.empty(), aggregatorHandle.accumulateThenReset()), - 0, - 100); - assertThat(metricData).isNotNull(); - assertThat(metricData.getType()).isEqualTo(MetricData.Type.LONG_GAUGE); - assertThat(metricData.getLongGaugeData().getPoints()) - .containsExactly(MetricData.LongPoint.create(0, 100, Labels.empty(), 10)); - } - - @Test - void getAggregatorFactory() { - AggregationFactory lastValue = AggregationFactory.lastValue(); - assertThat(lastValue.create(InstrumentValueType.LONG).getAggregator()) - .isInstanceOf(LongLastValueAggregator.getInstance().getClass()); - assertThat(lastValue.create(InstrumentValueType.DOUBLE).getAggregator()) - .isInstanceOf(DoubleLastValueAggregator.getInstance().getClass()); - } -} diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregation/MinMaxSumCountAggregationTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregation/MinMaxSumCountAggregationTest.java deleted file mode 100644 index 5c2b0fc276..0000000000 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregation/MinMaxSumCountAggregationTest.java +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.metrics.aggregation; - -import static org.assertj.core.api.Assertions.assertThat; - -import io.opentelemetry.api.common.Labels; -import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; -import io.opentelemetry.sdk.metrics.accumulation.MinMaxSumCountAccumulation; -import io.opentelemetry.sdk.metrics.aggregator.AggregatorHandle; -import io.opentelemetry.sdk.metrics.aggregator.DoubleMinMaxSumCountAggregator; -import io.opentelemetry.sdk.metrics.aggregator.LongMinMaxSumCountAggregator; -import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; -import io.opentelemetry.sdk.metrics.common.InstrumentType; -import io.opentelemetry.sdk.metrics.common.InstrumentValueType; -import io.opentelemetry.sdk.metrics.data.MetricData; -import io.opentelemetry.sdk.resources.Resource; -import java.util.Collections; -import org.junit.jupiter.api.Test; - -class MinMaxSumCountAggregationTest { - - @Test - void toMetricData() { - Aggregation minMaxSumCount = - AggregationFactory.minMaxSumCount().create(InstrumentValueType.LONG); - AggregatorHandle aggregatorHandle = - minMaxSumCount.getAggregator().createHandle(); - aggregatorHandle.recordLong(10); - - MetricData metricData = - minMaxSumCount.toMetricData( - Resource.getDefault(), - InstrumentationLibraryInfo.getEmpty(), - InstrumentDescriptor.create( - "name", - "description", - "unit", - InstrumentType.VALUE_RECORDER, - InstrumentValueType.LONG), - Collections.singletonMap(Labels.empty(), aggregatorHandle.accumulateThenReset()), - 0, - 100); - assertThat(metricData).isNotNull(); - assertThat(metricData.getType()).isEqualTo(MetricData.Type.SUMMARY); - } - - @Test - void getAggregatorFactory() { - AggregationFactory minMaxSumCount = AggregationFactory.minMaxSumCount(); - assertThat(minMaxSumCount.create(InstrumentValueType.LONG).getAggregator()) - .isInstanceOf(LongMinMaxSumCountAggregator.getInstance().getClass()); - assertThat(minMaxSumCount.create(InstrumentValueType.DOUBLE).getAggregator()) - .isInstanceOf(DoubleMinMaxSumCountAggregator.getInstance().getClass()); - } -} diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregation/SumAggregationTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregation/SumAggregationTest.java deleted file mode 100644 index 66741ad82c..0000000000 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregation/SumAggregationTest.java +++ /dev/null @@ -1,78 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.metrics.aggregation; - -import static org.assertj.core.api.Assertions.assertThat; - -import io.opentelemetry.api.common.Labels; -import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; -import io.opentelemetry.sdk.metrics.accumulation.DoubleAccumulation; -import io.opentelemetry.sdk.metrics.accumulation.LongAccumulation; -import io.opentelemetry.sdk.metrics.aggregator.AggregatorHandle; -import io.opentelemetry.sdk.metrics.aggregator.DoubleSumAggregator; -import io.opentelemetry.sdk.metrics.aggregator.LongSumAggregator; -import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; -import io.opentelemetry.sdk.metrics.common.InstrumentType; -import io.opentelemetry.sdk.metrics.common.InstrumentValueType; -import io.opentelemetry.sdk.metrics.data.MetricData; -import io.opentelemetry.sdk.resources.Resource; -import java.util.Collections; -import org.junit.jupiter.api.Test; - -/** Unit tests for {@link AggregationFactory#sum()}. */ -class SumAggregationTest { - - @Test - void toDoubleMetricData() { - Aggregation sum = DoubleSumAggregation.INSTANCE; - AggregatorHandle aggregatorHandle = sum.getAggregator().createHandle(); - aggregatorHandle.recordDouble(10); - - MetricData metricData = - sum.toMetricData( - Resource.getDefault(), - InstrumentationLibraryInfo.getEmpty(), - InstrumentDescriptor.create( - "name", "description", "unit", InstrumentType.COUNTER, InstrumentValueType.DOUBLE), - Collections.singletonMap(Labels.empty(), aggregatorHandle.accumulateThenReset()), - 0, - 100); - assertThat(metricData).isNotNull(); - assertThat(metricData.getType()).isEqualTo(MetricData.Type.DOUBLE_SUM); - assertThat(metricData.getDoubleSumData().getPoints()) - .containsExactly(MetricData.DoublePoint.create(0, 100, Labels.empty(), 10)); - } - - @Test - void toLongMetricData() { - Aggregation sum = LongSumAggregation.INSTANCE; - AggregatorHandle aggregatorHandle = sum.getAggregator().createHandle(); - aggregatorHandle.recordLong(10); - - MetricData metricData = - sum.toMetricData( - Resource.getDefault(), - InstrumentationLibraryInfo.getEmpty(), - InstrumentDescriptor.create( - "name", "description", "unit", InstrumentType.COUNTER, InstrumentValueType.LONG), - Collections.singletonMap(Labels.empty(), aggregatorHandle.accumulateThenReset()), - 0, - 100); - assertThat(metricData).isNotNull(); - assertThat(metricData.getType()).isEqualTo(MetricData.Type.LONG_SUM); - assertThat(metricData.getLongSumData().getPoints()) - .containsExactly(MetricData.LongPoint.create(0, 100, Labels.empty(), 10)); - } - - @Test - void getAggregatorFactory() { - AggregationFactory sum = AggregationFactory.sum(); - assertThat(sum.create(InstrumentValueType.LONG).getAggregator()) - .isInstanceOf(LongSumAggregator.getInstance().getClass()); - assertThat(sum.create(InstrumentValueType.DOUBLE).getAggregator()) - .isInstanceOf(DoubleSumAggregator.getInstance().getClass()); - } -} diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/AggregatorFactoryTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/AggregatorFactoryTest.java new file mode 100644 index 0000000000..911e8547d9 --- /dev/null +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/AggregatorFactoryTest.java @@ -0,0 +1,49 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.sdk.metrics.aggregator; + +import static org.assertj.core.api.Assertions.assertThat; + +import io.opentelemetry.sdk.metrics.common.InstrumentValueType; +import org.junit.jupiter.api.Test; + +class AggregatorFactoryTest { + @Test + void getCountAggregatorFactory() { + AggregatorFactory count = AggregatorFactory.count(); + assertThat(count.create(InstrumentValueType.LONG)) + .isInstanceOf(CountAggregator.getInstance().getClass()); + assertThat(count.create(InstrumentValueType.DOUBLE)) + .isInstanceOf(CountAggregator.getInstance().getClass()); + } + + @Test + void getLastValueAggregatorFactory() { + AggregatorFactory lastValue = AggregatorFactory.lastValue(); + assertThat(lastValue.create(InstrumentValueType.LONG)) + .isInstanceOf(LongLastValueAggregator.getInstance().getClass()); + assertThat(lastValue.create(InstrumentValueType.DOUBLE)) + .isInstanceOf(DoubleLastValueAggregator.getInstance().getClass()); + } + + @Test + void getMinMaxSumCountAggregatorFactory() { + AggregatorFactory minMaxSumCount = AggregatorFactory.minMaxSumCount(); + assertThat(minMaxSumCount.create(InstrumentValueType.LONG)) + .isInstanceOf(LongMinMaxSumCountAggregator.getInstance().getClass()); + assertThat(minMaxSumCount.create(InstrumentValueType.DOUBLE)) + .isInstanceOf(DoubleMinMaxSumCountAggregator.getInstance().getClass()); + } + + @Test + void getSumAggregatorFactory() { + AggregatorFactory sum = AggregatorFactory.sum(); + assertThat(sum.create(InstrumentValueType.LONG)) + .isInstanceOf(LongSumAggregator.getInstance().getClass()); + assertThat(sum.create(InstrumentValueType.DOUBLE)) + .isInstanceOf(DoubleSumAggregator.getInstance().getClass()); + } +} diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/CountAggregatorTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/CountAggregatorTest.java index 9e3d9ee616..8f5af7a573 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/CountAggregatorTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/CountAggregatorTest.java @@ -7,7 +7,15 @@ package io.opentelemetry.sdk.metrics.aggregator; import static org.assertj.core.api.Assertions.assertThat; +import io.opentelemetry.api.common.Labels; +import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.accumulation.LongAccumulation; +import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; +import io.opentelemetry.sdk.metrics.common.InstrumentType; +import io.opentelemetry.sdk.metrics.common.InstrumentValueType; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.resources.Resource; +import java.util.Collections; import org.junit.jupiter.api.Test; /** Unit tests for {@link CountAggregator}. */ @@ -42,4 +50,38 @@ class CountAggregatorTest { aggregatorHandle.recordDouble(12.3); assertThat(aggregatorHandle.accumulateThenReset()).isEqualTo(LongAccumulation.create(2)); } + + @Test + void toMetricData() { + Aggregator count = CountAggregator.getInstance(); + AggregatorHandle aggregatorHandle = count.createHandle(); + aggregatorHandle.recordLong(10); + + MetricData metricData = + count.toMetricData( + Resource.getDefault(), + InstrumentationLibraryInfo.getEmpty(), + InstrumentDescriptor.create( + "name", + "description", + "unit", + InstrumentType.VALUE_RECORDER, + InstrumentValueType.LONG), + Collections.singletonMap(Labels.empty(), aggregatorHandle.accumulateThenReset()), + 0, + 100); + assertThat(metricData) + .isEqualTo( + MetricData.createLongSum( + Resource.getDefault(), + InstrumentationLibraryInfo.getEmpty(), + "name", + "description", + "1", + MetricData.LongSumData.create( + /* isMonotonic= */ true, + MetricData.AggregationTemporality.CUMULATIVE, + Collections.singletonList( + MetricData.LongPoint.create(0, 100, Labels.empty(), 1))))); + } } diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/DoubleLastValueAggregatorTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/DoubleLastValueAggregatorTest.java index db7d02a51f..22b8e930a9 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/DoubleLastValueAggregatorTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/DoubleLastValueAggregatorTest.java @@ -7,7 +7,15 @@ package io.opentelemetry.sdk.metrics.aggregator; import static org.assertj.core.api.Assertions.assertThat; +import io.opentelemetry.api.common.Labels; +import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.accumulation.DoubleAccumulation; +import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; +import io.opentelemetry.sdk.metrics.common.InstrumentType; +import io.opentelemetry.sdk.metrics.common.InstrumentValueType; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.resources.Resource; +import java.util.Collections; import org.junit.jupiter.api.Test; /** Unit tests for {@link AggregatorHandle}. */ @@ -43,4 +51,36 @@ class DoubleLastValueAggregatorTest { assertThat(aggregatorHandle.accumulateThenReset()).isEqualTo(DoubleAccumulation.create(12.1)); assertThat(aggregatorHandle.accumulateThenReset()).isNull(); } + + @Test + void toMetricData() { + Aggregator lastValue = DoubleLastValueAggregator.getInstance(); + AggregatorHandle aggregatorHandle = lastValue.createHandle(); + aggregatorHandle.recordDouble(10); + + MetricData metricData = + lastValue.toMetricData( + Resource.getDefault(), + InstrumentationLibraryInfo.getEmpty(), + InstrumentDescriptor.create( + "name", + "description", + "unit", + InstrumentType.VALUE_OBSERVER, + InstrumentValueType.LONG), + Collections.singletonMap(Labels.empty(), aggregatorHandle.accumulateThenReset()), + 0, + 100); + assertThat(metricData) + .isEqualTo( + MetricData.createDoubleGauge( + Resource.getDefault(), + InstrumentationLibraryInfo.getEmpty(), + "name", + "description", + "unit", + MetricData.DoubleGaugeData.create( + Collections.singletonList( + MetricData.DoublePoint.create(0, 100, Labels.empty(), 10))))); + } } diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/DoubleMinMaxSumCountAggregatorTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/DoubleMinMaxSumCountAggregatorTest.java index 865fb6a98a..2696cf4f5c 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/DoubleMinMaxSumCountAggregatorTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/DoubleMinMaxSumCountAggregatorTest.java @@ -8,11 +8,17 @@ package io.opentelemetry.sdk.metrics.aggregator; import static org.assertj.core.api.Assertions.assertThat; import com.google.errorprone.annotations.concurrent.GuardedBy; +import io.opentelemetry.api.common.Labels; +import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.accumulation.Accumulation; import io.opentelemetry.sdk.metrics.accumulation.MinMaxSumCountAccumulation; -import io.opentelemetry.sdk.metrics.aggregation.AggregationFactory; +import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; +import io.opentelemetry.sdk.metrics.common.InstrumentType; import io.opentelemetry.sdk.metrics.common.InstrumentValueType; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.resources.Resource; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ThreadLocalRandom; @@ -62,6 +68,30 @@ class DoubleMinMaxSumCountAggregatorTest { assertThat(aggregatorHandle.accumulateThenReset()).isNull(); } + @Test + void toMetricData() { + Aggregator minMaxSumCount = + DoubleMinMaxSumCountAggregator.getInstance(); + AggregatorHandle aggregatorHandle = minMaxSumCount.createHandle(); + aggregatorHandle.recordDouble(10); + + MetricData metricData = + minMaxSumCount.toMetricData( + Resource.getDefault(), + InstrumentationLibraryInfo.getEmpty(), + InstrumentDescriptor.create( + "name", + "description", + "unit", + InstrumentType.VALUE_RECORDER, + InstrumentValueType.LONG), + Collections.singletonMap(Labels.empty(), aggregatorHandle.accumulateThenReset()), + 0, + 100); + assertThat(metricData).isNotNull(); + assertThat(metricData.getType()).isEqualTo(MetricData.Type.SUMMARY); + } + @Test void testMultithreadedUpdates() throws Exception { final AggregatorHandle aggregatorHandle = @@ -126,7 +156,7 @@ class DoubleMinMaxSumCountAggregatorTest { return; } accumulation = - AggregationFactory.minMaxSumCount() + AggregatorFactory.minMaxSumCount() .create(InstrumentValueType.DOUBLE) .merge(accumulation, other); } finally { diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/DoubleSumAggregatorTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/DoubleSumAggregatorTest.java index c322620b38..d52486902d 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/DoubleSumAggregatorTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/DoubleSumAggregatorTest.java @@ -7,7 +7,15 @@ package io.opentelemetry.sdk.metrics.aggregator; import static org.assertj.core.api.Assertions.assertThat; +import io.opentelemetry.api.common.Labels; +import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.accumulation.DoubleAccumulation; +import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; +import io.opentelemetry.sdk.metrics.common.InstrumentType; +import io.opentelemetry.sdk.metrics.common.InstrumentValueType; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.resources.Resource; +import java.util.Collections; import org.junit.jupiter.api.Test; /** Unit tests for {@link DoubleSumAggregator}. */ @@ -60,4 +68,34 @@ class DoubleSumAggregatorTest { assertThat(aggregatorHandle.accumulateThenReset()).isEqualTo(DoubleAccumulation.create(-13)); assertThat(aggregatorHandle.accumulateThenReset()).isNull(); } + + @Test + void toMetricData() { + Aggregator sum = DoubleSumAggregator.getInstance(); + AggregatorHandle aggregatorHandle = sum.createHandle(); + aggregatorHandle.recordDouble(10); + + MetricData metricData = + sum.toMetricData( + Resource.getDefault(), + InstrumentationLibraryInfo.getEmpty(), + InstrumentDescriptor.create( + "name", "description", "unit", InstrumentType.COUNTER, InstrumentValueType.DOUBLE), + Collections.singletonMap(Labels.empty(), aggregatorHandle.accumulateThenReset()), + 0, + 100); + assertThat(metricData) + .isEqualTo( + MetricData.createDoubleSum( + Resource.getDefault(), + InstrumentationLibraryInfo.getEmpty(), + "name", + "description", + "unit", + MetricData.DoubleSumData.create( + /* isMonotonic= */ true, + MetricData.AggregationTemporality.CUMULATIVE, + Collections.singletonList( + MetricData.DoublePoint.create(0, 100, Labels.empty(), 10))))); + } } diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/LongLastValueAggregatorTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/LongLastValueAggregatorTest.java index 83b4ab7152..9945b77af0 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/LongLastValueAggregatorTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/LongLastValueAggregatorTest.java @@ -7,7 +7,15 @@ package io.opentelemetry.sdk.metrics.aggregator; import static org.assertj.core.api.Assertions.assertThat; +import io.opentelemetry.api.common.Labels; +import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.accumulation.LongAccumulation; +import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; +import io.opentelemetry.sdk.metrics.common.InstrumentType; +import io.opentelemetry.sdk.metrics.common.InstrumentValueType; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.resources.Resource; +import java.util.Collections; import org.junit.jupiter.api.Test; /** Unit tests for {@link LongLastValueAggregator}. */ @@ -43,4 +51,36 @@ class LongLastValueAggregatorTest { assertThat(aggregatorHandle.accumulateThenReset()).isEqualTo(LongAccumulation.create(12)); assertThat(aggregatorHandle.accumulateThenReset()).isNull(); } + + @Test + void toMetricData() { + Aggregator lastValue = LongLastValueAggregator.getInstance(); + AggregatorHandle aggregatorHandle = lastValue.createHandle(); + aggregatorHandle.recordLong(10); + + MetricData metricData = + lastValue.toMetricData( + Resource.getDefault(), + InstrumentationLibraryInfo.getEmpty(), + InstrumentDescriptor.create( + "name", + "description", + "unit", + InstrumentType.VALUE_OBSERVER, + InstrumentValueType.LONG), + Collections.singletonMap(Labels.empty(), aggregatorHandle.accumulateThenReset()), + 0, + 100); + assertThat(metricData) + .isEqualTo( + MetricData.createLongGauge( + Resource.getDefault(), + InstrumentationLibraryInfo.getEmpty(), + "name", + "description", + "unit", + MetricData.LongGaugeData.create( + Collections.singletonList( + MetricData.LongPoint.create(0, 100, Labels.empty(), 10))))); + } } diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/LongMinMaxSumCountAggregatorTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/LongMinMaxSumCountAggregatorTest.java index a3c7c26729..d7e12b036f 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/LongMinMaxSumCountAggregatorTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/LongMinMaxSumCountAggregatorTest.java @@ -8,11 +8,17 @@ package io.opentelemetry.sdk.metrics.aggregator; import static org.assertj.core.api.Assertions.assertThat; import com.google.errorprone.annotations.concurrent.GuardedBy; +import io.opentelemetry.api.common.Labels; +import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.accumulation.Accumulation; import io.opentelemetry.sdk.metrics.accumulation.MinMaxSumCountAccumulation; -import io.opentelemetry.sdk.metrics.aggregation.AggregationFactory; +import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; +import io.opentelemetry.sdk.metrics.common.InstrumentType; import io.opentelemetry.sdk.metrics.common.InstrumentValueType; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.resources.Resource; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ThreadLocalRandom; @@ -59,6 +65,30 @@ class LongMinMaxSumCountAggregatorTest { assertThat(aggregatorHandle.accumulateThenReset()).isNull(); } + @Test + void toMetricData() { + Aggregator minMaxSumCount = + LongMinMaxSumCountAggregator.getInstance(); + AggregatorHandle aggregatorHandle = minMaxSumCount.createHandle(); + aggregatorHandle.recordLong(10); + + MetricData metricData = + minMaxSumCount.toMetricData( + Resource.getDefault(), + InstrumentationLibraryInfo.getEmpty(), + InstrumentDescriptor.create( + "name", + "description", + "unit", + InstrumentType.VALUE_RECORDER, + InstrumentValueType.LONG), + Collections.singletonMap(Labels.empty(), aggregatorHandle.accumulateThenReset()), + 0, + 100); + assertThat(metricData).isNotNull(); + assertThat(metricData.getType()).isEqualTo(MetricData.Type.SUMMARY); + } + @Test void testMultithreadedUpdates() throws Exception { final AggregatorHandle aggregatorHandle = @@ -123,7 +153,7 @@ class LongMinMaxSumCountAggregatorTest { return; } accumulation = - AggregationFactory.minMaxSumCount() + AggregatorFactory.minMaxSumCount() .create(InstrumentValueType.LONG) .merge(accumulation, other); } finally { diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/LongSumAggregatorTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/LongSumAggregatorTest.java index efb52c1c29..6a0da08b79 100644 --- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/LongSumAggregatorTest.java +++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/aggregator/LongSumAggregatorTest.java @@ -7,7 +7,15 @@ package io.opentelemetry.sdk.metrics.aggregator; import static org.assertj.core.api.Assertions.assertThat; +import io.opentelemetry.api.common.Labels; +import io.opentelemetry.sdk.common.InstrumentationLibraryInfo; import io.opentelemetry.sdk.metrics.accumulation.LongAccumulation; +import io.opentelemetry.sdk.metrics.common.InstrumentDescriptor; +import io.opentelemetry.sdk.metrics.common.InstrumentType; +import io.opentelemetry.sdk.metrics.common.InstrumentValueType; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.resources.Resource; +import java.util.Collections; import org.junit.jupiter.api.Test; /** Unit tests for {@link LongSumAggregator}. */ @@ -61,4 +69,34 @@ class LongSumAggregatorTest { assertThat(aggregatorHandle.accumulateThenReset()).isEqualTo(LongAccumulation.create(-13)); assertThat(aggregatorHandle.accumulateThenReset()).isNull(); } + + @Test + void toMetricData() { + Aggregator sum = LongSumAggregator.getInstance(); + AggregatorHandle aggregatorHandle = sum.createHandle(); + aggregatorHandle.recordLong(10); + + MetricData metricData = + sum.toMetricData( + Resource.getDefault(), + InstrumentationLibraryInfo.getEmpty(), + InstrumentDescriptor.create( + "name", "description", "unit", InstrumentType.COUNTER, InstrumentValueType.LONG), + Collections.singletonMap(Labels.empty(), aggregatorHandle.accumulateThenReset()), + 0, + 100); + assertThat(metricData) + .isEqualTo( + MetricData.createLongSum( + Resource.getDefault(), + InstrumentationLibraryInfo.getEmpty(), + "name", + "description", + "unit", + MetricData.LongSumData.create( + /* isMonotonic= */ true, + MetricData.AggregationTemporality.CUMULATIVE, + Collections.singletonList( + MetricData.LongPoint.create(0, 100, Labels.empty(), 10))))); + } }