@pocket-tools/tracing 0.0.0-development

package/dist/index.mjs

@@ -0,0 +1,1778 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js
+var _globalThis;
+var init_globalThis = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js"() {
+    _globalThis = typeof globalThis === "object" ? globalThis : global;
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/platform/node/index.js
+var init_node = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/platform/node/index.js"() {
+    init_globalThis();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/platform/index.js
+var init_platform = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/platform/index.js"() {
+    init_node();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/version.js
+var VERSION;
+var init_version = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/version.js"() {
+    VERSION = "1.8.0";
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/internal/semver.js
+function _makeCompatibilityCheck(ownVersion) {
+  var acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
+  var rejectedVersions = /* @__PURE__ */ new Set();
+  var myVersionMatch = ownVersion.match(re);
+  if (!myVersionMatch) {
+    return function() {
+      return false;
+    };
+  }
+  var ownVersionParsed = {
+    major: +myVersionMatch[1],
+    minor: +myVersionMatch[2],
+    patch: +myVersionMatch[3],
+    prerelease: myVersionMatch[4]
+  };
+  if (ownVersionParsed.prerelease != null) {
+    return function isExactmatch(globalVersion) {
+      return globalVersion === ownVersion;
+    };
+  }
+  function _reject(v) {
+    rejectedVersions.add(v);
+    return false;
+  }
+  function _accept(v) {
+    acceptedVersions.add(v);
+    return true;
+  }
+  return function isCompatible2(globalVersion) {
+    if (acceptedVersions.has(globalVersion)) {
+      return true;
+    }
+    if (rejectedVersions.has(globalVersion)) {
+      return false;
+    }
+    var globalVersionMatch = globalVersion.match(re);
+    if (!globalVersionMatch) {
+      return _reject(globalVersion);
+    }
+    var globalVersionParsed = {
+      major: +globalVersionMatch[1],
+      minor: +globalVersionMatch[2],
+      patch: +globalVersionMatch[3],
+      prerelease: globalVersionMatch[4]
+    };
+    if (globalVersionParsed.prerelease != null) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major !== globalVersionParsed.major) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major === 0) {
+      if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
+        return _accept(globalVersion);
+      }
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.minor <= globalVersionParsed.minor) {
+      return _accept(globalVersion);
+    }
+    return _reject(globalVersion);
+  };
+}
+var re, isCompatible;
+var init_semver = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/internal/semver.js"() {
+    init_version();
+    re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+    isCompatible = _makeCompatibilityCheck(VERSION);
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
+function registerGlobal(type, instance, diag2, allowOverride) {
+  var _a2;
+  if (allowOverride === void 0) {
+    allowOverride = false;
+  }
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a2 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a2 !== void 0 ? _a2 : {
+    version: VERSION
+  };
+  if (!allowOverride && api[type]) {
+    var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
+    diag2.error(err.stack || err.message);
+    return false;
+  }
+  if (api.version !== VERSION) {
+    var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION);
+    diag2.error(err.stack || err.message);
+    return false;
+  }
+  api[type] = instance;
+  diag2.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION + ".");
+  return true;
+}
+function getGlobal(type) {
+  var _a2, _b;
+  var globalVersion = (_a2 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a2 === void 0 ? void 0 : _a2.version;
+  if (!globalVersion || !isCompatible(globalVersion)) {
+    return;
+  }
+  return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+}
+function unregisterGlobal(type, diag2) {
+  diag2.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION + ".");
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+  if (api) {
+    delete api[type];
+  }
+}
+var major, GLOBAL_OPENTELEMETRY_API_KEY, _global;
+var init_global_utils = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/internal/global-utils.js"() {
+    init_platform();
+    init_version();
+    init_semver();
+    major = VERSION.split(".")[0];
+    GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
+    _global = _globalThis;
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
+function logProxy(funcName, namespace, args) {
+  var logger = getGlobal("diag");
+  if (!logger) {
+    return;
+  }
+  args.unshift(namespace);
+  return logger[funcName].apply(logger, __spreadArray([], __read(args), false));
+}
+var __read, __spreadArray, DiagComponentLogger;
+var init_ComponentLogger = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js"() {
+    init_global_utils();
+    __read = function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m)
+        return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+          ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"]))
+            m.call(i);
+        } finally {
+          if (e)
+            throw e.error;
+        }
+      }
+      return ar;
+    };
+    __spreadArray = function(to, from, pack) {
+      if (pack || arguments.length === 2)
+        for (var i = 0, l = from.length, ar; i < l; i++) {
+          if (ar || !(i in from)) {
+            if (!ar)
+              ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+          }
+        }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    DiagComponentLogger = /** @class */
+    function() {
+      function DiagComponentLogger2(props) {
+        this._namespace = props.namespace || "DiagComponentLogger";
+      }
+      DiagComponentLogger2.prototype.debug = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("debug", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.error = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("error", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.info = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("info", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.warn = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("warn", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.verbose = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("verbose", this._namespace, args);
+      };
+      return DiagComponentLogger2;
+    }();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/diag/types.js
+var DiagLogLevel;
+var init_types = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/diag/types.js"() {
+    (function(DiagLogLevel2) {
+      DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
+      DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
+      DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
+      DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
+      DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
+      DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
+      DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
+    })(DiagLogLevel || (DiagLogLevel = {}));
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
+function createLogLevelDiagLogger(maxLevel, logger) {
+  if (maxLevel < DiagLogLevel.NONE) {
+    maxLevel = DiagLogLevel.NONE;
+  } else if (maxLevel > DiagLogLevel.ALL) {
+    maxLevel = DiagLogLevel.ALL;
+  }
+  logger = logger || {};
+  function _filterFunc(funcName, theLevel) {
+    var theFunc = logger[funcName];
+    if (typeof theFunc === "function" && maxLevel >= theLevel) {
+      return theFunc.bind(logger);
+    }
+    return function() {
+    };
+  }
+  return {
+    error: _filterFunc("error", DiagLogLevel.ERROR),
+    warn: _filterFunc("warn", DiagLogLevel.WARN),
+    info: _filterFunc("info", DiagLogLevel.INFO),
+    debug: _filterFunc("debug", DiagLogLevel.DEBUG),
+    verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
+  };
+}
+var init_logLevelLogger = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js"() {
+    init_types();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/api/diag.js
+var __read2, __spreadArray2, API_NAME, DiagAPI;
+var init_diag = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/api/diag.js"() {
+    init_ComponentLogger();
+    init_logLevelLogger();
+    init_types();
+    init_global_utils();
+    __read2 = function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m)
+        return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+          ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"]))
+            m.call(i);
+        } finally {
+          if (e)
+            throw e.error;
+        }
+      }
+      return ar;
+    };
+    __spreadArray2 = function(to, from, pack) {
+      if (pack || arguments.length === 2)
+        for (var i = 0, l = from.length, ar; i < l; i++) {
+          if (ar || !(i in from)) {
+            if (!ar)
+              ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+          }
+        }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    API_NAME = "diag";
+    DiagAPI = /** @class */
+    function() {
+      function DiagAPI2() {
+        function _logProxy(funcName) {
+          return function() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments[_i];
+            }
+            var logger = getGlobal("diag");
+            if (!logger)
+              return;
+            return logger[funcName].apply(logger, __spreadArray2([], __read2(args), false));
+          };
+        }
+        var self = this;
+        var setLogger = function(logger, optionsOrLogLevel) {
+          var _a2, _b, _c;
+          if (optionsOrLogLevel === void 0) {
+            optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
+          }
+          if (logger === self) {
+            var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+            self.error((_a2 = err.stack) !== null && _a2 !== void 0 ? _a2 : err.message);
+            return false;
+          }
+          if (typeof optionsOrLogLevel === "number") {
+            optionsOrLogLevel = {
+              logLevel: optionsOrLogLevel
+            };
+          }
+          var oldLogger = getGlobal("diag");
+          var newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
+          if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+            var stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+            oldLogger.warn("Current logger will be overwritten from " + stack);
+            newLogger.warn("Current logger will overwrite one already registered from " + stack);
+          }
+          return registerGlobal("diag", newLogger, self, true);
+        };
+        self.setLogger = setLogger;
+        self.disable = function() {
+          unregisterGlobal(API_NAME, self);
+        };
+        self.createComponentLogger = function(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");
+      }
+      DiagAPI2.instance = function() {
+        if (!this._instance) {
+          this._instance = new DiagAPI2();
+        }
+        return this._instance;
+      };
+      return DiagAPI2;
+    }();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/context/context.js
+function createContextKey(description) {
+  return Symbol.for(description);
+}
+var BaseContext, ROOT_CONTEXT;
+var init_context = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/context/context.js"() {
+    BaseContext = /** @class */
+    /* @__PURE__ */ function() {
+      function BaseContext2(parentContext) {
+        var self = this;
+        self._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+        self.getValue = function(key) {
+          return self._currentContext.get(key);
+        };
+        self.setValue = function(key, value) {
+          var context2 = new BaseContext2(self._currentContext);
+          context2._currentContext.set(key, value);
+          return context2;
+        };
+        self.deleteValue = function(key) {
+          var context2 = new BaseContext2(self._currentContext);
+          context2._currentContext.delete(key);
+          return context2;
+        };
+      }
+      return BaseContext2;
+    }();
+    ROOT_CONTEXT = new BaseContext();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/diag/consoleLogger.js
+var consoleMap, DiagConsoleLogger;
+var init_consoleLogger = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/diag/consoleLogger.js"() {
+    consoleMap = [
+      { n: "error", c: "error" },
+      { n: "warn", c: "warn" },
+      { n: "info", c: "info" },
+      { n: "debug", c: "debug" },
+      { n: "verbose", c: "trace" }
+    ];
+    DiagConsoleLogger = /** @class */
+    /* @__PURE__ */ function() {
+      function DiagConsoleLogger2() {
+        function _consoleFunc(funcName) {
+          return function() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments[_i];
+            }
+            if (console) {
+              var theFunc = console[funcName];
+              if (typeof theFunc !== "function") {
+                theFunc = console.log;
+              }
+              if (typeof theFunc === "function") {
+                return theFunc.apply(console, args);
+              }
+            }
+          };
+        }
+        for (var i = 0; i < consoleMap.length; i++) {
+          this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);
+        }
+      }
+      return DiagConsoleLogger2;
+    }();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
+var __read3, __spreadArray3, NoopContextManager;
+var init_NoopContextManager = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js"() {
+    init_context();
+    __read3 = function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m)
+        return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+          ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"]))
+            m.call(i);
+        } finally {
+          if (e)
+            throw e.error;
+        }
+      }
+      return ar;
+    };
+    __spreadArray3 = function(to, from, pack) {
+      if (pack || arguments.length === 2)
+        for (var i = 0, l = from.length, ar; i < l; i++) {
+          if (ar || !(i in from)) {
+            if (!ar)
+              ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+          }
+        }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    NoopContextManager = /** @class */
+    function() {
+      function NoopContextManager2() {
+      }
+      NoopContextManager2.prototype.active = function() {
+        return ROOT_CONTEXT;
+      };
+      NoopContextManager2.prototype.with = function(_context, fn, thisArg) {
+        var args = [];
+        for (var _i = 3; _i < arguments.length; _i++) {
+          args[_i - 3] = arguments[_i];
+        }
+        return fn.call.apply(fn, __spreadArray3([thisArg], __read3(args), false));
+      };
+      NoopContextManager2.prototype.bind = function(_context, target) {
+        return target;
+      };
+      NoopContextManager2.prototype.enable = function() {
+        return this;
+      };
+      NoopContextManager2.prototype.disable = function() {
+        return this;
+      };
+      return NoopContextManager2;
+    }();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/api/context.js
+var __read4, __spreadArray4, API_NAME2, NOOP_CONTEXT_MANAGER, ContextAPI;
+var init_context2 = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/api/context.js"() {
+    init_NoopContextManager();
+    init_global_utils();
+    init_diag();
+    __read4 = function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m)
+        return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+          ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"]))
+            m.call(i);
+        } finally {
+          if (e)
+            throw e.error;
+        }
+      }
+      return ar;
+    };
+    __spreadArray4 = function(to, from, pack) {
+      if (pack || arguments.length === 2)
+        for (var i = 0, l = from.length, ar; i < l; i++) {
+          if (ar || !(i in from)) {
+            if (!ar)
+              ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+          }
+        }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    API_NAME2 = "context";
+    NOOP_CONTEXT_MANAGER = new NoopContextManager();
+    ContextAPI = /** @class */
+    function() {
+      function ContextAPI2() {
+      }
+      ContextAPI2.getInstance = function() {
+        if (!this._instance) {
+          this._instance = new ContextAPI2();
+        }
+        return this._instance;
+      };
+      ContextAPI2.prototype.setGlobalContextManager = function(contextManager) {
+        return registerGlobal(API_NAME2, contextManager, DiagAPI.instance());
+      };
+      ContextAPI2.prototype.active = function() {
+        return this._getContextManager().active();
+      };
+      ContextAPI2.prototype.with = function(context2, fn, thisArg) {
+        var _a2;
+        var args = [];
+        for (var _i = 3; _i < arguments.length; _i++) {
+          args[_i - 3] = arguments[_i];
+        }
+        return (_a2 = this._getContextManager()).with.apply(_a2, __spreadArray4([context2, fn, thisArg], __read4(args), false));
+      };
+      ContextAPI2.prototype.bind = function(context2, target) {
+        return this._getContextManager().bind(context2, target);
+      };
+      ContextAPI2.prototype._getContextManager = function() {
+        return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
+      };
+      ContextAPI2.prototype.disable = function() {
+        this._getContextManager().disable();
+        unregisterGlobal(API_NAME2, DiagAPI.instance());
+      };
+      return ContextAPI2;
+    }();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
+var TraceFlags;
+var init_trace_flags = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js"() {
+    (function(TraceFlags2) {
+      TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
+      TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
+    })(TraceFlags || (TraceFlags = {}));
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/context-api.js
+var context;
+var init_context_api = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/context-api.js"() {
+    init_context2();
+    context = ContextAPI.getInstance();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/diag-api.js
+var diag;
+var init_diag_api = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/diag-api.js"() {
+    init_diag();
+    diag = DiagAPI.instance();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/index.js
+var init_esm = __esm({
+  "../../node_modules/.pnpm/@opentelemetry+api@1.8.0/node_modules/@opentelemetry/api/build/esm/index.js"() {
+    init_context();
+    init_consoleLogger();
+    init_types();
+    init_trace_flags();
+    init_context_api();
+    init_diag_api();
+  }
+});
+
+// src/tracing.ts
+import process2 from "process";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { GraphQLInstrumentation } from "@opentelemetry/instrumentation-graphql";
+import { AwsInstrumentation } from "@opentelemetry/instrumentation-aws-sdk";
+import { AWSXRayIdGenerator } from "@opentelemetry/id-generator-aws-xray";
+import { AWSXRayPropagator } from "@opentelemetry/propagator-aws-xray";
+
+// ../../node_modules/.pnpm/@opentelemetry+core@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js
+init_esm();
+var SUPPRESS_TRACING_KEY = createContextKey("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
+function suppressTracing(context2) {
+  return context2.setValue(SUPPRESS_TRACING_KEY, true);
+}
+
+// ../../node_modules/.pnpm/@opentelemetry+core@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/core/build/esm/common/logging-error-handler.js
+init_esm();
+function loggingErrorHandler() {
+  return function(ex) {
+    diag.error(stringifyException(ex));
+  };
+}
+function stringifyException(ex) {
+  if (typeof ex === "string") {
+    return ex;
+  } else {
+    return JSON.stringify(flattenException(ex));
+  }
+}
+function flattenException(ex) {
+  var result = {};
+  var current = ex;
+  while (current !== null) {
+    Object.getOwnPropertyNames(current).forEach(function(propertyName) {
+      if (result[propertyName])
+        return;
+      var value = current[propertyName];
+      if (value) {
+        result[propertyName] = String(value);
+      }
+    });
+    current = Object.getPrototypeOf(current);
+  }
+  return result;
+}
+
+// ../../node_modules/.pnpm/@opentelemetry+core@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/core/build/esm/common/global-error-handler.js
+var delegateHandler = loggingErrorHandler();
+function globalErrorHandler(ex) {
+  try {
+    delegateHandler(ex);
+  } catch (_a2) {
+  }
+}
+
+// ../../node_modules/.pnpm/@opentelemetry+core@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/core/build/esm/utils/environment.js
+init_esm();
+
+// ../../node_modules/.pnpm/@opentelemetry+core@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/core/build/esm/utils/sampling.js
+var TracesSamplerValues;
+(function(TracesSamplerValues2) {
+  TracesSamplerValues2["AlwaysOff"] = "always_off";
+  TracesSamplerValues2["AlwaysOn"] = "always_on";
+  TracesSamplerValues2["ParentBasedAlwaysOff"] = "parentbased_always_off";
+  TracesSamplerValues2["ParentBasedAlwaysOn"] = "parentbased_always_on";
+  TracesSamplerValues2["ParentBasedTraceIdRatio"] = "parentbased_traceidratio";
+  TracesSamplerValues2["TraceIdRatio"] = "traceidratio";
+})(TracesSamplerValues || (TracesSamplerValues = {}));
+
+// ../../node_modules/.pnpm/@opentelemetry+core@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/core/build/esm/utils/environment.js
+var DEFAULT_LIST_SEPARATOR = ",";
+var ENVIRONMENT_BOOLEAN_KEYS = ["OTEL_SDK_DISABLED"];
+function isEnvVarABoolean(key) {
+  return ENVIRONMENT_BOOLEAN_KEYS.indexOf(key) > -1;
+}
+var ENVIRONMENT_NUMBERS_KEYS = [
+  "OTEL_BSP_EXPORT_TIMEOUT",
+  "OTEL_BSP_MAX_EXPORT_BATCH_SIZE",
+  "OTEL_BSP_MAX_QUEUE_SIZE",
+  "OTEL_BSP_SCHEDULE_DELAY",
+  "OTEL_BLRP_EXPORT_TIMEOUT",
+  "OTEL_BLRP_MAX_EXPORT_BATCH_SIZE",
+  "OTEL_BLRP_MAX_QUEUE_SIZE",
+  "OTEL_BLRP_SCHEDULE_DELAY",
+  "OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT",
+  "OTEL_ATTRIBUTE_COUNT_LIMIT",
+  "OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT",
+  "OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT",
+  "OTEL_LOGRECORD_ATTRIBUTE_VALUE_LENGTH_LIMIT",
+  "OTEL_LOGRECORD_ATTRIBUTE_COUNT_LIMIT",
+  "OTEL_SPAN_EVENT_COUNT_LIMIT",
+  "OTEL_SPAN_LINK_COUNT_LIMIT",
+  "OTEL_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT",
+  "OTEL_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT",
+  "OTEL_EXPORTER_OTLP_TIMEOUT",
+  "OTEL_EXPORTER_OTLP_TRACES_TIMEOUT",
+  "OTEL_EXPORTER_OTLP_METRICS_TIMEOUT",
+  "OTEL_EXPORTER_OTLP_LOGS_TIMEOUT",
+  "OTEL_EXPORTER_JAEGER_AGENT_PORT"
+];
+function isEnvVarANumber(key) {
+  return ENVIRONMENT_NUMBERS_KEYS.indexOf(key) > -1;
+}
+var ENVIRONMENT_LISTS_KEYS = [
+  "OTEL_NO_PATCH_MODULES",
+  "OTEL_PROPAGATORS"
+];
+function isEnvVarAList(key) {
+  return ENVIRONMENT_LISTS_KEYS.indexOf(key) > -1;
+}
+var DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT = Infinity;
+var DEFAULT_ATTRIBUTE_COUNT_LIMIT = 128;
+var DEFAULT_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT = 128;
+var DEFAULT_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT = 128;
+var DEFAULT_ENVIRONMENT = {
+  OTEL_SDK_DISABLED: false,
+  CONTAINER_NAME: "",
+  ECS_CONTAINER_METADATA_URI_V4: "",
+  ECS_CONTAINER_METADATA_URI: "",
+  HOSTNAME: "",
+  KUBERNETES_SERVICE_HOST: "",
+  NAMESPACE: "",
+  OTEL_BSP_EXPORT_TIMEOUT: 3e4,
+  OTEL_BSP_MAX_EXPORT_BATCH_SIZE: 512,
+  OTEL_BSP_MAX_QUEUE_SIZE: 2048,
+  OTEL_BSP_SCHEDULE_DELAY: 5e3,
+  OTEL_BLRP_EXPORT_TIMEOUT: 3e4,
+  OTEL_BLRP_MAX_EXPORT_BATCH_SIZE: 512,
+  OTEL_BLRP_MAX_QUEUE_SIZE: 2048,
+  OTEL_BLRP_SCHEDULE_DELAY: 5e3,
+  OTEL_EXPORTER_JAEGER_AGENT_HOST: "",
+  OTEL_EXPORTER_JAEGER_AGENT_PORT: 6832,
+  OTEL_EXPORTER_JAEGER_ENDPOINT: "",
+  OTEL_EXPORTER_JAEGER_PASSWORD: "",
+  OTEL_EXPORTER_JAEGER_USER: "",
+  OTEL_EXPORTER_OTLP_ENDPOINT: "",
+  OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: "",
+  OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: "",
+  OTEL_EXPORTER_OTLP_LOGS_ENDPOINT: "",
+  OTEL_EXPORTER_OTLP_HEADERS: "",
+  OTEL_EXPORTER_OTLP_TRACES_HEADERS: "",
+  OTEL_EXPORTER_OTLP_METRICS_HEADERS: "",
+  OTEL_EXPORTER_OTLP_LOGS_HEADERS: "",
+  OTEL_EXPORTER_OTLP_TIMEOUT: 1e4,
+  OTEL_EXPORTER_OTLP_TRACES_TIMEOUT: 1e4,
+  OTEL_EXPORTER_OTLP_METRICS_TIMEOUT: 1e4,
+  OTEL_EXPORTER_OTLP_LOGS_TIMEOUT: 1e4,
+  OTEL_EXPORTER_ZIPKIN_ENDPOINT: "http://localhost:9411/api/v2/spans",
+  OTEL_LOG_LEVEL: DiagLogLevel.INFO,
+  OTEL_NO_PATCH_MODULES: [],
+  OTEL_PROPAGATORS: ["tracecontext", "baggage"],
+  OTEL_RESOURCE_ATTRIBUTES: "",
+  OTEL_SERVICE_NAME: "",
+  OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT: DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT,
+  OTEL_ATTRIBUTE_COUNT_LIMIT: DEFAULT_ATTRIBUTE_COUNT_LIMIT,
+  OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT: DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT,
+  OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT: DEFAULT_ATTRIBUTE_COUNT_LIMIT,
+  OTEL_LOGRECORD_ATTRIBUTE_VALUE_LENGTH_LIMIT: DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT,
+  OTEL_LOGRECORD_ATTRIBUTE_COUNT_LIMIT: DEFAULT_ATTRIBUTE_COUNT_LIMIT,
+  OTEL_SPAN_EVENT_COUNT_LIMIT: 128,
+  OTEL_SPAN_LINK_COUNT_LIMIT: 128,
+  OTEL_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT: DEFAULT_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT,
+  OTEL_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT: DEFAULT_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT,
+  OTEL_TRACES_EXPORTER: "",
+  OTEL_TRACES_SAMPLER: TracesSamplerValues.ParentBasedAlwaysOn,
+  OTEL_TRACES_SAMPLER_ARG: "",
+  OTEL_LOGS_EXPORTER: "",
+  OTEL_EXPORTER_OTLP_INSECURE: "",
+  OTEL_EXPORTER_OTLP_TRACES_INSECURE: "",
+  OTEL_EXPORTER_OTLP_METRICS_INSECURE: "",
+  OTEL_EXPORTER_OTLP_LOGS_INSECURE: "",
+  OTEL_EXPORTER_OTLP_CERTIFICATE: "",
+  OTEL_EXPORTER_OTLP_TRACES_CERTIFICATE: "",
+  OTEL_EXPORTER_OTLP_METRICS_CERTIFICATE: "",
+  OTEL_EXPORTER_OTLP_LOGS_CERTIFICATE: "",
+  OTEL_EXPORTER_OTLP_COMPRESSION: "",
+  OTEL_EXPORTER_OTLP_TRACES_COMPRESSION: "",
+  OTEL_EXPORTER_OTLP_METRICS_COMPRESSION: "",
+  OTEL_EXPORTER_OTLP_LOGS_COMPRESSION: "",
+  OTEL_EXPORTER_OTLP_CLIENT_KEY: "",
+  OTEL_EXPORTER_OTLP_TRACES_CLIENT_KEY: "",
+  OTEL_EXPORTER_OTLP_METRICS_CLIENT_KEY: "",
+  OTEL_EXPORTER_OTLP_LOGS_CLIENT_KEY: "",
+  OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE: "",
+  OTEL_EXPORTER_OTLP_TRACES_CLIENT_CERTIFICATE: "",
+  OTEL_EXPORTER_OTLP_METRICS_CLIENT_CERTIFICATE: "",
+  OTEL_EXPORTER_OTLP_LOGS_CLIENT_CERTIFICATE: "",
+  OTEL_EXPORTER_OTLP_PROTOCOL: "http/protobuf",
+  OTEL_EXPORTER_OTLP_TRACES_PROTOCOL: "http/protobuf",
+  OTEL_EXPORTER_OTLP_METRICS_PROTOCOL: "http/protobuf",
+  OTEL_EXPORTER_OTLP_LOGS_PROTOCOL: "http/protobuf",
+  OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE: "cumulative"
+};
+function parseBoolean(key, environment, values) {
+  if (typeof values[key] === "undefined") {
+    return;
+  }
+  var value = String(values[key]);
+  environment[key] = value.toLowerCase() === "true";
+}
+function parseNumber(name, environment, values, min, max) {
+  if (min === void 0) {
+    min = -Infinity;
+  }
+  if (max === void 0) {
+    max = Infinity;
+  }
+  if (typeof values[name] !== "undefined") {
+    var value = Number(values[name]);
+    if (!isNaN(value)) {
+      if (value < min) {
+        environment[name] = min;
+      } else if (value > max) {
+        environment[name] = max;
+      } else {
+        environment[name] = value;
+      }
+    }
+  }
+}
+function parseStringList(name, output, input, separator) {
+  if (separator === void 0) {
+    separator = DEFAULT_LIST_SEPARATOR;
+  }
+  var givenValue = input[name];
+  if (typeof givenValue === "string") {
+    output[name] = givenValue.split(separator).map(function(v) {
+      return v.trim();
+    });
+  }
+}
+var logLevelMap = {
+  ALL: DiagLogLevel.ALL,
+  VERBOSE: DiagLogLevel.VERBOSE,
+  DEBUG: DiagLogLevel.DEBUG,
+  INFO: DiagLogLevel.INFO,
+  WARN: DiagLogLevel.WARN,
+  ERROR: DiagLogLevel.ERROR,
+  NONE: DiagLogLevel.NONE
+};
+function setLogLevelFromEnv(key, environment, values) {
+  var value = values[key];
+  if (typeof value === "string") {
+    var theLevel = logLevelMap[value.toUpperCase()];
+    if (theLevel != null) {
+      environment[key] = theLevel;
+    }
+  }
+}
+function parseEnvironment(values) {
+  var environment = {};
+  for (var env in DEFAULT_ENVIRONMENT) {
+    var key = env;
+    switch (key) {
+      case "OTEL_LOG_LEVEL":
+        setLogLevelFromEnv(key, environment, values);
+        break;
+      default:
+        if (isEnvVarABoolean(key)) {
+          parseBoolean(key, environment, values);
+        } else if (isEnvVarANumber(key)) {
+          parseNumber(key, environment, values);
+        } else if (isEnvVarAList(key)) {
+          parseStringList(key, environment, values);
+        } else {
+          var value = values[key];
+          if (typeof value !== "undefined" && value !== null) {
+            environment[key] = String(value);
+          }
+        }
+    }
+  }
+  return environment;
+}
+
+// ../../node_modules/.pnpm/@opentelemetry+core@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/core/build/esm/platform/node/environment.js
+function getEnv() {
+  var processEnv = parseEnvironment(process.env);
+  return Object.assign({}, DEFAULT_ENVIRONMENT, processEnv);
+}
+
+// ../../node_modules/.pnpm/@opentelemetry+core@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/core/build/esm/version.js
+var VERSION2 = "1.23.0";
+
+// ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.23.0/node_modules/@opentelemetry/semantic-conventions/build/esm/internal/utils.js
+// @__NO_SIDE_EFFECTS__
+function createConstMap(values) {
+  var res = {};
+  var len = values.length;
+  for (var lp = 0; lp < len; lp++) {
+    var val = values[lp];
+    if (val) {
+      res[String(val).toUpperCase().replace(/[-.]/g, "_")] = val;
+    }
+  }
+  return res;
+}
+
+// ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.23.0/node_modules/@opentelemetry/semantic-conventions/build/esm/resource/SemanticResourceAttributes.js
+var TMP_CLOUD_PROVIDER = "cloud.provider";
+var TMP_CLOUD_ACCOUNT_ID = "cloud.account.id";
+var TMP_CLOUD_REGION = "cloud.region";
+var TMP_CLOUD_AVAILABILITY_ZONE = "cloud.availability_zone";
+var TMP_CLOUD_PLATFORM = "cloud.platform";
+var TMP_AWS_ECS_CONTAINER_ARN = "aws.ecs.container.arn";
+var TMP_AWS_ECS_CLUSTER_ARN = "aws.ecs.cluster.arn";
+var TMP_AWS_ECS_LAUNCHTYPE = "aws.ecs.launchtype";
+var TMP_AWS_ECS_TASK_ARN = "aws.ecs.task.arn";
+var TMP_AWS_ECS_TASK_FAMILY = "aws.ecs.task.family";
+var TMP_AWS_ECS_TASK_REVISION = "aws.ecs.task.revision";
+var TMP_AWS_EKS_CLUSTER_ARN = "aws.eks.cluster.arn";
+var TMP_AWS_LOG_GROUP_NAMES = "aws.log.group.names";
+var TMP_AWS_LOG_GROUP_ARNS = "aws.log.group.arns";
+var TMP_AWS_LOG_STREAM_NAMES = "aws.log.stream.names";
+var TMP_AWS_LOG_STREAM_ARNS = "aws.log.stream.arns";
+var TMP_CONTAINER_NAME = "container.name";
+var TMP_CONTAINER_ID = "container.id";
+var TMP_CONTAINER_RUNTIME = "container.runtime";
+var TMP_CONTAINER_IMAGE_NAME = "container.image.name";
+var TMP_CONTAINER_IMAGE_TAG = "container.image.tag";
+var TMP_DEPLOYMENT_ENVIRONMENT = "deployment.environment";
+var TMP_DEVICE_ID = "device.id";
+var TMP_DEVICE_MODEL_IDENTIFIER = "device.model.identifier";
+var TMP_DEVICE_MODEL_NAME = "device.model.name";
+var TMP_FAAS_NAME = "faas.name";
+var TMP_FAAS_ID = "faas.id";
+var TMP_FAAS_VERSION = "faas.version";
+var TMP_FAAS_INSTANCE = "faas.instance";
+var TMP_FAAS_MAX_MEMORY = "faas.max_memory";
+var TMP_HOST_ID = "host.id";
+var TMP_HOST_NAME = "host.name";
+var TMP_HOST_TYPE = "host.type";
+var TMP_HOST_ARCH = "host.arch";
+var TMP_HOST_IMAGE_NAME = "host.image.name";
+var TMP_HOST_IMAGE_ID = "host.image.id";
+var TMP_HOST_IMAGE_VERSION = "host.image.version";
+var TMP_K8S_CLUSTER_NAME = "k8s.cluster.name";
+var TMP_K8S_NODE_NAME = "k8s.node.name";
+var TMP_K8S_NODE_UID = "k8s.node.uid";
+var TMP_K8S_NAMESPACE_NAME = "k8s.namespace.name";
+var TMP_K8S_POD_UID = "k8s.pod.uid";
+var TMP_K8S_POD_NAME = "k8s.pod.name";
+var TMP_K8S_CONTAINER_NAME = "k8s.container.name";
+var TMP_K8S_REPLICASET_UID = "k8s.replicaset.uid";
+var TMP_K8S_REPLICASET_NAME = "k8s.replicaset.name";
+var TMP_K8S_DEPLOYMENT_UID = "k8s.deployment.uid";
+var TMP_K8S_DEPLOYMENT_NAME = "k8s.deployment.name";
+var TMP_K8S_STATEFULSET_UID = "k8s.statefulset.uid";
+var TMP_K8S_STATEFULSET_NAME = "k8s.statefulset.name";
+var TMP_K8S_DAEMONSET_UID = "k8s.daemonset.uid";
+var TMP_K8S_DAEMONSET_NAME = "k8s.daemonset.name";
+var TMP_K8S_JOB_UID = "k8s.job.uid";
+var TMP_K8S_JOB_NAME = "k8s.job.name";
+var TMP_K8S_CRONJOB_UID = "k8s.cronjob.uid";
+var TMP_K8S_CRONJOB_NAME = "k8s.cronjob.name";
+var TMP_OS_TYPE = "os.type";
+var TMP_OS_DESCRIPTION = "os.description";
+var TMP_OS_NAME = "os.name";
+var TMP_OS_VERSION = "os.version";
+var TMP_PROCESS_PID = "process.pid";
+var TMP_PROCESS_EXECUTABLE_NAME = "process.executable.name";
+var TMP_PROCESS_EXECUTABLE_PATH = "process.executable.path";
+var TMP_PROCESS_COMMAND = "process.command";
+var TMP_PROCESS_COMMAND_LINE = "process.command_line";
+var TMP_PROCESS_COMMAND_ARGS = "process.command_args";
+var TMP_PROCESS_OWNER = "process.owner";
+var TMP_PROCESS_RUNTIME_NAME = "process.runtime.name";
+var TMP_PROCESS_RUNTIME_VERSION = "process.runtime.version";
+var TMP_PROCESS_RUNTIME_DESCRIPTION = "process.runtime.description";
+var TMP_SERVICE_NAME = "service.name";
+var TMP_SERVICE_NAMESPACE = "service.namespace";
+var TMP_SERVICE_INSTANCE_ID = "service.instance.id";
+var TMP_SERVICE_VERSION = "service.version";
+var TMP_TELEMETRY_SDK_NAME = "telemetry.sdk.name";
+var TMP_TELEMETRY_SDK_LANGUAGE = "telemetry.sdk.language";
+var TMP_TELEMETRY_SDK_VERSION = "telemetry.sdk.version";
+var TMP_TELEMETRY_AUTO_VERSION = "telemetry.auto.version";
+var TMP_WEBENGINE_NAME = "webengine.name";
+var TMP_WEBENGINE_VERSION = "webengine.version";
+var TMP_WEBENGINE_DESCRIPTION = "webengine.description";
+var SemanticResourceAttributes = /* @__PURE__ */ createConstMap([
+  TMP_CLOUD_PROVIDER,
+  TMP_CLOUD_ACCOUNT_ID,
+  TMP_CLOUD_REGION,
+  TMP_CLOUD_AVAILABILITY_ZONE,
+  TMP_CLOUD_PLATFORM,
+  TMP_AWS_ECS_CONTAINER_ARN,
+  TMP_AWS_ECS_CLUSTER_ARN,
+  TMP_AWS_ECS_LAUNCHTYPE,
+  TMP_AWS_ECS_TASK_ARN,
+  TMP_AWS_ECS_TASK_FAMILY,
+  TMP_AWS_ECS_TASK_REVISION,
+  TMP_AWS_EKS_CLUSTER_ARN,
+  TMP_AWS_LOG_GROUP_NAMES,
+  TMP_AWS_LOG_GROUP_ARNS,
+  TMP_AWS_LOG_STREAM_NAMES,
+  TMP_AWS_LOG_STREAM_ARNS,
+  TMP_CONTAINER_NAME,
+  TMP_CONTAINER_ID,
+  TMP_CONTAINER_RUNTIME,
+  TMP_CONTAINER_IMAGE_NAME,
+  TMP_CONTAINER_IMAGE_TAG,
+  TMP_DEPLOYMENT_ENVIRONMENT,
+  TMP_DEVICE_ID,
+  TMP_DEVICE_MODEL_IDENTIFIER,
+  TMP_DEVICE_MODEL_NAME,
+  TMP_FAAS_NAME,
+  TMP_FAAS_ID,
+  TMP_FAAS_VERSION,
+  TMP_FAAS_INSTANCE,
+  TMP_FAAS_MAX_MEMORY,
+  TMP_HOST_ID,
+  TMP_HOST_NAME,
+  TMP_HOST_TYPE,
+  TMP_HOST_ARCH,
+  TMP_HOST_IMAGE_NAME,
+  TMP_HOST_IMAGE_ID,
+  TMP_HOST_IMAGE_VERSION,
+  TMP_K8S_CLUSTER_NAME,
+  TMP_K8S_NODE_NAME,
+  TMP_K8S_NODE_UID,
+  TMP_K8S_NAMESPACE_NAME,
+  TMP_K8S_POD_UID,
+  TMP_K8S_POD_NAME,
+  TMP_K8S_CONTAINER_NAME,
+  TMP_K8S_REPLICASET_UID,
+  TMP_K8S_REPLICASET_NAME,
+  TMP_K8S_DEPLOYMENT_UID,
+  TMP_K8S_DEPLOYMENT_NAME,
+  TMP_K8S_STATEFULSET_UID,
+  TMP_K8S_STATEFULSET_NAME,
+  TMP_K8S_DAEMONSET_UID,
+  TMP_K8S_DAEMONSET_NAME,
+  TMP_K8S_JOB_UID,
+  TMP_K8S_JOB_NAME,
+  TMP_K8S_CRONJOB_UID,
+  TMP_K8S_CRONJOB_NAME,
+  TMP_OS_TYPE,
+  TMP_OS_DESCRIPTION,
+  TMP_OS_NAME,
+  TMP_OS_VERSION,
+  TMP_PROCESS_PID,
+  TMP_PROCESS_EXECUTABLE_NAME,
+  TMP_PROCESS_EXECUTABLE_PATH,
+  TMP_PROCESS_COMMAND,
+  TMP_PROCESS_COMMAND_LINE,
+  TMP_PROCESS_COMMAND_ARGS,
+  TMP_PROCESS_OWNER,
+  TMP_PROCESS_RUNTIME_NAME,
+  TMP_PROCESS_RUNTIME_VERSION,
+  TMP_PROCESS_RUNTIME_DESCRIPTION,
+  TMP_SERVICE_NAME,
+  TMP_SERVICE_NAMESPACE,
+  TMP_SERVICE_INSTANCE_ID,
+  TMP_SERVICE_VERSION,
+  TMP_TELEMETRY_SDK_NAME,
+  TMP_TELEMETRY_SDK_LANGUAGE,
+  TMP_TELEMETRY_SDK_VERSION,
+  TMP_TELEMETRY_AUTO_VERSION,
+  TMP_WEBENGINE_NAME,
+  TMP_WEBENGINE_VERSION,
+  TMP_WEBENGINE_DESCRIPTION
+]);
+var TMP_TELEMETRYSDKLANGUAGEVALUES_CPP = "cpp";
+var TMP_TELEMETRYSDKLANGUAGEVALUES_DOTNET = "dotnet";
+var TMP_TELEMETRYSDKLANGUAGEVALUES_ERLANG = "erlang";
+var TMP_TELEMETRYSDKLANGUAGEVALUES_GO = "go";
+var TMP_TELEMETRYSDKLANGUAGEVALUES_JAVA = "java";
+var TMP_TELEMETRYSDKLANGUAGEVALUES_NODEJS = "nodejs";
+var TMP_TELEMETRYSDKLANGUAGEVALUES_PHP = "php";
+var TMP_TELEMETRYSDKLANGUAGEVALUES_PYTHON = "python";
+var TMP_TELEMETRYSDKLANGUAGEVALUES_RUBY = "ruby";
+var TMP_TELEMETRYSDKLANGUAGEVALUES_WEBJS = "webjs";
+var TelemetrySdkLanguageValues = /* @__PURE__ */ createConstMap([
+  TMP_TELEMETRYSDKLANGUAGEVALUES_CPP,
+  TMP_TELEMETRYSDKLANGUAGEVALUES_DOTNET,
+  TMP_TELEMETRYSDKLANGUAGEVALUES_ERLANG,
+  TMP_TELEMETRYSDKLANGUAGEVALUES_GO,
+  TMP_TELEMETRYSDKLANGUAGEVALUES_JAVA,
+  TMP_TELEMETRYSDKLANGUAGEVALUES_NODEJS,
+  TMP_TELEMETRYSDKLANGUAGEVALUES_PHP,
+  TMP_TELEMETRYSDKLANGUAGEVALUES_PYTHON,
+  TMP_TELEMETRYSDKLANGUAGEVALUES_RUBY,
+  TMP_TELEMETRYSDKLANGUAGEVALUES_WEBJS
+]);
+
+// ../../node_modules/.pnpm/@opentelemetry+core@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/core/build/esm/platform/node/sdk-info.js
+var _a;
+var SDK_INFO = (_a = {}, _a[SemanticResourceAttributes.TELEMETRY_SDK_NAME] = "opentelemetry", _a[SemanticResourceAttributes.PROCESS_RUNTIME_NAME] = "node", _a[SemanticResourceAttributes.TELEMETRY_SDK_LANGUAGE] = TelemetrySdkLanguageValues.NODEJS, _a[SemanticResourceAttributes.TELEMETRY_SDK_VERSION] = VERSION2, _a);
+
+// ../../node_modules/.pnpm/@opentelemetry+core@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/core/build/esm/platform/node/timer-util.js
+function unrefTimer(timer) {
+  timer.unref();
+}
+
+// ../../node_modules/.pnpm/@opentelemetry+core@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/core/build/esm/ExportResult.js
+var ExportResultCode;
+(function(ExportResultCode2) {
+  ExportResultCode2[ExportResultCode2["SUCCESS"] = 0] = "SUCCESS";
+  ExportResultCode2[ExportResultCode2["FAILED"] = 1] = "FAILED";
+})(ExportResultCode || (ExportResultCode = {}));
+
+// ../../node_modules/.pnpm/@opentelemetry+core@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/core/build/esm/utils/promise.js
+var Deferred = (
+  /** @class */
+  function() {
+    function Deferred2() {
+      var _this = this;
+      this._promise = new Promise(function(resolve, reject) {
+        _this._resolve = resolve;
+        _this._reject = reject;
+      });
+    }
+    Object.defineProperty(Deferred2.prototype, "promise", {
+      get: function() {
+        return this._promise;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Deferred2.prototype.resolve = function(val) {
+      this._resolve(val);
+    };
+    Deferred2.prototype.reject = function(err) {
+      this._reject(err);
+    };
+    return Deferred2;
+  }()
+);
+
+// ../../node_modules/.pnpm/@opentelemetry+core@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/core/build/esm/utils/callback.js
+var __read5 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m)
+    return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+      ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"]))
+        m.call(i);
+    } finally {
+      if (e)
+        throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray5 = function(to, from, pack) {
+  if (pack || arguments.length === 2)
+    for (var i = 0, l = from.length, ar; i < l; i++) {
+      if (ar || !(i in from)) {
+        if (!ar)
+          ar = Array.prototype.slice.call(from, 0, i);
+        ar[i] = from[i];
+      }
+    }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+var BindOnceFuture = (
+  /** @class */
+  function() {
+    function BindOnceFuture2(_callback, _that) {
+      this._callback = _callback;
+      this._that = _that;
+      this._isCalled = false;
+      this._deferred = new Deferred();
+    }
+    Object.defineProperty(BindOnceFuture2.prototype, "isCalled", {
+      get: function() {
+        return this._isCalled;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(BindOnceFuture2.prototype, "promise", {
+      get: function() {
+        return this._deferred.promise;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    BindOnceFuture2.prototype.call = function() {
+      var _a2;
+      var _this = this;
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      if (!this._isCalled) {
+        this._isCalled = true;
+        try {
+          Promise.resolve((_a2 = this._callback).call.apply(_a2, __spreadArray5([this._that], __read5(args), false))).then(function(val) {
+            return _this._deferred.resolve(val);
+          }, function(err) {
+            return _this._deferred.reject(err);
+          });
+        } catch (err) {
+          this._deferred.reject(err);
+        }
+      }
+      return this._deferred.promise;
+    };
+    return BindOnceFuture2;
+  }()
+);
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/BatchSpanProcessorBase.js
+init_esm();
+var BatchSpanProcessorBase = (
+  /** @class */
+  function() {
+    function BatchSpanProcessorBase2(_exporter, config) {
+      this._exporter = _exporter;
+      this._isExporting = false;
+      this._finishedSpans = [];
+      this._droppedSpansCount = 0;
+      var env = getEnv();
+      this._maxExportBatchSize = typeof (config === null || config === void 0 ? void 0 : config.maxExportBatchSize) === "number" ? config.maxExportBatchSize : env.OTEL_BSP_MAX_EXPORT_BATCH_SIZE;
+      this._maxQueueSize = typeof (config === null || config === void 0 ? void 0 : config.maxQueueSize) === "number" ? config.maxQueueSize : env.OTEL_BSP_MAX_QUEUE_SIZE;
+      this._scheduledDelayMillis = typeof (config === null || config === void 0 ? void 0 : config.scheduledDelayMillis) === "number" ? config.scheduledDelayMillis : env.OTEL_BSP_SCHEDULE_DELAY;
+      this._exportTimeoutMillis = typeof (config === null || config === void 0 ? void 0 : config.exportTimeoutMillis) === "number" ? config.exportTimeoutMillis : env.OTEL_BSP_EXPORT_TIMEOUT;
+      this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
+      if (this._maxExportBatchSize > this._maxQueueSize) {
+        diag.warn("BatchSpanProcessor: maxExportBatchSize must be smaller or equal to maxQueueSize, setting maxExportBatchSize to match maxQueueSize");
+        this._maxExportBatchSize = this._maxQueueSize;
+      }
+    }
+    BatchSpanProcessorBase2.prototype.forceFlush = function() {
+      if (this._shutdownOnce.isCalled) {
+        return this._shutdownOnce.promise;
+      }
+      return this._flushAll();
+    };
+    BatchSpanProcessorBase2.prototype.onStart = function(_span, _parentContext) {
+    };
+    BatchSpanProcessorBase2.prototype.onEnd = function(span) {
+      if (this._shutdownOnce.isCalled) {
+        return;
+      }
+      if ((span.spanContext().traceFlags & TraceFlags.SAMPLED) === 0) {
+        return;
+      }
+      this._addToBuffer(span);
+    };
+    BatchSpanProcessorBase2.prototype.shutdown = function() {
+      return this._shutdownOnce.call();
+    };
+    BatchSpanProcessorBase2.prototype._shutdown = function() {
+      var _this = this;
+      return Promise.resolve().then(function() {
+        return _this.onShutdown();
+      }).then(function() {
+        return _this._flushAll();
+      }).then(function() {
+        return _this._exporter.shutdown();
+      });
+    };
+    BatchSpanProcessorBase2.prototype._addToBuffer = function(span) {
+      if (this._finishedSpans.length >= this._maxQueueSize) {
+        if (this._droppedSpansCount === 0) {
+          diag.debug("maxQueueSize reached, dropping spans");
+        }
+        this._droppedSpansCount++;
+        return;
+      }
+      if (this._droppedSpansCount > 0) {
+        diag.warn("Dropped " + this._droppedSpansCount + " spans because maxQueueSize reached");
+        this._droppedSpansCount = 0;
+      }
+      this._finishedSpans.push(span);
+      this._maybeStartTimer();
+    };
+    BatchSpanProcessorBase2.prototype._flushAll = function() {
+      var _this = this;
+      return new Promise(function(resolve, reject) {
+        var promises = [];
+        var count = Math.ceil(_this._finishedSpans.length / _this._maxExportBatchSize);
+        for (var i = 0, j = count; i < j; i++) {
+          promises.push(_this._flushOneBatch());
+        }
+        Promise.all(promises).then(function() {
+          resolve();
+        }).catch(reject);
+      });
+    };
+    BatchSpanProcessorBase2.prototype._flushOneBatch = function() {
+      var _this = this;
+      this._clearTimer();
+      if (this._finishedSpans.length === 0) {
+        return Promise.resolve();
+      }
+      return new Promise(function(resolve, reject) {
+        var timer = setTimeout(function() {
+          reject(new Error("Timeout"));
+        }, _this._exportTimeoutMillis);
+        context.with(suppressTracing(context.active()), function() {
+          var spans;
+          if (_this._finishedSpans.length <= _this._maxExportBatchSize) {
+            spans = _this._finishedSpans;
+            _this._finishedSpans = [];
+          } else {
+            spans = _this._finishedSpans.splice(0, _this._maxExportBatchSize);
+          }
+          var doExport = function() {
+            return _this._exporter.export(spans, function(result) {
+              var _a2;
+              clearTimeout(timer);
+              if (result.code === ExportResultCode.SUCCESS) {
+                resolve();
+              } else {
+                reject((_a2 = result.error) !== null && _a2 !== void 0 ? _a2 : new Error("BatchSpanProcessor: span export failed"));
+              }
+            });
+          };
+          var pendingResources = null;
+          for (var i = 0, len = spans.length; i < len; i++) {
+            var span = spans[i];
+            if (span.resource.asyncAttributesPending && span.resource.waitForAsyncAttributes) {
+              pendingResources !== null && pendingResources !== void 0 ? pendingResources : pendingResources = [];
+              pendingResources.push(span.resource.waitForAsyncAttributes());
+            }
+          }
+          if (pendingResources === null) {
+            doExport();
+          } else {
+            Promise.all(pendingResources).then(doExport, function(err) {
+              globalErrorHandler(err);
+              reject(err);
+            });
+          }
+        });
+      });
+    };
+    BatchSpanProcessorBase2.prototype._maybeStartTimer = function() {
+      var _this = this;
+      if (this._isExporting)
+        return;
+      var flush = function() {
+        _this._isExporting = true;
+        _this._flushOneBatch().finally(function() {
+          _this._isExporting = false;
+          if (_this._finishedSpans.length > 0) {
+            _this._clearTimer();
+            _this._maybeStartTimer();
+          }
+        }).catch(function(e) {
+          _this._isExporting = false;
+          globalErrorHandler(e);
+        });
+      };
+      if (this._finishedSpans.length >= this._maxExportBatchSize) {
+        return flush();
+      }
+      if (this._timer !== void 0)
+        return;
+      this._timer = setTimeout(function() {
+        return flush();
+      }, this._scheduledDelayMillis);
+      unrefTimer(this._timer);
+    };
+    BatchSpanProcessorBase2.prototype._clearTimer = function() {
+      if (this._timer !== void 0) {
+        clearTimeout(this._timer);
+        this._timer = void 0;
+      }
+    };
+    return BatchSpanProcessorBase2;
+  }()
+);
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/export/BatchSpanProcessor.js
+var __extends = /* @__PURE__ */ function() {
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+      d2.__proto__ = b2;
+    } || function(d2, b2) {
+      for (var p in b2)
+        if (Object.prototype.hasOwnProperty.call(b2, p))
+          d2[p] = b2[p];
+    };
+    return extendStatics(d, b);
+  };
+  return function(d, b) {
+    if (typeof b !== "function" && b !== null)
+      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+var BatchSpanProcessor = (
+  /** @class */
+  function(_super) {
+    __extends(BatchSpanProcessor2, _super);
+    function BatchSpanProcessor2() {
+      return _super !== null && _super.apply(this, arguments) || this;
+    }
+    BatchSpanProcessor2.prototype.onShutdown = function() {
+    };
+    return BatchSpanProcessor2;
+  }(BatchSpanProcessorBase)
+);
+
+// ../../node_modules/.pnpm/@opentelemetry+resources@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/resources/build/esm/Resource.js
+init_esm();
+
+// ../../node_modules/.pnpm/@opentelemetry+resources@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/resources/build/esm/platform/node/default-service-name.js
+function defaultServiceName() {
+  return "unknown_service:" + process.argv0;
+}
+
+// ../../node_modules/.pnpm/@opentelemetry+resources@1.23.0_@opentelemetry+api@1.8.0/node_modules/@opentelemetry/resources/build/esm/Resource.js
+var __assign = function() {
+  __assign = Object.assign || function(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p))
+          t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+var __awaiter = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = function(thisArg, body) {
+  var _ = { label: 0, sent: function() {
+    if (t[0] & 1)
+      throw t[1];
+    return t[1];
+  }, trys: [], ops: [] }, f, y, t, g;
+  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    while (_)
+      try {
+        if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+          return t;
+        if (y = 0, t)
+          op = [op[0] & 2, t.value];
+        switch (op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            _.label++;
+            return { value: op[1], done: false };
+          case 5:
+            _.label++;
+            y = op[1];
+            op = [0];
+            continue;
+          case 7:
+            op = _.ops.pop();
+            _.trys.pop();
+            continue;
+          default:
+            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1];
+              t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2];
+              _.ops.push(op);
+              break;
+            }
+            if (t[2])
+              _.ops.pop();
+            _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [6, e];
+        y = 0;
+      } finally {
+        f = t = 0;
+      }
+    if (op[0] & 5)
+      throw op[1];
+    return { value: op[0] ? op[1] : void 0, done: true };
+  }
+};
+var __read6 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m)
+    return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+      ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"]))
+        m.call(i);
+    } finally {
+      if (e)
+        throw e.error;
+    }
+  }
+  return ar;
+};
+var Resource = (
+  /** @class */
+  function() {
+    function Resource2(attributes, asyncAttributesPromise) {
+      var _this = this;
+      var _a2;
+      this._attributes = attributes;
+      this.asyncAttributesPending = asyncAttributesPromise != null;
+      this._syncAttributes = (_a2 = this._attributes) !== null && _a2 !== void 0 ? _a2 : {};
+      this._asyncAttributesPromise = asyncAttributesPromise === null || asyncAttributesPromise === void 0 ? void 0 : asyncAttributesPromise.then(function(asyncAttributes) {
+        _this._attributes = Object.assign({}, _this._attributes, asyncAttributes);
+        _this.asyncAttributesPending = false;
+        return asyncAttributes;
+      }, function(err) {
+        diag.debug("a resource's async attributes promise rejected: %s", err);
+        _this.asyncAttributesPending = false;
+        return {};
+      });
+    }
+    Resource2.empty = function() {
+      return Resource2.EMPTY;
+    };
+    Resource2.default = function() {
+      var _a2;
+      return new Resource2((_a2 = {}, _a2[SemanticResourceAttributes.SERVICE_NAME] = defaultServiceName(), _a2[SemanticResourceAttributes.TELEMETRY_SDK_LANGUAGE] = SDK_INFO[SemanticResourceAttributes.TELEMETRY_SDK_LANGUAGE], _a2[SemanticResourceAttributes.TELEMETRY_SDK_NAME] = SDK_INFO[SemanticResourceAttributes.TELEMETRY_SDK_NAME], _a2[SemanticResourceAttributes.TELEMETRY_SDK_VERSION] = SDK_INFO[SemanticResourceAttributes.TELEMETRY_SDK_VERSION], _a2));
+    };
+    Object.defineProperty(Resource2.prototype, "attributes", {
+      get: function() {
+        var _a2;
+        if (this.asyncAttributesPending) {
+          diag.error("Accessing resource attributes before async attributes settled");
+        }
+        return (_a2 = this._attributes) !== null && _a2 !== void 0 ? _a2 : {};
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Resource2.prototype.waitForAsyncAttributes = function() {
+      return __awaiter(this, void 0, void 0, function() {
+        return __generator(this, function(_a2) {
+          switch (_a2.label) {
+            case 0:
+              if (!this.asyncAttributesPending)
+                return [3, 2];
+              return [4, this._asyncAttributesPromise];
+            case 1:
+              _a2.sent();
+              _a2.label = 2;
+            case 2:
+              return [
+                2
+                /*return*/
+              ];
+          }
+        });
+      });
+    };
+    Resource2.prototype.merge = function(other) {
+      var _this = this;
+      var _a2;
+      if (!other)
+        return this;
+      var mergedSyncAttributes = __assign(__assign({}, this._syncAttributes), (_a2 = other._syncAttributes) !== null && _a2 !== void 0 ? _a2 : other.attributes);
+      if (!this._asyncAttributesPromise && !other._asyncAttributesPromise) {
+        return new Resource2(mergedSyncAttributes);
+      }
+      var mergedAttributesPromise = Promise.all([
+        this._asyncAttributesPromise,
+        other._asyncAttributesPromise
+      ]).then(function(_a3) {
+        var _b;
+        var _c = __read6(_a3, 2), thisAsyncAttributes = _c[0], otherAsyncAttributes = _c[1];
+        return __assign(__assign(__assign(__assign({}, _this._syncAttributes), thisAsyncAttributes), (_b = other._syncAttributes) !== null && _b !== void 0 ? _b : other.attributes), otherAsyncAttributes);
+      });
+      return new Resource2(mergedSyncAttributes, mergedAttributesPromise);
+    };
+    Resource2.EMPTY = new Resource2({});
+    return Resource2;
+  }()
+);
+
+// src/tracing.ts
+init_esm();
+import { DataloaderInstrumentation } from "@opentelemetry/instrumentation-dataloader";
+import { ExpressInstrumentation } from "@opentelemetry/instrumentation-express";
+import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
+import { KnexInstrumentation } from "@opentelemetry/instrumentation-knex";
+import { MySQL2Instrumentation } from "@opentelemetry/instrumentation-mysql2";
+import { NetInstrumentation } from "@opentelemetry/instrumentation-net";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
+import {
+  ParentBasedSampler,
+  TraceIdRatioBasedSampler
+} from "@opentelemetry/sdk-trace-node";
+import { ExpressLayerType } from "@opentelemetry/instrumentation-express/build/src/enums/ExpressLayerType";
+var tracingDefaults = {
+  serviceName: "unknown",
+  release: "unknown",
+  samplingRatio: 0.2,
+  graphQLDepth: 8,
+  grpcDefaultPort: 4317,
+  httpDefaultPort: 4318,
+  host: "otlpcollector",
+  logger: new DiagConsoleLogger()
+};
+async function nodeSDKBuilder(config) {
+  config = { ...tracingDefaults, ...config };
+  diag.setLogger(config.logger, DiagLogLevel.WARN);
+  const _resource = Resource.default().merge(
+    new Resource({
+      [SemanticResourceAttributes.SERVICE_NAME]: config.serviceName,
+      [SemanticResourceAttributes.SERVICE_VERSION]: config.release
+    })
+  );
+  const _traceExporter = new OTLPTraceExporter({
+    //collector url
+    url: `http://${config.host}:${config.grpcDefaultPort}`
+  });
+  const _spanProcessor = new BatchSpanProcessor(_traceExporter, {
+    // only force 100ms between 2 batch exports.
+    // Default is 5000ms which is 5 seconds and causes us to lose spans
+    scheduledDelayMillis: 100
+  });
+  const _idGenerator = new AWSXRayIdGenerator();
+  const sdk = new NodeSDK({
+    textMapPropagator: new AWSXRayPropagator(),
+    instrumentations: [
+      new AwsInstrumentation({
+        suppressInternalInstrumentation: true
+      }),
+      new DataloaderInstrumentation({}),
+      new ExpressInstrumentation({
+        ignoreLayersType: [ExpressLayerType.MIDDLEWARE]
+      }),
+      new GraphQLInstrumentation({
+        // optional params
+        depth: config.graphQLDepth,
+        //query depth
+        allowValues: true
+      }),
+      new HttpInstrumentation({
+        ignoreIncomingPaths: ["/.well-known/apollo/server-health"]
+      }),
+      new KnexInstrumentation({}),
+      new MySQL2Instrumentation({}),
+      new NetInstrumentation({})
+    ],
+    resource: _resource,
+    spanProcessor: _spanProcessor,
+    traceExporter: _traceExporter,
+    idGenerator: _idGenerator,
+    sampler: new ParentBasedSampler({
+      //set at 20% sampling rate
+      root: new TraceIdRatioBasedSampler(config.samplingRatio)
+    })
+  });
+  await sdk.start();
+  process2.on("SIGTERM", () => {
+    sdk.shutdown().then(() => diag.info("Tracing and Metrics terminated")).catch(
+      (error) => diag.error("Error terminating tracing and metrics", error)
+    ).finally(() => process2.exit(0));
+  });
+}
+export {
+  nodeSDKBuilder
+};