@zintrust/trace 0.4.76 → 0.4.79

package/src/watchers/HttpWatcher.ts

@@ -7,7 +7,7 @@ import { TraceContext } from '../context';
 import type { ITraceConfig, ITraceWatcher, ITraceWatcherConfig, RequestContent } from '../types';
 import { EntryType } from '../types';
 import { AuthTag } from '../utils/authTag';
-import { redactHeaders, redactObject } from '../utils/redact';
+import { redactHeaders, redactObject, redactUnknown } from '../utils/redact';
 import { RequestFilter } from '../utils/requestFilter';
 
 const normalizeHeaders = (headers: IRequest['headers']): Record<string, string> => {
@@ -22,23 +22,132 @@ const normalizeHeaders = (headers: IRequest['headers']): Record<string, string>
   );
 };
 
+const normalizeHeaderValue = (value: string | string[]): string => {
+  return Array.isArray(value) ? value.join(', ') : value;
+};
+
+const resolveRequestPayload = (req: IRequest, config: ITraceConfig): unknown => {
+  const redactFields = [...config.redaction.keys, ...config.redaction.body];
+  const requestBody = typeof req.getBody === 'function' ? req.getBody() : req.body;
+
+  if (requestBody === undefined || requestBody === null) return {};
+  if (typeof requestBody === 'object') {
+    return redactObject(requestBody as Record<string, unknown>, redactFields);
+  }
+
+  return redactUnknown(requestBody, redactFields);
+};
+
+type ResponseCapture = {
+  headers: Record<string, string>;
+  body?: unknown;
+  restore(): void;
+};
+
+type RawResponseWithLifecycle = ReturnType<IResponse['getRaw']> & {
+  once?: (event: 'finish' | 'close', listener: () => void) => unknown;
+  off?: (event: 'finish' | 'close', listener: () => void) => unknown;
+};
+
+const registerCompletionHandler = (response: IResponse, onComplete: () => void): (() => void) => {
+  const raw: RawResponseWithLifecycle = response.getRaw();
+  if (typeof raw.once !== 'function') return () => undefined;
+
+  let completed = false;
+
+  const cleanup = (): void => {
+    if (typeof raw.off === 'function') {
+      raw.off('finish', markCompleted);
+      raw.off('close', markCompleted);
+    }
+  };
+
+  const markCompleted = (): void => {
+    if (completed) return;
+    completed = true;
+    cleanup();
+    onComplete();
+  };
+
+  raw.once('finish', markCompleted);
+  raw.once('close', markCompleted);
+
+  return cleanup;
+};
+
+const captureResponse = (response: IResponse, config: ITraceConfig): ResponseCapture => {
+  const headers: Record<string, string> = {};
+  const redactFields = [...config.redaction.keys, ...config.redaction.body];
+
+  const originalSetHeader = response.setHeader;
+  const originalJson = response.json;
+  const originalText = response.text;
+  const originalHtml = response.html;
+  const originalSend = response.send;
+
+  const capture: ResponseCapture = {
+    headers,
+    body: undefined,
+    restore(): void {
+      response.setHeader = originalSetHeader;
+      response.json = originalJson;
+      response.text = originalText;
+      response.html = originalHtml;
+      response.send = originalSend;
+    },
+  };
+
+  response.setHeader = function setHeader(name: string, value: string | string[]): IResponse {
+    headers[name] = normalizeHeaderValue(value);
+    return originalSetHeader.call(this, name, value);
+  };
+
+  response.json = function json(data: unknown): void {
+    capture.body = redactUnknown(data, redactFields);
+    originalJson.call(this, data);
+  };
+
+  response.text = function text(value: string): void {
+    capture.body = value;
+    originalText.call(this, value);
+  };
+
+  response.html = function html(value: string): void {
+    capture.body = value;
+    originalHtml.call(this, value);
+  };
+
+  response.send = function send(data: string | Buffer): void {
+    capture.body = typeof data === 'string' ? data : `[binary ${data.length} bytes]`;
+    originalSend.call(this, data);
+  };
+
+  return capture;
+};
+
 const buildEntry = (
   req: IRequest,
   res: IResponse,
   start: number,
-  config: ITraceConfig
+  config: ITraceConfig,
+  responseCapture: ResponseCapture
 ): RequestContent => {
-  const headers = redactHeaders(normalizeHeaders(req.headers), config.redaction.headers);
-
-  const payload = req.body ? redactObject(req.body, config.redaction.body) : {};
+  const headers = redactHeaders(normalizeHeaders(req.headers), [
+    ...config.redaction.keys,
+    ...config.redaction.headers,
+  ]);
 
   return {
     method: req.getMethod(),
     uri: req.getPath(),
     headers,
-    payload,
+    payload: resolveRequestPayload(req, config),
     responseStatus: res.getStatus(),
-    responseHeaders: {},
+    responseHeaders: redactHeaders(responseCapture.headers, [
+      ...config.redaction.keys,
+      ...config.redaction.headers,
+    ]),
+    responseBody: responseCapture.body,
     duration: Date.now() - start,
     memory: TraceContext.getMemory(),
     middleware: [],
@@ -68,24 +177,34 @@ export const HttpWatcher: ITraceWatcher = Object.freeze({
 
       const start = TraceContext.now();
       const batchId = TraceContext.getBatchId();
+      const responseCapture = captureResponse(response, config);
+      let didPersist = false;
 
-      await next();
+      const persistEntry = (): void => {
+        if (didPersist) return;
+        didPersist = true;
+
+        const content = buildEntry(request, response, start, config, responseCapture);
+        const tags = AuthTag.append([]);
+        if (content.responseStatus >= 500) tags.push('failed');
+
+        responseCapture.restore();
 
-      const content = buildEntry(request, response, start, config);
-      const tags = AuthTag.append([]);
-      if (content.responseStatus >= 500) tags.push('failed');
-
-      storage
-        .writeEntry({
-          uuid: crypto.randomUUID(),
-          batchId,
-          type: EntryType.REQUEST,
-          content,
-          tags,
-          isLatest: true,
-          createdAt: TraceContext.now(),
-        })
-        .catch(() => undefined); // fire-and-forget
+        storage
+          .writeEntry({
+            uuid: crypto.randomUUID(),
+            batchId,
+            type: EntryType.REQUEST,
+            content,
+            tags,
+            isLatest: true,
+            createdAt: TraceContext.now(),
+          })
+          .catch(() => undefined); // fire-and-forget
+      };
+
+      registerCompletionHandler(response, persistEntry);
+      await next();
     };
 
     registerMiddleware(middleware);

package/src/watchers/LogWatcher.ts

@@ -8,8 +8,6 @@ import { EntryType } from '../types';
 import { AuthTag } from '../utils/authTag';
 import { RequestFilter } from '../utils/requestFilter';
 
-type LoggerSink = (level: string, message: string, context?: Record<string, unknown>) => void;
-
 const LEVEL_PRIORITY: Record<string, number> = {
   debug: 0,
   info: 1,
@@ -24,37 +22,37 @@ export const LogWatcher: ITraceWatcher = Object.freeze({
 
     const minPriority = LEVEL_PRIORITY[config.logMinLevel] ?? 1;
 
-    const loggerWithSink = Logger as typeof Logger & {
-      addSink?: (fn: LoggerSink) => () => void;
-    };
+    const loggerWithSink = Logger;
 
     if (typeof loggerWithSink.addSink !== 'function') {
       return () => undefined;
     }
 
-    const unsubscribe = loggerWithSink.addSink((level, message, context) => {
-      if ((LEVEL_PRIORITY[level] ?? 0) < minPriority) return;
-      if (RequestFilter.shouldIgnoreCurrentRequest(config.ignoreRoutes)) return;
-
-      const content: LogContent = {
-        level,
-        message,
-        context: context ?? undefined,
-        hostname: TraceContext.getHostname(),
-      };
-
-      storage
-        .writeEntry({
-          uuid: crypto.randomUUID(),
-          batchId: TraceContext.getBatchId(),
-          type: EntryType.LOG,
-          content,
-          tags: AuthTag.append([]),
-          isLatest: true,
-          createdAt: TraceContext.now(),
-        })
-        .catch(() => undefined);
-    });
+    const unsubscribe = loggerWithSink.addSink(
+      (level: string, message: string, context?: Record<string, unknown>) => {
+        if ((LEVEL_PRIORITY[level] ?? 0) < minPriority) return;
+        if (RequestFilter.shouldIgnoreCurrentRequest(config.ignoreRoutes)) return;
+
+        const content: LogContent = {
+          level,
+          message,
+          context: context ?? undefined,
+          hostname: TraceContext.getHostname(),
+        };
+
+        storage
+          .writeEntry({
+            uuid: crypto.randomUUID(),
+            batchId: TraceContext.getBatchId(),
+            type: EntryType.LOG,
+            content,
+            tags: AuthTag.append([]),
+            isLatest: true,
+            createdAt: TraceContext.now(),
+          })
+          .catch(() => undefined);
+      }
+    );
 
     return unsubscribe;
   },