@zintrust/trace 0.4.75 → 0.4.77

package/dist/migrations/{20260331000003_create_zin_debugger_monitoring_table.js → 20260331000003_create_zin_trace_monitoring_table.js}

@@ -1,17 +1,17 @@
 /**
- * Migration: CreateZinDebuggerMonitoringTable
- * Creates the tag watchlist table for @zintrust/system-debugger
+ * Migration: CreateZinTraceMonitoringTable
+ * Creates the tag watchlist table for @zintrust/trace
  */
 import { MigrationSchema } from '@zintrust/core';
 export const migration = {
     async up(db) {
         const schema = MigrationSchema.create(db);
-        await schema.create('zin_debugger_monitoring', (table) => {
+        await schema.create('zin_trace_monitoring', (table) => {
             table.string('tag').primary();
         });
     },
     async down(db) {
         const schema = MigrationSchema.create(db);
-        await schema.dropIfExists('zin_debugger_monitoring');
+        await schema.dropIfExists('zin_trace_monitoring');
     },
 };

package/dist/migrations/20260407193000_widen_trace_created_at_for_sql.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Migration: WidenTraceCreatedAtForSql
+ * Ensures SQL engines that treat INTEGER as 32-bit can store millisecond timestamps.
+ */
+import { type IDatabase } from '@zintrust/core';
+export interface Migration {
+    up(db: IDatabase): Promise<void>;
+    down(db: IDatabase): Promise<void>;
+}
+export declare const migration: Migration;

package/dist/migrations/20260407193000_widen_trace_created_at_for_sql.js

@@ -0,0 +1,34 @@
+/**
+ * Migration: WidenTraceCreatedAtForSql
+ * Ensures SQL engines that treat INTEGER as 32-bit can store millisecond timestamps.
+ */
+import { MigrationSchema } from '@zintrust/core';
+const alterCreatedAt = async (db) => {
+    const driver = db.getType?.() ?? 'sqlite';
+    if (driver === 'sqlite' || driver === 'd1' || driver === 'd1-remote')
+        return;
+    const schema = MigrationSchema.create(db);
+    if (!(await schema.hasTable('zin_trace_entries')))
+        return;
+    if (!(await schema.hasColumn('zin_trace_entries', 'created_at')))
+        return;
+    if (driver === 'mysql') {
+        await db.query('ALTER TABLE zin_trace_entries MODIFY COLUMN created_at BIGINT UNSIGNED NOT NULL', []);
+        return;
+    }
+    if (driver === 'postgresql') {
+        await db.query('ALTER TABLE zin_trace_entries ALTER COLUMN created_at TYPE BIGINT USING created_at::bigint', []);
+        return;
+    }
+    if (driver === 'sqlserver') {
+        await db.query('ALTER TABLE zin_trace_entries ALTER COLUMN created_at BIGINT NOT NULL', []);
+    }
+};
+export const migration = {
+    async up(db) {
+        await alterCreatedAt(db);
+    },
+    async down(_db) {
+        return;
+    },
+};

package/dist/migrations/index.d.ts

@@ -1,6 +1,6 @@
 /**
- * Migrations index for @zintrust/system-debugger
+ * Migrations index for @zintrust/trace
  * Export all migrations as an ordered array.
  */
-export type { Migration } from './20260331000001_create_zin_debugger_entries_table';
-export declare const migrations: import("./20260331000001_create_zin_debugger_entries_table").Migration[];
+export type { Migration } from './20260331000001_create_zin_trace_entries_table';
+export declare const migrations: import("./20260331000001_create_zin_trace_entries_table").Migration[];

package/dist/migrations/index.js

@@ -1,4 +1,5 @@
-import { migration as createEntries } from './20260331000001_create_zin_debugger_entries_table.js';
-import { migration as createEntriesTags } from './20260331000002_create_zin_debugger_entries_tags_table.js';
-import { migration as createMonitoring } from './20260331000003_create_zin_debugger_monitoring_table.js';
-export const migrations = [createEntries, createEntriesTags, createMonitoring];
+import { migration as createEntries } from './20260331000001_create_zin_trace_entries_table.js';
+import { migration as createEntriesTags } from './20260331000002_create_zin_trace_entries_tags_table.js';
+import { migration as createMonitoring } from './20260331000003_create_zin_trace_monitoring_table.js';
+import { migration as widenCreatedAt } from './20260407193000_widen_trace_created_at_for_sql.js';
+export const migrations = [createEntries, createEntriesTags, createMonitoring, widenCreatedAt];

package/dist/register.js

@@ -19,9 +19,12 @@
  *     middleware: ['admin'],
  *   });
  */
-import { TraceConfig } from './config';
-import { TraceContext } from './context';
-import { TraceStorage } from './storage';
+import { TraceConfig } from './config.js';
+import { TraceContext } from './context.js';
+import { TraceStorage } from './storage/index.js';
+import { TraceContentRedaction } from './storage/TraceContentRedaction.js';
+import { TraceEntryFiltering } from './storage/TraceEntryFiltering.js';
+import { TraceWriteDiagnostics } from './storage/TraceWriteDiagnostics.js';
 const globalTraceRegisterState = globalThis;
 globalTraceRegisterState.__zintrust_system_trace_plugin_requested__ = true;
 const traceAlreadyInitialized = globalTraceRegisterState.__zintrust_system_trace_register_initialized__ === true;
@@ -61,49 +64,144 @@ const resolveTraceConnectionName = (env, configuredConnection) => {
     }
     return resolveDefaultConnection();
 };
+const isObjectValue = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+const parseEnvList = (rawValue) => {
+    const value = rawValue.trim();
+    if (value === '')
+        return undefined;
+    if (value.startsWith('[')) {
+        try {
+            const parsed = JSON.parse(value);
+            if (Array.isArray(parsed)) {
+                return parsed
+                    .filter((entry) => typeof entry === 'string')
+                    .map((entry) => entry.trim())
+                    .filter((entry) => entry !== '');
+            }
+        }
+        catch {
+            // fall through to CSV parsing
+        }
+    }
+    return value
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter((entry) => entry !== '');
+};
+const resolveTraceStartupOverrides = (core) => {
+    const traceConfigFile = core.StartupConfigFile?.Trace;
+    if (typeof traceConfigFile !== 'string' || traceConfigFile.trim() === '')
+        return undefined;
+    const overrides = core.StartupConfigFileRegistry?.get(traceConfigFile);
+    return isObjectValue(overrides) ? overrides : undefined;
+};
+const buildTraceRedactionOverrides = (input) => {
+    const redaction = {
+        ...(isObjectValue(input.startupOverrides?.redaction) ? input.startupOverrides?.redaction : {}),
+    };
+    if (input.redactionKeys === undefined) {
+        // no-op
+    }
+    else {
+        redaction.keys = input.redactionKeys;
+    }
+    if (input.redactionHeaders === undefined) {
+        // no-op
+    }
+    else {
+        redaction.headers = input.redactionHeaders;
+    }
+    if (input.redactionBody === undefined) {
+        // no-op
+    }
+    else {
+        redaction.body = input.redactionBody;
+    }
+    if (input.redactionQuery === undefined) {
+        // no-op
+    }
+    else {
+        redaction.query = input.redactionQuery;
+    }
+    return Object.keys(redaction).length > 0
+        ? redaction
+        : undefined;
+};
 const core = (await importCore());
 const Env = core.Env;
+const startupOverrides = resolveTraceStartupOverrides(core);
 if (!traceAlreadyInitialized && Env) {
-    const enabled = Env.getBool('TRACE_ENABLED', false);
+    const enabled = startupOverrides?.enabled === true || Env.getBool('TRACE_ENABLED', false);
     if (enabled) {
-        const connection = Env.get('TRACE_DB_CONNECTION', '') || undefined;
-        const pruneAfterHours = Env.getInt('TRACE_PRUNE_HOURS', 24);
-        const slowQueryThreshold = Env.getInt('TRACE_SLOW_QUERY_MS', 100);
-        const logMinLevel = Env.get('TRACE_LOG_LEVEL', 'info');
+        const connectionRaw = Env.get('TRACE_DB_CONNECTION', '').trim();
+        const pruneAfterHoursRaw = Env.get('TRACE_PRUNE_HOURS', '').trim();
+        const slowQueryThresholdRaw = Env.get('TRACE_SLOW_QUERY_MS', '').trim();
+        const logMinLevelRaw = Env.get('TRACE_LOG_LEVEL', '').trim();
+        const redactionKeys = parseEnvList(Env.get('TRACE_REDACT_KEYS', ''));
+        const redactionHeaders = parseEnvList(Env.get('TRACE_REDACT_HEADERS', ''));
+        const redactionBody = parseEnvList(Env.get('TRACE_REDACT_BODY', ''));
+        const redactionQuery = parseEnvList(Env.get('TRACE_REDACT_QUERY', ''));
+        const connection = connectionRaw === '' ? startupOverrides?.connection : connectionRaw;
+        const pruneAfterHours = pruneAfterHoursRaw === ''
+            ? startupOverrides?.pruneAfterHours
+            : Number.parseInt(pruneAfterHoursRaw, 10);
+        const slowQueryThreshold = slowQueryThresholdRaw === ''
+            ? startupOverrides?.slowQueryThreshold
+            : Number.parseInt(slowQueryThresholdRaw, 10);
+        const logMinLevel = (logMinLevelRaw === '' ? startupOverrides?.logMinLevel : logMinLevelRaw);
+        const redaction = buildTraceRedactionOverrides({
+            startupOverrides,
+            redactionBody,
+            redactionHeaders,
+            redactionKeys,
+            redactionQuery,
+        });
         const config = TraceConfig.merge({
+            ...startupOverrides,
             enabled,
             connection,
-            pruneAfterHours,
-            slowQueryThreshold,
+            ...(typeof pruneAfterHours === 'number' && Number.isFinite(pruneAfterHours)
+                ? { pruneAfterHours }
+                : {}),
+            ...(typeof slowQueryThreshold === 'number' && Number.isFinite(slowQueryThreshold)
+                ? { slowQueryThreshold }
+                : {}),
             logMinLevel,
+            ...(redaction === undefined ? {} : { redaction }),
         });
-        const db = core.useDatabase?.(undefined, resolveTraceConnectionName(Env, connection));
+        const resolvedConnectionName = resolveTraceConnectionName(Env, config.connection);
+        const db = core.useDatabase?.(undefined, resolvedConnectionName);
         if (db) {
-            const storage = TraceStorage.resolveStorage(db);
+            const storage = TraceWriteDiagnostics.wrapStorage(TraceContentRedaction.wrapStorage(TraceEntryFiltering.wrapStorage(TraceStorage.resolveStorage(db), config), config.redaction), {
+                connectionName: resolvedConnectionName,
+                logger: core.Logger,
+            });
             if (core.RequestContext) {
                 TraceContext.setRequestContextImpl(core.RequestContext);
             }
             const [{ HttpWatcher }, { QueryWatcher }, { LogWatcher }, { ExceptionWatcher }, { JobWatcher }, { CacheWatcher }, { ScheduleWatcher }, { MailWatcher }, { AuthWatcher }, { EventWatcher }, { ModelWatcher }, { NotificationWatcher }, { RedisWatcher }, { GateWatcher }, { MiddlewareWatcher }, { CommandWatcher }, { BatchWatcher }, { DumpWatcher }, { ViewWatcher }, { HttpClientWatcher },] = await Promise.all([
-                import('./watchers/HttpWatcher'),
-                import('./watchers/QueryWatcher'),
-                import('./watchers/LogWatcher'),
-                import('./watchers/ExceptionWatcher'),
-                import('./watchers/JobWatcher'),
-                import('./watchers/CacheWatcher'),
-                import('./watchers/ScheduleWatcher'),
-                import('./watchers/MailWatcher'),
-                import('./watchers/AuthWatcher'),
-                import('./watchers/EventWatcher'),
-                import('./watchers/ModelWatcher'),
-                import('./watchers/NotificationWatcher'),
-                import('./watchers/RedisWatcher'),
-                import('./watchers/GateWatcher'),
-                import('./watchers/MiddlewareWatcher'),
-                import('./watchers/CommandWatcher'),
-                import('./watchers/BatchWatcher'),
-                import('./watchers/DumpWatcher'),
-                import('./watchers/ViewWatcher'),
-                import('./watchers/HttpClientWatcher'),
+                import('./watchers/HttpWatcher.js'),
+                import('./watchers/QueryWatcher.js'),
+                import('./watchers/LogWatcher.js'),
+                import('./watchers/ExceptionWatcher.js'),
+                import('./watchers/JobWatcher.js'),
+                import('./watchers/CacheWatcher.js'),
+                import('./watchers/ScheduleWatcher.js'),
+                import('./watchers/MailWatcher.js'),
+                import('./watchers/AuthWatcher.js'),
+                import('./watchers/EventWatcher.js'),
+                import('./watchers/ModelWatcher.js'),
+                import('./watchers/NotificationWatcher.js'),
+                import('./watchers/RedisWatcher.js'),
+                import('./watchers/GateWatcher.js'),
+                import('./watchers/MiddlewareWatcher.js'),
+                import('./watchers/CommandWatcher.js'),
+                import('./watchers/BatchWatcher.js'),
+                import('./watchers/DumpWatcher.js'),
+                import('./watchers/ViewWatcher.js'),
+                import('./watchers/HttpClientWatcher.js'),
             ]);
             const watcherArgs = { storage, config, db };
             HttpWatcher.register({ ...watcherArgs, registerMiddleware: resolveRegisterMiddleware() });

package/dist/storage/DebuggerStorage.js

@@ -1,4 +1,4 @@
-import { familyHash } from '../utils/familyHash';
+import { familyHash } from '../utils/familyHash.js';
 const TABLE_ENTRIES = 'zin_trace_entries';
 const TABLE_TAGS = 'zin_trace_entries_tags';
 const TABLE_MONITORING = 'zin_trace_monitoring';

package/dist/storage/TraceContentRedaction.d.ts

@@ -0,0 +1,4 @@
+import type { ITraceStorage, RedactionConfig } from '../types';
+export declare const TraceContentRedaction: Readonly<{
+    wrapStorage(storage: ITraceStorage, redaction: RedactionConfig): ITraceStorage;
+}>;

package/dist/storage/TraceContentRedaction.js

@@ -0,0 +1,33 @@
+import { redactUnknown } from '../utils/redact.js';
+const collectRedactionFields = (redaction) => {
+    return [
+        ...new Set([...redaction.keys, ...redaction.headers, ...redaction.body, ...redaction.query]),
+    ];
+};
+const redactTraceEntry = (entry, redaction) => {
+    return {
+        ...entry,
+        content: redactUnknown(entry.content, collectRedactionFields(redaction)),
+    };
+};
+const redactTracePatch = (patch, redaction) => {
+    if (patch.content === undefined)
+        return patch;
+    return {
+        ...patch,
+        content: redactUnknown(patch.content, collectRedactionFields(redaction)),
+    };
+};
+export const TraceContentRedaction = Object.freeze({
+    wrapStorage(storage, redaction) {
+        return Object.freeze({
+            ...storage,
+            writeEntry: async (entry) => {
+                await storage.writeEntry(redactTraceEntry(entry, redaction));
+            },
+            updateEntry: async (uuid, patch) => {
+                await storage.updateEntry(uuid, redactTracePatch(patch, redaction));
+            },
+        });
+    },
+});

package/dist/storage/TraceEntryFiltering.d.ts

@@ -0,0 +1,4 @@
+import type { ITraceConfig, ITraceStorage } from '../types';
+export declare const TraceEntryFiltering: Readonly<{
+    wrapStorage(storage: ITraceStorage, config: ITraceConfig): ITraceStorage;
+}>;

package/dist/storage/TraceEntryFiltering.js

@@ -0,0 +1,13 @@
+import { TraceEntryFilter } from '../utils/entryFilter.js';
+export const TraceEntryFiltering = Object.freeze({
+    wrapStorage(storage, config) {
+        return Object.freeze({
+            ...storage,
+            async writeEntry(entry) {
+                if (!TraceEntryFilter.shouldCapture(entry, config))
+                    return;
+                await storage.writeEntry(entry);
+            },
+        });
+    },
+});

package/dist/storage/TraceStorage.js

@@ -1,8 +1,40 @@
-import { familyHash } from '../utils/familyHash';
+import { familyHash } from '../utils/familyHash.js';
 const TABLE_ENTRIES = 'zin_trace_entries';
 const TABLE_TAGS = 'zin_trace_entries_tags';
 const TABLE_MONITORING = 'zin_trace_monitoring';
 const generateUuid = () => crypto.randomUUID();
+const buildIgnoreInsert = (db, table, columns, conflictColumns) => {
+    const columnList = columns.join(', ');
+    const placeholders = columns.map(() => '?').join(', ');
+    const driver = db.getType?.() ?? 'sqlite';
+    if (driver === 'sqlite' || driver === 'd1' || driver === 'd1-remote') {
+        return `INSERT OR IGNORE INTO ${table} (${columnList}) VALUES (${placeholders})`;
+    }
+    if (driver === 'mysql') {
+        return `INSERT IGNORE INTO ${table} (${columnList}) VALUES (${placeholders})`;
+    }
+    if (driver === 'postgresql') {
+        return `INSERT INTO ${table} (${columnList}) VALUES (${placeholders}) ON CONFLICT (${conflictColumns.join(', ')}) DO NOTHING`;
+    }
+    if (driver === 'sqlserver') {
+        const sourceColumns = columns.map((_, index) => `v${index + 1}`);
+        const selectClause = sourceColumns.map((name) => `? AS ${name}`).join(', ');
+        const conflictClause = conflictColumns
+            .map((column) => `target.${column} = source.${column}`)
+            .join(' AND ');
+        const insertValues = columns.map((column) => `source.${column}`).join(', ');
+        const sourceProjection = columns
+            .map((column, index) => `${sourceColumns[index]} AS ${column}`)
+            .join(', ');
+        return [
+            `MERGE INTO ${table} WITH (HOLDLOCK) AS target`,
+            `USING (SELECT ${sourceProjection} FROM (SELECT ${selectClause}) seed) AS source`,
+            `ON ${conflictClause}`,
+            `WHEN NOT MATCHED THEN INSERT (${columnList}) VALUES (${insertValues});`,
+        ].join(' ');
+    }
+    return `INSERT INTO ${table} (${columnList}) VALUES (${placeholders})`;
+};
 const rowToEntry = (row, tags) => ({
     uuid: row.uuid,
     batchId: row.batch_id,
@@ -16,11 +48,9 @@ const rowToEntry = (row, tags) => ({
 const insertTags = async (db, uuid, tags) => {
     if (tags.length === 0)
         return;
+    const sql = buildIgnoreInsert(db, TABLE_TAGS, ['entry_uuid', 'tag'], ['entry_uuid', 'tag']);
     await Promise.all(tags.map(async (tag) => {
-        await db.execute(`INSERT OR IGNORE INTO ${TABLE_TAGS} (entry_uuid, tag) VALUES (?, ?)`, [
-            uuid,
-            tag,
-        ]);
+        await db.execute(sql, [uuid, tag]);
     }));
 };
 const buildEntryFilters = (opts) => {
@@ -158,7 +188,7 @@ const createStorage = (db) => {
         return rows.map((row) => row.tag);
     };
     const addMonitoring = async (tag) => {
-        await db.execute(`INSERT OR IGNORE INTO ${TABLE_MONITORING} (tag) VALUES (?)`, [tag]);
+        await db.execute(buildIgnoreInsert(db, TABLE_MONITORING, ['tag'], ['tag']), [tag]);
     };
     const removeMonitoring = async (tag) => {
         await db.execute(`DELETE FROM ${TABLE_MONITORING} WHERE tag = ?`, [tag]);

package/dist/storage/TraceWriteDiagnostics.d.ts

@@ -0,0 +1,19 @@
+import type { ITraceStorage } from '../types';
+type TraceLogger = {
+    warn: (message: string, context?: Record<string, unknown>) => void;
+};
+type TraceWriteDiagnosticsSnapshot = {
+    degraded: boolean;
+    lastErrorMessage: string | null;
+    lastFailureAt: number | null;
+    totalFailures: number;
+};
+export declare const TraceWriteDiagnostics: Readonly<{
+    getSnapshot(): TraceWriteDiagnosticsSnapshot;
+    reset(): void;
+    wrapStorage(storage: ITraceStorage, options: {
+        connectionName: string;
+        logger?: TraceLogger;
+    }): ITraceStorage;
+}>;
+export {};

package/dist/storage/TraceWriteDiagnostics.js

@@ -0,0 +1,98 @@
+const LOG_WINDOW_MS = 30_000;
+const diagnosticsState = {
+    degraded: false,
+    lastErrorMessage: null,
+    lastFailureAt: null,
+    lastLoggedAtByFingerprint: new Map(),
+    totalFailures: 0,
+};
+const getErrorMessage = (error) => {
+    if (error instanceof Error && error.message.trim() !== '')
+        return error.message;
+    if (typeof error === 'string' && error.trim() !== '')
+        return error;
+    try {
+        const serialized = JSON.stringify(error);
+        if (typeof serialized === 'string' && serialized !== '')
+            return serialized;
+    }
+    catch {
+        // ignore serialization failures
+    }
+    return 'Unknown trace storage error';
+};
+const buildFingerprint = (context) => {
+    return [
+        context.connectionName,
+        context.operation,
+        context.watcherType ?? 'unknown',
+        getErrorMessage(context.error),
+    ].join('|');
+};
+const reportFailure = (logger, context) => {
+    const now = Date.now();
+    const errorMessage = getErrorMessage(context.error);
+    const fingerprint = buildFingerprint(context);
+    const lastLoggedAt = diagnosticsState.lastLoggedAtByFingerprint.get(fingerprint);
+    diagnosticsState.degraded = true;
+    diagnosticsState.lastErrorMessage = errorMessage;
+    diagnosticsState.lastFailureAt = now;
+    diagnosticsState.totalFailures += 1;
+    if (!logger)
+        return;
+    if (typeof lastLoggedAt === 'number' && now - lastLoggedAt < LOG_WINDOW_MS)
+        return;
+    diagnosticsState.lastLoggedAtByFingerprint.set(fingerprint, now);
+    logger.warn('[trace] Trace storage write degraded', {
+        connectionName: context.connectionName,
+        error: errorMessage,
+        lastFailureAt: now,
+        operation: context.operation,
+        totalFailures: diagnosticsState.totalFailures,
+        watcherType: context.watcherType ?? null,
+    });
+};
+const wrapStorageMethod = (method, describeFailure, connectionName, logger) => {
+    return async (...args) => {
+        try {
+            return await method(...args);
+        }
+        catch (error) {
+            reportFailure(logger, {
+                ...describeFailure(...args),
+                connectionName,
+                error,
+            });
+            throw error;
+        }
+    };
+};
+export const TraceWriteDiagnostics = Object.freeze({
+    getSnapshot() {
+        return {
+            degraded: diagnosticsState.degraded,
+            lastErrorMessage: diagnosticsState.lastErrorMessage,
+            lastFailureAt: diagnosticsState.lastFailureAt,
+            totalFailures: diagnosticsState.totalFailures,
+        };
+    },
+    reset() {
+        diagnosticsState.degraded = false;
+        diagnosticsState.lastErrorMessage = null;
+        diagnosticsState.lastFailureAt = null;
+        diagnosticsState.totalFailures = 0;
+        diagnosticsState.lastLoggedAtByFingerprint.clear();
+    },
+    wrapStorage(storage, options) {
+        return Object.freeze({
+            ...storage,
+            writeEntry: wrapStorageMethod(storage.writeEntry.bind(storage), (entry) => ({ operation: 'writeEntry', watcherType: entry.type }), options.connectionName, options.logger),
+            updateEntry: wrapStorageMethod(storage.updateEntry.bind(storage), (_uuid, _patch) => ({ operation: 'updateEntry' }), options.connectionName, options.logger),
+            markFamilyStale: wrapStorageMethod(storage.markFamilyStale.bind(storage), (_familyHash, _exceptUuid) => ({ operation: 'markFamilyStale' }), options.connectionName, options.logger),
+            prune: wrapStorageMethod(storage.prune.bind(storage), (_olderThanMs, _keepExceptions) => ({ operation: 'prune' }), options.connectionName, options.logger),
+            clear: wrapStorageMethod(storage.clear.bind(storage), () => ({ operation: 'clear' }), options.connectionName, options.logger),
+            addMonitoring: wrapStorageMethod(storage.addMonitoring.bind(storage), (_tag) => ({ operation: 'addMonitoring' }), options.connectionName, options.logger),
+            removeMonitoring: wrapStorageMethod(storage.removeMonitoring.bind(storage), (_tag) => ({ operation: 'removeMonitoring' }), options.connectionName, options.logger),
+        });
+    },
+});

package/dist/storage/index.js

@@ -1 +1 @@
-export { TraceStorage } from './TraceStorage';
+export { TraceStorage } from './TraceStorage.js';

package/dist/types.d.ts

@@ -33,6 +33,7 @@ export interface RequestContent {
     payload: Record<string, unknown>;
     responseStatus: number;
     responseHeaders: Record<string, string>;
+    responseBody?: unknown;
     duration: number;
     memory: number | null;
     middleware: string[];
@@ -231,31 +232,47 @@ export interface ITraceWatcher {
     register(opts: ITraceWatcherConfig): () => void;
 }
 export type RedactionConfig = {
+    keys: string[];
     headers: string[];
     body: string[];
     query: string[];
 };
+export type TraceFilterRule = {
+    enabled?: boolean;
+    include?: string[];
+    exclude?: string[];
+};
+export type TraceRequestWatcherConfig = TraceFilterRule & {
+    all?: TraceFilterRule;
+    get?: TraceFilterRule;
+    post?: TraceFilterRule;
+    put?: TraceFilterRule;
+    patch?: TraceFilterRule;
+    delete?: TraceFilterRule;
+};
+export type TraceWatcherToggle = boolean | TraceFilterRule;
+export type TraceRequestWatcherToggle = boolean | TraceRequestWatcherConfig;
 export type WatcherToggles = {
-    request?: boolean;
-    query?: boolean;
-    exception?: boolean;
-    log?: boolean;
-    job?: boolean;
-    cache?: boolean;
-    schedule?: boolean;
-    mail?: boolean;
-    auth?: boolean;
-    event?: boolean;
-    model?: boolean;
-    notification?: boolean;
-    redis?: boolean;
-    gate?: boolean;
-    middleware?: boolean;
-    command?: boolean;
-    batch?: boolean;
-    dump?: boolean;
-    view?: boolean;
-    clientRequest?: boolean;
+    request?: TraceRequestWatcherToggle;
+    query?: TraceWatcherToggle;
+    exception?: TraceWatcherToggle;
+    log?: TraceWatcherToggle;
+    job?: TraceWatcherToggle;
+    cache?: TraceWatcherToggle;
+    schedule?: TraceWatcherToggle;
+    mail?: TraceWatcherToggle;
+    auth?: TraceWatcherToggle;
+    event?: TraceWatcherToggle;
+    model?: TraceWatcherToggle;
+    notification?: TraceWatcherToggle;
+    redis?: TraceWatcherToggle;
+    gate?: TraceWatcherToggle;
+    middleware?: TraceWatcherToggle;
+    command?: TraceWatcherToggle;
+    batch?: TraceWatcherToggle;
+    dump?: TraceWatcherToggle;
+    view?: TraceWatcherToggle;
+    clientRequest?: TraceWatcherToggle;
 };
 export interface ITraceConfig {
     enabled: boolean;

package/dist/ui.js

@@ -4,4 +4,4 @@
  * Import this subpath when you only need trace dashboard registration
  * without pulling in the package root re-export surface.
  */
-export { registerTraceDashboard, registerTraceRoutes } from './dashboard/routes';
+export { registerTraceDashboard, registerTraceRoutes } from './dashboard/routes.js';

package/dist/utils/authTag.js

@@ -1,4 +1,4 @@
-import { TraceContext } from '../context';
+import { TraceContext } from '../context.js';
 const resolveAuthTag = () => {
     const userId = TraceContext.getUserId();
     if (userId === undefined || userId === '')

package/dist/utils/entryFilter.d.ts

@@ -0,0 +1,4 @@
+import type { ITraceConfig, ITraceEntry } from '../types';
+export declare const TraceEntryFilter: Readonly<{
+    shouldCapture(entry: ITraceEntry, config: ITraceConfig): boolean;
+}>;