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

package/README.md

@@ -3,8 +3,9 @@
 </p>
 
 <p align="center">
+  <a href="https://www.npmjs.com/package/@use-tusk/drift-node-sdk"><img src="https://img.shields.io/npm/v/@use-tusk/drift-node-sdk" alt="npm version"></a>
   <a href="https://opensource.org/licenses/Apache-2.0"><img src="https://img.shields.io/badge/License-Apache_2.0-blue.svg" alt="License: Apache 2.0"></a>
-  <a href="https://github.com/Use-Tusk/tusk-drift-sdk/commits/main"><img src="https://img.shields.io/github/last-commit/Use-Tusk/tusk-drift-sdk" alt="GitHub last commit"></a>
+  <a href="https://github.com/Use-Tusk/drift-node-sdk/commits/main/"><img src="https://img.shields.io/github/last-commit/Use-Tusk/drift-node-sdk" alt="GitHub last commit"></a>
 </p>
 
 The Node.js Tusk Drift SDK enables fast and deterministic API testing by capturing and replaying API calls made to/from your service. Automatically record real-world API calls, then replay them as tests using the [Tusk CLI](https://github.com/Use-Tusk/tusk-drift-cli) to find regressions. During replay, all outbound requests are intercepted with recorded data to ensure consistent behavior without side-effects.
@@ -57,6 +58,8 @@ Follow these steps in order to properly initialize the Tusk Drift SDK:
 
 Create a separate file (e.g. `tdInit.ts`) to initialize the Tusk Drift SDK. This ensures the SDK is initialized as early as possible before any other modules are loaded.
 
+#### For CommonJS Applications
+
 ```typescript
 // tdInit.ts
 import { TuskDrift } from "@use-tusk/drift-node-sdk";
@@ -71,6 +74,33 @@ TuskDrift.initialize({
 export { TuskDrift };
 ```
 
+#### For ESM Applications
+
+ESM applications require additional setup to properly intercept module imports:
+
+```typescript
+// tdInit.ts
+import { register } from 'node:module';
+import { pathToFileURL } from 'node:url';
+
+// Register the ESM loader
+// This enables interception of ESM module imports
+register('@use-tusk/drift-node-sdk/hook.mjs', pathToFileURL('./'));
+
+import { TuskDrift } from "@use-tusk/drift-node-sdk";
+
+// Initialize SDK immediately
+TuskDrift.initialize({
+  apiKey: process.env.TUSK_DRIFT_API_KEY,
+  env: process.env.ENV,
+  logLevel: process.env.TUSK_DRIFT_LOG_LEVEL,
+});
+
+export { TuskDrift };
+```
+
+**Why the ESM loader is needed**: ESM imports are statically analyzed and hoisted, meaning all imports are resolved before any code runs. The `register()` call sets up Node.js loader hooks that intercept module imports, allowing the SDK to instrument packages like `postgres`, `http`, etc. Without this, the SDK cannot patch ESM modules.
+
 #### Configuration Options
 
 <table>
@@ -106,7 +136,9 @@ export { TuskDrift };
 
 ### 2. Import SDK at Application Entry Point
 
-In your main server file (e.g., `server.ts`, `index.ts`, `app.ts`), import the initialized SDK **at the very top**, before any other imports:
+#### For CommonJS Applications
+
+In your main server file (e.g., `server.ts`, `index.ts`, `app.ts`), require the initialized SDK **at the very top**, before any other requires:
 
 ```typescript
 // server.ts
@@ -117,7 +149,24 @@ import { TuskDrift } from "./tdInit"; // MUST be the first import
 // Your application setup...
 ```
 
-> **IMPORTANT**: Ensure NO require/import calls are made before importing the SDK initialization file. This guarantees proper instrumentation of all dependencies.
+> **IMPORTANT**: Ensure NO require calls are made before requiring the SDK initialization file. This guarantees proper instrumentation of all dependencies.
+
+#### For ESM Applications
+
+For ESM applications, you **cannot** control import order within your application code because all imports are hoisted. Instead, use the `--import` flag:
+
+**Update your package.json scripts**:
+
+```json
+{
+  "scripts": {
+    "dev": "node --import ./dist/tdInit.js dist/server.js"
+    "dev:record": "TUSK_DRIFT_MODE=RECORD node --import ./dist/tdInit.js dist/server.js"
+  }
+}
+```
+
+**Why `--import` is required for ESM**: In ESM, all `import` statements are hoisted and evaluated before any code runs, making it impossible to control import order within a file. The `--import` flag ensures the SDK initialization (including loader registration) happens in a separate phase before your application code loads, guaranteeing proper module interception.
 
 ### 3. Update Configuration File
 

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.2";
 
 //#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
@@ -1930,6 +1957,7 @@ function wrap(target, propertyName, wrapper) {
 	wrapped._original = original;
 	wrapped._propertyName = propertyName;
 	target[propertyName] = wrapped;
+	return wrapped;
 }
 
 //#endregion
@@ -2212,18 +2240,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 +2603,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 +2625,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 							body: encodedBody,
 							bodySize: bodyBuffer.length
 						};
+						if (onBodyCaptured) onBodyCaptured(updatedInputValue);
 						SpanUtils.addSpanAttributes(spanInfo.span, {
 							inputValue: updatedInputValue,
 							inputSchemaMerges: {
@@ -2611,7 +2647,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 +2690,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 								},
 								headers: { matchImportance: 0 }
 							},
-							inputValue
+							inputValue: completeInputValue
 						});
 					} catch (error) {
 						logger.error(`[HttpInstrumentation] Error processing response body:`, error);
@@ -2669,7 +2708,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 +2951,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 		return fallback;
 	}
 	_wrap(target, propertyName, wrapper) {
-		wrap(target, propertyName, wrapper);
+		return wrap(target, propertyName, wrapper);
 	}
 };
 
@@ -3307,7 +3346,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 +3358,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 +3680,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 +3692,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 +3803,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 +3832,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 +4328,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 +4380,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 +4391,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 +4458,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 +4475,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 +4538,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 +4553,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 +4951,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;
 		}
@@ -4926,7 +4971,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;
 	}