feat: direct calling of metric instruments

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

@@ -21,6 +21,7 @@ import {
   Meter,
   Metric,
   MetricOptions,
+  MetricUtils,
   MeasureHandle,
   SpanContext,
   LabelSet,
@@ -110,6 +111,26 @@ export class NoopMetric<T> implements Metric<T> {
   }
 }
 
+export class NoopCounterMetric extends NoopMetric<CounterHandle>
+  implements Pick<MetricUtils, 'add'> {
+  add(value: number, labelSet: LabelSet) {
+    this.getHandle(labelSet).add(value);
+  }
+}
+
+export class NoopGaugeMetric extends NoopMetric<GaugeHandle>
+  implements Pick<MetricUtils, 'set'> {
+  set(value: number, labelSet: LabelSet) {
+    this.getHandle(labelSet).set(value);
+  }
+}
+
+export class NoopMeasureMetric extends NoopMetric<MeasureHandle> {
+  record(value: number, labelSet: LabelSet) {
+    this.getHandle(labelSet).record(value);
+  }
+}
+
 export class NoopCounterHandle implements CounterHandle {
   add(value: number): void {
     return;
@@ -133,16 +154,12 @@ export class NoopMeasureHandle implements MeasureHandle {
 }
 
 export const NOOP_GAUGE_HANDLE = new NoopGaugeHandle();
-export const NOOP_GAUGE_METRIC = new NoopMetric<GaugeHandle>(NOOP_GAUGE_HANDLE);
+export const NOOP_GAUGE_METRIC = new NoopGaugeMetric(NOOP_GAUGE_HANDLE);
 
 export const NOOP_COUNTER_HANDLE = new NoopCounterHandle();
-export const NOOP_COUNTER_METRIC = new NoopMetric<CounterHandle>(
-  NOOP_COUNTER_HANDLE
-);
+export const NOOP_COUNTER_METRIC = new NoopCounterMetric(NOOP_COUNTER_HANDLE);
 
 export const NOOP_MEASURE_HANDLE = new NoopMeasureHandle();
-export const NOOP_MEASURE_METRIC = new NoopMetric<MeasureHandle>(
-  NOOP_MEASURE_HANDLE
-);
+export const NOOP_MEASURE_METRIC = new NoopMeasureMetric(NOOP_MEASURE_HANDLE);
 
 export const NOOP_LABEL_SET = {} as LabelSet;

packages/opentelemetry-metrics/src/LabelSet.ts

@@ -28,12 +28,3 @@ export class LabelSet implements types.LabelSet {
     this.labels = labels;
   }
 }
-
-/**
- * Type guard to remove nulls from arrays
- *
- * @param value value to be checked for null equality
- */
-export function notNull<T>(value: T | null): value is T {
-  return value !== null;
-}

packages/opentelemetry-metrics/src/Metric.ts

@@ -121,7 +121,8 @@ export abstract class Metric<T extends BaseHandle> implements types.Metric<T> {
 }
 
 /** This is a SDK implementation of Counter Metric. */
-export class CounterMetric extends Metric<CounterHandle> {
+export class CounterMetric extends Metric<CounterHandle>
+  implements Pick<types.MetricUtils, 'add'> {
   constructor(
     name: string,
     options: MetricOptions,
@@ -145,10 +146,20 @@ export class CounterMetric extends Metric<CounterHandle> {
       this._onUpdate
     );
   }
+
+  /**
+   * Adds the given value to the current value. Values cannot be negative.
+   * @param value the value to add.
+   * @param labelSet the canonicalized LabelSet used to associate with this metric's handle.
+   */
+  add(value: number, labelSet: types.LabelSet) {
+    this.getHandle(labelSet).add(value);
+  }
 }
 
 /** This is a SDK implementation of Gauge Metric. */
-export class GaugeMetric extends Metric<GaugeHandle> {
+export class GaugeMetric extends Metric<GaugeHandle>
+  implements Pick<types.MetricUtils, 'set'> {
   constructor(
     name: string,
     options: MetricOptions,
@@ -172,4 +183,13 @@ export class GaugeMetric extends Metric<GaugeHandle> {
       this._onUpdate
     );
   }
+
+  /**
+   * Sets the given value. Values can be negative.
+   * @param value the new value.
+   * @param labelSet the canonicalized LabelSet used to associate with this metric's handle.
+   */
+  set(value: number, labelSet: types.LabelSet) {
+    this.getHandle(labelSet).set(value);
+  }
 }

packages/opentelemetry-metrics/test/Meter.test.ts

@@ -76,6 +76,14 @@ describe('Meter', () => {
       assert.ok(counter instanceof Metric);
     });
 
+    it('should be able to call add() directly on counter', () => {
+      const counter = meter.createCounter('name') as CounterMetric;
+      counter.add(10, labelSet);
+      assert.strictEqual(counter.getHandle(labelSet)['_data'], 10);
+      counter.add(10, labelSet);
+      assert.strictEqual(counter.getHandle(labelSet)['_data'], 20);
+    });
+
     describe('.getHandle()', () => {
       it('should create a counter handle', () => {
         const counter = meter.createCounter('name') as CounterMetric;
@@ -229,6 +237,14 @@ describe('Meter', () => {
       assert.ok(gauge instanceof Metric);
     });
 
+    it('should be able to call set() directly on gauge', () => {
+      const gauge = meter.createGauge('name') as GaugeMetric;
+      gauge.set(10, labelSet);
+      assert.strictEqual(gauge.getHandle(labelSet)['_data'], 10);
+      gauge.set(250, labelSet);
+      assert.strictEqual(gauge.getHandle(labelSet)['_data'], 250);
+    });
+
     describe('.getHandle()', () => {
       it('should create a gauge handle', () => {
         const gauge = meter.createGauge('name') as GaugeMetric;

packages/opentelemetry-types/src/metrics/Metric.ts

@@ -99,6 +99,23 @@ export interface Metric<T> {
   setCallback(fn: () => void): void;
 }
 
+export interface MetricUtils {
+  /**
+   * Adds the given value to the current value. Values cannot be negative.
+   */
+  add(value: number, labelSet: LabelSet): void;
+  /**
+   * Sets the given value. Values can be negative.
+   */
+
+  set(value: number, labelSet: LabelSet): void;
+  /**
+   * Records the given value to this measure.
+   */
+
+  record(value: number, labelSet: LabelSet): void;
+}
+
 /**
  * key-value pairs passed by the user.
  */