@reproapp/node-sdk 0.0.39 → 0.0.42

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");
@@ -822,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: 'critical' });
+}
 const als = new async_hooks_1.AsyncLocalStorage();
 const getCtx = () => als.getStore() || {};
 function normalizeNativeMongoSuppressionOp(op) {
@@ -964,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;
@@ -4598,6 +4619,7 @@ function reproMiddleware(cfg) {
         const clockSkewMs = headerTs !== null ? headerTs - requestStartRaw : 0;
         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] || '/';
@@ -6515,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 : [];
@@ -6623,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
@@ -6764,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',
@@ -6878,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',
@@ -7506,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) => {
@@ -7592,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',
@@ -8154,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;
@@ -9244,6 +9830,7 @@ async function initRepro(cfg) {
     patchKafkaJs(integrationCfg);
     patchAmqplib(integrationCfg);
     patchRedis(integrationCfg);
+    patchPostgreSql(integrationCfg);
     patchMongoDb(integrationCfg);
     await installMongoDbImportHook();
     patchSendgridMail(integrationCfg);
@@ -9306,6 +9893,9 @@ exports.__reproTestHooks = {
     patchAmqplibConnectionForTest: patchAmqplibConnection,
     patchAmqplibChannelForTest: patchAmqplibChannel,
     wrapAmqplibConsumeHandlerForTest: wrapAmqplibConsumeHandler,
+    patchPgModuleForTest: patchPgFromModuleExports,
+    patchPostgresJsModuleForTest: patchPostgresJsFromModuleExports,
+    patchTypeOrmModuleForTest: patchTypeOrmFromModuleExports,
     patchMongoDbModuleForTest: patchMongoDbFromModuleExports,
     patchMongoCollectionPrototypeForTest: patchMongoCollectionPrototype,
     chunkTraceEventsForTransportForTest: chunkTraceEventsForTransport,

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;