@use-tusk/drift-node-sdk 0.1.0 → 0.1.4

package/dist/index.cjs

@@ -34,6 +34,8 @@ let semver = require("semver");
 semver = __toESM(semver);
 let require_in_the_middle = require("require-in-the-middle");
 require_in_the_middle = __toESM(require_in_the_middle);
+let import_in_the_middle = require("import-in-the-middle");
+import_in_the_middle = __toESM(import_in_the_middle);
 let __use_tusk_drift_schemas_google_protobuf_struct = require("@use-tusk/drift-schemas/google/protobuf/struct");
 __use_tusk_drift_schemas_google_protobuf_struct = __toESM(__use_tusk_drift_schemas_google_protobuf_struct);
 let __opentelemetry_api = require("@opentelemetry/api");
@@ -89,7 +91,7 @@ var TdInstrumentationAbstract = class {
 
 //#endregion
 //#region package.json
-var version = "0.1.0";
+var version = "0.1.4";
 
 //#endregion
 //#region src/version.ts
@@ -414,10 +416,11 @@ function sendUnpatchedDependencyAlert({ method, spanId, traceId, stackTrace }) {
 
 //#endregion
 //#region src/instrumentation/core/baseClasses/TdInstrumentationBase.ts
-var TdInstrumentationBase = class extends TdInstrumentationAbstract {
+var TdInstrumentationBase = class TdInstrumentationBase extends TdInstrumentationAbstract {
 	constructor(instrumentationName, config = {}) {
 		super(instrumentationName, config);
 		this._modules = [];
+		this._hooks = [];
 		this._enabled = false;
 		let modules = this.init();
 		if (modules && !Array.isArray(modules)) modules = [modules];
@@ -458,12 +461,35 @@ var TdInstrumentationBase = class extends TdInstrumentationAbstract {
 			const onRequire = (exports$1, name, baseDir) => {
 				return this._onRequire(module$1, exports$1, name, baseDir);
 			};
-			new require_in_the_middle.Hook([module$1.name], { internals: true }, onRequire);
+			const hookFn = (exports$1, name, baseDir) => {
+				if (!baseDir && path.default.isAbsolute(name)) {
+					const parsedPath = path.default.parse(name);
+					name = parsedPath.name;
+					baseDir = parsedPath.dir;
+				}
+				return this._onRequire(module$1, exports$1, name, baseDir || void 0);
+			};
+			const cjsHook = new require_in_the_middle.Hook([module$1.name], { internals: true }, onRequire);
+			this._hooks.push(cjsHook);
+			const esmHook = new import_in_the_middle.Hook([module$1.name], { internals: false }, hookFn);
+			this._hooks.push(esmHook);
 		}
 	}
 	isEnabled() {
 		return this._enabled;
 	}
+	/**
+	* Mark a module as patched.
+	*/
+	markModuleAsPatched(moduleExports) {
+		TdInstrumentationBase._patchedModules.add(moduleExports);
+	}
+	/**
+	* Check if a module has already been patched.
+	*/
+	isModulePatched(moduleExports) {
+		return TdInstrumentationBase._patchedModules.has(moduleExports);
+	}
 	_onRequire(module$1, exports$1, name, baseDir) {
 		if (!baseDir) {
 			if (typeof module$1.patch === "function") {
@@ -526,6 +552,7 @@ var TdInstrumentationBase = class extends TdInstrumentationAbstract {
 		}, exports$1);
 	}
 };
+TdInstrumentationBase._patchedModules = /* @__PURE__ */ new WeakSet();
 
 //#endregion
 //#region src/instrumentation/core/baseClasses/TdInstrumentationNodeModule.ts
@@ -1552,10 +1579,11 @@ async function findMockResponseAsync({ mockRequestData, tuskDrift, inputValueSch
 
 //#endregion
 //#region src/instrumentation/libraries/http/mocks/TdMockClientRequest.ts
+let ClientRequest;
 /**
 * Mock ClientRequest implementation for Tusk Drift HTTP replay
 */
-var TdMockClientRequest = class extends events.EventEmitter {
+var TdMockClientRequest = class TdMockClientRequest extends events.EventEmitter {
 	constructor(options, spanInfo, callback) {
 		super();
 		this.INSTRUMENTATION_NAME = "HttpInstrumentation";
@@ -1564,6 +1592,7 @@ var TdMockClientRequest = class extends events.EventEmitter {
 		this.playbackStarted = false;
 		this.readyToStartPlaybackOnSocketEvent = false;
 		this.headers = {};
+		TdMockClientRequest._setupPrototype();
 		this.tuskDrift = TuskDriftCore.getInstance();
 		this.spanInfo = spanInfo;
 		if (!options || Object.keys(options).length === 0) throw new Error("Making a request with empty `options` is not supported in TdMockClientRequest");
@@ -1804,8 +1833,16 @@ var TdMockClientRequest = class extends events.EventEmitter {
 		this.socket.destroy();
 		return this;
 	}
+	static _setupPrototype() {
+		if (!ClientRequest) {
+			ClientRequest = require("http").ClientRequest;
+			Object.setPrototypeOf(TdMockClientRequest.prototype, ClientRequest.prototype);
+		}
+	}
+	static initialize() {
+		TdMockClientRequest._setupPrototype();
+	}
 };
-Object.setPrototypeOf(TdMockClientRequest.prototype, http.ClientRequest.prototype);
 
 //#endregion
 //#region src/instrumentation/libraries/http/HttpReplayHooks.ts
@@ -1930,6 +1967,7 @@ function wrap(target, propertyName, wrapper) {
 	wrapped._original = original;
 	wrapped._propertyName = propertyName;
 	target[propertyName] = wrapped;
+	return wrapped;
 }
 
 //#endregion
@@ -2075,7 +2113,19 @@ var HttpTransformEngine = class {
 			const target = span[selector];
 			if (!target) return false;
 			try {
-				return jsonpath.default.apply(target.body, jsonPath, actionFunction).length > 0;
+				const body = target.body;
+				if (!body) return false;
+				let bodyObj;
+				if (typeof body === "string") try {
+					const decoded = Buffer.from(body, "base64").toString("utf8");
+					bodyObj = JSON.parse(decoded);
+				} catch (e) {
+					return false;
+				}
+				else bodyObj = body;
+				const nodes = jsonpath.default.apply(bodyObj, jsonPath, actionFunction);
+				if (typeof body === "string" && nodes.length > 0) target.body = Buffer.from(JSON.stringify(bodyObj)).toString("base64");
+				return nodes.length > 0;
 			} catch (error) {
 				return false;
 			}
@@ -2083,9 +2133,8 @@ var HttpTransformEngine = class {
 	}
 	compileHeaderAction(headerName, actionFunction, direction) {
 		const lowerHeader = headerName.toLowerCase();
-		const selector = direction === "inbound" ? "inputValue" : "outputValue";
 		return (span) => {
-			const target = span[selector];
+			const target = span.inputValue;
 			if (!target?.headers) return false;
 			let applied = false;
 			for (const key of Object.keys(target.headers)) if (key.toLowerCase() === lowerHeader) {
@@ -2106,7 +2155,15 @@ var HttpTransformEngine = class {
 		return (span) => {
 			const target = span[selector];
 			if (!target || target.body === void 0) return false;
-			target.body = actionFunction(typeof target.body === "string" ? target.body : JSON.stringify(target.body));
+			if (direction === "outbound") if (typeof target.body === "string") try {
+				const decoded = Buffer.from(target.body, "base64").toString("utf8");
+				const transformed = actionFunction(decoded);
+				target.body = Buffer.from(transformed).toString("base64");
+			} catch (error) {
+				target.body = Buffer.from(actionFunction(target.body)).toString("base64");
+			}
+			else target.body = Buffer.from(actionFunction(JSON.stringify(target.body))).toString("base64");
+			else target.body = actionFunction(typeof target.body === "string" ? target.body : JSON.stringify(target.body));
 			return true;
 		};
 	}
@@ -2212,18 +2269,25 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 	_patchHttpModule(httpModule, protocol) {
 		const protocolUpper = protocol.toUpperCase();
 		logger.debug(`[HttpInstrumentation] Patching ${protocolUpper} module in ${this.mode} mode`);
-		if (httpModule._tdPatched) {
+		if (this.isModulePatched(httpModule)) {
 			logger.debug(`[HttpInstrumentation] ${protocolUpper} module already patched, skipping`);
 			return httpModule;
 		}
-		this._wrap(httpModule, "request", this._getRequestPatchFn(protocol));
-		this._wrap(httpModule, "get", this._getGetPatchFn(protocol));
+		if (httpModule[Symbol.toStringTag] === "Module") {
+			if (httpModule.default) {
+				this._wrap(httpModule.default, "request", this._getRequestPatchFn(protocol));
+				this._wrap(httpModule.default, "get", this._getGetPatchFn(protocol));
+			}
+		} else {
+			this._wrap(httpModule, "request", this._getRequestPatchFn(protocol));
+			this._wrap(httpModule, "get", this._getGetPatchFn(protocol));
+		}
 		const HttpServer = httpModule.Server;
 		if (HttpServer && HttpServer.prototype) {
 			this._wrap(HttpServer.prototype, "emit", this._getServerEmitPatchFn(protocol));
 			logger.debug(`[HttpInstrumentation] Wrapped Server.prototype.emit for ${protocolUpper}`);
 		}
-		httpModule._tdPatched = true;
+		this.markModuleAsPatched(httpModule);
 		logger.debug(`[HttpInstrumentation] ${protocolUpper} module patching complete`);
 		return httpModule;
 	}
@@ -2568,7 +2632,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 			}
 		});
 	}
-	_captureClientRequestBody(req, spanInfo, inputValue, schemaMerges) {
+	_captureClientRequestBody(req, spanInfo, inputValue, schemaMerges, onBodyCaptured) {
 		const requestBodyChunks = [];
 		let requestBodyCaptured = false;
 		const originalWrite = req.write?.bind(req);
@@ -2590,6 +2654,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 							body: encodedBody,
 							bodySize: bodyBuffer.length
 						};
+						if (onBodyCaptured) onBodyCaptured(updatedInputValue);
 						SpanUtils.addSpanAttributes(spanInfo.span, {
 							inputValue: updatedInputValue,
 							inputSchemaMerges: {
@@ -2611,7 +2676,10 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 	}
 	_handleOutboundRequestInSpan(originalRequest, args, spanInfo, inputValue, schemaMerges) {
 		const req = originalRequest.apply(this, args);
-		this._captureClientRequestBody(req, spanInfo, inputValue, schemaMerges);
+		let completeInputValue = inputValue;
+		this._captureClientRequestBody(req, spanInfo, inputValue, schemaMerges, (updatedInputValue) => {
+			completeInputValue = updatedInputValue;
+		});
 		req.on("response", (res) => {
 			logger.debug(`[HttpInstrumentation] HTTP response received: ${res.statusCode} (${SpanUtils.getTraceInfo()})`);
 			const outputValue = {
@@ -2651,7 +2719,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 								},
 								headers: { matchImportance: 0 }
 							},
-							inputValue
+							inputValue: completeInputValue
 						});
 					} catch (error) {
 						logger.error(`[HttpInstrumentation] Error processing response body:`, error);
@@ -2669,7 +2737,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 						},
 						headers: { matchImportance: 0 }
 					},
-					inputValue
+					inputValue: completeInputValue
 				});
 			} catch (error) {
 				logger.error(`[HttpInstrumentation] Error adding output attributes to span:`, error);
@@ -2912,7 +2980,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 		return fallback;
 	}
 	_wrap(target, propertyName, wrapper) {
-		wrap(target, propertyName, wrapper);
+		return wrap(target, propertyName, wrapper);
 	}
 };
 
@@ -3307,7 +3375,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 	}
 	_patchPgModule(pgModule) {
 		logger.debug(`[PgInstrumentation] Patching PG module in ${this.mode} mode`);
-		if (pgModule._tdPatched) {
+		if (this.isModulePatched(pgModule)) {
 			logger.debug(`[PgInstrumentation] PG module already patched, skipping`);
 			return pgModule;
 		}
@@ -3319,7 +3387,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 			this._wrap(pgModule.Client.prototype, "connect", this._getConnectPatchFn("client"));
 			logger.debug(`[PgInstrumentation] Wrapped Client.prototype.connect`);
 		}
-		pgModule._tdPatched = true;
+		this.markModuleAsPatched(pgModule);
 		logger.debug(`[PgInstrumentation] PG module patching complete`);
 		return pgModule;
 	}
@@ -3641,7 +3709,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 		SpanUtils.addSpanAttributes(spanInfo.span, { outputValue });
 	}
 	_patchPgPoolModule(pgPoolModule) {
-		if (pgPoolModule._tdPatched) {
+		if (this.isModulePatched(pgPoolModule)) {
 			logger.debug(`[PgInstrumentation] PG Pool module already patched, skipping`);
 			return pgPoolModule;
 		}
@@ -3653,7 +3721,7 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 			this._wrap(pgPoolModule.prototype, "connect", this._getPoolConnectPatchFn());
 			logger.debug(`[PgInstrumentation] Wrapped Pool.prototype.connect`);
 		}
-		pgPoolModule._tdPatched = true;
+		this.markModuleAsPatched(pgPoolModule);
 		logger.debug(`[PgInstrumentation] PG Pool module patching complete`);
 		return pgPoolModule;
 	}
@@ -3764,6 +3832,17 @@ var PgInstrumentation = class extends TdInstrumentationBase {
 	}
 };
 
+//#endregion
+//#region src/instrumentation/libraries/postgres/types.ts
+function isPostgresOutputValueType(value) {
+	return value !== null && value !== void 0 && typeof value === "object" && "_tdOriginalFormat" in value && Object.values(PostgresReturnType).includes(value._tdOriginalFormat);
+}
+let PostgresReturnType = /* @__PURE__ */ function(PostgresReturnType$1) {
+	PostgresReturnType$1["ARRAY"] = "array";
+	PostgresReturnType$1["OBJECT"] = "object";
+	return PostgresReturnType$1;
+}({});
+
 //#endregion
 //#region src/instrumentation/libraries/postgres/Instrumentation.ts
 var PostgresInstrumentation = class extends TdInstrumentationBase {
@@ -3782,25 +3861,41 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 	}
 	_patchPostgresModule(postgresModule) {
 		logger.debug(`[PostgresInstrumentation] Patching Postgres module in ${this.mode} mode`);
-		if (postgresModule._tdPatched) {
+		if (this.isModulePatched(postgresModule)) {
 			logger.debug(`[PostgresInstrumentation] Postgres module already patched, skipping`);
 			return postgresModule;
 		}
-		if (typeof postgresModule === "function") {
+		const self$1 = this;
+		if (postgresModule[Symbol.toStringTag] === "Module") {
+			logger.debug(`[PostgresInstrumentation] Wrapping ESM default export`);
+			this._wrap(postgresModule, "default", (originalFunction) => {
+				return function(...args) {
+					return self$1._handlePostgresConnection(originalFunction, args);
+				};
+			});
+		} else {
+			logger.debug(`[PostgresInstrumentation] Module is a function (CJS style)`);
 			const originalFunction = postgresModule;
-			const self$1 = this;
 			const wrappedFunction = function(...args) {
+				logger.debug(`[PostgresInstrumentation] Wrapped postgres() (CJS) called with args:`, args);
 				return self$1._handlePostgresConnection(originalFunction, args);
 			};
 			Object.setPrototypeOf(wrappedFunction, Object.getPrototypeOf(originalFunction));
 			Object.defineProperty(wrappedFunction, "name", { value: originalFunction.name });
+			for (const key in originalFunction) if (originalFunction.hasOwnProperty(key)) wrappedFunction[key] = originalFunction[key];
+			Object.getOwnPropertyNames(originalFunction).forEach((key) => {
+				if (key !== "prototype" && key !== "length" && key !== "name") {
+					const descriptor = Object.getOwnPropertyDescriptor(originalFunction, key);
+					if (descriptor) Object.defineProperty(wrappedFunction, key, descriptor);
+				}
+			});
 			postgresModule = wrappedFunction;
 		}
 		if (postgresModule.sql && typeof postgresModule.sql === "function") {
 			this._wrap(postgresModule, "sql", this._getSqlPatchFn());
 			logger.debug(`[PostgresInstrumentation] Wrapped sql function`);
 		}
-		postgresModule._tdPatched = true;
+		this.markModuleAsPatched(postgresModule);
 		logger.debug(`[PostgresInstrumentation] Postgres module patching complete`);
 		return postgresModule;
 	}
@@ -4262,8 +4357,8 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 		const isResultObject = processedResult && typeof processedResult === "object" && "rows" in processedResult;
 		const rows = isResultObject ? processedResult.rows || [] : processedResult || [];
 		return Object.assign(rows, {
-			command: isResultObject ? processedResult.command : "SELECT",
-			count: isResultObject ? processedResult.count : rows.length
+			command: isResultObject ? processedResult.command : void 0,
+			count: isResultObject ? processedResult.count : void 0
 		});
 	}
 	async handleReplayUnsafeQuery({ inputValue, spanInfo, submodule, name }) {
@@ -4314,8 +4409,8 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 					return Object.values(row);
 				});
 				return Object.assign(valueArrays, {
-					command: isResultObject ? result.command : "SELECT",
-					count: isResultObject ? result.count : valueArrays.length
+					command: isResultObject ? result.command : void 0,
+					count: isResultObject ? result.count : void 0
 				});
 			});
 		} });
@@ -4325,61 +4420,40 @@ var PostgresInstrumentation = class extends TdInstrumentationBase {
 	* based on common PostgreSQL data patterns.
 	*/
 	convertPostgresTypes(result) {
-		if (!result) return result;
-		if (result && typeof result === "object" && "rows" in result) {
-			const convertedResult = { ...result };
-			if (Array.isArray(result.rows)) convertedResult.rows = result.rows.map((row) => {
-				if (typeof row !== "object" || row === null) return row;
-				const convertedRow = { ...row };
-				Object.keys(row).forEach((fieldName) => {
-					const value = row[fieldName];
-					if (value === null || value === void 0) return;
-					if (typeof value === "string") {
-						if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) {
-							const dateObj = new Date(value);
-							if (!isNaN(dateObj.getTime())) convertedRow[fieldName] = dateObj;
-						}
-					}
-				});
-				return convertedRow;
-			});
-			return convertedResult;
+		if (!isPostgresOutputValueType(result)) {
+			logger.error(`[PostgresInstrumentation] output value is not of type PostgresOutputValueType: ${JSON.stringify(result)}`);
+			return;
+		}
+		if (!result) return;
+		const { _tdOriginalFormat: originalFormat,...convertedResult } = result;
+		if (originalFormat === PostgresReturnType.OBJECT) return convertedResult;
+		else if (originalFormat === PostgresReturnType.ARRAY) return convertedResult.rows || [];
+		else {
+			logger.error(`[PostgresInstrumentation] Invalid result format: ${JSON.stringify(result)}`);
+			return;
 		}
-		if (Array.isArray(result)) return result.map((row) => {
-			if (typeof row !== "object" || row === null) return row;
-			const convertedRow = { ...row };
-			Object.keys(row).forEach((fieldName) => {
-				const value = row[fieldName];
-				if (value === null || value === void 0) return;
-				if (typeof value === "string") {
-					if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) {
-						const dateObj = new Date(value);
-						if (!isNaN(dateObj.getTime())) convertedRow[fieldName] = dateObj;
-					}
-				}
-			});
-			return convertedRow;
-		});
-		return result;
 	}
 	_addOutputAttributesToSpan(spanInfo, result) {
 		if (!result) return;
 		let outputValue;
-		if (Array.isArray(result)) outputValue = {
-			count: result.length,
-			rows: result,
-			command: "SELECT"
-		};
-		else if (result && typeof result === "object" && "count" in result) outputValue = {
-			count: result.count || 0,
-			rows: result.rows || result,
-			command: result.command || "UNKNOWN"
-		};
-		else outputValue = {
-			count: 1,
-			rows: [result],
-			command: "UNKNOWN"
-		};
+		if (Array.isArray(result)) {
+			logger.debug(`[PostgresInstrumentation] Adding output attributes to span for array result: ${JSON.stringify(result)}`);
+			outputValue = {
+				_tdOriginalFormat: PostgresReturnType.ARRAY,
+				rows: result
+			};
+		} else if (typeof result === "object") {
+			logger.debug(`[PostgresInstrumentation] Adding output attributes to span for object result: ${JSON.stringify(result)}`);
+			outputValue = {
+				_tdOriginalFormat: PostgresReturnType.OBJECT,
+				count: result.count,
+				rows: result.rows,
+				command: result.command
+			};
+		} else {
+			logger.error(`[PostgresInstrumentation] Invalid result format: ${JSON.stringify(result)}`);
+			return;
+		}
 		SpanUtils.addSpanAttributes(spanInfo.span, { outputValue });
 	}
 	_wrap(target, propertyName, wrapper) {
@@ -4413,7 +4487,7 @@ var TcpInstrumentation = class extends TdInstrumentationBase {
 	}
 	_patchNetModule(netModule) {
 		logger.debug(`[TcpInstrumentation] Patching NET module in ${this.mode} mode`);
-		if (netModule._tdPatched) {
+		if (this.isModulePatched(netModule)) {
 			logger.debug(`[TcpInstrumentation] NET module already patched, skipping`);
 			return netModule;
 		}
@@ -4430,7 +4504,7 @@ var TcpInstrumentation = class extends TdInstrumentationBase {
 		netModule.Socket.prototype.write = function(...args) {
 			return self$1._handleTcpCall("write", originalWrite, args, this);
 		};
-		netModule._tdPatched = true;
+		this.markModuleAsPatched(netModule);
 		return netModule;
 	}
 	_logUnpatchedDependency(methodName, currentSpanInfo, socketContext) {
@@ -4493,7 +4567,7 @@ var JsonwebtokenInstrumentation = class extends TdInstrumentationBase {
 		})];
 	}
 	_patchJsonwebtokenModule(jwtModule) {
-		if (jwtModule._tdPatched) {
+		if (this.isModulePatched(jwtModule)) {
 			logger.debug(`[JsonwebtokenInstrumentation] jsonwebtoken module already patched, skipping`);
 			return jwtModule;
 		}
@@ -4508,7 +4582,7 @@ var JsonwebtokenInstrumentation = class extends TdInstrumentationBase {
 			this._wrap(jwtModule, "sign", this._getSignPatchFn());
 			logger.debug(`[JsonwebtokenInstrumentation] Wrapped jwt.sign`);
 		}
-		jwtModule._tdPatched = true;
+		this.markModuleAsPatched(jwtModule);
 		logger.debug(`[JsonwebtokenInstrumentation] jsonwebtoken module patching complete`);
 		return jwtModule;
 	}
@@ -4906,7 +4980,7 @@ var JwksRsaInstrumentation = class extends TdInstrumentationBase {
 	}
 	_patchJwksRsaModule(jwksModule) {
 		logger.debug(`[JwksRsaInstrumentation] Patching jwks-rsa module, current mode: ${this.tuskDrift.getMode()}`);
-		if (jwksModule._tdPatched) {
+		if (this.isModulePatched(jwksModule)) {
 			logger.debug(`[JwksRsaInstrumentation] jwks-rsa module already patched, skipping`);
 			return jwksModule;
 		}
@@ -4915,7 +4989,7 @@ var JwksRsaInstrumentation = class extends TdInstrumentationBase {
 			const originalExpressJwtSecret = jwksModule.expressJwtSecret;
 			jwksModule.expressJwtSecret = function(options) {
 				logger.debug(`[JwksRsaInstrumentation] expressJwtSecret called with options:`, options);
-				let modifiedOptions = { ...options };
+				const modifiedOptions = { ...options };
 				if (self$1.tuskDrift.getMode() === TuskDriftMode.REPLAY) {
 					logger.debug(`[JwksRsaInstrumentation] REPLAY MODE - Disabling rate limiting for expressJwtSecret`);
 					modifiedOptions.rateLimit = false;
@@ -4926,7 +5000,7 @@ var JwksRsaInstrumentation = class extends TdInstrumentationBase {
 			};
 			logger.debug(`[JwksRsaInstrumentation] Patched expressJwtSecret method`);
 		}
-		jwksModule._tdPatched = true;
+		this.markModuleAsPatched(jwksModule);
 		logger.debug(`[JwksRsaInstrumentation] jwks-rsa module patching complete`);
 		return jwksModule;
 	}
@@ -6060,9 +6134,9 @@ var require_types$3 = /* @__PURE__ */ __commonJS({ "node_modules/@opentelemetry/
 var require_ExportResult = /* @__PURE__ */ __commonJS({ "node_modules/@opentelemetry/core/build/src/ExportResult.js": ((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.ExportResultCode = void 0;
-	(function(ExportResultCode$1) {
-		ExportResultCode$1[ExportResultCode$1["SUCCESS"] = 0] = "SUCCESS";
-		ExportResultCode$1[ExportResultCode$1["FAILED"] = 1] = "FAILED";
+	(function(ExportResultCode$3) {
+		ExportResultCode$3[ExportResultCode$3["SUCCESS"] = 0] = "SUCCESS";
+		ExportResultCode$3[ExportResultCode$3["FAILED"] = 1] = "FAILED";
 	})(exports.ExportResultCode || (exports.ExportResultCode = {}));
 }) });
 
@@ -6904,122 +6978,23 @@ var require_src$6 = /* @__PURE__ */ __commonJS({ "node_modules/@opentelemetry/co
 }) });
 
 //#endregion
-//#region src/core/tracing/TdSpanExporter.ts
-var import_src$1 = /* @__PURE__ */ __toESM(require_src$6(), 1);
-const DRIFT_API_PATH = "/api/drift";
+//#region src/core/tracing/SpanTransformer.ts
+var import_src$3 = /* @__PURE__ */ __toESM(require_src$6(), 1);
 /**
-* If useRemoteExport is true, TdTraceExporter exports spans to a remote endpoint via protobuf.
-* If useRemoteExport is false, TdTraceExporter stores spans organized by trace ID in separate files.
-*  - Each trace gets its own JSONL file: `{baseDirectory}/{timestamp}_trace_{traceId}.jsonl`.
+* Utility class for transforming OpenTelemetry spans to CleanSpanData
 */
-var TdSpanExporter = class {
-	constructor(config) {
-		this.traceFileMap = /* @__PURE__ */ new Map();
-		this.baseDirectory = config.baseDirectory;
-		this.mode = config.mode;
-		this.useRemoteExport = config.useRemoteExport;
-		this.observableServiceId = config.observableServiceId;
-		this.apiKey = config.apiKey;
-		this.tuskBackendBaseUrl = config.tuskBackendBaseUrl;
-		this.environment = config.environment;
-		this.sdkVersion = config.sdkVersion;
-		this.sdkInstanceId = config.sdkInstanceId;
-		if (!fs.existsSync(this.baseDirectory)) fs.mkdirSync(this.baseDirectory, { recursive: true });
-		if (this.useRemoteExport && this.apiKey) {
-			const transport = new __protobuf_ts_twirp_transport.TwirpFetchTransport({
-				baseUrl: `${this.tuskBackendBaseUrl}${DRIFT_API_PATH}`,
-				meta: {
-					"x-api-key": this.apiKey,
-					"x-td-skip-instrumentation": "true"
-				}
-			});
-			this.spanExportClient = new __use_tusk_drift_schemas_backend_span_export_service_client.SpanExportServiceClient(transport);
-		}
-		logger.debug(`TdTraceExporter initialized - ${this.useRemoteExport ? "remote export enabled" : "local file export only"}`);
-	}
-	/**
-	* Export spans to trace-specific files and optionally to remote endpoint
-	*/
-	export(spans, resultCallback) {
-		logger.debug(`TdTraceExporter.export() called with ${spans.length} span(s)`);
-		if (this.mode !== TuskDriftMode.RECORD) {
-			logger.debug(`Not recording spans in tuskDriftMode: ${this.mode}`);
-			resultCallback({ code: import_src$1.ExportResultCode.SUCCESS });
-			return;
-		}
-		if (this.useRemoteExport) if (this.spanExportClient) this.exportToRemote(spans).then(() => {
-			logger.debug(`Successfully exported ${spans.length} spans to remote endpoint`);
-			resultCallback({ code: import_src$1.ExportResultCode.SUCCESS });
-		}).catch((error) => {
-			logger.error(`Failed to export spans to remote:`, error);
-			resultCallback({
-				code: import_src$1.ExportResultCode.FAILED,
-				error: error instanceof Error ? error : /* @__PURE__ */ new Error("Remote export failed")
-			});
-		});
-		else {
-			logger.error("Remote export client not initialized, likely because apiKey is not provided");
-			resultCallback({
-				code: import_src$1.ExportResultCode.FAILED,
-				error: /* @__PURE__ */ new Error("Remote export client not initialized, likely because apiKey is not provided")
-			});
-		}
-		else {
-			this.exportToLocalFiles(spans);
-			resultCallback({ code: import_src$1.ExportResultCode.SUCCESS });
-		}
-	}
-	/**
-	* Export spans to remote endpoint via protobuf
-	*/
-	async exportToRemote(spans) {
-		if (!this.spanExportClient) throw new Error("Remote export client not initialized");
-		if (!this.observableServiceId) throw new Error("Observable service ID not provided in config");
-		const protoSpans = spans.map((span) => this.transformSpanToProtobuf(span));
-		const request = {
-			observableServiceId: this.observableServiceId,
-			environment: this.environment,
-			sdkVersion: this.sdkVersion,
-			sdkInstanceId: this.sdkInstanceId,
-			spans: protoSpans
-		};
-		const response = await this.spanExportClient.exportSpans(request);
-		if (!response.response.success) throw new Error(`Remote export failed: ${response.response.message}`);
-	}
-	/**
-	* Export spans to local files
-	*/
-	exportToLocalFiles(spans) {
-		try {
-			for (const span of spans) {
-				const traceId = span.spanContext().traceId;
-				const spanData = this.transformSpanToCleanJSON(span);
-				let filePath = this.traceFileMap.get(traceId);
-				if (!filePath) {
-					const isoTimestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-					filePath = path.join(this.baseDirectory, `${isoTimestamp}_trace_${traceId}.jsonl`);
-					this.traceFileMap.set(traceId, filePath);
-				}
-				const jsonLine = JSON.stringify(spanData) + "\n";
-				fs.appendFileSync(filePath, jsonLine, "utf8");
-			}
-			logger.debug(`Exported ${spans.length} span(s) to trace-specific files in ${this.baseDirectory}`);
-		} catch (error) {
-			logger.error(`Failed to export spans to local files:`, error);
-			throw error;
-		}
-	}
+var SpanTransformer = class SpanTransformer {
 	/**
 	* Transform OpenTelemetry span to clean JSON format with compile-time type safety
 	* Return type is derived from protobuf schema but uses clean JSON.
 	* We use JSON because serialized protobuf is extremely verbose and not readable.
 	*/
-	transformSpanToCleanJSON(span) {
+	static transformSpanToCleanJSON(span) {
 		const isRootSpan = !span.parentSpanId || span.kind === __opentelemetry_api.SpanKind.SERVER;
 		const attributes = span.attributes;
-		const packageName = this.extractPackageName(attributes);
-		const instrumentationName = this.extractInstrumentationName(span, attributes);
-		const submoduleName = this.extractSubmoduleName(attributes);
+		const packageName = SpanTransformer.extractPackageName(attributes);
+		const instrumentationName = SpanTransformer.extractInstrumentationName(span, attributes);
+		const submoduleName = SpanTransformer.extractSubmoduleName(attributes);
 		const inputValueString = attributes[TdSpanAttributes.INPUT_VALUE];
 		const inputData = JSON.parse(inputValueString);
 		const inputSchemaMergesString = attributes[TdSpanAttributes.INPUT_SCHEMA_MERGES];
@@ -7085,10 +7060,115 @@ var TdSpanExporter = class {
 		};
 	}
 	/**
-	* Transform OpenTelemetry span to protobuf format
+	* Extract package name from attributes or instrumentation library
+	*/
+	static extractPackageName(attributes) {
+		if (attributes[TdSpanAttributes.PACKAGE_NAME]) return attributes[TdSpanAttributes.PACKAGE_NAME];
+		return "unknown";
+	}
+	/**
+	* Extract instrumentation name from span data
 	*/
-	transformSpanToProtobuf(span) {
-		const cleanSpan = this.transformSpanToCleanJSON(span);
+	static extractInstrumentationName(span, attributes) {
+		if (attributes[TdSpanAttributes.INSTRUMENTATION_NAME]) return attributes[TdSpanAttributes.INSTRUMENTATION_NAME];
+		if (span.instrumentationLibrary?.name) return `tusk-instrumentation-${span.instrumentationLibrary.name}`;
+		return `tusk-instrumentation-${SpanTransformer.extractPackageName(attributes)}`;
+	}
+	/**
+	* Extract submodule name from attributes
+	*/
+	static extractSubmoduleName(attributes) {
+		if (attributes[TdSpanAttributes.SUBMODULE_NAME]) return attributes[TdSpanAttributes.SUBMODULE_NAME];
+	}
+};
+
+//#endregion
+//#region src/core/tracing/adapters/FilesystemSpanAdapter.ts
+/**
+* Exports spans to local JSONL files organized by trace ID
+*/
+var FilesystemSpanAdapter = class {
+	constructor(config) {
+		this.name = "filesystem";
+		this.traceFileMap = /* @__PURE__ */ new Map();
+		this.baseDirectory = config.baseDirectory;
+		if (!fs.existsSync(this.baseDirectory)) fs.mkdirSync(this.baseDirectory, { recursive: true });
+	}
+	async exportSpans(spans) {
+		try {
+			for (const span of spans) {
+				const traceId = span.traceId;
+				let filePath = this.traceFileMap.get(traceId);
+				if (!filePath) {
+					const isoTimestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+					filePath = path.join(this.baseDirectory, `${isoTimestamp}_trace_${traceId}.jsonl`);
+					this.traceFileMap.set(traceId, filePath);
+				}
+				const jsonLine = JSON.stringify(span) + "\n";
+				fs.appendFileSync(filePath, jsonLine, "utf8");
+			}
+			logger.debug(`Exported ${spans.length} span(s) to trace-specific files in ${this.baseDirectory}`);
+			return { code: import_src$3.ExportResultCode.SUCCESS };
+		} catch (error) {
+			logger.error(`Failed to export spans to local files:`, error);
+			return {
+				code: import_src$3.ExportResultCode.FAILED,
+				error: error instanceof Error ? error : /* @__PURE__ */ new Error("Filesystem export failed")
+			};
+		}
+	}
+	async shutdown() {
+		return Promise.resolve();
+	}
+};
+
+//#endregion
+//#region src/core/tracing/adapters/ApiSpanAdapter.ts
+var import_src$2 = /* @__PURE__ */ __toESM(require_src$6(), 1);
+const DRIFT_API_PATH = "/api/drift";
+/**
+* Exports spans to Tusk backend API via protobuf
+*/
+var ApiSpanAdapter = class {
+	constructor(config) {
+		this.name = "api";
+		this.observableServiceId = config.observableServiceId;
+		this.environment = config.environment;
+		this.sdkVersion = config.sdkVersion;
+		this.sdkInstanceId = config.sdkInstanceId;
+		const transport = new __protobuf_ts_twirp_transport.TwirpFetchTransport({
+			baseUrl: `${config.tuskBackendBaseUrl}${DRIFT_API_PATH}`,
+			meta: {
+				"x-api-key": config.apiKey,
+				"x-td-skip-instrumentation": "true"
+			}
+		});
+		this.spanExportClient = new __use_tusk_drift_schemas_backend_span_export_service_client.SpanExportServiceClient(transport);
+		logger.debug("ApiSpanAdapter initialized");
+	}
+	async exportSpans(spans) {
+		try {
+			const protoSpans = spans.map((span) => this.transformSpanToProtobuf(span));
+			const request = {
+				observableServiceId: this.observableServiceId,
+				environment: this.environment,
+				sdkVersion: this.sdkVersion,
+				sdkInstanceId: this.sdkInstanceId,
+				spans: protoSpans
+			};
+			const response = await this.spanExportClient.exportSpans(request);
+			if (!response.response.success) throw new Error(`Remote export failed: ${response.response.message}`);
+			logger.debug(`Successfully exported ${spans.length} spans to remote endpoint`);
+			return { code: import_src$2.ExportResultCode.SUCCESS };
+		} catch (error) {
+			logger.error(`Failed to export spans to remote:`, error);
+			return {
+				code: import_src$2.ExportResultCode.FAILED,
+				error: error instanceof Error ? error : /* @__PURE__ */ new Error("API export failed")
+			};
+		}
+	}
+	transformSpanToProtobuf(cleanSpan) {
 		return {
 			traceId: cleanSpan.traceId,
 			spanId: cleanSpan.spanId,
@@ -7106,7 +7186,7 @@ var TdSpanExporter = class {
 			outputSchemaHash: cleanSpan.outputSchemaHash || "",
 			inputValueHash: cleanSpan.inputValueHash || "",
 			outputValueHash: cleanSpan.outputValueHash || "",
-			kind: mapOtToPb(span.kind),
+			kind: this.mapSpanKind(cleanSpan.kind),
 			status: cleanSpan.status,
 			isPreAppStart: cleanSpan.isPreAppStart,
 			timestamp: {
@@ -7121,32 +7201,111 @@ var TdSpanExporter = class {
 			metadata: toStruct(cleanSpan.metadata)
 		};
 	}
+	mapSpanKind(kind) {
+		switch (kind) {
+			case __opentelemetry_api.SpanKind.CLIENT: return __use_tusk_drift_schemas_core_span.SpanKind.CLIENT;
+			case __opentelemetry_api.SpanKind.SERVER: return __use_tusk_drift_schemas_core_span.SpanKind.SERVER;
+			case __opentelemetry_api.SpanKind.PRODUCER: return __use_tusk_drift_schemas_core_span.SpanKind.PRODUCER;
+			case __opentelemetry_api.SpanKind.CONSUMER: return __use_tusk_drift_schemas_core_span.SpanKind.CONSUMER;
+			case __opentelemetry_api.SpanKind.INTERNAL: return __use_tusk_drift_schemas_core_span.SpanKind.INTERNAL;
+			default: return __use_tusk_drift_schemas_core_span.SpanKind.UNSPECIFIED;
+		}
+	}
+	async shutdown() {
+		return Promise.resolve();
+	}
+};
+
+//#endregion
+//#region src/core/tracing/TdSpanExporter.ts
+var import_src$1 = /* @__PURE__ */ __toESM(require_src$6(), 1);
+var TdSpanExporter = class {
+	constructor(config) {
+		this.adapters = [];
+		this.mode = config.mode;
+		this.setupDefaultAdapters(config);
+		logger.debug(`TdSpanExporter initialized with ${this.adapters.length} adapter(s)`);
+	}
+	setupDefaultAdapters(config) {
+		if (config.useRemoteExport && config.apiKey && config.observableServiceId) {
+			logger.debug("TdSpanExporter using API adapter");
+			this.addAdapter(new ApiSpanAdapter({
+				apiKey: config.apiKey,
+				tuskBackendBaseUrl: config.tuskBackendBaseUrl,
+				observableServiceId: config.observableServiceId,
+				environment: config.environment,
+				sdkVersion: config.sdkVersion,
+				sdkInstanceId: config.sdkInstanceId
+			}));
+		} else {
+			logger.debug("TdSpanExporter falling back to filesystem adapter");
+			this.addAdapter(new FilesystemSpanAdapter({ baseDirectory: config.baseDirectory }));
+		}
+	}
+	getAdapters() {
+		return this.adapters;
+	}
 	/**
-	* Extract package name from attributes or instrumentation library
+	* Add a custom export adapter
 	*/
-	extractPackageName(attributes) {
-		if (attributes[TdSpanAttributes.PACKAGE_NAME]) return attributes[TdSpanAttributes.PACKAGE_NAME];
-		return "unknown";
+	addAdapter(adapter) {
+		this.adapters.push(adapter);
+		logger.debug(`Added ${adapter.name} adapter. Total adapters: ${this.adapters.length}`);
 	}
 	/**
-	* Extract instrumentation name from span data
+	* Remove a specific adapter
 	*/
-	extractInstrumentationName(span, attributes) {
-		if (attributes[TdSpanAttributes.INSTRUMENTATION_NAME]) return attributes[TdSpanAttributes.INSTRUMENTATION_NAME];
-		if (span.instrumentationLibrary?.name) return `tusk-instrumentation-${span.instrumentationLibrary.name}`;
-		return `tusk-instrumentation-${this.extractPackageName(attributes)}`;
+	removeAdapter(adapter) {
+		const index = this.adapters.indexOf(adapter);
+		if (index > -1) {
+			this.adapters.splice(index, 1);
+			logger.debug(`Removed ${adapter.name} adapter. Total adapters: ${this.adapters.length}`);
+		}
 	}
 	/**
-	* Extract submodule name from attributes
+	* Clear all adapters
 	*/
-	extractSubmoduleName(attributes) {
-		if (attributes[TdSpanAttributes.SUBMODULE_NAME]) return attributes[TdSpanAttributes.SUBMODULE_NAME];
+	clearAdapters() {
+		this.adapters = [];
+		logger.debug("All adapters cleared");
+	}
+	/**
+	* Set the mode for determining which adapters to run
+	*/
+	setMode(mode) {
+		this.mode = mode;
+	}
+	/**
+	* Export spans using all configured adapters
+	*/
+	export(spans, resultCallback) {
+		logger.debug(`TdSpanExporter.export() called with ${spans.length} span(s)`);
+		const cleanSpans = spans.map((span) => SpanTransformer.transformSpanToCleanJSON(span));
+		if (this.adapters.length === 0) {
+			logger.debug("No adapters configured");
+			resultCallback({ code: import_src$1.ExportResultCode.SUCCESS });
+			return;
+		}
+		const activeAdapters = this.getActiveAdapters();
+		if (activeAdapters.length === 0) {
+			logger.debug(`No active adapters for mode: ${this.mode}`);
+			resultCallback({ code: import_src$1.ExportResultCode.SUCCESS });
+			return;
+		}
+		Promise.all(activeAdapters.map((adapter) => adapter.exportSpans(cleanSpans))).then(() => resultCallback({ code: import_src$1.ExportResultCode.SUCCESS })).catch((error) => resultCallback({
+			code: import_src$1.ExportResultCode.FAILED,
+			error
+		}));
+	}
+	getActiveAdapters() {
+		if (this.mode !== TuskDriftMode.RECORD) return this.adapters.filter((adapter) => adapter.name === "in-memory" || adapter.name === "callback");
+		return this.adapters;
 	}
 	/**
-	* Shutdown the exporter
+	* Shutdown all adapters
 	*/
 	async shutdown() {
-		return Promise.resolve();
+		await Promise.all(this.adapters.map((adapter) => adapter.shutdown()));
 	}
 	/**
 	* Force flush any pending spans
@@ -10448,12 +10607,6 @@ var TuskDriftCore = class TuskDriftCore {
 			default: return TuskDriftMode.DISABLED;
 		}
 	}
-	initializeMemoryStore({ baseDirectory }) {
-		if (this.isRunningIntegrationTest()) {
-			logger.debug(`Initializing memory store with base directory: ${baseDirectory}`);
-			this.memoryStore.initialize(baseDirectory);
-		} else logger.debug("Not running integration test, skipping memory store initialization");
-	}
 	registerDefaultInstrumentations() {
 		const transforms = this.config.transforms ?? this.initParams.transforms;
 		new HttpInstrumentation({
@@ -10501,20 +10654,20 @@ var TuskDriftCore = class TuskDriftCore {
 	initializeTracing({ baseDirectory }) {
 		const serviceName = this.config.service?.name || "unknown";
 		logger.debug(`Initializing OpenTelemetry tracing for service: ${serviceName}`);
-		const traceExporter = new TdSpanExporter({
+		this.spanExporter = new TdSpanExporter({
 			baseDirectory,
 			mode: this.mode,
 			useRemoteExport: this.config.recording?.export_spans || false,
 			observableServiceId: this.config.service?.id,
 			apiKey: this.initParams.apiKey,
 			tuskBackendBaseUrl: this.config.tusk_api?.url || "https://api.usetusk.ai",
-			environment: this.initParams.env,
+			environment: this.initParams.env || "unknown",
 			sdkVersion: SDK_VERSION,
 			sdkInstanceId: this.generateSdkInstanceId()
 		});
 		this.sdk = new __opentelemetry_sdk_node.NodeSDK({
 			serviceName,
-			spanProcessor: new import_src.BatchSpanProcessor(traceExporter, {
+			spanProcessor: new import_src.BatchSpanProcessor(this.spanExporter, {
 				maxQueueSize: 2048,
 				maxExportBatchSize: 512,
 				scheduledDelayMillis: 2e3,
@@ -10531,6 +10684,11 @@ var TuskDriftCore = class TuskDriftCore {
 	initialize(initParams) {
 		this.samplingRate = this.config.recording?.sampling_rate ?? 1;
 		this.initParams = initParams;
+		if (!this.initParams.env) {
+			const nodeEnv = OriginalGlobalUtils.getOriginalProcessEnvVar("NODE_ENV") || "unknown";
+			logger.warn(`Environment not provided in initialization parameters. Using '${nodeEnv}' as the environment.`);
+			this.initParams.env = nodeEnv;
+		}
 		initializeGlobalLogger({
 			logLevel: initParams.logLevel || "info",
 			prefix: "TuskDrift"
@@ -10543,10 +10701,6 @@ var TuskDriftCore = class TuskDriftCore {
 			logger.error("In record mode and export_spans is true, but API key not provided. API key is required to export spans to Tusk backend. Please provide an API key in the initialization parameters.");
 			return;
 		}
-		if (!this.initParams.env) {
-			logger.error("Environment not provided. Please provide an environment in the initialization parameters.");
-			return;
-		}
 		if (this.config.recording?.export_spans && !this.config.service?.id) {
 			logger.error("Observable service ID not provided. Please provide an observable service ID in the configuration file.");
 			return;
@@ -10588,9 +10742,7 @@ var TuskDriftCore = class TuskDriftCore {
 		const baseDirectory = this.config.traces?.dir || path.default.join(process.cwd(), ".tusk/traces");
 		logger.debug(`Config: ${JSON.stringify(this.config)}`);
 		logger.debug(`Base directory: ${baseDirectory}`);
-		this.config.transforms ?? this.initParams.transforms;
 		this.initializeTracing({ baseDirectory });
-		this.initializeMemoryStore({ baseDirectory });
 		this.registerDefaultInstrumentations();
 		this.initialized = true;
 		logger.info("SDK initialized successfully");
@@ -10762,6 +10914,9 @@ var TuskDriftSDK = class {
 	markAppAsReady() {
 		return this.tuskDrift.markAppAsReady();
 	}
+	isAppReady() {
+		return this.tuskDrift.isAppReady();
+	}
 };
 const TuskDrift = new TuskDriftSDK();