@oconde/radar 0.3.0 → 0.4.2

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.4.2
+
+### Correções
+
+- SvelteKit: um `redirect()` ou `error()` lançado por um hook depois do `radarHandle` (um portão de login, por exemplo) é registrado com o status que o visitante recebe (303, 404). Antes, o log `http.request` saía como 500, contando como erro no Desempenho e na meta de disponibilidade.
+
+## 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

package/README.md

@@ -104,7 +104,20 @@ await radar.cron('nightly-report', () => buildReport());
 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.
+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
 

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

@@ -38,10 +38,24 @@ 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;
@@ -53,7 +67,7 @@ type RadarOptions = {
     minLevel?: LogLevel;
     redact?: RedactMode;
     requestDetail?: RequestDetail;
-    logRequests?: boolean;
+    logRequests?: LogRequestsOption;
     ignorePaths?: string[];
     captureUnhandled?: boolean;
     traceFetch?: TraceFetchOption;
@@ -69,7 +83,7 @@ type ResolvedOptions = {
     minLevel: LogLevel;
     redact: RedactMode;
     requestDetail: RequestDetail;
-    logRequests: boolean;
+    logRequests: ResolvedLogRequests;
     ignorePaths: string[];
     captureUnhandled: boolean;
     traceFetch: ResolvedTraceFetch;

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

@@ -38,10 +38,24 @@ 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;
@@ -53,7 +67,7 @@ type RadarOptions = {
     minLevel?: LogLevel;
     redact?: RedactMode;
     requestDetail?: RequestDetail;
-    logRequests?: boolean;
+    logRequests?: LogRequestsOption;
     ignorePaths?: string[];
     captureUnhandled?: boolean;
     traceFetch?: TraceFetchOption;
@@ -69,7 +83,7 @@ type ResolvedOptions = {
     minLevel: LogLevel;
     redact: RedactMode;
     requestDetail: RequestDetail;
-    logRequests: boolean;
+    logRequests: ResolvedLogRequests;
     ignorePaths: string[];
     captureUnhandled: boolean;
     traceFetch: ResolvedTraceFetch;

package/dist/index.cjs

@@ -280,6 +280,12 @@ 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;
   if (typeof req.route?.path !== "string") return void 0;
@@ -419,11 +425,24 @@ 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: [] };
-  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) };
+  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;
@@ -437,7 +456,7 @@ 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),
@@ -591,8 +610,8 @@ function headerOf(code, index, prefix) {
   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);
   }
@@ -912,12 +931,19 @@ function originOf(value) {
     return null;
   }
 }
-function targets(url, target) {
-  if (target instanceof RegExp) return target.test(url.host);
-  const wanted = target.trim().toLowerCase();
+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);
@@ -941,6 +967,7 @@ function traceFetch(config) {
     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 {
@@ -1189,7 +1216,7 @@ function withTimeout(promise, ms) {
 
 // src/version.ts
 var SDK_NAME = "@oconde/radar";
-var SDK_VERSION = true ? "0.3.0" : "0.0.0-dev";
+var SDK_VERSION = true ? "0.4.2" : "0.0.0-dev";
 
 // src/client.ts
 var MAX_CHECK_IN_DURATION_MS = 7 * 864e5;
@@ -1233,6 +1260,7 @@ var RadarClient = class {
         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))
         });
@@ -1343,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 } : {}
         })
       );
     });