@use-tusk/drift-node-sdk 0.1.8 → 0.1.9

package/dist/index.cjs

@@ -229,17 +229,28 @@ function withTuskDrift(nextConfig = {}, options = {}) {
 			if (webpackOptions.isServer) {
 				const originalExternals = webpackConfig.externals;
 				const coreExternals = ["require-in-the-middle", "jsonpath"];
+				const externalsMapping = {};
+				try {
+					const sdkPath = require.resolve("@use-tusk/drift-node-sdk");
+					const sdkNodeModules = require("path").resolve(sdkPath, "../..", "node_modules");
+					for (const pkg of coreExternals) {
+						const pkgPath = require("path").join(sdkNodeModules, pkg);
+						externalsMapping[pkg] = `commonjs ${pkgPath}`;
+						debugLog(debug, `Mapped external ${pkg} -> ${pkgPath}`);
+					}
+				} catch (e) {
+					warn(suppressAllWarnings || false, `Could not resolve SDK path, falling back to regular externals: ${e instanceof Error ? e.message : String(e)}`);
+					for (const pkg of coreExternals) externalsMapping[pkg] = `commonjs ${pkg}`;
+				}
 				if (!originalExternals) {
-					webpackConfig.externals = coreExternals;
-					debugLog(debug, "Created new externals array with core packages");
+					webpackConfig.externals = [externalsMapping];
+					debugLog(debug, "Created new externals with SDK paths");
 				} else if (Array.isArray(originalExternals)) {
-					for (const pkg of coreExternals) if (!originalExternals.includes(pkg)) {
-						originalExternals.push(pkg);
-						debugLog(debug, `Added ${pkg} to webpack externals`);
-					}
+					originalExternals.push(externalsMapping);
+					debugLog(debug, "Added SDK paths to existing externals array");
 				} else {
-					webpackConfig.externals = [originalExternals, ...coreExternals];
-					debugLog(debug, "Wrapped existing externals with core packages");
+					webpackConfig.externals = [originalExternals, externalsMapping];
+					debugLog(debug, "Wrapped existing externals with SDK paths");
 				}
 			}
 			if (typeof config.webpack === "function") return config.webpack(webpackConfig, webpackOptions);
@@ -275,7 +286,7 @@ var TdInstrumentationAbstract = class {
 
 //#endregion
 //#region package.json
-var version = "0.1.8";
+var version = "0.1.9";
 
 //#endregion
 //#region src/version.ts
@@ -1867,6 +1878,24 @@ var TdMockClientRequest = class TdMockClientRequest extends events.EventEmitter
 	async startPlayback() {
 		this.playbackStarted = true;
 		try {
+			if (!this.spanInfo) {
+				logger.debug(`[TdMockClientRequest] Background request detected (no spanInfo), returning 200 OK without mock lookup`);
+				const emptyResponse = {
+					statusCode: 200,
+					statusMessage: "OK",
+					headers: {},
+					httpVersion: "1.1",
+					httpVersionMajor: 1,
+					httpVersionMinor: 1,
+					complete: true,
+					readable: false
+				};
+				this.emit("finish");
+				process.nextTick(() => {
+					this.playResponse(emptyResponse);
+				});
+				return;
+			}
 			const rawInputValue = {
 				method: this.method || "GET",
 				path: this.path,
@@ -1904,7 +1933,10 @@ var TdMockClientRequest = class TdMockClientRequest extends events.EventEmitter
 					headers: { matchImportance: 0 }
 				}
 			});
-			if (!mockData) throw new Error(`No matching mock found for ${this.method} ${this.path}`);
+			if (!mockData) {
+				logger.warn(`[TdMockClientRequest] No mock data found for ${this.method} ${this.path}`);
+				throw new Error(`[TdMockClientRequest] No matching mock found for ${this.method} ${this.path}`);
+			}
 			this.emit("finish");
 			process.nextTick(() => {
 				this.playResponse(mockData.result);
@@ -2090,11 +2122,19 @@ function handleRecordMode({ originalFunctionCall, recordModeHandler, spanKind })
 /**
 * Utility function that abstracts the common replay mode pattern of checking if the app is ready
 *
-* Currently just calls the replayModeHandler, but we might add some logic here in the future.
+* If this is a background request (app is ready and no parent span), calls the backgroundRequestHandler.
+* Otherwise, calls the replayModeHandler.
 * @param replayModeHandler - Function that handles the replay mode logic when app is ready
-* @returns The result from either originalFunctionCall or replayModeHandler
+* @param noOpRequestHandler - Function to handle no-op requests, called for background requests
+* @returns The result from either noOpRequestHandler or replayModeHandler
 */
-function handleReplayMode({ replayModeHandler }) {
+function handleReplayMode({ replayModeHandler, noOpRequestHandler, isServerRequest }) {
+	const isAppReady = TuskDriftCore.getInstance().isAppReady();
+	const currentSpanInfo = SpanUtils.getCurrentSpanInfo();
+	if (isAppReady && !currentSpanInfo && !isServerRequest) {
+		logger.debug(`[ModeUtils] Handling no-op request`);
+		return noOpRequestHandler();
+	}
 	return replayModeHandler();
 }
 
@@ -2613,52 +2653,58 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 			logger.debug(`[HttpInstrumentation] Dropping inbound request due to transforms: ${method} ${url}`);
 			return originalHandler.call(this);
 		}
-		if (this.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-			if (req.headers["accept-encoding"]) delete req.headers["accept-encoding"];
-			const fullUrl = `${spanProtocol}://${req.headers.host || "localhost"}${url}`;
-			const inputValue = {
-				method,
-				url: fullUrl,
-				target,
-				headers: req.headers,
-				httpVersion: req.httpVersion,
-				remoteAddress: req.socket?.remoteAddress,
-				remotePort: req.socket?.remotePort
-			};
-			const replayTraceId = this.replayHooks.extractTraceIdFromHeaders(req);
-			if (!replayTraceId) {
-				logger.debug(`[HttpInstrumentation] No trace id found in headers`, req.headers);
-				return originalHandler.call(this);
-			}
-			logger.debug(`[HttpInstrumentation] Setting replay trace id`, replayTraceId);
-			const envVars = this.replayHooks.extractEnvVarsFromHeaders(req);
-			if (envVars) EnvVarTracker.setEnvVars(replayTraceId, envVars);
-			const ctxWithReplayTraceId = SpanUtils.setCurrentReplayTraceId(replayTraceId);
-			if (!ctxWithReplayTraceId) throw new Error("Error setting current replay trace id");
-			return __opentelemetry_api.context.with(ctxWithReplayTraceId, () => {
-				return SpanUtils.createAndExecuteSpan(this.mode, () => originalHandler.call(this), {
-					name: `${target}`,
-					kind: __opentelemetry_api.SpanKind.SERVER,
-					packageName: spanProtocol,
-					submodule: method,
-					packageType: __use_tusk_drift_schemas_core_span.PackageType.HTTP,
-					instrumentationName: this.INSTRUMENTATION_NAME,
-					inputValue,
-					inputSchemaMerges: { headers: { matchImportance: 0 } },
-					isPreAppStart: false
-				}, (spanInfo) => {
-					return this._handleInboundRequestInSpan({
-						req,
-						res,
-						originalHandler,
-						spanInfo,
+		if (this.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+			noOpRequestHandler: () => {
+				throw new Error(`[HttpInstrumentation] Should never call noOpRequestHandler for server requests`);
+			},
+			isServerRequest: true,
+			replayModeHandler: () => {
+				if (req.headers["accept-encoding"]) delete req.headers["accept-encoding"];
+				const fullUrl = `${spanProtocol}://${req.headers.host || "localhost"}${url}`;
+				const inputValue = {
+					method,
+					url: fullUrl,
+					target,
+					headers: req.headers,
+					httpVersion: req.httpVersion,
+					remoteAddress: req.socket?.remoteAddress,
+					remotePort: req.socket?.remotePort
+				};
+				const replayTraceId = this.replayHooks.extractTraceIdFromHeaders(req);
+				if (!replayTraceId) {
+					logger.debug(`[HttpInstrumentation] No trace id found in headers`, req.headers);
+					return originalHandler.call(this);
+				}
+				logger.debug(`[HttpInstrumentation] Setting replay trace id`, replayTraceId);
+				const envVars = this.replayHooks.extractEnvVarsFromHeaders(req);
+				if (envVars) EnvVarTracker.setEnvVars(replayTraceId, envVars);
+				const ctxWithReplayTraceId = SpanUtils.setCurrentReplayTraceId(replayTraceId);
+				if (!ctxWithReplayTraceId) throw new Error("Error setting current replay trace id");
+				return __opentelemetry_api.context.with(ctxWithReplayTraceId, () => {
+					return SpanUtils.createAndExecuteSpan(this.mode, () => originalHandler.call(this), {
+						name: `${target}`,
+						kind: __opentelemetry_api.SpanKind.SERVER,
+						packageName: spanProtocol,
+						submodule: method,
+						packageType: __use_tusk_drift_schemas_core_span.PackageType.HTTP,
+						instrumentationName: this.INSTRUMENTATION_NAME,
 						inputValue,
-						schemaMerges: { headers: { matchImportance: 0 } },
-						protocol: spanProtocol
+						inputSchemaMerges: { headers: { matchImportance: 0 } },
+						isPreAppStart: false
+					}, (spanInfo) => {
+						return this._handleInboundRequestInSpan({
+							req,
+							res,
+							originalHandler,
+							spanInfo,
+							inputValue,
+							schemaMerges: { headers: { matchImportance: 0 } },
+							protocol: spanProtocol
+						});
 					});
 				});
-			});
-		} });
+			}
+		});
 		else if (this.mode === TuskDriftMode.RECORD) {
 			if (method.toUpperCase() === "OPTIONS" || !!req.headers["access-control-request-method"]) return originalHandler.call(this);
 			logger.debug(`[HttpInstrumentation] Creating server span for ${method} ${url}`);
@@ -3139,37 +3185,48 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 				const requestProtocol = self._normalizeProtocol(requestOptions.protocol || void 0, protocol);
 				if (self.mode === TuskDriftMode.REPLAY) {
 					const stackTrace = captureStackTrace(["HttpInstrumentation"]);
-					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: __opentelemetry_api.SpanKind.CLIENT,
-							packageName: requestProtocol,
-							packageType: __use_tusk_drift_schemas_core_span.PackageType.HTTP,
-							instrumentationName: self.INSTRUMENTATION_NAME,
-							submodule: method,
-							inputValue,
-							isPreAppStart: false
-						}, (spanInfo) => {
+					return handleReplayMode({
+						noOpRequestHandler: () => {
 							return self.replayHooks.handleOutboundReplayRequest({
 								method,
 								requestOptions,
 								protocol: requestProtocol,
-								args,
-								spanInfo,
-								stackTrace
+								args
 							});
-						});
-					} });
+						},
+						isServerRequest: false,
+						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: __opentelemetry_api.SpanKind.CLIENT,
+								packageName: requestProtocol,
+								packageType: __use_tusk_drift_schemas_core_span.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({
 					originalFunctionCall: () => originalRequest.apply(this, args),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -3221,36 +3278,47 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 				} else requestOptions = args[0] || {};
 				const 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, () => originalGet.apply(this, args), {
-						name: requestOptions.path || `${requestProtocol.toUpperCase()} ${method}`,
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						packageName: requestProtocol,
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.HTTP,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						submodule: method,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
 						return self.replayHooks.handleOutboundReplayRequest({
 							method,
 							requestOptions,
 							protocol: requestProtocol,
-							args,
-							spanInfo
+							args
 						});
-					});
-				} });
+					},
+					isServerRequest: false,
+					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, () => originalGet.apply(this, args), {
+							name: requestOptions.path || `${requestProtocol.toUpperCase()} ${method}`,
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							packageName: requestProtocol,
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.HTTP,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							submodule: method,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							return self.replayHooks.handleOutboundReplayRequest({
+								method,
+								requestOptions,
+								protocol: requestProtocol,
+								args,
+								spanInfo
+							});
+						});
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalGet.apply(this, args),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -3646,7 +3714,8 @@ var TdPgClientMock = class extends events.EventEmitter {
 			clientType: "client"
 		};
 		const inputValue = createMockInputValue(rawInputValue);
-		return this.pgInstrumentation.handleReplayQuery(queryConfig, inputValue, this.spanInfo, stackTrace);
+		if (this.spanInfo) return this.pgInstrumentation.handleReplayQuery(queryConfig, inputValue, this.spanInfo, stackTrace);
+		else return this.pgInstrumentation.handleNoOpReplayQuery(queryConfig);
 	}
 	release() {
 		this.emit("end");
@@ -3751,22 +3820,28 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 				};
 				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: __opentelemetry_api.SpanKind.CLIENT,
-							submodule: "query",
-							packageType: __use_tusk_drift_schemas_core_span.PackageType.PG,
-							packageName,
-							instrumentationName: self.INSTRUMENTATION_NAME,
-							inputValue,
-							isPreAppStart: false
-						}, (spanInfo) => {
-							return self.handleReplayQuery(queryConfig, inputValue, spanInfo, stackTrace);
-						});
-					} });
+					return handleReplayMode({
+						noOpRequestHandler: () => {
+							return self.handleNoOpReplayQuery(queryConfig);
+						},
+						isServerRequest: false,
+						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: __opentelemetry_api.SpanKind.CLIENT,
+								submodule: "query",
+								packageType: __use_tusk_drift_schemas_core_span.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 }) => {
@@ -3796,20 +3871,29 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 		return (originalConnect) => {
 			return function connect(callback) {
 				const inputValue = { clientType };
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalConnect.apply(this, [callback]), {
-						name: `pg.connect`,
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "connect",
-						packageName: "pg",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.PG,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
-						return self._handleReplayConnect(callback);
-					});
-				} });
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
+						if (callback) {
+							process.nextTick(() => callback(null));
+							return;
+						} else return Promise.resolve();
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalConnect.apply(this, [callback]), {
+							name: `pg.connect`,
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "connect",
+							packageName: "pg",
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.PG,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							return self._handleReplayConnect(callback);
+						});
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalConnect.apply(this, [callback]),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -3913,6 +3997,16 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 			throw error;
 		});
 	}
+	async handleNoOpReplayQuery(queryConfig) {
+		const emptyResult = {
+			rows: [],
+			rowCount: 0
+		};
+		if (queryConfig.callback) {
+			process.nextTick(() => queryConfig.callback(null, emptyResult));
+			return;
+		} else return Promise.resolve(emptyResult);
+	}
 	async handleReplayQuery(queryConfig, inputValue, spanInfo, stackTrace) {
 		logger.debug(`[PgInstrumentation] Replaying PG query`);
 		const packageName = inputValue.clientType === "pool" ? "pg-pool" : "pg";
@@ -3934,10 +4028,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 		if (!mockData) {
 			const queryText = queryConfig.text || inputValue.text || "UNKNOWN_QUERY";
 			logger.warn(`[PgInstrumentation] No mock data found for PG query: ${queryText}`);
-			if (queryConfig.callback) {
-				process.nextTick(() => queryConfig.callback(/* @__PURE__ */ new Error("No mock data found")));
-				return;
-			} else return Promise.reject(/* @__PURE__ */ new Error("No mock data found"));
+			throw new Error(`[PgInstrumentation] No mock data found for PG query: ${queryText}`);
 		}
 		const processedResult = this.convertPostgresTypes(mockData.result);
 		if (queryConfig.callback) {
@@ -4072,20 +4163,30 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 		return (originalConnect) => {
 			return function connect(callback) {
 				const inputValue = { clientType: "pool" };
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalConnect.apply(this, [callback]), {
-						name: `pg-pool.connect`,
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "connect",
-						packageName: "pg-pool",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.PG,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
-						return self._handleReplayPoolConnect(spanInfo, callback);
-					});
-				} });
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
+						const mockClient = new TdPgClientMock(self);
+						if (callback) {
+							process.nextTick(() => callback(null, mockClient, () => {}));
+							return;
+						} else return Promise.resolve(mockClient);
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalConnect.apply(this, [callback]), {
+							name: `pg-pool.connect`,
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "connect",
+							packageName: "pg-pool",
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.PG,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							return self._handleReplayPoolConnect(spanInfo, callback);
+						});
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalConnect.apply(this, [callback]),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -4248,23 +4349,35 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 			connectionString: connectionString ? this._sanitizeConnectionString(connectionString) : void 0,
 			options: options ? this._sanitizeConnectionOptions(options) : void 0
 		};
-		if (this.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-			return SpanUtils.createAndExecuteSpan(this.mode, () => {
-				const sqlInstance = originalFunction(...args);
-				return this._wrapSqlInstance(sqlInstance);
-			}, {
-				name: "postgres.connect",
-				kind: __opentelemetry_api.SpanKind.CLIENT,
-				submodule: "connect",
-				packageType: __use_tusk_drift_schemas_core_span.PackageType.PG,
-				packageName: "postgres",
-				instrumentationName: this.INSTRUMENTATION_NAME,
-				inputValue,
-				isPreAppStart: false
-			}, (spanInfo) => {
-				return this._handleReplayConnect(spanInfo, originalFunction, args);
-			});
-		} });
+		if (this.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+			noOpRequestHandler: () => {
+				try {
+					const sqlInstance = originalFunction(...args);
+					return this._wrapSqlInstance(sqlInstance);
+				} catch (error) {
+					logger.debug(`[PostgresInstrumentation] Postgres connection error in replay: ${error.message}`);
+					throw error;
+				}
+			},
+			isServerRequest: false,
+			replayModeHandler: () => {
+				return SpanUtils.createAndExecuteSpan(this.mode, () => {
+					const sqlInstance = originalFunction(...args);
+					return this._wrapSqlInstance(sqlInstance);
+				}, {
+					name: "postgres.connect",
+					kind: __opentelemetry_api.SpanKind.CLIENT,
+					submodule: "connect",
+					packageType: __use_tusk_drift_schemas_core_span.PackageType.PG,
+					packageName: "postgres",
+					instrumentationName: this.INSTRUMENTATION_NAME,
+					inputValue,
+					isPreAppStart: false
+				}, (spanInfo) => {
+					return this._handleReplayConnect(originalFunction, args);
+				});
+			}
+		});
 		else if (this.mode === TuskDriftMode.RECORD) return handleRecordMode({
 			originalFunctionCall: () => {
 				const sqlInstance = originalFunction(...args);
@@ -4324,20 +4437,13 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 		}
 		return wrappedInstance;
 	}
-	_handleReplayConnect(spanInfo, originalFunction, args) {
+	_handleReplayConnect(originalFunction, args) {
 		logger.debug(`[PostgresInstrumentation] Replaying Postgres connection`);
 		try {
 			const sqlInstance = originalFunction(...args);
-			const wrappedInstance = this._wrapSqlInstance(sqlInstance);
-			SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: { connected: true } });
-			SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.OK });
-			return wrappedInstance;
+			return this._wrapSqlInstance(sqlInstance);
 		} catch (error) {
 			logger.debug(`[PostgresInstrumentation] Postgres connection error in replay: ${error.message}`);
-			SpanUtils.endSpan(spanInfo.span, {
-				code: __opentelemetry_api.SpanStatusCode.ERROR,
-				message: error.message
-			});
 			throw error;
 		}
 	}
@@ -4397,26 +4503,30 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 		};
 		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: __opentelemetry_api.SpanKind.CLIENT,
-					submodule: "query",
-					packageType: __use_tusk_drift_schemas_core_span.PackageType.PG,
-					packageName: "postgres",
-					instrumentationName: this.INSTRUMENTATION_NAME,
-					inputValue,
-					isPreAppStart: false
-				}, (spanInfo) => {
-					return this.handleReplaySqlQuery({
-						inputValue,
-						spanInfo,
-						submodule: "query",
+			return handleReplayMode({
+				noOpRequestHandler: () => {},
+				isServerRequest: false,
+				replayModeHandler: () => {
+					return SpanUtils.createAndExecuteSpan(this.mode, () => originalSql.call(this, strings, ...values), {
 						name: "postgres.query",
-						stackTrace
+						kind: __opentelemetry_api.SpanKind.CLIENT,
+						submodule: "query",
+						packageType: __use_tusk_drift_schemas_core_span.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({
 			originalFunctionCall: () => originalSql.call(this, strings, ...values),
 			recordModeHandler: ({ isPreAppStart }) => {
@@ -4450,28 +4560,34 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 		};
 		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: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "unsafe",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.PG,
-						packageName: "postgres",
-						instrumentationName: this.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
-						return this.handleReplayUnsafeQuery({
-							inputValue,
-							spanInfo,
-							submodule: "unsafe",
+			return handleReplayMode({
+				noOpRequestHandler: () => {
+					return Promise.resolve(void 0);
+				},
+				isServerRequest: false,
+				replayModeHandler: () => {
+					return this._createPendingQueryWrapper(() => {
+						return SpanUtils.createAndExecuteSpan(this.mode, () => executeUnsafe(), {
 							name: "postgres.unsafe",
-							stackTrace
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "unsafe",
+							packageType: __use_tusk_drift_schemas_core_span.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({
 			originalFunctionCall: executeUnsafe,
 			recordModeHandler: ({ isPreAppStart }) => {
@@ -4504,20 +4620,24 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 		};
 		if (this.mode === TuskDriftMode.REPLAY) {
 			const stackTrace = captureStackTrace(["PostgresInstrumentation"]);
-			return handleReplayMode({ replayModeHandler: () => {
-				return SpanUtils.createAndExecuteSpan(this.mode, () => executeBegin(), {
-					name: "postgres.begin",
-					kind: __opentelemetry_api.SpanKind.CLIENT,
-					submodule: "transaction",
-					packageType: __use_tusk_drift_schemas_core_span.PackageType.PG,
-					packageName: "postgres",
-					instrumentationName: this.INSTRUMENTATION_NAME,
-					inputValue,
-					isPreAppStart: false
-				}, (spanInfo) => {
-					return this._handleReplayBeginTransaction(spanInfo, options, stackTrace);
-				});
-			} });
+			return handleReplayMode({
+				noOpRequestHandler: () => {},
+				isServerRequest: false,
+				replayModeHandler: () => {
+					return SpanUtils.createAndExecuteSpan(this.mode, () => executeBegin(), {
+						name: "postgres.begin",
+						kind: __opentelemetry_api.SpanKind.CLIENT,
+						submodule: "transaction",
+						packageType: __use_tusk_drift_schemas_core_span.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 }) => {
@@ -4633,28 +4753,13 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 		});
 		if (!mockData) {
 			logger.warn(`[PostgresInstrumentation] No mock data found for transaction BEGIN`);
-			SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.OK });
-			return;
+			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") {
-			SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: {
-				status: "committed",
-				result: transactionResult.result
-			} });
-			SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.OK });
-			return transactionResult.result;
-		} else {
+		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";
-			SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: {
-				status: "rolled_back",
-				error: errorMessage
-			} });
-			SpanUtils.endSpan(spanInfo.span, {
-				code: __opentelemetry_api.SpanStatusCode.ERROR,
-				message: errorMessage
-			});
 			throw new Error(errorMessage);
 		}
 	}
@@ -4701,7 +4806,7 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 		if (!mockData) {
 			const queryText = inputValue.query || "UNKNOWN_QUERY";
 			logger.warn(`[PostgresInstrumentation] No mock data found for Postgres sql query: ${queryText}`);
-			return;
+			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);
@@ -4732,7 +4837,7 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 		if (!mockData) {
 			const queryText = inputValue.query || "UNKNOWN_QUERY";
 			logger.warn(`[PostgresInstrumentation] No mock data found for Postgres unsafe query: ${queryText}`);
-			return;
+			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);
@@ -4821,7 +4926,7 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 * Extends EventEmitter to properly handle all connection methods and events
 */
 var TdMysql2ConnectionMock = class extends events.EventEmitter {
-	constructor(mysql2Instrumentation, spanInfo, clientType = "poolConnection") {
+	constructor(mysql2Instrumentation, clientType = "poolConnection", spanInfo) {
 		super();
 		this.threadId = null;
 		this.config = {
@@ -4857,7 +4962,8 @@ var TdMysql2ConnectionMock = class extends events.EventEmitter {
 			clientType: this.clientType
 		};
 		const inputValue = createMockInputValue(rawInputValue);
-		return this.mysql2Instrumentation.handleReplayQuery(queryConfig, inputValue, this.spanInfo, stackTrace);
+		if (this.spanInfo) return this.mysql2Instrumentation.handleReplayQuery(queryConfig, inputValue, this.spanInfo, stackTrace);
+		else return this.mysql2Instrumentation.handleNoOpReplayQuery(queryConfig);
 	}
 	execute(...args) {
 		logger.debug(`[TdMysql2ConnectionMock] Mock connection execute intercepted in REPLAY mode`);
@@ -4881,7 +4987,8 @@ var TdMysql2ConnectionMock = class extends events.EventEmitter {
 			clientType: this.clientType
 		};
 		const inputValue = createMockInputValue(rawInputValue);
-		return this.mysql2Instrumentation.handleReplayQuery(queryConfig, inputValue, this.spanInfo, stackTrace);
+		if (this.spanInfo) return this.mysql2Instrumentation.handleReplayQuery(queryConfig, inputValue, this.spanInfo, stackTrace);
+		else return this.mysql2Instrumentation.handleNoOpReplayQuery(queryConfig);
 	}
 	release() {
 		this.emit("end");
@@ -4981,6 +5088,27 @@ var TdMysql2QueryMock = class {
 		return this._handleQuery(queryConfig, inputValue, spanInfo, spanName, submoduleName, stackTrace);
 	}
 	/**
+	* Handle background query requests (outside of trace context)
+	* Returns an EventEmitter that immediately completes with empty results
+	*/
+	handleNoOpReplayQuery(queryConfig) {
+		logger.debug(`[Mysql2Instrumentation] Background query detected, returning empty result`);
+		const emitter = new events.EventEmitter();
+		emitter.then = function(onResolve, onReject) {
+			return new Promise((resolve) => {
+				emitter.once("end", () => {
+					resolve([[], []]);
+				});
+			}).then(onResolve, onReject);
+		};
+		process.nextTick(() => {
+			const callback = queryConfig.callback;
+			if (callback) callback(null, [], []);
+			emitter.emit("end");
+		});
+		return emitter;
+	}
+	/**
 	* 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
@@ -5005,12 +5133,7 @@ var TdMysql2QueryMock = class {
 				if (!mockData) {
 					const sql = queryConfig.sql || inputValue.sql || "UNKNOWN_QUERY";
 					logger.warn(`[Mysql2Instrumentation] No mock data found for MySQL2 query: ${sql}`);
-					const error = /* @__PURE__ */ new Error("No mock data found");
-					process.nextTick(() => {
-						if (queryConfig.callback) queryConfig.callback(error);
-						emitter.emit("error", error);
-					});
-					return;
+					throw new Error(`[Mysql2Instrumentation] No matching mock found for query: ${sql}`);
 				}
 				const processedResult = this._convertMysql2Types(mockData.result);
 				storedRows = processedResult.rows;
@@ -5335,21 +5458,27 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 				};
 				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: __opentelemetry_api.SpanKind.CLIENT,
-							submodule: "query",
-							packageType: __use_tusk_drift_schemas_core_span.PackageType.MYSQL,
-							packageName: "mysql2",
-							instrumentationName: self.INSTRUMENTATION_NAME,
-							inputValue,
-							isPreAppStart: false
-						}, (spanInfo) => {
-							return self.handleReplayQuery(queryConfig, inputValue, spanInfo, "query", stackTrace);
-						});
-					} });
+					return handleReplayMode({
+						noOpRequestHandler: () => {
+							return self.queryMock.handleNoOpReplayQuery(queryConfig);
+						},
+						isServerRequest: false,
+						replayModeHandler: () => {
+							const spanName = `mysql2.${clientType}.query`;
+							return SpanUtils.createAndExecuteSpan(self.mode, () => originalQuery.apply(this, args), {
+								name: spanName,
+								kind: __opentelemetry_api.SpanKind.CLIENT,
+								submodule: "query",
+								packageType: __use_tusk_drift_schemas_core_span.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 }) => {
@@ -5394,21 +5523,27 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 				};
 				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: __opentelemetry_api.SpanKind.CLIENT,
-							submodule: "execute",
-							packageType: __use_tusk_drift_schemas_core_span.PackageType.MYSQL,
-							packageName: "mysql2",
-							instrumentationName: self.INSTRUMENTATION_NAME,
-							inputValue,
-							isPreAppStart: false
-						}, (spanInfo) => {
-							return self.handleReplayQuery(queryConfig, inputValue, spanInfo, "execute", stackTrace);
-						});
-					} });
+					return handleReplayMode({
+						noOpRequestHandler: () => {
+							return self.queryMock.handleNoOpReplayQuery(queryConfig);
+						},
+						isServerRequest: false,
+						replayModeHandler: () => {
+							const spanName = `mysql2.${clientType}.execute`;
+							return SpanUtils.createAndExecuteSpan(self.mode, () => originalExecute.apply(this, args), {
+								name: spanName,
+								kind: __opentelemetry_api.SpanKind.CLIENT,
+								submodule: "execute",
+								packageType: __use_tusk_drift_schemas_core_span.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 }) => {
@@ -5437,20 +5572,26 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 		return (originalGetConnection) => {
 			return function getConnection(callback) {
 				const inputValue = { clientType: "pool" };
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalGetConnection.apply(this, [callback]), {
-						name: `mysql2.pool.getConnection`,
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "getConnection",
-						packageName: "mysql2",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.MYSQL,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
-						return self._handleReplayPoolGetConnection(spanInfo, callback);
-					});
-				} });
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
+						return self.handleNoOpReplayGetConnection(callback);
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalGetConnection.apply(this, [callback]), {
+							name: `mysql2.pool.getConnection`,
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "getConnection",
+							packageName: "mysql2",
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.MYSQL,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							return self._handleReplayPoolGetConnection(spanInfo, callback);
+						});
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalGetConnection.apply(this, [callback]),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -5478,24 +5619,34 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 		return (originalConnect) => {
 			return function connect(callback) {
 				const inputValue = { clientType };
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalConnect.apply(this, [callback]), {
-						name: `mysql2.${clientType}.connect`,
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "connect",
-						packageName: "mysql2",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.MYSQL,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
 						if (callback) {
 							process.nextTick(() => callback(null));
 							return;
 						}
 						return Promise.resolve();
-					});
-				} });
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalConnect.apply(this, [callback]), {
+							name: `mysql2.${clientType}.connect`,
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "connect",
+							packageName: "mysql2",
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.MYSQL,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							if (callback) {
+								process.nextTick(() => callback(null));
+								return;
+							}
+							return Promise.resolve();
+						});
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalConnect.apply(this, [callback]),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -5523,24 +5674,34 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 		return (originalPing) => {
 			return function ping(callback) {
 				const inputValue = { clientType };
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalPing.apply(this, [callback]), {
-						name: `mysql2.${clientType}.ping`,
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "ping",
-						packageName: "mysql2",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.MYSQL,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
 						if (callback) {
 							process.nextTick(() => callback(null));
 							return;
 						}
 						return Promise.resolve();
-					});
-				} });
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalPing.apply(this, [callback]), {
+							name: `mysql2.${clientType}.ping`,
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "ping",
+							packageName: "mysql2",
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.MYSQL,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							if (callback) {
+								process.nextTick(() => callback(null));
+								return;
+							}
+							return Promise.resolve();
+						});
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalPing.apply(this, [callback]),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -5568,24 +5729,34 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 		return (originalEnd) => {
 			return function end(callback) {
 				const inputValue = { clientType };
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalEnd.apply(this, [callback]), {
-						name: `mysql2.${clientType}.end`,
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "end",
-						packageName: "mysql2",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.MYSQL,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
 						if (callback) {
 							process.nextTick(() => callback(null));
 							return;
 						}
 						return Promise.resolve();
-					});
-				} });
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalEnd.apply(this, [callback]), {
+							name: `mysql2.${clientType}.end`,
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "end",
+							packageName: "mysql2",
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.MYSQL,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							if (callback) {
+								process.nextTick(() => callback(null));
+								return;
+							}
+							return Promise.resolve();
+						});
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalEnd.apply(this, [callback]),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -5760,6 +5931,9 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 	handleReplayQuery(queryConfig, inputValue, spanInfo, submoduleName = "query", stackTrace) {
 		return this.queryMock.handleReplayQuery(queryConfig, inputValue, spanInfo, submoduleName, stackTrace);
 	}
+	handleNoOpReplayQuery(queryConfig) {
+		return this.queryMock.handleNoOpReplayQuery(queryConfig);
+	}
 	_handleRecordPoolGetConnectionInSpan(spanInfo, originalGetConnection, callback, context$4) {
 		if (callback) {
 			const wrappedCallback = (error, connection) => {
@@ -5813,9 +5987,18 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 			throw error;
 		});
 	}
+	handleNoOpReplayGetConnection(callback) {
+		logger.debug(`[Mysql2Instrumentation] Background getConnection detected, returning mock connection`);
+		const mockConnection = new TdMysql2ConnectionMock(this, "pool");
+		if (callback) {
+			process.nextTick(() => callback(null, mockConnection));
+			return;
+		}
+		return Promise.resolve(mockConnection);
+	}
 	_handleReplayPoolGetConnection(spanInfo, callback) {
 		logger.debug(`[Mysql2Instrumentation] Replaying MySQL2 Pool getConnection`);
-		const mockConnection = new TdMysql2ConnectionMock(this, spanInfo, "pool");
+		const mockConnection = new TdMysql2ConnectionMock(this, "pool", spanInfo);
 		if (callback) {
 			process.nextTick(() => callback(null, mockConnection));
 			return;
@@ -5874,58 +6057,59 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 				},
 				spanKind: __opentelemetry_api.SpanKind.CLIENT
 			});
-			if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-				return SpanUtils.createAndExecuteSpan(self.mode, () => new OriginalConnection(...args), {
-					name: `mysql2.connection.create`,
-					kind: __opentelemetry_api.SpanKind.CLIENT,
-					submodule: "connectEvent",
-					packageType: __use_tusk_drift_schemas_core_span.PackageType.MYSQL,
-					packageName: "mysql2",
-					instrumentationName: self.INSTRUMENTATION_NAME,
-					inputValue,
-					isPreAppStart: false
-				}, (spanInfo) => {
-					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;
+			if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+				noOpRequestHandler: () => {
+					return new TdMysql2ConnectionMock(self, "connection");
+				},
+				isServerRequest: false,
+				replayModeHandler: () => {
+					return SpanUtils.createAndExecuteSpan(self.mode, () => new OriginalConnection(...args), {
+						name: `mysql2.connection.create`,
+						kind: __opentelemetry_api.SpanKind.CLIENT,
+						submodule: "connectEvent",
+						packageType: __use_tusk_drift_schemas_core_span.PackageType.MYSQL,
+						packageName: "mysql2",
+						instrumentationName: self.INSTRUMENTATION_NAME,
+						inputValue,
+						isPreAppStart: false
+					}, (spanInfo) => {
+						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);
 							}
-							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;
+							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);
 									});
-								}).catch((err) => {
-									logger.error(`[Mysql2Instrumentation] Error replaying connection event:`, err);
-								});
-								return this;
+									return this;
+								}
+								if (event === "error" && !this._isConnectOrErrorEmitted) return this;
+								return super.on(event, listener);
 							}
-							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: __opentelemetry_api.SpanStatusCode.OK });
-					return mockConnection;
-				});
-			} });
+						const mockConnection = new MockConnection(...args);
+						mockConnection.addListener("error", (_err) => {});
+						return mockConnection;
+					});
+				}
+			});
 			return new OriginalConnection(...args);
 		}
 		const staticProps = Object.getOwnPropertyNames(OriginalConnection).filter((key) => ![
@@ -6123,19 +6307,28 @@ var JsonwebtokenInstrumentation = class extends TdInstrumentationBase {
 				}
 				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: __opentelemetry_api.SpanKind.CLIENT,
-							submodule: "verify",
-							packageName: "jsonwebtoken",
-							instrumentationName: self.INSTRUMENTATION_NAME,
-							inputValue,
-							isPreAppStart: false
-						}, (spanInfo) => {
-							return self.handleReplayVerify(verifyConfig, inputValue, spanInfo, stackTrace);
-						});
-					} });
+					return handleReplayMode({
+						noOpRequestHandler: () => {
+							if (!!verifyConfig.callback) {
+								process.nextTick(() => verifyConfig.callback(null, void 0));
+								return;
+							} else return;
+						},
+						isServerRequest: false,
+						replayModeHandler: () => {
+							return SpanUtils.createAndExecuteSpan(self.mode, () => originalVerify.apply(this, args), {
+								name: "jsonwebtoken.verify",
+								kind: __opentelemetry_api.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 }) => {
@@ -6178,19 +6371,28 @@ var JsonwebtokenInstrumentation = class extends TdInstrumentationBase {
 				};
 				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: __opentelemetry_api.SpanKind.CLIENT,
-							submodule: "sign",
-							packageName: "jsonwebtoken",
-							instrumentationName: self.INSTRUMENTATION_NAME,
-							inputValue,
-							isPreAppStart: false
-						}, (spanInfo) => {
-							return self.handleReplaySign(signConfig, inputValue, spanInfo, stackTrace);
-						});
-					} });
+					return handleReplayMode({
+						noOpRequestHandler: () => {
+							if (!!signConfig.callback) {
+								process.nextTick(() => signConfig.callback(null, void 0));
+								return;
+							} else return;
+						},
+						isServerRequest: false,
+						replayModeHandler: () => {
+							return SpanUtils.createAndExecuteSpan(self.mode, () => originalSign.apply(this, args), {
+								name: "jsonwebtoken.sign",
+								kind: __opentelemetry_api.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 }) => {
@@ -6378,11 +6580,7 @@ var JsonwebtokenInstrumentation = class extends TdInstrumentationBase {
 		const hasCallback = !!verifyConfig.callback;
 		if (!mockData) {
 			logger.warn(`[JsonwebtokenInstrumentation] No mock data found for JWT verify: ${verifyConfig.token}`);
-			const error = /* @__PURE__ */ new Error("No mock data found");
-			if (hasCallback) {
-				process.nextTick(() => verifyConfig.callback(error));
-				return;
-			} else throw error;
+			throw new Error(`[JsonwebtokenInstrumentation] No matching mock found for JWT verify: ${verifyConfig.token}`);
 		}
 		if (mockData.result && mockData.result.error) {
 			let error = mockData.result.error;
@@ -6425,11 +6623,7 @@ var JsonwebtokenInstrumentation = class extends TdInstrumentationBase {
 		const hasCallback = !!signConfig.callback;
 		if (!mockData) {
 			logger.warn(`[JsonwebtokenInstrumentation] No mock data found for JWT sign`);
-			const error = /* @__PURE__ */ new Error("No mock data found");
-			if (hasCallback) {
-				process.nextTick(() => signConfig.callback(error));
-				return;
-			} else throw error;
+			throw new Error(`[JsonwebtokenInstrumentation] No matching mock found for JWT sign`);
 		}
 		if (mockData.result && mockData.result.error) {
 			let error = mockData.result.error;
@@ -6846,20 +7040,30 @@ var FetchInstrumentation = class extends TdInstrumentationBase {
 			headers: normalizedHeaders,
 			body: encodedBody
 		};
-		if (this.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-			return SpanUtils.createAndExecuteSpan(this.mode, () => this.originalFetch(input, init), {
-				name: url,
-				kind: __opentelemetry_api.SpanKind.CLIENT,
-				packageName: "fetch",
-				packageType: __use_tusk_drift_schemas_core_span.PackageType.HTTP,
-				instrumentationName: this.INSTRUMENTATION_NAME,
-				submodule: inputValue.method,
-				inputValue,
-				isPreAppStart: false
-			}, (spanInfo) => {
-				return this._handleReplayFetch(inputValue, spanInfo, stackTrace);
-			});
-		} });
+		if (this.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+			noOpRequestHandler: () => {
+				const mockResponse = new Response(null, {
+					status: 200,
+					statusText: "OK"
+				});
+				return Promise.resolve(mockResponse);
+			},
+			isServerRequest: false,
+			replayModeHandler: () => {
+				return SpanUtils.createAndExecuteSpan(this.mode, () => this.originalFetch(input, init), {
+					name: url,
+					kind: __opentelemetry_api.SpanKind.CLIENT,
+					packageName: "fetch",
+					packageType: __use_tusk_drift_schemas_core_span.PackageType.HTTP,
+					instrumentationName: this.INSTRUMENTATION_NAME,
+					submodule: inputValue.method,
+					inputValue,
+					isPreAppStart: false
+				}, (spanInfo) => {
+					return this._handleReplayFetch(inputValue, spanInfo, stackTrace);
+				});
+			}
+		});
 		else if (this.mode === TuskDriftMode.RECORD) return handleRecordMode({
 			originalFunctionCall: () => this.originalFetch(input, init),
 			recordModeHandler: ({ isPreAppStart }) => this._handleRecordFetch(input, inputValue, isPreAppStart, init),
@@ -6961,7 +7165,10 @@ var FetchInstrumentation = class extends TdInstrumentationBase {
 				...inputValue.headers && { headers: { matchImportance: 0 } }
 			}
 		});
-		if (!mockData) throw new Error(`No matching mock found for fetch request with input value: ${JSON.stringify(inputValue)}`);
+		if (!mockData) {
+			logger.warn(`[FetchInstrumentation] No mock data found for fetch request with input value: ${JSON.stringify(inputValue)}`);
+			throw new Error(`[FetchInstrumentation] No matching mock found for fetch request`);
+		}
 		const { result } = mockData;
 		const responseBody = this._constructFetchResponseBody(result);
 		const mockResponse = new Response(responseBody, {
@@ -7227,20 +7434,24 @@ var IORedisInstrumentation = class extends TdInstrumentationBase {
 				};
 				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: __opentelemetry_api.SpanKind.CLIENT,
-							submodule: commandName,
-							packageType: __use_tusk_drift_schemas_core_span.PackageType.REDIS,
-							packageName: "ioredis",
-							instrumentationName: self.INSTRUMENTATION_NAME,
-							inputValue,
-							isPreAppStart: false
-						}, (spanInfo) => {
-							return self._handleReplaySendCommand(spanInfo, cmd, inputValue, commandName, stackTrace);
-						});
-					} });
+					return handleReplayMode({
+						noOpRequestHandler: () => {},
+						isServerRequest: false,
+						replayModeHandler: () => {
+							return SpanUtils.createAndExecuteSpan(self.mode, () => originalSendCommand.apply(this, arguments), {
+								name: `ioredis.${commandName}`,
+								kind: __opentelemetry_api.SpanKind.CLIENT,
+								submodule: commandName,
+								packageType: __use_tusk_drift_schemas_core_span.PackageType.REDIS,
+								packageName: "ioredis",
+								instrumentationName: self.INSTRUMENTATION_NAME,
+								inputValue,
+								isPreAppStart: false
+							}, (spanInfo) => {
+								return self._handleReplaySendCommand(spanInfo, cmd, inputValue, stackTrace);
+							});
+						}
+					});
 				} else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalSendCommand.apply(this, arguments),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -7271,20 +7482,29 @@ var IORedisInstrumentation = class extends TdInstrumentationBase {
 					host: this.options?.host,
 					port: this.options?.port
 				};
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalConnect.apply(this, arguments), {
-						name: "ioredis.connect",
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "connect",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.REDIS,
-						packageName: "ioredis",
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
-						return self._handleReplayConnect(spanInfo, this);
-					});
-				} });
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
+						process.nextTick(() => {
+							this.emit("ready");
+						});
+						return Promise.resolve();
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalConnect.apply(this, arguments), {
+							name: "ioredis.connect",
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "connect",
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.REDIS,
+							packageName: "ioredis",
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							return self._handleReplayConnect(this);
+						});
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalConnect.apply(this, arguments),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -7341,20 +7561,26 @@ var IORedisInstrumentation = class extends TdInstrumentationBase {
 					command: q.name,
 					args: q.args || []
 				})) };
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalExec.apply(this, args), {
-						name: "ioredis.pipeline.exec",
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "pipeline-exec",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.REDIS,
-						packageName: "ioredis",
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
-						return self._handleReplayPipelineExec(spanInfo, inputValue, args);
-					});
-				} });
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
+						return [];
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalExec.apply(this, args), {
+							name: "ioredis.pipeline.exec",
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "pipeline-exec",
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.REDIS,
+							packageName: "ioredis",
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							return self._handleReplayPipelineExec(spanInfo, inputValue, args);
+						});
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalExec.apply(this, args),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -7403,7 +7629,7 @@ var IORedisInstrumentation = class extends TdInstrumentationBase {
 		});
 		return promise;
 	}
-	async _handleReplaySendCommand(spanInfo, cmd, inputValue, commandName, stackTrace) {
+	async _handleReplaySendCommand(spanInfo, cmd, inputValue, stackTrace) {
 		logger.debug(`[IORedisInstrumentation] Replaying IORedis command ${cmd.name}`);
 		const mockData = await findMockResponseAsync({
 			mockRequestData: {
@@ -7421,13 +7647,10 @@ var IORedisInstrumentation = class extends TdInstrumentationBase {
 		});
 		if (!mockData) {
 			logger.warn(`[IORedisInstrumentation] No mock data found for command: ${cmd.name}`);
-			SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.OK });
-			return;
+			throw new Error(`[IORedisInstrumentation] No matching mock found for command: ${cmd.name}`);
 		}
 		logger.debug(`[IORedisInstrumentation] Found mock data for command ${cmd.name}: ${JSON.stringify(mockData)}`);
 		const result = this._deserializeOutput(mockData.result);
-		SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: mockData.result });
-		SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.OK });
 		if (cmd.callback && typeof cmd.callback === "function") process.nextTick(() => {
 			cmd.callback(null, result);
 		});
@@ -7465,10 +7688,8 @@ var IORedisInstrumentation = class extends TdInstrumentationBase {
 		}
 		return promise;
 	}
-	async _handleReplayConnect(spanInfo, thisContext) {
+	async _handleReplayConnect(thisContext) {
 		logger.debug(`[IORedisInstrumentation] Replaying IORedis connect`);
-		SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: { connected: true } });
-		SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.OK });
 		process.nextTick(() => {
 			thisContext.emit("ready");
 		});
@@ -7517,8 +7738,7 @@ var IORedisInstrumentation = class extends TdInstrumentationBase {
 		});
 		if (!mockData) {
 			logger.warn(`[IORedisInstrumentation] No mock data found for pipeline exec`);
-			SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.OK });
-			return [];
+			throw new Error(`[IORedisInstrumentation] No matching mock found for pipeline exec`);
 		}
 		logger.debug(`[IORedisInstrumentation] Found mock data for pipeline exec: ${JSON.stringify(mockData)}`);
 		const result = this._deserializePipelineOutput(mockData.result);
@@ -7526,8 +7746,6 @@ var IORedisInstrumentation = class extends TdInstrumentationBase {
 		if (typeof callback === "function") process.nextTick(() => {
 			callback(null, result);
 		});
-		SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: mockData.result });
-		SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.OK });
 		return Promise.resolve(result);
 	}
 	_sanitizeArgs(args) {
@@ -7868,20 +8086,26 @@ var GrpcInstrumentation = class GrpcInstrumentation extends TdInstrumentationBas
 				};
 				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: __opentelemetry_api.SpanKind.CLIENT,
-							submodule: "client",
-							packageType: __use_tusk_drift_schemas_core_span.PackageType.GRPC,
-							packageName: GRPC_MODULE_NAME,
-							instrumentationName: self.INSTRUMENTATION_NAME,
-							inputValue,
-							isPreAppStart: false
-						}, (spanInfo) => {
-							return self._handleReplayUnaryRequest(spanInfo, inputValue, callback, MetadataConstructor, stackTrace);
-						});
-					} });
+					return handleReplayMode({
+						noOpRequestHandler: () => {
+							callback(null, void 0);
+						},
+						isServerRequest: false,
+						replayModeHandler: () => {
+							return SpanUtils.createAndExecuteSpan(self.mode, () => original.apply(this, args), {
+								name: "grpc.client.unary",
+								kind: __opentelemetry_api.SpanKind.CLIENT,
+								submodule: "client",
+								packageType: __use_tusk_drift_schemas_core_span.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 }) => {
@@ -7947,20 +8171,35 @@ 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.server_stream",
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "client",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.GRPC,
-						packageName: GRPC_MODULE_NAME,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false
-					}, (spanInfo) => {
-						return self._handleReplayServerStreamRequest(spanInfo, inputValue, MetadataConstructor);
-					});
-				} });
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
+						const stream$1 = new stream.Readable({
+							objectMode: true,
+							read() {}
+						});
+						Object.assign(stream$1, {
+							cancel() {},
+							getPeer: () => "0.0.0.0:0000",
+							call: void 0
+						});
+						return stream$1;
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => original.apply(this, args), {
+							name: "grpc.client.server_stream",
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "client",
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.GRPC,
+							packageName: GRPC_MODULE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false
+						}, (spanInfo) => {
+							return self._handleReplayServerStreamRequest(spanInfo, inputValue, MetadataConstructor);
+						});
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => original.apply(this, args),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -8147,9 +8386,7 @@ var GrpcInstrumentation = class GrpcInstrumentation extends TdInstrumentationBas
 		}).then((mockData) => {
 			if (!mockData) {
 				logger.warn(`[GrpcInstrumentation] No mock data found for gRPC request: ${inputValue.service}/${inputValue.method}`, inputValue);
-				callback(/* @__PURE__ */ new Error("No mock data found"));
-				SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.ERROR });
-				return;
+				throw new Error(`[GrpcInstrumentation] No matching mock found for gRPC unary request`);
 			}
 			const mockResult = mockData.result;
 			let status;
@@ -8182,12 +8419,9 @@ var GrpcInstrumentation = class GrpcInstrumentation extends TdInstrumentationBas
 				if (mockResult.metadata) emitter.emit("metadata", deserializeGrpcMetadata(MetadataConstructor, mockResult.metadata));
 				emitter.emit("status", status);
 			});
-			SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: mockResult });
-			SpanUtils.endSpan(spanInfo.span, { code: mockResult.error ? __opentelemetry_api.SpanStatusCode.ERROR : __opentelemetry_api.SpanStatusCode.OK });
 		}).catch((error) => {
 			logger.error(`[GrpcInstrumentation] Error fetching mock data:`, error);
 			callback(error);
-			SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.ERROR });
 		});
 		return emitter;
 	}
@@ -8301,21 +8535,7 @@ var GrpcInstrumentation = class GrpcInstrumentation extends TdInstrumentationBas
 		}).then((mockData) => {
 			if (!mockData) {
 				logger.warn(`[GrpcInstrumentation] No mock data found for gRPC server stream request: ${inputValue.service}/${inputValue.method}`, inputValue);
-				const error = /* @__PURE__ */ new Error("No mock data found");
-				process.nextTick(() => {
-					stream$1.emit("error", error);
-					stream$1.emit("status", {
-						code: 2,
-						details: "No mock data found",
-						metadata: new MetadataConstructor()
-					});
-					stream$1.push(null);
-				});
-				SpanUtils.endSpan(spanInfo.span, {
-					code: __opentelemetry_api.SpanStatusCode.ERROR,
-					message: "No mock data found"
-				});
-				return;
+				throw new Error(`[GrpcInstrumentation] No matching mock found for gRPC server stream request`);
 			}
 			const mockResult = mockData.result;
 			process.nextTick(() => {
@@ -8335,11 +8555,6 @@ var GrpcInstrumentation = class GrpcInstrumentation extends TdInstrumentationBas
 					stream$1.emit("error", errorObj);
 					stream$1.emit("status", status);
 					stream$1.push(null);
-					SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: mockResult });
-					SpanUtils.endSpan(spanInfo.span, {
-						code: __opentelemetry_api.SpanStatusCode.ERROR,
-						message: error.message
-					});
 				} else {
 					const { body, status: successStatus } = mockResult;
 					const status = {
@@ -8356,8 +8571,6 @@ var GrpcInstrumentation = class GrpcInstrumentation extends TdInstrumentationBas
 					});
 					stream$1.push(null);
 					stream$1.emit("status", status);
-					SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: mockResult });
-					SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.OK });
 				}
 			});
 		}).catch((error) => {
@@ -8371,7 +8584,6 @@ var GrpcInstrumentation = class GrpcInstrumentation extends TdInstrumentationBas
 				});
 				stream$1.push(null);
 			});
-			SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.ERROR });
 		});
 		return stream$1;
 	}
@@ -8684,21 +8896,31 @@ var FirestoreInstrumentation = class extends TdInstrumentationBase {
 					operation: "document.get",
 					path: this.path
 				};
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalGet.call(this), {
-						name: "firestore.document.get",
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "document",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.FIRESTORE,
-						packageName: PACKAGE_NAME,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false,
-						stopRecordingChildSpans: true
-					}, (spanInfo) => {
-						return self._handleReplayDocumentGet(spanInfo, inputValue);
-					});
-				} });
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
+						return new TdFirestoreDocumentMock({
+							exists: false,
+							id: "",
+							path: ""
+						});
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalGet.call(this), {
+							name: "firestore.document.get",
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "document",
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.FIRESTORE,
+							packageName: PACKAGE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleReplayDocumentGet(spanInfo, inputValue);
+						});
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalGet.call(this),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -8767,7 +8989,7 @@ var FirestoreInstrumentation = class extends TdInstrumentationBase {
 		});
 		if (!mockData) {
 			logger.warn(`[FirestoreInstrumentation] No mock data found for document.get: ${inputValue.path}`);
-			return Promise.reject(/* @__PURE__ */ new Error("No mock data found"));
+			throw new Error(`[FirestoreInstrumentation] No matching mock found for document.get`);
 		}
 		const documentResult = mockData.result;
 		return new TdFirestoreDocumentMock(documentResult);
@@ -8781,21 +9003,32 @@ var FirestoreInstrumentation = class extends TdInstrumentationBase {
 					path: this.path,
 					data
 				};
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalCreate.call(this, data), {
-						name: "firestore.document.create",
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "document",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.FIRESTORE,
-						packageName: PACKAGE_NAME,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false,
-						stopRecordingChildSpans: true
-					}, (spanInfo) => {
-						return self._handleReplayDocumentWrite(spanInfo, inputValue);
-					});
-				} });
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
+						const now = Date.now();
+						const emptyWriteResult = { writeTime: {
+							seconds: Math.floor(now / 1e3),
+							nanoseconds: now % 1e3 * 1e6
+						} };
+						return new TdFirestoreWriteResultMock(emptyWriteResult);
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalCreate.call(this, data), {
+							name: "firestore.document.create",
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "document",
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.FIRESTORE,
+							packageName: PACKAGE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleReplayDocumentWrite(spanInfo, inputValue);
+						});
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalCreate.call(this, data),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -8829,21 +9062,32 @@ var FirestoreInstrumentation = class extends TdInstrumentationBase {
 					data,
 					options
 				};
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalSet.call(this, data, options), {
-						name: "firestore.document.set",
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "document",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.FIRESTORE,
-						packageName: PACKAGE_NAME,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false,
-						stopRecordingChildSpans: true
-					}, (spanInfo) => {
-						return self._handleReplayDocumentWrite(spanInfo, inputValue);
-					});
-				} });
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
+						const now = Date.now();
+						const emptyWriteResult = { writeTime: {
+							seconds: Math.floor(now / 1e3),
+							nanoseconds: now % 1e3 * 1e6
+						} };
+						return new TdFirestoreWriteResultMock(emptyWriteResult);
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalSet.call(this, data, options), {
+							name: "firestore.document.set",
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "document",
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.FIRESTORE,
+							packageName: PACKAGE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleReplayDocumentWrite(spanInfo, inputValue);
+						});
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalSet.call(this, data, options),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -8876,21 +9120,32 @@ var FirestoreInstrumentation = class extends TdInstrumentationBase {
 					path: this.path,
 					data: args.length === 1 ? args[0] : args
 				};
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalUpdate.apply(this, args), {
-						name: "firestore.document.update",
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "document",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.FIRESTORE,
-						packageName: PACKAGE_NAME,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false,
-						stopRecordingChildSpans: true
-					}, (spanInfo) => {
-						return self._handleReplayDocumentWrite(spanInfo, inputValue);
-					});
-				} });
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
+						const now = Date.now();
+						const emptyWriteResult = { writeTime: {
+							seconds: Math.floor(now / 1e3),
+							nanoseconds: now % 1e3 * 1e6
+						} };
+						return new TdFirestoreWriteResultMock(emptyWriteResult);
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalUpdate.apply(this, args), {
+							name: "firestore.document.update",
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "document",
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.FIRESTORE,
+							packageName: PACKAGE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleReplayDocumentWrite(spanInfo, inputValue);
+						});
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalUpdate.apply(this, args),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -8923,21 +9178,32 @@ var FirestoreInstrumentation = class extends TdInstrumentationBase {
 					path: this.path,
 					options: precondition
 				};
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalDelete.call(this, precondition), {
-						name: "firestore.document.delete",
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "document",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.FIRESTORE,
-						packageName: PACKAGE_NAME,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false,
-						stopRecordingChildSpans: true
-					}, (spanInfo) => {
-						return self._handleReplayDocumentWrite(spanInfo, inputValue);
-					});
-				} });
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
+						const now = Date.now();
+						const emptyWriteResult = { writeTime: {
+							seconds: Math.floor(now / 1e3),
+							nanoseconds: now % 1e3 * 1e6
+						} };
+						return new TdFirestoreWriteResultMock(emptyWriteResult);
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalDelete.call(this, precondition), {
+							name: "firestore.document.delete",
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "document",
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.FIRESTORE,
+							packageName: PACKAGE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleReplayDocumentWrite(spanInfo, inputValue);
+						});
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalDelete.call(this, precondition),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -8992,7 +9258,7 @@ var FirestoreInstrumentation = class extends TdInstrumentationBase {
 		});
 		if (!mockData) {
 			logger.warn(`[FirestoreInstrumentation] No mock data found for ${inputValue.operation}: ${inputValue.path}`);
-			return Promise.reject(/* @__PURE__ */ new Error("No mock data found"));
+			throw new Error(`[FirestoreInstrumentation] No matching mock found for ${inputValue.operation}`);
 		}
 		const writeResult = mockData.result;
 		return new TdFirestoreWriteResultMock(writeResult);
@@ -9006,21 +9272,31 @@ var FirestoreInstrumentation = class extends TdInstrumentationBase {
 					path: this.path,
 					data
 				};
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalAdd.call(this, data), {
-						name: "firestore.collection.add",
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "collection",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.FIRESTORE,
-						packageName: PACKAGE_NAME,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false,
-						stopRecordingChildSpans: true
-					}, (spanInfo) => {
-						return self._handleReplayCollectionAdd(spanInfo, inputValue, this);
-					});
-				} });
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
+						if (!this.originalCollectionDocFn) {
+							logger.error(`[FirestoreInstrumentation] Original doc function not available`);
+							return Promise.reject(/* @__PURE__ */ new Error("Original doc function not available"));
+						}
+						return this.originalCollectionDocFn.call(this, "");
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalAdd.call(this, data), {
+							name: "firestore.collection.add",
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "collection",
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.FIRESTORE,
+							packageName: PACKAGE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleReplayCollectionAdd(spanInfo, inputValue, this);
+						});
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalAdd.call(this, data),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -9075,7 +9351,7 @@ var FirestoreInstrumentation = class extends TdInstrumentationBase {
 		});
 		if (!mockData) {
 			logger.warn(`[FirestoreInstrumentation] No mock data found for collection.add: ${inputValue.path}`);
-			return Promise.reject(/* @__PURE__ */ new Error("No mock data found"));
+			throw new Error(`[FirestoreInstrumentation] No matching mock found for collection.add`);
 		}
 		const recordedId = mockData.result.id;
 		if (!this.originalCollectionDocFn) {
@@ -9094,42 +9370,48 @@ var FirestoreInstrumentation = class extends TdInstrumentationBase {
 					path: collectionPath,
 					documentId: documentPath
 				};
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => documentPath ? originalDoc.call(this, documentPath) : originalDoc.call(this), {
-						name: "firestore.collection.doc",
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "collection",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.FIRESTORE,
-						packageName: PACKAGE_NAME,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false,
-						stopRecordingChildSpans: true
-					}, (spanInfo) => {
-						const mockData = findMockResponseSync({
-							mockRequestData: {
-								traceId: spanInfo.traceId,
-								spanId: spanInfo.spanId,
-								name: "firestore.collection.doc",
-								inputValue: createMockInputValue(inputValue),
-								packageName: PACKAGE_NAME,
-								instrumentationName: self.INSTRUMENTATION_NAME,
-								submoduleName: "collection",
-								kind: __opentelemetry_api.SpanKind.CLIENT
-							},
-							tuskDrift: self.tuskDrift
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
+						return originalDoc.call(this, "");
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => documentPath ? originalDoc.call(this, documentPath) : originalDoc.call(this), {
+							name: "firestore.collection.doc",
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "collection",
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.FIRESTORE,
+							packageName: PACKAGE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							const mockData = findMockResponseSync({
+								mockRequestData: {
+									traceId: spanInfo.traceId,
+									spanId: spanInfo.spanId,
+									name: "firestore.collection.doc",
+									inputValue: createMockInputValue(inputValue),
+									packageName: PACKAGE_NAME,
+									instrumentationName: self.INSTRUMENTATION_NAME,
+									submoduleName: "collection",
+									kind: __opentelemetry_api.SpanKind.CLIENT
+								},
+								tuskDrift: self.tuskDrift
+							});
+							if (!mockData) {
+								logger.warn(`[FirestoreInstrumentation] No mock data found for collection.doc: ${collectionPath}`);
+								throw new Error(`[FirestoreInstrumentation] No matching mock found for collection.doc`);
+							}
+							const recordedId = mockData.result.id;
+							logger.debug(`[FirestoreInstrumentation] replaying doc call with recorded id: ${recordedId}`);
+							const docRef = originalDoc.call(this, recordedId);
+							logger.debug(`[FirestoreInstrumentation] doc ref, id`, docRef, recordedId);
+							return docRef;
 						});
-						if (!mockData) {
-							logger.warn(`[FirestoreInstrumentation] No mock data found for collection.doc: ${collectionPath}`);
-							throw new Error("No mock data found for collection.doc");
-						}
-						const recordedId = mockData.result.id;
-						logger.debug(`[FirestoreInstrumentation] replaying doc call with recorded id: ${recordedId}`);
-						const docRef = originalDoc.call(this, recordedId);
-						logger.debug(`[FirestoreInstrumentation] doc ref, id`, docRef, recordedId);
-						return docRef;
-					});
-				} });
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => documentPath ? originalDoc.call(this, documentPath) : originalDoc.call(this),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -9172,21 +9454,31 @@ var FirestoreInstrumentation = class extends TdInstrumentationBase {
 					operation: "query.get",
 					path: this._queryOptions?.parentPath?.formattedName || "unknown"
 				};
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					return SpanUtils.createAndExecuteSpan(self.mode, () => originalGet.call(this), {
-						name: "firestore.query.get",
-						kind: __opentelemetry_api.SpanKind.CLIENT,
-						submodule: "query",
-						packageType: __use_tusk_drift_schemas_core_span.PackageType.FIRESTORE,
-						packageName: PACKAGE_NAME,
-						instrumentationName: self.INSTRUMENTATION_NAME,
-						inputValue,
-						isPreAppStart: false,
-						stopRecordingChildSpans: true
-					}, (spanInfo) => {
-						return self._handleReplayQueryGet(spanInfo, inputValue);
-					});
-				} });
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
+						return new TdFirestoreQueryMock({
+							size: 0,
+							empty: true,
+							docs: []
+						});
+					},
+					isServerRequest: false,
+					replayModeHandler: () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalGet.call(this), {
+							name: "firestore.query.get",
+							kind: __opentelemetry_api.SpanKind.CLIENT,
+							submodule: "query",
+							packageType: __use_tusk_drift_schemas_core_span.PackageType.FIRESTORE,
+							packageName: PACKAGE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart: false,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleReplayQueryGet(spanInfo, inputValue);
+						});
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
 					originalFunctionCall: () => originalGet.call(this),
 					recordModeHandler: ({ isPreAppStart }) => {
@@ -9263,7 +9555,7 @@ var FirestoreInstrumentation = class extends TdInstrumentationBase {
 		});
 		if (!mockData) {
 			logger.warn(`[FirestoreInstrumentation] No mock data found for query.get: ${inputValue.path}`);
-			return Promise.reject(/* @__PURE__ */ new Error("No mock data found"));
+			throw new Error(`[FirestoreInstrumentation] No matching mock found for query.get`);
 		}
 		const queryResult = mockData.result;
 		return new TdFirestoreQueryMock(queryResult);
@@ -9345,47 +9637,53 @@ var NextjsInstrumentation = class extends TdInstrumentationBase {
 				const method = req.method || "GET";
 				const url = req.url || "/";
 				logger.debug(`[NextjsInstrumentation] Intercepted Next.js request: ${method} ${url}`);
-				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
-					const inputValue = {
-						method,
-						url,
-						target: url,
-						headers: self._normalizeHeaders(req.headers || {})
-					};
-					const replayTraceId = self.replayHooks.extractTraceIdFromHeaders(req);
-					if (!replayTraceId) {
-						logger.debug(`[NextjsInstrumentation] No trace ID found, calling original handler`);
-						return originalHandleRequest.call(this, req, res, parsedUrl);
-					}
-					logger.debug(`[NextjsInstrumentation] Setting replay trace id`, replayTraceId);
-					const envVars = self.replayHooks.extractEnvVarsFromHeaders(req);
-					if (envVars) EnvVarTracker.setEnvVars(replayTraceId, envVars);
-					const ctxWithReplayTraceId = SpanUtils.setCurrentReplayTraceId(replayTraceId);
-					if (!ctxWithReplayTraceId) throw new Error("Error setting current replay trace id");
-					return __opentelemetry_api.context.with(ctxWithReplayTraceId, () => {
-						return SpanUtils.createAndExecuteSpan(self.mode, () => originalHandleRequest.call(this, req, res, parsedUrl), {
-							name: url,
-							kind: __opentelemetry_api.SpanKind.SERVER,
-							packageName: "nextjs",
-							submodule: method,
-							packageType: __use_tusk_drift_schemas_core_span.PackageType.HTTP,
-							instrumentationName: self.INSTRUMENTATION_NAME,
-							inputValue,
-							inputSchemaMerges: { headers: { matchImportance: 0 } },
-							isPreAppStart: false
-						}, (spanInfo) => {
-							return self._handleNextjsRequestInSpan({
-								req,
-								res,
-								parsedUrl,
-								originalHandleRequest,
-								spanInfo,
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
+					noOpRequestHandler: () => {
+						throw new Error(`[NextjsInstrumentation] Should never call noOpRequestHandler for server requests ${method} ${url}`);
+					},
+					isServerRequest: true,
+					replayModeHandler: () => {
+						const inputValue = {
+							method,
+							url,
+							target: url,
+							headers: self._normalizeHeaders(req.headers || {})
+						};
+						const replayTraceId = self.replayHooks.extractTraceIdFromHeaders(req);
+						if (!replayTraceId) {
+							logger.debug(`[NextjsInstrumentation] No trace ID found, calling original handler`);
+							return originalHandleRequest.call(this, req, res, parsedUrl);
+						}
+						logger.debug(`[NextjsInstrumentation] Setting replay trace id`, replayTraceId);
+						const envVars = self.replayHooks.extractEnvVarsFromHeaders(req);
+						if (envVars) EnvVarTracker.setEnvVars(replayTraceId, envVars);
+						const ctxWithReplayTraceId = SpanUtils.setCurrentReplayTraceId(replayTraceId);
+						if (!ctxWithReplayTraceId) throw new Error("Error setting current replay trace id");
+						return __opentelemetry_api.context.with(ctxWithReplayTraceId, () => {
+							return SpanUtils.createAndExecuteSpan(self.mode, () => originalHandleRequest.call(this, req, res, parsedUrl), {
+								name: url,
+								kind: __opentelemetry_api.SpanKind.SERVER,
+								packageName: "nextjs",
+								submodule: method,
+								packageType: __use_tusk_drift_schemas_core_span.PackageType.HTTP,
+								instrumentationName: self.INSTRUMENTATION_NAME,
 								inputValue,
-								thisContext: this
+								inputSchemaMerges: { headers: { matchImportance: 0 } },
+								isPreAppStart: false
+							}, (spanInfo) => {
+								return self._handleNextjsRequestInSpan({
+									req,
+									res,
+									parsedUrl,
+									originalHandleRequest,
+									spanInfo,
+									inputValue,
+									thisContext: this
+								});
 							});
 						});
-					});
-				} });
+					}
+				});
 				else if (self.mode === TuskDriftMode.RECORD) {
 					if (method.toUpperCase() === "OPTIONS" || !!req.headers["access-control-request-method"]) return originalHandleRequest.call(this, req, res, parsedUrl);
 					logger.debug(`[NextjsInstrumentation] Creating server span for ${method} ${url}`);
@@ -12109,7 +12407,7 @@ var TdSpanExporter = class {
 		logger.debug(`After filtering based on library name: ${filteredSpansBasedOnLibraryName.length} span(s) remaining`);
 		const MAX_SPAN_SIZE_MB = 1;
 		const MAX_SPAN_SIZE_BYTES = MAX_SPAN_SIZE_MB * 1024 * 1024;
-		const filteredSpansBasedOnSize = filteredSpansBasedOnLibraryName.filter((span) => {
+		const filteredBlockedSpans = filteredSpansBasedOnLibraryName.filter((span) => {
 			const traceId = span.spanContext().traceId;
 			if (traceBlockingManager.isTraceBlocked(traceId)) {
 				logger.debug(`Skipping span '${span.name}' (${span.spanContext().spanId}) - trace ${traceId} is blocked`);
@@ -12128,8 +12426,8 @@ var TdSpanExporter = class {
 			}
 			return true;
 		});
-		logger.debug(`Filtered ${filteredSpansBasedOnLibraryName.length - filteredSpansBasedOnSize.length} oversized span(s), ${filteredSpansBasedOnSize.length} remaining`);
-		const cleanSpans = filteredSpansBasedOnSize.map((span) => SpanTransformer.transformSpanToCleanJSON(span));
+		logger.debug(`Filtered ${filteredSpansBasedOnLibraryName.length - filteredBlockedSpans.length} blocked/oversized span(s), ${filteredBlockedSpans.length} remaining`);
+		const cleanSpans = filteredBlockedSpans.map((span) => SpanTransformer.transformSpanToCleanJSON(span));
 		if (this.adapters.length === 0) {
 			logger.debug("No adapters configured");
 			resultCallback({ code: import_src.ExportResultCode.SUCCESS });
@@ -12773,14 +13071,15 @@ var TuskDriftCore = class TuskDriftCore {
 			sdkVersion: SDK_VERSION,
 			sdkInstanceId: this.generateSdkInstanceId()
 		});
-		const tracerProvider = new __opentelemetry_sdk_trace_node.NodeTracerProvider({ resource: new __opentelemetry_resources.Resource({ [__opentelemetry_semantic_conventions.ATTR_SERVICE_NAME]: serviceName }) });
-		tracerProvider.addSpanProcessor(new __opentelemetry_sdk_trace_node.BatchSpanProcessor(this.spanExporter, {
-			maxQueueSize: 2048,
-			maxExportBatchSize: 512,
-			scheduledDelayMillis: 2e3,
-			exportTimeoutMillis: 3e4
-		}));
-		tracerProvider.register();
+		new __opentelemetry_sdk_trace_node.NodeTracerProvider({
+			resource: new __opentelemetry_resources.Resource({ [__opentelemetry_semantic_conventions.ATTR_SERVICE_NAME]: serviceName }),
+			spanProcessors: [new __opentelemetry_sdk_trace_node.BatchSpanProcessor(this.spanExporter, {
+				maxQueueSize: 2048,
+				maxExportBatchSize: 512,
+				scheduledDelayMillis: 2e3,
+				exportTimeoutMillis: 3e4
+			})]
+		}).register();
 		logger.debug(`OpenTelemetry tracing initialized`);
 	}
 	generateSdkInstanceId() {