@reproapp/node-sdk 0.0.8 → 0.0.11

package/dist/index.d.ts

@@ -254,6 +254,8 @@ export type ReproTracingInitOptions = TracerInitOpts & {
 export declare function initReproTracing(opts?: ReproTracingInitOptions): TracerApi | null;
 /** Optional helper if users want to check it. */
 export declare function isReproTracingEnabled(): boolean;
+declare function sanitizeTraceValueForPrivacy(value: any): any;
+declare function sanitizeMaterializedTraceValue(value: any): any;
 export declare function __materializePendingTraceEventsForWorker(payload: TraceMaterializationWorkerPayload): Promise<PendingTraceEventRecord[]>;
 type NormalizedMaskRule = {
     when?: ReproMaskWhen;
@@ -283,6 +285,8 @@ type InlinePrivacyMaterializationResult = {
     };
 };
 declare function materializeInlinePrivacyValueAsync(target: RuntimePrivacySurface, value: any, cfg: ReproMiddlewareConfig, req: MaskRequestContext, trace: TraceEventForFilter | null, masking: NormalizedMaskingConfig | null, privacy: NormalizedRuntimePrivacyPolicy | null, db?: RuntimePrivacyDbContext | null): Promise<InlinePrivacyMaterializationResult>;
+declare function estimateTraceBatchSerializedBytes(batch: TraceEventRecord[], requestRid: string, actionId: string | null | undefined, batchIndex: number): number;
+declare function chunkTraceEventsForTransport(events: TraceEventRecord[], requestRid: string, actionId: string | null | undefined): TraceEventRecord[][];
 export type ReproMiddlewareConfig = IngestClientConfig & {
     /** Configure header capture/masking. Defaults to capturing with sensitive headers masked. */
     captureHeaders?: boolean | HeaderCaptureOptions;
@@ -342,11 +346,21 @@ export declare function initRepro(cfg: ReproInitConfig): Promise<void>;
 /** @internal Test hooks for runtime privacy policy wiring. */
 export declare const __reproTestHooks: {
     shareRuntimePrivacyStateForTest: typeof shareRuntimePrivacyState;
+    setFullValueCaptureEnabledForTest(enabled: boolean): void;
+    scheduleSdkBackgroundWorkForTest(work: () => Promise<void> | void, options?: {
+        priority?: 'high' | 'normal';
+    }): void;
+    drainSdkBackgroundQueueForTest(): Promise<void>;
+    resetSdkBackgroundQueuesForTest(): void;
     getRuntimePrivacyPolicyForTest(cfg: ReproMiddlewareConfig): NormalizedRuntimePrivacyPolicy | null;
     setRuntimePrivacyPolicyForTest(cfg: ReproMiddlewareConfig, policy: NormalizedRuntimePrivacyPolicy | null): void;
     recordKafkaTraceEventAsyncForTest: typeof recordKafkaTraceEventAsync;
     materializeInlinePrivacyValueAsyncForTest: typeof materializeInlinePrivacyValueAsync;
     patchKafkaProducerInstanceForTest: typeof patchKafkaProducerInstance;
     wrapKafkaEachMessageHandlerForTest: typeof wrapKafkaEachMessageHandler;
+    chunkTraceEventsForTransportForTest: typeof chunkTraceEventsForTransport;
+    estimateTraceBatchSerializedBytesForTest: typeof estimateTraceBatchSerializedBytes;
+    sanitizeTraceValueForPrivacyForTest: typeof sanitizeTraceValueForPrivacy;
+    sanitizeMaterializedTraceValueForTest: typeof sanitizeMaterializedTraceValue;
 };
 export {};

package/dist/index.js

@@ -863,6 +863,7 @@ let activeClientRequestCount = 0;
 let oldestActiveClientRequestAt = null;
 let lastClientActivityAt = 0;
 let sdkBackgroundQuietUntil = 0;
+const sdkBackgroundHighQueue = [];
 const sdkBackgroundQueue = [];
 let sdkBackgroundTimer = null;
 let sdkBackgroundDraining = false;
@@ -1155,8 +1156,13 @@ function endClientRequest() {
         scheduleSdkBackgroundDrain();
     }
 }
-function scheduleSdkBackgroundWork(work) {
-    sdkBackgroundQueue.push(work);
+function scheduleSdkBackgroundWork(work, options = {}) {
+    if (options.priority === 'high') {
+        sdkBackgroundHighQueue.push(work);
+    }
+    else {
+        sdkBackgroundQueue.push(work);
+    }
     scheduleSdkBackgroundDrain();
 }
 function scheduleSdkBackgroundDrain(delayMs = 0) {
@@ -1209,12 +1215,12 @@ async function drainSdkBackgroundQueue() {
     }
     sdkBackgroundDraining = true;
     try {
-        while (sdkBackgroundQueue.length > 0) {
+        while (sdkBackgroundHighQueue.length > 0 || sdkBackgroundQueue.length > 0) {
             if (shouldDeferSdkBackgroundWork()) {
                 scheduleSdkBackgroundDrain();
                 return;
             }
-            const work = sdkBackgroundQueue.shift();
+            const work = sdkBackgroundHighQueue.shift() ?? sdkBackgroundQueue.shift();
             if (!work)
                 continue;
             try {
@@ -1228,7 +1234,7 @@ async function drainSdkBackgroundQueue() {
     }
     finally {
         sdkBackgroundDraining = false;
-        if (sdkBackgroundQueue.length > 0) {
+        if (sdkBackgroundHighQueue.length > 0 || sdkBackgroundQueue.length > 0) {
             scheduleSdkBackgroundDrain();
         }
         else {
@@ -1657,6 +1663,12 @@ const TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS = (() => {
 })();
 const TRACE_VALUE_SIZE_EXCEEDED = Symbol('trace-value-size-exceeded');
 const TRACE_BATCH_SIZE = 100;
+const TRACE_BATCH_MAX_SERIALIZED_BYTES = (() => {
+    const env = Number(process.env.REPRO_TRACE_BATCH_MAX_SERIALIZED_BYTES);
+    if (Number.isFinite(env) && env > 0)
+        return Math.trunc(env);
+    return 512 * 1024;
+})();
 const TRACE_FLUSH_DELAY_MS = 20;
 // Choose how to order trace events in payloads.
 //  - "chronological" (default): preserve event arrival order (no reshuffle).
@@ -2026,14 +2038,26 @@ function sanitizeTraceValue(value, depth = 0, seen = new WeakMap(), options = {}
         return circularReference(existingPath);
     seen.set(value, valuePath);
     if (!options.disableTruncation && depth >= TRACE_VALUE_MAX_DEPTH) {
-        const shallow = safeJson(value);
-        if (shallow !== undefined) {
-            return shallow;
+        if (Array.isArray(value)) {
+            return {
+                __type: 'Array',
+                length: value.length,
+                __truncated: `depth>${TRACE_VALUE_MAX_DEPTH}`,
+            };
         }
         const ctor = value?.constructor?.name;
-        return ctor && ctor !== 'Object'
-            ? { __class: ctor, __truncated: `depth>${TRACE_VALUE_MAX_DEPTH}` }
-            : { __truncated: `depth>${TRACE_VALUE_MAX_DEPTH}` };
+        const keys = Object.keys(value);
+        const summary = {
+            __truncated: `depth>${TRACE_VALUE_MAX_DEPTH}`,
+            __keys: keys.slice(0, TRACE_VALUE_MAX_KEYS),
+        };
+        if (keys.length > TRACE_VALUE_MAX_KEYS) {
+            summary.__truncatedKeys = keys.length - TRACE_VALUE_MAX_KEYS;
+        }
+        if (ctor && ctor !== 'Object') {
+            summary.__class = ctor;
+        }
+        return summary;
     }
     if (Array.isArray(value)) {
         const sourceItems = options.disableTruncation ? value : value.slice(0, TRACE_VALUE_MAX_ITEMS);
@@ -2099,6 +2123,9 @@ function sanitizeTraceArgs(values) {
 function sanitizeTraceValueForPrivacy(value) {
     return sanitizeTraceValue(value, 0, new WeakMap(), { preserveLongStrings: true, disableTruncation: true });
 }
+function sanitizeInlinePrivacyValue(value) {
+    return sanitizeTraceValue(value, 0, new WeakMap(), { preserveLongStrings: true, disableTruncation: true });
+}
 function sanitizeMaterializedTraceValue(value) {
     return sanitizeTraceValue(value, 0, new WeakMap(), { preserveLongStrings: true, disableTruncation: true });
 }
@@ -3526,6 +3553,51 @@ function collectBatchTraceValueEntries(batch, batchIndex) {
     });
     return collected;
 }
+function serializedByteLength(value) {
+    try {
+        return Buffer.byteLength(JSON.stringify(value), 'utf8');
+    }
+    catch {
+        return Number.MAX_SAFE_INTEGER;
+    }
+}
+function estimateTraceBatchSerializedBytes(batch, requestRid, actionId, batchIndex) {
+    const traceValues = collectBatchTraceValueEntries(batch, batchIndex);
+    return serializedByteLength({
+        actionId: actionId ?? null,
+        trace: batch,
+        traceValues: traceValues.length ? traceValues : undefined,
+        traceBatch: {
+            rid: requestRid,
+            index: batchIndex,
+            total: 0,
+        },
+        t: 0,
+    });
+}
+function chunkTraceEventsForTransport(events, requestRid, actionId) {
+    if (!Array.isArray(events) || events.length === 0)
+        return [];
+    const countBatches = chunkArray(events, TRACE_BATCH_SIZE);
+    const sizedBatches = [];
+    let current = [];
+    for (const event of countBatches.flat()) {
+        const candidate = current.concat(event);
+        const batchIndex = sizedBatches.length;
+        const estimatedBytes = estimateTraceBatchSerializedBytes(candidate, requestRid, actionId, batchIndex);
+        if (current.length > 0 &&
+            estimatedBytes > TRACE_BATCH_MAX_SERIALIZED_BYTES) {
+            sizedBatches.push(current);
+            current = [event];
+            continue;
+        }
+        current = candidate;
+    }
+    if (current.length > 0) {
+        sizedBatches.push(current);
+    }
+    return sizedBatches;
+}
 function createCapturedValueEntry(params) {
     if (!__FULL_VALUE_CAPTURE_ENABLED)
         return undefined;
@@ -3809,7 +3881,7 @@ function reproMiddleware(cfg) {
                 }
                 catch { }
                 if (flushPayload) {
-                    const scheduleFlushPayload = () => scheduleSdkBackgroundWork(flushPayload);
+                    const scheduleFlushPayload = () => scheduleSdkBackgroundWork(flushPayload, { priority: 'high' });
                     if (sessionDrainWait) {
                         sessionDrainWait.then(scheduleFlushPayload).catch(scheduleFlushPayload);
                     }
@@ -4109,7 +4181,7 @@ function reproMiddleware(cfg) {
                             const orderedEvents = TRACE_ORDER_MODE === 'tree'
                                 ? reorderTraceEvents(baseEvents)
                                 : sortTraceEventsChronologically(baseEvents);
-                            const traceBatches = chunkArray(orderedEvents, TRACE_BATCH_SIZE);
+                            const traceBatches = chunkTraceEventsForTransport(orderedEvents, rid, aid);
                             if (traceBatches.length) {
                                 for (let i = 0; i < traceBatches.length; i++) {
                                     const batch = traceBatches[i];
@@ -5125,7 +5197,7 @@ function cloneKafkaTelemetryValue(value) {
     }
 }
 async function materializeKafkaRequestBody(cfg, maskReq, body) {
-    return materializeInlinePrivacyValueAsync('request.body', sanitizeTraceValueForPrivacy(body), cfg, maskReq, null, normalizeMaskingConfig(cfg.masking), getRuntimePrivacyState(cfg).policy ?? null);
+    return materializeInlinePrivacyValueAsync('request.body', sanitizeInlinePrivacyValue(body), cfg, maskReq, null, normalizeMaskingConfig(cfg.masking), getRuntimePrivacyState(cfg).policy ?? null);
 }
 function summarizeKafkaError(error) {
     const message = typeof error?.message === 'string'
@@ -5312,7 +5384,7 @@ function buildKafkaTraceEntries(actionId, requestRid, events) {
     const orderedEvents = TRACE_ORDER_MODE === 'tree'
         ? reorderTraceEvents(baseEvents)
         : sortTraceEventsChronologically(baseEvents);
-    const batches = chunkArray(orderedEvents, TRACE_BATCH_SIZE);
+    const batches = chunkTraceEventsForTransport(orderedEvents, requestRid, actionId);
     return batches.map((batch, index) => ({
         actionId: actionId ?? null,
         trace: batch,
@@ -5353,7 +5425,7 @@ function scheduleKafkaTraceFlush(cfg, kafkaCtx, actionId, requestRid, rawTraceEv
                 post(cfg, sid, { entries });
             }
         });
-    });
+    }, { priority: 'high' });
 }
 function patchKafkaProducerInstance(producer, cfg) {
     if (!producer || producer.__repro_kafka_producer_patched)
@@ -6616,6 +6688,31 @@ exports.initRepro = initRepro;
 /** @internal Test hooks for runtime privacy policy wiring. */
 exports.__reproTestHooks = {
     shareRuntimePrivacyStateForTest: shareRuntimePrivacyState,
+    setFullValueCaptureEnabledForTest(enabled) {
+        __FULL_VALUE_CAPTURE_ENABLED = enabled === true;
+    },
+    scheduleSdkBackgroundWorkForTest(work, options) {
+        scheduleSdkBackgroundWork(work, options);
+    },
+    async drainSdkBackgroundQueueForTest() {
+        await drainSdkBackgroundQueue();
+    },
+    resetSdkBackgroundQueuesForTest() {
+        sdkBackgroundHighQueue.length = 0;
+        sdkBackgroundQueue.length = 0;
+        if (sdkBackgroundTimer) {
+            try {
+                clearTimeout(sdkBackgroundTimer);
+            }
+            catch { }
+            sdkBackgroundTimer = null;
+        }
+        sdkBackgroundDraining = false;
+        activeClientRequestCount = 0;
+        oldestActiveClientRequestAt = null;
+        lastClientActivityAt = 0;
+        sdkBackgroundQuietUntil = 0;
+    },
     getRuntimePrivacyPolicyForTest(cfg) {
         return getRuntimePrivacyState(cfg).policy;
     },
@@ -6626,4 +6723,8 @@ exports.__reproTestHooks = {
     materializeInlinePrivacyValueAsyncForTest: materializeInlinePrivacyValueAsync,
     patchKafkaProducerInstanceForTest: patchKafkaProducerInstance,
     wrapKafkaEachMessageHandlerForTest: wrapKafkaEachMessageHandler,
+    chunkTraceEventsForTransportForTest: chunkTraceEventsForTransport,
+    estimateTraceBatchSerializedBytesForTest: estimateTraceBatchSerializedBytes,
+    sanitizeTraceValueForPrivacyForTest: sanitizeTraceValueForPrivacy,
+    sanitizeMaterializedTraceValueForTest: sanitizeMaterializedTraceValue,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.8",
+  "version": "0.0.11",
   "description": "Repro Nest SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,7 +12,7 @@
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput",
     "prepublishOnly": "npm run build",
-    "test": "npm run build && node test/unawaited.test.js && node test/integration-unawaited.js && node test/request-flush-timing.test.js && node test/express-trace-http-args.test.js && node -r ./tracer/register test/promise-map.test.js && node test/disable-subtree.test.js && node test/circular-capture.test.js && node test/wrap-plugin-arrow-args.test.js && node test/privacy-runtime-policy.test.js && node test/runtime-privacy-materialization.test.js && node test/kafka-runtime-privacy-policy.test.js"
+    "test": "npm run build && node test/unawaited.test.js && node test/integration-unawaited.js && node test/request-flush-timing.test.js && node test/express-trace-http-args.test.js && node test/trace-batch-size.test.js && node test/sdk-background-priority.test.js && node -r ./tracer/register test/promise-map.test.js && node test/disable-subtree.test.js && node test/circular-capture.test.js && node test/wrap-plugin-arrow-args.test.js && node test/privacy-runtime-policy.test.js && node test/runtime-privacy-materialization.test.js && node test/kafka-runtime-privacy-policy.test.js"
   },
   "peerDependencies": {
     "express": "^5.1.0",

package/src/index.ts

@@ -1231,6 +1231,7 @@ let activeClientRequestCount = 0;
 let oldestActiveClientRequestAt: number | null = null;
 let lastClientActivityAt = 0;
 let sdkBackgroundQuietUntil = 0;
+const sdkBackgroundHighQueue: Array<() => Promise<void> | void> = [];
 const sdkBackgroundQueue: Array<() => Promise<void> | void> = [];
 let sdkBackgroundTimer: NodeJS.Timeout | null = null;
 let sdkBackgroundDraining = false;
@@ -1499,8 +1500,15 @@ function endClientRequest(): void {
     }
 }
 
-function scheduleSdkBackgroundWork(work: () => Promise<void> | void): void {
-    sdkBackgroundQueue.push(work);
+function scheduleSdkBackgroundWork(
+    work: () => Promise<void> | void,
+    options: { priority?: 'high' | 'normal' } = {},
+): void {
+    if (options.priority === 'high') {
+        sdkBackgroundHighQueue.push(work);
+    } else {
+        sdkBackgroundQueue.push(work);
+    }
     scheduleSdkBackgroundDrain();
 }
 
@@ -1549,12 +1557,12 @@ async function drainSdkBackgroundQueue(): Promise<void> {
 
     sdkBackgroundDraining = true;
     try {
-        while (sdkBackgroundQueue.length > 0) {
+        while (sdkBackgroundHighQueue.length > 0 || sdkBackgroundQueue.length > 0) {
             if (shouldDeferSdkBackgroundWork()) {
                 scheduleSdkBackgroundDrain();
                 return;
             }
-            const work = sdkBackgroundQueue.shift();
+            const work = sdkBackgroundHighQueue.shift() ?? sdkBackgroundQueue.shift();
             if (!work) continue;
             try {
                 await drainQueuedIngestBeforeBackgroundWork();
@@ -1565,7 +1573,7 @@ async function drainSdkBackgroundQueue(): Promise<void> {
         }
     } finally {
         sdkBackgroundDraining = false;
-        if (sdkBackgroundQueue.length > 0) {
+        if (sdkBackgroundHighQueue.length > 0 || sdkBackgroundQueue.length > 0) {
             scheduleSdkBackgroundDrain();
         } else {
             kickIngestQueueDrain();
@@ -2028,6 +2036,11 @@ const TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS = (() => {
 })();
 const TRACE_VALUE_SIZE_EXCEEDED = Symbol('trace-value-size-exceeded');
 const TRACE_BATCH_SIZE = 100;
+const TRACE_BATCH_MAX_SERIALIZED_BYTES = (() => {
+    const env = Number(process.env.REPRO_TRACE_BATCH_MAX_SERIALIZED_BYTES);
+    if (Number.isFinite(env) && env > 0) return Math.trunc(env);
+    return 512 * 1024;
+})();
 const TRACE_FLUSH_DELAY_MS = 20;
 // Choose how to order trace events in payloads.
 //  - "chronological" (default): preserve event arrival order (no reshuffle).
@@ -2424,14 +2437,26 @@ function sanitizeTraceValue(
     seen.set(value, valuePath);
 
     if (!options.disableTruncation && depth >= TRACE_VALUE_MAX_DEPTH) {
-        const shallow = safeJson(value);
-        if (shallow !== undefined) {
-            return shallow;
+        if (Array.isArray(value)) {
+            return {
+                __type: 'Array',
+                length: value.length,
+                __truncated: `depth>${TRACE_VALUE_MAX_DEPTH}`,
+            };
         }
         const ctor = value?.constructor?.name;
-        return ctor && ctor !== 'Object'
-            ? { __class: ctor, __truncated: `depth>${TRACE_VALUE_MAX_DEPTH}` }
-            : { __truncated: `depth>${TRACE_VALUE_MAX_DEPTH}` };
+        const keys = Object.keys(value);
+        const summary: Record<string, any> = {
+            __truncated: `depth>${TRACE_VALUE_MAX_DEPTH}`,
+            __keys: keys.slice(0, TRACE_VALUE_MAX_KEYS),
+        };
+        if (keys.length > TRACE_VALUE_MAX_KEYS) {
+            summary.__truncatedKeys = keys.length - TRACE_VALUE_MAX_KEYS;
+        }
+        if (ctor && ctor !== 'Object') {
+            summary.__class = ctor;
+        }
+        return summary;
     }
 
     if (Array.isArray(value)) {
@@ -2500,6 +2525,10 @@ function sanitizeTraceValueForPrivacy(value: any): any {
     return sanitizeTraceValue(value, 0, new WeakMap(), { preserveLongStrings: true, disableTruncation: true });
 }
 
+function sanitizeInlinePrivacyValue(value: any): any {
+    return sanitizeTraceValue(value, 0, new WeakMap(), { preserveLongStrings: true, disableTruncation: true });
+}
+
 function sanitizeMaterializedTraceValue(value: any): any {
     return sanitizeTraceValue(value, 0, new WeakMap(), { preserveLongStrings: true, disableTruncation: true });
 }
@@ -4215,6 +4244,74 @@ function collectBatchTraceValueEntries(batch: TraceEventRecord[], batchIndex: nu
     return collected;
 }
 
+function serializedByteLength(value: any): number {
+    try {
+        return Buffer.byteLength(JSON.stringify(value), 'utf8');
+    } catch {
+        return Number.MAX_SAFE_INTEGER;
+    }
+}
+
+function estimateTraceBatchSerializedBytes(
+    batch: TraceEventRecord[],
+    requestRid: string,
+    actionId: string | null | undefined,
+    batchIndex: number,
+): number {
+    const traceValues = collectBatchTraceValueEntries(batch, batchIndex);
+    return serializedByteLength({
+        actionId: actionId ?? null,
+        trace: batch,
+        traceValues: traceValues.length ? traceValues : undefined,
+        traceBatch: {
+            rid: requestRid,
+            index: batchIndex,
+            total: 0,
+        },
+        t: 0,
+    });
+}
+
+function chunkTraceEventsForTransport(
+    events: TraceEventRecord[],
+    requestRid: string,
+    actionId: string | null | undefined,
+): TraceEventRecord[][] {
+    if (!Array.isArray(events) || events.length === 0) return [];
+
+    const countBatches = chunkArray(events, TRACE_BATCH_SIZE);
+    const sizedBatches: TraceEventRecord[][] = [];
+    let current: TraceEventRecord[] = [];
+
+    for (const event of countBatches.flat()) {
+        const candidate = current.concat(event);
+        const batchIndex = sizedBatches.length;
+        const estimatedBytes = estimateTraceBatchSerializedBytes(
+            candidate,
+            requestRid,
+            actionId,
+            batchIndex,
+        );
+
+        if (
+            current.length > 0 &&
+            estimatedBytes > TRACE_BATCH_MAX_SERIALIZED_BYTES
+        ) {
+            sizedBatches.push(current);
+            current = [event];
+            continue;
+        }
+
+        current = candidate;
+    }
+
+    if (current.length > 0) {
+        sizedBatches.push(current);
+    }
+
+    return sizedBatches;
+}
+
 function createCapturedValueEntry(
     params: {
         target:
@@ -4601,11 +4698,11 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
 	                        return;
 	                    }
 	                }
-	                flushed = true;
-	                clearTimers();
+                flushed = true;
+                clearTimers();
                 try { unsubscribe && unsubscribe(); } catch {}
                 if (flushPayload) {
-                    const scheduleFlushPayload = () => scheduleSdkBackgroundWork(flushPayload!);
+                    const scheduleFlushPayload = () => scheduleSdkBackgroundWork(flushPayload!, { priority: 'high' });
                     if (sessionDrainWait) {
                         sessionDrainWait.then(scheduleFlushPayload).catch(scheduleFlushPayload);
                     } else {
@@ -4953,7 +5050,11 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                                 const orderedEvents = TRACE_ORDER_MODE === 'tree'
                                     ? reorderTraceEvents(baseEvents)
                                     : sortTraceEventsChronologically(baseEvents);
-                                const traceBatches = chunkArray(orderedEvents, TRACE_BATCH_SIZE);
+                                const traceBatches = chunkTraceEventsForTransport(
+                                    orderedEvents,
+                                    rid,
+                                    aid,
+                                );
 
                                 if (traceBatches.length) {
                                     for (let i = 0; i < traceBatches.length; i++) {
@@ -6006,7 +6107,7 @@ async function materializeKafkaRequestBody(
 ): Promise<InlinePrivacyMaterializationResult> {
     return materializeInlinePrivacyValueAsync(
         'request.body',
-        sanitizeTraceValueForPrivacy(body),
+        sanitizeInlinePrivacyValue(body),
         cfg,
         maskReq,
         null,
@@ -6253,7 +6354,11 @@ function buildKafkaTraceEntries(
         TRACE_ORDER_MODE === 'tree'
             ? reorderTraceEvents(baseEvents)
             : sortTraceEventsChronologically(baseEvents);
-    const batches = chunkArray(orderedEvents, TRACE_BATCH_SIZE);
+    const batches = chunkTraceEventsForTransport(
+        orderedEvents,
+        requestRid,
+        actionId,
+    );
     return batches.map((batch, index) => ({
         actionId: actionId ?? null,
         trace: batch,
@@ -6300,7 +6405,7 @@ function scheduleKafkaTraceFlush(
                 post(cfg, sid, { entries });
             }
         });
-    });
+    }, { priority: 'high' });
 }
 
 function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
@@ -7605,6 +7710,31 @@ export async function initRepro(cfg: ReproInitConfig): Promise<void> {
 /** @internal Test hooks for runtime privacy policy wiring. */
 export const __reproTestHooks = {
     shareRuntimePrivacyStateForTest: shareRuntimePrivacyState,
+    setFullValueCaptureEnabledForTest(enabled: boolean): void {
+        __FULL_VALUE_CAPTURE_ENABLED = enabled === true;
+    },
+    scheduleSdkBackgroundWorkForTest(
+        work: () => Promise<void> | void,
+        options?: { priority?: 'high' | 'normal' },
+    ): void {
+        scheduleSdkBackgroundWork(work, options);
+    },
+    async drainSdkBackgroundQueueForTest(): Promise<void> {
+        await drainSdkBackgroundQueue();
+    },
+    resetSdkBackgroundQueuesForTest(): void {
+        sdkBackgroundHighQueue.length = 0;
+        sdkBackgroundQueue.length = 0;
+        if (sdkBackgroundTimer) {
+            try { clearTimeout(sdkBackgroundTimer); } catch {}
+            sdkBackgroundTimer = null;
+        }
+        sdkBackgroundDraining = false;
+        activeClientRequestCount = 0;
+        oldestActiveClientRequestAt = null;
+        lastClientActivityAt = 0;
+        sdkBackgroundQuietUntil = 0;
+    },
     getRuntimePrivacyPolicyForTest(cfg: ReproMiddlewareConfig): NormalizedRuntimePrivacyPolicy | null {
         return getRuntimePrivacyState(cfg).policy;
     },
@@ -7618,4 +7748,8 @@ export const __reproTestHooks = {
     materializeInlinePrivacyValueAsyncForTest: materializeInlinePrivacyValueAsync,
     patchKafkaProducerInstanceForTest: patchKafkaProducerInstance,
     wrapKafkaEachMessageHandlerForTest: wrapKafkaEachMessageHandler,
+    chunkTraceEventsForTransportForTest: chunkTraceEventsForTransport,
+    estimateTraceBatchSerializedBytesForTest: estimateTraceBatchSerializedBytes,
+    sanitizeTraceValueForPrivacyForTest: sanitizeTraceValueForPrivacy,
+    sanitizeMaterializedTraceValueForTest: sanitizeMaterializedTraceValue,
 };

package/test/kafka-runtime-privacy-policy.test.js

@@ -567,6 +567,7 @@ async function testLargeStringTraceValuesAreCapturedInlineWithoutTruncation() {
     };
 
     const sink = [];
+    __reproTestHooks.setFullValueCaptureEnabledForTest(true);
     await __reproTestHooks.recordKafkaTraceEventAsyncForTest(
         {
             type: 'enter',
@@ -579,6 +580,7 @@ async function testLargeStringTraceValuesAreCapturedInlineWithoutTruncation() {
         cfg,
         maskReq,
     );
+    __reproTestHooks.setFullValueCaptureEnabledForTest(false);
 
     assert.strictEqual(sink.length, 1);
     assert.strictEqual(sink[0].fn, 'parseGatewayPayload');
@@ -622,6 +624,7 @@ async function testLargeStructuredTraceValuesAreCapturedInlineWithoutTruncation(
     };
 
     const sink = [];
+    __reproTestHooks.setFullValueCaptureEnabledForTest(true);
     await __reproTestHooks.recordKafkaTraceEventAsyncForTest(
         {
             type: 'enter',
@@ -634,6 +637,7 @@ async function testLargeStructuredTraceValuesAreCapturedInlineWithoutTruncation(
         cfg,
         maskReq,
     );
+    __reproTestHooks.setFullValueCaptureEnabledForTest(false);
 
     assert.strictEqual(sink.length, 1);
     assert.strictEqual(sink[0].fn, 'recordConsumedEvent');
@@ -677,6 +681,7 @@ async function testLargeTraceReturnValueIsCapturedInlineWithoutTruncation() {
     };
 
     const sink = [];
+    __reproTestHooks.setFullValueCaptureEnabledForTest(true);
     await __reproTestHooks.recordKafkaTraceEventAsyncForTest(
         {
             type: 'exit',
@@ -689,6 +694,7 @@ async function testLargeTraceReturnValueIsCapturedInlineWithoutTruncation() {
         cfg,
         maskReq,
     );
+    __reproTestHooks.setFullValueCaptureEnabledForTest(false);
 
     assert.strictEqual(sink.length, 1);
     assert.strictEqual(sink[0].fn, 'toDrillResponse');

package/test/sdk-background-priority.test.js

@@ -0,0 +1,35 @@
+const assert = require('node:assert/strict');
+
+const sdk = require('../dist/index.js');
+
+async function main() {
+    const hooks = sdk.__reproTestHooks;
+    hooks.resetSdkBackgroundQueuesForTest();
+
+    const order = [];
+
+    hooks.scheduleSdkBackgroundWorkForTest(() => {
+        order.push('normal-1');
+    });
+    hooks.scheduleSdkBackgroundWorkForTest(() => {
+        order.push('normal-2');
+    });
+    hooks.scheduleSdkBackgroundWorkForTest(() => {
+        order.push('high-1');
+    }, { priority: 'high' });
+    hooks.scheduleSdkBackgroundWorkForTest(() => {
+        order.push('high-2');
+    }, { priority: 'high' });
+
+    await hooks.drainSdkBackgroundQueueForTest();
+
+    assert.deepStrictEqual(order, ['high-1', 'high-2', 'normal-1', 'normal-2']);
+
+    hooks.resetSdkBackgroundQueuesForTest();
+    console.log('sdk background priority OK');
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/test/trace-batch-size.test.js

@@ -0,0 +1,58 @@
+const assert = require('assert');
+const { __reproTestHooks } = require('../dist');
+
+function makeEvent(index, payload) {
+    return {
+        t: index,
+        type: 'enter',
+        fn: `fn${index}`,
+        file: '/app/src/controllers/subjects/index.ts',
+        line: index + 1,
+        depth: 1,
+        spanId: index + 1,
+        parentSpanId: null,
+        args: [payload],
+    };
+}
+
+function main() {
+    const payload = {
+        __kind: 'http-request',
+        method: 'POST',
+        url: '/api/v1/subject_visits/697001aaac70cc3d60f21273/subjects/createNewSubject?tenantId=tgtherapeutics',
+        headers: {
+            x_http_user: 'x'.repeat(12000),
+            authorization: '[dropped]',
+        },
+        body: {
+            value: 'y'.repeat(12000),
+        },
+    };
+
+    const events = Array.from({ length: 120 }, (_, index) => makeEvent(index, payload));
+    const batches = __reproTestHooks.chunkTraceEventsForTransportForTest(
+        events,
+        'RID_test_trace_batch_size',
+        'A_test_trace_batch_size',
+    );
+
+    assert(batches.length > 1, `expected more than one batch, got ${batches.length}`);
+
+    batches.forEach((batch, index) => {
+        const size = __reproTestHooks.estimateTraceBatchSerializedBytesForTest(
+            batch,
+            'RID_test_trace_batch_size',
+            'A_test_trace_batch_size',
+            index,
+        );
+        assert(
+            size <= 512 * 1024,
+            `batch ${index} too large: ${size}`,
+        );
+    });
+
+    // eslint-disable-next-line no-console
+    console.log('trace batch size chunking OK');
+}
+
+main();