@zintrust/trace 0.4.86 → 0.4.92

package/dist/build-manifest.json

@@ -1,14 +1,14 @@
 {
   "name": "@zintrust/trace",
-  "version": "0.4.86",
-  "buildDate": "2026-04-09T08:08:55.865Z",
+  "version": "0.4.92",
+  "buildDate": "2026-04-10T08:41:38.521Z",
   "buildEnvironment": {
     "node": "v20.20.2",
     "platform": "linux",
     "arch": "x64"
   },
   "git": {
-    "commit": "a456e7ec",
+    "commit": "d195a996",
     "branch": "master"
   },
   "package": {
@@ -75,7 +75,7 @@
     },
     "index.js": {
       "size": 3255,
-      "sha256": "faba7327d333f46340e9f6933510a88cb2439d14af9651cd8868a38782a44388"
+      "sha256": "683151fa06b666ec62b150a4fda949c3d35221228b8538644ef740252b63587d"
     },
     "migrations/20260331000001_create_zin_trace_entries_table.d.ts": {
       "size": 304,
@@ -130,8 +130,8 @@
       "sha256": "71d366165dd36f1675aa253a76262b226fb6c62e5ab632746b8aea61c0c625fc"
     },
     "register.js": {
-      "size": 12522,
-      "sha256": "66bccec7fac4d669702fa18e439788325d36ce17f228639005ffcde2cd968d70"
+      "size": 14225,
+      "sha256": "07e1643982cc93149c609d44beb11dea168ecf1cac3f78d95d6d22fedcafbc23"
     },
     "storage/TraceContentRedaction.d.ts": {
       "size": 207,
@@ -330,8 +330,8 @@
       "sha256": "f3ddc5f8b58c6c86ac6b464dd48e5a55e79ab2bf2e735feacffc7480e4ccc0c4"
     },
     "watchers/LogWatcher.js": {
-      "size": 2026,
-      "sha256": "c5d2227cd76ce10162993ac31f474b2460cd41264c36f01b5130152f14a0ad21"
+      "size": 3126,
+      "sha256": "e0944661b48b682520d60ee9e98b3fa9f8ba4694743f134f98b04b8b2dd479e6"
     },
     "watchers/MailWatcher.d.ts": {
       "size": 244,
@@ -370,8 +370,8 @@
       "sha256": "5d5046c65e5b683369c7709f1acd09b60aec3e7f44748fd1baeb35498836465b"
     },
     "watchers/QueryWatcher.js": {
-      "size": 2935,
-      "sha256": "577c6fec0282d2290db5c4b6c606b9b6ecdd64209af2b09f3205a15bf656bbef"
+      "size": 3002,
+      "sha256": "c7131284e75ab2f0193597cdf3ef0aa7eab1a3872fe9193579a140a41fadb57e"
     },
     "watchers/RedisWatcher.d.ts": {
       "size": 294,

package/dist/register.js

@@ -39,6 +39,11 @@ const importCore = async () => {
         return {};
     }
 };
+const TRACE_REQUIRED_TABLES = [
+    'zin_trace_entries',
+    'zin_trace_entries_tags',
+    'zin_trace_monitoring',
+];
 const resolveRegisterMiddleware = () => {
     const globalMiddlewareRegistrarState = globalThis;
     return (middleware) => {
@@ -69,7 +74,7 @@ const resolveObservedConnectionName = (env, configuredObservedConnection, storag
         configuredObservedConnection.trim() !== '') {
         return resolveTraceConnectionName(env, configuredObservedConnection);
     }
-    const defaultConnectionName = resolveTraceConnectionName(env, undefined);
+    const defaultConnectionName = resolveTraceConnectionName(env);
     if (storageConnectionName !== defaultConnectionName) {
         return defaultConnectionName;
     }
@@ -150,6 +155,43 @@ const buildTraceRedactionOverrides = (input) => {
         ? redaction
         : undefined;
 };
+const createTraceConfigError = (coreApi, message, details) => {
+    if (coreApi.ErrorFactory?.createConfigError !== undefined) {
+        return coreApi.ErrorFactory.createConfigError(message, details);
+    }
+    const error = new globalThis.Error(message);
+    error.name = 'ConfigError';
+    error.code = 'CONFIG_ERROR';
+    error.statusCode = 500;
+    error.details = details;
+    return error;
+};
+function assertTraceConnectionResolved(coreApi, db, params) {
+    if (db !== undefined) {
+        return;
+    }
+    throw createTraceConfigError(coreApi, `Trace connection "${params.connectionName}" could not be resolved.`, {
+        connectionName: params.connectionName,
+        envKey: params.envKey,
+        hint: params.envKey === 'TRACE_DB_CONNECTION'
+            ? 'Configure TRACE_DB_CONNECTION to an existing database connection before enabling TRACE_ENABLED.'
+            : 'Configure TRACE_QUERY_CONNECTION, or ensure DB_CONNECTION resolves to an existing database connection.',
+    });
+}
+const assertTraceStorageReady = async (coreApi, db, connectionName) => {
+    try {
+        await Promise.all(TRACE_REQUIRED_TABLES.map(async (table) => {
+            await db.queryOne(`SELECT 1 AS ok FROM ${table} LIMIT 1`, []);
+        }));
+    }
+    catch (error) {
+        throw createTraceConfigError(coreApi, `Trace storage connection "${connectionName}" is not ready. Create the database if needed and run \`zin migrate:trace\` before enabling TRACE_ENABLED.`, {
+            connectionName,
+            error,
+            requiredTables: [...TRACE_REQUIRED_TABLES],
+        });
+    }
+};
 const core = (await importCore());
 const Env = core.Env;
 const startupOverrides = resolveTraceStartupOverrides(core);
@@ -205,62 +247,65 @@ if (!traceAlreadyInitialized && Env) {
         const resolvedObservedConnectionName = resolveObservedConnectionName(Env, config.observeConnection, resolvedConnectionName);
         const storageDb = core.useDatabase?.(undefined, resolvedConnectionName);
         const observedDb = core.useDatabase?.(undefined, resolvedObservedConnectionName);
-        if (storageDb && observedDb) {
-            const storage = TraceWriteDiagnostics.wrapStorage(TraceContentRedaction.wrapStorage(TraceEntryFiltering.wrapStorage(TraceStorage.resolveStorage(storageDb), 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.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: observedDb };
-            HttpWatcher.register({ ...watcherArgs, registerMiddleware: resolveRegisterMiddleware() });
-            QueryWatcher.register(watcherArgs);
-            LogWatcher.register(watcherArgs);
-            ExceptionWatcher.register(watcherArgs);
-            JobWatcher.register(watcherArgs);
-            CacheWatcher.register(watcherArgs);
-            ScheduleWatcher.register(watcherArgs);
-            MailWatcher.register(watcherArgs);
-            AuthWatcher.register(watcherArgs);
-            EventWatcher.register(watcherArgs);
-            ModelWatcher.register(watcherArgs);
-            NotificationWatcher.register(watcherArgs);
-            RedisWatcher.register(watcherArgs);
-            GateWatcher.register(watcherArgs);
-            MiddlewareWatcher.register(watcherArgs);
-            CommandWatcher.register(watcherArgs);
-            BatchWatcher.register(watcherArgs);
-            DumpWatcher.register(watcherArgs);
-            ViewWatcher.register(watcherArgs);
-            HttpClientWatcher.register(watcherArgs);
-        }
-        else {
-            // eslint-disable-next-line no-console
-            console.warn('[trace] Could not resolve database connection - skipping init.');
+        assertTraceConnectionResolved(core, storageDb, {
+            connectionName: resolvedConnectionName,
+            envKey: 'TRACE_DB_CONNECTION',
+        });
+        assertTraceConnectionResolved(core, observedDb, {
+            connectionName: resolvedObservedConnectionName,
+            envKey: 'TRACE_QUERY_CONNECTION',
+        });
+        await assertTraceStorageReady(core, storageDb, resolvedConnectionName);
+        const storage = TraceWriteDiagnostics.wrapStorage(TraceContentRedaction.wrapStorage(TraceEntryFiltering.wrapStorage(TraceStorage.resolveStorage(storageDb), 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.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: observedDb };
+        HttpWatcher.register({ ...watcherArgs, registerMiddleware: resolveRegisterMiddleware() });
+        QueryWatcher.register(watcherArgs);
+        LogWatcher.register(watcherArgs);
+        ExceptionWatcher.register(watcherArgs);
+        JobWatcher.register(watcherArgs);
+        CacheWatcher.register(watcherArgs);
+        ScheduleWatcher.register(watcherArgs);
+        MailWatcher.register(watcherArgs);
+        AuthWatcher.register(watcherArgs);
+        EventWatcher.register(watcherArgs);
+        ModelWatcher.register(watcherArgs);
+        NotificationWatcher.register(watcherArgs);
+        RedisWatcher.register(watcherArgs);
+        GateWatcher.register(watcherArgs);
+        MiddlewareWatcher.register(watcherArgs);
+        CommandWatcher.register(watcherArgs);
+        BatchWatcher.register(watcherArgs);
+        DumpWatcher.register(watcherArgs);
+        ViewWatcher.register(watcherArgs);
+        HttpClientWatcher.register(watcherArgs);
     }
 }
 else if (!traceAlreadyInitialized) {

package/dist/watchers/LogWatcher.js

@@ -17,8 +17,37 @@ const TRACE_INFRASTRUCTURE_LOG_MESSAGES = new Set([
     '[MySQLProxyAdapter] Proxy request failed',
     '[trace] Trace storage write degraded',
 ]);
-const shouldSkipTraceInfrastructureLog = (message) => {
-    return TRACE_INFRASTRUCTURE_LOG_MESSAGES.has(message.trim());
+const TRACE_STORAGE_TABLE_NAMES = [
+    'zin_trace_entries',
+    'zin_trace_entries_tags',
+    'zin_trace_monitoring',
+];
+const isTraceStorageQuery = (sql) => {
+    const normalized = sql.toLowerCase();
+    return TRACE_STORAGE_TABLE_NAMES.some((tableName) => normalized.includes(tableName));
+};
+const extractSqlFromLog = (message, context) => {
+    const contextSql = context?.['sql'];
+    if (typeof contextSql === 'string')
+        return contextSql;
+    const trimmed = message.trim();
+    const rawPrefix = 'Raw SQL Query executed:';
+    if (trimmed.startsWith(rawPrefix)) {
+        const sql = trimmed.slice(rawPrefix.length).trim();
+        return sql === '' ? undefined : sql;
+    }
+    return undefined;
+};
+const isTraceStorageQueryLog = (message, context) => {
+    const normalizedMessage = message.trim().toLowerCase();
+    if (!normalizedMessage.includes('query executed'))
+        return false;
+    const sql = extractSqlFromLog(message, context);
+    return typeof sql === 'string' && isTraceStorageQuery(sql);
+};
+const shouldSkipTraceInfrastructureLog = (message, context) => {
+    return (TRACE_INFRASTRUCTURE_LOG_MESSAGES.has(message.trim()) ||
+        isTraceStorageQueryLog(message, context));
 };
 export const LogWatcher = Object.freeze({
     register({ storage, config }) {
@@ -34,7 +63,7 @@ export const LogWatcher = Object.freeze({
                 return;
             if (RequestFilter.shouldIgnoreCurrentRequest(config.ignoreRoutes))
                 return;
-            if (shouldSkipTraceInfrastructureLog(message))
+            if (shouldSkipTraceInfrastructureLog(message, context))
                 return;
             const content = {
                 level,

package/dist/watchers/QueryWatcher.js

@@ -22,7 +22,9 @@ const bindingsInterpolated = (sql, params) => {
 };
 const isTraceStorageQuery = (sql) => {
     const normalized = sql.toLowerCase();
-    return normalized.includes('zin_trace_entries') || normalized.includes('zin_trace_monitoring');
+    return (normalized.includes('zin_trace_entries') ||
+        normalized.includes('zin_trace_entries_tags') ||
+        normalized.includes('zin_trace_monitoring'));
 };
 const emit = (query, params, duration, connection = 'default') => {
     if (_storage === null || _config === null)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/trace",
-  "version": "0.4.86",
+  "version": "0.4.92",
   "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.84"
+    "@zintrust/core": "^0.4.91"
   },
   "publishConfig": {
     "access": "public"

package/src/register.ts

@@ -64,6 +64,9 @@ type CoreApi = {
   Logger?: {
     warn(message: string, context?: Record<string, unknown>): void;
   };
+  ErrorFactory?: {
+    createConfigError(message: string, details?: unknown): Error;
+  };
   StartupConfigFile?: {
     Trace?: string;
   };
@@ -72,6 +75,14 @@ type CoreApi = {
   };
 };
 
+type CoreDatabase = import('@zintrust/core').IDatabase;
+
+const TRACE_REQUIRED_TABLES = [
+  'zin_trace_entries',
+  'zin_trace_entries_tags',
+  'zin_trace_monitoring',
+] as const;
+
 type GlobalMiddlewareRegistrarState = {
   __zintrust_register_global_middleware__?: ITraceWatcherConfig['registerMiddleware'];
   __zintrust_pending_global_middlewares__?: Array<
@@ -125,7 +136,7 @@ const resolveObservedConnectionName = (
     return resolveTraceConnectionName(env, configuredObservedConnection);
   }
 
-  const defaultConnectionName = resolveTraceConnectionName(env, undefined);
+  const defaultConnectionName = resolveTraceConnectionName(env);
   if (storageConnectionName !== defaultConnectionName) {
     return defaultConnectionName;
   }
@@ -217,6 +228,71 @@ const buildTraceRedactionOverrides = (input: {
     : undefined;
 };
 
+const createTraceConfigError = (coreApi: CoreApi, message: string, details?: unknown): Error => {
+  if (coreApi.ErrorFactory?.createConfigError !== undefined) {
+    return coreApi.ErrorFactory.createConfigError(message, details);
+  }
+
+  const error = new globalThis.Error(message) as Error & {
+    code?: string;
+    details?: unknown;
+    name?: string;
+    statusCode?: number;
+  };
+  error.name = 'ConfigError';
+  error.code = 'CONFIG_ERROR';
+  error.statusCode = 500;
+  error.details = details;
+  return error;
+};
+
+function assertTraceConnectionResolved(
+  coreApi: CoreApi,
+  db: CoreDatabase | undefined,
+  params: { connectionName: string; envKey: 'TRACE_DB_CONNECTION' | 'TRACE_QUERY_CONNECTION' }
+): asserts db is CoreDatabase {
+  if (db !== undefined) {
+    return;
+  }
+
+  throw createTraceConfigError(
+    coreApi,
+    `Trace connection "${params.connectionName}" could not be resolved.`,
+    {
+      connectionName: params.connectionName,
+      envKey: params.envKey,
+      hint:
+        params.envKey === 'TRACE_DB_CONNECTION'
+          ? 'Configure TRACE_DB_CONNECTION to an existing database connection before enabling TRACE_ENABLED.'
+          : 'Configure TRACE_QUERY_CONNECTION, or ensure DB_CONNECTION resolves to an existing database connection.',
+    }
+  );
+}
+
+const assertTraceStorageReady = async (
+  coreApi: CoreApi,
+  db: CoreDatabase,
+  connectionName: string
+): Promise<void> => {
+  try {
+    await Promise.all(
+      TRACE_REQUIRED_TABLES.map(async (table) => {
+        await db.queryOne(`SELECT 1 AS ok FROM ${table} LIMIT 1`, []);
+      })
+    );
+  } catch (error) {
+    throw createTraceConfigError(
+      coreApi,
+      `Trace storage connection "${connectionName}" is not ready. Create the database if needed and run \`zin migrate:trace\` before enabling TRACE_ENABLED.`,
+      {
+        connectionName,
+        error,
+        requiredTables: [...TRACE_REQUIRED_TABLES],
+      }
+    );
+  }
+};
+
 const core = (await importCore()) as CoreApi;
 const Env = core.Env;
 const startupOverrides = resolveTraceStartupOverrides(core);
@@ -292,98 +368,103 @@ if (!traceAlreadyInitialized && Env) {
     const storageDb = core.useDatabase?.(undefined, resolvedConnectionName);
     const observedDb = core.useDatabase?.(undefined, resolvedObservedConnectionName);
 
-    if (storageDb && observedDb) {
-      const storage = TraceWriteDiagnostics.wrapStorage(
-        TraceContentRedaction.wrapStorage(
-          TraceEntryFiltering.wrapStorage(TraceStorage.resolveStorage(storageDb), config),
-          config.redaction
-        ),
-        {
-          connectionName: resolvedConnectionName,
-          logger: core.Logger,
-        }
-      );
-
-      if (core.RequestContext) {
-        TraceContext.setRequestContextImpl(
-          core.RequestContext as {
-            current?: () => unknown;
-            peek?: () => unknown;
-          }
-        );
+    assertTraceConnectionResolved(core, storageDb, {
+      connectionName: resolvedConnectionName,
+      envKey: 'TRACE_DB_CONNECTION',
+    });
+    assertTraceConnectionResolved(core, observedDb, {
+      connectionName: resolvedObservedConnectionName,
+      envKey: 'TRACE_QUERY_CONNECTION',
+    });
+    await assertTraceStorageReady(core, storageDb, resolvedConnectionName);
+
+    const storage = TraceWriteDiagnostics.wrapStorage(
+      TraceContentRedaction.wrapStorage(
+        TraceEntryFiltering.wrapStorage(TraceStorage.resolveStorage(storageDb), config),
+        config.redaction
+      ),
+      {
+        connectionName: resolvedConnectionName,
+        logger: core.Logger,
       }
+    );
 
-      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'),
-      ]);
-
-      const watcherArgs = { storage, config, db: observedDb };
-
-      HttpWatcher.register({ ...watcherArgs, registerMiddleware: resolveRegisterMiddleware() });
-
-      QueryWatcher.register(watcherArgs);
-      LogWatcher.register(watcherArgs);
-      ExceptionWatcher.register(watcherArgs);
-      JobWatcher.register(watcherArgs);
-      CacheWatcher.register(watcherArgs);
-      ScheduleWatcher.register(watcherArgs);
-      MailWatcher.register(watcherArgs);
-      AuthWatcher.register(watcherArgs);
-      EventWatcher.register(watcherArgs);
-      ModelWatcher.register(watcherArgs);
-      NotificationWatcher.register(watcherArgs);
-      RedisWatcher.register(watcherArgs);
-      GateWatcher.register(watcherArgs);
-      MiddlewareWatcher.register(watcherArgs);
-      CommandWatcher.register(watcherArgs);
-      BatchWatcher.register(watcherArgs);
-      DumpWatcher.register(watcherArgs);
-      ViewWatcher.register(watcherArgs);
-      HttpClientWatcher.register(watcherArgs);
-    } else {
-      // eslint-disable-next-line no-console
-      console.warn('[trace] Could not resolve database connection - skipping init.');
+    if (core.RequestContext) {
+      TraceContext.setRequestContextImpl(
+        core.RequestContext as {
+          current?: () => unknown;
+          peek?: () => unknown;
+        }
+      );
     }
+
+    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'),
+    ]);
+
+    const watcherArgs = { storage, config, db: observedDb };
+
+    HttpWatcher.register({ ...watcherArgs, registerMiddleware: resolveRegisterMiddleware() });
+
+    QueryWatcher.register(watcherArgs);
+    LogWatcher.register(watcherArgs);
+    ExceptionWatcher.register(watcherArgs);
+    JobWatcher.register(watcherArgs);
+    CacheWatcher.register(watcherArgs);
+    ScheduleWatcher.register(watcherArgs);
+    MailWatcher.register(watcherArgs);
+    AuthWatcher.register(watcherArgs);
+    EventWatcher.register(watcherArgs);
+    ModelWatcher.register(watcherArgs);
+    NotificationWatcher.register(watcherArgs);
+    RedisWatcher.register(watcherArgs);
+    GateWatcher.register(watcherArgs);
+    MiddlewareWatcher.register(watcherArgs);
+    CommandWatcher.register(watcherArgs);
+    BatchWatcher.register(watcherArgs);
+    DumpWatcher.register(watcherArgs);
+    ViewWatcher.register(watcherArgs);
+    HttpClientWatcher.register(watcherArgs);
   }
 } else if (!traceAlreadyInitialized) {
   // Running outside a ZinTrust project - skip init silently.

package/src/watchers/LogWatcher.ts

@@ -21,8 +21,50 @@ const TRACE_INFRASTRUCTURE_LOG_MESSAGES = new Set<string>([
   '[trace] Trace storage write degraded',
 ]);
 
-const shouldSkipTraceInfrastructureLog = (message: string): boolean => {
-  return TRACE_INFRASTRUCTURE_LOG_MESSAGES.has(message.trim());
+const TRACE_STORAGE_TABLE_NAMES = [
+  'zin_trace_entries',
+  'zin_trace_entries_tags',
+  'zin_trace_monitoring',
+];
+
+const isTraceStorageQuery = (sql: string): boolean => {
+  const normalized = sql.toLowerCase();
+  return TRACE_STORAGE_TABLE_NAMES.some((tableName) => normalized.includes(tableName));
+};
+
+const extractSqlFromLog = (
+  message: string,
+  context?: Record<string, unknown>
+): string | undefined => {
+  const contextSql = context?.['sql'];
+  if (typeof contextSql === 'string') return contextSql;
+
+  const trimmed = message.trim();
+  const rawPrefix = 'Raw SQL Query executed:';
+  if (trimmed.startsWith(rawPrefix)) {
+    const sql = trimmed.slice(rawPrefix.length).trim();
+    return sql === '' ? undefined : sql;
+  }
+
+  return undefined;
+};
+
+const isTraceStorageQueryLog = (message: string, context?: Record<string, unknown>): boolean => {
+  const normalizedMessage = message.trim().toLowerCase();
+  if (!normalizedMessage.includes('query executed')) return false;
+
+  const sql = extractSqlFromLog(message, context);
+  return typeof sql === 'string' && isTraceStorageQuery(sql);
+};
+
+const shouldSkipTraceInfrastructureLog = (
+  message: string,
+  context?: Record<string, unknown>
+): boolean => {
+  return (
+    TRACE_INFRASTRUCTURE_LOG_MESSAGES.has(message.trim()) ||
+    isTraceStorageQueryLog(message, context)
+  );
 };
 
 export const LogWatcher: ITraceWatcher = Object.freeze({
@@ -41,7 +83,7 @@ export const LogWatcher: ITraceWatcher = Object.freeze({
       (level: string, message: string, context?: Record<string, unknown>) => {
         if ((LEVEL_PRIORITY[level] ?? 0) < minPriority) return;
         if (RequestFilter.shouldIgnoreCurrentRequest(config.ignoreRoutes)) return;
-        if (shouldSkipTraceInfrastructureLog(message)) return;
+        if (shouldSkipTraceInfrastructureLog(message, context)) return;
 
         const content: LogContent = {
           level,

package/src/watchers/QueryWatcher.ts

@@ -24,7 +24,11 @@ const bindingsInterpolated = (sql: string, params: unknown[]): string => {
 
 const isTraceStorageQuery = (sql: string): boolean => {
   const normalized = sql.toLowerCase();
-  return normalized.includes('zin_trace_entries') || normalized.includes('zin_trace_monitoring');
+  return (
+    normalized.includes('zin_trace_entries') ||
+    normalized.includes('zin_trace_entries_tags') ||
+    normalized.includes('zin_trace_monitoring')
+  );
 };
 
 const emit = (query: string, params: unknown[], duration: number, connection = 'default'): void => {