@globalart/nestjs-logger 2.4.3 → 4.0.1

package/dist/index.mjs

@@ -1,4 +1,3 @@
-import { createRequire } from "node:module";
 import { ConfigurableModuleBuilder, Inject, Injectable, Module, RequestMethod, SetMetadata } from "@nestjs/common";
 import { APP_INTERCEPTOR, Reflector } from "@nestjs/core";
 import { hostname } from "os";
@@ -6,8 +5,32 @@ import { nanoid } from "nanoid";
 import { AsyncLocalStorage } from "async_hooks";
 import { randomBytes, randomUUID } from "crypto";
 //#region \0rolldown/runtime.js
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 //#endregion
 //#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/cjs/internal/util/isFunction.js
 var require_isFunction = /* @__PURE__ */ __commonJSMin(((exports) => {
@@ -7048,11 +7071,1523 @@ const DEFAULT_LOGGER_CONFIG = {
 	exclude: []
 };
 //#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/version.js
+var VERSION;
+var init_version = __esmMin((() => {
+	VERSION = "1.9.1";
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/internal/semver.js
+/**
+* Create a function to test an API version to see if it is compatible with the provided ownVersion.
+*
+* The returned function has the following semantics:
+* - Exact match is always compatible
+* - Major versions must match exactly
+*    - 1.x package cannot use global 2.x package
+*    - 2.x package cannot use global 1.x package
+* - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API
+*    - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects
+*    - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3
+* - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor
+* - Patch and build tag differences are not considered at this time
+*
+* @param ownVersion version which should be checked against
+*/
+function _makeCompatibilityCheck(ownVersion) {
+	const acceptedVersions = 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);
+	};
+}
+var re, isCompatible;
+var init_semver = __esmMin((() => {
+	init_version();
+	re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+	isCompatible = _makeCompatibilityCheck(VERSION);
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
+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 };
+	if (!allowOverride && api[type]) {
+		const err = /* @__PURE__ */ new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`);
+		diag.error(err.stack || err.message);
+		return false;
+	}
+	if (api.version !== "1.9.1") {
+		const err = /* @__PURE__ */ new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${VERSION}`);
+		diag.error(err.stack || err.message);
+		return false;
+	}
+	api[type] = instance;
+	diag.debug(`@opentelemetry/api: Registered a global for ${type} v${VERSION}.`);
+	return true;
+}
+function getGlobal(type) {
+	var _a, _b;
+	const globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+	if (!globalVersion || !isCompatible(globalVersion)) return;
+	return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+}
+function unregisterGlobal(type, diag) {
+	diag.debug(`@opentelemetry/api: Unregistering a global for ${type} v${VERSION}.`);
+	const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+	if (api) delete api[type];
+}
+var major, GLOBAL_OPENTELEMETRY_API_KEY, _global;
+var init_global_utils = __esmMin((() => {
+	init_version();
+	init_semver();
+	major = VERSION.split(".")[0];
+	GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(`opentelemetry.js.api.${major}`);
+	_global = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
+function logProxy(funcName, namespace, args) {
+	const logger = getGlobal("diag");
+	if (!logger) return;
+	return logger[funcName](namespace, ...args);
+}
+var DiagComponentLogger;
+var init_ComponentLogger = __esmMin((() => {
+	init_global_utils();
+	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);
+		}
+	};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/diag/types.js
+var DiagLogLevel;
+var init_types = __esmMin((() => {
+	(function(DiagLogLevel) {
+		/** Diagnostic Logging level setting to disable all logging (except and forced logs) */
+		DiagLogLevel[DiagLogLevel["NONE"] = 0] = "NONE";
+		/** Identifies an error scenario */
+		DiagLogLevel[DiagLogLevel["ERROR"] = 30] = "ERROR";
+		/** Identifies a warning scenario */
+		DiagLogLevel[DiagLogLevel["WARN"] = 50] = "WARN";
+		/** General informational log message */
+		DiagLogLevel[DiagLogLevel["INFO"] = 60] = "INFO";
+		/** General debug log message */
+		DiagLogLevel[DiagLogLevel["DEBUG"] = 70] = "DEBUG";
+		/**
+		* Detailed trace level logging should only be used for development, should only be set
+		* in a development environment.
+		*/
+		DiagLogLevel[DiagLogLevel["VERBOSE"] = 80] = "VERBOSE";
+		/** Used to set the logging level to include all logging */
+		DiagLogLevel[DiagLogLevel["ALL"] = 9999] = "ALL";
+	})(DiagLogLevel || (DiagLogLevel = {}));
+}));
+//#endregion
+//#region ../../../../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) {
+		const 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 = __esmMin((() => {
+	init_types();
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/api/diag.js
+var API_NAME$4, DiagAPI;
+var init_diag = __esmMin((() => {
+	init_ComponentLogger();
+	init_logLevelLogger();
+	init_types();
+	init_global_utils();
+	API_NAME$4 = "diag";
+	DiagAPI = class DiagAPI {
+		/** Get the singleton instance of the DiagAPI API */
+		static instance() {
+			if (!this._instance) this._instance = new DiagAPI();
+			return this._instance;
+		}
+		/**
+		* Private internal constructor
+		* @private
+		*/
+		constructor() {
+			function _logProxy(funcName) {
+				return function(...args) {
+					const logger = getGlobal("diag");
+					if (!logger) return;
+					return logger[funcName](...args);
+				};
+			}
+			const self = this;
+			const setLogger = (logger, optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }) => {
+				var _a, _b, _c;
+				if (logger === self) {
+					const err = /* @__PURE__ */ 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 = getGlobal("diag");
+				const newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
+				if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+					const stack = (_c = (/* @__PURE__ */ 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, self, true);
+			};
+			self.setLogger = setLogger;
+			self.disable = () => {
+				unregisterGlobal(API_NAME$4, self);
+			};
+			self.createComponentLogger = (options) => {
+				return new DiagComponentLogger(options);
+			};
+			self.verbose = _logProxy("verbose");
+			self.debug = _logProxy("debug");
+			self.info = _logProxy("info");
+			self.warn = _logProxy("warn");
+			self.error = _logProxy("error");
+		}
+	};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/baggage/internal/baggage-impl.js
+var BaggageImpl;
+var init_baggage_impl = __esmMin((() => {
+	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;
+			return Object.assign({}, entry);
+		}
+		getAllEntries() {
+			return Array.from(this._entries.entries());
+		}
+		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();
+		}
+	};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/baggage/internal/symbol.js
+var baggageEntryMetadataSymbol;
+var init_symbol = __esmMin((() => {
+	baggageEntryMetadataSymbol = Symbol("BaggageEntryMetadata");
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/baggage/utils.js
+/**
+* Create a new Baggage with optional entries
+*
+* @param entries An array of baggage entries the new baggage should contain
+*/
+function createBaggage(entries = {}) {
+	return new BaggageImpl(new Map(Object.entries(entries)));
+}
+/**
+* Create a serializable BaggageEntryMetadata object from a string.
+*
+* @param str string metadata. Format is currently not defined by the spec and has no special meaning.
+*
+* @since 1.0.0
+*/
+function baggageEntryMetadataFromString(str) {
+	if (typeof str !== "string") {
+		diag$1.error(`Cannot create baggage metadata from unknown type: ${typeof str}`);
+		str = "";
+	}
+	return {
+		__TYPE__: baggageEntryMetadataSymbol,
+		toString() {
+			return str;
+		}
+	};
+}
+var diag$1;
+var init_utils$1 = __esmMin((() => {
+	init_diag();
+	init_baggage_impl();
+	init_symbol();
+	diag$1 = DiagAPI.instance();
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/context/context.js
+/**
+* Get a key to uniquely identify a context value
+*
+* @since 1.0.0
+*/
+function createContextKey(description) {
+	return Symbol.for(description);
+}
+var BaseContext, ROOT_CONTEXT;
+var init_context$1 = __esmMin((() => {
+	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;
+			};
+		}
+	};
+	ROOT_CONTEXT = new BaseContext();
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/diag/consoleLogger.js
+var consoleMap, _originalConsoleMethods, DiagConsoleLogger;
+var init_consoleLogger = __esmMin((() => {
+	consoleMap = [
+		{
+			n: "error",
+			c: "error"
+		},
+		{
+			n: "warn",
+			c: "warn"
+		},
+		{
+			n: "info",
+			c: "info"
+		},
+		{
+			n: "debug",
+			c: "debug"
+		},
+		{
+			n: "verbose",
+			c: "trace"
+		}
+	];
+	_originalConsoleMethods = {};
+	if (typeof console !== "undefined") {
+		for (const key of [
+			"error",
+			"warn",
+			"info",
+			"debug",
+			"trace",
+			"log"
+		]) if (typeof console[key] === "function") _originalConsoleMethods[key] = console[key];
+	}
+	DiagConsoleLogger = class {
+		constructor() {
+			function _consoleFunc(funcName) {
+				return function(...args) {
+					let theFunc = _originalConsoleMethods[funcName];
+					if (typeof theFunc !== "function") theFunc = _originalConsoleMethods["log"];
+					if (typeof theFunc !== "function" && console) {
+						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);
+		}
+	};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js
+/**
+* Create a no-op Meter
+*
+* @since 1.3.0
+*/
+function createNoopMeter() {
+	return NOOP_METER;
+}
+var NoopMeter, NoopMetric, NoopCounterMetric, NoopUpDownCounterMetric, NoopGaugeMetric, NoopHistogramMetric, NoopObservableMetric, NoopObservableCounterMetric, NoopObservableGaugeMetric, NoopObservableUpDownCounterMetric, NOOP_METER, NOOP_COUNTER_METRIC, NOOP_GAUGE_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 = __esmMin((() => {
+	NoopMeter = class {
+		constructor() {}
+		/**
+		* @see {@link Meter.createGauge}
+		*/
+		createGauge(_name, _options) {
+			return NOOP_GAUGE_METRIC;
+		}
+		/**
+		* @see {@link Meter.createHistogram}
+		*/
+		createHistogram(_name, _options) {
+			return NOOP_HISTOGRAM_METRIC;
+		}
+		/**
+		* @see {@link Meter.createCounter}
+		*/
+		createCounter(_name, _options) {
+			return NOOP_COUNTER_METRIC;
+		}
+		/**
+		* @see {@link Meter.createUpDownCounter}
+		*/
+		createUpDownCounter(_name, _options) {
+			return NOOP_UP_DOWN_COUNTER_METRIC;
+		}
+		/**
+		* @see {@link Meter.createObservableGauge}
+		*/
+		createObservableGauge(_name, _options) {
+			return NOOP_OBSERVABLE_GAUGE_METRIC;
+		}
+		/**
+		* @see {@link Meter.createObservableCounter}
+		*/
+		createObservableCounter(_name, _options) {
+			return NOOP_OBSERVABLE_COUNTER_METRIC;
+		}
+		/**
+		* @see {@link Meter.createObservableUpDownCounter}
+		*/
+		createObservableUpDownCounter(_name, _options) {
+			return NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
+		}
+		/**
+		* @see {@link Meter.addBatchObservableCallback}
+		*/
+		addBatchObservableCallback(_callback, _observables) {}
+		/**
+		* @see {@link Meter.removeBatchObservableCallback}
+		*/
+		removeBatchObservableCallback(_callback) {}
+	};
+	NoopMetric = class {};
+	NoopCounterMetric = class extends NoopMetric {
+		add(_value, _attributes) {}
+	};
+	NoopUpDownCounterMetric = class extends NoopMetric {
+		add(_value, _attributes) {}
+	};
+	NoopGaugeMetric = class extends NoopMetric {
+		record(_value, _attributes) {}
+	};
+	NoopHistogramMetric = class extends NoopMetric {
+		record(_value, _attributes) {}
+	};
+	NoopObservableMetric = class {
+		addCallback(_callback) {}
+		removeCallback(_callback) {}
+	};
+	NoopObservableCounterMetric = class extends NoopObservableMetric {};
+	NoopObservableGaugeMetric = class extends NoopObservableMetric {};
+	NoopObservableUpDownCounterMetric = class extends NoopObservableMetric {};
+	NOOP_METER = new NoopMeter();
+	NOOP_COUNTER_METRIC = new NoopCounterMetric();
+	NOOP_GAUGE_METRIC = new NoopGaugeMetric();
+	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();
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/metrics/Metric.js
+var ValueType;
+var init_Metric = __esmMin((() => {
+	(function(ValueType) {
+		ValueType[ValueType["INT"] = 0] = "INT";
+		ValueType[ValueType["DOUBLE"] = 1] = "DOUBLE";
+	})(ValueType || (ValueType = {}));
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/propagation/TextMapPropagator.js
+var defaultTextMapGetter, defaultTextMapSetter;
+var init_TextMapPropagator = __esmMin((() => {
+	defaultTextMapGetter = {
+		get(carrier, key) {
+			if (carrier == null) return;
+			return carrier[key];
+		},
+		keys(carrier) {
+			if (carrier == null) return [];
+			return Object.keys(carrier);
+		}
+	};
+	defaultTextMapSetter = { set(carrier, key, value) {
+		if (carrier == null) return;
+		carrier[key] = value;
+	} };
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
+var NoopContextManager;
+var init_NoopContextManager = __esmMin((() => {
+	init_context$1();
+	NoopContextManager = class {
+		active() {
+			return ROOT_CONTEXT;
+		}
+		with(_context, fn, thisArg, ...args) {
+			return fn.call(thisArg, ...args);
+		}
+		bind(_context, target) {
+			return target;
+		}
+		enable() {
+			return this;
+		}
+		disable() {
+			return this;
+		}
+	};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/api/context.js
+var API_NAME$3, NOOP_CONTEXT_MANAGER, ContextAPI;
+var init_context = __esmMin((() => {
+	init_NoopContextManager();
+	init_global_utils();
+	init_diag();
+	API_NAME$3 = "context";
+	NOOP_CONTEXT_MANAGER = new NoopContextManager();
+	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 registerGlobal(API_NAME$3, contextManager, 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 getGlobal(API_NAME$3) || NOOP_CONTEXT_MANAGER;
+		}
+		/** Disable and remove the global context manager */
+		disable() {
+			this._getContextManager().disable();
+			unregisterGlobal(API_NAME$3, DiagAPI.instance());
+		}
+	};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
+var TraceFlags;
+var init_trace_flags = __esmMin((() => {
+	(function(TraceFlags) {
+		/** Represents no flag set. */
+		TraceFlags[TraceFlags["NONE"] = 0] = "NONE";
+		/** Bit to represent whether trace is sampled in trace flags. */
+		TraceFlags[TraceFlags["SAMPLED"] = 1] = "SAMPLED";
+	})(TraceFlags || (TraceFlags = {}));
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js
+var INVALID_SPANID, INVALID_TRACEID, INVALID_SPAN_CONTEXT;
+var init_invalid_span_constants = __esmMin((() => {
+	init_trace_flags();
+	INVALID_SPANID = "0000000000000000";
+	INVALID_TRACEID = "00000000000000000000000000000000";
+	INVALID_SPAN_CONTEXT = {
+		traceId: INVALID_TRACEID,
+		spanId: INVALID_SPANID,
+		traceFlags: TraceFlags.NONE
+	};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
+var NonRecordingSpan;
+var init_NonRecordingSpan = __esmMin((() => {
+	init_invalid_span_constants();
+	NonRecordingSpan = class {
+		constructor(spanContext = 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) {}
+	};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
+/**
+* Return the span if one exists
+*
+* @param context context to get span from
+*/
+function getSpan(context) {
+	return context.getValue(SPAN_KEY) || void 0;
+}
+/**
+* Gets the span from the current context, if one exists.
+*/
+function getActiveSpan() {
+	return getSpan(ContextAPI.getInstance().active());
+}
+/**
+* Set the span on a context
+*
+* @param context context to use as parent
+* @param span span to set active
+*/
+function setSpan(context, span) {
+	return context.setValue(SPAN_KEY, span);
+}
+/**
+* Remove current span stored in the context
+*
+* @param context context to delete span from
+*/
+function deleteSpan(context) {
+	return context.deleteValue(SPAN_KEY);
+}
+/**
+* Wrap span context in a NoopSpan and set as span in a new
+* context
+*
+* @param context context to set active span on
+* @param spanContext span context to be wrapped
+*/
+function setSpanContext(context, spanContext) {
+	return setSpan(context, new NonRecordingSpan(spanContext));
+}
+/**
+* Get the span context of the span if it exists.
+*
+* @param context context to get values from
+*/
+function getSpanContext(context) {
+	var _a;
+	return (_a = getSpan(context)) === null || _a === void 0 ? void 0 : _a.spanContext();
+}
+var SPAN_KEY;
+var init_context_utils = __esmMin((() => {
+	init_context$1();
+	init_NonRecordingSpan();
+	init_context();
+	SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
+function isValidHex(id, length) {
+	if (typeof id !== "string" || id.length !== length) return false;
+	let r = 0;
+	for (let i = 0; i < id.length; i += 4) r += (isHex[id.charCodeAt(i)] | 0) + (isHex[id.charCodeAt(i + 1)] | 0) + (isHex[id.charCodeAt(i + 2)] | 0) + (isHex[id.charCodeAt(i + 3)] | 0);
+	return r === length;
+}
+/**
+* @since 1.0.0
+*/
+function isValidTraceId(traceId) {
+	return isValidHex(traceId, 32) && traceId !== "00000000000000000000000000000000";
+}
+/**
+* @since 1.0.0
+*/
+function isValidSpanId(spanId) {
+	return isValidHex(spanId, 16) && spanId !== "0000000000000000";
+}
+/**
+* Returns true if this {@link SpanContext} is valid.
+* @return true if this {@link SpanContext} is valid.
+*
+* @since 1.0.0
+*/
+function isSpanContextValid(spanContext) {
+	return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
+}
+/**
+* Wrap the given {@link SpanContext} in a new non-recording {@link Span}
+*
+* @param spanContext span context to be wrapped
+* @returns a new non-recording {@link Span} with the provided context
+*/
+function wrapSpanContext(spanContext) {
+	return new NonRecordingSpan(spanContext);
+}
+var isHex;
+var init_spancontext_utils = __esmMin((() => {
+	init_invalid_span_constants();
+	init_NonRecordingSpan();
+	isHex = new Uint8Array([
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1
+	]);
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
+function isSpanContext(spanContext) {
+	return spanContext !== null && typeof spanContext === "object" && "spanId" in spanContext && typeof spanContext["spanId"] === "string" && "traceId" in spanContext && typeof spanContext["traceId"] === "string" && "traceFlags" in spanContext && typeof spanContext["traceFlags"] === "number";
+}
+var contextApi, NoopTracer;
+var init_NoopTracer = __esmMin((() => {
+	init_context();
+	init_context_utils();
+	init_NonRecordingSpan();
+	init_spancontext_utils();
+	contextApi = ContextAPI.getInstance();
+	NoopTracer = class {
+		startSpan(name, options, context = contextApi.active()) {
+			if (Boolean(options === null || options === void 0 ? void 0 : options.root)) return new NonRecordingSpan();
+			const parentFromContext = context && getSpanContext(context);
+			if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) return new NonRecordingSpan(parentFromContext);
+			else return new 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 = setSpan(parentContext, span);
+			return contextApi.with(contextWithSpanSet, fn, void 0, span);
+		}
+	};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
+var NOOP_TRACER, ProxyTracer;
+var init_ProxyTracer = __esmMin((() => {
+	init_NoopTracer();
+	NOOP_TRACER = new NoopTracer();
+	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;
+		}
+	};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
+var NoopTracerProvider;
+var init_NoopTracerProvider = __esmMin((() => {
+	init_NoopTracer();
+	NoopTracerProvider = class {
+		getTracer(_name, _version, _options) {
+			return new NoopTracer();
+		}
+	};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
+var NOOP_TRACER_PROVIDER, ProxyTracerProvider;
+var init_ProxyTracerProvider = __esmMin((() => {
+	init_ProxyTracer();
+	init_NoopTracerProvider();
+	NOOP_TRACER_PROVIDER = new NoopTracerProvider();
+	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(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);
+		}
+	};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/trace/SamplingResult.js
+var SamplingDecision;
+var init_SamplingResult = __esmMin((() => {
+	(function(SamplingDecision) {
+		/**
+		* `Span.isRecording() === false`, span will not be recorded and all events
+		* and attributes will be dropped.
+		*/
+		SamplingDecision[SamplingDecision["NOT_RECORD"] = 0] = "NOT_RECORD";
+		/**
+		* `Span.isRecording() === true`, but `Sampled` flag in {@link TraceFlags}
+		* MUST NOT be set.
+		*/
+		SamplingDecision[SamplingDecision["RECORD"] = 1] = "RECORD";
+		/**
+		* `Span.isRecording() === true` AND `Sampled` flag in {@link TraceFlags}
+		* MUST be set.
+		*/
+		SamplingDecision[SamplingDecision["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
+	})(SamplingDecision || (SamplingDecision = {}));
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/trace/span_kind.js
+var SpanKind;
+var init_span_kind = __esmMin((() => {
+	(function(SpanKind) {
+		/** Default value. Indicates that the span is used internally. */
+		SpanKind[SpanKind["INTERNAL"] = 0] = "INTERNAL";
+		/**
+		* Indicates that the span covers server-side handling of an RPC or other
+		* remote request.
+		*/
+		SpanKind[SpanKind["SERVER"] = 1] = "SERVER";
+		/**
+		* Indicates that the span covers the client-side wrapper around an RPC or
+		* other remote request.
+		*/
+		SpanKind[SpanKind["CLIENT"] = 2] = "CLIENT";
+		/**
+		* Indicates that the span describes producer sending a message to a
+		* broker. Unlike client and server, there is no direct critical path latency
+		* relationship between producer and consumer spans.
+		*/
+		SpanKind[SpanKind["PRODUCER"] = 3] = "PRODUCER";
+		/**
+		* Indicates that the span describes consumer receiving a message from a
+		* broker. Unlike client and server, there is no direct critical path latency
+		* relationship between producer and consumer spans.
+		*/
+		SpanKind[SpanKind["CONSUMER"] = 4] = "CONSUMER";
+	})(SpanKind || (SpanKind = {}));
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/trace/status.js
+var SpanStatusCode;
+var init_status = __esmMin((() => {
+	(function(SpanStatusCode) {
+		/**
+		* The default status.
+		*/
+		SpanStatusCode[SpanStatusCode["UNSET"] = 0] = "UNSET";
+		/**
+		* The operation has been validated by an Application developer or
+		* Operator to have completed successfully.
+		*/
+		SpanStatusCode[SpanStatusCode["OK"] = 1] = "OK";
+		/**
+		* The operation contains an error.
+		*/
+		SpanStatusCode[SpanStatusCode["ERROR"] = 2] = "ERROR";
+	})(SpanStatusCode || (SpanStatusCode = {}));
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-validators.js
+/**
+* Key is opaque string up to 256 characters printable. It MUST begin with a
+* lowercase letter, and can only contain lowercase letters a-z, digits 0-9,
+* underscores _, dashes -, asterisks *, and forward slashes /.
+* For multi-tenant vendor scenarios, an at sign (@) can be used to prefix the
+* vendor name. Vendors SHOULD set the tenant ID at the beginning of the key.
+* see https://www.w3.org/TR/trace-context/#key
+*/
+function validateKey(key) {
+	return VALID_KEY_REGEX.test(key);
+}
+/**
+* Value is opaque string up to 256 characters printable ASCII RFC0020
+* characters (i.e., the range 0x20 to 0x7E) except comma , and =.
+*/
+function validateValue(value) {
+	return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
+}
+var VALID_KEY_CHAR_RANGE, VALID_KEY_REGEX, VALID_VALUE_BASE_REGEX, INVALID_VALUE_COMMA_EQUAL_REGEX;
+var init_tracestate_validators = __esmMin((() => {
+	VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
+	VALID_KEY_REGEX = new RegExp(`^(?:${`[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`}|${`[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`})$`);
+	VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
+	INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
+}));
+//#endregion
+//#region ../../../../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 = __esmMin((() => {
+	init_tracestate_validators();
+	MAX_TRACE_STATE_ITEMS = 32;
+	MAX_TRACE_STATE_LEN = 512;
+	LIST_MEMBERS_SEPARATOR = ",";
+	LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
+	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 Array.from(this._internalState.keys()).reduceRight((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).reduceRight((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 (validateKey(key) && validateValue(value)) agg.set(key, value);
+				}
+				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;
+		}
+	};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/trace/internal/utils.js
+/**
+* @since 1.1.0
+*/
+function createTraceState(rawTraceState) {
+	return new TraceStateImpl(rawTraceState);
+}
+var init_utils = __esmMin((() => {
+	init_tracestate_impl();
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/context-api.js
+var context;
+var init_context_api = __esmMin((() => {
+	init_context();
+	context = ContextAPI.getInstance();
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/diag-api.js
+var diag;
+var init_diag_api = __esmMin((() => {
+	init_diag();
+	diag = DiagAPI.instance();
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js
+var NoopMeterProvider, NOOP_METER_PROVIDER;
+var init_NoopMeterProvider = __esmMin((() => {
+	init_NoopMeter();
+	NoopMeterProvider = class {
+		getMeter(_name, _version, _options) {
+			return NOOP_METER;
+		}
+	};
+	NOOP_METER_PROVIDER = new NoopMeterProvider();
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/api/metrics.js
+var API_NAME$2, MetricsAPI;
+var init_metrics = __esmMin((() => {
+	init_NoopMeterProvider();
+	init_global_utils();
+	init_diag();
+	API_NAME$2 = "metrics";
+	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 registerGlobal(API_NAME$2, provider, DiagAPI.instance());
+		}
+		/**
+		* Returns the global meter provider.
+		*/
+		getMeterProvider() {
+			return getGlobal(API_NAME$2) || 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() {
+			unregisterGlobal(API_NAME$2, DiagAPI.instance());
+		}
+	};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/metrics-api.js
+var metrics;
+var init_metrics_api = __esmMin((() => {
+	init_metrics();
+	metrics = MetricsAPI.getInstance();
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/propagation/NoopTextMapPropagator.js
+var NoopTextMapPropagator;
+var init_NoopTextMapPropagator = __esmMin((() => {
+	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 [];
+		}
+	};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/baggage/context-helpers.js
+/**
+* Retrieve the current baggage from the given context
+*
+* @param {Context} Context that manage all context values
+* @returns {Baggage} Extracted baggage from the context
+*/
+function getBaggage(context) {
+	return context.getValue(BAGGAGE_KEY) || void 0;
+}
+/**
+* Retrieve the current baggage from the active/current context
+*
+* @returns {Baggage} Extracted baggage from the context
+*/
+function getActiveBaggage() {
+	return getBaggage(ContextAPI.getInstance().active());
+}
+/**
+* Store a baggage in the given context
+*
+* @param {Context} Context that manage all context values
+* @param {Baggage} baggage that will be set in the actual context
+*/
+function setBaggage(context, baggage) {
+	return context.setValue(BAGGAGE_KEY, baggage);
+}
+/**
+* Delete the baggage stored in the given context
+*
+* @param {Context} Context that manage all context values
+*/
+function deleteBaggage(context) {
+	return context.deleteValue(BAGGAGE_KEY);
+}
+var BAGGAGE_KEY;
+var init_context_helpers = __esmMin((() => {
+	init_context();
+	init_context$1();
+	BAGGAGE_KEY = createContextKey("OpenTelemetry Baggage Key");
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/api/propagation.js
+var API_NAME$1, NOOP_TEXT_MAP_PROPAGATOR, PropagationAPI;
+var init_propagation = __esmMin((() => {
+	init_global_utils();
+	init_NoopTextMapPropagator();
+	init_TextMapPropagator();
+	init_context_helpers();
+	init_utils$1();
+	init_diag();
+	API_NAME$1 = "propagation";
+	NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator();
+	PropagationAPI = class PropagationAPI {
+		/** Empty private constructor prevents end users from constructing a new instance of the API */
+		constructor() {
+			this.createBaggage = createBaggage;
+			this.getBaggage = getBaggage;
+			this.getActiveBaggage = getActiveBaggage;
+			this.setBaggage = setBaggage;
+			this.deleteBaggage = 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 registerGlobal(API_NAME$1, propagator, 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 = 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 = 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() {
+			unregisterGlobal(API_NAME$1, DiagAPI.instance());
+		}
+		_getGlobalPropagator() {
+			return getGlobal(API_NAME$1) || NOOP_TEXT_MAP_PROPAGATOR;
+		}
+	};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/propagation-api.js
+var propagation;
+var init_propagation_api = __esmMin((() => {
+	init_propagation();
+	propagation = PropagationAPI.getInstance();
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/api/trace.js
+var API_NAME, TraceAPI;
+var init_trace = __esmMin((() => {
+	init_global_utils();
+	init_ProxyTracerProvider();
+	init_spancontext_utils();
+	init_context_utils();
+	init_diag();
+	API_NAME = "trace";
+	TraceAPI = class TraceAPI {
+		/** Empty private constructor prevents end users from constructing a new instance of the API */
+		constructor() {
+			this._proxyTracerProvider = new ProxyTracerProvider();
+			this.wrapSpanContext = wrapSpanContext;
+			this.isSpanContextValid = isSpanContextValid;
+			this.deleteSpan = deleteSpan;
+			this.getSpan = getSpan;
+			this.getActiveSpan = getActiveSpan;
+			this.getSpanContext = getSpanContext;
+			this.setSpan = setSpan;
+			this.setSpanContext = 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 = registerGlobal(API_NAME, this._proxyTracerProvider, DiagAPI.instance());
+			if (success) this._proxyTracerProvider.setDelegate(provider);
+			return success;
+		}
+		/**
+		* Returns the global tracer provider.
+		*/
+		getTracerProvider() {
+			return 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() {
+			unregisterGlobal(API_NAME, DiagAPI.instance());
+			this._proxyTracerProvider = new ProxyTracerProvider();
+		}
+	};
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/trace-api.js
+var trace;
+var init_trace_api = __esmMin((() => {
+	init_trace();
+	trace = TraceAPI.getInstance();
+}));
+//#endregion
+//#region ../../../../node_modules/@opentelemetry/api/build/esm/index.js
+var esm_exports = /* @__PURE__ */ __exportAll({
+	DiagConsoleLogger: () => DiagConsoleLogger,
+	DiagLogLevel: () => DiagLogLevel,
+	INVALID_SPANID: () => INVALID_SPANID,
+	INVALID_SPAN_CONTEXT: () => INVALID_SPAN_CONTEXT,
+	INVALID_TRACEID: () => INVALID_TRACEID,
+	ProxyTracer: () => ProxyTracer,
+	ProxyTracerProvider: () => ProxyTracerProvider,
+	ROOT_CONTEXT: () => ROOT_CONTEXT,
+	SamplingDecision: () => SamplingDecision,
+	SpanKind: () => SpanKind,
+	SpanStatusCode: () => SpanStatusCode,
+	TraceFlags: () => TraceFlags,
+	ValueType: () => ValueType,
+	baggageEntryMetadataFromString: () => baggageEntryMetadataFromString,
+	context: () => context,
+	createContextKey: () => createContextKey,
+	createNoopMeter: () => createNoopMeter,
+	createTraceState: () => createTraceState,
+	default: () => esm_default,
+	defaultTextMapGetter: () => defaultTextMapGetter,
+	defaultTextMapSetter: () => defaultTextMapSetter,
+	diag: () => diag,
+	isSpanContextValid: () => isSpanContextValid,
+	isValidSpanId: () => isValidSpanId,
+	isValidTraceId: () => isValidTraceId,
+	metrics: () => metrics,
+	propagation: () => propagation,
+	trace: () => trace
+});
+var esm_default;
+var init_esm = __esmMin((() => {
+	init_utils$1();
+	init_context$1();
+	init_consoleLogger();
+	init_types();
+	init_NoopMeter();
+	init_Metric();
+	init_TextMapPropagator();
+	init_ProxyTracer();
+	init_ProxyTracerProvider();
+	init_SamplingResult();
+	init_span_kind();
+	init_status();
+	init_trace_flags();
+	init_utils();
+	init_spancontext_utils();
+	init_invalid_span_constants();
+	init_context_api();
+	init_diag_api();
+	init_metrics_api();
+	init_propagation_api();
+	init_trace_api();
+	esm_default = {
+		context,
+		diag,
+		metrics,
+		propagation,
+		trace
+	};
+}));
+//#endregion
 //#region src/utils/opentelemetry-trace.ts
 let cachedGetter = void 0;
 function createGetter() {
 	try {
-		const api = __require("@opentelemetry/api");
+		const api = (init_esm(), __toCommonJS(esm_exports));
 		return () => {
 			const span = api.trace?.getSpan?.(api.context?.active?.());
 			if (!span) return {};
@@ -7074,7 +8609,7 @@ function getOpenTelemetryTraceIds() {
 //#region src/core/trace-context.storage.ts
 const traceContextStorage = new AsyncLocalStorage();
 //#endregion
-//#region \0@oxc-project+runtime@0.115.0/helpers/decorate.js
+//#region \0@oxc-project+runtime@0.134.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -7108,13 +8643,12 @@ let TraceContextService = class TraceContextService {
 };
 TraceContextService = __decorate([Injectable()], TraceContextService);
 //#endregion
-//#region \0@oxc-project+runtime@0.115.0/helpers/decorateMetadata.js
+//#region \0@oxc-project+runtime@0.134.0/helpers/esm/decorateMetadata.js
 function __decorateMetadata(k, v) {
 	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 //#endregion
 //#region src/core/logger.service.ts
-var _ref$2;
 const PINO_LEVEL_TO_LOG_LEVEL = {
 	60: "error",
 	50: "error",
@@ -7124,6 +8658,11 @@ const PINO_LEVEL_TO_LOG_LEVEL = {
 	10: "verbose"
 };
 let LoggerService = class LoggerService {
+	config;
+	formatter;
+	writer;
+	contextResolver;
+	traceContextService;
 	context;
 	constructor(config, formatter, writer, contextResolver, traceContextService) {
 		this.config = config;
@@ -7193,10 +8732,10 @@ LoggerService = __decorate([Injectable(), __decorateMetadata("design:paramtypes"
 	Object,
 	Object,
 	Object,
-	typeof (_ref$2 = typeof TraceContextService !== "undefined" && TraceContextService) === "function" ? _ref$2 : Object
+	typeof TraceContextService === "undefined" ? Object : TraceContextService
 ])], LoggerService);
 //#endregion
-//#region \0@oxc-project+runtime@0.115.0/helpers/decorateParam.js
+//#region \0@oxc-project+runtime@0.134.0/helpers/esm/decorateParam.js
 function __decorateParam(paramIndex, decorator) {
 	return function(target, key) {
 		decorator(target, key, paramIndex);
@@ -7204,8 +8743,12 @@ function __decorateParam(paramIndex, decorator) {
 }
 //#endregion
 //#region src/core/http-logger.interceptor.ts
-var _ref$1, _ref2$1;
 let HttpLoggerInterceptor = class HttpLoggerInterceptor {
+	logger;
+	dataSanitizer;
+	requestIdGenerator;
+	config;
+	reflector;
 	hostname = hostname();
 	pid = process.pid;
 	constructor(logger, dataSanitizer, requestIdGenerator, config, reflector) {
@@ -7355,11 +8898,11 @@ HttpLoggerInterceptor = __decorate([
 	Injectable(),
 	__decorateParam(3, Inject(LOGGER_CONFIG_TOKEN)),
 	__decorateMetadata("design:paramtypes", [
-		typeof (_ref$1 = typeof LoggerService !== "undefined" && LoggerService) === "function" ? _ref$1 : Object,
+		typeof LoggerService === "undefined" ? Object : LoggerService,
 		Object,
 		Object,
 		Object,
-		typeof (_ref2$1 = typeof Reflector !== "undefined" && Reflector) === "function" ? _ref2$1 : Object
+		typeof Reflector === "undefined" ? Object : Reflector
 	])
 ], HttpLoggerInterceptor);
 //#endregion
@@ -7382,6 +8925,7 @@ const getAllContextTokens = () => {
 //#endregion
 //#region src/formatters/base-formatter.ts
 var BaseFormatter = class {
+	options;
 	constructor(options) {
 		this.options = options;
 	}
@@ -7420,7 +8964,23 @@ let TextFormatter = class TextFormatter extends BaseFormatter {
 		return entry.trace ? this.addTrace(result, entry.trace) : result;
 	}
 	formatHttpRequest(entry) {
-		return JSON.stringify(entry);
+		const parts = [];
+		if (this.options.timestamp) parts.push(this.colorize(`[${new Date(entry.time).toISOString()}]`, "gray"));
+		const level = entry.level >= 50 ? "error" : entry.level >= 40 ? "warn" : "info";
+		parts.push(this.colorize(`[${level.toUpperCase()}]`, this.getColorForLevel(entry.level)));
+		parts.push(this.colorize("[HTTP]", "cyan"));
+		const { method, url, statusCode, responseTime } = {
+			method: entry.req.method,
+			url: entry.req.url,
+			statusCode: entry.res.statusCode,
+			responseTime: entry.responseTime
+		};
+		parts.push(this.colorize(`${method} ${url} ${statusCode} ${responseTime}ms`, "bright"));
+		if (entry.traceId || entry.spanId) {
+			const ids = [entry.traceId, entry.spanId].filter(Boolean).join("/");
+			parts.push(this.colorize(`[${ids}]`, "magenta"));
+		}
+		return parts.join(" ");
 	}
 	buildLogParts(entry) {
 		const parts = [];
@@ -7599,14 +9159,19 @@ let ConsoleWriter = class ConsoleWriter {
 ConsoleWriter = __decorate([Injectable()], ConsoleWriter);
 //#endregion
 //#region src/factories/dynamic-context-logger.factory.ts
-var _ref, _ref2, _ref3;
 let DynamicContextLoggerFactory = class DynamicContextLoggerFactory {
+	config;
+	formatterFactory;
+	writer;
+	contextResolver;
+	traceContextService;
 	loggerCache = /* @__PURE__ */ new Map();
-	constructor(config, formatterFactory, writer, contextResolver) {
+	constructor(config, formatterFactory, writer, contextResolver, traceContextService) {
 		this.config = config;
 		this.formatterFactory = formatterFactory;
 		this.writer = writer;
 		this.contextResolver = contextResolver;
+		this.traceContextService = traceContextService;
 	}
 	createLogger(context) {
 		if (this.loggerCache.has(context)) return this.loggerCache.get(context);
@@ -7615,7 +9180,7 @@ let DynamicContextLoggerFactory = class DynamicContextLoggerFactory {
 			timestamp: this.config.timestamp,
 			context: this.config.context
 		});
-		const logger = new LoggerService(this.config, formatter, this.writer, this.contextResolver);
+		const logger = new LoggerService(this.config, formatter, this.writer, this.contextResolver, this.traceContextService);
 		logger.setContext(context);
 		this.loggerCache.set(context, logger);
 		return logger;
@@ -7626,14 +9191,16 @@ DynamicContextLoggerFactory = __decorate([
 	__decorateParam(0, Inject(LOGGER_CONFIG_TOKEN)),
 	__decorateMetadata("design:paramtypes", [
 		Object,
-		typeof (_ref = typeof FormatterFactory !== "undefined" && FormatterFactory) === "function" ? _ref : Object,
-		typeof (_ref2 = typeof ConsoleWriter !== "undefined" && ConsoleWriter) === "function" ? _ref2 : Object,
-		typeof (_ref3 = typeof ContextResolver !== "undefined" && ContextResolver) === "function" ? _ref3 : Object
+		typeof FormatterFactory === "undefined" ? Object : FormatterFactory,
+		typeof ConsoleWriter === "undefined" ? Object : ConsoleWriter,
+		typeof ContextResolver === "undefined" ? Object : ContextResolver,
+		typeof TraceContextService === "undefined" ? Object : TraceContextService
 	])
 ], DynamicContextLoggerFactory);
 //#endregion
 //#region src/utils/data-sanitizer.ts
 let DataSanitizer = class DataSanitizer {
+	sensitiveFields;
 	redactedValue = "[REDACTED]";
 	constructor(sensitiveFields) {
 		this.sensitiveFields = sensitiveFields;