feat(metrics): adds NoopMeter implementation (open-telemetry#278)

* feat(metrics): adds NoopMeter implementation

Resolves open-telemetry/opentelemetry-js#264

* yarn fix

* rename test file

* fix the build attempt 1

* respond to comments

* fix the build part 2

* yarn fix

Author: bg451

packages/opentelemetry-core/src/index.ts

@@ -32,3 +32,4 @@ export * from './trace/sampler/ProbabilitySampler';
 export * from './trace/spancontext-utils';
 export * from './trace/TracerDelegate';
 export * from './trace/TraceState';
+export * from './metrics/NoopMeter';

packages/opentelemetry-core/src/metrics/NoopMeter.ts

@@ -0,0 +1,139 @@
+/*!
+ * Copyright 2019, 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
+ *
+ *      https://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 {
+  CounterHandle,
+  DistributedContext,
+  GaugeHandle,
+  Meter,
+  Metric,
+  MetricOptions,
+  MeasureHandle,
+  SpanContext,
+} from '@opentelemetry/types';
+
+/**
+ * NoopMeter is a noop implementation of the {@link Meter} interface. It reuses constant
+ * NoopMetrics for all of its methods.
+ */
+export class NoopMeter implements Meter {
+  constructor() {}
+
+  /**
+   * Returns constant noop measure.
+   * @param name the name of the metric.
+   * @param [options] the metric options.
+   */
+  createMeasure(name: string, options?: MetricOptions): Metric<MeasureHandle> {
+    return NOOP_MEASURE_METRIC;
+  }
+
+  /**
+   * Returns a constant noop counter.
+   * @param name the name of the metric.
+   * @param [options] the metric options.
+   */
+  createCounter(name: string, options?: MetricOptions): Metric<CounterHandle> {
+    return NOOP_COUNTER_METRIC;
+  }
+
+  /**
+   * Returns a constant gauge metric.
+   * @param name the name of the metric.
+   * @param [options] the metric options.
+   */
+  createGauge(name: string, options?: MetricOptions): Metric<GaugeHandle> {
+    return NOOP_GAUGE_METRIC;
+  }
+}
+
+export class NoopMetric<T> implements Metric<T> {
+  private readonly _handle: T;
+
+  constructor(handle: T) {
+    this._handle = handle;
+  }
+  /**
+   * Returns a Handle associated with specified label values.
+   * It is recommended to keep a reference to the Handle instead of always
+   * calling this method for every operations.
+   * @param labelValues the list of label values.
+   */
+  getHandle(labelValues: string[]): T {
+    return this._handle;
+  }
+
+  /**
+   * Returns a Handle for a metric with all labels not set.
+   */
+  getDefaultHandle(): T {
+    return this._handle;
+  }
+
+  /**
+   * Removes the Handle from the metric, if it is present.
+   * @param labelValues the list of label values.
+   */
+  removeHandle(labelValues: string[]): void {
+    return;
+  }
+
+  /**
+   * Clears all timeseries from the Metric.
+   */
+  clear(): void {
+    return;
+  }
+
+  setCallback(fn: () => void): void {
+    return;
+  }
+}
+
+export class NoopCounterHandle implements CounterHandle {
+  add(value: number): void {
+    return;
+  }
+}
+
+export class NoopGaugeHandle implements GaugeHandle {
+  set(value: number): void {
+    return;
+  }
+}
+
+export class NoopMeasureHandle implements MeasureHandle {
+  record(
+    value: number,
+    distContext?: DistributedContext,
+    spanContext?: SpanContext
+  ): void {
+    return;
+  }
+}
+
+export const NOOP_GAUGE_HANDLE = new NoopGaugeHandle();
+export const NOOP_GAUGE_METRIC = new NoopMetric<GaugeHandle>(NOOP_GAUGE_HANDLE);
+
+export const NOOP_COUNTER_HANDLE = new NoopCounterHandle();
+export const NOOP_COUNTER_METRIC = new NoopMetric<CounterHandle>(
+  NOOP_COUNTER_HANDLE
+);
+
+export const NOOP_MEASURE_HANDLE = new NoopMeasureHandle();
+export const NOOP_MEASURE_METRIC = new NoopMetric<MeasureHandle>(
+  NOOP_MEASURE_HANDLE
+);

packages/opentelemetry-core/test/metrics/NoopMeter.test.ts

@@ -0,0 +1,90 @@
+/*!
+ * Copyright 2019, 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
+ *
+ *      https://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 {
+  NoopMeter,
+  NOOP_GAUGE_HANDLE,
+  NOOP_GAUGE_METRIC,
+  NOOP_COUNTER_HANDLE,
+  NOOP_COUNTER_METRIC,
+  NOOP_MEASURE_HANDLE,
+  NOOP_MEASURE_METRIC,
+} from '../../src/metrics/NoopMeter';
+
+describe('NoopMeter', () => {
+  it('should not crash', () => {
+    const meter = new NoopMeter();
+    const counter = meter.createCounter('some-name');
+    // ensure NoopMetric does not crash.
+    counter.setCallback(() => {
+      assert.fail('callback occurred');
+    });
+    counter.getHandle(['val1', 'val2']).add(1);
+    counter.getDefaultHandle().add(1);
+    counter.removeHandle(['val1', 'val2']);
+
+    // ensure the correct noop const is returned
+    assert.strictEqual(counter, NOOP_COUNTER_METRIC);
+    assert.strictEqual(
+      counter.getHandle(['val1', 'val2']),
+      NOOP_COUNTER_HANDLE
+    );
+    assert.strictEqual(counter.getDefaultHandle(), NOOP_COUNTER_HANDLE);
+    counter.clear();
+
+    const measure = meter.createMeasure('some-name');
+    measure.getDefaultHandle().record(1);
+    measure.getDefaultHandle().record(1, { key: { value: 'value' } });
+    measure.getDefaultHandle().record(
+      1,
+      { key: { value: 'value' } },
+      {
+        traceId: 'a3cda95b652f4a1592b449d5929fda1b',
+        spanId: '5e0c63257de34c92',
+      }
+    );
+
+    // ensure the correct noop const is returned
+    assert.strictEqual(measure, NOOP_MEASURE_METRIC);
+    assert.strictEqual(measure.getDefaultHandle(), NOOP_MEASURE_HANDLE);
+    assert.strictEqual(
+      measure.getHandle(['val1', 'val2']),
+      NOOP_MEASURE_HANDLE
+    );
+
+    const gauge = meter.createGauge('some-name');
+    gauge.getDefaultHandle().set(1);
+
+    // ensure the correct noop const is returned
+    assert.strictEqual(gauge, NOOP_GAUGE_METRIC);
+    assert.strictEqual(gauge.getDefaultHandle(), NOOP_GAUGE_HANDLE);
+    assert.strictEqual(gauge.getHandle(['val1', 'val2']), NOOP_GAUGE_HANDLE);
+
+    const options = {
+      component: 'tests',
+      description: 'the testing package',
+      labelKeys: ['key1', 'key2'],
+    };
+
+    const measureWithOptions = meter.createMeasure('some-name', options);
+    assert.strictEqual(measureWithOptions, NOOP_MEASURE_METRIC);
+    const counterWithOptions = meter.createCounter('some-name', options);
+    assert.strictEqual(counterWithOptions, NOOP_COUNTER_METRIC);
+    const gaugeWithOptions = meter.createGauge('some-name', options);
+    assert.strictEqual(gaugeWithOptions, NOOP_GAUGE_METRIC);
+  });
+});