@use-tusk/drift-node-sdk 0.1.6 → 0.1.7

package/dist/index.js

@@ -252,7 +252,7 @@ var TdInstrumentationAbstract = class {
 
 //#endregion
 //#region package.json
-var version = "0.1.6";
+var version = "0.1.7";
 
 //#endregion
 //#region src/version.ts
@@ -1450,7 +1450,7 @@ var JsonSchemaHelper = class JsonSchemaHelper {
 			if (schema.decodedType === DecodedType$1.JSON && typeof decodedValue === "string") decodedValue = JSON.parse(decodedValue);
 			decodedData[key] = decodedValue;
 		} catch (error) {
-			logger.warn(`[JsonSchemaHelper] Failed to decode ${key}:`, error);
+			logger.debug(`[JsonSchemaHelper] Failed to decode ${key}:`, error);
 			decodedData[key] = data[key];
 		}
 		return decodedData;
@@ -1538,7 +1538,8 @@ function convertMockRequestDataToCleanSpanData(mockRequestData, tuskDrift, input
 		status: {
 			code: StatusCode.OK,
 			message: "OK"
-		}
+		},
+		stackTrace: mockRequestData.stackTrace
 	};
 }
 /**
@@ -1583,7 +1584,7 @@ let ClientRequest;
 * Mock ClientRequest implementation for Tusk Drift HTTP replay
 */
 var TdMockClientRequest = class TdMockClientRequest extends EventEmitter {
-	constructor(options, spanInfo, callback) {
+	constructor(options, spanInfo, callback, stackTrace) {
 		super();
 		this.INSTRUMENTATION_NAME = "HttpInstrumentation";
 		this.finished = false;
@@ -1594,6 +1595,7 @@ var TdMockClientRequest = class TdMockClientRequest extends EventEmitter {
 		TdMockClientRequest._setupPrototype();
 		this.tuskDrift = TuskDriftCore.getInstance();
 		this.spanInfo = spanInfo;
+		this.stackTrace = stackTrace;
 		if (!options || Object.keys(options).length === 0) throw new Error("Making a request with empty `options` is not supported in TdMockClientRequest");
 		this.options = {
 			...options,
@@ -1729,7 +1731,8 @@ var TdMockClientRequest = class TdMockClientRequest extends EventEmitter {
 					instrumentationName: this.INSTRUMENTATION_NAME,
 					submoduleName: rawInputValue.method,
 					inputValue,
-					kind: SpanKind.CLIENT
+					kind: SpanKind.CLIENT,
+					stackTrace: this.stackTrace
 				},
 				tuskDrift: this.tuskDrift,
 				inputValueSchemaMerges: {
@@ -1873,7 +1876,7 @@ var HttpReplayHooks = class {
 	* Handle outbound HTTP requests in replay mode
 	* Uses TdMockClientRequest for simplified mocking approach
 	*/
-	handleOutboundReplayRequest({ method, requestOptions, protocol, args, spanInfo }) {
+	handleOutboundReplayRequest({ method, requestOptions, protocol, args, spanInfo, stackTrace }) {
 		logger.debug(`[HttpReplayHooks] Handling outbound ${protocol.toUpperCase()} ${method} request in replay mode`);
 		let callback;
 		if (args.length > 1 && typeof args[1] === "function") callback = args[1];
@@ -1890,7 +1893,7 @@ var HttpReplayHooks = class {
 			port: requestOptions.port ? Number(requestOptions.port) : void 0,
 			method
 		};
-		const mockRequest = new TdMockClientRequest(mockOptions, spanInfo, callback);
+		const mockRequest = new TdMockClientRequest(mockOptions, spanInfo, callback, stackTrace);
 		if (method === "GET" || method === "HEAD") process.nextTick(() => {
 			mockRequest.end();
 		});
@@ -1959,17 +1962,17 @@ function isWrapped$1(func) {
 */
 function wrap(target, propertyName, wrapper) {
 	if (typeof target[propertyName] !== "function") {
-		logger.warn(`Cannot wrap non-function property: ${propertyName}`);
+		logger.debug(`Cannot wrap non-function property: ${propertyName}`);
 		return;
 	}
 	if (isWrapped$1(target[propertyName])) {
-		logger.warn(`Property ${propertyName} is already wrapped`);
+		logger.debug(`Property ${propertyName} is already wrapped`);
 		return;
 	}
 	const original = target[propertyName];
 	const wrapped = wrapper(original);
 	if (typeof wrapped !== "function") {
-		logger.warn(`Wrapper must return a function for property: ${propertyName}`);
+		logger.debug(`Wrapper must return a function for property: ${propertyName}`);
 		return;
 	}
 	wrapped._isWrapped = true;
@@ -1979,6 +1982,45 @@ function wrap(target, propertyName, wrapper) {
 	return wrapped;
 }
 
+//#endregion
+//#region src/instrumentation/core/utils/stackTraceUtils.ts
+/**
+* Helper functions for capturing stack traces in replay mode
+*
+* TODO: Consider using a structured format for stack frames:
+* 
+* {
+*   "frames": [
+*     {
+*       "fileName": "file.js",
+*       "lineNumber": 10,
+*       "columnNumber": 20,
+*       "functionName": "functionName"
+*     }
+*   ]
+* }
+*
+* This would allow for more efficient matching and filtering of stack frames.
+* It would also allow for more accurate stack trace reconstruction in replay mode.
+*/
+/**
+* 
+* @param excludeClassNames - Class names to exclude from the stack trace
+* @returns The stack trace as a string
+*/
+function captureStackTrace(excludeClassNames = []) {
+	const originalStackTraceLimit = Error.stackTraceLimit;
+	Error.stackTraceLimit = 100;
+	const s = (/* @__PURE__ */ new Error()).stack || "";
+	Error.stackTraceLimit = originalStackTraceLimit;
+	const allExcludes = [...[
+		"drift-node-sdk/src/instrumentation",
+		"drift-node-sdk/src/core",
+		"node_modules/@use-tusk"
+	], ...excludeClassNames];
+	return s.split("\n").slice(2).filter((l) => !allExcludes.some((exclude) => l.includes(exclude))).join("\n");
+}
+
 //#endregion
 //#region src/instrumentation/libraries/http/HttpTransformEngine.ts
 /**
@@ -2927,37 +2969,40 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 				} else requestOptions = args[0] || {};
 				const method = requestOptions.method || "GET";
 				const requestProtocol = self._normalizeProtocol(requestOptions.protocol || void 0, protocol);
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					const headers = normalizeHeaders(requestOptions.headers || {});
-					const inputValue = {
-						method,
-						path: requestOptions.path || void 0,
-						headers,
-						protocol: requestProtocol,
-						hostname: requestOptions.hostname || requestOptions.host || void 0,
-						port: requestOptions.port ? Number(requestOptions.port) : void 0,
-						timeout: requestOptions.timeout || void 0
-					};
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalRequest.apply(this, args), {
-						name: requestOptions.path || `${requestProtocol.toUpperCase()} ${method}`,
-						kind: SpanKind.CLIENT,
-						packageName: requestProtocol,
-						packageType: PackageType.HTTP,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						submodule: method,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
-						return self.replayHooks.handleOutboundReplayRequest({
+				if (self.mode === TuskDriftMode.REPLAY) {
+					const stackTrace = captureStackTrace(["HttpInstrumentation"]);
+					return handleReplayMode({ replayModeHandler: () => {
+						const headers = normalizeHeaders(requestOptions.headers || {});
+						const inputValue = {
 							method,
-							requestOptions,
+							path: requestOptions.path || void 0,
+							headers,
 							protocol: requestProtocol,
-							args,
-							spanInfo
+							hostname: requestOptions.hostname || requestOptions.host || void 0,
+							port: requestOptions.port ? Number(requestOptions.port) : void 0,
+							timeout: requestOptions.timeout || void 0
+						};
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalRequest.apply(this, args), {
+							name: requestOptions.path || `${requestProtocol.toUpperCase()} ${method}`,
+							kind: SpanKind.CLIENT,
+							packageName: requestProtocol,
+							packageType: PackageType.HTTP,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							submodule: method,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							return self.replayHooks.handleOutboundReplayRequest({
+								method,
+								requestOptions,
+								protocol: requestProtocol,
+								args,
+								spanInfo,
+								stackTrace
+							});
 						});
-					});
-				} });
-				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
+					} });
+				} else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalRequest.apply(this, args),
 					recordModeHandler: ({ isPreAppStart }) => {
 						const headers = normalizeHeaders(requestOptions.headers || {});
@@ -3412,6 +3457,7 @@ var TdPgClientMock = class extends EventEmitter {
 	}
 	query(...args) {
 		logger.debug(`[TdPgClientMock] Mock pool client query intercepted in REPLAY mode`);
+		const stackTrace = captureStackTrace(["TdPgClientMock"]);
 		const queryConfig = this.pgInstrumentation.parseQueryArgs(args);
 		if (!queryConfig || !queryConfig.text) {
 			logger.debug(`[TdPgClientMock] Could not parse mock client query, returning empty result`);
@@ -3426,7 +3472,7 @@ var TdPgClientMock = class extends EventEmitter {
 			clientType: "client"
 		};
 		const inputValue = createMockInputValue(rawInputValue);
-		return this.pgInstrumentation.handleReplayQuery(queryConfig, inputValue, this.spanInfo);
+		return this.pgInstrumentation.handleReplayQuery(queryConfig, inputValue, this.spanInfo, stackTrace);
 	}
 	release() {
 		this.emit("end");
@@ -3529,23 +3575,25 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 					values: queryConfig.values || [],
 					clientType
 				};
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					const packageName = inputValue.clientType === "pool" ? "pg-pool" : "pg";
-					const spanName = inputValue.clientType === "pool" ? "pg-pool.query" : "pg.query";
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalQuery.apply(this, args), {
-						name: spanName,
-						kind: SpanKind.CLIENT,
-						submodule: "query",
-						packageType: PackageType.PG,
-						packageName,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
-						return self.handleReplayQuery(queryConfig, inputValue, spanInfo);
-					});
-				} });
-				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
+				if (self.mode === TuskDriftMode.REPLAY) {
+					const stackTrace = captureStackTrace(["PgInstrumentation"]);
+					return handleReplayMode({ replayModeHandler: () => {
+						const packageName = inputValue.clientType === "pool" ? "pg-pool" : "pg";
+						const spanName = inputValue.clientType === "pool" ? "pg-pool.query" : "pg.query";
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalQuery.apply(this, args), {
+							name: spanName,
+							kind: SpanKind.CLIENT,
+							submodule: "query",
+							packageType: PackageType.PG,
+							packageName,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							return self.handleReplayQuery(queryConfig, inputValue, spanInfo, stackTrace);
+						});
+					} });
+				} else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalQuery.apply(this, args),
 					recordModeHandler: ({ isPreAppStart }) => {
 						const packageName = inputValue.clientType === "pool" ? "pg-pool" : "pg";
@@ -3691,7 +3739,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 			throw error;
 		});
 	}
-	async handleReplayQuery(queryConfig, inputValue, spanInfo) {
+	async handleReplayQuery(queryConfig, inputValue, spanInfo, stackTrace) {
 		logger.debug(`[PgInstrumentation] Replaying PG query`);
 		const packageName = inputValue.clientType === "pool" ? "pg-pool" : "pg";
 		const spanName = inputValue.clientType === "pool" ? "pg-pool.query" : "pg.query";
@@ -3704,7 +3752,8 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 				packageName,
 				instrumentationName: this.INSTRUMENTATION_NAME,
 				submoduleName: "query",
-				kind: SpanKind.CLIENT
+				kind: SpanKind.CLIENT,
+				stackTrace
 			},
 			tuskDrift: this.tuskDrift
 		});
@@ -4172,26 +4221,29 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 			query: query.trim(),
 			parameters: values
 		};
-		if (this.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-			return SpanUtils.createAndExecuteSpan(this.mode, () => originalSql.call(this, strings, ...values), {
-				name: "postgres.query",
-				kind: SpanKind.CLIENT,
-				submodule: "query",
-				packageType: PackageType.PG,
-				packageName: "postgres",
-				instrumentationName: this.INSTRUMENTATION_NAME,
-				inputValue,
-				isPreAppStart: false
-			}, (spanInfo) => {
-				return this.handleReplaySqlQuery({
-					inputValue,
-					spanInfo,
+		if (this.mode === TuskDriftMode.REPLAY) {
+			const stackTrace = captureStackTrace(["PostgresInstrumentation"]);
+			return handleReplayMode({ replayModeHandler: () => {
+				return SpanUtils.createAndExecuteSpan(this.mode, () => originalSql.call(this, strings, ...values), {
+					name: "postgres.query",
+					kind: SpanKind.CLIENT,
 					submodule: "query",
-					name: "postgres.query"
+					packageType: PackageType.PG,
+					packageName: "postgres",
+					instrumentationName: this.INSTRUMENTATION_NAME,
+					inputValue,
+					isPreAppStart: false
+				}, (spanInfo) => {
+					return this.handleReplaySqlQuery({
+						inputValue,
+						spanInfo,
+						submodule: "query",
+						name: "postgres.query",
+						stackTrace
+					});
 				});
-			});
-		} });
-		else if (this.mode === TuskDriftMode.RECORD) return handleRecordMode({
+			} });
+		} else if (this.mode === TuskDriftMode.RECORD) return handleRecordMode({
 			originalFunctionCall: () => originalSql.call(this, strings, ...values),
 			recordModeHandler: ({ isPreAppStart }) => {
 				return SpanUtils.createAndExecuteSpan(this.mode, () => originalSql.call(this, strings, ...values), {
@@ -4222,28 +4274,31 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 			parameters: parameters || [],
 			options: queryOptions
 		};
-		if (this.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-			return this._createPendingQueryWrapper(() => {
-				return SpanUtils.createAndExecuteSpan(this.mode, () => executeUnsafe(), {
-					name: "postgres.unsafe",
-					kind: SpanKind.CLIENT,
-					submodule: "unsafe",
-					packageType: PackageType.PG,
-					packageName: "postgres",
-					instrumentationName: this.INSTRUMENTATION_NAME,
-					inputValue,
-					isPreAppStart: false
-				}, (spanInfo) => {
-					return this.handleReplayUnsafeQuery({
-						inputValue,
-						spanInfo,
+		if (this.mode === TuskDriftMode.REPLAY) {
+			const stackTrace = captureStackTrace(["PostgresInstrumentation"]);
+			return handleReplayMode({ replayModeHandler: () => {
+				return this._createPendingQueryWrapper(() => {
+					return SpanUtils.createAndExecuteSpan(this.mode, () => executeUnsafe(), {
+						name: "postgres.unsafe",
+						kind: SpanKind.CLIENT,
 						submodule: "unsafe",
-						name: "postgres.unsafe"
+						packageType: PackageType.PG,
+						packageName: "postgres",
+						instrumentationName: this.INSTRUMENTATION_NAME,
+						inputValue,
+						isPreAppStart: false
+					}, (spanInfo) => {
+						return this.handleReplayUnsafeQuery({
+							inputValue,
+							spanInfo,
+							submodule: "unsafe",
+							name: "postgres.unsafe",
+							stackTrace
+						});
 					});
 				});
-			});
-		} });
-		else if (this.mode === TuskDriftMode.RECORD) return handleRecordMode({
+			} });
+		} else if (this.mode === TuskDriftMode.RECORD) return handleRecordMode({
 			originalFunctionCall: executeUnsafe,
 			recordModeHandler: ({ isPreAppStart }) => {
 				return SpanUtils.createAndExecuteSpan(this.mode, executeUnsafe, {
@@ -4273,21 +4328,23 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 			else if (transactionCallback) return originalBegin.call(sqlInstance, transactionCallback);
 			else return originalBegin.call(sqlInstance, options || void 0);
 		};
-		if (this.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-			return SpanUtils.createAndExecuteSpan(this.mode, () => executeBegin(), {
-				name: "postgres.begin",
-				kind: SpanKind.CLIENT,
-				submodule: "transaction",
-				packageType: PackageType.PG,
-				packageName: "postgres",
-				instrumentationName: this.INSTRUMENTATION_NAME,
-				inputValue,
-				isPreAppStart: false
-			}, (spanInfo) => {
-				return this._handleReplayBeginTransaction(spanInfo, options);
-			});
-		} });
-		else if (this.mode === TuskDriftMode.RECORD) return handleRecordMode({
+		if (this.mode === TuskDriftMode.REPLAY) {
+			const stackTrace = captureStackTrace(["PostgresInstrumentation"]);
+			return handleReplayMode({ replayModeHandler: () => {
+				return SpanUtils.createAndExecuteSpan(this.mode, () => executeBegin(), {
+					name: "postgres.begin",
+					kind: SpanKind.CLIENT,
+					submodule: "transaction",
+					packageType: PackageType.PG,
+					packageName: "postgres",
+					instrumentationName: this.INSTRUMENTATION_NAME,
+					inputValue,
+					isPreAppStart: false
+				}, (spanInfo) => {
+					return this._handleReplayBeginTransaction(spanInfo, options, stackTrace);
+				});
+			} });
+		} else if (this.mode === TuskDriftMode.RECORD) return handleRecordMode({
 			originalFunctionCall: executeBegin,
 			recordModeHandler: ({ isPreAppStart }) => {
 				return SpanUtils.createAndExecuteSpan(this.mode, executeBegin, {
@@ -4381,7 +4438,7 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 		});
 		return promise;
 	}
-	async _handleReplayBeginTransaction(spanInfo, options) {
+	async _handleReplayBeginTransaction(spanInfo, options, stackTrace) {
 		logger.debug(`[PostgresInstrumentation] Replaying Postgres transaction`);
 		const mockData = await findMockResponseAsync({
 			mockRequestData: {
@@ -4395,7 +4452,8 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 				packageName: "postgres",
 				instrumentationName: this.INSTRUMENTATION_NAME,
 				submoduleName: "transaction",
-				kind: SpanKind.CLIENT
+				kind: SpanKind.CLIENT,
+				stackTrace
 			},
 			tuskDrift: this.tuskDrift
 		});
@@ -4450,7 +4508,7 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 			throw error;
 		}
 	}
-	async handleReplaySqlQuery({ inputValue, spanInfo, submodule, name }) {
+	async handleReplaySqlQuery({ inputValue, spanInfo, submodule, name, stackTrace }) {
 		logger.debug(`[PostgresInstrumentation] Replaying Postgres sql query`);
 		const mockData = await findMockResponseAsync({
 			mockRequestData: {
@@ -4461,7 +4519,8 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 				packageName: "postgres",
 				instrumentationName: this.INSTRUMENTATION_NAME,
 				submoduleName: submodule,
-				kind: SpanKind.CLIENT
+				kind: SpanKind.CLIENT,
+				stackTrace
 			},
 			tuskDrift: this.tuskDrift
 		});
@@ -4480,7 +4539,7 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 			count: isResultObject ? processedResult.count : void 0
 		});
 	}
-	async handleReplayUnsafeQuery({ inputValue, spanInfo, submodule, name }) {
+	async handleReplayUnsafeQuery({ inputValue, spanInfo, submodule, name, stackTrace }) {
 		logger.debug(`[PostgresInstrumentation] Replaying Postgres unsafe query`);
 		const mockData = await findMockResponseAsync({
 			mockRequestData: {
@@ -4491,7 +4550,8 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 				packageName: "postgres",
 				instrumentationName: this.INSTRUMENTATION_NAME,
 				submoduleName: submodule,
-				kind: SpanKind.CLIENT
+				kind: SpanKind.CLIENT,
+				stackTrace
 			},
 			tuskDrift: this.tuskDrift
 		});
@@ -4603,6 +4663,7 @@ var TdMysql2ConnectionMock = class extends EventEmitter {
 	}
 	query(...args) {
 		logger.debug(`[TdMysql2ConnectionMock] Mock connection query intercepted in REPLAY mode`);
+		const stackTrace = captureStackTrace(["TdMysql2ConnectionMock"]);
 		const queryConfig = this.mysql2Instrumentation.parseQueryArgs(args);
 		if (!queryConfig || !queryConfig.sql) {
 			logger.debug(`[TdMysql2ConnectionMock] Could not parse mock connection query, returning empty result`);
@@ -4622,10 +4683,11 @@ var TdMysql2ConnectionMock = class extends EventEmitter {
 			clientType: this.clientType
 		};
 		const inputValue = createMockInputValue(rawInputValue);
-		return this.mysql2Instrumentation.handleReplayQuery(queryConfig, inputValue, this.spanInfo);
+		return this.mysql2Instrumentation.handleReplayQuery(queryConfig, inputValue, this.spanInfo, stackTrace);
 	}
 	execute(...args) {
 		logger.debug(`[TdMysql2ConnectionMock] Mock connection execute intercepted in REPLAY mode`);
+		const stackTrace = captureStackTrace(["TdMysql2ConnectionMock"]);
 		const queryConfig = this.mysql2Instrumentation.parseQueryArgs(args);
 		if (!queryConfig || !queryConfig.sql) {
 			logger.debug(`[TdMysql2ConnectionMock] Could not parse mock connection execute, returning empty result`);
@@ -4645,7 +4707,7 @@ var TdMysql2ConnectionMock = class extends EventEmitter {
 			clientType: this.clientType
 		};
 		const inputValue = createMockInputValue(rawInputValue);
-		return this.mysql2Instrumentation.handleReplayQuery(queryConfig, inputValue, this.spanInfo);
+		return this.mysql2Instrumentation.handleReplayQuery(queryConfig, inputValue, this.spanInfo, stackTrace);
 	}
 	release() {
 		this.emit("end");
@@ -4739,20 +4801,33 @@ var TdMysql2QueryMock = class {
 	/**
 	* Handle replay of a MySQL2 query (query or execute)
 	*/
-	handleReplayQuery(queryConfig, inputValue, spanInfo, submoduleName = "query") {
+	handleReplayQuery(queryConfig, inputValue, spanInfo, submoduleName = "query", stackTrace) {
 		logger.debug(`[Mysql2Instrumentation] Replaying MySQL2 query`);
 		const spanName = `mysql2.${inputValue.clientType}.${submoduleName}`;
-		return this._handleQuery(queryConfig, inputValue, spanInfo, spanName, submoduleName);
+		return this._handleQuery(queryConfig, inputValue, spanInfo, spanName, submoduleName, stackTrace);
 	}
 	/**
 	* Handle query - always returns an EventEmitter (like mysql2 does)
 	* This handles both callback and streaming modes
+	* The EventEmitter is also thenable (has a .then() method) to support await/Promise usage
 	*/
-	_handleQuery(queryConfig, inputValue, spanInfo, spanName, submoduleName) {
+	_handleQuery(queryConfig, inputValue, spanInfo, spanName, submoduleName, stackTrace) {
 		const emitter = new EventEmitter();
+		let storedRows = null;
+		let storedFields = null;
+		emitter.then = function(onResolve, onReject) {
+			return new Promise((resolve, reject) => {
+				emitter.once("end", () => {
+					resolve([storedRows, storedFields]);
+				});
+				emitter.once("error", (error) => {
+					reject(error);
+				});
+			}).then(onResolve, onReject);
+		};
 		(async () => {
 			try {
-				const mockData = await this._fetchMockData(inputValue, spanInfo, spanName, submoduleName);
+				const mockData = await this._fetchMockData(inputValue, spanInfo, spanName, submoduleName, stackTrace);
 				if (!mockData) {
 					const sql = queryConfig.sql || inputValue.sql || "UNKNOWN_QUERY";
 					logger.warn(`[Mysql2Instrumentation] No mock data found for MySQL2 query: ${sql}`);
@@ -4764,6 +4839,8 @@ var TdMysql2QueryMock = class {
 					return;
 				}
 				const processedResult = this._convertMysql2Types(mockData.result);
+				storedRows = processedResult.rows;
+				storedFields = processedResult.fields;
 				process.nextTick(() => {
 					if (processedResult.fields) emitter.emit("fields", processedResult.fields);
 					if (queryConfig.callback) queryConfig.callback(null, processedResult.rows, processedResult.fields);
@@ -4783,7 +4860,7 @@ var TdMysql2QueryMock = class {
 	/**
 	* Fetch mock data from CLI
 	*/
-	async _fetchMockData(inputValue, spanInfo, spanName, submoduleName) {
+	async _fetchMockData(inputValue, spanInfo, spanName, submoduleName, stackTrace) {
 		return await findMockResponseAsync({
 			mockRequestData: {
 				traceId: spanInfo.traceId,
@@ -4793,7 +4870,8 @@ var TdMysql2QueryMock = class {
 				packageName: "mysql2",
 				instrumentationName: this.INSTRUMENTATION_NAME,
 				submoduleName,
-				kind: SpanKind.CLIENT
+				kind: SpanKind.CLIENT,
+				stackTrace
 			},
 			tuskDrift: this.tuskDrift
 		});
@@ -4817,6 +4895,52 @@ var TdMysql2QueryMock = class {
 	}
 };
 
+//#endregion
+//#region src/instrumentation/libraries/mysql2/mocks/TdMysql2ConnectionEventMock.ts
+/**
+* Mock for MySQL2 connection events (connect/error)
+* Handles replay of recorded connection establishment events in REPLAY mode
+* Recording happens through normal SpanUtils flow in RECORD mode
+*/
+var TdMysql2ConnectionEventMock = class {
+	constructor(spanInfo) {
+		this.INSTRUMENTATION_NAME = "Mysql2Instrumentation";
+		this.spanInfo = spanInfo;
+		this.tuskDrift = TuskDriftCore.getInstance();
+	}
+	/**
+	* Get recorded connection event for replay
+	* Returns { output } for success, or throws error if connection failed
+	* The connection events are recorded automatically via SpanUtils in record mode
+	*/
+	async getReplayedConnectionEvent(inputValue) {
+		logger.debug(`[TdMysql2ConnectionEventMock] Retrieving recorded connection event`);
+		try {
+			const mockData = await findMockResponseAsync({
+				mockRequestData: {
+					traceId: this.spanInfo.traceId,
+					spanId: this.spanInfo.spanId,
+					name: "mysql2.connection.create",
+					inputValue,
+					packageName: "mysql2",
+					instrumentationName: this.INSTRUMENTATION_NAME,
+					submoduleName: "connectEvent",
+					kind: SpanKind.CLIENT
+				},
+				tuskDrift: this.tuskDrift
+			});
+			if (!mockData) {
+				logger.warn(`[TdMysql2ConnectionEventMock] No mock data found, using default success`);
+				return { output: {} };
+			}
+			return { output: mockData.result || {} };
+		} catch (error) {
+			logger.error(`[TdMysql2ConnectionEventMock] Error getting replay value:`, error);
+			return { output: {} };
+		}
+	}
+};
+
 //#endregion
 //#region src/instrumentation/libraries/mysql2/Instrumentation.ts
 const COMPLETE_SUPPORTED_VERSIONS = ">=2.3.3 <4.0.0";
@@ -4868,16 +4992,6 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 					name: "mysql2/lib/pool_connection.js",
 					supportedVersions: [V3_11_5_TO_4_0],
 					patch: (moduleExports) => this._patchPoolConnectionV3(moduleExports)
-				}),
-				new TdInstrumentationNodeModuleFile({
-					name: "mysql2/lib/create_connection.js",
-					supportedVersions: [COMPLETE_SUPPORTED_VERSIONS],
-					patch: (moduleExports) => this._patchCreateConnectionFile(moduleExports)
-				}),
-				new TdInstrumentationNodeModuleFile({
-					name: "mysql2/lib/create_pool.js",
-					supportedVersions: [COMPLETE_SUPPORTED_VERSIONS],
-					patch: (moduleExports) => this._patchCreatePoolFile(moduleExports)
 				})
 			]
 		})];
@@ -4929,13 +5043,14 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 			return ConnectionClass;
 		}
 		this._patchConnectionPrototypes(ConnectionClass);
+		const patchedConnectionClass = this._getPatchedConnectionClass(ConnectionClass);
 		this.markModuleAsPatched(ConnectionClass);
 		logger.debug(`[Mysql2Instrumentation] Connection class (v2) patching complete`);
-		return ConnectionClass;
+		return patchedConnectionClass;
 	}
 	_patchConnectionV3(ConnectionClass) {
-		logger.debug(`[Mysql2Instrumentation] Connection class (v3) - skipping (base patched)`);
-		return ConnectionClass;
+		logger.debug(`[Mysql2Instrumentation] Connection class (v3) - wrapping constructor only`);
+		return this._getPatchedConnectionClass(ConnectionClass);
 	}
 	_patchConnectionPrototypes(ConnectionClass) {
 		if (ConnectionClass.prototype && ConnectionClass.prototype.query) {
@@ -5044,22 +5159,24 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 					values: queryConfig.values || [],
 					clientType
 				};
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					const spanName = `mysql2.${clientType}.query`;
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalQuery.apply(this, args), {
-						name: spanName,
-						kind: SpanKind.CLIENT,
-						submodule: "query",
-						packageType: PackageType.MYSQL,
-						packageName: "mysql2",
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
-						return self.handleReplayQuery(queryConfig, inputValue, spanInfo, "query");
-					});
-				} });
-				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
+				if (self.mode === TuskDriftMode.REPLAY) {
+					const stackTrace = captureStackTrace(["Mysql2Instrumentation"]);
+					return handleReplayMode({ replayModeHandler: () => {
+						const spanName = `mysql2.${clientType}.query`;
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalQuery.apply(this, args), {
+							name: spanName,
+							kind: SpanKind.CLIENT,
+							submodule: "query",
+							packageType: PackageType.MYSQL,
+							packageName: "mysql2",
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							return self.handleReplayQuery(queryConfig, inputValue, spanInfo, "query", stackTrace);
+						});
+					} });
+				} else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalQuery.apply(this, args),
 					recordModeHandler: ({ isPreAppStart }) => {
 						const spanName = `mysql2.${clientType}.query`;
@@ -5101,22 +5218,24 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 					values: queryConfig.values || [],
 					clientType
 				};
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					const spanName = `mysql2.${clientType}.execute`;
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalExecute.apply(this, args), {
-						name: spanName,
-						kind: SpanKind.CLIENT,
-						submodule: "execute",
-						packageType: PackageType.MYSQL,
-						packageName: "mysql2",
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
-						return self.handleReplayQuery(queryConfig, inputValue, spanInfo, "execute");
-					});
-				} });
-				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
+				if (self.mode === TuskDriftMode.REPLAY) {
+					const stackTrace = captureStackTrace(["Mysql2Instrumentation"]);
+					return handleReplayMode({ replayModeHandler: () => {
+						const spanName = `mysql2.${clientType}.execute`;
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalExecute.apply(this, args), {
+							name: spanName,
+							kind: SpanKind.CLIENT,
+							submodule: "execute",
+							packageType: PackageType.MYSQL,
+							packageName: "mysql2",
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							return self.handleReplayQuery(queryConfig, inputValue, spanInfo, "execute", stackTrace);
+						});
+					} });
+				} else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalExecute.apply(this, args),
 					recordModeHandler: ({ isPreAppStart }) => {
 						const spanName = `mysql2.${clientType}.execute`;
@@ -5464,8 +5583,8 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 			return result;
 		}
 	}
-	handleReplayQuery(queryConfig, inputValue, spanInfo, submoduleName = "query") {
-		return this.queryMock.handleReplayQuery(queryConfig, inputValue, spanInfo, submoduleName);
+	handleReplayQuery(queryConfig, inputValue, spanInfo, submoduleName = "query", stackTrace) {
+		return this.queryMock.handleReplayQuery(queryConfig, inputValue, spanInfo, submoduleName, stackTrace);
 	}
 	_handleRecordPoolGetConnectionInSpan(spanInfo, originalGetConnection, callback, context$1) {
 		if (callback) {
@@ -5528,117 +5647,137 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 			return;
 		} else return Promise.resolve(mockConnection);
 	}
-	_addOutputAttributesToSpan(spanInfo, result, fields) {
-		if (!result) return;
-		let outputValue = {};
-		if (Array.isArray(result)) outputValue = {
-			rowCount: result.length,
-			rows: result,
-			fields: fields || []
-		};
-		else if (result.affectedRows !== void 0) outputValue = {
-			affectedRows: result.affectedRows,
-			insertId: result.insertId,
-			warningCount: result.warningCount
-		};
-		else outputValue = result;
-		SpanUtils.addSpanAttributes(spanInfo.span, { outputValue });
-	}
-	_patchCreateConnectionFile(createConnectionFn) {
-		logger.debug(`[Mysql2Instrumentation] Patching create_connection.js file`);
+	/**
+	* Creates a patched Connection class that intercepts the constructor
+	* to handle connection event recording/replay.
+	*
+	* Wrap the Connection constructor to:
+	* - In RECORD mode: listen for 'connect'/'error' events and record them
+	* - In REPLAY mode: create a MockConnection that fakes the connection and emits recorded events
+	*/
+	_getPatchedConnectionClass(OriginalConnection) {
 		const self = this;
-		const wrappedFn = function(...args) {
+		function TdPatchedConnection(...args) {
 			const inputValue = { method: "createConnection" };
-			if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-				return SpanUtils.createAndExecuteSpan(self.mode, () => createConnectionFn.apply(this, args), {
-					name: `mysql2.createConnection`,
-					kind: SpanKind.CLIENT,
-					submodule: "createConnection",
-					packageName: "mysql2",
-					packageType: PackageType.MYSQL,
-					instrumentationName: self.INSTRUMENTATION_NAME,
-					inputValue,
-					isPreAppStart: false
-				}, (spanInfo) => {
-					const connection = createConnectionFn.apply(this, args);
-					SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: { created: true } });
-					SpanUtils.endSpan(spanInfo.span, { code: SpanStatusCode.OK });
-					return connection;
-				});
-			} });
-			else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
-				originalFunctionCall: () => createConnectionFn.apply(this, args),
+			if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
+				originalFunctionCall: () => new OriginalConnection(...args),
 				recordModeHandler: ({ isPreAppStart }) => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => createConnectionFn.apply(this, args), {
-						name: `mysql2.createConnection`,
+					return SpanUtils.createAndExecuteSpan(self.mode, () => new OriginalConnection(...args), {
+						name: `mysql2.connection.create`,
 						kind: SpanKind.CLIENT,
-						submodule: "createConnection",
-						packageName: "mysql2",
+						submodule: "connectEvent",
 						packageType: PackageType.MYSQL,
+						packageName: "mysql2",
 						instrumentationName: self.INSTRUMENTATION_NAME,
 						inputValue,
 						isPreAppStart
 					}, (spanInfo) => {
-						const connection = createConnectionFn.apply(this, args);
-						SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: { created: true } });
-						SpanUtils.endSpan(spanInfo.span, { code: SpanStatusCode.OK });
+						const connection = new OriginalConnection(...args);
+						connection.on("connect", (connectionObj) => {
+							try {
+								SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: {
+									connected: true,
+									connectionObj
+								} });
+								SpanUtils.endSpan(spanInfo.span, { code: SpanStatusCode.OK });
+							} catch {
+								logger.error(`[Mysql2Instrumentation] error adding span attributes:`);
+							}
+						});
+						connection.on("error", (err) => {
+							try {
+								logger.debug(`[Mysql2Instrumentation] Connection error, recording: ${err.message}`);
+								SpanUtils.endSpan(spanInfo.span, {
+									code: SpanStatusCode.ERROR,
+									message: err.message
+								});
+							} catch {
+								logger.error(`[Mysql2Instrumentation] error ending span`);
+							}
+						});
 						return connection;
 					});
 				},
 				spanKind: SpanKind.CLIENT
 			});
-			else return createConnectionFn.apply(this, args);
-		};
-		logger.debug(`[Mysql2Instrumentation] Patched create_connection.js file`);
-		return wrappedFn;
-	}
-	_patchCreatePoolFile(createPoolFn) {
-		logger.debug(`[Mysql2Instrumentation] Patching create_pool.js file`);
-		const self = this;
-		const wrappedFn = function(...args) {
-			const inputValue = { method: "createPool" };
 			if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-				return SpanUtils.createAndExecuteSpan(self.mode, () => createPoolFn.apply(this, args), {
-					name: `mysql2.createPool`,
+				return SpanUtils.createAndExecuteSpan(self.mode, () => new OriginalConnection(...args), {
+					name: `mysql2.connection.create`,
 					kind: SpanKind.CLIENT,
-					submodule: "createPool",
-					packageName: "mysql2",
+					submodule: "connectEvent",
 					packageType: PackageType.MYSQL,
+					packageName: "mysql2",
 					instrumentationName: self.INSTRUMENTATION_NAME,
 					inputValue,
 					isPreAppStart: false
 				}, (spanInfo) => {
-					const pool = createPoolFn.apply(this, args);
-					SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: { created: true } });
+					class MockConnection extends OriginalConnection {
+						constructor(...mockConnectionArgs) {
+							const clonedArgs = JSON.parse(JSON.stringify(mockConnectionArgs));
+							if (clonedArgs[0] && clonedArgs[0].config) {
+								clonedArgs[0].config.host = "127.0.0.1";
+								clonedArgs[0].config.port = 127;
+							} else if (clonedArgs[0]) {
+								clonedArgs[0].host = "127.0.0.1";
+								clonedArgs[0].port = 127;
+							}
+							super(...clonedArgs);
+							this._isConnectOrErrorEmitted = false;
+							this._connectEventMock = new TdMysql2ConnectionEventMock(spanInfo);
+						}
+						on(event, listener) {
+							if (!this._connectEventMock) return super.on(event, listener);
+							if (event === "connect" && !this._isConnectOrErrorEmitted) {
+								this._connectEventMock.getReplayedConnectionEvent(inputValue).then(({ output }) => {
+									if (output !== void 0) process.nextTick(() => {
+										listener.call(this, output);
+										this._isConnectOrErrorEmitted = true;
+									});
+								}).catch((err) => {
+									logger.error(`[Mysql2Instrumentation] Error replaying connection event:`, err);
+								});
+								return this;
+							}
+							if (event === "error" && !this._isConnectOrErrorEmitted) return this;
+							return super.on(event, listener);
+						}
+					}
+					const mockConnection = new MockConnection(...args);
+					mockConnection.addListener("error", (_err) => {});
+					SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: {
+						connected: true,
+						mock: true
+					} });
 					SpanUtils.endSpan(spanInfo.span, { code: SpanStatusCode.OK });
-					return pool;
+					return mockConnection;
 				});
 			} });
-			else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
-				originalFunctionCall: () => createPoolFn.apply(this, args),
-				recordModeHandler: ({ isPreAppStart }) => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => createPoolFn.apply(this, args), {
-						name: `mysql2.createPool`,
-						kind: SpanKind.CLIENT,
-						submodule: "createPool",
-						packageName: "mysql2",
-						packageType: PackageType.MYSQL,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart
-					}, (spanInfo) => {
-						const pool = createPoolFn.apply(this, args);
-						SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: { created: true } });
-						SpanUtils.endSpan(spanInfo.span, { code: SpanStatusCode.OK });
-						return pool;
-					});
-				},
-				spanKind: SpanKind.CLIENT
-			});
-			else return createPoolFn.apply(this, args);
+			return new OriginalConnection(...args);
+		}
+		const staticProps = Object.getOwnPropertyNames(OriginalConnection).filter((key) => ![
+			"length",
+			"name",
+			"prototype"
+		].includes(key));
+		for (const staticProp of staticProps) TdPatchedConnection[staticProp] = OriginalConnection[staticProp];
+		Object.setPrototypeOf(TdPatchedConnection.prototype, OriginalConnection.prototype);
+		return TdPatchedConnection;
+	}
+	_addOutputAttributesToSpan(spanInfo, result, fields) {
+		if (!result) return;
+		let outputValue = {};
+		if (Array.isArray(result)) outputValue = {
+			rowCount: result.length,
+			rows: result,
+			fields: fields || []
+		};
+		else if (result.affectedRows !== void 0) outputValue = {
+			affectedRows: result.affectedRows,
+			insertId: result.insertId,
+			warningCount: result.warningCount
 		};
-		logger.debug(`[Mysql2Instrumentation] Patched create_pool.js file`);
-		return wrappedFn;
+		else outputValue = result;
+		SpanUtils.addSpanAttributes(spanInfo.span, { outputValue });
 	}
 	_wrap(target, propertyName, wrapper) {
 		wrap(target, propertyName, wrapper);
@@ -5796,20 +5935,22 @@ var JsonwebtokenInstrumentation = class extends TdInstrumentationBase {
 					logger.error(`[JsonwebtokenInstrumentation] error creating mock input value:`, error);
 					return originalVerify.apply(this, args);
 				}
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalVerify.apply(this, args), {
-						name: "jsonwebtoken.verify",
-						kind: SpanKind.CLIENT,
-						submodule: "verify",
-						packageName: "jsonwebtoken",
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
-						return self.handleReplayVerify(verifyConfig, inputValue, spanInfo);
-					});
-				} });
-				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
+				if (self.mode === TuskDriftMode.REPLAY) {
+					const stackTrace = captureStackTrace(["JsonwebtokenInstrumentation"]);
+					return handleReplayMode({ replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalVerify.apply(this, args), {
+							name: "jsonwebtoken.verify",
+							kind: SpanKind.CLIENT,
+							submodule: "verify",
+							packageName: "jsonwebtoken",
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							return self.handleReplayVerify(verifyConfig, inputValue, spanInfo, stackTrace);
+						});
+					} });
+				} else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalVerify.apply(this, args),
 					recordModeHandler: ({ isPreAppStart }) => {
 						return SpanUtils.createAndExecuteSpan(self.mode, () => originalVerify.apply(this, args), {
@@ -5849,20 +5990,22 @@ var JsonwebtokenInstrumentation = class extends TdInstrumentationBase {
 					secretOrPrivateKey: signConfig.secretOrPrivateKey,
 					options: signConfig.options
 				};
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalSign.apply(this, args), {
-						name: "jsonwebtoken.sign",
-						kind: SpanKind.CLIENT,
-						submodule: "sign",
-						packageName: "jsonwebtoken",
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
-						return self.handleReplaySign(signConfig, inputValue, spanInfo);
-					});
-				} });
-				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
+				if (self.mode === TuskDriftMode.REPLAY) {
+					const stackTrace = captureStackTrace(["JsonwebtokenInstrumentation"]);
+					return handleReplayMode({ replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalSign.apply(this, args), {
+							name: "jsonwebtoken.sign",
+							kind: SpanKind.CLIENT,
+							submodule: "sign",
+							packageName: "jsonwebtoken",
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							return self.handleReplaySign(signConfig, inputValue, spanInfo, stackTrace);
+						});
+					} });
+				} else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalSign.apply(this, args),
 					recordModeHandler: ({ isPreAppStart }) => {
 						return SpanUtils.createAndExecuteSpan(self.mode, () => originalSign.apply(this, args), {
@@ -6030,18 +6173,19 @@ var JsonwebtokenInstrumentation = class extends TdInstrumentationBase {
 			throw error;
 		}
 	}
-	async handleReplayVerify(verifyConfig, inputValue, spanInfo) {
+	async handleReplayVerify(verifyConfig, inputValue, spanInfo, stackTrace) {
 		logger.debug(`[JsonwebtokenInstrumentation] Replaying JWT verify`);
 		const mockData = await findMockResponseAsync({
 			mockRequestData: {
 				traceId: spanInfo.traceId,
 				spanId: spanInfo.spanId,
-				name: inputValue.token,
+				name: "jsonwebtoken.verify",
 				packageName: "jsonwebtoken",
 				instrumentationName: this.INSTRUMENTATION_NAME,
 				submoduleName: "verify",
 				inputValue,
-				kind: SpanKind.CLIENT
+				kind: SpanKind.CLIENT,
+				stackTrace
 			},
 			tuskDrift: this.tuskDrift
 		});
@@ -6076,18 +6220,19 @@ var JsonwebtokenInstrumentation = class extends TdInstrumentationBase {
 			return;
 		} else return result;
 	}
-	async handleReplaySign(signConfig, inputValue, spanInfo) {
+	async handleReplaySign(signConfig, inputValue, spanInfo, stackTrace) {
 		logger.debug(`[JsonwebtokenInstrumentation] Replaying JWT sign`);
 		const mockData = await findMockResponseAsync({
 			mockRequestData: {
 				traceId: spanInfo?.traceId,
 				spanId: spanInfo?.spanId,
-				name: JSON.stringify(inputValue.payload),
+				name: "jsonwebtoken.sign",
 				packageName: "jsonwebtoken",
 				instrumentationName: this.INSTRUMENTATION_NAME,
 				submoduleName: "sign",
 				inputValue,
-				kind: SpanKind.CLIENT
+				kind: SpanKind.CLIENT,
+				stackTrace
 			},
 			tuskDrift: this.tuskDrift
 		});
@@ -6491,11 +6636,12 @@ var FetchInstrumentation = class extends TdInstrumentationBase {
 		this.originalFetch = globalThis.fetch;
 		const self = this;
 		globalThis.fetch = function(input, init) {
-			return self._handleFetchRequest(input, init);
+			const stackTrace = captureStackTrace(["FetchInstrumentation"]);
+			return self._handleFetchRequest(input, init, stackTrace);
 		};
 		logger.debug("Global fetch patching complete");
 	}
-	async _handleFetchRequest(input, init) {
+	async _handleFetchRequest(input, init, stackTrace) {
 		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
 		const method = init?.method || "GET";
 		const headers = init?.headers || {};
@@ -6525,7 +6671,7 @@ var FetchInstrumentation = class extends TdInstrumentationBase {
 				inputValue,
 				isPreAppStart: false
 			}, (spanInfo) => {
-				return this._handleReplayFetch(inputValue, spanInfo);
+				return this._handleReplayFetch(inputValue, spanInfo, stackTrace);
 			});
 		} });
 		else if (this.mode === TuskDriftMode.RECORD) return handleRecordMode({
@@ -6606,7 +6752,7 @@ var FetchInstrumentation = class extends TdInstrumentationBase {
 			});
 		});
 	}
-	async _handleReplayFetch(inputValue, spanInfo) {
+	async _handleReplayFetch(inputValue, spanInfo, stackTrace) {
 		const mockData = await findMockResponseAsync({
 			mockRequestData: {
 				traceId: spanInfo.traceId,
@@ -6617,7 +6763,8 @@ var FetchInstrumentation = class extends TdInstrumentationBase {
 				instrumentationName: this.INSTRUMENTATION_NAME,
 				submoduleName: inputValue.method,
 				inputValue,
-				kind: SpanKind.CLIENT
+				kind: SpanKind.CLIENT,
+				stackTrace
 			},
 			tuskDrift: this.tuskDrift,
 			inputValueSchemaMerges: {
@@ -6892,21 +7039,23 @@ var IORedisInstrumentation = class extends TdInstrumentationBase {
 						port: this.options?.port
 					}
 				};
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalSendCommand.apply(this, arguments), {
-						name: `ioredis.${commandName}`,
-						kind: SpanKind.CLIENT,
-						submodule: commandName,
-						packageType: PackageType.REDIS,
-						packageName: "ioredis",
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
-						return self._handleReplaySendCommand(spanInfo, cmd, inputValue, commandName);
-					});
-				} });
-				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
+				if (self.mode === TuskDriftMode.REPLAY) {
+					const stackTrace = captureStackTrace(["IORedisInstrumentation"]);
+					return handleReplayMode({ replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalSendCommand.apply(this, arguments), {
+							name: `ioredis.${commandName}`,
+							kind: SpanKind.CLIENT,
+							submodule: commandName,
+							packageType: PackageType.REDIS,
+							packageName: "ioredis",
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							return self._handleReplaySendCommand(spanInfo, cmd, inputValue, commandName, stackTrace);
+						});
+					} });
+				} else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalSendCommand.apply(this, arguments),
 					recordModeHandler: ({ isPreAppStart }) => {
 						return SpanUtils.createAndExecuteSpan(self.mode, () => originalSendCommand.apply(this, arguments), {
@@ -7068,7 +7217,7 @@ var IORedisInstrumentation = class extends TdInstrumentationBase {
 		});
 		return promise;
 	}
-	async _handleReplaySendCommand(spanInfo, cmd, inputValue, commandName) {
+	async _handleReplaySendCommand(spanInfo, cmd, inputValue, commandName, stackTrace) {
 		logger.debug(`[IORedisInstrumentation] Replaying IORedis command ${cmd.name}`);
 		const mockData = await findMockResponseAsync({
 			mockRequestData: {
@@ -7079,7 +7228,8 @@ var IORedisInstrumentation = class extends TdInstrumentationBase {
 				packageName: "ioredis",
 				instrumentationName: this.INSTRUMENTATION_NAME,
 				submoduleName: cmd.name,
-				kind: SpanKind.CLIENT
+				kind: SpanKind.CLIENT,
+				stackTrace
 			},
 			tuskDrift: this.tuskDrift
 		});
@@ -7528,21 +7678,23 @@ var GrpcInstrumentation = class GrpcInstrumentation extends TdInstrumentationBas
 						jsonableStringMap
 					}
 				};
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => original.apply(this, args), {
-						name: "grpc.client.unary",
-						kind: SpanKind.CLIENT,
-						submodule: "client",
-						packageType: PackageType.GRPC,
-						packageName: GRPC_MODULE_NAME,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
-						return self._handleReplayUnaryRequest(spanInfo, inputValue, callback, MetadataConstructor);
-					});
-				} });
-				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
+				if (self.mode === TuskDriftMode.REPLAY) {
+					const stackTrace = captureStackTrace(["GrpcInstrumentation"]);
+					return handleReplayMode({ replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => original.apply(this, args), {
+							name: "grpc.client.unary",
+							kind: SpanKind.CLIENT,
+							submodule: "client",
+							packageType: PackageType.GRPC,
+							packageName: GRPC_MODULE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							return self._handleReplayUnaryRequest(spanInfo, inputValue, callback, MetadataConstructor, stackTrace);
+						});
+					} });
+				} else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => original.apply(this, args),
 					recordModeHandler: ({ isPreAppStart }) => {
 						return SpanUtils.createAndExecuteSpan(self.mode, () => original.apply(this, args), {
@@ -7674,7 +7826,7 @@ var GrpcInstrumentation = class GrpcInstrumentation extends TdInstrumentationBas
 	isGrpcErrorOutput(result) {
 		return "error" in result;
 	}
-	async _handleReplayUnaryRequest(spanInfo, inputValue, callback, MetadataConstructor) {
+	async _handleReplayUnaryRequest(spanInfo, inputValue, callback, MetadataConstructor, stackTrace) {
 		logger.debug(`[GrpcInstrumentation] Replaying gRPC unary request`);
 		const mockData = await findMockResponseAsync({
 			mockRequestData: {
@@ -7685,7 +7837,8 @@ var GrpcInstrumentation = class GrpcInstrumentation extends TdInstrumentationBas
 				packageName: GRPC_MODULE_NAME,
 				instrumentationName: this.INSTRUMENTATION_NAME,
 				submoduleName: "client",
-				kind: SpanKind.CLIENT
+				kind: SpanKind.CLIENT,
+				stackTrace
 			},
 			tuskDrift: this.tuskDrift
 		});
@@ -10315,7 +10468,7 @@ var SpanTransformer = class SpanTransformer {
 		if (transformMetadataString) try {
 			transformMetadata = JSON.parse(transformMetadataString);
 		} catch (error) {
-			logger.warn("Failed to parse transform metadata", error);
+			logger.warn("[SpanTransformer] Failed to parse transform metadata", error);
 		}
 		const originalDate = OriginalGlobalUtils.getOriginalDate();
 		return {
@@ -10701,7 +10854,7 @@ var ProtobufCommunicator = class {
 			requestId,
 			tags: {},
 			outboundSpan: cleanSpan,
-			stackTrace: this.getStackTrace()
+			stackTrace: cleanSpan?.stackTrace
 		});
 		const sdkMessage = SDKMessage.create({
 			type: MessageType.MOCK_REQUEST,
@@ -10742,7 +10895,7 @@ var ProtobufCommunicator = class {
 			requestId,
 			tags: {},
 			outboundSpan: cleanSpan,
-			stackTrace: this.getStackTrace()
+			stackTrace: cleanSpan?.stackTrace
 		});
 		const sdkMessage = SDKMessage.create({
 			type: MessageType.MOCK_REQUEST,
@@ -11034,7 +11187,7 @@ var TuskDriftCore = class TuskDriftCore {
 				const packageName = this.getPackageName(modulePath);
 				if (packageName && TuskDriftInstrumentationModuleNames.includes(packageName)) alreadyRequiredModuleNames.add(packageName);
 			}
-		} else logger.warn("Running in ES Module mode. Cannot detect pre-loaded instrumentation modules.");
+		} else logger.debug("Running in ES Module mode. Cannot detect pre-loaded instrumentation modules.");
 		return alreadyRequiredModuleNames;
 	}
 	static getInstance() {
@@ -11140,13 +11293,13 @@ var TuskDriftCore = class TuskDriftCore {
 	}
 	initialize(initParams) {
 		initializeGlobalLogger({
-			logLevel: initParams.logLevel || "silent",
+			logLevel: initParams.logLevel || "info",
 			prefix: "TuskDrift"
 		});
 		this.samplingRate = this.config.recording?.sampling_rate ?? 1;
 		this.initParams = initParams;
 		if (!this.initParams.env) {
-			const nodeEnv = OriginalGlobalUtils.getOriginalProcessEnvVar("NODE_ENV") || "unknown";
+			const nodeEnv = OriginalGlobalUtils.getOriginalProcessEnvVar("NODE_ENV") || "development";
 			logger.warn(`Environment not provided in initialization parameters. Using '${nodeEnv}' as the environment.`);
 			this.initParams.env = nodeEnv;
 		}
@@ -11224,8 +11377,8 @@ var TuskDriftCore = class TuskDriftCore {
 		}
 		this.appReady = true;
 		logger.debug("Application marked as ready");
-		if (this.mode === TuskDriftMode.REPLAY) logger.info("Replay mode active - ready to serve mocked responses");
-		else if (this.mode === TuskDriftMode.RECORD) logger.info("Record mode active - capturing requests and responses");
+		if (this.mode === TuskDriftMode.REPLAY) logger.debug("Replay mode active - ready to serve mocked responses");
+		else if (this.mode === TuskDriftMode.RECORD) logger.debug("Record mode active - capturing inbound requests and responses");
 	}
 	async sendInboundSpanForReplay(span) {
 		try {