Adds [MetricProducer], convertors to [DistributionValue] [Point] (#211)

* Adds [MetricProducer], convertors to [DistributionValue] [Point]
* Adds abstract class for [MetricProducer]

Author: isaikevych

packages/opencensus-core/src/metrics/export/metric-producer.ts

@@ -0,0 +1,29 @@
+/**
+ * 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.
+ */
+
+import {Metric} from './types';
+
+/**
+ * A MetricProducer producer that can be registered for exporting using
+ * MetricProducerManager.
+ */
+export abstract class MetricProducer {
+  /**
+   * Gets a collection of produced Metric`s to be exported.
+   * @returns {Metric[]} List of metrics
+   */
+  abstract getMetrics(): Metric[];
+}

packages/opencensus-core/src/metrics/export/types.ts

@@ -274,7 +274,8 @@ export interface SummaryValue {
    */
   readonly sum: number;
   /** Values calculated over an arbitrary time window. */
-  readonly snapshot: Snapshot;
+  // TODO: Change it to required when Exemplar functionality will be added.
+  readonly snapshot?: Snapshot;
 }
 
 /**

packages/opencensus-core/src/stats/metric-producer.ts

@@ -0,0 +1,44 @@
+/**
+ * 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.
+ */
+
+import {MetricProducer} from '../metrics/export/metric-producer';
+import {Metric} from '../metrics/export/types';
+
+import {Stats} from './stats';
+
+/**
+ * A MetricProducer producer that can be registered for exporting using
+ * MetricProducerManager.
+ */
+export class MetricProducerForStats extends MetricProducer {
+  private statsManager: Stats;
+
+  /**
+   * @param statsManager The stats
+   */
+  constructor(statsManager: Stats) {
+    super();
+    this.statsManager = statsManager;
+  }
+
+  /**
+   * Gets a collection of produced Metric`s to be exported.
+   * @returns {Metric[]} List of metrics
+   */
+  getMetrics(): Metric[] {
+    return this.statsManager.getMetrics();
+  }
+}

packages/opencensus-core/src/stats/metric-utils.ts

@@ -25,6 +25,7 @@ export class MetricUtils {
    * Gets the corresponding metric type for the given stats type.
    * @param measure The measure for which to find a metric type
    * @param aggregation The aggregation for which to find a metric type
+   * @returns {MetricDescriptorType} Type of metric descriptor
    */
   private static getType(measure: Measure, aggregation: AggregationType):
       MetricDescriptorType {
@@ -57,6 +58,7 @@ export class MetricUtils {
   /**
    * Gets a MetricDescriptor for given view.
    * @param view The view for which to build a metric descriptor
+   * @returns {MetricDescriptor}
    */
   static viewToMetricDescriptor(view: View): MetricDescriptor {
     return {
@@ -69,10 +71,11 @@ export class MetricUtils {
   }
 
   /**
-   * Converts tag values to label values.
+   * Converts tags to label values.
    * @param tags
+   * @returns {LabelValue[]} List of label values
    */
-  static tagValuesToLabelValues(tags: Tags): LabelValue[] {
+  static tagsToLabelValues(tags: Tags): LabelValue[] {
     return Object.keys(tags).map(key => {
       return {value: tags[key]} as LabelValue;
     });

packages/opencensus-core/src/stats/stats.ts

@@ -17,6 +17,7 @@
 import * as defaultLogger from '../common/console-logger';
 import * as loggerTypes from '../common/types';
 import {StatsEventListener} from '../exporters/types';
+import {Metric} from '../metrics/export/types';
 
 import {AggregationType, Measure, Measurement, MeasureType, MeasureUnit, View} from './types';
 import {BaseView} from './view';
@@ -123,6 +124,22 @@ export class Stats {
     return measurements.some(measurement => measurement.value < 0);
   }
 
+  /**
+   * Gets a collection of produced Metric`s to be exported.
+   * @returns {Metric[]} List of metrics
+   */
+  getMetrics(): Metric[] {
+    const metrics: Metric[] = [];
+
+    for (const measureName of Object.keys(this.registeredViews)) {
+      for (const view of this.registeredViews[measureName]) {
+        metrics.push(view.getMetric());
+      }
+    }
+
+    return metrics;
+  }
+
   /**
    * Updates all views with the new measurements.
    * @param measurements A list of measurements to record

packages/opencensus-core/src/stats/types.ts

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import {Metric} from '../metrics/export/types';
+
 /** Tags are maps of names -> values */
 export interface Tags { [key: string]: string; }
 
@@ -113,6 +115,8 @@ export interface View {
   getSnapshot(tags: Tags): AggregationData;
   /** Gets the view's tag keys */
   getColumns(): string[];
+  /** Gets view`s metric */
+  getMetric(): Metric;
 }
 
 /**
@@ -189,7 +193,7 @@ export interface DistributionData extends AggregationMetadata {
   /** Bucket distribution of the histogram */
   buckets: Bucket[];
   /** Buckets count */
-  bucketCounts: number[];
+  bucketCounts?: number[];
 }
 
 export type Bucket = number;

packages/opencensus-core/src/stats/view.ts

@@ -16,7 +16,10 @@
 
 import * as defaultLogger from '../common/console-logger';
 import * as loggerTypes from '../common/types';
+import {LabelValue, Metric, MetricDescriptor, MetricDescriptorType, Point, TimeSeries, Timestamp} from '../metrics/export/types';
+
 import {BucketBoundaries} from './bucket-boundaries';
+import {MetricUtils} from './metric-utils';
 import {Recorder} from './recorder';
 import {AggregationData, AggregationType, Measure, Measurement, Tags, View} from './types';
 
@@ -56,6 +59,11 @@ export class BaseView implements View {
   readonly startTime: number;
   /** The bucket boundaries in a Distribution Aggregation */
   private bucketBoundaries: BucketBoundaries;
+  /**
+   * Cache a MetricDescriptor to avoid converting View to MetricDescriptor
+   * in the future.
+   */
+  private metricDescriptor: MetricDescriptor;
   /**
    * The end time for this view - represents the last time a value was recorded
    */
@@ -93,6 +101,7 @@ export class BaseView implements View {
     this.aggregation = aggregation;
     this.startTime = Date.now();
     this.bucketBoundaries = new BucketBoundaries(bucketBoundaries);
+    this.metricDescriptor = MetricUtils.viewToMetricDescriptor(this);
   }
 
   /** Gets the view's tag keys */
@@ -185,9 +194,65 @@ export class BaseView implements View {
     }
   }
 
+  /**
+   * Gets view`s metric
+   * @returns {Metric}
+   */
+  getMetric(): Metric {
+    const {type} = this.metricDescriptor;
+    let startTimestamp: Timestamp;
+
+    switch (type) {
+      case MetricDescriptorType.GAUGE_INT64:
+      case MetricDescriptorType.GAUGE_DOUBLE:
+        startTimestamp = null;
+        break;
+      default:
+        const [seconds, nanos] = process.hrtime();
+        startTimestamp = {seconds, nanos};
+    }
+
+    const timeseries: TimeSeries[] = [];
+
+    Object.keys(this.rows).forEach(key => {
+      const {tags} = this.rows[key];
+      const labelValues: LabelValue[] = MetricUtils.tagsToLabelValues(tags);
+      const point: Point = this.toPoint(startTimestamp, this.getSnapshot(tags));
+      timeseries.push({startTimestamp, labelValues, points: [point]});
+    });
+
+    return {descriptor: this.metricDescriptor, timeseries};
+  }
+
+  /**
+   * Converts snapshot to point
+   * @param timestamp The timestamp
+   * @param data The aggregated data
+   * @returns {Point}
+   */
+  private toPoint(timestamp: Timestamp, data: AggregationData): Point {
+    let value;
+
+    if (data.type === AggregationType.DISTRIBUTION) {
+      // TODO: Add examplar transition
+      const {count, sum, sumOfSquaredDeviation} = data;
+      value = {
+        count,
+        sum,
+        sumOfSquaredDeviation,
+        bucketOptions: {explicit: {bounds: data.buckets}},
+        buckets: data.bucketCounts
+      };
+    } else {
+      value = data.value;
+    }
+    return {timestamp, value};
+  }
+
   /**
    * Returns a snapshot of an AggregationData for that tags/labels values.
    * @param tags The desired data's tags
+   * @returns {AggregationData}
    */
   getSnapshot(tags: Tags): AggregationData {
     return this.rows[this.encodeTags(tags)];

packages/opencensus-core/test/test-metric-producer.ts

@@ -0,0 +1,101 @@
+/**
+ * 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.
+ */
+
+import * as assert from 'assert';
+
+import {AggregationType, Measure, MeasureType, MeasureUnit, Stats, Tags, View} from '../src';
+import {MetricDescriptorType} from '../src/metrics/export/types';
+import {MetricProducerForStats} from '../src/stats/metric-producer';
+
+describe('Metric producer for stats', () => {
+  interface AggregationTestCase {
+    aggregationType: AggregationType;
+    description: string;
+    metricDescriptorType: MetricDescriptorType;
+  }
+  const aggregationTestCases: AggregationTestCase[] = [
+    {
+      aggregationType: AggregationType.SUM,
+      description: 'Sum',
+      metricDescriptorType: MetricDescriptorType.CUMULATIVE_DOUBLE
+    },
+    {
+      aggregationType: AggregationType.COUNT,
+      description: 'Count',
+      metricDescriptorType: MetricDescriptorType.CUMULATIVE_INT64
+    },
+    {
+      aggregationType: AggregationType.LAST_VALUE,
+      description: 'Last Value',
+      metricDescriptorType: MetricDescriptorType.GAUGE_DOUBLE
+    },
+    {
+      aggregationType: AggregationType.DISTRIBUTION,
+      description: 'Distribution',
+      metricDescriptorType: MetricDescriptorType.CUMULATIVE_DISTRIBUTION
+    }
+  ];
+  const measure: Measure = {
+    name: 'Test Measure',
+    type: MeasureType.DOUBLE,
+    unit: MeasureUnit.UNIT
+  };
+
+  let stats: Stats;
+  let metricProducerForStats: MetricProducerForStats;
+
+  beforeEach(() => {
+    stats = new Stats();
+    metricProducerForStats = new MetricProducerForStats(stats);
+  });
+
+  describe('Metric producer', () => {
+    const tags: Tags = {testKey1: 'testValue', testKey2: 'testValue'};
+    const measurementValues = [1.1, 2.3, 3.2, 4.3, 5.2];
+    const buckets = [2, 4, 6];
+
+    describe('getMetrics()', () => {
+      // Detailed coverage in test-viev.ts
+      for (const aggregation of aggregationTestCases) {
+        it(`should return list of metrics for ${
+               aggregation.aggregationType} aggregation`,
+           () => {
+             const view: View = stats.createView(
+                 'test/view/name', measure, aggregation.aggregationType,
+                 Object.keys(tags), 'test description', buckets);
+             for (const value of measurementValues) {
+               const measurement = {measure, tags, value};
+               view.recordMeasurement(measurement);
+             }
+
+             const metrics = metricProducerForStats.getMetrics();
+
+             assert.strictEqual(metrics.length, 1);
+             const [{descriptor, timeseries}] = metrics;
+
+             assert.deepStrictEqual(descriptor, {
+               name: 'test/view/name',
+               description: 'test description',
+               'labelKeys': [{'key': 'testKey1'}, {'key': 'testKey2'}],
+               unit: MeasureUnit.UNIT,
+               type: aggregation.metricDescriptorType,
+             });
+             assert.strictEqual(timeseries.length, 1);
+           });
+      }
+    });
+  });
+});

packages/opencensus-core/test/test-metric-utils.ts

@@ -48,7 +48,7 @@ describe('MetricUtil', () => {
   it('should convert tag values to label values', () => {
     const tags: Tags = {test: 'test1', tag: 'test2', empty: '', fake: null};
     assert.deepStrictEqual(
-        MetricUtils.tagValuesToLabelValues(tags),
+        MetricUtils.tagsToLabelValues(tags),
         [{value: 'test1'}, {value: 'test2'}, {value: ''}, {value: null}]);
   });
 });