@zintrust/trace 0.4.95 → 0.5.0

package/dist/watchers/HttpClientWatcher.js

@@ -1,5 +1,6 @@
+import { generateUuid } from '@zintrust/core';
 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';
@@ -7,35 +8,127 @@ 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 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) => {
+    const content = {
+        method: input.method.toUpperCase(),
+        url: input.url,
+        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)
+        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(),
+        uuid: generateUuid(),
         batchId: TraceContext.getBatchId(),
         type: EntryType.CLIENT_REQUEST,
         content,
@@ -48,14 +141,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/trace",
-  "version": "0.4.95",
+  "version": "0.5.0",
   "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.94"
+    "@zintrust/core": "^0.4.101"
   },
   "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),
   };
 };
 

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,128 @@ 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 SUMMARY_TEXT_LIMIT = 280;
+const SUMMARY_ARRAY_LIMIT = 10;
+
+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 +186,25 @@ 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),
     };
     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 });
     }

package/src/dashboard/ui.ts

@@ -38,6 +38,7 @@ const SUN_ICON = `<svg viewBox="0 0 24 24" aria-hidden="true" fill="none" stroke
 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+)?)`;
@@ -137,6 +138,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'];
@@ -651,6 +653,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>',
@@ -1083,6 +1086,7 @@ const buildDashboardHtml = (basePath: string, projectName?: string): string => {
     .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)