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

package/dist/index.js

@@ -256,7 +256,7 @@ var TdInstrumentationAbstract = class {
 
 //#endregion
 //#region package.json
-var version = "0.1.11";
+var version = "0.1.12";
 
 //#endregion
 //#region src/version.ts
@@ -2038,7 +2038,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
 		};
@@ -3007,13 +3007,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"];
@@ -3022,40 +3038,24 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 							contentEncoding
 						});
 						outputValue.bodySize = responseBuffer.length;
-						this._addOutputAttributesToSpan({
-							spanInfo,
-							outputValue,
-							statusCode: res.statusCode || 1,
-							outputSchemaMerges: {
-								body: {
-									encoding: 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: EncodingType.BASE64,
-							decodedType: getDecodedType(outputValue.headers["content-type"] || "")
+					this._addOutputAttributesToSpan({
+						spanInfo,
+						outputValue,
+						statusCode: res.statusCode || 1,
+						outputSchemaMerges: {
+							body: {
+								encoding: 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 {
@@ -9918,6 +9918,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: SpanKind.CLIENT,
+					submodule: model,
+					packageType: PackageType.UNSPECIFIED,
+					packageName: "@prisma/client",
+					instrumentationName: this.INSTRUMENTATION_NAME,
+					inputValue,
+					isPreAppStart
+				}, (spanInfo) => {
+					return this._handleRecordPrismaOperation(spanInfo, query, args);
+				});
+			},
+			spanKind: 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: SpanKind.CLIENT,
+						submodule: model,
+						packageType: 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: 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: 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: 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: SpanStatusCode.ERROR,
+				message: errorObj.message || "Prisma error"
+			});
+			throw errorObj;
+		}
+		SpanUtils.endSpan(spanInfo.span, { code: 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) => {
@@ -13047,6 +13280,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";