@oconde/radar 0.2.0 → 0.4.1

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 0.4.1
+
+### Correções
+
+- `logRequests: { sample: 0 }` não registra nenhuma requisição. Antes, 0 era tratado como valor inválido e virava 1, guardando todas.
+
+## 0.4.0
+
+### Novo
+
+- `logRequests` aceita filtros e amostragem: `{ include, exclude, sample }`. `include` e `exclude` recebem caminhos ou rotas (`'/dashboard'` vale para `/dashboard` e tudo abaixo dele) ou RegExp, testados no caminho e na rota do framework. `sample` (de 0 a 1) guarda só essa fração das requisições, sorteada de forma uniforme, e cada log guardado leva `sampleRate`, que o Radar usa para estimar os totais. `logRequests: true` e `false` continuam valendo.
+- `traceFetch.ignore`: hosts (o nome exato ou `.dominio`) ou RegExp testadas em `host + caminho` que não viram log `http.client`. As chamadas continuam saindo normalmente.
+
+### Correções
+
+- Uma RegExp com a flag `g` em `propagateTo` deixava de mandar o `x-request-id` em chamadas alternadas.
+
+## 0.3.0
+
+### Novo
+
+- `traceFetch`: cada `fetch` de saída vira um log `http.client` com método, host, caminho (sem a query, com trechos que parecem segredo mascarados), status e duração, ou o erro com a causa (`fetch failed (ECONNREFUSED)`). Para os hosts de `propagateTo`, o SDK manda o `x-request-id` da requisição atual, sem trocar um que o app já tenha posto. Chamadas para o próprio Radar ficam de fora. Desligado por padrão.
+
+### Correções
+
+- O nome da função inferido do código original não se confunde mais com chaves e com a palavra `function` dentro de comentários de várias linhas (como os de JSDoc).
+
 ## 0.2.0
 
 ### Novo

package/README.md

@@ -98,6 +98,27 @@ await radar.cron('nightly-report', () => buildReport());
 
 `radar.cron` avisa o Radar no início, no fim e na falha, e o Radar alerta se a tarefa atrasar ou falhar. Em scripts sem o SDK, o check-in é um `POST` (veja o [PROTOCOL.md](PROTOCOL.md)). Para jobs e workers, `radar.withContext(fn)` dá a cada execução o próprio `requestId`. Detalhes em [Tarefas agendadas](https://radar.oconde.dev/docs/sdk/cron/).
 
+## Chamadas para outros serviços
+
+```ts
+radar.init({ key: process.env.RADAR_KEY, traceFetch: { propagateTo: ['api.spinlab.dev', '.oconde.dev'] } });
+```
+
+Com `traceFetch`, cada `fetch` que o app faz vira um log `http.client` com método, host, caminho (sem a query, e com trechos que parecem token mascarados), status e duração, ou o erro quando a chamada nem chega a responder. Dentro de uma requisição, o log entra na linha do tempo dela. Para os hosts de `propagateTo` (o nome exato, `.dominio` para os subdomínios ou uma RegExp), o SDK manda o `x-request-id` da requisição atual, e o Radar mostra a mesma requisição nos dois projetos. `traceFetch: true` registra as chamadas sem mandar o id para ninguém. Chamadas para o próprio Radar ficam de fora. Para não registrar chamadas barulhentas, como polling, use `ignore` com hosts ou RegExp testadas em `host + caminho`: `traceFetch: { ignore: ['api.telegram.org', /\/getUpdates$/] }`.
+
+## Quais requisições viram log
+
+Por padrão, cada requisição vira um log `http.request`, que alimenta o Desempenho e os limites do Radar. Para guardar só uma parte:
+
+```ts
+radar.init({
+  key: process.env.RADAR_KEY,
+  logRequests: { include: ['/dashboard', /^\/api\//], exclude: ['/dashboard/ping'], sample: 0.5 },
+});
+```
+
+`include` e `exclude` recebem caminhos ou rotas (`'/dashboard'` vale para `/dashboard` e tudo abaixo dele) ou RegExp. `sample` guarda só essa fração, sorteada de forma uniforme, e o Radar compensa a amostragem nos totais. `logRequests: false` desliga.
+
 ## Erros com o seu código
 
 Ligue no `tsconfig` para os erros mostrarem as linhas do TypeScript:

package/dist/{client-CZHtsQAd.d.cts → client-DRZ7htMJ.d.cts}

@@ -35,6 +35,28 @@ type RadarMiddleware = (req: RequestLike, res: ResponseLike, next: (error?: unkn
 
 type RedactMode = 'mask' | 'none';
 type RequestDetail = 'full' | 'route';
+type FetchTraceTarget = string | RegExp;
+type TraceFetchOption = boolean | {
+    propagateTo?: FetchTraceTarget[];
+    ignore?: FetchTraceTarget[];
+};
+type ResolvedTraceFetch = {
+    enabled: boolean;
+    propagateTo: FetchTraceTarget[];
+    ignore: FetchTraceTarget[];
+};
+type RequestPattern = string | RegExp;
+type LogRequestsOption = boolean | {
+    include?: RequestPattern[];
+    exclude?: RequestPattern[];
+    sample?: number;
+};
+type ResolvedLogRequests = {
+    enabled: boolean;
+    include: RequestPattern[];
+    exclude: RequestPattern[];
+    sample: number;
+};
 type RadarOptions = {
     key?: string;
     endpoint?: string;
@@ -45,9 +67,10 @@ type RadarOptions = {
     minLevel?: LogLevel;
     redact?: RedactMode;
     requestDetail?: RequestDetail;
-    logRequests?: boolean;
+    logRequests?: LogRequestsOption;
     ignorePaths?: string[];
     captureUnhandled?: boolean;
+    traceFetch?: TraceFetchOption;
     debug?: boolean;
 };
 type ResolvedOptions = {
@@ -60,9 +83,10 @@ type ResolvedOptions = {
     minLevel: LogLevel;
     redact: RedactMode;
     requestDetail: RequestDetail;
-    logRequests: boolean;
+    logRequests: ResolvedLogRequests;
     ignorePaths: string[];
     captureUnhandled: boolean;
+    traceFetch: ResolvedTraceFetch;
     debug: boolean;
 };
 
@@ -95,6 +119,7 @@ declare class RadarClient {
     private initialized;
     private closed;
     private readonly captured;
+    private restoreFetch;
     get isEnabled(): boolean;
     get settings(): Readonly<ResolvedOptions>;
     init(options?: RadarOptions): void;

package/dist/{client-DbBsXgpj.d.ts → client-FkXWx8sJ.d.ts}

@@ -35,6 +35,28 @@ type RadarMiddleware = (req: RequestLike, res: ResponseLike, next: (error?: unkn
 
 type RedactMode = 'mask' | 'none';
 type RequestDetail = 'full' | 'route';
+type FetchTraceTarget = string | RegExp;
+type TraceFetchOption = boolean | {
+    propagateTo?: FetchTraceTarget[];
+    ignore?: FetchTraceTarget[];
+};
+type ResolvedTraceFetch = {
+    enabled: boolean;
+    propagateTo: FetchTraceTarget[];
+    ignore: FetchTraceTarget[];
+};
+type RequestPattern = string | RegExp;
+type LogRequestsOption = boolean | {
+    include?: RequestPattern[];
+    exclude?: RequestPattern[];
+    sample?: number;
+};
+type ResolvedLogRequests = {
+    enabled: boolean;
+    include: RequestPattern[];
+    exclude: RequestPattern[];
+    sample: number;
+};
 type RadarOptions = {
     key?: string;
     endpoint?: string;
@@ -45,9 +67,10 @@ type RadarOptions = {
     minLevel?: LogLevel;
     redact?: RedactMode;
     requestDetail?: RequestDetail;
-    logRequests?: boolean;
+    logRequests?: LogRequestsOption;
     ignorePaths?: string[];
     captureUnhandled?: boolean;
+    traceFetch?: TraceFetchOption;
     debug?: boolean;
 };
 type ResolvedOptions = {
@@ -60,9 +83,10 @@ type ResolvedOptions = {
     minLevel: LogLevel;
     redact: RedactMode;
     requestDetail: RequestDetail;
-    logRequests: boolean;
+    logRequests: ResolvedLogRequests;
     ignorePaths: string[];
     captureUnhandled: boolean;
+    traceFetch: ResolvedTraceFetch;
     debug: boolean;
 };
 
@@ -95,6 +119,7 @@ declare class RadarClient {
     private initialized;
     private closed;
     private readonly captured;
+    private restoreFetch;
     get isEnabled(): boolean;
     get settings(): Readonly<ResolvedOptions>;
     init(options?: RadarOptions): void;

package/dist/index.cjs

@@ -280,9 +280,18 @@ function requestPath(req) {
   const end = url.indexOf("?");
   return end >= 0 ? url.slice(0, end) : url;
 }
+function matchesRequest(pattern, path, route) {
+  const candidates = route === void 0 ? [path] : [path, route];
+  if (pattern instanceof RegExp) return candidates.some((value) => value.search(pattern) !== -1);
+  const prefix = pattern.endsWith("/") ? pattern : `${pattern}/`;
+  return candidates.some((value) => value === pattern || value.startsWith(prefix));
+}
 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) {
@@ -416,6 +425,25 @@ function createMiddleware(logger) {
 // src/options.ts
 var DEFAULT_ENDPOINT = "https://radar-ingest.oconde.dev";
 var LEVELS = ["debug", "info", "warn", "error"];
+function patterns(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    if (item instanceof RegExp) return [item];
+    if (typeof item === "string" && item.trim() !== "") return [item.trim()];
+    return [];
+  });
+}
+function resolveTraceFetch(value) {
+  if (!value) return { enabled: false, propagateTo: [], ignore: [] };
+  if (value === true) return { enabled: true, propagateTo: [], ignore: [] };
+  return { enabled: true, propagateTo: patterns(value.propagateTo), ignore: patterns(value.ignore) };
+}
+function resolveLogRequests(value) {
+  if (value === false) return { enabled: false, include: [], exclude: [], sample: 1 };
+  if (value === void 0 || value === true || typeof value !== "object" || value === null) return { enabled: true, include: [], exclude: [], sample: 1 };
+  const sample = typeof value.sample === "number" && Number.isFinite(value.sample) && value.sample >= 0 && value.sample <= 1 ? value.sample : 1;
+  return { enabled: true, include: patterns(value.include), exclude: patterns(value.exclude), sample };
+}
 function resolveOptions(options = {}, env = process.env) {
   const key = options.key?.trim() || void 0;
   return {
@@ -428,9 +456,10 @@ function resolveOptions(options = {}, env = process.env) {
     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,
+    logRequests: resolveLogRequests(options.logRequests),
     ignorePaths: options.ignorePaths ?? ["/healthz", "/health"],
     captureUnhandled: options.captureUnhandled ?? true,
+    traceFetch: resolveTraceFetch(options.traceFetch),
     debug: options.debug ?? false
   };
 }
@@ -498,6 +527,7 @@ 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;
@@ -510,8 +540,58 @@ var NAME_PATTERNS = [
 ];
 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|=>/;
-function codeOnly(text) {
-  return text.replace(/(["'`])(?:\\.|(?!\1)[^\\])*\1/g, '""').replace(/\/\*.*?\*\//g, "").replace(/(^|[^:])\/\/.*$/, "$1");
+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;
@@ -521,17 +601,17 @@ function parenBalance(text) {
   }
   return balance;
 }
-function headerOf(lines, index, prefix) {
+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 = `${codeOnly(lines[previous] ?? "")} ${header}`;
+    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 patterns2 = ANONYMOUS_FUNCTION.test(header) ? NAME_PATTERNS : [...NAME_PATTERNS, METHOD_PATTERN];
+  for (const pattern of patterns2) {
     const name = pattern.exec(header)?.[1];
     if (name && !KEYWORDS.has(name)) return name.slice(0, MAX_NAME_LENGTH);
   }
@@ -540,11 +620,12 @@ function nameIn(header) {
 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--) {
-    const raw = lines[index] ?? "";
-    if (index < start && MARKUP_BOUNDARY.test(raw)) return void 0;
-    const code = codeOnly(index === start && column ? raw.slice(0, Math.max(0, column - 1)) : raw);
+    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 === "}") {
@@ -554,7 +635,7 @@ function enclosingFunctionName(lines, line, column) {
           depth -= 1;
           continue;
         }
-        const header = headerOf(lines, index, code.slice(0, position));
+        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);
@@ -796,10 +877,6 @@ function safeStringify(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) {
@@ -809,7 +886,109 @@ function elapsedSince(startedAt) {
   return Math.round(import_node_perf_hooks2.performance.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 hostMatches(url, host) {
+  const wanted = host.trim().toLowerCase();
+  if (wanted.startsWith(".")) return url.hostname.toLowerCase().endsWith(wanted);
+  return url.host.toLowerCase() === wanted || url.hostname.toLowerCase() === wanted;
+}
+function targets(url, target) {
+  if (target instanceof RegExp) return url.host.search(target) !== -1;
+  return hostMatches(url, target);
+}
+function ignored(url, target) {
+  if (target instanceof RegExp) return `${url.host}${url.pathname}`.search(target) !== -1;
+  return hostMatches(url, target);
+}
+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];
+    if (config.ignore?.some((target) => ignored(url, target))) return original(nextInput, nextInit);
+    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
+var import_node_util2 = require("util");
+var import_node_zlib = require("zlib");
 var gzipAsync = (0, import_node_util2.promisify)(import_node_zlib.gzip);
 var MAX_BATCH_BYTES = 9e5;
 var GZIP_THRESHOLD_BYTES = 8192;
@@ -1037,7 +1216,7 @@ function withTimeout(promise, ms) {
 
 // src/version.ts
 var SDK_NAME = "@oconde/radar";
-var SDK_VERSION = true ? "0.2.0" : "0.0.0-dev";
+var SDK_VERSION = true ? "0.4.1" : "0.0.0-dev";
 
 // src/client.ts
 var MAX_CHECK_IN_DURATION_MS = 7 * 864e5;
@@ -1049,6 +1228,7 @@ var RadarClient = class {
   initialized = false;
   closed = false;
   captured = /* @__PURE__ */ new WeakSet();
+  restoreFetch = null;
   get isEnabled() {
     return this.transport !== null && !this.closed;
   }
@@ -1076,6 +1256,15 @@ var RadarClient = class {
         });
       }
       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,
+          ignore: this.options.traceFetch.ignore,
+          redact: this.options.redact,
+          record: (level, attrs) => this.safely(() => this.emitLog(level, "http.client", attrs))
+        });
+      }
     } catch (error) {
       this.debugWarn(`radar.init falhou: ${describeError(error)}`);
     }
@@ -1182,22 +1371,28 @@ var RadarClient = class {
     return createMiddleware(this);
   }
   shouldLogRequest(req) {
-    return this.options.logRequests && !this.options.ignorePaths.includes(requestPath(req));
+    return this.options.logRequests.enabled && !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);
+      const path = requestPath(req);
+      const { include, exclude, sample } = this.options.logRequests;
+      if (include.length > 0 && !include.some((pattern) => matchesRequest(pattern, path, route))) return;
+      if (exclude.some((pattern) => matchesRequest(pattern, path, route))) return;
+      if (sample < 1 && Math.random() >= sample) return;
+      const level = status >= 500 ? "error" : status >= 400 ? "warn" : "info";
       runWithContext(
         context,
         () => this.emitLog(level, "http.request", {
           method: (req.method ?? "GET").toUpperCase(),
           ...route ? { route } : {},
-          ...this.options.requestDetail === "full" ? { path: redactPath(requestPath(req), pathParams(req, requestPath(req)), this.options.redact) } : {},
+          ...this.options.requestDetail === "full" ? { path: redactPath(path, pathParams(req, path), this.options.redact) } : {},
           status,
-          durationMs: elapsedSince(context.startedAt)
+          durationMs: elapsedSince(context.startedAt),
+          ...sample < 1 ? { sampleRate: sample } : {}
         })
       );
     });
@@ -1212,6 +1407,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();
   }