@otel-test-runner/bun-test
Version:
Bun Test Runner with Open telemetry support for auto-instrumentation with dagger
1,327 lines (1,252 loc) • 1.96 MB
JavaScript
import { createRequire } from "node:module";
var __create = Object.create;
var __getProtoOf = Object.getPrototypeOf;
var __defProp = Object.defineProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __toESM = (mod2, isNodeMode, target) => {
target = mod2 != null ? __create(__getProtoOf(mod2)) : {};
const to = isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target;
for (let key of __getOwnPropNames(mod2))
if (!__hasOwnProp.call(to, key))
__defProp(to, key, {
get: () => mod2[key],
enumerable: true
});
return to;
};
var __commonJS = (cb, mod2) => () => (mod2 || cb((mod2 = { exports: {} }).exports, mod2), mod2.exports);
var __require = /* @__PURE__ */ createRequire(import.meta.url);
// node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js
var require_globalThis4 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2._globalThis = undefined;
exports2._globalThis = typeof globalThis === "object" ? globalThis : global;
});
// node_modules/@opentelemetry/api/build/src/platform/node/index.js
var require_node17 = __commonJS((exports2) => {
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
if (k2 === undefined)
k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() {
return m[k];
} });
} : function(o, m, k, k2) {
if (k2 === undefined)
k2 = k;
o[k2] = m[k];
});
var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
for (var p in m)
if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
__createBinding(exports3, m, p);
};
Object.defineProperty(exports2, "__esModule", { value: true });
__exportStar(require_globalThis4(), exports2);
});
// node_modules/@opentelemetry/api/build/src/platform/index.js
var require_platform16 = __commonJS((exports2) => {
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
if (k2 === undefined)
k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() {
return m[k];
} });
} : function(o, m, k, k2) {
if (k2 === undefined)
k2 = k;
o[k2] = m[k];
});
var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
for (var p in m)
if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
__createBinding(exports3, m, p);
};
Object.defineProperty(exports2, "__esModule", { value: true });
__exportStar(require_node17(), exports2);
});
// node_modules/@opentelemetry/api/build/src/version.js
var require_version5 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.VERSION = undefined;
exports2.VERSION = "1.9.0";
});
// node_modules/@opentelemetry/api/build/src/internal/semver.js
var require_semver3 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.isCompatible = exports2._makeCompatibilityCheck = undefined;
var version_1 = require_version5();
var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
function _makeCompatibilityCheck(ownVersion) {
const acceptedVersions = new Set([ownVersion]);
const rejectedVersions = 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);
};
}
exports2._makeCompatibilityCheck = _makeCompatibilityCheck;
exports2.isCompatible = _makeCompatibilityCheck(version_1.VERSION);
});
// node_modules/@opentelemetry/api/build/src/internal/global-utils.js
var require_global_utils3 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.unregisterGlobal = exports2.getGlobal = exports2.registerGlobal = undefined;
var platform_1 = require_platform16();
var version_1 = require_version5();
var semver_1 = require_semver3();
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 !== undefined ? _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;
}
exports2.registerGlobal = registerGlobal;
function getGlobal(type) {
var _a, _b;
const globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === undefined ? undefined : _a.version;
if (!globalVersion || !(0, semver_1.isCompatible)(globalVersion)) {
return;
}
return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === undefined ? undefined : _b[type];
}
exports2.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];
}
}
exports2.unregisterGlobal = unregisterGlobal;
});
// node_modules/@opentelemetry/api/build/src/diag/ComponentLogger.js
var require_ComponentLogger2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.DiagComponentLogger = undefined;
var global_utils_1 = require_global_utils3();
class DiagComponentLogger {
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);
}
}
exports2.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_types8 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.DiagLogLevel = undefined;
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 = exports2.DiagLogLevel || (exports2.DiagLogLevel = {}));
});
// node_modules/@opentelemetry/api/build/src/diag/internal/logLevelLogger.js
var require_logLevelLogger2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.createLogLevelDiagLogger = undefined;
var types_1 = require_types8();
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)
};
}
exports2.createLogLevelDiagLogger = createLogLevelDiagLogger;
});
// node_modules/@opentelemetry/api/build/src/api/diag.js
var require_diag2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.DiagAPI = undefined;
var ComponentLogger_1 = require_ComponentLogger2();
var logLevelLogger_1 = require_logLevelLogger2();
var types_1 = require_types8();
var global_utils_1 = require_global_utils3();
var API_NAME = "diag";
class DiagAPI {
constructor() {
function _logProxy(funcName) {
return function(...args) {
const logger = (0, global_utils_1.getGlobal)("diag");
if (!logger)
return;
return logger[funcName](...args);
};
}
const self2 = this;
const setLogger = (logger, optionsOrLogLevel = { logLevel: types_1.DiagLogLevel.INFO }) => {
var _a, _b, _c;
if (logger === self2) {
const err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
self2.error((_a = err.stack) !== null && _a !== undefined ? _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 !== undefined ? _b : types_1.DiagLogLevel.INFO, logger);
if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
const stack = (_c = new Error().stack) !== null && _c !== undefined ? _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, self2, true);
};
self2.setLogger = setLogger;
self2.disable = () => {
(0, global_utils_1.unregisterGlobal)(API_NAME, self2);
};
self2.createComponentLogger = (options) => {
return new ComponentLogger_1.DiagComponentLogger(options);
};
self2.verbose = _logProxy("verbose");
self2.debug = _logProxy("debug");
self2.info = _logProxy("info");
self2.warn = _logProxy("warn");
self2.error = _logProxy("error");
}
static instance() {
if (!this._instance) {
this._instance = new DiagAPI;
}
return this._instance;
}
}
exports2.DiagAPI = DiagAPI;
});
// node_modules/@opentelemetry/api/build/src/baggage/internal/baggage-impl.js
var require_baggage_impl2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.BaggageImpl = undefined;
class BaggageImpl {
constructor(entries) {
this._entries = entries ? new Map(entries) : new Map;
}
getEntry(key) {
const entry = this._entries.get(key);
if (!entry) {
return;
}
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;
}
}
exports2.BaggageImpl = BaggageImpl;
});
// node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.js
var require_symbol2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.baggageEntryMetadataSymbol = undefined;
exports2.baggageEntryMetadataSymbol = Symbol("BaggageEntryMetadata");
});
// node_modules/@opentelemetry/api/build/src/baggage/utils.js
var require_utils12 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.baggageEntryMetadataFromString = exports2.createBaggage = undefined;
var diag_1 = require_diag2();
var baggage_impl_1 = require_baggage_impl2();
var symbol_1 = require_symbol2();
var diag = diag_1.DiagAPI.instance();
function createBaggage(entries = {}) {
return new baggage_impl_1.BaggageImpl(new Map(Object.entries(entries)));
}
exports2.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;
}
};
}
exports2.baggageEntryMetadataFromString = baggageEntryMetadataFromString;
});
// node_modules/@opentelemetry/api/build/src/context/context.js
var require_context3 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ROOT_CONTEXT = exports2.createContextKey = undefined;
function createContextKey(description) {
return Symbol.for(description);
}
exports2.createContextKey = createContextKey;
class BaseContext {
constructor(parentContext) {
const self2 = this;
self2._currentContext = parentContext ? new Map(parentContext) : new Map;
self2.getValue = (key) => self2._currentContext.get(key);
self2.setValue = (key, value) => {
const context = new BaseContext(self2._currentContext);
context._currentContext.set(key, value);
return context;
};
self2.deleteValue = (key) => {
const context = new BaseContext(self2._currentContext);
context._currentContext.delete(key);
return context;
};
}
}
exports2.ROOT_CONTEXT = new BaseContext;
});
// node_modules/@opentelemetry/api/build/src/diag/consoleLogger.js
var require_consoleLogger2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.DiagConsoleLogger = undefined;
var consoleMap = [
{ n: "error", c: "error" },
{ n: "warn", c: "warn" },
{ n: "info", c: "info" },
{ n: "debug", c: "debug" },
{ n: "verbose", c: "trace" }
];
class DiagConsoleLogger {
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);
}
}
}
exports2.DiagConsoleLogger = DiagConsoleLogger;
});
// node_modules/@opentelemetry/api/build/src/metrics/NoopMeter.js
var require_NoopMeter2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.createNoopMeter = exports2.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = exports2.NOOP_OBSERVABLE_GAUGE_METRIC = exports2.NOOP_OBSERVABLE_COUNTER_METRIC = exports2.NOOP_UP_DOWN_COUNTER_METRIC = exports2.NOOP_HISTOGRAM_METRIC = exports2.NOOP_GAUGE_METRIC = exports2.NOOP_COUNTER_METRIC = exports2.NOOP_METER = exports2.NoopObservableUpDownCounterMetric = exports2.NoopObservableGaugeMetric = exports2.NoopObservableCounterMetric = exports2.NoopObservableMetric = exports2.NoopHistogramMetric = exports2.NoopGaugeMetric = exports2.NoopUpDownCounterMetric = exports2.NoopCounterMetric = exports2.NoopMetric = exports2.NoopMeter = undefined;
class NoopMeter {
constructor() {}
createGauge(_name, _options) {
return exports2.NOOP_GAUGE_METRIC;
}
createHistogram(_name, _options) {
return exports2.NOOP_HISTOGRAM_METRIC;
}
createCounter(_name, _options) {
return exports2.NOOP_COUNTER_METRIC;
}
createUpDownCounter(_name, _options) {
return exports2.NOOP_UP_DOWN_COUNTER_METRIC;
}
createObservableGauge(_name, _options) {
return exports2.NOOP_OBSERVABLE_GAUGE_METRIC;
}
createObservableCounter(_name, _options) {
return exports2.NOOP_OBSERVABLE_COUNTER_METRIC;
}
createObservableUpDownCounter(_name, _options) {
return exports2.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
}
addBatchObservableCallback(_callback, _observables) {}
removeBatchObservableCallback(_callback) {}
}
exports2.NoopMeter = NoopMeter;
class NoopMetric {
}
exports2.NoopMetric = NoopMetric;
class NoopCounterMetric extends NoopMetric {
add(_value, _attributes) {}
}
exports2.NoopCounterMetric = NoopCounterMetric;
class NoopUpDownCounterMetric extends NoopMetric {
add(_value, _attributes) {}
}
exports2.NoopUpDownCounterMetric = NoopUpDownCounterMetric;
class NoopGaugeMetric extends NoopMetric {
record(_value, _attributes) {}
}
exports2.NoopGaugeMetric = NoopGaugeMetric;
class NoopHistogramMetric extends NoopMetric {
record(_value, _attributes) {}
}
exports2.NoopHistogramMetric = NoopHistogramMetric;
class NoopObservableMetric {
addCallback(_callback) {}
removeCallback(_callback) {}
}
exports2.NoopObservableMetric = NoopObservableMetric;
class NoopObservableCounterMetric extends NoopObservableMetric {
}
exports2.NoopObservableCounterMetric = NoopObservableCounterMetric;
class NoopObservableGaugeMetric extends NoopObservableMetric {
}
exports2.NoopObservableGaugeMetric = NoopObservableGaugeMetric;
class NoopObservableUpDownCounterMetric extends NoopObservableMetric {
}
exports2.NoopObservableUpDownCounterMetric = NoopObservableUpDownCounterMetric;
exports2.NOOP_METER = new NoopMeter;
exports2.NOOP_COUNTER_METRIC = new NoopCounterMetric;
exports2.NOOP_GAUGE_METRIC = new NoopGaugeMetric;
exports2.NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric;
exports2.NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric;
exports2.NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric;
exports2.NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric;
exports2.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric;
function createNoopMeter() {
return exports2.NOOP_METER;
}
exports2.createNoopMeter = createNoopMeter;
});
// node_modules/@opentelemetry/api/build/src/metrics/Metric.js
var require_Metric2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ValueType = undefined;
var ValueType;
(function(ValueType2) {
ValueType2[ValueType2["INT"] = 0] = "INT";
ValueType2[ValueType2["DOUBLE"] = 1] = "DOUBLE";
})(ValueType = exports2.ValueType || (exports2.ValueType = {}));
});
// node_modules/@opentelemetry/api/build/src/propagation/TextMapPropagator.js
var require_TextMapPropagator2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.defaultTextMapSetter = exports2.defaultTextMapGetter = undefined;
exports2.defaultTextMapGetter = {
get(carrier, key) {
if (carrier == null) {
return;
}
return carrier[key];
},
keys(carrier) {
if (carrier == null) {
return [];
}
return Object.keys(carrier);
}
};
exports2.defaultTextMapSetter = {
set(carrier, key, value) {
if (carrier == null) {
return;
}
carrier[key] = value;
}
};
});
// node_modules/@opentelemetry/api/build/src/context/NoopContextManager.js
var require_NoopContextManager2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.NoopContextManager = undefined;
var context_1 = require_context3();
class NoopContextManager {
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;
}
}
exports2.NoopContextManager = NoopContextManager;
});
// node_modules/@opentelemetry/api/build/src/api/context.js
var require_context5 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ContextAPI = undefined;
var NoopContextManager_1 = require_NoopContextManager2();
var global_utils_1 = require_global_utils3();
var diag_1 = require_diag2();
var API_NAME = "context";
var NOOP_CONTEXT_MANAGER = new NoopContextManager_1.NoopContextManager;
class ContextAPI {
constructor() {}
static getInstance() {
if (!this._instance) {
this._instance = new ContextAPI;
}
return this._instance;
}
setGlobalContextManager(contextManager) {
return (0, global_utils_1.registerGlobal)(API_NAME, contextManager, diag_1.DiagAPI.instance());
}
active() {
return this._getContextManager().active();
}
with(context, fn, thisArg, ...args) {
return this._getContextManager().with(context, fn, thisArg, ...args);
}
bind(context, target) {
return this._getContextManager().bind(context, target);
}
_getContextManager() {
return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_CONTEXT_MANAGER;
}
disable() {
this._getContextManager().disable();
(0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
}
}
exports2.ContextAPI = ContextAPI;
});
// node_modules/@opentelemetry/api/build/src/trace/trace_flags.js
var require_trace_flags2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.TraceFlags = undefined;
var TraceFlags;
(function(TraceFlags2) {
TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
})(TraceFlags = exports2.TraceFlags || (exports2.TraceFlags = {}));
});
// node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.js
var require_invalid_span_constants2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.INVALID_SPAN_CONTEXT = exports2.INVALID_TRACEID = exports2.INVALID_SPANID = undefined;
var trace_flags_1 = require_trace_flags2();
exports2.INVALID_SPANID = "0000000000000000";
exports2.INVALID_TRACEID = "00000000000000000000000000000000";
exports2.INVALID_SPAN_CONTEXT = {
traceId: exports2.INVALID_TRACEID,
spanId: exports2.INVALID_SPANID,
traceFlags: trace_flags_1.TraceFlags.NONE
};
});
// node_modules/@opentelemetry/api/build/src/trace/NonRecordingSpan.js
var require_NonRecordingSpan2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.NonRecordingSpan = undefined;
var invalid_span_constants_1 = require_invalid_span_constants2();
class NonRecordingSpan {
constructor(_spanContext = invalid_span_constants_1.INVALID_SPAN_CONTEXT) {
this._spanContext = _spanContext;
}
spanContext() {
return this._spanContext;
}
setAttribute(_key, _value) {
return this;
}
setAttributes(_attributes) {
return this;
}
addEvent(_name, _attributes) {
return this;
}
addLink(_link) {
return this;
}
addLinks(_links) {
return this;
}
setStatus(_status) {
return this;
}
updateName(_name) {
return this;
}
end(_endTime) {}
isRecording() {
return false;
}
recordException(_exception, _time) {}
}
exports2.NonRecordingSpan = NonRecordingSpan;
});
// node_modules/@opentelemetry/api/build/src/trace/context-utils.js
var require_context_utils2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.getSpanContext = exports2.setSpanContext = exports2.deleteSpan = exports2.setSpan = exports2.getActiveSpan = exports2.getSpan = undefined;
var context_1 = require_context3();
var NonRecordingSpan_1 = require_NonRecordingSpan2();
var context_2 = require_context5();
var SPAN_KEY = (0, context_1.createContextKey)("OpenTelemetry Context Key SPAN");
function getSpan(context) {
return context.getValue(SPAN_KEY) || undefined;
}
exports2.getSpan = getSpan;
function getActiveSpan() {
return getSpan(context_2.ContextAPI.getInstance().active());
}
exports2.getActiveSpan = getActiveSpan;
function setSpan(context, span) {
return context.setValue(SPAN_KEY, span);
}
exports2.setSpan = setSpan;
function deleteSpan(context) {
return context.deleteValue(SPAN_KEY);
}
exports2.deleteSpan = deleteSpan;
function setSpanContext(context, spanContext) {
return setSpan(context, new NonRecordingSpan_1.NonRecordingSpan(spanContext));
}
exports2.setSpanContext = setSpanContext;
function getSpanContext(context) {
var _a;
return (_a = getSpan(context)) === null || _a === undefined ? undefined : _a.spanContext();
}
exports2.getSpanContext = getSpanContext;
});
// node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.js
var require_spancontext_utils2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.wrapSpanContext = exports2.isSpanContextValid = exports2.isValidSpanId = exports2.isValidTraceId = undefined;
var invalid_span_constants_1 = require_invalid_span_constants2();
var NonRecordingSpan_1 = require_NonRecordingSpan2();
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;
}
exports2.isValidTraceId = isValidTraceId;
function isValidSpanId(spanId) {
return VALID_SPANID_REGEX.test(spanId) && spanId !== invalid_span_constants_1.INVALID_SPANID;
}
exports2.isValidSpanId = isValidSpanId;
function isSpanContextValid(spanContext) {
return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
}
exports2.isSpanContextValid = isSpanContextValid;
function wrapSpanContext(spanContext) {
return new NonRecordingSpan_1.NonRecordingSpan(spanContext);
}
exports2.wrapSpanContext = wrapSpanContext;
});
// node_modules/@opentelemetry/api/build/src/trace/NoopTracer.js
var require_NoopTracer2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.NoopTracer = undefined;
var context_1 = require_context5();
var context_utils_1 = require_context_utils2();
var NonRecordingSpan_1 = require_NonRecordingSpan2();
var spancontext_utils_1 = require_spancontext_utils2();
var contextApi = context_1.ContextAPI.getInstance();
class NoopTracer {
startSpan(name, options, context = contextApi.active()) {
const root = Boolean(options === null || options === undefined ? undefined : 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 !== undefined ? ctx : contextApi.active();
const span = this.startSpan(name, opts, parentContext);
const contextWithSpanSet = (0, context_utils_1.setSpan)(parentContext, span);
return contextApi.with(contextWithSpanSet, fn, undefined, span);
}
}
exports2.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_ProxyTracer2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ProxyTracer = undefined;
var NoopTracer_1 = require_NoopTracer2();
var NOOP_TRACER = new NoopTracer_1.NoopTracer;
class ProxyTracer {
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);
}
_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;
}
}
exports2.ProxyTracer = ProxyTracer;
});
// node_modules/@opentelemetry/api/build/src/trace/NoopTracerProvider.js
var require_NoopTracerProvider2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.NoopTracerProvider = undefined;
var NoopTracer_1 = require_NoopTracer2();
class NoopTracerProvider {
getTracer(_name, _version, _options) {
return new NoopTracer_1.NoopTracer;
}
}
exports2.NoopTracerProvider = NoopTracerProvider;
});
// node_modules/@opentelemetry/api/build/src/trace/ProxyTracerProvider.js
var require_ProxyTracerProvider2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ProxyTracerProvider = undefined;
var ProxyTracer_1 = require_ProxyTracer2();
var NoopTracerProvider_1 = require_NoopTracerProvider2();
var NOOP_TRACER_PROVIDER = new NoopTracerProvider_1.NoopTracerProvider;
class ProxyTracerProvider {
getTracer(name, version, options) {
var _a;
return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== undefined ? _a : new ProxyTracer_1.ProxyTracer(this, name, version, options);
}
getDelegate() {
var _a;
return (_a = this._delegate) !== null && _a !== undefined ? _a : NOOP_TRACER_PROVIDER;
}
setDelegate(delegate) {
this._delegate = delegate;
}
getDelegateTracer(name, version, options) {
var _a;
return (_a = this._delegate) === null || _a === undefined ? undefined : _a.getTracer(name, version, options);
}
}
exports2.ProxyTracerProvider = ProxyTracerProvider;
});
// node_modules/@opentelemetry/api/build/src/trace/SamplingResult.js
var require_SamplingResult2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.SamplingDecision = undefined;
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 = exports2.SamplingDecision || (exports2.SamplingDecision = {}));
});
// node_modules/@opentelemetry/api/build/src/trace/span_kind.js
var require_span_kind2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.SpanKind = undefined;
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 = exports2.SpanKind || (exports2.SpanKind = {}));
});
// node_modules/@opentelemetry/api/build/src/trace/status.js
var require_status2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.SpanStatusCode = undefined;
var SpanStatusCode;
(function(SpanStatusCode2) {
SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
})(SpanStatusCode = exports2.SpanStatusCode || (exports2.SpanStatusCode = {}));
});
// node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-validators.js
var require_tracestate_validators2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.validateValue = exports2.validateKey = undefined;
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);
}
exports2.validateKey = validateKey;
function validateValue(value) {
return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
}
exports2.validateValue = validateValue;
});
// node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-impl.js
var require_tracestate_impl2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.TraceStateImpl = undefined;
var tracestate_validators_1 = require_tracestate_validators2();
var MAX_TRACE_STATE_ITEMS = 32;
var MAX_TRACE_STATE_LEN = 512;
var LIST_MEMBERS_SEPARATOR = ",";
var LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
class TraceStateImpl {
constructor(rawTraceState) {
this._internalState = 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;
}, 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;
}
}
exports2.TraceStateImpl = TraceStateImpl;
});
// node_modules/@opentelemetry/api/build/src/trace/internal/utils.js
var require_utils14 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.createTraceState = undefined;
var tracestate_impl_1 = require_tracestate_impl2();
function createTraceState(rawTraceState) {
return new tracestate_impl_1.TraceStateImpl(rawTraceState);
}
exports2.createTraceState = createTraceState;
});
// node_modules/@opentelemetry/api/build/src/context-api.js
var require_context_api2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.context = undefined;
var context_1 = require_context5();
exports2.context = context_1.ContextAPI.getInstance();
});
// node_modules/@opentelemetry/api/build/src/diag-api.js
var require_diag_api2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.diag = undefined;
var diag_1 = require_diag2();
exports2.diag = diag_1.DiagAPI.instance();
});
// node_modules/@opentelemetry/api/build/src/metrics/NoopMeterProvider.js
var require_NoopMeterProvider2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.NOOP_METER_PROVIDER = exports2.NoopMeterProvider = undefined;
var NoopMeter_1 = require_NoopMeter2();
class NoopMeterProvider {
getMeter(_name, _version, _options) {
return NoopMeter_1.NOOP_METER;
}
}
exports2.NoopMeterProvider = NoopMeterProvider;
exports2.NOOP_METER_PROVIDER = new NoopMeterProvider;
});
// node_modules/@opentelemetry/api/build/src/api/metrics.js
var require_metrics4 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.MetricsAPI = undefined;
var NoopMeterProvider_1 = require_NoopMeterProvider2();
var global_utils_1 = require_global_utils3();
var diag_1 = require_diag2();
var API_NAME = "metrics";
class MetricsAPI {
constructor() {}
static getInstance() {
if (!this._instance) {
this._instance = new MetricsAPI;
}
return this._instance;
}
setGlobalMeterProvider(provider) {
return (0, global_utils_1.registerGlobal)(API_NAME, provider, diag_1.DiagAPI.instance());
}
getMeterProvider() {
return (0, global_utils_1.getGlobal)(API_NAME) || NoopMeterProvider_1.NOOP_METER_PROVIDER;
}
getMeter(name, version, options) {
return this.getMeterProvider().getMeter(name, version, options);
}
disable() {
(0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
}
}
exports2.MetricsAPI = MetricsAPI;
});
// node_modules/@opentelemetry/api/build/src/metrics-api.js
var require_metrics_api2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.metrics = undefined;
var metrics_1 = require_metrics4();
exports2.metrics = metrics_1.MetricsAPI.getInstance();
});
// node_modules/@opentelemetry/api/build/src/propagation/NoopTextMapPropagator.js
var require_NoopTextMapPropagator2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.NoopTextMapPropagator = undefined;
class NoopTextMapPropagator {
inject(_context, _carrier) {}
extract(context, _carrier) {
return context;
}
fields() {
return [];
}
}
exports2.NoopTextMapPropagator = NoopTextMapPropagator;
});
// node_modules/@opentelemetry/api/build/src/baggage/context-helpers.js
var require_context_helpers2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.deleteBaggage = exports2.setBaggage = exports2.getActiveBaggage = exports2.getBaggage = undefined;
var context_1 = require_context5();
var context_2 = require_context3();
var BAGGAGE_KEY = (0, context_2.createContextKey)("OpenTelemetry Baggage Key");
function getBaggage(context) {
return context.getValue(BAGGAGE_KEY) || undefined;
}
exports2.getBaggage = getBaggage;
function getActiveBaggage() {
return getBaggage(context_1.ContextAPI.getInstance().active());
}
exports2.getActiveBaggage = getActiveBaggage;
function setBaggage(context, baggage) {
return context.setValue(BAGGAGE_KEY, baggage);
}
exports2.setBaggage = setBaggage;
function deleteBaggage(context) {
return context.deleteValue(BAGGAGE_KEY);
}
exports2.deleteBaggage = deleteBaggage;
});
// node_modules/@opentelemetry/api/build/src/api/propagation.js
var require_propagation2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.PropagationAPI = undefined;
var global_utils_1 = require_global_utils3();
var NoopTextMapPropagator_1 = require_NoopTextMapPropagator2();
var TextMapPropagator_1 = require_TextMapPropagator2();
var context_helpers_1 = require_context_helpers2();
var utils_1 = require_utils12();
var diag_1 = require_diag2();
var API_NAME = "propagation";
var NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator_1.NoopTextMapPropagator;
class PropagationAPI {
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;
}
static getInstance() {
if (!this._instance) {
this._instance = new PropagationAPI;
}
return this._instance;
}
setGlobalPropagator(propagator) {
return (0, global_utils_1.registerGlobal)(API_NAME, propagator, diag_1.DiagAPI.instance());
}
inject(context, carrier, setter = TextMapPropagator_1.defaultTextMapSetter) {
return this._getGlobalPropagator().inject(context, carrier, setter);
}
extract(context, carrier, getter = TextMapPropagator_1.defaultTextMapGetter) {
return this._getGlobalPropagator().extract(context, carrier, getter);
}
fields() {
return this._getGlobalPropagator().fields();
}
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;
}
}
exports2.PropagationAPI = PropagationAPI;
});
// node_modules/@opentelemetry/api/build/src/propagation-api.js
var require_propagation_api2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.propagation = undefined;
var propagation_1 = require_propagation2();
exports2.propagation = propagation_1.PropagationAPI.getInstance();
});
// node_modules/@opentelemetry/api/build/src/api/trace.js
var require_trace5 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.TraceAPI = undefined;
var global_utils_1 = require_global_utils3();
var ProxyTracerProvider_1 = require_ProxyTracerProvider2();
var spancontext_utils_1 = require_spancontext_utils2();
var context_utils_1 = require_context_utils2();
var diag_1 = require_diag2();
var API_NAME = "trace";
class TraceAPI {
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;
}
static getInstance() {
if (!this._instance) {
this._instance = new TraceAPI;
}
return this._instance;
}
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;
}
getTracerProvider() {
return (0, global_utils_1.getGlobal)(API_NAME) || this._proxyTracerProvider;
}
getTracer(name, version) {
return this.getTracerProvider().getTracer(name, version);
}
disable() {
(0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider;
}
}
exports2.TraceAPI = TraceAPI;
});
// node_modules/@opentelemetry/api/build/src/trace-api.js
var require_trace_api2 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.trace = undefined;
var trace_1 = require_trace5();
exports2.trace = trace_1.TraceAPI.getInstance();
});
// node_modules/@opentelemetry/api/build/src/index.js
var require_src33 = __commonJS((exports2) => {
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.trace = exports2.propagation = exports2.metrics = exports2.diag = exports2.context = exports2.INVALID_SPAN_CONTEXT = exports2.INVALID_TRACEID = exports2.INVALID_SPANID = exports2.isValidSpanId = exports2.isValidTraceId = exports2.isSpanContextValid = exports2.createTraceState = exports2.TraceFlags = exports2.SpanStatusCode = exports2.SpanKind = exports2.SamplingDecision = exports2.ProxyTracerProvider = exports2.ProxyTracer = exports2.defaultTextMapSetter = exports2.defaultTextMapGetter = exports2.ValueType = exports2.createNoopMeter = exports2.DiagLogLevel = exports2.DiagConsoleLogger = exports2.ROOT_CONTEXT = exports2.createContextKey = exports2.baggageEntryMetadataFromString = undefined;
var utils_1 = require_utils12();
Object.defineProperty(exports2, "baggageEntryMetadataFromString", { enumerable: true, get: function() {
return utils_1.baggageEntryMetadataFromString;
} });
var context_1 = require_context3();
Object.defineProperty(exports2, "createContextKey", { enumerable: true, get: function() {
return context_1.createContextKey;
} });
Object.defineProperty(exports2, "ROOT_CONTEXT", { enumerable: true, get: function() {
return context_1.ROOT_CONTEXT;
} });
var consoleLogger_1 = require_consoleLogger2();
Object.defineProperty(exports2, "DiagConsoleLogger", { enumerable: true, get: function() {
return consoleLogger_1.DiagConsoleLogger;
} });
var types_1 = require_types8();
Object.defineProperty(exports2, "DiagLogLevel", {