@reproapp/node-sdk 0.0.47 → 0.0.49

package/src/index.ts

@@ -2,7 +2,7 @@ import type { Request, Response, NextFunction } from 'express';
 import type { Schema, Model, Query } from 'mongoose';
 import * as mongoose from 'mongoose';
 import { AsyncLocalStorage } from 'async_hooks';
-import { randomUUID } from 'crypto';
+import { createHash, createHmac, randomUUID } from 'crypto';
 import { createRequire } from 'module';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
@@ -28,6 +28,7 @@ import {
     type RuntimePrivacySurface,
     type RuntimePrivacyTraceContext,
 } from './privacy';
+import { projectSemanticInfrastructureValue } from './semantic-serialization';
 
 /**
  * ============================= IMPORTANT =============================
@@ -418,6 +419,7 @@ type TraceValueBatchEntry = {
 };
 
 type TraceMaterializationConfig = {
+    tenantId: string;
     appId: string;
     appSecret?: string;
     appName?: string;
@@ -431,6 +433,7 @@ type TraceMaterializationWorkerPayload = {
     masking: NormalizedMaskingConfig | null;
     privacy: NormalizedRuntimePrivacyPolicy | null;
     fullValueCaptureEnabled: boolean;
+    valueNamespace?: string;
 };
 
 type TraceMaterializationWorkerRequest = {
@@ -1224,6 +1227,8 @@ type RequestCaptureScopeState = {
     privacyMode: 'policy' | 'fallback' | 'raw';
     privacyPolicyFingerprint?: string;
     privacyStatementCount: number;
+    emittedValueDefinitionIds: Set<string>;
+    traceObservationSnapshots: Map<string, any>;
 };
 
 function createRequestCaptureScope(
@@ -1251,6 +1256,8 @@ function createRequestCaptureScope(
         privacyMode,
         privacyPolicyFingerprint: privacy?.fingerprint,
         privacyStatementCount: privacy?.statements.length ?? 0,
+        emittedValueDefinitionIds: new Set(),
+        traceObservationSnapshots: new Map(),
     };
 }
 
@@ -2828,7 +2835,11 @@ const TRACE_MAX_EVENTS_PER_REQUEST = (() => {
 const TRACE_MAX_BATCHES_PER_REQUEST = (() => {
     const env = Number(process.env.REPRO_TRACE_MAX_BATCHES_PER_REQUEST);
     if (Number.isFinite(env) && env > 0) return Math.trunc(env);
-    return Math.ceil(TRACE_MAX_EVENTS_PER_REQUEST / TRACE_BATCH_SIZE);
+    // Byte-based splitting can legitimately produce one batch per event when
+    // every event owns a distinct large value. The event limit remains the
+    // hard upper bound; deriving this from the count-only batch size silently
+    // dropped otherwise valid events after ten batches.
+    return TRACE_MAX_EVENTS_PER_REQUEST;
 })();
 const TRACE_FLUSH_DELAY_MS = 20;
 // Choose how to order trace events in payloads.
@@ -3180,6 +3191,17 @@ function sanitizeTraceValue(
     const mongoPlaceholder = describeMongoPlaceholder(value);
     if (mongoPlaceholder) return mongoPlaceholder;
 
+    const semanticProjection = projectSemanticInfrastructureValue(value);
+    if (semanticProjection) {
+        return sanitizeTraceValue(
+            semanticProjection.value,
+            depth,
+            seen,
+            options,
+            valuePath,
+        );
+    }
+
     if (isThenable(value)) {
         return { __type: 'Promise', state: 'pending' };
     }
@@ -3383,6 +3405,107 @@ function hasMeaningfulRawTraceError(error: any): boolean {
     return error !== undefined && error !== null;
 }
 
+const TRACE_OBSERVATION_SNAPSHOT = Symbol('repro.traceObservationSnapshot');
+
+// Trace events can remain queued after user code mutates the observed objects.
+// Intern immutable semantic snapshots per request so temporal evidence stays
+// correct without retaining another full copy for repeated unchanged values.
+function internTraceObservationSnapshot(
+    snapshot: any,
+    captureScope?: RequestCaptureScopeState | null,
+): any {
+    if (!captureScope || snapshot === null || typeof snapshot !== 'object') {
+        return snapshot;
+    }
+
+    const serialized = stableSerializeTraceValue(snapshot);
+    if (serialized === null) return snapshot;
+
+    const digest = createHash('sha256')
+        .update('repro-trace-observation-v1\0')
+        .update(serialized)
+        .digest('hex');
+    const existing = captureScope.traceObservationSnapshots.get(digest);
+    if (existing !== undefined) return existing;
+
+    captureScope.traceObservationSnapshots.set(digest, snapshot);
+    return snapshot;
+}
+
+function snapshotTraceValueAtObservation(
+    value: any,
+    captureScope?: RequestCaptureScopeState | null,
+    valuePath = '$',
+    target = 'trace.value',
+): any {
+    try {
+        const snapshot = sanitizeTraceValue(
+            value,
+            0,
+            new WeakMap(),
+            { preserveLongStrings: true, disableTruncation: true },
+            valuePath,
+        );
+        return internTraceObservationSnapshot(snapshot, captureScope);
+    } catch {
+        recordRequestCaptureFailure(
+            captureScope,
+            'trace.snapshot',
+            target,
+            'snapshot_failed',
+        );
+        return makeOmittedValue('capture-snapshot-failed');
+    }
+}
+
+function snapshotTraceArgsAtObservation(
+    values: any,
+    captureScope?: RequestCaptureScopeState | null,
+): any[] {
+    const snapshot = snapshotTraceValueAtObservation(
+        normalizeRawTraceArgs(values),
+        captureScope,
+        '$',
+        'trace.args',
+    );
+    return Array.isArray(snapshot) ? snapshot : [snapshot];
+}
+
+function snapshotRawTraceEventAtObservation(
+    raw: any,
+    captureScope?: RequestCaptureScopeState | null,
+): any {
+    if (!raw || typeof raw !== 'object' || raw[TRACE_OBSERVATION_SNAPSHOT] === true) {
+        return raw;
+    }
+
+    const snapshot = { ...raw };
+    if (raw.args !== undefined) {
+        snapshot.args = snapshotTraceArgsAtObservation(raw.args, captureScope);
+    }
+    if (raw.returnValue !== undefined) {
+        snapshot.returnValue = snapshotTraceValueAtObservation(
+            raw.returnValue,
+            captureScope,
+            '$',
+            'trace.returnValue',
+        );
+    }
+    if (hasMeaningfulRawTraceError(raw.error)) {
+        snapshot.error = snapshotTraceValueAtObservation(
+            raw.error,
+            captureScope,
+            '$',
+            'trace.error',
+        );
+    }
+    Object.defineProperty(snapshot, TRACE_OBSERVATION_SNAPSHOT, {
+        value: true,
+        enumerable: false,
+    });
+    return snapshot;
+}
+
 function attachTraceValueEntry(
     event: TraceEventRecord | PendingTraceEventRecord,
     entry: TraceValueBatchEntry,
@@ -3403,6 +3526,7 @@ async function materializePendingTraceEvents(
         masking: NormalizedMaskingConfig | null;
         resolvePrivacy: () => NormalizedRuntimePrivacyPolicy | null;
         captureScope?: RequestCaptureScopeState | null;
+        valueNamespace?: string;
     },
 ): Promise<TraceEventRecord[]> {
     for (const evt of events) {
@@ -3420,6 +3544,7 @@ async function materializePendingTraceEvents(
             trace: candidate,
             masking: params.masking,
             privacy: activePrivacy,
+            valueNamespace: params.valueNamespace,
         };
         const traceValueMetadata = {
             fn: evt.fn,
@@ -3556,6 +3681,7 @@ async function materializePendingTraceEventsAsync(
         masking: NormalizedMaskingConfig | null;
         resolvePrivacy: () => NormalizedRuntimePrivacyPolicy | null;
         captureScope?: RequestCaptureScopeState | null;
+        valueNamespace?: string;
     },
 ): Promise<TraceEventRecord[]> {
     if (!events.some((evt) => evt.__reproPending)) {
@@ -3583,6 +3709,7 @@ async function materializePendingTraceEventsAsync(
         return await materializePendingTraceEventsOffThread(events, {
             events,
             cfg: {
+                tenantId: params.cfg.tenantId,
                 appId: params.cfg.appId,
                 appSecret: params.cfg.appSecret,
                 appName: params.cfg.appName,
@@ -3592,6 +3719,7 @@ async function materializePendingTraceEventsAsync(
             masking: params.masking,
             privacy,
             fullValueCaptureEnabled: __FULL_VALUE_CAPTURE_ENABLED,
+            valueNamespace: params.valueNamespace,
         });
     } catch (err) {
         try {
@@ -3627,6 +3755,7 @@ export async function __materializePendingTraceEventsForWorker(
             maskReq: payload.maskReq,
             masking: payload.masking,
             resolvePrivacy: () => payload.privacy,
+            valueNamespace: payload.valueNamespace,
         });
         return materialized.map((event) => {
             const entries = getEventTraceValueEntries(event);
@@ -4435,6 +4564,7 @@ type FullValueCaptureContext = {
     masking: NormalizedMaskingConfig | null;
     privacy: NormalizedRuntimePrivacyPolicy | null;
     db?: RuntimePrivacyDbContext | null;
+    valueNamespace?: string;
 };
 
 const TRACE_FULL_VALUE_ENTRY_SYMBOL = Symbol('repro.traceFullValueEntries');
@@ -4840,6 +4970,18 @@ function cloneFullValueCandidate(
     const mongoPlaceholder = describeMongoPlaceholder(value);
     if (mongoPlaceholder) return undefined;
 
+    const semanticProjection = projectSemanticInfrastructureValue(value);
+    if (semanticProjection) {
+        return cloneFullValueCandidate(
+            semanticProjection.value,
+            ctx,
+            limits,
+            depth,
+            seen,
+            valuePath,
+        );
+    }
+
     if (isThenable(value)) return undefined;
     if (shouldSkipFullValueObject(value)) return undefined;
 
@@ -5067,6 +5209,18 @@ async function cloneFullValueCandidateAsync(
     const mongoPlaceholder = describeMongoPlaceholder(value);
     if (mongoPlaceholder) return undefined;
 
+    const semanticProjection = projectSemanticInfrastructureValue(value);
+    if (semanticProjection) {
+        return cloneFullValueCandidateAsync(
+            semanticProjection.value,
+            ctx,
+            limits,
+            depth,
+            seen,
+            valuePath,
+        );
+    }
+
     if (isThenable(value)) return undefined;
     if (shouldSkipFullValueObject(value)) return undefined;
 
@@ -5213,12 +5367,18 @@ function getEventTraceValueEntries(event: TraceEventRecord | PendingTraceEventRe
     return undefined;
 }
 
-function collectBatchTraceValueEntries(batch: TraceEventRecord[], batchIndex: number): TraceValueBatchEntry[] {
+function collectBatchTraceValueEntries(
+    batch: TraceEventRecord[],
+    batchIndex: number,
+    emittedValueIds: Set<string> = new Set(),
+): TraceValueBatchEntry[] {
     const collected: TraceValueBatchEntry[] = [];
     batch.forEach((event, eventIndex) => {
         const entries = getEventTraceValueEntries(event);
         if (!Array.isArray(entries) || !entries.length) return;
         entries.forEach((entry) => {
+            if (emittedValueIds.has(entry.id)) return;
+            emittedValueIds.add(entry.id);
             collected.push({
                 ...entry,
                 batchIndex,
@@ -5237,13 +5397,44 @@ function serializedByteLength(value: any): number {
     }
 }
 
+function contentAddressedValueId(
+    target: TraceValueBatchEntry['target'],
+    candidateSerialized: string,
+    capture: FullValueCaptureContext,
+): string {
+    const config = capture.runtimeConfig;
+    const signingKey = String(
+        config.appSecret ||
+        `${config.tenantId || 'tenant'}:${config.appId || 'app'}`,
+    );
+    const namespace = String(
+        capture.valueNamespace ||
+        `${config.tenantId || 'tenant'}:${config.appId || 'app'}`,
+    );
+    const digest = createHmac('sha256', signingKey)
+        .update('repro-captured-value-v1\0')
+        .update(namespace)
+        .update('\0')
+        .update(target)
+        .update('\0')
+        .update(candidateSerialized)
+        .digest('hex')
+        .slice(0, 40);
+    return `rv1_${digest}`;
+}
+
 function estimateTraceBatchSerializedBytes(
     batch: TraceEventRecord[],
     requestRid: string,
     actionId: string | null | undefined,
     batchIndex: number,
+    previouslyEmittedValueIds: ReadonlySet<string> = new Set(),
 ): number {
-    const traceValues = collectBatchTraceValueEntries(batch, batchIndex);
+    const traceValues = collectBatchTraceValueEntries(
+        batch,
+        batchIndex,
+        new Set(previouslyEmittedValueIds),
+    );
     return serializedByteLength({
         actionId: actionId ?? null,
         trace: batch,
@@ -5267,15 +5458,26 @@ function chunkTraceEventsForTransport(
     const boundedEvents = boundTraceEventsForTransport(events);
     const countBatches = chunkArray(boundedEvents, TRACE_BATCH_SIZE);
     const sizedBatches: TraceEventRecord[][] = [];
+    const emittedValueIds = new Set<string>();
     let current: TraceEventRecord[] = [];
 
+    const commitCurrent = (): void => {
+        if (!current.length) return;
+        collectBatchTraceValueEntries(
+            current,
+            sizedBatches.length,
+            emittedValueIds,
+        );
+        sizedBatches.push(current);
+        current = [];
+    };
+
     for (const event of countBatches.flat()) {
         if (sizedBatches.length >= TRACE_MAX_BATCHES_PER_REQUEST) {
             break;
         }
         if (current.length >= TRACE_BATCH_SIZE) {
-            sizedBatches.push(current);
-            current = [];
+            commitCurrent();
             if (sizedBatches.length >= TRACE_MAX_BATCHES_PER_REQUEST) {
                 break;
             }
@@ -5287,15 +5489,15 @@ function chunkTraceEventsForTransport(
             requestRid,
             actionId,
             batchIndex,
+            emittedValueIds,
         );
 
         if (
             current.length > 0 &&
             estimatedBytes > TRACE_BATCH_MAX_SERIALIZED_BYTES
         ) {
-            sizedBatches.push(current);
+            commitCurrent();
             if (sizedBatches.length >= TRACE_MAX_BATCHES_PER_REQUEST) {
-                current = [];
                 break;
             }
             current = [event];
@@ -5309,7 +5511,7 @@ function chunkTraceEventsForTransport(
         current.length > 0 &&
         sizedBatches.length < TRACE_MAX_BATCHES_PER_REQUEST
     ) {
-        sizedBatches.push(current);
+        commitCurrent();
     }
 
     return sizedBatches;
@@ -5381,7 +5583,11 @@ function createCapturedValueEntry(
         return undefined;
     }
 
-    const valueId = randomUUID();
+    const valueId = contentAddressedValueId(
+        params.target,
+        candidateSerialized,
+        params.capture,
+    );
     const projectedKind =
         candidate && typeof candidate === 'object'
             ? ((candidate as Record<string, any>).__kind || (candidate as Record<string, any>).__type)
@@ -5463,7 +5669,11 @@ async function createCapturedValueEntryAsync(
         return undefined;
     }
 
-    const valueId = randomUUID();
+    const valueId = contentAddressedValueId(
+        params.target,
+        candidateSerialized,
+        params.capture,
+    );
     const projectedKind =
         candidate && typeof candidate === 'object'
             ? ((candidate as Record<string, any>).__kind || (candidate as Record<string, any>).__type)
@@ -5486,6 +5696,18 @@ async function createCapturedValueEntryAsync(
     };
 }
 
+function appendCapturedValueDefinition(
+    sink: TraceValueBatchEntry[],
+    entry: TraceValueBatchEntry | undefined,
+    captureScope?: RequestCaptureScopeState | null,
+): void {
+    if (!entry) return;
+    const emitted = captureScope?.emittedValueDefinitionIds;
+    if (emitted?.has(entry.id)) return;
+    emitted?.add(entry.id);
+    sink.push(entry);
+}
+
 function maybeCaptureRequestValue(
     params: {
         target: 'request.headers' | 'request.body' | 'request.params' | 'request.query' | 'response.body';
@@ -5497,9 +5719,7 @@ function maybeCaptureRequestValue(
 ): TraceValueCaptureRef | undefined {
     const result = createCapturedValueEntry(params);
     if (!result) return undefined;
-    if (result.entry) {
-        sink.push(result.entry);
-    }
+    appendCapturedValueDefinition(sink, result.entry);
     return result.captureRef;
 }
 
@@ -5526,9 +5746,7 @@ async function maybeCaptureRequestValueAsync(
         return { status: 'failed-policy' };
     }
     if (!result) return undefined;
-    if (result.entry) {
-        sink.push(result.entry);
-    }
+    appendCapturedValueDefinition(sink, result.entry, captureScope);
     return result.captureRef;
 }
 
@@ -5578,9 +5796,7 @@ function maybeCaptureDbValue(
 ): TraceValueCaptureRef | undefined {
     const result = createCapturedValueEntry(params);
     if (!result) return undefined;
-    if (result.entry) {
-        sink.push(result.entry);
-    }
+    appendCapturedValueDefinition(sink, result.entry);
     return result.captureRef;
 }
 
@@ -5607,9 +5823,7 @@ async function maybeCaptureDbValueAsync(
         return { status: 'failed-policy' };
     }
     if (!result) return undefined;
-    if (result.entry) {
-        sink.push(result.entry);
-    }
+    appendCapturedValueDefinition(sink, result.entry, captureScope);
     return result.captureRef;
 }
 
@@ -5664,7 +5878,7 @@ async function maybeCaptureDbValueFromCandidatesAsync(
         }
         if (!result) continue;
         if (result.entry) {
-            sink.push(result.entry);
+            appendCapturedValueDefinition(sink, result.entry, captureScope);
             return result.captureRef;
         }
         if (!skippedRef) {
@@ -5935,21 +6149,24 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
             res.on('close', endTrackedClientRequest);
             return next(); // only capture tagged requests
         }
-        const captureCfg: ReproMiddlewareConfig = backendLiveChild
-            ? {
+        let captureCfg: ReproMiddlewareConfig = cfg;
+        if (backendLiveChild) {
+            captureCfg = {
                 ...cfg,
                 actorId: backendLiveChild.actorId,
                 actorType: backendLiveChild.actorType,
                 actorLabels: backendLiveChild.actorLabels,
-            }
-            : taggedActorIdentity
-                ? {
-                    ...cfg,
-                    actorId: taggedActorIdentity.actorId,
-                    actorType: taggedActorIdentity.actorType,
-                    actorLabels: taggedActorIdentity.actorLabels,
-                }
-            : cfg;
+            };
+            shareRuntimePrivacyState(cfg, captureCfg);
+        } else if (taggedActorIdentity) {
+            captureCfg = {
+                ...cfg,
+                actorId: taggedActorIdentity.actorId,
+                actorType: taggedActorIdentity.actorType,
+                actorLabels: taggedActorIdentity.actorLabels,
+            };
+            shareRuntimePrivacyState(cfg, captureCfg);
+        }
         if (taggedActorIdentity) {
             post(captureCfg, sid, {
                 entries: [{
@@ -6240,6 +6457,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                             trace: endpointTraceCtx,
                             masking,
                             privacy: activePrivacy,
+                            valueNamespace: sid,
                         },
                     }, requestValueEntries, captureScope);
                 const paramsValueCapture = await maybeCaptureRequestValueAsync({
@@ -6253,6 +6471,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                         trace: endpointTraceCtx,
                         masking,
                         privacy: activePrivacy,
+                        valueNamespace: sid,
                     },
                 }, requestValueEntries, captureScope);
                 const queryValueCapture = await maybeCaptureRequestValueAsync({
@@ -6266,6 +6485,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                         trace: endpointTraceCtx,
                         masking,
                         privacy: activePrivacy,
+                        valueNamespace: sid,
                     },
                 }, requestValueEntries, captureScope);
                 const headersValueCapture = await maybeCaptureRequestValueAsync({
@@ -6279,6 +6499,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                         trace: endpointTraceCtx,
                         masking,
                         privacy: activePrivacy,
+                        valueNamespace: sid,
                     },
                 }, requestValueEntries, captureScope);
                 const respBodyValueCapture = capturedBody === undefined
@@ -6294,6 +6515,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                             trace: endpointTraceCtx,
                             masking,
                             privacy: activePrivacy,
+                            valueNamespace: sid,
                         },
                     }, requestValueEntries, captureScope);
 
@@ -6302,7 +6524,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                         ? Math.max(0, finishedAt - t0)
                         : Date.now() - t0;
                 const requestPayload: Record<string, any> = {
-                    rid,
+            rid,
                     method: req.method,
                     url,
                     path,
@@ -6472,17 +6694,27 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                                 evt.__reproPending = {
                                     ...(ev.args !== undefined
                                         ? {
-                                            argsRaw: normalizeRawTraceArgs(ev.args),
+                                            argsRaw: snapshotTraceArgsAtObservation(ev.args, captureScope),
                                         }
                                         : {}),
                                     ...(ev.returnValue !== undefined
                                         ? {
-                                            returnValueRaw: ev.returnValue,
+                                            returnValueRaw: snapshotTraceValueAtObservation(
+                                                ev.returnValue,
+                                                captureScope,
+                                                '$',
+                                                'trace.returnValue',
+                                            ),
                                         }
                                         : {}),
                                     ...(hasErrorPayload
                                         ? {
-                                            errorRaw: ev.error,
+                                            errorRaw: snapshotTraceValueAtObservation(
+                                                ev.error,
+                                                captureScope,
+                                                '$',
+                                                'trace.error',
+                                            ),
                                         }
                                         : {}),
                                 };
@@ -6516,6 +6748,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                                 masking,
                                 resolvePrivacy,
                                 captureScope,
+                                valueNamespace: sid,
                             });
                             const baseEvents = balanceTraceEvents(materializedEvents.slice());
                             const orderedEvents = TRACE_ORDER_MODE === 'tree'
@@ -6550,9 +6783,14 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                         emitRequestCaptureManifest(traceBatches.length);
 
                         try {
+                            const emittedValueIds = new Set<string>();
                             for (let i = 0; i < traceBatches.length; i++) {
                                 const batch = traceBatches[i];
-                                const traceValues = collectBatchTraceValueEntries(batch, i);
+                                const traceValues = collectBatchTraceValueEntries(
+                                    batch,
+                                    i,
+                                    emittedValueIds,
+                                );
 
                                 post(captureCfg, sid, {
                                     entries: [{
@@ -7162,12 +7400,6 @@ function dehydrateComplexValue(value: any) {
         }
     } catch {}
 
-    const ctor = (value as any)?.constructor?.name;
-    if (ctor && ctor !== 'Object') {
-        const plain = safeJson(value);
-        if (plain !== undefined) return plain;
-    }
-
     return value;
 }
 
@@ -7242,6 +7474,7 @@ async function emitDbQueryAsync(cfg: any, sid?: string, aid?: string, payload?:
         masking: null,
         privacy,
         db: dbContext,
+        valueNamespace: sid,
     };
     const dbValues: TraceValueBatchEntry[] = [];
     const pkValueCapture = pkMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
@@ -7249,37 +7482,37 @@ async function emitDbQueryAsync(cfg: any, sid?: string, aid?: string, payload?:
         rawValue: payload.pk,
         previewValue: pkPreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const beforeValueCapture = beforeMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
         target: 'db.before',
         rawValue: payload.before,
         previewValue: beforePreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const afterValueCapture = afterMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
         target: 'db.after',
         rawValue: payload.after,
         previewValue: afterPreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const queryValueCapture = queryMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
         target: 'db.query',
         rawValue: querySource,
         previewValue: queryPreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const resultMetaValueCapture = resultMetaMaterialization.skipped ? undefined : await maybeCaptureDbValueFromCandidatesAsync({
         target: 'db.resultMeta',
         rawValues: buildResultMetaFullValueCandidates(payload.resultMetaRaw, resultMetaSource),
         previewValue: resultMetaPreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const errorValueCapture = errorMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
         target: 'db.error',
         rawValue: payload.error,
         previewValue: errorPreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const dbEntry = attachSpanContext({
         type: payload.type ?? 'mongo',
         collection: payload.collection,
@@ -7884,6 +8117,7 @@ function recordKafkaTraceEvent(
         trace: candidate,
         masking,
         privacy,
+        valueNamespace: getCtx().sid,
     };
     const traceValueMetadata = {
         fn: evt.fn,
@@ -7976,6 +8210,8 @@ function recordKafkaTraceEvent(
 function buildPendingKafkaTraceEvent(raw: any): PendingTraceEventRecord | null {
     if (!raw || (raw.type !== 'enter' && raw.type !== 'exit')) return null;
 
+    raw = snapshotRawTraceEventAtObservation(raw, getCtx().captureScope);
+
     const sourceFileForLibrary =
         typeof raw.sourceFile === 'string' && raw.sourceFile
             ? String(raw.sourceFile)
@@ -8052,6 +8288,7 @@ async function recordKafkaTraceEventAsync(
         maskReq,
         masking,
         resolvePrivacy: () => getRuntimePrivacyState(cfg).policy ?? null,
+        valueNamespace: getCtx().sid,
     });
     sink.push(...materializedEvents);
 }
@@ -8072,10 +8309,11 @@ function buildKafkaTraceEntries(
         requestRid,
         actionId,
     );
+    const emittedValueIds = new Set<string>();
     return batches.map((batch, index) => ({
         actionId: actionId ?? null,
         trace: batch,
-        traceValues: collectBatchTraceValueEntries(batch, index),
+        traceValues: collectBatchTraceValueEntries(batch, index, emittedValueIds),
         traceBatch: {
             rid: requestRid,
             index,
@@ -8117,6 +8355,7 @@ function scheduleKafkaTraceFlush(
                         masking,
                         resolvePrivacy: () => getRuntimePrivacyState(cfg).policy ?? null,
                         captureScope,
+                        valueNamespace: sid,
                     });
                     entries = buildKafkaTraceEntries(actionId, requestRid, materializedEvents);
                 }
@@ -8453,7 +8692,7 @@ function wrapKafkaEachMessageHandler(eachMessage: any, cfg: KafkaJsPatchConfig,
                 try {
                     unsubscribe = __TRACER__.tracer.on((event: any) => {
                         if (!event || event.traceId !== traceId) return;
-                        rawTraceEvents.push(event);
+                        rawTraceEvents.push(snapshotRawTraceEventAtObservation(event, captureScope));
                     });
                 } catch {}
             }
@@ -8563,7 +8802,7 @@ function wrapKafkaEachBatchHandler(eachBatch: any, cfg: KafkaJsPatchConfig, cons
                 try {
                     unsubscribe = __TRACER__.tracer.on((event: any) => {
                         if (!event || event.traceId !== traceId) return;
-                        rawTraceEvents.push(event);
+                        rawTraceEvents.push(snapshotRawTraceEventAtObservation(event, captureScope));
                     });
                 } catch {}
             }
@@ -9371,7 +9610,7 @@ function wrapAmqplibConsumeHandler(onMessage: any, cfg: AmqplibPatchConfig, queu
             try {
                 unsubscribe = __TRACER__.tracer.on((event: any) => {
                     if (!event || event.traceId !== traceId) return;
-                    rawTraceEvents.push(event);
+                    rawTraceEvents.push(snapshotRawTraceEventAtObservation(event, captureScope));
                 });
             } catch {}
         };
@@ -11773,5 +12012,6 @@ export const __reproTestHooks = {
     estimateTraceBatchSerializedBytesForTest: estimateTraceBatchSerializedBytes,
     sanitizeTraceValueForPrivacyForTest: sanitizeTraceValueForPrivacy,
     sanitizeMaterializedTraceValueForTest: sanitizeMaterializedTraceValue,
+    projectSemanticInfrastructureValueForTest: projectSemanticInfrastructureValue,
     getEventTraceValueEntriesForTest: getEventTraceValueEntries,
 };