@use-tusk/drift-node-sdk 0.1.11 → 0.1.13

package/dist/index.cjs

@@ -276,15 +276,6 @@ var TdInstrumentationAbstract = class {
 	}
 };
 
-//#endregion
-//#region package.json
-var version = "0.1.11";
-
-//#endregion
-//#region src/version.ts
-const SDK_VERSION = version;
-const MIN_CLI_VERSION = "0.1.0";
-
 //#endregion
 //#region src/core/utils/dataNormalizationUtils.ts
 /**
@@ -564,51 +555,40 @@ const logger = {
 
 //#endregion
 //#region src/core/analytics/analyticsUtils.ts
-function sendAnalyticsPayload(payload) {
-	try {
-		if (TuskDriftCore.getInstance().getConfig().recording?.enable_analytics) {}
-	} catch (e) {
-		logger.error("Error sending analytics event:", e);
-	}
-}
-function sendTdAnalytics(eventName, properties = {}) {
-	const serviceId = TuskDriftCore.getInstance().getConfig().service?.id || "unknown-service";
-	const payload = {
-		distinctId: `tusk-drift:${serviceId}`,
-		event: `${eventName}`,
-		properties: {
-			serviceId,
-			tdMode: TuskDriftCore.getInstance().getMode(),
-			sdkVersion: SDK_VERSION,
-			...properties
-		}
-	};
-	sendAnalyticsPayload(payload);
-}
 /**
-* NOTE: analytics has not been implemented yet, so this function does nothing
+* Send version mismatch alert to CLI (only in REPLAY mode)
 */
 function sendVersionMismatchAlert({ moduleName, foundVersion, supportedVersions }) {
+	logger.info("Sending version mismatch alert", {
+		moduleName,
+		foundVersion,
+		supportedVersions
+	});
 	try {
-		sendTdAnalytics("version_mismatch", {
+		if (TuskDriftCore.getInstance().getMode() !== TuskDriftMode.REPLAY) return;
+		const protobufComm = TuskDriftCore.getInstance().getProtobufCommunicator();
+		if (protobufComm) protobufComm.sendInstrumentationVersionMismatchAlert({
 			moduleName,
-			foundVersion: foundVersion || "unknown",
-			supportedVersions: supportedVersions.join(", ")
+			requestedVersion: foundVersion,
+			supportedVersions
 		});
 	} catch (e) {
 		logger.error("Error sending version mismatch alert:", e);
 	}
 }
 /**
-* NOTE: analytics has not been implemented yet, so this function does nothing
+* Send unpatched dependency alert to CLI
 */
-function sendUnpatchedDependencyAlert({ method, spanId, traceId, stackTrace }) {
+function sendUnpatchedDependencyAlert({ traceTestServerSpanId, stackTrace }) {
+	logger.info("Sending unpatched dependency alert", {
+		traceTestServerSpanId,
+		stackTrace
+	});
 	try {
-		sendTdAnalytics("unpatched_dependency", {
-			method,
-			spanId,
-			traceId,
-			stackTrace: stackTrace ? stackTrace.split("\n").slice(0, 10).join("\n") : void 0
+		const protobufComm = TuskDriftCore.getInstance().getProtobufCommunicator();
+		if (protobufComm && stackTrace) protobufComm.sendUnpatchedDependencyAlert({
+			stackTrace,
+			traceTestServerSpanId
 		});
 	} catch (e) {
 		logger.error("Error sending unpatched dependency alert:", e);
@@ -2039,9 +2019,12 @@ var HttpReplayHooks = class {
 		const traceIdHeader = req.headers["x-td-trace-id"] || req.headers["X-TD-TRACE-ID"];
 		return traceIdHeader ? String(traceIdHeader) : null;
 	}
-	extractEnvVarsFromHeaders(req) {
-		const envVarsHeader = req.headers["x-td-env-vars"] || req.headers["X-TD-ENV-VARS"];
-		return envVarsHeader ? JSON.parse(String(envVarsHeader)) : void 0;
+	/**
+	* Check if we should fetch env vars from CLI
+	*/
+	extractShouldFetchEnvVars(req) {
+		const fetchHeader = req.headers["x-td-fetch-env-vars"] || req.headers["X-TD-FETCH-ENV-VARS"];
+		return fetchHeader === "true" || fetchHeader === true;
 	}
 	/**
 	* Handle outbound HTTP requests in replay mode
@@ -2060,7 +2043,7 @@ var HttpReplayHooks = class {
 			auth: requestOptions.auth || void 0,
 			agent: requestOptions.agent || void 0,
 			protocol,
-			hostname: requestOptions.hostname || void 0,
+			hostname: requestOptions.hostname || requestOptions.host || void 0,
 			port: requestOptions.port ? Number(requestOptions.port) : void 0,
 			method
 		};
@@ -2654,8 +2637,13 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 					return originalHandler.call(this);
 				}
 				logger.debug(`[HttpInstrumentation] Setting replay trace id`, replayTraceId);
-				const envVars = this.replayHooks.extractEnvVarsFromHeaders(req);
-				if (envVars) EnvVarTracker.setEnvVars(replayTraceId, envVars);
+				if (this.replayHooks.extractShouldFetchEnvVars(req)) try {
+					const envVars = this.tuskDrift.requestEnvVarsSync(replayTraceId);
+					EnvVarTracker.setEnvVars(replayTraceId, envVars);
+					logger.debug(`[HttpInstrumentation] Fetched env vars from CLI for trace ${replayTraceId}`);
+				} catch (error) {
+					logger.error(`[HttpInstrumentation] Failed to fetch env vars from CLI:`, error);
+				}
 				const ctxWithReplayTraceId = SpanUtils.setCurrentReplayTraceId(replayTraceId);
 				if (!ctxWithReplayTraceId) throw new Error("Error setting current replay trace id");
 				return __opentelemetry_api.context.with(ctxWithReplayTraceId, () => {
@@ -3029,13 +3017,29 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 				readable: res.readable
 			};
 			const responseChunks = [];
-			if (res.readable) {
+			let streamConsumptionMode = "NOT_CONSUMING";
+			const originalRead = res.read?.bind(res);
+			if (originalRead) res.read = function read(size) {
+				const chunk = originalRead(size);
+				if (chunk && (streamConsumptionMode === "READ" || streamConsumptionMode === "NOT_CONSUMING")) {
+					streamConsumptionMode = "READ";
+					responseChunks.push(Buffer.from(chunk));
+				}
+				return chunk;
+			};
+			res.once("resume", () => {
 				res.on("data", (chunk) => {
-					responseChunks.push(chunk);
+					if (chunk && (streamConsumptionMode === "PIPE" || streamConsumptionMode === "NOT_CONSUMING")) {
+						streamConsumptionMode = "PIPE";
+						responseChunks.push(Buffer.from(chunk));
+					}
 				});
-				res.on("end", async () => {
-					if (responseChunks.length > 0) try {
-						const responseBuffer = combineChunks(responseChunks);
+			});
+			res.on("end", async (chunk) => {
+				if (chunk && typeof chunk !== "function") responseChunks.push(Buffer.from(chunk));
+				try {
+					if (responseChunks.length > 0) {
+						const responseBuffer = Buffer.concat(responseChunks);
 						const rawHeaders = this._captureHeadersFromRawHeaders(res.rawHeaders);
 						outputValue.headers = rawHeaders;
 						const contentEncoding = rawHeaders["content-encoding"];
@@ -3044,40 +3048,24 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 							contentEncoding
 						});
 						outputValue.bodySize = responseBuffer.length;
-						this._addOutputAttributesToSpan({
-							spanInfo,
-							outputValue,
-							statusCode: res.statusCode || 1,
-							outputSchemaMerges: {
-								body: {
-									encoding: __use_tusk_drift_schemas_core_json_schema.EncodingType.BASE64,
-									decodedType: getDecodedType(outputValue.headers["content-type"] || "")
-								},
-								headers: { matchImportance: 0 }
-							},
-							inputValue: completeInputValue
-						});
-					} catch (error) {
-						logger.error(`[HttpInstrumentation] Error processing response body:`, error);
 					}
-				});
-			} else try {
-				this._addOutputAttributesToSpan({
-					spanInfo,
-					outputValue,
-					statusCode: res.statusCode || 1,
-					outputSchemaMerges: {
-						body: {
-							encoding: __use_tusk_drift_schemas_core_json_schema.EncodingType.BASE64,
-							decodedType: getDecodedType(outputValue.headers["content-type"] || "")
+					this._addOutputAttributesToSpan({
+						spanInfo,
+						outputValue,
+						statusCode: res.statusCode || 1,
+						outputSchemaMerges: {
+							body: {
+								encoding: __use_tusk_drift_schemas_core_json_schema.EncodingType.BASE64,
+								decodedType: getDecodedType(outputValue.headers["content-type"] || "")
+							},
+							headers: { matchImportance: 0 }
 						},
-						headers: { matchImportance: 0 }
-					},
-					inputValue: completeInputValue
-				});
-			} catch (error) {
-				logger.error(`[HttpInstrumentation] Error adding output attributes to span:`, error);
-			}
+						inputValue: completeInputValue
+					});
+				} catch (error) {
+					logger.error(`[HttpInstrumentation] Error processing response body:`, error);
+				}
+			});
 		});
 		req.on("error", (error) => {
 			try {
@@ -6189,12 +6177,13 @@ var TcpInstrumentation = class extends TdInstrumentationBase {
 				traceId: currentSpanInfo.traceId,
 				socketContext
 			});
-			logger.warn(`[TcpInstrumentation] Full stack trace:\n${(/* @__PURE__ */ new Error()).stack}`);
+			const stackTrace = (/* @__PURE__ */ new Error()).stack || "";
+			const traceTestServerSpanId = SpanUtils.getCurrentReplayTraceId();
+			logger.warn(`[TcpInstrumentation] Full stack trace:\n${stackTrace}`, { traceTestServerSpanId });
 			Error.stackTraceLimit = 10;
 			sendUnpatchedDependencyAlert({
-				method: methodName,
-				spanId: currentSpanInfo.spanId,
-				traceId: currentSpanInfo.traceId
+				traceTestServerSpanId: traceTestServerSpanId || "",
+				stackTrace
 			});
 			if (this.loggedSpans.size > 1e3) {
 				logger.debug(`[TcpInstrumentation] Cleaning up logged spans cache (${this.loggedSpans.size} entries)`);
@@ -9633,8 +9622,13 @@ var NextjsInstrumentation = class extends TdInstrumentationBase {
 							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);
+						if (self.replayHooks.extractShouldFetchEnvVars(req)) try {
+							const envVars = self.tuskDrift.requestEnvVarsSync(replayTraceId);
+							EnvVarTracker.setEnvVars(replayTraceId, envVars);
+							logger.debug(`[NextjsInstrumentation] Fetched env vars from CLI for trace ${replayTraceId}`);
+						} catch (error) {
+							logger.error(`[NextjsInstrumentation] Failed to fetch env vars from CLI:`, error);
+						}
 						const ctxWithReplayTraceId = SpanUtils.setCurrentReplayTraceId(replayTraceId);
 						if (!ctxWithReplayTraceId) throw new Error("Error setting current replay trace id");
 						return __opentelemetry_api.context.with(ctxWithReplayTraceId, () => {
@@ -9940,6 +9934,239 @@ var NextjsInstrumentation = class extends TdInstrumentationBase {
 	}
 };
 
+//#endregion
+//#region src/instrumentation/libraries/prisma/types.ts
+/**
+* Prisma error class names for proper error handling
+*/
+let PrismaErrorClassName = /* @__PURE__ */ function(PrismaErrorClassName$1) {
+	PrismaErrorClassName$1["PrismaClientKnownRequestError"] = "PrismaClientKnownRequestError";
+	PrismaErrorClassName$1["PrismaClientUnknownRequestError"] = "PrismaClientUnknownRequestError";
+	PrismaErrorClassName$1["PrismaClientInitializationError"] = "PrismaClientInitializationError";
+	PrismaErrorClassName$1["PrismaClientValidationError"] = "PrismaClientValidationError";
+	PrismaErrorClassName$1["PrismaClientRustPanicError"] = "PrismaClientRustPanicError";
+	PrismaErrorClassName$1["NotFoundError"] = "NotFoundError";
+	return PrismaErrorClassName$1;
+}({});
+
+//#endregion
+//#region src/instrumentation/libraries/prisma/Instrumentation.ts
+var PrismaInstrumentation = class extends TdInstrumentationBase {
+	constructor(config = {}) {
+		super("@prisma/client", config);
+		this.INSTRUMENTATION_NAME = "PrismaInstrumentation";
+		this.prismaErrorClasses = [];
+		this.mode = config.mode || TuskDriftMode.DISABLED;
+		this.tuskDrift = TuskDriftCore.getInstance();
+	}
+	init() {
+		return [new TdInstrumentationNodeModule({
+			name: "@prisma/client",
+			supportedVersions: ["5.*", "6.*"],
+			patch: (moduleExports) => this._patchPrismaModule(moduleExports)
+		})];
+	}
+	_patchPrismaModule(prismaModule) {
+		if (this.isModulePatched(prismaModule)) {
+			logger.debug(`[PrismaInstrumentation] Prisma module already patched, skipping`);
+			return prismaModule;
+		}
+		this._storePrismaErrorClasses(prismaModule);
+		logger.debug(`[PrismaInstrumentation] Wrapping PrismaClient constructor`);
+		this._wrap(prismaModule, "PrismaClient", (OriginalPrismaClient) => {
+			const self = this;
+			logger.debug(`[PrismaInstrumentation] PrismaClient wrapper called`);
+			return class TdPrismaClient {
+				constructor(...args) {
+					logger.debug(`[PrismaInstrumentation] Creating patched PrismaClient instance`);
+					return new OriginalPrismaClient(...args).$extends({ query: { async $allOperations({ model, operation, args: operationArgs, query }) {
+						logger.debug(`[PrismaInstrumentation] $allOperations intercepted: ${model}.${operation}`);
+						return self._handlePrismaOperation({
+							model,
+							operation,
+							args: operationArgs,
+							query
+						});
+					} } });
+				}
+			};
+		});
+		this.markModuleAsPatched(prismaModule);
+		logger.debug(`[PrismaInstrumentation] Prisma module patching complete`);
+		return prismaModule;
+	}
+	_storePrismaErrorClasses(moduleExports) {
+		const prismaNamespace = moduleExports.Prisma || {};
+		this.prismaErrorClasses = [
+			{
+				name: PrismaErrorClassName.PrismaClientKnownRequestError,
+				errorClass: moduleExports.PrismaClientKnownRequestError || prismaNamespace.PrismaClientKnownRequestError
+			},
+			{
+				name: PrismaErrorClassName.PrismaClientUnknownRequestError,
+				errorClass: moduleExports.PrismaClientUnknownRequestError || prismaNamespace.PrismaClientUnknownRequestError
+			},
+			{
+				name: PrismaErrorClassName.PrismaClientInitializationError,
+				errorClass: moduleExports.PrismaClientInitializationError || prismaNamespace.PrismaClientInitializationError
+			},
+			{
+				name: PrismaErrorClassName.PrismaClientValidationError,
+				errorClass: moduleExports.PrismaClientValidationError || prismaNamespace.PrismaClientValidationError
+			},
+			{
+				name: PrismaErrorClassName.PrismaClientRustPanicError,
+				errorClass: moduleExports.PrismaClientRustPanicError || prismaNamespace.PrismaClientRustPanicError
+			},
+			{
+				name: PrismaErrorClassName.NotFoundError,
+				errorClass: moduleExports.NotFoundError || prismaNamespace.NotFoundError
+			}
+		];
+	}
+	_handlePrismaOperation({ model, operation, args, query }) {
+		const inputValue = {
+			model,
+			operation,
+			args
+		};
+		logger.debug(`[PrismaInstrumentation] Intercepted Prisma operation: ${model}.${operation} in ${this.mode} mode`);
+		if (this.mode === TuskDriftMode.RECORD) return handleRecordMode({
+			originalFunctionCall: () => query(args),
+			recordModeHandler: ({ isPreAppStart }) => {
+				return SpanUtils.createAndExecuteSpan(this.mode, () => query(args), {
+					name: `prisma.${operation}`,
+					kind: __opentelemetry_api.SpanKind.CLIENT,
+					submodule: model,
+					packageType: __use_tusk_drift_schemas_core_span.PackageType.UNSPECIFIED,
+					packageName: "@prisma/client",
+					instrumentationName: this.INSTRUMENTATION_NAME,
+					inputValue,
+					isPreAppStart
+				}, (spanInfo) => {
+					return this._handleRecordPrismaOperation(spanInfo, query, args);
+				});
+			},
+			spanKind: __opentelemetry_api.SpanKind.CLIENT
+		});
+		else if (this.mode === TuskDriftMode.REPLAY) {
+			const stackTrace = captureStackTrace(["PrismaInstrumentation"]);
+			return handleReplayMode({
+				noOpRequestHandler: () => query(args),
+				isServerRequest: false,
+				replayModeHandler: () => {
+					return SpanUtils.createAndExecuteSpan(this.mode, () => query(args), {
+						name: `prisma.${operation}`,
+						kind: __opentelemetry_api.SpanKind.CLIENT,
+						submodule: model,
+						packageType: __use_tusk_drift_schemas_core_span.PackageType.UNSPECIFIED,
+						packageName: "@prisma/client",
+						instrumentationName: this.INSTRUMENTATION_NAME,
+						inputValue,
+						isPreAppStart: false
+					}, (spanInfo) => {
+						return this._handleReplayPrismaOperation(spanInfo, inputValue, stackTrace);
+					});
+				}
+			});
+		} else return query(args);
+	}
+	async _handleRecordPrismaOperation(spanInfo, query, args) {
+		try {
+			logger.debug(`[PrismaInstrumentation] Recording Prisma operation`);
+			const result = await query(args);
+			const outputValue = {
+				prismaResult: result,
+				_tdOriginalFormat: "result"
+			};
+			try {
+				SpanUtils.addSpanAttributes(spanInfo.span, { outputValue });
+				SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.OK });
+			} catch (spanError) {
+				logger.error(`[PrismaInstrumentation] error adding span attributes:`, spanError);
+			}
+			return result;
+		} catch (error) {
+			logger.debug(`[PrismaInstrumentation] Prisma operation error: ${error.message}`);
+			try {
+				const errorClassName = this._getPrismaErrorClassName(error);
+				const errorWithClassName = this._cloneError(error);
+				if (errorClassName) errorWithClassName.customTdName = errorClassName;
+				const outputValue = {
+					prismaResult: errorWithClassName,
+					_tdOriginalFormat: "error"
+				};
+				SpanUtils.addSpanAttributes(spanInfo.span, { outputValue });
+				SpanUtils.endSpan(spanInfo.span, {
+					code: __opentelemetry_api.SpanStatusCode.ERROR,
+					message: error.message
+				});
+			} catch (spanError) {
+				logger.error(`[PrismaInstrumentation] error extracting error and adding span attributes:`, spanError);
+			}
+			throw error;
+		}
+	}
+	async _handleReplayPrismaOperation(spanInfo, inputValue, stackTrace) {
+		const mockData = await findMockResponseAsync({
+			mockRequestData: {
+				traceId: spanInfo.traceId,
+				spanId: spanInfo.spanId,
+				name: `prisma.${inputValue.operation}`,
+				inputValue,
+				packageName: "@prisma/client",
+				instrumentationName: this.INSTRUMENTATION_NAME,
+				submoduleName: inputValue.model,
+				kind: __opentelemetry_api.SpanKind.CLIENT,
+				stackTrace
+			},
+			tuskDrift: this.tuskDrift
+		});
+		if (!mockData) {
+			logger.warn(`[PrismaInstrumentation] No mock data found for Prisma operation: ${inputValue.model}.${inputValue.operation}`);
+			throw new Error(`[PrismaInstrumentation] No matching mock found for Prisma operation: ${inputValue.model}.${inputValue.operation}`);
+		}
+		logger.debug(`[PrismaInstrumentation] Found mock data for Prisma operation: ${inputValue.model}.${inputValue.operation}`);
+		const outputValue = mockData.result;
+		if (outputValue._tdOriginalFormat === "error") {
+			const errorObj = outputValue.prismaResult;
+			if (errorObj.customTdName) {
+				const errorClass = this._getPrismaErrorClassFromName(errorObj.customTdName);
+				if (errorClass) Object.setPrototypeOf(errorObj, errorClass.prototype);
+			}
+			SpanUtils.endSpan(spanInfo.span, {
+				code: __opentelemetry_api.SpanStatusCode.ERROR,
+				message: errorObj.message || "Prisma error"
+			});
+			throw errorObj;
+		}
+		SpanUtils.endSpan(spanInfo.span, { code: __opentelemetry_api.SpanStatusCode.OK });
+		return outputValue.prismaResult;
+	}
+	_getPrismaErrorClassName(error) {
+		for (const errorInfo of this.prismaErrorClasses) if (error instanceof errorInfo.errorClass) return errorInfo.name;
+	}
+	_getPrismaErrorClassFromName(className) {
+		for (const errorInfo of this.prismaErrorClasses) if (errorInfo.name === className) return errorInfo.errorClass;
+		return null;
+	}
+	/**
+	* Deep clone an error object to make it serializable
+	*/
+	_cloneError(error) {
+		const cloned = new Error(error.message);
+		cloned.name = error.name;
+		cloned.stack = error.stack;
+		for (const key in error) if (error.hasOwnProperty(key)) try {
+			cloned[key] = error[key];
+		} catch (e) {}
+		return cloned;
+	}
+	_wrap(target, propertyName, wrapper) {
+		wrap(target, propertyName, wrapper);
+	}
+};
+
 //#endregion
 //#region node_modules/@opentelemetry/core/build/src/trace/suppress-tracing.js
 var require_suppress_tracing = /* @__PURE__ */ __commonJS({ "node_modules/@opentelemetry/core/build/src/trace/suppress-tracing.js": ((exports) => {
@@ -12440,9 +12667,18 @@ var TdSpanExporter = class {
 	}
 };
 
+//#endregion
+//#region package.json
+var version = "0.1.13";
+
+//#endregion
+//#region src/version.ts
+const SDK_VERSION = version;
+const MIN_CLI_VERSION = "0.1.0";
+
 //#endregion
 //#region src/core/ProtobufCommunicator.ts
-var ProtobufCommunicator = class {
+var ProtobufCommunicator = class ProtobufCommunicator {
 	constructor() {
 		this.client = null;
 		this.pendingRequests = /* @__PURE__ */ new Map();
@@ -12540,43 +12776,18 @@ var ProtobufCommunicator = class {
 		});
 	}
 	/**
-	* 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.
-	*
-	* 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.
+	* Generic synchronous request handler that spawns a child process.
+	* @param sdkMessage The SDK message to send
+	* @param filePrefix Prefix for temporary files (e.g., 'envvar', 'mock')
+	* @param responseHandler Function to extract and return the desired response
 	*/
-	requestMockSync(mockRequest) {
-		const requestId = this.generateRequestId();
-		const cleanSpan = mockRequest.outboundSpan ? this.cleanSpan(mockRequest.outboundSpan) : void 0;
-		if (cleanSpan?.inputValue) cleanSpan.inputValue = objectToProtobufStruct(cleanSpan.inputValue);
-		if (cleanSpan?.inputSchema) cleanSpan.inputSchema = objectToProtobufStruct(cleanSpan.inputSchema);
-		if (cleanSpan?.kind) cleanSpan.kind = mapOtToPb(cleanSpan.kind);
-		const protoMockRequest = __use_tusk_drift_schemas_core_communication.GetMockRequest.create({
-			...mockRequest,
-			requestId,
-			tags: {},
-			outboundSpan: cleanSpan,
-			stackTrace: cleanSpan?.stackTrace
-		});
-		const sdkMessage = __use_tusk_drift_schemas_core_communication.SDKMessage.create({
-			type: __use_tusk_drift_schemas_core_communication.MessageType.MOCK_REQUEST,
-			requestId,
-			payload: {
-				oneofKind: "getMockRequest",
-				getMockRequest: protoMockRequest
-			}
-		});
-		logger.debug("Sending protobuf request to CLI (sync)", {
-			outboundSpan: mockRequest.outboundSpan,
-			testId: mockRequest.testId
-		});
+	executeSyncRequest(sdkMessage, filePrefix, responseHandler) {
+		const requestId = sdkMessage.requestId;
 		const messageBytes = __use_tusk_drift_schemas_core_communication.SDKMessage.toBinary(sdkMessage);
 		const tempDir = os.default.tmpdir();
-		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`);
+		const requestFile = path.default.join(tempDir, `tusk-sync-${filePrefix}-request-${requestId}.bin`);
+		const responseFile = path.default.join(tempDir, `tusk-sync-${filePrefix}-response-${requestId}.bin`);
+		const scriptFile = path.default.join(tempDir, `tusk-sync-${filePrefix}-script-${requestId}.js`);
 		try {
 			const lengthBuffer = Buffer.allocUnsafe(4);
 			lengthBuffer.writeUInt32BE(messageBytes.length, 0);
@@ -12599,95 +12810,7 @@ var ProtobufCommunicator = class {
 				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);
-}
-`);
+			fs.default.writeFileSync(scriptFile, ProtobufCommunicator.SYNC_CHILD_SCRIPT);
 			try {
 				(0, child_process.execSync)(`node "${scriptFile}" "${requestFile}" "${responseFile}" '${JSON.stringify(connectionConfig)}'`, {
 					timeout: 12e3,
@@ -12699,27 +12822,13 @@ try {
 				if (responseBuffer.length < 4 + responseLength) throw new Error("Invalid response: incomplete message");
 				const responseData = responseBuffer.slice(4, 4 + responseLength);
 				const cliMessage = __use_tusk_drift_schemas_core_communication.CLIMessage.fromBinary(responseData);
-				if (cliMessage.payload.oneofKind !== "getMockResponse") throw new Error(`Unexpected response type: ${cliMessage.type}`);
-				const mockResponse = cliMessage.payload.getMockResponse;
-				if (!mockResponse) throw new Error("No mock response received");
-				if (mockResponse.found) try {
-					return {
-						found: true,
-						response: this.extractResponseData(mockResponse)
-					};
-				} catch (error) {
-					throw new Error(`Failed to extract response data: ${error}`);
-				}
-				else return {
-					found: false,
-					error: mockResponse.error || "Mock not found"
-				};
+				return responseHandler(cliMessage);
 			} catch (error) {
-				logger.error("[ProtobufCommunicator] error in sync request child process:", error);
+				logger.error(`[ProtobufCommunicator] error in sync ${filePrefix} request child process:`, error);
 				throw error;
 			}
 		} catch (error) {
-			throw new Error(`Sync request failed: ${error.message}`);
+			throw new Error(`Sync ${filePrefix} request failed: ${error.message}`);
 		} finally {
 			try {
 				if (fs.default.existsSync(requestFile)) fs.default.unlinkSync(requestFile);
@@ -12738,6 +12847,86 @@ try {
 			}
 		}
 	}
+	/**
+	* Request environment variables from CLI synchronously using a child process.
+	* This blocks the main thread, so it should be used carefully.
+	* Similar to requestMockSync but for environment variables.
+	*/
+	requestEnvVarsSync(traceTestServerSpanId) {
+		const requestId = this.generateRequestId();
+		const envVarRequest = __use_tusk_drift_schemas_core_communication.EnvVarRequest.create({ traceTestServerSpanId });
+		const sdkMessage = __use_tusk_drift_schemas_core_communication.SDKMessage.create({
+			type: __use_tusk_drift_schemas_core_communication.MessageType.ENV_VAR_REQUEST,
+			requestId,
+			payload: {
+				oneofKind: "envVarRequest",
+				envVarRequest
+			}
+		});
+		logger.debug(`[ProtobufCommunicator] Requesting env vars (sync) for trace: ${traceTestServerSpanId}`);
+		return this.executeSyncRequest(sdkMessage, "envvar", (cliMessage) => {
+			if (cliMessage.payload.oneofKind !== "envVarResponse") throw new Error(`Unexpected response type: ${cliMessage.type}`);
+			const envVarResponse = cliMessage.payload.envVarResponse;
+			if (!envVarResponse) throw new Error("No env var response received");
+			const envVars = {};
+			if (envVarResponse.envVars) Object.entries(envVarResponse.envVars).forEach(([key, value]) => {
+				envVars[key] = value;
+			});
+			logger.debug(`[ProtobufCommunicator] Received env vars (sync), count: ${Object.keys(envVars).length}`);
+			return envVars;
+		});
+	}
+	/**
+	* 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.
+	*
+	* 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();
+		const cleanSpan = mockRequest.outboundSpan ? this.cleanSpan(mockRequest.outboundSpan) : void 0;
+		if (cleanSpan?.inputValue) cleanSpan.inputValue = objectToProtobufStruct(cleanSpan.inputValue);
+		if (cleanSpan?.inputSchema) cleanSpan.inputSchema = objectToProtobufStruct(cleanSpan.inputSchema);
+		if (cleanSpan?.kind) cleanSpan.kind = mapOtToPb(cleanSpan.kind);
+		const protoMockRequest = __use_tusk_drift_schemas_core_communication.GetMockRequest.create({
+			...mockRequest,
+			requestId,
+			tags: {},
+			outboundSpan: cleanSpan,
+			stackTrace: cleanSpan?.stackTrace
+		});
+		const sdkMessage = __use_tusk_drift_schemas_core_communication.SDKMessage.create({
+			type: __use_tusk_drift_schemas_core_communication.MessageType.MOCK_REQUEST,
+			requestId,
+			payload: {
+				oneofKind: "getMockRequest",
+				getMockRequest: protoMockRequest
+			}
+		});
+		logger.debug("Sending protobuf request to CLI (sync)", {
+			outboundSpan: mockRequest.outboundSpan,
+			testId: mockRequest.testId
+		});
+		return this.executeSyncRequest(sdkMessage, "mock", (cliMessage) => {
+			if (cliMessage.payload.oneofKind !== "getMockResponse") throw new Error(`Unexpected response type: ${cliMessage.type}`);
+			const mockResponse = cliMessage.payload.getMockResponse;
+			if (!mockResponse) throw new Error("No mock response received");
+			if (mockResponse.found) try {
+				return {
+					found: true,
+					response: this.extractResponseData(mockResponse)
+				};
+			} catch (error) {
+				throw new Error(`Failed to extract response data: ${error}`);
+			}
+			else return {
+				found: false,
+				error: mockResponse.error || "Mock not found"
+			};
+		});
+	}
 	async sendProtobufMessage(message) {
 		if (!this.client || !this.protobufContext) throw new Error("Not connected to CLI");
 		const messageBytes = __use_tusk_drift_schemas_core_communication.SDKMessage.toBinary(message);
@@ -12790,6 +12979,58 @@ try {
 		});
 		await this.sendProtobufMessage(sdkMessage);
 	}
+	/**
+	* Send an alert to the CLI (fire-and-forget, no response expected)
+	*/
+	async sendAlert(alert) {
+		if (!this.client || !this.protobufContext) {
+			logger.debug("[ProtobufCommunicator] Not connected to CLI, skipping alert");
+			return;
+		}
+		const sdkMessage = __use_tusk_drift_schemas_core_communication.SDKMessage.create({
+			type: __use_tusk_drift_schemas_core_communication.MessageType.ALERT,
+			requestId: this.generateRequestId(),
+			payload: {
+				oneofKind: "sendAlertRequest",
+				sendAlertRequest: alert
+			}
+		});
+		try {
+			await this.sendProtobufMessage(sdkMessage);
+			logger.debug("[ProtobufCommunicator] Alert sent to CLI");
+		} catch (error) {
+			logger.debug("[ProtobufCommunicator] Failed to send alert to CLI:", error);
+		}
+	}
+	/**
+	* Send instrumentation version mismatch alert to CLI
+	*/
+	async sendInstrumentationVersionMismatchAlert(params) {
+		const alert = __use_tusk_drift_schemas_core_communication.SendAlertRequest.create({ alert: {
+			oneofKind: "versionMismatch",
+			versionMismatch: __use_tusk_drift_schemas_core_communication.InstrumentationVersionMismatchAlert.create({
+				moduleName: params.moduleName,
+				requestedVersion: params.requestedVersion || "",
+				supportedVersions: params.supportedVersions,
+				sdkVersion: SDK_VERSION
+			})
+		} });
+		await this.sendAlert(alert);
+	}
+	/**
+	* Send unpatched dependency alert to CLI
+	*/
+	async sendUnpatchedDependencyAlert(params) {
+		const alert = __use_tusk_drift_schemas_core_communication.SendAlertRequest.create({ alert: {
+			oneofKind: "unpatchedDependency",
+			unpatchedDependency: __use_tusk_drift_schemas_core_communication.UnpatchedDependencyAlert.create({
+				stackTrace: params.stackTrace,
+				traceTestServerSpanId: params.traceTestServerSpanId,
+				sdkVersion: SDK_VERSION
+			})
+		} });
+		await this.sendAlert(alert);
+	}
 	handleIncomingData(data) {
 		this.incomingBuffer = Buffer.concat([this.incomingBuffer, data]);
 		logger.debug(`[ProtobufCommunicator] Processing buffer, length: ${this.incomingBuffer.length}`);
@@ -12847,6 +13088,22 @@ try {
 				error: mockResponse.error || "Mock not found"
 			});
 		}
+		if (message.payload.oneofKind === "envVarResponse") {
+			const envVarResponse = message.payload.envVarResponse;
+			logger.debug(`[ProtobufCommunicator] Received env var response for requestId: ${requestId}`);
+			const pendingRequest = this.pendingRequests.get(requestId);
+			if (!pendingRequest) {
+				logger.warn("[ProtobufCommunicator] received env var response for unknown request:", requestId);
+				return;
+			}
+			this.pendingRequests.delete(requestId);
+			const envVars = {};
+			if (envVarResponse?.envVars) Object.entries(envVarResponse.envVars).forEach(([key, value]) => {
+				envVars[key] = value;
+			});
+			pendingRequest.resolve(envVars);
+			return;
+		}
 	}
 	/**
 	* Extract response data from MockResponse
@@ -12889,6 +13146,95 @@ try {
 		}
 	}
 };
+ProtobufCommunicator.SYNC_CHILD_SCRIPT = `
+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);
+}
+`;
 
 //#endregion
 //#region src/core/TuskDriftInstrumentationModuleNames.ts
@@ -13069,6 +13415,10 @@ var TuskDriftCore = class TuskDriftCore {
 			enabled: true,
 			mode: this.mode
 		});
+		new PrismaInstrumentation({
+			enabled: true,
+			mode: this.mode
+		});
 	}
 	initializeTracing({ baseDirectory }) {
 		const serviceName = this.config.service?.name || "unknown";
@@ -13237,6 +13587,30 @@ var TuskDriftCore = class TuskDriftCore {
 			};
 		}
 	}
+	/**
+	* Request environment variables from CLI for a specific trace (synchronously).
+	* This blocks the main thread, so it should be used carefully.
+	*/
+	requestEnvVarsSync(traceTestServerSpanId) {
+		if (!this.isConnectedWithCLI) {
+			logger.error("Requesting sync env vars but CLI is not ready yet");
+			throw new Error("Requesting sync env vars but CLI is not ready yet");
+		}
+		if (!this.communicator || this.mode !== TuskDriftMode.REPLAY) {
+			logger.debug("Cannot request env vars: not in replay mode or no CLI connection");
+			return {};
+		}
+		try {
+			logger.debug(`Requesting env vars (sync) for trace: ${traceTestServerSpanId}`);
+			const envVars = this.communicator.requestEnvVarsSync(traceTestServerSpanId);
+			logger.debug(`Received env vars from CLI, count: ${Object.keys(envVars).length}`);
+			logger.debug(`First 10 env vars: ${JSON.stringify(Object.keys(envVars).slice(0, 10), null, 2)}`);
+			return envVars;
+		} catch (error) {
+			logger.error(`[TuskDrift] Error requesting env vars from CLI:`, error);
+			return {};
+		}
+	}
 	requestMockSync(mockRequest) {
 		if (!this.isConnectedWithCLI) {
 			logger.error("Requesting sync mock but CLI is not ready yet");
@@ -13291,6 +13665,9 @@ var TuskDriftCore = class TuskDriftCore {
 	getTracer() {
 		return __opentelemetry_api.trace.getTracer(TD_INSTRUMENTATION_LIBRARY_NAME);
 	}
+	getProtobufCommunicator() {
+		return this.communicator;
+	}
 };
 var TuskDriftSDK = class {
 	constructor() {