@baselime/node-opentelemetry
Version:
Instrument node.js applications with open telemetry
1,445 lines (1,404 loc) • 673 kB
JavaScript
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 __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
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/esm/platform/node/globalThis.js
var _globalThis;
var init_globalThis = __esm({
"node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js"() {
_globalThis = typeof globalThis === "object" ? globalThis : global;
}
});
// node_modules/@opentelemetry/api/build/esm/platform/node/index.js
var init_node = __esm({
"node_modules/@opentelemetry/api/build/esm/platform/node/index.js"() {
init_globalThis();
}
});
// node_modules/@opentelemetry/api/build/esm/platform/index.js
var init_platform = __esm({
"node_modules/@opentelemetry/api/build/esm/platform/index.js"() {
init_node();
}
});
// node_modules/@opentelemetry/api/build/esm/version.js
var VERSION;
var init_version = __esm({
"node_modules/@opentelemetry/api/build/esm/version.js"() {
VERSION = "1.8.0";
}
});
// node_modules/@opentelemetry/api/build/esm/internal/semver.js
function _makeCompatibilityCheck(ownVersion) {
var acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
var rejectedVersions = /* @__PURE__ */ new Set();
var myVersionMatch = ownVersion.match(re);
if (!myVersionMatch) {
return function() {
return false;
};
}
var 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 isCompatible2(globalVersion) {
if (acceptedVersions.has(globalVersion)) {
return true;
}
if (rejectedVersions.has(globalVersion)) {
return false;
}
var globalVersionMatch = globalVersion.match(re);
if (!globalVersionMatch) {
return _reject(globalVersion);
}
var 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);
};
}
var re, isCompatible;
var init_semver = __esm({
"node_modules/@opentelemetry/api/build/esm/internal/semver.js"() {
init_version();
re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
isCompatible = _makeCompatibilityCheck(VERSION);
}
});
// node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
function registerGlobal(type, instance, diag3, allowOverride) {
var _a2;
if (allowOverride === void 0) {
allowOverride = false;
}
var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a2 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a2 !== void 0 ? _a2 : {
version: VERSION
};
if (!allowOverride && api[type]) {
var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
diag3.error(err.stack || err.message);
return false;
}
if (api.version !== VERSION) {
var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION);
diag3.error(err.stack || err.message);
return false;
}
api[type] = instance;
diag3.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION + ".");
return true;
}
function getGlobal(type) {
var _a2, _b;
var globalVersion = (_a2 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a2 === void 0 ? void 0 : _a2.version;
if (!globalVersion || !isCompatible(globalVersion)) {
return;
}
return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
}
function unregisterGlobal(type, diag3) {
diag3.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION + ".");
var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
if (api) {
delete api[type];
}
}
var major, GLOBAL_OPENTELEMETRY_API_KEY, _global;
var init_global_utils = __esm({
"node_modules/@opentelemetry/api/build/esm/internal/global-utils.js"() {
init_platform();
init_version();
init_semver();
major = VERSION.split(".")[0];
GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
_global = _globalThis;
}
});
// node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
function logProxy(funcName, namespace, args) {
var logger = getGlobal("diag");
if (!logger) {
return;
}
args.unshift(namespace);
return logger[funcName].apply(logger, __spreadArray([], __read(args), false));
}
var __read, __spreadArray, DiagComponentLogger;
var init_ComponentLogger = __esm({
"node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js"() {
init_global_utils();
__read = function(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m)
return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
ar.push(r.value);
} catch (error) {
e = { error };
} finally {
try {
if (r && !r.done && (m = i["return"]))
m.call(i);
} finally {
if (e)
throw e.error;
}
}
return ar;
};
__spreadArray = function(to, from, pack) {
if (pack || arguments.length === 2)
for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar)
ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
DiagComponentLogger = /** @class */
function() {
function DiagComponentLogger2(props) {
this._namespace = props.namespace || "DiagComponentLogger";
}
DiagComponentLogger2.prototype.debug = function() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return logProxy("debug", this._namespace, args);
};
DiagComponentLogger2.prototype.error = function() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return logProxy("error", this._namespace, args);
};
DiagComponentLogger2.prototype.info = function() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return logProxy("info", this._namespace, args);
};
DiagComponentLogger2.prototype.warn = function() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return logProxy("warn", this._namespace, args);
};
DiagComponentLogger2.prototype.verbose = function() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return logProxy("verbose", this._namespace, args);
};
return DiagComponentLogger2;
}();
}
});
// node_modules/@opentelemetry/api/build/esm/diag/types.js
var DiagLogLevel;
var init_types = __esm({
"node_modules/@opentelemetry/api/build/esm/diag/types.js"() {
(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 || (DiagLogLevel = {}));
}
});
// node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
function createLogLevelDiagLogger(maxLevel, logger) {
if (maxLevel < DiagLogLevel.NONE) {
maxLevel = DiagLogLevel.NONE;
} else if (maxLevel > DiagLogLevel.ALL) {
maxLevel = DiagLogLevel.ALL;
}
logger = logger || {};
function _filterFunc(funcName, theLevel) {
var theFunc = logger[funcName];
if (typeof theFunc === "function" && maxLevel >= theLevel) {
return theFunc.bind(logger);
}
return function() {
};
}
return {
error: _filterFunc("error", DiagLogLevel.ERROR),
warn: _filterFunc("warn", DiagLogLevel.WARN),
info: _filterFunc("info", DiagLogLevel.INFO),
debug: _filterFunc("debug", DiagLogLevel.DEBUG),
verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
};
}
var init_logLevelLogger = __esm({
"node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js"() {
init_types();
}
});
// node_modules/@opentelemetry/api/build/esm/api/diag.js
var __read2, __spreadArray2, API_NAME, DiagAPI;
var init_diag = __esm({
"node_modules/@opentelemetry/api/build/esm/api/diag.js"() {
init_ComponentLogger();
init_logLevelLogger();
init_types();
init_global_utils();
__read2 = function(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m)
return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
ar.push(r.value);
} catch (error) {
e = { error };
} finally {
try {
if (r && !r.done && (m = i["return"]))
m.call(i);
} finally {
if (e)
throw e.error;
}
}
return ar;
};
__spreadArray2 = function(to, from, pack) {
if (pack || arguments.length === 2)
for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar)
ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
API_NAME = "diag";
DiagAPI = /** @class */
function() {
function DiagAPI2() {
function _logProxy(funcName) {
return function() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var logger = getGlobal("diag");
if (!logger)
return;
return logger[funcName].apply(logger, __spreadArray2([], __read2(args), false));
};
}
var self2 = this;
var setLogger = function(logger, optionsOrLogLevel) {
var _a2, _b, _c;
if (optionsOrLogLevel === void 0) {
optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
}
if (logger === self2) {
var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
self2.error((_a2 = err.stack) !== null && _a2 !== void 0 ? _a2 : err.message);
return false;
}
if (typeof optionsOrLogLevel === "number") {
optionsOrLogLevel = {
logLevel: optionsOrLogLevel
};
}
var oldLogger = getGlobal("diag");
var newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
var 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 registerGlobal("diag", newLogger, self2, true);
};
self2.setLogger = setLogger;
self2.disable = function() {
unregisterGlobal(API_NAME, self2);
};
self2.createComponentLogger = function(options) {
return new DiagComponentLogger(options);
};
self2.verbose = _logProxy("verbose");
self2.debug = _logProxy("debug");
self2.info = _logProxy("info");
self2.warn = _logProxy("warn");
self2.error = _logProxy("error");
}
DiagAPI2.instance = function() {
if (!this._instance) {
this._instance = new DiagAPI2();
}
return this._instance;
};
return DiagAPI2;
}();
}
});
// node_modules/@opentelemetry/api/build/esm/baggage/internal/baggage-impl.js
var __read3, __values, BaggageImpl;
var init_baggage_impl = __esm({
"node_modules/@opentelemetry/api/build/esm/baggage/internal/baggage-impl.js"() {
__read3 = function(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m)
return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
ar.push(r.value);
} catch (error) {
e = { error };
} finally {
try {
if (r && !r.done && (m = i["return"]))
m.call(i);
} finally {
if (e)
throw e.error;
}
}
return ar;
};
__values = function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m)
return m.call(o);
if (o && typeof o.length === "number")
return {
next: function() {
if (o && i >= o.length)
o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
BaggageImpl = /** @class */
function() {
function BaggageImpl2(entries) {
this._entries = entries ? new Map(entries) : /* @__PURE__ */ new Map();
}
BaggageImpl2.prototype.getEntry = function(key) {
var entry = this._entries.get(key);
if (!entry) {
return void 0;
}
return Object.assign({}, entry);
};
BaggageImpl2.prototype.getAllEntries = function() {
return Array.from(this._entries.entries()).map(function(_a2) {
var _b = __read3(_a2, 2), k = _b[0], v = _b[1];
return [k, v];
});
};
BaggageImpl2.prototype.setEntry = function(key, entry) {
var newBaggage = new BaggageImpl2(this._entries);
newBaggage._entries.set(key, entry);
return newBaggage;
};
BaggageImpl2.prototype.removeEntry = function(key) {
var newBaggage = new BaggageImpl2(this._entries);
newBaggage._entries.delete(key);
return newBaggage;
};
BaggageImpl2.prototype.removeEntries = function() {
var e_1, _a2;
var keys = [];
for (var _i = 0; _i < arguments.length; _i++) {
keys[_i] = arguments[_i];
}
var newBaggage = new BaggageImpl2(this._entries);
try {
for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
var key = keys_1_1.value;
newBaggage._entries.delete(key);
}
} catch (e_1_1) {
e_1 = { error: e_1_1 };
} finally {
try {
if (keys_1_1 && !keys_1_1.done && (_a2 = keys_1.return))
_a2.call(keys_1);
} finally {
if (e_1)
throw e_1.error;
}
}
return newBaggage;
};
BaggageImpl2.prototype.clear = function() {
return new BaggageImpl2();
};
return BaggageImpl2;
}();
}
});
// node_modules/@opentelemetry/api/build/esm/baggage/internal/symbol.js
var baggageEntryMetadataSymbol;
var init_symbol = __esm({
"node_modules/@opentelemetry/api/build/esm/baggage/internal/symbol.js"() {
baggageEntryMetadataSymbol = Symbol("BaggageEntryMetadata");
}
});
// node_modules/@opentelemetry/api/build/esm/baggage/utils.js
function createBaggage(entries) {
if (entries === void 0) {
entries = {};
}
return new BaggageImpl(new Map(Object.entries(entries)));
}
function baggageEntryMetadataFromString(str) {
if (typeof str !== "string") {
diag.error("Cannot create baggage metadata from unknown type: " + typeof str);
str = "";
}
return {
__TYPE__: baggageEntryMetadataSymbol,
toString: function() {
return str;
}
};
}
var diag;
var init_utils = __esm({
"node_modules/@opentelemetry/api/build/esm/baggage/utils.js"() {
init_diag();
init_baggage_impl();
init_symbol();
diag = DiagAPI.instance();
}
});
// node_modules/@opentelemetry/api/build/esm/context/context.js
function createContextKey(description) {
return Symbol.for(description);
}
var BaseContext, ROOT_CONTEXT;
var init_context = __esm({
"node_modules/@opentelemetry/api/build/esm/context/context.js"() {
BaseContext = /** @class */
function() {
function BaseContext2(parentContext) {
var self2 = this;
self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
self2.getValue = function(key) {
return self2._currentContext.get(key);
};
self2.setValue = function(key, value) {
var context2 = new BaseContext2(self2._currentContext);
context2._currentContext.set(key, value);
return context2;
};
self2.deleteValue = function(key) {
var context2 = new BaseContext2(self2._currentContext);
context2._currentContext.delete(key);
return context2;
};
}
return BaseContext2;
}();
ROOT_CONTEXT = new BaseContext();
}
});
// node_modules/@opentelemetry/api/build/esm/diag/consoleLogger.js
var consoleMap, DiagConsoleLogger;
var init_consoleLogger = __esm({
"node_modules/@opentelemetry/api/build/esm/diag/consoleLogger.js"() {
consoleMap = [
{ n: "error", c: "error" },
{ n: "warn", c: "warn" },
{ n: "info", c: "info" },
{ n: "debug", c: "debug" },
{ n: "verbose", c: "trace" }
];
DiagConsoleLogger = /** @class */
function() {
function DiagConsoleLogger2() {
function _consoleFunc(funcName) {
return function() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
if (console) {
var theFunc = console[funcName];
if (typeof theFunc !== "function") {
theFunc = console.log;
}
if (typeof theFunc === "function") {
return theFunc.apply(console, args);
}
}
};
}
for (var i = 0; i < consoleMap.length; i++) {
this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);
}
}
return DiagConsoleLogger2;
}();
}
});
// node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js
function createNoopMeter() {
return NOOP_METER;
}
var __extends, NoopMeter, NoopMetric, NoopCounterMetric, NoopUpDownCounterMetric, NoopHistogramMetric, NoopObservableMetric, NoopObservableCounterMetric, NoopObservableGaugeMetric, NoopObservableUpDownCounterMetric, NOOP_METER, NOOP_COUNTER_METRIC, NOOP_HISTOGRAM_METRIC, NOOP_UP_DOWN_COUNTER_METRIC, NOOP_OBSERVABLE_COUNTER_METRIC, NOOP_OBSERVABLE_GAUGE_METRIC, NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
var init_NoopMeter = __esm({
"node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js"() {
__extends = function() {
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
d2.__proto__ = b2;
} || function(d2, b2) {
for (var p in b2)
if (Object.prototype.hasOwnProperty.call(b2, p))
d2[p] = b2[p];
};
return extendStatics(d, b);
};
return function(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
}();
NoopMeter = /** @class */
function() {
function NoopMeter2() {
}
NoopMeter2.prototype.createHistogram = function(_name, _options) {
return NOOP_HISTOGRAM_METRIC;
};
NoopMeter2.prototype.createCounter = function(_name, _options) {
return NOOP_COUNTER_METRIC;
};
NoopMeter2.prototype.createUpDownCounter = function(_name, _options) {
return NOOP_UP_DOWN_COUNTER_METRIC;
};
NoopMeter2.prototype.createObservableGauge = function(_name, _options) {
return NOOP_OBSERVABLE_GAUGE_METRIC;
};
NoopMeter2.prototype.createObservableCounter = function(_name, _options) {
return NOOP_OBSERVABLE_COUNTER_METRIC;
};
NoopMeter2.prototype.createObservableUpDownCounter = function(_name, _options) {
return NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
};
NoopMeter2.prototype.addBatchObservableCallback = function(_callback, _observables) {
};
NoopMeter2.prototype.removeBatchObservableCallback = function(_callback) {
};
return NoopMeter2;
}();
NoopMetric = /** @class */
function() {
function NoopMetric2() {
}
return NoopMetric2;
}();
NoopCounterMetric = /** @class */
function(_super) {
__extends(NoopCounterMetric2, _super);
function NoopCounterMetric2() {
return _super !== null && _super.apply(this, arguments) || this;
}
NoopCounterMetric2.prototype.add = function(_value, _attributes) {
};
return NoopCounterMetric2;
}(NoopMetric);
NoopUpDownCounterMetric = /** @class */
function(_super) {
__extends(NoopUpDownCounterMetric2, _super);
function NoopUpDownCounterMetric2() {
return _super !== null && _super.apply(this, arguments) || this;
}
NoopUpDownCounterMetric2.prototype.add = function(_value, _attributes) {
};
return NoopUpDownCounterMetric2;
}(NoopMetric);
NoopHistogramMetric = /** @class */
function(_super) {
__extends(NoopHistogramMetric2, _super);
function NoopHistogramMetric2() {
return _super !== null && _super.apply(this, arguments) || this;
}
NoopHistogramMetric2.prototype.record = function(_value, _attributes) {
};
return NoopHistogramMetric2;
}(NoopMetric);
NoopObservableMetric = /** @class */
function() {
function NoopObservableMetric2() {
}
NoopObservableMetric2.prototype.addCallback = function(_callback) {
};
NoopObservableMetric2.prototype.removeCallback = function(_callback) {
};
return NoopObservableMetric2;
}();
NoopObservableCounterMetric = /** @class */
function(_super) {
__extends(NoopObservableCounterMetric2, _super);
function NoopObservableCounterMetric2() {
return _super !== null && _super.apply(this, arguments) || this;
}
return NoopObservableCounterMetric2;
}(NoopObservableMetric);
NoopObservableGaugeMetric = /** @class */
function(_super) {
__extends(NoopObservableGaugeMetric2, _super);
function NoopObservableGaugeMetric2() {
return _super !== null && _super.apply(this, arguments) || this;
}
return NoopObservableGaugeMetric2;
}(NoopObservableMetric);
NoopObservableUpDownCounterMetric = /** @class */
function(_super) {
__extends(NoopObservableUpDownCounterMetric2, _super);
function NoopObservableUpDownCounterMetric2() {
return _super !== null && _super.apply(this, arguments) || this;
}
return NoopObservableUpDownCounterMetric2;
}(NoopObservableMetric);
NOOP_METER = new NoopMeter();
NOOP_COUNTER_METRIC = new NoopCounterMetric();
NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric();
NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric();
NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();
NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();
NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();
}
});
// node_modules/@opentelemetry/api/build/esm/metrics/Metric.js
var ValueType;
var init_Metric = __esm({
"node_modules/@opentelemetry/api/build/esm/metrics/Metric.js"() {
(function(ValueType2) {
ValueType2[ValueType2["INT"] = 0] = "INT";
ValueType2[ValueType2["DOUBLE"] = 1] = "DOUBLE";
})(ValueType || (ValueType = {}));
}
});
// node_modules/@opentelemetry/api/build/esm/propagation/TextMapPropagator.js
var defaultTextMapGetter, defaultTextMapSetter;
var init_TextMapPropagator = __esm({
"node_modules/@opentelemetry/api/build/esm/propagation/TextMapPropagator.js"() {
defaultTextMapGetter = {
get: function(carrier, key) {
if (carrier == null) {
return void 0;
}
return carrier[key];
},
keys: function(carrier) {
if (carrier == null) {
return [];
}
return Object.keys(carrier);
}
};
defaultTextMapSetter = {
set: function(carrier, key, value) {
if (carrier == null) {
return;
}
carrier[key] = value;
}
};
}
});
// node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
var __read4, __spreadArray3, NoopContextManager;
var init_NoopContextManager = __esm({
"node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js"() {
init_context();
__read4 = function(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m)
return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
ar.push(r.value);
} catch (error) {
e = { error };
} finally {
try {
if (r && !r.done && (m = i["return"]))
m.call(i);
} finally {
if (e)
throw e.error;
}
}
return ar;
};
__spreadArray3 = function(to, from, pack) {
if (pack || arguments.length === 2)
for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar)
ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
NoopContextManager = /** @class */
function() {
function NoopContextManager2() {
}
NoopContextManager2.prototype.active = function() {
return ROOT_CONTEXT;
};
NoopContextManager2.prototype.with = function(_context, fn, thisArg) {
var args = [];
for (var _i = 3; _i < arguments.length; _i++) {
args[_i - 3] = arguments[_i];
}
return fn.call.apply(fn, __spreadArray3([thisArg], __read4(args), false));
};
NoopContextManager2.prototype.bind = function(_context, target) {
return target;
};
NoopContextManager2.prototype.enable = function() {
return this;
};
NoopContextManager2.prototype.disable = function() {
return this;
};
return NoopContextManager2;
}();
}
});
// node_modules/@opentelemetry/api/build/esm/api/context.js
var __read5, __spreadArray4, API_NAME2, NOOP_CONTEXT_MANAGER, ContextAPI;
var init_context2 = __esm({
"node_modules/@opentelemetry/api/build/esm/api/context.js"() {
init_NoopContextManager();
init_global_utils();
init_diag();
__read5 = function(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m)
return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
ar.push(r.value);
} catch (error) {
e = { error };
} finally {
try {
if (r && !r.done && (m = i["return"]))
m.call(i);
} finally {
if (e)
throw e.error;
}
}
return ar;
};
__spreadArray4 = function(to, from, pack) {
if (pack || arguments.length === 2)
for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar)
ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
API_NAME2 = "context";
NOOP_CONTEXT_MANAGER = new NoopContextManager();
ContextAPI = /** @class */
function() {
function ContextAPI2() {
}
ContextAPI2.getInstance = function() {
if (!this._instance) {
this._instance = new ContextAPI2();
}
return this._instance;
};
ContextAPI2.prototype.setGlobalContextManager = function(contextManager) {
return registerGlobal(API_NAME2, contextManager, DiagAPI.instance());
};
ContextAPI2.prototype.active = function() {
return this._getContextManager().active();
};
ContextAPI2.prototype.with = function(context2, fn, thisArg) {
var _a2;
var args = [];
for (var _i = 3; _i < arguments.length; _i++) {
args[_i - 3] = arguments[_i];
}
return (_a2 = this._getContextManager()).with.apply(_a2, __spreadArray4([context2, fn, thisArg], __read5(args), false));
};
ContextAPI2.prototype.bind = function(context2, target) {
return this._getContextManager().bind(context2, target);
};
ContextAPI2.prototype._getContextManager = function() {
return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
};
ContextAPI2.prototype.disable = function() {
this._getContextManager().disable();
unregisterGlobal(API_NAME2, DiagAPI.instance());
};
return ContextAPI2;
}();
}
});
// node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
var TraceFlags;
var init_trace_flags = __esm({
"node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js"() {
(function(TraceFlags2) {
TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
})(TraceFlags || (TraceFlags = {}));
}
});
// node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js
var INVALID_SPANID, INVALID_TRACEID, INVALID_SPAN_CONTEXT;
var init_invalid_span_constants = __esm({
"node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js"() {
init_trace_flags();
INVALID_SPANID = "0000000000000000";
INVALID_TRACEID = "00000000000000000000000000000000";
INVALID_SPAN_CONTEXT = {
traceId: INVALID_TRACEID,
spanId: INVALID_SPANID,
traceFlags: TraceFlags.NONE
};
}
});
// node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
var NonRecordingSpan;
var init_NonRecordingSpan = __esm({
"node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js"() {
init_invalid_span_constants();
NonRecordingSpan = /** @class */
function() {
function NonRecordingSpan2(_spanContext) {
if (_spanContext === void 0) {
_spanContext = INVALID_SPAN_CONTEXT;
}
this._spanContext = _spanContext;
}
NonRecordingSpan2.prototype.spanContext = function() {
return this._spanContext;
};
NonRecordingSpan2.prototype.setAttribute = function(_key, _value) {
return this;
};
NonRecordingSpan2.prototype.setAttributes = function(_attributes) {
return this;
};
NonRecordingSpan2.prototype.addEvent = function(_name, _attributes) {
return this;
};
NonRecordingSpan2.prototype.setStatus = function(_status) {
return this;
};
NonRecordingSpan2.prototype.updateName = function(_name) {
return this;
};
NonRecordingSpan2.prototype.end = function(_endTime) {
};
NonRecordingSpan2.prototype.isRecording = function() {
return false;
};
NonRecordingSpan2.prototype.recordException = function(_exception, _time) {
};
return NonRecordingSpan2;
}();
}
});
// node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
function getSpan(context2) {
return context2.getValue(SPAN_KEY) || void 0;
}
function getActiveSpan() {
return getSpan(ContextAPI.getInstance().active());
}
function setSpan(context2, span) {
return context2.setValue(SPAN_KEY, span);
}
function deleteSpan(context2) {
return context2.deleteValue(SPAN_KEY);
}
function setSpanContext(context2, spanContext) {
return setSpan(context2, new NonRecordingSpan(spanContext));
}
function getSpanContext(context2) {
var _a2;
return (_a2 = getSpan(context2)) === null || _a2 === void 0 ? void 0 : _a2.spanContext();
}
var SPAN_KEY;
var init_context_utils = __esm({
"node_modules/@opentelemetry/api/build/esm/trace/context-utils.js"() {
init_context();
init_NonRecordingSpan();
init_context2();
SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
}
});
// node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
function isValidTraceId(traceId) {
return VALID_TRACEID_REGEX.test(traceId) && traceId !== INVALID_TRACEID;
}
function isValidSpanId(spanId) {
return VALID_SPANID_REGEX.test(spanId) && spanId !== INVALID_SPANID;
}
function isSpanContextValid(spanContext) {
return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
}
function wrapSpanContext(spanContext) {
return new NonRecordingSpan(spanContext);
}
var VALID_TRACEID_REGEX, VALID_SPANID_REGEX;
var init_spancontext_utils = __esm({
"node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js"() {
init_invalid_span_constants();
init_NonRecordingSpan();
VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
}
});
// node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
function isSpanContext(spanContext) {
return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
}
var contextApi, NoopTracer;
var init_NoopTracer = __esm({
"node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js"() {
init_context2();
init_context_utils();
init_NonRecordingSpan();
init_spancontext_utils();
contextApi = ContextAPI.getInstance();
NoopTracer = /** @class */
function() {
function NoopTracer2() {
}
NoopTracer2.prototype.startSpan = function(name, options, context2) {
if (context2 === void 0) {
context2 = contextApi.active();
}
var root = Boolean(options === null || options === void 0 ? void 0 : options.root);
if (root) {
return new NonRecordingSpan();
}
var parentFromContext = context2 && getSpanContext(context2);
if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
return new NonRecordingSpan(parentFromContext);
} else {
return new NonRecordingSpan();
}
};
NoopTracer2.prototype.startActiveSpan = function(name, arg2, arg3, arg4) {
var opts;
var ctx;
var 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;
}
var parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
var span = this.startSpan(name, opts, parentContext);
var contextWithSpanSet = setSpan(parentContext, span);
return contextApi.with(contextWithSpanSet, fn, void 0, span);
};
return NoopTracer2;
}();
}
});
// node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
var NOOP_TRACER, ProxyTracer;
var init_ProxyTracer = __esm({
"node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js"() {
init_NoopTracer();
NOOP_TRACER = new NoopTracer();
ProxyTracer = /** @class */
function() {
function ProxyTracer2(_provider, name, version, options) {
this._provider = _provider;
this.name = name;
this.version = version;
this.options = options;
}
ProxyTracer2.prototype.startSpan = function(name, options, context2) {
return this._getTracer().startSpan(name, options, context2);
};
ProxyTracer2.prototype.startActiveSpan = function(_name, _options, _context, _fn) {
var tracer = this._getTracer();
return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
};
ProxyTracer2.prototype._getTracer = function() {
if (this._delegate) {
return this._delegate;
}
var tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
if (!tracer) {
return NOOP_TRACER;
}
this._delegate = tracer;
return this._delegate;
};
return ProxyTracer2;
}();
}
});
// node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
var NoopTracerProvider;
var init_NoopTracerProvider = __esm({
"node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js"() {
init_NoopTracer();
NoopTracerProvider = /** @class */
function() {
function NoopTracerProvider2() {
}
NoopTracerProvider2.prototype.getTracer = function(_name, _version, _options) {
return new NoopTracer();
};
return NoopTracerProvider2;
}();
}
});
// node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
var NOOP_TRACER_PROVIDER, ProxyTracerProvider;
var init_ProxyTracerProvider = __esm({
"node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js"() {
init_ProxyTracer();
init_NoopTracerProvider();
NOOP_TRACER_PROVIDER = new NoopTracerProvider();
ProxyTracerProvider = /** @class */
function() {
function ProxyTracerProvider2() {
}
ProxyTracerProvider2.prototype.getTracer = function(name, version, options) {
var _a2;
return (_a2 = this.getDelegateTracer(name, version, options)) !== null && _a2 !== void 0 ? _a2 : new ProxyTracer(this, name, version, options);
};
ProxyTracerProvider2.prototype.getDelegate = function() {
var _a2;
return (_a2 = this._delegate) !== null && _a2 !== void 0 ? _a2 : NOOP_TRACER_PROVIDER;
};
ProxyTracerProvider2.prototype.setDelegate = function(delegate) {
this._delegate = delegate;
};
ProxyTracerProvider2.prototype.getDelegateTracer = function(name, version, options) {
var _a2;
return (_a2 = this._delegate) === null || _a2 === void 0 ? void 0 : _a2.getTracer(name, version, options);
};
return ProxyTracerProvider2;
}();
}
});
// node_modules/@opentelemetry/api/build/esm/trace/SamplingResult.js
var SamplingDecision;
var init_SamplingResult = __esm({
"node_modules/@opentelemetry/api/build/esm/trace/SamplingResult.js"() {
(function(SamplingDecision3) {
SamplingDecision3[SamplingDecision3["NOT_RECORD"] = 0] = "NOT_RECORD";
SamplingDecision3[SamplingDecision3["RECORD"] = 1] = "RECORD";
SamplingDecision3[SamplingDecision3["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
})(SamplingDecision || (SamplingDecision = {}));
}
});
// node_modules/@opentelemetry/api/build/esm/trace/span_kind.js
var SpanKind;
var init_span_kind = __esm({
"node_modules/@opentelemetry/api/build/esm/trace/span_kind.js"() {
(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 || (SpanKind = {}));
}
});
// node_modules/@opentelemetry/api/build/esm/trace/status.js
var SpanStatusCode;
var init_status = __esm({
"node_modules/@opentelemetry/api/build/esm/trace/status.js"() {
(function(SpanStatusCode2) {
SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
})(SpanStatusCode || (SpanStatusCode = {}));
}
});
// node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-validators.js
function validateKey(key) {
return VALID_KEY_REGEX.test(key);
}
function validateValue(value) {
return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
}
var VALID_KEY_CHAR_RANGE, VALID_KEY, VALID_VENDOR_KEY, VALID_KEY_REGEX, VALID_VALUE_BASE_REGEX, INVALID_VALUE_COMMA_EQUAL_REGEX;
var init_tracestate_validators = __esm({
"node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-validators.js"() {
VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
VALID_KEY = "[a-z]" + VALID_KEY_CHAR_RANGE + "{0,255}";
VALID_VENDOR_KEY = "[a-z0-9]" + VALID_KEY_CHAR_RANGE + "{0,240}@[a-z]" + VALID_KEY_CHAR_RANGE + "{0,13}";
VALID_KEY_REGEX = new RegExp("^(?:" + VALID_KEY + "|" + VALID_VENDOR_KEY + ")$");
VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
}
});
// node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-impl.js
var MAX_TRACE_STATE_ITEMS, MAX_TRACE_STATE_LEN, LIST_MEMBERS_SEPARATOR, LIST_MEMBER_KEY_VALUE_SPLITTER, TraceStateImpl;
var init_tracestate_impl = __esm({
"node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-impl.js"() {
init_tracestate_validators();
MAX_TRACE_STATE_ITEMS = 32;
MAX_TRACE_STATE_LEN = 512;
LIST_MEMBERS_SEPARATOR = ",";
LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
TraceStateImpl = /** @class */
function() {
function TraceStateImpl2(rawTraceState) {
this._internalState = /* @__PURE__ */ new Map();
if (rawTraceState)
this._parse(rawTraceState);
}
TraceStateImpl2.prototype.set = function(key, value) {
var traceState = this._clone();
if (traceState._internalState.has(key)) {
traceState._internalState.delete(key);
}
traceState._internalState.set(key, value);
return traceState;
};
TraceStateImpl2.prototype.unset = function(key) {
var traceState = this._clone();
traceState._internalState.delete(key);
return traceState;
};
TraceStateImpl2.prototype.get = function(key) {
return this._internalState.get(key);
};
TraceStateImpl2.prototype.serialize = function() {
var _this = this;
return this._keys().reduce(function(agg, key) {
agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + _this.get(key));
return agg;
}, []).join(LIST_MEMBERS_SEPARATOR);
};
TraceStateImpl2.prototype._parse = function(rawTraceState) {
if (rawTraceState.length > MAX_TRACE_STATE_LEN)
return;
this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reverse().reduce(function(agg, part) {
var listMember = part.trim();
var i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
if (i !== -1) {
var key = listMember.slice(0, i);
var value = listMember.slice(i + 1, part.length);
if (validateKey(key) && 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));
}
};
TraceStateImpl2.prototype._keys = function() {
return Array.from(this._internalState.keys()).reverse();
};
TraceStateImpl2.prototype._clone = function() {
var traceState = new TraceStateImpl2();
traceState._internalState = new Map(this._internalState);
return traceState;
};
return TraceStateImpl2;
}();
}
});
// node_modules/@opentelemetry/api/build/esm/trace/internal/utils.js
function createTraceState(rawTraceState) {
return new TraceStateImpl(rawTraceState);
}
var init_utils2 = __esm({
"node_modules/@opentelemetry/api/build/esm/trace/internal/utils.js"() {
init_tracestate_impl();
}
});
// node_modules/@opentelemetry/api/build/esm/context-api.js
var context;
var init_context_api = __esm({
"node_modules/@opentelemetry/api/build/esm/context-api.js"() {
init_context2();
context = ContextAPI.getInstance();
}
});
// node_modules/@opentelemetry/api/build/esm/diag-api.js
var diag2;
var init_diag_api = __esm({
"node_modules/@opentelemetry/api/build/esm/diag-api.js"() {
init_diag();
diag2 = DiagAPI.instance();
}
});
// node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js
var NoopMeterProvider, NOOP_METER_PROVIDER;
var init_NoopMeterProvider = __esm({
"node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js"() {
init_NoopMeter();
NoopMeterProvider = /** @class */
function() {
function NoopMeterProvider2() {
}
NoopMeterProvider2.prototype.getMeter = function(_name, _version, _options) {
return NOOP_METER;
};
return NoopMeterProvider2;
}();
NOOP_METER_PROVIDER = new NoopMeterProvider();
}
});
// node_modules/@opentelemetry/api/build/esm/api/metrics.js
var API_NAME3, MetricsAPI;
var init_metrics = __esm({
"node_modules/@opentelemetry/api/build/esm/api/metrics.js"() {
init_NoopMeterProvider();
init_global_utils();
init_diag();
API_NAME3 = "metrics";
MetricsAPI = /** @class */
function() {
function MetricsAPI2() {
}
MetricsAPI2.getInstance = function() {
if (!this._instance) {
this._instance = new MetricsAPI2();
}
return this._instance;
};
MetricsAPI2.prototype.setGlobalMeterProvider = function(provider) {
return registerGlobal(API_NAME3, provider, DiagAPI.instance());
};
MetricsAPI2.prototype.getMeterProvider = function() {
return getGlobal(API_NAME3) || NOOP_METER_PROVIDER;
};
MetricsAPI2.prototype.getMeter = function(name, version, options) {
return this.getMeterProvider().getMeter(name, version, options);
};
MetricsAPI2.prototype.disable = function() {
unregisterGlobal(API_NAME3, DiagAPI.instance());
};
return MetricsAPI2;
}();
}
});
// node_modules/@opentelemetry/api/build/esm/metrics-api.js
var metrics;
var init_metrics_api = __esm({
"node_modules/@opentelemetry/api/build/esm/metrics-api.js"() {
init_metrics();
metrics = MetricsAPI.getInstance();
}
});
// node_modules/@opentelemetry/api/build/esm/propagation/NoopTextMapPropagator.js
var NoopTextMapPropagator;
var init_NoopTextMapPropagator = __esm({
"node_modules/@