@hellsoft/vaka-node 0.0.0-stage → 0.3.0

package/dist/index.mjs

@@ -0,0 +1,953 @@
+// src/index.ts
+import { randomUUID } from "node:crypto";
+import { hostname, release as osRelease, type as osType } from "node:os";
+import { trace } from "@opentelemetry/api";
+
+// src/stack.ts
+import { readFileSync, statSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+var V8 = /^\s*at (?:(.+?) \()?((?:[a-z][a-z0-9+.-]*:|\/|[a-z]:\\|\\\\)[^)]*?):(\d+):(\d+)\)?\s*$/i;
+var V8_NOPOS = /^\s*at (?:(.+?) \()?(native|<anonymous>|node:[^)]+)\)?\s*$/i;
+function parseStack(stack, cwd = safeCwd()) {
+  if (!stack) return [];
+  const frames = [];
+  for (const line of stack.split("\n").slice(0, 100)) {
+    let fn;
+    let path;
+    let lineno;
+    let colno;
+    const m = V8.exec(line);
+    if (m) {
+      fn = m[1];
+      path = m[2];
+      lineno = +m[3];
+      colno = +m[4];
+    } else {
+      const n = V8_NOPOS.exec(line);
+      if (!n) continue;
+      fn = n[1];
+      path = n[2];
+    }
+    if (path.startsWith("file://")) {
+      try {
+        path = fileURLToPath(path);
+      } catch {
+      }
+    }
+    if (fn) fn = fn.replace(/^async /, "").replace(/^new /, "").replace(/ \[as [^\]]+\]$/, "");
+    const internal = /^node:|^native$|^<anonymous>$|^internal\//.test(path);
+    const vendor = /[\\/]node_modules[\\/]/.test(path);
+    frames.push({
+      function: fn || "<anonymous>",
+      module: moduleName(path, cwd),
+      abs_path: path,
+      filename: relative(path, cwd),
+      lineno,
+      colno,
+      in_app: !internal && !vendor
+    });
+  }
+  return frames;
+}
+function safeCwd() {
+  try {
+    return process.cwd();
+  } catch {
+    return "";
+  }
+}
+function relative(path, cwd) {
+  if (cwd && path.startsWith(cwd + "/")) return path.slice(cwd.length + 1);
+  if (cwd && path.startsWith(cwd + "\\")) return path.slice(cwd.length + 1).replace(/\\/g, "/");
+  return path;
+}
+function moduleName(path, cwd) {
+  const norm = path.replace(/\\/g, "/");
+  const i = norm.lastIndexOf("/node_modules/");
+  if (i >= 0) {
+    const rest = norm.slice(i + 14).split("/");
+    const pkg = rest[0].startsWith("@") ? rest.slice(0, 2).join("/") : rest[0];
+    const file = rest.slice(rest[0].startsWith("@") ? 2 : 1).join("/");
+    return `${pkg}:${file.replace(/\.[cm]?[jt]sx?$/, "")}`;
+  }
+  if (norm.startsWith("node:")) return norm.slice(5);
+  const rel = relative(path, cwd).replace(/\\/g, "/");
+  return rel.startsWith("/") ? void 0 : rel.replace(/\.[cm]?[jt]sx?$/, "");
+}
+var CONTEXT_LINES = 5;
+var MAX_FILE_BYTES = 1 << 20;
+var cache = /* @__PURE__ */ new Map();
+function lines(path) {
+  if (cache.has(path)) return cache.get(path);
+  let out = null;
+  try {
+    if (statSync(path).size <= MAX_FILE_BYTES) out = readFileSync(path, "utf8").split(/\r?\n/);
+  } catch {
+    out = null;
+  }
+  if (cache.size > 200) cache.delete(cache.keys().next().value);
+  cache.set(path, out);
+  return out;
+}
+function addSourceContext(frames, maxFrames = 10) {
+  let n = 0;
+  for (const f of frames) {
+    if (n >= maxFrames) break;
+    if (!f.in_app || !f.abs_path || !f.lineno) continue;
+    const src = lines(f.abs_path);
+    if (!src || f.lineno > src.length) continue;
+    n++;
+    const i = f.lineno - 1;
+    const cut = (s) => s.length > 300 ? s.slice(0, 300) + "\u2026" : s;
+    f.context_line = cut(src[i]);
+    f.pre_context = src.slice(Math.max(0, i - CONTEXT_LINES), i).map(cut);
+    f.post_context = src.slice(i + 1, i + 1 + CONTEXT_LINES).map(cut);
+  }
+  return frames;
+}
+
+// src/scope.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var MAX_BREADCRUMBS = 100;
+var Scope = class _Scope {
+  user;
+  tags = {};
+  contexts = {};
+  breadcrumbs = [];
+  flags = {};
+  request;
+  transaction;
+  clone() {
+    const s = new _Scope();
+    s.user = this.user;
+    s.tags = { ...this.tags };
+    s.contexts = { ...this.contexts };
+    s.breadcrumbs = this.breadcrumbs.slice();
+    s.flags = { ...this.flags };
+    s.request = this.request;
+    s.transaction = this.transaction;
+    return s;
+  }
+  addBreadcrumb(b, max = MAX_BREADCRUMBS) {
+    this.breadcrumbs.push({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", ...b });
+    if (this.breadcrumbs.length > max) this.breadcrumbs.splice(0, this.breadcrumbs.length - max);
+  }
+};
+var storage = new AsyncLocalStorage();
+var globalScope = new Scope();
+function currentScope() {
+  return storage.getStore() || globalScope;
+}
+function withScope(fn) {
+  const scope = currentScope().clone();
+  return storage.run(scope, () => fn(scope));
+}
+function _resetScopes() {
+  globalScope = new Scope();
+  storage.disable();
+}
+
+// src/transport.ts
+import { gzipSync } from "node:zlib";
+import { context } from "@opentelemetry/api";
+import { suppressTracing } from "@opentelemetry/core";
+var MAX_BATCH = 1e3;
+var MAX_QUEUE = 5e3;
+var Transport = class {
+  constructor(o) {
+    this.o = o;
+  }
+  queue = [];
+  timer;
+  backoffUntil = 0;
+  backoffMs = 0;
+  inflight = /* @__PURE__ */ new Set();
+  disabled = false;
+  send(item, urgent = false) {
+    if (this.disabled) return;
+    this.queue.push(item);
+    if (this.queue.length > MAX_QUEUE) this.queue.splice(0, this.queue.length - MAX_QUEUE);
+    if (urgent || this.queue.length >= 100) this.schedule(urgent ? 0 : 10);
+    else this.schedule(this.o.flushIntervalMs);
+  }
+  schedule(ms) {
+    if (this.timer) {
+      if (ms > 0) return;
+      clearTimeout(this.timer);
+    }
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      void this.drain();
+    }, ms);
+    this.timer.unref?.();
+  }
+  async drain() {
+    while (this.queue.length && !this.disabled) {
+      if (Date.now() < this.backoffUntil) {
+        this.schedule(this.backoffUntil - Date.now());
+        return;
+      }
+      const items = this.queue.splice(0, MAX_BATCH);
+      const p = this.post(items);
+      this.inflight.add(p);
+      try {
+        await p;
+      } finally {
+        this.inflight.delete(p);
+      }
+    }
+  }
+  async post(items) {
+    const json = JSON.stringify({ sdk: this.o.sdk, items });
+    const headers2 = { "Content-Type": "application/json", "X-Vaka-Key": this.o.key, "X-Vaka-Sdk": `${this.o.sdk.name}/${this.o.sdk.version}` };
+    let body = json;
+    if (json.length > 2048) {
+      body = gzipSync(json);
+      headers2["Content-Encoding"] = "gzip";
+    }
+    try {
+      const r = await context.with(
+        suppressTracing(context.active()),
+        () => fetch(`${this.o.endpoint}/ingest/v1/batch`, { method: "POST", headers: headers2, body, signal: AbortSignal.timeout(15e3) })
+      );
+      if (r.status === 429 || r.status >= 500) return this.retry(items, r.status);
+      this.backoffMs = 0;
+      if (r.status === 401) {
+        this.disabled = true;
+        this.queue = [];
+        this.o.log("ingest key rejected (401); disabling until restart");
+      } else if (r.status === 413 && items.length > 1) {
+        const half = Math.ceil(items.length / 2);
+        await this.post(items.slice(0, half));
+        await this.post(items.slice(half));
+      } else if (r.status >= 400) {
+        this.o.log("batch dropped", r.status, await r.text().catch(() => ""));
+      } else {
+        this.o.log("sent", items.length, "items", r.status);
+      }
+    } catch (e) {
+      this.retry(items, String(e?.message || e));
+    }
+  }
+  retry(items, why) {
+    this.backoffMs = Math.min(3e5, this.backoffMs ? this.backoffMs * 2 : 2e3);
+    this.backoffUntil = Date.now() + this.backoffMs;
+    this.queue = items.concat(this.queue).slice(0, MAX_QUEUE);
+    this.o.log("send failed, retrying in", this.backoffMs, "ms:", why);
+    this.schedule(this.backoffMs);
+  }
+  /** Send everything queued now, waiting at most `timeoutMs`. Resolves true when all was sent. */
+  async flush(timeoutMs = 5e3) {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    this.backoffUntil = 0;
+    const work = (async () => {
+      await Promise.all([...this.inflight]);
+      await this.drain();
+      return this.queue.length === 0;
+    })();
+    let t;
+    const timeout = new Promise((res) => {
+      t = setTimeout(() => res(false), timeoutMs);
+      t.unref?.();
+    });
+    try {
+      return await Promise.race([work, timeout]);
+    } finally {
+      if (t) clearTimeout(t);
+    }
+  }
+  pending() {
+    return this.queue.length;
+  }
+};
+
+// src/otel.ts
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-proto";
+import { BatchLogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { BatchSpanProcessor, ParentBasedSampler, TraceIdRatioBasedSampler } from "@opentelemetry/sdk-trace";
+import { defaultResource, resourceFromAttributes } from "@opentelemetry/resources";
+import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
+var headers = (key) => ({ "x-vaka-key": key });
+function vakaSpanExporter(o) {
+  return new OTLPTraceExporter({ url: `${o.endpoint.replace(/\/+$/, "")}/ingest/otlp/v1/traces`, headers: headers(o.key) });
+}
+function vakaLogRecordProcessor(o) {
+  return new BatchLogRecordProcessor({ exporter: new OTLPLogExporter({ url: `${o.endpoint.replace(/\/+$/, "")}/ingest/otlp/v1/logs`, headers: headers(o.key) }) });
+}
+var VakaScopeSpanProcessor = class {
+  onStart(span, _ctx) {
+    const s = currentScope();
+    if (s.user?.id) span.setAttribute("enduser.id", s.user.id);
+    for (const k of Object.keys(s.flags)) span.setAttribute(`feature_flag.${k}`, s.flags[k]);
+  }
+  onEnd() {
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+};
+function startOtel(c) {
+  const attrs = { ...c.resourceAttributes || {} };
+  if (c.serviceName) attrs["service.name"] = c.serviceName;
+  if (c.release) attrs["service.version"] = c.release;
+  if (c.environment) attrs["deployment.environment.name"] = c.environment;
+  const rate = Number.isFinite(c.tracesSampleRate) ? Math.max(0, Math.min(1, c.tracesSampleRate)) : 1;
+  const sdk = new NodeSDK({
+    resource: defaultResource().merge(resourceFromAttributes(attrs)),
+    serviceName: c.serviceName,
+    sampler: new ParentBasedSampler({ root: new TraceIdRatioBasedSampler(rate) }),
+    spanProcessors: [new VakaScopeSpanProcessor(), new BatchSpanProcessor({ exporter: vakaSpanExporter(c) })],
+    logRecordProcessors: c.logs ? [vakaLogRecordProcessor(c)] : [],
+    metricReaders: [],
+    instrumentations: c.instrumentations || [new HttpInstrumentation()]
+  });
+  sdk.start();
+  return sdk;
+}
+
+// src/integrations.ts
+import diagnostics from "node:diagnostics_channel";
+import { format } from "node:util";
+var addCrumb = () => void 0;
+var ownEndpoint = "";
+var unhooks = [];
+function installBreadcrumbs(endpoint, add) {
+  addCrumb = add;
+  ownEndpoint = endpoint;
+  for (const level of ["warn", "error"]) {
+    const orig = console[level];
+    const wrapped = function(...args) {
+      try {
+        addCrumb({ category: "console", level: level === "warn" ? "warning" : "error", message: format(...args).slice(0, 500) });
+      } catch {
+      }
+      return orig.apply(this, args);
+    };
+    console[level] = wrapped;
+    unhooks.push(() => {
+      if (console[level] === wrapped) console[level] = orig;
+    });
+  }
+  const starts = /* @__PURE__ */ new WeakMap();
+  sub("undici:request:create", (m) => {
+    starts.set(m.request, { t: Date.now(), scope: currentScope() });
+  });
+  sub("undici:request:headers", (m) => {
+    const s = starts.get(m.request);
+    httpCrumb(s?.scope, m.request.method || "GET", `${m.request.origin || ""}${m.request.path || ""}`, m.response.statusCode, s?.t);
+  });
+  sub("undici:request:error", (m) => {
+    const s = starts.get(m.request);
+    httpCrumb(s?.scope, m.request.method || "GET", `${m.request.origin || ""}${m.request.path || ""}`, void 0, s?.t, m.error);
+  });
+  const httpStarts = /* @__PURE__ */ new WeakMap();
+  sub("http.client.request.start", (m) => httpStarts.set(m.request, { t: Date.now(), scope: currentScope() }));
+  sub("http.client.response.finish", (m) => {
+    const s = httpStarts.get(m.request);
+    httpCrumb(s?.scope, m.request.method || "GET", `${m.request.protocol || "http:"}//${m.request.host || ""}${m.request.path || ""}`, m.response.statusCode, s?.t);
+  });
+}
+function sub(name, fn) {
+  const safe = (m) => {
+    try {
+      fn(m);
+    } catch {
+    }
+  };
+  diagnostics.subscribe(name, safe);
+  unhooks.push(() => diagnostics.unsubscribe(name, safe));
+}
+function stripQuery(url) {
+  const i = url.search(/[?#]/);
+  return i >= 0 ? url.slice(0, i) : url;
+}
+function httpCrumb(scope, method, url, status, t, err) {
+  if (ownEndpoint && url.startsWith(ownEndpoint)) return;
+  const clean2 = stripQuery(url);
+  const level = err ? "error" : status && status >= 500 ? "error" : status && status >= 400 ? "warning" : "info";
+  const b = {
+    category: "http",
+    level,
+    message: err ? `${method} ${clean2} failed: ${err.message}` : `${method} ${clean2} ${status}`,
+    data: { method, url: clean2, status_code: status, duration_ms: t ? Date.now() - t : void 0 }
+  };
+  if (scope) scope.addBreadcrumb(b);
+  else addCrumb(b);
+}
+function uninstallIntegrations() {
+  while (unhooks.length) unhooks.pop()();
+}
+function installProcessHandlers(h) {
+  const onUncaught = (err, origin) => {
+    h.capture(err, true, origin === "unhandledRejection" ? "unhandledRejection" : "uncaughtException");
+    if (!h.exitOnUncaught || process.listenerCount("uncaughtException") > 1) return;
+    process.stderr.write(`${err?.stack || String(err)}
+`);
+    process.exitCode = 1;
+    h.flush(h.shutdownTimeoutMs).finally(() => process.exit(1));
+  };
+  const onRejection = (reason) => {
+    const fatal = h.unhandledRejection === "strict" && process.listenerCount("unhandledRejection") <= 1;
+    h.capture(reason, fatal, "unhandledRejection");
+    if (process.listenerCount("unhandledRejection") > 1 || h.unhandledRejection === "none") return;
+    const text = reason?.stack || String(reason);
+    if (h.unhandledRejection === "warn") {
+      process.emitWarning(`Unhandled promise rejection: ${text}`);
+      return;
+    }
+    process.stderr.write(`${text}
+`);
+    process.exitCode = 1;
+    h.flush(h.shutdownTimeoutMs).finally(() => process.exit(1));
+  };
+  process.on("uncaughtException", onUncaught);
+  process.on("unhandledRejection", onRejection);
+  unhooks.push(() => {
+    process.off("uncaughtException", onUncaught);
+    process.off("unhandledRejection", onRejection);
+  });
+}
+function nodeRejectionMode() {
+  const args = [...process.execArgv, ...(process.env.NODE_OPTIONS || "").split(/\s+/)];
+  const flag = args.find((a) => a.startsWith("--unhandled-rejections="));
+  const v = flag ? flag.split("=")[1] : "throw";
+  if (v === "none") return "none";
+  if (v === "warn" || v === "warn-with-error-code") return "warn";
+  return "strict";
+}
+var SAFE_HEADERS = ["user-agent", "content-type", "content-length", "accept", "referer", "x-request-id", "traceparent"];
+function requestInfo(req) {
+  const raw = req.originalUrl || req.url || "";
+  const q = raw.indexOf("?");
+  const path = q >= 0 ? raw.slice(0, q) : raw;
+  const headers2 = {};
+  for (const h of SAFE_HEADERS) {
+    const v = req.headers?.[h];
+    if (v) headers2[h] = Array.isArray(v) ? v.join(", ") : v;
+  }
+  const host = req.headers?.["x-forwarded-host"] || req.headers?.host;
+  const proto = req.protocol || req.headers?.["x-forwarded-proto"] || "http";
+  return {
+    method: req.method,
+    url: host ? `${proto}://${host}${path}` : path,
+    route: routeOf(req),
+    query_string: q >= 0 ? raw.slice(q + 1, q + 1 + 500) : void 0,
+    headers: headers2
+  };
+}
+function routeOf(req) {
+  return req.routeOptions?.url || req.routerPath || req.route?.path;
+}
+function makeRequestHandler() {
+  return function vakaRequestHandler(req, _res, next) {
+    const scope = currentScope().clone();
+    scope.breadcrumbs = [];
+    scope.request = requestInfo(req);
+    storage.run(scope, () => next());
+  };
+}
+function makeErrorHandler(capture, shouldCapture2) {
+  return function vakaErrorHandler(err, req, res, next) {
+    const e = err;
+    const status = e?.status || e?.statusCode || (res?.statusCode && res.statusCode >= 400 ? res.statusCode : 500);
+    if (shouldCapture2(status)) {
+      const scope = currentScope();
+      scope.request = { ...requestInfo(req), ...scope.request?.route ? { route: scope.request.route } : {} };
+      if (!scope.request.route) scope.request.route = routeOf(req);
+      capture(err, { handled: false, mechanism: "express", status });
+    }
+    next(err);
+  };
+}
+function makeFastifyPlugin(capture, shouldCapture2) {
+  const plugin = function vakaFastify(fastify, _opts, done) {
+    fastify.addHook("onRequest", (req, _reply, next) => {
+      const scope = currentScope().clone();
+      scope.breadcrumbs = [];
+      scope.request = requestInfo(req);
+      storage.run(scope, next);
+    });
+    fastify.addHook("onError", (req, _reply, err, next) => {
+      const status = err?.statusCode || 500;
+      if (shouldCapture2(status)) {
+        const scope = currentScope();
+        scope.request = requestInfo(req);
+        capture(err, { handled: false, mechanism: "fastify", status });
+      }
+      next();
+    });
+    done();
+  };
+  plugin[Symbol.for("skip-override")] = true;
+  plugin[Symbol.for("fastify.display-name")] = "vaka";
+  return plugin;
+}
+
+// src/index.ts
+var SDK = { name: "vaka-node", version: "0.3.0" };
+var opts;
+var transport;
+var otelSdk;
+var processId = randomUUID();
+function log(...a) {
+  if (opts?.debug) process.stderr.write(`[vaka] ${a.map((x) => typeof x === "string" ? x : JSON.stringify(x)).join(" ")}
+`);
+}
+function env(...names) {
+  for (const n of names) {
+    const v = process.env[n];
+    if (v) return v;
+  }
+  return void 0;
+}
+function init(options = {}) {
+  if (opts) return;
+  options = Object.fromEntries(Object.entries(options).filter(([, v]) => v !== void 0));
+  const key = options.key || env("VAKA_KEY", "VAKA_INGEST_KEY");
+  const endpoint = (options.endpoint || env("VAKA_ENDPOINT") || "").replace(/\/+$/, "");
+  if (!key || !endpoint) {
+    process.emitWarning("[vaka] init needs { key, endpoint } (or VAKA_KEY and VAKA_ENDPOINT); SDK disabled");
+    return;
+  }
+  opts = {
+    otel: true,
+    tracesSampleRate: 1,
+    logs: true,
+    captureUnhandled: true,
+    exitOnUncaught: true,
+    shutdownTimeoutMs: 2e3,
+    breadcrumbs: true,
+    maxBreadcrumbs: 100,
+    sourceContext: true,
+    errorSampleRate: 1,
+    flagsCacheTtlMs: 3e4,
+    flushIntervalMs: 2e3,
+    ...options,
+    key,
+    endpoint,
+    release: options.release || env("VAKA_RELEASE", "npm_package_version"),
+    environment: options.environment || env("VAKA_ENVIRONMENT", "NODE_ENV") || "production",
+    serviceName: options.serviceName || env("OTEL_SERVICE_NAME", "npm_package_name")
+  };
+  const o = opts;
+  transport = new Transport({ endpoint, key, sdk: SDK, flushIntervalMs: o.flushIntervalMs, log });
+  if (o.breadcrumbs) installBreadcrumbs(endpoint, (b) => addBreadcrumb(b));
+  if (o.captureUnhandled) {
+    installProcessHandlers({
+      capture: (err, fatal, mechanism) => {
+        captureException(err, { handled: false, level: fatal ? "fatal" : "error", tags: { mechanism } }, fatal);
+      },
+      flush: (ms) => close(ms),
+      unhandledRejection: o.unhandledRejection || nodeRejectionMode(),
+      exitOnUncaught: o.exitOnUncaught,
+      shutdownTimeoutMs: o.shutdownTimeoutMs
+    });
+  }
+  if (o.otel) {
+    try {
+      otelSdk = startOtel({
+        endpoint,
+        key,
+        serviceName: o.serviceName,
+        release: o.release,
+        environment: o.environment,
+        tracesSampleRate: o.tracesSampleRate,
+        logs: o.logs,
+        instrumentations: o.instrumentations,
+        resourceAttributes: o.resourceAttributes
+      });
+    } catch (e) {
+      log("OpenTelemetry setup failed:", String(e));
+    }
+  }
+  process.once("beforeExit", () => void flush());
+  log("initialized", endpoint, o.release || "(no release)", o.environment);
+}
+function isInitialized() {
+  return !!opts;
+}
+function setUser(user) {
+  currentScope().user = user === null ? void 0 : typeof user === "string" ? { id: user } : user;
+  const span = trace.getActiveSpan();
+  const id = currentScope().user?.id;
+  if (span && id) span.setAttribute("enduser.id", id);
+}
+function setTag(key, value) {
+  currentScope().tags[key] = String(value);
+}
+function setTags(tags) {
+  for (const k of Object.keys(tags)) setTag(k, tags[k]);
+}
+function setContext(name, value) {
+  if (value === null) delete currentScope().contexts[name];
+  else currentScope().contexts[name] = value;
+}
+function addBreadcrumb(b) {
+  currentScope().addBreadcrumb(b, opts?.maxBreadcrumbs);
+}
+function traceId() {
+  const ctx = trace.getActiveSpan()?.spanContext();
+  return ctx && ctx.traceId !== "00000000000000000000000000000000" ? ctx.traceId : void 0;
+}
+function exceptionChain(error) {
+  const out = [];
+  let e = error;
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < 6 && e !== void 0 && e !== null && !seen.has(e); i++) {
+    seen.add(e);
+    if (e instanceof Error || typeof e === "object" && "message" in e) {
+      const err = e;
+      let frames = parseStack(err.stack);
+      if (opts?.sourceContext) frames = addSourceContext(frames);
+      const type = err.name && err.name !== "Error" ? err.name : err.constructor?.name && err.constructor.name !== "Object" ? err.constructor.name : "Error";
+      out.push({ type: err.code && type === "Error" ? `Error [${err.code}]` : type, value: String(err.message ?? ""), stacktrace: frames });
+      e = err.cause;
+    } else {
+      out.push({ type: "Error", value: typeof e === "string" ? e : safeJson(e), stacktrace: [] });
+      break;
+    }
+  }
+  return out;
+}
+function safeJson(v) {
+  try {
+    return JSON.stringify(v)?.slice(0, 1e3) ?? String(v);
+  } catch {
+    return String(v);
+  }
+}
+function ignored(error) {
+  const pats = opts?.ignoreErrors;
+  if (!pats || !pats.length) return false;
+  const msg = String(error?.message ?? error);
+  return pats.some((p) => typeof p === "string" ? msg.includes(p) : p.test(msg));
+}
+function baseItem(scope, ctx) {
+  const span = trace.getActiveSpan()?.spanContext();
+  const tid = span && span.traceId !== "00000000000000000000000000000000" ? span.traceId : void 0;
+  const contexts = {
+    runtime: { name: "node", version: process.version },
+    os: { name: osType(), version: osRelease() },
+    ...scope.contexts
+  };
+  if (ctx.extra) contexts.extra = ctx.extra;
+  if (scope.request) contexts.request = scope.request;
+  if (tid) contexts.trace = { trace_id: tid, span_id: span.spanId };
+  const user = ctx.user || scope.user;
+  const tags = { server_name: hostname(), ...scope.tags, ...ctx.tags || {} };
+  if (scope.request?.method && scope.request.route) tags.transaction = `${scope.request.method} ${scope.request.route}`;
+  if (opts?.serviceName) tags.service = opts.serviceName;
+  return {
+    event_id: randomUUID(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    platform: "node",
+    release: opts?.release,
+    environment: opts?.environment,
+    breadcrumbs: scope.breadcrumbs.slice(),
+    tags,
+    contexts,
+    user: user ? { id: user.id } : void 0,
+    user_id: user?.id,
+    url: scope.request?.url,
+    trace_id: tid,
+    flags: Object.keys(scope.flags).length ? { ...scope.flags } : void 0
+  };
+}
+function captureException(error, ctx = {}, fatal = false) {
+  if (!opts || !transport) return;
+  if (ignored(error)) return;
+  if (!fatal && (opts.errorSampleRate ?? 1) < 1 && Math.random() >= (opts.errorSampleRate ?? 1)) return;
+  const scope = currentScope();
+  const item = {
+    type: "error",
+    ...baseItem(scope, ctx),
+    level: ctx.level || (fatal ? "fatal" : "error"),
+    handled: ctx.handled !== false,
+    fatal,
+    exceptions: exceptionChain(error),
+    fingerprint: ctx.fingerprint
+  };
+  const id = item.event_id;
+  if (!enqueue(item, true)) return;
+  trace.getActiveSpan()?.setAttribute("vaka.error_captured", true);
+  scope.addBreadcrumb({ category: "error", level: "error", message: String(error?.message ?? error).slice(0, 300) }, opts.maxBreadcrumbs);
+  return id;
+}
+var captureError = captureException;
+function captureMessage(message, level = "info", ctx = {}) {
+  if (!opts || !transport) return;
+  const item = { type: "error", ...baseItem(currentScope(), ctx), level, message, fingerprint: ctx.fingerprint };
+  return enqueue(item, level === "error" || level === "fatal") ? item.event_id : void 0;
+}
+var FeedbackError = class extends Error {
+  /** HTTP status, or 0 when nothing was sent. 429 means a rate limit was hit. */
+  status;
+  constructor(message, status = 0) {
+    super(message);
+    this.name = "FeedbackError";
+    this.status = status;
+  }
+};
+function contentTypeOf(filename) {
+  const ext = filename.toLowerCase().split(".").pop();
+  return ext === "png" ? "image/png" : ext === "webp" ? "image/webp" : "image/jpeg";
+}
+async function captureFeedback(f) {
+  if (!opts || !transport) throw new FeedbackError("vaka is not initialized");
+  const message = String(f?.message ?? "").trim();
+  if (!message) throw new FeedbackError("feedback needs a message");
+  const files = (f.attachments || []).filter(Boolean);
+  if (files.length > 3) throw new FeedbackError("at most 3 attachments per feedback");
+  const scope = currentScope();
+  const userId = f.userId || scope.user?.id;
+  const item = {
+    id: randomUUID(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    platform: "node",
+    source: "api",
+    message: message.slice(0, 5e3),
+    email: f.email?.trim() || void 0,
+    name: f.name?.trim() || void 0,
+    event_id: f.eventId,
+    issue: f.issue,
+    user_id: userId,
+    anon_id: userId ? void 0 : processId,
+    session_id: f.sessionId,
+    url: f.url || scope.request?.url,
+    release: opts.release,
+    environment: opts.environment,
+    tags: { ...scope.tags, ...f.tags || {} },
+    flags: Object.keys(scope.flags).length ? { ...scope.flags } : void 0
+  };
+  for (const k of Object.keys(item)) if (item[k] === void 0) delete item[k];
+  const headers2 = { "X-Vaka-Key": opts.key, "X-Vaka-Sdk": `${SDK.name}/${SDK.version}` };
+  if (f.ip) headers2["X-Forwarded-For"] = f.ip;
+  let body;
+  if (files.length) {
+    const form = new FormData();
+    form.append("feedback", JSON.stringify(item));
+    for (const a of files) {
+      const data = a.data instanceof ArrayBuffer ? new Uint8Array(a.data) : a.data;
+      form.append("attachment", new Blob([data], { type: a.contentType || contentTypeOf(a.filename) }), a.filename);
+    }
+    body = form;
+  } else {
+    headers2["Content-Type"] = "application/json";
+    body = JSON.stringify(item);
+  }
+  const { context: context2 } = await import("@opentelemetry/api");
+  const { suppressTracing: suppressTracing2 } = await import("@opentelemetry/core");
+  let r;
+  try {
+    r = await context2.with(
+      suppressTracing2(context2.active()),
+      () => fetch(`${opts.endpoint}/ingest/v1/feedback`, { method: "POST", headers: headers2, body, signal: AbortSignal.timeout(3e4) })
+    );
+  } catch (e) {
+    throw new FeedbackError(`vaka feedback: ${String(e?.message || e)}`);
+  }
+  const text = await r.text().catch(() => "");
+  let json = {};
+  try {
+    json = text ? JSON.parse(text) : {};
+  } catch {
+  }
+  if (r.status < 200 || r.status >= 300) throw new FeedbackError(`vaka feedback: HTTP ${r.status}${json.error ? `: ${json.error}` : ""}`, r.status);
+  scope.addBreadcrumb({ category: "feedback", message: "user feedback sent" }, opts.maxBreadcrumbs);
+  return { id: json.id || String(item.id), shortId: json.short_id || "" };
+}
+function track(name, props, o = {}) {
+  if (!opts || !name) return;
+  const scope = currentScope();
+  enqueue({
+    type: "event",
+    name,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    props: clean(props),
+    user_id: o.userId || scope.user?.id,
+    anon_id: o.userId || scope.user?.id ? void 0 : processId,
+    url: o.url,
+    release: opts.release,
+    environment: opts.environment,
+    flags: Object.keys(scope.flags).length ? { ...scope.flags } : void 0
+  });
+}
+function clean(props) {
+  if (!props) return void 0;
+  const out = {};
+  for (const k of Object.keys(props)) {
+    const v = props[k];
+    if (v !== null && v !== void 0) out[k] = v;
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function enqueue(item, urgent = false) {
+  if (!opts || !transport) return false;
+  for (const k of Object.keys(item)) if (item[k] === void 0) delete item[k];
+  let final = item;
+  if (opts.beforeSend) {
+    try {
+      final = opts.beforeSend(item);
+    } catch (e) {
+      log("beforeSend threw:", String(e));
+    }
+  }
+  if (!final) return false;
+  transport.send(final, urgent);
+  return true;
+}
+var flagCache = /* @__PURE__ */ new Map();
+async function getFlags(ctx = {}) {
+  if (!opts || !transport || transport.disabled) return {};
+  const scope = currentScope();
+  const userId = ctx.userId || scope.user?.id;
+  const distinct = ctx.distinctId || userId || processId;
+  const body = { distinct_id: distinct, user_id: userId, environment: opts.environment, properties: clean(ctx.properties) };
+  const cacheKey = JSON.stringify(body);
+  const ttl = opts.flagsCacheTtlMs ?? 3e4;
+  const hit = flagCache.get(cacheKey);
+  let flags;
+  if (hit && ttl > 0 && Date.now() - hit.at < ttl) {
+    flags = hit.flags;
+  } else {
+    const { context: context2 } = await import("@opentelemetry/api");
+    const { suppressTracing: suppressTracing2 } = await import("@opentelemetry/core");
+    const r = await context2.with(
+      suppressTracing2(context2.active()),
+      () => fetch(`${opts.endpoint}/ingest/v1/flags`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "X-Vaka-Key": opts.key },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(5e3)
+      })
+    );
+    if (r.status !== 200) throw new Error(`vaka flags: HTTP ${r.status}`);
+    flags = (await r.json()).flags || {};
+    if (ttl > 0) {
+      if (flagCache.size >= 1e3) flagCache.delete(flagCache.keys().next().value);
+      flagCache.set(cacheKey, { at: Date.now(), flags });
+    }
+  }
+  for (const k of Object.keys(flags)) scope.flags[k] = String(flags[k]);
+  const span = trace.getActiveSpan();
+  if (span) for (const k of Object.keys(flags)) span.setAttribute(`feature_flag.${k}`, String(flags[k]));
+  return flags;
+}
+async function getFlag(key, fallback = false, ctx = {}) {
+  try {
+    const flags = await getFlags(ctx);
+    return key in flags ? flags[key] : fallback;
+  } catch (e) {
+    log("flag evaluation failed:", String(e));
+    return fallback;
+  }
+}
+async function isEnabled(key, ctx = {}) {
+  const v = await getFlag(key, false, ctx);
+  return v !== false && v !== "false";
+}
+function middlewareCapture(err, c) {
+  captureException(err, { handled: c.handled, tags: { mechanism: c.mechanism } });
+}
+var shouldCapture = (status) => opts?.shouldCaptureStatus ? opts.shouldCaptureStatus(status) : status >= 500;
+function requestHandler() {
+  return makeRequestHandler();
+}
+function errorHandler() {
+  return makeErrorHandler(middlewareCapture, shouldCapture);
+}
+function setupExpressErrorHandler(app) {
+  app.use(errorHandler());
+}
+var fastifyPlugin = makeFastifyPlugin(middlewareCapture, shouldCapture);
+function wrapHandler(fn) {
+  return (...args) => withScope((scope) => {
+    scope.breadcrumbs = [];
+    try {
+      const r = fn(...args);
+      if (r && typeof r.then === "function") {
+        return r.catch((e) => {
+          captureException(e, { handled: false, tags: { mechanism: "wrapHandler" } });
+          throw e;
+        });
+      }
+      return r;
+    } catch (e) {
+      captureException(e, { handled: false, tags: { mechanism: "wrapHandler" } });
+      throw e;
+    }
+  });
+}
+async function flush(timeoutMs = 5e3) {
+  if (!transport) return true;
+  return transport.flush(timeoutMs);
+}
+async function close(timeoutMs = 5e3) {
+  const sent = await flush(timeoutMs);
+  if (otelSdk) {
+    const sdk = otelSdk;
+    otelSdk = void 0;
+    let t;
+    await Promise.race([
+      sdk.shutdown().catch(() => void 0),
+      new Promise((r) => {
+        t = setTimeout(r, timeoutMs);
+        t.unref?.();
+      })
+    ]);
+    if (t) clearTimeout(t);
+  }
+  return sent;
+}
+async function _reset() {
+  uninstallIntegrations();
+  if (otelSdk) await otelSdk.shutdown().catch(() => void 0);
+  otelSdk = void 0;
+  opts = void 0;
+  transport = void 0;
+  flagCache.clear();
+  _resetScopes();
+}
+export {
+  FeedbackError,
+  SDK,
+  VakaScopeSpanProcessor,
+  globalScope as _globalScope,
+  _reset,
+  addBreadcrumb,
+  captureError,
+  captureException,
+  captureFeedback,
+  captureMessage,
+  close,
+  currentScope,
+  errorHandler,
+  fastifyPlugin,
+  flush,
+  getFlag,
+  getFlags,
+  init,
+  isEnabled,
+  isInitialized,
+  parseStack,
+  requestHandler,
+  setContext,
+  setTag,
+  setTags,
+  setUser,
+  setupExpressErrorHandler,
+  traceId,
+  track,
+  vakaLogRecordProcessor,
+  vakaSpanExporter,
+  withScope,
+  wrapHandler
+};