Prototype of a very basic Aggregation-configuration API in the SDK.

sdk/src/main/java/io/opentelemetry/sdk/metrics/ActiveBatcher.java

@@ -50,4 +50,9 @@ public void batch(Labels labelSet, Aggregator aggregator, boolean mappedAggregat
  public List<MetricData> completeCollectionCycle() {
  return batcher.completeCollectionCycle();
  }
+
+ @Override
+ public boolean generatesDeltas() {
+ return batcher.generatesDeltas();
+ }
 }

sdk/src/main/java/io/opentelemetry/sdk/metrics/Batcher.java

@@ -62,4 +62,7 @@ interface Batcher {
  * @return the list of metrics batched in this Batcher.
  */
  List<MetricData> completeCollectionCycle();
+
+ /** Does this batcher generate "delta" style metrics. The alternative is "cumulative". */
+ boolean generatesDeltas();
 }

sdk/src/main/java/io/opentelemetry/sdk/metrics/Batchers.java

@@ -92,6 +92,11 @@ public void batch(Labels labelSet, Aggregator aggregator, boolean mappedAggregat
  public List<MetricData> completeCollectionCycle() {
  return Collections.emptyList();
  }
+
+ @Override
+ public boolean generatesDeltas() {
+ return false;
+ }
  }
 
  private static final class AllLabels implements Batcher {
@@ -158,6 +163,11 @@ public final List<MetricData> completeCollectionCycle() {
  return Collections.singletonList(
  MetricData.create(descriptor, resource, instrumentationLibraryInfo, points));
  }
+
+ @Override
+ public boolean generatesDeltas() {
+ return delta;
+ }
  }
 
  private static Descriptor getDefaultMetricDescriptor(

sdk/src/main/java/io/opentelemetry/sdk/metrics/MeterSdkProvider.java

@@ -23,6 +23,8 @@
 import io.opentelemetry.sdk.internal.MillisClock;
 import io.opentelemetry.sdk.metrics.data.MetricData;
 import io.opentelemetry.sdk.metrics.export.MetricProducer;
+import io.opentelemetry.sdk.metrics.view.AggregationConfiguration;
+import io.opentelemetry.sdk.metrics.view.InstrumentSelector;
 import io.opentelemetry.sdk.resources.Resource;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -41,11 +43,12 @@ public final class MeterSdkProvider implements MeterProvider {
 
  private final MeterSdkComponentRegistry registry;
  private final MetricProducer metricProducer;
+ private final ViewRegistry viewRegistry = new ViewRegistry();
 
  private MeterSdkProvider(Clock clock, Resource resource) {
  this.registry =
  new MeterSdkComponentRegistry(
- MeterProviderSharedState.create(clock, resource), new ViewRegistry());
+ MeterProviderSharedState.create(clock, resource), viewRegistry);
  this.metricProducer = new MetricProducerSdk(this.registry);
  }
 
@@ -142,6 +145,34 @@ public MeterSdk newComponent(InstrumentationLibraryInfo instrumentationLibraryIn
  }
  }
 
+ /**
+ * Register a view with the given {@link InstrumentSelector}.
+ *
+ * <p>Example on how to register a view:
+ *
+ * <pre>{@code
+ * // get a handle to the MeterSdkProvider
+ * MeterSdkProvider meterProvider = OpenTelemetrySdk.getMeterProvider();
+ *
+ * // create a selector to select which instruments to customize:
+ * InstrumentSelector instrumentSelector = InstrumentSelector.newBuilder()
+ * .instrumentType(InstrumentType.COUNTER)
+ * .build();
+ *
+ * // create a specification of how you want the metrics aggregated:
+ * AggregationConfiguration viewSpecification =
+ * AggregationConfiguration.create(Aggregations.minMaxSumCount(), Temporality.DELTA);
+ *
+ * //register the view with the MeterSdkProvider
+ * meterProvider.registerView(instrumentSelector, viewSpecification);
+ * }</pre>
+ *
+ * @see AggregationConfiguration
+ */
+ public void registerView(InstrumentSelector selector, AggregationConfiguration specification) {
+ viewRegistry.registerView(selector, specification);
+ }
+
  private static final class MetricProducerSdk implements MetricProducer {
  private final MeterSdkComponentRegistry registry;
 

sdk/src/main/java/io/opentelemetry/sdk/metrics/ViewRegistry.java

@@ -17,27 +17,43 @@
 package io.opentelemetry.sdk.metrics;
 
 import io.opentelemetry.sdk.metrics.view.Aggregation;
+import io.opentelemetry.sdk.metrics.view.AggregationConfiguration;
+import io.opentelemetry.sdk.metrics.view.AggregationConfiguration.Temporality;
 import io.opentelemetry.sdk.metrics.view.Aggregations;
+import io.opentelemetry.sdk.metrics.view.InstrumentSelector;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.regex.Pattern;
 
 // notes:
 // specify by pieces of the descriptor.
-// instrument type
-// instrument value type
-// instrument name (wildcards allowed?)
+// instrument type √
+// instrument name (regex) √
+// instrument value type (?)
 // constant labels (?)
 // units (?)
 
 // what you can choose:
-// aggregation
+// aggregation √
+// delta vs. cumulative √
 // all labels vs. a list of labels
-// delta vs. cumulative
 
 /**
  * Central location for Views to be registered. Registration of a view should eventually be done via
  * the {@link io.opentelemetry.sdk.metrics.MeterSdkProvider}.
  */
 class ViewRegistry {
 
+ private static final AggregationConfiguration CUMULATIVE_SUM =
+ AggregationConfiguration.create(Aggregations.sum(), Temporality.CUMULATIVE);
+ private static final AggregationConfiguration DELTA_SUMMARY =
+ AggregationConfiguration.create(Aggregations.minMaxSumCount(), Temporality.DELTA);
+ private static final AggregationConfiguration CUMULATIVE_LAST_VALUE =
+ AggregationConfiguration.create(Aggregations.lastValue(), Temporality.CUMULATIVE);
+
+ private final Map<InstrumentSelector, AggregationConfiguration> configuration =
+ new ConcurrentHashMap<>();
+
  /**
  * Create a new {@link io.opentelemetry.sdk.metrics.Batcher} for use in metric recording
  * aggregation.
@@ -47,39 +63,71 @@ Batcher createBatcher(
  MeterSharedState meterSharedState,
  InstrumentDescriptor descriptor) {
 
- Aggregation aggregation = getRegisteredAggregation(descriptor);
+ AggregationConfiguration specification = findBestMatch(descriptor);
 
- // todo: don't just use the defaults!
- switch (descriptor.getType()) {
- case COUNTER:
- case UP_DOWN_COUNTER:
- case SUM_OBSERVER:
- case UP_DOWN_SUM_OBSERVER:
- return Batchers.getCumulativeAllLabels(
- descriptor, meterProviderSharedState, meterSharedState, aggregation);
- case VALUE_RECORDER:
- // TODO: Revisit the batcher used here for value observers,
- // currently this does not remove duplicate records in the same cycle.
- case VALUE_OBSERVER:
- return Batchers.getDeltaAllLabels(
- descriptor, meterProviderSharedState, meterSharedState, aggregation);
+ Aggregation aggregation = specification.aggregation();
+
+ if (Temporality.CUMULATIVE == specification.temporality()) {
+ return Batchers.getCumulativeAllLabels(
+ descriptor, meterProviderSharedState, meterSharedState, aggregation);
+ } else if (Temporality.DELTA == specification.temporality()) {
+ return Batchers.getDeltaAllLabels(
+ descriptor, meterProviderSharedState, meterSharedState, aggregation);
  }
- throw new IllegalArgumentException("Unknown descriptor type: " + descriptor.getType());
+ throw new IllegalStateException("unsupported Temporality: " + specification.temporality());
  }
 
- private static Aggregation getRegisteredAggregation(InstrumentDescriptor descriptor) {
- // todo look up based on fields of the descriptor.
+ // todo: consider moving this method to its own class, for more targetted testing.
+ private AggregationConfiguration findBestMatch(InstrumentDescriptor descriptor) {
+
+ for (Map.Entry<InstrumentSelector, AggregationConfiguration> entry : configuration.entrySet()) {
+ InstrumentSelector registeredSelector = entry.getKey();
+
+ if (matchesOnType(descriptor, registeredSelector)
+ && matchesOnName(descriptor, registeredSelector)) {
+ return entry.getValue();
+ }
+ }
+
+ // If none found, use the defaults:
+ return getDefaultSpecification(descriptor);
+ }
+
+ private static boolean matchesOnType(
+ InstrumentDescriptor descriptor, InstrumentSelector registeredSelector) {
+ if (registeredSelector.instrumentType() == null) {
+ return true;
+ }
+ return registeredSelector.instrumentType().equals(descriptor.getType());
+ }
+
+ private static boolean matchesOnName(
+ InstrumentDescriptor descriptor, InstrumentSelector registeredSelector) {
+ Pattern pattern = registeredSelector.instrumentNamePattern();
+ if (pattern == null) {
+ return true;
+ }
+ return pattern.matcher(descriptor.getName()).matches();
+ }
+
+ private static AggregationConfiguration getDefaultSpecification(InstrumentDescriptor descriptor) {
  switch (descriptor.getType()) {
  case COUNTER:
  case UP_DOWN_COUNTER:
- return Aggregations.sum();
- case VALUE_RECORDER:
+ return CUMULATIVE_SUM;
+ // TODO: Revisit the batcher used here for value observers,
+ // currently this does not remove duplicate records in the same cycle.
  case VALUE_OBSERVER:
- return Aggregations.minMaxSumCount();
+ case VALUE_RECORDER:
+ return DELTA_SUMMARY;
  case SUM_OBSERVER:
  case UP_DOWN_SUM_OBSERVER:
- return Aggregations.lastValue();
+ return CUMULATIVE_LAST_VALUE;
  }
  throw new IllegalArgumentException("Unknown descriptor type: " + descriptor.getType());
  }
+
+ void registerView(InstrumentSelector selector, AggregationConfiguration specification) {
+ configuration.put(selector, specification);
+ }
 }

sdk/src/main/java/io/opentelemetry/sdk/metrics/view/AggregationConfiguration.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2020, OpenTelemetry 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.opentelemetry.sdk.metrics.view;
+
+import com.google.auto.value.AutoValue;
+import io.opentelemetry.metrics.Instrument;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+
+@AutoValue
+@Immutable
+public abstract class AggregationConfiguration {
+
+ public static AggregationConfiguration create(Aggregation aggregation, Temporality temporality) {
+ return new AutoValue_AggregationConfiguration(aggregation, temporality);
+ }
+
+ /** Which {@link Aggregation} should be used for this View. */
+ @Nullable
+ public abstract Aggregation aggregation();
+
+ /** What {@link Temporality} should be used for this View (delta vs. cumulative). */
+ @Nullable
+ public abstract Temporality temporality();
+
+ /** An enumeration which describes the time period over which metrics should be aggregated. */
+ public enum Temporality {
+ /** Metrics will be aggregated only over the most recent collection interval. */
+ DELTA,
+ /** Metrics will be aggregated over the lifetime of the associated {@link Instrument}. */
+ CUMULATIVE
+ }
+}

sdk/src/main/java/io/opentelemetry/sdk/metrics/view/InstrumentSelector.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2020, OpenTelemetry 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.opentelemetry.sdk.metrics.view;
+
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import io.opentelemetry.sdk.metrics.common.InstrumentType;
+import java.util.regex.Pattern;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+
+@AutoValue
+@Immutable
+public abstract class InstrumentSelector {
+
+ public static Builder newBuilder() {
+ return new AutoValue_InstrumentSelector.Builder();
+ }
+
+ @Nullable
+ public abstract InstrumentType instrumentType();
+
+ @Nullable
+ public abstract String instrumentNameRegex();
+
+ @Memoized
+ @Nullable
+ public Pattern instrumentNamePattern() {
+ return instrumentNameRegex() == null ? null : Pattern.compile(instrumentNameRegex());
+ }
+
+ @AutoValue.Builder
+ public interface Builder {
+ Builder instrumentType(InstrumentType instrumentType);
+
+ Builder instrumentNameRegex(String regex);
+
+ InstrumentSelector build();
+ }
+}