@zintrust/trace 0.4.94 → 0.4.96

package/dist/storage/TraceContentBudget.js

@@ -21,6 +21,58 @@ const describeValueType = (value) => {
         return 'null';
     return typeof value;
 };
+const chooseLargerCandidate = (left, right) => {
+    if (left === null)
+        return right;
+    if (right === null)
+        return left;
+    return right.size > left.size ? right : left;
+};
+const fallbackCandidate = (value, path) => {
+    return path.length === 0 ? null : { path, size: serializedSize(value) };
+};
+const findLargestDroppablePathInArray = (value, path) => {
+    let best = null;
+    for (const [index, item] of value.entries()) {
+        best = chooseLargerCandidate(best, findLargestDroppablePath(item, [...path, index]));
+    }
+    return best ?? fallbackCandidate(value, path);
+};
+const findLargestDroppablePathInObject = (value, path) => {
+    let best = null;
+    for (const [key, entryValue] of Object.entries(value)) {
+        if (key === '__traceNotice')
+            continue;
+        best = chooseLargerCandidate(best, findLargestDroppablePath(entryValue, [...path, key]));
+    }
+    return best ?? fallbackCandidate(value, path);
+};
+const findLargestDroppablePath = (value, path = []) => {
+    if (Array.isArray(value))
+        return findLargestDroppablePathInArray(value, path);
+    if (typeof value === 'object' && value !== null) {
+        return findLargestDroppablePathInObject(value, path);
+    }
+    return fallbackCandidate(value, path);
+};
+const replaceAtPath = (value, path, replacement) => {
+    if (path.length === 0)
+        return replacement;
+    const [segment, ...rest] = path;
+    if (Array.isArray(value) && typeof segment === 'number') {
+        const next = value.slice();
+        next[segment] = replaceAtPath(next[segment], rest, replacement);
+        return next;
+    }
+    if (typeof value === 'object' && value !== null && typeof segment === 'string') {
+        const current = value;
+        return {
+            ...current,
+            [segment]: replaceAtPath(current[segment], rest, replacement),
+        };
+    }
+    return value;
+};
 const compactValue = (value, depth) => {
     if (depth >= DEFAULT_MAX_DEPTH) {
         return DROPPED_FIELD_MESSAGE;
@@ -52,18 +104,18 @@ const compactValue = (value, depth) => {
     }
     return Object.fromEntries(compactedEntries);
 };
-const compactTopLevelObjectToBudget = (value) => {
-    const compacted = {
-        ...value,
-        __traceNotice: COMPACTED_CONTENT_MESSAGE,
-    };
-    const keysByDescendingSize = Object.keys(compacted)
-        .filter((key) => key !== '__traceNotice')
-        .sort((left, right) => serializedSize(compacted[right]) - serializedSize(compacted[left]));
-    for (const key of keysByDescendingSize) {
-        if (serializedSize(compacted) <= DEFAULT_MAX_ENTRY_BYTES)
+const compactStructuredValueToBudget = (value) => {
+    let compacted = typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? {
+            ...value,
+            __traceNotice: COMPACTED_CONTENT_MESSAGE,
+        }
+        : value;
+    while (serializedSize(compacted) > DEFAULT_MAX_ENTRY_BYTES) {
+        const candidate = findLargestDroppablePath(compacted);
+        if (candidate === null)
             break;
-        compacted[key] = DROPPED_FIELD_MESSAGE;
+        compacted = replaceAtPath(compacted, candidate.path, DROPPED_FIELD_MESSAGE);
     }
     return compacted;
 };
@@ -75,10 +127,10 @@ const fitContentToBudget = (content) => {
     if (serializedSize(compacted) <= DEFAULT_MAX_ENTRY_BYTES) {
         return compacted;
     }
-    if (typeof compacted === 'object' && compacted !== null && !Array.isArray(compacted)) {
-        const topLevelCompacted = compactTopLevelObjectToBudget(compacted);
-        if (serializedSize(topLevelCompacted) <= DEFAULT_MAX_ENTRY_BYTES) {
-            return topLevelCompacted;
+    if (typeof compacted === 'object' && compacted !== null) {
+        const budgetCompacted = compactStructuredValueToBudget(compacted);
+        if (serializedSize(budgetCompacted) <= DEFAULT_MAX_ENTRY_BYTES) {
+            return budgetCompacted;
         }
     }
     return {

package/dist/types.d.ts

@@ -189,6 +189,7 @@ export interface ViewContent {
     hostname: string;
 }
 export interface ClientRequestContent {
+    source?: string;
     method: string;
     url: string;
     requestHeaders: Record<string, string>;
@@ -201,6 +202,7 @@ export interface ClientRequestContent {
     hostname: string;
 }
 export interface ClientRequestTraceInput {
+    source?: string;
     method: string;
     url: string;
     requestHeaders: Record<string, string>;
@@ -268,6 +270,12 @@ export type TraceFilterRule = {
     include?: string[];
     exclude?: string[];
 };
+export type TraceClientRequestCaptureRule = TraceFilterRule & {
+    requestHeaders?: boolean;
+    requestBody?: boolean;
+    responseHeaders?: boolean;
+    responseBody?: boolean;
+};
 export type TraceRequestWatcherConfig = TraceFilterRule & {
     all?: TraceFilterRule;
     get?: TraceFilterRule;
@@ -276,8 +284,12 @@ export type TraceRequestWatcherConfig = TraceFilterRule & {
     patch?: TraceFilterRule;
     delete?: TraceFilterRule;
 };
+export type TraceClientRequestWatcherConfig = TraceClientRequestCaptureRule & {
+    sources?: Record<string, TraceClientRequestCaptureRule>;
+};
 export type TraceWatcherToggle = boolean | TraceFilterRule;
 export type TraceRequestWatcherToggle = boolean | TraceRequestWatcherConfig;
+export type TraceClientRequestWatcherToggle = boolean | TraceClientRequestWatcherConfig;
 export type WatcherToggles = {
     request?: TraceRequestWatcherToggle;
     query?: TraceWatcherToggle;
@@ -298,7 +310,7 @@ export type WatcherToggles = {
     batch?: TraceWatcherToggle;
     dump?: TraceWatcherToggle;
     view?: TraceWatcherToggle;
-    clientRequest?: TraceWatcherToggle;
+    clientRequest?: TraceClientRequestWatcherToggle;
 };
 export interface ITraceConfig {
     enabled: boolean;

package/dist/utils/entryFilter.js

@@ -13,6 +13,8 @@ const normalizeTerms = (terms) => {
 const matchesRule = (haystack, rule) => {
     if (!rule)
         return true;
+    if (rule.enabled === false)
+        return false;
     const include = normalizeTerms(rule.include);
     const exclude = normalizeTerms(rule.exclude);
     if (exclude.some((term) => haystack.includes(term)))
@@ -71,6 +73,16 @@ const getRequestMethodRule = (watcher, entry) => {
         return watcher.delete;
     return watcher.all;
 };
+const getClientRequestSourceRule = (watcher, entry) => {
+    if (entry.type !== EntryType.CLIENT_REQUEST)
+        return undefined;
+    const content = isObjectValue(entry.content) ? entry.content : undefined;
+    const sourceValue = content?.['source'];
+    const source = typeof sourceValue === 'string' ? sourceValue.trim().toLowerCase() : '';
+    if (source === '')
+        return undefined;
+    return watcher.sources?.[source];
+};
 export const TraceEntryFilter = Object.freeze({
     shouldCapture(entry, config) {
         const watcherKey = watcherKeyByEntryType[entry.type];
@@ -90,6 +102,14 @@ export const TraceEntryFilter = Object.freeze({
             if (!matchesRule(haystack, methodRule))
                 return false;
         }
+        if (watcherKey === 'clientRequest') {
+            const clientRequestWatcher = watcher;
+            const sourceRule = getClientRequestSourceRule(clientRequestWatcher, entry);
+            if (sourceRule?.enabled === false)
+                return false;
+            if (!matchesRule(haystack, sourceRule))
+                return false;
+        }
         return true;
     },
 });

package/dist/watchers/HttpClientWatcher.d.ts

@@ -1,5 +1,5 @@
 import type { ClientRequestTraceInput, ITraceWatcher } from '../types';
-declare const emit: ({ method, url, requestHeaders, responseStatus, duration, requestBody, responseHeaders, responseBody, error, }: ClientRequestTraceInput) => void;
+declare const emit: ({ source, method, url, requestHeaders, responseStatus, duration, requestBody, responseHeaders, responseBody, error, }: ClientRequestTraceInput) => void;
 export declare const HttpClientWatcher: ITraceWatcher & {
     emit: typeof emit;
 };

package/dist/watchers/HttpClientWatcher.js

@@ -7,32 +7,104 @@ let _storage = null;
 let _redactHeaderNames = [];
 let _redactBodyFields = [];
 let _ignoreRoutes = [];
-const emit = ({ method, url, requestHeaders, responseStatus, duration, requestBody, responseHeaders, responseBody, error, }) => {
+let _clientRequestWatcher;
+const isObjectValue = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+const resolveSource = (value) => {
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    return normalized === '' ? undefined : normalized;
+};
+const resolveSourceRule = (source) => {
+    if (source === undefined)
+        return undefined;
+    return _clientRequestWatcher?.sources?.[source];
+};
+const shouldCaptureField = (field, sourceRule) => {
+    const scoped = sourceRule?.[field];
+    if (typeof scoped === 'boolean')
+        return scoped;
+    const global = _clientRequestWatcher?.[field];
+    if (typeof global === 'boolean')
+        return global;
+    return true;
+};
+const buildRequestHeaders = (requestHeaders, sourceRule) => {
+    return shouldCaptureField('requestHeaders', sourceRule)
+        ? { requestHeaders: redactHeaders(requestHeaders, _redactHeaderNames) }
+        : { requestHeaders: {} };
+};
+const buildRequestBody = (requestBody, sourceRule) => {
+    if (requestBody === undefined)
+        return {};
+    if (!shouldCaptureField('requestBody', sourceRule))
+        return {};
+    return { requestBody: redactUnknown(requestBody, _redactBodyFields) };
+};
+const buildResponseHeaders = (responseHeaders, sourceRule) => {
+    if (responseHeaders === undefined)
+        return {};
+    if (!shouldCaptureField('responseHeaders', sourceRule))
+        return {};
+    return { responseHeaders: redactHeaders(responseHeaders, _redactHeaderNames) };
+};
+const buildResponseBody = (responseBody, sourceRule) => {
+    if (responseBody === undefined)
+        return {};
+    if (!shouldCaptureField('responseBody', sourceRule))
+        return {};
+    return { responseBody: redactUnknown(responseBody, _redactBodyFields) };
+};
+const buildClientRequestContent = (input, sourceRule, normalizedSource) => {
+    return {
+        ...(normalizedSource === undefined ? {} : { source: normalizedSource }),
+        method: input.method.toUpperCase(),
+        url: input.url,
+        ...buildRequestHeaders(input.requestHeaders, sourceRule),
+        ...buildRequestBody(input.requestBody, sourceRule),
+        ...(input.responseStatus === undefined ? {} : { responseStatus: input.responseStatus }),
+        ...buildResponseHeaders(input.responseHeaders, sourceRule),
+        ...buildResponseBody(input.responseBody, sourceRule),
+        ...(typeof input.error === 'string' && input.error !== '' ? { error: input.error } : {}),
+        duration: input.duration,
+        hostname: TraceContext.getHostname(),
+    };
+};
+const isWatcherEnabled = (value) => {
+    if (value === false)
+        return false;
+    if (isObjectValue(value) && value.enabled === false)
+        return false;
+    return true;
+};
+const emit = ({ source, method, url, requestHeaders, responseStatus, duration, requestBody, responseHeaders, responseBody, error, }) => {
     if (!_storage)
         return;
     if (RequestFilter.shouldIgnoreCurrentRequest(_ignoreRoutes))
         return;
+    const normalizedSource = resolveSource(source);
+    const sourceRule = resolveSourceRule(normalizedSource);
+    if (sourceRule?.enabled === false)
+        return;
     const tags = AuthTag.append([method.toUpperCase()]);
     if ((responseStatus ?? 0) >= 400 || error)
         tags.push('failed');
-    const content = {
-        method: method.toUpperCase(),
+    if (normalizedSource !== undefined)
+        tags.push(normalizedSource);
+    const content = buildClientRequestContent({
+        source,
+        method,
         url,
-        requestHeaders: redactHeaders(requestHeaders, _redactHeaderNames),
-        ...(requestBody === undefined
-            ? {}
-            : { requestBody: redactUnknown(requestBody, _redactBodyFields) }),
-        ...(responseStatus === undefined ? {} : { responseStatus }),
-        ...(responseHeaders === undefined
-            ? {}
-            : { responseHeaders: redactHeaders(responseHeaders, _redactHeaderNames) }),
-        ...(responseBody === undefined
-            ? {}
-            : { responseBody: redactUnknown(responseBody, _redactBodyFields) }),
-        ...(typeof error === 'string' && error !== '' ? { error } : {}),
+        requestHeaders,
+        responseStatus,
         duration,
-        hostname: TraceContext.getHostname(),
-    };
+        requestBody,
+        responseHeaders,
+        responseBody,
+        error,
+    }, sourceRule, normalizedSource);
     _storage
         .writeEntry({
         uuid: crypto.randomUUID(),
@@ -48,14 +120,19 @@ const emit = ({ method, url, requestHeaders, responseStatus, duration, requestBo
 export const HttpClientWatcher = Object.freeze({
     emit,
     register({ storage, config }) {
-        if (config.watchers.clientRequest === false)
+        if (!isWatcherEnabled(config.watchers.clientRequest))
             return () => undefined;
         _storage = storage;
+        _clientRequestWatcher =
+            typeof config.watchers.clientRequest === 'object' && config.watchers.clientRequest !== null
+                ? config.watchers.clientRequest
+                : undefined;
         _redactHeaderNames = [...(config.redaction?.keys ?? []), ...(config.redaction?.headers ?? [])];
         _redactBodyFields = [...(config.redaction?.keys ?? []), ...(config.redaction?.body ?? [])];
         _ignoreRoutes = config.ignoreRoutes;
         return () => {
             _storage = null;
+            _clientRequestWatcher = undefined;
             _redactBodyFields = [];
             _ignoreRoutes = [];
         };

package/dist/watchers/HttpWatcher.js

@@ -17,6 +17,12 @@ const normalizeHeaders = (headers) => {
 const normalizeHeaderValue = (value) => {
     return Array.isArray(value) ? value.join(', ') : value;
 };
+const resolveRouteMiddleware = (req) => {
+    const middleware = req.context?.['traceRouteMiddleware'];
+    return Array.isArray(middleware)
+        ? middleware.filter((value) => typeof value === 'string')
+        : [];
+};
 const resolveRequestPayload = (req, config) => {
     const redactFields = [...config.redaction.keys, ...config.redaction.body];
     const requestBody = typeof req.getBody === 'function' ? req.getBody() : req.body;
@@ -108,7 +114,7 @@ const buildEntry = (req, res, start, config, responseCapture) => {
         responseBody: responseCapture.body,
         duration: Date.now() - start,
         memory: TraceContext.getMemory(),
-        middleware: [],
+        middleware: resolveRouteMiddleware(req),
         hostname: TraceContext.getHostname(),
         userId: TraceContext.getUserId(),
     };

package/dist/watchers/MiddlewareWatcher.js

@@ -33,7 +33,12 @@ export const MiddlewareWatcher = Object.freeze({
             return () => undefined;
         _storage = storage;
         _ignoreRoutes = config.ignoreRoutes;
+        globalThis.__zintrust_trace_middleware_emit__ = emit;
         return () => {
+            const globalState = globalThis;
+            if (globalState.__zintrust_trace_middleware_emit__ === emit) {
+                delete globalState.__zintrust_trace_middleware_emit__;
+            }
             _storage = null;
             _ignoreRoutes = [];
         };

package/dist/watchers/ModelWatcher.js

@@ -34,7 +34,12 @@ export const ModelWatcher = Object.freeze({
             return () => undefined;
         _storage = storage;
         _ignoreRoutes = config.ignoreRoutes;
+        globalThis.__zintrust_trace_model_emit__ = emit;
         return () => {
+            const globalState = globalThis;
+            if (globalState.__zintrust_trace_model_emit__ === emit) {
+                delete globalState.__zintrust_trace_model_emit__;
+            }
             _storage = null;
             _ignoreRoutes = [];
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/trace",
-  "version": "0.4.94",
+  "version": "0.4.96",
   "description": "Trace assistant for ZinTrust: logs requests, queries, exceptions, jobs, and more.",
   "private": false,
   "type": "module",
@@ -40,7 +40,7 @@
     "node": ">=20.0.0"
   },
   "peerDependencies": {
-    "@zintrust/core": "^0.4.93"
+    "@zintrust/core": "^0.4.95"
   },
   "publishConfig": {
     "access": "public"

package/src/config.ts

@@ -3,6 +3,8 @@
  */
 import type {
   ITraceConfig,
+  TraceClientRequestCaptureRule,
+  TraceClientRequestWatcherToggle,
   TraceConfigOverrides,
   TraceFilterRule,
   TraceRequestWatcherConfig,
@@ -25,19 +27,44 @@ const isObjectValue = (value: unknown): value is Record<string, unknown> => {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 };
 
+const resolveEnabled = (
+  base?: TraceFilterRule,
+  override?: TraceFilterRule
+): boolean | undefined => {
+  return override?.enabled ?? base?.enabled;
+};
+
+const hasMergedRuleValues = (
+  include: string[],
+  exclude: string[],
+  enabled: boolean | undefined
+): boolean => {
+  return include.length > 0 || exclude.length > 0 || enabled !== undefined;
+};
+
+const buildFilterRule = (input: {
+  include: string[];
+  exclude: string[];
+  enabled: boolean | undefined;
+}): TraceFilterRule => {
+  return Object.freeze({
+    ...(input.enabled === undefined ? {} : { enabled: input.enabled }),
+    ...(input.include.length > 0 ? { include: input.include } : {}),
+    ...(input.exclude.length > 0 ? { exclude: input.exclude } : {}),
+  });
+};
+
 const mergeFilterRule = (
   base?: TraceFilterRule,
   override?: TraceFilterRule
 ): TraceFilterRule | undefined => {
   const include = mergeStringLists(base?.include ?? [], override?.include);
   const exclude = mergeStringLists(base?.exclude ?? [], override?.exclude);
+  const enabled = resolveEnabled(base, override);
 
-  if (include.length === 0 && exclude.length === 0) return undefined;
+  if (!hasMergedRuleValues(include, exclude, enabled)) return undefined;
 
-  return Object.freeze({
-    ...(include.length > 0 ? { include } : {}),
-    ...(exclude.length > 0 ? { exclude } : {}),
-  });
+  return buildFilterRule({ include, exclude, enabled });
 };
 
 const mergeWatcherToggle = (
@@ -51,6 +78,109 @@ const mergeWatcherToggle = (
   return mergeFilterRule(baseRule, override);
 };
 
+type ClientRequestCaptureFlags = Pick<
+  TraceClientRequestCaptureRule,
+  'requestHeaders' | 'requestBody' | 'responseHeaders' | 'responseBody'
+>;
+
+const resolveClientRequestCaptureFlags = (
+  base?: TraceClientRequestCaptureRule,
+  override?: TraceClientRequestCaptureRule
+): ClientRequestCaptureFlags => {
+  return {
+    requestHeaders: override?.requestHeaders ?? base?.requestHeaders,
+    requestBody: override?.requestBody ?? base?.requestBody,
+    responseHeaders: override?.responseHeaders ?? base?.responseHeaders,
+    responseBody: override?.responseBody ?? base?.responseBody,
+  };
+};
+
+const hasClientRequestCaptureFlags = (flags: ClientRequestCaptureFlags): boolean => {
+  return Object.values(flags).some((value) => value !== undefined);
+};
+
+const buildClientRequestCaptureRule = (
+  mergedRule: TraceFilterRule | undefined,
+  flags: ClientRequestCaptureFlags
+): TraceClientRequestCaptureRule => {
+  const baseRule = mergedRule ? { ...mergedRule } : {};
+
+  return Object.freeze({
+    ...baseRule,
+    ...(flags.requestHeaders === undefined ? {} : { requestHeaders: flags.requestHeaders }),
+    ...(flags.requestBody === undefined ? {} : { requestBody: flags.requestBody }),
+    ...(flags.responseHeaders === undefined ? {} : { responseHeaders: flags.responseHeaders }),
+    ...(flags.responseBody === undefined ? {} : { responseBody: flags.responseBody }),
+  });
+};
+
+const mergeClientRequestCaptureRule = (
+  base?: TraceClientRequestCaptureRule,
+  override?: TraceClientRequestCaptureRule
+): TraceClientRequestCaptureRule | undefined => {
+  const mergedRule = mergeFilterRule(base, override);
+  const flags = resolveClientRequestCaptureFlags(base, override);
+
+  if (mergedRule === undefined && !hasClientRequestCaptureFlags(flags)) {
+    return undefined;
+  }
+
+  return buildClientRequestCaptureRule(mergedRule, flags);
+};
+
+const collectClientRequestSourceKeys = (
+  base?: TraceClientRequestWatcherToggle,
+  override?: Exclude<TraceClientRequestWatcherToggle, boolean>
+): string[] => {
+  const overrideSources = override?.sources ?? {};
+  const sourceKeys = new Set<string>([
+    ...Object.keys(isObjectValue(base) ? base.sources ?? {} : {}),
+    ...Object.keys(overrideSources),
+  ]);
+
+  return [...sourceKeys];
+};
+
+const mergeClientRequestSources = (
+  base?: TraceClientRequestWatcherToggle,
+  override?: Exclude<TraceClientRequestWatcherToggle, boolean>
+): Record<string, TraceClientRequestCaptureRule> | undefined => {
+  if (override === undefined) return undefined;
+
+  const sources: Record<string, TraceClientRequestCaptureRule> = {};
+
+  for (const key of collectClientRequestSourceKeys(base, override)) {
+    const baseSources = isObjectValue(base) ? base.sources : undefined;
+    const sourceRule = mergeClientRequestCaptureRule(baseSources?.[key], override.sources?.[key]);
+    if (sourceRule !== undefined) {
+      sources[key] = sourceRule;
+    }
+  }
+
+  return Object.keys(sources).length === 0 ? undefined : sources;
+};
+
+const mergeClientRequestWatcherToggle = (
+  base?: TraceClientRequestWatcherToggle,
+  override?: TraceClientRequestWatcherToggle
+): TraceClientRequestWatcherToggle | undefined => {
+  if (override === undefined) return base;
+  if (override === false || override === true) return override;
+
+  const baseConfig = isObjectValue(base) ? base : undefined;
+  const merged = mergeClientRequestCaptureRule(baseConfig, override) ?? {};
+  const sources = mergeClientRequestSources(base, override);
+
+  if (sources === undefined) {
+    return merged;
+  }
+
+  return Object.freeze({
+    ...merged,
+    sources,
+  });
+};
+
 const REQUEST_METHOD_KEYS = ['all', 'get', 'post', 'put', 'patch', 'delete'] as const;
 
 const mergeRequestWatcherToggle = (
@@ -99,7 +229,7 @@ const mergeWatchers = (
     batch: mergeWatcherToggle(base.batch, override.batch),
     dump: mergeWatcherToggle(base.dump, override.dump),
     view: mergeWatcherToggle(base.view, override.view),
-    clientRequest: mergeWatcherToggle(base.clientRequest, override.clientRequest),
+    clientRequest: mergeClientRequestWatcherToggle(base.clientRequest, override.clientRequest),
   };
 };