@synnaxlabs/alamos 0.1.0 → 0.2.0

package/dist/instrumentation-wOKsWHkZ.js

@@ -0,0 +1,676 @@
+var U = Object.defineProperty;
+var W = (r, e, t) => e in r ? U(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var s = (r, e, t) => (W(r, typeof e != "symbol" ? e + "" : e, t), t);
+const d = class d {
+  constructor(e, t, n = "", a = !1) {
+    s(this, "_noop", !1);
+    s(this, "key");
+    s(this, "path");
+    s(this, "serviceName");
+    this.key = e, this.path = t, this.serviceName = n, this._noop = a;
+  }
+  child(e) {
+    return new d(e, this.extendPath(e), this.serviceName, this.noop);
+  }
+  extendPath(e) {
+    return `${this.path}.${e}`;
+  }
+  get noop() {
+    return this._noop;
+  }
+};
+s(d, "NOOP", new d("", "", ""));
+let b = d;
+const S = ["debug", "info", "warn", "error"], Pe = (r) => {
+  const e = S.indexOf(r);
+  return ({ level: t }) => S.indexOf(t) >= e;
+}, Re = (r) => {
+  const { include: e, exclude: t } = r;
+  return ({ path: n }) => !(e != null && !e.some((a) => n.startsWith(a)) || t != null && t.some((a) => n.startsWith(a)));
+}, v = class v {
+  constructor(e = {}) {
+    s(this, "meta", b.NOOP);
+    s(this, "filters");
+    const { filters: t = [] } = e;
+    this.filters = t;
+  }
+  filter(e) {
+    return !this.meta.noop && this.filters.every(
+      (t) => t({
+        key: this.meta.key,
+        path: this.meta.path,
+        level: e
+      })
+    );
+  }
+  child(e) {
+    const t = new v({ filters: this.filters });
+    return t.meta = e, t;
+  }
+  debug(e, t) {
+    this.filter("debug") && (t == null ? console.log("%cDEBUG", "color: #8c00f0;", this.meta.path, e) : console.log("%cDEBUG", "color: #8c00f0;", this.meta.path, e, A(t)));
+  }
+  info(e, t) {
+    this.filter("info") && (t == null ? console.log("%cINFO", "color: #005eff;", this.meta.path, e) : console.log("%cINFO", "color: #005eff;", this.meta.path, e, A(t)));
+  }
+  warn(e, t) {
+    this.filter("warn") && (t == null ? console.warn("WARN", this.meta.path, e) : console.warn("WARN", this.meta.path, e, A(t)));
+  }
+  error(e, t) {
+    this.filter("error") && (t == null ? console.error("ERROR", this.meta.path, e) : console.error("ERROR", this.meta.path, e, A(t)));
+  }
+};
+s(v, "NOOP", new v());
+let P = v;
+const A = (r) => (Object.entries(r).forEach(([e, t]) => {
+  typeof t == "function" && (r[e] = t());
+}), r);
+var k = typeof globalThis == "object" ? globalThis : typeof self == "object" ? self : typeof window == "object" ? window : typeof global == "object" ? global : {}, g = "1.6.0", F = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+function X(r) {
+  var e = /* @__PURE__ */ new Set([r]), t = /* @__PURE__ */ new Set(), n = r.match(F);
+  if (!n)
+    return function() {
+      return !1;
+    };
+  var a = {
+    major: +n[1],
+    minor: +n[2],
+    patch: +n[3],
+    prerelease: n[4]
+  };
+  if (a.prerelease != null)
+    return function(c) {
+      return c === r;
+    };
+  function o(u) {
+    return t.add(u), !1;
+  }
+  function i(u) {
+    return e.add(u), !0;
+  }
+  return function(c) {
+    if (e.has(c))
+      return !0;
+    if (t.has(c))
+      return !1;
+    var f = c.match(F);
+    if (!f)
+      return o(c);
+    var p = {
+      major: +f[1],
+      minor: +f[2],
+      patch: +f[3],
+      prerelease: f[4]
+    };
+    return p.prerelease != null || a.major !== p.major ? o(c) : a.major === 0 ? a.minor === p.minor && a.patch <= p.patch ? i(c) : o(c) : a.minor <= p.minor ? i(c) : o(c);
+  };
+}
+var Y = X(g), D = g.split(".")[0], _ = Symbol.for("opentelemetry.js.api." + D), w = k;
+function I(r, e, t, n) {
+  var a;
+  n === void 0 && (n = !1);
+  var o = w[_] = (a = w[_]) !== null && a !== void 0 ? a : {
+    version: g
+  };
+  if (!n && o[r]) {
+    var i = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + r);
+    return t.error(i.stack || i.message), !1;
+  }
+  if (o.version !== g) {
+    var i = new Error("@opentelemetry/api: Registration of version v" + o.version + " for " + r + " does not match previously registered API v" + g);
+    return t.error(i.stack || i.message), !1;
+  }
+  return o[r] = e, t.debug("@opentelemetry/api: Registered a global for " + r + " v" + g + "."), !0;
+}
+function O(r) {
+  var e, t, n = (e = w[_]) === null || e === void 0 ? void 0 : e.version;
+  if (!(!n || !Y(n)))
+    return (t = w[_]) === null || t === void 0 ? void 0 : t[r];
+}
+function T(r, e) {
+  e.debug("@opentelemetry/api: Unregistering a global for " + r + " v" + g + ".");
+  var t = w[_];
+  t && delete t[r];
+}
+var q = function(r, e) {
+  var t = typeof Symbol == "function" && r[Symbol.iterator];
+  if (!t)
+    return r;
+  var n = t.call(r), a, o = [], i;
+  try {
+    for (; (e === void 0 || e-- > 0) && !(a = n.next()).done; )
+      o.push(a.value);
+  } catch (u) {
+    i = { error: u };
+  } finally {
+    try {
+      a && !a.done && (t = n.return) && t.call(n);
+    } finally {
+      if (i)
+        throw i.error;
+    }
+  }
+  return o;
+}, z = function(r, e, t) {
+  if (t || arguments.length === 2)
+    for (var n = 0, a = e.length, o; n < a; n++)
+      (o || !(n in e)) && (o || (o = Array.prototype.slice.call(e, 0, n)), o[n] = e[n]);
+  return r.concat(o || Array.prototype.slice.call(e));
+}, H = (
+  /** @class */
+  function() {
+    function r(e) {
+      this._namespace = e.namespace || "DiagComponentLogger";
+    }
+    return r.prototype.debug = function() {
+      for (var e = [], t = 0; t < arguments.length; t++)
+        e[t] = arguments[t];
+      return h("debug", this._namespace, e);
+    }, r.prototype.error = function() {
+      for (var e = [], t = 0; t < arguments.length; t++)
+        e[t] = arguments[t];
+      return h("error", this._namespace, e);
+    }, r.prototype.info = function() {
+      for (var e = [], t = 0; t < arguments.length; t++)
+        e[t] = arguments[t];
+      return h("info", this._namespace, e);
+    }, r.prototype.warn = function() {
+      for (var e = [], t = 0; t < arguments.length; t++)
+        e[t] = arguments[t];
+      return h("warn", this._namespace, e);
+    }, r.prototype.verbose = function() {
+      for (var e = [], t = 0; t < arguments.length; t++)
+        e[t] = arguments[t];
+      return h("verbose", this._namespace, e);
+    }, r;
+  }()
+);
+function h(r, e, t) {
+  var n = O("diag");
+  if (n)
+    return t.unshift(e), n[r].apply(n, z([], q(t), !1));
+}
+var l;
+(function(r) {
+  r[r.NONE = 0] = "NONE", r[r.ERROR = 30] = "ERROR", r[r.WARN = 50] = "WARN", r[r.INFO = 60] = "INFO", r[r.DEBUG = 70] = "DEBUG", r[r.VERBOSE = 80] = "VERBOSE", r[r.ALL = 9999] = "ALL";
+})(l || (l = {}));
+function J(r, e) {
+  r < l.NONE ? r = l.NONE : r > l.ALL && (r = l.ALL), e = e || {};
+  function t(n, a) {
+    var o = e[n];
+    return typeof o == "function" && r >= a ? o.bind(e) : function() {
+    };
+  }
+  return {
+    error: t("error", l.ERROR),
+    warn: t("warn", l.WARN),
+    info: t("info", l.INFO),
+    debug: t("debug", l.DEBUG),
+    verbose: t("verbose", l.VERBOSE)
+  };
+}
+var Q = function(r, e) {
+  var t = typeof Symbol == "function" && r[Symbol.iterator];
+  if (!t)
+    return r;
+  var n = t.call(r), a, o = [], i;
+  try {
+    for (; (e === void 0 || e-- > 0) && !(a = n.next()).done; )
+      o.push(a.value);
+  } catch (u) {
+    i = { error: u };
+  } finally {
+    try {
+      a && !a.done && (t = n.return) && t.call(n);
+    } finally {
+      if (i)
+        throw i.error;
+    }
+  }
+  return o;
+}, Z = function(r, e, t) {
+  if (t || arguments.length === 2)
+    for (var n = 0, a = e.length, o; n < a; n++)
+      (o || !(n in e)) && (o || (o = Array.prototype.slice.call(e, 0, n)), o[n] = e[n]);
+  return r.concat(o || Array.prototype.slice.call(e));
+}, L = "diag", E = (
+  /** @class */
+  function() {
+    function r() {
+      function e(a) {
+        return function() {
+          for (var o = [], i = 0; i < arguments.length; i++)
+            o[i] = arguments[i];
+          var u = O("diag");
+          if (u)
+            return u[a].apply(u, Z([], Q(o), !1));
+        };
+      }
+      var t = this, n = function(a, o) {
+        var i, u, c;
+        if (o === void 0 && (o = { logLevel: l.INFO }), a === t) {
+          var f = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+          return t.error((i = f.stack) !== null && i !== void 0 ? i : f.message), !1;
+        }
+        typeof o == "number" && (o = {
+          logLevel: o
+        });
+        var p = O("diag"), j = J((u = o.logLevel) !== null && u !== void 0 ? u : l.INFO, a);
+        if (p && !o.suppressOverrideMessage) {
+          var G = (c = new Error().stack) !== null && c !== void 0 ? c : "<failed to generate stacktrace>";
+          p.warn("Current logger will be overwritten from " + G), j.warn("Current logger will overwrite one already registered from " + G);
+        }
+        return I("diag", j, t, !0);
+      };
+      t.setLogger = n, t.disable = function() {
+        T(L, t);
+      }, t.createComponentLogger = function(a) {
+        return new H(a);
+      }, t.verbose = e("verbose"), t.debug = e("debug"), t.info = e("info"), t.warn = e("warn"), t.error = e("error");
+    }
+    return r.instance = function() {
+      return this._instance || (this._instance = new r()), this._instance;
+    }, r;
+  }()
+), ee = function(r, e) {
+  var t = typeof Symbol == "function" && r[Symbol.iterator];
+  if (!t)
+    return r;
+  var n = t.call(r), a, o = [], i;
+  try {
+    for (; (e === void 0 || e-- > 0) && !(a = n.next()).done; )
+      o.push(a.value);
+  } catch (u) {
+    i = { error: u };
+  } finally {
+    try {
+      a && !a.done && (t = n.return) && t.call(n);
+    } finally {
+      if (i)
+        throw i.error;
+    }
+  }
+  return o;
+}, te = function(r) {
+  var e = typeof Symbol == "function" && Symbol.iterator, t = e && r[e], n = 0;
+  if (t)
+    return t.call(r);
+  if (r && typeof r.length == "number")
+    return {
+      next: function() {
+        return r && n >= r.length && (r = void 0), { value: r && r[n++], done: !r };
+      }
+    };
+  throw new TypeError(e ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}, re = (
+  /** @class */
+  function() {
+    function r(e) {
+      this._entries = e ? new Map(e) : /* @__PURE__ */ new Map();
+    }
+    return r.prototype.getEntry = function(e) {
+      var t = this._entries.get(e);
+      if (t)
+        return Object.assign({}, t);
+    }, r.prototype.getAllEntries = function() {
+      return Array.from(this._entries.entries()).map(function(e) {
+        var t = ee(e, 2), n = t[0], a = t[1];
+        return [n, a];
+      });
+    }, r.prototype.setEntry = function(e, t) {
+      var n = new r(this._entries);
+      return n._entries.set(e, t), n;
+    }, r.prototype.removeEntry = function(e) {
+      var t = new r(this._entries);
+      return t._entries.delete(e), t;
+    }, r.prototype.removeEntries = function() {
+      for (var e, t, n = [], a = 0; a < arguments.length; a++)
+        n[a] = arguments[a];
+      var o = new r(this._entries);
+      try {
+        for (var i = te(n), u = i.next(); !u.done; u = i.next()) {
+          var c = u.value;
+          o._entries.delete(c);
+        }
+      } catch (f) {
+        e = { error: f };
+      } finally {
+        try {
+          u && !u.done && (t = i.return) && t.call(i);
+        } finally {
+          if (e)
+            throw e.error;
+        }
+      }
+      return o;
+    }, r.prototype.clear = function() {
+      return new r();
+    }, r;
+  }()
+);
+E.instance();
+function ne(r) {
+  return r === void 0 && (r = {}), new re(new Map(Object.entries(r)));
+}
+function ae(r) {
+  return Symbol.for(r);
+}
+var oe = (
+  /** @class */
+  /* @__PURE__ */ function() {
+    function r(e) {
+      var t = this;
+      t._currentContext = e ? new Map(e) : /* @__PURE__ */ new Map(), t.getValue = function(n) {
+        return t._currentContext.get(n);
+      }, t.setValue = function(n, a) {
+        var o = new r(t._currentContext);
+        return o._currentContext.set(n, a), o;
+      }, t.deleteValue = function(n) {
+        var a = new r(t._currentContext);
+        return a._currentContext.delete(n), a;
+      };
+    }
+    return r;
+  }()
+), ie = new oe(), ue = {
+  get: function(r, e) {
+    if (r != null)
+      return r[e];
+  },
+  keys: function(r) {
+    return r == null ? [] : Object.keys(r);
+  }
+}, se = {
+  set: function(r, e, t) {
+    r != null && (r[e] = t);
+  }
+}, ce = function(r, e) {
+  var t = typeof Symbol == "function" && r[Symbol.iterator];
+  if (!t)
+    return r;
+  var n = t.call(r), a, o = [], i;
+  try {
+    for (; (e === void 0 || e-- > 0) && !(a = n.next()).done; )
+      o.push(a.value);
+  } catch (u) {
+    i = { error: u };
+  } finally {
+    try {
+      a && !a.done && (t = n.return) && t.call(n);
+    } finally {
+      if (i)
+        throw i.error;
+    }
+  }
+  return o;
+}, le = function(r, e, t) {
+  if (t || arguments.length === 2)
+    for (var n = 0, a = e.length, o; n < a; n++)
+      (o || !(n in e)) && (o || (o = Array.prototype.slice.call(e, 0, n)), o[n] = e[n]);
+  return r.concat(o || Array.prototype.slice.call(e));
+}, fe = (
+  /** @class */
+  function() {
+    function r() {
+    }
+    return r.prototype.active = function() {
+      return ie;
+    }, r.prototype.with = function(e, t, n) {
+      for (var a = [], o = 3; o < arguments.length; o++)
+        a[o - 3] = arguments[o];
+      return t.call.apply(t, le([n], ce(a), !1));
+    }, r.prototype.bind = function(e, t) {
+      return t;
+    }, r.prototype.enable = function() {
+      return this;
+    }, r.prototype.disable = function() {
+      return this;
+    }, r;
+  }()
+), pe = function(r, e) {
+  var t = typeof Symbol == "function" && r[Symbol.iterator];
+  if (!t)
+    return r;
+  var n = t.call(r), a, o = [], i;
+  try {
+    for (; (e === void 0 || e-- > 0) && !(a = n.next()).done; )
+      o.push(a.value);
+  } catch (u) {
+    i = { error: u };
+  } finally {
+    try {
+      a && !a.done && (t = n.return) && t.call(n);
+    } finally {
+      if (i)
+        throw i.error;
+    }
+  }
+  return o;
+}, ge = function(r, e, t) {
+  if (t || arguments.length === 2)
+    for (var n = 0, a = e.length, o; n < a; n++)
+      (o || !(n in e)) && (o || (o = Array.prototype.slice.call(e, 0, n)), o[n] = e[n]);
+  return r.concat(o || Array.prototype.slice.call(e));
+}, N = "context", he = new fe(), V = (
+  /** @class */
+  function() {
+    function r() {
+    }
+    return r.getInstance = function() {
+      return this._instance || (this._instance = new r()), this._instance;
+    }, r.prototype.setGlobalContextManager = function(e) {
+      return I(N, e, E.instance());
+    }, r.prototype.active = function() {
+      return this._getContextManager().active();
+    }, r.prototype.with = function(e, t, n) {
+      for (var a, o = [], i = 3; i < arguments.length; i++)
+        o[i - 3] = arguments[i];
+      return (a = this._getContextManager()).with.apply(a, ge([e, t, n], pe(o), !1));
+    }, r.prototype.bind = function(e, t) {
+      return this._getContextManager().bind(e, t);
+    }, r.prototype._getContextManager = function() {
+      return O(N) || he;
+    }, r.prototype.disable = function() {
+      this._getContextManager().disable(), T(N, E.instance());
+    }, r;
+  }()
+), R;
+(function(r) {
+  r[r.UNSET = 0] = "UNSET", r[r.OK = 1] = "OK", r[r.ERROR = 2] = "ERROR";
+})(R || (R = {}));
+var de = V.getInstance(), ve = (
+  /** @class */
+  function() {
+    function r() {
+    }
+    return r.prototype.inject = function(e, t) {
+    }, r.prototype.extract = function(e, t) {
+      return e;
+    }, r.prototype.fields = function() {
+      return [];
+    }, r;
+  }()
+), M = ae("OpenTelemetry Baggage Key");
+function K(r) {
+  return r.getValue(M) || void 0;
+}
+function ye() {
+  return K(V.getInstance().active());
+}
+function me(r, e) {
+  return r.setValue(M, e);
+}
+function be(r) {
+  return r.deleteValue(M);
+}
+var x = "propagation", _e = new ve(), we = (
+  /** @class */
+  function() {
+    function r() {
+      this.createBaggage = ne, this.getBaggage = K, this.getActiveBaggage = ye, this.setBaggage = me, this.deleteBaggage = be;
+    }
+    return r.getInstance = function() {
+      return this._instance || (this._instance = new r()), this._instance;
+    }, r.prototype.setGlobalPropagator = function(e) {
+      return I(x, e, E.instance());
+    }, r.prototype.inject = function(e, t, n) {
+      return n === void 0 && (n = se), this._getGlobalPropagator().inject(e, t, n);
+    }, r.prototype.extract = function(e, t, n) {
+      return n === void 0 && (n = ue), this._getGlobalPropagator().extract(e, t, n);
+    }, r.prototype.fields = function() {
+      return this._getGlobalPropagator().fields();
+    }, r.prototype.disable = function() {
+      T(x, E.instance());
+    }, r.prototype._getGlobalPropagator = function() {
+      return O(x) || _e;
+    }, r;
+  }()
+), Oe = we.getInstance();
+const $ = ["bench", "debug", "prod"], Ee = (r) => (e) => $.indexOf(e) >= $.indexOf(r), y = class y {
+  constructor(e, t = Ee("debug")) {
+    s(this, "meta", b.NOOP);
+    s(this, "tracer");
+    s(this, "filter");
+    this.tracer = e, this.filter = t;
+  }
+  child(e) {
+    const t = new y(this.tracer, this.filter);
+    return t.meta = e, 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(e, t) {
+    return this.trace(e, "debug", t);
+  }
+  /**
+   * 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(e, t) {
+    return this.trace(e, "bench", t);
+  }
+  /**
+   * 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(e, t) {
+    return this.trace(e, "prod", t);
+  }
+  /**
+   * 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(e, t, n) {
+    return this.meta.noop || !this.filter(t) ? n(new Ne(e)) : this.tracer.startActiveSpan(e, (a) => {
+      const o = new Ae(e, a), i = n(o);
+      return a.end(), i;
+    });
+  }
+  /**
+   * 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(e) {
+    if (this.meta.noop)
+      return;
+    const t = de.active();
+    Oe.inject(t, e, {
+      set: (n, a, o) => {
+        n[a] = o;
+      }
+    });
+  }
+};
+/** Tracer implementation that does nothing */
+s(y, "NOOP", new y());
+let C = y;
+class Ae {
+  constructor(e, t) {
+    s(this, "key");
+    s(this, "otel");
+    this.key = e, this.otel = t;
+  }
+  set(e, t) {
+    this.otel.setAttribute(e, t);
+  }
+  recordError(e) {
+    e != null && (this.otel.recordException(e), this.otel.setStatus({ code: R.ERROR }));
+  }
+}
+class Ne {
+  constructor(e) {
+    s(this, "key");
+    this.key = e;
+  }
+  set(e, t) {
+  }
+  recordError(e) {
+  }
+}
+const m = class m {
+  constructor({
+    key: e = "",
+    serviceName: t = "",
+    logger: n = P.NOOP,
+    tracer: a = C.NOOP,
+    noop: o = !1,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    __meta: i
+  }) {
+    s(this, "meta");
+    s(this, "T");
+    s(this, "L");
+    this.meta = i ?? new b(e, e, t, o), this.T = a.child(this.meta), this.L = n.child(this.meta);
+  }
+  child(e) {
+    const t = this.meta.child(e);
+    return new m({ __meta: t, tracer: this.T, logger: this.L });
+  }
+};
+s(m, "NOOP", new m({ noop: !0 }));
+let B = m;
+const Ce = B.NOOP;
+export {
+  V as C,
+  E as D,
+  B as I,
+  S as L,
+  Ce as N,
+  C as T,
+  Ae as _,
+  P as a,
+  Ne as b,
+  Pe as c,
+  ae as d,
+  O as g,
+  Re as l,
+  I as r,
+  T as u
+};
+//# sourceMappingURL=instrumentation-wOKsWHkZ.js.map