@oconde/radar 0.1.0 → 0.3.0

package/dist/nest/index.js

@@ -26,6 +26,33 @@ import { catchError, throwError } from "rxjs";
 
 // src/context.ts
 import { AsyncLocalStorage } from "async_hooks";
+import { randomUUID } from "crypto";
+
+// src/protocol/index.ts
+var INGEST_PATH = "/api/v1/events";
+var CHECKIN_PATH = "/api/v1/checkins/";
+var CHECKIN_SLUG = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var CHECKIN_STATUSES = ["in_progress", "ok", "error"];
+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,
+  checkInIdLength: 64
+};
+
+// src/context.ts
 var STATE_KEY = /* @__PURE__ */ Symbol.for("@oconde/radar");
 function globalState() {
   const holder = globalThis;
@@ -42,35 +69,19 @@ function currentContext() {
 function runWithContext(context, fn) {
   return globalState().storage.run(context, fn);
 }
+var SAFE_REQUEST_ID = /^[\x21-\x7e]+$/;
+function requestIdFrom(incoming) {
+  const value = incoming?.trim();
+  return value && value.length <= LIMITS.requestIdLength && SAFE_REQUEST_ID.test(value) ? value : randomUUID();
+}
 
 // src/client.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { hostname } from "os";
-import { performance as performance3 } from "perf_hooks";
+import { performance as performance4 } from "perf_hooks";
 
 // src/express.ts
-import { randomUUID } from "crypto";
-import { performance } from "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
-};
+import { performance as performance2 } from "perf_hooks";
 
 // src/redact.ts
 import { createHash, createHmac, randomBytes } from "crypto";
@@ -270,7 +281,44 @@ function requestPath(req) {
 }
 function requestRoute(req, route) {
   if (route) return route;
-  return typeof req.route?.path === "string" ? req.route.path : void 0;
+  if (typeof req.route?.path !== "string") return void 0;
+  const base = typeof req.baseUrl === "string" ? req.baseUrl.replace(/\/+$/, "") : "";
+  if (!base) return req.route.path;
+  return req.route.path === "/" ? base : `${base}${req.route.path}`;
+}
+var ROUTE_PARAM = /^:([A-Za-z_$][\w$]*)/;
+function pathSegments(value) {
+  const segments = value.split("/");
+  while (segments.length > 1 && segments[segments.length - 1] === "") segments.pop();
+  return segments;
+}
+function decodeSegment(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function routeParams(req, path) {
+  if (typeof req.route?.path !== "string") return {};
+  const pattern = pathSegments(`${typeof req.baseUrl === "string" ? req.baseUrl : ""}${req.route.path}`).filter((segment, index) => index > 0 || segment !== "");
+  const values = pathSegments(path);
+  if (pattern.length > values.length) return {};
+  const offset = values.length - pattern.length;
+  const result = {};
+  for (let index = 0; index < pattern.length; index++) {
+    const value = values[offset + index];
+    const param = ROUTE_PARAM.exec(pattern[index]);
+    if (!param) {
+      if (pattern[index] !== value) return {};
+      continue;
+    }
+    if (value) result[param[1]] = decodeSegment(value);
+  }
+  return result;
+}
+function pathParams(req, path) {
+  return { ...routeParams(req, path), ...req.params ?? {} };
 }
 function redactPath(path, params, mode) {
   if (mode === "none" || !params) return path;
@@ -287,7 +335,7 @@ function safeUrl(req, mode) {
   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);
+  return redactUrl(redactPath(path, pathParams(req, path), mode) + query, mode);
 }
 function redactUrl(url, mode) {
   const queryStart = url.indexOf("?");
@@ -355,9 +403,8 @@ 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 : randomUUID();
-      context = { requestId, startedAt: performance.now(), req };
+      const requestId = requestIdFrom(headerValue(req.headers["x-request-id"]));
+      context = { requestId, startedAt: performance2.now(), req };
       res.setHeader("x-request-id", requestId);
       if (logger.shouldLogRequest(req)) res.once("finish", () => logger.logHttpRequest(context, res.statusCode));
     } catch {
@@ -371,6 +418,12 @@ function createMiddleware(logger) {
 // src/options.ts
 var DEFAULT_ENDPOINT = "https://radar-ingest.oconde.dev";
 var LEVELS = ["debug", "info", "warn", "error"];
+function resolveTraceFetch(value) {
+  if (!value) return { enabled: false, propagateTo: [] };
+  if (value === true) return { enabled: true, propagateTo: [] };
+  const targets2 = Array.isArray(value.propagateTo) ? value.propagateTo : [];
+  return { enabled: true, propagateTo: targets2.filter((target) => typeof target === "string" ? target.trim() !== "" : target instanceof RegExp) };
+}
 function resolveOptions(options = {}, env = process.env) {
   const key = options.key?.trim() || void 0;
   return {
@@ -386,6 +439,7 @@ function resolveOptions(options = {}, env = process.env) {
     logRequests: options.logRequests ?? true,
     ignorePaths: options.ignorePaths ?? ["/healthz", "/health"],
     captureUnhandled: options.captureUnhandled ?? true,
+    traceFetch: resolveTraceFetch(options.traceFetch),
     debug: options.debug ?? false
   };
 }
@@ -447,16 +501,144 @@ import { readFile, stat } from "fs/promises";
 import { SourceMap } from "module";
 import { dirname, isAbsolute, relative, resolve, sep } from "path";
 import { fileURLToPath } from "url";
+
+// src/function-name.ts
+var IDENTIFIER = "[A-Za-z_$][\\w$]*";
+var MAX_LINES_UP = 400;
+var MAX_HEADER_LINES = 6;
+var MAX_NAME_LENGTH = 100;
+var MAX_COMMENT_LINES = 40;
+var CONTROL_BLOCK = /^\s*(?:\}\s*)?(?:if|else|for|while|do|switch|try|catch|finally|with)\b/;
+var CLASS_BODY = new RegExp(`\\bclass\\s+${IDENTIFIER}`);
+var MARKUP_BOUNDARY = /<\/?(?:script|style|template)\b/i;
+var KEYWORDS = /* @__PURE__ */ new Set(["if", "for", "while", "switch", "catch", "function", "return", "new", "typeof", "await", "else", "do", "try"]);
+var NAME_PATTERNS = [
+  new RegExp(`\\bfunction\\s*\\*?\\s*(${IDENTIFIER})\\s*\\(`),
+  new RegExp(`(${IDENTIFIER})\\s*[:=]\\s*(?:async\\s+)?function\\b`),
+  new RegExp(`(${IDENTIFIER})\\s*(?::\\s*[^=]+)?=\\s*(?:async\\s+)?(?:\\([^]*\\)|${IDENTIFIER})\\s*(?::\\s*[^=]+)?=>\\s*$`),
+  new RegExp(`(?:^|[{,(]\\s*)(${IDENTIFIER})\\s*:\\s*(?:async\\s+)?(?:\\([^]*\\)|${IDENTIFIER})\\s*(?::\\s*[^=]+)?=>\\s*$`)
+];
+var METHOD_PATTERN = new RegExp(`^\\s*(?:(?:export|default|public|private|protected|static|async|override|readonly|get|set)\\s+)*\\*?\\s*(${IDENTIFIER})\\s*(?:<[^>]*>)?\\s*\\([^]*\\)\\s*(?::\\s*[^{]+)?$`);
+var ANONYMOUS_FUNCTION = /\bfunction\b|=>/;
+var STRING_LITERAL = /(["'`])(?:\\.|(?!\1)[^\\])*\1/g;
+function lineCommentAt(text, from) {
+  for (let index = text.indexOf("//", from); index >= 0; index = text.indexOf("//", index + 1)) {
+    if (index === 0 || text[index - 1] !== ":") return index;
+  }
+  return -1;
+}
+function blockCommentAt(text, from) {
+  for (let index = text.indexOf("/*", from); index >= 0; index = text.indexOf("/*", index + 1)) {
+    if (index === 0 || text[index - 1] !== "\\") return index;
+  }
+  return -1;
+}
+function stripComments(text, insideComment, closesLater) {
+  let code = "";
+  let position = 0;
+  let inside = insideComment;
+  while (position < text.length) {
+    if (inside) {
+      const end = text.indexOf("*/", position);
+      if (end < 0) return { code, insideComment: true };
+      inside = false;
+      position = end + 2;
+      continue;
+    }
+    const block = blockCommentAt(text, position);
+    const line = lineCommentAt(text, position);
+    if (line >= 0 && (block < 0 || line < block)) return { code: code + text.slice(position, line), insideComment: false };
+    if (block < 0) return { code: code + text.slice(position), insideComment: false };
+    if (text.indexOf("*/", block + 2) < 0 && !closesLater()) {
+      code += text.slice(position, block + 2);
+      position = block + 2;
+      continue;
+    }
+    code += text.slice(position, block);
+    inside = true;
+    position = block + 2;
+  }
+  return { code, insideComment: inside };
+}
+function codeLines(lines, from, start, column) {
+  const plain = lines.slice(from, start + 1).map((line) => line.replace(STRING_LITERAL, '""'));
+  const closesWithin = (index) => plain.slice(index + 1, index + 1 + MAX_COMMENT_LINES).some((line) => line.includes("*/"));
+  const result = [];
+  let insideComment = false;
+  for (let index = 0; index < plain.length; index++) {
+    const text = index === plain.length - 1 && column ? (lines[start] ?? "").slice(0, Math.max(0, column - 1)).replace(STRING_LITERAL, '""') : plain[index] ?? "";
+    const stripped = stripComments(text, insideComment, () => closesWithin(index));
+    insideComment = stripped.insideComment;
+    result.push(stripped.code);
+  }
+  return result;
+}
+function parenBalance(text) {
+  let balance = 0;
+  for (const char of text) {
+    if (char === "(") balance += 1;
+    else if (char === ")") balance -= 1;
+  }
+  return balance;
+}
+function headerOf(code, index, prefix) {
+  let header = prefix;
+  for (let previous = index - 1; previous >= 0 && previous >= index - MAX_HEADER_LINES; previous--) {
+    if (header.trim() !== "" && parenBalance(header) >= 0) break;
+    header = `${code[previous] ?? ""} ${header}`;
+  }
+  return header;
+}
+function nameIn(header) {
+  const patterns = ANONYMOUS_FUNCTION.test(header) ? NAME_PATTERNS : [...NAME_PATTERNS, METHOD_PATTERN];
+  for (const pattern of patterns) {
+    const name = pattern.exec(header)?.[1];
+    if (name && !KEYWORDS.has(name)) return name.slice(0, MAX_NAME_LENGTH);
+  }
+  return void 0;
+}
+function enclosingFunctionName(lines, line, column) {
+  const start = line - 1;
+  if (start < 0 || start >= lines.length) return void 0;
+  const from = Math.max(0, start - MAX_LINES_UP - MAX_HEADER_LINES);
+  const cleaned = codeLines(lines, from, start, column);
+  let depth = 0;
+  for (let index = start; index >= 0 && index >= start - MAX_LINES_UP; index--) {
+    if (index < start && MARKUP_BOUNDARY.test(lines[index] ?? "")) return void 0;
+    const code = cleaned[index - from] ?? "";
+    for (let position = code.length - 1; position >= 0; position--) {
+      const char = code[position];
+      if (char === "}") {
+        depth += 1;
+      } else if (char === "{") {
+        if (depth > 0) {
+          depth -= 1;
+          continue;
+        }
+        const header = headerOf(cleaned, index - from, code.slice(0, position));
+        if (CLASS_BODY.test(header)) return void 0;
+        if (CONTROL_BLOCK.test(header)) continue;
+        const name = nameIn(header);
+        if (name) return name;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/source.ts
 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()) {
+async function enrichFrames(frames, cwd = process.cwd(), options = {}) {
   const result = [];
   let withContext = 0;
   for (const frame of frames) {
     try {
-      const { frame: mapped, lines } = await mapFrame(frame);
+      const { frame: located, lines, original } = await mapFrame(frame, options.mapLocator);
+      const named = options.inferFunctionNames && original && !located.fn && lines && located.line ? withInferredName(located, lines) : located;
+      const mapped = named.inApp && isLibraryPath(named.file) ? { ...named, inApp: false } : named;
       let next = mapped;
       if (mapped.inApp && lines && mapped.line && withContext < LIMITS.contextFrames) {
         const context = contextFor(lines, mapped.line);
@@ -472,29 +654,36 @@ async function enrichFrames(frames, cwd = process.cwd()) {
   }
   return result;
 }
-async function enrichException(exception, cwd = process.cwd()) {
-  const frames = await enrichFrames(exception.frames, cwd);
+async function enrichException(exception, cwd = process.cwd(), options = {}) {
+  const frames = await enrichFrames(exception.frames, cwd, options);
   if (!exception.cause) return { ...exception, frames };
-  return { ...exception, frames, cause: await enrichException(exception.cause, cwd) };
+  return { ...exception, frames, cause: await enrichException(exception.cause, cwd, options) };
+}
+function withInferredName(frame, lines) {
+  const fn = enclosingFunctionName(lines, frame.line ?? 0, frame.col);
+  return fn ? { ...frame, fn } : frame;
+}
+function isLibraryPath(file) {
+  return file.includes("/node_modules/") || file.includes("\\node_modules\\");
 }
 function relativize(file, cwd) {
   if (!isAbsolute(file)) return file;
   const path = relative(cwd, file);
   return path.startsWith("..") || isAbsolute(path) ? file : path.split(sep).join("/");
 }
-async function mapFrame(frame) {
-  if (!frame.line || !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 };
+async function mapFrame(frame, locator) {
+  if (!frame.line || !isAbsolute(frame.file)) return { frame, lines: null, original: false };
+  const file = await loadFile(frame.file, locator);
+  if (!file) return { frame, lines: null, original: false };
+  if (!file.map) return { frame, lines: file.lines, original: false };
   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 };
+  if (typeof entry.originalSource !== "string" || typeof entry.originalLine !== "number") return { frame, lines: file.lines, original: false };
   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 };
+  if (lines) return { frame: mapped, lines, original: true };
   const original = await loadFile(originalPath);
-  return { frame: mapped, lines: original?.lines ?? null };
+  return { frame: mapped, lines: original?.lines ?? null, original: true };
 }
 function embeddedLines(map, index) {
   if (index < 0) return null;
@@ -526,26 +715,27 @@ function resolveSource(map, source) {
   }
   return isAbsolute(source) ? source : resolve(map.baseDir, source);
 }
-function loadFile(path) {
-  const cached = cache.get(path);
+function loadFile(path, locator) {
+  const key = locator ? `${path}\0located` : path;
+  const cached = cache.get(key);
   if (cached) {
-    cache.delete(path);
-    cache.set(path, cached);
+    cache.delete(key);
+    cache.set(key, cached);
     return cached;
   }
-  const pending = readSource(path).catch(() => null);
-  cache.set(path, pending);
+  const pending = readSource(path, locator).catch(() => null);
+  cache.set(key, 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) {
+async function readSource(path, locator) {
   const text = await readText(path);
   if (text === null) return null;
   const lines = text.split(/\r?\n/);
-  return { lines, map: await loadMap(path, lines) };
+  return { lines, map: await loadMap(path, lines, locator) };
 }
 async function readText(path) {
   try {
@@ -556,7 +746,7 @@ async function readText(path) {
     return null;
   }
 }
-async function loadMap(path, lines) {
+async function loadMap(path, lines, locator) {
   let url;
   for (let index = lines.length - 1; index >= 0 && index >= lines.length - 5; index--) {
     const match = MAPPING_URL.exec(lines[index] ?? "");
@@ -565,10 +755,15 @@ async function loadMap(path, lines) {
       break;
     }
   }
-  if (!url) return null;
   let raw;
   let mapDir;
-  if (url.startsWith("data:")) {
+  const located = url ? null : locator ? locator(path) : `${path}.map`;
+  if (located) {
+    raw = await readText(located);
+    mapDir = dirname(located);
+  } else if (!url) {
+    return null;
+  } else 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);
@@ -597,12 +792,13 @@ async function loadMap(path, lines) {
 import { fileURLToPath as fileURLToPath2 } from "url";
 var WITH_FUNCTION = /^at (?:async )?(.+?) \((.+)\)$/;
 var LOCATION = /^(.+):(\d+):(\d+)$/;
+var MAX_FRAME_LINE = 1e3;
 function parseStack(stack) {
   if (!stack) return [];
   const frames = [];
   for (const raw of stack.split("\n")) {
     const line = raw.trim();
-    if (!line.startsWith("at ")) continue;
+    if (line.length > MAX_FRAME_LINE || !line.startsWith("at ")) continue;
     const withFunction = WITH_FUNCTION.exec(line);
     const fn = withFunction?.[1];
     const location = withFunction ? withFunction[2] ?? "" : line.replace(/^at (?:async )?/, "");
@@ -661,20 +857,110 @@ function safeStringify(value) {
   }
 }
 
-// src/transport.ts
-import { promisify } from "util";
-import { gzip } from "zlib";
-
 // src/util.ts
-import { performance as performance2 } from "perf_hooks";
+import { performance as performance3 } from "perf_hooks";
 function describeError(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function elapsedSince(startedAt) {
-  return Math.round(performance2.now() - startedAt);
+  return Math.round(performance3.now() - startedAt);
+}
+
+// src/trace-fetch.ts
+var WRAPPED = /* @__PURE__ */ Symbol.for("@oconde/radar.fetch");
+var REQUEST_ID_HEADER = "x-request-id";
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var TELEGRAM_BOT = /^bot\d{5,}:[\w-]{20,}$/;
+var TOKEN_LIKE = /^[\w\-.~+=]{20,}$/;
+function secretSegment(segment) {
+  if (UUID.test(segment)) return false;
+  if (TELEGRAM_BOT.test(segment) || looksLikeCredential(segment)) return true;
+  return TOKEN_LIKE.test(segment) && /[A-Za-z]/.test(segment) && /\d/.test(segment);
+}
+function outboundPath(pathname, mode) {
+  if (mode === "none") return pathname;
+  return pathname.split("/").map((segment) => {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+      decoded = segment;
+    }
+    return secretSegment(decoded) ? maskValue(decoded, false) : segment;
+  }).join("/");
+}
+function failureOf(error) {
+  const message = describeError(error);
+  const cause = error instanceof Error ? error.cause : void 0;
+  const detail = typeof cause?.code === "string" ? cause.code : typeof cause?.message === "string" ? cause.message : "";
+  return detail && !message.includes(detail) ? `${message} (${detail})` : message;
+}
+function urlOf(input) {
+  try {
+    if (typeof input === "string") return new URL(input);
+    if (input instanceof URL) return input;
+    return new URL(input.url);
+  } catch {
+    return null;
+  }
+}
+function originOf(value) {
+  try {
+    return new URL(value).origin;
+  } catch {
+    return null;
+  }
+}
+function targets(url, target) {
+  if (target instanceof RegExp) return target.test(url.host);
+  const wanted = target.trim().toLowerCase();
+  if (wanted.startsWith(".")) return url.hostname.toLowerCase().endsWith(wanted);
+  return url.host.toLowerCase() === wanted || url.hostname.toLowerCase() === wanted;
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function withRequestId(input, init, requestId) {
+  const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : void 0));
+  if (headers.has(REQUEST_ID_HEADER)) return [input, init];
+  headers.set(REQUEST_ID_HEADER, requestId);
+  if (init === void 0 || isPlainObject(init)) return [input, { ...init, headers }];
+  return [new Request(input, init), { headers }];
+}
+function traceFetch(config) {
+  const current = globalThis.fetch;
+  if (typeof current !== "function" || current[WRAPPED]) return () => void 0;
+  const original = current;
+  const radarOrigin = originOf(config.endpoint);
+  const traced = async (input, init) => {
+    const url = urlOf(input);
+    if (!url || url.origin === radarOrigin || url.protocol !== "http:" && url.protocol !== "https:") return original(input, init);
+    const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+    const context = currentContext();
+    const [nextInput, nextInit] = context && config.propagateTo.some((target) => targets(url, target)) ? withRequestId(input, init, context.requestId) : [input, init];
+    const attrs = { method, host: url.host, path: outboundPath(url.pathname, config.redact) };
+    const started = performance.now();
+    try {
+      const response = await original(nextInput, nextInit);
+      config.record(response.status >= 500 ? "error" : response.status >= 400 ? "warn" : "info", { ...attrs, status: response.status, durationMs: elapsedSince(started) });
+      return response;
+    } catch (error) {
+      config.record("error", { ...attrs, error: failureOf(error), durationMs: elapsedSince(started) });
+      throw error;
+    }
+  };
+  Object.defineProperty(traced, WRAPPED, { value: original });
+  globalThis.fetch = traced;
+  return () => {
+    if (globalThis.fetch === traced) globalThis.fetch = original;
+  };
 }
 
 // src/transport.ts
+import { promisify } from "util";
+import { gzip } from "zlib";
 var gzipAsync = promisify(gzip);
 var MAX_BATCH_BYTES = 9e5;
 var GZIP_THRESHOLD_BYTES = 8192;
@@ -697,6 +983,7 @@ var Transport = class {
   inFlight = null;
   nextAttemptAt = 0;
   backoffMs = 0;
+  unauthorizedUntil = 0;
   stopped = false;
   warned = /* @__PURE__ */ new Set();
   timer;
@@ -786,10 +1073,8 @@ var Transport = class {
         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);
+        this.droppedCount += events.length;
+        this.pauseUnauthorized(outcome.status);
         return false;
       case "rejected":
         this.droppedCount += events.length;
@@ -797,6 +1082,47 @@ var Transport = class {
         return true;
     }
   }
+  async checkIn(slug, payload) {
+    if (this.stopped || !this.config.checkInBaseUrl || Date.now() < this.unauthorizedUntil) return;
+    let response;
+    try {
+      response = await fetch(this.config.checkInBaseUrl + encodeURIComponent(slug), {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify(payload),
+        redirect: "error",
+        signal: AbortSignal.timeout(this.config.requestTimeoutMs ?? 5e3)
+      });
+    } catch (error) {
+      this.warn("checkin_network", `check-in no Radar falhou: ${describeError(error)}`, false);
+      return;
+    }
+    await response.arrayBuffer().catch(() => void 0);
+    if (response.ok) return;
+    if (response.status === 401 || response.status === 403) {
+      this.pauseUnauthorized(response.status);
+      return;
+    }
+    if (response.status === 404) {
+      this.warn(`checkin_unknown_${slug}`, `tarefa agendada "${slug}" n\xE3o existe no projeto da chave; crie o monitor com esse slug no Radar`, true);
+      return;
+    }
+    this.warn(`checkin_rejected_${response.status}`, `check-in recusado pelo Radar (${response.status})`, false);
+  }
+  pauseUnauthorized(status) {
+    this.droppedCount += this.queue.length;
+    this.queue = [];
+    this.unauthorizedUntil = Date.now() + UNAUTHORIZED_PAUSE_MS;
+    this.nextAttemptAt = Math.max(this.nextAttemptAt, this.unauthorizedUntil);
+    this.warn("unauthorized", `chave do Radar recusada (${status}); envios pausados por 10 minutos`, true);
+  }
+  headers() {
+    return {
+      "content-type": "application/json",
+      authorization: `Bearer ${this.config.key}`,
+      "user-agent": `${this.config.sdk.name}/${this.config.sdk.version}`
+    };
+  }
   requeue(events) {
     this.queue.unshift(...events);
     const overflow = this.queue.length - this.maxQueue;
@@ -808,11 +1134,7 @@ var Transport = class {
   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}`
-    };
+    const headers = this.headers();
     if (compress) headers["content-encoding"] = "gzip";
     let response;
     try {
@@ -866,15 +1188,19 @@ function withTimeout(promise, ms) {
 
 // src/version.ts
 var SDK_NAME = "@oconde/radar";
-var SDK_VERSION = true ? "0.1.0" : "0.0.0-dev";
+var SDK_VERSION = true ? "0.3.0" : "0.0.0-dev";
 
 // src/client.ts
+var MAX_CHECK_IN_DURATION_MS = 7 * 864e5;
+var MAX_CHECK_IN_ENVIRONMENT = 64;
+var MAX_CHECK_IN_RELEASE = 128;
 var RadarClient = class {
   options = resolveOptions({}, {});
   transport = null;
   initialized = false;
   closed = false;
   captured = /* @__PURE__ */ new WeakSet();
+  restoreFetch = null;
   get isEnabled() {
     return this.transport !== null && !this.closed;
   }
@@ -897,10 +1223,19 @@ var RadarClient = class {
           sdk: { name: SDK_NAME, version: SDK_VERSION },
           environment: this.options.environment,
           ...this.options.release ? { release: this.options.release } : {},
+          checkInBaseUrl: this.options.endpoint + CHECKIN_PATH,
           onWarning: (message, always) => always ? this.writeWarning(message) : this.debugWarn(message)
         });
       }
       if (this.options.captureUnhandled && (this.transport || this.options.console)) installProcessHandlers(this);
+      if (this.options.traceFetch.enabled && (this.transport || this.options.console)) {
+        this.restoreFetch = traceFetch({
+          endpoint: this.options.endpoint,
+          propagateTo: this.options.traceFetch.propagateTo,
+          redact: this.options.redact,
+          record: (level, attrs) => this.safely(() => this.emitLog(level, "http.client", attrs))
+        });
+      }
     } catch (error) {
       this.debugWarn(`radar.init falhou: ${describeError(error)}`);
     }
@@ -944,7 +1279,7 @@ var RadarClient = class {
   }
   async track(name, fn, data) {
     const execute = async () => {
-      const started = performance3.now();
+      const started = performance4.now();
       try {
         const result = await fn();
         this.info(name, { ...data, durationMs: elapsedSince(started), ok: true });
@@ -956,7 +1291,52 @@ var RadarClient = class {
       }
     };
     if (currentContext()) return execute();
-    return runWithContext({ requestId: randomUUID2(), startedAt: performance3.now() }, execute);
+    return runWithContext({ requestId: randomUUID2(), startedAt: performance4.now() }, execute);
+  }
+  withContext(fn, options = {}) {
+    return runWithContext({ requestId: requestIdFrom(options.requestId), startedAt: performance4.now() }, fn);
+  }
+  async checkIn(slug, status, options = {}) {
+    try {
+      if (!this.transport || this.closed) return;
+      if (typeof slug !== "string" || !CHECKIN_SLUG.test(slug)) {
+        this.debugWarn(`slug de tarefa agendada inv\xE1lido: ${String(slug).slice(0, 80)}`);
+        return;
+      }
+      if (!CHECKIN_STATUSES.includes(status)) return;
+      const checkInId = typeof options.checkInId === "string" && options.checkInId ? options.checkInId.slice(0, LIMITS.checkInIdLength) : void 0;
+      const durationMs = typeof options.durationMs === "number" && Number.isFinite(options.durationMs) && options.durationMs >= 0 ? Math.min(Math.round(options.durationMs), MAX_CHECK_IN_DURATION_MS) : void 0;
+      const environment = this.options.environment.slice(0, MAX_CHECK_IN_ENVIRONMENT) || "production";
+      const release = this.options.release?.slice(0, MAX_CHECK_IN_RELEASE);
+      const payload = {
+        status,
+        ...checkInId ? { checkInId } : {},
+        ...durationMs !== void 0 ? { durationMs } : {},
+        environment,
+        ...release ? { release } : {}
+      };
+      await this.transport.checkIn(slug, payload);
+    } catch (error) {
+      this.debugWarn(`check-in falhou: ${describeError(error)}`);
+    }
+  }
+  async cron(slug, fn) {
+    const checkInId = randomUUID2();
+    const started = performance4.now();
+    const execute = async () => {
+      await this.checkIn(slug, "in_progress", { checkInId });
+      try {
+        const result = await fn();
+        await this.checkIn(slug, "ok", { checkInId, durationMs: elapsedSince(started) });
+        return result;
+      } catch (error) {
+        this.captureError(error, { cron: slug });
+        await this.checkIn(slug, "error", { checkInId, durationMs: elapsedSince(started) });
+        throw error;
+      }
+    };
+    if (currentContext()) return execute();
+    return this.withContext(execute);
   }
   middleware() {
     return createMiddleware(this);
@@ -975,7 +1355,7 @@ var RadarClient = class {
         () => 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) } : {},
+          ...this.options.requestDetail === "full" ? { path: redactPath(requestPath(req), pathParams(req, requestPath(req)), this.options.redact) } : {},
           status,
           durationMs: elapsedSince(context.startedAt)
         })
@@ -992,6 +1372,8 @@ var RadarClient = class {
   async close(timeoutMs = 2e3) {
     if (this.closed) return;
     await this.flush(timeoutMs);
+    this.restoreFetch?.();
+    this.restoreFetch = null;
     this.closed = true;
     this.transport?.stop();
   }
@@ -1012,31 +1394,40 @@ var RadarClient = class {
     this.print(event);
     this.transport?.enqueue(event);
   }
+  captureException(exception, options = {}) {
+    this.safely(() => this.emitException(exception, options));
+  }
   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);
     }
+    this.emitException(exceptionInfo(error), { level, handled, ...data !== void 0 ? { attrs: data } : {} }, error instanceof Error ? error.stack : void 0);
+  }
+  emitException(exception, options, stack) {
+    if (this.closed) return;
     const context = currentContext();
     const mode = this.options.redact;
+    const request = options.request === null ? void 0 : options.request ?? (context?.req ? requestInfo(context.req, mode, { route: context.route }, this.options.requestDetail) : void 0);
+    const runtime = options.runtime === void 0 ? runtimeInfo() : options.runtime;
     const event = {
       type: "error",
       ts: Date.now(),
-      level,
-      handled,
-      exception: exceptionInfo(error),
+      level: options.level ?? "error",
+      handled: options.handled ?? true,
+      exception,
       ...context ? { requestId: context.requestId } : {},
-      ...context?.req ? { request: requestInfo(context.req, mode, { route: context.route }, this.options.requestDetail) } : {},
+      ...request ? { request } : {},
       ...context?.user ? { user: context.user } : {},
-      runtime: runtimeInfo(),
-      ...data !== void 0 ? { attrs: prepareAttrs(data, mode) } : {}
+      ...runtime ? { runtime } : {},
+      ...options.attrs !== void 0 ? { attrs: prepareAttrs(options.attrs, mode) } : {}
     };
-    this.print(event, error instanceof Error ? error.stack : void 0);
+    this.print(event, stack);
     if (!this.transport) return;
     this.transport.enqueue(
-      () => enrichException(event.exception).then(
-        (exception) => ({ ...event, exception }),
+      () => enrichException(event.exception, process.cwd(), options.enrich).then(
+        (enriched) => ({ ...event, exception: enriched }),
         () => event
       )
     );