imean-service-engine
Version:
基于Hono的轻量级微服务引擎框架
1,288 lines (1,245 loc) • 264 kB
JavaScript
'use strict';
var winston = require('winston');
var html = require('hono/html');
var jsxRuntime = require('hono/jsx/jsx-runtime');
var ejson = require('ejson');
var zod = require('zod');
var crypto = require('crypto');
var fs = require('fs');
var path = require('path');
var prettier = require('prettier');
var nodeServer = require('@hono/node-server');
var hono = require('hono');
var net = require('net');
function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
function _interopNamespace(e) {
if (e && e.__esModule) return e;
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () { return e[k]; }
});
}
});
}
n.default = e;
return Object.freeze(n);
}
var winston__default = /*#__PURE__*/_interopDefault(winston);
var ejson__namespace = /*#__PURE__*/_interopNamespace(ejson);
var prettier__default = /*#__PURE__*/_interopDefault(prettier);
var net__namespace = /*#__PURE__*/_interopNamespace(net);
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
!mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
// node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js
var require_globalThis = __commonJS({
"node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1._globalThis = void 0;
exports$1._globalThis = typeof globalThis === "object" ? globalThis : global;
}
});
// node_modules/@opentelemetry/api/build/src/platform/node/index.js
var require_node = __commonJS({
"node_modules/@opentelemetry/api/build/src/platform/node/index.js"(exports$1) {
var __createBinding = exports$1 && exports$1.__createBinding || (Object.create ? (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() {
return m[k];
} });
}) : (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
o[k2] = m[k];
}));
var __exportStar = exports$1 && exports$1.__exportStar || function(m, exports2) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
};
Object.defineProperty(exports$1, "__esModule", { value: true });
__exportStar(require_globalThis(), exports$1);
}
});
// node_modules/@opentelemetry/api/build/src/platform/index.js
var require_platform = __commonJS({
"node_modules/@opentelemetry/api/build/src/platform/index.js"(exports$1) {
var __createBinding = exports$1 && exports$1.__createBinding || (Object.create ? (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() {
return m[k];
} });
}) : (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
o[k2] = m[k];
}));
var __exportStar = exports$1 && exports$1.__exportStar || function(m, exports2) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
};
Object.defineProperty(exports$1, "__esModule", { value: true });
__exportStar(require_node(), exports$1);
}
});
// node_modules/@opentelemetry/api/build/src/version.js
var require_version = __commonJS({
"node_modules/@opentelemetry/api/build/src/version.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.VERSION = void 0;
exports$1.VERSION = "1.9.0";
}
});
// node_modules/@opentelemetry/api/build/src/internal/semver.js
var require_semver = __commonJS({
"node_modules/@opentelemetry/api/build/src/internal/semver.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.isCompatible = exports$1._makeCompatibilityCheck = void 0;
var version_1 = require_version();
var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
function _makeCompatibilityCheck(ownVersion) {
const acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
const rejectedVersions = /* @__PURE__ */ new Set();
const myVersionMatch = ownVersion.match(re);
if (!myVersionMatch) {
return () => false;
}
const ownVersionParsed = {
major: +myVersionMatch[1],
minor: +myVersionMatch[2],
patch: +myVersionMatch[3],
prerelease: myVersionMatch[4]
};
if (ownVersionParsed.prerelease != null) {
return function isExactmatch(globalVersion) {
return globalVersion === ownVersion;
};
}
function _reject(v) {
rejectedVersions.add(v);
return false;
}
function _accept(v) {
acceptedVersions.add(v);
return true;
}
return function isCompatible(globalVersion) {
if (acceptedVersions.has(globalVersion)) {
return true;
}
if (rejectedVersions.has(globalVersion)) {
return false;
}
const globalVersionMatch = globalVersion.match(re);
if (!globalVersionMatch) {
return _reject(globalVersion);
}
const globalVersionParsed = {
major: +globalVersionMatch[1],
minor: +globalVersionMatch[2],
patch: +globalVersionMatch[3],
prerelease: globalVersionMatch[4]
};
if (globalVersionParsed.prerelease != null) {
return _reject(globalVersion);
}
if (ownVersionParsed.major !== globalVersionParsed.major) {
return _reject(globalVersion);
}
if (ownVersionParsed.major === 0) {
if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
return _accept(globalVersion);
}
return _reject(globalVersion);
}
if (ownVersionParsed.minor <= globalVersionParsed.minor) {
return _accept(globalVersion);
}
return _reject(globalVersion);
};
}
exports$1._makeCompatibilityCheck = _makeCompatibilityCheck;
exports$1.isCompatible = _makeCompatibilityCheck(version_1.VERSION);
}
});
// node_modules/@opentelemetry/api/build/src/internal/global-utils.js
var require_global_utils = __commonJS({
"node_modules/@opentelemetry/api/build/src/internal/global-utils.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.unregisterGlobal = exports$1.getGlobal = exports$1.registerGlobal = void 0;
var platform_1 = require_platform();
var version_1 = require_version();
var semver_1 = require_semver();
var major = version_1.VERSION.split(".")[0];
var GLOBAL_OPENTELEMETRY_API_KEY = /* @__PURE__ */ Symbol.for(`opentelemetry.js.api.${major}`);
var _global = platform_1._globalThis;
function registerGlobal(type, instance, diag, allowOverride = false) {
var _a;
const api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
version: version_1.VERSION
};
if (!allowOverride && api[type]) {
const err = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`);
diag.error(err.stack || err.message);
return false;
}
if (api.version !== version_1.VERSION) {
const err = new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${version_1.VERSION}`);
diag.error(err.stack || err.message);
return false;
}
api[type] = instance;
diag.debug(`@opentelemetry/api: Registered a global for ${type} v${version_1.VERSION}.`);
return true;
}
exports$1.registerGlobal = registerGlobal;
function getGlobal(type) {
var _a, _b;
const globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
if (!globalVersion || !(0, semver_1.isCompatible)(globalVersion)) {
return;
}
return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
}
exports$1.getGlobal = getGlobal;
function unregisterGlobal(type, diag) {
diag.debug(`@opentelemetry/api: Unregistering a global for ${type} v${version_1.VERSION}.`);
const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
if (api) {
delete api[type];
}
}
exports$1.unregisterGlobal = unregisterGlobal;
}
});
// node_modules/@opentelemetry/api/build/src/diag/ComponentLogger.js
var require_ComponentLogger = __commonJS({
"node_modules/@opentelemetry/api/build/src/diag/ComponentLogger.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.DiagComponentLogger = void 0;
var global_utils_1 = require_global_utils();
var DiagComponentLogger = class {
constructor(props) {
this._namespace = props.namespace || "DiagComponentLogger";
}
debug(...args) {
return logProxy("debug", this._namespace, args);
}
error(...args) {
return logProxy("error", this._namespace, args);
}
info(...args) {
return logProxy("info", this._namespace, args);
}
warn(...args) {
return logProxy("warn", this._namespace, args);
}
verbose(...args) {
return logProxy("verbose", this._namespace, args);
}
};
exports$1.DiagComponentLogger = DiagComponentLogger;
function logProxy(funcName, namespace, args) {
const logger2 = (0, global_utils_1.getGlobal)("diag");
if (!logger2) {
return;
}
args.unshift(namespace);
return logger2[funcName](...args);
}
}
});
// node_modules/@opentelemetry/api/build/src/diag/types.js
var require_types = __commonJS({
"node_modules/@opentelemetry/api/build/src/diag/types.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.DiagLogLevel = void 0;
(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";
})(exports$1.DiagLogLevel || (exports$1.DiagLogLevel = {}));
}
});
// node_modules/@opentelemetry/api/build/src/diag/internal/logLevelLogger.js
var require_logLevelLogger = __commonJS({
"node_modules/@opentelemetry/api/build/src/diag/internal/logLevelLogger.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.createLogLevelDiagLogger = void 0;
var types_1 = require_types();
function createLogLevelDiagLogger(maxLevel, logger2) {
if (maxLevel < types_1.DiagLogLevel.NONE) {
maxLevel = types_1.DiagLogLevel.NONE;
} else if (maxLevel > types_1.DiagLogLevel.ALL) {
maxLevel = types_1.DiagLogLevel.ALL;
}
logger2 = logger2 || {};
function _filterFunc(funcName, theLevel) {
const theFunc = logger2[funcName];
if (typeof theFunc === "function" && maxLevel >= theLevel) {
return theFunc.bind(logger2);
}
return function() {
};
}
return {
error: _filterFunc("error", types_1.DiagLogLevel.ERROR),
warn: _filterFunc("warn", types_1.DiagLogLevel.WARN),
info: _filterFunc("info", types_1.DiagLogLevel.INFO),
debug: _filterFunc("debug", types_1.DiagLogLevel.DEBUG),
verbose: _filterFunc("verbose", types_1.DiagLogLevel.VERBOSE)
};
}
exports$1.createLogLevelDiagLogger = createLogLevelDiagLogger;
}
});
// node_modules/@opentelemetry/api/build/src/api/diag.js
var require_diag = __commonJS({
"node_modules/@opentelemetry/api/build/src/api/diag.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.DiagAPI = void 0;
var ComponentLogger_1 = require_ComponentLogger();
var logLevelLogger_1 = require_logLevelLogger();
var types_1 = require_types();
var global_utils_1 = require_global_utils();
var API_NAME = "diag";
var DiagAPI = class _DiagAPI {
/**
* Private internal constructor
* @private
*/
constructor() {
function _logProxy(funcName) {
return function(...args) {
const logger2 = (0, global_utils_1.getGlobal)("diag");
if (!logger2)
return;
return logger2[funcName](...args);
};
}
const self = this;
const setLogger = (logger2, optionsOrLogLevel = { logLevel: types_1.DiagLogLevel.INFO }) => {
var _a, _b, _c;
if (logger2 === self) {
const err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
return false;
}
if (typeof optionsOrLogLevel === "number") {
optionsOrLogLevel = {
logLevel: optionsOrLogLevel
};
}
const oldLogger = (0, global_utils_1.getGlobal)("diag");
const newLogger = (0, logLevelLogger_1.createLogLevelDiagLogger)((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : types_1.DiagLogLevel.INFO, logger2);
if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
const stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
oldLogger.warn(`Current logger will be overwritten from ${stack}`);
newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
}
return (0, global_utils_1.registerGlobal)("diag", newLogger, self, true);
};
self.setLogger = setLogger;
self.disable = () => {
(0, global_utils_1.unregisterGlobal)(API_NAME, self);
};
self.createComponentLogger = (options) => {
return new ComponentLogger_1.DiagComponentLogger(options);
};
self.verbose = _logProxy("verbose");
self.debug = _logProxy("debug");
self.info = _logProxy("info");
self.warn = _logProxy("warn");
self.error = _logProxy("error");
}
/** Get the singleton instance of the DiagAPI API */
static instance() {
if (!this._instance) {
this._instance = new _DiagAPI();
}
return this._instance;
}
};
exports$1.DiagAPI = DiagAPI;
}
});
// node_modules/@opentelemetry/api/build/src/baggage/internal/baggage-impl.js
var require_baggage_impl = __commonJS({
"node_modules/@opentelemetry/api/build/src/baggage/internal/baggage-impl.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.BaggageImpl = void 0;
var BaggageImpl = class _BaggageImpl {
constructor(entries) {
this._entries = entries ? new Map(entries) : /* @__PURE__ */ new Map();
}
getEntry(key) {
const entry = this._entries.get(key);
if (!entry) {
return void 0;
}
return Object.assign({}, entry);
}
getAllEntries() {
return Array.from(this._entries.entries()).map(([k, v]) => [k, v]);
}
setEntry(key, entry) {
const newBaggage = new _BaggageImpl(this._entries);
newBaggage._entries.set(key, entry);
return newBaggage;
}
removeEntry(key) {
const newBaggage = new _BaggageImpl(this._entries);
newBaggage._entries.delete(key);
return newBaggage;
}
removeEntries(...keys) {
const newBaggage = new _BaggageImpl(this._entries);
for (const key of keys) {
newBaggage._entries.delete(key);
}
return newBaggage;
}
clear() {
return new _BaggageImpl();
}
};
exports$1.BaggageImpl = BaggageImpl;
}
});
// node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.js
var require_symbol = __commonJS({
"node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.baggageEntryMetadataSymbol = void 0;
exports$1.baggageEntryMetadataSymbol = /* @__PURE__ */ Symbol("BaggageEntryMetadata");
}
});
// node_modules/@opentelemetry/api/build/src/baggage/utils.js
var require_utils = __commonJS({
"node_modules/@opentelemetry/api/build/src/baggage/utils.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.baggageEntryMetadataFromString = exports$1.createBaggage = void 0;
var diag_1 = require_diag();
var baggage_impl_1 = require_baggage_impl();
var symbol_1 = require_symbol();
var diag = diag_1.DiagAPI.instance();
function createBaggage(entries = {}) {
return new baggage_impl_1.BaggageImpl(new Map(Object.entries(entries)));
}
exports$1.createBaggage = createBaggage;
function baggageEntryMetadataFromString(str) {
if (typeof str !== "string") {
diag.error(`Cannot create baggage metadata from unknown type: ${typeof str}`);
str = "";
}
return {
__TYPE__: symbol_1.baggageEntryMetadataSymbol,
toString() {
return str;
}
};
}
exports$1.baggageEntryMetadataFromString = baggageEntryMetadataFromString;
}
});
// node_modules/@opentelemetry/api/build/src/context/context.js
var require_context = __commonJS({
"node_modules/@opentelemetry/api/build/src/context/context.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.ROOT_CONTEXT = exports$1.createContextKey = void 0;
function createContextKey(description) {
return Symbol.for(description);
}
exports$1.createContextKey = createContextKey;
var BaseContext = class _BaseContext {
/**
* Construct a new context which inherits values from an optional parent context.
*
* @param parentContext a context from which to inherit values
*/
constructor(parentContext) {
const self = this;
self._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
self.getValue = (key) => self._currentContext.get(key);
self.setValue = (key, value) => {
const context = new _BaseContext(self._currentContext);
context._currentContext.set(key, value);
return context;
};
self.deleteValue = (key) => {
const context = new _BaseContext(self._currentContext);
context._currentContext.delete(key);
return context;
};
}
};
exports$1.ROOT_CONTEXT = new BaseContext();
}
});
// node_modules/@opentelemetry/api/build/src/diag/consoleLogger.js
var require_consoleLogger = __commonJS({
"node_modules/@opentelemetry/api/build/src/diag/consoleLogger.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.DiagConsoleLogger = void 0;
var consoleMap = [
{ n: "error", c: "error" },
{ n: "warn", c: "warn" },
{ n: "info", c: "info" },
{ n: "debug", c: "debug" },
{ n: "verbose", c: "trace" }
];
var DiagConsoleLogger = class {
constructor() {
function _consoleFunc(funcName) {
return function(...args) {
if (console) {
let theFunc = console[funcName];
if (typeof theFunc !== "function") {
theFunc = console.log;
}
if (typeof theFunc === "function") {
return theFunc.apply(console, args);
}
}
};
}
for (let i = 0; i < consoleMap.length; i++) {
this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);
}
}
};
exports$1.DiagConsoleLogger = DiagConsoleLogger;
}
});
// node_modules/@opentelemetry/api/build/src/metrics/NoopMeter.js
var require_NoopMeter = __commonJS({
"node_modules/@opentelemetry/api/build/src/metrics/NoopMeter.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.createNoopMeter = exports$1.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = exports$1.NOOP_OBSERVABLE_GAUGE_METRIC = exports$1.NOOP_OBSERVABLE_COUNTER_METRIC = exports$1.NOOP_UP_DOWN_COUNTER_METRIC = exports$1.NOOP_HISTOGRAM_METRIC = exports$1.NOOP_GAUGE_METRIC = exports$1.NOOP_COUNTER_METRIC = exports$1.NOOP_METER = exports$1.NoopObservableUpDownCounterMetric = exports$1.NoopObservableGaugeMetric = exports$1.NoopObservableCounterMetric = exports$1.NoopObservableMetric = exports$1.NoopHistogramMetric = exports$1.NoopGaugeMetric = exports$1.NoopUpDownCounterMetric = exports$1.NoopCounterMetric = exports$1.NoopMetric = exports$1.NoopMeter = void 0;
var NoopMeter = class {
constructor() {
}
/**
* @see {@link Meter.createGauge}
*/
createGauge(_name, _options) {
return exports$1.NOOP_GAUGE_METRIC;
}
/**
* @see {@link Meter.createHistogram}
*/
createHistogram(_name, _options) {
return exports$1.NOOP_HISTOGRAM_METRIC;
}
/**
* @see {@link Meter.createCounter}
*/
createCounter(_name, _options) {
return exports$1.NOOP_COUNTER_METRIC;
}
/**
* @see {@link Meter.createUpDownCounter}
*/
createUpDownCounter(_name, _options) {
return exports$1.NOOP_UP_DOWN_COUNTER_METRIC;
}
/**
* @see {@link Meter.createObservableGauge}
*/
createObservableGauge(_name, _options) {
return exports$1.NOOP_OBSERVABLE_GAUGE_METRIC;
}
/**
* @see {@link Meter.createObservableCounter}
*/
createObservableCounter(_name, _options) {
return exports$1.NOOP_OBSERVABLE_COUNTER_METRIC;
}
/**
* @see {@link Meter.createObservableUpDownCounter}
*/
createObservableUpDownCounter(_name, _options) {
return exports$1.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
}
/**
* @see {@link Meter.addBatchObservableCallback}
*/
addBatchObservableCallback(_callback, _observables) {
}
/**
* @see {@link Meter.removeBatchObservableCallback}
*/
removeBatchObservableCallback(_callback) {
}
};
exports$1.NoopMeter = NoopMeter;
var NoopMetric = class {
};
exports$1.NoopMetric = NoopMetric;
var NoopCounterMetric = class extends NoopMetric {
add(_value, _attributes) {
}
};
exports$1.NoopCounterMetric = NoopCounterMetric;
var NoopUpDownCounterMetric = class extends NoopMetric {
add(_value, _attributes) {
}
};
exports$1.NoopUpDownCounterMetric = NoopUpDownCounterMetric;
var NoopGaugeMetric = class extends NoopMetric {
record(_value, _attributes) {
}
};
exports$1.NoopGaugeMetric = NoopGaugeMetric;
var NoopHistogramMetric = class extends NoopMetric {
record(_value, _attributes) {
}
};
exports$1.NoopHistogramMetric = NoopHistogramMetric;
var NoopObservableMetric = class {
addCallback(_callback) {
}
removeCallback(_callback) {
}
};
exports$1.NoopObservableMetric = NoopObservableMetric;
var NoopObservableCounterMetric = class extends NoopObservableMetric {
};
exports$1.NoopObservableCounterMetric = NoopObservableCounterMetric;
var NoopObservableGaugeMetric = class extends NoopObservableMetric {
};
exports$1.NoopObservableGaugeMetric = NoopObservableGaugeMetric;
var NoopObservableUpDownCounterMetric = class extends NoopObservableMetric {
};
exports$1.NoopObservableUpDownCounterMetric = NoopObservableUpDownCounterMetric;
exports$1.NOOP_METER = new NoopMeter();
exports$1.NOOP_COUNTER_METRIC = new NoopCounterMetric();
exports$1.NOOP_GAUGE_METRIC = new NoopGaugeMetric();
exports$1.NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric();
exports$1.NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric();
exports$1.NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();
exports$1.NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();
exports$1.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();
function createNoopMeter() {
return exports$1.NOOP_METER;
}
exports$1.createNoopMeter = createNoopMeter;
}
});
// node_modules/@opentelemetry/api/build/src/metrics/Metric.js
var require_Metric = __commonJS({
"node_modules/@opentelemetry/api/build/src/metrics/Metric.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.ValueType = void 0;
(function(ValueType2) {
ValueType2[ValueType2["INT"] = 0] = "INT";
ValueType2[ValueType2["DOUBLE"] = 1] = "DOUBLE";
})(exports$1.ValueType || (exports$1.ValueType = {}));
}
});
// node_modules/@opentelemetry/api/build/src/propagation/TextMapPropagator.js
var require_TextMapPropagator = __commonJS({
"node_modules/@opentelemetry/api/build/src/propagation/TextMapPropagator.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.defaultTextMapSetter = exports$1.defaultTextMapGetter = void 0;
exports$1.defaultTextMapGetter = {
get(carrier, key) {
if (carrier == null) {
return void 0;
}
return carrier[key];
},
keys(carrier) {
if (carrier == null) {
return [];
}
return Object.keys(carrier);
}
};
exports$1.defaultTextMapSetter = {
set(carrier, key, value) {
if (carrier == null) {
return;
}
carrier[key] = value;
}
};
}
});
// node_modules/@opentelemetry/api/build/src/context/NoopContextManager.js
var require_NoopContextManager = __commonJS({
"node_modules/@opentelemetry/api/build/src/context/NoopContextManager.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.NoopContextManager = void 0;
var context_1 = require_context();
var NoopContextManager = class {
active() {
return context_1.ROOT_CONTEXT;
}
with(_context, fn, thisArg, ...args) {
return fn.call(thisArg, ...args);
}
bind(_context, target) {
return target;
}
enable() {
return this;
}
disable() {
return this;
}
};
exports$1.NoopContextManager = NoopContextManager;
}
});
// node_modules/@opentelemetry/api/build/src/api/context.js
var require_context2 = __commonJS({
"node_modules/@opentelemetry/api/build/src/api/context.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.ContextAPI = void 0;
var NoopContextManager_1 = require_NoopContextManager();
var global_utils_1 = require_global_utils();
var diag_1 = require_diag();
var API_NAME = "context";
var NOOP_CONTEXT_MANAGER = new NoopContextManager_1.NoopContextManager();
var ContextAPI = class _ContextAPI {
/** Empty private constructor prevents end users from constructing a new instance of the API */
constructor() {
}
/** Get the singleton instance of the Context API */
static getInstance() {
if (!this._instance) {
this._instance = new _ContextAPI();
}
return this._instance;
}
/**
* Set the current context manager.
*
* @returns true if the context manager was successfully registered, else false
*/
setGlobalContextManager(contextManager) {
return (0, global_utils_1.registerGlobal)(API_NAME, contextManager, diag_1.DiagAPI.instance());
}
/**
* Get the currently active context
*/
active() {
return this._getContextManager().active();
}
/**
* Execute a function with an active context
*
* @param context context to be active during function execution
* @param fn function to execute in a context
* @param thisArg optional receiver to be used for calling fn
* @param args optional arguments forwarded to fn
*/
with(context, fn, thisArg, ...args) {
return this._getContextManager().with(context, fn, thisArg, ...args);
}
/**
* Bind a context to a target function or event emitter
*
* @param context context to bind to the event emitter or function. Defaults to the currently active context
* @param target function or event emitter to bind
*/
bind(context, target) {
return this._getContextManager().bind(context, target);
}
_getContextManager() {
return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_CONTEXT_MANAGER;
}
/** Disable and remove the global context manager */
disable() {
this._getContextManager().disable();
(0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
}
};
exports$1.ContextAPI = ContextAPI;
}
});
// node_modules/@opentelemetry/api/build/src/trace/trace_flags.js
var require_trace_flags = __commonJS({
"node_modules/@opentelemetry/api/build/src/trace/trace_flags.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.TraceFlags = void 0;
(function(TraceFlags2) {
TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
})(exports$1.TraceFlags || (exports$1.TraceFlags = {}));
}
});
// node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.js
var require_invalid_span_constants = __commonJS({
"node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.INVALID_SPAN_CONTEXT = exports$1.INVALID_TRACEID = exports$1.INVALID_SPANID = void 0;
var trace_flags_1 = require_trace_flags();
exports$1.INVALID_SPANID = "0000000000000000";
exports$1.INVALID_TRACEID = "00000000000000000000000000000000";
exports$1.INVALID_SPAN_CONTEXT = {
traceId: exports$1.INVALID_TRACEID,
spanId: exports$1.INVALID_SPANID,
traceFlags: trace_flags_1.TraceFlags.NONE
};
}
});
// node_modules/@opentelemetry/api/build/src/trace/NonRecordingSpan.js
var require_NonRecordingSpan = __commonJS({
"node_modules/@opentelemetry/api/build/src/trace/NonRecordingSpan.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.NonRecordingSpan = void 0;
var invalid_span_constants_1 = require_invalid_span_constants();
var NonRecordingSpan = class {
constructor(_spanContext = invalid_span_constants_1.INVALID_SPAN_CONTEXT) {
this._spanContext = _spanContext;
}
// Returns a SpanContext.
spanContext() {
return this._spanContext;
}
// By default does nothing
setAttribute(_key, _value) {
return this;
}
// By default does nothing
setAttributes(_attributes) {
return this;
}
// By default does nothing
addEvent(_name, _attributes) {
return this;
}
addLink(_link) {
return this;
}
addLinks(_links) {
return this;
}
// By default does nothing
setStatus(_status) {
return this;
}
// By default does nothing
updateName(_name) {
return this;
}
// By default does nothing
end(_endTime) {
}
// isRecording always returns false for NonRecordingSpan.
isRecording() {
return false;
}
// By default does nothing
recordException(_exception, _time) {
}
};
exports$1.NonRecordingSpan = NonRecordingSpan;
}
});
// node_modules/@opentelemetry/api/build/src/trace/context-utils.js
var require_context_utils = __commonJS({
"node_modules/@opentelemetry/api/build/src/trace/context-utils.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.getSpanContext = exports$1.setSpanContext = exports$1.deleteSpan = exports$1.setSpan = exports$1.getActiveSpan = exports$1.getSpan = void 0;
var context_1 = require_context();
var NonRecordingSpan_1 = require_NonRecordingSpan();
var context_2 = require_context2();
var SPAN_KEY = (0, context_1.createContextKey)("OpenTelemetry Context Key SPAN");
function getSpan(context) {
return context.getValue(SPAN_KEY) || void 0;
}
exports$1.getSpan = getSpan;
function getActiveSpan() {
return getSpan(context_2.ContextAPI.getInstance().active());
}
exports$1.getActiveSpan = getActiveSpan;
function setSpan(context, span) {
return context.setValue(SPAN_KEY, span);
}
exports$1.setSpan = setSpan;
function deleteSpan(context) {
return context.deleteValue(SPAN_KEY);
}
exports$1.deleteSpan = deleteSpan;
function setSpanContext(context, spanContext) {
return setSpan(context, new NonRecordingSpan_1.NonRecordingSpan(spanContext));
}
exports$1.setSpanContext = setSpanContext;
function getSpanContext(context) {
var _a;
return (_a = getSpan(context)) === null || _a === void 0 ? void 0 : _a.spanContext();
}
exports$1.getSpanContext = getSpanContext;
}
});
// node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.js
var require_spancontext_utils = __commonJS({
"node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.wrapSpanContext = exports$1.isSpanContextValid = exports$1.isValidSpanId = exports$1.isValidTraceId = void 0;
var invalid_span_constants_1 = require_invalid_span_constants();
var NonRecordingSpan_1 = require_NonRecordingSpan();
var VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
var VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
function isValidTraceId(traceId) {
return VALID_TRACEID_REGEX.test(traceId) && traceId !== invalid_span_constants_1.INVALID_TRACEID;
}
exports$1.isValidTraceId = isValidTraceId;
function isValidSpanId(spanId) {
return VALID_SPANID_REGEX.test(spanId) && spanId !== invalid_span_constants_1.INVALID_SPANID;
}
exports$1.isValidSpanId = isValidSpanId;
function isSpanContextValid(spanContext) {
return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
}
exports$1.isSpanContextValid = isSpanContextValid;
function wrapSpanContext(spanContext) {
return new NonRecordingSpan_1.NonRecordingSpan(spanContext);
}
exports$1.wrapSpanContext = wrapSpanContext;
}
});
// node_modules/@opentelemetry/api/build/src/trace/NoopTracer.js
var require_NoopTracer = __commonJS({
"node_modules/@opentelemetry/api/build/src/trace/NoopTracer.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.NoopTracer = void 0;
var context_1 = require_context2();
var context_utils_1 = require_context_utils();
var NonRecordingSpan_1 = require_NonRecordingSpan();
var spancontext_utils_1 = require_spancontext_utils();
var contextApi = context_1.ContextAPI.getInstance();
var NoopTracer = class {
// startSpan starts a noop span.
startSpan(name, options, context = contextApi.active()) {
const root = Boolean(options === null || options === void 0 ? void 0 : options.root);
if (root) {
return new NonRecordingSpan_1.NonRecordingSpan();
}
const parentFromContext = context && (0, context_utils_1.getSpanContext)(context);
if (isSpanContext(parentFromContext) && (0, spancontext_utils_1.isSpanContextValid)(parentFromContext)) {
return new NonRecordingSpan_1.NonRecordingSpan(parentFromContext);
} else {
return new NonRecordingSpan_1.NonRecordingSpan();
}
}
startActiveSpan(name, arg2, arg3, arg4) {
let opts;
let ctx;
let fn;
if (arguments.length < 2) {
return;
} else if (arguments.length === 2) {
fn = arg2;
} else if (arguments.length === 3) {
opts = arg2;
fn = arg3;
} else {
opts = arg2;
ctx = arg3;
fn = arg4;
}
const parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
const span = this.startSpan(name, opts, parentContext);
const contextWithSpanSet = (0, context_utils_1.setSpan)(parentContext, span);
return contextApi.with(contextWithSpanSet, fn, void 0, span);
}
};
exports$1.NoopTracer = NoopTracer;
function isSpanContext(spanContext) {
return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
}
}
});
// node_modules/@opentelemetry/api/build/src/trace/ProxyTracer.js
var require_ProxyTracer = __commonJS({
"node_modules/@opentelemetry/api/build/src/trace/ProxyTracer.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.ProxyTracer = void 0;
var NoopTracer_1 = require_NoopTracer();
var NOOP_TRACER = new NoopTracer_1.NoopTracer();
var ProxyTracer = class {
constructor(_provider, name, version, options) {
this._provider = _provider;
this.name = name;
this.version = version;
this.options = options;
}
startSpan(name, options, context) {
return this._getTracer().startSpan(name, options, context);
}
startActiveSpan(_name, _options, _context, _fn) {
const tracer2 = this._getTracer();
return Reflect.apply(tracer2.startActiveSpan, tracer2, 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 tracer2 = this._provider.getDelegateTracer(this.name, this.version, this.options);
if (!tracer2) {
return NOOP_TRACER;
}
this._delegate = tracer2;
return this._delegate;
}
};
exports$1.ProxyTracer = ProxyTracer;
}
});
// node_modules/@opentelemetry/api/build/src/trace/NoopTracerProvider.js
var require_NoopTracerProvider = __commonJS({
"node_modules/@opentelemetry/api/build/src/trace/NoopTracerProvider.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.NoopTracerProvider = void 0;
var NoopTracer_1 = require_NoopTracer();
var NoopTracerProvider = class {
getTracer(_name, _version, _options) {
return new NoopTracer_1.NoopTracer();
}
};
exports$1.NoopTracerProvider = NoopTracerProvider;
}
});
// node_modules/@opentelemetry/api/build/src/trace/ProxyTracerProvider.js
var require_ProxyTracerProvider = __commonJS({
"node_modules/@opentelemetry/api/build/src/trace/ProxyTracerProvider.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.ProxyTracerProvider = void 0;
var ProxyTracer_1 = require_ProxyTracer();
var NoopTracerProvider_1 = require_NoopTracerProvider();
var NOOP_TRACER_PROVIDER = new NoopTracerProvider_1.NoopTracerProvider();
var ProxyTracerProvider = class {
/**
* Get a {@link ProxyTracer}
*/
getTracer(name, version, options) {
var _a;
return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer_1.ProxyTracer(this, name, version, options);
}
getDelegate() {
var _a;
return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
}
/**
* Set the delegate tracer provider
*/
setDelegate(delegate) {
this._delegate = delegate;
}
getDelegateTracer(name, version, options) {
var _a;
return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
}
};
exports$1.ProxyTracerProvider = ProxyTracerProvider;
}
});
// node_modules/@opentelemetry/api/build/src/trace/SamplingResult.js
var require_SamplingResult = __commonJS({
"node_modules/@opentelemetry/api/build/src/trace/SamplingResult.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.SamplingDecision = void 0;
(function(SamplingDecision2) {
SamplingDecision2[SamplingDecision2["NOT_RECORD"] = 0] = "NOT_RECORD";
SamplingDecision2[SamplingDecision2["RECORD"] = 1] = "RECORD";
SamplingDecision2[SamplingDecision2["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
})(exports$1.SamplingDecision || (exports$1.SamplingDecision = {}));
}
});
// node_modules/@opentelemetry/api/build/src/trace/span_kind.js
var require_span_kind = __commonJS({
"node_modules/@opentelemetry/api/build/src/trace/span_kind.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.SpanKind = void 0;
(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";
})(exports$1.SpanKind || (exports$1.SpanKind = {}));
}
});
// node_modules/@opentelemetry/api/build/src/trace/status.js
var require_status = __commonJS({
"node_modules/@opentelemetry/api/build/src/trace/status.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.SpanStatusCode = void 0;
(function(SpanStatusCode3) {
SpanStatusCode3[SpanStatusCode3["UNSET"] = 0] = "UNSET";
SpanStatusCode3[SpanStatusCode3["OK"] = 1] = "OK";
SpanStatusCode3[SpanStatusCode3["ERROR"] = 2] = "ERROR";
})(exports$1.SpanStatusCode || (exports$1.SpanStatusCode = {}));
}
});
// node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-validators.js
var require_tracestate_validators = __commonJS({
"node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-validators.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.validateValue = exports$1.validateKey = void 0;
var VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
var VALID_KEY = `[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`;
var VALID_VENDOR_KEY = `[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`;
var VALID_KEY_REGEX = new RegExp(`^(?:${VALID_KEY}|${VALID_VENDOR_KEY})$`);
var VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
var INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
function validateKey(key) {
return VALID_KEY_REGEX.test(key);
}
exports$1.validateKey = validateKey;
function validateValue(value) {
return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
}
exports$1.validateValue = validateValue;
}
});
// node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-impl.js
var require_tracestate_impl = __commonJS({
"node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-impl.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.TraceStateImpl = void 0;
var tracestate_validators_1 = require_tracestate_validators();
var MAX_TRACE_STATE_ITEMS = 32;
var MAX_TRACE_STATE_LEN = 512;
var LIST_MEMBERS_SEPARATOR = ",";
var LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
var TraceStateImpl = class _TraceStateImpl {
constructor(rawTraceState) {
this._internalState = /* @__PURE__ */ new Map();
if (rawTraceState)
this._parse(rawTraceState);
}
set(key, value) {
const traceState = this._clone();
if (traceState._internalState.has(key)) {
traceState._internalState.delete(key);
}
traceState._internalState.set(key, value);
return traceState;
}
unset(key) {
const traceState = this._clone();
traceState._internalState.delete(key);
return traceState;
}
get(key) {
return this._internalState.get(key);
}
serialize() {
return this._keys().reduce((agg, key) => {
agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key));
return agg;
}, []).join(LIST_MEMBERS_SEPARATOR);
}
_parse(rawTraceState) {
if (rawTraceState.length > MAX_TRACE_STATE_LEN)
return;
this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reverse().reduce((agg, part) => {
const listMember = part.trim();
const i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
if (i !== -1) {
const key = listMember.slice(0, i);
const value = listMember.slice(i + 1, part.length);
if ((0, tracestate_validators_1.validateKey)(key) && (0, tracestate_validators_1.validateValue)(value)) {
agg.set(key, value);
}
}
return agg;
}, /* @__PURE__ */ new Map());
if (this._internalState.size > MAX_TRACE_STATE_ITEMS) {
this._internalState = new Map(Array.from(this._internalState.entries()).reverse().slice(0, MAX_TRACE_STATE_ITEMS));
}
}
_keys() {
return Array.from(this._internalState.keys()).reverse();
}
_clone() {
const traceState = new _TraceStateImpl();
traceState._internalState = new Map(this._internalState);
return traceState;
}
};
exports$1.TraceStateImpl = TraceStateImpl;
}
});
// node_modules/@opentelemetry/api/build/src/trace/internal/utils.js
var require_utils2 = __commonJS({
"node_modules/@opentelemetry/api/build/src/trace/internal/utils.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.createTraceState = void 0;
var tracestate_impl_1 = require_tracestate_impl();
function createTraceState(rawTraceState) {
return new tracestate_impl_1.TraceStateImpl(rawTraceState);
}
exports$1.createTraceState = createTraceState;
}
});
// node_modules/@opentelemetry/api/build/src/context-api.js
var require_context_api = __commonJS({
"node_modules/@opentelemetry/api/build/src/context-api.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.context = void 0;
var context_1 = require_context2();
exports$1.context = context_1.ContextAPI.getInstance();
}
});
// node_modules/@opentelemetry/api/build/src/diag-api.js
var require_diag_api = __commonJS({
"node_modules/@opentelemetry/api/build/src/diag-api.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.diag = void 0;
var diag_1 = require_diag();
exports$1.diag = diag_1.DiagAPI.instance();
}
});
// node_modules/@opentelemetry/api/build/src/metrics/NoopMeterProvider.js
var require_NoopMeterProvider = __commonJS({
"node_modules/@opentelemetry/api/build/src/metrics/NoopMeterProvider.js"(exports$1) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.NOOP_METER_PROVIDER = exports$1.NoopMeterProvider = void 0;
var NoopMeter_1 = require_NoopMeter();
var NoopMeterProvider = class {
getMeter(_name, _version, _options) {
return NoopMeter_1.NOOP_METER;
}
};
exports$1.NoopMeterProvider = NoopMeterProvider;
exports$1.NOOP_METE