@zintrust/trace 1.5.2 → 1.6.1

package/dist/build-manifest.json

@@ -1,15 +1,15 @@
 {
   "name": "@zintrust/trace",
-  "version": "1.5.2",
-  "buildDate": "2026-04-25T12:38:43.860Z",
+  "version": "1.5.1",
+  "buildDate": "2026-04-28T16:08:58.961Z",
   "buildEnvironment": {
-    "node": "v20.20.2",
-    "platform": "linux",
-    "arch": "x64"
+    "node": "v22.22.1",
+    "platform": "darwin",
+    "arch": "arm64"
   },
   "git": {
-    "commit": "616b0d5d",
-    "branch": "master"
+    "commit": "6c6a3f59",
+    "branch": "release"
   },
   "package": {
     "engines": {
@@ -29,6 +29,10 @@
       "size": 4640,
       "sha256": "c51cc312046b6b2bbe1673f1ff9508425cc7140a1d2341907f67aa36069c09f9"
     },
+    "build-manifest.json": {
+      "size": 15912,
+      "sha256": "b7ce0234e13707d03336dbad905b5c1403a910880469504ec6cde78ad67fe9a9"
+    },
     "cli-register.d.ts": {
       "size": 255,
       "sha256": "da8d689fe5ef32e97e755f28017e4d3cb1aa63489073a71907ea41ad5761ede9"
@@ -83,7 +87,7 @@
     },
     "index.js": {
       "size": 3421,
-      "sha256": "199bd3c4a0618b7b336e3b866169656a0b49c8f527b083be87d44fe092518ad6"
+      "sha256": "6cab0d02424c088c23dce13c349f177993fd55f21864eea1842c2276a81ad526"
     },
     "ingest/TraceIngestGateway.d.ts": {
       "size": 786,
@@ -142,12 +146,20 @@
       "sha256": "2d05bec517f57634276220b8a946125059fe0e320c42295b4f5a985431bb3d1c"
     },
     "register.d.ts": {
-      "size": 16,
-      "sha256": "71d366165dd36f1675aa253a76262b226fb6c62e5ab632746b8aea61c0c625fc"
+      "size": 72,
+      "sha256": "535869aa1bfcdf0ec26fad27d7f18bb8822bc586c38fcc5ffdde5274ecbea17e"
     },
     "register.js": {
-      "size": 19822,
-      "sha256": "c553356d90c812f7de430d5679b1d44468131433e034ae2ea89e2876b1254444"
+      "size": 20927,
+      "sha256": "026fd79a98596d2be108b350668f4345b11020953f24369866c0aad42cd7ba0f"
+    },
+    "storage/DebuggerStorage.d.ts": {
+      "size": 517,
+      "sha256": "c9c215aaa414f7b0c1fec6c82b054fc52bdf97af58f96f35c7f96672fb859c31"
+    },
+    "storage/DebuggerStorage.js": {
+      "size": 7442,
+      "sha256": "5ecce0fcfcf695df587a7b90a7a5c7efd2e64ad13c9f2d104b392f89f34f0dc4"
     },
     "storage/ProxyTraceStorage.d.ts": {
       "size": 339,

package/dist/register.d.ts

@@ -1 +1,2 @@
 export type {};
+export declare const registerTraceReady: Promise<void>;

package/dist/register.js

@@ -131,249 +131,258 @@ const buildTraceRedactionOverrides = (input) => {
         ? redaction
         : undefined;
 };
-const core = (await importCore());
-const Env = core.Env;
-const startupOverrides = await resolveTraceStartupOverrides(core);
-if (!traceAlreadyInitialized && Env) {
+const readTraceEnvValues = (Env) => {
+    return {
+        connectionRaw: Env.get('TRACE_DB_CONNECTION', '').trim(),
+        observeConnectionRaw: Env.get('TRACE_QUERY_CONNECTION', '').trim(),
+        pruneAfterHoursRaw: Env.get('TRACE_PRUNE_HOURS', '').trim(),
+        slowQueryThresholdRaw: Env.get('TRACE_SLOW_QUERY_MS', '').trim(),
+        logMinLevelRaw: Env.get('TRACE_LOG_LEVEL', '').trim(),
+        traceProxyRaw: Env.get('TRACE_PROXY', '').trim(),
+        traceProxyUrlRaw: Env.get('TRACE_PROXY_URL', '').trim(),
+        traceProxyPathRaw: Env.get('TRACE_PROXY_PATH', '').trim(),
+        traceProxyKeyIdRaw: Env.get('TRACE_PROXY_KEY_ID', '').trim(),
+        traceProxySecretRaw: Env.get('TRACE_PROXY_SECRET', '').trim(),
+        traceProxyTimeoutRaw: Env.get('TRACE_PROXY_TIMEOUT_MS', '').trim(),
+        traceServiceTagRaw: Env.get('TRACE_SERVICE_TAG', '').trim(),
+        appNameRaw: Env.get('APP_NAME', '').trim(),
+        appKeyRaw: Env.get('APP_KEY', '').trim(),
+        captureCachePayloadsRaw: Env.get('TRACE_CACHE_PAYLOADS', '').trim(),
+        captureQueryBindingsRaw: Env.get('TRACE_QUERY_BINDINGS', '').trim(),
+        contentDispatchDriverRaw: Env.get('TRACE_CONTENT_QUEUE_DRIVER', '').trim(),
+        contentDispatchQueueRaw: Env.get('TRACE_CONTENT_QUEUE_NAME', '').trim(),
+        contentDispatchEnqueueTimeoutRaw: Env.get('TRACE_CONTENT_QUEUE_ENQUEUE_TIMEOUT_MS', '').trim(),
+        contentDispatchWorkerEnabledRaw: Env.get('TRACE_CONTENT_QUEUE_WORKER_ENABLED', '').trim(),
+        contentDispatchWorkerIntervalRaw: Env.get('TRACE_CONTENT_QUEUE_WORKER_INTERVAL_MS', '').trim(),
+        contentDispatchWorkerDurationRaw: Env.get('TRACE_CONTENT_QUEUE_WORKER_MAX_DURATION_MS', '').trim(),
+        contentDispatchWorkerConcurrencyRaw: Env.get('TRACE_CONTENT_QUEUE_WORKER_CONCURRENCY', '').trim(),
+        redactionKeys: parseEnvList(Env.get('TRACE_REDACT_KEYS', '')),
+        redactionHeaders: parseEnvList(Env.get('TRACE_REDACT_HEADERS', '')),
+        redactionBody: parseEnvList(Env.get('TRACE_REDACT_BODY', '')),
+        redactionQuery: parseEnvList(Env.get('TRACE_REDACT_QUERY', '')),
+    };
+};
+const resolveStringOverride = (rawValue, fallback) => {
+    return rawValue === '' ? fallback : rawValue;
+};
+const resolveNumberOverride = (rawValue, fallback) => {
+    return rawValue === '' ? fallback : Number.parseInt(rawValue, 10);
+};
+const resolveBooleanOverride = (rawValue, fallback) => {
+    return parseEnvBool(rawValue) ?? fallback;
+};
+const resolveTraceProxyKeyId = (startupOverrides, values) => {
+    return resolveStringOverride(values.traceProxyKeyIdRaw, startupOverrides?.proxy?.keyId ?? values.appNameRaw);
+};
+const resolveTraceProxySecret = (startupOverrides, values) => {
+    return resolveStringOverride(values.traceProxySecretRaw, startupOverrides?.proxy?.secret ?? values.appKeyRaw);
+};
+const withStringProperty = (key, value) => {
+    return typeof value === 'string' && value !== '' ? { [key]: value } : {};
+};
+const withNumberProperty = (key, value) => {
+    return typeof value === 'number' && Number.isFinite(value) ? { [key]: value } : {};
+};
+const withBooleanProperty = (key, value) => {
+    return typeof value === 'boolean' ? { [key]: value } : {};
+};
+const resolveTraceServiceTag = (startupOverrides, values) => {
+    const fallback = (startupOverrides?.serviceTag ?? values.appNameRaw).trim() || undefined;
+    return resolveStringOverride(values.traceServiceTagRaw, fallback);
+};
+const resolveContentDispatchWorkerEnabled = (startupOverrides, values) => {
+    return resolveBooleanOverride(values.contentDispatchWorkerEnabledRaw, startupOverrides?.contentDispatch?.worker?.enabled);
+};
+const resolveContentDispatchWorkerInterval = (startupOverrides, values) => {
+    return resolveNumberOverride(values.contentDispatchWorkerIntervalRaw, startupOverrides?.contentDispatch?.worker?.intervalMs);
+};
+const resolveContentDispatchWorkerDuration = (startupOverrides, values) => {
+    return resolveNumberOverride(values.contentDispatchWorkerDurationRaw, startupOverrides?.contentDispatch?.worker?.maxDurationMs);
+};
+const resolveContentDispatchWorkerConcurrency = (startupOverrides, values) => {
+    return resolveNumberOverride(values.contentDispatchWorkerConcurrencyRaw, startupOverrides?.contentDispatch?.worker?.concurrency);
+};
+const buildTraceContentDispatchWorkerConfig = (startupOverrides, values) => {
+    const defaultWorker = TraceConfig.defaults().contentDispatch.worker;
+    const startupWorker = startupOverrides?.contentDispatch?.worker;
+    const contentDispatchWorkerEnabled = resolveContentDispatchWorkerEnabled(startupOverrides, values);
+    const contentDispatchWorkerInterval = resolveContentDispatchWorkerInterval(startupOverrides, values);
+    const contentDispatchWorkerDuration = resolveContentDispatchWorkerDuration(startupOverrides, values);
+    const contentDispatchWorkerConcurrency = resolveContentDispatchWorkerConcurrency(startupOverrides, values);
+    return {
+        ...defaultWorker,
+        ...startupWorker,
+        enabled: contentDispatchWorkerEnabled ?? startupWorker?.enabled ?? defaultWorker.enabled,
+        intervalMs: contentDispatchWorkerInterval ?? startupWorker?.intervalMs ?? defaultWorker.intervalMs,
+        maxDurationMs: contentDispatchWorkerDuration ?? startupWorker?.maxDurationMs ?? defaultWorker.maxDurationMs,
+        concurrency: contentDispatchWorkerConcurrency ?? startupWorker?.concurrency ?? defaultWorker.concurrency,
+    };
+};
+const buildTraceProxyConfig = (startupOverrides, values) => {
+    const traceProxyEnabled = resolveBooleanOverride(values.traceProxyRaw, startupOverrides?.proxy?.enabled);
+    const traceProxyUrl = resolveStringOverride(values.traceProxyUrlRaw, startupOverrides?.proxy?.url);
+    const traceProxyPath = resolveStringOverride(values.traceProxyPathRaw, startupOverrides?.proxy?.path);
+    const traceProxyKeyId = resolveTraceProxyKeyId(startupOverrides, values);
+    const traceProxySecret = resolveTraceProxySecret(startupOverrides, values);
+    const traceProxyTimeout = resolveNumberOverride(values.traceProxyTimeoutRaw, startupOverrides?.proxy?.timeoutMs);
+    return {
+        ...TraceConfig.defaults().proxy,
+        ...startupOverrides?.proxy,
+        ...withBooleanProperty('enabled', traceProxyEnabled),
+        ...withStringProperty('url', traceProxyUrl),
+        ...withStringProperty('path', traceProxyPath),
+        ...withStringProperty('keyId', traceProxyKeyId),
+        ...withStringProperty('secret', traceProxySecret),
+        ...withNumberProperty('timeoutMs', traceProxyTimeout),
+    };
+};
+const buildTraceContentDispatchConfig = (startupOverrides, values) => {
+    const defaultContentDispatch = TraceConfig.defaults().contentDispatch;
+    const startupContentDispatch = startupOverrides?.contentDispatch;
+    const contentDispatchDriver = resolveStringOverride(values.contentDispatchDriverRaw, startupContentDispatch?.driver);
+    const contentDispatchQueueName = resolveStringOverride(values.contentDispatchQueueRaw, startupContentDispatch?.queueName);
+    const contentDispatchEnqueueTimeout = resolveNumberOverride(values.contentDispatchEnqueueTimeoutRaw, startupContentDispatch?.enqueueTimeoutMs);
+    return {
+        ...defaultContentDispatch,
+        ...startupContentDispatch,
+        ...withStringProperty('driver', contentDispatchDriver),
+        ...withStringProperty('queueName', contentDispatchQueueName),
+        ...withNumberProperty('enqueueTimeoutMs', contentDispatchEnqueueTimeout),
+        worker: buildTraceContentDispatchWorkerConfig(startupOverrides, values),
+    };
+};
+const buildTraceRuntimeConfig = (Env, startupOverrides) => {
+    const values = readTraceEnvValues(Env);
     const enabled = startupOverrides?.enabled === true || Env.getBool('TRACE_ENABLED', false);
-    if (enabled) {
-        const connectionRaw = Env.get('TRACE_DB_CONNECTION', '').trim();
-        const observeConnectionRaw = Env.get('TRACE_QUERY_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 traceProxyRaw = Env.get('TRACE_PROXY', '').trim();
-        const traceProxyUrlRaw = Env.get('TRACE_PROXY_URL', '').trim();
-        const traceProxyPathRaw = Env.get('TRACE_PROXY_PATH', '').trim();
-        const traceProxyKeyIdRaw = Env.get('TRACE_PROXY_KEY_ID', '').trim();
-        const traceProxySecretRaw = Env.get('TRACE_PROXY_SECRET', '').trim();
-        const traceProxyTimeoutRaw = Env.get('TRACE_PROXY_TIMEOUT_MS', '').trim();
-        const traceServiceTagRaw = Env.get('TRACE_SERVICE_TAG', '').trim();
-        const appNameRaw = Env.get('APP_NAME', '').trim();
-        const appKeyRaw = Env.get('APP_KEY', '').trim();
-        const captureCachePayloadsRaw = Env.get('TRACE_CACHE_PAYLOADS', '').trim();
-        const captureQueryBindingsRaw = Env.get('TRACE_QUERY_BINDINGS', '').trim();
-        const contentDispatchDriverRaw = Env.get('TRACE_CONTENT_QUEUE_DRIVER', '').trim();
-        const contentDispatchQueueRaw = Env.get('TRACE_CONTENT_QUEUE_NAME', '').trim();
-        const contentDispatchEnqueueTimeoutRaw = Env.get('TRACE_CONTENT_QUEUE_ENQUEUE_TIMEOUT_MS', '').trim();
-        const contentDispatchWorkerEnabledRaw = Env.get('TRACE_CONTENT_QUEUE_WORKER_ENABLED', '').trim();
-        const contentDispatchWorkerIntervalRaw = Env.get('TRACE_CONTENT_QUEUE_WORKER_INTERVAL_MS', '').trim();
-        const contentDispatchWorkerDurationRaw = Env.get('TRACE_CONTENT_QUEUE_WORKER_MAX_DURATION_MS', '').trim();
-        const contentDispatchWorkerConcurrencyRaw = Env.get('TRACE_CONTENT_QUEUE_WORKER_CONCURRENCY', '').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 observeConnection = observeConnectionRaw === '' ? startupOverrides?.observeConnection : observeConnectionRaw;
-        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 captureCachePayloads = parseEnvBool(captureCachePayloadsRaw) ?? startupOverrides?.captureCachePayloads;
-        const captureQueryBindings = parseEnvBool(captureQueryBindingsRaw) ?? startupOverrides?.captureQueryBindings;
-        const traceProxyEnabled = parseEnvBool(traceProxyRaw) ?? startupOverrides?.proxy?.enabled;
-        const traceProxyUrl = traceProxyUrlRaw === '' ? startupOverrides?.proxy?.url : traceProxyUrlRaw;
-        const traceProxyPath = traceProxyPathRaw === '' ? startupOverrides?.proxy?.path : traceProxyPathRaw;
-        const traceProxyKeyId = traceProxyKeyIdRaw === ''
-            ? (startupOverrides?.proxy?.keyId ?? appNameRaw)
-            : traceProxyKeyIdRaw;
-        const traceProxySecret = traceProxySecretRaw === ''
-            ? (startupOverrides?.proxy?.secret ?? appKeyRaw)
-            : traceProxySecretRaw;
-        const traceProxyTimeout = traceProxyTimeoutRaw === ''
-            ? startupOverrides?.proxy?.timeoutMs
-            : Number.parseInt(traceProxyTimeoutRaw, 10);
-        const traceServiceTag = traceServiceTagRaw === ''
-            ? (startupOverrides?.serviceTag ?? appNameRaw).trim() || undefined
-            : traceServiceTagRaw;
-        const contentDispatchDriver = contentDispatchDriverRaw === ''
-            ? startupOverrides?.contentDispatch?.driver
-            : contentDispatchDriverRaw;
-        const contentDispatchQueueName = contentDispatchQueueRaw === ''
-            ? startupOverrides?.contentDispatch?.queueName
-            : contentDispatchQueueRaw;
-        const contentDispatchEnqueueTimeout = contentDispatchEnqueueTimeoutRaw === ''
-            ? startupOverrides?.contentDispatch?.enqueueTimeoutMs
-            : Number.parseInt(contentDispatchEnqueueTimeoutRaw, 10);
-        const contentDispatchWorkerEnabled = parseEnvBool(contentDispatchWorkerEnabledRaw) ??
-            startupOverrides?.contentDispatch?.worker?.enabled;
-        const contentDispatchWorkerInterval = contentDispatchWorkerIntervalRaw === ''
-            ? startupOverrides?.contentDispatch?.worker?.intervalMs
-            : Number.parseInt(contentDispatchWorkerIntervalRaw, 10);
-        const contentDispatchWorkerDuration = contentDispatchWorkerDurationRaw === ''
-            ? startupOverrides?.contentDispatch?.worker?.maxDurationMs
-            : Number.parseInt(contentDispatchWorkerDurationRaw, 10);
-        const contentDispatchWorkerConcurrency = contentDispatchWorkerConcurrencyRaw === ''
-            ? startupOverrides?.contentDispatch?.worker?.concurrency
-            : Number.parseInt(contentDispatchWorkerConcurrencyRaw, 10);
-        const redaction = buildTraceRedactionOverrides({
-            startupOverrides,
-            redactionBody,
-            redactionHeaders,
-            redactionKeys,
-            redactionQuery,
-        });
-        const defaultContentDispatch = TraceConfig.defaults().contentDispatch;
-        const startupContentDispatch = startupOverrides?.contentDispatch;
-        const startupContentDispatchWorker = startupContentDispatch?.worker;
-        const config = TraceConfig.merge({
-            ...startupOverrides,
-            enabled,
-            connection,
-            observeConnection,
-            ...(typeof traceServiceTag === 'string' && traceServiceTag !== ''
-                ? { serviceTag: traceServiceTag }
-                : {}),
-            proxy: {
-                ...TraceConfig.defaults().proxy,
-                ...startupOverrides?.proxy,
-                ...(typeof traceProxyEnabled === 'boolean' ? { enabled: traceProxyEnabled } : {}),
-                ...(typeof traceProxyUrl === 'string' && traceProxyUrl !== ''
-                    ? { url: traceProxyUrl }
-                    : {}),
-                ...(typeof traceProxyPath === 'string' && traceProxyPath !== ''
-                    ? { path: traceProxyPath }
-                    : {}),
-                ...(typeof traceProxyKeyId === 'string' && traceProxyKeyId !== ''
-                    ? { keyId: traceProxyKeyId }
-                    : {}),
-                ...(typeof traceProxySecret === 'string' && traceProxySecret !== ''
-                    ? { secret: traceProxySecret }
-                    : {}),
-                ...(typeof traceProxyTimeout === 'number' && Number.isFinite(traceProxyTimeout)
-                    ? { timeoutMs: traceProxyTimeout }
-                    : {}),
-            },
-            ...(typeof pruneAfterHours === 'number' && Number.isFinite(pruneAfterHours)
-                ? { pruneAfterHours }
-                : {}),
-            ...(typeof slowQueryThreshold === 'number' && Number.isFinite(slowQueryThreshold)
-                ? { slowQueryThreshold }
-                : {}),
-            ...(typeof captureCachePayloads === 'boolean' ? { captureCachePayloads } : {}),
-            ...(typeof captureQueryBindings === 'boolean' ? { captureQueryBindings } : {}),
-            contentDispatch: {
-                ...defaultContentDispatch,
-                ...startupContentDispatch,
-                ...(typeof contentDispatchDriver === 'string' && contentDispatchDriver !== ''
-                    ? { driver: contentDispatchDriver }
-                    : {}),
-                ...(typeof contentDispatchQueueName === 'string' && contentDispatchQueueName !== ''
-                    ? { queueName: contentDispatchQueueName }
-                    : {}),
-                ...(typeof contentDispatchEnqueueTimeout === 'number' &&
-                    Number.isFinite(contentDispatchEnqueueTimeout)
-                    ? { enqueueTimeoutMs: contentDispatchEnqueueTimeout }
-                    : {}),
-                worker: {
-                    ...defaultContentDispatch.worker,
-                    ...startupContentDispatchWorker,
-                    enabled: typeof contentDispatchWorkerEnabled === 'boolean'
-                        ? contentDispatchWorkerEnabled
-                        : (startupContentDispatchWorker?.enabled ?? defaultContentDispatch.worker.enabled),
-                    intervalMs: typeof contentDispatchWorkerInterval === 'number' &&
-                        Number.isFinite(contentDispatchWorkerInterval)
-                        ? contentDispatchWorkerInterval
-                        : (startupContentDispatchWorker?.intervalMs ??
-                            defaultContentDispatch.worker.intervalMs),
-                    maxDurationMs: typeof contentDispatchWorkerDuration === 'number' &&
-                        Number.isFinite(contentDispatchWorkerDuration)
-                        ? contentDispatchWorkerDuration
-                        : (startupContentDispatchWorker?.maxDurationMs ??
-                            defaultContentDispatch.worker.maxDurationMs),
-                    concurrency: typeof contentDispatchWorkerConcurrency === 'number' &&
-                        Number.isFinite(contentDispatchWorkerConcurrency)
-                        ? contentDispatchWorkerConcurrency
-                        : (startupContentDispatchWorker?.concurrency ??
-                            defaultContentDispatch.worker.concurrency),
-                },
-            },
-            logMinLevel,
-            ...(redaction === undefined ? {} : { redaction }),
-        });
-        const resolvedConnectionName = resolveTraceConnectionName(Env, config.connection);
-        const resolvedObservedConnectionName = resolveObservedConnectionName(Env, config.observeConnection, resolvedConnectionName);
-        globalTraceRegisterState.__zintrust_system_trace_connection_name__ = resolvedConnectionName;
-        globalTraceRegisterState.__zintrust_system_trace_observe_connection_name__ =
-            resolvedObservedConnectionName;
-        const storageDb = core.useDatabase?.(undefined, resolvedConnectionName);
-        const observedDb = core.useDatabase?.(undefined, resolvedObservedConnectionName);
-        assertTraceConnectionResolved(core, storageDb, {
-            connectionName: resolvedConnectionName,
-            envKey: 'TRACE_DB_CONNECTION',
-        });
-        assertTraceConnectionResolved(core, observedDb, {
-            connectionName: resolvedObservedConnectionName,
-            envKey: 'TRACE_QUERY_CONNECTION',
-        });
-        await assertTraceStorageReady(core, storageDb, resolvedConnectionName);
-        const resolvedStorage = config.proxy.enabled
-            ? ProxyTraceStorage.create({
-                baseUrl: config.proxy.url ?? '',
-                path: config.proxy.path,
-                keyId: config.proxy.keyId ?? '',
-                secret: config.proxy.secret ?? '',
-                timeoutMs: config.proxy.timeoutMs,
-            })
-            : TraceStorage.resolveStorage(storageDb);
-        const storage = TraceWriteDiagnostics.wrapStorage(TraceContentBudget.wrapStorage(TraceContentRedaction.wrapStorage(TraceEntryFiltering.wrapStorage(TraceServiceTag.wrapStorage(resolvedStorage, config), config), config.redaction), config), {
-            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);
+    const connection = resolveStringOverride(values.connectionRaw, startupOverrides?.connection);
+    const observeConnection = resolveStringOverride(values.observeConnectionRaw, startupOverrides?.observeConnection);
+    const pruneAfterHours = resolveNumberOverride(values.pruneAfterHoursRaw, startupOverrides?.pruneAfterHours);
+    const slowQueryThreshold = resolveNumberOverride(values.slowQueryThresholdRaw, startupOverrides?.slowQueryThreshold);
+    const logMinLevel = (values.logMinLevelRaw === '' ? startupOverrides?.logMinLevel : values.logMinLevelRaw);
+    const captureCachePayloads = resolveBooleanOverride(values.captureCachePayloadsRaw, startupOverrides?.captureCachePayloads);
+    const captureQueryBindings = resolveBooleanOverride(values.captureQueryBindingsRaw, startupOverrides?.captureQueryBindings);
+    const traceServiceTag = resolveTraceServiceTag(startupOverrides, values);
+    const redaction = buildTraceRedactionOverrides({
+        startupOverrides,
+        redactionBody: values.redactionBody,
+        redactionHeaders: values.redactionHeaders,
+        redactionKeys: values.redactionKeys,
+        redactionQuery: values.redactionQuery,
+    });
+    return TraceConfig.merge({
+        ...startupOverrides,
+        enabled,
+        connection,
+        observeConnection,
+        ...withStringProperty('serviceTag', traceServiceTag),
+        proxy: buildTraceProxyConfig(startupOverrides, values),
+        ...withNumberProperty('pruneAfterHours', pruneAfterHours),
+        ...withNumberProperty('slowQueryThreshold', slowQueryThreshold),
+        ...withBooleanProperty('captureCachePayloads', captureCachePayloads),
+        ...withBooleanProperty('captureQueryBindings', captureQueryBindings),
+        contentDispatch: buildTraceContentDispatchConfig(startupOverrides, values),
+        logMinLevel,
+        ...(redaction === undefined ? {} : { redaction }),
+    });
+};
+const createTraceWatcherArgs = async (core, Env, config) => {
+    const resolvedConnectionName = resolveTraceConnectionName(Env, config.connection);
+    const resolvedObservedConnectionName = resolveObservedConnectionName(Env, config.observeConnection, resolvedConnectionName);
+    globalTraceRegisterState.__zintrust_system_trace_connection_name__ = resolvedConnectionName;
+    globalTraceRegisterState.__zintrust_system_trace_observe_connection_name__ =
+        resolvedObservedConnectionName;
+    const storageDb = core.useDatabase?.(undefined, resolvedConnectionName);
+    const observedDb = core.useDatabase?.(undefined, resolvedObservedConnectionName);
+    assertTraceConnectionResolved(core, storageDb, {
+        connectionName: resolvedConnectionName,
+        envKey: 'TRACE_DB_CONNECTION',
+    });
+    assertTraceConnectionResolved(core, observedDb, {
+        connectionName: resolvedObservedConnectionName,
+        envKey: 'TRACE_QUERY_CONNECTION',
+    });
+    await assertTraceStorageReady(core, storageDb, resolvedConnectionName);
+    const resolvedStorage = config.proxy.enabled
+        ? ProxyTraceStorage.create({
+            baseUrl: config.proxy.url ?? '',
+            path: config.proxy.path,
+            keyId: config.proxy.keyId ?? '',
+            secret: config.proxy.secret ?? '',
+            timeoutMs: config.proxy.timeoutMs,
+        })
+        : TraceStorage.resolveStorage(storageDb);
+    const storage = TraceWriteDiagnostics.wrapStorage(TraceContentBudget.wrapStorage(TraceContentRedaction.wrapStorage(TraceEntryFiltering.wrapStorage(TraceServiceTag.wrapStorage(resolvedStorage, config), config), config.redaction), config), {
+        connectionName: resolvedConnectionName,
+        logger: core.Logger,
+    });
+    return { storage, config, db: observedDb };
+};
+const registerTraceWatchers = async (watcherArgs) => {
+    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'),
+    ]);
+    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);
+};
+const activateTrace = async (core, Env, startupOverrides) => {
+    const config = buildTraceRuntimeConfig(Env, startupOverrides);
+    if (!config.enabled)
+        return;
+    const watcherArgs = await createTraceWatcherArgs(core, Env, config);
+    if (core.RequestContext) {
+        TraceContext.setRequestContextImpl(core.RequestContext);
     }
-}
-else if (!traceAlreadyInitialized) {
-    // Running outside a ZinTrust project - skip init silently.
-    // eslint-disable-next-line no-console
-    console.warn('[trace] @zintrust/core not found - trace will not be activated.');
-}
+    await registerTraceWatchers(watcherArgs);
+};
+const initializeTraceRegister = async () => {
+    const core = (await importCore());
+    const Env = core.Env;
+    const startupOverrides = await resolveTraceStartupOverrides(core);
+    if (!traceAlreadyInitialized && Env) {
+        await activateTrace(core, Env, startupOverrides);
+        return;
+    }
+    if (!traceAlreadyInitialized) {
+        // Running outside a ZinTrust project - skip init silently.
+        // eslint-disable-next-line no-console
+        console.warn('[trace] @zintrust/core not found - trace will not be activated.');
+    }
+};
+export const registerTraceReady = initializeTraceRegister();

package/dist/storage/DebuggerStorage.d.ts

@@ -0,0 +1,13 @@
+/**
+ * TraceStorage — sealed namespace wrapping the D1/SQLite driver.
+ * Resolves the correct IDatabase from the app config, then delegates all
+ * read/write operations to the trace storage facade.
+ */
+import type { IDatabase } from '@zintrust/core';
+import type { ITraceStorage } from '../types';
+export declare const TraceStorage: Readonly<{
+    resolveStorage: (db: IDatabase) => ITraceStorage;
+    reset: () => void;
+    familyHash: (input: string) => string;
+}>;
+export { type ITraceStorage } from '../types';