@zintrust/trace 0.5.8 → 0.6.0

package/dist/register.js

@@ -117,11 +117,15 @@ const parseEnvBool = (rawValue) => {
         return false;
     return undefined;
 };
-const resolveTraceStartupOverrides = (core) => {
+const resolveTraceStartupOverrides = async (core) => {
     const traceConfigFile = core.StartupConfigFile?.Trace;
     if (typeof traceConfigFile !== 'string' || traceConfigFile.trim() === '')
         return undefined;
-    const overrides = core.StartupConfigFileRegistry?.get(traceConfigFile);
+    const registry = core.StartupConfigFileRegistry;
+    if (registry?.has?.(traceConfigFile) !== true && typeof registry?.preload === 'function') {
+        await registry.preload([traceConfigFile]);
+    }
+    const overrides = registry?.get(traceConfigFile);
     return isObjectValue(overrides) ? overrides : undefined;
 };
 const buildTraceRedactionOverrides = (input) => {
@@ -195,7 +199,7 @@ const assertTraceStorageReady = async (coreApi, db, connectionName) => {
 };
 const core = (await importCore());
 const Env = core.Env;
-const startupOverrides = resolveTraceStartupOverrides(core);
+const startupOverrides = await resolveTraceStartupOverrides(core);
 if (!traceAlreadyInitialized && Env) {
     const enabled = startupOverrides?.enabled === true || Env.getBool('TRACE_ENABLED', false);
     if (enabled) {

package/dist/storage/TraceEntryFiltering.js

@@ -1,9 +1,64 @@
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
 import { TraceEntryFilter } from '../utils/entryFilter.js';
+import { RequestFilter } from '../utils/requestFilter.js';
+const MAX_IGNORED_BATCHES = 512;
+const isObjectValue = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+const getEntryUri = (entry) => {
+    if (entry.type !== EntryType.REQUEST)
+        return undefined;
+    const content = isObjectValue(entry.content) ? entry.content : undefined;
+    const uri = content?.['uri'];
+    return typeof uri === 'string' && uri.trim() !== '' ? uri : undefined;
+};
+const createIgnoredBatchTracker = () => {
+    const ignoredBatchIds = new Set();
+    const ignoredBatchOrder = [];
+    const remember = (batchId) => {
+        if (ignoredBatchIds.has(batchId))
+            return;
+        ignoredBatchIds.add(batchId);
+        ignoredBatchOrder.push(batchId);
+        if (ignoredBatchOrder.length <= MAX_IGNORED_BATCHES)
+            return;
+        const evictedBatchId = ignoredBatchOrder.shift();
+        if (evictedBatchId !== undefined) {
+            ignoredBatchIds.delete(evictedBatchId);
+        }
+    };
+    const has = (batchId) => {
+        return ignoredBatchIds.has(batchId);
+    };
+    return Object.freeze({ has, remember });
+};
+const shouldDropForIgnoredRequest = (entry, config, tracker) => {
+    if (tracker.has(entry.batchId)) {
+        return true;
+    }
+    const currentPath = TraceContext.getRequestPath();
+    if (typeof currentPath === 'string' &&
+        currentPath !== '' &&
+        RequestFilter.matchesIgnoredPath(currentPath, config)) {
+        tracker.remember(entry.batchId);
+        return true;
+    }
+    const uri = getEntryUri(entry);
+    if (typeof uri === 'string' && RequestFilter.matchesIgnoredPath(uri, config)) {
+        tracker.remember(entry.batchId);
+        return true;
+    }
+    return false;
+};
 export const TraceEntryFiltering = Object.freeze({
     wrapStorage(storage, config) {
+        const ignoredBatchTracker = createIgnoredBatchTracker();
         return Object.freeze({
             ...storage,
             async writeEntry(entry) {
+                if (shouldDropForIgnoredRequest(entry, config, ignoredBatchTracker))
+                    return;
                 if (!TraceEntryFilter.shouldCapture(entry, config))
                     return;
                 await storage.writeEntry(entry);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/trace",
-  "version": "0.5.8",
+  "version": "0.6.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.5.5"
+    "@zintrust/core": "^0.5.9"
   },
   "publishConfig": {
     "access": "public"

package/src/register.ts

@@ -72,7 +72,9 @@ type CoreApi = {
     Trace?: string;
   };
   StartupConfigFileRegistry?: {
+    preload?(files: readonly string[]): Promise<void>;
     get<T>(file: string): T | undefined;
+    has?(file: string): boolean;
   };
 };
 
@@ -181,11 +183,18 @@ const parseEnvBool = (rawValue: string): boolean | undefined => {
   return undefined;
 };
 
-const resolveTraceStartupOverrides = (core: CoreApi): TraceConfigOverrides | undefined => {
+const resolveTraceStartupOverrides = async (
+  core: CoreApi
+): Promise<TraceConfigOverrides | undefined> => {
   const traceConfigFile = core.StartupConfigFile?.Trace;
   if (typeof traceConfigFile !== 'string' || traceConfigFile.trim() === '') return undefined;
 
-  const overrides = core.StartupConfigFileRegistry?.get<unknown>(traceConfigFile);
+  const registry = core.StartupConfigFileRegistry;
+  if (registry?.has?.(traceConfigFile) !== true && typeof registry?.preload === 'function') {
+    await registry.preload([traceConfigFile]);
+  }
+
+  const overrides = registry?.get<unknown>(traceConfigFile);
   return isObjectValue(overrides) ? (overrides as TraceConfigOverrides) : undefined;
 };
 
@@ -296,7 +305,7 @@ const assertTraceStorageReady = async (
 
 const core = (await importCore()) as CoreApi;
 const Env = core.Env;
-const startupOverrides = resolveTraceStartupOverrides(core);
+const startupOverrides = await resolveTraceStartupOverrides(core);
 
 if (!traceAlreadyInitialized && Env) {
   const enabled = startupOverrides?.enabled === true || Env.getBool('TRACE_ENABLED', false);

package/src/storage/TraceEntryFiltering.ts

@@ -1,11 +1,84 @@
+import { TraceContext } from '../context';
 import type { ITraceConfig, ITraceEntry, ITraceStorage } from '../types';
+import { EntryType } from '../types';
 import { TraceEntryFilter } from '../utils/entryFilter';
+import { RequestFilter } from '../utils/requestFilter';
+
+const MAX_IGNORED_BATCHES = 512;
+
+const isObjectValue = (value: unknown): value is Record<string, unknown> => {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+
+const getEntryUri = (entry: ITraceEntry): string | undefined => {
+  if (entry.type !== EntryType.REQUEST) return undefined;
+
+  const content = isObjectValue(entry.content) ? entry.content : undefined;
+  const uri = content?.['uri'];
+  return typeof uri === 'string' && uri.trim() !== '' ? uri : undefined;
+};
+
+const createIgnoredBatchTracker = () => {
+  const ignoredBatchIds = new Set<string>();
+  const ignoredBatchOrder: string[] = [];
+
+  const remember = (batchId: string): void => {
+    if (ignoredBatchIds.has(batchId)) return;
+
+    ignoredBatchIds.add(batchId);
+    ignoredBatchOrder.push(batchId);
+
+    if (ignoredBatchOrder.length <= MAX_IGNORED_BATCHES) return;
+
+    const evictedBatchId = ignoredBatchOrder.shift();
+    if (evictedBatchId !== undefined) {
+      ignoredBatchIds.delete(evictedBatchId);
+    }
+  };
+
+  const has = (batchId: string): boolean => {
+    return ignoredBatchIds.has(batchId);
+  };
+
+  return Object.freeze({ has, remember });
+};
+
+const shouldDropForIgnoredRequest = (
+  entry: ITraceEntry,
+  config: ITraceConfig,
+  tracker: ReturnType<typeof createIgnoredBatchTracker>
+): boolean => {
+  if (tracker.has(entry.batchId)) {
+    return true;
+  }
+
+  const currentPath = TraceContext.getRequestPath();
+  if (
+    typeof currentPath === 'string' &&
+    currentPath !== '' &&
+    RequestFilter.matchesIgnoredPath(currentPath, config)
+  ) {
+    tracker.remember(entry.batchId);
+    return true;
+  }
+
+  const uri = getEntryUri(entry);
+  if (typeof uri === 'string' && RequestFilter.matchesIgnoredPath(uri, config)) {
+    tracker.remember(entry.batchId);
+    return true;
+  }
+
+  return false;
+};
 
 export const TraceEntryFiltering = Object.freeze({
   wrapStorage(storage: ITraceStorage, config: ITraceConfig): ITraceStorage {
+    const ignoredBatchTracker = createIgnoredBatchTracker();
+
     return Object.freeze({
       ...storage,
       async writeEntry(entry: ITraceEntry) {
+        if (shouldDropForIgnoredRequest(entry, config, ignoredBatchTracker)) return;
         if (!TraceEntryFilter.shouldCapture(entry, config)) return;
         await storage.writeEntry(entry);
       },