@reproapp/node-sdk 0.0.41 → 0.0.44

package/README.md

@@ -194,10 +194,11 @@ type ReproInitConfig = {
 ```
 
 Important options:
-- `tenantId`, `appId`, `appSecret`: Repro service credentials.
-- `appName`: Product or workspace label sent as `X-App-Name`.
+- `tenantId`, `appId`, `appSecret`: Repro application credentials.
+- `appName`: Application label sent as `X-App-Name`.
 - `serviceName`: Backend service label stored on request, trace, DB, queue, Redis,
-  and email events.
+  and email events. The SDK also registers this service with the application in
+  the background so admins can see its environments and privacy policy status.
 - `apiBase`: Repro API base URL. Used by backend live sessions and privacy policy fetches.
 - `captureHeaders`: Enables header capture. Sensitive headers are masked unless
   explicitly unmasked.

package/dist/index.d.ts

@@ -292,6 +292,7 @@ type BackendLiveTimingConfig = {
     segmentMaxDurationMs: number;
     segmentIdleMs: number;
 };
+declare function registerRuntimeService(cfg: ReproMiddlewareConfig): Promise<void>;
 declare function sanitizeTraceValueForPrivacy(value: any): any;
 declare function sanitizeMaterializedTraceValue(value: any): any;
 export declare function __materializePendingTraceEventsForWorker(payload: TraceMaterializationWorkerPayload): Promise<PendingTraceEventRecord[]>;
@@ -458,6 +459,7 @@ export declare const __reproTestHooks: {
     }): void;
     drainSdkBackgroundQueueForTest(): Promise<void>;
     resetSdkBackgroundQueuesForTest(): void;
+    registerRuntimeServiceForTest: typeof registerRuntimeService;
     setBackendLiveTimingForTest(override: Partial<BackendLiveTimingConfig> | null): void;
     runWithRequestContextForTest<T>(ctx: Partial<Ctx>, fn: () => T): T;
     getNativeMongoSuppressionCountForTest(): number;

package/dist/index.js

@@ -841,7 +841,7 @@ function emitRequestCaptureStart(cfg, sessionId, actionId, scope, openedAtMs) {
                 },
                 t: openedAt,
             }],
-    }, { priority: 'high' });
+    }, { priority: 'critical' });
 }
 const als = new async_hooks_1.AsyncLocalStorage();
 const getCtx = () => als.getStore() || {};
@@ -985,7 +985,7 @@ const SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = (() => {
 const SDK_BACKGROUND_MAX_DEFER_MS = (() => {
     const raw = String(process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS ?? '').trim().toLowerCase();
     if (!raw) {
-        return Number.POSITIVE_INFINITY;
+        return 30000;
     }
     if (raw === 'off' || raw === 'never' || raw === 'infinite' || raw === 'infinity' || raw === '-1') {
         return Number.POSITIVE_INFINITY;
@@ -1813,6 +1813,47 @@ async function postLiveApiJson(cfg, liveMode, path, body) {
         return null;
     }
 }
+async function registerRuntimeService(cfg) {
+    const serviceName = typeof cfg.serviceName === 'string' ? cfg.serviceName.trim() : '';
+    const apiBase = resolveLiveApiBase(cfg, normalizeLiveModeConfig(cfg));
+    const fetchImpl = globalThis.fetch;
+    if (!serviceName ||
+        !apiBase ||
+        !cfg.appId ||
+        !cfg.appSecret ||
+        typeof fetchImpl !== 'function') {
+        return;
+    }
+    const controller = typeof AbortController === 'function' ? new AbortController() : null;
+    const timeout = setTimeout(() => controller?.abort(), 2500);
+    try {
+        timeout.unref?.();
+    }
+    catch { }
+    try {
+        await fetchImpl(`${apiBase}/v1/sdk/runtime-services`, {
+            method: 'POST',
+            headers: liveApiHeaders(cfg),
+            body: JSON.stringify({
+                serviceName,
+                environment: (0, privacy_1.normalizePrivacyEnvironment)(cfg.privacy?.environment),
+            }),
+            ...(controller ? { signal: controller.signal } : {}),
+        });
+    }
+    catch {
+        // Service discovery is best-effort and must never affect host startup.
+    }
+    finally {
+        try {
+            clearTimeout(timeout);
+        }
+        catch { }
+    }
+}
+function enqueueRuntimeServiceRegistration(cfg) {
+    scheduleSdkBackgroundWork(() => registerRuntimeService(cfg));
+}
 function enqueueLiveSessionStart(cfg, liveMode, payload) {
     scheduleSdkBackgroundWork(() => postLiveApi(cfg, liveMode, '/v1/live-sessions', payload), { priority: 'high' });
 }
@@ -3190,6 +3231,7 @@ async function ensureRuntimePrivacyPolicyLoaded(cfg) {
         appId: cfg.appId,
         appSecret: cfg.appSecret,
         appName: cfg.appName,
+        serviceName: cfg.serviceName,
         apiBase,
         environment: state.environment,
         fetchTimeoutMs: privacy?.fetchTimeoutMs,
@@ -3231,6 +3273,7 @@ async function initializeRuntimePrivacyPolicyAtStartup(cfg) {
             appId: cfg.appId,
             appSecret: cfg.appSecret,
             appName: cfg.appName,
+            serviceName: cfg.serviceName,
             apiBase,
             environment: state.environment,
             fetchTimeoutMs: privacy?.fetchTimeoutMs,
@@ -9835,6 +9878,7 @@ async function initRepro(cfg) {
     await installMongoDbImportHook();
     patchSendgridMail(integrationCfg);
     patchMongooseIntegration(reproAutoMiddlewareConfig);
+    enqueueRuntimeServiceRegistration(reproAutoMiddlewareConfig);
     await initializeRuntimePrivacyPolicyAtStartup(reproAutoMiddlewareConfig);
 }
 exports.initRepro = initRepro;
@@ -9866,6 +9910,7 @@ exports.__reproTestHooks = {
         lastClientActivityAt = 0;
         sdkBackgroundQuietUntil = 0;
     },
+    registerRuntimeServiceForTest: registerRuntimeService,
     setBackendLiveTimingForTest(override) {
         backendLiveTimingOverrideForTest = override;
     },

package/dist/ingest/client.d.ts

@@ -1,6 +1,6 @@
 import type { IngestClientConfig, LegacyEntry } from './types';
 export type EnqueueIngestOptions = {
-    priority?: 'normal' | 'high';
+    priority?: 'normal' | 'high' | 'critical';
 };
 export declare const configureIngestQueueDrain: (options: {
     shouldDefer?: (() => boolean) | null;

package/dist/ingest/client.js

@@ -14,6 +14,22 @@ const DEFAULT_QUEUE_MAX_ITEMS = (() => {
 const DEFAULT_QUEUE_MAX_ATTEMPTS = 5;
 const DEFAULT_QUEUE_BACKOFF_MAX_MS = 4000;
 const DEFAULT_DEFER_DRAIN_MS = 25;
+const DEFAULT_BATCH_MAX_ENTRIES = (() => {
+    const env = Number(typeof process !== 'undefined' ? process?.env?.REPRO_INGEST_BATCH_MAX_ENTRIES : undefined);
+    if (Number.isFinite(env) && env > 0) {
+        return Math.trunc(env);
+    }
+    return 100;
+})();
+const DEFAULT_BATCH_MAX_SERIALIZED_BYTES = (() => {
+    const env = Number(typeof process !== 'undefined'
+        ? process?.env?.REPRO_INGEST_BATCH_MAX_SERIALIZED_BYTES
+        : undefined);
+    if (Number.isFinite(env) && env > 0) {
+        return Math.trunc(env);
+    }
+    return 1024 * 1024;
+})();
 const DEFAULT_INGEST_REQUEST_TIMEOUT_MS = (() => {
     const env = Number(typeof process !== 'undefined' ? process?.env?.REPRO_INGEST_REQUEST_TIMEOUT_MS : undefined);
     if (Number.isFinite(env) && env >= 0) {
@@ -22,9 +38,13 @@ const DEFAULT_INGEST_REQUEST_TIMEOUT_MS = (() => {
     return 120000;
 })();
 const ingestQueue = [];
+const criticalIngestQueue = [];
 let drainTimer = null;
+let criticalDrainTimer = null;
 let draining = false;
+let criticalDraining = false;
 let backoffMs = 0;
+let criticalBackoffMs = 0;
 let shouldDeferDrain = null;
 let deferDrainMs = DEFAULT_DEFER_DRAIN_MS;
 const configureIngestQueueDrain = (options) => {
@@ -35,12 +55,15 @@ const configureIngestQueueDrain = (options) => {
 };
 exports.configureIngestQueueDrain = configureIngestQueueDrain;
 const kickIngestQueueDrain = () => {
+    if (criticalIngestQueue.length > 0 && !criticalDrainTimer) {
+        scheduleCriticalDrain();
+    }
     if (ingestQueue.length > 0 && !drainTimer) {
         scheduleDrain(shouldDeferDrain?.() ? deferDrainMs : 0);
     }
 };
 exports.kickIngestQueueDrain = kickIngestQueueDrain;
-const isCriticalIngestEntry = (entry) => (entry.requestCaptureStart !== undefined ||
+const isHighPriorityIngestEntry = (entry) => (entry.requestCaptureStart !== undefined ||
     entry.requestCaptureManifest !== undefined ||
     entry.sessionCaptureManifest !== undefined ||
     entry.request !== undefined ||
@@ -48,10 +71,72 @@ const isCriticalIngestEntry = (entry) => (entry.requestCaptureStart !== undefine
     entry.trace !== undefined ||
     entry.email !== undefined);
 const resolveBatchPriority = (entries, options) => {
-    if (options.priority === 'high') {
-        return 'high';
+    if (options.priority === 'high' || options.priority === 'critical') {
+        return options.priority;
+    }
+    return entries.some(isHighPriorityIngestEntry) ? 'high' : 'normal';
+};
+const sameIngestDestination = (left, right) => (left.sessionId === right.sessionId &&
+    left.priority === right.priority &&
+    left.config.appId === right.config.appId &&
+    left.config.tenantId === right.config.tenantId &&
+    left.config.appSecret === right.config.appSecret &&
+    left.config.appName === right.config.appName &&
+    left.config.serviceName === right.config.serviceName &&
+    left.config.ingestBase === right.config.ingestBase &&
+    left.config.ingestPath === right.config.ingestPath &&
+    left.config.actorId === right.config.actorId &&
+    left.config.actorType === right.config.actorType &&
+    JSON.stringify(left.config.actorLabels ?? null) ===
+        JSON.stringify(right.config.actorLabels ?? null) &&
+    left.config.source === right.config.source &&
+    left.config.schemaVersion === right.config.schemaVersion);
+const serializedBytes = (value) => {
+    try {
+        return Buffer.byteLength(JSON.stringify(value), 'utf8');
+    }
+    catch {
+        return DEFAULT_BATCH_MAX_SERIALIZED_BYTES + 1;
     }
-    return entries.some(isCriticalIngestEntry) ? 'high' : 'normal';
+};
+const selectSendBatch = (queue) => {
+    const first = queue[0];
+    if (!first) {
+        return null;
+    }
+    if (first.priority === 'normal') {
+        return { batch: first, queueItems: 1 };
+    }
+    const entries = first.entries.slice();
+    let bytes = serializedBytes(entries);
+    let queueItems = 1;
+    for (let index = 1; index < queue.length && entries.length < DEFAULT_BATCH_MAX_ENTRIES; index += 1) {
+        const candidate = queue[index];
+        if (!candidate || !sameIngestDestination(first, candidate)) {
+            break;
+        }
+        if (entries.length + candidate.entries.length > DEFAULT_BATCH_MAX_ENTRIES) {
+            break;
+        }
+        const candidateBytes = serializedBytes(candidate.entries);
+        if (bytes + candidateBytes > DEFAULT_BATCH_MAX_SERIALIZED_BYTES) {
+            break;
+        }
+        entries.push(...candidate.entries);
+        bytes += candidateBytes;
+        queueItems += 1;
+    }
+    if (queueItems === 1) {
+        return { batch: first, queueItems };
+    }
+    return {
+        batch: {
+            ...first,
+            entries,
+            attempts: Math.max(...queue.slice(0, queueItems).map((item) => item.attempts)),
+        },
+        queueItems,
+    };
 };
 const resolveIngestUrl = (config) => {
     const envBase = typeof process !== 'undefined' ? process?.env?.REPRO_INGEST_BASE : undefined;
@@ -144,6 +229,51 @@ const scheduleDrain = (delayMs = 0) => {
     }
     catch { }
 };
+const scheduleCriticalDrain = (delayMs = 0) => {
+    if (criticalDrainTimer) {
+        return;
+    }
+    criticalDrainTimer = setTimeout(() => {
+        criticalDrainTimer = null;
+        void drainCriticalIngestQueue();
+    }, Math.max(0, delayMs));
+    try {
+        criticalDrainTimer.unref?.();
+    }
+    catch { }
+};
+const drainCriticalIngestQueue = async () => {
+    if (criticalDraining) {
+        return;
+    }
+    criticalDraining = true;
+    try {
+        while (criticalIngestQueue.length > 0) {
+            const selected = selectSendBatch(criticalIngestQueue);
+            if (!selected) {
+                return;
+            }
+            const ok = await sendIngestEntries(selected.batch.config, selected.batch.sessionId, selected.batch.entries);
+            if (ok) {
+                criticalIngestQueue.splice(0, selected.queueItems);
+                criticalBackoffMs = 0;
+                continue;
+            }
+            for (let index = 0; index < selected.queueItems; index += 1) {
+                criticalIngestQueue[index].attempts += 1;
+            }
+            criticalBackoffMs = Math.min(DEFAULT_QUEUE_BACKOFF_MAX_MS, criticalBackoffMs ? criticalBackoffMs * 2 : 250);
+            scheduleCriticalDrain(criticalBackoffMs);
+            return;
+        }
+    }
+    finally {
+        criticalDraining = false;
+        if (criticalIngestQueue.length > 0 && !criticalDrainTimer) {
+            scheduleCriticalDrain(criticalBackoffMs);
+        }
+    }
+};
 const drainIngestQueue = async () => {
     if (draining) {
         return;
@@ -159,15 +289,22 @@ const drainIngestQueue = async () => {
                 scheduleDrain(deferDrainMs);
                 return;
             }
-            const batch = ingestQueue[0];
+            const selected = selectSendBatch(ingestQueue);
+            if (!selected) {
+                return;
+            }
+            const batch = selected.batch;
             const ok = await sendIngestEntries(batch.config, batch.sessionId, batch.entries);
             if (ok) {
-                ingestQueue.shift();
+                ingestQueue.splice(0, selected.queueItems);
                 backoffMs = 0;
                 continue;
             }
-            batch.attempts += 1;
-            if (batch.attempts >= DEFAULT_QUEUE_MAX_ATTEMPTS && batch.priority !== 'high') {
+            for (let index = 0; index < selected.queueItems; index += 1) {
+                ingestQueue[index].attempts += 1;
+            }
+            if (ingestQueue[0].attempts >= DEFAULT_QUEUE_MAX_ATTEMPTS &&
+                ingestQueue[0].priority === 'normal') {
                 ingestQueue.shift();
                 backoffMs = 0;
                 continue;
@@ -196,6 +333,11 @@ const enqueueIngestEntries = (config, sessionId, entries, options = {}) => {
         attempts: 0,
         priority,
     };
+    if (priority === 'critical') {
+        criticalIngestQueue.push(batch);
+        scheduleCriticalDrain();
+        return true;
+    }
     if (priority === 'high') {
         const firstNormalIndex = ingestQueue.findIndex((queued) => queued.priority !== 'high');
         if (firstNormalIndex === -1) {
@@ -228,10 +370,15 @@ const enqueueIngestEntries = (config, sessionId, entries, options = {}) => {
 };
 exports.enqueueIngestEntries = enqueueIngestEntries;
 const flushIngestQueue = async () => {
+    if (criticalDrainTimer) {
+        clearTimeout(criticalDrainTimer);
+        criticalDrainTimer = null;
+    }
     if (drainTimer) {
         clearTimeout(drainTimer);
         drainTimer = null;
     }
+    await drainCriticalIngestQueue();
     await drainIngestQueue();
 };
 exports.flushIngestQueue = flushIngestQueue;

package/dist/privacy.d.ts

@@ -98,6 +98,7 @@ export declare function fetchApprovedRuntimePrivacyPolicy(params: {
     appId: string;
     appSecret?: string;
     appName?: string;
+    serviceName?: string;
     apiBase: string;
     environment: string;
     fetchTimeoutMs?: number;

package/dist/privacy.js

@@ -104,7 +104,13 @@ async function fetchApprovedRuntimePrivacyPolicy(params) {
             reason: !params.apiBase ? 'missing_config' : 'missing_credentials',
         };
     }
-    const url = `${params.apiBase}/v1/sdk/privacy-policy?environment=${encodeURIComponent(params.environment)}`;
+    const query = new URLSearchParams({
+        environment: params.environment,
+    });
+    if (typeof params.serviceName === 'string' && params.serviceName.trim()) {
+        query.set('serviceName', params.serviceName.trim());
+    }
+    const url = `${params.apiBase}/v1/sdk/privacy-policy?${query.toString()}`;
     const headers = {
         accept: 'application/json',
         'x-app-id': params.appId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.41",
+  "version": "0.0.44",
   "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/request-capture-background.test.js && node test/init-auto-http-server.test.js && node test/backend-live-mode.test.js && node test/client-performance-regression.test.js && node test/request-manifest-priority.test.js && node test/runtime-no-double-invoke.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 test/ingest-queue-retention.test.js && node test/ingest-high-priority-retention.test.js && node test/ingest-critical-retention.test.js && node test/ingest-critical-retry-retention.test.js && node test/ingest-timeout.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/wrap-plugin-super-call.test.js && node test/function-arg-identity.test.js && node test/privacy-runtime-policy.test.js && node test/runtime-privacy-materialization.test.js && node test/kafka-runtime-privacy-policy.test.js && node test/amqplib-integration.test.js && node test/mongodb-integration.test.js && node test/mongodb-esm-import-hook.test.js && node test/mongodb-suppression-cleanup.test.js && node test/postgresql-integration.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/request-capture-background.test.js && node test/init-auto-http-server.test.js && node test/backend-live-mode.test.js && node test/client-performance-regression.test.js && node test/request-manifest-priority.test.js && node test/runtime-no-double-invoke.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 test/runtime-service-registration.test.js && node test/ingest-queue-retention.test.js && node test/ingest-high-priority-retention.test.js && node test/ingest-critical-retention.test.js && node test/ingest-critical-retry-retention.test.js && node test/ingest-batching.test.js && node test/ingest-timeout.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/wrap-plugin-super-call.test.js && node test/function-arg-identity.test.js && node test/privacy-service-scope.test.js && node test/privacy-runtime-policy.test.js && node test/runtime-privacy-materialization.test.js && node test/kafka-runtime-privacy-policy.test.js && node test/amqplib-integration.test.js && node test/mongodb-integration.test.js && node test/mongodb-esm-import-hook.test.js && node test/mongodb-suppression-cleanup.test.js && node test/postgresql-integration.test.js",
     "test:containers": "npm run build && node test/runtime-no-double-invoke.testcontainers.test.js && node test/wrap-plugin-super-call.testcontainers.test.js && node test/function-arg-identity.testcontainers.test.js && node test/mongodb-mongoose-native-suppression.testcontainers.test.js && node test/postgresql-integrations.testcontainers.test.js"
   },
   "peerDependencies": {

package/src/index.ts

@@ -1249,7 +1249,7 @@ function emitRequestCaptureStart(
             },
             t: openedAt,
         }],
-    }, { priority: 'high' });
+    }, { priority: 'critical' });
 }
 
 const als = new AsyncLocalStorage<Ctx>();
@@ -1393,7 +1393,7 @@ const SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = (() => {
 const SDK_BACKGROUND_MAX_DEFER_MS = (() => {
     const raw = String(process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS ?? '').trim().toLowerCase();
     if (!raw) {
-        return Number.POSITIVE_INFINITY;
+        return 30000;
     }
     if (raw === 'off' || raw === 'never' || raw === 'infinite' || raw === 'infinity' || raw === '-1') {
         return Number.POSITIVE_INFINITY;
@@ -2250,6 +2250,55 @@ async function postLiveApiJson<T = Record<string, any>>(
     }
 }
 
+async function registerRuntimeService(
+    cfg: ReproMiddlewareConfig,
+): Promise<void> {
+    const serviceName =
+        typeof cfg.serviceName === 'string' ? cfg.serviceName.trim() : '';
+    const apiBase = resolveLiveApiBase(cfg, normalizeLiveModeConfig(cfg));
+    const fetchImpl = (globalThis as any).fetch;
+    if (
+        !serviceName ||
+        !apiBase ||
+        !cfg.appId ||
+        !cfg.appSecret ||
+        typeof fetchImpl !== 'function'
+    ) {
+        return;
+    }
+
+    const controller =
+        typeof AbortController === 'function' ? new AbortController() : null;
+    const timeout = setTimeout(() => controller?.abort(), 2_500);
+    try {
+        timeout.unref?.();
+    } catch {}
+
+    try {
+        await fetchImpl(`${apiBase}/v1/sdk/runtime-services`, {
+            method: 'POST',
+            headers: liveApiHeaders(cfg),
+            body: JSON.stringify({
+                serviceName,
+                environment: normalizePrivacyEnvironment(
+                    cfg.privacy?.environment,
+                ),
+            }),
+            ...(controller ? { signal: controller.signal } : {}),
+        });
+    } catch {
+        // Service discovery is best-effort and must never affect host startup.
+    } finally {
+        try {
+            clearTimeout(timeout);
+        } catch {}
+    }
+}
+
+function enqueueRuntimeServiceRegistration(cfg: ReproMiddlewareConfig): void {
+    scheduleSdkBackgroundWork(() => registerRuntimeService(cfg));
+}
+
 function enqueueLiveSessionStart(
     cfg: ReproMiddlewareConfig,
     liveMode: ReproLiveModeConfig | null,
@@ -3844,6 +3893,7 @@ async function ensureRuntimePrivacyPolicyLoaded(cfg: ReproMiddlewareConfig): Pro
         appId: cfg.appId,
         appSecret: cfg.appSecret,
         appName: cfg.appName,
+        serviceName: cfg.serviceName,
         apiBase,
         environment: state.environment,
         fetchTimeoutMs: privacy?.fetchTimeoutMs,
@@ -3894,6 +3944,7 @@ async function initializeRuntimePrivacyPolicyAtStartup(cfg: ReproMiddlewareConfi
             appId: cfg.appId,
             appSecret: cfg.appSecret,
             appName: cfg.appName,
+            serviceName: cfg.serviceName,
             apiBase,
             environment: state.environment,
             fetchTimeoutMs: privacy?.fetchTimeoutMs,
@@ -11365,6 +11416,7 @@ export async function initRepro(cfg: ReproInitConfig): Promise<void> {
     patchSendgridMail(integrationCfg);
     patchMongooseIntegration(reproAutoMiddlewareConfig);
 
+    enqueueRuntimeServiceRegistration(reproAutoMiddlewareConfig);
     await initializeRuntimePrivacyPolicyAtStartup(reproAutoMiddlewareConfig);
 }
 
@@ -11396,6 +11448,7 @@ export const __reproTestHooks = {
         lastClientActivityAt = 0;
         sdkBackgroundQuietUntil = 0;
     },
+    registerRuntimeServiceForTest: registerRuntimeService,
     setBackendLiveTimingForTest(override: Partial<BackendLiveTimingConfig> | null): void {
         backendLiveTimingOverrideForTest = override;
     },

package/src/ingest/client.ts

@@ -13,6 +13,24 @@ const DEFAULT_QUEUE_MAX_ITEMS = (() => {
 const DEFAULT_QUEUE_MAX_ATTEMPTS = 5;
 const DEFAULT_QUEUE_BACKOFF_MAX_MS = 4000;
 const DEFAULT_DEFER_DRAIN_MS = 25;
+const DEFAULT_BATCH_MAX_ENTRIES = (() => {
+    const env = Number(typeof process !== 'undefined' ? (process as any)?.env?.REPRO_INGEST_BATCH_MAX_ENTRIES : undefined);
+    if (Number.isFinite(env) && env > 0) {
+        return Math.trunc(env);
+    }
+    return 100;
+})();
+const DEFAULT_BATCH_MAX_SERIALIZED_BYTES = (() => {
+    const env = Number(
+        typeof process !== 'undefined'
+            ? (process as any)?.env?.REPRO_INGEST_BATCH_MAX_SERIALIZED_BYTES
+            : undefined,
+    );
+    if (Number.isFinite(env) && env > 0) {
+        return Math.trunc(env);
+    }
+    return 1024 * 1024;
+})();
 const DEFAULT_INGEST_REQUEST_TIMEOUT_MS = (() => {
     const env = Number(typeof process !== 'undefined' ? (process as any)?.env?.REPRO_INGEST_REQUEST_TIMEOUT_MS : undefined);
     if (Number.isFinite(env) && env >= 0) {
@@ -26,17 +44,21 @@ type QueuedIngestBatch = {
     sessionId: string;
     entries: LegacyEntry[];
     attempts: number;
-    priority: 'normal' | 'high';
+    priority: 'normal' | 'high' | 'critical';
 };
 
 export type EnqueueIngestOptions = {
-    priority?: 'normal' | 'high';
+    priority?: 'normal' | 'high' | 'critical';
 };
 
 const ingestQueue: QueuedIngestBatch[] = [];
+const criticalIngestQueue: QueuedIngestBatch[] = [];
 let drainTimer: ReturnType<typeof setTimeout> | null = null;
+let criticalDrainTimer: ReturnType<typeof setTimeout> | null = null;
 let draining = false;
+let criticalDraining = false;
 let backoffMs = 0;
+let criticalBackoffMs = 0;
 let shouldDeferDrain: (() => boolean) | null = null;
 let deferDrainMs = DEFAULT_DEFER_DRAIN_MS;
 
@@ -51,12 +73,15 @@ export const configureIngestQueueDrain = (options: {
 };
 
 export const kickIngestQueueDrain = (): void => {
+    if (criticalIngestQueue.length > 0 && !criticalDrainTimer) {
+        scheduleCriticalDrain();
+    }
     if (ingestQueue.length > 0 && !drainTimer) {
         scheduleDrain(shouldDeferDrain?.() ? deferDrainMs : 0);
     }
 };
 
-const isCriticalIngestEntry = (entry: LegacyEntry): boolean => (
+const isHighPriorityIngestEntry = (entry: LegacyEntry): boolean => (
     entry.requestCaptureStart !== undefined ||
     entry.requestCaptureManifest !== undefined ||
     entry.sessionCaptureManifest !== undefined ||
@@ -70,10 +95,89 @@ const resolveBatchPriority = (
     entries: LegacyEntry[],
     options: EnqueueIngestOptions,
 ): QueuedIngestBatch['priority'] => {
-    if (options.priority === 'high') {
-        return 'high';
+    if (options.priority === 'high' || options.priority === 'critical') {
+        return options.priority;
+    }
+    return entries.some(isHighPriorityIngestEntry) ? 'high' : 'normal';
+};
+
+const sameIngestDestination = (
+    left: QueuedIngestBatch,
+    right: QueuedIngestBatch,
+): boolean => (
+    left.sessionId === right.sessionId &&
+    left.priority === right.priority &&
+    left.config.appId === right.config.appId &&
+    left.config.tenantId === right.config.tenantId &&
+    left.config.appSecret === right.config.appSecret &&
+    left.config.appName === right.config.appName &&
+    left.config.serviceName === right.config.serviceName &&
+    left.config.ingestBase === right.config.ingestBase &&
+    left.config.ingestPath === right.config.ingestPath &&
+    left.config.actorId === right.config.actorId &&
+    left.config.actorType === right.config.actorType &&
+    JSON.stringify(left.config.actorLabels ?? null) ===
+        JSON.stringify(right.config.actorLabels ?? null) &&
+    left.config.source === right.config.source &&
+    left.config.schemaVersion === right.config.schemaVersion
+);
+
+const serializedBytes = (value: unknown): number => {
+    try {
+        return Buffer.byteLength(JSON.stringify(value), 'utf8');
+    } catch {
+        return DEFAULT_BATCH_MAX_SERIALIZED_BYTES + 1;
     }
-    return entries.some(isCriticalIngestEntry) ? 'high' : 'normal';
+};
+
+const selectSendBatch = (
+    queue: QueuedIngestBatch[],
+): { batch: QueuedIngestBatch; queueItems: number } | null => {
+    const first = queue[0];
+    if (!first) {
+        return null;
+    }
+    if (first.priority === 'normal') {
+        return { batch: first, queueItems: 1 };
+    }
+
+    const entries = first.entries.slice();
+    let bytes = serializedBytes(entries);
+    let queueItems = 1;
+    for (
+        let index = 1;
+        index < queue.length && entries.length < DEFAULT_BATCH_MAX_ENTRIES;
+        index += 1
+    ) {
+        const candidate = queue[index];
+        if (!candidate || !sameIngestDestination(first, candidate)) {
+            break;
+        }
+        if (entries.length + candidate.entries.length > DEFAULT_BATCH_MAX_ENTRIES) {
+            break;
+        }
+        const candidateBytes = serializedBytes(candidate.entries);
+        if (bytes + candidateBytes > DEFAULT_BATCH_MAX_SERIALIZED_BYTES) {
+            break;
+        }
+        entries.push(...candidate.entries);
+        bytes += candidateBytes;
+        queueItems += 1;
+    }
+
+    if (queueItems === 1) {
+        return { batch: first, queueItems };
+    }
+    return {
+        batch: {
+            ...first,
+            entries,
+            attempts: Math.max(
+                ...queue.slice(0, queueItems).map((item) => item.attempts),
+            ),
+        },
+        queueItems,
+    };
 };
 
 const resolveIngestUrl = (config: IngestClientConfig): string => {
@@ -181,6 +285,59 @@ const scheduleDrain = (delayMs = 0): void => {
     } catch {}
 };
 
+const scheduleCriticalDrain = (delayMs = 0): void => {
+    if (criticalDrainTimer) {
+        return;
+    }
+    criticalDrainTimer = setTimeout(() => {
+        criticalDrainTimer = null;
+        void drainCriticalIngestQueue();
+    }, Math.max(0, delayMs));
+    try {
+        (criticalDrainTimer as any).unref?.();
+    } catch {}
+};
+
+const drainCriticalIngestQueue = async (): Promise<void> => {
+    if (criticalDraining) {
+        return;
+    }
+    criticalDraining = true;
+    try {
+        while (criticalIngestQueue.length > 0) {
+            const selected = selectSendBatch(criticalIngestQueue);
+            if (!selected) {
+                return;
+            }
+            const ok = await sendIngestEntries(
+                selected.batch.config,
+                selected.batch.sessionId,
+                selected.batch.entries,
+            );
+            if (ok) {
+                criticalIngestQueue.splice(0, selected.queueItems);
+                criticalBackoffMs = 0;
+                continue;
+            }
+
+            for (let index = 0; index < selected.queueItems; index += 1) {
+                criticalIngestQueue[index].attempts += 1;
+            }
+            criticalBackoffMs = Math.min(
+                DEFAULT_QUEUE_BACKOFF_MAX_MS,
+                criticalBackoffMs ? criticalBackoffMs * 2 : 250,
+            );
+            scheduleCriticalDrain(criticalBackoffMs);
+            return;
+        }
+    } finally {
+        criticalDraining = false;
+        if (criticalIngestQueue.length > 0 && !criticalDrainTimer) {
+            scheduleCriticalDrain(criticalBackoffMs);
+        }
+    }
+};
+
 const drainIngestQueue = async (): Promise<void> => {
     if (draining) {
         return;
@@ -196,16 +353,25 @@ const drainIngestQueue = async (): Promise<void> => {
                 scheduleDrain(deferDrainMs);
                 return;
             }
-            const batch = ingestQueue[0];
+            const selected = selectSendBatch(ingestQueue);
+            if (!selected) {
+                return;
+            }
+            const batch = selected.batch;
             const ok = await sendIngestEntries(batch.config, batch.sessionId, batch.entries);
             if (ok) {
-                ingestQueue.shift();
+                ingestQueue.splice(0, selected.queueItems);
                 backoffMs = 0;
                 continue;
             }
 
-            batch.attempts += 1;
-            if (batch.attempts >= DEFAULT_QUEUE_MAX_ATTEMPTS && batch.priority !== 'high') {
+            for (let index = 0; index < selected.queueItems; index += 1) {
+                ingestQueue[index].attempts += 1;
+            }
+            if (
+                ingestQueue[0].attempts >= DEFAULT_QUEUE_MAX_ATTEMPTS &&
+                ingestQueue[0].priority === 'normal'
+            ) {
                 ingestQueue.shift();
                 backoffMs = 0;
                 continue;
@@ -243,6 +409,11 @@ export const enqueueIngestEntries = (
         attempts: 0,
         priority,
     };
+    if (priority === 'critical') {
+        criticalIngestQueue.push(batch);
+        scheduleCriticalDrain();
+        return true;
+    }
     if (priority === 'high') {
         const firstNormalIndex = ingestQueue.findIndex((queued) => queued.priority !== 'high');
         if (firstNormalIndex === -1) {
@@ -273,10 +444,15 @@ export const enqueueIngestEntries = (
 };
 
 export const flushIngestQueue = async (): Promise<void> => {
+    if (criticalDrainTimer) {
+        clearTimeout(criticalDrainTimer);
+        criticalDrainTimer = null;
+    }
     if (drainTimer) {
         clearTimeout(drainTimer);
         drainTimer = null;
     }
+    await drainCriticalIngestQueue();
     await drainIngestQueue();
 };
 

package/src/privacy.ts

@@ -230,6 +230,7 @@ export async function fetchApprovedRuntimePrivacyPolicy(params: {
     appId: string;
     appSecret?: string;
     appName?: string;
+    serviceName?: string;
     apiBase: string;
     environment: string;
     fetchTimeoutMs?: number;
@@ -240,7 +241,13 @@ export async function fetchApprovedRuntimePrivacyPolicy(params: {
             reason: !params.apiBase ? 'missing_config' : 'missing_credentials',
         };
     }
-    const url = `${params.apiBase}/v1/sdk/privacy-policy?environment=${encodeURIComponent(params.environment)}`;
+    const query = new URLSearchParams({
+        environment: params.environment,
+    });
+    if (typeof params.serviceName === 'string' && params.serviceName.trim()) {
+        query.set('serviceName', params.serviceName.trim());
+    }
+    const url = `${params.apiBase}/v1/sdk/privacy-policy?${query.toString()}`;
     const headers: Record<string, string> = {
         accept: 'application/json',
         'x-app-id': params.appId,

package/test/client-performance-regression.test.js

@@ -119,6 +119,11 @@ async function main() {
         });
 
         await sleep(2200);
+        assert.equal(
+            eventsOf(capturedBodies, 'request_capture_start').length,
+            1,
+            `request-open fence was deferred with background work: ${JSON.stringify(capturedBodies)}`,
+        );
         assert.equal(
             eventsOf(capturedBodies, 'backend_request').length,
             0,

package/test/ingest-batching.test.js

@@ -0,0 +1,67 @@
+process.env.REPRO_INGEST_BATCH_MAX_ENTRIES = '100';
+process.env.REPRO_INGEST_BATCH_MAX_SERIALIZED_BYTES = String(1024 * 1024);
+
+const assert = require('node:assert/strict');
+
+const originalFetch = global.fetch;
+const capturedBodies = [];
+
+global.fetch = async (_url, init = {}) => {
+    capturedBodies.push(JSON.parse(String(init.body || '{}')));
+    return {
+        ok: true,
+        status: 202,
+        json: async () => ({ ok: true }),
+        text: async () => '{"ok":true}',
+    };
+};
+
+const { enqueueIngestEntries, flushIngestQueue } = require('../dist/ingest/client');
+
+async function main() {
+    const cfg = {
+        tenantId: 'TENANT_test',
+        appId: 'APP_test',
+        appSecret: 'secret',
+        serviceName: 'batching-test',
+        ingestBase: 'http://127.0.0.1:65535',
+    };
+    const sessionId = 'S_ingest_batching';
+
+    for (let index = 0; index < 209; index += 1) {
+        enqueueIngestEntries(cfg, sessionId, [{
+            actionId: 'A_ingest_batching',
+            requestRid: 'R_ingest_batching',
+            db: [{
+                collection: 'subjects',
+                op: 'findOne',
+                query: { index },
+            }],
+            t: Date.now() + index,
+        }], { priority: 'high' });
+    }
+
+    await flushIngestQueue();
+
+    const events = capturedBodies.flatMap((body) =>
+        Array.isArray(body?.events) ? body.events : [],
+    );
+    assert.equal(events.length, 209);
+    assert(events.every((event) => event.event_type === 'db_change'));
+    assert.equal(
+        capturedBodies.length,
+        3,
+        `209 small evidence entries should use three bounded requests, got ${capturedBodies.length}`,
+    );
+
+    console.log('ingest batching OK');
+}
+
+main()
+    .catch((error) => {
+        console.error(error);
+        process.exitCode = 1;
+    })
+    .finally(() => {
+        global.fetch = originalFetch;
+    });

package/test/privacy-service-scope.test.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const assert = require('node:assert');
+const {
+    fetchApprovedRuntimePrivacyPolicy,
+} = require('../dist/privacy.js');
+
+async function main() {
+    const originalFetch = global.fetch;
+    const calls = [];
+    global.fetch = async (url, init) => {
+        calls.push({ url: String(url), init });
+        return {
+            ok: true,
+            json: async () => ({ enabled: false }),
+        };
+    };
+
+    try {
+        await fetchApprovedRuntimePrivacyPolicy({
+            appId: 'APP_shared',
+            appSecret: 'secret',
+            appName: 'Shared app',
+            serviceName: ' Orders API ',
+            apiBase: 'https://repro.example/api',
+            environment: 'prod',
+        });
+        await fetchApprovedRuntimePrivacyPolicy({
+            appId: 'APP_shared',
+            appSecret: 'secret',
+            apiBase: 'https://repro.example/api',
+            environment: 'dev',
+        });
+    } finally {
+        global.fetch = originalFetch;
+    }
+
+    assert.strictEqual(calls.length, 2);
+    const serviceUrl = new URL(calls[0].url);
+    assert.strictEqual(serviceUrl.pathname, '/api/v1/sdk/privacy-policy');
+    assert.strictEqual(serviceUrl.searchParams.get('environment'), 'prod');
+    assert.strictEqual(serviceUrl.searchParams.get('serviceName'), 'Orders API');
+    assert.strictEqual(calls[0].init.headers['x-app-id'], 'APP_shared');
+    assert.strictEqual(calls[0].init.headers['x-app-secret'], 'secret');
+
+    const appWideUrl = new URL(calls[1].url);
+    assert.strictEqual(appWideUrl.searchParams.get('environment'), 'dev');
+    assert.strictEqual(appWideUrl.searchParams.has('serviceName'), false);
+
+    console.log('runtime privacy service scope OK');
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/test/request-capture-background.test.js

@@ -107,14 +107,19 @@ async function main() {
         });
 
         await sleep(100);
+        assert.equal(
+            countEvents(capturedBodies, 'request_capture_start'),
+            1,
+            `request-open fence must bypass client workload deferral: ${JSON.stringify(capturedBodies)}`,
+        );
         assert.equal(
             countEvents(capturedBodies, 'backend_request'),
             0,
             `request capture should defer while another client request is active: ${JSON.stringify(capturedBodies)}`,
         );
 
-        held.res.emit('finish');
         await waitFor(() => countEvents(capturedBodies, 'backend_request') === 1);
+        held.res.emit('finish');
         await flushIngestQueue();
 
         assert.equal(countEvents(capturedBodies, 'backend_request'), 1, JSON.stringify(capturedBodies));

package/test/runtime-service-registration.test.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+
+const { __reproTestHooks } = require('../dist');
+
+async function main() {
+  const originalFetch = global.fetch;
+  const calls = [];
+
+  try {
+    global.fetch = async (url, options) => {
+      calls.push({ url: String(url), options });
+      return { ok: true };
+    };
+
+    await __reproTestHooks.registerRuntimeServiceForTest({
+      tenantId: 'TENANT_test',
+      appId: 'APP_test',
+      appSecret: 'secret',
+      appName: 'Acme',
+      serviceName: ' orders-api ',
+      apiBase: 'http://repro-api.test/api/',
+      privacy: {
+        environment: 'production',
+        captureRaw: true,
+      },
+      ingestBase: 'http://collector.test',
+    });
+
+    assert.equal(calls.length, 1);
+    assert.equal(
+      calls[0].url,
+      'http://repro-api.test/api/v1/sdk/runtime-services',
+    );
+    assert.equal(calls[0].options.method, 'POST');
+    assert.deepEqual(calls[0].options.headers, {
+      'Content-Type': 'application/json',
+      'X-App-Id': 'APP_test',
+      'X-App-Secret': 'secret',
+      'X-App-Name': 'Acme',
+    });
+    assert.deepEqual(JSON.parse(calls[0].options.body), {
+      serviceName: 'orders-api',
+      environment: 'prod',
+    });
+    assert.ok(calls[0].options.signal);
+
+    await __reproTestHooks.registerRuntimeServiceForTest({
+      tenantId: 'TENANT_test',
+      appId: 'APP_test',
+      appSecret: 'secret',
+      appName: 'Acme',
+      apiBase: 'http://repro-api.test/api',
+      ingestBase: 'http://collector.test',
+    });
+    assert.equal(calls.length, 1);
+
+    global.fetch = async () => {
+      throw new Error('network down');
+    };
+    await __reproTestHooks.registerRuntimeServiceForTest({
+      tenantId: 'TENANT_test',
+      appId: 'APP_test',
+      appSecret: 'secret',
+      serviceName: 'billing-api',
+      apiBase: 'http://repro-api.test/api',
+      ingestBase: 'http://collector.test',
+    });
+  } finally {
+    global.fetch = originalFetch;
+  }
+
+  console.log('runtime service registration OK');
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});