@ms-cloudpack/telemetry 0.4.6 → 0.4.7-beta.1

package/dist/chunk-LA4AUP26.js

@@ -0,0 +1,1790 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js
+var require_globalThis = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports._globalThis = void 0;
+    exports._globalThis = typeof globalThis === "object" ? globalThis : global;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/platform/node/index.js
+var require_node = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/platform/node/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_globalThis(), exports);
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/platform/index.js
+var require_platform = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/platform/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_node(), exports);
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/version.js
+var require_version = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/version.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.VERSION = void 0;
+    exports.VERSION = "1.7.0";
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/internal/semver.js
+var require_semver = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/internal/semver.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isCompatible = exports._makeCompatibilityCheck = void 0;
+    var version_1 = require_version();
+    var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+    function _makeCompatibilityCheck(ownVersion) {
+      const acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
+      const rejectedVersions = /* @__PURE__ */ new Set();
+      const myVersionMatch = ownVersion.match(re);
+      if (!myVersionMatch) {
+        return () => false;
+      }
+      const ownVersionParsed = {
+        major: +myVersionMatch[1],
+        minor: +myVersionMatch[2],
+        patch: +myVersionMatch[3],
+        prerelease: myVersionMatch[4]
+      };
+      if (ownVersionParsed.prerelease != null) {
+        return function isExactmatch(globalVersion) {
+          return globalVersion === ownVersion;
+        };
+      }
+      function _reject(v) {
+        rejectedVersions.add(v);
+        return false;
+      }
+      function _accept(v) {
+        acceptedVersions.add(v);
+        return true;
+      }
+      return function isCompatible(globalVersion) {
+        if (acceptedVersions.has(globalVersion)) {
+          return true;
+        }
+        if (rejectedVersions.has(globalVersion)) {
+          return false;
+        }
+        const globalVersionMatch = globalVersion.match(re);
+        if (!globalVersionMatch) {
+          return _reject(globalVersion);
+        }
+        const globalVersionParsed = {
+          major: +globalVersionMatch[1],
+          minor: +globalVersionMatch[2],
+          patch: +globalVersionMatch[3],
+          prerelease: globalVersionMatch[4]
+        };
+        if (globalVersionParsed.prerelease != null) {
+          return _reject(globalVersion);
+        }
+        if (ownVersionParsed.major !== globalVersionParsed.major) {
+          return _reject(globalVersion);
+        }
+        if (ownVersionParsed.major === 0) {
+          if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
+            return _accept(globalVersion);
+          }
+          return _reject(globalVersion);
+        }
+        if (ownVersionParsed.minor <= globalVersionParsed.minor) {
+          return _accept(globalVersion);
+        }
+        return _reject(globalVersion);
+      };
+    }
+    exports._makeCompatibilityCheck = _makeCompatibilityCheck;
+    exports.isCompatible = _makeCompatibilityCheck(version_1.VERSION);
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/internal/global-utils.js
+var require_global_utils = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/internal/global-utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.unregisterGlobal = exports.getGlobal = exports.registerGlobal = void 0;
+    var platform_1 = require_platform();
+    var version_1 = require_version();
+    var semver_1 = require_semver();
+    var major = version_1.VERSION.split(".")[0];
+    var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(`opentelemetry.js.api.${major}`);
+    var _global = platform_1._globalThis;
+    function registerGlobal(type, instance, diag, allowOverride = false) {
+      var _a;
+      const api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
+        version: version_1.VERSION
+      };
+      if (!allowOverride && api[type]) {
+        const err = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`);
+        diag.error(err.stack || err.message);
+        return false;
+      }
+      if (api.version !== version_1.VERSION) {
+        const err = new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${version_1.VERSION}`);
+        diag.error(err.stack || err.message);
+        return false;
+      }
+      api[type] = instance;
+      diag.debug(`@opentelemetry/api: Registered a global for ${type} v${version_1.VERSION}.`);
+      return true;
+    }
+    exports.registerGlobal = registerGlobal;
+    function getGlobal(type) {
+      var _a, _b;
+      const globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+      if (!globalVersion || !(0, semver_1.isCompatible)(globalVersion)) {
+        return;
+      }
+      return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+    }
+    exports.getGlobal = getGlobal;
+    function unregisterGlobal(type, diag) {
+      diag.debug(`@opentelemetry/api: Unregistering a global for ${type} v${version_1.VERSION}.`);
+      const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+      if (api) {
+        delete api[type];
+      }
+    }
+    exports.unregisterGlobal = unregisterGlobal;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/diag/ComponentLogger.js
+var require_ComponentLogger = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/diag/ComponentLogger.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DiagComponentLogger = void 0;
+    var global_utils_1 = require_global_utils();
+    var DiagComponentLogger = class {
+      constructor(props) {
+        this._namespace = props.namespace || "DiagComponentLogger";
+      }
+      debug(...args) {
+        return logProxy("debug", this._namespace, args);
+      }
+      error(...args) {
+        return logProxy("error", this._namespace, args);
+      }
+      info(...args) {
+        return logProxy("info", this._namespace, args);
+      }
+      warn(...args) {
+        return logProxy("warn", this._namespace, args);
+      }
+      verbose(...args) {
+        return logProxy("verbose", this._namespace, args);
+      }
+    };
+    exports.DiagComponentLogger = DiagComponentLogger;
+    function logProxy(funcName, namespace, args) {
+      const logger = (0, global_utils_1.getGlobal)("diag");
+      if (!logger) {
+        return;
+      }
+      args.unshift(namespace);
+      return logger[funcName](...args);
+    }
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/diag/types.js
+var require_types = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/diag/types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DiagLogLevel = void 0;
+    var DiagLogLevel;
+    (function(DiagLogLevel2) {
+      DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
+      DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
+      DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
+      DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
+      DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
+      DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
+      DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
+    })(DiagLogLevel = exports.DiagLogLevel || (exports.DiagLogLevel = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/diag/internal/logLevelLogger.js
+var require_logLevelLogger = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/diag/internal/logLevelLogger.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createLogLevelDiagLogger = void 0;
+    var types_1 = require_types();
+    function createLogLevelDiagLogger(maxLevel, logger) {
+      if (maxLevel < types_1.DiagLogLevel.NONE) {
+        maxLevel = types_1.DiagLogLevel.NONE;
+      } else if (maxLevel > types_1.DiagLogLevel.ALL) {
+        maxLevel = types_1.DiagLogLevel.ALL;
+      }
+      logger = logger || {};
+      function _filterFunc(funcName, theLevel) {
+        const theFunc = logger[funcName];
+        if (typeof theFunc === "function" && maxLevel >= theLevel) {
+          return theFunc.bind(logger);
+        }
+        return function() {
+        };
+      }
+      return {
+        error: _filterFunc("error", types_1.DiagLogLevel.ERROR),
+        warn: _filterFunc("warn", types_1.DiagLogLevel.WARN),
+        info: _filterFunc("info", types_1.DiagLogLevel.INFO),
+        debug: _filterFunc("debug", types_1.DiagLogLevel.DEBUG),
+        verbose: _filterFunc("verbose", types_1.DiagLogLevel.VERBOSE)
+      };
+    }
+    exports.createLogLevelDiagLogger = createLogLevelDiagLogger;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/api/diag.js
+var require_diag = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/api/diag.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DiagAPI = void 0;
+    var ComponentLogger_1 = require_ComponentLogger();
+    var logLevelLogger_1 = require_logLevelLogger();
+    var types_1 = require_types();
+    var global_utils_1 = require_global_utils();
+    var API_NAME = "diag";
+    var DiagAPI = class _DiagAPI {
+      /**
+       * Private internal constructor
+       * @private
+       */
+      constructor() {
+        function _logProxy(funcName) {
+          return function(...args) {
+            const logger = (0, global_utils_1.getGlobal)("diag");
+            if (!logger)
+              return;
+            return logger[funcName](...args);
+          };
+        }
+        const self = this;
+        const setLogger = (logger, optionsOrLogLevel = { logLevel: types_1.DiagLogLevel.INFO }) => {
+          var _a, _b, _c;
+          if (logger === self) {
+            const err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+            self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+            return false;
+          }
+          if (typeof optionsOrLogLevel === "number") {
+            optionsOrLogLevel = {
+              logLevel: optionsOrLogLevel
+            };
+          }
+          const oldLogger = (0, global_utils_1.getGlobal)("diag");
+          const newLogger = (0, logLevelLogger_1.createLogLevelDiagLogger)((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : types_1.DiagLogLevel.INFO, logger);
+          if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+            const stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+            oldLogger.warn(`Current logger will be overwritten from ${stack}`);
+            newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
+          }
+          return (0, global_utils_1.registerGlobal)("diag", newLogger, self, true);
+        };
+        self.setLogger = setLogger;
+        self.disable = () => {
+          (0, global_utils_1.unregisterGlobal)(API_NAME, self);
+        };
+        self.createComponentLogger = (options) => {
+          return new ComponentLogger_1.DiagComponentLogger(options);
+        };
+        self.verbose = _logProxy("verbose");
+        self.debug = _logProxy("debug");
+        self.info = _logProxy("info");
+        self.warn = _logProxy("warn");
+        self.error = _logProxy("error");
+      }
+      /** Get the singleton instance of the DiagAPI API */
+      static instance() {
+        if (!this._instance) {
+          this._instance = new _DiagAPI();
+        }
+        return this._instance;
+      }
+    };
+    exports.DiagAPI = DiagAPI;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/baggage/internal/baggage-impl.js
+var require_baggage_impl = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/baggage/internal/baggage-impl.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BaggageImpl = void 0;
+    var BaggageImpl = class _BaggageImpl {
+      constructor(entries) {
+        this._entries = entries ? new Map(entries) : /* @__PURE__ */ new Map();
+      }
+      getEntry(key) {
+        const entry = this._entries.get(key);
+        if (!entry) {
+          return void 0;
+        }
+        return Object.assign({}, entry);
+      }
+      getAllEntries() {
+        return Array.from(this._entries.entries()).map(([k, v]) => [k, v]);
+      }
+      setEntry(key, entry) {
+        const newBaggage = new _BaggageImpl(this._entries);
+        newBaggage._entries.set(key, entry);
+        return newBaggage;
+      }
+      removeEntry(key) {
+        const newBaggage = new _BaggageImpl(this._entries);
+        newBaggage._entries.delete(key);
+        return newBaggage;
+      }
+      removeEntries(...keys) {
+        const newBaggage = new _BaggageImpl(this._entries);
+        for (const key of keys) {
+          newBaggage._entries.delete(key);
+        }
+        return newBaggage;
+      }
+      clear() {
+        return new _BaggageImpl();
+      }
+    };
+    exports.BaggageImpl = BaggageImpl;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.js
+var require_symbol = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.baggageEntryMetadataSymbol = void 0;
+    exports.baggageEntryMetadataSymbol = Symbol("BaggageEntryMetadata");
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/baggage/utils.js
+var require_utils = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/baggage/utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.baggageEntryMetadataFromString = exports.createBaggage = void 0;
+    var diag_1 = require_diag();
+    var baggage_impl_1 = require_baggage_impl();
+    var symbol_1 = require_symbol();
+    var diag = diag_1.DiagAPI.instance();
+    function createBaggage(entries = {}) {
+      return new baggage_impl_1.BaggageImpl(new Map(Object.entries(entries)));
+    }
+    exports.createBaggage = createBaggage;
+    function baggageEntryMetadataFromString(str) {
+      if (typeof str !== "string") {
+        diag.error(`Cannot create baggage metadata from unknown type: ${typeof str}`);
+        str = "";
+      }
+      return {
+        __TYPE__: symbol_1.baggageEntryMetadataSymbol,
+        toString() {
+          return str;
+        }
+      };
+    }
+    exports.baggageEntryMetadataFromString = baggageEntryMetadataFromString;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/context/context.js
+var require_context = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/context/context.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ROOT_CONTEXT = exports.createContextKey = void 0;
+    function createContextKey(description) {
+      return Symbol.for(description);
+    }
+    exports.createContextKey = createContextKey;
+    var BaseContext = class _BaseContext {
+      /**
+       * Construct a new context which inherits values from an optional parent context.
+       *
+       * @param parentContext a context from which to inherit values
+       */
+      constructor(parentContext) {
+        const self = this;
+        self._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+        self.getValue = (key) => self._currentContext.get(key);
+        self.setValue = (key, value) => {
+          const context = new _BaseContext(self._currentContext);
+          context._currentContext.set(key, value);
+          return context;
+        };
+        self.deleteValue = (key) => {
+          const context = new _BaseContext(self._currentContext);
+          context._currentContext.delete(key);
+          return context;
+        };
+      }
+    };
+    exports.ROOT_CONTEXT = new BaseContext();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/diag/consoleLogger.js
+var require_consoleLogger = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/diag/consoleLogger.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DiagConsoleLogger = void 0;
+    var consoleMap = [
+      { n: "error", c: "error" },
+      { n: "warn", c: "warn" },
+      { n: "info", c: "info" },
+      { n: "debug", c: "debug" },
+      { n: "verbose", c: "trace" }
+    ];
+    var DiagConsoleLogger = class {
+      constructor() {
+        function _consoleFunc(funcName) {
+          return function(...args) {
+            if (console) {
+              let theFunc = console[funcName];
+              if (typeof theFunc !== "function") {
+                theFunc = console.log;
+              }
+              if (typeof theFunc === "function") {
+                return theFunc.apply(console, args);
+              }
+            }
+          };
+        }
+        for (let i = 0; i < consoleMap.length; i++) {
+          this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);
+        }
+      }
+    };
+    exports.DiagConsoleLogger = DiagConsoleLogger;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/metrics/NoopMeter.js
+var require_NoopMeter = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/metrics/NoopMeter.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createNoopMeter = exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = exports.NOOP_OBSERVABLE_GAUGE_METRIC = exports.NOOP_OBSERVABLE_COUNTER_METRIC = exports.NOOP_UP_DOWN_COUNTER_METRIC = exports.NOOP_HISTOGRAM_METRIC = exports.NOOP_COUNTER_METRIC = exports.NOOP_METER = exports.NoopObservableUpDownCounterMetric = exports.NoopObservableGaugeMetric = exports.NoopObservableCounterMetric = exports.NoopObservableMetric = exports.NoopHistogramMetric = exports.NoopUpDownCounterMetric = exports.NoopCounterMetric = exports.NoopMetric = exports.NoopMeter = void 0;
+    var NoopMeter = class {
+      constructor() {
+      }
+      /**
+       * @see {@link Meter.createHistogram}
+       */
+      createHistogram(_name, _options) {
+        return exports.NOOP_HISTOGRAM_METRIC;
+      }
+      /**
+       * @see {@link Meter.createCounter}
+       */
+      createCounter(_name, _options) {
+        return exports.NOOP_COUNTER_METRIC;
+      }
+      /**
+       * @see {@link Meter.createUpDownCounter}
+       */
+      createUpDownCounter(_name, _options) {
+        return exports.NOOP_UP_DOWN_COUNTER_METRIC;
+      }
+      /**
+       * @see {@link Meter.createObservableGauge}
+       */
+      createObservableGauge(_name, _options) {
+        return exports.NOOP_OBSERVABLE_GAUGE_METRIC;
+      }
+      /**
+       * @see {@link Meter.createObservableCounter}
+       */
+      createObservableCounter(_name, _options) {
+        return exports.NOOP_OBSERVABLE_COUNTER_METRIC;
+      }
+      /**
+       * @see {@link Meter.createObservableUpDownCounter}
+       */
+      createObservableUpDownCounter(_name, _options) {
+        return exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
+      }
+      /**
+       * @see {@link Meter.addBatchObservableCallback}
+       */
+      addBatchObservableCallback(_callback, _observables) {
+      }
+      /**
+       * @see {@link Meter.removeBatchObservableCallback}
+       */
+      removeBatchObservableCallback(_callback) {
+      }
+    };
+    exports.NoopMeter = NoopMeter;
+    var NoopMetric = class {
+    };
+    exports.NoopMetric = NoopMetric;
+    var NoopCounterMetric = class extends NoopMetric {
+      add(_value, _attributes) {
+      }
+    };
+    exports.NoopCounterMetric = NoopCounterMetric;
+    var NoopUpDownCounterMetric = class extends NoopMetric {
+      add(_value, _attributes) {
+      }
+    };
+    exports.NoopUpDownCounterMetric = NoopUpDownCounterMetric;
+    var NoopHistogramMetric = class extends NoopMetric {
+      record(_value, _attributes) {
+      }
+    };
+    exports.NoopHistogramMetric = NoopHistogramMetric;
+    var NoopObservableMetric = class {
+      addCallback(_callback) {
+      }
+      removeCallback(_callback) {
+      }
+    };
+    exports.NoopObservableMetric = NoopObservableMetric;
+    var NoopObservableCounterMetric = class extends NoopObservableMetric {
+    };
+    exports.NoopObservableCounterMetric = NoopObservableCounterMetric;
+    var NoopObservableGaugeMetric = class extends NoopObservableMetric {
+    };
+    exports.NoopObservableGaugeMetric = NoopObservableGaugeMetric;
+    var NoopObservableUpDownCounterMetric = class extends NoopObservableMetric {
+    };
+    exports.NoopObservableUpDownCounterMetric = NoopObservableUpDownCounterMetric;
+    exports.NOOP_METER = new NoopMeter();
+    exports.NOOP_COUNTER_METRIC = new NoopCounterMetric();
+    exports.NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric();
+    exports.NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric();
+    exports.NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();
+    exports.NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();
+    exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();
+    function createNoopMeter() {
+      return exports.NOOP_METER;
+    }
+    exports.createNoopMeter = createNoopMeter;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/metrics/Metric.js
+var require_Metric = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/metrics/Metric.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ValueType = void 0;
+    var ValueType;
+    (function(ValueType2) {
+      ValueType2[ValueType2["INT"] = 0] = "INT";
+      ValueType2[ValueType2["DOUBLE"] = 1] = "DOUBLE";
+    })(ValueType = exports.ValueType || (exports.ValueType = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/propagation/TextMapPropagator.js
+var require_TextMapPropagator = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/propagation/TextMapPropagator.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.defaultTextMapSetter = exports.defaultTextMapGetter = void 0;
+    exports.defaultTextMapGetter = {
+      get(carrier, key) {
+        if (carrier == null) {
+          return void 0;
+        }
+        return carrier[key];
+      },
+      keys(carrier) {
+        if (carrier == null) {
+          return [];
+        }
+        return Object.keys(carrier);
+      }
+    };
+    exports.defaultTextMapSetter = {
+      set(carrier, key, value) {
+        if (carrier == null) {
+          return;
+        }
+        carrier[key] = value;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/context/NoopContextManager.js
+var require_NoopContextManager = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/context/NoopContextManager.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NoopContextManager = void 0;
+    var context_1 = require_context();
+    var NoopContextManager = class {
+      active() {
+        return context_1.ROOT_CONTEXT;
+      }
+      with(_context, fn, thisArg, ...args) {
+        return fn.call(thisArg, ...args);
+      }
+      bind(_context, target) {
+        return target;
+      }
+      enable() {
+        return this;
+      }
+      disable() {
+        return this;
+      }
+    };
+    exports.NoopContextManager = NoopContextManager;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/api/context.js
+var require_context2 = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/api/context.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ContextAPI = void 0;
+    var NoopContextManager_1 = require_NoopContextManager();
+    var global_utils_1 = require_global_utils();
+    var diag_1 = require_diag();
+    var API_NAME = "context";
+    var NOOP_CONTEXT_MANAGER = new NoopContextManager_1.NoopContextManager();
+    var ContextAPI = class _ContextAPI {
+      /** Empty private constructor prevents end users from constructing a new instance of the API */
+      constructor() {
+      }
+      /** Get the singleton instance of the Context API */
+      static getInstance() {
+        if (!this._instance) {
+          this._instance = new _ContextAPI();
+        }
+        return this._instance;
+      }
+      /**
+       * Set the current context manager.
+       *
+       * @returns true if the context manager was successfully registered, else false
+       */
+      setGlobalContextManager(contextManager) {
+        return (0, global_utils_1.registerGlobal)(API_NAME, contextManager, diag_1.DiagAPI.instance());
+      }
+      /**
+       * Get the currently active context
+       */
+      active() {
+        return this._getContextManager().active();
+      }
+      /**
+       * Execute a function with an active context
+       *
+       * @param context context to be active during function execution
+       * @param fn function to execute in a context
+       * @param thisArg optional receiver to be used for calling fn
+       * @param args optional arguments forwarded to fn
+       */
+      with(context, fn, thisArg, ...args) {
+        return this._getContextManager().with(context, fn, thisArg, ...args);
+      }
+      /**
+       * Bind a context to a target function or event emitter
+       *
+       * @param context context to bind to the event emitter or function. Defaults to the currently active context
+       * @param target function or event emitter to bind
+       */
+      bind(context, target) {
+        return this._getContextManager().bind(context, target);
+      }
+      _getContextManager() {
+        return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_CONTEXT_MANAGER;
+      }
+      /** Disable and remove the global context manager */
+      disable() {
+        this._getContextManager().disable();
+        (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+      }
+    };
+    exports.ContextAPI = ContextAPI;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/trace_flags.js
+var require_trace_flags = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/trace_flags.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TraceFlags = void 0;
+    var TraceFlags;
+    (function(TraceFlags2) {
+      TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
+      TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
+    })(TraceFlags = exports.TraceFlags || (exports.TraceFlags = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.js
+var require_invalid_span_constants = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.INVALID_SPAN_CONTEXT = exports.INVALID_TRACEID = exports.INVALID_SPANID = void 0;
+    var trace_flags_1 = require_trace_flags();
+    exports.INVALID_SPANID = "0000000000000000";
+    exports.INVALID_TRACEID = "00000000000000000000000000000000";
+    exports.INVALID_SPAN_CONTEXT = {
+      traceId: exports.INVALID_TRACEID,
+      spanId: exports.INVALID_SPANID,
+      traceFlags: trace_flags_1.TraceFlags.NONE
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/NonRecordingSpan.js
+var require_NonRecordingSpan = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/NonRecordingSpan.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NonRecordingSpan = void 0;
+    var invalid_span_constants_1 = require_invalid_span_constants();
+    var NonRecordingSpan = class {
+      constructor(_spanContext = invalid_span_constants_1.INVALID_SPAN_CONTEXT) {
+        this._spanContext = _spanContext;
+      }
+      // Returns a SpanContext.
+      spanContext() {
+        return this._spanContext;
+      }
+      // By default does nothing
+      setAttribute(_key, _value) {
+        return this;
+      }
+      // By default does nothing
+      setAttributes(_attributes) {
+        return this;
+      }
+      // By default does nothing
+      addEvent(_name, _attributes) {
+        return this;
+      }
+      // By default does nothing
+      setStatus(_status) {
+        return this;
+      }
+      // By default does nothing
+      updateName(_name) {
+        return this;
+      }
+      // By default does nothing
+      end(_endTime) {
+      }
+      // isRecording always returns false for NonRecordingSpan.
+      isRecording() {
+        return false;
+      }
+      // By default does nothing
+      recordException(_exception, _time) {
+      }
+    };
+    exports.NonRecordingSpan = NonRecordingSpan;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/context-utils.js
+var require_context_utils = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/context-utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getSpanContext = exports.setSpanContext = exports.deleteSpan = exports.setSpan = exports.getActiveSpan = exports.getSpan = void 0;
+    var context_1 = require_context();
+    var NonRecordingSpan_1 = require_NonRecordingSpan();
+    var context_2 = require_context2();
+    var SPAN_KEY = (0, context_1.createContextKey)("OpenTelemetry Context Key SPAN");
+    function getSpan(context) {
+      return context.getValue(SPAN_KEY) || void 0;
+    }
+    exports.getSpan = getSpan;
+    function getActiveSpan() {
+      return getSpan(context_2.ContextAPI.getInstance().active());
+    }
+    exports.getActiveSpan = getActiveSpan;
+    function setSpan(context, span) {
+      return context.setValue(SPAN_KEY, span);
+    }
+    exports.setSpan = setSpan;
+    function deleteSpan(context) {
+      return context.deleteValue(SPAN_KEY);
+    }
+    exports.deleteSpan = deleteSpan;
+    function setSpanContext(context, spanContext) {
+      return setSpan(context, new NonRecordingSpan_1.NonRecordingSpan(spanContext));
+    }
+    exports.setSpanContext = setSpanContext;
+    function getSpanContext(context) {
+      var _a;
+      return (_a = getSpan(context)) === null || _a === void 0 ? void 0 : _a.spanContext();
+    }
+    exports.getSpanContext = getSpanContext;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.js
+var require_spancontext_utils = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.wrapSpanContext = exports.isSpanContextValid = exports.isValidSpanId = exports.isValidTraceId = void 0;
+    var invalid_span_constants_1 = require_invalid_span_constants();
+    var NonRecordingSpan_1 = require_NonRecordingSpan();
+    var VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
+    var VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
+    function isValidTraceId(traceId) {
+      return VALID_TRACEID_REGEX.test(traceId) && traceId !== invalid_span_constants_1.INVALID_TRACEID;
+    }
+    exports.isValidTraceId = isValidTraceId;
+    function isValidSpanId(spanId) {
+      return VALID_SPANID_REGEX.test(spanId) && spanId !== invalid_span_constants_1.INVALID_SPANID;
+    }
+    exports.isValidSpanId = isValidSpanId;
+    function isSpanContextValid(spanContext) {
+      return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
+    }
+    exports.isSpanContextValid = isSpanContextValid;
+    function wrapSpanContext(spanContext) {
+      return new NonRecordingSpan_1.NonRecordingSpan(spanContext);
+    }
+    exports.wrapSpanContext = wrapSpanContext;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/NoopTracer.js
+var require_NoopTracer = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/NoopTracer.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NoopTracer = void 0;
+    var context_1 = require_context2();
+    var context_utils_1 = require_context_utils();
+    var NonRecordingSpan_1 = require_NonRecordingSpan();
+    var spancontext_utils_1 = require_spancontext_utils();
+    var contextApi = context_1.ContextAPI.getInstance();
+    var NoopTracer = class {
+      // startSpan starts a noop span.
+      startSpan(name, options, context = contextApi.active()) {
+        const root = Boolean(options === null || options === void 0 ? void 0 : options.root);
+        if (root) {
+          return new NonRecordingSpan_1.NonRecordingSpan();
+        }
+        const parentFromContext = context && (0, context_utils_1.getSpanContext)(context);
+        if (isSpanContext(parentFromContext) && (0, spancontext_utils_1.isSpanContextValid)(parentFromContext)) {
+          return new NonRecordingSpan_1.NonRecordingSpan(parentFromContext);
+        } else {
+          return new NonRecordingSpan_1.NonRecordingSpan();
+        }
+      }
+      startActiveSpan(name, arg2, arg3, arg4) {
+        let opts;
+        let ctx;
+        let fn;
+        if (arguments.length < 2) {
+          return;
+        } else if (arguments.length === 2) {
+          fn = arg2;
+        } else if (arguments.length === 3) {
+          opts = arg2;
+          fn = arg3;
+        } else {
+          opts = arg2;
+          ctx = arg3;
+          fn = arg4;
+        }
+        const parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+        const span = this.startSpan(name, opts, parentContext);
+        const contextWithSpanSet = (0, context_utils_1.setSpan)(parentContext, span);
+        return contextApi.with(contextWithSpanSet, fn, void 0, span);
+      }
+    };
+    exports.NoopTracer = NoopTracer;
+    function isSpanContext(spanContext) {
+      return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
+    }
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/ProxyTracer.js
+var require_ProxyTracer = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/ProxyTracer.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ProxyTracer = void 0;
+    var NoopTracer_1 = require_NoopTracer();
+    var NOOP_TRACER = new NoopTracer_1.NoopTracer();
+    var ProxyTracer = class {
+      constructor(_provider, name, version, options) {
+        this._provider = _provider;
+        this.name = name;
+        this.version = version;
+        this.options = options;
+      }
+      startSpan(name, options, context) {
+        return this._getTracer().startSpan(name, options, context);
+      }
+      startActiveSpan(_name, _options, _context, _fn) {
+        const tracer = this._getTracer();
+        return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
+      }
+      /**
+       * Try to get a tracer from the proxy tracer provider.
+       * If the proxy tracer provider has no delegate, return a noop tracer.
+       */
+      _getTracer() {
+        if (this._delegate) {
+          return this._delegate;
+        }
+        const tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
+        if (!tracer) {
+          return NOOP_TRACER;
+        }
+        this._delegate = tracer;
+        return this._delegate;
+      }
+    };
+    exports.ProxyTracer = ProxyTracer;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/NoopTracerProvider.js
+var require_NoopTracerProvider = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/NoopTracerProvider.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NoopTracerProvider = void 0;
+    var NoopTracer_1 = require_NoopTracer();
+    var NoopTracerProvider = class {
+      getTracer(_name, _version, _options) {
+        return new NoopTracer_1.NoopTracer();
+      }
+    };
+    exports.NoopTracerProvider = NoopTracerProvider;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/ProxyTracerProvider.js
+var require_ProxyTracerProvider = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/ProxyTracerProvider.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ProxyTracerProvider = void 0;
+    var ProxyTracer_1 = require_ProxyTracer();
+    var NoopTracerProvider_1 = require_NoopTracerProvider();
+    var NOOP_TRACER_PROVIDER = new NoopTracerProvider_1.NoopTracerProvider();
+    var ProxyTracerProvider = class {
+      /**
+       * Get a {@link ProxyTracer}
+       */
+      getTracer(name, version, options) {
+        var _a;
+        return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer_1.ProxyTracer(this, name, version, options);
+      }
+      getDelegate() {
+        var _a;
+        return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
+      }
+      /**
+       * Set the delegate tracer provider
+       */
+      setDelegate(delegate) {
+        this._delegate = delegate;
+      }
+      getDelegateTracer(name, version, options) {
+        var _a;
+        return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
+      }
+    };
+    exports.ProxyTracerProvider = ProxyTracerProvider;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/SamplingResult.js
+var require_SamplingResult = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/SamplingResult.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SamplingDecision = void 0;
+    var SamplingDecision;
+    (function(SamplingDecision2) {
+      SamplingDecision2[SamplingDecision2["NOT_RECORD"] = 0] = "NOT_RECORD";
+      SamplingDecision2[SamplingDecision2["RECORD"] = 1] = "RECORD";
+      SamplingDecision2[SamplingDecision2["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
+    })(SamplingDecision = exports.SamplingDecision || (exports.SamplingDecision = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/span_kind.js
+var require_span_kind = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/span_kind.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SpanKind = void 0;
+    var SpanKind;
+    (function(SpanKind2) {
+      SpanKind2[SpanKind2["INTERNAL"] = 0] = "INTERNAL";
+      SpanKind2[SpanKind2["SERVER"] = 1] = "SERVER";
+      SpanKind2[SpanKind2["CLIENT"] = 2] = "CLIENT";
+      SpanKind2[SpanKind2["PRODUCER"] = 3] = "PRODUCER";
+      SpanKind2[SpanKind2["CONSUMER"] = 4] = "CONSUMER";
+    })(SpanKind = exports.SpanKind || (exports.SpanKind = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/status.js
+var require_status = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/status.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SpanStatusCode = void 0;
+    var SpanStatusCode;
+    (function(SpanStatusCode2) {
+      SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
+      SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
+      SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
+    })(SpanStatusCode = exports.SpanStatusCode || (exports.SpanStatusCode = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-validators.js
+var require_tracestate_validators = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-validators.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.validateValue = exports.validateKey = void 0;
+    var VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
+    var VALID_KEY = `[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`;
+    var VALID_VENDOR_KEY = `[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`;
+    var VALID_KEY_REGEX = new RegExp(`^(?:${VALID_KEY}|${VALID_VENDOR_KEY})$`);
+    var VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
+    var INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
+    function validateKey(key) {
+      return VALID_KEY_REGEX.test(key);
+    }
+    exports.validateKey = validateKey;
+    function validateValue(value) {
+      return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
+    }
+    exports.validateValue = validateValue;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-impl.js
+var require_tracestate_impl = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-impl.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TraceStateImpl = void 0;
+    var tracestate_validators_1 = require_tracestate_validators();
+    var MAX_TRACE_STATE_ITEMS = 32;
+    var MAX_TRACE_STATE_LEN = 512;
+    var LIST_MEMBERS_SEPARATOR = ",";
+    var LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
+    var TraceStateImpl = class _TraceStateImpl {
+      constructor(rawTraceState) {
+        this._internalState = /* @__PURE__ */ new Map();
+        if (rawTraceState)
+          this._parse(rawTraceState);
+      }
+      set(key, value) {
+        const traceState = this._clone();
+        if (traceState._internalState.has(key)) {
+          traceState._internalState.delete(key);
+        }
+        traceState._internalState.set(key, value);
+        return traceState;
+      }
+      unset(key) {
+        const traceState = this._clone();
+        traceState._internalState.delete(key);
+        return traceState;
+      }
+      get(key) {
+        return this._internalState.get(key);
+      }
+      serialize() {
+        return this._keys().reduce((agg, key) => {
+          agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key));
+          return agg;
+        }, []).join(LIST_MEMBERS_SEPARATOR);
+      }
+      _parse(rawTraceState) {
+        if (rawTraceState.length > MAX_TRACE_STATE_LEN)
+          return;
+        this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reverse().reduce((agg, part) => {
+          const listMember = part.trim();
+          const i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
+          if (i !== -1) {
+            const key = listMember.slice(0, i);
+            const value = listMember.slice(i + 1, part.length);
+            if ((0, tracestate_validators_1.validateKey)(key) && (0, tracestate_validators_1.validateValue)(value)) {
+              agg.set(key, value);
+            } else {
+            }
+          }
+          return agg;
+        }, /* @__PURE__ */ new Map());
+        if (this._internalState.size > MAX_TRACE_STATE_ITEMS) {
+          this._internalState = new Map(Array.from(this._internalState.entries()).reverse().slice(0, MAX_TRACE_STATE_ITEMS));
+        }
+      }
+      _keys() {
+        return Array.from(this._internalState.keys()).reverse();
+      }
+      _clone() {
+        const traceState = new _TraceStateImpl();
+        traceState._internalState = new Map(this._internalState);
+        return traceState;
+      }
+    };
+    exports.TraceStateImpl = TraceStateImpl;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/internal/utils.js
+var require_utils2 = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/internal/utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createTraceState = void 0;
+    var tracestate_impl_1 = require_tracestate_impl();
+    function createTraceState(rawTraceState) {
+      return new tracestate_impl_1.TraceStateImpl(rawTraceState);
+    }
+    exports.createTraceState = createTraceState;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/context-api.js
+var require_context_api = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/context-api.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.context = void 0;
+    var context_1 = require_context2();
+    exports.context = context_1.ContextAPI.getInstance();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/diag-api.js
+var require_diag_api = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/diag-api.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.diag = void 0;
+    var diag_1 = require_diag();
+    exports.diag = diag_1.DiagAPI.instance();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/metrics/NoopMeterProvider.js
+var require_NoopMeterProvider = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/metrics/NoopMeterProvider.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NOOP_METER_PROVIDER = exports.NoopMeterProvider = void 0;
+    var NoopMeter_1 = require_NoopMeter();
+    var NoopMeterProvider = class {
+      getMeter(_name, _version, _options) {
+        return NoopMeter_1.NOOP_METER;
+      }
+    };
+    exports.NoopMeterProvider = NoopMeterProvider;
+    exports.NOOP_METER_PROVIDER = new NoopMeterProvider();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/api/metrics.js
+var require_metrics = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/api/metrics.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.MetricsAPI = void 0;
+    var NoopMeterProvider_1 = require_NoopMeterProvider();
+    var global_utils_1 = require_global_utils();
+    var diag_1 = require_diag();
+    var API_NAME = "metrics";
+    var MetricsAPI = class _MetricsAPI {
+      /** Empty private constructor prevents end users from constructing a new instance of the API */
+      constructor() {
+      }
+      /** Get the singleton instance of the Metrics API */
+      static getInstance() {
+        if (!this._instance) {
+          this._instance = new _MetricsAPI();
+        }
+        return this._instance;
+      }
+      /**
+       * Set the current global meter provider.
+       * Returns true if the meter provider was successfully registered, else false.
+       */
+      setGlobalMeterProvider(provider) {
+        return (0, global_utils_1.registerGlobal)(API_NAME, provider, diag_1.DiagAPI.instance());
+      }
+      /**
+       * Returns the global meter provider.
+       */
+      getMeterProvider() {
+        return (0, global_utils_1.getGlobal)(API_NAME) || NoopMeterProvider_1.NOOP_METER_PROVIDER;
+      }
+      /**
+       * Returns a meter from the global meter provider.
+       */
+      getMeter(name, version, options) {
+        return this.getMeterProvider().getMeter(name, version, options);
+      }
+      /** Remove the global meter provider */
+      disable() {
+        (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+      }
+    };
+    exports.MetricsAPI = MetricsAPI;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/metrics-api.js
+var require_metrics_api = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/metrics-api.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.metrics = void 0;
+    var metrics_1 = require_metrics();
+    exports.metrics = metrics_1.MetricsAPI.getInstance();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/propagation/NoopTextMapPropagator.js
+var require_NoopTextMapPropagator = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/propagation/NoopTextMapPropagator.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NoopTextMapPropagator = void 0;
+    var NoopTextMapPropagator = class {
+      /** Noop inject function does nothing */
+      inject(_context, _carrier) {
+      }
+      /** Noop extract function does nothing and returns the input context */
+      extract(context, _carrier) {
+        return context;
+      }
+      fields() {
+        return [];
+      }
+    };
+    exports.NoopTextMapPropagator = NoopTextMapPropagator;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/baggage/context-helpers.js
+var require_context_helpers = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/baggage/context-helpers.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.deleteBaggage = exports.setBaggage = exports.getActiveBaggage = exports.getBaggage = void 0;
+    var context_1 = require_context2();
+    var context_2 = require_context();
+    var BAGGAGE_KEY = (0, context_2.createContextKey)("OpenTelemetry Baggage Key");
+    function getBaggage(context) {
+      return context.getValue(BAGGAGE_KEY) || void 0;
+    }
+    exports.getBaggage = getBaggage;
+    function getActiveBaggage() {
+      return getBaggage(context_1.ContextAPI.getInstance().active());
+    }
+    exports.getActiveBaggage = getActiveBaggage;
+    function setBaggage(context, baggage) {
+      return context.setValue(BAGGAGE_KEY, baggage);
+    }
+    exports.setBaggage = setBaggage;
+    function deleteBaggage(context) {
+      return context.deleteValue(BAGGAGE_KEY);
+    }
+    exports.deleteBaggage = deleteBaggage;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/api/propagation.js
+var require_propagation = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/api/propagation.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PropagationAPI = void 0;
+    var global_utils_1 = require_global_utils();
+    var NoopTextMapPropagator_1 = require_NoopTextMapPropagator();
+    var TextMapPropagator_1 = require_TextMapPropagator();
+    var context_helpers_1 = require_context_helpers();
+    var utils_1 = require_utils();
+    var diag_1 = require_diag();
+    var API_NAME = "propagation";
+    var NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator_1.NoopTextMapPropagator();
+    var PropagationAPI = class _PropagationAPI {
+      /** Empty private constructor prevents end users from constructing a new instance of the API */
+      constructor() {
+        this.createBaggage = utils_1.createBaggage;
+        this.getBaggage = context_helpers_1.getBaggage;
+        this.getActiveBaggage = context_helpers_1.getActiveBaggage;
+        this.setBaggage = context_helpers_1.setBaggage;
+        this.deleteBaggage = context_helpers_1.deleteBaggage;
+      }
+      /** Get the singleton instance of the Propagator API */
+      static getInstance() {
+        if (!this._instance) {
+          this._instance = new _PropagationAPI();
+        }
+        return this._instance;
+      }
+      /**
+       * Set the current propagator.
+       *
+       * @returns true if the propagator was successfully registered, else false
+       */
+      setGlobalPropagator(propagator) {
+        return (0, global_utils_1.registerGlobal)(API_NAME, propagator, diag_1.DiagAPI.instance());
+      }
+      /**
+       * Inject context into a carrier to be propagated inter-process
+       *
+       * @param context Context carrying tracing data to inject
+       * @param carrier carrier to inject context into
+       * @param setter Function used to set values on the carrier
+       */
+      inject(context, carrier, setter = TextMapPropagator_1.defaultTextMapSetter) {
+        return this._getGlobalPropagator().inject(context, carrier, setter);
+      }
+      /**
+       * Extract context from a carrier
+       *
+       * @param context Context which the newly created context will inherit from
+       * @param carrier Carrier to extract context from
+       * @param getter Function used to extract keys from a carrier
+       */
+      extract(context, carrier, getter = TextMapPropagator_1.defaultTextMapGetter) {
+        return this._getGlobalPropagator().extract(context, carrier, getter);
+      }
+      /**
+       * Return a list of all fields which may be used by the propagator.
+       */
+      fields() {
+        return this._getGlobalPropagator().fields();
+      }
+      /** Remove the global propagator */
+      disable() {
+        (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+      }
+      _getGlobalPropagator() {
+        return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_TEXT_MAP_PROPAGATOR;
+      }
+    };
+    exports.PropagationAPI = PropagationAPI;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/propagation-api.js
+var require_propagation_api = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/propagation-api.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.propagation = void 0;
+    var propagation_1 = require_propagation();
+    exports.propagation = propagation_1.PropagationAPI.getInstance();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/api/trace.js
+var require_trace = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/api/trace.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TraceAPI = void 0;
+    var global_utils_1 = require_global_utils();
+    var ProxyTracerProvider_1 = require_ProxyTracerProvider();
+    var spancontext_utils_1 = require_spancontext_utils();
+    var context_utils_1 = require_context_utils();
+    var diag_1 = require_diag();
+    var API_NAME = "trace";
+    var TraceAPI = class _TraceAPI {
+      /** Empty private constructor prevents end users from constructing a new instance of the API */
+      constructor() {
+        this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider();
+        this.wrapSpanContext = spancontext_utils_1.wrapSpanContext;
+        this.isSpanContextValid = spancontext_utils_1.isSpanContextValid;
+        this.deleteSpan = context_utils_1.deleteSpan;
+        this.getSpan = context_utils_1.getSpan;
+        this.getActiveSpan = context_utils_1.getActiveSpan;
+        this.getSpanContext = context_utils_1.getSpanContext;
+        this.setSpan = context_utils_1.setSpan;
+        this.setSpanContext = context_utils_1.setSpanContext;
+      }
+      /** Get the singleton instance of the Trace API */
+      static getInstance() {
+        if (!this._instance) {
+          this._instance = new _TraceAPI();
+        }
+        return this._instance;
+      }
+      /**
+       * Set the current global tracer.
+       *
+       * @returns true if the tracer provider was successfully registered, else false
+       */
+      setGlobalTracerProvider(provider) {
+        const success = (0, global_utils_1.registerGlobal)(API_NAME, this._proxyTracerProvider, diag_1.DiagAPI.instance());
+        if (success) {
+          this._proxyTracerProvider.setDelegate(provider);
+        }
+        return success;
+      }
+      /**
+       * Returns the global tracer provider.
+       */
+      getTracerProvider() {
+        return (0, global_utils_1.getGlobal)(API_NAME) || this._proxyTracerProvider;
+      }
+      /**
+       * Returns a tracer from the global tracer provider.
+       */
+      getTracer(name, version) {
+        return this.getTracerProvider().getTracer(name, version);
+      }
+      /** Remove the global tracer provider */
+      disable() {
+        (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+        this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider();
+      }
+    };
+    exports.TraceAPI = TraceAPI;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace-api.js
+var require_trace_api = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace-api.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.trace = void 0;
+    var trace_1 = require_trace();
+    exports.trace = trace_1.TraceAPI.getInstance();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.trace = exports.propagation = exports.metrics = exports.diag = exports.context = exports.INVALID_SPAN_CONTEXT = exports.INVALID_TRACEID = exports.INVALID_SPANID = exports.isValidSpanId = exports.isValidTraceId = exports.isSpanContextValid = exports.createTraceState = exports.TraceFlags = exports.SpanStatusCode = exports.SpanKind = exports.SamplingDecision = exports.ProxyTracerProvider = exports.ProxyTracer = exports.defaultTextMapSetter = exports.defaultTextMapGetter = exports.ValueType = exports.createNoopMeter = exports.DiagLogLevel = exports.DiagConsoleLogger = exports.ROOT_CONTEXT = exports.createContextKey = exports.baggageEntryMetadataFromString = void 0;
+    var utils_1 = require_utils();
+    Object.defineProperty(exports, "baggageEntryMetadataFromString", { enumerable: true, get: function() {
+      return utils_1.baggageEntryMetadataFromString;
+    } });
+    var context_1 = require_context();
+    Object.defineProperty(exports, "createContextKey", { enumerable: true, get: function() {
+      return context_1.createContextKey;
+    } });
+    Object.defineProperty(exports, "ROOT_CONTEXT", { enumerable: true, get: function() {
+      return context_1.ROOT_CONTEXT;
+    } });
+    var consoleLogger_1 = require_consoleLogger();
+    Object.defineProperty(exports, "DiagConsoleLogger", { enumerable: true, get: function() {
+      return consoleLogger_1.DiagConsoleLogger;
+    } });
+    var types_1 = require_types();
+    Object.defineProperty(exports, "DiagLogLevel", { enumerable: true, get: function() {
+      return types_1.DiagLogLevel;
+    } });
+    var NoopMeter_1 = require_NoopMeter();
+    Object.defineProperty(exports, "createNoopMeter", { enumerable: true, get: function() {
+      return NoopMeter_1.createNoopMeter;
+    } });
+    var Metric_1 = require_Metric();
+    Object.defineProperty(exports, "ValueType", { enumerable: true, get: function() {
+      return Metric_1.ValueType;
+    } });
+    var TextMapPropagator_1 = require_TextMapPropagator();
+    Object.defineProperty(exports, "defaultTextMapGetter", { enumerable: true, get: function() {
+      return TextMapPropagator_1.defaultTextMapGetter;
+    } });
+    Object.defineProperty(exports, "defaultTextMapSetter", { enumerable: true, get: function() {
+      return TextMapPropagator_1.defaultTextMapSetter;
+    } });
+    var ProxyTracer_1 = require_ProxyTracer();
+    Object.defineProperty(exports, "ProxyTracer", { enumerable: true, get: function() {
+      return ProxyTracer_1.ProxyTracer;
+    } });
+    var ProxyTracerProvider_1 = require_ProxyTracerProvider();
+    Object.defineProperty(exports, "ProxyTracerProvider", { enumerable: true, get: function() {
+      return ProxyTracerProvider_1.ProxyTracerProvider;
+    } });
+    var SamplingResult_1 = require_SamplingResult();
+    Object.defineProperty(exports, "SamplingDecision", { enumerable: true, get: function() {
+      return SamplingResult_1.SamplingDecision;
+    } });
+    var span_kind_1 = require_span_kind();
+    Object.defineProperty(exports, "SpanKind", { enumerable: true, get: function() {
+      return span_kind_1.SpanKind;
+    } });
+    var status_1 = require_status();
+    Object.defineProperty(exports, "SpanStatusCode", { enumerable: true, get: function() {
+      return status_1.SpanStatusCode;
+    } });
+    var trace_flags_1 = require_trace_flags();
+    Object.defineProperty(exports, "TraceFlags", { enumerable: true, get: function() {
+      return trace_flags_1.TraceFlags;
+    } });
+    var utils_2 = require_utils2();
+    Object.defineProperty(exports, "createTraceState", { enumerable: true, get: function() {
+      return utils_2.createTraceState;
+    } });
+    var spancontext_utils_1 = require_spancontext_utils();
+    Object.defineProperty(exports, "isSpanContextValid", { enumerable: true, get: function() {
+      return spancontext_utils_1.isSpanContextValid;
+    } });
+    Object.defineProperty(exports, "isValidTraceId", { enumerable: true, get: function() {
+      return spancontext_utils_1.isValidTraceId;
+    } });
+    Object.defineProperty(exports, "isValidSpanId", { enumerable: true, get: function() {
+      return spancontext_utils_1.isValidSpanId;
+    } });
+    var invalid_span_constants_1 = require_invalid_span_constants();
+    Object.defineProperty(exports, "INVALID_SPANID", { enumerable: true, get: function() {
+      return invalid_span_constants_1.INVALID_SPANID;
+    } });
+    Object.defineProperty(exports, "INVALID_TRACEID", { enumerable: true, get: function() {
+      return invalid_span_constants_1.INVALID_TRACEID;
+    } });
+    Object.defineProperty(exports, "INVALID_SPAN_CONTEXT", { enumerable: true, get: function() {
+      return invalid_span_constants_1.INVALID_SPAN_CONTEXT;
+    } });
+    var context_api_1 = require_context_api();
+    Object.defineProperty(exports, "context", { enumerable: true, get: function() {
+      return context_api_1.context;
+    } });
+    var diag_api_1 = require_diag_api();
+    Object.defineProperty(exports, "diag", { enumerable: true, get: function() {
+      return diag_api_1.diag;
+    } });
+    var metrics_api_1 = require_metrics_api();
+    Object.defineProperty(exports, "metrics", { enumerable: true, get: function() {
+      return metrics_api_1.metrics;
+    } });
+    var propagation_api_1 = require_propagation_api();
+    Object.defineProperty(exports, "propagation", { enumerable: true, get: function() {
+      return propagation_api_1.propagation;
+    } });
+    var trace_api_1 = require_trace_api();
+    Object.defineProperty(exports, "trace", { enumerable: true, get: function() {
+      return trace_api_1.trace;
+    } });
+    exports.default = {
+      context: context_api_1.context,
+      diag: diag_api_1.diag,
+      metrics: metrics_api_1.metrics,
+      propagation: propagation_api_1.propagation,
+      trace: trace_api_1.trace
+    };
+  }
+});
+
+// src/PerformanceRecorder.ts
+import { performance } from "perf_hooks";
+
+// src/MetricEventAggregatorRegistry.ts
+var MetricEventAggregatorRegistry = class {
+  constructor() {
+    this._aggregators = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Registers a new aggregator. If an aggregator already exists, it will be return the aggregator.
+   * @param name - The name of the metric.
+   * @param aggregate - The aggregator function.
+   * @returns The aggregator that is passed in.
+   */
+  register(aggregator) {
+    if (!this._aggregators.has(aggregator)) {
+      this._aggregators.add(aggregator);
+    }
+    return aggregator;
+  }
+  /**
+   * Gets all the aggregated events from all the registered aggregators.
+   * @returns The aggregated events.
+   */
+  getAggregatedEvents() {
+    const events = [];
+    for (const aggregator of this._aggregators) {
+      events.push(...aggregator.getAggregatedEvents());
+    }
+    return events;
+  }
+};
+
+// src/PerformanceRecorder.ts
+var PerformanceRecorder = class {
+  constructor(span) {
+    this.span = span;
+    this._metricEventAggregatorRegistry = new MetricEventAggregatorRegistry();
+  }
+  /**
+   * Registers a new aggregator for a given metric.
+   * If an aggregator already exists, it will be skipped.
+   * @param name - The name of the metric.
+   * @param aggregator - The aggregator function.
+   */
+  registerAggregator(aggregator) {
+    return this._metricEventAggregatorRegistry.register(aggregator);
+  }
+  /**
+   * Records a performance metric into telemetry. The metric will be recorded as an event on the span and logged to the console.
+   * It can be used for any situation where a performance metric (ie: how long does it take run something, or any other purpose) is needed.
+   * @param attributes
+   */
+  record(attributes) {
+    const { name, value, additionalProperties = {} } = attributes;
+    this.span.addEvent("Performance-Metric", { ...additionalProperties, name, value });
+    console.debug(`Performance-Metric: ${name} ${value}`);
+  }
+  /**
+   * Tracks the execution time of a given `execute` function and report it to telemetry.
+   * @param name - The name of the performance metric.
+   * @param execute - The function to execute and track.
+   * @returns - The result of the `execute` function.
+   */
+  async track(name, execute) {
+    const additionalProperties = {};
+    const startTime = performance.now();
+    const tracker = {
+      name,
+      startTime,
+      setProperties: (properties) => {
+        for (const [key, value] of Object.entries(properties)) {
+          additionalProperties[key] = value;
+        }
+      }
+    };
+    const result = await execute(tracker);
+    this.record({ name, value: performance.now() - startTime, additionalProperties });
+    return result;
+  }
+  /**
+   * Shuts down the performance recorder and records any aggregated events.
+   */
+  shutdown() {
+    for (const { name, value, attributes } of this._metricEventAggregatorRegistry.getAggregatedEvents()) {
+      this.record({ name, value, additionalProperties: attributes });
+    }
+  }
+};
+
+export {
+  __require,
+  __esm,
+  __commonJS,
+  __export,
+  __toESM,
+  __toCommonJS,
+  require_src,
+  PerformanceRecorder
+};
+//# sourceMappingURL=chunk-LA4AUP26.js.map