From f6064c1653334c622247e32cfc82991ba145d2e2 Mon Sep 17 00:00:00 2001 From: Yang Song Date: Wed, 25 Jul 2018 17:12:03 -0700 Subject: Cleanup: Move static util methods to util class. (#1343) * Cleanup: Move static util methods to util class. * Fix checker framework. --- .../opencensus/implcore/stats/IntervalBucket.java | 2 +- .../implcore/stats/MeasureToViewMap.java | 58 +--- .../opencensus/implcore/stats/MutableViewData.java | 251 +---------------- .../io/opencensus/implcore/stats/RecordUtils.java | 306 +++++++++++++++++++++ .../implcore/stats/MutableViewDataTest.java | 114 -------- .../opencensus/implcore/stats/RecordUtilsTest.java | 144 ++++++++++ .../implcore/stats/StatsRecorderImplTest.java | 16 +- .../opencensus/implcore/stats/StatsTestUtil.java | 21 +- .../implcore/stats/ViewManagerImplTest.java | 4 +- 9 files changed, 480 insertions(+), 436 deletions(-) create mode 100644 impl_core/src/main/java/io/opencensus/implcore/stats/RecordUtils.java create mode 100644 impl_core/src/test/java/io/opencensus/implcore/stats/RecordUtilsTest.java diff --git a/impl_core/src/main/java/io/opencensus/implcore/stats/IntervalBucket.java b/impl_core/src/main/java/io/opencensus/implcore/stats/IntervalBucket.java index 12cb319e..75efabf7 100644 --- a/impl_core/src/main/java/io/opencensus/implcore/stats/IntervalBucket.java +++ b/impl_core/src/main/java/io/opencensus/implcore/stats/IntervalBucket.java @@ -67,7 +67,7 @@ final class IntervalBucket { Map attachments, Timestamp timestamp) { if (!tagValueAggregationMap.containsKey(tagValues)) { - tagValueAggregationMap.put(tagValues, MutableViewData.createMutableAggregation(aggregation)); + tagValueAggregationMap.put(tagValues, RecordUtils.createMutableAggregation(aggregation)); } tagValueAggregationMap.get(tagValues).add(value, attachments, timestamp); } diff --git a/impl_core/src/main/java/io/opencensus/implcore/stats/MeasureToViewMap.java b/impl_core/src/main/java/io/opencensus/implcore/stats/MeasureToViewMap.java index b5917289..79e913db 100644 --- a/impl_core/src/main/java/io/opencensus/implcore/stats/MeasureToViewMap.java +++ b/impl_core/src/main/java/io/opencensus/implcore/stats/MeasureToViewMap.java @@ -21,13 +21,9 @@ import com.google.common.collect.Maps; import com.google.common.collect.Multimap; import com.google.common.collect.Sets; import io.opencensus.common.Clock; -import io.opencensus.common.Function; -import io.opencensus.common.Functions; import io.opencensus.common.Timestamp; import io.opencensus.stats.Measure; import io.opencensus.stats.Measurement; -import io.opencensus.stats.Measurement.MeasurementDouble; -import io.opencensus.stats.Measurement.MeasurementLong; import io.opencensus.stats.StatsCollectionState; import io.opencensus.stats.View; import io.opencensus.stats.ViewData; @@ -156,10 +152,8 @@ final class MeasureToViewMap { } Collection views = mutableMap.get(measure.getName()); for (MutableViewData view : views) { - measurement.match( - new RecordDoubleValueFunc(tags, view, timestamp, attachments), - new RecordLongValueFunc(tags, view, timestamp, attachments), - Functions.throwAssertionError()); + view.record( + tags, RecordUtils.getDoubleValueFromMeasurement(measurement), timestamp, attachments); } } } @@ -181,52 +175,4 @@ final class MeasureToViewMap { } } } - - private static final class RecordDoubleValueFunc implements Function { - @Override - public Void apply(MeasurementDouble arg) { - view.record(tags, arg.getValue(), timestamp, attachments); - return null; - } - - private final TagContext tags; - private final MutableViewData view; - private final Timestamp timestamp; - private final Map attachments; - - private RecordDoubleValueFunc( - TagContext tags, - MutableViewData view, - Timestamp timestamp, - Map attachments) { - this.tags = tags; - this.view = view; - this.timestamp = timestamp; - this.attachments = attachments; - } - } - - private static final class RecordLongValueFunc implements Function { - @Override - public Void apply(MeasurementLong arg) { - view.record(tags, arg.getValue(), timestamp, attachments); - return null; - } - - private final TagContext tags; - private final MutableViewData view; - private final Timestamp timestamp; - private final Map attachments; - - private RecordLongValueFunc( - TagContext tags, - MutableViewData view, - Timestamp timestamp, - Map attachments) { - this.tags = tags; - this.view = view; - this.timestamp = timestamp; - this.attachments = attachments; - } - } } diff --git a/impl_core/src/main/java/io/opencensus/implcore/stats/MutableViewData.java b/impl_core/src/main/java/io/opencensus/implcore/stats/MutableViewData.java index df99ecfb..876415a3 100644 --- a/impl_core/src/main/java/io/opencensus/implcore/stats/MutableViewData.java +++ b/impl_core/src/main/java/io/opencensus/implcore/stats/MutableViewData.java @@ -17,6 +17,10 @@ package io.opencensus.implcore.stats; import static com.google.common.base.Preconditions.checkArgument; +import static io.opencensus.implcore.stats.RecordUtils.createAggregationMap; +import static io.opencensus.implcore.stats.RecordUtils.createMutableAggregation; +import static io.opencensus.implcore.stats.RecordUtils.getTagMap; +import static io.opencensus.implcore.stats.RecordUtils.getTagValues; import com.google.common.annotations.VisibleForTesting; import com.google.common.collect.LinkedHashMultimap; @@ -27,37 +31,14 @@ import io.opencensus.common.Function; import io.opencensus.common.Functions; import io.opencensus.common.Timestamp; import io.opencensus.implcore.internal.CheckerFrameworkUtils; -import io.opencensus.implcore.stats.MutableAggregation.MutableCount; -import io.opencensus.implcore.stats.MutableAggregation.MutableDistribution; -import io.opencensus.implcore.stats.MutableAggregation.MutableLastValue; -import io.opencensus.implcore.stats.MutableAggregation.MutableMean; -import io.opencensus.implcore.stats.MutableAggregation.MutableSum; -import io.opencensus.implcore.tags.TagContextImpl; import io.opencensus.stats.Aggregation; -import io.opencensus.stats.Aggregation.Count; -import io.opencensus.stats.Aggregation.Distribution; -import io.opencensus.stats.Aggregation.LastValue; -import io.opencensus.stats.Aggregation.Sum; import io.opencensus.stats.AggregationData; -import io.opencensus.stats.AggregationData.CountData; -import io.opencensus.stats.AggregationData.DistributionData; -import io.opencensus.stats.AggregationData.DistributionData.Exemplar; -import io.opencensus.stats.AggregationData.LastValueDataDouble; -import io.opencensus.stats.AggregationData.LastValueDataLong; -import io.opencensus.stats.AggregationData.SumDataDouble; -import io.opencensus.stats.AggregationData.SumDataLong; -import io.opencensus.stats.Measure; import io.opencensus.stats.StatsCollectionState; import io.opencensus.stats.View; import io.opencensus.stats.ViewData; -import io.opencensus.tags.InternalUtils; -import io.opencensus.tags.Tag; import io.opencensus.tags.TagContext; -import io.opencensus.tags.TagKey; import io.opencensus.tags.TagValue; -import java.util.ArrayList; import java.util.Collections; -import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Map; @@ -71,8 +52,6 @@ import org.checkerframework.checker.nullness.qual.Nullable; @SuppressWarnings("deprecation") abstract class MutableViewData { - @javax.annotation.Nullable @VisibleForTesting static final TagValue UNKNOWN_TAG_VALUE = null; - @VisibleForTesting static final Timestamp ZERO_TIMESTAMP = Timestamp.create(0, 0); private final View view; @@ -101,16 +80,10 @@ abstract class MutableViewData { return view; } - /** Record double stats with the given tags. */ + /** Record stats with the given tags. */ abstract void record( TagContext context, double value, Timestamp timestamp, Map attachments); - /** Record long stats with the given tags. */ - void record(TagContext tags, long value, Timestamp timestamp, Map attachments) { - // TODO(songya): shall we check for precision loss here? - record(tags, (double) value, timestamp, attachments); - } - /** Convert this {@link MutableViewData} to {@link ViewData}. */ abstract ViewData toViewData(Timestamp now, StatsCollectionState state); @@ -121,81 +94,6 @@ abstract class MutableViewData { // bucket list (for InternalMutableViewData). abstract void resumeStatsCollection(Timestamp now); - private static Map getTagMap(TagContext ctx) { - if (ctx instanceof TagContextImpl) { - return ((TagContextImpl) ctx).getTags(); - } else { - Map tags = Maps.newHashMap(); - for (Iterator i = InternalUtils.getTags(ctx); i.hasNext(); ) { - Tag tag = i.next(); - tags.put(tag.getKey(), tag.getValue()); - } - return tags; - } - } - - @VisibleForTesting - static List getTagValues( - Map tags, List columns) { - List tagValues = new ArrayList(columns.size()); - // Record all the measures in a "Greedy" way. - // Every view aggregates every measure. This is similar to doing a GROUPBY view’s keys. - for (int i = 0; i < columns.size(); ++i) { - TagKey tagKey = columns.get(i); - if (!tags.containsKey(tagKey)) { - // replace not found key values by null. - tagValues.add(UNKNOWN_TAG_VALUE); - } else { - tagValues.add(tags.get(tagKey)); - } - } - return tagValues; - } - - /** - * Create an empty {@link MutableAggregation} based on the given {@link Aggregation}. - * - * @param aggregation {@code Aggregation}. - * @return an empty {@code MutableAggregation}. - */ - @VisibleForTesting - static MutableAggregation createMutableAggregation(Aggregation aggregation) { - return aggregation.match( - CreateMutableSum.INSTANCE, - CreateMutableCount.INSTANCE, - CreateMutableDistribution.INSTANCE, - CreateMutableLastValue.INSTANCE, - AggregationDefaultFunction.INSTANCE); - } - - /** - * Create an {@link AggregationData} snapshot based on the given {@link MutableAggregation}. - * - * @param aggregation {@code MutableAggregation} - * @param measure {@code Measure} - * @return an {@code AggregationData} which is the snapshot of current summary statistics. - */ - @VisibleForTesting - static AggregationData createAggregationData(MutableAggregation aggregation, Measure measure) { - return aggregation.match( - new CreateSumData(measure), - CreateCountData.INSTANCE, - CreateMeanData.INSTANCE, - CreateDistributionData.INSTANCE, - new CreateLastValueData(measure)); - } - - // Covert a mapping from TagValues to MutableAggregation, to a mapping from TagValues to - // AggregationData. - private static Map createAggregationMap( - Map tagValueAggregationMap, Measure measure) { - Map map = Maps.newHashMap(); - for (Entry entry : tagValueAggregationMap.entrySet()) { - map.put(entry.getKey(), createAggregationData(entry.getValue(), measure)); - } - return map; - } - private static final class CumulativeMutableViewData extends MutableViewData { private Timestamp start; @@ -483,145 +381,6 @@ abstract class MutableViewData { } } - // static inner Function classes - - private static final class CreateMutableSum implements Function { - @Override - public MutableAggregation apply(Sum arg) { - return MutableSum.create(); - } - - private static final CreateMutableSum INSTANCE = new CreateMutableSum(); - } - - private static final class CreateMutableCount implements Function { - @Override - public MutableAggregation apply(Count arg) { - return MutableCount.create(); - } - - private static final CreateMutableCount INSTANCE = new CreateMutableCount(); - } - - // TODO(songya): remove this once Mean aggregation is completely removed. Before that - // we need to continue supporting Mean, since it could still be used by users and some - // deprecated RPC views. - private static final class AggregationDefaultFunction - implements Function { - @Override - public MutableAggregation apply(Aggregation arg) { - if (arg instanceof Aggregation.Mean) { - return MutableMean.create(); - } - throw new IllegalArgumentException("Unknown Aggregation."); - } - - private static final AggregationDefaultFunction INSTANCE = new AggregationDefaultFunction(); - } - - private static final class CreateMutableDistribution - implements Function { - @Override - public MutableAggregation apply(Distribution arg) { - return MutableDistribution.create(arg.getBucketBoundaries()); - } - - private static final CreateMutableDistribution INSTANCE = new CreateMutableDistribution(); - } - - private static final class CreateMutableLastValue - implements Function { - @Override - public MutableAggregation apply(LastValue arg) { - return MutableLastValue.create(); - } - - private static final CreateMutableLastValue INSTANCE = new CreateMutableLastValue(); - } - - private static final class CreateSumData implements Function { - - private final Measure measure; - - private CreateSumData(Measure measure) { - this.measure = measure; - } - - @Override - public AggregationData apply(final MutableSum arg) { - return measure.match( - Functions.returnConstant(SumDataDouble.create(arg.getSum())), - Functions.returnConstant(SumDataLong.create(Math.round(arg.getSum()))), - Functions.throwAssertionError()); - } - } - - private static final class CreateCountData implements Function { - @Override - public AggregationData apply(MutableCount arg) { - return CountData.create(arg.getCount()); - } - - private static final CreateCountData INSTANCE = new CreateCountData(); - } - - private static final class CreateMeanData implements Function { - @Override - public AggregationData apply(MutableMean arg) { - return AggregationData.MeanData.create(arg.getMean(), arg.getCount()); - } - - private static final CreateMeanData INSTANCE = new CreateMeanData(); - } - - private static final class CreateDistributionData - implements Function { - @Override - public AggregationData apply(MutableDistribution arg) { - List boxedBucketCounts = new ArrayList(); - for (long bucketCount : arg.getBucketCounts()) { - boxedBucketCounts.add(bucketCount); - } - List exemplars = new ArrayList(); - if (arg.getExemplars() != null) { - for (Exemplar exemplar : arg.getExemplars()) { - if (exemplar != null) { - exemplars.add(exemplar); - } - } - } - return DistributionData.create( - arg.getMean(), - arg.getCount(), - arg.getMin(), - arg.getMax(), - arg.getSumOfSquaredDeviations(), - boxedBucketCounts, - exemplars); - } - - private static final CreateDistributionData INSTANCE = new CreateDistributionData(); - } - - private static final class CreateLastValueData - implements Function { - - private final Measure measure; - - private CreateLastValueData(Measure measure) { - this.measure = measure; - } - - @Override - public AggregationData apply(final MutableLastValue arg) { - return measure.match( - Functions.returnConstant(LastValueDataDouble.create(arg.getLastValue())), - Functions.returnConstant( - LastValueDataLong.create(Math.round(arg.getLastValue()))), - Functions.throwAssertionError()); - } - } - private static final class CreateCumulative implements Function { @Override diff --git a/impl_core/src/main/java/io/opencensus/implcore/stats/RecordUtils.java b/impl_core/src/main/java/io/opencensus/implcore/stats/RecordUtils.java new file mode 100644 index 00000000..5dc77cb1 --- /dev/null +++ b/impl_core/src/main/java/io/opencensus/implcore/stats/RecordUtils.java @@ -0,0 +1,306 @@ +/* + * Copyright 2018, OpenCensus Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.opencensus.implcore.stats; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.Maps; +import io.opencensus.common.Function; +import io.opencensus.common.Functions; +import io.opencensus.implcore.stats.MutableAggregation.MutableCount; +import io.opencensus.implcore.stats.MutableAggregation.MutableDistribution; +import io.opencensus.implcore.stats.MutableAggregation.MutableLastValue; +import io.opencensus.implcore.stats.MutableAggregation.MutableMean; +import io.opencensus.implcore.stats.MutableAggregation.MutableSum; +import io.opencensus.implcore.tags.TagContextImpl; +import io.opencensus.stats.Aggregation; +import io.opencensus.stats.Aggregation.Count; +import io.opencensus.stats.Aggregation.Distribution; +import io.opencensus.stats.Aggregation.LastValue; +import io.opencensus.stats.Aggregation.Sum; +import io.opencensus.stats.AggregationData; +import io.opencensus.stats.AggregationData.CountData; +import io.opencensus.stats.AggregationData.DistributionData; +import io.opencensus.stats.AggregationData.DistributionData.Exemplar; +import io.opencensus.stats.AggregationData.LastValueDataDouble; +import io.opencensus.stats.AggregationData.LastValueDataLong; +import io.opencensus.stats.AggregationData.SumDataDouble; +import io.opencensus.stats.AggregationData.SumDataLong; +import io.opencensus.stats.Measure; +import io.opencensus.stats.Measurement; +import io.opencensus.stats.Measurement.MeasurementDouble; +import io.opencensus.stats.Measurement.MeasurementLong; +import io.opencensus.tags.InternalUtils; +import io.opencensus.tags.Tag; +import io.opencensus.tags.TagContext; +import io.opencensus.tags.TagKey; +import io.opencensus.tags.TagValue; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; + +/*>>> +import org.checkerframework.checker.nullness.qual.Nullable; +*/ + +@SuppressWarnings("deprecation") +/* Common static utilities for stats recording. */ +final class RecordUtils { + + @javax.annotation.Nullable @VisibleForTesting static final TagValue UNKNOWN_TAG_VALUE = null; + + static Map getTagMap(TagContext ctx) { + if (ctx instanceof TagContextImpl) { + return ((TagContextImpl) ctx).getTags(); + } else { + Map tags = Maps.newHashMap(); + for (Iterator i = InternalUtils.getTags(ctx); i.hasNext(); ) { + Tag tag = i.next(); + tags.put(tag.getKey(), tag.getValue()); + } + return tags; + } + } + + @VisibleForTesting + static List getTagValues( + Map tags, List columns) { + List tagValues = new ArrayList(columns.size()); + // Record all the measures in a "Greedy" way. + // Every view aggregates every measure. This is similar to doing a GROUPBY view’s keys. + for (int i = 0; i < columns.size(); ++i) { + TagKey tagKey = columns.get(i); + if (!tags.containsKey(tagKey)) { + // replace not found key values by null. + tagValues.add(UNKNOWN_TAG_VALUE); + } else { + tagValues.add(tags.get(tagKey)); + } + } + return tagValues; + } + + /** + * Create an empty {@link MutableAggregation} based on the given {@link Aggregation}. + * + * @param aggregation {@code Aggregation}. + * @return an empty {@code MutableAggregation}. + */ + @VisibleForTesting + static MutableAggregation createMutableAggregation(Aggregation aggregation) { + return aggregation.match( + CreateMutableSum.INSTANCE, + CreateMutableCount.INSTANCE, + CreateMutableDistribution.INSTANCE, + CreateMutableLastValue.INSTANCE, + AggregationDefaultFunction.INSTANCE); + } + + /** + * Create an {@link AggregationData} snapshot based on the given {@link MutableAggregation}. + * + * @param aggregation {@code MutableAggregation} + * @param measure {@code Measure} + * @return an {@code AggregationData} which is the snapshot of current summary statistics. + */ + @VisibleForTesting + static AggregationData createAggregationData(MutableAggregation aggregation, Measure measure) { + return aggregation.match( + new CreateSumData(measure), + CreateCountData.INSTANCE, + CreateMeanData.INSTANCE, + CreateDistributionData.INSTANCE, + new CreateLastValueData(measure)); + } + + // Covert a mapping from TagValues to MutableAggregation, to a mapping from TagValues to + // AggregationData. + static Map createAggregationMap( + Map tagValueAggregationMap, Measure measure) { + Map map = Maps.newHashMap(); + for (Entry entry : tagValueAggregationMap.entrySet()) { + map.put(entry.getKey(), createAggregationData(entry.getValue(), measure)); + } + return map; + } + + static double getDoubleValueFromMeasurement(Measurement measurement) { + return measurement.match( + GET_VALUE_FROM_MEASUREMENT_DOUBLE, + GET_VALUE_FROM_MEASUREMENT_LONG, + Functions.throwAssertionError()); + } + + // static inner Function classes + + private static final Function GET_VALUE_FROM_MEASUREMENT_DOUBLE = + new Function() { + @Override + public Double apply(MeasurementDouble arg) { + return arg.getValue(); + } + }; + + private static final Function GET_VALUE_FROM_MEASUREMENT_LONG = + new Function() { + @Override + public Double apply(MeasurementLong arg) { + // TODO: consider checking truncation here. + return (double) arg.getValue(); + } + }; + + private static final class CreateMutableSum implements Function { + @Override + public MutableAggregation apply(Sum arg) { + return MutableSum.create(); + } + + private static final CreateMutableSum INSTANCE = new CreateMutableSum(); + } + + private static final class CreateMutableCount implements Function { + @Override + public MutableAggregation apply(Count arg) { + return MutableCount.create(); + } + + private static final CreateMutableCount INSTANCE = new CreateMutableCount(); + } + + // TODO(songya): remove this once Mean aggregation is completely removed. Before that + // we need to continue supporting Mean, since it could still be used by users and some + // deprecated RPC views. + private static final class AggregationDefaultFunction + implements Function { + @Override + public MutableAggregation apply(Aggregation arg) { + if (arg instanceof Aggregation.Mean) { + return MutableMean.create(); + } + throw new IllegalArgumentException("Unknown Aggregation."); + } + + private static final AggregationDefaultFunction INSTANCE = new AggregationDefaultFunction(); + } + + private static final class CreateMutableDistribution + implements Function { + @Override + public MutableAggregation apply(Distribution arg) { + return MutableDistribution.create(arg.getBucketBoundaries()); + } + + private static final CreateMutableDistribution INSTANCE = new CreateMutableDistribution(); + } + + private static final class CreateMutableLastValue + implements Function { + @Override + public MutableAggregation apply(LastValue arg) { + return MutableLastValue.create(); + } + + private static final CreateMutableLastValue INSTANCE = new CreateMutableLastValue(); + } + + private static final class CreateSumData implements Function { + + private final Measure measure; + + private CreateSumData(Measure measure) { + this.measure = measure; + } + + @Override + public AggregationData apply(final MutableSum arg) { + return measure.match( + Functions.returnConstant(SumDataDouble.create(arg.getSum())), + Functions.returnConstant(SumDataLong.create(Math.round(arg.getSum()))), + Functions.throwAssertionError()); + } + } + + private static final class CreateCountData implements Function { + @Override + public AggregationData apply(MutableCount arg) { + return CountData.create(arg.getCount()); + } + + private static final CreateCountData INSTANCE = new CreateCountData(); + } + + private static final class CreateMeanData implements Function { + @Override + public AggregationData apply(MutableMean arg) { + return AggregationData.MeanData.create(arg.getMean(), arg.getCount()); + } + + private static final CreateMeanData INSTANCE = new CreateMeanData(); + } + + private static final class CreateDistributionData + implements Function { + @Override + public AggregationData apply(MutableDistribution arg) { + List boxedBucketCounts = new ArrayList(); + for (long bucketCount : arg.getBucketCounts()) { + boxedBucketCounts.add(bucketCount); + } + List exemplars = new ArrayList(); + if (arg.getExemplars() != null) { + for (Exemplar exemplar : arg.getExemplars()) { + if (exemplar != null) { + exemplars.add(exemplar); + } + } + } + return DistributionData.create( + arg.getMean(), + arg.getCount(), + arg.getMin(), + arg.getMax(), + arg.getSumOfSquaredDeviations(), + boxedBucketCounts, + exemplars); + } + + private static final CreateDistributionData INSTANCE = new CreateDistributionData(); + } + + private static final class CreateLastValueData + implements Function { + + private final Measure measure; + + private CreateLastValueData(Measure measure) { + this.measure = measure; + } + + @Override + public AggregationData apply(final MutableLastValue arg) { + return measure.match( + Functions.returnConstant(LastValueDataDouble.create(arg.getLastValue())), + Functions.returnConstant( + LastValueDataLong.create(Math.round(arg.getLastValue()))), + Functions.throwAssertionError()); + } + } + + private RecordUtils() {} +} diff --git a/impl_core/src/test/java/io/opencensus/implcore/stats/MutableViewDataTest.java b/impl_core/src/test/java/io/opencensus/implcore/stats/MutableViewDataTest.java index e397ad65..06f50fed 100644 --- a/impl_core/src/test/java/io/opencensus/implcore/stats/MutableViewDataTest.java +++ b/impl_core/src/test/java/io/opencensus/implcore/stats/MutableViewDataTest.java @@ -18,35 +18,7 @@ package io.opencensus.implcore.stats; import static com.google.common.truth.Truth.assertThat; -import com.google.common.collect.ImmutableMap; import io.opencensus.common.Timestamp; -import io.opencensus.implcore.stats.MutableAggregation.MutableCount; -import io.opencensus.implcore.stats.MutableAggregation.MutableDistribution; -import io.opencensus.implcore.stats.MutableAggregation.MutableLastValue; -import io.opencensus.implcore.stats.MutableAggregation.MutableMean; -import io.opencensus.implcore.stats.MutableAggregation.MutableSum; -import io.opencensus.stats.Aggregation.Count; -import io.opencensus.stats.Aggregation.Distribution; -import io.opencensus.stats.Aggregation.LastValue; -import io.opencensus.stats.Aggregation.Mean; -import io.opencensus.stats.Aggregation.Sum; -import io.opencensus.stats.AggregationData; -import io.opencensus.stats.AggregationData.CountData; -import io.opencensus.stats.AggregationData.DistributionData; -import io.opencensus.stats.AggregationData.LastValueDataDouble; -import io.opencensus.stats.AggregationData.LastValueDataLong; -import io.opencensus.stats.AggregationData.MeanData; -import io.opencensus.stats.AggregationData.SumDataDouble; -import io.opencensus.stats.AggregationData.SumDataLong; -import io.opencensus.stats.BucketBoundaries; -import io.opencensus.stats.Measure.MeasureDouble; -import io.opencensus.stats.Measure.MeasureLong; -import io.opencensus.tags.TagKey; -import io.opencensus.tags.TagValue; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Map; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @@ -55,94 +27,8 @@ import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class MutableViewDataTest { - private static final double EPSILON = 1e-7; - - private static final TagKey ORIGINATOR = TagKey.create("originator"); - private static final TagKey CALLER = TagKey.create("caller"); - private static final TagKey METHOD = TagKey.create("method"); - private static final TagValue CALLER_V = TagValue.create("some caller"); - private static final TagValue METHOD_V = TagValue.create("some method"); - private static final MeasureDouble MEASURE_DOUBLE = - MeasureDouble.create("measure1", "description", "1"); - private static final MeasureLong MEASURE_LONG = - MeasureLong.create("measure2", "description", "1"); - @Test public void testConstants() { - assertThat(MutableViewData.UNKNOWN_TAG_VALUE).isNull(); assertThat(MutableViewData.ZERO_TIMESTAMP).isEqualTo(Timestamp.create(0, 0)); } - - @Test - public void testGetTagValues() { - List columns = Arrays.asList(CALLER, METHOD, ORIGINATOR); - Map tags = ImmutableMap.of(CALLER, CALLER_V, METHOD, METHOD_V); - - assertThat(MutableViewData.getTagValues(tags, columns)) - .containsExactly(CALLER_V, METHOD_V, MutableViewData.UNKNOWN_TAG_VALUE) - .inOrder(); - } - - @Test - public void createMutableAggregation() { - BucketBoundaries bucketBoundaries = BucketBoundaries.create(Arrays.asList(-1.0, 0.0, 1.0)); - - assertThat(((MutableSum) MutableViewData.createMutableAggregation(Sum.create())).getSum()) - .isWithin(EPSILON) - .of(0.0); - assertThat(((MutableCount) MutableViewData.createMutableAggregation(Count.create())).getCount()) - .isEqualTo(0L); - assertThat(((MutableMean) MutableViewData.createMutableAggregation(Mean.create())).getMean()) - .isWithin(EPSILON) - .of(0D); - assertThat( - ((MutableLastValue) MutableViewData.createMutableAggregation(LastValue.create())) - .getLastValue()) - .isNaN(); - - MutableDistribution mutableDistribution = - (MutableDistribution) - MutableViewData.createMutableAggregation(Distribution.create(bucketBoundaries)); - assertThat(mutableDistribution.getMin()).isPositiveInfinity(); - assertThat(mutableDistribution.getMax()).isNegativeInfinity(); - assertThat(mutableDistribution.getSumOfSquaredDeviations()).isWithin(EPSILON).of(0); - assertThat(mutableDistribution.getBucketCounts()).isEqualTo(new long[4]); - } - - @Test - public void createAggregationData() { - BucketBoundaries bucketBoundaries = BucketBoundaries.create(Arrays.asList(-1.0, 0.0, 1.0)); - List aggregates = new ArrayList(); - aggregates.add(MutableViewData.createAggregationData(MutableSum.create(), MEASURE_DOUBLE)); - aggregates.add(MutableViewData.createAggregationData(MutableSum.create(), MEASURE_LONG)); - aggregates.add( - MutableViewData.createAggregationData(MutableLastValue.create(), MEASURE_DOUBLE)); - aggregates.add(MutableViewData.createAggregationData(MutableLastValue.create(), MEASURE_LONG)); - - List mutableAggregations = - Arrays.asList( - MutableCount.create(), - MutableMean.create(), - MutableDistribution.create(bucketBoundaries)); - for (MutableAggregation mutableAggregation : mutableAggregations) { - aggregates.add(MutableViewData.createAggregationData(mutableAggregation, MEASURE_DOUBLE)); - } - - assertThat(aggregates) - .containsExactly( - SumDataDouble.create(0), - SumDataLong.create(0), - LastValueDataDouble.create(Double.NaN), - LastValueDataLong.create(0), - CountData.create(0), - MeanData.create(0, 0), - DistributionData.create( - 0, - 0, - Double.POSITIVE_INFINITY, - Double.NEGATIVE_INFINITY, - 0, - Arrays.asList(new Long[] {0L, 0L, 0L, 0L}))) - .inOrder(); - } } diff --git a/impl_core/src/test/java/io/opencensus/implcore/stats/RecordUtilsTest.java b/impl_core/src/test/java/io/opencensus/implcore/stats/RecordUtilsTest.java new file mode 100644 index 00000000..7a4b1b3d --- /dev/null +++ b/impl_core/src/test/java/io/opencensus/implcore/stats/RecordUtilsTest.java @@ -0,0 +1,144 @@ +/* + * Copyright 2018, OpenCensus Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.opencensus.implcore.stats; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableMap; +import io.opencensus.implcore.stats.MutableAggregation.MutableCount; +import io.opencensus.implcore.stats.MutableAggregation.MutableDistribution; +import io.opencensus.implcore.stats.MutableAggregation.MutableLastValue; +import io.opencensus.implcore.stats.MutableAggregation.MutableMean; +import io.opencensus.implcore.stats.MutableAggregation.MutableSum; +import io.opencensus.stats.Aggregation.Count; +import io.opencensus.stats.Aggregation.Distribution; +import io.opencensus.stats.Aggregation.LastValue; +import io.opencensus.stats.Aggregation.Mean; +import io.opencensus.stats.Aggregation.Sum; +import io.opencensus.stats.AggregationData; +import io.opencensus.stats.AggregationData.CountData; +import io.opencensus.stats.AggregationData.DistributionData; +import io.opencensus.stats.AggregationData.LastValueDataDouble; +import io.opencensus.stats.AggregationData.LastValueDataLong; +import io.opencensus.stats.AggregationData.MeanData; +import io.opencensus.stats.AggregationData.SumDataDouble; +import io.opencensus.stats.AggregationData.SumDataLong; +import io.opencensus.stats.BucketBoundaries; +import io.opencensus.stats.Measure.MeasureDouble; +import io.opencensus.stats.Measure.MeasureLong; +import io.opencensus.tags.TagKey; +import io.opencensus.tags.TagValue; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Map; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +/** Tests for {@link RecordUtils}. */ +@RunWith(JUnit4.class) +public class RecordUtilsTest { + + private static final double EPSILON = 1e-7; + private static final MeasureDouble MEASURE_DOUBLE = + MeasureDouble.create("measure1", "description", "1"); + private static final MeasureLong MEASURE_LONG = + MeasureLong.create("measure2", "description", "1"); + private static final TagKey ORIGINATOR = TagKey.create("originator"); + private static final TagKey CALLER = TagKey.create("caller"); + private static final TagKey METHOD = TagKey.create("method"); + private static final TagValue CALLER_V = TagValue.create("some caller"); + private static final TagValue METHOD_V = TagValue.create("some method"); + + @Test + public void testConstants() { + assertThat(RecordUtils.UNKNOWN_TAG_VALUE).isNull(); + } + + @Test + public void testGetTagValues() { + List columns = Arrays.asList(CALLER, METHOD, ORIGINATOR); + Map tags = ImmutableMap.of(CALLER, CALLER_V, METHOD, METHOD_V); + + assertThat(RecordUtils.getTagValues(tags, columns)) + .containsExactly(CALLER_V, METHOD_V, RecordUtils.UNKNOWN_TAG_VALUE) + .inOrder(); + } + + @Test + public void createMutableAggregation() { + BucketBoundaries bucketBoundaries = BucketBoundaries.create(Arrays.asList(-1.0, 0.0, 1.0)); + + assertThat(((MutableSum) RecordUtils.createMutableAggregation(Sum.create())).getSum()) + .isWithin(EPSILON) + .of(0.0); + assertThat(((MutableCount) RecordUtils.createMutableAggregation(Count.create())).getCount()) + .isEqualTo(0L); + assertThat(((MutableMean) RecordUtils.createMutableAggregation(Mean.create())).getMean()) + .isWithin(EPSILON) + .of(0D); + assertThat( + ((MutableLastValue) RecordUtils.createMutableAggregation(LastValue.create())) + .getLastValue()) + .isNaN(); + + MutableDistribution mutableDistribution = + (MutableDistribution) + RecordUtils.createMutableAggregation(Distribution.create(bucketBoundaries)); + assertThat(mutableDistribution.getMin()).isPositiveInfinity(); + assertThat(mutableDistribution.getMax()).isNegativeInfinity(); + assertThat(mutableDistribution.getSumOfSquaredDeviations()).isWithin(EPSILON).of(0); + assertThat(mutableDistribution.getBucketCounts()).isEqualTo(new long[4]); + } + + @Test + public void createAggregationData() { + BucketBoundaries bucketBoundaries = BucketBoundaries.create(Arrays.asList(-1.0, 0.0, 1.0)); + List aggregates = new ArrayList(); + aggregates.add(RecordUtils.createAggregationData(MutableSum.create(), MEASURE_DOUBLE)); + aggregates.add(RecordUtils.createAggregationData(MutableSum.create(), MEASURE_LONG)); + aggregates.add(RecordUtils.createAggregationData(MutableLastValue.create(), MEASURE_DOUBLE)); + aggregates.add(RecordUtils.createAggregationData(MutableLastValue.create(), MEASURE_LONG)); + + List mutableAggregations = + Arrays.asList( + MutableCount.create(), + MutableMean.create(), + MutableDistribution.create(bucketBoundaries)); + for (MutableAggregation mutableAggregation : mutableAggregations) { + aggregates.add(RecordUtils.createAggregationData(mutableAggregation, MEASURE_DOUBLE)); + } + + assertThat(aggregates) + .containsExactly( + SumDataDouble.create(0), + SumDataLong.create(0), + LastValueDataDouble.create(Double.NaN), + LastValueDataLong.create(0), + CountData.create(0), + MeanData.create(0, 0), + DistributionData.create( + 0, + 0, + Double.POSITIVE_INFINITY, + Double.NEGATIVE_INFINITY, + 0, + Arrays.asList(0L, 0L, 0L, 0L))) + .inOrder(); + } +} diff --git a/impl_core/src/test/java/io/opencensus/implcore/stats/StatsRecorderImplTest.java b/impl_core/src/test/java/io/opencensus/implcore/stats/StatsRecorderImplTest.java index 3c8d7af3..bd8b5b88 100644 --- a/impl_core/src/test/java/io/opencensus/implcore/stats/StatsRecorderImplTest.java +++ b/impl_core/src/test/java/io/opencensus/implcore/stats/StatsRecorderImplTest.java @@ -21,11 +21,11 @@ import static io.opencensus.implcore.stats.MutableViewData.ZERO_TIMESTAMP; import static io.opencensus.implcore.stats.StatsTestUtil.createEmptyViewData; import com.google.common.collect.ImmutableMap; -import com.google.common.collect.Lists; import io.grpc.Context; import io.opencensus.common.Duration; import io.opencensus.common.Timestamp; import io.opencensus.implcore.internal.SimpleEventQueue; +import io.opencensus.implcore.stats.StatsTestUtil.SimpleTagContext; import io.opencensus.stats.Aggregation.Count; import io.opencensus.stats.Aggregation.Distribution; import io.opencensus.stats.Aggregation.Sum; @@ -51,7 +51,6 @@ import io.opencensus.tags.unsafe.ContextUtils; import io.opencensus.testing.common.TestClock; import java.util.Arrays; import java.util.Collections; -import java.util.Iterator; import java.util.List; import org.junit.Test; import org.junit.runner.RunWith; @@ -347,17 +346,4 @@ public final class StatsRecorderImplTest { StatsTestUtil.createAggregationData(Sum.create(), MEASURE_DOUBLE, 4.0)), 1e-6); } - - private static final class SimpleTagContext extends TagContext { - private final List tags; - - SimpleTagContext(Tag... tags) { - this.tags = Collections.unmodifiableList(Lists.newArrayList(tags)); - } - - @Override - protected Iterator getIterator() { - return tags.iterator(); - } - } } diff --git a/impl_core/src/test/java/io/opencensus/implcore/stats/StatsTestUtil.java b/impl_core/src/test/java/io/opencensus/implcore/stats/StatsTestUtil.java index 6a2e6366..ec436d22 100644 --- a/impl_core/src/test/java/io/opencensus/implcore/stats/StatsTestUtil.java +++ b/impl_core/src/test/java/io/opencensus/implcore/stats/StatsTestUtil.java @@ -20,6 +20,7 @@ import static com.google.common.truth.Truth.assertThat; import static io.opencensus.implcore.stats.MutableViewData.ZERO_TIMESTAMP; import com.google.common.collect.Iterables; +import com.google.common.collect.Lists; import io.opencensus.common.Function; import io.opencensus.common.Functions; import io.opencensus.common.Timestamp; @@ -38,9 +39,12 @@ import io.opencensus.stats.ViewData; import io.opencensus.stats.ViewData.AggregationWindowData; import io.opencensus.stats.ViewData.AggregationWindowData.CumulativeData; import io.opencensus.stats.ViewData.AggregationWindowData.IntervalData; +import io.opencensus.tags.Tag; +import io.opencensus.tags.TagContext; import io.opencensus.tags.TagValue; import java.util.ArrayList; import java.util.Collections; +import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Map.Entry; @@ -63,11 +67,11 @@ final class StatsTestUtil { */ static AggregationData createAggregationData( Aggregation aggregation, Measure measure, double... values) { - MutableAggregation mutableAggregation = MutableViewData.createMutableAggregation(aggregation); + MutableAggregation mutableAggregation = RecordUtils.createMutableAggregation(aggregation); for (double value : values) { mutableAggregation.add(value, Collections.emptyMap(), EMPTY); } - return MutableViewData.createAggregationData(mutableAggregation, measure); + return RecordUtils.createAggregationData(mutableAggregation, measure); } /** @@ -211,4 +215,17 @@ final class StatsTestUtil { } return truncated; } + + static final class SimpleTagContext extends TagContext { + private final List tags; + + SimpleTagContext(Tag... tags) { + this.tags = Collections.unmodifiableList(Lists.newArrayList(tags)); + } + + @Override + protected Iterator getIterator() { + return tags.iterator(); + } + } } diff --git a/impl_core/src/test/java/io/opencensus/implcore/stats/ViewManagerImplTest.java b/impl_core/src/test/java/io/opencensus/implcore/stats/ViewManagerImplTest.java index 270d65c0..b3ec6f2d 100644 --- a/impl_core/src/test/java/io/opencensus/implcore/stats/ViewManagerImplTest.java +++ b/impl_core/src/test/java/io/opencensus/implcore/stats/ViewManagerImplTest.java @@ -634,7 +634,7 @@ public class ViewManagerImplTest { ImmutableMap.of( // Tag is missing for associated measureValues, should use default tag value // "unknown/not set". - Arrays.asList(MutableViewData.UNKNOWN_TAG_VALUE), + Arrays.asList(RecordUtils.UNKNOWN_TAG_VALUE), // Should record stats with default tag value: "KEY" : "unknown/not set". createAggregationData(DISTRIBUTION, MEASURE_DOUBLE, 10.0)), EPSILON); @@ -682,7 +682,7 @@ public class ViewManagerImplTest { ImmutableMap.of( // Won't record the unregistered tag key, for missing registered keys will use default // tag value : "unknown/not set". - Arrays.asList(MutableViewData.UNKNOWN_TAG_VALUE), + Arrays.asList(RecordUtils.UNKNOWN_TAG_VALUE), // Should record stats with default tag value: "KEY" : "unknown/not set". createAggregationData(DISTRIBUTION, MEASURE_DOUBLE, 10.0, 50.0)), EPSILON); -- cgit v1.2.3