@reproapp/node-sdk 0.0.24 → 0.0.26

package/src/index.ts

@@ -1158,7 +1158,7 @@ type Ctx = {
 
 type RequestCaptureScopeState = {
     requestRid: string;
-    transport: 'http' | 'kafka' | 'background';
+    transport: 'http' | 'kafka' | 'amqp' | 'background';
     backendRequestCount: number;
     traceBatchCount: number;
     dbChangeCount: number;
@@ -6419,7 +6419,7 @@ function cloneKafkaTelemetryValue(value: any): any {
 }
 
 async function materializeKafkaRequestBody(
-    cfg: KafkaJsPatchConfig,
+    cfg: ReproMiddlewareConfig,
     maskReq: MaskRequestContext,
     body: Record<string, any>,
 ): Promise<InlinePrivacyMaterializationResult> {
@@ -7380,6 +7380,890 @@ export function patchKafkaJs(cfg: KafkaJsPatchConfig) {
     }
 }
 
+type AmqpHeaderMap = Record<string, any>;
+type AmqpContextResolver = () => { sid?: string; aid?: string } | undefined;
+type AmqpPropagationContext = {
+    sid: string | null;
+    aid: string | null;
+    traceId: string | null;
+    parentSpanId: string | null;
+    requestRid: string | null;
+};
+const AMQP_INTERNAL_PUBLISH_DEPTH = Symbol.for('repro.amqplib.internalPublishDepth');
+
+export type AmqplibPatchConfig = ReproMiddlewareConfig & {
+    resolveContext?: AmqpContextResolver;
+};
+
+function decodeAmqpHeaderValue(value: any): string | null {
+    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: any, key: string): string | null {
+    if (!headers || typeof headers !== 'object') return null;
+    const direct = decodeAmqpHeaderValue((headers as Record<string, any>)[key]);
+    if (direct) return direct;
+    const normalized = key.toLowerCase();
+    for (const [entryKey, entryValue] of Object.entries(headers as Record<string, any>)) {
+        if (entryKey.toLowerCase() !== normalized) continue;
+        return decodeAmqpHeaderValue(entryValue);
+    }
+    return null;
+}
+
+function cloneAmqpHeaders(headers: any): AmqpHeaderMap {
+    if (!headers || typeof headers !== 'object' || Buffer.isBuffer(headers)) return {};
+    const out: AmqpHeaderMap = {};
+    for (const [key, value] of Object.entries(headers as Record<string, any>)) {
+        out[key] = value;
+    }
+    return out;
+}
+
+function withAmqpPropagationHeaders(
+    headers: any,
+    values: Record<string, string | null | undefined>,
+): AmqpHeaderMap {
+    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: any): Record<string, any> {
+    const out: Record<string, any> = {};
+    if (!headers || typeof headers !== 'object' || Buffer.isBuffer(headers)) return out;
+    for (const [key, value] of Object.entries(headers as Record<string, any>)) {
+        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: Record<string, string | null | undefined>): boolean {
+    return Object.values(values).some((value) => {
+        if (value === null || value === undefined) return false;
+        return String(value).trim().length > 0;
+    });
+}
+
+function isAmqpOptionsObject(value: any): boolean {
+    return Boolean(value && typeof value === 'object' && !Buffer.isBuffer(value) && typeof value !== 'function');
+}
+
+function withAmqpPropagationOptions(
+    options: any,
+    values: Record<string, string | null | undefined>,
+): Record<string, any> {
+    const base = isAmqpOptionsObject(options) ? { ...options } : {};
+    return {
+        ...base,
+        headers: withAmqpPropagationHeaders(base.headers, values),
+    };
+}
+
+function amqpContentSize(content: any): number | null {
+    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: any): any {
+    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: any): boolean {
+    return typeof contentType === 'string' && /\bjson\b/i.test(contentType);
+}
+
+function parseAmqpJsonString(
+    value: string,
+    contentType?: any,
+): { parsed: true; value: any } | { parsed: false; value: string } {
+    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: any, propertiesOrOptions?: any): {
+    value: any;
+    rawValue?: string;
+    valueEncoding: string | null;
+} {
+    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: any, propertiesOrOptions?: any): Record<string, any> {
+    const decoded = decodeAmqpMessageContent(content, propertiesOrOptions);
+    const payload: Record<string, any> = {
+        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: any): Record<string, any> {
+    if (!properties || typeof properties !== 'object') return {};
+    const payload: Record<string, any> = {};
+    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: any): string {
+    const value = typeof queue === 'string' ? queue.trim() : '';
+    return value.length ? value : 'unknown-queue';
+}
+
+function sanitizeAmqpExchange(exchange: any): string {
+    if (exchange === undefined || exchange === null) return '';
+    const value = typeof exchange === 'string' ? exchange.trim() : String(exchange).trim();
+    return value;
+}
+
+function sanitizeAmqpRoutingKey(routingKey: any): string {
+    const value = typeof routingKey === 'string' ? routingKey.trim() : '';
+    return value.length ? value : 'unknown-routing-key';
+}
+
+function summarizeAmqpError(error: any): Record<string, unknown> {
+    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: AmqplibPatchConfig, headers: any): AmqpPropagationContext {
+    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<T>(traceId: string | null, fn: () => T): T {
+    const tracerWithTrace = (__TRACER__ as (TracerApi & { withTrace?: <R>(id: string, runner: () => R) => R }) | null)?.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: string | null | undefined,
+    requestRid: string,
+    events: TraceEventRecord[],
+): LegacyEntry[] {
+    return buildKafkaTraceEntries(actionId, requestRid, events);
+}
+
+function scheduleAmqpTraceFlush(
+    cfg: AmqplibPatchConfig,
+    amqpCtx: Ctx,
+    actionId: string | null,
+    requestRid: string,
+    rawTraceEvents: any[],
+    maskReq: MaskRequestContext,
+    captureScope: RequestCaptureScopeState,
+): void {
+    const sid = amqpCtx.sid;
+    if (!sid) return;
+    const rawEvents = rawTraceEvents.slice();
+
+    scheduleSdkBackgroundWork(async () => {
+        await als.run(amqpCtx, async () => {
+            await drainPrivacyTasks(amqpCtx);
+            const pendingEvents: PendingTraceEventRecord[] = [];
+            for (const rawTraceEvent of rawEvents) {
+                const evt = buildPendingKafkaTraceEvent(rawTraceEvent);
+                if (evt) pendingEvents.push(evt);
+            }
+
+            let entries: LegacyEntry[] = [];
+            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: any[],
+    optionsIndex: number,
+    nextOptions: Record<string, any>,
+    callbackIndex: number,
+    wrappedCallback?: (...callbackArgs: any[]) => any,
+): any[] {
+    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: {
+    cfg: AmqplibPatchConfig;
+    sid: string | null;
+    aid: string | null;
+    publishRid: string;
+    captureScope: RequestCaptureScopeState;
+    method: 'AMQP_PUBLISH' | 'AMQP_SEND_TO_QUEUE';
+    path: string;
+    key: string;
+    exchange?: string;
+    routingKey?: string;
+    queue?: string;
+    content: any;
+    options: any;
+    span: SpanContext | null;
+    t0: number;
+    status: number;
+    error?: any;
+    result?: any;
+}): void {
+    if (!params.sid) return;
+    const maskReq: MaskRequestContext = {
+        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: Record<string, any> = {
+            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: any,
+    cfg: AmqplibPatchConfig,
+    methodName: 'publish' | 'sendToQueue',
+) {
+    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(this: any, ...args: any[]) {
+        if (methodName === 'publish' && Number(this?.[AMQP_INTERNAL_PUBLISH_DEPTH] ?? 0) > 0) {
+            return orig.apply(this, 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: number, error?: any, result?: any) => {
+            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(this: any, ...callbackArgs: any[]) {
+                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);
+        let bumpedInternalPublishDepth = false;
+
+        try {
+            if (methodName === 'sendToQueue' && this && typeof this === 'object') {
+                this[AMQP_INTERNAL_PUBLISH_DEPTH] = Number(this?.[AMQP_INTERNAL_PUBLISH_DEPTH] ?? 0) + 1;
+                bumpedInternalPublishDepth = true;
+            }
+            const result = orig.apply(this, nextArgs);
+            if (!wrappedCallback) {
+                finish(200, undefined, result);
+            }
+            return result;
+        } catch (error) {
+            finish(500, error);
+            throw error;
+        } finally {
+            if (bumpedInternalPublishDepth) {
+                const nextDepth = Number(this?.[AMQP_INTERNAL_PUBLISH_DEPTH] ?? 0) - 1;
+                if (nextDepth > 0) {
+                    this[AMQP_INTERNAL_PUBLISH_DEPTH] = nextDepth;
+                } else if (this && typeof this === 'object') {
+                    delete this[AMQP_INTERNAL_PUBLISH_DEPTH];
+                }
+            }
+        }
+    };
+
+    (wrapped as any).__repro_amqplib_patched = true;
+    channel[methodName] = wrapped;
+}
+
+function wrapAmqplibConsumeHandler(onMessage: any, cfg: AmqplibPatchConfig, queue: any) {
+    return function reproAmqplibConsumeMessage(this: any, message: any) {
+        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: any[] = [];
+        const maskReq: MaskRequestContext = {
+            method: 'AMQP_CONSUME',
+            path: `amqp://queue/${queueName}`,
+            key: `AMQP_CONSUME ${queueName}`,
+        };
+        const amqpCtx: Ctx = {
+            sid: sid ?? undefined,
+            aid: aid ?? undefined,
+            rid: consumeRid,
+            clockSkewMs: 0,
+            excludedSpanIds: new Set<string>(),
+            maskReq,
+            privacyTasks: new Set<Promise<void>>(),
+            captureScope,
+        };
+        let unsubscribe: undefined | (() => void);
+
+        const subscribeTrace = () => {
+            if (!__TRACER__?.tracer?.on) return;
+            try {
+                unsubscribe = __TRACER__.tracer.on((event: any) => {
+                    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: boolean, error?: any) => {
+            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: Record<string, any> = {
+                    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 as any).then === 'function') {
+                return (result as Promise<any>).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: any, cfg: AmqplibPatchConfig) {
+    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(this: any, queue: any, onMessage: any, ...rest: any[]) {
+            if (typeof onMessage !== 'function') {
+                return origConsume.call(this, queue, onMessage, ...rest);
+            }
+            return origConsume.call(this, queue, wrapAmqplibConsumeHandler(onMessage, cfg, queue), ...rest);
+        };
+        (wrapped as any).__repro_amqplib_patched = true;
+        channel.consume = wrapped;
+    }
+}
+
+function wrapAmqplibChannelFactory(
+    connection: any,
+    cfg: AmqplibPatchConfig,
+    methodName: 'createChannel' | 'createConfirmChannel',
+) {
+    const orig = connection?.[methodName];
+    if (typeof orig !== 'function' || orig.__repro_amqplib_patched) return;
+
+    const wrapped = function reproPatchedAmqplibCreateChannel(this: any, ...args: any[]) {
+        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(this: any, error: any, channel: any, ...rest: any[]) {
+                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: any) => {
+                patchAmqplibChannel(channel, cfg);
+                return channel;
+            });
+        }
+        if (result) patchAmqplibChannel(result, cfg);
+        return result;
+    };
+
+    (wrapped as any).__repro_amqplib_patched = true;
+    connection[methodName] = wrapped;
+}
+
+function patchAmqplibConnection(connection: any, cfg: AmqplibPatchConfig) {
+    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: any, cfg: AmqplibPatchConfig) {
+    if (!amqpModule || typeof amqpModule !== 'object') return;
+    const targets = new Set<any>([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(this: any, ...args: any[]) {
+            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(this: any, error: any, connection: any, ...rest: any[]) {
+                    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: any) => {
+                    patchAmqplibConnection(connection, cfg);
+                    return connection;
+                });
+            }
+            if (result) patchAmqplibConnection(result, cfg);
+            return result;
+        };
+    }
+}
+
+const amqplibPatchConfigs: AmqplibPatchConfig[] = [];
+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: any) => {
+            for (const cfg of amqplibPatchConfigs) {
+                patchAmqplibModule(exports, cfg);
+            }
+            return exports;
+        });
+    } catch {}
+}
+
+export function patchAmqplib(cfg: AmqplibPatchConfig) {
+    amqplibPatchConfigs.push(cfg);
+    installAmqplibRequireHook();
+
+    const amqpModules = new Set<any>();
+    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);
+    }
+}
+
 export type RedisPatchConfig = ReproMiddlewareConfig & {
     resolveContext?: () => { sid?: string; aid?: string } | undefined;
 };
@@ -8129,6 +9013,7 @@ export async function initRepro(cfg: ReproInitConfig): Promise<void> {
         skipUrls: [resolveIngestUrl(ingestCfg)],
     });
     patchKafkaJs(integrationCfg);
+    patchAmqplib(integrationCfg);
     patchRedis(integrationCfg);
     patchSendgridMail(integrationCfg);
     patchMongooseIntegration(reproAutoMiddlewareConfig);
@@ -8177,6 +9062,10 @@ export const __reproTestHooks = {
     materializeInlinePrivacyValueAsyncForTest: materializeInlinePrivacyValueAsync,
     patchKafkaProducerInstanceForTest: patchKafkaProducerInstance,
     wrapKafkaEachMessageHandlerForTest: wrapKafkaEachMessageHandler,
+    patchAmqplibModuleForTest: patchAmqplibModule,
+    patchAmqplibConnectionForTest: patchAmqplibConnection,
+    patchAmqplibChannelForTest: patchAmqplibChannel,
+    wrapAmqplibConsumeHandlerForTest: wrapAmqplibConsumeHandler,
     chunkTraceEventsForTransportForTest: chunkTraceEventsForTransport,
     estimateTraceBatchSerializedBytesForTest: estimateTraceBatchSerializedBytes,
     sanitizeTraceValueForPrivacyForTest: sanitizeTraceValueForPrivacy,