@reproapp/node-sdk 0.0.38 → 0.0.41

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__reproTestHooks = exports.initRepro = exports.patchSendgridMail = exports.patchMongoDb = exports.patchRedis = exports.patchAmqplib = exports.patchKafkaJs = exports.reproMongoosePlugin = exports.reproMiddleware = exports.__materializePendingTraceEventsForWorker = exports.isReproTracingEnabled = exports.initReproTracing = exports.disableReproTraceLogs = exports.enableReproTraceLogs = exports.setReproTraceLogsEnabled = exports.setDisabledTraceFiles = exports.setDisabledFunctionTypes = exports.setDisabledFunctionTraces = void 0;
+exports.__reproTestHooks = exports.initRepro = exports.patchSendgridMail = exports.patchMongoDb = exports.patchPostgreSql = exports.patchRedis = exports.patchAmqplib = exports.patchKafkaJs = exports.reproMongoosePlugin = exports.reproMiddleware = exports.__materializePendingTraceEventsForWorker = exports.isReproTracingEnabled = exports.initReproTracing = exports.disableReproTraceLogs = exports.enableReproTraceLogs = exports.setReproTraceLogsEnabled = exports.setDisabledTraceFiles = exports.setDisabledFunctionTypes = exports.setDisabledFunctionTraces = void 0;
 const mongoose = require("mongoose");
 const async_hooks_1 = require("async_hooks");
 const crypto_1 = require("crypto");
@@ -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;
@@ -819,6 +822,27 @@ function buildRequestCaptureManifestPayload(scope, traceBatchTotal, closedAtMs)
         closedAt,
     };
 }
+function emitRequestCaptureStart(cfg, sessionId, actionId, scope, openedAtMs) {
+    if (!sessionId) {
+        return;
+    }
+    const openedAt = typeof openedAtMs === 'number' && Number.isFinite(openedAtMs)
+        ? openedAtMs
+        : alignedNow();
+    post(cfg, sessionId, {
+        entries: [{
+                actionId: actionId ?? null,
+                requestRid: scope.requestRid,
+                requestCaptureStart: {
+                    scopeId: `req:${scope.requestRid}`,
+                    requestRid: scope.requestRid,
+                    transport: scope.transport,
+                    openedAt,
+                },
+                t: openedAt,
+            }],
+    }, { priority: 'high' });
+}
 const als = new async_hooks_1.AsyncLocalStorage();
 const getCtx = () => als.getStore() || {};
 function normalizeNativeMongoSuppressionOp(op) {
@@ -1681,6 +1705,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 +2044,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;
@@ -4131,6 +4461,72 @@ async function maybeCaptureDbValueFromCandidatesAsync(params, sink) {
     }
     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);
@@ -4165,20 +4561,65 @@ 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');
+        emitRequestCaptureStart(captureCfg, sid, aid, captureScope, requestEpochMs);
         const t0 = requestStartRaw;
         const url = req.originalUrl || req.url || '/';
         const urlPathOnly = (url || '/').split('?')[0] || '/';
@@ -4380,15 +4821,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
@@ -4398,7 +4839,7 @@ function reproMiddleware(cfg) {
                         rawValue: req.body,
                         previewValue: requestBody,
                         capture: {
-                            runtimeConfig: cfg,
+                            runtimeConfig: captureCfg,
                             captureHeaders: cfg.captureHeaders,
                             maskReq,
                             trace: endpointTraceCtx,
@@ -4411,7 +4852,7 @@ function reproMiddleware(cfg) {
                     rawValue: req.params,
                     previewValue: requestParams,
                     capture: {
-                        runtimeConfig: cfg,
+                        runtimeConfig: captureCfg,
                         captureHeaders: cfg.captureHeaders,
                         maskReq,
                         trace: endpointTraceCtx,
@@ -4424,7 +4865,7 @@ function reproMiddleware(cfg) {
                     rawValue: req.query,
                     previewValue: requestQuery,
                     capture: {
-                        runtimeConfig: cfg,
+                        runtimeConfig: captureCfg,
                         captureHeaders: cfg.captureHeaders,
                         maskReq,
                         trace: endpointTraceCtx,
@@ -4437,7 +4878,7 @@ function reproMiddleware(cfg) {
                     rawValue: req.headers,
                     previewValue: maskedHeaders,
                     capture: {
-                        runtimeConfig: cfg,
+                        runtimeConfig: captureCfg,
                         captureHeaders: cfg.captureHeaders,
                         maskReq,
                         trace: endpointTraceCtx,
@@ -4452,7 +4893,7 @@ function reproMiddleware(cfg) {
                         rawValue: capturedBody,
                         previewValue: responseBody,
                         capture: {
-                            runtimeConfig: cfg,
+                            runtimeConfig: captureCfg,
                             captureHeaders: cfg.captureHeaders,
                             maskReq,
                             trace: endpointTraceCtx,
@@ -4513,7 +4954,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,
@@ -4531,7 +4972,7 @@ function reproMiddleware(cfg) {
                 if (requestCaptureManifestScheduled)
                     return;
                 requestCaptureManifestScheduled = true;
-                post(cfg, sid, {
+                post(captureCfg, sid, {
                     entries: [{
                             actionId: aid,
                             requestRid: rid,
@@ -4634,7 +5075,7 @@ function reproMiddleware(cfg) {
                         try {
                             const pendingEvents = preparePendingTraceEventsForFlush(events.slice());
                             const materializedEvents = await materializePendingTraceEventsAsync(pendingEvents, {
-                                cfg,
+                                cfg: captureCfg,
                                 maskReq,
                                 masking,
                                 resolvePrivacy,
@@ -4662,7 +5103,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,
@@ -4684,6 +5125,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();
@@ -6093,6 +6537,7 @@ function patchKafkaProducerInstance(producer, cfg) {
             const span = captureSpanContextFromTracer();
             const publishRid = nextRequestId(alignedNow());
             const captureScope = createRequestCaptureScope(publishRid, 'kafka');
+            emitRequestCaptureStart(cfg, sid, aid, captureScope);
             const payloadObj = payload && typeof payload === 'object' ? payload : {};
             const topic = sanitizeKafkaTopic(payloadObj.topic);
             const rawMessages = Array.isArray(payloadObj.messages) ? payloadObj.messages : [];
@@ -6201,6 +6646,7 @@ function patchKafkaProducerInstance(producer, cfg) {
             const span = captureSpanContextFromTracer();
             const publishRid = nextRequestId(alignedNow());
             const captureScope = createRequestCaptureScope(publishRid, 'kafka');
+            emitRequestCaptureStart(cfg, sid, aid, captureScope);
             const payloadObj = payload && typeof payload === 'object' ? payload : {};
             const topicMessages = Array.isArray(payloadObj.topicMessages)
                 ? payloadObj.topicMessages
@@ -6342,6 +6788,7 @@ function wrapKafkaEachMessageHandler(eachMessage, cfg, consumer) {
         const consumeRid = nextRequestId(`${topic}-${message?.offset ?? alignedNow()}`);
         const traceId = consumeRid;
         const captureScope = createRequestCaptureScope(consumeRid, 'kafka');
+        emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const rawTraceEvents = [];
         const maskReq = {
             method: 'KAFKA_CONSUME',
@@ -6456,6 +6903,7 @@ function wrapKafkaEachBatchHandler(eachBatch, cfg, consumer) {
         const consumeRid = nextRequestId(`${topic}-batch-${alignedNow()}`);
         const traceId = consumeRid;
         const captureScope = createRequestCaptureScope(consumeRid, 'kafka');
+        emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const rawTraceEvents = [];
         const maskReq = {
             method: 'KAFKA_CONSUME_BATCH',
@@ -7084,6 +7532,7 @@ function patchAmqplibPublishMethod(channel, cfg, methodName) {
         const key = `${method} ${methodName === 'publish' ? `${exchange || 'default'}/${routingKey}` : queue}`;
         const content = methodName === 'publish' ? args[2] : args[1];
         const captureScope = createRequestCaptureScope(publishRid, 'amqp');
+        emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const t0 = Date.now();
         let finished = false;
         const finish = (status, error, result) => {
@@ -7170,6 +7619,7 @@ function wrapAmqplibConsumeHandler(onMessage, cfg, queue) {
         const consumeRid = nextRequestId(`${queueName}-${deliveryTag}`);
         const traceId = consumeRid;
         const captureScope = createRequestCaptureScope(consumeRid, 'amqp');
+        emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const rawTraceEvents = [];
         const maskReq = {
             method: 'AMQP_CONSUME',
@@ -7732,6 +8182,564 @@ function patchRedis(cfg) {
     }
 }
 exports.patchRedis = patchRedis;
+const postgresSqlPatchConfigs = [];
+const postgresSqlSourceAls = new async_hooks_1.AsyncLocalStorage();
+const pgPoolQueryAls = new async_hooks_1.AsyncLocalStorage();
+let pgRequireHookInstalled = false;
+let postgresJsRequireHookInstalled = false;
+let typeOrmRequireHookInstalled = false;
+const PG_CLIENT_PATCHED = Symbol.for('@reproapp/node-sdk/pg-client-patched');
+const PG_POOL_PATCHED = Symbol.for('@reproapp/node-sdk/pg-pool-patched');
+const POSTGRES_JS_QUERY_PATCHED = Symbol.for('@reproapp/node-sdk/postgres-js-query-patched');
+const TYPEORM_DATASOURCE_PATCHED = Symbol.for('@reproapp/node-sdk/typeorm-datasource-patched');
+const TYPEORM_QUERY_RUNNER_PATCHED = Symbol.for('@reproapp/node-sdk/typeorm-query-runner-patched');
+function registerPostgreSqlPatchConfig(cfg) {
+    if (!postgresSqlPatchConfigs.includes(cfg)) {
+        postgresSqlPatchConfigs.push(cfg);
+    }
+}
+function resolvePostgreSqlCaptureContext(defaultSource, source) {
+    const ctx = getCtx();
+    const contextualSource = postgresSqlSourceAls.getStore();
+    for (let i = postgresSqlPatchConfigs.length - 1; i >= 0; i -= 1) {
+        const cfg = postgresSqlPatchConfigs[i];
+        if (!cfg)
+            continue;
+        const fallback = cfg.resolveContext?.() ?? {};
+        const sid = ctx.sid ?? fallback.sid ?? null;
+        if (!sid)
+            continue;
+        return {
+            cfg,
+            sid,
+            aid: ctx.aid ?? fallback.aid ?? null,
+            spanContext: captureSpanContextFromTracer(source),
+            source: contextualSource ?? defaultSource,
+        };
+    }
+    return null;
+}
+function stripSqlComments(sql) {
+    let remaining = sql.trimStart();
+    while (remaining.length) {
+        if (remaining.startsWith('--')) {
+            const newline = remaining.indexOf('\n');
+            remaining = newline < 0 ? '' : remaining.slice(newline + 1).trimStart();
+            continue;
+        }
+        if (remaining.startsWith('/*')) {
+            const end = remaining.indexOf('*/', 2);
+            remaining = end < 0 ? '' : remaining.slice(end + 2).trimStart();
+            continue;
+        }
+        break;
+    }
+    return remaining;
+}
+function normalizeSqlOperation(sql) {
+    const normalized = stripSqlComments(sql);
+    const first = normalized.match(/^([a-z]+)/i)?.[1]?.toLowerCase() ?? 'query';
+    if (first !== 'with')
+        return first;
+    // CTEs can wrap any DML statement. The last top-level DML keyword is the
+    // operation users care about, while nested SELECTs only build the CTE.
+    const matches = Array.from(normalized.matchAll(/\b(select|insert|update|delete|merge)\b/gi));
+    return matches.length ? String(matches[matches.length - 1][1]).toLowerCase() : 'query';
+}
+function cleanSqlIdentifier(value) {
+    if (!value)
+        return undefined;
+    const cleaned = value
+        .trim()
+        .replace(/[;,]$/, '')
+        .split('.')
+        .map((part) => part.replace(/^['"`]|['"`]$/g, ''))
+        .join('.');
+    return cleaned || undefined;
+}
+function resolveSqlTable(sql, op) {
+    const normalized = stripSqlComments(sql);
+    let match = null;
+    if (op === 'insert')
+        match = normalized.match(/\binsert\s+into\s+([^\s(]+)/i);
+    else if (op === 'update')
+        match = normalized.match(/\bupdate\s+([^\s(]+)/i);
+    else if (op === 'delete')
+        match = normalized.match(/\bdelete\s+from\s+([^\s(]+)/i);
+    else if (op === 'merge')
+        match = normalized.match(/\bmerge\s+into\s+([^\s(]+)/i);
+    else
+        match = normalized.match(/\bfrom\s+([^\s(]+)/i);
+    return cleanSqlIdentifier(match?.[1]) ?? 'unknown';
+}
+function buildPostgresQueryPayload(sql, parameters, source, extra) {
+    return {
+        sql,
+        parameters,
+        library: source.library,
+        driver: source.driver,
+        ...(extra ?? {}),
+    };
+}
+function summarizePostgresError(error) {
+    return {
+        name: error?.name ?? 'Error',
+        message: error?.message ?? String(error),
+        code: error?.code,
+        severity: error?.severity,
+        detail: error?.detail,
+        hint: error?.hint,
+        position: error?.position,
+        internalPosition: error?.internalPosition,
+        internalQuery: error?.internalQuery,
+        where: error?.where,
+        schema: error?.schema,
+        table: error?.table,
+        column: error?.column,
+        dataType: error?.dataType,
+        constraint: error?.constraint,
+        file: error?.file,
+        line: error?.line,
+        routine: error?.routine,
+    };
+}
+function normalizePgQueryInput(config, values) {
+    if (typeof config === 'string') {
+        return { sql: config, parameters: Array.isArray(values) ? values : [] };
+    }
+    const sql = typeof config?.text === 'string' ? config.text : '';
+    const parameters = Array.isArray(config?.values)
+        ? config.values
+        : Array.isArray(values)
+            ? values
+            : [];
+    return {
+        sql,
+        parameters,
+        extra: {
+            name: typeof config?.name === 'string' ? config.name : undefined,
+            rowMode: config?.rowMode,
+            binary: config?.binary,
+        },
+    };
+}
+function normalizePgResult(result) {
+    if (Array.isArray(result))
+        return result.map(normalizePgResult);
+    if (!result || typeof result !== 'object')
+        return result;
+    return {
+        command: result.command,
+        rowCount: result.rowCount,
+        oid: result.oid,
+        fields: Array.isArray(result.fields)
+            ? result.fields.map((field) => ({
+                name: field?.name,
+                tableID: field?.tableID,
+                columnID: field?.columnID,
+                dataTypeID: field?.dataTypeID,
+                dataTypeSize: field?.dataTypeSize,
+                dataTypeModifier: field?.dataTypeModifier,
+                format: field?.format,
+            }))
+            : undefined,
+        rows: result.rows,
+    };
+}
+function emitPostgreSqlResult(capture, sql, parameters, startedAt, result, error, extra) {
+    const op = normalizeSqlOperation(sql);
+    emitDbQuery(capture.cfg, capture.sid, capture.aid ?? undefined, {
+        type: 'postgresql',
+        collection: resolveSqlTable(sql, op),
+        op,
+        queryRaw: buildPostgresQueryPayload(sql, parameters, capture.source, extra),
+        resultMetaRaw: error ? undefined : result,
+        error: error ? summarizePostgresError(error) : undefined,
+        durMs: Date.now() - startedAt,
+        t: alignedNow(),
+        spanContext: capture.spanContext,
+    });
+}
+function findPgCallbackIndex(args) {
+    for (let i = args.length - 1; i >= 1; i -= 1) {
+        if (typeof args[i] === 'function')
+            return i;
+    }
+    return -1;
+}
+function patchPgClientPrototype(proto) {
+    if (!proto || proto[PG_CLIENT_PATCHED])
+        return;
+    const original = proto.query;
+    if (typeof original !== 'function')
+        return;
+    try {
+        Object.defineProperty(proto, PG_CLIENT_PATCHED, { value: true, configurable: true });
+    }
+    catch {
+        return;
+    }
+    proto.query = function reproPatchedPgQuery(...args) {
+        if (pgPoolQueryAls.getStore())
+            return original.apply(this, args);
+        const capture = resolvePostgreSqlCaptureContext({ library: 'pg', driver: 'pg' }, this);
+        if (!capture)
+            return original.apply(this, args);
+        const input = normalizePgQueryInput(args[0], args[1]);
+        const startedAt = Date.now();
+        const callbackIndex = findPgCallbackIndex(args);
+        const actualArgs = callbackIndex >= 0 ? [...args] : args;
+        let emitted = false;
+        const emitSuccess = (result) => {
+            if (emitted)
+                return;
+            emitted = true;
+            emitPostgreSqlResult(capture, input.sql, input.parameters, startedAt, normalizePgResult(result), undefined, input.extra);
+        };
+        const emitFailure = (error) => {
+            if (emitted)
+                return;
+            emitted = true;
+            emitPostgreSqlResult(capture, input.sql, input.parameters, startedAt, undefined, error, input.extra);
+        };
+        if (callbackIndex >= 0) {
+            const callback = args[callbackIndex];
+            actualArgs[callbackIndex] = function reproPgQueryCallback(error, result, ...rest) {
+                if (error)
+                    emitFailure(error);
+                else
+                    emitSuccess(result);
+                return callback.call(this, error, result, ...rest);
+            };
+        }
+        try {
+            const returned = original.apply(this, actualArgs);
+            if (returned && typeof returned.then === 'function') {
+                return returned.then((result) => {
+                    emitSuccess(result);
+                    return result;
+                }, (error) => {
+                    emitFailure(error);
+                    throw error;
+                });
+            }
+            if (returned && callbackIndex < 0 && typeof returned.once === 'function') {
+                returned.once('end', emitSuccess);
+                returned.once('error', emitFailure);
+            }
+            return returned;
+        }
+        catch (error) {
+            emitFailure(error);
+            throw error;
+        }
+    };
+}
+function patchPgPoolPrototype(proto) {
+    if (!proto || proto[PG_POOL_PATCHED])
+        return;
+    const original = proto.query;
+    if (typeof original !== 'function')
+        return;
+    try {
+        Object.defineProperty(proto, PG_POOL_PATCHED, { value: true, configurable: true });
+    }
+    catch {
+        return;
+    }
+    proto.query = function reproPatchedPgPoolQuery(...args) {
+        const capture = resolvePostgreSqlCaptureContext({ library: 'pg', driver: 'pg' }, this);
+        if (!capture)
+            return original.apply(this, args);
+        const input = normalizePgQueryInput(args[0], args[1]);
+        const startedAt = Date.now();
+        const callbackIndex = findPgCallbackIndex(args);
+        const actualArgs = callbackIndex >= 0 ? [...args] : args;
+        let emitted = false;
+        const emitSuccess = (result) => {
+            if (emitted)
+                return;
+            emitted = true;
+            emitPostgreSqlResult(capture, input.sql, input.parameters, startedAt, normalizePgResult(result), undefined, input.extra);
+        };
+        const emitFailure = (error) => {
+            if (emitted)
+                return;
+            emitted = true;
+            emitPostgreSqlResult(capture, input.sql, input.parameters, startedAt, undefined, error, input.extra);
+        };
+        if (callbackIndex >= 0) {
+            const callback = args[callbackIndex];
+            actualArgs[callbackIndex] = function reproPgPoolQueryCallback(error, result, ...rest) {
+                if (error)
+                    emitFailure(error);
+                else
+                    emitSuccess(result);
+                return callback.call(this, error, result, ...rest);
+            };
+        }
+        try {
+            const returned = pgPoolQueryAls.run(true, () => original.apply(this, actualArgs));
+            if (returned && typeof returned.then === 'function') {
+                return returned.then((result) => {
+                    emitSuccess(result);
+                    return result;
+                }, (error) => {
+                    emitFailure(error);
+                    throw error;
+                });
+            }
+            return returned;
+        }
+        catch (error) {
+            emitFailure(error);
+            throw error;
+        }
+    };
+}
+function patchPgFromModuleExports(pgModule) {
+    if (!pgModule)
+        return;
+    const candidates = [pgModule, pgModule.default];
+    for (const candidate of candidates) {
+        patchPgClientPrototype(candidate?.Client?.prototype);
+        patchPgClientPrototype(candidate?.native?.Client?.prototype);
+        patchPgPoolPrototype(candidate?.Pool?.prototype);
+        patchPgPoolPrototype(candidate?.native?.Pool?.prototype);
+    }
+}
+function installPgRequireHook() {
+    if (pgRequireHookInstalled)
+        return;
+    pgRequireHookInstalled = true;
+    try {
+        const rim = requireOptionalHostModule('require-in-the-middle');
+        const Hook = rim?.Hook ?? rim;
+        if (typeof Hook !== 'function')
+            return;
+        // eslint-disable-next-line no-new
+        new Hook(['pg'], (exports) => {
+            patchPgFromModuleExports(exports);
+            return exports;
+        });
+    }
+    catch { }
+}
+function normalizePostgresJsInput(query) {
+    if (typeof query?.statement?.string === 'string') {
+        return {
+            sql: query.statement.string,
+            parameters: Array.isArray(query?.parameters) ? query.parameters : [],
+            extra: {
+                tagged: query?.tagged === true,
+                parameterTypes: Array.isArray(query?.statement?.types) ? query.statement.types : undefined,
+            },
+        };
+    }
+    const strings = Array.isArray(query?.strings) ? query.strings : [];
+    const parameters = Array.isArray(query?.args) ? query.args : [];
+    if (query?.tagged) {
+        return {
+            sql: strings.map((part, index) => `${String(part)}${index < parameters.length ? `$${index + 1}` : ''}`).join(''),
+            parameters,
+            extra: { tagged: true },
+        };
+    }
+    return {
+        sql: typeof strings[0] === 'string' ? strings[0] : '',
+        parameters,
+        extra: { tagged: false },
+    };
+}
+function normalizePostgresJsResult(result) {
+    if (!Array.isArray(result))
+        return result;
+    const metadata = result;
+    return {
+        command: metadata.command,
+        count: metadata.count,
+        columns: Array.isArray(metadata.columns)
+            ? metadata.columns.map((column) => ({
+                name: column?.name,
+                type: column?.type,
+                table: column?.table,
+                number: column?.number,
+            }))
+            : undefined,
+        rows: Array.from(result),
+    };
+}
+function patchPostgresJsQueryPrototype(proto) {
+    if (!proto || proto[POSTGRES_JS_QUERY_PATCHED])
+        return;
+    const originalHandle = proto.handle;
+    if (typeof originalHandle !== 'function')
+        return;
+    try {
+        Object.defineProperty(proto, POSTGRES_JS_QUERY_PATCHED, { value: true, configurable: true });
+    }
+    catch {
+        return;
+    }
+    proto.handle = function reproPatchedPostgresJsHandle(...args) {
+        if (!this.__repro_postgres_capture_attached) {
+            const capture = resolvePostgreSqlCaptureContext({ library: 'postgres', driver: 'postgres' }, this);
+            if (capture) {
+                try {
+                    Object.defineProperty(this, '__repro_postgres_capture_attached', { value: true, configurable: true });
+                }
+                catch {
+                    this.__repro_postgres_capture_attached = true;
+                }
+                const input = normalizePostgresJsInput(this);
+                const startedAt = Date.now();
+                Promise.prototype.then.call(this, (result) => {
+                    const executedInput = normalizePostgresJsInput(this);
+                    emitPostgreSqlResult(capture, executedInput.sql || input.sql, executedInput.parameters, startedAt, normalizePostgresJsResult(result), undefined, executedInput.extra);
+                    return result;
+                }, (error) => {
+                    const executedInput = normalizePostgresJsInput(this);
+                    emitPostgreSqlResult(capture, executedInput.sql || input.sql, executedInput.parameters.length ? executedInput.parameters : input.parameters, startedAt, undefined, error, executedInput.extra);
+                });
+            }
+        }
+        return originalHandle.apply(this, args);
+    };
+}
+function patchPostgresJsFromModuleExports(postgresModule) {
+    const factories = new Set();
+    const addFactory = (candidate) => {
+        if (typeof candidate !== 'function')
+            return;
+        // getLoadedModuleExportsByPackage also returns internal postgres.js
+        // helpers. Only the public factory carries these static exports.
+        if (!candidate.PostgresError && !candidate.BigInt && !candidate.__repro_postgres_factory)
+            return;
+        factories.add(candidate);
+    };
+    addFactory(postgresModule);
+    addFactory(postgresModule?.default);
+    for (const factory of factories) {
+        let sql;
+        try {
+            sql = factory({ max: 1, idle_timeout: 1, connect_timeout: 1 });
+            const query = sql.unsafe('select 1');
+            patchPostgresJsQueryPrototype(Object.getPrototypeOf(query));
+        }
+        catch { }
+        try {
+            const ended = sql?.end?.({ timeout: 0 });
+            if (ended && typeof ended.catch === 'function')
+                ended.catch(() => undefined);
+        }
+        catch { }
+    }
+}
+function installPostgresJsRequireHook() {
+    if (postgresJsRequireHookInstalled)
+        return;
+    postgresJsRequireHookInstalled = true;
+    try {
+        const rim = requireOptionalHostModule('require-in-the-middle');
+        const Hook = rim?.Hook ?? rim;
+        if (typeof Hook !== 'function')
+            return;
+        // eslint-disable-next-line no-new
+        new Hook(['postgres'], (exports) => {
+            patchPostgresJsFromModuleExports(exports);
+            return exports;
+        });
+    }
+    catch { }
+}
+function patchTypeOrmQueryRunner(queryRunner) {
+    if (!queryRunner || queryRunner[TYPEORM_QUERY_RUNNER_PATCHED])
+        return queryRunner;
+    const original = queryRunner.query;
+    if (typeof original !== 'function')
+        return queryRunner;
+    try {
+        Object.defineProperty(queryRunner, TYPEORM_QUERY_RUNNER_PATCHED, { value: true, configurable: true });
+    }
+    catch {
+        return queryRunner;
+    }
+    queryRunner.query = function reproPatchedTypeOrmQuery(...args) {
+        return postgresSqlSourceAls.run({ library: 'typeorm', driver: 'pg' }, () => original.apply(this, args));
+    };
+    return queryRunner;
+}
+function patchTypeOrmDataSourcePrototype(proto) {
+    if (!proto || proto[TYPEORM_DATASOURCE_PATCHED])
+        return;
+    const original = proto.createQueryRunner;
+    if (typeof original !== 'function')
+        return;
+    try {
+        Object.defineProperty(proto, TYPEORM_DATASOURCE_PATCHED, { value: true, configurable: true });
+    }
+    catch {
+        return;
+    }
+    proto.createQueryRunner = function reproPatchedCreateQueryRunner(...args) {
+        return patchTypeOrmQueryRunner(original.apply(this, args));
+    };
+}
+function patchTypeOrmFromModuleExports(typeOrmModule) {
+    if (!typeOrmModule)
+        return;
+    patchTypeOrmDataSourcePrototype(typeOrmModule?.DataSource?.prototype);
+    patchTypeOrmDataSourcePrototype(typeOrmModule?.Connection?.prototype);
+    patchTypeOrmDataSourcePrototype(typeOrmModule?.default?.DataSource?.prototype);
+}
+function installTypeOrmRequireHook() {
+    if (typeOrmRequireHookInstalled)
+        return;
+    typeOrmRequireHookInstalled = true;
+    try {
+        const rim = requireOptionalHostModule('require-in-the-middle');
+        const Hook = rim?.Hook ?? rim;
+        if (typeof Hook !== 'function')
+            return;
+        // eslint-disable-next-line no-new
+        new Hook(['typeorm'], (exports) => {
+            patchTypeOrmFromModuleExports(exports);
+            return exports;
+        });
+    }
+    catch { }
+}
+function patchPostgreSql(cfg) {
+    registerPostgreSqlPatchConfig(cfg);
+    installPgRequireHook();
+    installPostgresJsRequireHook();
+    installTypeOrmRequireHook();
+    const pgModules = new Set();
+    const pg = requireOptionalHostModule('pg');
+    if (pg)
+        pgModules.add(pg);
+    for (const loaded of getLoadedModuleExportsByPackage('pg'))
+        pgModules.add(loaded);
+    for (const loaded of pgModules)
+        patchPgFromModuleExports(loaded);
+    const postgresModules = new Set();
+    const postgres = requireOptionalHostModule('postgres');
+    if (postgres)
+        postgresModules.add(postgres);
+    for (const loaded of getLoadedModuleExportsByPackage('postgres'))
+        postgresModules.add(loaded);
+    for (const loaded of postgresModules)
+        patchPostgresJsFromModuleExports(loaded);
+    const typeOrmModules = new Set();
+    const typeOrm = requireOptionalHostModule('typeorm');
+    if (typeOrm)
+        typeOrmModules.add(typeOrm);
+    for (const loaded of getLoadedModuleExportsByPackage('typeorm'))
+        typeOrmModules.add(loaded);
+    for (const loaded of typeOrmModules)
+        patchTypeOrmFromModuleExports(loaded);
+}
+exports.patchPostgreSql = patchPostgreSql;
 const mongoDbPatchConfigs = [];
 let mongoDbRequireHookInstalled = false;
 let mongoDbImportHookInstalled = false;
@@ -8801,9 +9809,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,
@@ -8820,6 +9830,7 @@ async function initRepro(cfg) {
     patchKafkaJs(integrationCfg);
     patchAmqplib(integrationCfg);
     patchRedis(integrationCfg);
+    patchPostgreSql(integrationCfg);
     patchMongoDb(integrationCfg);
     await installMongoDbImportHook();
     patchSendgridMail(integrationCfg);
@@ -8855,6 +9866,9 @@ exports.__reproTestHooks = {
         lastClientActivityAt = 0;
         sdkBackgroundQuietUntil = 0;
     },
+    setBackendLiveTimingForTest(override) {
+        backendLiveTimingOverrideForTest = override;
+    },
     runWithRequestContextForTest(ctx, fn) {
         return als.run({
             ...ctx,
@@ -8879,6 +9893,9 @@ exports.__reproTestHooks = {
     patchAmqplibConnectionForTest: patchAmqplibConnection,
     patchAmqplibChannelForTest: patchAmqplibChannel,
     wrapAmqplibConsumeHandlerForTest: wrapAmqplibConsumeHandler,
+    patchPgModuleForTest: patchPgFromModuleExports,
+    patchPostgresJsModuleForTest: patchPostgresJsFromModuleExports,
+    patchTypeOrmModuleForTest: patchTypeOrmFromModuleExports,
     patchMongoDbModuleForTest: patchMongoDbFromModuleExports,
     patchMongoCollectionPrototypeForTest: patchMongoCollectionPrototype,
     chunkTraceEventsForTransportForTest: chunkTraceEventsForTransport,