| /* |
| * Copyright 2017, 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.exporter.stats.stackdriver; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| import static io.opencensus.exporter.stats.stackdriver.StackdriverExporterWorker.CUSTOM_OPENCENSUS_DOMAIN; |
| import static io.opencensus.exporter.stats.stackdriver.StackdriverExporterWorker.DEFAULT_DISPLAY_NAME_PREFIX; |
| |
| import com.google.api.Distribution.BucketOptions; |
| import com.google.api.Distribution.BucketOptions.Explicit; |
| import com.google.api.LabelDescriptor; |
| import com.google.api.LabelDescriptor.ValueType; |
| import com.google.api.Metric; |
| import com.google.api.MetricDescriptor; |
| import com.google.api.MetricDescriptor.MetricKind; |
| import com.google.api.MonitoredResource; |
| import com.google.common.collect.ImmutableMap; |
| import com.google.monitoring.v3.Point; |
| import com.google.monitoring.v3.TimeInterval; |
| import com.google.monitoring.v3.TimeSeries; |
| import com.google.monitoring.v3.TypedValue; |
| import io.opencensus.common.Duration; |
| import io.opencensus.common.Timestamp; |
| 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.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.stats.View; |
| import io.opencensus.stats.View.AggregationWindow.Cumulative; |
| import io.opencensus.stats.View.AggregationWindow.Interval; |
| import io.opencensus.stats.View.Name; |
| import io.opencensus.stats.ViewData; |
| import io.opencensus.stats.ViewData.AggregationWindowData.CumulativeData; |
| import io.opencensus.stats.ViewData.AggregationWindowData.IntervalData; |
| import io.opencensus.tags.TagKey; |
| import io.opencensus.tags.TagValue; |
| import java.lang.management.ManagementFactory; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.Map; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.rules.ExpectedException; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.JUnit4; |
| |
| /** Unit tests for {@link StackdriverExportUtils}. */ |
| @RunWith(JUnit4.class) |
| public class StackdriverExportUtilsTest { |
| |
| @Rule public final ExpectedException thrown = ExpectedException.none(); |
| |
| private static final TagKey KEY = TagKey.create("KEY"); |
| private static final TagKey KEY_2 = TagKey.create("KEY2"); |
| private static final TagKey KEY_3 = TagKey.create("KEY3"); |
| private static final TagValue VALUE_1 = TagValue.create("VALUE1"); |
| private static final TagValue VALUE_2 = TagValue.create("VALUE2"); |
| private static final String MEASURE_UNIT = "us"; |
| private static final String MEASURE_DESCRIPTION = "measure description"; |
| private static final MeasureDouble MEASURE_DOUBLE = |
| MeasureDouble.create("measure1", MEASURE_DESCRIPTION, MEASURE_UNIT); |
| private static final MeasureLong MEASURE_LONG = |
| MeasureLong.create("measure2", MEASURE_DESCRIPTION, MEASURE_UNIT); |
| private static final String VIEW_NAME = "view"; |
| private static final String VIEW_DESCRIPTION = "view description"; |
| private static final Duration TEN_SECONDS = Duration.create(10, 0); |
| private static final Cumulative CUMULATIVE = Cumulative.create(); |
| private static final Interval INTERVAL = Interval.create(TEN_SECONDS); |
| private static final BucketBoundaries BUCKET_BOUNDARIES = |
| BucketBoundaries.create(Arrays.asList(0.0, 1.0, 3.0, 5.0)); |
| private static final Sum SUM = Sum.create(); |
| private static final Count COUNT = Count.create(); |
| private static final Mean MEAN = Mean.create(); |
| private static final Distribution DISTRIBUTION = Distribution.create(BUCKET_BOUNDARIES); |
| private static final LastValue LAST_VALUE = LastValue.create(); |
| private static final String PROJECT_ID = "id"; |
| private static final MonitoredResource DEFAULT_RESOURCE = |
| MonitoredResource.newBuilder().setType("global").build(); |
| private static final String DEFAULT_TASK_VALUE = |
| "java-" + ManagementFactory.getRuntimeMXBean().getName(); |
| |
| @Test |
| public void testConstant() { |
| assertThat(StackdriverExportUtils.LABEL_DESCRIPTION).isEqualTo("OpenCensus TagKey"); |
| } |
| |
| @Test |
| public void createLabelDescriptor() { |
| assertThat(StackdriverExportUtils.createLabelDescriptor(TagKey.create("string"))) |
| .isEqualTo( |
| LabelDescriptor.newBuilder() |
| .setKey("string") |
| .setDescription(StackdriverExportUtils.LABEL_DESCRIPTION) |
| .setValueType(ValueType.STRING) |
| .build()); |
| } |
| |
| @Test |
| public void createMetricKind() { |
| assertThat(StackdriverExportUtils.createMetricKind(CUMULATIVE, SUM)) |
| .isEqualTo(MetricKind.CUMULATIVE); |
| assertThat(StackdriverExportUtils.createMetricKind(INTERVAL, COUNT)) |
| .isEqualTo(MetricKind.UNRECOGNIZED); |
| assertThat(StackdriverExportUtils.createMetricKind(CUMULATIVE, LAST_VALUE)) |
| .isEqualTo(MetricKind.GAUGE); |
| assertThat(StackdriverExportUtils.createMetricKind(INTERVAL, LAST_VALUE)) |
| .isEqualTo(MetricKind.GAUGE); |
| } |
| |
| @Test |
| public void createValueType() { |
| assertThat(StackdriverExportUtils.createValueType(SUM, MEASURE_DOUBLE)) |
| .isEqualTo(MetricDescriptor.ValueType.DOUBLE); |
| assertThat(StackdriverExportUtils.createValueType(SUM, MEASURE_LONG)) |
| .isEqualTo(MetricDescriptor.ValueType.INT64); |
| assertThat(StackdriverExportUtils.createValueType(COUNT, MEASURE_DOUBLE)) |
| .isEqualTo(MetricDescriptor.ValueType.INT64); |
| assertThat(StackdriverExportUtils.createValueType(COUNT, MEASURE_LONG)) |
| .isEqualTo(MetricDescriptor.ValueType.INT64); |
| assertThat(StackdriverExportUtils.createValueType(MEAN, MEASURE_DOUBLE)) |
| .isEqualTo(MetricDescriptor.ValueType.DOUBLE); |
| assertThat(StackdriverExportUtils.createValueType(MEAN, MEASURE_LONG)) |
| .isEqualTo(MetricDescriptor.ValueType.DOUBLE); |
| assertThat(StackdriverExportUtils.createValueType(DISTRIBUTION, MEASURE_DOUBLE)) |
| .isEqualTo(MetricDescriptor.ValueType.DISTRIBUTION); |
| assertThat(StackdriverExportUtils.createValueType(DISTRIBUTION, MEASURE_LONG)) |
| .isEqualTo(MetricDescriptor.ValueType.DISTRIBUTION); |
| assertThat(StackdriverExportUtils.createValueType(LAST_VALUE, MEASURE_DOUBLE)) |
| .isEqualTo(MetricDescriptor.ValueType.DOUBLE); |
| assertThat(StackdriverExportUtils.createValueType(LAST_VALUE, MEASURE_LONG)) |
| .isEqualTo(MetricDescriptor.ValueType.INT64); |
| } |
| |
| @Test |
| public void createUnit() { |
| assertThat(StackdriverExportUtils.createUnit(SUM, MEASURE_DOUBLE)).isEqualTo(MEASURE_UNIT); |
| assertThat(StackdriverExportUtils.createUnit(COUNT, MEASURE_DOUBLE)).isEqualTo("1"); |
| assertThat(StackdriverExportUtils.createUnit(MEAN, MEASURE_DOUBLE)).isEqualTo(MEASURE_UNIT); |
| assertThat(StackdriverExportUtils.createUnit(DISTRIBUTION, MEASURE_DOUBLE)) |
| .isEqualTo(MEASURE_UNIT); |
| assertThat(StackdriverExportUtils.createUnit(LAST_VALUE, MEASURE_DOUBLE)) |
| .isEqualTo(MEASURE_UNIT); |
| } |
| |
| @Test |
| public void createMetric() { |
| View view = |
| View.create( |
| Name.create(VIEW_NAME), |
| VIEW_DESCRIPTION, |
| MEASURE_DOUBLE, |
| DISTRIBUTION, |
| Arrays.asList(KEY), |
| CUMULATIVE); |
| assertThat( |
| StackdriverExportUtils.createMetric( |
| view, Arrays.asList(VALUE_1), CUSTOM_OPENCENSUS_DOMAIN)) |
| .isEqualTo( |
| Metric.newBuilder() |
| .setType("custom.googleapis.com/opencensus/" + VIEW_NAME) |
| .putLabels("KEY", "VALUE1") |
| .putLabels(StackdriverExportUtils.OPENCENSUS_TASK, DEFAULT_TASK_VALUE) |
| .build()); |
| } |
| |
| @Test |
| public void createMetric_WithExternalMetricDomain() { |
| View view = |
| View.create( |
| Name.create(VIEW_NAME), |
| VIEW_DESCRIPTION, |
| MEASURE_DOUBLE, |
| DISTRIBUTION, |
| Arrays.asList(KEY), |
| CUMULATIVE); |
| String prometheusDomain = "external.googleapis.com/prometheus/"; |
| assertThat(StackdriverExportUtils.createMetric(view, Arrays.asList(VALUE_1), prometheusDomain)) |
| .isEqualTo( |
| Metric.newBuilder() |
| .setType(prometheusDomain + VIEW_NAME) |
| .putLabels("KEY", "VALUE1") |
| .putLabels(StackdriverExportUtils.OPENCENSUS_TASK, DEFAULT_TASK_VALUE) |
| .build()); |
| } |
| |
| @Test |
| public void createMetric_skipNullTagValue() { |
| View view = |
| View.create( |
| Name.create(VIEW_NAME), |
| VIEW_DESCRIPTION, |
| MEASURE_DOUBLE, |
| DISTRIBUTION, |
| Arrays.asList(KEY, KEY_2, KEY_3), |
| CUMULATIVE); |
| assertThat( |
| StackdriverExportUtils.createMetric( |
| view, Arrays.asList(VALUE_1, null, VALUE_2), CUSTOM_OPENCENSUS_DOMAIN)) |
| .isEqualTo( |
| Metric.newBuilder() |
| .setType("custom.googleapis.com/opencensus/" + VIEW_NAME) |
| .putLabels("KEY", "VALUE1") |
| .putLabels("KEY3", "VALUE2") |
| .putLabels(StackdriverExportUtils.OPENCENSUS_TASK, DEFAULT_TASK_VALUE) |
| .build()); |
| } |
| |
| @Test |
| public void createMetric_throwWhenTagKeysAndValuesHaveDifferentSize() { |
| View view = |
| View.create( |
| Name.create(VIEW_NAME), |
| VIEW_DESCRIPTION, |
| MEASURE_DOUBLE, |
| DISTRIBUTION, |
| Arrays.asList(KEY, KEY_2, KEY_3), |
| CUMULATIVE); |
| List<TagValue> tagValues = Arrays.asList(VALUE_1, null); |
| thrown.expect(IllegalArgumentException.class); |
| thrown.expectMessage("TagKeys and TagValues don't have same size."); |
| StackdriverExportUtils.createMetric(view, tagValues, CUSTOM_OPENCENSUS_DOMAIN); |
| } |
| |
| @Test |
| public void convertTimestamp() { |
| Timestamp censusTimestamp1 = Timestamp.create(100, 3000); |
| assertThat(StackdriverExportUtils.convertTimestamp(censusTimestamp1)) |
| .isEqualTo( |
| com.google.protobuf.Timestamp.newBuilder().setSeconds(100).setNanos(3000).build()); |
| |
| // Stackdriver doesn't allow negative values, instead it will replace the negative values |
| // by returning a default instance. |
| Timestamp censusTimestamp2 = Timestamp.create(-100, 3000); |
| assertThat(StackdriverExportUtils.convertTimestamp(censusTimestamp2)) |
| .isEqualTo(com.google.protobuf.Timestamp.newBuilder().build()); |
| } |
| |
| @Test |
| public void createTimeInterval_cumulative() { |
| Timestamp censusTimestamp1 = Timestamp.create(100, 3000); |
| Timestamp censusTimestamp2 = Timestamp.create(200, 0); |
| assertThat( |
| StackdriverExportUtils.createTimeInterval( |
| CumulativeData.create(censusTimestamp1, censusTimestamp2), DISTRIBUTION)) |
| .isEqualTo( |
| TimeInterval.newBuilder() |
| .setStartTime(StackdriverExportUtils.convertTimestamp(censusTimestamp1)) |
| .setEndTime(StackdriverExportUtils.convertTimestamp(censusTimestamp2)) |
| .build()); |
| assertThat( |
| StackdriverExportUtils.createTimeInterval( |
| CumulativeData.create(censusTimestamp1, censusTimestamp2), LAST_VALUE)) |
| .isEqualTo( |
| TimeInterval.newBuilder() |
| .setEndTime(StackdriverExportUtils.convertTimestamp(censusTimestamp2)) |
| .build()); |
| } |
| |
| @Test |
| public void createTimeInterval_interval() { |
| IntervalData intervalData = IntervalData.create(Timestamp.create(200, 0)); |
| // Only Cumulative view will supported in this version. |
| thrown.expect(IllegalArgumentException.class); |
| StackdriverExportUtils.createTimeInterval(intervalData, SUM); |
| } |
| |
| @Test |
| public void createBucketOptions() { |
| assertThat(StackdriverExportUtils.createBucketOptions(BUCKET_BOUNDARIES)) |
| .isEqualTo( |
| BucketOptions.newBuilder() |
| .setExplicitBuckets( |
| Explicit.newBuilder().addAllBounds(Arrays.asList(0.0, 1.0, 3.0, 5.0))) |
| .build()); |
| } |
| |
| @Test |
| public void createDistribution() { |
| DistributionData distributionData = |
| DistributionData.create(2, 3, 0, 5, 14, Arrays.asList(0L, 1L, 1L, 0L, 1L)); |
| assertThat(StackdriverExportUtils.createDistribution(distributionData, BUCKET_BOUNDARIES)) |
| .isEqualTo( |
| com.google.api.Distribution.newBuilder() |
| .setMean(2) |
| .setCount(3) |
| // TODO(songya): uncomment this once Stackdriver supports setting max and min. |
| // .setRange( |
| // com.google.api.Distribution.Range.newBuilder().setMin(0).setMax(5).build()) |
| .setBucketOptions(StackdriverExportUtils.createBucketOptions(BUCKET_BOUNDARIES)) |
| .addAllBucketCounts(Arrays.asList(0L, 1L, 1L, 0L, 1L)) |
| .setSumOfSquaredDeviation(14) |
| .build()); |
| } |
| |
| @Test |
| public void createTypedValue() { |
| assertThat(StackdriverExportUtils.createTypedValue(SUM, SumDataDouble.create(1.1))) |
| .isEqualTo(TypedValue.newBuilder().setDoubleValue(1.1).build()); |
| assertThat(StackdriverExportUtils.createTypedValue(SUM, SumDataLong.create(10000))) |
| .isEqualTo(TypedValue.newBuilder().setInt64Value(10000).build()); |
| assertThat(StackdriverExportUtils.createTypedValue(COUNT, CountData.create(55))) |
| .isEqualTo(TypedValue.newBuilder().setInt64Value(55).build()); |
| assertThat(StackdriverExportUtils.createTypedValue(MEAN, MeanData.create(7.7, 8))) |
| .isEqualTo(TypedValue.newBuilder().setDoubleValue(7.7).build()); |
| DistributionData distributionData = |
| DistributionData.create(2, 3, 0, 5, 14, Arrays.asList(0L, 1L, 1L, 0L, 1L)); |
| assertThat(StackdriverExportUtils.createTypedValue(DISTRIBUTION, distributionData)) |
| .isEqualTo( |
| TypedValue.newBuilder() |
| .setDistributionValue( |
| StackdriverExportUtils.createDistribution(distributionData, BUCKET_BOUNDARIES)) |
| .build()); |
| assertThat(StackdriverExportUtils.createTypedValue(LAST_VALUE, LastValueDataDouble.create(9.9))) |
| .isEqualTo(TypedValue.newBuilder().setDoubleValue(9.9).build()); |
| assertThat(StackdriverExportUtils.createTypedValue(LAST_VALUE, LastValueDataLong.create(90000))) |
| .isEqualTo(TypedValue.newBuilder().setInt64Value(90000).build()); |
| } |
| |
| @Test |
| public void createPoint_cumulative() { |
| Timestamp censusTimestamp1 = Timestamp.create(100, 3000); |
| Timestamp censusTimestamp2 = Timestamp.create(200, 0); |
| CumulativeData cumulativeData = CumulativeData.create(censusTimestamp1, censusTimestamp2); |
| SumDataDouble sumDataDouble = SumDataDouble.create(33.3); |
| |
| assertThat(StackdriverExportUtils.createPoint(sumDataDouble, cumulativeData, SUM)) |
| .isEqualTo( |
| Point.newBuilder() |
| .setInterval(StackdriverExportUtils.createTimeInterval(cumulativeData, SUM)) |
| .setValue(StackdriverExportUtils.createTypedValue(SUM, sumDataDouble)) |
| .build()); |
| } |
| |
| @Test |
| public void createPoint_interval() { |
| IntervalData intervalData = IntervalData.create(Timestamp.create(200, 0)); |
| SumDataDouble sumDataDouble = SumDataDouble.create(33.3); |
| // Only Cumulative view will supported in this version. |
| thrown.expect(IllegalArgumentException.class); |
| StackdriverExportUtils.createPoint(sumDataDouble, intervalData, SUM); |
| } |
| |
| @Test |
| public void createMetricDescriptor_cumulative() { |
| View view = |
| View.create( |
| Name.create(VIEW_NAME), |
| VIEW_DESCRIPTION, |
| MEASURE_DOUBLE, |
| DISTRIBUTION, |
| Arrays.asList(KEY), |
| CUMULATIVE); |
| MetricDescriptor metricDescriptor = |
| StackdriverExportUtils.createMetricDescriptor( |
| view, PROJECT_ID, "custom.googleapis.com/myorg/", "myorg/"); |
| assertThat(metricDescriptor.getName()) |
| .isEqualTo( |
| "projects/" |
| + PROJECT_ID |
| + "/metricDescriptors/custom.googleapis.com/myorg/" |
| + VIEW_NAME); |
| assertThat(metricDescriptor.getDescription()).isEqualTo(VIEW_DESCRIPTION); |
| assertThat(metricDescriptor.getDisplayName()).isEqualTo("myorg/" + VIEW_NAME); |
| assertThat(metricDescriptor.getType()).isEqualTo("custom.googleapis.com/myorg/" + VIEW_NAME); |
| assertThat(metricDescriptor.getUnit()).isEqualTo(MEASURE_UNIT); |
| assertThat(metricDescriptor.getMetricKind()).isEqualTo(MetricKind.CUMULATIVE); |
| assertThat(metricDescriptor.getValueType()).isEqualTo(MetricDescriptor.ValueType.DISTRIBUTION); |
| assertThat(metricDescriptor.getLabelsList()) |
| .containsExactly( |
| LabelDescriptor.newBuilder() |
| .setKey(KEY.getName()) |
| .setDescription(StackdriverExportUtils.LABEL_DESCRIPTION) |
| .setValueType(ValueType.STRING) |
| .build(), |
| LabelDescriptor.newBuilder() |
| .setKey(StackdriverExportUtils.OPENCENSUS_TASK) |
| .setDescription(StackdriverExportUtils.OPENCENSUS_TASK_DESCRIPTION) |
| .setValueType(ValueType.STRING) |
| .build()); |
| } |
| |
| @Test |
| public void createMetricDescriptor_cumulative_count() { |
| View view = |
| View.create( |
| Name.create(VIEW_NAME), |
| VIEW_DESCRIPTION, |
| MEASURE_DOUBLE, |
| COUNT, |
| Arrays.asList(KEY), |
| CUMULATIVE); |
| MetricDescriptor metricDescriptor = |
| StackdriverExportUtils.createMetricDescriptor( |
| view, PROJECT_ID, CUSTOM_OPENCENSUS_DOMAIN, DEFAULT_DISPLAY_NAME_PREFIX); |
| assertThat(metricDescriptor.getName()) |
| .isEqualTo( |
| "projects/" |
| + PROJECT_ID |
| + "/metricDescriptors/custom.googleapis.com/opencensus/" |
| + VIEW_NAME); |
| assertThat(metricDescriptor.getDescription()).isEqualTo(VIEW_DESCRIPTION); |
| assertThat(metricDescriptor.getDisplayName()).isEqualTo("OpenCensus/" + VIEW_NAME); |
| assertThat(metricDescriptor.getType()) |
| .isEqualTo("custom.googleapis.com/opencensus/" + VIEW_NAME); |
| assertThat(metricDescriptor.getUnit()).isEqualTo("1"); |
| assertThat(metricDescriptor.getMetricKind()).isEqualTo(MetricKind.CUMULATIVE); |
| assertThat(metricDescriptor.getValueType()).isEqualTo(MetricDescriptor.ValueType.INT64); |
| assertThat(metricDescriptor.getLabelsList()) |
| .containsExactly( |
| LabelDescriptor.newBuilder() |
| .setKey(KEY.getName()) |
| .setDescription(StackdriverExportUtils.LABEL_DESCRIPTION) |
| .setValueType(ValueType.STRING) |
| .build(), |
| LabelDescriptor.newBuilder() |
| .setKey(StackdriverExportUtils.OPENCENSUS_TASK) |
| .setDescription(StackdriverExportUtils.OPENCENSUS_TASK_DESCRIPTION) |
| .setValueType(ValueType.STRING) |
| .build()); |
| } |
| |
| @Test |
| public void createMetricDescriptor_interval() { |
| View view = |
| View.create( |
| Name.create(VIEW_NAME), |
| VIEW_DESCRIPTION, |
| MEASURE_DOUBLE, |
| DISTRIBUTION, |
| Arrays.asList(KEY), |
| INTERVAL); |
| assertThat( |
| StackdriverExportUtils.createMetricDescriptor( |
| view, PROJECT_ID, CUSTOM_OPENCENSUS_DOMAIN, DEFAULT_DISPLAY_NAME_PREFIX)) |
| .isNull(); |
| } |
| |
| @Test |
| public void createTimeSeriesList_cumulative() { |
| View view = |
| View.create( |
| Name.create(VIEW_NAME), |
| VIEW_DESCRIPTION, |
| MEASURE_DOUBLE, |
| DISTRIBUTION, |
| Arrays.asList(KEY), |
| CUMULATIVE); |
| DistributionData distributionData1 = |
| DistributionData.create(2, 3, 0, 5, 14, Arrays.asList(0L, 1L, 1L, 0L, 1L)); |
| DistributionData distributionData2 = |
| DistributionData.create(-1, 1, -1, -1, 0, Arrays.asList(1L, 0L, 0L, 0L, 0L)); |
| Map<List<TagValue>, DistributionData> aggregationMap = |
| ImmutableMap.of( |
| Arrays.asList(VALUE_1), distributionData1, Arrays.asList(VALUE_2), distributionData2); |
| CumulativeData cumulativeData = |
| CumulativeData.create(Timestamp.fromMillis(1000), Timestamp.fromMillis(2000)); |
| ViewData viewData = ViewData.create(view, aggregationMap, cumulativeData); |
| List<TimeSeries> timeSeriesList = |
| StackdriverExportUtils.createTimeSeriesList( |
| viewData, DEFAULT_RESOURCE, CUSTOM_OPENCENSUS_DOMAIN); |
| assertThat(timeSeriesList).hasSize(2); |
| TimeSeries expected1 = |
| TimeSeries.newBuilder() |
| .setMetricKind(MetricKind.CUMULATIVE) |
| .setValueType(MetricDescriptor.ValueType.DISTRIBUTION) |
| .setMetric( |
| StackdriverExportUtils.createMetric( |
| view, Arrays.asList(VALUE_1), CUSTOM_OPENCENSUS_DOMAIN)) |
| .setResource(MonitoredResource.newBuilder().setType("global")) |
| .addPoints( |
| StackdriverExportUtils.createPoint(distributionData1, cumulativeData, DISTRIBUTION)) |
| .build(); |
| TimeSeries expected2 = |
| TimeSeries.newBuilder() |
| .setMetricKind(MetricKind.CUMULATIVE) |
| .setValueType(MetricDescriptor.ValueType.DISTRIBUTION) |
| .setMetric( |
| StackdriverExportUtils.createMetric( |
| view, Arrays.asList(VALUE_2), CUSTOM_OPENCENSUS_DOMAIN)) |
| .setResource(MonitoredResource.newBuilder().setType("global")) |
| .addPoints( |
| StackdriverExportUtils.createPoint(distributionData2, cumulativeData, DISTRIBUTION)) |
| .build(); |
| assertThat(timeSeriesList).containsExactly(expected1, expected2); |
| } |
| |
| @Test |
| public void createTimeSeriesList_interval() { |
| View view = |
| View.create( |
| Name.create(VIEW_NAME), |
| VIEW_DESCRIPTION, |
| MEASURE_DOUBLE, |
| DISTRIBUTION, |
| Arrays.asList(KEY), |
| INTERVAL); |
| Map<List<TagValue>, DistributionData> aggregationMap = |
| ImmutableMap.of( |
| Arrays.asList(VALUE_1), |
| DistributionData.create(2, 3, 0, 5, 14, Arrays.asList(0L, 1L, 1L, 0L, 1L)), |
| Arrays.asList(VALUE_2), |
| DistributionData.create(-1, 1, -1, -1, 0, Arrays.asList(1L, 0L, 0L, 0L, 0L))); |
| ViewData viewData = |
| ViewData.create(view, aggregationMap, IntervalData.create(Timestamp.fromMillis(2000))); |
| assertThat( |
| StackdriverExportUtils.createTimeSeriesList( |
| viewData, DEFAULT_RESOURCE, CUSTOM_OPENCENSUS_DOMAIN)) |
| .isEmpty(); |
| } |
| |
| @Test |
| public void createTimeSeriesList_withCustomMonitoredResource() { |
| MonitoredResource resource = |
| MonitoredResource.newBuilder().setType("global").putLabels("key", "value").build(); |
| View view = |
| View.create( |
| Name.create(VIEW_NAME), |
| VIEW_DESCRIPTION, |
| MEASURE_DOUBLE, |
| SUM, |
| Arrays.asList(KEY), |
| CUMULATIVE); |
| SumDataDouble sumData = SumDataDouble.create(55.5); |
| Map<List<TagValue>, SumDataDouble> aggregationMap = |
| ImmutableMap.of(Arrays.asList(VALUE_1), sumData); |
| CumulativeData cumulativeData = |
| CumulativeData.create(Timestamp.fromMillis(1000), Timestamp.fromMillis(2000)); |
| ViewData viewData = ViewData.create(view, aggregationMap, cumulativeData); |
| List<TimeSeries> timeSeriesList = |
| StackdriverExportUtils.createTimeSeriesList(viewData, resource, CUSTOM_OPENCENSUS_DOMAIN); |
| assertThat(timeSeriesList) |
| .containsExactly( |
| TimeSeries.newBuilder() |
| .setMetricKind(MetricKind.CUMULATIVE) |
| .setValueType(MetricDescriptor.ValueType.DOUBLE) |
| .setMetric( |
| StackdriverExportUtils.createMetric( |
| view, Arrays.asList(VALUE_1), CUSTOM_OPENCENSUS_DOMAIN)) |
| .setResource(resource) |
| .addPoints(StackdriverExportUtils.createPoint(sumData, cumulativeData, SUM)) |
| .build()); |
| } |
| } |
