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

package/dist/index.cjs

@@ -58,6 +58,10 @@ let __use_tusk_drift_schemas_backend_span_export_service = require("@use-tusk/dr
 __use_tusk_drift_schemas_backend_span_export_service = __toESM(__use_tusk_drift_schemas_backend_span_export_service);
 let jsonpath = require("jsonpath");
 jsonpath = __toESM(jsonpath);
+let net = require("net");
+net = __toESM(net);
+let stream = require("stream");
+stream = __toESM(stream);
 let __opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conventions");
 __opentelemetry_semantic_conventions = __toESM(__opentelemetry_semantic_conventions);
 let __use_tusk_drift_schemas_backend_span_export_service_client = require("@use-tusk/drift-schemas/backend/span_export_service.client");
@@ -66,8 +70,6 @@ let __protobuf_ts_twirp_transport = require("@protobuf-ts/twirp-transport");
 __protobuf_ts_twirp_transport = __toESM(__protobuf_ts_twirp_transport);
 let __opentelemetry_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
 __opentelemetry_sdk_trace_node = __toESM(__opentelemetry_sdk_trace_node);
-let net = require("net");
-net = __toESM(net);
 let child_process = require("child_process");
 child_process = __toESM(child_process);
 let __use_tusk_drift_schemas_core_communication = require("@use-tusk/drift-schemas/core/communication");
@@ -227,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);
@@ -273,7 +286,7 @@ var TdInstrumentationAbstract = class {
 
 //#endregion
 //#region package.json
-var version = "0.1.7";
+var version = "0.1.9";
 
 //#endregion
 //#region src/version.ts
@@ -470,6 +483,20 @@ function loadTuskConfig() {
 	}
 }
 
+//#endregion
+//#region src/core/utils/runtimeDetectionUtils.ts
+function isNextJsRuntime() {
+	return process.env.NEXT_RUNTIME !== void 0 || typeof global.__NEXT_DATA__ !== "undefined";
+}
+function isEsm(moduleExports) {
+	if (!moduleExports || typeof moduleExports !== "object") return false;
+	try {
+		return moduleExports[Symbol.toStringTag] === "Module";
+	} catch (error) {
+		return false;
+	}
+}
+
 //#endregion
 //#region src/core/utils/logger.ts
 var Logger = class {
@@ -749,9 +776,11 @@ var TdInstrumentationNodeModule = class {
 
 //#endregion
 //#region src/core/types.ts
+const TD_INSTRUMENTATION_LIBRARY_NAME = "tusk-drift-sdk";
 const REPLAY_TRACE_ID_CONTEXT_KEY = (0, __opentelemetry_api.createContextKey)("td.replayTraceId");
 const SPAN_KIND_CONTEXT_KEY = (0, __opentelemetry_api.createContextKey)("td.spanKind");
 const IS_PRE_APP_START_CONTEXT_KEY = (0, __opentelemetry_api.createContextKey)("td.isPreAppStart");
+const STOP_RECORDING_CHILD_SPANS_CONTEXT_KEY = (0, __opentelemetry_api.createContextKey)("td.stopRecordingChildSpans");
 const CALLING_LIBRARY_CONTEXT_KEY = (0, __opentelemetry_api.createContextKey)("td.callingLibrary");
 let TdSpanAttributes = /* @__PURE__ */ function(TdSpanAttributes$1) {
 	/**
@@ -794,6 +823,74 @@ let TdSpanAttributes = /* @__PURE__ */ function(TdSpanAttributes$1) {
 	return TdSpanAttributes$1;
 }({});
 
+//#endregion
+//#region src/core/tracing/TraceBlockingManager.ts
+/**
+* Manages blocked trace IDs to prevent creation and export of spans
+* that belong to traces exceeding size limits.
+*
+* This class uses an in-memory Set for O(1) lookup performance and
+* automatically cleans up old entries to prevent memory leaks.
+*/
+var TraceBlockingManager = class TraceBlockingManager {
+	constructor() {
+		this.blockedTraceIds = /* @__PURE__ */ new Set();
+		this.traceTimestamps = /* @__PURE__ */ new Map();
+		this.cleanupIntervalId = null;
+		this.DEFAULT_TTL_MS = 600 * 1e3;
+		this.CLEANUP_INTERVAL_MS = 120 * 1e3;
+		this.startCleanupInterval();
+	}
+	/**
+	* Get singleton instance
+	*/
+	static getInstance() {
+		if (!TraceBlockingManager.instance) TraceBlockingManager.instance = new TraceBlockingManager();
+		return TraceBlockingManager.instance;
+	}
+	/**
+	* Check if a trace ID is blocked
+	*/
+	isTraceBlocked(traceId) {
+		return this.blockedTraceIds.has(traceId);
+	}
+	/**
+	* Block a trace ID and all future spans for this trace
+	*/
+	blockTrace(traceId) {
+		if (!this.blockedTraceIds.has(traceId)) {
+			this.blockedTraceIds.add(traceId);
+			const originalDate = OriginalGlobalUtils.getOriginalDate();
+			this.traceTimestamps.set(traceId, originalDate.getTime());
+			logger.debug(`[TraceBlockingManager] Blocked trace: ${traceId}`);
+		}
+	}
+	/**
+	* Start periodic cleanup of old blocked trace IDs
+	*/
+	startCleanupInterval() {
+		if (this.cleanupIntervalId) return;
+		this.cleanupIntervalId = setInterval(() => {
+			this.cleanupOldTraces();
+		}, this.CLEANUP_INTERVAL_MS);
+		if (this.cleanupIntervalId.unref) this.cleanupIntervalId.unref();
+	}
+	/**
+	* Clean up trace IDs older than TTL
+	*/
+	cleanupOldTraces() {
+		const now = OriginalGlobalUtils.getOriginalDate().getTime();
+		const expiredTraces = [];
+		for (const [traceId, timestamp] of this.traceTimestamps.entries()) if (now - timestamp > this.DEFAULT_TTL_MS) expiredTraces.push(traceId);
+		for (const traceId of expiredTraces) {
+			this.blockedTraceIds.delete(traceId);
+			this.traceTimestamps.delete(traceId);
+		}
+		if (expiredTraces.length > 0) logger.debug(`[TraceBlockingManager] Cleaned up ${expiredTraces.length} expired blocked trace(s)`);
+	}
+};
+TraceBlockingManager.instance = null;
+
 //#endregion
 //#region src/core/tracing/SpanUtils.ts
 var SpanUtils = class SpanUtils {
@@ -804,6 +901,14 @@ var SpanUtils = class SpanUtils {
 		try {
 			const tracer = TuskDriftCore.getInstance().getTracer();
 			const parentContext = options.parentContext || __opentelemetry_api.context.active();
+			const activeSpan = __opentelemetry_api.trace.getSpan(parentContext);
+			if (activeSpan) {
+				const parentTraceId = activeSpan.spanContext().traceId;
+				if (TraceBlockingManager.getInstance().isTraceBlocked(parentTraceId)) {
+					logger.debug(`[SpanUtils] Skipping span creation for '${options.name}' - trace ${parentTraceId} is blocked`);
+					return null;
+				}
+			}
 			const span = tracer.startSpan(options.name, {
 				kind: options.kind || __opentelemetry_api.SpanKind.CLIENT,
 				attributes: options.attributes || {}
@@ -843,7 +948,14 @@ var SpanUtils = class SpanUtils {
 	* @returns The result of the function execution
 	*/
 	static createAndExecuteSpan(mode, originalFunctionCall, options, fn) {
-		const { name, kind, packageName, instrumentationName, packageType, submodule, inputValue, inputSchemaMerges, isPreAppStart, metadata } = options;
+		const spanContext = __opentelemetry_api.trace.getActiveSpan()?.spanContext();
+		if (spanContext) {
+			if (__opentelemetry_api.context.active().getValue(STOP_RECORDING_CHILD_SPANS_CONTEXT_KEY)) {
+				logger.debug(`[SpanUtils] Stopping recording of child spans for span ${spanContext.spanId}, packageName: ${options.packageName}, instrumentationName: ${options.instrumentationName}`);
+				return originalFunctionCall();
+			}
+		}
+		const { name, kind, packageName, instrumentationName, packageType, submodule, inputValue, inputSchemaMerges, isPreAppStart, metadata, stopRecordingChildSpans } = options;
 		let spanInfo = null;
 		try {
 			spanInfo = SpanUtils.createSpan({
@@ -868,6 +980,7 @@ var SpanUtils = class SpanUtils {
 		}
 		if (!spanInfo) if (mode === TuskDriftMode.REPLAY) throw new Error("Error creating span in replay mode");
 		else return originalFunctionCall();
+		if (stopRecordingChildSpans) spanInfo.context = spanInfo.context.setValue(STOP_RECORDING_CHILD_SPANS_CONTEXT_KEY, true);
 		return SpanUtils.withSpan(spanInfo, () => fn(spanInfo));
 	}
 	/**
@@ -1123,6 +1236,22 @@ function getDecodedType(contentType) {
 	const mainType = contentTypeString.toLowerCase().split(";")[0].trim();
 	return CONTENT_TYPE_MAPPING[mainType];
 }
+const STATIC_ASSET_TYPES = new Set([
+	__use_tusk_drift_schemas_core_json_schema.DecodedType.HTML,
+	__use_tusk_drift_schemas_core_json_schema.DecodedType.CSS,
+	__use_tusk_drift_schemas_core_json_schema.DecodedType.JAVASCRIPT,
+	__use_tusk_drift_schemas_core_json_schema.DecodedType.JPEG,
+	__use_tusk_drift_schemas_core_json_schema.DecodedType.PNG,
+	__use_tusk_drift_schemas_core_json_schema.DecodedType.GIF,
+	__use_tusk_drift_schemas_core_json_schema.DecodedType.WEBP,
+	__use_tusk_drift_schemas_core_json_schema.DecodedType.SVG,
+	__use_tusk_drift_schemas_core_json_schema.DecodedType.PDF,
+	__use_tusk_drift_schemas_core_json_schema.DecodedType.AUDIO,
+	__use_tusk_drift_schemas_core_json_schema.DecodedType.VIDEO,
+	__use_tusk_drift_schemas_core_json_schema.DecodedType.BINARY,
+	__use_tusk_drift_schemas_core_json_schema.DecodedType.ZIP,
+	__use_tusk_drift_schemas_core_json_schema.DecodedType.GZIP
+]);
 
 //#endregion
 //#region src/instrumentation/libraries/http/mocks/TdHttpMockSocket.ts
@@ -1597,6 +1726,28 @@ async function findMockResponseAsync({ mockRequestData, tuskDrift, inputValueSch
 		return null;
 	}
 }
+function findMockResponseSync({ mockRequestData, tuskDrift, inputValueSchemaMerges }) {
+	const outboundSpan = convertMockRequestDataToCleanSpanData(mockRequestData, tuskDrift, inputValueSchemaMerges);
+	try {
+		const replayTraceId = SpanUtils.getCurrentReplayTraceId();
+		logger.debug(`Finding ${outboundSpan.traceId} mock for replay trace ID: ${replayTraceId}`);
+		const mockResponse = tuskDrift.requestMockSync({
+			outboundSpan,
+			testId: replayTraceId || ""
+		});
+		if (!mockResponse || !mockResponse.found) {
+			logger.debug(`No matching mock found for ${outboundSpan.traceId} with input value: ${JSON.stringify(outboundSpan.inputValue)}`, replayTraceId);
+			return null;
+		}
+		const responseBody = mockResponse.response?.response?.body;
+		logger.debug(`Found ${outboundSpan.traceId} mock response and timestamp:`, responseBody, { timestamp: mockResponse.response?.timestamp });
+		if (mockResponse.response?.timestamp) DateTracker.updateLatestTimestamp(replayTraceId || "", mockResponse.response.timestamp);
+		return { result: responseBody };
+	} catch (error) {
+		logger.error(`Error finding ${outboundSpan.traceId} mock response:`, error);
+		return null;
+	}
+}
 
 //#endregion
 //#region src/instrumentation/libraries/http/mocks/TdMockClientRequest.ts
@@ -1727,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,
@@ -1764,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);
@@ -1950,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();
 }
 
@@ -2009,7 +2189,7 @@ function wrap(target, propertyName, wrapper) {
 * Helper functions for capturing stack traces in replay mode
 *
 * TODO: Consider using a structured format for stack frames:
-* 
+*
 * {
 *   "frames": [
 *     {
@@ -2025,7 +2205,7 @@ function wrap(target, propertyName, wrapper) {
 * It would also allow for more accurate stack trace reconstruction in replay mode.
 */
 /**
-* 
+*
 * @param excludeClassNames - Class names to exclude from the stack trace
 * @returns The stack trace as a string
 */
@@ -2438,7 +2618,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 			logger.debug(`[HttpInstrumentation] ${protocolUpper} module already patched, skipping`);
 			return httpModule;
 		}
-		if (httpModule[Symbol.toStringTag] === "Module") {
+		if (isEsm(httpModule)) {
 			if (httpModule.default) {
 				this._wrap(httpModule.default, "request", this._getRequestPatchFn(protocol));
 				this._wrap(httpModule.default, "get", this._getGetPatchFn(protocol));
@@ -2457,67 +2637,76 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 		return httpModule;
 	}
 	_createServerSpan({ req, res, originalHandler, protocol }) {
+		if (isNextJsRuntime()) {
+			logger.debug(`[HttpInstrumentation] Skipping recording/replaying for nextJs runtime, handled by nextJs instrumentation`);
+			return originalHandler.call(this);
+		}
 		const method = req.method || "GET";
 		const url = req.url || "/";
 		const target = req.url || "/";
 		const spanProtocol = this._normalizeProtocol(protocol, "http");
-		if (isTuskDriftIngestionUrl(url) || isTuskDriftIngestionUrl(target)) return originalHandler.call(this);
+		if (isTuskDriftIngestionUrl(url) || isTuskDriftIngestionUrl(target)) {
+			logger.debug(`[HttpInstrumentation] Ignoring drift ingestion endpoints`);
+			return originalHandler.call(this);
+		}
 		if (this.transformEngine.shouldDropInboundRequest(method, url, req.headers)) {
 			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) 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);
-			if (!shouldSample({
-				samplingRate: this.tuskDrift.getSamplingRate(),
-				isAppReady: this.tuskDrift.isAppReady()
-			})) {
-				logger.debug(`Skipping server span due to sampling rate`, url, this.tuskDrift.getSamplingRate());
-				return originalHandler.call(this);
-			}
 			logger.debug(`[HttpInstrumentation] Creating server span for ${method} ${url}`);
 			return handleRecordMode({
 				originalFunctionCall: () => originalHandler.call(this),
@@ -2611,7 +2800,6 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 					outputValue.bodySize = responseBuffer.length;
 				} catch (error) {
 					logger.error(`[HttpInstrumentation] Error processing server response body:`, error);
-					outputValue.bodyProcessingError = error instanceof Error ? error.message : String(error);
 				}
 				try {
 					const spanData = {
@@ -2629,7 +2817,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 						outputSchemaMerges: {
 							body: {
 								encoding: __use_tusk_drift_schemas_core_json_schema.EncodingType.BASE64,
-								decodedType: getDecodedType(spanData.outputValue.headers?.["content-type"] || "")
+								decodedType: getDecodedType(spanData.outputValue?.headers?.["content-type"] || "")
 							},
 							headers: { matchImportance: 0 }
 						},
@@ -2642,6 +2830,11 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 						message: `HTTP ${statusCode}`
 					} : { code: __opentelemetry_api.SpanStatusCode.OK };
 					SpanUtils.setStatus(spanInfo.span, status);
+					const decodedType = getDecodedType(outputValue.headers?.["content-type"] || "");
+					if (decodedType && STATIC_ASSET_TYPES.has(decodedType)) {
+						TraceBlockingManager.getInstance().blockTrace(spanInfo.traceId);
+						logger.debug(`[HttpInstrumentation] Blocking trace ${spanInfo.traceId} because it is an static asset response. Decoded type: ${decodedType}`);
+					}
 					SpanUtils.endSpan(spanInfo.span);
 				} catch (error) {
 					logger.error(`[HttpInstrumentation] Error adding response attributes to span:`, error);
@@ -2992,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 }) => {
@@ -3074,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 }) => {
@@ -3143,6 +3358,12 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 		return (originalEmit) => {
 			return function(eventName, ...args) {
 				if (eventName === "request") {
+					if (self.mode === TuskDriftMode.RECORD) {
+						if (!shouldSample({
+							samplingRate: self.tuskDrift.getSamplingRate(),
+							isAppReady: self.tuskDrift.isAppReady()
+						})) return originalEmit.apply(this, [eventName, ...args]);
+					}
 					const req = args[0];
 					const res = args[1];
 					return self._createServerSpan({
@@ -3493,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");
@@ -3598,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 }) => {
@@ -3643,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 }) => {
@@ -3760,7 +3997,17 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 			throw error;
 		});
 	}
-	async handleReplayQuery(queryConfig, inputValue, spanInfo, stackTrace) {
+	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";
 		const spanName = inputValue.clientType === "pool" ? "pg-pool.query" : "pg.query";
@@ -3781,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) {
@@ -3919,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 }) => {
@@ -4055,7 +4309,7 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 			return postgresModule;
 		}
 		const self = this;
-		if (postgresModule[Symbol.toStringTag] === "Module") {
+		if (isEsm(postgresModule)) {
 			logger.debug(`[PostgresInstrumentation] Wrapping ESM default export`);
 			this._wrap(postgresModule, "default", (originalFunction) => {
 				return function(...args) {
@@ -4095,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);
@@ -4171,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;
 		}
 	}
@@ -4244,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 }) => {
@@ -4297,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 }) => {
@@ -4351,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 }) => {
@@ -4480,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);
 		}
 	}
@@ -4548,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);
@@ -4579,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);
@@ -4668,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 = {
@@ -4704,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`);
@@ -4728,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");
@@ -4828,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
@@ -4852,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;
@@ -5182,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 }) => {
@@ -5241,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 }) => {
@@ -5284,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 }) => {
@@ -5325,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 }) => {
@@ -5370,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 }) => {
@@ -5415,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 }) => {
@@ -5607,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) => {
@@ -5660,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;
@@ -5721,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) => ![
@@ -5821,6 +6158,7 @@ var TcpInstrumentation = class extends TdInstrumentationBase {
 		super("tcp", config);
 		this.loggedSpans = /* @__PURE__ */ new Set();
 		this.mode = config.mode || TuskDriftMode.DISABLED;
+		this._patchLoadedModules();
 	}
 	init() {
 		return [new TdInstrumentationNodeModule({
@@ -5829,6 +6167,17 @@ var TcpInstrumentation = class extends TdInstrumentationBase {
 			patch: (moduleExports) => this._patchNetModule(moduleExports)
 		})];
 	}
+	_patchLoadedModules() {
+		if (isNextJsRuntime()) {
+			logger.debug(`[TcpInstrumentation] Next.js environment detected - force-loading net module to ensure patching`);
+			try {
+				require("net");
+				logger.debug(`[TcpInstrumentation] net module force-loaded`);
+			} catch (err) {
+				logger.error(`[TcpInstrumentation] Error force-loading net module:`, err);
+			}
+		} else logger.debug(`[TcpInstrumentation] Regular Node.js environment - hooks will catch net module on first require`);
+	}
 	_patchNetModule(netModule) {
 		logger.debug(`[TcpInstrumentation] Patching NET module in ${this.mode} mode`);
 		if (this.isModulePatched(netModule)) {
@@ -5958,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 }) => {
@@ -6013,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 }) => {
@@ -6213,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;
@@ -6260,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;
@@ -6681,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),
@@ -6796,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, {
@@ -6981,7 +7353,7 @@ var IORedisInstrumentation = class extends TdInstrumentationBase {
 			logger.debug(`[IORedisInstrumentation] IORedis module already patched, skipping`);
 			return moduleExports;
 		}
-		const actualExports = moduleExports[Symbol.toStringTag] === "Module" ? moduleExports.default : moduleExports;
+		const actualExports = isEsm(moduleExports) ? moduleExports.default : moduleExports;
 		if (!actualExports || !actualExports.prototype) {
 			logger.error(`[IORedisInstrumentation] Invalid module exports, cannot patch`);
 			return moduleExports;
@@ -7020,7 +7392,7 @@ var IORedisInstrumentation = class extends TdInstrumentationBase {
 			logger.debug(`[IORedisInstrumentation] Pipeline module already patched, skipping`);
 			return moduleExports;
 		}
-		const actualExports = moduleExports[Symbol.toStringTag] === "Module" ? moduleExports.default : moduleExports;
+		const actualExports = isEsm(moduleExports) ? moduleExports.default : moduleExports;
 		if (!actualExports || !actualExports.prototype) {
 			logger.debug(`[IORedisInstrumentation] Invalid Pipeline module exports, cannot patch`);
 			return moduleExports;
@@ -7062,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 }) => {
@@ -7106,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 }) => {
@@ -7176,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 }) => {
@@ -7238,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: {
@@ -7256,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);
 		});
@@ -7300,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");
 		});
@@ -7352,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);
@@ -7361,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) {
@@ -7613,6 +7996,7 @@ var GrpcInstrumentation = class GrpcInstrumentation extends TdInstrumentationBas
 			return;
 		}
 		this._wrap(clientPrototype, "makeUnaryRequest", this._getMakeUnaryRequestPatchFn(version$1));
+		this._wrap(clientPrototype, "makeServerStreamRequest", this._getMakeServerStreamRequestPatchFn(version$1));
 		this._wrap(clientPrototype, "waitForReady", this._getWaitForReadyPatchFn());
 		this._wrap(clientPrototype, "close", this._getClosePatchFn());
 		this._wrap(clientPrototype, "getChannel", this._getGetChannelPatchFn());
@@ -7662,6 +8046,7 @@ var GrpcInstrumentation = class GrpcInstrumentation extends TdInstrumentationBas
 		logger.debug(`[GrpcInstrumentation] _getMakeUnaryRequestPatchFn called for version: ${version$1}`);
 		return (original) => {
 			return function makeUnaryRequest(...args) {
+				logger.debug(`[GrpcInstrumentation] makeUnaryRequest called! args length: ${args.length}`);
 				const MetadataConstructor = GrpcInstrumentation.metadataStore.get(version$1) || self.Metadata;
 				if (!MetadataConstructor) {
 					logger.warn(`[GrpcInstrumentation] Metadata constructor not found for version ${version$1}`);
@@ -7701,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 }) => {
@@ -7737,33 +8128,157 @@ var GrpcInstrumentation = class GrpcInstrumentation extends TdInstrumentationBas
 			};
 		};
 	}
-	_handleRecordUnaryRequest(spanInfo, original, context$4, parsedParams, callback) {
-		let isResponseReceived = false;
-		let isStatusEmitted = false;
-		let hasErrorOccurred = false;
-		let isSpanCompleted = false;
-		let readableResponseBody;
-		let responseBufferMap = {};
-		let responseJsonableStringMap = {};
-		let status;
-		let responseMetadataInitial = {};
-		let serviceError;
-		/**
-		* Completes the span exactly once, regardless of which event fires first.
-		* gRPC's asynchronous nature means the callback and status event can fire in any order,
-		* so we need to guard against double span completion.
-		*/
-		const completeSpan = (output, statusCode, errorMessage) => {
-			if (isSpanCompleted) return;
-			isSpanCompleted = true;
-			try {
-				SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: output });
-				SpanUtils.endSpan(spanInfo.span, {
-					code: statusCode,
-					message: errorMessage
-				});
-			} catch (e) {
-				logger.error(`[GrpcInstrumentation] Error completing span:`, e);
+	_getMakeServerStreamRequestPatchFn(version$1) {
+		const self = this;
+		logger.debug(`[GrpcInstrumentation] _getMakeServerStreamRequestPatchFn called for version: ${version$1}`);
+		return (original) => {
+			return function makeServerStreamRequest(...args) {
+				logger.debug(`[GrpcInstrumentation] makeServerStreamRequest called! args length: ${args.length}`);
+				const MetadataConstructor = GrpcInstrumentation.metadataStore.get(version$1) || self.Metadata;
+				if (!MetadataConstructor) {
+					logger.warn(`[GrpcInstrumentation] Metadata constructor not found for version ${version$1}`);
+					return original.apply(this, args);
+				}
+				let parsedParams;
+				try {
+					parsedParams = self.extractServerStreamRequestParameters(args, MetadataConstructor);
+				} catch (error) {
+					logger.error(`[GrpcInstrumentation] Error parsing makeServerStreamRequest arguments:`, error);
+					return original.apply(this, args);
+				}
+				const { method: path$5, argument, metadata, options } = parsedParams;
+				let method;
+				let service;
+				let readableBody;
+				let bufferMap;
+				let jsonableStringMap;
+				let readableMetadata;
+				try {
+					({method, service} = parseGrpcPath(path$5));
+					({readableBody, bufferMap, jsonableStringMap} = serializeGrpcPayload(argument));
+					readableMetadata = serializeGrpcMetadata(metadata);
+				} catch (error) {
+					logger.error(`[GrpcInstrumentation] Error parsing makeServerStreamRequest arguments:`, error);
+					return original.apply(this, args);
+				}
+				const inputValue = {
+					method,
+					service,
+					body: readableBody,
+					metadata: readableMetadata,
+					inputMeta: {
+						bufferMap,
+						jsonableStringMap
+					}
+				};
+				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 }) => {
+						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
+						}, (spanInfo) => {
+							return self._handleRecordServerStreamRequest(spanInfo, original, this, parsedParams);
+						});
+					},
+					spanKind: __opentelemetry_api.SpanKind.CLIENT
+				});
+				else return original.apply(this, args);
+			};
+		};
+	}
+	extractServerStreamRequestParameters(args, MetadataConstructor) {
+		const method = args[0];
+		const serialize = args[1];
+		const deserialize = args[2];
+		const argument = args[3];
+		let metadata;
+		let options;
+		if (args.length === 6) {
+			metadata = args[4];
+			options = args[5];
+		} else if (args.length === 5) if (args[4] instanceof MetadataConstructor) {
+			metadata = args[4];
+			options = {};
+		} else {
+			metadata = new MetadataConstructor();
+			options = args[4] || {};
+		}
+		else {
+			metadata = new MetadataConstructor();
+			options = {};
+		}
+		return {
+			method,
+			serialize,
+			deserialize,
+			argument,
+			metadata,
+			options
+		};
+	}
+	_handleRecordUnaryRequest(spanInfo, original, context$4, parsedParams, callback) {
+		let isResponseReceived = false;
+		let isStatusEmitted = false;
+		let hasErrorOccurred = false;
+		let isSpanCompleted = false;
+		let readableResponseBody;
+		let responseBufferMap = {};
+		let responseJsonableStringMap = {};
+		let status;
+		let responseMetadataInitial = {};
+		let serviceError;
+		/**
+		* Completes the span exactly once, regardless of which event fires first.
+		* gRPC's asynchronous nature means the callback and status event can fire in any order,
+		* so we need to guard against double span completion.
+		*/
+		const completeSpan = (output, statusCode, errorMessage) => {
+			if (isSpanCompleted) return;
+			isSpanCompleted = true;
+			try {
+				SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: output });
+				SpanUtils.endSpan(spanInfo.span, {
+					code: statusCode,
+					message: errorMessage
+				});
+			} catch (e) {
+				logger.error(`[GrpcInstrumentation] Error completing span:`, e);
 			}
 		};
 		const patchedCallback = (err, value) => {
@@ -7839,113 +8354,1221 @@ var GrpcInstrumentation = class GrpcInstrumentation extends TdInstrumentationBas
 					status,
 					metadata: responseMetadataInitial
 				};
-				completeSpan(errorOutput, __opentelemetry_api.SpanStatusCode.ERROR, serviceError.message);
-			}
-		});
-		return result;
+				completeSpan(errorOutput, __opentelemetry_api.SpanStatusCode.ERROR, serviceError.message);
+			}
+		});
+		return result;
+	}
+	isGrpcErrorOutput(result) {
+		return "error" in result;
+	}
+	_handleReplayUnaryRequest(spanInfo, inputValue, callback, MetadataConstructor, stackTrace) {
+		logger.debug(`[GrpcInstrumentation] Replaying gRPC unary request`);
+		const emitter = Object.assign(new events.EventEmitter(), {
+			cancel() {},
+			getPeer: () => "0.0.0.0:0000",
+			call: void 0
+		});
+		findMockResponseAsync({
+			mockRequestData: {
+				traceId: spanInfo.traceId,
+				spanId: spanInfo.spanId,
+				name: "grpc.client.unary",
+				inputValue,
+				packageName: GRPC_MODULE_NAME,
+				packageType: __use_tusk_drift_schemas_core_span.PackageType.GRPC,
+				instrumentationName: this.INSTRUMENTATION_NAME,
+				submoduleName: "client",
+				kind: __opentelemetry_api.SpanKind.CLIENT,
+				stackTrace
+			},
+			tuskDrift: this.tuskDrift
+		}).then((mockData) => {
+			if (!mockData) {
+				logger.warn(`[GrpcInstrumentation] No mock data found for gRPC request: ${inputValue.service}/${inputValue.method}`, inputValue);
+				throw new Error(`[GrpcInstrumentation] No matching mock found for gRPC unary request`);
+			}
+			const mockResult = mockData.result;
+			let status;
+			if (this.isGrpcErrorOutput(mockResult)) {
+				const { error, status: errorStatus } = mockResult;
+				status = {
+					code: errorStatus.code,
+					details: errorStatus.details,
+					metadata: deserializeGrpcMetadata(MetadataConstructor, errorStatus.metadata)
+				};
+				const errorObj = Object.assign(new Error(error.message), {
+					name: error.name,
+					stack: error.stack,
+					...status
+				});
+				callback(errorObj);
+			} else {
+				const { body, status: successStatus, bufferMap, jsonableStringMap } = mockResult;
+				const bufferMapToUse = bufferMap || {};
+				const jsonableStringMapToUse = jsonableStringMap || {};
+				status = {
+					code: successStatus.code,
+					details: successStatus.details,
+					metadata: deserializeGrpcMetadata(MetadataConstructor, successStatus.metadata)
+				};
+				const realResponse = deserializeGrpcPayload(body, bufferMapToUse, jsonableStringMapToUse);
+				callback(null, realResponse);
+			}
+			process.nextTick(() => {
+				if (mockResult.metadata) emitter.emit("metadata", deserializeGrpcMetadata(MetadataConstructor, mockResult.metadata));
+				emitter.emit("status", status);
+			});
+		}).catch((error) => {
+			logger.error(`[GrpcInstrumentation] Error fetching mock data:`, error);
+			callback(error);
+		});
+		return emitter;
+	}
+	_handleRecordServerStreamRequest(spanInfo, original, context$4, parsedParams) {
+		let hasErrorOccurred = false;
+		let isSpanCompleted = false;
+		let streamResponses = [];
+		let status;
+		let responseMetadataInitial = {};
+		let serviceError;
+		/**
+		* Completes the span exactly once
+		*/
+		const completeSpan = (output, statusCode, errorMessage) => {
+			if (isSpanCompleted) return;
+			isSpanCompleted = true;
+			try {
+				SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: output });
+				SpanUtils.endSpan(spanInfo.span, { code: statusCode });
+			} catch (e) {
+				logger.error(`[GrpcInstrumentation] Error completing span:`, e);
+			}
+		};
+		const inputArgs = [
+			parsedParams.method,
+			parsedParams.serialize,
+			parsedParams.deserialize,
+			parsedParams.argument,
+			parsedParams.metadata,
+			parsedParams.options
+		];
+		const stream$1 = original.apply(context$4, inputArgs);
+		stream$1.on("data", (data) => {
+			try {
+				const { readableBody, bufferMap, jsonableStringMap } = serializeGrpcPayload(data);
+				streamResponses.push({
+					body: readableBody,
+					bufferMap,
+					jsonableStringMap
+				});
+			} catch (e) {
+				logger.error(`[GrpcInstrumentation] Error serializing stream data:`, e);
+			}
+		});
+		stream$1.on("metadata", (initialMetadata) => {
+			responseMetadataInitial = serializeGrpcMetadata(initialMetadata);
+		});
+		stream$1.on("error", (err) => {
+			serviceError = err;
+			hasErrorOccurred = true;
+		});
+		stream$1.on("status", (responseStatus) => {
+			status = {
+				code: responseStatus.code,
+				details: responseStatus.details,
+				metadata: serializeGrpcMetadata(responseStatus.metadata)
+			};
+			if (!hasErrorOccurred && streamResponses.length > 0) completeSpan({
+				body: streamResponses,
+				metadata: responseMetadataInitial,
+				status,
+				bufferMap: {},
+				jsonableStringMap: {}
+			}, __opentelemetry_api.SpanStatusCode.OK);
+			else if (!hasErrorOccurred && streamResponses.length === 0) completeSpan({
+				body: [],
+				metadata: responseMetadataInitial,
+				status,
+				bufferMap: {},
+				jsonableStringMap: {}
+			}, __opentelemetry_api.SpanStatusCode.OK);
+			else if (hasErrorOccurred) {
+				const errorOutput = {
+					error: {
+						message: serviceError.message,
+						name: serviceError.name,
+						stack: serviceError.stack
+					},
+					status,
+					metadata: responseMetadataInitial
+				};
+				completeSpan(errorOutput, __opentelemetry_api.SpanStatusCode.ERROR, serviceError.message);
+			}
+		});
+		return stream$1;
+	}
+	_handleReplayServerStreamRequest(spanInfo, inputValue, MetadataConstructor) {
+		logger.debug(`[GrpcInstrumentation] Replaying gRPC server stream request`);
+		const stream$1 = new stream.Readable({
+			objectMode: true,
+			read() {}
+		});
+		Object.assign(stream$1, {
+			cancel() {},
+			getPeer: () => "0.0.0.0:0000",
+			call: void 0
+		});
+		findMockResponseAsync({
+			mockRequestData: {
+				traceId: spanInfo.traceId,
+				spanId: spanInfo.spanId,
+				name: "grpc.client.server_stream",
+				inputValue,
+				packageName: GRPC_MODULE_NAME,
+				packageType: __use_tusk_drift_schemas_core_span.PackageType.GRPC,
+				instrumentationName: this.INSTRUMENTATION_NAME,
+				submoduleName: "client",
+				kind: __opentelemetry_api.SpanKind.CLIENT
+			},
+			tuskDrift: this.tuskDrift
+		}).then((mockData) => {
+			if (!mockData) {
+				logger.warn(`[GrpcInstrumentation] No mock data found for gRPC server stream request: ${inputValue.service}/${inputValue.method}`, inputValue);
+				throw new Error(`[GrpcInstrumentation] No matching mock found for gRPC server stream request`);
+			}
+			const mockResult = mockData.result;
+			process.nextTick(() => {
+				if (this.isGrpcErrorOutput(mockResult)) {
+					const { error, status: errorStatus } = mockResult;
+					const status = {
+						code: errorStatus.code,
+						details: errorStatus.details,
+						metadata: deserializeGrpcMetadata(MetadataConstructor, errorStatus.metadata)
+					};
+					if (mockResult.metadata) stream$1.emit("metadata", deserializeGrpcMetadata(MetadataConstructor, mockResult.metadata));
+					const errorObj = Object.assign(new Error(error.message), {
+						name: error.name,
+						stack: error.stack,
+						...status
+					});
+					stream$1.emit("error", errorObj);
+					stream$1.emit("status", status);
+					stream$1.push(null);
+				} else {
+					const { body, status: successStatus } = mockResult;
+					const status = {
+						code: successStatus.code,
+						details: successStatus.details,
+						metadata: deserializeGrpcMetadata(MetadataConstructor, successStatus.metadata)
+					};
+					if (mockResult.metadata) stream$1.emit("metadata", deserializeGrpcMetadata(MetadataConstructor, mockResult.metadata));
+					if (Array.isArray(body)) body.forEach((item) => {
+						const bufferMapToUse = item.bufferMap || {};
+						const jsonableStringMapToUse = item.jsonableStringMap || {};
+						const realResponse = deserializeGrpcPayload(item.body, bufferMapToUse, jsonableStringMapToUse);
+						stream$1.push(realResponse);
+					});
+					stream$1.push(null);
+					stream$1.emit("status", status);
+				}
+			});
+		}).catch((error) => {
+			logger.error(`[GrpcInstrumentation] Error fetching mock data for server stream:`, error);
+			process.nextTick(() => {
+				stream$1.emit("error", error);
+				stream$1.emit("status", {
+					code: 2,
+					details: error.message,
+					metadata: new MetadataConstructor()
+				});
+				stream$1.push(null);
+			});
+		});
+		return stream$1;
+	}
+	_getWaitForReadyPatchFn() {
+		const self = this;
+		return (original) => {
+			return function waitForReady(deadline, callback) {
+				if (self.mode === TuskDriftMode.REPLAY) {
+					process.nextTick(() => callback());
+					return;
+				} else return original.apply(this, [deadline, callback]);
+			};
+		};
+	}
+	_getClosePatchFn() {
+		const self = this;
+		return (original) => {
+			return function close() {
+				if (self.mode === TuskDriftMode.REPLAY) return;
+				else return original.apply(this, arguments);
+			};
+		};
+	}
+	_getGetChannelPatchFn() {
+		const self = this;
+		return (original) => {
+			return function getChannel() {
+				if (self.mode === TuskDriftMode.REPLAY) return {};
+				else return original.apply(this, arguments);
+			};
+		};
+	}
+	_wrap(target, propertyName, wrapper) {
+		wrap(target, propertyName, wrapper);
+	}
+};
+GrpcInstrumentation.metadataStore = /* @__PURE__ */ new Map();
+
+//#endregion
+//#region src/instrumentation/libraries/firestore/mocks/TdFirestoreDocumentMock.ts
+/**
+* Mock Firestore DocumentSnapshot for replay mode
+* Mimics the Firestore DocumentSnapshot API
+*/
+var TdFirestoreDocumentMock = class {
+	constructor(documentData) {
+		this.documentData = documentData;
+	}
+	/**
+	* The document's identifier within its collection
+	*/
+	get id() {
+		return this.documentData.id;
+	}
+	/**
+	* Whether the document exists
+	*/
+	get exists() {
+		return this.documentData.exists;
+	}
+	/**
+	* A DocumentReference to the document location
+	*/
+	get ref() {
+		return {
+			id: this.documentData.id,
+			path: this.documentData.path
+		};
+	}
+	/**
+	* The time the document was created (if available)
+	*/
+	get createTime() {
+		return this.documentData.createTime ? {
+			seconds: this.documentData.createTime.seconds,
+			nanoseconds: this.documentData.createTime.nanoseconds,
+			toDate: () => /* @__PURE__ */ new Date(this.documentData.createTime.seconds * 1e3 + this.documentData.createTime.nanoseconds / 1e6)
+		} : null;
+	}
+	/**
+	* The time the document was last updated (if available)
+	*/
+	get updateTime() {
+		return this.documentData.updateTime ? {
+			seconds: this.documentData.updateTime.seconds,
+			nanoseconds: this.documentData.updateTime.nanoseconds,
+			toDate: () => /* @__PURE__ */ new Date(this.documentData.updateTime.seconds * 1e3 + this.documentData.updateTime.nanoseconds / 1e6)
+		} : null;
+	}
+	/**
+	* The time the document was read (if available)
+	*/
+	get readTime() {
+		return this.documentData.readTime ? {
+			seconds: this.documentData.readTime.seconds,
+			nanoseconds: this.documentData.readTime.nanoseconds,
+			toDate: () => /* @__PURE__ */ new Date(this.documentData.readTime.seconds * 1e3 + this.documentData.readTime.nanoseconds / 1e6)
+		} : null;
+	}
+	/**
+	* Retrieves all fields in the document as an object
+	*/
+	data() {
+		return this.documentData.data;
+	}
+	/**
+	* Retrieves the field specified by fieldPath
+	*/
+	get(fieldPath) {
+		if (!this.documentData.data) return;
+		return this.documentData.data[fieldPath];
+	}
+	/**
+	* Returns true if the document's data and path are equal to the provided value
+	*/
+	isEqual(other) {
+		return this.documentData.path === other.documentData.path;
+	}
+};
+
+//#endregion
+//#region src/instrumentation/libraries/firestore/mocks/TdFirestoreQueryMock.ts
+/**
+* Mock Firestore QuerySnapshot for replay mode
+* Mimics the Firestore QuerySnapshot API
+*/
+var TdFirestoreQueryMock = class {
+	constructor(queryResult) {
+		this.queryResult = queryResult;
+		this._docs = queryResult.docs.map((doc) => new TdFirestoreDocumentMock(doc));
+	}
+	/**
+	* An array of all the documents in the QuerySnapshot
+	*/
+	get docs() {
+		return this._docs;
+	}
+	/**
+	* The number of documents in the QuerySnapshot
+	*/
+	get size() {
+		return this.queryResult.size;
+	}
+	/**
+	* True if there are no documents in the QuerySnapshot
+	*/
+	get empty() {
+		return this.queryResult.empty;
+	}
+	/**
+	* The time the query snapshot was read
+	*/
+	get readTime() {
+		return this.queryResult.readTime ? {
+			seconds: this.queryResult.readTime.seconds,
+			nanoseconds: this.queryResult.readTime.nanoseconds,
+			toDate: () => /* @__PURE__ */ new Date(this.queryResult.readTime.seconds * 1e3 + this.queryResult.readTime.nanoseconds / 1e6)
+		} : null;
+	}
+	/**
+	* The query on which you called get or onSnapshot
+	*/
+	get query() {
+		return {};
+	}
+	/**
+	* Enumerates all of the documents in the QuerySnapshot
+	*/
+	forEach(callback, thisArg) {
+		this._docs.forEach(callback, thisArg);
+	}
+	/**
+	* Returns an array of the documents changes since the last snapshot
+	*/
+	docChanges() {
+		return [];
+	}
+	/**
+	* Returns true if the document data and path are equal to this QuerySnapshot
+	*/
+	isEqual(other) {
+		if (this.size !== other.size) return false;
+		return this.size === other.size && this.empty === other.empty;
+	}
+};
+
+//#endregion
+//#region src/instrumentation/libraries/firestore/mocks/TdFirestoreWriteResultMock.ts
+/**
+* Mock Firestore WriteResult for replay mode
+* Mimics the Firestore WriteResult API
+*/
+var TdFirestoreWriteResultMock = class {
+	constructor(result) {
+		this.result = result;
+	}
+	/**
+	* The write time as reported by the server
+	*/
+	get writeTime() {
+		return this.result.writeTime ? {
+			seconds: this.result.writeTime.seconds,
+			nanoseconds: this.result.writeTime.nanoseconds,
+			toDate: () => /* @__PURE__ */ new Date(this.result.writeTime.seconds * 1e3 + this.result.writeTime.nanoseconds / 1e6)
+		} : null;
+	}
+	/**
+	* Returns true if this WriteResult is equal to the provided one
+	*/
+	isEqual(other) {
+		if (!this.writeTime || !other.writeTime) return this.writeTime === other.writeTime;
+		return this.writeTime.seconds === other.writeTime.seconds && this.writeTime.nanoseconds === other.writeTime.nanoseconds;
+	}
+};
+
+//#endregion
+//#region src/instrumentation/libraries/firestore/Instrumentation.ts
+const FIRESTORE_VERSION = "7.*";
+const PACKAGE_NAME = "@google-cloud/firestore";
+var FirestoreInstrumentation = class extends TdInstrumentationBase {
+	constructor(config = {}) {
+		super(PACKAGE_NAME, config);
+		this.INSTRUMENTATION_NAME = "FirestoreInstrumentation";
+		this.originalCollectionDocFn = null;
+		this.mode = config.mode || TuskDriftMode.DISABLED;
+		this.tuskDrift = TuskDriftCore.getInstance();
+	}
+	init() {
+		return [new TdInstrumentationNodeModule({
+			name: PACKAGE_NAME,
+			supportedVersions: [FIRESTORE_VERSION],
+			files: [
+				new TdInstrumentationNodeModuleFile({
+					name: "@google-cloud/firestore/build/src/reference/document-reference.js",
+					supportedVersions: [FIRESTORE_VERSION],
+					patch: (moduleExports) => this._patchDocumentReference(moduleExports)
+				}),
+				new TdInstrumentationNodeModuleFile({
+					name: "@google-cloud/firestore/build/src/reference/collection-reference.js",
+					supportedVersions: [FIRESTORE_VERSION],
+					patch: (moduleExports) => this._patchCollectionReference(moduleExports)
+				}),
+				new TdInstrumentationNodeModuleFile({
+					name: "@google-cloud/firestore/build/src/reference/query.js",
+					supportedVersions: [FIRESTORE_VERSION],
+					patch: (moduleExports) => this._patchQuery(moduleExports)
+				})
+			]
+		})];
+	}
+	_patchDocumentReference(moduleExports) {
+		logger.debug(`[FirestoreInstrumentation] Patching DocumentReference in ${this.mode} mode`);
+		if (this.isModulePatched(moduleExports)) {
+			logger.debug(`[FirestoreInstrumentation] DocumentReference already patched, skipping`);
+			return moduleExports;
+		}
+		const DocumentReference = moduleExports.DocumentReference;
+		if (!DocumentReference || !DocumentReference.prototype) {
+			logger.warn(`[FirestoreInstrumentation] DocumentReference.prototype not found`);
+			return moduleExports;
+		}
+		this._wrap(DocumentReference.prototype, "get", this._getDocumentGetPatchFn());
+		this._wrap(DocumentReference.prototype, "create", this._getDocumentCreatePatchFn());
+		this._wrap(DocumentReference.prototype, "set", this._getDocumentSetPatchFn());
+		this._wrap(DocumentReference.prototype, "update", this._getDocumentUpdatePatchFn());
+		this._wrap(DocumentReference.prototype, "delete", this._getDocumentDeletePatchFn());
+		this.markModuleAsPatched(moduleExports);
+		logger.debug(`[FirestoreInstrumentation] DocumentReference patching complete`);
+		return moduleExports;
+	}
+	_patchCollectionReference(moduleExports) {
+		logger.debug(`[FirestoreInstrumentation] Patching CollectionReference in ${this.mode} mode`);
+		if (this.isModulePatched(moduleExports)) {
+			logger.debug(`[FirestoreInstrumentation] CollectionReference already patched, skipping`);
+			return moduleExports;
+		}
+		const CollectionReference = moduleExports.CollectionReference;
+		if (!CollectionReference || !CollectionReference.prototype) {
+			logger.warn(`[FirestoreInstrumentation] CollectionReference.prototype not found`);
+			return moduleExports;
+		}
+		this.originalCollectionDocFn = CollectionReference.prototype.doc;
+		this._wrap(CollectionReference.prototype, "add", this._getCollectionAddPatchFn());
+		this._wrap(CollectionReference.prototype, "doc", this._getCollectionDocPatchFn());
+		this.markModuleAsPatched(moduleExports);
+		logger.debug(`[FirestoreInstrumentation] CollectionReference patching complete`);
+		return moduleExports;
+	}
+	_patchQuery(moduleExports) {
+		logger.debug(`[FirestoreInstrumentation] Patching Query in ${this.mode} mode`);
+		if (this.isModulePatched(moduleExports)) {
+			logger.debug(`[FirestoreInstrumentation] Query already patched, skipping`);
+			return moduleExports;
+		}
+		const Query = moduleExports.Query;
+		if (!Query || !Query.prototype) {
+			logger.warn(`[FirestoreInstrumentation] Query.prototype not found`);
+			return moduleExports;
+		}
+		this._wrap(Query.prototype, "get", this._getQueryGetPatchFn());
+		this.markModuleAsPatched(moduleExports);
+		logger.debug(`[FirestoreInstrumentation] Query patching complete`);
+		return moduleExports;
+	}
+	_getDocumentGetPatchFn() {
+		const self = this;
+		return (originalGet) => {
+			return function() {
+				const inputValue = {
+					operation: "document.get",
+					path: this.path
+				};
+				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 }) => {
+						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,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleRecordDocumentGet(spanInfo, originalGet, this);
+						});
+					},
+					spanKind: __opentelemetry_api.SpanKind.CLIENT
+				});
+				else return originalGet.call(this);
+			};
+		};
+	}
+	async _handleRecordDocumentGet(spanInfo, originalGet, context$4) {
+		const snapshot = await originalGet.call(context$4);
+		const documentResult = {
+			id: snapshot.id,
+			path: snapshot.ref.path,
+			exists: snapshot.exists,
+			data: snapshot.exists ? snapshot.data() : void 0,
+			createTime: snapshot.createTime ? {
+				seconds: snapshot.createTime.seconds,
+				nanoseconds: snapshot.createTime.nanoseconds
+			} : void 0,
+			updateTime: snapshot.updateTime ? {
+				seconds: snapshot.updateTime.seconds,
+				nanoseconds: snapshot.updateTime.nanoseconds
+			} : void 0,
+			readTime: snapshot.readTime ? {
+				seconds: snapshot.readTime.seconds,
+				nanoseconds: snapshot.readTime.nanoseconds
+			} : void 0
+		};
+		try {
+			SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: documentResult });
+			SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.OK });
+		} catch {
+			logger.error(`[FirestoreInstrumentation] Error updating span attributes for document.get`);
+		}
+		return snapshot;
+	}
+	async _handleReplayDocumentGet(spanInfo, inputValue) {
+		logger.debug(`[FirestoreInstrumentation] Replaying document.get`);
+		const mockData = await findMockResponseAsync({
+			mockRequestData: {
+				traceId: spanInfo.traceId,
+				spanId: spanInfo.spanId,
+				name: "firestore.document.get",
+				inputValue: createMockInputValue(inputValue),
+				packageName: PACKAGE_NAME,
+				instrumentationName: this.INSTRUMENTATION_NAME,
+				submoduleName: "document",
+				kind: __opentelemetry_api.SpanKind.CLIENT
+			},
+			tuskDrift: this.tuskDrift
+		});
+		if (!mockData) {
+			logger.warn(`[FirestoreInstrumentation] No mock data found for document.get: ${inputValue.path}`);
+			throw new Error(`[FirestoreInstrumentation] No matching mock found for document.get`);
+		}
+		const documentResult = mockData.result;
+		return new TdFirestoreDocumentMock(documentResult);
+	}
+	_getDocumentCreatePatchFn() {
+		const self = this;
+		return (originalCreate) => {
+			return function(data) {
+				const inputValue = {
+					operation: "document.create",
+					path: this.path,
+					data
+				};
+				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 }) => {
+						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,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleRecordDocumentWrite(spanInfo, originalCreate, this, data);
+						});
+					},
+					spanKind: __opentelemetry_api.SpanKind.CLIENT
+				});
+				else return originalCreate.call(this, data);
+			};
+		};
+	}
+	_getDocumentSetPatchFn() {
+		const self = this;
+		return (originalSet) => {
+			return function(data, options) {
+				const inputValue = {
+					operation: "document.set",
+					path: this.path,
+					data,
+					options
+				};
+				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 }) => {
+						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,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleRecordDocumentWrite(spanInfo, originalSet, this, data, options);
+						});
+					},
+					spanKind: __opentelemetry_api.SpanKind.CLIENT
+				});
+				else return originalSet.call(this, data, options);
+			};
+		};
+	}
+	_getDocumentUpdatePatchFn() {
+		const self = this;
+		return (originalUpdate) => {
+			return function(...args) {
+				const inputValue = {
+					operation: "document.update",
+					path: this.path,
+					data: args.length === 1 ? args[0] : args
+				};
+				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 }) => {
+						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,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleRecordDocumentWrite(spanInfo, originalUpdate, this, ...args);
+						});
+					},
+					spanKind: __opentelemetry_api.SpanKind.CLIENT
+				});
+				else return originalUpdate.apply(this, args);
+			};
+		};
+	}
+	_getDocumentDeletePatchFn() {
+		const self = this;
+		return (originalDelete) => {
+			return function(precondition) {
+				const inputValue = {
+					operation: "document.delete",
+					path: this.path,
+					options: precondition
+				};
+				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 }) => {
+						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,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleRecordDocumentWrite(spanInfo, originalDelete, this, precondition);
+						});
+					},
+					spanKind: __opentelemetry_api.SpanKind.CLIENT
+				});
+				else return originalDelete.call(this, precondition);
+			};
+		};
+	}
+	async _handleRecordDocumentWrite(spanInfo, originalWrite, context$4, ...args) {
+		const writeResult = await originalWrite.apply(context$4, args);
+		const result = { writeTime: writeResult.writeTime ? {
+			seconds: writeResult.writeTime.seconds,
+			nanoseconds: writeResult.writeTime.nanoseconds
+		} : void 0 };
+		try {
+			SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: result });
+			SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.OK });
+		} catch {
+			logger.error(`[FirestoreInstrumentation] Error updating span attributes for document.write`);
+		}
+		return writeResult;
+	}
+	async _handleReplayDocumentWrite(spanInfo, inputValue) {
+		logger.debug(`[FirestoreInstrumentation] Replaying document write: ${inputValue.operation}`);
+		const mockData = await findMockResponseAsync({
+			mockRequestData: {
+				traceId: spanInfo.traceId,
+				spanId: spanInfo.spanId,
+				name: `firestore.${inputValue.operation}`,
+				inputValue: createMockInputValue(inputValue),
+				packageName: PACKAGE_NAME,
+				instrumentationName: this.INSTRUMENTATION_NAME,
+				submoduleName: "document",
+				kind: __opentelemetry_api.SpanKind.CLIENT
+			},
+			tuskDrift: this.tuskDrift
+		});
+		if (!mockData) {
+			logger.warn(`[FirestoreInstrumentation] No mock data found for ${inputValue.operation}: ${inputValue.path}`);
+			throw new Error(`[FirestoreInstrumentation] No matching mock found for ${inputValue.operation}`);
+		}
+		const writeResult = mockData.result;
+		return new TdFirestoreWriteResultMock(writeResult);
+	}
+	_getCollectionAddPatchFn() {
+		const self = this;
+		return (originalAdd) => {
+			return function(data) {
+				const inputValue = {
+					operation: "collection.add",
+					path: this.path,
+					data
+				};
+				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 }) => {
+						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,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleRecordCollectionAdd(spanInfo, originalAdd, this, data);
+						});
+					},
+					spanKind: __opentelemetry_api.SpanKind.CLIENT
+				});
+				else return originalAdd.call(this, data);
+			};
+		};
 	}
-	isGrpcErrorOutput(result) {
-		return "error" in result;
+	async _handleRecordCollectionAdd(spanInfo, originalAdd, context$4, data) {
+		const docRef = await originalAdd.call(context$4, data);
+		const result = {
+			id: docRef.id,
+			path: docRef.path
+		};
+		try {
+			SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: result });
+			SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.OK });
+		} catch {
+			logger.error(`[FirestoreInstrumentation] Error updating span attributes for collection.add`);
+		}
+		return docRef;
 	}
-	async _handleReplayUnaryRequest(spanInfo, inputValue, callback, MetadataConstructor, stackTrace) {
-		logger.debug(`[GrpcInstrumentation] Replaying gRPC unary request`);
+	async _handleReplayCollectionAdd(spanInfo, inputValue, collectionRef) {
+		logger.debug(`[FirestoreInstrumentation] Replaying collection.add`);
 		const mockData = await findMockResponseAsync({
 			mockRequestData: {
 				traceId: spanInfo.traceId,
 				spanId: spanInfo.spanId,
-				name: "grpc.client.unary",
-				inputValue,
-				packageName: GRPC_MODULE_NAME,
+				name: "firestore.collection.add",
+				inputValue: createMockInputValue(inputValue),
+				packageName: PACKAGE_NAME,
 				instrumentationName: this.INSTRUMENTATION_NAME,
-				submoduleName: "client",
-				kind: __opentelemetry_api.SpanKind.CLIENT,
-				stackTrace
+				submoduleName: "collection",
+				kind: __opentelemetry_api.SpanKind.CLIENT
 			},
 			tuskDrift: this.tuskDrift
 		});
 		if (!mockData) {
-			logger.warn(`[GrpcInstrumentation] No mock data found for gRPC request: ${inputValue.service}/${inputValue.method}`);
-			callback(/* @__PURE__ */ new Error("No mock data found"));
-			SpanUtils.endSpan(spanInfo.span, {
-				code: __opentelemetry_api.SpanStatusCode.ERROR,
-				message: "No mock data found"
-			});
-			return;
+			logger.warn(`[FirestoreInstrumentation] No mock data found for collection.add: ${inputValue.path}`);
+			throw new Error(`[FirestoreInstrumentation] No matching mock found for collection.add`);
 		}
-		const mockResult = mockData.result;
-		let status;
-		if (this.isGrpcErrorOutput(mockResult)) {
-			const { error, status: errorStatus } = mockResult;
-			status = {
-				code: errorStatus.code,
-				details: errorStatus.details,
-				metadata: deserializeGrpcMetadata(MetadataConstructor, errorStatus.metadata)
-			};
-			const errorObj = Object.assign(new Error(error.message), {
-				name: error.name,
-				stack: error.stack,
-				...status
-			});
-			callback(errorObj);
-		} else {
-			const { body, status: successStatus, bufferMap, jsonableStringMap } = mockResult;
-			const bufferMapToUse = bufferMap || {};
-			const jsonableStringMapToUse = jsonableStringMap || {};
-			status = {
-				code: successStatus.code,
-				details: successStatus.details,
-				metadata: deserializeGrpcMetadata(MetadataConstructor, successStatus.metadata)
-			};
-			const realResponse = deserializeGrpcPayload(body, bufferMapToUse, jsonableStringMapToUse);
-			callback(null, realResponse);
+		const recordedId = mockData.result.id;
+		if (!this.originalCollectionDocFn) {
+			logger.error(`[FirestoreInstrumentation] Original doc function not available`);
+			return Promise.reject(/* @__PURE__ */ new Error("Original doc function not available"));
 		}
-		const emitter = Object.assign(new events.EventEmitter(), {
-			cancel() {},
-			getPeer: () => "0.0.0.0:0000",
-			call: void 0
-		});
-		process.nextTick(() => {
-			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 });
-		return emitter;
+		return this.originalCollectionDocFn.call(collectionRef, recordedId);
 	}
-	_getWaitForReadyPatchFn() {
+	_getCollectionDocPatchFn() {
 		const self = this;
-		return (original) => {
-			return function waitForReady(deadline, callback) {
-				if (self.mode === TuskDriftMode.REPLAY) {
-					process.nextTick(() => callback());
-					return;
-				} else return original.apply(this, [deadline, callback]);
+		return (originalDoc) => {
+			return function(documentPath) {
+				const collectionPath = this.path;
+				const inputValue = {
+					operation: "collection.doc",
+					path: collectionPath,
+					documentId: documentPath
+				};
+				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;
+						});
+					}
+				});
+				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
+					originalFunctionCall: () => documentPath ? originalDoc.call(this, documentPath) : originalDoc.call(this),
+					recordModeHandler: ({ isPreAppStart }) => {
+						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,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							const docRef = documentPath ? originalDoc.call(this, documentPath) : originalDoc.call(this);
+							const result = {
+								id: docRef.id,
+								path: docRef.path
+							};
+							try {
+								SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: result });
+								SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.OK });
+							} catch {
+								logger.error(`[FirestoreInstrumentation] Error updating span attributes for collection.doc`);
+							}
+							return docRef;
+						});
+					},
+					spanKind: __opentelemetry_api.SpanKind.CLIENT
+				});
+				else return documentPath ? originalDoc.call(this, documentPath) : originalDoc.call(this);
 			};
 		};
 	}
-	_getClosePatchFn() {
+	_getQueryGetPatchFn() {
 		const self = this;
-		return (original) => {
-			return function close() {
-				if (self.mode === TuskDriftMode.REPLAY) return;
-				else return original.apply(this, arguments);
+		return (originalGet) => {
+			return function() {
+				const inputValue = {
+					operation: "query.get",
+					path: this._queryOptions?.parentPath?.formattedName || "unknown"
+				};
+				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 }) => {
+						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,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleRecordQueryGet(spanInfo, originalGet, this);
+						});
+					},
+					spanKind: __opentelemetry_api.SpanKind.CLIENT
+				});
+				else return originalGet.call(this);
 			};
 		};
 	}
-	_getGetChannelPatchFn() {
-		const self = this;
-		return (original) => {
-			return function getChannel() {
-				if (self.mode === TuskDriftMode.REPLAY) return {};
-				else return original.apply(this, arguments);
-			};
+	async _handleRecordQueryGet(spanInfo, originalGet, context$4) {
+		const querySnapshot = await originalGet.call(context$4);
+		const queryResult = {
+			docs: querySnapshot.docs.map((doc) => ({
+				id: doc.id,
+				path: doc.ref.path,
+				exists: doc.exists,
+				data: doc.exists ? doc.data() : void 0,
+				createTime: doc.createTime ? {
+					seconds: doc.createTime.seconds,
+					nanoseconds: doc.createTime.nanoseconds
+				} : void 0,
+				updateTime: doc.updateTime ? {
+					seconds: doc.updateTime.seconds,
+					nanoseconds: doc.updateTime.nanoseconds
+				} : void 0,
+				readTime: doc.readTime ? {
+					seconds: doc.readTime.seconds,
+					nanoseconds: doc.readTime.nanoseconds
+				} : void 0
+			})),
+			size: querySnapshot.size,
+			empty: querySnapshot.empty,
+			readTime: querySnapshot.readTime ? {
+				seconds: querySnapshot.readTime.seconds,
+				nanoseconds: querySnapshot.readTime.nanoseconds
+			} : void 0
 		};
+		try {
+			SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: queryResult });
+			SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.OK });
+		} catch {
+			logger.error(`[FirestoreInstrumentation] Error updating span attributes for query.get`);
+		}
+		return querySnapshot;
+	}
+	async _handleReplayQueryGet(spanInfo, inputValue) {
+		logger.debug(`[FirestoreInstrumentation] Replaying query.get`);
+		const mockData = await findMockResponseAsync({
+			mockRequestData: {
+				traceId: spanInfo.traceId,
+				spanId: spanInfo.spanId,
+				name: "firestore.query.get",
+				inputValue: createMockInputValue(inputValue),
+				packageName: PACKAGE_NAME,
+				instrumentationName: this.INSTRUMENTATION_NAME,
+				submoduleName: "query",
+				kind: __opentelemetry_api.SpanKind.CLIENT
+			},
+			tuskDrift: this.tuskDrift
+		});
+		if (!mockData) {
+			logger.warn(`[FirestoreInstrumentation] No mock data found for query.get: ${inputValue.path}`);
+			throw new Error(`[FirestoreInstrumentation] No matching mock found for query.get`);
+		}
+		const queryResult = mockData.result;
+		return new TdFirestoreQueryMock(queryResult);
 	}
 	_wrap(target, propertyName, wrapper) {
-		wrap(target, propertyName, wrapper);
+		if (!target || typeof target[propertyName] !== "function") {
+			logger.warn(`[FirestoreInstrumentation] Cannot wrap ${propertyName}: not a function or target is undefined`);
+			return;
+		}
+		const original = target[propertyName];
+		target[propertyName] = wrapper(original);
 	}
 };
-GrpcInstrumentation.metadataStore = /* @__PURE__ */ new Map();
 
 //#endregion
 //#region src/instrumentation/libraries/nextjs/Instrumentation.ts
@@ -8005,58 +9628,64 @@ var NextjsInstrumentation = class extends TdInstrumentationBase {
 		const self = this;
 		return (originalHandleRequest) => {
 			return async function(req, res, parsedUrl) {
+				if (self.mode === TuskDriftMode.RECORD) {
+					if (!shouldSample({
+						samplingRate: self.tuskDrift.getSamplingRate(),
+						isAppReady: self.tuskDrift.isAppReady()
+					})) return originalHandleRequest.call(this, req, res, parsedUrl);
+				}
 				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);
-					}
-					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);
-					if (!shouldSample({
-						samplingRate: self.tuskDrift.getSamplingRate(),
-						isAppReady: self.tuskDrift.isAppReady()
-					})) {
-						logger.debug(`[NextjsInstrumentation] Skipping server span due to sampling rate: ${url}`);
-						return originalHandleRequest.call(this, req, res, parsedUrl);
-					}
 					logger.debug(`[NextjsInstrumentation] Creating server span for ${method} ${url}`);
 					return handleRecordMode({
 						originalFunctionCall: () => originalHandleRequest.call(this, req, res, parsedUrl),
@@ -8135,6 +9764,19 @@ var NextjsInstrumentation = class extends TdInstrumentationBase {
 		};
 		try {
 			await originalHandleRequest.call(thisContext, req, res, parsedUrl);
+		} catch (error) {
+			logger.error(`[NextjsInstrumentation] Error in Next.js request: ${error instanceof Error ? error.message : "Unknown error"}`);
+			try {
+				SpanUtils.endSpan(spanInfo.span, {
+					code: __opentelemetry_api.SpanStatusCode.ERROR,
+					message: error instanceof Error ? error.message : "Unknown error"
+				});
+			} catch (e) {
+				logger.error(`[NextjsInstrumentation] Error ending span:`, e);
+			}
+			throw error;
+		}
+		try {
 			if (!capturedStatusCode) {
 				capturedStatusCode = res.statusCode;
 				capturedStatusMessage = res.statusMessage;
@@ -8159,7 +9801,6 @@ var NextjsInstrumentation = class extends TdInstrumentationBase {
 				outputValue.bodySize = responseBuffer.length;
 			} catch (error) {
 				logger.error(`[NextjsInstrumentation] Error processing response body:`, error);
-				outputValue.bodyProcessingError = error instanceof Error ? error.message : String(error);
 			}
 			SpanUtils.addSpanAttributes(spanInfo.span, {
 				inputValue: completeInputValue,
@@ -8179,6 +9820,11 @@ var NextjsInstrumentation = class extends TdInstrumentationBase {
 				message: `HTTP ${capturedStatusCode}`
 			} : { code: __opentelemetry_api.SpanStatusCode.OK };
 			SpanUtils.setStatus(spanInfo.span, status);
+			const decodedType = getDecodedType(outputValue.headers?.["content-type"] || "");
+			if (decodedType && STATIC_ASSET_TYPES.has(decodedType)) {
+				TraceBlockingManager.getInstance().blockTrace(spanInfo.traceId);
+				logger.debug(`[NextjsInstrumentation] Blocking trace ${spanInfo.traceId} because it is an static asset response. Decoded type: ${decodedType}`);
+			}
 			SpanUtils.endSpan(spanInfo.span);
 			if (self.mode === TuskDriftMode.REPLAY) try {
 				const now = OriginalGlobalUtils.getOriginalDate();
@@ -8236,12 +9882,15 @@ var NextjsInstrumentation = class extends TdInstrumentationBase {
 				logger.error("[NextjsInstrumentation] Failed to build/send inbound replay span:", e);
 			}
 		} catch (error) {
-			logger.error(`[NextjsInstrumentation] Error in Next.js request: ${error instanceof Error ? error.message : String(error)}`);
-			SpanUtils.endSpan(spanInfo.span, {
-				code: __opentelemetry_api.SpanStatusCode.ERROR,
-				message: error instanceof Error ? error.message : String(error)
-			});
-			throw error;
+			logger.error(`[NextjsInstrumentation] Error in Next.js request: ${error instanceof Error ? error.message : "Unknown error"}`);
+			try {
+				SpanUtils.endSpan(spanInfo.span, {
+					code: __opentelemetry_api.SpanStatusCode.ERROR,
+					message: error instanceof Error ? error.message : "Unknown error"
+				});
+			} catch (e) {
+				logger.error(`[NextjsInstrumentation] Error ending span:`, e);
+			}
 		}
 	}
 	/**
@@ -10468,20 +12117,21 @@ var SpanTransformer = class SpanTransformer {
 		const inputData = JSON.parse(inputValueString);
 		const inputSchemaMergesString = attributes[TdSpanAttributes.INPUT_SCHEMA_MERGES];
 		const inputSchemaMerges = inputSchemaMergesString ? JSON.parse(inputSchemaMergesString) : void 0;
-		const { schema: inputSchema, decodedValueHash: inputValueHash } = JsonSchemaHelper.generateSchemaAndHash(inputData, inputSchemaMerges);
+		const { schema: inputSchema, decodedValueHash: inputValueHash, decodedSchemaHash: inputSchemaHash } = JsonSchemaHelper.generateSchemaAndHash(inputData, inputSchemaMerges);
 		let outputData = {};
 		let outputSchema = {
 			type: __use_tusk_drift_schemas_core_json_schema.JsonSchemaType.OBJECT,
 			properties: {}
 		};
 		let outputValueHash = "";
+		let outputSchemaHash = "";
 		if (attributes[TdSpanAttributes.OUTPUT_VALUE]) {
 			const outputValueString = attributes[TdSpanAttributes.OUTPUT_VALUE];
 			outputData = JSON.parse(outputValueString);
 			const outputSchemaMergesString = attributes[TdSpanAttributes.OUTPUT_SCHEMA_MERGES];
 			const outputSchemaMerges = outputSchemaMergesString ? JSON.parse(outputSchemaMergesString) : void 0;
-			({schema: outputSchema, decodedValueHash: outputValueHash} = JsonSchemaHelper.generateSchemaAndHash(outputData, outputSchemaMerges));
-		} else ({schema: outputSchema, decodedSchemaHash: outputValueHash} = JsonSchemaHelper.generateSchemaAndHash(outputData));
+			({schema: outputSchema, decodedValueHash: outputValueHash, decodedSchemaHash: outputSchemaHash} = JsonSchemaHelper.generateSchemaAndHash(outputData, outputSchemaMerges));
+		} else ({schema: outputSchema, decodedValueHash: outputValueHash, decodedSchemaHash: outputSchemaHash} = JsonSchemaHelper.generateSchemaAndHash(outputData));
 		let metadata = void 0;
 		if (attributes[TdSpanAttributes.METADATA]) metadata = JSON.parse(attributes[TdSpanAttributes.METADATA]);
 		let transformMetadata;
@@ -10505,8 +12155,8 @@ var SpanTransformer = class SpanTransformer {
 			outputValue: outputData,
 			inputSchema,
 			outputSchema,
-			inputSchemaHash: JsonSchemaHelper.generateDeterministicHash(inputSchema),
-			outputSchemaHash: JsonSchemaHelper.generateDeterministicHash(outputSchema),
+			inputSchemaHash,
+			outputSchemaHash,
 			inputValueHash,
 			outputValueHash,
 			kind: span.kind,
@@ -10749,18 +12399,35 @@ var TdSpanExporter = class {
 	*/
 	export(spans, resultCallback) {
 		logger.debug(`TdSpanExporter.export() called with ${spans.length} span(s)`);
-		const filteredSpans = spans.filter((span) => {
-			if (span.instrumentationLibrary?.name === "next.js") return false;
+		const traceBlockingManager = TraceBlockingManager.getInstance();
+		const filteredSpansBasedOnLibraryName = spans.filter((span) => {
+			if (span.instrumentationLibrary.name === TD_INSTRUMENTATION_LIBRARY_NAME) return true;
+			return false;
+		});
+		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 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`);
+				return false;
+			}
+			const inputValueString = span.attributes[TdSpanAttributes.INPUT_VALUE] || "";
+			const outputValueString = span.attributes[TdSpanAttributes.OUTPUT_VALUE] || "";
+			const inputSize = Buffer.byteLength(inputValueString, "utf8");
+			const outputSize = Buffer.byteLength(outputValueString, "utf8");
+			const estimatedTotalSize = inputSize + outputSize + 5e4;
+			const estimatedSizeMB = estimatedTotalSize / (1024 * 1024);
+			if (estimatedTotalSize > MAX_SPAN_SIZE_BYTES) {
+				traceBlockingManager.blockTrace(traceId);
+				logger.warn(`Blocking trace ${traceId} - span '${span.name}' (${span.spanContext().spanId}) has estimated size ${estimatedSizeMB.toFixed(2)} MB exceeding limit of ${MAX_SPAN_SIZE_MB} MB. Future spans for this trace will be prevented.`);
+				return false;
+			}
 			return true;
 		});
-		logger.debug(`After filtering: ${filteredSpans.length} span(s) remaining`);
-		let cleanSpans;
-		try {
-			cleanSpans = filteredSpans.map((span) => SpanTransformer.transformSpanToCleanJSON(span));
-		} catch (error) {
-			logger.error("Error transforming spans to CleanSpanData", error);
-			throw error;
-		}
+		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 });
@@ -10895,15 +12562,12 @@ var ProtobufCommunicator = class {
 		});
 	}
 	/**
-	* This function uses a Node.js script to communicate with the CLI over a socket.
-	* The script is called using execSync, which will block the main thread until the child process exits. This makes requesting mocks from the CLI synchronous.
-	*
-	* Since this function blocks the main thread, there is a perfomance impact for using this. We should use requestMockAsync whenever possilbe and only use this function
-	* for instrumentations that request fetching mocks synchronously.
+	* This function uses a separate Node.js child process to communicate with the CLI over a socket.
+	* The child process creates its own connection and event loop, allowing proper async socket handling.
+	* The parent process blocks synchronously waiting for the child to complete.
 	*
-	* (10/9/2025) Currently not using this function since we are not actually fetching mocks for the only sync instrumentation (Date)
-	* NOTE: This function probably doesn't work. plus, nc might not be installed on all machines (especially windows)
-	*       Better approach is replacing nc command with pure Node.js implementation
+	* Since this function blocks the main thread, there is a performance impact. We should use requestMockAsync whenever possible and only use this function
+	* for instrumentations that require fetching mocks synchronously.
 	*/
 	requestMockSync(mockRequest) {
 		const requestId = this.generateRequestId();
@@ -10926,10 +12590,15 @@ var ProtobufCommunicator = class {
 				getMockRequest: protoMockRequest
 			}
 		});
+		logger.debug("Sending protobuf request to CLI (sync)", {
+			outboundSpan: mockRequest.outboundSpan,
+			testId: mockRequest.testId
+		});
 		const messageBytes = __use_tusk_drift_schemas_core_communication.SDKMessage.toBinary(sdkMessage);
 		const tempDir = os.default.tmpdir();
-		const requestFile = path.default.join(tempDir, `tusk-request-${requestId}.bin`);
-		const responseFile = path.default.join(tempDir, `tusk-response-${requestId}.bin`);
+		const requestFile = path.default.join(tempDir, `tusk-sync-request-${requestId}.bin`);
+		const responseFile = path.default.join(tempDir, `tusk-sync-response-${requestId}.bin`);
+		const scriptFile = path.default.join(tempDir, `tusk-sync-script-${requestId}.js`);
 		try {
 			const lengthBuffer = Buffer.allocUnsafe(4);
 			lengthBuffer.writeUInt32BE(messageBytes.length, 0);
@@ -10938,19 +12607,112 @@ var ProtobufCommunicator = class {
 			const mockSocket = OriginalGlobalUtils.getOriginalProcessEnvVar("TUSK_MOCK_SOCKET");
 			const mockHost = OriginalGlobalUtils.getOriginalProcessEnvVar("TUSK_MOCK_HOST");
 			const mockPort = OriginalGlobalUtils.getOriginalProcessEnvVar("TUSK_MOCK_PORT");
-			let command;
-			if (mockSocket) {
-				if (!fs.default.existsSync(mockSocket)) throw new Error(`Socket file does not exist: ${mockSocket}`);
-				command = `nc -U -w 10 "${mockSocket}" < "${requestFile}" > "${responseFile}"`;
-			} else if (mockHost && mockPort) command = `nc -w 10 "${mockHost}" ${mockPort} < "${requestFile}" > "${responseFile}"`;
-			else {
-				const socketPath = path.default.join(os.default.tmpdir(), "tusk-connect.sock");
-				if (!fs.default.existsSync(socketPath)) throw new Error(`Socket file does not exist: ${socketPath}`);
-				command = `nc -U -w 10 "${socketPath}" < "${requestFile}" > "${responseFile}"`;
-			}
+			let connectionConfig;
+			if (mockSocket) connectionConfig = {
+				type: "unix",
+				path: mockSocket
+			};
+			else if (mockHost && mockPort) connectionConfig = {
+				type: "tcp",
+				host: mockHost,
+				port: parseInt(mockPort, 10)
+			};
+			else connectionConfig = {
+				type: "unix",
+				path: path.default.join(os.default.tmpdir(), "tusk-connect.sock")
+			};
+			fs.default.writeFileSync(scriptFile, `
+const net = require('net');
+const fs = require('fs');
+
+const requestFile = process.argv[2];
+const responseFile = process.argv[3];
+const config = JSON.parse(process.argv[4]);
+
+let responseReceived = false;
+let timeoutId;
+
+function cleanup(exitCode) {
+  if (timeoutId) clearTimeout(timeoutId);
+  process.exit(exitCode);
+}
+
+try {
+  // Read the request data
+  const requestData = fs.readFileSync(requestFile);
+  
+  // Create connection based on config
+  const client = config.type === 'unix' 
+    ? net.createConnection({ path: config.path })
+    : net.createConnection({ host: config.host, port: config.port });
+
+  const incomingChunks = [];
+  let incomingBuffer = Buffer.alloc(0);
+
+  // Set timeout
+  timeoutId = setTimeout(() => {
+    if (!responseReceived) {
+      console.error('Timeout waiting for response');
+      client.destroy();
+      cleanup(1);
+    }
+  }, 10000);
+
+  client.on('connect', () => {
+    // Send the request
+    client.write(requestData);
+  });
+
+  client.on('data', (data) => {
+    incomingBuffer = Buffer.concat([incomingBuffer, data]);
+    
+    // Try to parse complete message (4 byte length prefix + message)
+    while (incomingBuffer.length >= 4) {
+      const messageLength = incomingBuffer.readUInt32BE(0);
+      
+      if (incomingBuffer.length < 4 + messageLength) {
+        // Incomplete message, wait for more data
+        break;
+      }
+      
+      // We have a complete message
+      const messageData = incomingBuffer.slice(4, 4 + messageLength);
+      incomingBuffer = incomingBuffer.slice(4 + messageLength);
+      
+      // Write the complete response (including length prefix)
+      const lengthPrefix = Buffer.allocUnsafe(4);
+      lengthPrefix.writeUInt32BE(messageLength, 0);
+      fs.writeFileSync(responseFile, Buffer.concat([lengthPrefix, messageData]));
+      
+      responseReceived = true;
+      client.destroy();
+      cleanup(0);
+      break;
+    }
+  });
+
+  client.on('error', (err) => {
+    if (!responseReceived) {
+      console.error('Connection error:', err.message);
+      cleanup(1);
+    }
+  });
+
+  client.on('close', () => {
+    if (!responseReceived) {
+      console.error('Connection closed without response');
+      cleanup(1);
+    }
+  });
+
+} catch (err) {
+  console.error('Script error:', err.message);
+  cleanup(1);
+}
+`);
 			try {
-				(0, child_process.execSync)(command, {
-					timeout: 1e4,
+				(0, child_process.execSync)(`node "${scriptFile}" "${requestFile}" "${responseFile}" '${JSON.stringify(connectionConfig)}'`, {
+					timeout: 12e3,
 					stdio: "pipe"
 				});
 				const responseBuffer = fs.default.readFileSync(responseFile);
@@ -10975,22 +12737,27 @@ var ProtobufCommunicator = class {
 					error: mockResponse.error || "Mock not found"
 				};
 			} catch (error) {
-				logger.error("[ProtobufCommunicator] error sending request to CLI:", error);
+				logger.error("[ProtobufCommunicator] error in sync request child process:", error);
 				throw error;
 			}
 		} catch (error) {
 			throw new Error(`Sync request failed: ${error.message}`);
 		} finally {
 			try {
-				fs.default.unlinkSync(requestFile);
+				if (fs.default.existsSync(requestFile)) fs.default.unlinkSync(requestFile);
 			} catch (e) {
 				logger.error("[ProtobufCommunicator] error cleaning up request file:", e);
 			}
 			try {
-				fs.default.unlinkSync(responseFile);
+				if (fs.default.existsSync(responseFile)) fs.default.unlinkSync(responseFile);
 			} catch (e) {
 				logger.error("[ProtobufCommunicator] error cleaning up response file:", e);
 			}
+			try {
+				if (fs.default.existsSync(scriptFile)) fs.default.unlinkSync(scriptFile);
+			} catch (e) {
+				logger.error("[ProtobufCommunicator] error cleaning up script file:", e);
+			}
 		}
 	}
 	async sendProtobufMessage(message) {
@@ -11158,7 +12925,8 @@ const TuskDriftInstrumentationModuleNames = [
 	"jwks-rsa",
 	"mysql2",
 	"ioredis",
-	"@grpc/grpc-js"
+	"@grpc/grpc-js",
+	"@google-cloud/firestore"
 ];
 
 //#endregion
@@ -11280,6 +13048,10 @@ var TuskDriftCore = class TuskDriftCore {
 			enabled: true,
 			mode: this.mode
 		});
+		new FirestoreInstrumentation({
+			enabled: true,
+			mode: this.mode
+		});
 		new NextjsInstrumentation({
 			enabled: true,
 			mode: this.mode
@@ -11299,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() {
@@ -11452,6 +13225,10 @@ var TuskDriftCore = class TuskDriftCore {
 		}
 	}
 	requestMockSync(mockRequest) {
+		if (!this.isConnectedWithCLI) {
+			logger.error("Requesting sync mock but CLI is not ready yet");
+			throw new Error("Requesting sync mock but CLI is not ready yet");
+		}
 		const mockRequestCore = this.createMockRequestCore(mockRequest);
 		if (mockRequestCore) return mockRequestCore;
 		return this.requestMockFromCLISync(mockRequest);
@@ -11499,7 +13276,7 @@ var TuskDriftCore = class TuskDriftCore {
 		return this.initParams;
 	}
 	getTracer() {
-		return __opentelemetry_api.trace.getTracer("tusk-drift-sdk", "1.0.0");
+		return __opentelemetry_api.trace.getTracer(TD_INSTRUMENTATION_LIBRARY_NAME);
 	}
 };
 var TuskDriftSDK = class {