@oas-tools/oas-telemetry 0.7.0-alpha.2 → 0.7.0-alpha.3

package/dist/cjs/telemetry/custom-implementations/exporters/PluginLogExporter.cjs

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PluginLogExporter = void 0;
+var _core = require("@opentelemetry/core");
+var _logger = _interopRequireDefault(require("../../../utils/logger.cjs"));
+var _wrappers = require("../wrappers.cjs");
+var _pluginService = require("../../../tlm-plugin/pluginService.cjs");
+var _circular = require("../utils/circular.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class PluginLogExporter extends _wrappers.Enabler {
+  constructor() {
+    super();
+  }
+  export(logs, resultCallback) {
+    _logger.default.debug('PluginLogExporter.export called with logs: ', logs.length);
+    try {
+      if (!this.isEnabled()) {
+        _logger.default.debug('PluginLogExporter is not enabled. Skipping export.');
+        return resultCallback({
+          code: _core.ExportResultCode.SUCCESS
+        });
+      }
+      const cleanLogs = logs.map(log => (0, _circular.removeCircularRefs)(log)).map(log => (0, _circular.applyNesting)(log));
+      _pluginService.pluginService.getPlugins().forEach((pluginResource, i) => {
+        if (typeof pluginResource.pluginImplementation.newLog === 'function') {
+          cleanLogs.forEach(log => {
+            _logger.default.debug(`Sending log to plugin (Plugin #${i}) <${pluginResource.name}>`);
+            pluginResource.pluginImplementation.newLog(log);
+          });
+        } else {
+          _logger.default.debug(`Plugin <${pluginResource.name}> does not implement newLog method. Skipping log export.`);
+        }
+      });
+      setTimeout(() => resultCallback({
+        code: _core.ExportResultCode.SUCCESS
+      }), 0);
+    } catch (error) {
+      _logger.default.error('Error exporting logs\n' + error.message + '\n' + error.stack);
+      return resultCallback({
+        code: _core.ExportResultCode.FAILED,
+        error: new Error('Error exporting logs\n' + error.message + '\n' + error.stack)
+      });
+    }
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+}
+exports.PluginLogExporter = PluginLogExporter;

package/dist/cjs/telemetry/custom-implementations/exporters/PluginMetricExporter.cjs

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PluginMetricExporter = void 0;
+var _core = require("@opentelemetry/core");
+var _logger = _interopRequireDefault(require("../../../utils/logger.cjs"));
+var _wrappers = require("../wrappers.cjs");
+var _pluginService = require("../../../tlm-plugin/pluginService.cjs");
+var _circular = require("../utils/circular.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class PluginMetricExporter extends _wrappers.Enabler {
+  constructor() {
+    super();
+  }
+  export(metrics, resultCallback) {
+    _logger.default.debug('PluginMetricExporter.export called');
+    try {
+      if (!this.isEnabled()) {
+        _logger.default.debug('PluginMetricExporter is not enabled. Skipping export.');
+        return resultCallback({
+          code: _core.ExportResultCode.SUCCESS
+        });
+      }
+      const cleanMetrics = (0, _circular.applyNesting)((0, _circular.removeCircularRefs)(metrics));
+      _pluginService.pluginService.getPlugins().forEach((pluginResource, i) => {
+        if (typeof pluginResource.pluginImplementation.newMetric === 'function') {
+          _logger.default.debug(`Sending metric to plugin (Plugin #${i}) <${pluginResource.name}>`);
+          pluginResource.pluginImplementation.newMetric(cleanMetrics);
+        } else {
+          _logger.default.debug(`Plugin <${pluginResource.name}> does not implement newMetric method. Skipping metric export.`);
+        }
+      });
+      setTimeout(() => resultCallback({
+        code: _core.ExportResultCode.SUCCESS
+      }), 0);
+    } catch (error) {
+      _logger.default.error('Error exporting metrics\n' + error.message + '\n' + error.stack);
+      return resultCallback({
+        code: _core.ExportResultCode.FAILED,
+        error: new Error('Error exporting metrics\n' + error.message + '\n' + error.stack)
+      });
+    }
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+}
+exports.PluginMetricExporter = PluginMetricExporter;

package/dist/cjs/telemetry/custom-implementations/exporters/PluginSpanExporter.cjs

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PluginSpanExporter = void 0;
+var _core = require("@opentelemetry/core");
+var _logger = _interopRequireDefault(require("../../../utils/logger.cjs"));
+var _wrappers = require("../wrappers.cjs");
+var _pluginService = require("../../../tlm-plugin/pluginService.cjs");
+var _circular = require("../utils/circular.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class PluginSpanExporter extends _wrappers.Enabler {
+  constructor() {
+    super();
+    this._baseUrl = '/telemetry'; // Default base URL, can be overridden by the config
+  }
+  set baseUrl(baseUrl) {
+    this._baseUrl = baseUrl;
+  }
+  export(readableSpans, resultCallback) {
+    _logger.default.debug('PluginSpanExporter.export called with spans: ', readableSpans.length);
+    try {
+      if (!this.isEnabled()) {
+        _logger.default.debug('PluginSpanExporter is not enabled. Skipping export.');
+        return resultCallback({
+          code: _core.ExportResultCode.SUCCESS
+        });
+      }
+      // Prepare spans to be inserted into the in-memory database (remove circular references and convert to nested objects)
+      const cleanSpans = readableSpans.map(nestedSpan => (0, _circular.removeCircularRefs)(nestedSpan)) // to avoid JSON parsing error
+      .map(span => (0, _circular.applyNesting)(span)) // to avoid dot notation in keys (neDB does not support dot notation in keys)
+      .filter(span => {
+        const target = span?.attributes?.http?.target; // Exclude spans where target includes 'telemetry' but NOT 'telemetry/utils'
+        if (target && target.includes(this._baseUrl)) {
+          return target.includes(this._baseUrl + '/utils');
+        }
+        return true;
+      });
+      _pluginService.pluginService.getPlugins().forEach((pluginResource, i) => {
+        if (typeof pluginResource.pluginImplementation.newTrace === 'function') {
+          cleanSpans.forEach(span => {
+            _logger.default.debug(`Sending span to plugin (Plugin #${i}) <${pluginResource.name}>`);
+            //TODO: This should be called newSpan instead of newTrace
+            pluginResource.pluginImplementation.newTrace(span);
+          });
+        } else {
+          _logger.default.debug(`Plugin <${pluginResource.name}> does not implement newTrace method. Skipping span export.`);
+        }
+      });
+      setTimeout(() => resultCallback({
+        code: _core.ExportResultCode.SUCCESS
+      }), 0);
+    } catch (error) {
+      _logger.default.error('Error exporting spans\n' + error.message + '\n' + error.stack);
+      return resultCallback({
+        code: _core.ExportResultCode.FAILED,
+        error: new Error('Error exporting spans\n' + error.message + '\n' + error.stack)
+      });
+    }
+  }
+  shutdown() {
+    return this.forceFlush();
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+}
+exports.PluginSpanExporter = PluginSpanExporter;

package/dist/cjs/telemetry/custom-implementations/processors/dynamicMultiLogProcessor.cjs

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DynamicMultiLogRecordProcessor = void 0;
+var _core = require("@opentelemetry/core");
+var _logger = _interopRequireDefault(require("../../../utils/logger.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// optional if you want logging
+class DynamicMultiLogRecordProcessor {
+  constructor(initialProcessors = [], forceFlushTimeoutMillis = 30000) {
+    this._processors = [];
+    this._processors = [...initialProcessors];
+    this._forceFlushTimeoutMillis = forceFlushTimeoutMillis;
+  }
+  /**
+   * Add a new LogRecordProcessor or an array of LogRecordProcessors at runtime.
+   */
+  addProcessors(processor) {
+    if (Array.isArray(processor)) {
+      this._processors.push(...processor);
+    } else {
+      this._processors.push(processor);
+    }
+  }
+  /**
+   * Remove a specific LogRecordProcessor.
+   */
+  removeProcessor(processor) {
+    this._processors = this._processors.filter(p => p !== processor);
+  }
+  /**
+   * Clear all LogRecordProcessors.
+   */
+  clearProcessors() {
+    this._processors = [];
+  }
+  /**
+   * Called when a log record is emitted.
+   */
+  onEmit(logRecord, context) {
+    for (const processor of this._processors) {
+      try {
+        processor.onEmit(logRecord, context);
+      } catch (error) {
+        _logger.default?.error?.('Error in onEmit of LogRecordProcessor:', error);
+      }
+    }
+  }
+  /**
+   * Force flush all processors with timeout.
+   */
+  async forceFlush() {
+    const timeout = this._forceFlushTimeoutMillis;
+    const promises = this._processors.map(p => (0, _core.callWithTimeout)(p.forceFlush(), timeout));
+    try {
+      await Promise.all(promises);
+    } catch (error) {
+      _logger.default?.error?.('Error during forceFlush in DynamicMultiLogRecordProcessor:', error);
+    }
+  }
+  /**
+   * Shutdown all processors.
+   */
+  async shutdown() {
+    await Promise.all(this._processors.map(p => p.shutdown()));
+  }
+}
+exports.DynamicMultiLogRecordProcessor = DynamicMultiLogRecordProcessor;

package/dist/cjs/telemetry/custom-implementations/processors/dynamicMultiSpanProcessor.cjs

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DynamicMultiSpanProcessor = void 0;
+var _logger = _interopRequireDefault(require("../../../utils/logger.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class DynamicMultiSpanProcessor {
+  constructor(initialProcessors = []) {
+    this._spanProcessors = [];
+    this._spanProcessors = [...initialProcessors];
+  }
+  /**
+   * Add a new SpanProcessor or an array of SpanProcessors at runtime.
+   */
+  addProcessors(processor) {
+    if (Array.isArray(processor)) {
+      this._spanProcessors.push(...processor);
+    } else {
+      this._spanProcessors.push(processor);
+    }
+  }
+  /**
+   * Remove a specific SpanProcessor if needed.
+   */
+  removeProcessor(processor) {
+    this._spanProcessors = this._spanProcessors.filter(p => p !== processor);
+  }
+  /**
+   * Clear all processors.
+   */
+  clearProcessors() {
+    this._spanProcessors = [];
+  }
+  /**
+   * Called when a span is started.
+   */
+  onStart(span, context) {
+    for (const processor of this._spanProcessors) {
+      processor.onStart(span, context);
+    }
+  }
+  /**
+   * Called when a span ends.
+   */
+  onEnd(span) {
+    for (const processor of this._spanProcessors) {
+      processor.onEnd(span);
+    }
+  }
+  /**
+   * Force flush all processors.
+   */
+  async forceFlush() {
+    const promises = this._spanProcessors.map(p => p.forceFlush());
+    try {
+      await Promise.all(promises);
+    } catch (error) {
+      _logger.default.error('Error during forceFlush:', error);
+    }
+  }
+  /**
+   * Shutdown all processors.
+   */
+  async shutdown() {
+    await Promise.all(this._spanProcessors.map(p => p.shutdown()));
+  }
+}
+exports.DynamicMultiSpanProcessor = DynamicMultiSpanProcessor;

package/dist/cjs/{utils → telemetry/custom-implementations/utils}/circular.cjs

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.applyNesting = applyNesting;
-exports.convertToNestedObject = convertToNestedObject;
 exports.removeCircularRefs = removeCircularRefs;
 function removeCircularRefs(obj) {
   // const seen = new WeakMap(); // Used to keep track of visited objects
@@ -34,57 +33,48 @@ function removeCircularRefs(obj) {
  * @param {any} obj - The object to process.
  * @returns {any} - The object with all dot-separated keys converted to nested objects.
  * @example
- * // Input:
- * // {
- * //   "http.method": "GET",
- * //   "http.url": "http://example.com",
- * //   "nested.obj.key": "value"
- * // }
- * // Output:
- * // {
- * //   "http": {
- * //     "method": "GET",
- * //     "url": "http://example.com"
- * //   },
- * //   "nested": {
- * //     "obj": {
- * //       "key": "value"
- * //     }
- * //   }
- * // }
+ *  Input:
+ *  {
+ *    "http.method": "GET",
+ *    "http.url": "http://example.com",
+ *    "nested.obj.key": "value"
+ *  }
+ *  Output:
+ *  {
+ *    "http": {
+ *      "method": "GET",
+ *      "url": "http://example.com"
+ *    },
+ *    "nested": {
+ *      "obj": {
+ *        "key": "value"
+ *      }
+ *    }
+ *  }
  */
-function convertToNestedObject(obj) {
-  const result = {};
-  for (const key in obj) {
-    const keys = key.split('.');
-    let temp = result;
-    for (let i = 0; i < keys.length; i++) {
-      const currentKey = keys[i];
-      if (i === keys.length - 1) {
-        // Last key, set the value
-        temp[currentKey] = obj[key];
-      } else {
-        // Intermediate key, ensure the object exists
-        if (!temp[currentKey]) {
-          temp[currentKey] = {};
+function applyNesting(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(item => applyNesting(item));
+  } else if (typeof obj === 'object' && obj !== null) {
+    const result = {};
+    for (const key in obj) {
+      const value = applyNesting(obj[key]);
+      const keys = key.split('.');
+      let temp = result;
+      for (let i = 0; i < keys.length; i++) {
+        const currentKey = keys[i];
+        if (i === keys.length - 1) {
+          temp[currentKey] = value;
+        } else {
+          if (!temp[currentKey]) {
+            temp[currentKey] = {};
+          }
+          temp = temp[currentKey];
         }
-        temp = temp[currentKey];
       }
     }
+    return result;
+  } else {
+    return obj;
   }
-  return result;
-}
-/**
- * Applies nesting to all dot-separated keys within an object.
- */
-function applyNesting(obj) {
-  for (const key in obj) {
-    const value = obj[key];
-    if (Array.isArray(value)) {
-      obj[key] = value.map(item => typeof item === 'object' && item !== null ? applyNesting(item) : item);
-    } else if (typeof value === 'object' && value !== null) {
-      obj[key] = applyNesting(value);
-    }
-  }
-  return convertToNestedObject(obj);
 }

package/dist/cjs/telemetry/custom-implementations/wrappers.cjs

@@ -0,0 +1,175 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EnablerSpanExporter = exports.EnablerMultiSpanExporter = exports.EnablerMultiLogExporter = exports.EnablerMetricReader = exports.EnablerLogExporter = exports.Enabler = void 0;
+var _resources = require("@opentelemetry/resources");
+var _logger = _interopRequireDefault(require("../../utils/logger.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class Enabler {
+  constructor(enabled) {
+    this._enabled = true;
+    if (typeof enabled === 'boolean') {
+      this._enabled = enabled;
+    }
+  }
+  setEnabledValue(value) {
+    this._enabled = value;
+  }
+  enable() {
+    this._enabled = true;
+  }
+  disable() {
+    this._enabled = false;
+  }
+  isEnabled() {
+    return this._enabled;
+  }
+  toggle() {
+    this._enabled = !this._enabled;
+  }
+}
+/*
+ * Classes for enabler exporters, allowing enable/disable toggling of exporters at runtime.
+ *
+ * This class is designed to work for trace and log exporters, where multiple exporters can be active simultaneously
+ * (e.g., via a MultiExporter and one processor). By toggling the exporter, you can dynamically enable or
+ * disable the export operation without removing the exporter from the pipeline.
+ *
+ * For metrics, the OpenTelemetry model is different: there are two types of readers. PullMetricExporters do not have
+ * an exporter instance, and PushMetricExporters do, but only allow a single exporter per reader (with optional
+ * `selectAggregationTemporality` and `selectAggregation` attributes). Therefore, multiple exporters per reader are not
+ * supported for metrics.
+ *
+ * For metrics readers, a separate `DeactivableReader` class is recommended, which is even more efficient: when
+ * disabled, the reader's `collect` method is not called at all, saving additional resources compared to disabling the exporter.
+ *
+ */
+exports.Enabler = Enabler;
+class EnablerSpanExporter extends Enabler {
+  constructor(exporter) {
+    super();
+    this.exporter = exporter;
+  }
+  export(spans, resultCallback) {
+    if (this.isEnabled()) {
+      this.exporter.export(spans, resultCallback);
+    }
+  }
+  shutdown() {
+    return this.exporter.shutdown();
+  }
+  forceFlush() {
+    if (typeof this.exporter.forceFlush === 'function') {
+      return this.exporter.forceFlush();
+    }
+    return Promise.resolve();
+  }
+}
+exports.EnablerSpanExporter = EnablerSpanExporter;
+class EnablerLogExporter extends Enabler {
+  constructor(exporter) {
+    super();
+    this.exporter = exporter;
+  }
+  export(logs, resultCallback) {
+    if (this.isEnabled()) {
+      this.exporter.export(logs, resultCallback);
+    }
+  }
+  shutdown() {
+    return this.exporter.shutdown();
+  }
+}
+exports.EnablerLogExporter = EnablerLogExporter;
+class EnablerMultiExporter extends Enabler {
+  constructor(exporters) {
+    super();
+    this._exporters = [];
+    if (exporters && Array.isArray(exporters)) {
+      this._exporters = exporters;
+    }
+  }
+  addExporters(exporter) {
+    if (!this._exporters) {
+      this._exporters = [];
+    }
+    if (Array.isArray(exporter)) {
+      this._exporters.push(...exporter);
+    } else {
+      this._exporters.push(exporter);
+    }
+  }
+}
+class EnablerMultiSpanExporter extends EnablerMultiExporter {
+  export(spans, resultCallback) {
+    _logger.default.debug(`EnablerMultiSpanExporter.export called with ${spans.length} spans, exporters: ${this._exporters?.length ?? 0}, enabled: ${this.isEnabled()}`);
+    if (this.isEnabled() && this._exporters) {
+      this._exporters.forEach(exporter => exporter.export(spans, resultCallback));
+    }
+  }
+  async shutdown() {
+    if (this._exporters) {
+      await Promise.all(this._exporters.map(exporter => exporter.shutdown()));
+    }
+    return;
+  }
+}
+exports.EnablerMultiSpanExporter = EnablerMultiSpanExporter;
+class EnablerMultiLogExporter extends EnablerMultiExporter {
+  export(logs, resultCallback) {
+    if (this.isEnabled() && this._exporters) {
+      this._exporters.forEach(exporter => exporter.export(logs, resultCallback));
+    }
+  }
+  async shutdown() {
+    if (this._exporters) {
+      await Promise.all(this._exporters.map(exporter => exporter.shutdown()));
+    }
+    return;
+  }
+}
+exports.EnablerMultiLogExporter = EnablerMultiLogExporter;
+class EnablerMetricReader extends Enabler {
+  constructor(reader) {
+    super();
+    this.reader = reader;
+  }
+  forceFlush(options) {
+    if (this.isEnabled()) {
+      return this.reader.forceFlush(options);
+    }
+    return Promise.resolve();
+  }
+  setMetricProducer(metricProducer) {
+    if (this.isEnabled()) {
+      this.reader.setMetricProducer(metricProducer);
+    }
+  }
+  selectAggregation(instrumentType) {
+    return this.reader.selectAggregation(instrumentType);
+  }
+  selectAggregationTemporality(instrumentType) {
+    return this.reader.selectAggregationTemporality(instrumentType);
+  }
+  selectCardinalityLimit(instrumentType) {
+    return this.reader.selectCardinalityLimit(instrumentType);
+  }
+  async collect(options) {
+    if (this.isEnabled()) {
+      return await this.reader.collect(options);
+    }
+    return {
+      resourceMetrics: {
+        resource: (0, _resources.resourceFromAttributes)({}),
+        scopeMetrics: []
+      },
+      errors: []
+    };
+  }
+  shutdown(options) {
+    return this.reader.shutdown(options);
+  }
+}
+exports.EnablerMetricReader = EnablerMetricReader;

package/dist/cjs/telemetry/initializeTelemetry.cjs

@@ -0,0 +1,74 @@
+"use strict";
+
+var _instrumentationHttp = require("@opentelemetry/instrumentation-http");
+var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
+var _instrumentation = require("@opentelemetry/instrumentation");
+var _telemetryRegistry = require("./telemetryRegistry.cjs");
+var _sdkTraceNode = require("@opentelemetry/sdk-trace-node");
+var _apiLogs = require("@opentelemetry/api-logs");
+var _sdkLogs = require("@opentelemetry/sdk-logs");
+var _bootConfig = require("../config/bootConfig.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// THIS INSTRUMENTATIONS NEED TO BE LOADED BEFORE ANYTHING ELSE
+// They use monkey-patching to instrument the HTTP server and client.
+// THIS FILE MUST BE CALLED BEFORE ANYTHING ELSE
+if (_bootConfig.bootEnvVariables.OASTLM_BOOT_MODULE_DISABLED) {
+  _logger.default.info('🚫 OASTLM module is disabled, Providers not initialized.');
+} else {
+  _logger.default.info('🚀 Initializing Open Telemetry');
+  initializeTraces();
+  initializeMetrics();
+  initializeLogs();
+  (0, _instrumentation.registerInstrumentations)({
+    instrumentations: [new _instrumentationHttp.HttpInstrumentation()
+    // new ExpressInstrumentation(),
+    ]
+  });
+}
+function initializeTraces() {
+  _logger.default.info('📊 Initializing TracerProvider');
+  const tracerProvider = new _sdkTraceNode.NodeTracerProvider({
+    resource: _telemetryRegistry.oasTelemetryResource,
+    spanProcessors: [_telemetryRegistry.dynamicMultiSpanProcessor]
+  });
+  tracerProvider.register();
+}
+function initializeLogs() {
+  _logger.default.info('📜 Initializing LoggerProvider');
+  // Create and configure LoggerProvider
+  const loggerProvider = new _sdkLogs.LoggerProvider({
+    resource: _telemetryRegistry.oasTelemetryResource,
+    processors: [_telemetryRegistry.dynamicMultiLogProcessor]
+  });
+  // Get a logger instance
+  const loggerInstance = loggerProvider.getLogger('oas-telemetry'); // Use loggerProvider to get the logger
+  // Override console methods to emit logs via OpenTelemetry, like an instrumentation
+  const originalConsoleMethods = {
+    log: console.log,
+    warn: console.warn,
+    error: console.error,
+    info: console.info,
+    debug: console.debug
+  };
+  Object.keys(originalConsoleMethods).forEach(method => {
+    // @ts-expect-error yes
+    console[method] = (...args) => {
+      loggerInstance.emit({
+        severityNumber: _apiLogs.SeverityNumber[method.toUpperCase()] || _apiLogs.SeverityNumber.INFO,
+        severityText: method.toUpperCase(),
+        body: args.join(' '),
+        attributes: {
+          'source.source': `console.${method}`
+        }
+      });
+      // @ts-expect-error yes
+      originalConsoleMethods[method](...args);
+    };
+  });
+}
+function initializeMetrics() {
+  _logger.default.info('📈 Initializing MeterProvider');
+  // WARN: This is a custom provider that allows adding readers dynamically at runtime.
+  // WARN: Default PeriodicExportingMetricReader is added post initialization (see telemetryConfigurator.ts)
+  // The in memory exporter is added by default to that reader. More readers are allowed to be added dynamically
+}