feat(api): Add delegating no-op meter provider

CHANGELOG.md

@@ -10,6 +10,8 @@ For experimental package changes, see the [experimental CHANGELOG](experimental/
 
 ### :boom: Breaking Change
 
+* feat(api) Add delegating no-op meter provider [#4858](https://github.com/open-telemetry/opentelemetry-js/pull/4858) @hectorhdzg
+
 ### :rocket: (Enhancement)
 
 ### :bug: (Bug Fix)

api/src/api/metrics.ts

@@ -16,13 +16,13 @@
 
 import { Meter, MeterOptions } from '../metrics/Meter';
 import { MeterProvider } from '../metrics/MeterProvider';
-import { NOOP_METER_PROVIDER } from '../metrics/NoopMeterProvider';
 import {
   getGlobal,
   registerGlobal,
   unregisterGlobal,
 } from '../internal/global-utils';
 import { DiagAPI } from './diag';
+import { ProxyMeterProvider } from '../metrics/ProxyMeterProvider';
 
 const API_NAME = 'metrics';
 
@@ -32,6 +32,8 @@ const API_NAME = 'metrics';
 export class MetricsAPI {
   private static _instance?: MetricsAPI;
 
+  private _proxyMeterProvider = new ProxyMeterProvider();
+
   /** Empty private constructor prevents end users from constructing a new instance of the API */
   private constructor() {}
 
@@ -49,14 +51,22 @@ export class MetricsAPI {
    * Returns true if the meter provider was successfully registered, else false.
    */
   public setGlobalMeterProvider(provider: MeterProvider): boolean {
-    return registerGlobal(API_NAME, provider, DiagAPI.instance());
+    const success = registerGlobal(
+      API_NAME,
+      this._proxyMeterProvider,
+      DiagAPI.instance()
+    );
+    if (success) {
+      this._proxyMeterProvider.setDelegate(provider);
+    }
+    return success;
   }
 
   /**
    * Returns the global meter provider.
    */
   public getMeterProvider(): MeterProvider {
-    return getGlobal(API_NAME) || NOOP_METER_PROVIDER;
+    return getGlobal(API_NAME) || this._proxyMeterProvider;
   }
 
   /**
@@ -73,5 +83,6 @@ export class MetricsAPI {
   /** Remove the global meter provider */
   public disable(): void {
     unregisterGlobal(API_NAME, DiagAPI.instance());
+    this._proxyMeterProvider = new ProxyMeterProvider();
   }
 }

api/src/index.ts

@@ -37,6 +37,8 @@ export {
 export type { DiagAPI } from './api/diag';
 
 // Metrics APIs
+export { ProxyMeter, MeterDelegator } from './metrics/ProxyMeter';
+export { ProxyMeterProvider } from './metrics/ProxyMeterProvider';
 export { createNoopMeter } from './metrics/NoopMeter';
 export { MeterOptions, Meter } from './metrics/Meter';
 export { MeterProvider } from './metrics/MeterProvider';

api/src/metrics/ProxyMeter.ts

@@ -0,0 +1,156 @@
+/*
+ * Copyright The 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 { Meter, MeterOptions } from './Meter';
+import { NoopMeter } from './NoopMeter';
+import {
+  BatchObservableCallback,
+  Counter,
+  Histogram,
+  MetricOptions,
+  ObservableCounter,
+  ObservableGauge,
+  ObservableUpDownCounter,
+  UpDownCounter,
+  Observable,
+  Gauge,
+} from './Metric';
+
+const NOOP_METER = new NoopMeter();
+
+/**
+ * Proxy meter provided by the proxy meter provider
+ */
+export class ProxyMeter implements Meter {
+  // When a real implementation is provided, this will be it
+  private _delegate?: Meter;
+
+  constructor(
+    private _provider: MeterDelegator,
+    public readonly name: string,
+    public readonly version?: string,
+    public readonly options?: MeterOptions
+  ) {}
+
+  /**
+   * @see {@link Meter.createGauge}
+   */
+  createGauge(_name: string, _options?: MetricOptions): Gauge {
+    return this._getMeter().createGauge(_name, _options);
+  }
+
+  /**
+   * @see {@link Meter.createUpDownCounter}
+   */
+  createHistogram(_name: string, _options?: MetricOptions): Histogram {
+    return this._getMeter().createHistogram(_name, _options);
+  }
+
+  /**
+   * @see {@link Meter.createUpDownCounter}
+   */
+  createCounter(_name: string, _options?: MetricOptions): Counter {
+    return this._getMeter().createCounter(_name, _options);
+  }
+
+  /**
+   * @see {@link Meter.createUpDownCounter}
+   */
+  createUpDownCounter(_name: string, _options?: MetricOptions): UpDownCounter {
+    return this._getMeter().createUpDownCounter(_name, _options);
+  }
+
+  /**
+   * @see {@link Meter.createObservableGauge}
+   */
+  createObservableGauge(
+    _name: string,
+    _options?: MetricOptions
+  ): ObservableGauge {
+    return this._getMeter().createObservableGauge(_name, _options);
+  }
+
+  /**
+   * @see {@link Meter.createObservableCounter}
+   */
+  createObservableCounter(
+    _name: string,
+    _options?: MetricOptions
+  ): ObservableCounter {
+    return this._getMeter().createObservableCounter(_name, _options);
+  }
+
+  /**
+   * @see {@link Meter.createObservableUpDownCounter}
+   */
+  createObservableUpDownCounter(
+    _name: string,
+    _options?: MetricOptions
+  ): ObservableUpDownCounter {
+    return this._getMeter().createObservableUpDownCounter(_name, _options);
+  }
+
+  /**
+   * @see {@link Meter.addBatchObservableCallback}
+   */
+  addBatchObservableCallback(
+    _callback: BatchObservableCallback,
+    _observables: Observable[]
+  ): void {
+    this._getMeter().addBatchObservableCallback(_callback, _observables);
+  }
+
+  /**
+   * @see {@link Meter.removeBatchObservableCallback}
+   */
+  removeBatchObservableCallback(
+    _callback: BatchObservableCallback,
+    _observables: Observable[]
+  ): void {
+    this._getMeter().removeBatchObservableCallback(_callback, _observables);
+  }
+
+  /**
+   * Try to get a meter from the proxy meter provider.
+   * If the proxy meter provider has no delegate, return a noop meter.
+   */
+  private _getMeter() {
+    if (this._delegate) {
+      return this._delegate;
+    }
+
+    const meter = this._provider.getDelegateMeter(
+      this.name,
+      this.version,
+      this.options
+    );
+
+    if (!meter) {
+      return NOOP_METER;
+    }
+
+    this._delegate = meter;
+    return this._delegate;
+  }
+}
+
+export interface MeterDelegator {
+  getDelegateMeter(
+    name: string,
+    version?: string,
+    options?: MeterOptions
+  ): Meter | undefined;
+}

api/src/metrics/ProxyMeterProvider.ts

@@ -0,0 +1,63 @@
+/*
+ * Copyright The 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 { MeterProvider } from './MeterProvider';
+import { ProxyMeter } from './ProxyMeter';
+import { NoopMeterProvider } from './NoopMeterProvider';
+import { Meter, MeterOptions } from './Meter';
+
+const NOOP_METER_PROVIDER = new NoopMeterProvider();
+
+/**
+ * Meter provider which provides {@link ProxyMeter}s.
+ *
+ * Before a delegate is set, meters provided are NoOp.
+ *   When a delegate is set, meters are provided from the delegate.
+ *   When a delegate is set after meters have already been provided,
+ *   all meters already provided will use the provided delegate implementation.
+ */
+export class ProxyMeterProvider implements MeterProvider {
+  private _delegate?: MeterProvider;
+
+  /**
+   * Get a {@link ProxyMeter}
+   */
+  getMeter(name: string, version?: string, options?: MeterOptions): Meter {
+    return (
+      this.getDelegateMeter(name, version, options) ??
+      new ProxyMeter(this, name, version, options)
+    );
+  }
+
+  getDelegate(): MeterProvider {
+    return this._delegate ?? NOOP_METER_PROVIDER;
+  }
+
+  /**
+   * Set the delegate meter provider
+   */
+  setDelegate(delegate: MeterProvider) {
+    this._delegate = delegate;
+  }
+
+  getDelegateMeter(
+    name: string,
+    version?: string,
+    options?: MeterOptions
+  ): Meter | undefined {
+    return this._delegate?.getMeter(name, version, options);
+  }
+}