@oconde/radar 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1107 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  RadarClient: () => RadarClient,
+  radar: () => radar
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/client.ts
+var import_node_crypto3 = require("crypto");
+var import_node_os = require("os");
+var import_node_perf_hooks3 = require("perf_hooks");
+
+// src/context.ts
+var import_node_async_hooks = require("async_hooks");
+var STATE_KEY = /* @__PURE__ */ Symbol.for("@oconde/radar");
+function globalState() {
+  const holder = globalThis;
+  let state2 = holder[STATE_KEY];
+  if (!state2) {
+    state2 = { storage: new import_node_async_hooks.AsyncLocalStorage() };
+    holder[STATE_KEY] = state2;
+  }
+  return state2;
+}
+function currentContext() {
+  return globalState().storage.getStore();
+}
+function runWithContext(context, fn) {
+  return globalState().storage.run(context, fn);
+}
+
+// src/express.ts
+var import_node_crypto2 = require("crypto");
+var import_node_perf_hooks = require("perf_hooks");
+
+// src/protocol/index.ts
+var INGEST_PATH = "/api/v1/events";
+var LIMITS = {
+  batchBytes: 1e6,
+  batchEvents: 500,
+  messageLength: 2e3,
+  stringLength: 2e3,
+  attrsBytes: 16384,
+  bodyBytes: 16384,
+  headers: 50,
+  frames: 50,
+  contextFrames: 10,
+  contextLines: 5,
+  contextLineLength: 300,
+  causeDepth: 5,
+  depth: 6,
+  arrayItems: 50,
+  requestIdLength: 128
+};
+
+// src/redact.ts
+var import_node_crypto = require("crypto");
+var SECRET_WORDS = /* @__PURE__ */ new Set([
+  "pass",
+  "passwd",
+  "password",
+  "passwords",
+  "senha",
+  "secret",
+  "secrets",
+  "token",
+  "tokens",
+  "authorization",
+  "auth",
+  "cookie",
+  "cookies",
+  "apikey",
+  "privatekey",
+  "cpf",
+  "card",
+  "cvv",
+  "cvc",
+  "pin",
+  "otp",
+  "signature",
+  "jwt",
+  "session",
+  "sessionid",
+  "credential",
+  "credentials"
+]);
+var SECRET_PAIRS = [
+  ["api", "key"],
+  ["private", "key"],
+  ["access", "key"],
+  ["secret", "key"]
+];
+var LOW_ENTROPY_WORDS = /* @__PURE__ */ new Set(["pass", "passwd", "password", "passwords", "senha", "cpf", "card", "cvv", "cvc", "pin", "otp"]);
+var CUSTOM_SECRET_HEADER = /^x-.+-(key|secret|token)$/i;
+var AUTH_SCHEME = /^(Bearer|Basic|Token|Digest|ApiKey)\s+/i;
+var JWT_PREFIX = /^eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\./;
+var MAX_DEPTH = 8;
+var KEY_SLOT = /* @__PURE__ */ Symbol.for("@oconde/radar/fingerprint-key");
+function fingerprintSlot() {
+  const holder = globalThis;
+  let slot = holder[KEY_SLOT];
+  if (!slot) {
+    slot = { key: (0, import_node_crypto.randomBytes)(32) };
+    holder[KEY_SLOT] = slot;
+  }
+  return slot;
+}
+function setFingerprintSecret(secret) {
+  fingerprintSlot().key = secret ? (0, import_node_crypto.createHash)("sha256").update(`@oconde/radar:${secret}`).digest() : (0, import_node_crypto.randomBytes)(32);
+}
+function fingerprint(value) {
+  return (0, import_node_crypto.createHmac)("sha256", fingerprintSlot().key).update(value).digest("hex").slice(0, 8);
+}
+function words(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+}
+function isSensitiveKey(key) {
+  const parts = words(key);
+  if (parts.length === 1 && parts[0] === "key") return true;
+  if (parts.some((part) => SECRET_WORDS.has(part))) return true;
+  return SECRET_PAIRS.some(([first, second]) => parts.some((part, index) => part === first && parts[index + 1] === second));
+}
+function isLowEntropyKey(key) {
+  return words(key).some((part) => LOW_ENTROPY_WORDS.has(part));
+}
+function isSensitiveHeader(name) {
+  return isSensitiveKey(name) || CUSTOM_SECRET_HEADER.test(name);
+}
+function looksLikeCredential(value) {
+  const head = value.slice(0, 64);
+  return AUTH_SCHEME.test(head.slice(0, 16)) || JWT_PREFIX.test(head);
+}
+function maskValue(value, revealEdges = true) {
+  const text = typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
+  const scheme = AUTH_SCHEME.exec(text.slice(0, 16));
+  const prefix = scheme ? `${scheme[1]} ` : "";
+  const secret = scheme ? text.slice(scheme[0].length) : text;
+  const visible = revealEdges && secret.length > 12 ? `${secret.slice(0, 4)}\u2026${secret.slice(-4)}` : "\u2022\u2022\u2022";
+  return `${prefix}${visible} #${fingerprint(text)}`;
+}
+function redactDeep(value, mode, depth = 0) {
+  if (mode === "none" || depth > MAX_DEPTH || value === null) return value;
+  if (typeof value === "string") return looksLikeCredential(value) ? maskValue(value) : value;
+  if (typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((item) => redactDeep(item, mode, depth + 1));
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    const hasValue = item !== null && item !== void 0 && item !== "";
+    result[key] = isSensitiveKey(key) && hasValue ? maskValue(item, !isLowEntropyKey(key)) : redactDeep(item, mode, depth + 1);
+  }
+  return result;
+}
+
+// src/serialize.ts
+var TRUNCATED = "\u2026[cortado]";
+var LIMIT_REACHED = "\u2026[limite]";
+var MAX_NODES = 2e3;
+function truncate(value, max = LIMITS.stringLength) {
+  return value.length > max ? value.slice(0, max) + TRUNCATED : value;
+}
+function sanitize(value, depth = 0, seen = /* @__PURE__ */ new WeakSet(), budget = { remaining: MAX_NODES }) {
+  if (value === null || value === void 0) return value;
+  budget.remaining -= 1;
+  switch (typeof value) {
+    case "string":
+      return truncate(value);
+    case "number":
+      return Number.isFinite(value) ? value : String(value);
+    case "boolean":
+      return value;
+    case "bigint":
+      return value.toString();
+    case "function":
+    case "symbol":
+      return void 0;
+  }
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value.toISOString();
+  if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return `[bin\xE1rio ${value.byteLength} bytes]`;
+  if (value instanceof Error) return { name: value.name, message: truncate(value.message) };
+  const object = value;
+  if (seen.has(object)) return "[circular]";
+  if (depth >= LIMITS.depth) return "[profundidade]";
+  if (budget.remaining <= 0) return LIMIT_REACHED;
+  seen.add(object);
+  try {
+    if (Array.isArray(object)) {
+      const items = [];
+      for (const item of object.slice(0, LIMITS.arrayItems)) {
+        if (budget.remaining <= 0) {
+          items.push(LIMIT_REACHED);
+          break;
+        }
+        items.push(sanitize(item, depth + 1, seen, budget) ?? null);
+      }
+      if (object.length > LIMITS.arrayItems) items.push(`\u2026[mais ${object.length - LIMITS.arrayItems}]`);
+      return items;
+    }
+    if (object instanceof Map) return sanitize(Object.fromEntries(object.entries()), depth + 1, seen, budget);
+    if (object instanceof Set) return sanitize([...object], depth + 1, seen, budget);
+    const result = {};
+    for (const key in object) {
+      if (!Object.prototype.hasOwnProperty.call(object, key)) continue;
+      if (budget.remaining <= 0) {
+        result["\u2026"] = LIMIT_REACHED;
+        break;
+      }
+      const clean = sanitize(object[key], depth + 1, seen, budget);
+      if (clean !== void 0) result[key] = clean;
+    }
+    return result;
+  } finally {
+    seen.delete(object);
+  }
+}
+function limitBytes(value, maxBytes) {
+  const json = JSON.stringify(value);
+  if (json === void 0 || Buffer.byteLength(json) <= maxBytes) return value;
+  return { _truncated: truncate(json, maxBytes) };
+}
+function prepareAttrs(data, mode) {
+  const clean = redactDeep(sanitize(data), mode);
+  const record = isRecord(clean) ? clean : { value: clean };
+  return limitBytes(record, LIMITS.attrsBytes);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/request.ts
+function headerValue(value) {
+  if (value === void 0) return void 0;
+  return Array.isArray(value) ? value.join(", ") : String(value);
+}
+function requestHeaders(headers, mode) {
+  const result = {};
+  let count = 0;
+  for (const [name, raw] of Object.entries(headers)) {
+    const value = headerValue(raw);
+    if (value === void 0) continue;
+    if (count >= LIMITS.headers) break;
+    const key = name.toLowerCase();
+    result[key] = mode === "mask" && (isSensitiveHeader(key) || looksLikeCredential(value)) ? maskValue(value) : truncate(value);
+    count++;
+  }
+  return result;
+}
+function requestPath(req) {
+  const url = req.originalUrl ?? req.url ?? "";
+  const end = url.indexOf("?");
+  return end >= 0 ? url.slice(0, end) : url;
+}
+function requestRoute(req, route) {
+  if (route) return route;
+  return typeof req.route?.path === "string" ? req.route.path : void 0;
+}
+function redactPath(path, params, mode) {
+  if (mode === "none" || !params) return path;
+  let result = path;
+  for (const [key, value] of Object.entries(params)) {
+    if (typeof value !== "string" || value.length < 4 || !isSensitiveKey(key)) continue;
+    const masked = maskValue(value, !isLowEntropyKey(key));
+    for (const form of /* @__PURE__ */ new Set([value, encodeURIComponent(value)])) result = result.split(form).join(masked);
+  }
+  return result;
+}
+function safeUrl(req, mode) {
+  const url = req.originalUrl ?? req.url ?? "";
+  const queryStart = url.indexOf("?");
+  const path = queryStart >= 0 ? url.slice(0, queryStart) : url;
+  const query = queryStart >= 0 ? url.slice(queryStart) : "";
+  return redactUrl(redactPath(path, req.params, mode) + query, mode);
+}
+function redactUrl(url, mode) {
+  const queryStart = url.indexOf("?");
+  if (mode === "none" || queryStart < 0) return url;
+  const params = new URLSearchParams(url.slice(queryStart + 1));
+  let changed = false;
+  for (const [key, value] of [...params.entries()]) {
+    if (isSensitiveKey(key) && value !== "") {
+      params.set(key, maskValue(value, !isLowEntropyKey(key)));
+      changed = true;
+    }
+  }
+  return changed ? `${url.slice(0, queryStart)}?${params.toString()}` : url;
+}
+function requestInfo(req, mode, extra = {}, detail = "full") {
+  const route = requestRoute(req, extra.route);
+  if (detail === "route") {
+    return {
+      method: (req.method ?? "GET").toUpperCase(),
+      url: route ?? "",
+      ...route ? { route } : {},
+      ...extra.status !== void 0 ? { status: extra.status } : {},
+      ...extra.durationMs !== void 0 ? { durationMs: extra.durationMs } : {}
+    };
+  }
+  const params = prepareRecord(req.params, mode);
+  const query = prepareRecord(req.query, mode);
+  const body = prepareBody(req.body, mode);
+  const userAgent = headerValue(req.headers["user-agent"]);
+  const ip = req.ip ?? req.socket?.remoteAddress;
+  return {
+    method: (req.method ?? "GET").toUpperCase(),
+    url: truncate(safeUrl(req, mode)),
+    ...route ? { route } : {},
+    ...params ? { params } : {},
+    ...query ? { query } : {},
+    headers: requestHeaders(req.headers, mode),
+    ...body !== void 0 ? { body } : {},
+    ...ip ? { ip } : {},
+    ...userAgent ? { userAgent: truncate(userAgent, 500) } : {},
+    ...extra.status !== void 0 ? { status: extra.status } : {},
+    ...extra.durationMs !== void 0 ? { durationMs: extra.durationMs } : {}
+  };
+}
+function isEmptyRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+function prepareRecord(value, mode) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const clean = prepare(value, mode);
+  return isEmptyRecord(clean) || typeof clean !== "object" || clean === null ? void 0 : clean;
+}
+function prepare(value, mode) {
+  return redactDeep(sanitize(value), mode);
+}
+function prepareBody(body, mode) {
+  if (body === void 0 || body === null || body === "") return void 0;
+  const clean = prepare(body, mode);
+  if (isEmptyRecord(clean)) return void 0;
+  return limitBytes(clean, LIMITS.bodyBytes);
+}
+
+// src/express.ts
+function createMiddleware(logger) {
+  return (req, res, next) => {
+    let context;
+    try {
+      const incoming = headerValue(req.headers["x-request-id"])?.trim();
+      const requestId = incoming && incoming.length <= LIMITS.requestIdLength ? incoming : (0, import_node_crypto2.randomUUID)();
+      context = { requestId, startedAt: import_node_perf_hooks.performance.now(), req };
+      res.setHeader("x-request-id", requestId);
+      if (logger.shouldLogRequest(req)) res.once("finish", () => logger.logHttpRequest(context, res.statusCode));
+    } catch {
+      next();
+      return;
+    }
+    runWithContext(context, () => next());
+  };
+}
+
+// src/options.ts
+var DEFAULT_ENDPOINT = "https://radar-ingest.oconde.dev";
+var LEVELS = ["debug", "info", "warn", "error"];
+function resolveOptions(options = {}, env = process.env) {
+  const key = options.key?.trim() || void 0;
+  return {
+    key,
+    endpoint: (options.endpoint ?? DEFAULT_ENDPOINT).replace(/\/+$/, ""),
+    environment: options.environment ?? env.NODE_ENV ?? "production",
+    release: options.release || void 0,
+    enabled: options.enabled ?? Boolean(key),
+    console: options.console ?? false,
+    minLevel: options.minLevel && LEVELS.includes(options.minLevel) ? options.minLevel : "info",
+    redact: options.redact === "none" ? "none" : "mask",
+    requestDetail: options.requestDetail === "route" ? "route" : "full",
+    logRequests: options.logRequests ?? true,
+    ignorePaths: options.ignorePaths ?? ["/healthz", "/health"],
+    captureUnhandled: options.captureUnhandled ?? true,
+    debug: options.debug ?? false
+  };
+}
+function levelEnabled(level, minLevel) {
+  return LEVELS.indexOf(level) >= LEVELS.indexOf(minLevel);
+}
+
+// src/process-handlers.ts
+var import_node_util = require("util");
+var INSTALLED = /* @__PURE__ */ Symbol.for("@oconde/radar/process-handlers");
+var MODE_FLAG = /^--unhandled-rejections=(\S+)$/;
+function unhandledRejectionsMode(execArgv = process.execArgv, nodeOptions = process.env.NODE_OPTIONS ?? "") {
+  for (const arg of [...nodeOptions.split(/\s+/), ...execArgv]) {
+    const match = MODE_FLAG.exec(arg);
+    if (match?.[1]) return match[1];
+  }
+  return "throw";
+}
+function asUncaught(reason) {
+  if (reason instanceof Error) return reason;
+  const error = new Error(
+    `This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason "${(0, import_node_util.inspect)(reason)}".`
+  );
+  error.code = "ERR_UNHANDLED_REJECTION";
+  return error;
+}
+function installProcessHandlers(capturer) {
+  const holder = process;
+  if (holder[INSTALLED]) return;
+  holder[INSTALLED] = true;
+  process.on("unhandledRejection", (reason) => {
+    const mode = unhandledRejectionsMode();
+    const othersListen = process.listenerCount("unhandledRejection") > 1;
+    if (othersListen || mode !== "throw") {
+      capturer.captureUnhandled(reason, "error");
+      if (!othersListen && mode === "warn-with-error-code") process.exitCode = 1;
+      return;
+    }
+    const uncaught = asUncaught(reason);
+    setImmediate(() => {
+      throw uncaught;
+    });
+  });
+  process.on("uncaughtException", (error) => {
+    capturer.captureUnhandled(error, "fatal");
+    if (process.listenerCount("uncaughtException") > 1) return;
+    try {
+      process.stderr.write(`${(0, import_node_util.inspect)(error)}
+`);
+    } catch {
+      process.exitCode = 1;
+    }
+    void capturer.flush(2e3).finally(() => process.exit(1));
+  });
+}
+
+// src/source.ts
+var import_promises = require("fs/promises");
+var import_node_module = require("module");
+var import_node_path = require("path");
+var import_node_url = require("url");
+var MAX_FILE_BYTES = 2 * 1024 * 1024;
+var MAX_CACHED_FILES = 50;
+var MAPPING_URL = /\/\/[#@]\s*sourceMappingURL=(\S+)\s*$/;
+var cache = /* @__PURE__ */ new Map();
+async function enrichFrames(frames, cwd = process.cwd()) {
+  const result = [];
+  let withContext = 0;
+  for (const frame of frames) {
+    try {
+      const { frame: mapped, lines } = await mapFrame(frame);
+      let next = mapped;
+      if (mapped.inApp && lines && mapped.line && withContext < LIMITS.contextFrames) {
+        const context = contextFor(lines, mapped.line);
+        if (context) {
+          next = { ...mapped, context };
+          withContext++;
+        }
+      }
+      result.push({ ...next, file: relativize(next.file, cwd) });
+    } catch {
+      result.push({ ...frame, file: relativize(frame.file, cwd) });
+    }
+  }
+  return result;
+}
+async function enrichException(exception, cwd = process.cwd()) {
+  const frames = await enrichFrames(exception.frames, cwd);
+  if (!exception.cause) return { ...exception, frames };
+  return { ...exception, frames, cause: await enrichException(exception.cause, cwd) };
+}
+function relativize(file, cwd) {
+  if (!(0, import_node_path.isAbsolute)(file)) return file;
+  const path = (0, import_node_path.relative)(cwd, file);
+  return path.startsWith("..") || (0, import_node_path.isAbsolute)(path) ? file : path.split(import_node_path.sep).join("/");
+}
+async function mapFrame(frame) {
+  if (!frame.line || !(0, import_node_path.isAbsolute)(frame.file)) return { frame, lines: null };
+  const file = await loadFile(frame.file);
+  if (!file) return { frame, lines: null };
+  if (!file.map) return { frame, lines: file.lines };
+  const entry = file.map.map.findEntry(frame.line - 1, (frame.col ?? 1) - 1);
+  if (typeof entry.originalSource !== "string" || typeof entry.originalLine !== "number") return { frame, lines: file.lines };
+  const originalPath = resolveSource(file.map, entry.originalSource);
+  const mapped = { ...frame, file: originalPath, line: entry.originalLine + 1, col: (entry.originalColumn ?? 0) + 1 };
+  const lines = embeddedLines(file.map, file.map.sources.indexOf(entry.originalSource));
+  if (lines) return { frame: mapped, lines };
+  const original = await loadFile(originalPath);
+  return { frame: mapped, lines: original?.lines ?? null };
+}
+function embeddedLines(map, index) {
+  if (index < 0) return null;
+  const cached = map.lines.get(index);
+  if (cached) return cached;
+  const content = map.contents[index];
+  if (typeof content !== "string") return null;
+  const lines = content.split(/\r?\n/);
+  map.lines.set(index, lines);
+  return lines;
+}
+function contextFor(lines, line) {
+  const index = line - 1;
+  if (index < 0 || index >= lines.length) return void 0;
+  const clip = (text) => text.length > LIMITS.contextLineLength ? `${text.slice(0, LIMITS.contextLineLength)}\u2026` : text;
+  return {
+    pre: lines.slice(Math.max(0, index - LIMITS.contextLines), index).map(clip),
+    line: clip(lines[index] ?? ""),
+    post: lines.slice(index + 1, index + 1 + LIMITS.contextLines).map(clip)
+  };
+}
+function resolveSource(map, source) {
+  if (source.startsWith("file://")) {
+    try {
+      return (0, import_node_url.fileURLToPath)(source);
+    } catch {
+      return source;
+    }
+  }
+  return (0, import_node_path.isAbsolute)(source) ? source : (0, import_node_path.resolve)(map.baseDir, source);
+}
+function loadFile(path) {
+  const cached = cache.get(path);
+  if (cached) {
+    cache.delete(path);
+    cache.set(path, cached);
+    return cached;
+  }
+  const pending = readSource(path).catch(() => null);
+  cache.set(path, pending);
+  if (cache.size > MAX_CACHED_FILES) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) cache.delete(oldest);
+  }
+  return pending;
+}
+async function readSource(path) {
+  const text = await readText(path);
+  if (text === null) return null;
+  const lines = text.split(/\r?\n/);
+  return { lines, map: await loadMap(path, lines) };
+}
+async function readText(path) {
+  try {
+    const info = await (0, import_promises.stat)(path);
+    if (!info.isFile() || info.size > MAX_FILE_BYTES) return null;
+    return await (0, import_promises.readFile)(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function loadMap(path, lines) {
+  let url;
+  for (let index = lines.length - 1; index >= 0 && index >= lines.length - 5; index--) {
+    const match = MAPPING_URL.exec(lines[index] ?? "");
+    if (match) {
+      url = match[1];
+      break;
+    }
+  }
+  if (!url) return null;
+  let raw;
+  let mapDir;
+  if (url.startsWith("data:")) {
+    const comma = url.indexOf(",");
+    const encoded = url.slice(comma + 1);
+    raw = url.slice(0, comma).endsWith(";base64") ? Buffer.from(encoded, "base64").toString("utf8") : decodeURIComponent(encoded);
+    mapDir = (0, import_node_path.dirname)(path);
+  } else {
+    const mapPath = url.startsWith("file://") ? (0, import_node_url.fileURLToPath)(url) : (0, import_node_path.resolve)((0, import_node_path.dirname)(path), decodeURIComponent(url));
+    raw = await readText(mapPath);
+    mapDir = (0, import_node_path.dirname)(mapPath);
+  }
+  if (!raw) return null;
+  try {
+    const payload = JSON.parse(raw);
+    return {
+      map: new import_node_module.SourceMap(payload),
+      baseDir: (0, import_node_path.resolve)(mapDir, payload.sourceRoot ?? ""),
+      sources: payload.sources ?? [],
+      contents: payload.sourcesContent ?? [],
+      lines: /* @__PURE__ */ new Map()
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/stack.ts
+var import_node_url2 = require("url");
+var WITH_FUNCTION = /^at (?:async )?(.+?) \((.+)\)$/;
+var LOCATION = /^(.+):(\d+):(\d+)$/;
+function parseStack(stack) {
+  if (!stack) return [];
+  const frames = [];
+  for (const raw of stack.split("\n")) {
+    const line = raw.trim();
+    if (!line.startsWith("at ")) continue;
+    const withFunction = WITH_FUNCTION.exec(line);
+    const fn = withFunction?.[1];
+    const location = withFunction ? withFunction[2] ?? "" : line.replace(/^at (?:async )?/, "");
+    const parsed = LOCATION.exec(location);
+    if (parsed) {
+      const file = toPath(parsed[1] ?? "");
+      frames.push({ ...fn ? { fn } : {}, file, line: Number(parsed[2]), col: Number(parsed[3]), inApp: isInApp(file) });
+    } else {
+      frames.push({ ...fn ? { fn } : {}, file: location, inApp: false });
+    }
+    if (frames.length >= LIMITS.frames) break;
+  }
+  return frames;
+}
+function isInApp(file) {
+  if (file.includes("/node_modules/") || file.includes("\\node_modules\\")) return false;
+  if (file.startsWith("node:") || file.startsWith("internal/")) return false;
+  return file.startsWith("/") || /^[A-Za-z]:[\\/]/.test(file);
+}
+function exceptionInfo(error, depth = 0) {
+  if (error instanceof Error) {
+    const info = {
+      type: errorType(error),
+      message: truncate(error.message ?? "", LIMITS.messageLength),
+      frames: parseStack(error.stack)
+    };
+    const cause = error.cause;
+    if (cause !== void 0 && cause !== null && depth < LIMITS.causeDepth) info.cause = exceptionInfo(cause, depth + 1);
+    return info;
+  }
+  if (typeof error === "object" && error !== null) {
+    const record = error;
+    const message = typeof record.message === "string" ? record.message : safeStringify(error);
+    return { type: typeof record.name === "string" ? record.name : "Object", message: truncate(message, LIMITS.messageLength), frames: [] };
+  }
+  return { type: "Error", message: truncate(String(error), LIMITS.messageLength), frames: [] };
+}
+function toPath(location) {
+  if (!location.startsWith("file://")) return location;
+  try {
+    return (0, import_node_url2.fileURLToPath)(location);
+  } catch {
+    return location;
+  }
+}
+function errorType(error) {
+  if (error.name && error.name !== "Error") return error.name;
+  const constructorName = error.constructor?.name;
+  return constructorName && constructorName !== "Object" ? constructorName : "Error";
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+
+// src/transport.ts
+var import_node_util2 = require("util");
+var import_node_zlib = require("zlib");
+
+// src/util.ts
+var import_node_perf_hooks2 = require("perf_hooks");
+function describeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function elapsedSince(startedAt) {
+  return Math.round(import_node_perf_hooks2.performance.now() - startedAt);
+}
+
+// src/transport.ts
+var gzipAsync = (0, import_node_util2.promisify)(import_node_zlib.gzip);
+var MAX_BATCH_BYTES = 9e5;
+var GZIP_THRESHOLD_BYTES = 8192;
+var MAX_BACKOFF_MS = 3e4;
+var MAX_RETRY_AFTER_MS = 864e5;
+var UNAUTHORIZED_PAUSE_MS = 10 * 6e4;
+var Transport = class {
+  constructor(config) {
+    this.config = config;
+    this.maxQueue = config.maxQueue ?? 1e3;
+    this.batchSize = Math.min(config.batchSize ?? 100, LIMITS.batchEvents);
+    this.timer = setInterval(() => {
+      void this.send();
+    }, config.flushIntervalMs ?? 2e3);
+    this.timer.unref();
+  }
+  config;
+  queue = [];
+  droppedCount = 0;
+  inFlight = null;
+  nextAttemptAt = 0;
+  backoffMs = 0;
+  stopped = false;
+  warned = /* @__PURE__ */ new Set();
+  timer;
+  maxQueue;
+  batchSize;
+  get pending() {
+    return this.queue.length;
+  }
+  get dropped() {
+    return this.droppedCount;
+  }
+  enqueue(event) {
+    if (this.stopped) return;
+    if (this.queue.length >= this.maxQueue) {
+      this.droppedCount += 1;
+      this.warn("queue_full", "fila do Radar cheia; eventos est\xE3o sendo descartados", false);
+      return;
+    }
+    this.queue.push(event);
+    if (this.queue.length >= this.batchSize) void this.send();
+  }
+  send() {
+    if (this.inFlight) return this.inFlight;
+    if (this.stopped || this.queue.length === 0 || Date.now() < this.nextAttemptAt) return Promise.resolve(false);
+    const attempt = this.sendBatch().catch((error) => {
+      this.warn("internal", `envio ao Radar falhou: ${describeError(error)}`, false);
+      return false;
+    });
+    this.inFlight = attempt.finally(() => {
+      this.inFlight = null;
+    });
+    return this.inFlight;
+  }
+  async flush(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (this.queue.length > 0 || this.inFlight) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) return;
+      const progressed = await withTimeout(this.send(), remaining);
+      if (progressed !== true && !this.inFlight) return;
+    }
+  }
+  stop() {
+    this.stopped = true;
+    clearInterval(this.timer);
+  }
+  async sendBatch() {
+    const items = this.queue.splice(0, this.batchSize);
+    const resolved = await Promise.all(items.map((item) => Promise.resolve().then(() => typeof item === "function" ? item() : item).then((event) => event, () => null)));
+    const events = [];
+    const leftovers = [];
+    let bytes = 0;
+    for (const event of resolved) {
+      if (!event) {
+        this.droppedCount += 1;
+        continue;
+      }
+      const size = Buffer.byteLength(JSON.stringify(event));
+      if (events.length > 0 && bytes + size > MAX_BATCH_BYTES) {
+        leftovers.push(event);
+        continue;
+      }
+      events.push(event);
+      bytes += size;
+    }
+    if (leftovers.length > 0) this.queue.unshift(...leftovers);
+    if (events.length === 0) return true;
+    const dropped = this.droppedCount;
+    const batch = {
+      v: 1,
+      sdk: this.config.sdk,
+      environment: this.config.environment,
+      ...this.config.release ? { release: this.config.release } : {},
+      ...dropped > 0 ? { dropped } : {},
+      events
+    };
+    const outcome = await this.post(batch);
+    switch (outcome.kind) {
+      case "ok":
+        this.droppedCount -= dropped;
+        this.backoffMs = 0;
+        this.nextAttemptAt = 0;
+        return true;
+      case "retry":
+        this.requeue(events);
+        this.backoffMs = Math.min(this.backoffMs > 0 ? this.backoffMs * 2 : 1e3, MAX_BACKOFF_MS);
+        this.nextAttemptAt = Date.now() + Math.max(this.backoffMs, outcome.retryAfterMs ?? 0);
+        return false;
+      case "unauthorized":
+        this.droppedCount += events.length + this.queue.length;
+        this.queue = [];
+        this.nextAttemptAt = Date.now() + UNAUTHORIZED_PAUSE_MS;
+        this.warn("unauthorized", `chave do Radar recusada (${outcome.status}); envios pausados por 10 minutos`, true);
+        return false;
+      case "rejected":
+        this.droppedCount += events.length;
+        this.warn(`rejected_${outcome.status}`, `lote recusado pelo Radar (${outcome.status}); eventos descartados`, true);
+        return true;
+    }
+  }
+  requeue(events) {
+    this.queue.unshift(...events);
+    const overflow = this.queue.length - this.maxQueue;
+    if (overflow > 0) {
+      this.queue.splice(this.maxQueue, overflow);
+      this.droppedCount += overflow;
+    }
+  }
+  async post(batch) {
+    const json = JSON.stringify(batch);
+    const compress = Buffer.byteLength(json) > GZIP_THRESHOLD_BYTES;
+    const headers = {
+      "content-type": "application/json",
+      authorization: `Bearer ${this.config.key}`,
+      "user-agent": `${this.config.sdk.name}/${this.config.sdk.version}`
+    };
+    if (compress) headers["content-encoding"] = "gzip";
+    let response;
+    try {
+      response = await fetch(this.config.url, {
+        method: "POST",
+        headers,
+        body: compress ? await gzipAsync(json) : json,
+        redirect: "error",
+        signal: AbortSignal.timeout(this.config.requestTimeoutMs ?? 5e3)
+      });
+    } catch (error) {
+      this.warn("network", `Radar indispon\xEDvel: ${describeError(error)}`, false);
+      return { kind: "retry" };
+    }
+    await response.arrayBuffer().catch(() => void 0);
+    if (response.ok) return { kind: "ok" };
+    if (response.status === 401 || response.status === 403) return { kind: "unauthorized", status: response.status };
+    if (response.status === 429) return { kind: "retry", retryAfterMs: retryAfterMs(response.headers.get("retry-after")) };
+    if (response.status >= 500) return { kind: "retry" };
+    return { kind: "rejected", status: response.status };
+  }
+  warn(key, message, always) {
+    if (this.warned.has(key)) return;
+    this.warned.add(key);
+    this.config.onWarning?.(message, always);
+  }
+};
+function retryAfterMs(header) {
+  if (!header) return void 0;
+  const seconds = Number(header);
+  if (Number.isFinite(seconds)) return Math.min(Math.max(0, seconds * 1e3), MAX_RETRY_AFTER_MS);
+  const date = Date.parse(header);
+  return Number.isNaN(date) ? void 0 : Math.min(Math.max(0, date - Date.now()), MAX_RETRY_AFTER_MS);
+}
+function withTimeout(promise, ms) {
+  return new Promise((resolve2) => {
+    const timer = setTimeout(() => resolve2(void 0), ms);
+    timer.unref();
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve2(value);
+      },
+      () => {
+        clearTimeout(timer);
+        resolve2(void 0);
+      }
+    );
+  });
+}
+
+// src/version.ts
+var SDK_NAME = "@oconde/radar";
+var SDK_VERSION = true ? "0.1.0" : "0.0.0-dev";
+
+// src/client.ts
+var RadarClient = class {
+  options = resolveOptions({}, {});
+  transport = null;
+  initialized = false;
+  closed = false;
+  captured = /* @__PURE__ */ new WeakSet();
+  get isEnabled() {
+    return this.transport !== null && !this.closed;
+  }
+  get settings() {
+    return this.options;
+  }
+  init(options = {}) {
+    try {
+      if (this.initialized) {
+        this.debugWarn("radar.init chamado mais de uma vez; mantida a primeira configura\xE7\xE3o");
+        return;
+      }
+      this.initialized = true;
+      this.options = resolveOptions(options);
+      setFingerprintSecret(this.options.key);
+      if (this.options.enabled && this.options.key) {
+        this.transport = new Transport({
+          url: this.options.endpoint + INGEST_PATH,
+          key: this.options.key,
+          sdk: { name: SDK_NAME, version: SDK_VERSION },
+          environment: this.options.environment,
+          ...this.options.release ? { release: this.options.release } : {},
+          onWarning: (message, always) => always ? this.writeWarning(message) : this.debugWarn(message)
+        });
+      }
+      if (this.options.captureUnhandled && (this.transport || this.options.console)) installProcessHandlers(this);
+    } catch (error) {
+      this.debugWarn(`radar.init falhou: ${describeError(error)}`);
+    }
+  }
+  debug(message, data) {
+    this.safely(() => this.emitLog("debug", message, data));
+  }
+  info(message, data) {
+    this.safely(() => this.emitLog("info", message, data));
+  }
+  warn(message, data) {
+    this.safely(() => this.emitLog("warn", message, data));
+  }
+  error(message, data) {
+    this.safely(() => this.emitLog("error", message, data));
+  }
+  logRequest(title, data, options = {}) {
+    this.safely(() => {
+      const context = currentContext();
+      const mode = options.redact ?? this.options.redact;
+      const request = context?.req ? requestInfo(context.req, mode, { route: context.route }, this.options.requestDetail) : void 0;
+      this.emitLog(options.level ?? "info", title, data, { request, mode });
+    });
+  }
+  captureError(error, data) {
+    this.safely(() => this.emitError(error, data, "error", true));
+  }
+  captureUnhandled(error, level) {
+    this.safely(() => this.emitError(error, void 0, level, false));
+  }
+  setUser(user) {
+    this.safely(() => {
+      const context = currentContext();
+      if (!context) return;
+      context.user = {
+        ...user.id !== void 0 && user.id !== null ? { id: truncate(String(user.id), 200) } : {},
+        ...user.email ? { email: truncate(String(user.email), 200) } : {},
+        ...user.name ? { name: truncate(String(user.name), 200) } : {}
+      };
+    });
+  }
+  async track(name, fn, data) {
+    const execute = async () => {
+      const started = import_node_perf_hooks3.performance.now();
+      try {
+        const result = await fn();
+        this.info(name, { ...data, durationMs: elapsedSince(started), ok: true });
+        return result;
+      } catch (error) {
+        this.error(name, { ...data, durationMs: elapsedSince(started), ok: false });
+        this.captureError(error, data);
+        throw error;
+      }
+    };
+    if (currentContext()) return execute();
+    return runWithContext({ requestId: (0, import_node_crypto3.randomUUID)(), startedAt: import_node_perf_hooks3.performance.now() }, execute);
+  }
+  middleware() {
+    return createMiddleware(this);
+  }
+  shouldLogRequest(req) {
+    return this.options.logRequests && !this.options.ignorePaths.includes(requestPath(req));
+  }
+  logHttpRequest(context, status) {
+    this.safely(() => {
+      const req = context.req;
+      if (!req) return;
+      const level = status >= 500 ? "error" : status >= 400 ? "warn" : "info";
+      const route = requestRoute(req, context.route);
+      runWithContext(
+        context,
+        () => this.emitLog(level, "http.request", {
+          method: (req.method ?? "GET").toUpperCase(),
+          ...route ? { route } : {},
+          ...this.options.requestDetail === "full" ? { path: redactPath(requestPath(req), req.params, this.options.redact) } : {},
+          status,
+          durationMs: elapsedSince(context.startedAt)
+        })
+      );
+    });
+  }
+  async flush(timeoutMs = 2e3) {
+    try {
+      await this.transport?.flush(timeoutMs);
+    } catch (error) {
+      this.debugWarn(`flush falhou: ${describeError(error)}`);
+    }
+  }
+  async close(timeoutMs = 2e3) {
+    if (this.closed) return;
+    await this.flush(timeoutMs);
+    this.closed = true;
+    this.transport?.stop();
+  }
+  emitLog(level, message, data, extras = {}) {
+    if (this.closed || !levelEnabled(level, this.options.minLevel)) return;
+    const context = currentContext();
+    const mode = extras.mode ?? this.options.redact;
+    const event = {
+      type: "log",
+      ts: Date.now(),
+      level,
+      message: truncate(String(message), LIMITS.messageLength),
+      ...context ? { requestId: context.requestId } : {},
+      ...data !== void 0 ? { attrs: prepareAttrs(data, mode) } : {},
+      ...extras.request ? { request: extras.request } : {},
+      ...context?.user ? { user: context.user } : {}
+    };
+    this.print(event);
+    this.transport?.enqueue(event);
+  }
+  emitError(error, data, level, handled) {
+    if (this.closed) return;
+    if (typeof error === "object" && error !== null) {
+      if (this.captured.has(error)) return;
+      this.captured.add(error);
+    }
+    const context = currentContext();
+    const mode = this.options.redact;
+    const event = {
+      type: "error",
+      ts: Date.now(),
+      level,
+      handled,
+      exception: exceptionInfo(error),
+      ...context ? { requestId: context.requestId } : {},
+      ...context?.req ? { request: requestInfo(context.req, mode, { route: context.route }, this.options.requestDetail) } : {},
+      ...context?.user ? { user: context.user } : {},
+      runtime: runtimeInfo(),
+      ...data !== void 0 ? { attrs: prepareAttrs(data, mode) } : {}
+    };
+    this.print(event, error instanceof Error ? error.stack : void 0);
+    if (!this.transport) return;
+    this.transport.enqueue(
+      () => enrichException(event.exception).then(
+        (exception) => ({ ...event, exception }),
+        () => event
+      )
+    );
+  }
+  print(event, stack) {
+    if (!this.options.console) return;
+    try {
+      const requestId = event.requestId ? { requestId: event.requestId } : {};
+      if (event.type === "log") {
+        const line2 = { ...event.attrs, ts: new Date(event.ts).toISOString(), level: event.level, message: event.message, ...requestId };
+        (event.level === "error" ? process.stderr : process.stdout).write(`${JSON.stringify(line2)}
+`);
+        return;
+      }
+      const line = {
+        ...event.attrs,
+        ts: new Date(event.ts).toISOString(),
+        level: event.level,
+        message: `${event.exception.type}: ${event.exception.message}`,
+        ...requestId,
+        ...stack ? { stack } : {}
+      };
+      process.stderr.write(`${JSON.stringify(line)}
+`);
+    } catch {
+      return;
+    }
+  }
+  safely(action) {
+    try {
+      action();
+    } catch (error) {
+      this.debugWarn(`falha interna do Radar: ${describeError(error)}`);
+    }
+  }
+  debugWarn(message) {
+    if (this.options.debug) this.writeWarning(message);
+  }
+  writeWarning(message) {
+    try {
+      process.stderr.write(`[radar] ${message}
+`);
+    } catch {
+      return;
+    }
+  }
+};
+function runtimeInfo() {
+  return {
+    name: "node",
+    version: process.versions.node,
+    host: (0, import_node_os.hostname)(),
+    pid: process.pid,
+    memoryMb: Math.round(process.memoryUsage.rss() / 1048576),
+    uptimeS: Math.round(process.uptime())
+  };
+}
+
+// src/radar.ts
+var state = globalState();
+var radar = state.client ?? (state.client = new RadarClient());
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RadarClient,
+  radar
+});
+//# sourceMappingURL=index.cjs.map