@zintrust/trace 0.4.95 → 0.5.0

package/dist/build-manifest.json

@@ -1,14 +1,14 @@
 {
   "name": "@zintrust/trace",
-  "version": "0.4.95",
-  "buildDate": "2026-04-11T17:50:25.235Z",
+  "version": "0.5.0",
+  "buildDate": "2026-04-12T15:38:51.982Z",
   "buildEnvironment": {
     "node": "v22.22.1",
     "platform": "darwin",
     "arch": "arm64"
   },
   "git": {
-    "commit": "8f4c9f2f",
+    "commit": "d9f9cf02",
     "branch": "release"
   },
   "package": {
@@ -22,8 +22,8 @@
   },
   "files": {
     "build-manifest.json": {
-      "size": 14440,
-      "sha256": "cbd454ac88211f4242ab1d62b641b064452d5532792e5ecae7cbe2a49f4d652a"
+      "size": 14739,
+      "sha256": "ccb926d22667a613e35b97c316d5924b223b5522c5f7deab259d99343fe4c8d8"
     },
     "cli-register.d.ts": {
       "size": 255,
@@ -38,8 +38,8 @@
       "sha256": "b034cbef0c71fb868071363624ef7a9f8d7acc20f8be8c895dd5db5a75e81f37"
     },
     "config.js": {
-      "size": 5961,
-      "sha256": "1402cf8ad7c850da99e429c8c937385b7b5cf401fa3714d972d4e6bd94f1663e"
+      "size": 9272,
+      "sha256": "d23145038d47ce94a51394088b2b6a3138ec232802bde7bd521d347c9bdfb310"
     },
     "context.d.ts": {
       "size": 596,
@@ -54,8 +54,8 @@
       "sha256": "430f5b294d960e13e2ec39ed5c22f6655f85c46c2de9455c222505c67298ec6a"
     },
     "dashboard/handlers.js": {
-      "size": 5390,
-      "sha256": "a8644a932c2da07231098f9adc31cfca00727b448524107ce23ad87a239f53f3"
+      "size": 9192,
+      "sha256": "ebc592e84772b93c820c76f1834e1131a05c19df3bada7b75cf46bcd5f6732fc"
     },
     "dashboard/routes.d.ts": {
       "size": 997,
@@ -70,16 +70,16 @@
       "sha256": "4862b41e0477f01afa0dbb446d4553b65c22ed774cd1e2db3489059ced392f94"
     },
     "dashboard/ui.js": {
-      "size": 74630,
-      "sha256": "925ab75a6176dc4639d0772eda904f1401d73e866f0f0882450d9fd4e253ad89"
+      "size": 75051,
+      "sha256": "941c8647e778f67b8ab3f37b9272b914e5da4f35e07511ff1112287a0620b6da"
     },
     "index.d.ts": {
       "size": 2537,
       "sha256": "1707d26322dbad17f6bf85938ae6fe2477e84c7fed3333760ce8d6eadfaaffd2"
     },
     "index.js": {
-      "size": 3325,
-      "sha256": "3715aa0dca22638b15c2ec534e2463d7c82268e7648f75571c591d07edc9a0de"
+      "size": 3324,
+      "sha256": "8a10c92829328ecb61fadb66c54768b52d72956fb196ad9a0087ba1ad9b17cbd"
     },
     "migrations/20260331000001_create_zin_trace_entries_table.d.ts": {
       "size": 304,
@@ -150,8 +150,8 @@
       "sha256": "d899a615e6cf2a5eea51f6200347cb81fbaae11979b801859f57135083aaf85b"
     },
     "storage/TraceContentBudget.js": {
-      "size": 4022,
-      "sha256": "4b1d4f0ad7da15caeaa1f9fe8b4edcd3000b0000c5bdc270601cd6db2eedce2e"
+      "size": 5868,
+      "sha256": "020597ed8a44def06677b8f0ae3947f44cb8c53d03803a2cf214a831858288a7"
     },
     "storage/TraceContentRedaction.d.ts": {
       "size": 207,
@@ -194,8 +194,8 @@
       "sha256": "d916e8e3abb1b1087f6b184851b0e6265e53380d7857b008e745d566aad15d44"
     },
     "types.d.ts": {
-      "size": 8448,
-      "sha256": "de994120c04696e08afb428cff27a99fb2918f5c4277b8190b8fb3d36d139f0d"
+      "size": 8919,
+      "sha256": "4ff6c7c067fa9d16535e4356181a73325977c6813a13983ae9edb17c5fa3c466"
     },
     "types.js": {
       "size": 696,
@@ -222,8 +222,8 @@
       "sha256": "a7809e98f76b4e326262c26b0e43e278b1c50ac0b35fee145e3e6006357dc700"
     },
     "utils/entryFilter.js": {
-      "size": 3279,
-      "sha256": "0ce8c5955411194447a16bd79c2f0a33ba60f63b2bd010ac33772718f02f0124"
+      "size": 4123,
+      "sha256": "de2690c6e5852969083387b469fd2e12f10470c6eee81120154437cd8d8f3555"
     },
     "utils/familyHash.d.ts": {
       "size": 60,
@@ -322,12 +322,12 @@
       "sha256": "f318cdeec954ce0bba97be1dc11a6dff935b081e6b6a417c614be1934fa47f04"
     },
     "watchers/HttpClientWatcher.d.ts": {
-      "size": 333,
-      "sha256": "08ab7e213c489ecc4fdd3166d7a121b9a5220ff9cbae9841d4787d9a804e11ce"
+      "size": 346,
+      "sha256": "dfb13bba526d5338e4dcd7a5aa0f72a61a03d9e2f6a250250c0bb8f0054c9712"
     },
     "watchers/HttpClientWatcher.js": {
-      "size": 2414,
-      "sha256": "817c74e7a89bcd0c53c0344d713b422e0c9e51ec65e7b6c97f0c486116dda7a5"
+      "size": 5829,
+      "sha256": "3921cfb79cd5ff0da8af90ee66a5ad3b76a397e60df808885d6ecc84b5269810"
     },
     "watchers/HttpWatcher.d.ts": {
       "size": 96,

package/dist/config.js

@@ -12,15 +12,26 @@ const mergeStringLists = (base, override) => {
 const isObjectValue = (value) => {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 };
+const resolveEnabled = (base, override) => {
+    return override?.enabled ?? base?.enabled;
+};
+const hasMergedRuleValues = (include, exclude, enabled) => {
+    return include.length > 0 || exclude.length > 0 || enabled !== undefined;
+};
+const buildFilterRule = (input) => {
+    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, override) => {
     const include = mergeStringLists(base?.include ?? [], override?.include);
     const exclude = mergeStringLists(base?.exclude ?? [], override?.exclude);
-    if (include.length === 0 && exclude.length === 0)
+    const enabled = resolveEnabled(base, override);
+    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 = (base, override) => {
     if (override === undefined)
@@ -30,6 +41,72 @@ const mergeWatcherToggle = (base, override) => {
     const baseRule = isObjectValue(base) ? base : undefined;
     return mergeFilterRule(baseRule, override);
 };
+const resolveClientRequestCaptureFlags = (base, override) => {
+    return {
+        requestHeaders: override?.requestHeaders ?? base?.requestHeaders,
+        requestBody: override?.requestBody ?? base?.requestBody,
+        responseHeaders: override?.responseHeaders ?? base?.responseHeaders,
+        responseBody: override?.responseBody ?? base?.responseBody,
+    };
+};
+const hasClientRequestCaptureFlags = (flags) => {
+    return Object.values(flags).some((value) => value !== undefined);
+};
+const buildClientRequestCaptureRule = (mergedRule, flags) => {
+    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, override) => {
+    const mergedRule = mergeFilterRule(base, override);
+    const flags = resolveClientRequestCaptureFlags(base, override);
+    if (mergedRule === undefined && !hasClientRequestCaptureFlags(flags)) {
+        return undefined;
+    }
+    return buildClientRequestCaptureRule(mergedRule, flags);
+};
+const collectClientRequestSourceKeys = (base, override) => {
+    const overrideSources = override?.sources ?? {};
+    const sourceKeys = new Set([
+        ...Object.keys(isObjectValue(base) ? (base.sources ?? {}) : {}),
+        ...Object.keys(overrideSources),
+    ]);
+    return [...sourceKeys];
+};
+const mergeClientRequestSources = (base, override) => {
+    if (override === undefined)
+        return undefined;
+    const sources = {};
+    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, override) => {
+    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'];
 const mergeRequestWatcherToggle = (base, override) => {
     if (override === undefined)
@@ -70,7 +147,7 @@ const mergeWatchers = (base, override) => {
         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),
     };
 };
 const DEFAULTS = Object.freeze({

package/dist/dashboard/handlers.js

@@ -38,24 +38,127 @@ const getNumericQueryParam = (req, key) => {
     }
     return undefined;
 };
+const DEFAULT_PER_PAGE = 50;
+const MAX_PER_PAGE = 100;
+const DEFAULT_REQUEST_PER_PAGE = 25;
+const MAX_REQUEST_PER_PAGE = 50;
+const SUMMARY_TEXT_LIMIT = 280;
+const SUMMARY_ARRAY_LIMIT = 10;
+const truncateText = (value, limit = SUMMARY_TEXT_LIMIT) => value.length <= limit ? value : `${value.slice(0, Math.max(0, limit - 3))}...`;
+const compactValue = (value) => {
+    if (typeof value === 'string') {
+        return truncateText(value);
+    }
+    if (typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        value === null ||
+        value === undefined) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.slice(0, SUMMARY_ARRAY_LIMIT).map((item) => {
+            if (typeof item === 'string') {
+                return truncateText(item);
+            }
+            if (typeof item === 'number' || typeof item === 'boolean' || item === null) {
+                return item;
+            }
+            return '[complex]';
+        });
+    }
+    return undefined;
+};
+const pickCompactContent = (content, keys) => {
+    if (typeof content !== 'object' || content === null || Array.isArray(content)) {
+        return {};
+    }
+    const source = content;
+    const compact = {};
+    for (const key of keys) {
+        const value = compactValue(source[key]);
+        if (value !== undefined) {
+            compact[key] = value;
+        }
+    }
+    return compact;
+};
+const COMPACT_ENTRY_KEYS = {
+    request: [
+        'method',
+        'uri',
+        'responseStatus',
+        'duration',
+        'memory',
+        'middleware',
+        'hostname',
+        'userId',
+    ],
+    query: ['connection', 'sql', 'time', 'duration', 'slow', 'hash', 'hostname'],
+    exception: ['class', 'file', 'line', 'message', 'occurrences', 'hostname', 'userId'],
+    log: ['level', 'message', 'hostname'],
+    job: ['status', 'connection', 'queue', 'name', 'tries', 'timeout', 'hostname'],
+    cache: ['operation', 'key', 'hit', 'store', 'payloadLogged', 'ttl', 'duration', 'hostname'],
+    schedule: ['name', 'expression', 'status', 'duration', 'hostname'],
+    mail: ['to', 'subject', 'template', 'hostname'],
+    auth: ['event', 'userId', 'hostname'],
+    event: ['name', 'listenerCount', 'hostname'],
+    model: ['action', 'model', 'id', 'hostname'],
+    notification: ['channels', 'notifiable', 'notification', 'message', 'hostname'],
+    redis: ['command', 'duration', 'hostname'],
+    gate: ['ability', 'result', 'userId', 'subject', 'hostname'],
+    middleware: ['name', 'event', 'duration', 'hostname'],
+    command: ['name', 'exitCode', 'duration', 'hostname'],
+    batch: ['name', 'total', 'processed', 'failed', 'status', 'hostname'],
+    dump: ['file', 'line', 'hostname'],
+    view: ['template', 'duration', 'hostname'],
+    client_request: ['source', 'method', 'url', 'responseStatus', 'error', 'duration', 'hostname'],
+};
+const compactEntryContent = (entry) => pickCompactContent(entry.content, COMPACT_ENTRY_KEYS[entry.type]);
+const estimateContentBytes = (content) => {
+    try {
+        return new TextEncoder().encode(JSON.stringify(content)).length;
+    }
+    catch {
+        return undefined;
+    }
+};
+const compactListEntry = (entry) => ({
+    ...entry,
+    content: compactEntryContent(entry),
+    hasDetails: true,
+    contentBytes: estimateContentBytes(entry.content),
+});
+const resolvePerPage = (req, type) => {
+    const isRequestList = type === 'request';
+    const fallback = isRequestList ? DEFAULT_REQUEST_PER_PAGE : DEFAULT_PER_PAGE;
+    const limit = isRequestList ? MAX_REQUEST_PER_PAGE : MAX_PER_PAGE;
+    return Math.max(1, Math.min(qpInt(req, 'perPage', fallback), limit));
+};
 // ---------------------------------------------------------------------------
 // Entry handlers
 // ---------------------------------------------------------------------------
 export async function listEntries(req, res) {
     const storage = getStorage(res);
     if (storage !== null) {
+        const type = qp(req, 'type');
         const opts = {
-            type: qp(req, 'type'),
+            type,
             tag: qp(req, 'tag'),
             batchId: qp(req, 'batchId'),
             from: getNumericQueryParam(req, 'from'),
             to: getNumericQueryParam(req, 'to'),
-            page: qpInt(req, 'page', 1),
-            perPage: Math.min(qpInt(req, 'perPage', 50), 200),
+            page: Math.max(1, qpInt(req, 'page', 1)),
+            perPage: resolvePerPage(req, type),
         };
         try {
             const result = await storage.queryEntries(opts);
-            res.json({ ok: true, ...result, page: opts.page, perPage: opts.perPage });
+            res.json({
+                ok: true,
+                data: result.data.map(compactListEntry),
+                total: result.total,
+                page: opts.page,
+                perPage: opts.perPage,
+            });
         }
         catch (err) {
             res.setStatus(500).json({ error: err.message });

package/dist/dashboard/ui.js

@@ -35,6 +35,7 @@ const BRAND_SVG = `<svg width="120" height="120" viewBox="0 0 100 100" fill="non
 const SUN_ICON = `<svg viewBox="0 0 24 24" aria-hidden="true" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="4"></circle><path d="M12 2v2.2M12 19.8V22M4.93 4.93l1.56 1.56M17.51 17.51l1.56 1.56M2 12h2.2M19.8 12H22M4.93 19.07l1.56-1.56M17.51 6.49l1.56-1.56"></path></svg>`;
 const MOON_ICON = `<svg viewBox="0 0 24 24" aria-hidden="true" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 12.8A9 9 0 1 1 11.2 3a7 7 0 0 0 9.8 9.8z"></path></svg>`;
 const COPY_ICON = `<svg viewBox="0 0 24 24" aria-hidden="true" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect x="9" y="9" width="11" height="11" rx="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>`;
+const DISCLOSURE_ICON = `<svg viewBox="0 0 20 20" aria-hidden="true" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M7 4l6 6-6 6"></path></svg>`;
 const JSON_HIGHLIGHT_PATTERN = String.raw `("(?:\\u[\da-fA-F]{4}|\\[^u]|[^\\"])*")(?=\s*:)|(\s*:)|("(?:\\u[\da-fA-F]{4}|\\[^u]|[^\\"])*")|\btrue\b|\bfalse\b|\bnull\b|-?\d+(?:\.\d+)?(?:[eE][+\-]?\d+)?`;
 const SQL_HIGHLIGHT_PATTERN = String.raw `(\/\*[\s\S]*?\*\/|--.*$|'(?:''|[^'])*'|\x60[^\x60]+\x60|\b(?:select|from|where|insert|into|values|update|delete|join|left|right|inner|outer|on|and|or|limit|order|by|group|having|as|distinct|null|is|in|like|set|case|when|then|else|end|returning|union|all)\b|-?\d+(?:\.\d+)?)`;
 const encodeSvgDataUri = (svg) => {
@@ -131,6 +132,7 @@ const DASHBOARD_DOCUMENT = String.raw `<!DOCTYPE html>
     const SUN_ICON = __TRACE_SUN_ICON__;
     const MOON_ICON = __TRACE_MOON_ICON__;
     const COPY_ICON = __TRACE_COPY_ICON__;
+    const DISCLOSURE_ICON = __TRACE_DISCLOSURE_ICON__;
     const JSON_HIGHLIGHT_PATTERN = new RegExp(__TRACE_JSON_REGEX__, 'g');
     const SQL_HIGHLIGHT_PATTERN = new RegExp(__TRACE_SQL_REGEX__, 'gim');
     const ENTRY_TYPES = ['request','query','exception','log','job','cache','schedule','mail','auth','event','model','notification','redis','gate','middleware','command','batch','dump','view','client_request'];
@@ -645,6 +647,7 @@ const DASHBOARD_DOCUMENT = String.raw `<!DOCTYPE html>
           return [
             '<details class="trace-item trace-disclosure"' + (isInitiallyOpen ? ' open' : '') + '>',
             '<summary class="trace-item-head trace-summary">',
+            '<span class="trace-summary-icon">' + DISCLOSURE_ICON + '</span>',
             '<span class="trace-summary-main">',
             '<span><span class="' + typeClass(entry) + '">' + escapeHtml(entryTypeLabel(entry)) + '</span></span>',
             '<span class="trace-summary-copy">' + entrySummaryInlineHtml(entry) + '</span>',
@@ -1075,6 +1078,7 @@ const buildDashboardHtml = (basePath, projectName) => {
         .replace('__TRACE_SUN_ICON__', JSON.stringify(SUN_ICON))
         .replace('__TRACE_MOON_ICON__', JSON.stringify(MOON_ICON))
         .replace('__TRACE_COPY_ICON__', JSON.stringify(COPY_ICON))
+        .replace('__TRACE_DISCLOSURE_ICON__', JSON.stringify(DISCLOSURE_ICON))
         .replace('__TRACE_JSON_REGEX__', JSON.stringify(JSON_HIGHLIGHT_PATTERN))
         .replace('__TRACE_SQL_REGEX__', JSON.stringify(SQL_HIGHLIGHT_PATTERN))
         .replace('__TRACE_BASE_PATH_LABEL__', basePath)

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