@reproapp/node-sdk 0.0.23 → 0.0.25

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__reproTestHooks = exports.initRepro = exports.patchSendgridMail = exports.patchRedis = 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.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");
@@ -1525,9 +1525,10 @@ function resolveCollectionOrWarn(source, type) {
 function post(cfg, sessionId, body, options) {
     try {
         const entries = Array.isArray(body?.entries) ? body.entries : [];
-        (0, client_1.enqueueIngestEntries)(cfg, sessionId, entries, options);
+        return (0, client_1.enqueueIngestEntries)(cfg, sessionId, entries, options);
     }
     catch { /* swallow in SDK */ }
+    return false;
 }
 function toIngestConfig(cfg) {
     return {
@@ -4918,9 +4919,6 @@ function emitDbQuery(cfg, sid, aid, payload) {
     const spanContext = payload?.spanContext ?? captureSpanContextFromTracer();
     if (!shouldCaptureDbSpan(spanContext))
         return;
-    if (ctx.captureScope) {
-        ctx.captureScope.dbChangeCount += 1;
-    }
     const runCtx = {
         sid: ctx.sid,
         aid: ctx.aid,
@@ -5039,7 +5037,7 @@ async function emitDbQueryAsync(cfg, sid, aid, payload) {
         resultMetaMaterialization: resultMetaMaterialization.skipped,
         errorMaterialization: errorMaterialization.skipped,
     }, spanContext);
-    post(cfg, sid, {
+    const enqueued = post(cfg, sid, {
         entries: [{
                 actionId: aid ?? null,
                 requestRid: ctx.rid ?? null,
@@ -5048,6 +5046,9 @@ async function emitDbQueryAsync(cfg, sid, aid, payload) {
                 t: payload.t,
             }]
     });
+    if (enqueued && ctx.captureScope) {
+        ctx.captureScope.dbChangeCount += 1;
+    }
 }
 function buildMinimalUpdate(before, after) {
     const set = {};
@@ -6324,6 +6325,780 @@ function patchKafkaJs(cfg) {
     }
 }
 exports.patchKafkaJs = patchKafkaJs;
+function decodeAmqpHeaderValue(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed.length ? trimmed : null;
+    }
+    if (Buffer.isBuffer(value)) {
+        const decoded = value.toString('utf8').trim();
+        return decoded.length ? decoded : null;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+        return String(value);
+    }
+    return null;
+}
+function readAmqpHeader(headers, key) {
+    if (!headers || typeof headers !== 'object')
+        return null;
+    const direct = decodeAmqpHeaderValue(headers[key]);
+    if (direct)
+        return direct;
+    const normalized = key.toLowerCase();
+    for (const [entryKey, entryValue] of Object.entries(headers)) {
+        if (entryKey.toLowerCase() !== normalized)
+            continue;
+        return decodeAmqpHeaderValue(entryValue);
+    }
+    return null;
+}
+function cloneAmqpHeaders(headers) {
+    if (!headers || typeof headers !== 'object' || Buffer.isBuffer(headers))
+        return {};
+    const out = {};
+    for (const [key, value] of Object.entries(headers)) {
+        out[key] = value;
+    }
+    return out;
+}
+function withAmqpPropagationHeaders(headers, values) {
+    const out = cloneAmqpHeaders(headers);
+    for (const [key, value] of Object.entries(values)) {
+        if (value === null || value === undefined)
+            continue;
+        const str = String(value).trim();
+        if (!str.length)
+            continue;
+        out[key] = str;
+    }
+    return out;
+}
+function normalizeAmqpHeadersForPayload(headers) {
+    const out = {};
+    if (!headers || typeof headers !== 'object' || Buffer.isBuffer(headers))
+        return out;
+    for (const [key, value] of Object.entries(headers)) {
+        const decoded = decodeAmqpHeaderValue(value);
+        if (decoded !== null) {
+            out[key] = decoded;
+        }
+        else {
+            const sanitized = sanitizeResultForMeta(value);
+            if (sanitized !== undefined)
+                out[key] = sanitized;
+        }
+    }
+    return out;
+}
+function hasAmqpPropagationValues(values) {
+    return Object.values(values).some((value) => {
+        if (value === null || value === undefined)
+            return false;
+        return String(value).trim().length > 0;
+    });
+}
+function isAmqpOptionsObject(value) {
+    return Boolean(value && typeof value === 'object' && !Buffer.isBuffer(value) && typeof value !== 'function');
+}
+function withAmqpPropagationOptions(options, values) {
+    const base = isAmqpOptionsObject(options) ? { ...options } : {};
+    return {
+        ...base,
+        headers: withAmqpPropagationHeaders(base.headers, values),
+    };
+}
+function amqpContentSize(content) {
+    if (content === null || content === undefined)
+        return null;
+    if (typeof content === 'string')
+        return Buffer.byteLength(content, 'utf8');
+    if (Buffer.isBuffer(content))
+        return content.length;
+    if (content instanceof Uint8Array)
+        return content.byteLength;
+    return null;
+}
+function decodeAmqpContent(content) {
+    if (content === null || content === undefined)
+        return null;
+    if (typeof content === 'string')
+        return content;
+    if (Buffer.isBuffer(content))
+        return content.toString('utf8');
+    if (content instanceof Uint8Array)
+        return Buffer.from(content).toString('utf8');
+    if (typeof content === 'number' || typeof content === 'boolean')
+        return content;
+    return sanitizeResultForMeta(content);
+}
+function contentTypeLooksJson(contentType) {
+    return typeof contentType === 'string' && /\bjson\b/i.test(contentType);
+}
+function parseAmqpJsonString(value, contentType) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return { parsed: false, value };
+    if (!contentTypeLooksJson(contentType) && !'{['.includes(trimmed[0])) {
+        return { parsed: false, value };
+    }
+    try {
+        return { parsed: true, value: JSON.parse(value) };
+    }
+    catch {
+        return { parsed: false, value };
+    }
+}
+function decodeAmqpMessageContent(content, propertiesOrOptions) {
+    const decoded = decodeAmqpContent(content);
+    if (typeof decoded !== 'string') {
+        return {
+            value: decoded,
+            valueEncoding: decoded === null ? null : typeof decoded,
+        };
+    }
+    const parsed = parseAmqpJsonString(decoded, propertiesOrOptions?.contentType);
+    if (parsed.parsed) {
+        return {
+            value: parsed.value,
+            rawValue: decoded,
+            valueEncoding: 'json',
+        };
+    }
+    return {
+        value: decoded,
+        valueEncoding: Buffer.isBuffer(content) || content instanceof Uint8Array ? 'utf8' : 'string',
+    };
+}
+function buildAmqpMessagePayload(content, propertiesOrOptions) {
+    const decoded = decodeAmqpMessageContent(content, propertiesOrOptions);
+    const payload = {
+        value: decoded.value,
+        valueEncoding: decoded.valueEncoding,
+        valueBytes: amqpContentSize(content),
+        headers: normalizeAmqpHeadersForPayload(propertiesOrOptions?.headers),
+    };
+    if (decoded.rawValue !== undefined) {
+        payload.rawValue = decoded.rawValue;
+    }
+    if (propertiesOrOptions?.contentType !== undefined) {
+        payload.contentType = propertiesOrOptions.contentType;
+    }
+    if (propertiesOrOptions?.contentEncoding !== undefined) {
+        payload.contentEncoding = propertiesOrOptions.contentEncoding;
+    }
+    if (propertiesOrOptions?.messageId !== undefined) {
+        payload.messageId = propertiesOrOptions.messageId;
+    }
+    if (propertiesOrOptions?.correlationId !== undefined) {
+        payload.correlationId = propertiesOrOptions.correlationId;
+    }
+    if (propertiesOrOptions?.replyTo !== undefined) {
+        payload.replyTo = propertiesOrOptions.replyTo;
+    }
+    if (propertiesOrOptions?.type !== undefined) {
+        payload.type = propertiesOrOptions.type;
+    }
+    return payload;
+}
+function buildAmqpMessagePropertiesPayload(properties) {
+    if (!properties || typeof properties !== 'object')
+        return {};
+    const payload = {};
+    const copyKeys = [
+        'contentType',
+        'contentEncoding',
+        'deliveryMode',
+        'priority',
+        'correlationId',
+        'replyTo',
+        'expiration',
+        'messageId',
+        'timestamp',
+        'type',
+        'userId',
+        'appId',
+        'clusterId',
+    ];
+    for (const key of copyKeys) {
+        if (properties[key] !== undefined)
+            payload[key] = sanitizeResultForMeta(properties[key]);
+    }
+    payload.headers = normalizeAmqpHeadersForPayload(properties.headers);
+    return payload;
+}
+function sanitizeAmqpQueue(queue) {
+    const value = typeof queue === 'string' ? queue.trim() : '';
+    return value.length ? value : 'unknown-queue';
+}
+function sanitizeAmqpExchange(exchange) {
+    if (exchange === undefined || exchange === null)
+        return '';
+    const value = typeof exchange === 'string' ? exchange.trim() : String(exchange).trim();
+    return value;
+}
+function sanitizeAmqpRoutingKey(routingKey) {
+    const value = typeof routingKey === 'string' ? routingKey.trim() : '';
+    return value.length ? value : 'unknown-routing-key';
+}
+function summarizeAmqpError(error) {
+    const message = typeof error?.message === 'string'
+        ? error.message
+        : error === null || error === undefined
+            ? 'Unknown AMQP error'
+            : String(error);
+    return {
+        name: typeof error?.name === 'string' ? error.name : undefined,
+        message,
+        code: error?.code ?? undefined,
+    };
+}
+function resolveAmqpContext(cfg, headers) {
+    const ctx = getCtx();
+    const fallback = cfg.resolveContext?.() ?? {};
+    const tracerSpan = captureSpanContextFromTracer();
+    const sid = readAmqpHeader(headers, KAFKA_HEADER_SESSION_ID) ?? ctx.sid ?? fallback.sid ?? null;
+    const aid = readAmqpHeader(headers, KAFKA_HEADER_ACTION_ID) ?? ctx.aid ?? fallback.aid ?? null;
+    const traceId = readAmqpHeader(headers, KAFKA_HEADER_TRACE_ID) ??
+        tracerSpan?.traceId ??
+        __TRACER__?.getCurrentTraceId?.() ??
+        null;
+    const parentSpanId = readAmqpHeader(headers, KAFKA_HEADER_SPAN_ID) ??
+        readAmqpHeader(headers, KAFKA_HEADER_PARENT_SPAN_ID) ??
+        null;
+    const requestRid = readAmqpHeader(headers, KAFKA_HEADER_REQUEST_ID);
+    return { sid, aid, traceId, parentSpanId, requestRid };
+}
+function withOptionalTraceContextSync(traceId, fn) {
+    const tracerWithTrace = __TRACER__?.withTrace;
+    if (traceId && typeof tracerWithTrace === 'function') {
+        let invoked = false;
+        try {
+            return tracerWithTrace(traceId, () => {
+                invoked = true;
+                return fn();
+            });
+        }
+        catch (error) {
+            if (invoked)
+                throw error;
+            return fn();
+        }
+    }
+    return fn();
+}
+function buildAmqpTraceEntries(actionId, requestRid, events) {
+    return buildKafkaTraceEntries(actionId, requestRid, events);
+}
+function scheduleAmqpTraceFlush(cfg, amqpCtx, actionId, requestRid, rawTraceEvents, maskReq, captureScope) {
+    const sid = amqpCtx.sid;
+    if (!sid)
+        return;
+    const rawEvents = rawTraceEvents.slice();
+    scheduleSdkBackgroundWork(async () => {
+        await als.run(amqpCtx, async () => {
+            await drainPrivacyTasks(amqpCtx);
+            const pendingEvents = [];
+            for (const rawTraceEvent of rawEvents) {
+                const evt = buildPendingKafkaTraceEvent(rawTraceEvent);
+                if (evt)
+                    pendingEvents.push(evt);
+            }
+            let entries = [];
+            if (pendingEvents.length) {
+                const masking = normalizeMaskingConfig(cfg.masking);
+                const preparedEvents = preparePendingTraceEventsForFlush(pendingEvents);
+                const materializedEvents = await materializePendingTraceEventsAsync(preparedEvents, {
+                    cfg,
+                    maskReq,
+                    masking,
+                    resolvePrivacy: () => getRuntimePrivacyState(cfg).policy ?? null,
+                });
+                entries = buildAmqpTraceEntries(actionId, requestRid, materializedEvents);
+                captureScope.traceBatchCount = entries.length;
+                if (entries.length) {
+                    post(cfg, sid, { entries });
+                }
+            }
+            else {
+                captureScope.traceBatchCount = 0;
+            }
+            post(cfg, sid, {
+                entries: [{
+                        actionId: actionId ?? null,
+                        requestRid,
+                        requestCaptureManifest: buildRequestCaptureManifestPayload(captureScope, entries.length),
+                        t: alignedNow(),
+                    }],
+            });
+        });
+    }, { priority: 'high' });
+}
+function setAmqpPublishOptionsArg(args, optionsIndex, nextOptions, callbackIndex, wrappedCallback) {
+    const nextArgs = args.slice();
+    while (nextArgs.length <= optionsIndex) {
+        nextArgs.push(undefined);
+    }
+    nextArgs[optionsIndex] = nextOptions;
+    if (callbackIndex >= 0 && wrappedCallback) {
+        if (callbackIndex === optionsIndex) {
+            nextArgs[optionsIndex + 1] = wrappedCallback;
+        }
+        else {
+            nextArgs[callbackIndex] = wrappedCallback;
+        }
+    }
+    return nextArgs;
+}
+function scheduleAmqpPublishCapture(params) {
+    if (!params.sid)
+        return;
+    const maskReq = {
+        method: params.method,
+        path: params.path,
+        key: params.key,
+    };
+    const messagePayload = buildAmqpMessagePayload(params.content, params.options);
+    const body = {
+        transport: 'amqp',
+        exchange: params.exchange,
+        routingKey: params.routingKey,
+        queue: params.queue,
+        messageBytes: amqpContentSize(params.content),
+        message: messagePayload,
+        value: cloneKafkaTelemetryValue(messagePayload.value),
+        rawValue: messagePayload.rawValue,
+        valueEncoding: messagePayload.valueEncoding,
+        valueBytes: messagePayload.valueBytes,
+        properties: buildAmqpMessagePropertiesPayload(params.options),
+        traceId: params.span?.traceId ?? null,
+        spanId: params.span?.spanId ?? null,
+        parentSpanId: params.span?.parentSpanId ?? null,
+    };
+    scheduleSdkBackgroundWork(async () => {
+        const bodyMaterialization = await materializeKafkaRequestBody(params.cfg, maskReq, body);
+        const requestPayload = {
+            rid: params.publishRid,
+            method: params.method,
+            url: params.path,
+            path: params.path,
+            status: params.status,
+            durMs: Date.now() - params.t0,
+            key: params.key,
+            headers: {
+                transport: 'amqp',
+                exchange: params.exchange,
+                routingKey: params.routingKey,
+                queue: params.queue,
+                messageBytes: amqpContentSize(params.content),
+                backpressure: params.result === false ? true : undefined,
+            },
+            body: bodyMaterialization.value,
+            bodyMaterialization: bodyMaterialization.skipped,
+            respBody: params.status >= 400
+                ? { error: summarizeAmqpError(params.error) }
+                : { accepted: params.result !== false, backpressure: params.result === false ? true : undefined },
+        };
+        post(params.cfg, params.sid, {
+            entries: [{
+                    actionId: params.aid ?? null,
+                    request: requestPayload,
+                    t: alignedNow(),
+                }],
+        });
+        params.captureScope.backendRequestCount += 1;
+        post(params.cfg, params.sid, {
+            entries: [{
+                    actionId: params.aid ?? null,
+                    requestRid: params.publishRid,
+                    requestCaptureManifest: buildRequestCaptureManifestPayload(params.captureScope, 0),
+                    t: alignedNow(),
+                }],
+        });
+    }, { priority: 'high' });
+}
+function patchAmqplibPublishMethod(channel, cfg, methodName) {
+    const orig = channel?.[methodName];
+    if (typeof orig !== 'function' || orig.__repro_amqplib_patched)
+        return;
+    const optionsIndex = methodName === 'publish' ? 3 : 2;
+    const method = methodName === 'publish' ? 'AMQP_PUBLISH' : 'AMQP_SEND_TO_QUEUE';
+    const wrapped = function reproPatchedAmqplibPublish(...args) {
+        const ctx = getCtx();
+        const fallback = cfg.resolveContext?.() ?? {};
+        const sid = ctx.sid ?? fallback.sid ?? null;
+        const aid = ctx.aid ?? fallback.aid ?? null;
+        const span = captureSpanContextFromTracer();
+        const publishRid = nextRequestId(alignedNow());
+        const propagationValues = {
+            [KAFKA_HEADER_TRACE_ID]: span?.traceId ?? null,
+            [KAFKA_HEADER_SPAN_ID]: span?.spanId === null || span?.spanId === undefined ? null : String(span.spanId),
+            [KAFKA_HEADER_PARENT_SPAN_ID]: span?.parentSpanId === null || span?.parentSpanId === undefined ? null : String(span.parentSpanId),
+            [KAFKA_HEADER_REQUEST_ID]: publishRid,
+            [KAFKA_HEADER_SESSION_ID]: sid,
+            [KAFKA_HEADER_ACTION_ID]: aid,
+        };
+        const shouldPropagate = hasAmqpPropagationValues(propagationValues);
+        const callbackIndex = args.length > 0 && typeof args[args.length - 1] === 'function'
+            ? args.length - 1
+            : -1;
+        const originalOptions = callbackIndex === optionsIndex ? undefined : args[optionsIndex];
+        const nextOptions = shouldPropagate
+            ? withAmqpPropagationOptions(originalOptions, propagationValues)
+            : originalOptions;
+        const exchange = methodName === 'publish' ? sanitizeAmqpExchange(args[0]) : '';
+        const routingKey = methodName === 'publish' ? sanitizeAmqpRoutingKey(args[1]) : undefined;
+        const queue = methodName === 'sendToQueue' ? sanitizeAmqpQueue(args[0]) : undefined;
+        const path = methodName === 'publish'
+            ? `amqp://${exchange || 'default'}/${routingKey}`
+            : `amqp://queue/${queue}`;
+        const key = `${method} ${methodName === 'publish' ? `${exchange || 'default'}/${routingKey}` : queue}`;
+        const content = methodName === 'publish' ? args[2] : args[1];
+        const captureScope = createRequestCaptureScope(publishRid, 'amqp');
+        const t0 = Date.now();
+        let finished = false;
+        const finish = (status, error, result) => {
+            if (finished)
+                return;
+            finished = true;
+            scheduleAmqpPublishCapture({
+                cfg,
+                sid,
+                aid,
+                publishRid,
+                captureScope,
+                method,
+                path,
+                key,
+                exchange,
+                routingKey,
+                queue,
+                content,
+                options: nextOptions,
+                span,
+                t0,
+                status,
+                error,
+                result,
+            });
+        };
+        const originalCallback = callbackIndex >= 0 ? args[callbackIndex] : null;
+        const wrappedCallback = typeof originalCallback === 'function'
+            ? function reproAmqplibPublishCallback(...callbackArgs) {
+                const error = callbackArgs[0];
+                finish(error ? 500 : 200, error, callbackArgs[1]);
+                return originalCallback.apply(this, callbackArgs);
+            }
+            : undefined;
+        const nextArgs = shouldPropagate
+            ? setAmqpPublishOptionsArg(args, optionsIndex, nextOptions, callbackIndex, wrappedCallback)
+            : (wrappedCallback
+                ? setAmqpPublishOptionsArg(args, optionsIndex, nextOptions, callbackIndex, wrappedCallback)
+                : args);
+        try {
+            const result = orig.apply(this, nextArgs);
+            if (!wrappedCallback) {
+                finish(200, undefined, result);
+            }
+            return result;
+        }
+        catch (error) {
+            finish(500, error);
+            throw error;
+        }
+    };
+    wrapped.__repro_amqplib_patched = true;
+    channel[methodName] = wrapped;
+}
+function wrapAmqplibConsumeHandler(onMessage, cfg, queue) {
+    return function reproAmqplibConsumeMessage(message) {
+        if (message === null || message === undefined) {
+            return onMessage.call(this, message);
+        }
+        const queueName = sanitizeAmqpQueue(queue);
+        const properties = message?.properties ?? {};
+        const headers = properties?.headers;
+        const runtime = resolveAmqpContext(cfg, headers);
+        const sid = runtime.sid;
+        const aid = runtime.aid;
+        const deliveryTag = message?.fields?.deliveryTag ?? alignedNow();
+        const consumeRid = nextRequestId(`${queueName}-${deliveryTag}`);
+        const traceId = consumeRid;
+        const captureScope = createRequestCaptureScope(consumeRid, 'amqp');
+        const rawTraceEvents = [];
+        const maskReq = {
+            method: 'AMQP_CONSUME',
+            path: `amqp://queue/${queueName}`,
+            key: `AMQP_CONSUME ${queueName}`,
+        };
+        const amqpCtx = {
+            sid: sid ?? undefined,
+            aid: aid ?? undefined,
+            rid: consumeRid,
+            clockSkewMs: 0,
+            excludedSpanIds: new Set(),
+            maskReq,
+            privacyTasks: new Set(),
+            captureScope,
+        };
+        let unsubscribe;
+        const subscribeTrace = () => {
+            if (!__TRACER__?.tracer?.on)
+                return;
+            try {
+                unsubscribe = __TRACER__.tracer.on((event) => {
+                    if (!event || event.traceId !== traceId)
+                        return;
+                    rawTraceEvents.push(event);
+                });
+            }
+            catch { }
+        };
+        const unsubscribeTrace = () => {
+            try {
+                unsubscribe && unsubscribe();
+            }
+            catch { }
+            unsubscribe = undefined;
+        };
+        const invoke = () => {
+            subscribeTrace();
+            try {
+                const result = onMessage.call(this, message);
+                if (result && typeof result.then === 'function') {
+                    return result.finally(() => {
+                        unsubscribeTrace();
+                    });
+                }
+                unsubscribeTrace();
+                return result;
+            }
+            catch (error) {
+                unsubscribeTrace();
+                throw error;
+            }
+        };
+        const runInAls = () => {
+            if (!sid && !aid)
+                return invoke();
+            return als.run(amqpCtx, () => invoke());
+        };
+        const t0 = Date.now();
+        let finished = false;
+        const finish = (threw, error) => {
+            if (finished)
+                return;
+            finished = true;
+            if (!sid)
+                return;
+            const fields = message?.fields ?? {};
+            const messagePayload = buildAmqpMessagePayload(message?.content, properties);
+            const body = {
+                transport: 'amqp',
+                queue: queueName,
+                exchange: sanitizeAmqpExchange(fields.exchange),
+                routingKey: sanitizeAmqpRoutingKey(fields.routingKey),
+                deliveryTag: fields.deliveryTag ?? null,
+                redelivered: fields.redelivered ?? null,
+                consumerTag: fields.consumerTag ?? null,
+                parentRequestRid: runtime.requestRid,
+                parentTraceId: runtime.traceId,
+                parentSpanId: runtime.parentSpanId,
+                messageBytes: amqpContentSize(message?.content),
+                message: messagePayload,
+                value: cloneKafkaTelemetryValue(messagePayload.value),
+                rawValue: messagePayload.rawValue,
+                valueEncoding: messagePayload.valueEncoding,
+                valueBytes: messagePayload.valueBytes,
+                properties: buildAmqpMessagePropertiesPayload(properties),
+            };
+            scheduleSdkBackgroundWork(async () => {
+                const bodyMaterialization = await materializeKafkaRequestBody(cfg, maskReq, body);
+                const requestPayload = {
+                    rid: consumeRid,
+                    method: 'AMQP_CONSUME',
+                    url: `amqp://queue/${queueName}`,
+                    path: `amqp://queue/${queueName}`,
+                    status: threw ? 500 : 200,
+                    durMs: Date.now() - t0,
+                    key: `AMQP_CONSUME ${queueName}`,
+                    headers: normalizeAmqpHeadersForPayload(headers),
+                    body: bodyMaterialization.value,
+                    bodyMaterialization: bodyMaterialization.skipped,
+                    respBody: threw ? { error: summarizeAmqpError(error) } : undefined,
+                };
+                post(cfg, sid, {
+                    entries: [{
+                            actionId: aid ?? null,
+                            request: requestPayload,
+                            t: alignedNow(),
+                        }],
+                });
+                captureScope.backendRequestCount += 1;
+                scheduleAmqpTraceFlush(cfg, amqpCtx, aid, consumeRid, rawTraceEvents, maskReq, captureScope);
+            }, { priority: 'high' });
+        };
+        try {
+            const result = withOptionalTraceContextSync(traceId, runInAls);
+            if (result && typeof result.then === 'function') {
+                return result.then((value) => {
+                    finish(false);
+                    return value;
+                }, (error) => {
+                    finish(true, error);
+                    throw error;
+                });
+            }
+            finish(false);
+            return result;
+        }
+        catch (error) {
+            finish(true, error);
+            throw error;
+        }
+    };
+}
+function patchAmqplibChannel(channel, cfg) {
+    if (!channel || channel.__repro_amqplib_channel_patched)
+        return;
+    channel.__repro_amqplib_channel_patched = true;
+    patchAmqplibPublishMethod(channel, cfg, 'publish');
+    patchAmqplibPublishMethod(channel, cfg, 'sendToQueue');
+    const origConsume = channel.consume;
+    if (typeof origConsume === 'function' && !origConsume.__repro_amqplib_patched) {
+        const wrapped = function reproPatchedAmqplibConsume(queue, onMessage, ...rest) {
+            if (typeof onMessage !== 'function') {
+                return origConsume.call(this, queue, onMessage, ...rest);
+            }
+            return origConsume.call(this, queue, wrapAmqplibConsumeHandler(onMessage, cfg, queue), ...rest);
+        };
+        wrapped.__repro_amqplib_patched = true;
+        channel.consume = wrapped;
+    }
+}
+function wrapAmqplibChannelFactory(connection, cfg, methodName) {
+    const orig = connection?.[methodName];
+    if (typeof orig !== 'function' || orig.__repro_amqplib_patched)
+        return;
+    const wrapped = function reproPatchedAmqplibCreateChannel(...args) {
+        const callbackIndex = args.length > 0 && typeof args[args.length - 1] === 'function'
+            ? args.length - 1
+            : -1;
+        const nextArgs = args.slice();
+        if (callbackIndex >= 0) {
+            const originalCallback = args[callbackIndex];
+            nextArgs[callbackIndex] = function reproAmqplibCreateChannelCallback(error, channel, ...rest) {
+                if (channel)
+                    patchAmqplibChannel(channel, cfg);
+                return originalCallback.call(this, error, channel, ...rest);
+            };
+        }
+        const result = orig.apply(this, nextArgs);
+        if (result && typeof result.then === 'function') {
+            return result.then((channel) => {
+                patchAmqplibChannel(channel, cfg);
+                return channel;
+            });
+        }
+        if (result)
+            patchAmqplibChannel(result, cfg);
+        return result;
+    };
+    wrapped.__repro_amqplib_patched = true;
+    connection[methodName] = wrapped;
+}
+function patchAmqplibConnection(connection, cfg) {
+    if (!connection || connection.__repro_amqplib_connection_patched)
+        return;
+    connection.__repro_amqplib_connection_patched = true;
+    wrapAmqplibChannelFactory(connection, cfg, 'createChannel');
+    wrapAmqplibChannelFactory(connection, cfg, 'createConfirmChannel');
+}
+function patchAmqplibModule(amqpModule, cfg) {
+    if (!amqpModule || typeof amqpModule !== 'object')
+        return;
+    const targets = new Set([amqpModule]);
+    if (amqpModule.default && typeof amqpModule.default === 'object') {
+        targets.add(amqpModule.default);
+    }
+    for (const target of targets) {
+        if (!target || target.__repro_amqplib_module_patched)
+            continue;
+        const origConnect = target.connect;
+        if (typeof origConnect !== 'function')
+            continue;
+        target.__repro_amqplib_module_patched = true;
+        target.connect = function reproPatchedAmqplibConnect(...args) {
+            const callbackIndex = args.length > 0 && typeof args[args.length - 1] === 'function'
+                ? args.length - 1
+                : -1;
+            const nextArgs = args.slice();
+            if (callbackIndex >= 0) {
+                const originalCallback = args[callbackIndex];
+                nextArgs[callbackIndex] = function reproAmqplibConnectCallback(error, connection, ...rest) {
+                    if (connection)
+                        patchAmqplibConnection(connection, cfg);
+                    return originalCallback.call(this, error, connection, ...rest);
+                };
+            }
+            const result = origConnect.apply(this, nextArgs);
+            if (result && typeof result.then === 'function') {
+                return result.then((connection) => {
+                    patchAmqplibConnection(connection, cfg);
+                    return connection;
+                });
+            }
+            if (result)
+                patchAmqplibConnection(result, cfg);
+            return result;
+        };
+    }
+}
+const amqplibPatchConfigs = [];
+let amqplibRequireHookInstalled = false;
+function installAmqplibRequireHook() {
+    if (amqplibRequireHookInstalled)
+        return;
+    amqplibRequireHookInstalled = 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(['amqplib', 'amqplib/callback_api'], (exports) => {
+            for (const cfg of amqplibPatchConfigs) {
+                patchAmqplibModule(exports, cfg);
+            }
+            return exports;
+        });
+    }
+    catch { }
+}
+function patchAmqplib(cfg) {
+    amqplibPatchConfigs.push(cfg);
+    installAmqplibRequireHook();
+    const amqpModules = new Set();
+    const resolvedAmqpModule = requireOptionalHostModule('amqplib');
+    if (resolvedAmqpModule) {
+        amqpModules.add(resolvedAmqpModule);
+    }
+    const resolvedAmqpCallbackModule = requireOptionalHostModule('amqplib/callback_api');
+    if (resolvedAmqpCallbackModule) {
+        amqpModules.add(resolvedAmqpCallbackModule);
+    }
+    for (const loadedAmqpModule of getLoadedModuleExportsByPackage('amqplib')) {
+        amqpModules.add(loadedAmqpModule);
+    }
+    if (!amqpModules.size)
+        return;
+    for (const amqpModule of amqpModules) {
+        patchAmqplibModule(amqpModule, cfg);
+    }
+}
+exports.patchAmqplib = patchAmqplib;
 const redisPatchConfigs = [];
 let redisRequireHookInstalled = false;
 const REDIS_KEYLESS_COMMANDS = new Set([
@@ -7037,6 +7812,7 @@ async function initRepro(cfg) {
         skipUrls: [resolveIngestUrl(ingestCfg)],
     });
     patchKafkaJs(integrationCfg);
+    patchAmqplib(integrationCfg);
     patchRedis(integrationCfg);
     patchSendgridMail(integrationCfg);
     patchMongooseIntegration(reproAutoMiddlewareConfig);
@@ -7081,6 +7857,10 @@ exports.__reproTestHooks = {
     materializeInlinePrivacyValueAsyncForTest: materializeInlinePrivacyValueAsync,
     patchKafkaProducerInstanceForTest: patchKafkaProducerInstance,
     wrapKafkaEachMessageHandlerForTest: wrapKafkaEachMessageHandler,
+    patchAmqplibModuleForTest: patchAmqplibModule,
+    patchAmqplibConnectionForTest: patchAmqplibConnection,
+    patchAmqplibChannelForTest: patchAmqplibChannel,
+    wrapAmqplibConsumeHandlerForTest: wrapAmqplibConsumeHandler,
     chunkTraceEventsForTransportForTest: chunkTraceEventsForTransport,
     estimateTraceBatchSerializedBytesForTest: estimateTraceBatchSerializedBytes,
     sanitizeTraceValueForPrivacyForTest: sanitizeTraceValueForPrivacy,