chore: use semver to determine API compatibility

Author: dyladan

src/api/context.ts

@@ -17,12 +17,12 @@
 import { NoopContextManager } from '../context/NoopContextManager';
 import { Context, ContextManager } from '../context/types';
 import {
- API_BACKWARDS_COMPATIBILITY_VERSION,
- GLOBAL_CONTEXT_MANAGER_API_KEY,
- makeGetter,
- _global,
-} from './global-utils';
+ getGlobal,
+ registerGlobal,
+ unregisterGlobal,
+} from '../internal/global-utils';
 
+const API_NAME = 'context';
 const NOOP_CONTEXT_MANAGER = new NoopContextManager();
 
 /**
@@ -49,17 +49,7 @@ export class ContextAPI {
  public setGlobalContextManager(
  contextManager: ContextManager
  ): ContextManager {
- if (_global[GLOBAL_CONTEXT_MANAGER_API_KEY]) {
- // global context manager has already been set
- return this._getContextManager();
- }
-
- _global[GLOBAL_CONTEXT_MANAGER_API_KEY] = makeGetter(
- API_BACKWARDS_COMPATIBILITY_VERSION,
- contextManager,
- NOOP_CONTEXT_MANAGER
- );
-
+ registerGlobal(API_NAME, contextManager);
  return contextManager;
  }
 
@@ -98,16 +88,12 @@ export class ContextAPI {
  }
 
  private _getContextManager(): ContextManager {
- return (
- _global[GLOBAL_CONTEXT_MANAGER_API_KEY]?.(
- API_BACKWARDS_COMPATIBILITY_VERSION
- ) ?? NOOP_CONTEXT_MANAGER
- );
+ return getGlobal(API_NAME) || NOOP_CONTEXT_MANAGER;
  }
 
  /** Disable and remove the global context manager */
  public disable() {
  this._getContextManager().disable();
- delete _global[GLOBAL_CONTEXT_MANAGER_API_KEY];
+ unregisterGlobal(API_NAME);
  }
 }

src/api/diag.ts

@@ -22,63 +22,38 @@ import {
 } from '../diag/logger';
 import { DiagLogLevel, createLogLevelDiagLogger } from '../diag/logLevel';
 import {
- API_BACKWARDS_COMPATIBILITY_VERSION,
- GLOBAL_DIAG_LOGGER_API_KEY,
- makeGetter,
- _global,
-} from './global-utils';
-
-/** Internal simple Noop Diag API that returns a noop logger and does not allow any changes */
-function noopDiagApi(): DiagAPI {
- const noopApi = createNoopDiagLogger() as DiagAPI;
-
- noopApi.getLogger = () => noopApi;
- noopApi.setLogger = noopApi.getLogger;
- noopApi.setLogLevel = () => {};
-
- return noopApi;
-}
+ getGlobal,
+ registerGlobal,
+ unregisterGlobal,
+} from '../internal/global-utils';
 
 /**
  * Singleton object which represents the entry point to the OpenTelemetry internal
  * diagnostic API
  */
 export class DiagAPI implements DiagLogger {
+ private static _instance?: DiagAPI;
+
  /** Get the singleton instance of the DiagAPI API */
  public static instance(): DiagAPI {
- let theInst = null;
- if (_global[GLOBAL_DIAG_LOGGER_API_KEY]) {
- // Looks like a previous instance was set, so try and fetch it
- theInst = _global[GLOBAL_DIAG_LOGGER_API_KEY]?.(
- API_BACKWARDS_COMPATIBILITY_VERSION
- ) as DiagAPI;
- }
-
- if (!theInst) {
- theInst = new DiagAPI();
- _global[GLOBAL_DIAG_LOGGER_API_KEY] = makeGetter(
- API_BACKWARDS_COMPATIBILITY_VERSION,
- theInst,
- noopDiagApi()
- );
+ if (!this._instance) {
+ this._instance = new DiagAPI();
  }
 
- return theInst;
+ return this._instance;
  }
 
  /**
  * Private internal constructor
  * @private
  */
  private constructor() {
- let _logLevel: DiagLogLevel = DiagLogLevel.INFO;
- let _filteredLogger: DiagLogger | null;
- let _logger: DiagLogger = createNoopDiagLogger();
+ const _noopLogger = createNoopDiagLogger();
 
  function _logProxy(funcName: keyof DiagLogger): DiagLogFunction {
  return function () {
  const orgArguments = arguments as unknown;
- const theLogger = _filteredLogger || _logger;
+ const theLogger = getGlobal('filteredDiagLogger') || _noopLogger;
  const theFunc = theLogger[funcName];
  if (typeof theFunc === 'function') {
  return theFunc.apply(
@@ -89,34 +64,44 @@ export class DiagAPI implements DiagLogger {
  };
  }
 
+ function getLevel(): DiagLogLevel {
+ return getGlobal('diagLogLevel') ?? DiagLogLevel.INFO;
+ }
+
  // Using self local variable for minification purposes as 'this' cannot be minified
  const self = this;
 
  // DiagAPI specific functions
 
  self.getLogger = (): DiagLogger => {
- // Return itself if no existing logger is defined (defaults effectively to a Noop)
- return _logger;
+ return getGlobal('diagLogger') || _noopLogger;
  };
 
  self.setLogger = (logger?: DiagLogger): DiagLogger => {
- const prevLogger = _logger;
- if (!logger || logger !== self) {
- // Simple special case to avoid any possible infinite recursion on the logging functions
- _logger = logger || createNoopDiagLogger();
- _filteredLogger = createLogLevelDiagLogger(_logLevel, _logger);
- }
-
- return prevLogger;
+ const previous = getGlobal('diagLogger') || _noopLogger;
+
+ unregisterGlobal('diagLogger');
+ unregisterGlobal('filteredDiagLogger');
+
+ const newLogger = logger || _noopLogger;
+ registerGlobal('diagLogger', newLogger);
+ registerGlobal(
+ 'filteredDiagLogger',
+ createLogLevelDiagLogger(getLevel(), newLogger)
+ );
+
+ return previous;
  };
 
  self.setLogLevel = (maxLogLevel: DiagLogLevel) => {
- if (maxLogLevel !== _logLevel) {
- _logLevel = maxLogLevel;
- if (_logger) {
- _filteredLogger = createLogLevelDiagLogger(maxLogLevel, _logger);
- }
- }
+ const logger = self.getLogger();
+ unregisterGlobal('diagLogLevel');
+ unregisterGlobal('filteredDiagLogger');
+ registerGlobal('diagLogLevel', maxLogLevel);
+ registerGlobal(
+ 'filteredDiagLogger',
+ createLogLevelDiagLogger(maxLogLevel, logger)
+ );
  };
 
  for (let i = 0; i < diagLoggerFunctions.length; i++) {

src/api/global-utils.ts

@@ -24,11 +24,12 @@ import {
  TextMapSetter,
 } from '../propagation/TextMapPropagator';
 import {
- API_BACKWARDS_COMPATIBILITY_VERSION,
- GLOBAL_PROPAGATION_API_KEY,
- makeGetter,
- _global,
-} from './global-utils';
+ getGlobal,
+ registerGlobal,
+ unregisterGlobal,
+} from '../internal/global-utils';
+
+const API_NAME = 'propagation';
 
 /**
  * Singleton object which represents the entry point to the OpenTelemetry Propagation API
@@ -52,17 +53,7 @@ export class PropagationAPI {
  * Set the current propagator. Returns the initialized propagator
  */
  public setGlobalPropagator(propagator: TextMapPropagator): TextMapPropagator {
- if (_global[GLOBAL_PROPAGATION_API_KEY]) {
- // global propagator has already been set
- return this._getGlobalPropagator();
- }
-
- _global[GLOBAL_PROPAGATION_API_KEY] = makeGetter(
- API_BACKWARDS_COMPATIBILITY_VERSION,
- propagator,
- NOOP_TEXT_MAP_PROPAGATOR
- );
-
+ registerGlobal(API_NAME, propagator);
  return propagator;
  }
 
@@ -105,14 +96,10 @@ export class PropagationAPI {
 
  /** Remove the global propagator */
  public disable() {
- delete _global[GLOBAL_PROPAGATION_API_KEY];
+ unregisterGlobal(API_NAME);
  }
 
  private _getGlobalPropagator(): TextMapPropagator {
- return (
- _global[GLOBAL_PROPAGATION_API_KEY]?.(
- API_BACKWARDS_COMPATIBILITY_VERSION
- ) ?? NOOP_TEXT_MAP_PROPAGATOR
- );
+ return getGlobal(API_NAME) || NOOP_TEXT_MAP_PROPAGATOR;
  }
 }

src/api/propagation.ts

@@ -14,17 +14,17 @@
  * limitations under the License.
  */
 
-import { NOOP_TRACER_PROVIDER } from '../trace/NoopTracerProvider';
 import { ProxyTracerProvider } from '../trace/ProxyTracerProvider';
 import { Tracer } from '../trace/tracer';
 import { TracerProvider } from '../trace/tracer_provider';
 import { isSpanContextValid } from '../trace/spancontext-utils';
 import {
- API_BACKWARDS_COMPATIBILITY_VERSION,
- GLOBAL_TRACE_API_KEY,
- makeGetter,
- _global,
-} from './global-utils';
+ getGlobal,
+ registerGlobal,
+ unregisterGlobal,
+} from '../internal/global-utils';
+
+const API_NAME = 'trace';
 
 /**
  * Singleton object which represents the entry point to the OpenTelemetry Tracing API
@@ -50,30 +50,16 @@ export class TraceAPI {
  * Set the current global tracer. Returns the initialized global tracer provider
  */
  public setGlobalTracerProvider(provider: TracerProvider): TracerProvider {
- if (_global[GLOBAL_TRACE_API_KEY]) {
- // global tracer provider has already been set
- return this.getTracerProvider();
- }
-
  this._proxyTracerProvider.setDelegate(provider);
-
- _global[GLOBAL_TRACE_API_KEY] = makeGetter(
- API_BACKWARDS_COMPATIBILITY_VERSION,
- this._proxyTracerProvider,
- NOOP_TRACER_PROVIDER
- );
-
- return this.getTracerProvider();
+ registerGlobal(API_NAME, this._proxyTracerProvider);
+ return this._proxyTracerProvider;
  }
 
  /**
  * Returns the global tracer provider.
  */
  public getTracerProvider(): TracerProvider {
- return (
- _global[GLOBAL_TRACE_API_KEY]?.(API_BACKWARDS_COMPATIBILITY_VERSION) ??
- this._proxyTracerProvider
- );
+ return getGlobal(API_NAME) || this._proxyTracerProvider;
  }
 
  /**
@@ -85,7 +71,7 @@ export class TraceAPI {
 
  /** Remove the global tracer provider */
  public disable() {
- delete _global[GLOBAL_TRACE_API_KEY];
+ unregisterGlobal(API_NAME);
  this._proxyTracerProvider = new ProxyTracerProvider();
  }