@synnaxlabs/alamos 0.1.0

package/dist/instrumentation-2edee102.js

@@ -0,0 +1,946 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const _Meta = class _Meta {
+  constructor(key, path, serviceName = "", noop = false) {
+    __publicField(this, "_noop", false);
+    __publicField(this, "key");
+    __publicField(this, "path");
+    __publicField(this, "serviceName");
+    this.key = key;
+    this.path = path;
+    this.serviceName = serviceName;
+    this._noop = noop;
+  }
+  child(key) {
+    return new _Meta(key, this.extendPath(key), this.serviceName);
+  }
+  extendPath(key) {
+    return `${this.path}.${key}`;
+  }
+  get noop() {
+    return this._noop;
+  }
+};
+__publicField(_Meta, "NOOP", new _Meta("", "", ""));
+let Meta = _Meta;
+const LOG_LEVELS = ["debug", "info", "warn", "error"];
+const logThresholdFilter = (thresh) => {
+  const threshIdx = LOG_LEVELS.indexOf(thresh);
+  return ({ level }) => LOG_LEVELS.indexOf(level) >= threshIdx;
+};
+const logLevelKeyFiler = (props) => {
+  const { include, exclude } = props;
+  return ({ key }) => {
+    if (include != null && !include.includes(key))
+      return false;
+    if (exclude != null && exclude.includes(key))
+      return false;
+    return true;
+  };
+};
+const _Logger = class _Logger {
+  constructor(p = {}) {
+    __publicField(this, "meta", Meta.NOOP);
+    __publicField(this, "filters");
+    const { filters = [] } = p;
+    this.filters = filters;
+  }
+  filter(level) {
+    return !this.meta.noop && this.filters.every(
+      (f) => f({
+        key: this.meta.key,
+        path: this.meta.path,
+        level
+      })
+    );
+  }
+  child(meta) {
+    const l = new _Logger({ filters: this.filters });
+    l.meta = meta;
+    return l;
+  }
+  debug(msg, kv) {
+    if (!this.filter("debug"))
+      return;
+    if (kv == null)
+      console.log("%cDEBUG", "color: #8c00f0;", this.meta.path, msg);
+    else
+      console.log("%cDEBUG", "color: #8c00f0;", this.meta.path, msg, kv);
+  }
+  info(msg, kv) {
+    if (!this.filter("info"))
+      return;
+    if (kv == null)
+      console.log("%cINFO", "color: #005eff;", this.meta.path, msg);
+    else
+      console.log("%cINFO", "color: #005eff;", this.meta.path, msg, kv);
+  }
+  warn(msg, kv) {
+    if (!this.filter("warn"))
+      return;
+    if (kv == null)
+      console.warn("WARN", this.meta.path, msg);
+    else
+      console.warn("WARN", this.meta.path, msg, kv);
+  }
+  error(msg, kv) {
+    if (!this.filter("error"))
+      return;
+    if (kv == null)
+      console.error("ERROR", this.meta.path, msg);
+    else
+      console.error("ERROR", this.meta.path, msg, kv);
+  }
+};
+__publicField(_Logger, "NOOP", new _Logger());
+let Logger = _Logger;
+var _globalThis = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+var VERSION = "1.6.0";
+var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+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 isCompatible = _makeCompatibilityCheck(VERSION);
+var major = VERSION.split(".")[0];
+var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
+var _global = _globalThis;
+function registerGlobal(type, instance, diag, allowOverride) {
+  var _a;
+  if (allowOverride === void 0) {
+    allowOverride = false;
+  }
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
+    version: VERSION
+  };
+  if (!allowOverride && api[type]) {
+    var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
+    diag.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);
+    diag.error(err.stack || err.message);
+    return false;
+  }
+  api[type] = instance;
+  diag.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION + ".");
+  return true;
+}
+function getGlobal(type) {
+  var _a, _b;
+  var globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+  if (!globalVersion || !isCompatible(globalVersion)) {
+    return;
+  }
+  return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+}
+function unregisterGlobal(type, diag) {
+  diag.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION + ".");
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+  if (api) {
+    delete api[type];
+  }
+}
+var __read$4 = globalThis && globalThis.__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;
+};
+var __spreadArray$3 = globalThis && globalThis.__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));
+};
+var 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;
+  }()
+);
+function logProxy(funcName, namespace, args) {
+  var logger = getGlobal("diag");
+  if (!logger) {
+    return;
+  }
+  args.unshift(namespace);
+  return logger[funcName].apply(logger, __spreadArray$3([], __read$4(args), false));
+}
+var DiagLogLevel;
+(function(DiagLogLevel2) {
+  DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
+  DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
+  DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
+  DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
+  DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
+  DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
+  DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
+})(DiagLogLevel || (DiagLogLevel = {}));
+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 __read$3 = globalThis && globalThis.__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;
+};
+var __spreadArray$2 = globalThis && globalThis.__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));
+};
+var API_NAME$2 = "diag";
+var 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, __spreadArray$2([], __read$3(args), false));
+        };
+      }
+      var self2 = this;
+      var setLogger = function(logger, optionsOrLogLevel) {
+        var _a, _b, _c;
+        if (optionsOrLogLevel === void 0) {
+          optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
+        }
+        if (logger === self2) {
+          var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+          self2.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+          return false;
+        }
+        if (typeof optionsOrLogLevel === "number") {
+          optionsOrLogLevel = {
+            logLevel: optionsOrLogLevel
+          };
+        }
+        var oldLogger = getGlobal("diag");
+        var newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
+        if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+          var stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+          oldLogger.warn("Current logger will be overwritten from " + stack);
+          newLogger.warn("Current logger will overwrite one already registered from " + stack);
+        }
+        return registerGlobal("diag", newLogger, self2, true);
+      };
+      self2.setLogger = setLogger;
+      self2.disable = function() {
+        unregisterGlobal(API_NAME$2, self2);
+      };
+      self2.createComponentLogger = function(options) {
+        return new DiagComponentLogger(options);
+      };
+      self2.verbose = _logProxy("verbose");
+      self2.debug = _logProxy("debug");
+      self2.info = _logProxy("info");
+      self2.warn = _logProxy("warn");
+      self2.error = _logProxy("error");
+    }
+    DiagAPI2.instance = function() {
+      if (!this._instance) {
+        this._instance = new DiagAPI2();
+      }
+      return this._instance;
+    };
+    return DiagAPI2;
+  }()
+);
+var __read$2 = globalThis && globalThis.__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;
+};
+var __values = globalThis && globalThis.__values || function(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m)
+    return m.call(o);
+  if (o && typeof o.length === "number")
+    return {
+      next: function() {
+        if (o && i >= o.length)
+          o = void 0;
+        return { value: o && o[i++], done: !o };
+      }
+    };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var BaggageImpl = (
+  /** @class */
+  function() {
+    function BaggageImpl2(entries) {
+      this._entries = entries ? new Map(entries) : /* @__PURE__ */ new Map();
+    }
+    BaggageImpl2.prototype.getEntry = function(key) {
+      var entry = this._entries.get(key);
+      if (!entry) {
+        return void 0;
+      }
+      return Object.assign({}, entry);
+    };
+    BaggageImpl2.prototype.getAllEntries = function() {
+      return Array.from(this._entries.entries()).map(function(_a) {
+        var _b = __read$2(_a, 2), k = _b[0], v = _b[1];
+        return [k, v];
+      });
+    };
+    BaggageImpl2.prototype.setEntry = function(key, entry) {
+      var newBaggage = new BaggageImpl2(this._entries);
+      newBaggage._entries.set(key, entry);
+      return newBaggage;
+    };
+    BaggageImpl2.prototype.removeEntry = function(key) {
+      var newBaggage = new BaggageImpl2(this._entries);
+      newBaggage._entries.delete(key);
+      return newBaggage;
+    };
+    BaggageImpl2.prototype.removeEntries = function() {
+      var e_1, _a;
+      var keys = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        keys[_i] = arguments[_i];
+      }
+      var newBaggage = new BaggageImpl2(this._entries);
+      try {
+        for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+          var key = keys_1_1.value;
+          newBaggage._entries.delete(key);
+        }
+      } catch (e_1_1) {
+        e_1 = { error: e_1_1 };
+      } finally {
+        try {
+          if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return))
+            _a.call(keys_1);
+        } finally {
+          if (e_1)
+            throw e_1.error;
+        }
+      }
+      return newBaggage;
+    };
+    BaggageImpl2.prototype.clear = function() {
+      return new BaggageImpl2();
+    };
+    return BaggageImpl2;
+  }()
+);
+DiagAPI.instance();
+function createBaggage(entries) {
+  if (entries === void 0) {
+    entries = {};
+  }
+  return new BaggageImpl(new Map(Object.entries(entries)));
+}
+function createContextKey(description) {
+  return Symbol.for(description);
+}
+var BaseContext = (
+  /** @class */
+  function() {
+    function BaseContext2(parentContext) {
+      var self2 = this;
+      self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+      self2.getValue = function(key) {
+        return self2._currentContext.get(key);
+      };
+      self2.setValue = function(key, value) {
+        var context2 = new BaseContext2(self2._currentContext);
+        context2._currentContext.set(key, value);
+        return context2;
+      };
+      self2.deleteValue = function(key) {
+        var context2 = new BaseContext2(self2._currentContext);
+        context2._currentContext.delete(key);
+        return context2;
+      };
+    }
+    return BaseContext2;
+  }()
+);
+var ROOT_CONTEXT = new BaseContext();
+var defaultTextMapGetter = {
+  get: function(carrier, key) {
+    if (carrier == null) {
+      return void 0;
+    }
+    return carrier[key];
+  },
+  keys: function(carrier) {
+    if (carrier == null) {
+      return [];
+    }
+    return Object.keys(carrier);
+  }
+};
+var defaultTextMapSetter = {
+  set: function(carrier, key, value) {
+    if (carrier == null) {
+      return;
+    }
+    carrier[key] = value;
+  }
+};
+var __read$1 = globalThis && globalThis.__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;
+};
+var __spreadArray$1 = globalThis && globalThis.__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));
+};
+var 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, __spreadArray$1([thisArg], __read$1(args), false));
+    };
+    NoopContextManager2.prototype.bind = function(_context, target) {
+      return target;
+    };
+    NoopContextManager2.prototype.enable = function() {
+      return this;
+    };
+    NoopContextManager2.prototype.disable = function() {
+      return this;
+    };
+    return NoopContextManager2;
+  }()
+);
+var __read = globalThis && globalThis.__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;
+};
+var __spreadArray = globalThis && globalThis.__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));
+};
+var API_NAME$1 = "context";
+var NOOP_CONTEXT_MANAGER = new NoopContextManager();
+var 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_NAME$1, contextManager, DiagAPI.instance());
+    };
+    ContextAPI2.prototype.active = function() {
+      return this._getContextManager().active();
+    };
+    ContextAPI2.prototype.with = function(context2, fn, thisArg) {
+      var _a;
+      var args = [];
+      for (var _i = 3; _i < arguments.length; _i++) {
+        args[_i - 3] = arguments[_i];
+      }
+      return (_a = this._getContextManager()).with.apply(_a, __spreadArray([context2, fn, thisArg], __read(args), false));
+    };
+    ContextAPI2.prototype.bind = function(context2, target) {
+      return this._getContextManager().bind(context2, target);
+    };
+    ContextAPI2.prototype._getContextManager = function() {
+      return getGlobal(API_NAME$1) || NOOP_CONTEXT_MANAGER;
+    };
+    ContextAPI2.prototype.disable = function() {
+      this._getContextManager().disable();
+      unregisterGlobal(API_NAME$1, DiagAPI.instance());
+    };
+    return ContextAPI2;
+  }()
+);
+var SpanStatusCode;
+(function(SpanStatusCode2) {
+  SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
+  SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
+  SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
+})(SpanStatusCode || (SpanStatusCode = {}));
+var context = ContextAPI.getInstance();
+var NoopTextMapPropagator = (
+  /** @class */
+  function() {
+    function NoopTextMapPropagator2() {
+    }
+    NoopTextMapPropagator2.prototype.inject = function(_context, _carrier) {
+    };
+    NoopTextMapPropagator2.prototype.extract = function(context2, _carrier) {
+      return context2;
+    };
+    NoopTextMapPropagator2.prototype.fields = function() {
+      return [];
+    };
+    return NoopTextMapPropagator2;
+  }()
+);
+var BAGGAGE_KEY = createContextKey("OpenTelemetry Baggage Key");
+function getBaggage(context2) {
+  return context2.getValue(BAGGAGE_KEY) || void 0;
+}
+function getActiveBaggage() {
+  return getBaggage(ContextAPI.getInstance().active());
+}
+function setBaggage(context2, baggage) {
+  return context2.setValue(BAGGAGE_KEY, baggage);
+}
+function deleteBaggage(context2) {
+  return context2.deleteValue(BAGGAGE_KEY);
+}
+var API_NAME = "propagation";
+var NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator();
+var PropagationAPI = (
+  /** @class */
+  function() {
+    function PropagationAPI2() {
+      this.createBaggage = createBaggage;
+      this.getBaggage = getBaggage;
+      this.getActiveBaggage = getActiveBaggage;
+      this.setBaggage = setBaggage;
+      this.deleteBaggage = deleteBaggage;
+    }
+    PropagationAPI2.getInstance = function() {
+      if (!this._instance) {
+        this._instance = new PropagationAPI2();
+      }
+      return this._instance;
+    };
+    PropagationAPI2.prototype.setGlobalPropagator = function(propagator) {
+      return registerGlobal(API_NAME, propagator, DiagAPI.instance());
+    };
+    PropagationAPI2.prototype.inject = function(context2, carrier, setter) {
+      if (setter === void 0) {
+        setter = defaultTextMapSetter;
+      }
+      return this._getGlobalPropagator().inject(context2, carrier, setter);
+    };
+    PropagationAPI2.prototype.extract = function(context2, carrier, getter) {
+      if (getter === void 0) {
+        getter = defaultTextMapGetter;
+      }
+      return this._getGlobalPropagator().extract(context2, carrier, getter);
+    };
+    PropagationAPI2.prototype.fields = function() {
+      return this._getGlobalPropagator().fields();
+    };
+    PropagationAPI2.prototype.disable = function() {
+      unregisterGlobal(API_NAME, DiagAPI.instance());
+    };
+    PropagationAPI2.prototype._getGlobalPropagator = function() {
+      return getGlobal(API_NAME) || NOOP_TEXT_MAP_PROPAGATOR;
+    };
+    return PropagationAPI2;
+  }()
+);
+var propagation = PropagationAPI.getInstance();
+const ENVIRONMENTS = ["bench", "debug", "prod"];
+const envThresholdFilter = (treshold) => (env) => ENVIRONMENTS.indexOf(env) >= ENVIRONMENTS.indexOf(treshold);
+const _Tracer = class _Tracer {
+  constructor(tracer, filter = envThresholdFilter("debug")) {
+    __publicField(this, "meta", Meta.NOOP);
+    __publicField(this, "tracer");
+    __publicField(this, "filter");
+    this.tracer = tracer;
+    this.filter = filter;
+  }
+  child(meta) {
+    const t = new _Tracer(this.tracer, this.filter);
+    t.meta = meta;
+    return t;
+  }
+  /**
+   * Starts a new span in the debug environment. If a span already exists in the
+   * current context, it will be used as the parent span.
+   *
+   * @param key - The name of the span.
+   * @param f - The function to run under the span.
+   * @returns A span that tracks program execution. If the Tracer's environment
+   * rejects the 'debug' environment or the Tracer is noop, a NoopSpan is returned.
+   */
+  debug(key, f) {
+    return this.trace(key, "debug", f);
+  }
+  /**
+   * Starts a new span in the bench environment. If a span already exists in the
+   * current context, it will be used as the parent span.
+   *
+   * @param key - The name of the span.
+   * @param f - The function to run under the span.
+   * @returns A span that tracks program execution. If the Tracer's environment
+   * rejects the 'bench' environment or the Tracer is noop, a NoopSpan is returned.
+   */
+  bench(key, f) {
+    return this.trace(key, "bench", f);
+  }
+  /**
+   * Starts a new span in the prod environment. If a span already exists in the
+   * current context, it will be used as the parent span.
+   *
+   * @param key - The name of the span.
+   * @param f - The function to run under the span.
+   * @returns A span that tracks program execution. If the Tracer's environment
+   * rejects the 'prod' environment or the Tracer is noop, a NoopSpan is returned.
+   */
+  prod(key, f) {
+    return this.trace(key, "prod", f);
+  }
+  /**
+   * Stars a new span with the given key and environment. If a span already
+   * exists in the current context, it will be used as the parent span.
+   *
+   * @param key - The name of the span.
+   * @param env - The environment to run the span under.
+   * @param f - The function to run under the span.
+   * @returns A span that tracks program execution. If the Tracer's environment
+   * rejects the provided span or the Tracer is noop, a NoopSpan is returned.
+   */
+  trace(key, env, f) {
+    if (this.meta.noop || !this.filter(env))
+      return f(new NoopSpan(key));
+    return this.tracer.startActiveSpan(key, (otelSpan) => {
+      const span = new _Span(key, otelSpan);
+      const result = f(span);
+      otelSpan.end();
+      return result;
+    });
+  }
+  /**
+   * Injects metadata about the current trace into the provided carrier. This
+   * metadata can be paresed on teh other side of a network or IPC request to
+   * allow the trace to proapgate across services.
+   *
+   * @param carrier - The carrier to inject the metadata into.
+   */
+  propagate(carrier) {
+    if (this.meta.noop)
+      return;
+    const ctx = context.active();
+    propagation.inject(ctx, carrier, {
+      set: (carrier2, key, value) => {
+        carrier2[key] = value;
+      }
+    });
+  }
+};
+/** Tracer implementation that does nothing */
+__publicField(_Tracer, "NOOP", new _Tracer());
+let Tracer = _Tracer;
+class _Span {
+  constructor(key, span) {
+    __publicField(this, "key");
+    __publicField(this, "otel");
+    this.key = key;
+    this.otel = span;
+  }
+  set(key, value) {
+    this.otel.setAttribute(key, value);
+  }
+  recordError(error) {
+    if (error == null)
+      return;
+    this.otel.recordException(error);
+    this.otel.setStatus({ code: SpanStatusCode.ERROR });
+  }
+}
+class NoopSpan {
+  constructor(key) {
+    __publicField(this, "key");
+    this.key = key;
+  }
+  set(key, value) {
+  }
+  recordError(_) {
+  }
+}
+const _Instrumentation = class _Instrumentation {
+  constructor({
+    key = "",
+    serviceName = "",
+    logger = Logger.NOOP,
+    tracer = Tracer.NOOP,
+    noop = false,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    __meta
+  }) {
+    __publicField(this, "meta");
+    __publicField(this, "T");
+    __publicField(this, "L");
+    this.meta = __meta ?? new Meta(key, key, serviceName, noop);
+    this.T = tracer.child(this.meta);
+    this.L = logger.child(this.meta);
+  }
+  child(key) {
+    const __meta = this.meta.child(key);
+    return new _Instrumentation({ __meta, tracer: this.T, logger: this.L });
+  }
+};
+__publicField(_Instrumentation, "NOOP", new _Instrumentation({ noop: true }));
+let Instrumentation = _Instrumentation;
+const NOOP = Instrumentation.NOOP;
+export {
+  ContextAPI as C,
+  DiagAPI as D,
+  Instrumentation as I,
+  LOG_LEVELS as L,
+  NOOP as N,
+  Tracer as T,
+  _Span as _,
+  Logger as a,
+  NoopSpan as b,
+  logThresholdFilter as c,
+  createContextKey as d,
+  getGlobal as g,
+  logLevelKeyFiler as l,
+  registerGlobal as r,
+  unregisterGlobal as u
+};
+//# sourceMappingURL=instrumentation-2edee102.js.map