@use-tusk/drift-node-sdk 0.1.18 → 0.1.19

package/dist/index.cjs

@@ -4989,31 +4989,31 @@ var require_SamplingResult = /* @__PURE__ */ __commonJS({ "node_modules/@opentel
 var require_span_kind = /* @__PURE__ */ __commonJS({ "node_modules/@opentelemetry/api/build/src/trace/span_kind.js": ((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.SpanKind = void 0;
-	(function(SpanKind$25) {
+	(function(SpanKind$26) {
 		/** Default value. Indicates that the span is used internally. */
-		SpanKind$25[SpanKind$25["INTERNAL"] = 0] = "INTERNAL";
+		SpanKind$26[SpanKind$26["INTERNAL"] = 0] = "INTERNAL";
 		/**
 		* Indicates that the span covers server-side handling of an RPC or other
 		* remote request.
 		*/
-		SpanKind$25[SpanKind$25["SERVER"] = 1] = "SERVER";
+		SpanKind$26[SpanKind$26["SERVER"] = 1] = "SERVER";
 		/**
 		* Indicates that the span covers the client-side wrapper around an RPC or
 		* other remote request.
 		*/
-		SpanKind$25[SpanKind$25["CLIENT"] = 2] = "CLIENT";
+		SpanKind$26[SpanKind$26["CLIENT"] = 2] = "CLIENT";
 		/**
 		* Indicates that the span describes producer sending a message to a
 		* broker. Unlike client and server, there is no direct critical path latency
 		* relationship between producer and consumer spans.
 		*/
-		SpanKind$25[SpanKind$25["PRODUCER"] = 3] = "PRODUCER";
+		SpanKind$26[SpanKind$26["PRODUCER"] = 3] = "PRODUCER";
 		/**
 		* Indicates that the span describes consumer receiving a message from a
 		* broker. Unlike client and server, there is no direct critical path latency
 		* relationship between producer and consumer spans.
 		*/
-		SpanKind$25[SpanKind$25["CONSUMER"] = 4] = "CONSUMER";
+		SpanKind$26[SpanKind$26["CONSUMER"] = 4] = "CONSUMER";
 	})(exports.SpanKind || (exports.SpanKind = {}));
 }) });
 
@@ -5022,20 +5022,20 @@ var require_span_kind = /* @__PURE__ */ __commonJS({ "node_modules/@opentelemetr
 var require_status = /* @__PURE__ */ __commonJS({ "node_modules/@opentelemetry/api/build/src/trace/status.js": ((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.SpanStatusCode = void 0;
-	(function(SpanStatusCode$14) {
+	(function(SpanStatusCode$15) {
 		/**
 		* The default status.
 		*/
-		SpanStatusCode$14[SpanStatusCode$14["UNSET"] = 0] = "UNSET";
+		SpanStatusCode$15[SpanStatusCode$15["UNSET"] = 0] = "UNSET";
 		/**
 		* The operation has been validated by an Application developer or
 		* Operator to have completed successfully.
 		*/
-		SpanStatusCode$14[SpanStatusCode$14["OK"] = 1] = "OK";
+		SpanStatusCode$15[SpanStatusCode$15["OK"] = 1] = "OK";
 		/**
 		* The operation contains an error.
 		*/
-		SpanStatusCode$14[SpanStatusCode$14["ERROR"] = 2] = "ERROR";
+		SpanStatusCode$15[SpanStatusCode$15["ERROR"] = 2] = "ERROR";
 	})(exports.SpanStatusCode || (exports.SpanStatusCode = {}));
 }) });
 
@@ -5684,7 +5684,7 @@ var require_src$7 = /* @__PURE__ */ __commonJS({ "node_modules/@opentelemetry/ap
 
 //#endregion
 //#region node_modules/@use-tusk/drift-schemas/dist/duration-B3fwb4jB.js
-var import_src$34 = /* @__PURE__ */ __toESM(require_src$7(), 1);
+var import_src$35 = /* @__PURE__ */ __toESM(require_src$7(), 1);
 var import_commonjs$9 = /* @__PURE__ */ __toESM(require_commonjs$2(), 1);
 var Duration$Type = class extends import_commonjs$9.MessageType {
 	constructor() {
@@ -7008,11 +7008,11 @@ const Trace = new Trace$Type();
 const toStruct = (obj) => obj ? objectToProtobufStruct(obj) : void 0;
 const mapOtToPb = (k) => {
 	switch (k) {
-		case import_src$34.SpanKind.INTERNAL: return SpanKind$1.INTERNAL;
-		case import_src$34.SpanKind.SERVER: return SpanKind$1.SERVER;
-		case import_src$34.SpanKind.CLIENT: return SpanKind$1.CLIENT;
-		case import_src$34.SpanKind.PRODUCER: return SpanKind$1.PRODUCER;
-		case import_src$34.SpanKind.CONSUMER: return SpanKind$1.CONSUMER;
+		case import_src$35.SpanKind.INTERNAL: return SpanKind$1.INTERNAL;
+		case import_src$35.SpanKind.SERVER: return SpanKind$1.SERVER;
+		case import_src$35.SpanKind.CLIENT: return SpanKind$1.CLIENT;
+		case import_src$35.SpanKind.PRODUCER: return SpanKind$1.PRODUCER;
+		case import_src$35.SpanKind.CONSUMER: return SpanKind$1.CONSUMER;
 		default: return SpanKind$1.UNSPECIFIED;
 	}
 };
@@ -7416,13 +7416,13 @@ var TdInstrumentationNodeModule = class {
 
 //#endregion
 //#region src/core/types.ts
-var import_src$33 = /* @__PURE__ */ __toESM(require_src$7(), 1);
+var import_src$34 = /* @__PURE__ */ __toESM(require_src$7(), 1);
 const TD_INSTRUMENTATION_LIBRARY_NAME = "tusk-drift-sdk";
-const REPLAY_TRACE_ID_CONTEXT_KEY = (0, import_src$33.createContextKey)("td.replayTraceId");
-const SPAN_KIND_CONTEXT_KEY = (0, import_src$33.createContextKey)("td.spanKind");
-const IS_PRE_APP_START_CONTEXT_KEY = (0, import_src$33.createContextKey)("td.isPreAppStart");
-const STOP_RECORDING_CHILD_SPANS_CONTEXT_KEY = (0, import_src$33.createContextKey)("td.stopRecordingChildSpans");
-const CALLING_LIBRARY_CONTEXT_KEY = (0, import_src$33.createContextKey)("td.callingLibrary");
+const REPLAY_TRACE_ID_CONTEXT_KEY = (0, import_src$34.createContextKey)("td.replayTraceId");
+const SPAN_KIND_CONTEXT_KEY = (0, import_src$34.createContextKey)("td.spanKind");
+const IS_PRE_APP_START_CONTEXT_KEY = (0, import_src$34.createContextKey)("td.isPreAppStart");
+const STOP_RECORDING_CHILD_SPANS_CONTEXT_KEY = (0, import_src$34.createContextKey)("td.stopRecordingChildSpans");
+const CALLING_LIBRARY_CONTEXT_KEY = (0, import_src$34.createContextKey)("td.callingLibrary");
 let TdSpanAttributes = /* @__PURE__ */ function(TdSpanAttributes$1) {
 	/**
 	* Presentational information:
@@ -7534,7 +7534,7 @@ TraceBlockingManager.instance = null;
 
 //#endregion
 //#region src/core/tracing/SpanUtils.ts
-var import_src$32 = /* @__PURE__ */ __toESM(require_src$7(), 1);
+var import_src$33 = /* @__PURE__ */ __toESM(require_src$7(), 1);
 var SpanUtils = class SpanUtils {
 	/**
 	* Creates a new span and returns span info including trace ID and span ID
@@ -7542,8 +7542,8 @@ var SpanUtils = class SpanUtils {
 	static createSpan(options) {
 		try {
 			const tracer = TuskDriftCore.getInstance().getTracer();
-			const parentContext = options.parentContext || import_src$32.context.active();
-			const activeSpan = import_src$32.trace.getSpan(parentContext);
+			const parentContext = options.parentContext || import_src$33.context.active();
+			const activeSpan = import_src$33.trace.getSpan(parentContext);
 			if (activeSpan) {
 				const parentTraceId = activeSpan.spanContext().traceId;
 				if (TraceBlockingManager.getInstance().isTraceBlocked(parentTraceId)) {
@@ -7552,11 +7552,11 @@ var SpanUtils = class SpanUtils {
 				}
 			}
 			const span = tracer.startSpan(options.name, {
-				kind: options.kind || import_src$32.SpanKind.CLIENT,
+				kind: options.kind || import_src$33.SpanKind.CLIENT,
 				attributes: options.attributes || {}
 			}, parentContext);
 			const spanContext = span.spanContext();
-			const newContext = import_src$32.trace.setSpan(parentContext, span).setValue(SPAN_KIND_CONTEXT_KEY, options.kind).setValue(IS_PRE_APP_START_CONTEXT_KEY, options.isPreAppStart);
+			const newContext = import_src$33.trace.setSpan(parentContext, span).setValue(SPAN_KIND_CONTEXT_KEY, options.kind).setValue(IS_PRE_APP_START_CONTEXT_KEY, options.isPreAppStart);
 			return {
 				traceId: spanContext.traceId,
 				spanId: spanContext.spanId,
@@ -7573,7 +7573,7 @@ var SpanUtils = class SpanUtils {
 	* Executes a function within a span context
 	*/
 	static withSpan(spanInfo, fn) {
-		return import_src$32.context.with(spanInfo.context, fn);
+		return import_src$33.context.with(spanInfo.context, fn);
 	}
 	/**
 	* Execute a function within a properly configured span
@@ -7590,9 +7590,9 @@ var SpanUtils = class SpanUtils {
 	* @returns The result of the function execution
 	*/
 	static createAndExecuteSpan(mode, originalFunctionCall, options, fn) {
-		const spanContext = import_src$32.trace.getActiveSpan()?.spanContext();
+		const spanContext = import_src$33.trace.getActiveSpan()?.spanContext();
 		if (spanContext) {
-			if (import_src$32.context.active().getValue(STOP_RECORDING_CHILD_SPANS_CONTEXT_KEY)) {
+			if (import_src$33.context.active().getValue(STOP_RECORDING_CHILD_SPANS_CONTEXT_KEY)) {
 				logger.debug(`[SpanUtils] Stopping recording of child spans for span ${spanContext.spanId}, packageName: ${options.packageName}, instrumentationName: ${options.instrumentationName}`);
 				return originalFunctionCall();
 			}
@@ -7631,15 +7631,15 @@ var SpanUtils = class SpanUtils {
 	*/
 	static getCurrentSpanInfo() {
 		try {
-			const activeSpan = import_src$32.trace.getActiveSpan();
+			const activeSpan = import_src$33.trace.getActiveSpan();
 			if (!activeSpan) return null;
 			const spanContext = activeSpan.spanContext();
 			return {
 				traceId: spanContext.traceId,
 				spanId: spanContext.spanId,
 				span: activeSpan,
-				context: import_src$32.context.active(),
-				isPreAppStart: import_src$32.context.active().getValue(IS_PRE_APP_START_CONTEXT_KEY)
+				context: import_src$33.context.active(),
+				isPreAppStart: import_src$33.context.active().getValue(IS_PRE_APP_START_CONTEXT_KEY)
 			};
 		} catch (error) {
 			logger.error("SpanUtils error getting current span info:", error);
@@ -7703,7 +7703,7 @@ var SpanUtils = class SpanUtils {
 	}
 	static setCurrentReplayTraceId(replayTraceId) {
 		try {
-			return import_src$32.context.active().setValue(REPLAY_TRACE_ID_CONTEXT_KEY, replayTraceId);
+			return import_src$33.context.active().setValue(REPLAY_TRACE_ID_CONTEXT_KEY, replayTraceId);
 		} catch (error) {
 			logger.error("SpanUtils error setting current replay trace id:", error);
 			return null;
@@ -7714,7 +7714,7 @@ var SpanUtils = class SpanUtils {
 	*/
 	static getCurrentReplayTraceId() {
 		try {
-			return import_src$32.context.active().getValue(REPLAY_TRACE_ID_CONTEXT_KEY);
+			return import_src$33.context.active().getValue(REPLAY_TRACE_ID_CONTEXT_KEY);
 		} catch (error) {
 			logger.error("SpanUtils error getting current replay trace id:", error);
 			return null;
@@ -8363,7 +8363,7 @@ function findMockResponseSync({ mockRequestData, tuskDrift, inputValueSchemaMerg
 
 //#endregion
 //#region src/instrumentation/libraries/http/mocks/TdMockClientRequest.ts
-var import_src$31 = /* @__PURE__ */ __toESM(require_src$7(), 1);
+var import_src$32 = /* @__PURE__ */ __toESM(require_src$7(), 1);
 let ClientRequest;
 /**
 * Mock ClientRequest implementation for Tusk Drift HTTP replay
@@ -8534,7 +8534,7 @@ var TdMockClientRequest = class TdMockClientRequest extends events.EventEmitter
 					instrumentationName: this.INSTRUMENTATION_NAME,
 					submoduleName: rawInputValue.method,
 					inputValue,
-					kind: import_src$31.SpanKind.CLIENT,
+					kind: import_src$32.SpanKind.CLIENT,
 					stackTrace: this.stackTrace
 				},
 				tuskDrift: this.tuskDrift,
@@ -8704,7 +8704,7 @@ var HttpReplayHooks = class {
 
 //#endregion
 //#region src/instrumentation/core/utils/modeUtils.ts
-var import_src$30 = /* @__PURE__ */ __toESM(require_src$7(), 1);
+var import_src$31 = /* @__PURE__ */ __toESM(require_src$7(), 1);
 /**
 * Utility function that abstracts the common record mode pattern of checking for current span context
 * and deciding whether to execute record mode logic or just call the original function.
@@ -8725,7 +8725,7 @@ function handleRecordMode({ originalFunctionCall, recordModeHandler, spanKind })
 		return originalFunctionCall();
 	}
 	if (!isAppReady) return recordModeHandler({ isPreAppStart: true });
-	if (!currentSpanInfo && spanKind !== import_src$30.SpanKind.SERVER || currentSpanInfo?.isPreAppStart) return originalFunctionCall();
+	if (!currentSpanInfo && spanKind !== import_src$31.SpanKind.SERVER || currentSpanInfo?.isPreAppStart) return originalFunctionCall();
 	else return recordModeHandler({ isPreAppStart: false });
 }
 /**
@@ -10205,7 +10205,7 @@ function captureStackTrace(excludeClassNames = []) {
 
 //#endregion
 //#region src/instrumentation/libraries/http/HttpTransformEngine.ts
-var import_src$29 = /* @__PURE__ */ __toESM(require_src$7(), 1);
+var import_src$30 = /* @__PURE__ */ __toESM(require_src$7(), 1);
 /**
 * Creates an empty HttpClientInputValue object for dropped spans
 */
@@ -10258,7 +10258,7 @@ var HttpTransformEngine = class {
 		const testSpan = {
 			traceId: "",
 			spanId: "",
-			kind: import_src$29.SpanKind.SERVER,
+			kind: import_src$30.SpanKind.SERVER,
 			protocol: "http",
 			inputValue: {
 				method,
@@ -10281,7 +10281,7 @@ var HttpTransformEngine = class {
 		const testSpan = {
 			traceId: "",
 			spanId: "",
-			kind: import_src$29.SpanKind.CLIENT,
+			kind: import_src$30.SpanKind.CLIENT,
 			protocol: inputValue.protocol || "http",
 			inputValue: clonedInputValue
 		};
@@ -10308,8 +10308,8 @@ var HttpTransformEngine = class {
 		const matcherFunction = this.compileMatcher(matcher);
 		if (action.type === "drop") return (span) => {
 			if (!matcherFunction(span)) return;
-			if (span.inputValue) span.inputValue = span.kind === import_src$29.SpanKind.CLIENT ? createEmptyClientInputValue(span.protocol) : createEmptyServerInputValue();
-			if (span.outputValue) span.outputValue = span.kind === import_src$29.SpanKind.CLIENT ? createEmptyClientOutputValue() : createEmptyServerOutputValue();
+			if (span.inputValue) span.inputValue = span.kind === import_src$30.SpanKind.CLIENT ? createEmptyClientInputValue(span.protocol) : createEmptyServerInputValue();
+			if (span.outputValue) span.outputValue = span.kind === import_src$30.SpanKind.CLIENT ? createEmptyClientOutputValue() : createEmptyServerOutputValue();
 			return {
 				type: "drop",
 				field: "entire_span",
@@ -10339,8 +10339,8 @@ var HttpTransformEngine = class {
 	}
 	compileMatcher(matcher) {
 		const checks = [];
-		if (matcher.direction === "outbound") checks.push((span) => span.kind === import_src$29.SpanKind.CLIENT);
-		else if (matcher.direction === "inbound") checks.push((span) => span.kind === import_src$29.SpanKind.SERVER);
+		if (matcher.direction === "outbound") checks.push((span) => span.kind === import_src$30.SpanKind.CLIENT);
+		else if (matcher.direction === "inbound") checks.push((span) => span.kind === import_src$30.SpanKind.SERVER);
 		if (matcher.method) if (matcher.method.length === 0) {} else {
 			const methods = matcher.method.map((method) => method.toUpperCase());
 			checks.push((span) => {
@@ -10568,7 +10568,7 @@ var HttpTransformEngine = class {
 
 //#endregion
 //#region src/instrumentation/libraries/http/Instrumentation.ts
-var import_src$28 = /* @__PURE__ */ __toESM(require_src$7(), 1);
+var import_src$29 = /* @__PURE__ */ __toESM(require_src$7(), 1);
 var HttpInstrumentation = class extends TdInstrumentationBase {
 	constructor(config) {
 		super("http", config);
@@ -10655,10 +10655,10 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 				logger.debug(`[HttpInstrumentation] Setting replay trace id`, replayTraceId);
 				const ctxWithReplayTraceId = SpanUtils.setCurrentReplayTraceId(replayTraceId);
 				if (!ctxWithReplayTraceId) throw new Error("Error setting current replay trace id");
-				return import_src$28.context.with(ctxWithReplayTraceId, () => {
+				return import_src$29.context.with(ctxWithReplayTraceId, () => {
 					return SpanUtils.createAndExecuteSpan(this.mode, () => originalHandler.call(this), {
 						name: `${target}`,
-						kind: import_src$28.SpanKind.SERVER,
+						kind: import_src$29.SpanKind.SERVER,
 						packageName: spanProtocol,
 						submodule: method,
 						packageType: PackageType.HTTP,
@@ -10703,7 +10703,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 					logger.debug(`[HttpInstrumentation] Http inbound request arriving, inputValue: ${JSON.stringify(inputValue)}`);
 					return SpanUtils.createAndExecuteSpan(this.mode, () => originalHandler.call(this), {
 						name: `${target}`,
-						kind: import_src$28.SpanKind.SERVER,
+						kind: import_src$29.SpanKind.SERVER,
 						packageName: spanProtocol,
 						packageType: PackageType.HTTP,
 						submodule: method,
@@ -10723,7 +10723,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 						});
 					});
 				},
-				spanKind: import_src$28.SpanKind.SERVER
+				spanKind: import_src$29.SpanKind.SERVER
 			});
 		} else return originalHandler.call(this);
 	}
@@ -10740,8 +10740,8 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 	_handleInboundRequestInSpan({ req, res, originalHandler, spanInfo, inputValue, schemaMerges, protocol }) {
 		const self = this;
 		const spanProtocol = this._normalizeProtocol(protocol, "http");
-		import_src$28.context.bind(spanInfo.context, req);
-		import_src$28.context.bind(spanInfo.context, res);
+		import_src$29.context.bind(spanInfo.context, req);
+		import_src$29.context.bind(spanInfo.context, res);
 		let completeInputValue = inputValue;
 		this._captureServerRequestBody(req, spanInfo, inputValue, schemaMerges, (updatedInputValue) => {
 			completeInputValue = updatedInputValue;
@@ -10779,7 +10779,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 					const spanData = {
 						traceId: spanInfo.traceId,
 						spanId: spanInfo.spanId,
-						kind: import_src$28.SpanKind.SERVER,
+						kind: import_src$29.SpanKind.SERVER,
 						protocol: spanProtocol,
 						inputValue: completeInputValue,
 						outputValue
@@ -10798,9 +10798,9 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 						...spanData.transformMetadata && { transformMetadata: spanData.transformMetadata }
 					});
 					const status = statusCode >= 400 ? {
-						code: import_src$28.SpanStatusCode.ERROR,
+						code: import_src$29.SpanStatusCode.ERROR,
 						message: `HTTP ${statusCode}`
-					} : { code: import_src$28.SpanStatusCode.OK };
+					} : { code: import_src$29.SpanStatusCode.OK };
 					SpanUtils.setStatus(spanInfo.span, status);
 					const decodedType = getDecodedType(outputValue.headers?.["content-type"] || "");
 					if (decodedType && !ACCEPTABLE_CONTENT_TYPES.has(decodedType)) {
@@ -10850,7 +10850,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 						outputSchemaHash: JsonSchemaHelper.generateDeterministicHash(outputSchema),
 						inputValueHash,
 						outputValueHash,
-						kind: import_src$28.SpanKind.SERVER,
+						kind: import_src$29.SpanKind.SERVER,
 						packageType: PackageType.HTTP,
 						status: {
 							code: statusCode >= 400 ? StatusCode.ERROR : StatusCode.OK,
@@ -10879,7 +10879,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 			try {
 				logger.debug(`[HttpInstrumentation] Server request error: ${error.message} (${SpanUtils.getTraceInfo()})`);
 				SpanUtils.endSpan(spanInfo.span, {
-					code: import_src$28.SpanStatusCode.ERROR,
+					code: import_src$29.SpanStatusCode.ERROR,
 					message: error.message
 				});
 			} catch (error$1) {
@@ -10890,7 +10890,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 			try {
 				logger.debug(`[HttpInstrumentation] Server response error: ${error.message} (${SpanUtils.getTraceInfo()})`);
 				SpanUtils.endSpan(spanInfo.span, {
-					code: import_src$28.SpanStatusCode.ERROR,
+					code: import_src$29.SpanStatusCode.ERROR,
 					message: error.message
 				});
 			} catch (error$1) {
@@ -11095,7 +11095,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 					inputValue: completeInputValue
 				});
 				SpanUtils.endSpan(spanInfo.span, {
-					code: import_src$28.SpanStatusCode.ERROR,
+					code: import_src$29.SpanStatusCode.ERROR,
 					message: error.message
 				});
 			} catch (error$1) {
@@ -11112,7 +11112,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 		const spanData = {
 			traceId: spanInfo.traceId,
 			spanId: spanInfo.spanId,
-			kind: import_src$28.SpanKind.CLIENT,
+			kind: import_src$29.SpanKind.CLIENT,
 			protocol: normalizedProtocol,
 			inputValue,
 			outputValue
@@ -11125,9 +11125,9 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 			transformMetadata: spanData.transformMetadata ? spanData.transformMetadata : void 0
 		});
 		const status = statusCode >= 400 ? {
-			code: import_src$28.SpanStatusCode.ERROR,
+			code: import_src$29.SpanStatusCode.ERROR,
 			message: `HTTP ${statusCode}`
-		} : { code: import_src$28.SpanStatusCode.OK };
+		} : { code: import_src$29.SpanStatusCode.OK };
 		SpanUtils.endSpan(spanInfo.span, status);
 	}
 	_captureHeadersFromRawHeaders(rawHeaders) {
@@ -11181,7 +11181,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 							};
 							return SpanUtils.createAndExecuteSpan(self.mode, () => originalRequest.apply(this, args), {
 								name: requestOptions.path || `${requestProtocol.toUpperCase()} ${method}`,
-								kind: import_src$28.SpanKind.CLIENT,
+								kind: import_src$29.SpanKind.CLIENT,
 								packageName: requestProtocol,
 								packageType: PackageType.HTTP,
 								instrumentationName: self.INSTRUMENTATION_NAME,
@@ -11216,7 +11216,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 						};
 						return SpanUtils.createAndExecuteSpan(self.mode, () => originalRequest.apply(this, args), {
 							name: requestOptions.path || `${requestProtocol.toUpperCase()} ${method}`,
-							kind: import_src$28.SpanKind.CLIENT,
+							kind: import_src$29.SpanKind.CLIENT,
 							packageName: requestProtocol,
 							packageType: PackageType.HTTP,
 							instrumentationName: self.INSTRUMENTATION_NAME,
@@ -11228,7 +11228,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 							return self._handleOutboundRequestInSpan(originalRequest, args, spanInfo, inputValue, { headers: { matchImportance: 0 } });
 						});
 					},
-					spanKind: import_src$28.SpanKind.CLIENT
+					spanKind: import_src$29.SpanKind.CLIENT
 				});
 				else return originalRequest.apply(this, args);
 			};
@@ -11274,7 +11274,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 						};
 						return SpanUtils.createAndExecuteSpan(self.mode, () => originalGet.apply(this, args), {
 							name: requestOptions.path || `${requestProtocol.toUpperCase()} ${method}`,
-							kind: import_src$28.SpanKind.CLIENT,
+							kind: import_src$29.SpanKind.CLIENT,
 							packageName: requestProtocol,
 							packageType: PackageType.HTTP,
 							instrumentationName: self.INSTRUMENTATION_NAME,
@@ -11308,7 +11308,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 						};
 						return SpanUtils.createAndExecuteSpan(self.mode, () => originalGet.apply(this, args), {
 							name: requestOptions.path || `${requestProtocol.toUpperCase()} ${method}`,
-							kind: import_src$28.SpanKind.CLIENT,
+							kind: import_src$29.SpanKind.CLIENT,
 							packageName: requestProtocol,
 							packageType: PackageType.HTTP,
 							instrumentationName: self.INSTRUMENTATION_NAME,
@@ -11320,7 +11320,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 							return self._handleOutboundRequestInSpan(originalGet, args, spanInfo, inputValue, { headers: { matchImportance: 0 } });
 						});
 					},
-					spanKind: import_src$28.SpanKind.CLIENT
+					spanKind: import_src$29.SpanKind.CLIENT
 				});
 				else return originalGet.apply(this, args);
 			};
@@ -11365,7 +11365,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 
 //#endregion
 //#region src/instrumentation/libraries/date/Instrumentation.ts
-var import_src$27 = /* @__PURE__ */ __toESM(require_src$7(), 1);
+var import_src$28 = /* @__PURE__ */ __toESM(require_src$7(), 1);
 /**
 * Date instrumentation that provides consistent dates in replay mode.
 * In replay mode, new Date() calls return the latest mock response timestamp.
@@ -11404,7 +11404,7 @@ var DateInstrumentation = class DateInstrumentation extends TdInstrumentationBas
 		if (this.mode !== TuskDriftMode.REPLAY) return this._callOriginalDate(args, isConstructorCall);
 		const currentSpanInfo = SpanUtils.getCurrentSpanInfo();
 		if (!currentSpanInfo) return this._callOriginalDate(args, isConstructorCall);
-		if (currentSpanInfo.context.getValue(SPAN_KIND_CONTEXT_KEY) !== import_src$27.SpanKind.SERVER) return this._callOriginalDate(args, isConstructorCall);
+		if (currentSpanInfo.context.getValue(SPAN_KIND_CONTEXT_KEY) !== import_src$28.SpanKind.SERVER) return this._callOriginalDate(args, isConstructorCall);
 		this.isInPatchedCall = true;
 		try {
 			return this._handleReplayDate(args, isConstructorCall);
@@ -11650,7 +11650,7 @@ var TdPgClientMock = class extends events.EventEmitter {
 
 //#endregion
 //#region src/instrumentation/libraries/pg/Instrumentation.ts
-var import_src$26 = /* @__PURE__ */ __toESM(require_src$7(), 1);
+var import_src$27 = /* @__PURE__ */ __toESM(require_src$7(), 1);
 var PgInstrumentation = class extends TdInstrumentationBase {
 	constructor(config = {}) {
 		super("pg", config);
@@ -11691,6 +11691,10 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 		const self = this;
 		return (originalQuery) => {
 			return function query(...args) {
+				if (self.isSubmittable(args[0])) {
+					logger.debug(`[PgInstrumentation] Submittable query detected, passing through uninstrumented`);
+					return originalQuery.apply(this, args);
+				}
 				let queryConfig = null;
 				try {
 					queryConfig = self.parseQueryArgs(args);
@@ -11719,7 +11723,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 							const spanName = inputValue.clientType === "pool" ? "pg-pool.query" : "pg.query";
 							return SpanUtils.createAndExecuteSpan(self.mode, () => originalQuery.apply(this, args), {
 								name: spanName,
-								kind: import_src$26.SpanKind.CLIENT,
+								kind: import_src$27.SpanKind.CLIENT,
 								submodule: "query",
 								packageType: PackageType.PG,
 								packageName,
@@ -11738,7 +11742,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 						const spanName = inputValue.clientType === "pool" ? "pg-pool.query" : "pg.query";
 						return SpanUtils.createAndExecuteSpan(self.mode, () => originalQuery.apply(this, args), {
 							name: spanName,
-							kind: import_src$26.SpanKind.CLIENT,
+							kind: import_src$27.SpanKind.CLIENT,
 							submodule: "query",
 							packageType: PackageType.PG,
 							instrumentationName: self.INSTRUMENTATION_NAME,
@@ -11749,7 +11753,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 							return self._handleRecordQueryInSpan(spanInfo, originalQuery, queryConfig, args, this);
 						});
 					},
-					spanKind: import_src$26.SpanKind.CLIENT
+					spanKind: import_src$27.SpanKind.CLIENT
 				});
 				else return originalQuery.apply(this, args);
 			};
@@ -11771,7 +11775,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 					replayModeHandler: () => {
 						return SpanUtils.createAndExecuteSpan(self.mode, () => originalConnect.apply(this, [callback]), {
 							name: `pg.connect`,
-							kind: import_src$26.SpanKind.CLIENT,
+							kind: import_src$27.SpanKind.CLIENT,
 							submodule: "connect",
 							packageName: "pg",
 							packageType: PackageType.PG,
@@ -11788,7 +11792,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 					recordModeHandler: ({ isPreAppStart }) => {
 						return SpanUtils.createAndExecuteSpan(self.mode, () => originalConnect.apply(this, [callback]), {
 							name: `pg.connect`,
-							kind: import_src$26.SpanKind.CLIENT,
+							kind: import_src$27.SpanKind.CLIENT,
 							submodule: "connect",
 							packageName: "pg",
 							packageType: PackageType.PG,
@@ -11799,12 +11803,19 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 							return self._handleRecordConnectInSpan(spanInfo, originalConnect, callback, this);
 						});
 					},
-					spanKind: import_src$26.SpanKind.CLIENT
+					spanKind: import_src$27.SpanKind.CLIENT
 				});
 				else return originalConnect.apply(this, [callback]);
 			};
 		};
 	}
+	/**
+	* Check if an object is a Submittable (Query object with submit method).
+	* This is the same check pg uses internally: typeof config.submit === 'function'
+	*/
+	isSubmittable(arg) {
+		return arg && typeof arg.submit === "function";
+	}
 	parseQueryArgs(args) {
 		if (args.length === 0) return null;
 		const firstArg = args[0];
@@ -11832,7 +11843,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 					logger.debug(`[PgInstrumentation] PG query error (hasCallback): ${error.message} (${SpanUtils.getTraceInfo()})`);
 					try {
 						SpanUtils.endSpan(spanInfo.span, {
-							code: import_src$26.SpanStatusCode.ERROR,
+							code: import_src$27.SpanStatusCode.ERROR,
 							message: error.message
 						});
 					} catch (error$1) {
@@ -11842,7 +11853,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 					logger.debug(`[PgInstrumentation] PG query completed successfully (hasCallback) (${SpanUtils.getTraceInfo()})`);
 					try {
 						this._addOutputAttributesToSpan(spanInfo, result);
-						SpanUtils.endSpan(spanInfo.span, { code: import_src$26.SpanStatusCode.OK });
+						SpanUtils.endSpan(spanInfo.span, { code: import_src$27.SpanStatusCode.OK });
 					} catch (error$1) {
 						logger.error(`[PgInstrumentation] error processing response:`, error$1);
 					}
@@ -11869,7 +11880,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 			logger.debug(`[PgInstrumentation] PG query completed successfully (${SpanUtils.getTraceInfo()})`);
 			try {
 				this._addOutputAttributesToSpan(spanInfo, result);
-				SpanUtils.endSpan(spanInfo.span, { code: import_src$26.SpanStatusCode.OK });
+				SpanUtils.endSpan(spanInfo.span, { code: import_src$27.SpanStatusCode.OK });
 			} catch (error) {
 				logger.error(`[PgInstrumentation] error processing response:`, error);
 			}
@@ -11878,7 +11889,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 			logger.debug(`[PgInstrumentation] PG query error: ${error.message} (${SpanUtils.getTraceInfo()})`);
 			try {
 				SpanUtils.endSpan(spanInfo.span, {
-					code: import_src$26.SpanStatusCode.ERROR,
+					code: import_src$27.SpanStatusCode.ERROR,
 					message: error.message
 				});
 			} catch (error$1) {
@@ -11910,7 +11921,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 				packageName,
 				instrumentationName: this.INSTRUMENTATION_NAME,
 				submoduleName: "query",
-				kind: import_src$26.SpanKind.CLIENT,
+				kind: import_src$27.SpanKind.CLIENT,
 				stackTrace
 			},
 			tuskDrift: this.tuskDrift
@@ -11954,6 +11965,8 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 	* Reference for data type IDs: https://jdbc.postgresql.org/documentation/publicapi/constant-values.html
 	*/
 	convertPostgresTypes(result, rowMode) {
+		if (result && result.isMultiStatement && Array.isArray(result.results)) return result.results.map((singleResult) => this.convertPostgresTypes(singleResult, rowMode));
+		if (Array.isArray(result)) return result.map((singleResult) => this.convertPostgresTypes(singleResult, rowMode));
 		if (!result || !result.fields || !result.rows) return result;
 		if (rowMode === "array") {
 			const convertedRows$1 = result.rows.map((row) => {
@@ -11994,7 +12007,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 					logger.debug(`[PgInstrumentation] PG connect error: ${error.message} (${SpanUtils.getTraceInfo()})`);
 					try {
 						SpanUtils.endSpan(spanInfo.span, {
-							code: import_src$26.SpanStatusCode.ERROR,
+							code: import_src$27.SpanStatusCode.ERROR,
 							message: error.message
 						});
 					} catch (error$1) {
@@ -12004,7 +12017,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 					logger.debug(`[PgInstrumentation] PG connect completed successfully (${SpanUtils.getTraceInfo()})`);
 					try {
 						SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: { connected: true } });
-						SpanUtils.endSpan(spanInfo.span, { code: import_src$26.SpanStatusCode.OK });
+						SpanUtils.endSpan(spanInfo.span, { code: import_src$27.SpanStatusCode.OK });
 					} catch (error$1) {
 						logger.error(`[PgInstrumentation] error processing connect response:`, error$1);
 					}
@@ -12016,7 +12029,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 			logger.debug(`[PgInstrumentation] PG connect completed successfully (${SpanUtils.getTraceInfo()})`);
 			try {
 				SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: { connected: true } });
-				SpanUtils.endSpan(spanInfo.span, { code: import_src$26.SpanStatusCode.OK });
+				SpanUtils.endSpan(spanInfo.span, { code: import_src$27.SpanStatusCode.OK });
 			} catch (error) {
 				logger.error(`[PgInstrumentation] error processing connect response:`, error);
 			}
@@ -12025,7 +12038,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 			logger.debug(`[PgInstrumentation] PG connect error: ${error.message} (${SpanUtils.getTraceInfo()})`);
 			try {
 				SpanUtils.endSpan(spanInfo.span, {
-					code: import_src$26.SpanStatusCode.ERROR,
+					code: import_src$27.SpanStatusCode.ERROR,
 					message: error.message
 				});
 			} catch (error$1) {
@@ -12043,7 +12056,18 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 	}
 	_addOutputAttributesToSpan(spanInfo, result) {
 		if (!result) return;
-		const outputValue = {
+		let outputValue;
+		if (Array.isArray(result)) outputValue = {
+			isMultiStatement: true,
+			results: result.map((r) => ({
+				command: r.command,
+				rowCount: r.rowCount,
+				oid: r.oid,
+				rows: r.rows || [],
+				fields: r.fields || []
+			}))
+		};
+		else outputValue = {
 			command: result.command,
 			rowCount: result.rowCount,
 			oid: result.oid,
@@ -12086,7 +12110,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 					replayModeHandler: () => {
 						return SpanUtils.createAndExecuteSpan(self.mode, () => originalConnect.apply(this, [callback]), {
 							name: `pg-pool.connect`,
-							kind: import_src$26.SpanKind.CLIENT,
+							kind: import_src$27.SpanKind.CLIENT,
 							submodule: "connect",
 							packageName: "pg-pool",
 							packageType: PackageType.PG,
@@ -12103,7 +12127,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 					recordModeHandler: ({ isPreAppStart }) => {
 						return SpanUtils.createAndExecuteSpan(self.mode, () => originalConnect.apply(this, [callback]), {
 							name: `pg-pool.connect`,
-							kind: import_src$26.SpanKind.CLIENT,
+							kind: import_src$27.SpanKind.CLIENT,
 							submodule: "connect",
 							packageName: "pg-pool",
 							packageType: PackageType.PG,
@@ -12114,7 +12138,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 							return self._handleRecordPoolConnectInSpan(spanInfo, originalConnect, callback, this);
 						});
 					},
-					spanKind: import_src$26.SpanKind.CLIENT
+					spanKind: import_src$27.SpanKind.CLIENT
 				});
 				else return originalConnect.apply(this, [callback]);
 			};
@@ -12127,7 +12151,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 					logger.debug(`[PgInstrumentation] PG Pool connect error: ${error.message} (${SpanUtils.getTraceInfo()})`);
 					try {
 						SpanUtils.endSpan(spanInfo.span, {
-							code: import_src$26.SpanStatusCode.ERROR,
+							code: import_src$27.SpanStatusCode.ERROR,
 							message: error.message
 						});
 					} catch (error$1) {
@@ -12140,7 +12164,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 							connected: true,
 							hasClient: !!client
 						} });
-						SpanUtils.endSpan(spanInfo.span, { code: import_src$26.SpanStatusCode.OK });
+						SpanUtils.endSpan(spanInfo.span, { code: import_src$27.SpanStatusCode.OK });
 					} catch (error$1) {
 						logger.error(`[PgInstrumentation] error processing pool connect response:`, error$1);
 					}
@@ -12155,7 +12179,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 					connected: true,
 					hasClient: !!client
 				} });
-				SpanUtils.endSpan(spanInfo.span, { code: import_src$26.SpanStatusCode.OK });
+				SpanUtils.endSpan(spanInfo.span, { code: import_src$27.SpanStatusCode.OK });
 			} catch (error) {
 				logger.error(`[PgInstrumentation] error processing pool connect response:`, error);
 			}
@@ -12164,7 +12188,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 			logger.debug(`[PgInstrumentation] PG Pool connect error: ${error.message} (${SpanUtils.getTraceInfo()})`);
 			try {
 				SpanUtils.endSpan(spanInfo.span, {
-					code: import_src$26.SpanStatusCode.ERROR,
+					code: import_src$27.SpanStatusCode.ERROR,
 					message: error.message
 				});
 			} catch (error$1) {
@@ -12193,68 +12217,114 @@ function isPostgresOutputValueType(value) {
 }
 
 //#endregion
-//#region src/instrumentation/libraries/postgres/Instrumentation.ts
-var import_src$25 = /* @__PURE__ */ __toESM(require_src$7(), 1);
-var PostgresInstrumentation = class extends TdInstrumentationBase {
-	constructor(config = {}) {
-		super("postgres", config);
-		this.INSTRUMENTATION_NAME = "PostgresInstrumentation";
-		this.mode = config.mode || TuskDriftMode.DISABLED;
-		this.tuskDrift = TuskDriftCore.getInstance();
+//#region src/instrumentation/libraries/postgres/utils/typeConversion.ts
+/**
+* Convert PostgreSQL string values back to appropriate JavaScript types
+* based on field metadata from the recorded response.
+*/
+function convertPostgresTypes(result) {
+	if (!isPostgresOutputValueType(result)) {
+		logger.error(`[PostgresInstrumentation] output value is not of type PostgresOutputValueType`, result);
+		return;
 	}
-	init() {
-		return [new TdInstrumentationNodeModule({
-			name: "postgres",
-			supportedVersions: ["3.*"],
-			patch: (moduleExports) => this._patchPostgresModule(moduleExports)
-		})];
+	const { rows, count, command, columns, state, statement } = result;
+	const resultArray = Array.from((rows || []).map((row) => reconstructBuffers(row)));
+	if (count !== void 0) Object.defineProperty(resultArray, "count", {
+		value: count,
+		writable: true,
+		enumerable: false
+	});
+	if (command !== void 0) Object.defineProperty(resultArray, "command", {
+		value: command,
+		writable: true,
+		enumerable: false
+	});
+	if (columns !== void 0) Object.defineProperty(resultArray, "columns", {
+		value: columns,
+		writable: true,
+		enumerable: false
+	});
+	if (state !== void 0) Object.defineProperty(resultArray, "state", {
+		value: state,
+		writable: true,
+		enumerable: false
+	});
+	if (statement !== void 0) Object.defineProperty(resultArray, "statement", {
+		value: statement,
+		writable: true,
+		enumerable: false
+	});
+	return resultArray;
+}
+/**
+* Recursively reconstructs Buffer objects from their JSON-serialized format.
+* When Buffers are JSON.stringify'd, they become { type: "Buffer", data: [...] }.
+* This method converts them back to actual Buffer instances.
+*/
+function reconstructBuffers(value) {
+	if (value === null || value === void 0) return value;
+	if (typeof value === "object" && value.type === "Buffer" && Array.isArray(value.data)) return Buffer.from(value.data);
+	if (Array.isArray(value)) return value.map((item) => reconstructBuffers(item));
+	if (typeof value === "object") {
+		const result = {};
+		for (const key of Object.keys(value)) result[key] = reconstructBuffers(value[key]);
+		return result;
 	}
-	_patchPostgresModule(postgresModule) {
-		logger.debug(`[PostgresInstrumentation] Patching Postgres module in ${this.mode} mode`);
-		if (this.isModulePatched(postgresModule)) {
-			logger.debug(`[PostgresInstrumentation] Postgres module already patched, skipping`);
-			return postgresModule;
-		}
-		const self = this;
-		if (isEsm(postgresModule)) {
-			logger.debug(`[PostgresInstrumentation] Wrapping ESM default export`);
-			this._wrap(postgresModule, "default", (originalFunction) => {
-				return function(...args) {
-					return self._handlePostgresConnection(originalFunction, args);
-				};
-			});
-		} else {
-			logger.debug(`[PostgresInstrumentation] Module is a function (CJS style)`);
-			const originalFunction = postgresModule;
-			const wrappedFunction = function(...args) {
-				logger.debug(`[PostgresInstrumentation] Wrapped postgres() (CJS) called with args:`, args);
-				return self._handlePostgresConnection(originalFunction, args);
-			};
-			Object.setPrototypeOf(wrappedFunction, Object.getPrototypeOf(originalFunction));
-			Object.defineProperty(wrappedFunction, "name", { value: originalFunction.name });
-			for (const key in originalFunction) if (originalFunction.hasOwnProperty(key)) wrappedFunction[key] = originalFunction[key];
-			Object.getOwnPropertyNames(originalFunction).forEach((key) => {
-				if (key !== "prototype" && key !== "length" && key !== "name") {
-					const descriptor = Object.getOwnPropertyDescriptor(originalFunction, key);
-					if (descriptor) Object.defineProperty(wrappedFunction, key, descriptor);
-				}
-			});
-			postgresModule = wrappedFunction;
-		}
-		if (postgresModule.sql && typeof postgresModule.sql === "function") {
-			this._wrap(postgresModule, "sql", this._getSqlPatchFn());
-			logger.debug(`[PostgresInstrumentation] Wrapped sql function`);
-		}
-		this.markModuleAsPatched(postgresModule);
-		logger.debug(`[PostgresInstrumentation] Postgres module patching complete`);
-		return postgresModule;
+	return value;
+}
+/**
+* Add output attributes to span for PostgreSQL results.
+*/
+function addOutputAttributesToSpan(spanInfo, result) {
+	if (!result) return;
+	const isArray$1 = Array.isArray(result);
+	logger.debug(`[PostgresInstrumentation] Adding output attributes to span for ${isArray$1 ? "array" : "object"} result`);
+	const normalizeValue = (val) => {
+		if (Buffer.isBuffer(val)) return val.toString("utf8");
+		else if (Array.isArray(val)) return val.map(normalizeValue);
+		else if (val && typeof val === "object" && val.type === "Buffer" && Array.isArray(val.data)) return Buffer.from(val.data).toString("utf8");
+		return val;
+	};
+	const outputValue = {
+		rows: isArray$1 ? Array.from(result).map(normalizeValue) : (result.rows || []).map(normalizeValue),
+		count: result.count !== void 0 && result.count !== null ? result.count : void 0,
+		command: result.command || void 0,
+		columns: result.columns || void 0,
+		state: result.state || void 0,
+		statement: result.statement || void 0
+	};
+	SpanUtils.addSpanAttributes(spanInfo.span, { outputValue });
+}
+
+//#endregion
+//#region src/instrumentation/libraries/postgres/utils/queryUtils.ts
+/**
+* Reconstruct a parameterized query string from template strings array and values.
+* Converts values to $1, $2, etc. placeholders.
+*/
+function reconstructQueryString(strings, values) {
+	let queryString = "";
+	for (let i = 0; i < strings.length; i++) {
+		queryString += strings[i];
+		if (i < values.length) queryString += `$${i + 1}`;
 	}
-	_handlePostgresConnection(originalFunction, args) {
-		const connectionString = typeof args[0] === "string" ? args[0] : void 0;
-		const options = typeof args[0] === "string" ? args[1] : args[0];
+	return queryString;
+}
+
+//#endregion
+//#region src/instrumentation/libraries/postgres/handlers/ConnectionHandler.ts
+var import_src$26 = /* @__PURE__ */ __toESM(require_src$7(), 1);
+var ConnectionHandler = class {
+	constructor(mode, instrumentationName, isAppReady, wrapSqlInstance) {
+		this.mode = mode;
+		this.instrumentationName = instrumentationName;
+		this.isAppReady = isAppReady;
+		this.wrapSqlInstance = wrapSqlInstance;
+	}
+	handlePostgresConnection(originalFunction, args) {
 		const inputValue = {
-			connectionString: connectionString ? this._sanitizeConnectionString(connectionString) : void 0,
-			options: options ? this._sanitizeConnectionOptions(options) : void 0
+			connectionString: typeof args[0] === "string" ? args[0] : void 0,
+			options: typeof args[0] === "string" ? args[1] : args[0]
 		};
 		if (this.mode === TuskDriftMode.REPLAY) return handleReplayMode({
 			noOpRequestHandler: () => {
@@ -12268,96 +12338,148 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 				}));
 				mockSql.begin = () => Promise.resolve();
 				mockSql.end = () => Promise.resolve();
+				mockSql.file = () => Promise.resolve(Object.assign([], {
+					count: 0,
+					command: null
+				}));
+				mockSql.reserve = () => Promise.resolve(mockSql);
+				mockSql.listen = () => Promise.resolve({
+					state: { state: "I" },
+					unlisten: async () => {}
+				});
+				mockSql.notify = () => Promise.resolve();
 				return mockSql;
 			},
 			isServerRequest: false,
 			replayModeHandler: () => {
 				return SpanUtils.createAndExecuteSpan(this.mode, () => {
 					const sqlInstance = originalFunction(...args);
-					return this._wrapSqlInstance(sqlInstance);
+					return this.wrapSqlInstance(sqlInstance);
 				}, {
 					name: "postgres.connect",
-					kind: import_src$25.SpanKind.CLIENT,
+					kind: import_src$26.SpanKind.CLIENT,
 					submodule: "connect",
 					packageType: PackageType.PG,
 					packageName: "postgres",
-					instrumentationName: this.INSTRUMENTATION_NAME,
+					instrumentationName: this.instrumentationName,
 					inputValue,
-					isPreAppStart: false
+					isPreAppStart: this.isAppReady() ? false : true
 				}, (spanInfo) => {
-					return this._handleReplayConnect(originalFunction, args);
+					return this.handleReplayConnect(originalFunction, args);
 				});
 			}
 		});
 		else if (this.mode === TuskDriftMode.RECORD) return handleRecordMode({
 			originalFunctionCall: () => {
 				const sqlInstance = originalFunction(...args);
-				return this._wrapSqlInstance(sqlInstance);
+				return this.wrapSqlInstance(sqlInstance);
 			},
 			recordModeHandler: ({ isPreAppStart }) => {
 				return SpanUtils.createAndExecuteSpan(this.mode, () => {
 					const sqlInstance = originalFunction(...args);
-					return this._wrapSqlInstance(sqlInstance);
+					return this.wrapSqlInstance(sqlInstance);
 				}, {
 					name: "postgres.connect",
-					kind: import_src$25.SpanKind.CLIENT,
+					kind: import_src$26.SpanKind.CLIENT,
 					submodule: "connect",
 					packageType: PackageType.PG,
 					packageName: "postgres",
-					instrumentationName: this.INSTRUMENTATION_NAME,
+					instrumentationName: this.instrumentationName,
 					inputValue,
 					isPreAppStart
 				}, (spanInfo) => {
-					return this._handleRecordConnect(spanInfo, originalFunction, args);
+					return this.handleRecordConnect(spanInfo, originalFunction, args);
 				});
 			},
-			spanKind: import_src$25.SpanKind.CLIENT
+			spanKind: import_src$26.SpanKind.CLIENT
 		});
 		else return originalFunction(...args);
 	}
-	_sanitizeConnectionString(connectionString) {
-		try {
-			const url = new URL(connectionString);
-			if (url.password) url.password = "***";
-			return url.toString();
-		} catch {
-			return "[INVALID_URL]";
-		}
-	}
-	_sanitizeConnectionOptions(options) {
-		if (!options || typeof options !== "object") return options;
-		const sanitized = { ...options };
-		if (sanitized.password) sanitized.password = "***";
-		if (sanitized.ssl && typeof sanitized.ssl === "object") {
-			sanitized.ssl = { ...sanitized.ssl };
-			if (sanitized.ssl.key) sanitized.ssl.key = "***";
-			if (sanitized.ssl.cert) sanitized.ssl.cert = "***";
-			if (sanitized.ssl.ca) sanitized.ssl.ca = "***";
-		}
-		return sanitized;
-	}
-	_handleRecordConnect(spanInfo, originalFunction, args) {
+	handleRecordConnect(spanInfo, originalFunction, args) {
 		const sqlInstance = originalFunction(...args);
-		const wrappedInstance = this._wrapSqlInstance(sqlInstance);
+		const wrappedInstance = this.wrapSqlInstance(sqlInstance);
 		try {
 			logger.debug(`[PostgresInstrumentation] Postgres connection created successfully (${SpanUtils.getTraceInfo()})`);
 			SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: { connected: true } });
-			SpanUtils.endSpan(spanInfo.span, { code: import_src$25.SpanStatusCode.OK });
+			SpanUtils.endSpan(spanInfo.span, { code: import_src$26.SpanStatusCode.OK });
 		} catch (error) {
 			logger.error(`[PostgresInstrumentation] error adding span attributes:`, error);
 		}
 		return wrappedInstance;
 	}
-	_handleReplayConnect(originalFunction, args) {
+	handleReplayConnect(originalFunction, args) {
 		logger.debug(`[PostgresInstrumentation] Replaying Postgres connection`);
 		try {
 			const sqlInstance = originalFunction(...args);
-			return this._wrapSqlInstance(sqlInstance);
+			return this.wrapSqlInstance(sqlInstance);
 		} catch (error) {
 			logger.debug(`[PostgresInstrumentation] Postgres connection error in replay: ${error.message}`);
 			throw error;
 		}
 	}
+};
+
+//#endregion
+//#region src/instrumentation/libraries/postgres/Instrumentation.ts
+var import_src$25 = /* @__PURE__ */ __toESM(require_src$7(), 1);
+var PostgresInstrumentation = class extends TdInstrumentationBase {
+	constructor(config = {}) {
+		super("postgres", config);
+		this.INSTRUMENTATION_NAME = "PostgresInstrumentation";
+		this.mode = config.mode || TuskDriftMode.DISABLED;
+		this.tuskDrift = TuskDriftCore.getInstance();
+		this.connectionHandler = new ConnectionHandler(this.mode, this.INSTRUMENTATION_NAME, () => this.tuskDrift.isAppReady(), (sqlInstance) => this._wrapSqlInstance(sqlInstance));
+	}
+	init() {
+		return [new TdInstrumentationNodeModule({
+			name: "postgres",
+			supportedVersions: ["3.*"],
+			patch: (moduleExports) => this._patchPostgresModule(moduleExports)
+		})];
+	}
+	_patchPostgresModule(postgresModule) {
+		logger.debug(`[PostgresInstrumentation] Patching Postgres module in ${this.mode} mode`);
+		if (this.isModulePatched(postgresModule)) {
+			logger.debug(`[PostgresInstrumentation] Postgres module already patched, skipping`);
+			return postgresModule;
+		}
+		const self = this;
+		if (isEsm(postgresModule)) {
+			logger.debug(`[PostgresInstrumentation] Wrapping ESM default export`);
+			this._wrap(postgresModule, "default", (originalFunction) => {
+				return function(...args) {
+					return self._handlePostgresConnection(originalFunction, args);
+				};
+			});
+		} else {
+			logger.debug(`[PostgresInstrumentation] Module is a function (CJS style)`);
+			const originalFunction = postgresModule;
+			const wrappedFunction = function(...args) {
+				logger.debug(`[PostgresInstrumentation] Wrapped postgres() (CJS) called with args:`, args);
+				return self._handlePostgresConnection(originalFunction, args);
+			};
+			Object.setPrototypeOf(wrappedFunction, Object.getPrototypeOf(originalFunction));
+			Object.defineProperty(wrappedFunction, "name", { value: originalFunction.name });
+			for (const key in originalFunction) if (originalFunction.hasOwnProperty(key)) wrappedFunction[key] = originalFunction[key];
+			Object.getOwnPropertyNames(originalFunction).forEach((key) => {
+				if (key !== "prototype" && key !== "length" && key !== "name") {
+					const descriptor = Object.getOwnPropertyDescriptor(originalFunction, key);
+					if (descriptor) Object.defineProperty(wrappedFunction, key, descriptor);
+				}
+			});
+			postgresModule = wrappedFunction;
+		}
+		if (postgresModule.sql && typeof postgresModule.sql === "function") {
+			this._wrap(postgresModule, "sql", this._getSqlPatchFn());
+			logger.debug(`[PostgresInstrumentation] Wrapped sql function`);
+		}
+		this.markModuleAsPatched(postgresModule);
+		logger.debug(`[PostgresInstrumentation] Postgres module patching complete`);
+		return postgresModule;
+	}
+	_handlePostgresConnection(originalFunction, args) {
+		return this.connectionHandler.handlePostgresConnection(originalFunction, args);
+	}
 	_wrapSqlInstance(sqlInstance) {
 		if (!sqlInstance || typeof sqlInstance !== "function") return sqlInstance;
 		const self = this;
@@ -12373,11 +12495,34 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 			logger.debug(`[PostgresInstrumentation] Wrapped unsafe method on sql instance`);
 		}
 		if (typeof originalSql.begin === "function") {
-			wrappedSql.begin = self._wrapBeginMethod(originalSql);
-			logger.debug(`[PostgresInstrumentation] Wrapped begin method on sql instance`);
+			const wrappedBegin = self._wrapBeginMethod(originalSql);
+			originalSql.begin = wrappedBegin;
+			wrappedSql.begin = wrappedBegin;
+		}
+		if (typeof originalSql.file === "function") {
+			wrappedSql.file = self._wrapFileMethod(originalSql);
+			logger.debug(`[PostgresInstrumentation] Wrapped file method on sql instance`);
+		}
+		if (typeof originalSql.reserve === "function") {
+			wrappedSql.reserve = self._wrapReserveMethod(originalSql);
+			logger.debug(`[PostgresInstrumentation] Wrapped reserve method on sql instance`);
+		}
+		if (typeof originalSql.listen === "function") {
+			wrappedSql.listen = self._wrapListenMethod(originalSql);
+			logger.debug(`[PostgresInstrumentation] Wrapped listen method on sql instance`);
+		}
+		if (typeof originalSql.notify === "function") {
+			wrappedSql.notify = self._wrapNotifyMethod(wrappedSql);
+			logger.debug(`[PostgresInstrumentation] Wrapped notify method on sql instance`);
 		}
 		return wrappedSql;
 	}
+	_wrapNotifyMethod(wrappedSqlInstance) {
+		return async function notify(channel, payload) {
+			logger.debug(`[PostgresInstrumentation] notify() called for channel ${channel}`);
+			return wrappedSqlInstance`select pg_notify(${channel}, ${String(payload)})`;
+		};
+	}
 	_wrapUnsafeMethod(sqlInstance) {
 		const self = this;
 		const originalUnsafe = sqlInstance.unsafe;
@@ -12394,6 +12539,175 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 			return self._handleBeginTransaction(sqlInstance, originalBegin, options, transactionCallback);
 		};
 	}
+	_wrapFileMethod(sqlInstance) {
+		const self = this;
+		const originalFile = sqlInstance.file;
+		return function file(path$5, parameters, queryOptions) {
+			return self._handleFileQuery(sqlInstance, originalFile, path$5, parameters, queryOptions);
+		};
+	}
+	_wrapReserveMethod(sqlInstance) {
+		const self = this;
+		const originalReserve = sqlInstance.reserve;
+		return async function reserve() {
+			if (self.mode === TuskDriftMode.REPLAY) {
+				logger.debug(`[PostgresInstrumentation] REPLAY mode: Creating mock reserved connection without TCP`);
+				const mockReservedSql = self._wrapSqlInstance(sqlInstance);
+				if (typeof mockReservedSql === "function") mockReservedSql.release = function() {
+					logger.debug(`[PostgresInstrumentation] Mock reserved connection released`);
+				};
+				return mockReservedSql;
+			}
+			const reservedSql = await originalReserve.call(sqlInstance);
+			const wrappedReservedSql = self._wrapSqlInstance(reservedSql);
+			logger.debug(`[PostgresInstrumentation] Reserved connection obtained and wrapped`);
+			return wrappedReservedSql;
+		};
+	}
+	_wrapListenMethod(sqlInstance) {
+		const self = this;
+		const originalListen = sqlInstance.listen;
+		return async function listen(channelName, callback, onlisten) {
+			return self._handleListenMethod(sqlInstance, originalListen, channelName, callback, onlisten);
+		};
+	}
+	async _handleListenMethod(sqlInstance, originalListen, channelName, callback, onlisten) {
+		const inputValue = {
+			operation: "listen",
+			channel: channelName
+		};
+		if (this.mode === TuskDriftMode.REPLAY) return this._handleReplayListen(channelName, callback, onlisten, inputValue);
+		else if (this.mode === TuskDriftMode.RECORD) return this._handleRecordListen(sqlInstance, originalListen, channelName, callback, onlisten, inputValue);
+		else return originalListen.call(sqlInstance, channelName, callback, onlisten);
+	}
+	async _handleRecordListen(sqlInstance, originalListen, channelName, callback, onlisten, inputValue) {
+		const receivedPayloads = [];
+		const wrappedCallback = (payload) => {
+			logger.debug(`[PostgresInstrumentation] RECORD: Captured notification payload on channel ${channelName}: ${payload}`);
+			receivedPayloads.push(payload);
+			callback(payload);
+		};
+		return handleRecordMode({
+			originalFunctionCall: () => originalListen.call(sqlInstance, channelName, callback, onlisten),
+			recordModeHandler: ({ isPreAppStart }) => {
+				return SpanUtils.createAndExecuteSpan(this.mode, () => originalListen.call(sqlInstance, channelName, callback, onlisten), {
+					name: "postgres.listen",
+					kind: import_src$25.SpanKind.CLIENT,
+					submodule: "listen",
+					packageType: PackageType.PG,
+					packageName: "postgres",
+					instrumentationName: this.INSTRUMENTATION_NAME,
+					inputValue,
+					isPreAppStart
+				}, async (spanInfo) => {
+					try {
+						const result = await originalListen.call(sqlInstance, channelName, wrappedCallback, onlisten);
+						try {
+							SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: {
+								channel: channelName,
+								state: result.state
+							} });
+						} catch (error) {
+							logger.error(`[PostgresInstrumentation] error adding span attributes:`, error);
+						}
+						const originalUnlisten = result.unlisten;
+						const wrappedUnlisten = async () => {
+							logger.debug(`[PostgresInstrumentation] RECORD: Unlisten called, captured ${receivedPayloads.length} payloads`);
+							try {
+								SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: {
+									channel: channelName,
+									state: result.state,
+									payloads: receivedPayloads
+								} });
+								SpanUtils.endSpan(spanInfo.span, { code: import_src$25.SpanStatusCode.OK });
+							} catch (error) {
+								logger.error(`[PostgresInstrumentation] error adding span attributes:`, error);
+							}
+							return originalUnlisten();
+						};
+						return {
+							state: result.state,
+							unlisten: wrappedUnlisten
+						};
+					} catch (error) {
+						logger.error(`[PostgresInstrumentation] RECORD listen error: ${error.message}`);
+						try {
+							SpanUtils.endSpan(spanInfo.span, {
+								code: import_src$25.SpanStatusCode.ERROR,
+								message: error.message
+							});
+						} catch (error$1) {
+							logger.error(`[PostgresInstrumentation] error ending span:`, error$1);
+						}
+						throw error;
+					}
+				});
+			},
+			spanKind: import_src$25.SpanKind.CLIENT
+		});
+	}
+	async _handleReplayListen(channelName, callback, onlisten, inputValue) {
+		logger.debug(`[PostgresInstrumentation] REPLAY: Mocking listen for channel ${channelName} without TCP`);
+		const stackTrace = captureStackTrace(["PostgresInstrumentation"]);
+		return handleReplayMode({
+			noOpRequestHandler: () => Promise.resolve({
+				state: { state: "I" },
+				unlisten: async () => {}
+			}),
+			isServerRequest: false,
+			replayModeHandler: () => {
+				return SpanUtils.createAndExecuteSpan(this.mode, () => Promise.resolve({
+					state: { state: "I" },
+					unlisten: async () => {}
+				}), {
+					name: "postgres.listen",
+					kind: import_src$25.SpanKind.CLIENT,
+					submodule: "listen",
+					packageType: PackageType.PG,
+					packageName: "postgres",
+					instrumentationName: this.INSTRUMENTATION_NAME,
+					inputValue,
+					isPreAppStart: this.tuskDrift.isAppReady() ? false : true
+				}, async (spanInfo) => {
+					try {
+						const mockData = await this._findMockData({
+							spanInfo,
+							name: "postgres.listen",
+							inputValue,
+							submoduleName: "listen",
+							stackTrace
+						});
+						if (!mockData) {
+							logger.warn(`[PostgresInstrumentation] No mock data found for listen channel: ${channelName}`);
+							throw new Error(`No mock data found for listen channel: ${channelName}`);
+						}
+						logger.debug(`[PostgresInstrumentation] Found mock data for listen: ${JSON.stringify(mockData)}`);
+						const recordedPayloads = mockData.result?.payloads || [];
+						const recordedState = mockData.result?.state || { state: "I" };
+						if (onlisten) onlisten();
+						for (const payload of recordedPayloads) {
+							logger.debug(`[PostgresInstrumentation] REPLAY: Invoking callback with recorded payload: ${payload}`);
+							callback(payload);
+						}
+						SpanUtils.endSpan(spanInfo.span, { code: import_src$25.SpanStatusCode.OK });
+						return {
+							state: recordedState,
+							unlisten: async () => {
+								logger.debug(`[PostgresInstrumentation] REPLAY: Mock unlisten called`);
+							}
+						};
+					} catch (error) {
+						logger.error(`[PostgresInstrumentation] REPLAY listen error: ${error.message}`);
+						SpanUtils.endSpan(spanInfo.span, {
+							code: import_src$25.SpanStatusCode.ERROR,
+							message: error.message
+						});
+						throw error;
+					}
+				});
+			}
+		});
+	}
 	_getSqlPatchFn() {
 		const self = this;
 		return (originalSql) => {
@@ -12406,93 +12720,19 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 		if (!strings || !Array.isArray(strings.raw)) return originalSql.call(this, strings, ...values);
 		const creationContext = import_src$25.context.active();
 		const query = originalSql.call(this, strings, ...values);
+		const inputValue = {
+			query: reconstructQueryString(strings, values).trim(),
+			parameters: values
+		};
 		const originalThen = query.then.bind(query);
-		const self = this;
-		query.then = function(onFulfilled, onRejected) {
-			let queryString = "";
-			for (let i = 0; i < strings.length; i++) {
-				queryString += strings[i];
-				if (i < values.length) queryString += `$${i + 1}`;
-			}
-			const inputValue = {
-				query: queryString.trim(),
-				parameters: values
-			};
-			return import_src$25.context.with(creationContext, () => {
-				if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
-					originalFunctionCall: () => originalThen(onFulfilled, onRejected),
-					recordModeHandler: ({ isPreAppStart }) => {
-						return SpanUtils.createAndExecuteSpan(self.mode, () => originalThen(onFulfilled, onRejected), {
-							name: "postgres.query",
-							kind: import_src$25.SpanKind.CLIENT,
-							submodule: "query",
-							packageType: PackageType.PG,
-							instrumentationName: self.INSTRUMENTATION_NAME,
-							packageName: "postgres",
-							inputValue,
-							isPreAppStart
-						}, (spanInfo) => {
-							const wrappedOnFulfilled = (result) => {
-								try {
-									logger.debug(`[PostgresInstrumentation] Postgres query completed successfully`, result);
-									self._addOutputAttributesToSpan(spanInfo, result);
-									SpanUtils.endSpan(spanInfo.span, { code: import_src$25.SpanStatusCode.OK });
-								} catch (error) {
-									logger.error(`[PostgresInstrumentation] error processing query response:`, error);
-								}
-								return onFulfilled ? onFulfilled(result) : result;
-							};
-							const wrappedOnRejected = (error) => {
-								try {
-									logger.debug(`[PostgresInstrumentation] Postgres query error`, error);
-									SpanUtils.endSpan(spanInfo.span, {
-										code: import_src$25.SpanStatusCode.ERROR,
-										message: error.message
-									});
-								} catch (spanError) {
-									logger.error(`[PostgresInstrumentation] error ending span:`, spanError);
-								}
-								if (onRejected) return onRejected(error);
-								throw error;
-							};
-							return originalThen(wrappedOnFulfilled, wrappedOnRejected);
-						});
-					},
-					spanKind: import_src$25.SpanKind.CLIENT
-				});
-				else if (self.mode === TuskDriftMode.REPLAY) {
-					const stackTrace = captureStackTrace(["PostgresInstrumentation"]);
-					return handleReplayMode({
-						noOpRequestHandler: () => Promise.resolve(Object.assign([], {
-							count: 0,
-							command: null
-						})),
-						isServerRequest: false,
-						replayModeHandler: () => {
-							return SpanUtils.createAndExecuteSpan(self.mode, () => originalThen(onFulfilled, onRejected), {
-								name: "postgres.query",
-								kind: import_src$25.SpanKind.CLIENT,
-								submodule: "query",
-								packageType: PackageType.PG,
-								packageName: "postgres",
-								instrumentationName: self.INSTRUMENTATION_NAME,
-								inputValue,
-								isPreAppStart: false
-							}, async (spanInfo) => {
-								const mockedResult = await self.handleReplaySqlQuery({
-									inputValue,
-									spanInfo,
-									submodule: "query",
-									name: "postgres.query",
-									stackTrace
-								});
-								return onFulfilled ? onFulfilled(mockedResult) : mockedResult;
-							});
-						}
-					});
-				} else return originalThen(onFulfilled, onRejected);
-			});
-		};
+		this._wrapThenMethod(query, originalThen, inputValue, creationContext, {
+			name: "postgres.query",
+			submodule: "query",
+			operationType: "sql"
+		});
+		this._wrapExecuteMethod(query);
+		this._wrapCursorMethod(query, inputValue, creationContext);
+		this._wrapForEachMethod(query, inputValue, creationContext);
 		return query;
 	}
 	_handleUnsafeQuery(sqlInstance, originalUnsafe, query, parameters, queryOptions) {
@@ -12503,21 +12743,46 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 		})();
 		const creationContext = import_src$25.context.active();
 		const originalThen = unsafeQuery.then.bind(unsafeQuery);
-		const self = this;
 		const inputValue = {
 			query: query.trim(),
 			parameters: parameters || [],
 			options: queryOptions
 		};
-		unsafeQuery.then = function(onFulfilled, onRejected) {
+		this._wrapThenMethod(unsafeQuery, originalThen, inputValue, creationContext, {
+			name: "postgres.unsafe",
+			submodule: "unsafe",
+			operationType: "unsafe"
+		});
+		this._wrapExecuteMethod(unsafeQuery);
+		this._wrapCursorMethod(unsafeQuery, inputValue, creationContext);
+		this._wrapForEachMethod(unsafeQuery, inputValue, creationContext);
+		return unsafeQuery;
+	}
+	_handleFileQuery(sqlInstance, originalFile, path$5, parameters, queryOptions) {
+		const fileQuery = (() => {
+			if (queryOptions !== void 0) return originalFile.call(sqlInstance, path$5, parameters, queryOptions);
+			else if (parameters !== void 0) return originalFile.call(sqlInstance, path$5, parameters);
+			else return originalFile.call(sqlInstance, path$5);
+		})();
+		const creationContext = import_src$25.context.active();
+		const originalThen = fileQuery.then.bind(fileQuery);
+		const self = this;
+		const inputValue = {
+			query: path$5,
+			parameters: parameters || [],
+			options: queryOptions
+		};
+		fileQuery.then = function(onFulfilled, onRejected) {
+			if (fileQuery._tuskRecorded) return originalThen(onFulfilled, onRejected);
+			fileQuery._tuskRecorded = true;
 			return import_src$25.context.with(creationContext, () => {
 				if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalThen(onFulfilled, onRejected),
 					recordModeHandler: ({ isPreAppStart }) => {
 						return SpanUtils.createAndExecuteSpan(self.mode, () => originalThen(onFulfilled, onRejected), {
-							name: "postgres.unsafe",
+							name: "postgres.file",
 							kind: import_src$25.SpanKind.CLIENT,
-							submodule: "unsafe",
+							submodule: "file",
 							packageType: PackageType.PG,
 							packageName: "postgres",
 							instrumentationName: self.INSTRUMENTATION_NAME,
@@ -12526,17 +12791,17 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 						}, (spanInfo) => {
 							const wrappedOnFulfilled = (result) => {
 								try {
-									logger.debug(`[PostgresInstrumentation] Postgres unsafe query completed successfully (${SpanUtils.getTraceInfo()})`);
-									self._addOutputAttributesToSpan(spanInfo, result);
+									logger.debug(`[PostgresInstrumentation] Postgres file query completed successfully (${SpanUtils.getTraceInfo()})`);
+									addOutputAttributesToSpan(spanInfo, result);
 									SpanUtils.endSpan(spanInfo.span, { code: import_src$25.SpanStatusCode.OK });
 								} catch (error) {
-									logger.error(`[PostgresInstrumentation] error processing unsafe query response:`, error);
+									logger.error(`[PostgresInstrumentation] error processing file query response:`, error);
 								}
 								return onFulfilled ? onFulfilled(result) : result;
 							};
 							const wrappedOnRejected = (error) => {
 								try {
-									logger.debug(`[PostgresInstrumentation] Postgres unsafe query error: ${error.message}`);
+									logger.debug(`[PostgresInstrumentation] Postgres file query error: ${error.message}`);
 									SpanUtils.endSpan(spanInfo.span, {
 										code: import_src$25.SpanStatusCode.ERROR,
 										message: error.message
@@ -12562,22 +12827,24 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 						isServerRequest: false,
 						replayModeHandler: () => {
 							return SpanUtils.createAndExecuteSpan(self.mode, () => originalThen(onFulfilled, onRejected), {
-								name: "postgres.unsafe",
+								name: "postgres.file",
 								kind: import_src$25.SpanKind.CLIENT,
-								submodule: "unsafe",
+								submodule: "file",
 								packageType: PackageType.PG,
 								packageName: "postgres",
 								instrumentationName: self.INSTRUMENTATION_NAME,
 								inputValue,
-								isPreAppStart: false
+								isPreAppStart: self.tuskDrift.isAppReady() ? false : true
 							}, async (spanInfo) => {
-								const mockedResult = await self.handleReplayUnsafeQuery({
+								const mockedResult = await self._handleReplayQueryOperation({
 									inputValue,
 									spanInfo,
-									submodule: "unsafe",
-									name: "postgres.unsafe",
-									stackTrace
+									submodule: "file",
+									name: "postgres.file",
+									stackTrace,
+									operationType: "file"
 								});
+								if (!mockedResult) throw new Error(`No mock data found for Postgres file query: ${inputValue.query}`);
 								return onFulfilled ? onFulfilled(mockedResult) : mockedResult;
 							});
 						}
@@ -12585,16 +12852,45 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 				} else return originalThen(onFulfilled, onRejected);
 			});
 		};
-		return unsafeQuery;
+		const originalExecute = fileQuery.execute ? fileQuery.execute.bind(fileQuery) : void 0;
+		if (originalExecute) fileQuery.execute = function() {
+			if (self.mode === TuskDriftMode.REPLAY) return this;
+			else return originalExecute.call(this);
+		};
+		return fileQuery;
+	}
+	/**
+	* Wraps a transaction callback to ensure the inner SQL instance is instrumented.
+	* This is necessary because postgres.js creates a new SQL instance inside begin()
+	* that would otherwise bypass instrumentation.
+	*/
+	_wrapTransactionCallback(transactionCallback) {
+		const self = this;
+		return (transactionSql) => {
+			const wrappedSql = self._wrapSqlInstance(transactionSql);
+			if (typeof transactionSql.savepoint === "function") {
+				const originalSavepoint = transactionSql.savepoint;
+				wrappedSql.savepoint = function(nameOrFn, fn) {
+					const savepointCallback = typeof nameOrFn === "function" ? nameOrFn : fn;
+					const savepointName = typeof nameOrFn === "string" ? nameOrFn : void 0;
+					const wrappedSavepointCallback = self._wrapTransactionCallback(savepointCallback);
+					if (savepointName) return originalSavepoint.call(transactionSql, savepointName, wrappedSavepointCallback);
+					else return originalSavepoint.call(transactionSql, wrappedSavepointCallback);
+				};
+			}
+			if (typeof transactionSql.prepare === "function") wrappedSql.prepare = transactionSql.prepare.bind(transactionSql);
+			return transactionCallback(wrappedSql);
+		};
 	}
 	_handleBeginTransaction(sqlInstance, originalBegin, options, transactionCallback) {
 		const inputValue = {
 			query: "BEGIN",
 			options: options ? { transactionOptions: options } : void 0
 		};
+		const wrappedCallback = transactionCallback ? this._wrapTransactionCallback(transactionCallback) : void 0;
 		const executeBegin = () => {
-			if (options && transactionCallback) return originalBegin.call(sqlInstance, options, transactionCallback);
-			else if (transactionCallback) return originalBegin.call(sqlInstance, transactionCallback);
+			if (options && wrappedCallback) return originalBegin.call(sqlInstance, options, wrappedCallback);
+			else if (wrappedCallback) return originalBegin.call(sqlInstance, wrappedCallback);
 			else return originalBegin.call(sqlInstance, options || void 0);
 		};
 		if (this.mode === TuskDriftMode.REPLAY) {
@@ -12611,9 +12907,9 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 						packageName: "postgres",
 						instrumentationName: this.INSTRUMENTATION_NAME,
 						inputValue,
-						isPreAppStart: false
+						isPreAppStart: this.tuskDrift.isAppReady() ? false : true
 					}, (spanInfo) => {
-						return this._handleReplayBeginTransaction(spanInfo, options, stackTrace);
+						return this._handleReplayBeginTransaction(spanInfo, options, stackTrace, wrappedCallback);
 					});
 				}
 			});
@@ -12638,151 +12934,672 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 		else return executeBegin();
 	}
 	_handleRecordBeginTransaction(spanInfo, executeBegin) {
-		const promise = executeBegin();
-		promise.finally(() => {
-			promise.then((result) => {
-				logger.debug(`[PostgresInstrumentation] Postgres transaction completed successfully (${SpanUtils.getTraceInfo()})`);
-				try {
-					SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: {
-						status: "committed",
-						result
-					} });
-					SpanUtils.endSpan(spanInfo.span, { code: import_src$25.SpanStatusCode.OK });
-				} catch (error) {
-					logger.error(`[PostgresInstrumentation] error processing transaction response:`, error);
+		return executeBegin().then((result) => {
+			logger.debug(`[PostgresInstrumentation] Postgres transaction completed successfully (${SpanUtils.getTraceInfo()})`);
+			try {
+				SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: {
+					status: "committed",
+					result
+				} });
+				SpanUtils.endSpan(spanInfo.span, { code: import_src$25.SpanStatusCode.OK });
+			} catch (error) {
+				logger.error(`[PostgresInstrumentation] error processing transaction response:`, error);
+			}
+			return result;
+		}).catch((error) => {
+			logger.debug(`[PostgresInstrumentation] Postgres transaction error (rolled back): ${error.message} (${SpanUtils.getTraceInfo()})`);
+			try {
+				SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: {
+					status: "rolled_back",
+					error: error.message
+				} });
+				SpanUtils.endSpan(spanInfo.span, {
+					code: import_src$25.SpanStatusCode.ERROR,
+					message: error.message
+				});
+			} catch (spanError) {
+				logger.error(`[PostgresInstrumentation] error ending span:`, spanError);
+			}
+			throw error;
+		});
+	}
+	async _handleReplayBeginTransaction(spanInfo, options, stackTrace, wrappedCallback) {
+		logger.debug(`[PostgresInstrumentation] Replaying Postgres transaction`);
+		const transactionInputValue = {
+			query: "BEGIN",
+			options: options ? { transactionOptions: options } : void 0
+		};
+		const mockData = await this._findMockData({
+			spanInfo,
+			name: "postgres.begin",
+			inputValue: transactionInputValue,
+			submoduleName: "transaction",
+			stackTrace
+		});
+		if (!mockData) {
+			logger.warn(`[PostgresInstrumentation] No mock data found for transaction BEGIN`);
+			throw new Error(`[PostgresInstrumentation] No matching mock found for transaction BEGIN`);
+		}
+		logger.debug(`[PostgresInstrumentation] Found mock data for transaction: ${JSON.stringify(mockData)}`);
+		const transactionResult = mockData.result;
+		const wasCommitted = transactionResult && typeof transactionResult === "object" && "status" in transactionResult && transactionResult.status === "committed";
+		if (!wrappedCallback) if (wasCommitted) return transactionResult.result;
+		else {
+			const errorMessage = transactionResult && typeof transactionResult === "object" && "error" in transactionResult && transactionResult.error ? transactionResult.error : "Transaction rolled back";
+			throw new Error(errorMessage);
+		}
+		try {
+			const result = await wrappedCallback(this._createMockTransactionSql());
+			logger.debug(`[PostgresInstrumentation] Replay transaction callback completed with result`);
+			return result;
+		} catch (error) {
+			if (!wasCommitted) throw error;
+			logger.error(`[PostgresInstrumentation] Unexpected error during transaction replay: ${error.message}`);
+			throw error;
+		}
+	}
+	/**
+	* Creates a minimal mock SQL instance for transaction replay.
+	* _wrapSqlInstance will wrap this and handle all the actual REPLAY logic.
+	* The mock just needs to return objects with .then() methods that can be wrapped.
+	*/
+	_createMockTransactionSql() {
+		const self = this;
+		const createThenable = () => ({ then: (onFulfilled, onRejected) => Promise.resolve([]).then(onFulfilled, onRejected) });
+		const mockSql = function() {
+			return createThenable();
+		};
+		mockSql.unsafe = function() {
+			return createThenable();
+		};
+		mockSql.savepoint = function(nameOrFn, fn) {
+			const callback = typeof nameOrFn === "function" ? nameOrFn : fn;
+			const nestedMockSql = self._createMockTransactionSql();
+			return Promise.resolve(callback(nestedMockSql));
+		};
+		return mockSql;
+	}
+	/**
+	* Generic helper to find mock data for replay operations.
+	* Consolidates the common findMockResponseAsync pattern used across multiple handlers.
+	*/
+	async _findMockData({ spanInfo, name, inputValue, submoduleName, stackTrace }) {
+		return findMockResponseAsync({
+			mockRequestData: {
+				traceId: spanInfo.traceId,
+				spanId: spanInfo.spanId,
+				name,
+				inputValue: createMockInputValue(inputValue),
+				packageName: "postgres",
+				instrumentationName: this.INSTRUMENTATION_NAME,
+				submoduleName,
+				kind: import_src$25.SpanKind.CLIENT,
+				stackTrace
+			},
+			tuskDrift: this.tuskDrift
+		});
+	}
+	/**
+	* Helper to end a cursor span with collected rows.
+	* Consolidates common span ending logic used in cursor and forEach operations.
+	*/
+	_endCursorSpan(spanInfo, allRows, result, operation = "Cursor") {
+		addOutputAttributesToSpan(spanInfo, Object.assign(allRows, {
+			count: allRows.length,
+			columns: result?.columns,
+			state: result?.state,
+			statement: result?.statement
+		}));
+		SpanUtils.endSpan(spanInfo.span, { code: import_src$25.SpanStatusCode.OK });
+		logger.debug(`[PostgresInstrumentation] ${operation} completed, recorded ${allRows.length} rows`);
+	}
+	/**
+	* Generic helper to handle replay for query operations (sql, unsafe, file).
+	* Consolidates common logic for finding mock data and processing results.
+	*/
+	async _handleReplayQueryOperation({ inputValue, spanInfo, submodule, name, stackTrace, operationType }) {
+		logger.debug(`[PostgresInstrumentation] Replaying Postgres ${operationType} query`);
+		const mockData = await this._findMockData({
+			spanInfo,
+			name,
+			inputValue,
+			submoduleName: submodule,
+			stackTrace
+		});
+		if (!mockData) {
+			const errorMsg = `[PostgresInstrumentation] No matching mock found for Postgres ${operationType} query: ${inputValue.query || "UNKNOWN_QUERY"}`;
+			logger.warn(errorMsg);
+			throw new Error(errorMsg);
+		}
+		logger.debug(`[PostgresInstrumentation] Found mock data for Postgres ${operationType} query: ${JSON.stringify(mockData)}`);
+		const processedResult = convertPostgresTypes(mockData.result);
+		logger.debug(`[PostgresInstrumentation] ${operationType} query processed result: ${JSON.stringify(processedResult)}`);
+		return processedResult;
+	}
+	_handleCursorCallbackRecord({ originalCursor, rows, inputValue, creationContext, userCallback }) {
+		const self = this;
+		return import_src$25.context.with(creationContext, () => {
+			return handleRecordMode({
+				originalFunctionCall: () => originalCursor(rows, userCallback),
+				recordModeHandler: ({ isPreAppStart }) => {
+					return SpanUtils.createAndExecuteSpan(self.mode, () => originalCursor(rows, userCallback), {
+						name: "postgres.cursor",
+						kind: import_src$25.SpanKind.CLIENT,
+						submodule: "cursor",
+						packageType: PackageType.PG,
+						packageName: "postgres",
+						instrumentationName: self.INSTRUMENTATION_NAME,
+						inputValue,
+						isPreAppStart
+					}, (spanInfo) => {
+						return self._executeAndRecordCursorCallback({
+							originalCursor,
+							rows,
+							userCallback,
+							spanInfo
+						});
+					});
+				},
+				spanKind: import_src$25.SpanKind.CLIENT
+			});
+		});
+	}
+	async _executeAndRecordCursorCallback({ originalCursor, rows, userCallback, spanInfo }) {
+		const allRows = [];
+		try {
+			const wrappedCallback = (batchRows) => {
+				allRows.push(...batchRows);
+				return userCallback(batchRows);
+			};
+			const cursorPromise = originalCursor(rows, wrappedCallback);
+			cursorPromise._tuskRecorded = true;
+			const result = await cursorPromise;
+			if (spanInfo) try {
+				this._endCursorSpan(spanInfo, allRows, result, "Cursor callback");
+			} catch (error) {
+				logger.error(`[PostgresInstrumentation] error ending cursor span:`, error);
+			}
+		} catch (error) {
+			logger.debug(`[PostgresInstrumentation] Cursor callback error: ${error.message}`);
+			if (spanInfo) try {
+				SpanUtils.endSpan(spanInfo.span, {
+					code: import_src$25.SpanStatusCode.ERROR,
+					message: error.message
+				});
+			} catch (error$1) {
+				logger.error(`[PostgresInstrumentation] error ending cursor span:`, error$1);
+			}
+			throw error;
+		}
+	}
+	_handleCursorCallbackReplay({ inputValue, creationContext, cursorBatchSize, userCallback }) {
+		const self = this;
+		const stackTrace = captureStackTrace(["PostgresInstrumentation"]);
+		return import_src$25.context.with(creationContext, () => {
+			return handleReplayMode({
+				noOpRequestHandler: () => Promise.resolve(),
+				isServerRequest: false,
+				replayModeHandler: () => {
+					return SpanUtils.createAndExecuteSpan(self.mode, () => Promise.resolve(), {
+						name: "postgres.cursor",
+						kind: import_src$25.SpanKind.CLIENT,
+						submodule: "cursor",
+						packageType: PackageType.PG,
+						packageName: "postgres",
+						instrumentationName: self.INSTRUMENTATION_NAME,
+						inputValue,
+						isPreAppStart: self.tuskDrift.isAppReady() ? false : true
+					}, async (spanInfo) => {
+						try {
+							const mockData = await this._findMockData({
+								spanInfo,
+								name: "postgres.cursor",
+								inputValue,
+								submoduleName: "cursor",
+								stackTrace
+							});
+							if (!mockData) throw new Error(`[PostgresInstrumentation] No matching mock found for cursor query: ${inputValue.query}`);
+							logger.debug(`[PostgresInstrumentation] Found mock data for cursor query: ${JSON.stringify(mockData)}`);
+							const processedResult = convertPostgresTypes(mockData.result);
+							const mockedData = Array.isArray(processedResult) ? processedResult : [];
+							for (let i = 0; i < mockedData.length; i += cursorBatchSize) {
+								const batch = mockedData.slice(i, i + cursorBatchSize);
+								logger.debug(`[PostgresInstrumentation] Cursor replay calling callback with batch of ${batch.length} rows`);
+								await userCallback(batch);
+							}
+							SpanUtils.endSpan(spanInfo.span, { code: import_src$25.SpanStatusCode.OK });
+						} catch (error) {
+							logger.debug(`[PostgresInstrumentation] Cursor callback replay error: ${error.message}`);
+							SpanUtils.endSpan(spanInfo.span, {
+								code: import_src$25.SpanStatusCode.ERROR,
+								message: error.message
+							});
+							throw error;
+						}
+					});
 				}
-			}).catch((error) => {
-				logger.debug(`[PostgresInstrumentation] Postgres transaction error (rolled back): ${error.message} (${SpanUtils.getTraceInfo()})`);
-				try {
-					SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: {
-						status: "rolled_back",
-						error: error.message
-					} });
-					SpanUtils.endSpan(spanInfo.span, {
-						code: import_src$25.SpanStatusCode.ERROR,
-						message: error.message
+			});
+		});
+	}
+	_handleCursorRecord({ originalCursor, rows, inputValue, creationContext, queryObject }) {
+		const self = this;
+		return { [Symbol.asyncIterator]() {
+			const iterator = originalCursor(rows)[Symbol.asyncIterator]();
+			let allRows = [];
+			let result;
+			let spanInfo = null;
+			let spanStarted = false;
+			return {
+				async next() {
+					return import_src$25.context.with(creationContext, async () => {
+						if (!spanStarted) {
+							spanStarted = true;
+							let spanInputValue;
+							try {
+								spanInputValue = createSpanInputValue(inputValue);
+							} catch (error) {
+								logger.error(`[PostgresInstrumentation] error creating span input value:`, error);
+								spanInputValue = void 0;
+							}
+							spanInfo = SpanUtils.createSpan({
+								name: "postgres.cursor",
+								kind: import_src$25.SpanKind.CLIENT,
+								isPreAppStart: self.tuskDrift.isAppReady() ? false : true,
+								attributes: {
+									[TdSpanAttributes.NAME]: "postgres.cursor",
+									[TdSpanAttributes.PACKAGE_NAME]: "postgres",
+									[TdSpanAttributes.SUBMODULE_NAME]: "cursor",
+									[TdSpanAttributes.INSTRUMENTATION_NAME]: self.INSTRUMENTATION_NAME,
+									[TdSpanAttributes.PACKAGE_TYPE]: PackageType.PG,
+									[TdSpanAttributes.INPUT_VALUE]: spanInputValue,
+									[TdSpanAttributes.IS_PRE_APP_START]: self.tuskDrift.isAppReady() ? false : true
+								}
+							});
+							if (!spanInfo) logger.warn(`[PostgresInstrumentation] Failed to create cursor span in RECORD mode`);
+						}
+						try {
+							result = await iterator.next();
+							if (result.done) {
+								if (spanInfo) try {
+									self._endCursorSpan(spanInfo, allRows, queryObject, "Cursor");
+								} catch (error) {
+									logger.error(`[PostgresInstrumentation] error ending cursor span:`, error);
+								}
+								return {
+									done: true,
+									value: void 0
+								};
+							}
+							if (Array.isArray(result.value)) allRows.push(...result.value);
+							return {
+								done: false,
+								value: result.value
+							};
+						} catch (error) {
+							if (spanInfo) try {
+								SpanUtils.endSpan(spanInfo.span, {
+									code: import_src$25.SpanStatusCode.ERROR,
+									message: error.message
+								});
+							} catch (error$1) {
+								logger.error(`[PostgresInstrumentation] error ending cursor span:`, error$1);
+							}
+							throw error;
+						}
+					});
+				},
+				async return() {
+					if (spanInfo) try {
+						self._endCursorSpan(spanInfo, allRows, queryObject, "Cursor terminated early");
+					} catch (error) {
+						logger.error(`[PostgresInstrumentation] error ending cursor span:`, error);
+					}
+					if (iterator.return) await iterator.return();
+					return {
+						done: true,
+						value: void 0
+					};
+				}
+			};
+		} };
+	}
+	_handleCursorReplay({ inputValue, creationContext, cursorBatchSize }) {
+		const self = this;
+		const stackTrace = captureStackTrace(["PostgresInstrumentation"]);
+		return { [Symbol.asyncIterator]() {
+			let mockedData = null;
+			let currentIndex = 0;
+			let spanInfo = null;
+			let dataFetched = false;
+			return {
+				async next() {
+					return import_src$25.context.with(creationContext, async () => {
+						if (!dataFetched) {
+							dataFetched = true;
+							spanInfo = SpanUtils.createSpan({
+								name: "postgres.cursor",
+								kind: import_src$25.SpanKind.CLIENT,
+								isPreAppStart: self.tuskDrift.isAppReady() ? false : true,
+								attributes: {
+									[TdSpanAttributes.NAME]: "postgres.cursor",
+									[TdSpanAttributes.PACKAGE_NAME]: "postgres",
+									[TdSpanAttributes.SUBMODULE_NAME]: "cursor",
+									[TdSpanAttributes.INSTRUMENTATION_NAME]: self.INSTRUMENTATION_NAME,
+									[TdSpanAttributes.PACKAGE_TYPE]: PackageType.PG,
+									[TdSpanAttributes.INPUT_VALUE]: createSpanInputValue(inputValue),
+									[TdSpanAttributes.IS_PRE_APP_START]: self.tuskDrift.isAppReady() ? false : true
+								}
+							});
+							if (!spanInfo) throw new Error(`[PostgresInstrumentation] Failed to create cursor span in REPLAY mode`);
+							const mockData = await self._findMockData({
+								spanInfo,
+								name: "postgres.cursor",
+								inputValue,
+								submoduleName: "cursor",
+								stackTrace
+							});
+							if (!mockData) {
+								SpanUtils.endSpan(spanInfo.span, {
+									code: import_src$25.SpanStatusCode.ERROR,
+									message: "No mock data found"
+								});
+								throw new Error(`[PostgresInstrumentation] No matching mock found for cursor query: ${inputValue.query}`);
+							}
+							logger.debug(`[PostgresInstrumentation] Found mock data for cursor query: ${JSON.stringify(mockData)}`);
+							const processedResult = convertPostgresTypes(mockData.result);
+							mockedData = Array.isArray(processedResult) ? processedResult : [];
+						}
+						if (currentIndex >= mockedData.length) {
+							if (spanInfo) SpanUtils.endSpan(spanInfo.span, { code: import_src$25.SpanStatusCode.OK });
+							return {
+								done: true,
+								value: void 0
+							};
+						}
+						const batch = mockedData.slice(currentIndex, currentIndex + cursorBatchSize);
+						currentIndex += batch.length;
+						logger.debug(`[PostgresInstrumentation] Cursor replay returning batch of ${batch.length} rows`);
+						return {
+							done: false,
+							value: batch
+						};
+					});
+				},
+				async return() {
+					if (spanInfo) SpanUtils.endSpan(spanInfo.span, { code: import_src$25.SpanStatusCode.OK });
+					return {
+						done: true,
+						value: void 0
+					};
+				}
+			};
+		} };
+	}
+	_handleForEachRecord({ originalForEach, inputValue, creationContext, userCallback }) {
+		const self = this;
+		return import_src$25.context.with(creationContext, () => {
+			return handleRecordMode({
+				originalFunctionCall: () => originalForEach(userCallback),
+				recordModeHandler: ({ isPreAppStart }) => {
+					return SpanUtils.createAndExecuteSpan(self.mode, () => originalForEach(userCallback), {
+						name: "postgres.query",
+						kind: import_src$25.SpanKind.CLIENT,
+						submodule: "query",
+						packageType: PackageType.PG,
+						packageName: "postgres",
+						instrumentationName: self.INSTRUMENTATION_NAME,
+						inputValue,
+						isPreAppStart
+					}, async (spanInfo) => {
+						const allRows = [];
+						const wrappedCallback = (row, result) => {
+							allRows.push(row);
+							return userCallback(row, result);
+						};
+						try {
+							const result = await originalForEach(wrappedCallback);
+							try {
+								self._endCursorSpan(spanInfo, allRows, result, "forEach");
+							} catch (error) {
+								logger.error(`[PostgresInstrumentation] error ending cursor span:`, error);
+							}
+							return result;
+						} catch (error) {
+							try {
+								SpanUtils.endSpan(spanInfo.span, {
+									code: import_src$25.SpanStatusCode.ERROR,
+									message: error.message
+								});
+							} catch (error$1) {
+								logger.error(`[PostgresInstrumentation] error ending cursor span:`, error$1);
+							}
+							throw error;
+						}
+					});
+				},
+				spanKind: import_src$25.SpanKind.CLIENT
+			});
+		});
+	}
+	_handleForEachReplay({ inputValue, creationContext, userCallback }) {
+		const self = this;
+		const stackTrace = captureStackTrace(["PostgresInstrumentation"]);
+		return import_src$25.context.with(creationContext, () => {
+			return handleReplayMode({
+				noOpRequestHandler: () => Promise.resolve(Object.assign([], {
+					count: 0,
+					command: null
+				})),
+				isServerRequest: false,
+				replayModeHandler: () => {
+					return SpanUtils.createAndExecuteSpan(self.mode, () => Promise.resolve(Object.assign([], {
+						count: 0,
+						command: null
+					})), {
+						name: "postgres.query",
+						kind: import_src$25.SpanKind.CLIENT,
+						submodule: "query",
+						packageType: PackageType.PG,
+						packageName: "postgres",
+						instrumentationName: self.INSTRUMENTATION_NAME,
+						inputValue,
+						isPreAppStart: self.tuskDrift.isAppReady() ? false : true
+					}, async (spanInfo) => {
+						try {
+							const mockedResult = await self._handleReplayQueryOperation({
+								inputValue,
+								spanInfo,
+								submodule: "query",
+								name: "postgres.query",
+								stackTrace,
+								operationType: "forEach"
+							});
+							const mockedRows = Array.isArray(mockedResult) ? mockedResult : [];
+							logger.debug(`[PostgresInstrumentation] forEach replay: calling callback with ${mockedRows.length} mocked rows`);
+							for (const row of mockedRows) userCallback(row, mockedResult);
+							SpanUtils.endSpan(spanInfo.span, { code: import_src$25.SpanStatusCode.OK });
+							return Object.assign([], {
+								count: mockedRows.length,
+								command: null
+							});
+						} catch (error) {
+							logger.debug(`[PostgresInstrumentation] forEach replay error: ${error.message}`);
+							SpanUtils.endSpan(spanInfo.span, {
+								code: import_src$25.SpanStatusCode.ERROR,
+								message: error.message
+							});
+							throw error;
+						}
+					});
+				}
+			});
+		});
+	}
+	/**
+	* Wraps a query's .then() method to add instrumentation.
+	* This is reusable for both sql template literals and unsafe() queries.
+	*/
+	_wrapThenMethod(query, originalThen, inputValue, creationContext, spanConfig) {
+		const self = this;
+		query.then = function(onFulfilled, onRejected) {
+			if (query._forEachCalled) return originalThen(onFulfilled, onRejected);
+			if (query._tuskRecorded) return originalThen(onFulfilled, onRejected);
+			query._tuskRecorded = true;
+			return import_src$25.context.with(creationContext, () => {
+				if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
+					originalFunctionCall: () => originalThen(onFulfilled, onRejected),
+					recordModeHandler: ({ isPreAppStart }) => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalThen(onFulfilled, onRejected), {
+							name: spanConfig.name,
+							kind: import_src$25.SpanKind.CLIENT,
+							submodule: spanConfig.submodule,
+							packageType: PackageType.PG,
+							packageName: "postgres",
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart
+						}, (spanInfo) => {
+							const wrappedOnFulfilled = (result) => {
+								try {
+									logger.debug(`[PostgresInstrumentation] Postgres ${spanConfig.operationType} query completed successfully (${SpanUtils.getTraceInfo()})`);
+									addOutputAttributesToSpan(spanInfo, result);
+									SpanUtils.endSpan(spanInfo.span, { code: import_src$25.SpanStatusCode.OK });
+								} catch (error) {
+									logger.error(`[PostgresInstrumentation] error processing ${spanConfig.operationType} query response:`, error);
+								}
+								return onFulfilled ? onFulfilled(result) : result;
+							};
+							const wrappedOnRejected = (error) => {
+								try {
+									logger.debug(`[PostgresInstrumentation] Postgres ${spanConfig.operationType} query error: ${error.message}`);
+									SpanUtils.endSpan(spanInfo.span, {
+										code: import_src$25.SpanStatusCode.ERROR,
+										message: error.message
+									});
+								} catch (spanError) {
+									logger.error(`[PostgresInstrumentation] error ending span:`, spanError);
+								}
+								if (onRejected) return onRejected(error);
+								throw error;
+							};
+							return originalThen(wrappedOnFulfilled, wrappedOnRejected);
+						});
+					},
+					spanKind: import_src$25.SpanKind.CLIENT
+				});
+				else if (self.mode === TuskDriftMode.REPLAY) {
+					const stackTrace = captureStackTrace(["PostgresInstrumentation"]);
+					return handleReplayMode({
+						noOpRequestHandler: () => Promise.resolve(Object.assign([], {
+							count: 0,
+							command: null
+						})),
+						isServerRequest: false,
+						replayModeHandler: () => {
+							return SpanUtils.createAndExecuteSpan(self.mode, () => originalThen(onFulfilled, onRejected), {
+								name: spanConfig.name,
+								kind: import_src$25.SpanKind.CLIENT,
+								submodule: spanConfig.submodule,
+								packageType: PackageType.PG,
+								packageName: "postgres",
+								instrumentationName: self.INSTRUMENTATION_NAME,
+								inputValue,
+								isPreAppStart: self.tuskDrift.isAppReady() ? false : true
+							}, async (spanInfo) => {
+								const mockedResult = await self._handleReplayQueryOperation({
+									inputValue,
+									spanInfo,
+									submodule: spanConfig.submodule,
+									name: spanConfig.name,
+									stackTrace,
+									operationType: spanConfig.operationType
+								});
+								return onFulfilled ? onFulfilled(mockedResult) : mockedResult;
+							});
+						}
 					});
-				} catch (spanError) {
-					logger.error(`[PostgresInstrumentation] error ending span:`, spanError);
-				}
+				} else return originalThen(onFulfilled, onRejected);
 			});
-		});
-		return promise;
-	}
-	async _handleReplayBeginTransaction(spanInfo, options, stackTrace) {
-		logger.debug(`[PostgresInstrumentation] Replaying Postgres transaction`);
-		const mockData = await findMockResponseAsync({
-			mockRequestData: {
-				traceId: spanInfo.traceId,
-				spanId: spanInfo.spanId,
-				name: "postgres.begin",
-				inputValue: createMockInputValue({
-					query: "BEGIN",
-					options: options ? { transactionOptions: options } : void 0
-				}),
-				packageName: "postgres",
-				instrumentationName: this.INSTRUMENTATION_NAME,
-				submoduleName: "transaction",
-				kind: import_src$25.SpanKind.CLIENT,
-				stackTrace
-			},
-			tuskDrift: this.tuskDrift
-		});
-		if (!mockData) {
-			logger.warn(`[PostgresInstrumentation] No mock data found for transaction BEGIN`);
-			throw new Error(`[PostgresInstrumentation] No matching mock found for transaction BEGIN`);
-		}
-		logger.debug(`[PostgresInstrumentation] Found mock data for transaction: ${JSON.stringify(mockData)}`);
-		const transactionResult = mockData.result;
-		if (transactionResult && typeof transactionResult === "object" && "status" in transactionResult && transactionResult.status === "committed") return transactionResult.result;
-		else {
-			const errorMessage = transactionResult && typeof transactionResult === "object" && "error" in transactionResult && transactionResult.error ? transactionResult.error : "Transaction rolled back";
-			throw new Error(errorMessage);
-		}
-	}
-	async handleReplaySqlQuery({ inputValue, spanInfo, submodule, name, stackTrace }) {
-		logger.debug(`[PostgresInstrumentation] Replaying Postgres sql query`);
-		const mockData = await findMockResponseAsync({
-			mockRequestData: {
-				traceId: spanInfo.traceId,
-				spanId: spanInfo.spanId,
-				name,
-				inputValue: createMockInputValue(inputValue),
-				packageName: "postgres",
-				instrumentationName: this.INSTRUMENTATION_NAME,
-				submoduleName: submodule,
-				kind: import_src$25.SpanKind.CLIENT,
-				stackTrace
-			},
-			tuskDrift: this.tuskDrift
-		});
-		if (!mockData) {
-			const queryText = inputValue.query || "UNKNOWN_QUERY";
-			logger.warn(`[PostgresInstrumentation] No mock data found for Postgres sql query: ${queryText}`);
-			throw new Error(`[PostgresInstrumentation] No matching mock found for Postgres sql query: ${queryText}`);
-		}
-		logger.debug(`[PostgresInstrumentation] Found mock data for Postgres sql query: ${JSON.stringify(mockData)}`);
-		const processedResult = this.convertPostgresTypes(mockData.result);
-		logger.debug(`[PostgresInstrumentation] Sql query processed result: ${JSON.stringify(processedResult)}`);
-		return processedResult;
+		};
 	}
-	async handleReplayUnsafeQuery({ inputValue, spanInfo, submodule, name, stackTrace }) {
-		logger.debug(`[PostgresInstrumentation] Replaying Postgres unsafe query`);
-		const mockData = await findMockResponseAsync({
-			mockRequestData: {
-				traceId: spanInfo.traceId,
-				spanId: spanInfo.spanId,
-				name,
-				inputValue: createMockInputValue(inputValue),
-				packageName: "postgres",
-				instrumentationName: this.INSTRUMENTATION_NAME,
-				submoduleName: submodule,
-				kind: import_src$25.SpanKind.CLIENT,
-				stackTrace
-			},
-			tuskDrift: this.tuskDrift
-		});
-		if (!mockData) {
-			const queryText = inputValue.query || "UNKNOWN_QUERY";
-			logger.warn(`[PostgresInstrumentation] No mock data found for Postgres unsafe query: ${queryText}`);
-			throw new Error(`[PostgresInstrumentation] No matching mock found for Postgres unsafe query: ${queryText}`);
-		}
-		logger.debug(`[PostgresInstrumentation] Found mock data for Postgres unsafe query: ${JSON.stringify(mockData)}`);
-		const processedResult = this.convertPostgresTypes(mockData.result);
-		logger.debug(`[PostgresInstrumentation] Unsafe query processed result: ${JSON.stringify(processedResult)}`);
-		return processedResult;
+	/**
+	* Wraps a query's .execute() method to prevent TCP calls in REPLAY mode.
+	* This is reusable for both sql template literals and unsafe() queries.
+	*/
+	_wrapExecuteMethod(query) {
+		const self = this;
+		const originalExecute = query.execute ? query.execute.bind(query) : void 0;
+		if (originalExecute) query.execute = function() {
+			if (self.mode === TuskDriftMode.REPLAY) return this;
+			else return originalExecute.call(this);
+		};
 	}
-	convertPostgresTypes(result) {
-		if (!isPostgresOutputValueType(result)) {
-			logger.error(`[PostgresInstrumentation] output value is not of type PostgresOutputValueType`, result);
-			return;
-		}
-		const { rows, count, command } = result;
-		const resultArray = Array.from(rows || []);
-		Object.defineProperties(resultArray, {
-			count: {
-				value: count !== void 0 ? count : null,
-				writable: true,
-				enumerable: false
-			},
-			command: {
-				value: command || null,
-				writable: true,
-				enumerable: false
-			}
-		});
-		return resultArray;
+	/**
+	* Wraps a query's cursor() method to add instrumentation.
+	* This is reusable for both sql template literals and unsafe() queries.
+	*/
+	_wrapCursorMethod(query, inputValue, creationContext) {
+		if (typeof query.cursor !== "function") return;
+		const self = this;
+		const originalCursor = query.cursor.bind(query);
+		query.cursor = function(rows, fn) {
+			if (typeof rows === "function") {
+				fn = rows;
+				rows = 1;
+			}
+			if (!rows) rows = 1;
+			if (typeof fn === "function") if (self.mode === TuskDriftMode.RECORD) return self._handleCursorCallbackRecord({
+				originalCursor,
+				rows,
+				inputValue,
+				creationContext,
+				userCallback: fn
+			});
+			else if (self.mode === TuskDriftMode.REPLAY) return self._handleCursorCallbackReplay({
+				inputValue,
+				creationContext,
+				cursorBatchSize: rows,
+				userCallback: fn
+			});
+			else return originalCursor(rows, fn);
+			if (self.mode === TuskDriftMode.RECORD) return self._handleCursorRecord({
+				originalCursor,
+				rows,
+				inputValue,
+				creationContext,
+				queryObject: this
+			});
+			else if (self.mode === TuskDriftMode.REPLAY) return self._handleCursorReplay({
+				inputValue,
+				creationContext,
+				cursorBatchSize: rows
+			});
+			else return originalCursor(rows);
+		};
 	}
-	_addOutputAttributesToSpan(spanInfo, result) {
-		if (!result) return;
-		const isArray$1 = Array.isArray(result);
-		logger.debug(`[PostgresInstrumentation] Adding output attributes to span for ${isArray$1 ? "array" : "object"} result`);
-		const outputValue = {
-			rows: isArray$1 ? Array.from(result) : result.rows || [],
-			count: result.count !== void 0 && result.count !== null ? result.count : void 0,
-			command: result.command || void 0
+	/**
+	* Wraps a query's forEach() method to add instrumentation.
+	* This is reusable for both sql template literals and unsafe() queries.
+	*/
+	_wrapForEachMethod(query, inputValue, creationContext) {
+		if (typeof query.forEach !== "function") return;
+		const self = this;
+		const originalForEach = query.forEach.bind(query);
+		query.forEach = function(fn) {
+			query._forEachCalled = true;
+			if (self.mode === TuskDriftMode.RECORD) return self._handleForEachRecord({
+				originalForEach,
+				inputValue,
+				creationContext,
+				userCallback: fn
+			});
+			else if (self.mode === TuskDriftMode.REPLAY) return self._handleForEachReplay({
+				inputValue,
+				creationContext,
+				userCallback: fn
+			});
+			else return originalForEach(fn);
 		};
-		SpanUtils.addSpanAttributes(spanInfo.span, { outputValue });
 	}
 	_wrap(target, propertyName, wrapper) {
 		wrap(target, propertyName, wrapper);
@@ -12805,8 +13622,9 @@ function isMysqlOkPacket(result) {
 * Extends EventEmitter to properly handle all connection methods and events
 */
 var TdMysqlConnectionMock = class extends events.EventEmitter {
-	constructor(mysqlInstrumentation, clientType = "poolConnection", spanInfo) {
+	constructor(mysqlInstrumentation, clientType = "poolConnection", spanInfo, pool) {
 		super();
+		this._pool = null;
 		this.threadId = null;
 		this.config = {
 			host: "localhost",
@@ -12818,6 +13636,7 @@ var TdMysqlConnectionMock = class extends events.EventEmitter {
 		this.spanInfo = spanInfo;
 		this.clientType = clientType;
 		this.threadId = 1;
+		this._pool = pool;
 	}
 	query(...args) {
 		logger.debug(`[TdMysqlConnectionMock] Mock connection query intercepted in REPLAY mode`);
@@ -12825,7 +13644,13 @@ var TdMysqlConnectionMock = class extends events.EventEmitter {
 		let values;
 		let callback;
 		let options = {};
-		if (typeof args[0] === "string") {
+		const firstArg = args[0];
+		if (firstArg && typeof firstArg === "object" && typeof firstArg._callback === "function") {
+			sql = firstArg.sql;
+			values = firstArg.values;
+			callback = firstArg._callback;
+			options = { nestTables: firstArg.nestTables };
+		} else if (typeof args[0] === "string") {
 			sql = args[0];
 			if (typeof args[1] === "function") callback = args[1];
 			else if (Array.isArray(args[1])) {
@@ -12877,6 +13702,7 @@ var TdMysqlConnectionMock = class extends events.EventEmitter {
 		}
 	}
 	release() {
+		if (this._pool) this._pool.emit("release", this);
 		this.emit("end");
 	}
 	destroy() {
@@ -12901,19 +13727,22 @@ var TdMysqlConnectionMock = class extends events.EventEmitter {
 			return;
 		}
 	}
-	beginTransaction(callback) {
+	beginTransaction(optionsOrCallback, callbackArg) {
+		const callback = typeof optionsOrCallback === "function" ? optionsOrCallback : callbackArg;
 		if (callback) {
 			process.nextTick(() => callback(null));
 			return;
 		}
 	}
-	commit(callback) {
+	commit(optionsOrCallback, callbackArg) {
+		const callback = typeof optionsOrCallback === "function" ? optionsOrCallback : callbackArg;
 		if (callback) {
 			process.nextTick(() => callback(null));
 			return;
 		}
 	}
-	rollback(callback) {
+	rollback(optionsOrCallback, callbackArg) {
+		const callback = typeof optionsOrCallback === "function" ? optionsOrCallback : callbackArg;
 		if (callback) {
 			process.nextTick(() => callback(null));
 			return;
@@ -13109,6 +13938,11 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 					name: "mysql/lib/Pool.js",
 					supportedVersions: ["2.*"],
 					patch: (moduleExports) => this._patchPoolFile(moduleExports)
+				}),
+				new TdInstrumentationNodeModuleFile({
+					name: "mysql/lib/PoolNamespace.js",
+					supportedVersions: ["2.*"],
+					patch: (moduleExports) => this._patchPoolNamespaceFile(moduleExports)
 				})
 			]
 		})];
@@ -13248,12 +14082,40 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 		return PoolClass;
 	}
 	/**
+	* Patch PoolNamespace.prototype methods at the file level
+	* This handles queries made via poolCluster.of("pattern").query()
+	*/
+	_patchPoolNamespaceFile(PoolNamespaceClass) {
+		logger.debug(`[MysqlInstrumentation] Patching PoolNamespace class (file-based)`);
+		if (this.isModulePatched(PoolNamespaceClass)) {
+			logger.debug(`[MysqlInstrumentation] PoolNamespace class already patched, skipping`);
+			return PoolNamespaceClass;
+		}
+		if (PoolNamespaceClass.prototype && PoolNamespaceClass.prototype.query) {
+			if (!isWrapped$1(PoolNamespaceClass.prototype.query)) {
+				this._wrap(PoolNamespaceClass.prototype, "query", this._getPoolNamespaceQueryPatchFn());
+				logger.debug(`[MysqlInstrumentation] Wrapped PoolNamespace.prototype.query`);
+			}
+		}
+		if (PoolNamespaceClass.prototype && PoolNamespaceClass.prototype.getConnection) {
+			if (!isWrapped$1(PoolNamespaceClass.prototype.getConnection)) {
+				this._wrap(PoolNamespaceClass.prototype, "getConnection", this._getPoolNamespaceGetConnectionPatchFn());
+				logger.debug(`[MysqlInstrumentation] Wrapped PoolNamespace.prototype.getConnection`);
+			}
+		}
+		this.markModuleAsPatched(PoolNamespaceClass);
+		logger.debug(`[MysqlInstrumentation] PoolNamespace class patching complete`);
+		return PoolNamespaceClass;
+	}
+	/**
 	* Get wrapper function for query method (prototype-level patching)
 	*/
 	_getQueryPatchFn() {
 		const self = this;
 		return (originalQuery) => {
 			return function query(...args) {
+				const firstArg = args[0];
+				const hasInternalCallback = firstArg && typeof firstArg === "object" && typeof firstArg._callback === "function";
 				let sql;
 				let values;
 				let callback;
@@ -13264,6 +14126,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 					values = queryObj.values;
 					options = { nestTables: queryObj.nestTables };
 					callback = args.find((arg) => typeof arg === "function");
+					if (!callback && hasInternalCallback) callback = firstArg._callback;
 				} catch (error) {
 					logger.debug(`[MysqlInstrumentation] Error using createQuery, falling back to manual parsing:`, error);
 					({sql, values, callback, options} = self._parseQueryArgs(args));
@@ -13274,7 +14137,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 					values,
 					options: options.nestTables ? { nestTables: options.nestTables } : void 0
 				};
-				const isEventEmitterMode = !callback;
+				const isEventEmitterMode = !callback && !hasInternalCallback;
 				if (self.mode === TuskDriftMode.REPLAY) {
 					const stackTrace = captureStackTrace(["MysqlInstrumentation"]);
 					return handleReplayMode({
@@ -13370,11 +14233,14 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 	_getBeginTransactionPatchFn() {
 		const self = this;
 		return (originalBeginTransaction) => {
-			return function beginTransaction(callback) {
+			return function beginTransaction(optionsOrCallback, callbackArg) {
+				let actualCallback;
+				if (typeof optionsOrCallback === "function") actualCallback = optionsOrCallback;
+				else actualCallback = callbackArg;
 				const inputValue = { query: "BEGIN" };
 				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
 					noOpRequestHandler: () => {
-						if (callback) setImmediate(() => callback(null));
+						if (actualCallback) setImmediate(() => actualCallback(null));
 					},
 					isServerRequest: false,
 					replayModeHandler: () => {
@@ -13388,7 +14254,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 							inputValue,
 							isPreAppStart: false
 						}, (spanInfo) => {
-							return self._handleReplayTransaction(inputValue, callback);
+							return self._handleReplayTransaction(inputValue, actualCallback);
 						});
 					}
 				});
@@ -13405,7 +14271,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 							inputValue,
 							isPreAppStart
 						}, (spanInfo) => {
-							return self._handleRecordTransaction(spanInfo, originalBeginTransaction, this, arguments, callback);
+							return self._handleRecordTransaction(spanInfo, originalBeginTransaction, this, arguments, actualCallback);
 						});
 					},
 					spanKind: import_src$23.SpanKind.CLIENT
@@ -13420,11 +14286,14 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 	_getCommitPatchFn() {
 		const self = this;
 		return (originalCommit) => {
-			return function commit(callback) {
+			return function commit(optionsOrCallback, callbackArg) {
+				let actualCallback;
+				if (typeof optionsOrCallback === "function") actualCallback = optionsOrCallback;
+				else actualCallback = callbackArg;
 				const inputValue = { query: "COMMIT" };
 				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
 					noOpRequestHandler: () => {
-						if (callback) setImmediate(() => callback(null));
+						if (actualCallback) setImmediate(() => actualCallback(null));
 					},
 					isServerRequest: false,
 					replayModeHandler: () => {
@@ -13438,7 +14307,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 							inputValue,
 							isPreAppStart: false
 						}, (spanInfo) => {
-							return self._handleReplayTransaction(inputValue, callback);
+							return self._handleReplayTransaction(inputValue, actualCallback);
 						});
 					}
 				});
@@ -13455,7 +14324,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 							inputValue,
 							isPreAppStart
 						}, (spanInfo) => {
-							return self._handleRecordTransaction(spanInfo, originalCommit, this, arguments, callback);
+							return self._handleRecordTransaction(spanInfo, originalCommit, this, arguments, actualCallback);
 						});
 					},
 					spanKind: import_src$23.SpanKind.CLIENT
@@ -13470,11 +14339,14 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 	_getRollbackPatchFn() {
 		const self = this;
 		return (originalRollback) => {
-			return function rollback(callback) {
+			return function rollback(optionsOrCallback, callbackArg) {
+				let actualCallback;
+				if (typeof optionsOrCallback === "function") actualCallback = optionsOrCallback;
+				else actualCallback = callbackArg;
 				const inputValue = { query: "ROLLBACK" };
 				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
 					noOpRequestHandler: () => {
-						if (callback) setImmediate(() => callback(null));
+						if (actualCallback) setImmediate(() => actualCallback(null));
 					},
 					isServerRequest: false,
 					replayModeHandler: () => {
@@ -13488,7 +14360,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 							inputValue,
 							isPreAppStart: false
 						}, (spanInfo) => {
-							return self._handleReplayTransaction(inputValue, callback);
+							return self._handleReplayTransaction(inputValue, actualCallback);
 						});
 					}
 				});
@@ -13505,7 +14377,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 							inputValue,
 							isPreAppStart
 						}, (spanInfo) => {
-							return self._handleRecordTransaction(spanInfo, originalRollback, this, arguments, callback);
+							return self._handleRecordTransaction(spanInfo, originalRollback, this, arguments, actualCallback);
 						});
 					},
 					spanKind: import_src$23.SpanKind.CLIENT
@@ -13673,9 +14545,10 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 		return (originalGetConnection) => {
 			return function getConnection(callback) {
 				const inputValue = { clientType: "pool" };
+				const pool = this;
 				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
 					noOpRequestHandler: () => {
-						return self._handleNoOpReplayGetConnection(callback);
+						return self._handleNoOpReplayGetConnection(pool, callback);
 					},
 					isServerRequest: false,
 					replayModeHandler: () => {
@@ -13689,7 +14562,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 							inputValue,
 							isPreAppStart: false
 						}, (spanInfo) => {
-							return self._handleReplayPoolGetConnection(spanInfo, callback);
+							return self._handleReplayPoolGetConnection(pool, spanInfo, callback);
 						});
 					}
 				});
@@ -13719,6 +14592,8 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 		const self = this;
 		return (originalQuery) => {
 			return function query(...args) {
+				const firstArg = args[0];
+				const hasInternalCallback = firstArg && typeof firstArg === "object" && typeof firstArg._callback === "function";
 				let sql;
 				let values;
 				let callback;
@@ -13729,6 +14604,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 					values = queryObj.values;
 					options = { nestTables: queryObj.nestTables };
 					callback = args.find((arg) => typeof arg === "function");
+					if (!callback && hasInternalCallback) callback = firstArg._callback;
 				} catch (error) {
 					logger.debug(`[MysqlInstrumentation] Error using createQuery, falling back to manual parsing:`, error);
 					({sql, values, callback, options} = self._parseQueryArgs(args));
@@ -13739,7 +14615,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 					values,
 					options: options.nestTables ? { nestTables: options.nestTables } : void 0
 				};
-				const isEventEmitterMode = !callback;
+				const isEventEmitterMode = !callback && !hasInternalCallback;
 				if (self.mode === TuskDriftMode.REPLAY) {
 					const stackTrace = captureStackTrace(["MysqlInstrumentation"]);
 					return handleReplayMode({
@@ -13841,6 +14717,33 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 			});
 			return queryEmitter;
 		} else {
+			const queryObject = args[0];
+			if (queryObject && typeof queryObject === "object" && typeof queryObject._callback === "function") {
+				const originalCallback$1 = queryObject._callback;
+				queryObject._callback = function(err, results, fields) {
+					if (err) try {
+						SpanUtils.endSpan(spanInfo.span, {
+							code: import_src$23.SpanStatusCode.ERROR,
+							message: err.message
+						});
+					} catch (error) {
+						logger.error(`[MysqlInstrumentation] error ending span:`, error);
+					}
+					else try {
+						const outputValue = {
+							results,
+							fields
+						};
+						SpanUtils.addSpanAttributes(spanInfo.span, { outputValue });
+						SpanUtils.endSpan(spanInfo.span, { code: import_src$23.SpanStatusCode.OK });
+					} catch (error) {
+						logger.error(`[MysqlInstrumentation] error ending span:`, error);
+					}
+					logger.debug(`[MysqlInstrumentation] Query completed`);
+					originalCallback$1.call(this, err, results, fields);
+				};
+				return originalQuery.apply(connection, args);
+			}
 			const originalCallback = callback;
 			const callbackIndex = args.findIndex((arg) => typeof arg === "function");
 			args[callbackIndex] = function(err, results, fields) {
@@ -13895,11 +14798,14 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 	_patchBeginTransaction(connection) {
 		const self = this;
 		return (originalBeginTransaction) => {
-			return function beginTransaction(callback) {
+			return function beginTransaction(optionsOrCallback, callbackArg) {
+				let actualCallback;
+				if (typeof optionsOrCallback === "function") actualCallback = optionsOrCallback;
+				else actualCallback = callbackArg;
 				const inputValue = { query: "BEGIN" };
 				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
 					noOpRequestHandler: () => {
-						if (callback) setImmediate(() => callback(null));
+						if (actualCallback) setImmediate(() => actualCallback(null));
 					},
 					isServerRequest: false,
 					replayModeHandler: () => {
@@ -13913,7 +14819,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 							inputValue,
 							isPreAppStart: false
 						}, (spanInfo) => {
-							return self._handleReplayTransaction(inputValue, callback);
+							return self._handleReplayTransaction(inputValue, actualCallback);
 						});
 					}
 				});
@@ -13930,7 +14836,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 							inputValue,
 							isPreAppStart
 						}, (spanInfo) => {
-							return self._handleRecordTransaction(spanInfo, originalBeginTransaction, connection, arguments, callback);
+							return self._handleRecordTransaction(spanInfo, originalBeginTransaction, connection, arguments, actualCallback);
 						});
 					},
 					spanKind: import_src$23.SpanKind.CLIENT
@@ -13942,11 +14848,14 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 	_patchCommit(connection) {
 		const self = this;
 		return (originalCommit) => {
-			return function commit(callback) {
+			return function commit(optionsOrCallback, callbackArg) {
+				let actualCallback;
+				if (typeof optionsOrCallback === "function") actualCallback = optionsOrCallback;
+				else actualCallback = callbackArg;
 				const inputValue = { query: "COMMIT" };
 				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
 					noOpRequestHandler: () => {
-						if (callback) setImmediate(() => callback(null));
+						if (actualCallback) setImmediate(() => actualCallback(null));
 					},
 					isServerRequest: false,
 					replayModeHandler: () => {
@@ -13960,7 +14869,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 							inputValue,
 							isPreAppStart: false
 						}, (spanInfo) => {
-							return self._handleReplayTransaction(inputValue, callback);
+							return self._handleReplayTransaction(inputValue, actualCallback);
 						});
 					}
 				});
@@ -13977,7 +14886,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 							inputValue,
 							isPreAppStart
 						}, (spanInfo) => {
-							return self._handleRecordTransaction(spanInfo, originalCommit, connection, arguments, callback);
+							return self._handleRecordTransaction(spanInfo, originalCommit, connection, arguments, actualCallback);
 						});
 					},
 					spanKind: import_src$23.SpanKind.CLIENT
@@ -13989,11 +14898,14 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 	_patchRollback(connection) {
 		const self = this;
 		return (originalRollback) => {
-			return function rollback(callback) {
+			return function rollback(optionsOrCallback, callbackArg) {
+				let actualCallback;
+				if (typeof optionsOrCallback === "function") actualCallback = optionsOrCallback;
+				else actualCallback = callbackArg;
 				const inputValue = { query: "ROLLBACK" };
 				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
 					noOpRequestHandler: () => {
-						if (callback) setImmediate(() => callback(null));
+						if (actualCallback) setImmediate(() => actualCallback(null));
 					},
 					isServerRequest: false,
 					replayModeHandler: () => {
@@ -14007,7 +14919,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 							inputValue,
 							isPreAppStart: false
 						}, (spanInfo) => {
-							return self._handleReplayTransaction(inputValue, callback);
+							return self._handleReplayTransaction(inputValue, actualCallback);
 						});
 					}
 				});
@@ -14024,7 +14936,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 							inputValue,
 							isPreAppStart
 						}, (spanInfo) => {
-							return self._handleRecordTransaction(spanInfo, originalRollback, connection, arguments, callback);
+							return self._handleRecordTransaction(spanInfo, originalRollback, connection, arguments, actualCallback);
 						});
 					},
 					spanKind: import_src$23.SpanKind.CLIENT
@@ -14057,7 +14969,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 		const argsArray = Array.from(args);
 		const callbackIndex = argsArray.findIndex((arg) => typeof arg === "function");
 		if (callbackIndex !== -1) {
-			const originalCallback = callback;
+			const originalCallback = argsArray[callbackIndex];
 			argsArray[callbackIndex] = function(err) {
 				if (err) try {
 					SpanUtils.endSpan(spanInfo.span, {
@@ -14086,7 +14998,7 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 			callback(null);
 		});
 	}
-	_handleRecordPoolGetConnectionInSpan(spanInfo, originalGetConnection, callback, context$6) {
+	_handleRecordPoolGetConnectionInSpan(spanInfo, originalGetConnection, callback, poolContext) {
 		const self = this;
 		if (callback) {
 			const wrappedCallback = (error, connection) => {
@@ -14111,11 +15023,11 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 					} });
 					SpanUtils.endSpan(spanInfo.span, { code: import_src$23.SpanStatusCode.OK });
 				}
-				return callback(error, connection);
+				return import_src$23.context.bind(spanInfo.context, callback)(error, connection);
 			};
-			return originalGetConnection.call(context$6, wrappedCallback);
+			return originalGetConnection.call(poolContext, wrappedCallback);
 		} else try {
-			const result = originalGetConnection.call(context$6);
+			const result = originalGetConnection.call(poolContext);
 			SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: {
 				connected: true,
 				hasConnection: true
@@ -14130,20 +15042,28 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 			throw error;
 		}
 	}
-	_handleNoOpReplayGetConnection(callback) {
+	_handleNoOpReplayGetConnection(pool, callback) {
 		logger.debug(`[MysqlInstrumentation] Background getConnection detected, returning mock connection`);
-		const mockConnection = new TdMysqlConnectionMock(this, "pool");
+		const mockConnection = new TdMysqlConnectionMock(this, "pool", void 0, pool);
 		if (callback) {
-			process.nextTick(() => callback(null, mockConnection));
+			process.nextTick(() => {
+				pool.emit("connection", mockConnection);
+				pool.emit("acquire", mockConnection);
+				callback(null, mockConnection);
+			});
 			return;
 		}
 		return mockConnection;
 	}
-	_handleReplayPoolGetConnection(spanInfo, callback) {
+	_handleReplayPoolGetConnection(pool, spanInfo, callback) {
 		logger.debug(`[MysqlInstrumentation] Replaying MySQL Pool getConnection`);
-		const mockConnection = new TdMysqlConnectionMock(this, "pool", spanInfo);
+		const mockConnection = new TdMysqlConnectionMock(this, "pool", spanInfo, pool);
 		if (callback) {
-			process.nextTick(() => callback(null, mockConnection));
+			process.nextTick(() => {
+				pool.emit("connection", mockConnection);
+				pool.emit("acquire", mockConnection);
+				callback(null, mockConnection);
+			});
 			return;
 		}
 		return mockConnection;
@@ -14376,6 +15296,122 @@ var MysqlInstrumentation = class extends TdInstrumentationBase {
 		});
 		return readableStream;
 	}
+	/**
+	* Get wrapper function for PoolNamespace.query method
+	* This handles queries made via poolCluster.of("pattern").query()
+	*/
+	_getPoolNamespaceQueryPatchFn() {
+		const self = this;
+		return (originalQuery) => {
+			return function query(...args) {
+				const firstArg = args[0];
+				const hasInternalCallback = firstArg && typeof firstArg === "object" && typeof firstArg._callback === "function";
+				if (self.mode === TuskDriftMode.REPLAY) {
+					let sql;
+					let values;
+					let callback;
+					let options = {};
+					if (self.createQuery) try {
+						const queryObj = self.createQuery(...args);
+						sql = queryObj.sql;
+						values = queryObj.values;
+						options = { nestTables: queryObj.nestTables };
+						callback = args.find((arg) => typeof arg === "function");
+						if (!callback && hasInternalCallback) callback = firstArg._callback;
+					} catch (error) {
+						({sql, values, callback, options} = self._parseQueryArgs(args));
+					}
+					else ({sql, values, callback, options} = self._parseQueryArgs(args));
+					const inputValue = {
+						sql,
+						values,
+						options: options.nestTables ? { nestTables: options.nestTables } : void 0
+					};
+					const stackTrace = captureStackTrace(["MysqlInstrumentation"]);
+					return handleReplayMode({
+						noOpRequestHandler: () => {
+							return self.queryMock.handleNoOpReplayQuery({
+								sql,
+								values,
+								callback,
+								options
+							});
+						},
+						isServerRequest: false,
+						replayModeHandler: () => {
+							return SpanUtils.createAndExecuteSpan(self.mode, () => originalQuery.apply(this, args), {
+								name: "mysql.query",
+								kind: import_src$23.SpanKind.CLIENT,
+								submodule: "query",
+								packageType: PackageType.MYSQL,
+								packageName: "mysql",
+								instrumentationName: self.INSTRUMENTATION_NAME,
+								inputValue,
+								isPreAppStart: false
+							}, (spanInfo) => {
+								const queryEmitter = self.queryMock.handleReplayQuery({
+									sql,
+									values,
+									callback,
+									options
+								}, inputValue, spanInfo, stackTrace);
+								if (queryEmitter && typeof queryEmitter === "object") queryEmitter.stream = function(streamOptions) {
+									return self._createReplayStreamForQuery(inputValue, spanInfo, stackTrace, queryEmitter, streamOptions);
+								};
+								return queryEmitter;
+							});
+						}
+					});
+				} else if (self.mode === TuskDriftMode.RECORD) return originalQuery.apply(this, args);
+				else return originalQuery.apply(this, args);
+			};
+		};
+	}
+	/**
+	* Get wrapper function for PoolNamespace.getConnection method
+	* This handles connections obtained via poolCluster.of("pattern").getConnection()
+	*/
+	_getPoolNamespaceGetConnectionPatchFn() {
+		const self = this;
+		return (originalGetConnection) => {
+			return function getConnection(callback) {
+				const namespace = this;
+				const inputValue = { clientType: "poolNamespace" };
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
+						const mockConnection = new TdMysqlConnectionMock(self, "pool", void 0, void 0);
+						if (callback) {
+							process.nextTick(() => callback(null, mockConnection));
+							return;
+						}
+						return mockConnection;
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalGetConnection.apply(namespace, [callback]), {
+							name: `mysql.poolNamespace.getConnection`,
+							kind: import_src$23.SpanKind.CLIENT,
+							submodule: "getConnection",
+							packageName: "mysql",
+							packageType: PackageType.MYSQL,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							const mockConnection = new TdMysqlConnectionMock(self, "pool", spanInfo, void 0);
+							if (callback) {
+								process.nextTick(() => callback(null, mockConnection));
+								return;
+							}
+							return mockConnection;
+						});
+					}
+				});
+				else if (self.mode === TuskDriftMode.RECORD) return originalGetConnection.apply(namespace, [callback]);
+				else return originalGetConnection.apply(namespace, [callback]);
+			};
+		};
+	}
 	_wrap(target, propertyName, wrapper) {
 		wrap(target, propertyName, wrapper);
 	}
@@ -31946,7 +32982,7 @@ var require_src = /* @__PURE__ */ __commonJS({ "node_modules/@opentelemetry/sdk-
 //#endregion
 //#region package.json
 var import_src$1 = /* @__PURE__ */ __toESM(require_src(), 1);
-var version = "0.1.18";
+var version = "0.1.19";
 
 //#endregion
 //#region src/version.ts