@zintrust/trace 0.4.96 → 0.5.1

package/dist/storage/TraceStorage.js

@@ -3,6 +3,107 @@ const TABLE_ENTRIES = 'zin_trace_entries';
 const TABLE_TAGS = 'zin_trace_entries_tags';
 const TABLE_MONITORING = 'zin_trace_monitoring';
 const generateUuid = () => crypto.randomUUID();
+const decodeJsonStringLiteral = (value) => {
+    try {
+        return JSON.parse(`"${value}"`);
+    }
+    catch {
+        return undefined;
+    }
+};
+const matchJsonStringField = (content, key) => {
+    const match = new RegExp(String.raw `"${key}"\s*:\s*"((?:\\.|[^"\\])*)"`, 's').exec(content);
+    return match ? decodeJsonStringLiteral(match[1]) : undefined;
+};
+const matchJsonNumberField = (content, key) => {
+    const match = new RegExp(String.raw `"${key}"\s*:\s*(-?\d+(?:\.\d+)?)`, 's').exec(content);
+    if (!match)
+        return undefined;
+    const parsed = Number(match[1]);
+    return Number.isFinite(parsed) ? parsed : undefined;
+};
+const matchJsonNullOrNumberField = (content, key) => {
+    const nullMatch = new RegExp(String.raw `"${key}"\s*:\s*null`, 's').exec(content);
+    if (nullMatch)
+        return null;
+    return matchJsonNumberField(content, key);
+};
+const matchJsonStringArrayField = (content, key) => {
+    const match = new RegExp(String.raw `"${key}"\s*:\s*(\[.*?\])`, 's').exec(content);
+    if (!match)
+        return undefined;
+    try {
+        const parsed = JSON.parse(match[1]);
+        return Array.isArray(parsed)
+            ? parsed.filter((value) => typeof value === 'string')
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const compactRequestContent = (content) => {
+    const compact = {};
+    const method = matchJsonStringField(content, 'method');
+    const uri = matchJsonStringField(content, 'uri');
+    const responseStatus = matchJsonNumberField(content, 'responseStatus');
+    const duration = matchJsonNumberField(content, 'duration');
+    const memory = matchJsonNullOrNumberField(content, 'memory');
+    const middleware = matchJsonStringArrayField(content, 'middleware');
+    const hostname = matchJsonStringField(content, 'hostname');
+    const userId = matchJsonStringField(content, 'userId');
+    if (method !== undefined)
+        compact['method'] = method;
+    if (uri !== undefined)
+        compact['uri'] = uri;
+    if (responseStatus !== undefined)
+        compact['responseStatus'] = responseStatus;
+    if (duration !== undefined)
+        compact['duration'] = duration;
+    if (memory !== undefined)
+        compact['memory'] = memory;
+    if (middleware !== undefined)
+        compact['middleware'] = middleware;
+    if (hostname !== undefined)
+        compact['hostname'] = hostname;
+    if (userId !== undefined)
+        compact['userId'] = userId;
+    return Object.keys(compact).length > 0 ? compact : undefined;
+};
+const compactClientRequestContent = (content) => {
+    const compact = {};
+    const source = matchJsonStringField(content, 'source');
+    const method = matchJsonStringField(content, 'method');
+    const url = matchJsonStringField(content, 'url');
+    const responseStatus = matchJsonNumberField(content, 'responseStatus');
+    const error = matchJsonStringField(content, 'error');
+    const duration = matchJsonNumberField(content, 'duration');
+    const hostname = matchJsonStringField(content, 'hostname');
+    if (source !== undefined)
+        compact['source'] = source;
+    if (method !== undefined)
+        compact['method'] = method;
+    if (url !== undefined)
+        compact['url'] = url;
+    if (responseStatus !== undefined)
+        compact['responseStatus'] = responseStatus;
+    if (error !== undefined)
+        compact['error'] = error;
+    if (duration !== undefined)
+        compact['duration'] = duration;
+    if (hostname !== undefined)
+        compact['hostname'] = hostname;
+    return Object.keys(compact).length > 0 ? compact : undefined;
+};
+const summarizeEntryContent = (row) => {
+    if (row.type === 'request') {
+        return compactRequestContent(row.content) ?? JSON.parse(row.content);
+    }
+    if (row.type === 'client_request') {
+        return compactClientRequestContent(row.content) ?? JSON.parse(row.content);
+    }
+    return JSON.parse(row.content);
+};
 const buildIgnoreInsert = (db, table, columns, conflictColumns) => {
     const columnList = columns.join(', ');
     const placeholders = columns.map(() => '?').join(', ');
@@ -35,12 +136,12 @@ const buildIgnoreInsert = (db, table, columns, conflictColumns) => {
     }
     return `INSERT INTO ${table} (${columnList}) VALUES (${placeholders})`;
 };
-const rowToEntry = (row, tags) => ({
+const rowToEntry = (row, tags, summary = false) => ({
     uuid: row.uuid,
     batchId: row.batch_id,
     familyHash: row.family_hash ?? undefined,
     type: row.type,
-    content: JSON.parse(row.content),
+    content: summary ? summarizeEntryContent(row) : JSON.parse(row.content),
     tags,
     isLatest: Boolean(row.is_latest),
     createdAt: row.created_at,
@@ -81,6 +182,29 @@ const buildEntryFilters = (opts) => {
     const countParams = opts.tag ? [opts.tag, ...params.slice(1)] : [...params];
     return { joinClause, whereClause, params, countParams };
 };
+const buildBatchCounts = async (db, batchId) => {
+    const rows = (await db.query(`SELECT type, COUNT(*) as cnt FROM ${TABLE_ENTRIES} WHERE batch_id = ? GROUP BY type`, [batchId]));
+    const counts = {};
+    for (const row of rows) {
+        counts[row.type] = row.cnt;
+    }
+    return counts;
+};
+const buildBatchEntryFilters = (batchId, opts) => {
+    const conditions = ['batch_id = ?'];
+    const params = [batchId];
+    if (opts.type) {
+        conditions.push('type = ?');
+        params.push(opts.type);
+    }
+    const excludeTypes = opts.excludeTypes ?? [];
+    if (excludeTypes.length > 0) {
+        const placeholders = excludeTypes.map(() => '?').join(', ');
+        conditions.push(`type NOT IN (${placeholders})`);
+        params.push(...excludeTypes);
+    }
+    return { whereClause: `WHERE ${conditions.join(' AND ')}`, params };
+};
 const loadTagsByUuid = async (db, uuids) => {
     const tagsByUuid = new Map();
     if (uuids.length === 0)
@@ -143,7 +267,7 @@ const createStorage = (db) => {
        LIMIT ? OFFSET ?`, [...params, perPage, offset]));
         const tagsByUuid = await loadTagsByUuid(db, rows.map((row) => row.uuid));
         return {
-            data: rows.map((row) => rowToEntry(row, tagsByUuid.get(row.uuid) ?? [])),
+            data: rows.map((row) => rowToEntry(row, tagsByUuid.get(row.uuid) ?? [], opts.summary)),
             total,
         };
     };
@@ -168,6 +292,35 @@ const createStorage = (db) => {
         const tagsByUuid = await loadTagsByUuid(db, rows.map((row) => row.uuid));
         return rows.map((row) => rowToEntry(row, tagsByUuid.get(row.uuid) ?? []));
     };
+    const queryBatchEntries = async (batchId, opts = {}) => {
+        const page = opts.page ?? 1;
+        const perPage = opts.perPage ?? 10;
+        const offset = (page - 1) * perPage;
+        const counts = await buildBatchCounts(db, batchId);
+        if (opts.countsOnly) {
+            const total = Object.values(counts).reduce((sum, value) => sum + Number(value ?? 0), 0);
+            return { entries: [], total, counts, page, perPage };
+        }
+        const { whereClause, params } = buildBatchEntryFilters(batchId, opts);
+        const countResult = (await db.queryOne(`SELECT COUNT(*) as cnt FROM ${TABLE_ENTRIES} ${whereClause}`, params));
+        const total = countResult?.cnt ?? 0;
+        if (total === 0) {
+            return { entries: [], total: 0, counts, page, perPage };
+        }
+        const rows = (await db.query(`SELECT id, uuid, batch_id, family_hash, type, content, is_latest, created_at
+       FROM ${TABLE_ENTRIES}
+       ${whereClause}
+       ORDER BY created_at ASC, id ASC
+       LIMIT ? OFFSET ?`, [...params, perPage, offset]));
+        const tagsByUuid = await loadTagsByUuid(db, rows.map((row) => row.uuid));
+        return {
+            entries: rows.map((row) => rowToEntry(row, tagsByUuid.get(row.uuid) ?? [], opts.summary)),
+            total,
+            counts,
+            page,
+            perPage,
+        };
+    };
     const prune = async (olderThanMs, keepExceptions = false) => {
         const countResult = (await db.queryOne(`SELECT COUNT(*) as cnt FROM ${TABLE_ENTRIES}
        WHERE created_at < ?
@@ -208,6 +361,7 @@ const createStorage = (db) => {
         queryEntries,
         getEntry,
         getBatch,
+        queryBatchEntries,
         prune,
         clear,
         getMonitoring,

package/dist/types.d.ts

@@ -231,6 +231,22 @@ export interface QueryEntriesOptions {
     to?: number;
     page?: number;
     perPage?: number;
+    summary?: boolean;
+}
+export interface QueryBatchEntriesOptions {
+    type?: EntryTypeValue;
+    excludeTypes?: EntryTypeValue[];
+    page?: number;
+    perPage?: number;
+    summary?: boolean;
+    countsOnly?: boolean;
+}
+export interface QueryBatchEntriesResult {
+    entries: ITraceEntry[];
+    total: number;
+    counts: Partial<Record<EntryTypeValue, number>>;
+    page: number;
+    perPage: number;
 }
 export interface ITraceStorage {
     writeEntry(entry: ITraceEntry): Promise<void>;
@@ -242,6 +258,7 @@ export interface ITraceStorage {
     }>;
     getEntry(uuid: string): Promise<ITraceEntry | null>;
     getBatch(batchId: string): Promise<ITraceEntry[]>;
+    queryBatchEntries(batchId: string, opts?: QueryBatchEntriesOptions): Promise<QueryBatchEntriesResult>;
     prune(olderThanMs: number, keepExceptions?: boolean): Promise<number>;
     clear(): Promise<void>;
     getMonitoring(): Promise<string[]>;

package/dist/watchers/HttpClientWatcher.d.ts

@@ -1,4 +1,4 @@
-import type { ClientRequestTraceInput, ITraceWatcher } from '../types';
+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;

package/dist/watchers/HttpClientWatcher.js

@@ -1,5 +1,5 @@
 import { TraceContext } from '../context.js';
-import { EntryType } from '../types.js';
+import { EntryType, } from '../types.js';
 import { AuthTag } from '../utils/authTag.js';
 import { redactHeaders, redactUnknown } from '../utils/redact.js';
 import { RequestFilter } from '../utils/requestFilter.js';
@@ -57,20 +57,40 @@ const buildResponseBody = (responseBody, sourceRule) => {
         return {};
     return { responseBody: redactUnknown(responseBody, _redactBodyFields) };
 };
+const applySource = (content, normalizedSource) => {
+    if (normalizedSource !== undefined) {
+        content.source = normalizedSource;
+    }
+};
+const applyResponseStatus = (content, responseStatus) => {
+    if (responseStatus !== undefined) {
+        content.responseStatus = responseStatus;
+    }
+};
+const applyError = (content, error) => {
+    if (typeof error === 'string' && error !== '') {
+        content.error = error;
+    }
+};
+const mergePartialContent = (content, partial) => {
+    Object.assign(content, partial);
+};
 const buildClientRequestContent = (input, sourceRule, normalizedSource) => {
-    return {
-        ...(normalizedSource === undefined ? {} : { source: normalizedSource }),
+    const content = {
         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 } : {}),
+        requestHeaders: {},
         duration: input.duration,
         hostname: TraceContext.getHostname(),
     };
+    applySource(content, normalizedSource);
+    mergePartialContent(content, buildRequestHeaders(input.requestHeaders, sourceRule));
+    mergePartialContent(content, buildRequestBody(input.requestBody, sourceRule));
+    applyResponseStatus(content, input.responseStatus);
+    mergePartialContent(content, buildResponseHeaders(input.responseHeaders, sourceRule));
+    mergePartialContent(content, buildResponseBody(input.responseBody, sourceRule));
+    applyError(content, input.error);
+    return content;
 };
 const isWatcherEnabled = (value) => {
     if (value === false)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/trace",
-  "version": "0.4.96",
+  "version": "0.5.1",
   "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.95"
+    "@zintrust/core": "^0.5.0"
   },
   "publishConfig": {
     "access": "public"
@@ -56,4 +56,4 @@
     "build": "tsc -p tsconfig.json && tsc -p tsconfig.migrations.json && node ../../scripts/fix-dist-esm-imports.mjs dist",
     "prepublishOnly": "npm run build"
   }
-}
+}

package/src/config.ts

@@ -134,7 +134,7 @@ const collectClientRequestSourceKeys = (
 ): string[] => {
   const overrideSources = override?.sources ?? {};
   const sourceKeys = new Set<string>([
-    ...Object.keys(isObjectValue(base) ? base.sources ?? {} : {}),
+    ...Object.keys(isObjectValue(base) ? (base.sources ?? {}) : {}),
     ...Object.keys(overrideSources),
   ]);
 

package/src/dashboard/handlers.ts

@@ -3,7 +3,7 @@
  * No auth in this layer — caller mounts middleware as needed.
  */
 import type { IRequest, IResponse } from '@zintrust/core';
-import type { EntryTypeValue, ITraceStorage } from '../types';
+import type { EntryTypeValue, ITraceEntry, ITraceStorage } from '../types';
 
 // ---------------------------------------------------------------------------
 // Storage holder (set once from routes.ts)
@@ -57,6 +57,140 @@ const getNumericQueryParam = (req: IRequest, key: string): number | undefined =>
   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 DEFAULT_BATCH_PER_PAGE = 10;
+const MAX_BATCH_PER_PAGE = 25;
+const SUMMARY_TEXT_LIMIT = 280;
+const SUMMARY_ARRAY_LIMIT = 10;
+const REQUEST_BATCH_DEFAULT_EXCLUDED_TYPES: EntryTypeValue[] = [
+  'request',
+  'query',
+  'middleware',
+  'model',
+  'log',
+  'exception',
+  'client_request',
+  'cache',
+];
+
+type CompactTraceEntry = ITraceEntry<Record<string, unknown>> & {
+  hasDetails: true;
+  contentBytes?: number;
+};
+
+const truncateText = (value: string, limit = SUMMARY_TEXT_LIMIT): string =>
+  value.length <= limit ? value : `${value.slice(0, Math.max(0, limit - 3))}...`;
+
+const compactValue = (value: unknown): unknown => {
+  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: unknown, keys: readonly string[]): Record<string, unknown> => {
+  if (typeof content !== 'object' || content === null || Array.isArray(content)) {
+    return {};
+  }
+
+  const source = content as Record<string, unknown>;
+  const compact: Record<string, unknown> = {};
+
+  for (const key of keys) {
+    const value = compactValue(source[key]);
+    if (value !== undefined) {
+      compact[key] = value;
+    }
+  }
+
+  return compact;
+};
+
+const COMPACT_ENTRY_KEYS: Record<EntryTypeValue, readonly string[]> = {
+  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: ITraceEntry): Record<string, unknown> =>
+  pickCompactContent(entry.content, COMPACT_ENTRY_KEYS[entry.type]);
+
+const estimateContentBytes = (content: unknown): number | undefined => {
+  try {
+    return new TextEncoder().encode(JSON.stringify(content)).length;
+  } catch {
+    return undefined;
+  }
+};
+
+const compactListEntry = (entry: ITraceEntry): CompactTraceEntry => ({
+  ...entry,
+  content: compactEntryContent(entry),
+  hasDetails: true,
+  contentBytes: estimateContentBytes(entry.content),
+});
+
+const resolvePerPage = (req: IRequest, type?: EntryTypeValue): number => {
+  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
 // ---------------------------------------------------------------------------
@@ -64,18 +198,26 @@ const getNumericQueryParam = (req: IRequest, key: string): number | undefined =>
 export async function listEntries(req: IRequest, res: IResponse): Promise<void> {
   const storage = getStorage(res);
   if (storage !== null) {
+    const type = qp(req, 'type') as EntryTypeValue | undefined;
     const opts = {
-      type: qp(req, 'type') as EntryTypeValue | undefined,
+      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),
+      summary: true,
     };
     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 as Error).message });
     }
@@ -111,8 +253,22 @@ export async function getBatch(req: IRequest, res: IResponse): Promise<void> {
   const batchId = req.getParam('batchId');
   if (batchId) {
     try {
-      const entries = await storage.getBatch(batchId);
-      res.json({ ok: true, entries });
+      const scope = qp(req, 'scope');
+      const type = qp(req, 'type') as EntryTypeValue | undefined;
+      const countsOnly = qp(req, 'countsOnly') === 'true';
+      const page = Math.max(1, qpInt(req, 'page', 1));
+      const perPage = Math.max(
+        1,
+        Math.min(qpInt(req, 'perPage', DEFAULT_BATCH_PER_PAGE), MAX_BATCH_PER_PAGE)
+      );
+      const result = await storage.queryBatchEntries(batchId, {
+        type,
+        excludeTypes: scope === 'other' ? REQUEST_BATCH_DEFAULT_EXCLUDED_TYPES : undefined,
+        page,
+        perPage,
+        countsOnly,
+      });
+      res.json({ ok: true, ...result });
       return;
     } catch (err) {
       res.setStatus(500).json({ error: (err as Error).message });