@reproapp/node-sdk 0.0.37 → 0.0.39

package/dist/index.js

@@ -305,6 +305,9 @@ const KAFKA_HEADER_SESSION_ID = 'x-bug-session-id';
 const KAFKA_HEADER_ACTION_ID = 'x-bug-action-id';
 const DEFAULT_INGEST_BASE = 'http://localhost:8080';
 const DEFAULT_INGEST_PATH = '/v1/ingest/events';
+const DEFAULT_LIVE_SESSION_DURATION_MS = 3 * 60000;
+const DEFAULT_LIVE_SEGMENT_IDLE_MS = 15000;
+const DEFAULT_LIVE_SEGMENT_DURATION_MS = DEFAULT_LIVE_SESSION_DURATION_MS;
 function escapeRx(s) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
 let __TRACER__ = null;
 let __TRACER_READY = false;
@@ -1681,6 +1684,299 @@ function toIngestConfig(cfg) {
         schemaVersion: cfg.schemaVersion,
     };
 }
+function normalizeLiveModeConfig(cfg) {
+    const liveMode = cfg.liveMode;
+    if (liveMode === true) {
+        return { enabled: true };
+    }
+    if (!liveMode || typeof liveMode !== 'object') {
+        return null;
+    }
+    if (liveMode.enabled === false) {
+        return null;
+    }
+    return liveMode;
+}
+let backendLiveTimingOverrideForTest = null;
+function positiveInternalDuration(value, fallback) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric <= 0)
+        return fallback;
+    return Math.max(1, Math.trunc(numeric));
+}
+function getBackendLiveTiming() {
+    return {
+        sessionMaxDurationMs: positiveInternalDuration(backendLiveTimingOverrideForTest?.sessionMaxDurationMs, DEFAULT_LIVE_SESSION_DURATION_MS),
+        segmentMaxDurationMs: positiveInternalDuration(backendLiveTimingOverrideForTest?.segmentMaxDurationMs, DEFAULT_LIVE_SEGMENT_DURATION_MS),
+        segmentIdleMs: positiveInternalDuration(backendLiveTimingOverrideForTest?.segmentIdleMs, DEFAULT_LIVE_SEGMENT_IDLE_MS),
+    };
+}
+function normalizeLiveActorId(value) {
+    if (value === undefined || value === null)
+        return null;
+    const normalized = String(value).trim();
+    return normalized.length ? normalized : null;
+}
+function normalizeLiveActorLabels(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const labels = {};
+    for (const [key, rawValue] of Object.entries(value)) {
+        const normalizedKey = key.trim();
+        if (!normalizedKey || rawValue === undefined || rawValue === null)
+            continue;
+        const normalizedValue = String(rawValue).trim();
+        if (normalizedValue)
+            labels[normalizedKey] = normalizedValue;
+    }
+    return Object.keys(labels).length ? labels : undefined;
+}
+function newSessionId(base = Date.now()) {
+    return `S_${Math.max(0, Math.trunc(base))}_${(0, crypto_1.randomUUID)().slice(0, 8)}`;
+}
+function newActionId(base = Date.now()) {
+    return `A_${Math.max(0, Math.trunc(base))}_${(0, crypto_1.randomUUID)().slice(0, 8)}`;
+}
+function resolveLiveApiBase(cfg, liveMode) {
+    const env = typeof process !== 'undefined' ? process?.env : undefined;
+    const raw = liveMode?.apiBase ||
+        cfg.apiBase ||
+        env?.REPRO_API_BASE_URL ||
+        env?.REPRO_API_BASE ||
+        cfg.privacy?.apiBase ||
+        null;
+    if (typeof raw !== 'string' || !raw.trim())
+        return null;
+    return raw.trim().replace(/\/+$/, '');
+}
+function liveApiHeaders(cfg) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'X-App-Id': cfg.appId,
+    };
+    if (cfg.appSecret) {
+        headers['X-App-Secret'] = cfg.appSecret;
+    }
+    if (cfg.appName) {
+        headers['X-App-Name'] = cfg.appName;
+    }
+    return headers;
+}
+async function postLiveApi(cfg, liveMode, path, body) {
+    await postLiveApiJson(cfg, liveMode, path, body);
+}
+async function postLiveApiJson(cfg, liveMode, path, body) {
+    const apiBase = resolveLiveApiBase(cfg, liveMode);
+    const fetchImpl = globalThis.fetch;
+    if (!apiBase || !cfg.appId || !cfg.appSecret || typeof fetchImpl !== 'function') {
+        return null;
+    }
+    try {
+        const res = await fetchImpl(`${apiBase}${path}`, {
+            method: 'POST',
+            headers: liveApiHeaders(cfg),
+            body: JSON.stringify(body),
+        });
+        if (!res?.ok) {
+            return null;
+        }
+        try {
+            return await res.json();
+        }
+        catch {
+            return null;
+        }
+    }
+    catch {
+        // never break user code
+        return null;
+    }
+}
+function enqueueLiveSessionStart(cfg, liveMode, payload) {
+    scheduleSdkBackgroundWork(() => postLiveApi(cfg, liveMode, '/v1/live-sessions', payload), { priority: 'high' });
+}
+function enqueueLiveSessionFinish(cfg, liveMode, sessionId) {
+    scheduleSdkBackgroundWork(() => postLiveApi(cfg, liveMode, `/v1/live-sessions/${encodeURIComponent(sessionId)}/finish`, { notes: '' }), { priority: 'high' });
+}
+function emitBackendLiveSessionManifest(cfg, session, options) {
+    post(cfg, session.sessionId, {
+        entries: [{
+                sessionCaptureManifest: {
+                    mode: 'backend-only',
+                    captureMode: 'backend-only',
+                    sessionKind: options.sessionKind,
+                    parentSessionId: options.parentSessionId ?? null,
+                    previousSessionId: options.previousSessionId ?? null,
+                    actorId: options.actorId,
+                    actorType: options.actorType,
+                    actorLabels: options.actorLabels,
+                    expected: {
+                        frontendActionDoc: 0,
+                        rrwebChunk: 0,
+                        frontendSessionEnd: 0,
+                    },
+                    closedAt: options.closedAt,
+                },
+                t: options.closedAt,
+            }],
+    }, { priority: 'high' });
+}
+function closeBackendLiveParent(cfg, liveMode, state, parent, closedAt) {
+    if (parent.closed) {
+        return;
+    }
+    parent.closed = true;
+    if (parent.closeTimer) {
+        try {
+            clearTimeout(parent.closeTimer);
+        }
+        catch { }
+        parent.closeTimer = null;
+    }
+    state.previousParentSessionId = parent.sessionId;
+    if (state.parent === parent) {
+        state.parent = null;
+    }
+    emitBackendLiveSessionManifest(cfg, parent, {
+        sessionKind: 'parent',
+        actorId: parent.actorId,
+        actorType: parent.actorType,
+        actorLabels: parent.actorLabels,
+        previousSessionId: parent.previousSessionId,
+        closedAt,
+    });
+    enqueueLiveSessionFinish(cfg, liveMode, parent.sessionId);
+}
+function scheduleBackendLiveParentClose(cfg, liveMode, state, parent) {
+    if (parent.closed) {
+        return;
+    }
+    if (parent.closeTimer) {
+        try {
+            clearTimeout(parent.closeTimer);
+        }
+        catch { }
+        parent.closeTimer = null;
+    }
+    const now = Date.now();
+    const activeChild = state.activeChild;
+    const activeChildBelongsToParent = activeChild?.parentSessionId === parent.sessionId;
+    const closeAt = activeChildBelongsToParent && now >= parent.expiresAt
+        ? Math.max(parent.expiresAt, activeChild.closeDeadline, now + 1)
+        : parent.expiresAt;
+    parent.closeTimer = setTimeout(() => {
+        parent.closeTimer = null;
+        if (parent.closed || state.parent !== parent) {
+            return;
+        }
+        const currentChild = state.activeChild;
+        if (currentChild?.parentSessionId === parent.sessionId) {
+            if (currentChild.requestsInFlight <= 0) {
+                scheduleBackendLiveChildClose(cfg, liveMode, state, currentChild);
+            }
+            scheduleBackendLiveParentClose(cfg, liveMode, state, parent);
+            return;
+        }
+        closeBackendLiveParent(cfg, liveMode, state, parent, Date.now());
+    }, Math.max(0, closeAt - now));
+    try {
+        parent.closeTimer.unref?.();
+    }
+    catch { }
+}
+function scheduleBackendLiveChildClose(cfg, liveMode, state, child) {
+    if (child.closeTimer) {
+        try {
+            clearTimeout(child.closeTimer);
+        }
+        catch { }
+        child.closeTimer = null;
+    }
+    const delay = Math.max(0, child.closeDeadline - Date.now());
+    child.closeTimer = setTimeout(() => {
+        child.closeTimer = null;
+        if (child.requestsInFlight > 0 || Date.now() < child.closeDeadline) {
+            scheduleBackendLiveChildClose(cfg, liveMode, state, child);
+            return;
+        }
+        if (state.activeChild === child) {
+            state.activeChild = null;
+        }
+        state.previousChildSessionId = child.sessionId;
+        const closedAt = Date.now();
+        emitBackendLiveSessionManifest(cfg, child, {
+            sessionKind: 'child',
+            actorId: child.actorId,
+            actorType: child.actorType,
+            actorLabels: child.actorLabels,
+            parentSessionId: child.parentSessionId,
+            previousSessionId: child.previousSessionId,
+            closedAt,
+        });
+        enqueueLiveSessionFinish(cfg, liveMode, child.sessionId);
+    }, delay);
+    try {
+        child.closeTimer.unref?.();
+    }
+    catch { }
+}
+function releaseBackendLiveRequest(cfg, liveMode, state, child, finishedAt) {
+    child.requestsInFlight = Math.max(0, child.requestsInFlight - 1);
+    const idleMs = getBackendLiveTiming().segmentIdleMs;
+    child.closeDeadline = Math.max(child.closeDeadline, finishedAt + idleMs);
+    if (child.requestsInFlight <= 0) {
+        scheduleBackendLiveChildClose(cfg, liveMode, state, child);
+    }
+}
+async function resolveBackendLiveContext(cfg, req, requestStart) {
+    const liveMode = normalizeLiveModeConfig(cfg);
+    if (!liveMode?.backendOnly) {
+        return null;
+    }
+    const method = String(req.method || 'GET').toUpperCase();
+    if (method === 'OPTIONS' && !hasReproRequestCorrelation(req)) {
+        return null;
+    }
+    const identity = await resolveLiveActorIdentity(cfg, req);
+    if (!identity) {
+        return null;
+    }
+    const { actorId, actorType, actorLabels } = identity;
+    const claim = await postLiveApiJson(cfg, liveMode, '/v1/live-sessions/claim', {
+        clientTime: requestStart,
+        captureMode: 'backend-only',
+        actorId,
+        actorIds: [actorId],
+        actorType,
+        actorLabels,
+    });
+    const sid = normalizeLiveActorId(claim?.childSessionId) ??
+        normalizeLiveActorId(claim?.sessionId);
+    if (!sid) {
+        return null;
+    }
+    const aid = normalizeLiveActorId(claim?.actionId) ?? newActionId(requestStart);
+    const parentSessionId = normalizeLiveActorId(claim?.parentSessionId) ?? '';
+    const liveChild = {
+        sessionId: sid,
+        parentSessionId,
+        previousSessionId: null,
+        actorId,
+        actorType,
+        actorLabels,
+        startedAt: requestStart,
+        expiresAt: requestStart,
+        closeDeadline: requestStart,
+        requestsInFlight: 0,
+        closeTimer: null,
+    };
+    return {
+        sid: liveChild.sessionId,
+        aid,
+        requestStart,
+        child: liveChild,
+    };
+}
 function resolveIngestUrl(cfg) {
     const envBase = typeof process !== 'undefined' ? process?.env?.REPRO_INGEST_BASE : undefined;
     const ingestBase = String(envBase || cfg.ingestBase || DEFAULT_INGEST_BASE).replace(/\/+$/, '');
@@ -1727,6 +2023,19 @@ function readRequestQueryNumber(req, name) {
     const parsed = Number(raw);
     return Number.isFinite(parsed) ? parsed : null;
 }
+function hasReproRequestCorrelation(req) {
+    const headers = req.headers || {};
+    if (hasHttpHeader(headers, KAFKA_HEADER_SESSION_ID) ||
+        hasHttpHeader(headers, KAFKA_HEADER_ACTION_ID) ||
+        hasHttpHeader(headers, KAFKA_HEADER_REQUEST_ID) ||
+        hasHttpHeader(headers, KAFKA_HEADER_TRACE_ID) ||
+        hasHttpHeader(headers, KAFKA_HEADER_SPAN_ID) ||
+        hasHttpHeader(headers, KAFKA_HEADER_PARENT_SPAN_ID)) {
+        return true;
+    }
+    return Boolean(readRequestQueryParam(req, REPRO_QUERY_SESSION_PARAM) ||
+        readRequestQueryParam(req, REPRO_QUERY_ACTION_PARAM));
+}
 function stripReproQueryFromUrl(rawUrl) {
     if (!rawUrl || !rawUrl.includes('?')) {
         return rawUrl;
@@ -4092,6 +4401,111 @@ async function maybeCaptureDbValueAsync(params, sink) {
     }
     return result.captureRef;
 }
+function pushUniqueCaptureCandidate(candidates, value) {
+    if (value === undefined)
+        return;
+    if (candidates.some((candidate) => candidate === value))
+        return;
+    candidates.push(value);
+}
+function buildResultMetaFullValueCandidates(resultMetaRaw, resultMetaSource) {
+    const candidates = [];
+    pushUniqueCaptureCandidate(candidates, resultMetaRaw);
+    if (resultMetaSource &&
+        typeof resultMetaSource === 'object' &&
+        Object.prototype.hasOwnProperty.call(resultMetaSource, 'result')) {
+        pushUniqueCaptureCandidate(candidates, resultMetaSource.result);
+    }
+    pushUniqueCaptureCandidate(candidates, resultMetaSource);
+    return candidates;
+}
+async function maybeCaptureDbValueFromCandidatesAsync(params, sink) {
+    let skippedRef;
+    for (const rawValue of params.rawValues) {
+        const result = await createCapturedValueEntryAsync({
+            target: params.target,
+            rawValue,
+            previewValue: params.previewValue,
+            capture: params.capture,
+        });
+        if (!result)
+            continue;
+        if (result.entry) {
+            sink.push(result.entry);
+            return result.captureRef;
+        }
+        if (!skippedRef) {
+            skippedRef = result.captureRef;
+        }
+    }
+    return skippedRef;
+}
+function buildLiveActorArgs(cfg, req) {
+    const rawUrl = String(req.originalUrl || req.url || '/');
+    const path = rawUrl.split('?')[0] || '/';
+    return {
+        req,
+        headers: req.headers,
+        method: String(req.method || 'GET').toUpperCase(),
+        url: rawUrl,
+        path,
+        ip: req.ip ?? req.socket?.remoteAddress ?? null,
+        appId: cfg.appId,
+        appName: cfg.appName,
+        serviceName: cfg.serviceName,
+    };
+}
+async function resolveLiveActorIdentity(cfg, req) {
+    const liveMode = normalizeLiveModeConfig(cfg);
+    if (!liveMode) {
+        return null;
+    }
+    const args = buildLiveActorArgs(cfg, req);
+    let rawActorId;
+    try {
+        rawActorId = liveMode.defineActorId
+            ? await liveMode.defineActorId(args)
+            : cfg.actorId;
+    }
+    catch {
+        rawActorId = null;
+    }
+    const actorId = normalizeLiveActorId(rawActorId);
+    if (!actorId) {
+        return null;
+    }
+    const actorType = normalizeLiveActorId(liveMode.actorType) ?? cfg.actorType ?? 'user';
+    const decision = {
+        ...args,
+        actorId,
+        actorType,
+    };
+    if (liveMode.shouldCapture) {
+        let shouldCapture = false;
+        try {
+            shouldCapture = (await liveMode.shouldCapture(decision)) === true;
+        }
+        catch {
+            shouldCapture = false;
+        }
+        if (!shouldCapture) {
+            return null;
+        }
+    }
+    let rawLabels;
+    try {
+        rawLabels =
+            typeof liveMode.actorLabels === 'function'
+                ? await liveMode.actorLabels(decision)
+                : liveMode.actorLabels;
+    }
+    catch {
+        rawLabels = undefined;
+    }
+    const actorLabels = normalizeLiveActorLabels(rawLabels) ?? normalizeLiveActorLabels(cfg.actorLabels);
+    return { actorId, actorType, actorLabels };
+}
+const backendLiveActors = new Map();
 function reproMiddleware(cfg) {
     const masking = normalizeMaskingConfig(cfg.masking);
     patchMongoDb(cfg);
@@ -4126,18 +4540,62 @@ function reproMiddleware(cfg) {
             clientRequestEnded = true;
             endClientRequest();
         };
-        const sid = req.headers['x-bug-session-id'] || querySid || '';
-        const aid = req.headers['x-bug-action-id'] || queryAid || '';
+        const requestStartRaw = Date.now();
+        const headerTs = readHeaderNumber(req.headers[REQUEST_START_HEADER]) ?? queryTs;
+        const requestEpochMs = headerTs !== null ? headerTs : requestStartRaw;
+        let backendLiveState = null;
+        let backendLiveChild = null;
+        const headerSid = req.headers['x-bug-session-id'] || '';
+        const headerAid = req.headers['x-bug-action-id'] || '';
+        const hasIncomingReproSession = Boolean(headerSid || querySid || headerAid || queryAid);
+        const backendLiveContext = !hasIncomingReproSession
+            ? await resolveBackendLiveContext(cfg, req, requestEpochMs)
+            : null;
+        const taggedActorIdentity = hasIncomingReproSession
+            ? await resolveLiveActorIdentity(cfg, req)
+            : null;
+        if (backendLiveContext) {
+            backendLiveState = backendLiveActors.get(backendLiveContext.child.actorId) ?? null;
+            backendLiveChild = backendLiveContext.child;
+        }
+        const sid = headerSid || querySid || backendLiveContext?.sid || '';
+        const aid = headerAid || queryAid || backendLiveContext?.aid || '';
         if (!sid || !aid) {
             res.on('finish', endTrackedClientRequest);
             res.on('close', endTrackedClientRequest);
             return next(); // only capture tagged requests
         }
-        const resolvePrivacy = () => getRuntimePrivacyState(cfg).policy ?? null;
-        const requestStartRaw = Date.now();
-        const headerTs = readHeaderNumber(req.headers[REQUEST_START_HEADER]) ?? queryTs;
+        const captureCfg = backendLiveChild
+            ? {
+                ...cfg,
+                actorId: backendLiveChild.actorId,
+                actorType: backendLiveChild.actorType,
+                actorLabels: backendLiveChild.actorLabels,
+            }
+            : taggedActorIdentity
+                ? {
+                    ...cfg,
+                    actorId: taggedActorIdentity.actorId,
+                    actorType: taggedActorIdentity.actorType,
+                    actorLabels: taggedActorIdentity.actorLabels,
+                }
+                : cfg;
+        if (taggedActorIdentity) {
+            post(captureCfg, sid, {
+                entries: [{
+                        actionId: aid,
+                        sessionActor: {
+                            actorId: taggedActorIdentity.actorId,
+                            actorType: taggedActorIdentity.actorType,
+                            actorLabels: taggedActorIdentity.actorLabels,
+                            source: 'node-sdk',
+                        },
+                        t: requestEpochMs,
+                    }],
+            }, { priority: 'high' });
+        }
+        const resolvePrivacy = () => getRuntimePrivacyState(captureCfg).policy ?? null;
         const clockSkewMs = headerTs !== null ? headerTs - requestStartRaw : 0;
-        const requestEpochMs = headerTs !== null ? headerTs : requestStartRaw + clockSkewMs;
         const rid = nextRequestId(requestEpochMs);
         const captureScope = createRequestCaptureScope(rid, 'http');
         const t0 = requestStartRaw;
@@ -4341,15 +4799,15 @@ function reproMiddleware(cfg) {
                 const activePrivacy = resolvePrivacy();
                 const requestBodyRaw = req.body;
                 const requestBodyMaterialization = limitRawInlinePrivacyValue('request.body', requestBodyRaw)
-                    ?? await materializeInlinePrivacyValueAsync('request.body', sanitizeRequestSnapshot(requestBodyRaw), cfg, maskReq, endpointTraceCtx, masking, activePrivacy);
+                    ?? await materializeInlinePrivacyValueAsync('request.body', sanitizeRequestSnapshot(requestBodyRaw), captureCfg, maskReq, endpointTraceCtx, masking, activePrivacy);
                 const requestBody = requestBodyMaterialization.value;
-                const requestParams = await applyPrivacyThenMaskAsync('request.params', sanitizeRequestSnapshot(req.params), cfg, maskReq, endpointTraceCtx, masking, activePrivacy);
-                const requestQuery = await applyPrivacyThenMaskAsync('request.query', sanitizeRequestSnapshot(req.query), cfg, maskReq, endpointTraceCtx, masking, activePrivacy);
-                const maskedHeaders = await applyPrivacyThenMaskAsync('request.headers', requestHeaders, cfg, maskReq, endpointTraceCtx, masking, activePrivacy);
+                const requestParams = await applyPrivacyThenMaskAsync('request.params', sanitizeRequestSnapshot(req.params), captureCfg, maskReq, endpointTraceCtx, masking, activePrivacy);
+                const requestQuery = await applyPrivacyThenMaskAsync('request.query', sanitizeRequestSnapshot(req.query), captureCfg, maskReq, endpointTraceCtx, masking, activePrivacy);
+                const maskedHeaders = await applyPrivacyThenMaskAsync('request.headers', requestHeaders, captureCfg, maskReq, endpointTraceCtx, masking, activePrivacy);
                 const responseBodyMaterialization = capturedBody === undefined
                     ? { value: undefined }
                     : limitRawInlinePrivacyValue('response.body', capturedBody)
-                        ?? await materializeInlinePrivacyValueAsync('response.body', sanitizeRequestSnapshot(capturedBody), cfg, maskReq, endpointTraceCtx, masking, activePrivacy);
+                        ?? await materializeInlinePrivacyValueAsync('response.body', sanitizeRequestSnapshot(capturedBody), captureCfg, maskReq, endpointTraceCtx, masking, activePrivacy);
                 const responseBody = responseBodyMaterialization.value;
                 const requestValueEntries = [];
                 const bodyValueCapture = requestBodyMaterialization.skipped
@@ -4359,7 +4817,7 @@ function reproMiddleware(cfg) {
                         rawValue: req.body,
                         previewValue: requestBody,
                         capture: {
-                            runtimeConfig: cfg,
+                            runtimeConfig: captureCfg,
                             captureHeaders: cfg.captureHeaders,
                             maskReq,
                             trace: endpointTraceCtx,
@@ -4372,7 +4830,7 @@ function reproMiddleware(cfg) {
                     rawValue: req.params,
                     previewValue: requestParams,
                     capture: {
-                        runtimeConfig: cfg,
+                        runtimeConfig: captureCfg,
                         captureHeaders: cfg.captureHeaders,
                         maskReq,
                         trace: endpointTraceCtx,
@@ -4385,7 +4843,7 @@ function reproMiddleware(cfg) {
                     rawValue: req.query,
                     previewValue: requestQuery,
                     capture: {
-                        runtimeConfig: cfg,
+                        runtimeConfig: captureCfg,
                         captureHeaders: cfg.captureHeaders,
                         maskReq,
                         trace: endpointTraceCtx,
@@ -4398,7 +4856,7 @@ function reproMiddleware(cfg) {
                     rawValue: req.headers,
                     previewValue: maskedHeaders,
                     capture: {
-                        runtimeConfig: cfg,
+                        runtimeConfig: captureCfg,
                         captureHeaders: cfg.captureHeaders,
                         maskReq,
                         trace: endpointTraceCtx,
@@ -4413,7 +4871,7 @@ function reproMiddleware(cfg) {
                         rawValue: capturedBody,
                         previewValue: responseBody,
                         capture: {
-                            runtimeConfig: cfg,
+                            runtimeConfig: captureCfg,
                             captureHeaders: cfg.captureHeaders,
                             maskReq,
                             trace: endpointTraceCtx,
@@ -4474,7 +4932,7 @@ function reproMiddleware(cfg) {
                     }
                     const { chosenEndpoint, hasTraceEvents } = chooseRequestEndpoint();
                     const { requestPayload, requestValueEntries } = await buildRequestCapturePayloadAsync(chosenEndpoint, hasTraceEvents);
-                    post(cfg, sid, {
+                    post(captureCfg, sid, {
                         entries: [{
                                 actionId: aid,
                                 request: requestPayload,
@@ -4492,7 +4950,7 @@ function reproMiddleware(cfg) {
                 if (requestCaptureManifestScheduled)
                     return;
                 requestCaptureManifestScheduled = true;
-                post(cfg, sid, {
+                post(captureCfg, sid, {
                     entries: [{
                             actionId: aid,
                             requestRid: rid,
@@ -4595,7 +5053,7 @@ function reproMiddleware(cfg) {
                         try {
                             const pendingEvents = preparePendingTraceEventsForFlush(events.slice());
                             const materializedEvents = await materializePendingTraceEventsAsync(pendingEvents, {
-                                cfg,
+                                cfg: captureCfg,
                                 maskReq,
                                 masking,
                                 resolvePrivacy,
@@ -4623,7 +5081,7 @@ function reproMiddleware(cfg) {
                             for (let i = 0; i < traceBatches.length; i++) {
                                 const batch = traceBatches[i];
                                 const traceValues = collectBatchTraceValueEntries(batch, i);
-                                post(cfg, sid, {
+                                post(captureCfg, sid, {
                                     entries: [{
                                             actionId: aid,
                                             trace: batch,
@@ -4645,6 +5103,9 @@ function reproMiddleware(cfg) {
                 }
                 sessionDrainWait = waitForSessionDrain(sid);
                 endSessionRequest(sid);
+                if (backendLiveState && backendLiveChild) {
+                    releaseBackendLiveRequest(cfg, normalizeLiveModeConfig(cfg), backendLiveState, backendLiveChild, finishedAtAligned ?? alignedNow());
+                }
                 endTrackedClientRequest();
                 if (__TRACER_READY) {
                     bumpIdle();
@@ -5285,9 +5746,9 @@ async function emitDbQueryAsync(cfg, sid, aid, payload) {
         previewValue: queryPreview,
         capture,
     }, dbValues);
-    const resultMetaValueCapture = resultMetaMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
+    const resultMetaValueCapture = resultMetaMaterialization.skipped ? undefined : await maybeCaptureDbValueFromCandidatesAsync({
         target: 'db.resultMeta',
-        rawValue: payload.resultMetaRaw ?? resultMetaSource,
+        rawValues: buildResultMetaFullValueCandidates(payload.resultMetaRaw, resultMetaSource),
         previewValue: resultMetaPreview,
         capture,
     }, dbValues);
@@ -8762,9 +9223,11 @@ async function initRepro(cfg) {
     const ingestCfg = toIngestConfig(cfg);
     reproAutoMiddlewareConfig = {
         ...ingestCfg,
+        apiBase: cfg.apiBase,
         captureHeaders: cfg.captureHeaders,
         masking: cfg.masking,
         privacy: cfg.privacy,
+        liveMode: cfg.liveMode,
     };
     const integrationCfg = {
         ...reproAutoMiddlewareConfig,
@@ -8816,6 +9279,9 @@ exports.__reproTestHooks = {
         lastClientActivityAt = 0;
         sdkBackgroundQuietUntil = 0;
     },
+    setBackendLiveTimingForTest(override) {
+        backendLiveTimingOverrideForTest = override;
+    },
     runWithRequestContextForTest(ctx, fn) {
         return als.run({
             ...ctx,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.37",
+  "version": "0.0.39",
   "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/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",
+    "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",
     "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"
   },
   "peerDependencies": {