@fabbahiense/pulsar-pino-transport 0.3.0 → 0.4.0

package/dist/middleware.js

@@ -1,49 +1,228 @@
+// ../shared/src/redact.ts
+var DEFAULT_REDACT_KEYS = [
+  "password",
+  "passwd",
+  "password_hash",
+  "secret",
+  "client_secret",
+  "token",
+  "access_token",
+  "refresh_token",
+  "id_token",
+  "session_id",
+  "api_key",
+  "x-api-key",
+  "x-auth-token",
+  "authorization",
+  "proxy-authorization",
+  "cookie",
+  "set-cookie"
+];
+function normalizeKey(key) {
+  return String(key).toLowerCase().replace(/[-_]/g, "");
+}
+function redactKeyList(extra = []) {
+  return [...new Set([...DEFAULT_REDACT_KEYS, ...extra].map(normalizeKey))];
+}
+function isRedactedKey(key, redactKeys) {
+  return redactKeys.includes(normalizeKey(key));
+}
+
+// ../shared/src/trace.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { createHash, randomBytes } from "crypto";
+var TRACEPARENT_HEADER = "traceparent";
+var TRACESTATE_HEADER = "tracestate";
+var TRACE_ID_HEADER = "x-trace-id";
+var MAX_TRACESTATE_CHARS = 512;
+var ZERO_TRACE_ID = "0".repeat(32);
+var ZERO_SPAN_ID = "0".repeat(16);
+var TRACEPARENT_RE = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})(-.*)?$/;
+var TRACE_ID_RE = /^[0-9a-f]{32}$/;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function newTraceId() {
+  for (; ; ) {
+    const id = randomBytes(16).toString("hex");
+    if (id !== ZERO_TRACE_ID) return id;
+  }
+}
+function newSpanId() {
+  for (; ; ) {
+    const id = randomBytes(8).toString("hex");
+    if (id !== ZERO_SPAN_ID) return id;
+  }
+}
+function sha256Hex(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function toW3CTraceId(traceId) {
+  const lower = traceId.toLowerCase();
+  if (TRACE_ID_RE.test(lower) && lower !== ZERO_TRACE_ID) return lower;
+  if (UUID_RE.test(lower)) {
+    const hex = lower.replace(/-/g, "");
+    if (hex !== ZERO_TRACE_ID) return hex;
+  }
+  return sha256Hex(traceId).slice(0, 32);
+}
+function parseTraceparent(value) {
+  if (typeof value !== "string") return null;
+  const header = value.trim();
+  const match = TRACEPARENT_RE.exec(header);
+  if (!match) return null;
+  const [, version, traceId, parentId, flagsHex, rest] = match;
+  if (version === "ff") return null;
+  if (version === "00" && rest !== void 0) return null;
+  if (traceId === ZERO_TRACE_ID || parentId === ZERO_SPAN_ID) return null;
+  const flags = parseInt(flagsHex, 16);
+  return { version, traceId, parentId, flags, sampled: (flags & 1) === 1 };
+}
+var STORE_KEY = /* @__PURE__ */ Symbol.for("@fabbahiense/pulsar.trace-context.v1");
+function sharedStore() {
+  const g = globalThis;
+  let store = g[STORE_KEY];
+  if (!store) {
+    store = new AsyncLocalStorage();
+    g[STORE_KEY] = store;
+  }
+  return store;
+}
+var traceStore = sharedStore();
+function text(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function completeContext(init) {
+  const ctx = {
+    traceId: text(init?.traceId) ?? newTraceId(),
+    spanId: text(init?.spanId) ?? newSpanId(),
+    sampled: init?.sampled !== false
+  };
+  const parentSpanId = text(init?.parentSpanId);
+  if (parentSpanId) ctx.parentSpanId = parentSpanId;
+  const traceState = text(init?.traceState);
+  if (traceState) ctx.traceState = traceState;
+  const method = text(init?.method);
+  if (method) ctx.method = method;
+  const url = text(init?.url);
+  if (url) ctx.url = url;
+  return ctx;
+}
+function childContext(parent) {
+  if (!parent || !text(parent.traceId)) return completeContext(null);
+  const local = parent;
+  return completeContext({
+    traceId: parent.traceId,
+    parentSpanId: parent.spanId,
+    sampled: parent.sampled,
+    traceState: parent.traceState,
+    method: local.method,
+    url: local.url
+  });
+}
+function read(carrier, name) {
+  let value;
+  if (typeof carrier.get === "function") {
+    value = carrier.get(name);
+  } else {
+    const record = carrier;
+    value = record[name];
+    if (value === void 0) {
+      for (const key of Object.keys(record)) {
+        if (key.toLowerCase() === name) {
+          value = record[key];
+          break;
+        }
+      }
+    }
+  }
+  if (Array.isArray(value)) value = value.find((v) => typeof v === "string");
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readTraceState(carrier) {
+  let raw;
+  if (typeof carrier.get === "function") {
+    raw = carrier.get(TRACESTATE_HEADER);
+  } else {
+    const record = carrier;
+    raw = record[TRACESTATE_HEADER];
+    if (raw === void 0) {
+      const key = Object.keys(record).find((k) => k.toLowerCase() === TRACESTATE_HEADER);
+      raw = key === void 0 ? void 0 : record[key];
+    }
+  }
+  const joined = Array.isArray(raw) ? raw.filter((v) => typeof v === "string").join(",") : raw;
+  if (typeof joined !== "string") return void 0;
+  const value = joined.trim();
+  return value.length > 0 && value.length <= MAX_TRACESTATE_CHARS ? value : void 0;
+}
+function extractTrace(carrier) {
+  if (typeof carrier !== "object" || carrier === null) return null;
+  try {
+    const source = carrier;
+    const legacy = read(source, TRACE_ID_HEADER);
+    const parent = parseTraceparent(read(source, TRACEPARENT_HEADER));
+    if (legacy !== void 0) {
+      if (parent && parent.traceId === toW3CTraceId(legacy)) {
+        return withTraceState({ traceId: legacy, spanId: parent.parentId, sampled: parent.sampled }, source);
+      }
+      return { traceId: legacy, sampled: true };
+    }
+    if (parent) return withTraceState({ traceId: parent.traceId, spanId: parent.parentId, sampled: parent.sampled }, source);
+    return null;
+  } catch {
+    return null;
+  }
+}
+function withTraceState(trace, carrier) {
+  const traceState = readTraceState(carrier);
+  if (traceState) trace.traceState = traceState;
+  return trace;
+}
+
 // src/middleware.ts
 var DEFAULT_SKIP_URLS = ["/health", "/metrics", "/favicon.ico"];
-var DEFAULT_REDACT = ["authorization", "cookie", "set-cookie", "x-api-key", "x-auth-token"];
 var DEFAULT_MAX_BODY = 5e4;
 function pulsarRequestLogger(options) {
   const logger = options.logger;
   if (!logger) throw new Error("pulsarRequestLogger: options.logger is required");
   const skipUrls = options.skipUrls ?? DEFAULT_SKIP_URLS;
-  const redactKeys = [...DEFAULT_REDACT, ...options.redactKeys ?? []].map((k) => k.toLowerCase());
+  const redactKeys = redactKeyList(options.redactKeys ?? []);
   const maxBodySize = options.maxBodySize ?? DEFAULT_MAX_BODY;
   const getUserId = options.getUserId ?? ((req) => req.user?.id);
   const getLevel = options.getLevel ?? defaultLevel;
   return function pulsarMw(req, res, next) {
     const url = req.originalUrl || req.url;
-    if (skipUrls.some((s) => url.includes(s))) return next();
+    const ctx = requestContext(req, url);
+    if (skipUrls.some((s) => url.includes(s))) return traceStore.run(ctx, next);
     const startedAt = Date.now();
-    const chunks = [];
+    const capture = new BodyCapture(maxBodySize);
     const originalWrite = res.write.bind(res);
     const originalEnd = res.end.bind(res);
     res.write = function(chunk, ...rest) {
-      try {
-        if (chunk) chunks.push(toBuffer(chunk));
-      } catch {
-      }
+      capture.add(chunk, rest[0]);
       return originalWrite(chunk, ...rest);
     };
     res.end = function(chunk, ...rest) {
-      try {
-        if (chunk) chunks.push(toBuffer(chunk));
-      } catch {
-      }
+      capture.add(chunk, rest[0]);
       return originalEnd(chunk, ...rest);
     };
-    res.on("finish", () => {
+    res.on("finish", () => traceStore.run(ctx, () => {
       try {
         const responseTime = Date.now() - startedAt;
         const status = res.statusCode;
         const level = getLevel(req, res);
-        const responseBody = readBuffer(chunks, maxBodySize, getResponseContentType(res));
+        const responseBody = readBuffer(capture, maxBodySize, getResponseContentType(res), redactKeys);
         const payload = {
-          // Top-level → colunas/filtros
+          // Top level: becomes columns and filters
           req: { method: req.method, url, id: req.id },
           res: { statusCode: status },
           responseTime,
-          traceId: req.id || (typeof req.headers["x-trace-id"] === "string" ? req.headers["x-trace-id"] : void 0),
-          // metadata → seções coloridas no painel lateral
+          // A request id set later (pino-http registered after this middleware) still wins, as it always has.
+          traceId: req.id || ctx.traceId,
+          // The request's span-end entry.
+          spanId: ctx.spanId,
+          ...ctx.parentSpanId ? { parentSpanId: ctx.parentSpanId } : {},
+          spanKind: "server",
+          // metadata: the sections of the side panel
           metadata: trimUndefined({
             requestBody: redactDeep(req.body, redactKeys),
             responseBody,
@@ -59,36 +238,75 @@ function pulsarRequestLogger(options) {
       } catch (err) {
         if (typeof console !== "undefined") console.error("[pulsarRequestLogger] failed:", err);
       }
-    });
-    next();
+    }));
+    traceStore.run(ctx, next);
   };
 }
+function requestContext(req, url) {
+  let parent = extractTrace(req.headers);
+  const id = req.id;
+  if (id !== void 0 && id !== null && id !== "") {
+    const traceId = String(id);
+    if (!parent || parent.traceId !== traceId) parent = { traceId, sampled: parent?.sampled ?? true };
+  }
+  const ctx = childContext(parent);
+  ctx.method = req.method;
+  ctx.url = url;
+  return ctx;
+}
 function defaultLevel(_req, res) {
   if (res.statusCode >= 500) return "error";
   if (res.statusCode >= 400) return "warn";
   return "info";
 }
-function toBuffer(chunk) {
+function toBuffer(chunk, encoding) {
   if (Buffer.isBuffer(chunk)) return chunk;
-  if (typeof chunk === "string") return Buffer.from(chunk);
+  if (chunk instanceof Uint8Array) return Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+  if (typeof chunk === "string") {
+    return typeof encoding === "string" && Buffer.isEncoding(encoding) ? Buffer.from(chunk, encoding) : Buffer.from(chunk);
+  }
   try {
     return Buffer.from(JSON.stringify(chunk));
   } catch {
     return Buffer.alloc(0);
   }
 }
-function readBuffer(chunks, max, contentType) {
-  if (chunks.length === 0) return void 0;
-  const buf = Buffer.concat(chunks);
-  if (buf.length === 0) return void 0;
-  if (buf.length > max) {
-    return `[TRUNCATED ${buf.length}B > ${max}B] ${buf.subarray(0, max).toString("utf8")}\u2026`;
+var BodyCapture = class {
+  constructor(max) {
+    this.max = max;
+  }
+  max;
+  chunks = [];
+  kept = 0;
+  total = 0;
+  add(chunk, encoding) {
+    if (!chunk || typeof chunk === "function") return;
+    try {
+      const buf = toBuffer(chunk, encoding);
+      this.total += buf.length;
+      const room = this.max + 1 - this.kept;
+      if (room <= 0) return;
+      const part = Buffer.from(buf.length > room ? buf.subarray(0, room) : buf);
+      this.chunks.push(part);
+      this.kept += part.length;
+    } catch {
+    }
+  }
+  bytes() {
+    return Buffer.concat(this.chunks);
+  }
+};
+function readBuffer(capture, max, contentType, redactKeys) {
+  if (capture.total === 0) return void 0;
+  const buf = capture.bytes();
+  if (capture.total > max) {
+    return `[TRUNCATED ${capture.total}B > ${max}B] ${buf.subarray(0, max).toString("utf8")}\u2026`;
   }
   const raw = buf.toString("utf8");
   const ct = contentType.toLowerCase();
   if (ct.includes("application/json")) {
     try {
-      return JSON.parse(raw);
+      return redactDeep(JSON.parse(raw), redactKeys);
     } catch {
       return raw;
     }
@@ -107,19 +325,25 @@ function redactHeaders(headers, redactKeys) {
   const out = {};
   for (const [k, v] of Object.entries(headers)) {
     if (v === void 0 || v === null) continue;
-    out[k] = redactKeys.includes(k.toLowerCase()) ? "[REDACTED]" : Array.isArray(v) ? v.join(", ") : String(v);
+    out[k] = isRedactedKey(k, redactKeys) ? "[REDACTED]" : Array.isArray(v) ? v.join(", ") : String(v);
   }
   return out;
 }
-function redactDeep(value, redactKeys) {
+function redactDeep(value, redactKeys, seen = /* @__PURE__ */ new WeakSet()) {
   if (value === null || value === void 0) return value;
   if (typeof value !== "object") return value;
-  if (Array.isArray(value)) return value.map((v) => redactDeep(v, redactKeys));
-  const out = {};
-  for (const [k, v] of Object.entries(value)) {
-    out[k] = redactKeys.includes(k.toLowerCase()) ? "[REDACTED]" : redactDeep(v, redactKeys);
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) return value.map((v) => redactDeep(v, redactKeys, seen));
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = isRedactedKey(k, redactKeys) ? "[REDACTED]" : redactDeep(v, redactKeys, seen);
+    }
+    return out;
+  } finally {
+    seen.delete(value);
   }
-  return out;
 }
 function trimUndefined(obj) {
   const out = {};

package/package.json

@@ -1,33 +1,54 @@
 {
   "name": "@fabbahiense/pulsar-pino-transport",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Pino transport for Pulsar observability platform + Express request logger middleware",
+  "author": "Fabrício Bahiense Santos",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     },
     "./middleware": {
-      "types": "./dist/middleware.d.ts",
-      "import": "./dist/middleware.js",
-      "require": "./dist/middleware.cjs"
+      "import": {
+        "types": "./dist/middleware.d.ts",
+        "default": "./dist/middleware.js"
+      },
+      "require": {
+        "types": "./dist/middleware.d.cts",
+        "default": "./dist/middleware.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "middleware": ["./dist/middleware.d.ts"]
     }
   },
-  "files": ["dist"],
+  "files": ["dist", "CHANGELOG.md"],
+  "sideEffects": false,
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",
-    "test": "node --test test/"
+    "pretest": "npm run build",
+    "test": "vitest run --coverage",
+    "prepublishOnly": "npm test"
   },
   "peerDependencies": {
     "pino-abstract-transport": ">=2.0.0"
   },
   "devDependencies": {
+    "pino": "10.3.1",
     "pino-abstract-transport": "^3.0.0",
     "tsup": "^8.0.0",
     "typescript": "^5.9.0"