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

package/dist/index.js

@@ -18,11 +18,12 @@ import { IncomingMessage } from "http";
 import * as crypto from "crypto";
 import { SpanExportService } from "@use-tusk/drift-schemas/backend/span_export_service";
 import jp from "jsonpath";
+import net from "net";
+import { Readable } from "stream";
 import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
 import { SpanExportServiceClient } from "@use-tusk/drift-schemas/backend/span_export_service.client";
 import { TwirpFetchTransport } from "@protobuf-ts/twirp-transport";
 import { BatchSpanProcessor, NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
-import net from "net";
 import { execSync } from "child_process";
 import { CLIMessage, ConnectRequest, GetMockRequest, MessageType, SDKMessage, SendInboundSpanForReplayRequest } from "@use-tusk/drift-schemas/core/communication";
 import { Resource } from "@opentelemetry/resources";
@@ -252,7 +253,7 @@ var TdInstrumentationAbstract = class {
 
 //#endregion
 //#region package.json
-var version = "0.1.7";
+var version = "0.1.8";
 
 //#endregion
 //#region src/version.ts
@@ -449,6 +450,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 {
@@ -728,9 +743,11 @@ var TdInstrumentationNodeModule = class {
 
 //#endregion
 //#region src/core/types.ts
+const TD_INSTRUMENTATION_LIBRARY_NAME = "tusk-drift-sdk";
 const REPLAY_TRACE_ID_CONTEXT_KEY = createContextKey("td.replayTraceId");
 const SPAN_KIND_CONTEXT_KEY = createContextKey("td.spanKind");
 const IS_PRE_APP_START_CONTEXT_KEY = createContextKey("td.isPreAppStart");
+const STOP_RECORDING_CHILD_SPANS_CONTEXT_KEY = createContextKey("td.stopRecordingChildSpans");
 const CALLING_LIBRARY_CONTEXT_KEY = createContextKey("td.callingLibrary");
 let TdSpanAttributes = /* @__PURE__ */ function(TdSpanAttributes$1) {
 	/**
@@ -773,6 +790,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 {
@@ -783,6 +868,14 @@ var SpanUtils = class SpanUtils {
 		try {
 			const tracer = TuskDriftCore.getInstance().getTracer();
 			const parentContext = options.parentContext || context.active();
+			const activeSpan = 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 || SpanKind.CLIENT,
 				attributes: options.attributes || {}
@@ -822,7 +915,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 = trace.getActiveSpan()?.spanContext();
+		if (spanContext) {
+			if (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({
@@ -847,6 +947,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));
 	}
 	/**
@@ -1102,6 +1203,22 @@ function getDecodedType(contentType) {
 	const mainType = contentTypeString.toLowerCase().split(";")[0].trim();
 	return CONTENT_TYPE_MAPPING[mainType];
 }
+const STATIC_ASSET_TYPES = new Set([
+	DecodedType.HTML,
+	DecodedType.CSS,
+	DecodedType.JAVASCRIPT,
+	DecodedType.JPEG,
+	DecodedType.PNG,
+	DecodedType.GIF,
+	DecodedType.WEBP,
+	DecodedType.SVG,
+	DecodedType.PDF,
+	DecodedType.AUDIO,
+	DecodedType.VIDEO,
+	DecodedType.BINARY,
+	DecodedType.ZIP,
+	DecodedType.GZIP
+]);
 
 //#endregion
 //#region src/instrumentation/libraries/http/mocks/TdHttpMockSocket.ts
@@ -1576,6 +1693,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
@@ -1988,7 +2127,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": [
 *     {
@@ -2004,7 +2143,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
 */
@@ -2417,7 +2556,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));
@@ -2436,11 +2575,18 @@ 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);
@@ -2458,7 +2604,10 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 				remotePort: req.socket?.remotePort
 			};
 			const replayTraceId = this.replayHooks.extractTraceIdFromHeaders(req);
-			if (!replayTraceId) return originalHandler.call(this);
+			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);
@@ -2490,13 +2639,6 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 		} });
 		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),
@@ -2590,7 +2732,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 = {
@@ -2608,7 +2749,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 						outputSchemaMerges: {
 							body: {
 								encoding: EncodingType.BASE64,
-								decodedType: getDecodedType(spanData.outputValue.headers?.["content-type"] || "")
+								decodedType: getDecodedType(spanData.outputValue?.headers?.["content-type"] || "")
 							},
 							headers: { matchImportance: 0 }
 						},
@@ -2621,6 +2762,11 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 						message: `HTTP ${statusCode}`
 					} : { code: 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);
@@ -3122,6 +3268,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({
@@ -4034,7 +4186,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) {
@@ -5800,6 +5952,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({
@@ -5808,6 +5961,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)) {
@@ -6960,7 +7124,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;
@@ -6999,7 +7163,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;
@@ -7592,6 +7756,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());
@@ -7641,6 +7806,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}`);
@@ -7716,6 +7882,115 @@ var GrpcInstrumentation = class GrpcInstrumentation extends TdInstrumentationBas
 			};
 		};
 	}
+	_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$2, argument, metadata, options } = parsedParams;
+				let method;
+				let service;
+				let readableBody;
+				let bufferMap;
+				let jsonableStringMap;
+				let readableMetadata;
+				try {
+					({method, service} = parseGrpcPath(path$2));
+					({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({ replayModeHandler: () => {
+					return SpanUtils.createAndExecuteSpan(self.mode, () => original.apply(this, args), {
+						name: "grpc.client.server_stream",
+						kind: SpanKind.CLIENT,
+						submodule: "client",
+						packageType: 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: SpanKind.CLIENT,
+							submodule: "client",
+							packageType: PackageType.GRPC,
+							packageName: GRPC_MODULE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart
+						}, (spanInfo) => {
+							return self._handleRecordServerStreamRequest(spanInfo, original, this, parsedParams);
+						});
+					},
+					spanKind: 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$1, parsedParams, callback) {
 		let isResponseReceived = false;
 		let isStatusEmitted = false;
@@ -7826,105 +8101,1160 @@ var GrpcInstrumentation = class GrpcInstrumentation extends TdInstrumentationBas
 	isGrpcErrorOutput(result) {
 		return "error" in result;
 	}
-	async _handleReplayUnaryRequest(spanInfo, inputValue, callback, MetadataConstructor, stackTrace) {
+	_handleReplayUnaryRequest(spanInfo, inputValue, callback, MetadataConstructor, stackTrace) {
 		logger.debug(`[GrpcInstrumentation] Replaying gRPC unary request`);
-		const mockData = await findMockResponseAsync({
+		const emitter = Object.assign(new 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: PackageType.GRPC,
 				instrumentationName: this.INSTRUMENTATION_NAME,
 				submoduleName: "client",
 				kind: SpanKind.CLIENT,
 				stackTrace
 			},
 			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: SpanStatusCode.ERROR,
-				message: "No mock data found"
+		}).then((mockData) => {
+			if (!mockData) {
+				logger.warn(`[GrpcInstrumentation] No mock data found for gRPC request: ${inputValue.service}/${inputValue.method}`, inputValue);
+				callback(/* @__PURE__ */ new Error("No mock data found"));
+				SpanUtils.endSpan(spanInfo.span, { code: SpanStatusCode.ERROR });
+				return;
+			}
+			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);
 			});
-			return;
-		}
-		const mockResult = mockData.result;
+			SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: mockResult });
+			SpanUtils.endSpan(spanInfo.span, { code: mockResult.error ? SpanStatusCode.ERROR : SpanStatusCode.OK });
+		}).catch((error) => {
+			logger.error(`[GrpcInstrumentation] Error fetching mock data:`, error);
+			callback(error);
+			SpanUtils.endSpan(spanInfo.span, { code: SpanStatusCode.ERROR });
+		});
+		return emitter;
+	}
+	_handleRecordServerStreamRequest(spanInfo, original, context$1, parsedParams) {
+		let hasErrorOccurred = false;
+		let isSpanCompleted = false;
+		let streamResponses = [];
 		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 || {};
+		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 = original.apply(context$1, inputArgs);
+		stream.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.on("metadata", (initialMetadata) => {
+			responseMetadataInitial = serializeGrpcMetadata(initialMetadata);
+		});
+		stream.on("error", (err) => {
+			serviceError = err;
+			hasErrorOccurred = true;
+		});
+		stream.on("status", (responseStatus) => {
 			status = {
-				code: successStatus.code,
-				details: successStatus.details,
-				metadata: deserializeGrpcMetadata(MetadataConstructor, successStatus.metadata)
+				code: responseStatus.code,
+				details: responseStatus.details,
+				metadata: serializeGrpcMetadata(responseStatus.metadata)
 			};
-			const realResponse = deserializeGrpcPayload(body, bufferMapToUse, jsonableStringMapToUse);
-			callback(null, realResponse);
-		}
-		const emitter = Object.assign(new EventEmitter(), {
+			if (!hasErrorOccurred && streamResponses.length > 0) completeSpan({
+				body: streamResponses,
+				metadata: responseMetadataInitial,
+				status,
+				bufferMap: {},
+				jsonableStringMap: {}
+			}, SpanStatusCode.OK);
+			else if (!hasErrorOccurred && streamResponses.length === 0) completeSpan({
+				body: [],
+				metadata: responseMetadataInitial,
+				status,
+				bufferMap: {},
+				jsonableStringMap: {}
+			}, SpanStatusCode.OK);
+			else if (hasErrorOccurred) {
+				const errorOutput = {
+					error: {
+						message: serviceError.message,
+						name: serviceError.name,
+						stack: serviceError.stack
+					},
+					status,
+					metadata: responseMetadataInitial
+				};
+				completeSpan(errorOutput, SpanStatusCode.ERROR, serviceError.message);
+			}
+		});
+		return stream;
+	}
+	_handleReplayServerStreamRequest(spanInfo, inputValue, MetadataConstructor) {
+		logger.debug(`[GrpcInstrumentation] Replaying gRPC server stream request`);
+		const stream = new Readable({
+			objectMode: true,
+			read() {}
+		});
+		Object.assign(stream, {
 			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 ? SpanStatusCode.ERROR : SpanStatusCode.OK });
-		return emitter;
-	}
-	_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]);
+		findMockResponseAsync({
+			mockRequestData: {
+				traceId: spanInfo.traceId,
+				spanId: spanInfo.spanId,
+				name: "grpc.client.server_stream",
+				inputValue,
+				packageName: GRPC_MODULE_NAME,
+				packageType: PackageType.GRPC,
+				instrumentationName: this.INSTRUMENTATION_NAME,
+				submoduleName: "client",
+				kind: 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);
+				const error = /* @__PURE__ */ new Error("No mock data found");
+				process.nextTick(() => {
+					stream.emit("error", error);
+					stream.emit("status", {
+						code: 2,
+						details: "No mock data found",
+						metadata: new MetadataConstructor()
+					});
+					stream.push(null);
+				});
+				SpanUtils.endSpan(spanInfo.span, {
+					code: SpanStatusCode.ERROR,
+					message: "No mock data found"
+				});
+				return;
+			}
+			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.emit("metadata", deserializeGrpcMetadata(MetadataConstructor, mockResult.metadata));
+					const errorObj = Object.assign(new Error(error.message), {
+						name: error.name,
+						stack: error.stack,
+						...status
+					});
+					stream.emit("error", errorObj);
+					stream.emit("status", status);
+					stream.push(null);
+					SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: mockResult });
+					SpanUtils.endSpan(spanInfo.span, {
+						code: SpanStatusCode.ERROR,
+						message: error.message
+					});
+				} else {
+					const { body, status: successStatus } = mockResult;
+					const status = {
+						code: successStatus.code,
+						details: successStatus.details,
+						metadata: deserializeGrpcMetadata(MetadataConstructor, successStatus.metadata)
+					};
+					if (mockResult.metadata) stream.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.push(realResponse);
+					});
+					stream.push(null);
+					stream.emit("status", status);
+					SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: mockResult });
+					SpanUtils.endSpan(spanInfo.span, { code: SpanStatusCode.OK });
+				}
+			});
+		}).catch((error) => {
+			logger.error(`[GrpcInstrumentation] Error fetching mock data for server stream:`, error);
+			process.nextTick(() => {
+				stream.emit("error", error);
+				stream.emit("status", {
+					code: 2,
+					details: error.message,
+					metadata: new MetadataConstructor()
+				});
+				stream.push(null);
+			});
+			SpanUtils.endSpan(spanInfo.span, { code: SpanStatusCode.ERROR });
+		});
+		return stream;
+	}
+	_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({ replayModeHandler: () => {
+					return SpanUtils.createAndExecuteSpan(self.mode, () => originalGet.call(this), {
+						name: "firestore.document.get",
+						kind: SpanKind.CLIENT,
+						submodule: "document",
+						packageType: 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: SpanKind.CLIENT,
+							submodule: "document",
+							packageType: PackageType.FIRESTORE,
+							packageName: PACKAGE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleRecordDocumentGet(spanInfo, originalGet, this);
+						});
+					},
+					spanKind: SpanKind.CLIENT
+				});
+				else return originalGet.call(this);
+			};
+		};
+	}
+	async _handleRecordDocumentGet(spanInfo, originalGet, context$1) {
+		const snapshot = await originalGet.call(context$1);
+		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: 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: SpanKind.CLIENT
+			},
+			tuskDrift: this.tuskDrift
+		});
+		if (!mockData) {
+			logger.warn(`[FirestoreInstrumentation] No mock data found for document.get: ${inputValue.path}`);
+			return Promise.reject(/* @__PURE__ */ new Error("No mock data found"));
+		}
+		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({ replayModeHandler: () => {
+					return SpanUtils.createAndExecuteSpan(self.mode, () => originalCreate.call(this, data), {
+						name: "firestore.document.create",
+						kind: SpanKind.CLIENT,
+						submodule: "document",
+						packageType: 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: SpanKind.CLIENT,
+							submodule: "document",
+							packageType: PackageType.FIRESTORE,
+							packageName: PACKAGE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleRecordDocumentWrite(spanInfo, originalCreate, this, data);
+						});
+					},
+					spanKind: 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({ replayModeHandler: () => {
+					return SpanUtils.createAndExecuteSpan(self.mode, () => originalSet.call(this, data, options), {
+						name: "firestore.document.set",
+						kind: SpanKind.CLIENT,
+						submodule: "document",
+						packageType: 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: SpanKind.CLIENT,
+							submodule: "document",
+							packageType: PackageType.FIRESTORE,
+							packageName: PACKAGE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleRecordDocumentWrite(spanInfo, originalSet, this, data, options);
+						});
+					},
+					spanKind: 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({ replayModeHandler: () => {
+					return SpanUtils.createAndExecuteSpan(self.mode, () => originalUpdate.apply(this, args), {
+						name: "firestore.document.update",
+						kind: SpanKind.CLIENT,
+						submodule: "document",
+						packageType: 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: SpanKind.CLIENT,
+							submodule: "document",
+							packageType: PackageType.FIRESTORE,
+							packageName: PACKAGE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleRecordDocumentWrite(spanInfo, originalUpdate, this, ...args);
+						});
+					},
+					spanKind: SpanKind.CLIENT
+				});
+				else return originalUpdate.apply(this, args);
 			};
 		};
 	}
-	_getClosePatchFn() {
+	_getDocumentDeletePatchFn() {
 		const self = this;
-		return (original) => {
-			return function close() {
-				if (self.mode === TuskDriftMode.REPLAY) return;
-				else return original.apply(this, arguments);
+		return (originalDelete) => {
+			return function(precondition) {
+				const inputValue = {
+					operation: "document.delete",
+					path: this.path,
+					options: precondition
+				};
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
+					return SpanUtils.createAndExecuteSpan(self.mode, () => originalDelete.call(this, precondition), {
+						name: "firestore.document.delete",
+						kind: SpanKind.CLIENT,
+						submodule: "document",
+						packageType: 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: SpanKind.CLIENT,
+							submodule: "document",
+							packageType: PackageType.FIRESTORE,
+							packageName: PACKAGE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleRecordDocumentWrite(spanInfo, originalDelete, this, precondition);
+						});
+					},
+					spanKind: SpanKind.CLIENT
+				});
+				else return originalDelete.call(this, precondition);
 			};
 		};
 	}
-	_getGetChannelPatchFn() {
+	async _handleRecordDocumentWrite(spanInfo, originalWrite, context$1, ...args) {
+		const writeResult = await originalWrite.apply(context$1, 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: 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: SpanKind.CLIENT
+			},
+			tuskDrift: this.tuskDrift
+		});
+		if (!mockData) {
+			logger.warn(`[FirestoreInstrumentation] No mock data found for ${inputValue.operation}: ${inputValue.path}`);
+			return Promise.reject(/* @__PURE__ */ new Error("No mock data found"));
+		}
+		const writeResult = mockData.result;
+		return new TdFirestoreWriteResultMock(writeResult);
+	}
+	_getCollectionAddPatchFn() {
 		const self = this;
-		return (original) => {
-			return function getChannel() {
-				if (self.mode === TuskDriftMode.REPLAY) return {};
-				else return original.apply(this, arguments);
+		return (originalAdd) => {
+			return function(data) {
+				const inputValue = {
+					operation: "collection.add",
+					path: this.path,
+					data
+				};
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
+					return SpanUtils.createAndExecuteSpan(self.mode, () => originalAdd.call(this, data), {
+						name: "firestore.collection.add",
+						kind: SpanKind.CLIENT,
+						submodule: "collection",
+						packageType: 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: SpanKind.CLIENT,
+							submodule: "collection",
+							packageType: PackageType.FIRESTORE,
+							packageName: PACKAGE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleRecordCollectionAdd(spanInfo, originalAdd, this, data);
+						});
+					},
+					spanKind: SpanKind.CLIENT
+				});
+				else return originalAdd.call(this, data);
+			};
+		};
+	}
+	async _handleRecordCollectionAdd(spanInfo, originalAdd, context$1, data) {
+		const docRef = await originalAdd.call(context$1, data);
+		const result = {
+			id: docRef.id,
+			path: docRef.path
+		};
+		try {
+			SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: result });
+			SpanUtils.endSpan(spanInfo.span, { code: SpanStatusCode.OK });
+		} catch {
+			logger.error(`[FirestoreInstrumentation] Error updating span attributes for collection.add`);
+		}
+		return docRef;
+	}
+	async _handleReplayCollectionAdd(spanInfo, inputValue, collectionRef) {
+		logger.debug(`[FirestoreInstrumentation] Replaying collection.add`);
+		const mockData = await findMockResponseAsync({
+			mockRequestData: {
+				traceId: spanInfo.traceId,
+				spanId: spanInfo.spanId,
+				name: "firestore.collection.add",
+				inputValue: createMockInputValue(inputValue),
+				packageName: PACKAGE_NAME,
+				instrumentationName: this.INSTRUMENTATION_NAME,
+				submoduleName: "collection",
+				kind: SpanKind.CLIENT
+			},
+			tuskDrift: this.tuskDrift
+		});
+		if (!mockData) {
+			logger.warn(`[FirestoreInstrumentation] No mock data found for collection.add: ${inputValue.path}`);
+			return Promise.reject(/* @__PURE__ */ new Error("No mock data found"));
+		}
+		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"));
+		}
+		return this.originalCollectionDocFn.call(collectionRef, recordedId);
+	}
+	_getCollectionDocPatchFn() {
+		const self = this;
+		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({ replayModeHandler: () => {
+					return SpanUtils.createAndExecuteSpan(self.mode, () => documentPath ? originalDoc.call(this, documentPath) : originalDoc.call(this), {
+						name: "firestore.collection.doc",
+						kind: SpanKind.CLIENT,
+						submodule: "collection",
+						packageType: 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: SpanKind.CLIENT
+							},
+							tuskDrift: self.tuskDrift
+						});
+						if (!mockData) {
+							logger.warn(`[FirestoreInstrumentation] No mock data found for collection.doc: ${collectionPath}`);
+							throw new Error("No mock data found for collection.doc");
+						}
+						const recordedId = mockData.result.id;
+						logger.debug(`[FirestoreInstrumentation] replaying doc call with recorded id: ${recordedId}`);
+						const docRef = originalDoc.call(this, recordedId);
+						logger.debug(`[FirestoreInstrumentation] doc ref, id`, docRef, recordedId);
+						return docRef;
+					});
+				} });
+				else if (self.mode === TuskDriftMode.RECORD) return handleRecordMode({
+					originalFunctionCall: () => documentPath ? originalDoc.call(this, documentPath) : originalDoc.call(this),
+					recordModeHandler: ({ isPreAppStart }) => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => documentPath ? originalDoc.call(this, documentPath) : originalDoc.call(this), {
+							name: "firestore.collection.doc",
+							kind: SpanKind.CLIENT,
+							submodule: "collection",
+							packageType: 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: SpanStatusCode.OK });
+							} catch {
+								logger.error(`[FirestoreInstrumentation] Error updating span attributes for collection.doc`);
+							}
+							return docRef;
+						});
+					},
+					spanKind: SpanKind.CLIENT
+				});
+				else return documentPath ? originalDoc.call(this, documentPath) : originalDoc.call(this);
+			};
+		};
+	}
+	_getQueryGetPatchFn() {
+		const self = this;
+		return (originalGet) => {
+			return function() {
+				const inputValue = {
+					operation: "query.get",
+					path: this._queryOptions?.parentPath?.formattedName || "unknown"
+				};
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
+					return SpanUtils.createAndExecuteSpan(self.mode, () => originalGet.call(this), {
+						name: "firestore.query.get",
+						kind: SpanKind.CLIENT,
+						submodule: "query",
+						packageType: 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: SpanKind.CLIENT,
+							submodule: "query",
+							packageType: PackageType.FIRESTORE,
+							packageName: PACKAGE_NAME,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							isPreAppStart,
+							stopRecordingChildSpans: true
+						}, (spanInfo) => {
+							return self._handleRecordQueryGet(spanInfo, originalGet, this);
+						});
+					},
+					spanKind: SpanKind.CLIENT
+				});
+				else return originalGet.call(this);
 			};
 		};
 	}
+	async _handleRecordQueryGet(spanInfo, originalGet, context$1) {
+		const querySnapshot = await originalGet.call(context$1);
+		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: 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: SpanKind.CLIENT
+			},
+			tuskDrift: this.tuskDrift
+		});
+		if (!mockData) {
+			logger.warn(`[FirestoreInstrumentation] No mock data found for query.get: ${inputValue.path}`);
+			return Promise.reject(/* @__PURE__ */ new Error("No mock data found"));
+		}
+		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
@@ -7984,6 +9314,12 @@ 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}`);
@@ -7999,6 +9335,7 @@ var NextjsInstrumentation = class extends TdInstrumentationBase {
 						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);
@@ -8029,13 +9366,6 @@ var NextjsInstrumentation = class extends TdInstrumentationBase {
 				} });
 				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),
@@ -8114,6 +9444,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: 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;
@@ -8138,7 +9481,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,
@@ -8158,6 +9500,11 @@ var NextjsInstrumentation = class extends TdInstrumentationBase {
 				message: `HTTP ${capturedStatusCode}`
 			} : { code: 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();
@@ -8215,12 +9562,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: 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: SpanStatusCode.ERROR,
+					message: error instanceof Error ? error.message : "Unknown error"
+				});
+			} catch (e) {
+				logger.error(`[NextjsInstrumentation] Error ending span:`, e);
+			}
 		}
 	}
 	/**
@@ -10447,20 +11797,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: 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;
@@ -10484,8 +11835,8 @@ var SpanTransformer = class SpanTransformer {
 			outputValue: outputData,
 			inputSchema,
 			outputSchema,
-			inputSchemaHash: JsonSchemaHelper.generateDeterministicHash(inputSchema),
-			outputSchemaHash: JsonSchemaHelper.generateDeterministicHash(outputSchema),
+			inputSchemaHash,
+			outputSchemaHash,
 			inputValueHash,
 			outputValueHash,
 			kind: span.kind,
@@ -10728,18 +12079,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 filteredSpansBasedOnSize = 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 - filteredSpansBasedOnSize.length} oversized span(s), ${filteredSpansBasedOnSize.length} remaining`);
+		const cleanSpans = filteredSpansBasedOnSize.map((span) => SpanTransformer.transformSpanToCleanJSON(span));
 		if (this.adapters.length === 0) {
 			logger.debug("No adapters configured");
 			resultCallback({ code: import_src.ExportResultCode.SUCCESS });
@@ -10874,15 +12242,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();
@@ -10905,10 +12270,15 @@ var ProtobufCommunicator = class {
 				getMockRequest: protoMockRequest
 			}
 		});
+		logger.debug("Sending protobuf request to CLI (sync)", {
+			outboundSpan: mockRequest.outboundSpan,
+			testId: mockRequest.testId
+		});
 		const messageBytes = SDKMessage.toBinary(sdkMessage);
 		const tempDir = os.tmpdir();
-		const requestFile = path.join(tempDir, `tusk-request-${requestId}.bin`);
-		const responseFile = path.join(tempDir, `tusk-response-${requestId}.bin`);
+		const requestFile = path.join(tempDir, `tusk-sync-request-${requestId}.bin`);
+		const responseFile = path.join(tempDir, `tusk-sync-response-${requestId}.bin`);
+		const scriptFile = path.join(tempDir, `tusk-sync-script-${requestId}.js`);
 		try {
 			const lengthBuffer = Buffer.allocUnsafe(4);
 			lengthBuffer.writeUInt32BE(messageBytes.length, 0);
@@ -10917,19 +12287,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.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.join(os.tmpdir(), "tusk-connect.sock");
-				if (!fs.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.join(os.tmpdir(), "tusk-connect.sock")
+			};
+			fs.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 {
-				execSync(command, {
-					timeout: 1e4,
+				execSync(`node "${scriptFile}" "${requestFile}" "${responseFile}" '${JSON.stringify(connectionConfig)}'`, {
+					timeout: 12e3,
 					stdio: "pipe"
 				});
 				const responseBuffer = fs.readFileSync(responseFile);
@@ -10954,22 +12417,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.unlinkSync(requestFile);
+				if (fs.existsSync(requestFile)) fs.unlinkSync(requestFile);
 			} catch (e) {
 				logger.error("[ProtobufCommunicator] error cleaning up request file:", e);
 			}
 			try {
-				fs.unlinkSync(responseFile);
+				if (fs.existsSync(responseFile)) fs.unlinkSync(responseFile);
 			} catch (e) {
 				logger.error("[ProtobufCommunicator] error cleaning up response file:", e);
 			}
+			try {
+				if (fs.existsSync(scriptFile)) fs.unlinkSync(scriptFile);
+			} catch (e) {
+				logger.error("[ProtobufCommunicator] error cleaning up script file:", e);
+			}
 		}
 	}
 	async sendProtobufMessage(message) {
@@ -11137,7 +12605,8 @@ const TuskDriftInstrumentationModuleNames = [
 	"jwks-rsa",
 	"mysql2",
 	"ioredis",
-	"@grpc/grpc-js"
+	"@grpc/grpc-js",
+	"@google-cloud/firestore"
 ];
 
 //#endregion
@@ -11259,6 +12728,10 @@ var TuskDriftCore = class TuskDriftCore {
 			enabled: true,
 			mode: this.mode
 		});
+		new FirestoreInstrumentation({
+			enabled: true,
+			mode: this.mode
+		});
 		new NextjsInstrumentation({
 			enabled: true,
 			mode: this.mode
@@ -11431,6 +12904,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);
@@ -11478,7 +12955,7 @@ var TuskDriftCore = class TuskDriftCore {
 		return this.initParams;
 	}
 	getTracer() {
-		return trace.getTracer("tusk-drift-sdk", "1.0.0");
+		return trace.getTracer(TD_INSTRUMENTATION_LIBRARY_NAME);
 	}
 };
 var TuskDriftSDK = class {