@use-tusk/drift-node-sdk 0.1.5 → 0.1.6

package/dist/index.js

@@ -1,10 +1,10 @@
 import { createRequire } from "node:module";
 import * as fs$1 from "fs";
 import fs from "fs";
-import os from "os";
 import * as path$1 from "path";
 import path, { normalize } from "path";
-import { satisfies } from "semver";
+import { parse, satisfies } from "semver";
+import os from "os";
 import { Hook } from "require-in-the-middle";
 import { Hook as Hook$1 } from "import-in-the-middle";
 import { Struct, Value } from "@use-tusk/drift-schemas/google/protobuf/struct";
@@ -53,6 +53,182 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+//#endregion
+//#region src/nextjs/utils.ts
+/**
+* Get the installed Next.js version by reading package.json from node_modules.
+*
+* @returns The Next.js version string, or undefined if not found
+*/
+function getNextjsVersion() {
+	try {
+		const nextPackageJsonPath = path$1.join(process.cwd(), "node_modules", "next", "package.json");
+		if (fs$1.existsSync(nextPackageJsonPath)) return JSON.parse(fs$1.readFileSync(nextPackageJsonPath, "utf-8")).version;
+	} catch (error) {}
+}
+/**
+* Parse a semantic version string into its components.
+*
+* @param version - The version string to parse (e.g., "15.0.0-canary.124")
+* @returns Parsed version object with major, minor, patch, and prerelease
+*/
+function parseVersion(version$1) {
+	try {
+		const parsed = parse(version$1);
+		if (!parsed) return {
+			major: void 0,
+			minor: void 0,
+			patch: void 0,
+			prerelease: void 0
+		};
+		return {
+			major: parsed.major,
+			minor: parsed.minor,
+			patch: parsed.patch,
+			prerelease: parsed.prerelease.length > 0 ? parsed.prerelease.join(".") : void 0
+		};
+	} catch {
+		return {
+			major: void 0,
+			minor: void 0,
+			patch: void 0,
+			prerelease: void 0
+		};
+	}
+}
+/**
+* Check if the Next.js version requires the instrumentationHook to be set.
+* From Next.js 15.0.0-rc.1 onwards, the instrumentationHook is no longer needed
+* and Next.js will warn if it's set.
+*
+* @param version - The Next.js version string
+* @returns true if instrumentationHook should be set, false otherwise
+*/
+function shouldSetInstrumentationHook(version$1) {
+	if (!version$1) return true;
+	const { major, minor, patch, prerelease } = parseVersion(version$1);
+	if (major === void 0 || minor === void 0 || patch === void 0) return true;
+	if (major >= 16) return false;
+	if (major < 15) return true;
+	if (major === 15) {
+		if (minor > 0 || patch > 0) return false;
+		if (minor === 0 && patch === 0 && prerelease === void 0) return false;
+		if (prerelease?.startsWith("rc.")) {
+			if (parseInt(prerelease.split(".")[1] || "0", 10) >= 1) return false;
+		}
+		if (prerelease?.startsWith("canary.")) {
+			if (parseInt(prerelease.split(".")[1] || "0", 10) >= 124) return false;
+		}
+		return true;
+	}
+	return true;
+}
+/**
+* Log a message if debug mode is enabled.
+*
+* @param debug - Whether debug mode is enabled
+* @param message - The message to log
+*/
+function debugLog(debug, message) {
+	if (debug) console.log(`[Tusk Drift] ${message}`);
+}
+/**
+* Log a warning message if warnings are not suppressed.
+*
+* @param suppress - Whether to suppress the warning
+* @param message - The warning message to log
+*/
+function warn(suppress, message) {
+	if (!suppress) console.warn(`[Tusk Drift] ${message}`);
+}
+
+//#endregion
+//#region src/nextjs/withTuskDrift.ts
+/**
+* Wraps your Next.js configuration with Tusk Drift instrumentation setup.
+*
+* This function automatically configures Next.js to work with Tusk Drift by:
+* - Enabling the Next.js instrumentation hook (for Next.js < 15.0.0-rc.1)
+* - Configuring webpack externals to prevent bundling of core instrumentation packages
+* - Preserving your existing Next.js configuration and webpack customizations
+*
+* @param nextConfig - Your existing Next.js configuration object (optional)
+* @param options - Additional options to configure Tusk Drift's behavior (optional)
+* @returns The wrapped Next.js configuration with Tusk Drift instrumentation enabled
+*
+* @example
+* Basic usage:
+* ```javascript
+* // next.config.js
+* const { withTuskDrift } = require('@use-tusk/drift-node-sdk');
+*
+* module.exports = withTuskDrift({
+*   // Your Next.js config
+* });
+* ```
+*
+* @example
+* With debug logging:
+* ```javascript
+* // next.config.js
+* const { withTuskDrift } = require('@use-tusk/drift-node-sdk');
+*
+* module.exports = withTuskDrift(
+*   {
+*     // Your Next.js config
+*   },
+*   {
+*     debug: true,
+*   }
+* );
+* ```
+*
+* @remarks
+* The following webpack externals are added for server-side builds:
+* - `require-in-the-middle` - Required for CommonJS module interception
+* - `jsonpath` - Required for schema manipulation
+*/
+function withTuskDrift(nextConfig = {}, options = {}) {
+	const config = nextConfig;
+	const debug = options.debug || false;
+	const suppressAllWarnings = options.suppressWarnings || false;
+	const nextjsVersion = getNextjsVersion();
+	if (nextjsVersion) debugLog(debug, `Detected Next.js version: ${nextjsVersion}`);
+	else warn(suppressAllWarnings || false, "Could not detect Next.js version. Some features may not work correctly. If you encounter issues, please ensure Next.js is properly installed.");
+	const needsInstrumentationHook = !options.disableInstrumentationHook && shouldSetInstrumentationHook(nextjsVersion);
+	const wrappedConfig = {
+		...config,
+		...needsInstrumentationHook ? { experimental: {
+			...config.experimental,
+			instrumentationHook: true
+		} } : { experimental: config.experimental },
+		webpack: (webpackConfig, webpackOptions) => {
+			if (webpackOptions.isServer) {
+				const originalExternals = webpackConfig.externals;
+				const coreExternals = ["require-in-the-middle", "jsonpath"];
+				if (!originalExternals) {
+					webpackConfig.externals = coreExternals;
+					debugLog(debug, "Created new externals array with core packages");
+				} else if (Array.isArray(originalExternals)) {
+					for (const pkg of coreExternals) if (!originalExternals.includes(pkg)) {
+						originalExternals.push(pkg);
+						debugLog(debug, `Added ${pkg} to webpack externals`);
+					}
+				} else {
+					webpackConfig.externals = [originalExternals, ...coreExternals];
+					debugLog(debug, "Wrapped existing externals with core packages");
+				}
+			}
+			if (typeof config.webpack === "function") return config.webpack(webpackConfig, webpackOptions);
+			return webpackConfig;
+		}
+	};
+	if (needsInstrumentationHook) debugLog(debug, "Set experimental.instrumentationHook to true");
+	else debugLog(debug, "Skipped setting experimental.instrumentationHook (not needed for Next.js 15.0.0-rc.1+)");
+	if (options.disableInstrumentationHook && nextjsVersion && shouldSetInstrumentationHook(nextjsVersion)) warn(suppressAllWarnings || false, "You disabled instrumentationHook, but your Next.js version requires it. Tusk Drift may not initialize properly. Please remove the disableInstrumentationHook option.");
+	return wrappedConfig;
+}
+
 //#endregion
 //#region src/instrumentation/core/baseClasses/TdInstrumentationAbstract.ts
 var TdInstrumentationAbstract = class {
@@ -76,7 +252,7 @@ var TdInstrumentationAbstract = class {
 
 //#endregion
 //#region package.json
-var version = "0.1.5";
+var version = "0.1.6";
 
 //#endregion
 //#region src/version.ts
@@ -1172,7 +1348,7 @@ var JsonSchemaHelper = class JsonSchemaHelper {
 	}
 	/**
 	* Generate schema from data object using standardized types
-	* 
+	*
 	* Note: We properties always exists on JsonSchema because proto3 maps cannot be marked optional.
 	* The JSON data is a bit inefficient because of this, but the easiest way to handle this is to keep it for now.
 	*/
@@ -2241,6 +2417,7 @@ var HttpInstrumentation = class extends TdInstrumentationBase {
 			};
 			const replayTraceId = this.replayHooks.extractTraceIdFromHeaders(req);
 			if (!replayTraceId) return originalHandler.call(this);
+			logger.debug(`[HttpInstrumentation] Setting replay trace id`, replayTraceId);
 			const envVars = this.replayHooks.extractEnvVarsFromHeaders(req);
 			if (envVars) EnvVarTracker.setEnvVars(replayTraceId, envVars);
 			const ctxWithReplayTraceId = SpanUtils.setCurrentReplayTraceId(replayTraceId);
@@ -4642,7 +4819,9 @@ var TdMysql2QueryMock = class {
 
 //#endregion
 //#region src/instrumentation/libraries/mysql2/Instrumentation.ts
-const SUPPORTED_VERSIONS$1 = [">=3.0.0 <4.0.0"];
+const COMPLETE_SUPPORTED_VERSIONS = ">=2.3.3 <4.0.0";
+const V2_3_3_TO_3_11_4 = ">=2.3.3 <3.11.5";
+const V3_11_5_TO_4_0 = ">=3.11.5 <4.0.0";
 var Mysql2Instrumentation = class extends TdInstrumentationBase {
 	constructor(config = {}) {
 		super("mysql2", config);
@@ -4653,42 +4832,112 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 	init() {
 		return [new TdInstrumentationNodeModule({
 			name: "mysql2",
-			supportedVersions: SUPPORTED_VERSIONS$1,
+			supportedVersions: [COMPLETE_SUPPORTED_VERSIONS],
 			files: [
 				new TdInstrumentationNodeModuleFile({
 					name: "mysql2/lib/connection.js",
-					supportedVersions: SUPPORTED_VERSIONS$1,
-					patch: (moduleExports) => this._patchConnection(moduleExports)
+					supportedVersions: [V2_3_3_TO_3_11_4],
+					patch: (moduleExports) => this._patchConnectionV2(moduleExports)
+				}),
+				new TdInstrumentationNodeModuleFile({
+					name: "mysql2/lib/base/connection.js",
+					supportedVersions: [V3_11_5_TO_4_0],
+					patch: (moduleExports) => this._patchBaseConnection(moduleExports)
+				}),
+				new TdInstrumentationNodeModuleFile({
+					name: "mysql2/lib/connection.js",
+					supportedVersions: [V3_11_5_TO_4_0],
+					patch: (moduleExports) => this._patchConnectionV3(moduleExports)
 				}),
 				new TdInstrumentationNodeModuleFile({
 					name: "mysql2/lib/pool.js",
-					supportedVersions: SUPPORTED_VERSIONS$1,
-					patch: (moduleExports) => this._patchPool(moduleExports)
+					supportedVersions: [V2_3_3_TO_3_11_4],
+					patch: (moduleExports) => this._patchPoolV2(moduleExports)
+				}),
+				new TdInstrumentationNodeModuleFile({
+					name: "mysql2/lib/pool.js",
+					supportedVersions: [V3_11_5_TO_4_0],
+					patch: (moduleExports) => this._patchPoolV3(moduleExports)
+				}),
+				new TdInstrumentationNodeModuleFile({
+					name: "mysql2/lib/pool_connection.js",
+					supportedVersions: [V2_3_3_TO_3_11_4],
+					patch: (moduleExports) => this._patchPoolConnectionV2(moduleExports)
 				}),
 				new TdInstrumentationNodeModuleFile({
 					name: "mysql2/lib/pool_connection.js",
-					supportedVersions: SUPPORTED_VERSIONS$1,
-					patch: (moduleExports) => this._patchPoolConnection(moduleExports)
+					supportedVersions: [V3_11_5_TO_4_0],
+					patch: (moduleExports) => this._patchPoolConnectionV3(moduleExports)
 				}),
 				new TdInstrumentationNodeModuleFile({
 					name: "mysql2/lib/create_connection.js",
-					supportedVersions: SUPPORTED_VERSIONS$1,
+					supportedVersions: [COMPLETE_SUPPORTED_VERSIONS],
 					patch: (moduleExports) => this._patchCreateConnectionFile(moduleExports)
 				}),
 				new TdInstrumentationNodeModuleFile({
 					name: "mysql2/lib/create_pool.js",
-					supportedVersions: SUPPORTED_VERSIONS$1,
+					supportedVersions: [COMPLETE_SUPPORTED_VERSIONS],
 					patch: (moduleExports) => this._patchCreatePoolFile(moduleExports)
 				})
 			]
 		})];
 	}
-	_patchConnection(ConnectionClass) {
-		logger.debug(`[Mysql2Instrumentation] Patching Connection class`);
+	_patchBaseConnection(BaseConnectionClass) {
+		logger.debug(`[Mysql2Instrumentation] Patching BaseConnection class`);
+		if (this.isModulePatched(BaseConnectionClass)) {
+			logger.debug(`[Mysql2Instrumentation] BaseConnection class already patched, skipping`);
+			return BaseConnectionClass;
+		}
+		if (BaseConnectionClass.prototype && BaseConnectionClass.prototype.query) {
+			if (!isWrapped$1(BaseConnectionClass.prototype.query)) {
+				this._wrap(BaseConnectionClass.prototype, "query", this._getQueryPatchFn("connection"));
+				logger.debug(`[Mysql2Instrumentation] Wrapped BaseConnection.prototype.query`);
+			}
+		}
+		if (BaseConnectionClass.prototype && BaseConnectionClass.prototype.execute) {
+			if (!isWrapped$1(BaseConnectionClass.prototype.execute)) {
+				this._wrap(BaseConnectionClass.prototype, "execute", this._getExecutePatchFn("connection"));
+				logger.debug(`[Mysql2Instrumentation] Wrapped BaseConnection.prototype.execute`);
+			}
+		}
+		if (BaseConnectionClass.prototype && BaseConnectionClass.prototype.connect) {
+			if (!isWrapped$1(BaseConnectionClass.prototype.connect)) {
+				this._wrap(BaseConnectionClass.prototype, "connect", this._getConnectPatchFn("connection"));
+				logger.debug(`[Mysql2Instrumentation] Wrapped BaseConnection.prototype.connect`);
+			}
+		}
+		if (BaseConnectionClass.prototype && BaseConnectionClass.prototype.ping) {
+			if (!isWrapped$1(BaseConnectionClass.prototype.ping)) {
+				this._wrap(BaseConnectionClass.prototype, "ping", this._getPingPatchFn("connection"));
+				logger.debug(`[Mysql2Instrumentation] Wrapped BaseConnection.prototype.ping`);
+			}
+		}
+		if (BaseConnectionClass.prototype && BaseConnectionClass.prototype.end) {
+			if (!isWrapped$1(BaseConnectionClass.prototype.end)) {
+				this._wrap(BaseConnectionClass.prototype, "end", this._getEndPatchFn("connection"));
+				logger.debug(`[Mysql2Instrumentation] Wrapped BaseConnection.prototype.end`);
+			}
+		}
+		this.markModuleAsPatched(BaseConnectionClass);
+		logger.debug(`[Mysql2Instrumentation] BaseConnection class patching complete`);
+		return BaseConnectionClass;
+	}
+	_patchConnectionV2(ConnectionClass) {
+		logger.debug(`[Mysql2Instrumentation] Patching Connection class (v2)`);
 		if (this.isModulePatched(ConnectionClass)) {
 			logger.debug(`[Mysql2Instrumentation] Connection class already patched, skipping`);
 			return ConnectionClass;
 		}
+		this._patchConnectionPrototypes(ConnectionClass);
+		this.markModuleAsPatched(ConnectionClass);
+		logger.debug(`[Mysql2Instrumentation] Connection class (v2) patching complete`);
+		return ConnectionClass;
+	}
+	_patchConnectionV3(ConnectionClass) {
+		logger.debug(`[Mysql2Instrumentation] Connection class (v3) - skipping (base patched)`);
+		return ConnectionClass;
+	}
+	_patchConnectionPrototypes(ConnectionClass) {
 		if (ConnectionClass.prototype && ConnectionClass.prototype.query) {
 			if (!isWrapped$1(ConnectionClass.prototype.query)) {
 				this._wrap(ConnectionClass.prototype, "query", this._getQueryPatchFn("connection"));
@@ -4719,16 +4968,30 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 				logger.debug(`[Mysql2Instrumentation] Wrapped Connection.prototype.end`);
 			}
 		}
-		this.markModuleAsPatched(ConnectionClass);
-		logger.debug(`[Mysql2Instrumentation] Connection class patching complete`);
-		return ConnectionClass;
 	}
-	_patchPool(PoolClass) {
-		logger.debug(`[Mysql2Instrumentation] Patching Pool class`);
+	_patchPoolV2(PoolClass) {
+		logger.debug(`[Mysql2Instrumentation] Patching Pool class (v2)`);
 		if (this.isModulePatched(PoolClass)) {
 			logger.debug(`[Mysql2Instrumentation] Pool class already patched, skipping`);
 			return PoolClass;
 		}
+		this._patchPoolPrototypes(PoolClass);
+		this.markModuleAsPatched(PoolClass);
+		logger.debug(`[Mysql2Instrumentation] Pool class (v2) patching complete`);
+		return PoolClass;
+	}
+	_patchPoolV3(PoolClass) {
+		logger.debug(`[Mysql2Instrumentation] Patching Pool class (v3)`);
+		if (this.isModulePatched(PoolClass)) {
+			logger.debug(`[Mysql2Instrumentation] Pool class already patched, skipping`);
+			return PoolClass;
+		}
+		this._patchPoolPrototypes(PoolClass);
+		this.markModuleAsPatched(PoolClass);
+		logger.debug(`[Mysql2Instrumentation] Pool class (v3) patching complete`);
+		return PoolClass;
+	}
+	_patchPoolPrototypes(PoolClass) {
 		if (PoolClass.prototype && PoolClass.prototype.query) {
 			if (!isWrapped$1(PoolClass.prototype.query)) {
 				this._wrap(PoolClass.prototype, "query", this._getQueryPatchFn("pool"));
@@ -4747,30 +5010,19 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 				logger.debug(`[Mysql2Instrumentation] Wrapped Pool.prototype.getConnection`);
 			}
 		}
-		this.markModuleAsPatched(PoolClass);
-		logger.debug(`[Mysql2Instrumentation] Pool class patching complete`);
-		return PoolClass;
-	}
-	_patchPoolConnection(PoolConnectionClass) {
-		logger.debug(`[Mysql2Instrumentation] Patching PoolConnection class`);
-		if (this.isModulePatched(PoolConnectionClass)) {
-			logger.debug(`[Mysql2Instrumentation] PoolConnection class already patched, skipping`);
-			return PoolConnectionClass;
-		}
-		if (PoolConnectionClass.prototype && PoolConnectionClass.prototype.query) {
-			if (!isWrapped$1(PoolConnectionClass.prototype.query)) {
-				this._wrap(PoolConnectionClass.prototype, "query", this._getQueryPatchFn("poolConnection"));
-				logger.debug(`[Mysql2Instrumentation] Wrapped PoolConnection.prototype.query`);
-			}
-		}
-		if (PoolConnectionClass.prototype && PoolConnectionClass.prototype.execute) {
-			if (!isWrapped$1(PoolConnectionClass.prototype.execute)) {
-				this._wrap(PoolConnectionClass.prototype, "execute", this._getExecutePatchFn("poolConnection"));
-				logger.debug(`[Mysql2Instrumentation] Wrapped PoolConnection.prototype.execute`);
+		if (PoolClass.prototype && PoolClass.prototype.end) {
+			if (!isWrapped$1(PoolClass.prototype.end)) {
+				this._wrap(PoolClass.prototype, "end", this._getEndPatchFn("pool"));
+				logger.debug(`[Mysql2Instrumentation] Wrapped Pool.prototype.end`);
 			}
 		}
-		this.markModuleAsPatched(PoolConnectionClass);
-		logger.debug(`[Mysql2Instrumentation] PoolConnection class patching complete`);
+	}
+	_patchPoolConnectionV2(PoolConnectionClass) {
+		logger.debug(`[Mysql2Instrumentation] PoolConnection class (v2) - skipping (inherits from Connection)`);
+		return PoolConnectionClass;
+	}
+	_patchPoolConnectionV3(PoolConnectionClass) {
+		logger.debug(`[Mysql2Instrumentation] PoolConnection class (v3) - skipping (inherits from Connection)`);
 		return PoolConnectionClass;
 	}
 	_getQueryPatchFn(clientType) {
@@ -6602,7 +6854,7 @@ var IORedisInstrumentation = class extends TdInstrumentationBase {
 		}
 		const actualExports = moduleExports[Symbol.toStringTag] === "Module" ? moduleExports.default : moduleExports;
 		if (!actualExports || !actualExports.prototype) {
-			logger.error(`[IORedisInstrumentation] Invalid Pipeline module exports, cannot patch`);
+			logger.debug(`[IORedisInstrumentation] Invalid Pipeline module exports, cannot patch`);
 			return moduleExports;
 		}
 		if (actualExports.prototype.exec) {
@@ -7521,6 +7773,372 @@ var GrpcInstrumentation = class GrpcInstrumentation extends TdInstrumentationBas
 };
 GrpcInstrumentation.metadataStore = /* @__PURE__ */ new Map();
 
+//#endregion
+//#region src/instrumentation/libraries/nextjs/Instrumentation.ts
+var NextjsInstrumentation = class extends TdInstrumentationBase {
+	constructor(config = {}) {
+		super("nextjs", config);
+		this.INSTRUMENTATION_NAME = "NextjsInstrumentation";
+		this.mode = config.mode || TuskDriftMode.DISABLED;
+		this.replayHooks = new HttpReplayHooks();
+		this.tuskDrift = TuskDriftCore.getInstance();
+		logger.debug(`[NextjsInstrumentation] Constructor called with mode: ${this.mode}`);
+		this._patchLoadedModules();
+	}
+	init() {
+		logger.debug(`[NextjsInstrumentation] Initializing in ${this.mode} mode`);
+		return [new TdInstrumentationNodeModule({
+			name: "next/dist/server/base-server",
+			supportedVersions: ["*"],
+			patch: (moduleExports) => {
+				return this._patchBaseServer(moduleExports);
+			}
+		})];
+	}
+	_patchLoadedModules() {
+		logger.debug(`[NextjsInstrumentation] Checking for already-loaded Next.js modules`);
+		const pattern = "/next/dist/server/base-server.js";
+		let patchedCount = 0;
+		for (const [modulePath, cached] of Object.entries(__require.cache)) if (modulePath.includes(pattern) && cached && cached.exports) {
+			logger.debug(`[NextjsInstrumentation] Found ${pattern} at ${modulePath}, patching now`);
+			this._patchBaseServer(cached.exports);
+			patchedCount++;
+			break;
+		}
+		if (patchedCount === 0) {
+			logger.debug(`[NextjsInstrumentation] No Next.js server modules found in require.cache yet`);
+			logger.debug(`[NextjsInstrumentation] Will wait for require-in-the-middle hooks to catch them`);
+		} else logger.debug(`[NextjsInstrumentation] Patched ${patchedCount} already-loaded Next.js modules`);
+	}
+	_patchBaseServer(baseServerModule) {
+		logger.debug(`[NextjsInstrumentation] Patching Next.js BaseServer in ${this.mode} mode`);
+		const BaseServer = baseServerModule.default || baseServerModule.BaseServer || baseServerModule;
+		if (BaseServer && BaseServer.prototype) {
+			if (this.isModulePatched(BaseServer.prototype)) {
+				logger.debug(`[NextjsInstrumentation] BaseServer.prototype already patched, skipping`);
+				return baseServerModule;
+			}
+			if (BaseServer.prototype.handleRequest) {
+				this._wrap(BaseServer.prototype, "handleRequest", this._getHandleRequestPatchFn());
+				logger.debug(`[NextjsInstrumentation] Wrapped BaseServer.prototype.handleRequest`);
+				this.markModuleAsPatched(BaseServer.prototype);
+			} else logger.warn(`[NextjsInstrumentation] Could not find BaseServer.prototype.handleRequest`);
+		} else logger.warn(`[NextjsInstrumentation] Could not find BaseServer class`);
+		logger.debug(`[NextjsInstrumentation] Next.js BaseServer patching complete`);
+		return baseServerModule;
+	}
+	_getHandleRequestPatchFn() {
+		const self = this;
+		return (originalHandleRequest) => {
+			return async function(req, res, parsedUrl) {
+				const method = req.method || "GET";
+				const url = req.url || "/";
+				logger.debug(`[NextjsInstrumentation] Intercepted Next.js request: ${method} ${url}`);
+				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({ replayModeHandler: () => {
+					const inputValue = {
+						method,
+						url,
+						target: url,
+						headers: self._normalizeHeaders(req.headers || {})
+					};
+					const replayTraceId = self.replayHooks.extractTraceIdFromHeaders(req);
+					if (!replayTraceId) {
+						logger.debug(`[NextjsInstrumentation] No trace ID found, calling original handler`);
+						return originalHandleRequest.call(this, req, res, parsedUrl);
+					}
+					const envVars = self.replayHooks.extractEnvVarsFromHeaders(req);
+					if (envVars) EnvVarTracker.setEnvVars(replayTraceId, envVars);
+					const ctxWithReplayTraceId = SpanUtils.setCurrentReplayTraceId(replayTraceId);
+					if (!ctxWithReplayTraceId) throw new Error("Error setting current replay trace id");
+					return context.with(ctxWithReplayTraceId, () => {
+						return SpanUtils.createAndExecuteSpan(self.mode, () => originalHandleRequest.call(this, req, res, parsedUrl), {
+							name: url,
+							kind: SpanKind.SERVER,
+							packageName: "nextjs",
+							submodule: method,
+							packageType: PackageType.HTTP,
+							instrumentationName: self.INSTRUMENTATION_NAME,
+							inputValue,
+							inputSchemaMerges: { headers: { matchImportance: 0 } },
+							isPreAppStart: false
+						}, (spanInfo) => {
+							return self._handleNextjsRequestInSpan({
+								req,
+								res,
+								parsedUrl,
+								originalHandleRequest,
+								spanInfo,
+								inputValue,
+								thisContext: this
+							});
+						});
+					});
+				} });
+				else if (self.mode === TuskDriftMode.RECORD) {
+					if (method.toUpperCase() === "OPTIONS" || !!req.headers["access-control-request-method"]) return originalHandleRequest.call(this, req, res, parsedUrl);
+					if (!shouldSample({
+						samplingRate: self.tuskDrift.getSamplingRate(),
+						isAppReady: self.tuskDrift.isAppReady()
+					})) {
+						logger.debug(`[NextjsInstrumentation] Skipping server span due to sampling rate: ${url}`);
+						return originalHandleRequest.call(this, req, res, parsedUrl);
+					}
+					logger.debug(`[NextjsInstrumentation] Creating server span for ${method} ${url}`);
+					return handleRecordMode({
+						originalFunctionCall: () => originalHandleRequest.call(this, req, res, parsedUrl),
+						recordModeHandler: ({ isPreAppStart }) => {
+							const inputValue = {
+								method,
+								url,
+								target: url,
+								headers: self._normalizeHeaders(req.headers || {})
+							};
+							return SpanUtils.createAndExecuteSpan(self.mode, () => originalHandleRequest.call(this, req, res, parsedUrl), {
+								name: url,
+								kind: SpanKind.SERVER,
+								packageName: "nextjs",
+								packageType: PackageType.HTTP,
+								submodule: method,
+								instrumentationName: self.INSTRUMENTATION_NAME,
+								inputValue,
+								inputSchemaMerges: { headers: { matchImportance: 0 } },
+								isPreAppStart
+							}, (spanInfo) => {
+								return self._handleNextjsRequestInSpan({
+									req,
+									res,
+									parsedUrl,
+									originalHandleRequest,
+									spanInfo,
+									inputValue,
+									thisContext: this
+								});
+							});
+						},
+						spanKind: SpanKind.SERVER
+					});
+				} else return originalHandleRequest.call(this, req, res, parsedUrl);
+			};
+		};
+	}
+	async _handleNextjsRequestInSpan({ req, res, parsedUrl, originalHandleRequest, spanInfo, inputValue, thisContext }) {
+		const self = this;
+		context.bind(spanInfo.context, req);
+		context.bind(spanInfo.context, res);
+		let completeInputValue = inputValue;
+		this._captureRequestBody(req, spanInfo, inputValue, (updatedInputValue) => {
+			completeInputValue = updatedInputValue;
+		});
+		let capturedStatusCode;
+		let capturedStatusMessage;
+		let capturedHeaders = {};
+		const responseChunks = [];
+		const actualRes = res.originalResponse || res;
+		const originalWriteHead = actualRes.writeHead?.bind(actualRes);
+		if (originalWriteHead) actualRes.writeHead = function(statusCode, statusMessage, headers) {
+			capturedStatusCode = statusCode;
+			if (typeof statusMessage === "object") capturedHeaders = self._normalizeHeaders(statusMessage);
+			else {
+				capturedStatusMessage = statusMessage;
+				if (headers) capturedHeaders = self._normalizeHeaders(headers);
+			}
+			return originalWriteHead.call(this, statusCode, statusMessage, headers);
+		};
+		const originalSetHeader = actualRes.setHeader?.bind(actualRes);
+		if (originalSetHeader) actualRes.setHeader = function(name, value) {
+			capturedHeaders[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+			return originalSetHeader.call(this, name, value);
+		};
+		const originalWrite = actualRes.write?.bind(actualRes);
+		if (originalWrite) actualRes.write = function(chunk, encoding, callback) {
+			if (chunk) responseChunks.push(chunk);
+			return originalWrite.call(this, chunk, encoding, callback);
+		};
+		const originalEnd = actualRes.end?.bind(actualRes);
+		if (originalEnd) actualRes.end = function(chunk, encoding, callback) {
+			if (chunk) responseChunks.push(chunk);
+			return originalEnd.call(this, chunk, encoding, callback);
+		};
+		try {
+			await originalHandleRequest.call(thisContext, req, res, parsedUrl);
+			if (!capturedStatusCode) {
+				capturedStatusCode = res.statusCode;
+				capturedStatusMessage = res.statusMessage;
+			}
+			if (Object.keys(capturedHeaders).length === 0 && res.getHeaders) {
+				const rawHeaders = res.getHeaders();
+				capturedHeaders = self._normalizeHeaders(rawHeaders);
+			}
+			logger.debug(`[NextjsInstrumentation] Next.js request completed: ${capturedStatusCode} (${SpanUtils.getTraceInfo()})`);
+			const outputValue = {
+				statusCode: capturedStatusCode,
+				statusMessage: capturedStatusMessage,
+				headers: capturedHeaders
+			};
+			if (responseChunks.length > 0) try {
+				const responseBuffer = combineChunks(responseChunks);
+				const contentEncoding = outputValue.headers?.["content-encoding"];
+				outputValue.body = await httpBodyEncoder({
+					bodyBuffer: responseBuffer,
+					contentEncoding
+				});
+				outputValue.bodySize = responseBuffer.length;
+			} catch (error) {
+				logger.error(`[NextjsInstrumentation] Error processing response body:`, error);
+				outputValue.bodyProcessingError = error instanceof Error ? error.message : String(error);
+			}
+			SpanUtils.addSpanAttributes(spanInfo.span, {
+				inputValue: completeInputValue,
+				outputValue,
+				outputSchemaMerges: {
+					body: {
+						encoding: EncodingType.BASE64,
+						decodedType: getDecodedType(outputValue.headers?.["content-type"] || "")
+					},
+					headers: { matchImportance: 0 }
+				},
+				metadata: { ENV_VARS: EnvVarTracker.getEnvVars(spanInfo.traceId) }
+			});
+			EnvVarTracker.clearEnvVars(spanInfo.traceId);
+			const status = (capturedStatusCode || 200) >= 400 ? {
+				code: SpanStatusCode.ERROR,
+				message: `HTTP ${capturedStatusCode}`
+			} : { code: SpanStatusCode.OK };
+			SpanUtils.setStatus(spanInfo.span, status);
+			SpanUtils.endSpan(spanInfo.span);
+			if (self.mode === TuskDriftMode.REPLAY) try {
+				const now = OriginalGlobalUtils.getOriginalDate();
+				const replayTraceId = SpanUtils.getCurrentReplayTraceId() || spanInfo.traceId;
+				const { schema: inputSchema, decodedValueHash: inputValueHash } = JsonSchemaHelper.generateSchemaAndHash(completeInputValue, {
+					body: {
+						encoding: EncodingType.BASE64,
+						decodedType: getDecodedType(completeInputValue.headers && completeInputValue.headers["content-type"] || "")
+					},
+					headers: { matchImportance: 0 }
+				});
+				const { schema: outputSchema, decodedValueHash: outputValueHash } = JsonSchemaHelper.generateSchemaAndHash(outputValue, {
+					body: {
+						encoding: EncodingType.BASE64,
+						decodedType: getDecodedType(outputValue.headers["content-type"] || "")
+					},
+					headers: { matchImportance: 0 }
+				});
+				const cleanSpan = {
+					traceId: replayTraceId,
+					spanId: spanInfo.spanId,
+					parentSpanId: "",
+					name: completeInputValue.url,
+					packageName: "nextjs",
+					instrumentationName: self.INSTRUMENTATION_NAME,
+					submoduleName: completeInputValue.method,
+					inputValue: completeInputValue,
+					outputValue,
+					inputSchema,
+					outputSchema,
+					inputSchemaHash: JsonSchemaHelper.generateDeterministicHash(inputSchema),
+					outputSchemaHash: JsonSchemaHelper.generateDeterministicHash(outputSchema),
+					inputValueHash,
+					outputValueHash,
+					kind: SpanKind.SERVER,
+					packageType: PackageType.HTTP,
+					status: {
+						code: (capturedStatusCode || 200) >= 400 ? StatusCode.ERROR : StatusCode.OK,
+						message: (capturedStatusCode || 200) >= 400 ? `HTTP ${capturedStatusCode}` : ""
+					},
+					timestamp: {
+						seconds: Math.floor(now.getTime() / 1e3),
+						nanos: now.getTime() % 1e3 * 1e6
+					},
+					duration: {
+						seconds: 0,
+						nanos: 0
+					},
+					isRootSpan: true,
+					isPreAppStart: false,
+					metadata: void 0
+				};
+				await self.tuskDrift.sendInboundSpanForReplay(cleanSpan);
+			} catch (e) {
+				logger.error("[NextjsInstrumentation] Failed to build/send inbound replay span:", e);
+			}
+		} catch (error) {
+			logger.error(`[NextjsInstrumentation] Error in Next.js request: ${error instanceof Error ? error.message : String(error)}`);
+			SpanUtils.endSpan(spanInfo.span, {
+				code: SpanStatusCode.ERROR,
+				message: error instanceof Error ? error.message : String(error)
+			});
+			throw error;
+		}
+	}
+	/**
+	* Captures the request body from an IncomingMessage stream by patching req.read() and listening for data events.
+	* Similar to HTTP instrumentation's request body capture, but adapted for Next.js.
+	*/
+	_captureRequestBody(req, spanInfo, inputValue, onBodyCaptured) {
+		const actualReq = req.originalRequest || req._req || req;
+		const requestBodyChunks = [];
+		let streamConsumptionMode = "NOT_CONSUMING";
+		const originalRead = actualReq.read?.bind(actualReq);
+		if (originalRead) actualReq.read = function read(size) {
+			const chunk = originalRead(size);
+			if (chunk && (streamConsumptionMode === "READ" || streamConsumptionMode === "NOT_CONSUMING")) {
+				streamConsumptionMode = "READ";
+				requestBodyChunks.push(Buffer.from(chunk));
+			}
+			return chunk;
+		};
+		if (typeof actualReq.once !== "function" || typeof actualReq.addListener !== "function") {
+			logger.debug(`[NextjsInstrumentation] Request object doesn't have event emitter methods, skipping body capture`);
+			return;
+		}
+		actualReq.once("resume", () => {
+			actualReq.addListener("data", (chunk) => {
+				if (chunk && (streamConsumptionMode === "PIPE" || streamConsumptionMode === "NOT_CONSUMING")) {
+					streamConsumptionMode = "PIPE";
+					requestBodyChunks.push(Buffer.from(chunk));
+				}
+			});
+		});
+		actualReq.addListener("end", async (chunk) => {
+			if (chunk) requestBodyChunks.push(Buffer.from(chunk));
+			if (requestBodyChunks.length > 0) try {
+				const bodyBuffer = Buffer.concat(requestBodyChunks);
+				const encodedBody = await httpBodyEncoder({
+					bodyBuffer,
+					contentEncoding: actualReq.headers["content-encoding"]
+				});
+				const updatedInputValue = {
+					...inputValue,
+					body: encodedBody,
+					bodySize: bodyBuffer.length
+				};
+				if (onBodyCaptured) onBodyCaptured(updatedInputValue);
+				SpanUtils.addSpanAttributes(spanInfo.span, {
+					inputValue: updatedInputValue,
+					inputSchemaMerges: {
+						body: {
+							encoding: EncodingType.BASE64,
+							decodedType: getDecodedType(actualReq.headers["content-type"] || "")
+						},
+						headers: { matchImportance: 0 }
+					}
+				});
+				logger.debug(`[NextjsInstrumentation] Captured request body for ${actualReq.method} ${actualReq.url}: ${bodyBuffer.length} bytes`);
+			} catch (error) {
+				logger.error(`[NextjsInstrumentation] Error processing request body:`, error);
+			}
+		});
+	}
+	_normalizeHeaders(headers) {
+		const normalized = {};
+		for (const [key, value] of Object.entries(headers)) if (value !== void 0) normalized[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : String(value);
+		return normalized;
+	}
+	_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) => {
@@ -9957,7 +10575,18 @@ var TdSpanExporter = class {
 	*/
 	export(spans, resultCallback) {
 		logger.debug(`TdSpanExporter.export() called with ${spans.length} span(s)`);
-		const cleanSpans = spans.map((span) => SpanTransformer.transformSpanToCleanJSON(span));
+		const filteredSpans = spans.filter((span) => {
+			if (span.instrumentationLibrary?.name === "next.js") return false;
+			return true;
+		});
+		logger.debug(`After filtering: ${filteredSpans.length} span(s) remaining`);
+		let cleanSpans;
+		try {
+			cleanSpans = filteredSpans.map((span) => SpanTransformer.transformSpanToCleanJSON(span));
+		} catch (error) {
+			logger.error("Error transforming spans to CleanSpanData", error);
+			throw error;
+		}
 		if (this.adapters.length === 0) {
 			logger.debug("No adapters configured");
 			resultCallback({ code: import_src.ExportResultCode.SUCCESS });
@@ -10477,6 +11106,10 @@ var TuskDriftCore = class TuskDriftCore {
 			enabled: true,
 			mode: this.mode
 		});
+		new NextjsInstrumentation({
+			enabled: true,
+			mode: this.mode
+		});
 	}
 	initializeTracing({ baseDirectory }) {
 		const serviceName = this.config.service?.name || "unknown";
@@ -10506,6 +11139,10 @@ var TuskDriftCore = class TuskDriftCore {
 		return `sdk-${OriginalGlobalUtils.getOriginalDate().getTime()}-${Math.random().toString(36).substr(2, 9)}`;
 	}
 	initialize(initParams) {
+		initializeGlobalLogger({
+			logLevel: initParams.logLevel || "silent",
+			prefix: "TuskDrift"
+		});
 		this.samplingRate = this.config.recording?.sampling_rate ?? 1;
 		this.initParams = initParams;
 		if (!this.initParams.env) {
@@ -10513,10 +11150,6 @@ var TuskDriftCore = class TuskDriftCore {
 			logger.warn(`Environment not provided in initialization parameters. Using '${nodeEnv}' as the environment.`);
 			this.initParams.env = nodeEnv;
 		}
-		initializeGlobalLogger({
-			logLevel: initParams.logLevel || "silent",
-			prefix: "TuskDrift"
-		});
 		if (this.initialized) {
 			logger.debug("Already initialized, skipping...");
 			return;
@@ -10712,5 +11345,5 @@ var TuskDriftSDK = class {
 const TuskDrift = new TuskDriftSDK();
 
 //#endregion
-export { TuskDrift };
+export { TuskDrift, withTuskDrift };
 //# sourceMappingURL=index.js.map