Allow RegExp pattern for targeting bundled files (e.g. chunk-XXXX.mjs)

library/agent/hooks/VersionedPackage.ts

@@ -65,6 +65,12 @@ export class VersionedPackage {
    * The path is relative to the package root.
    */
   addFileInstrumentation(instruction: PackageFileInstrumentationInstruction) {
+    if (instruction.path instanceof RegExp) {
+      // Just accept RegExp paths as-is
+      this.fileInstrumentationInstructions.push(instruction);
+      return this;
+    }
+
     if (instruction.path.length === 0) {
       throw new Error("Path must not be empty");
     }

library/agent/hooks/instrumentation/codeTransformation.ts

@@ -14,12 +14,20 @@ export function transformCode(
   pkgLoadFormat: PackageLoadFormat,
   fileInstructions: PackageFileInstrumentationInstructionJSON
 ): string {
+  // Path can be a RegExp pattern but JSON.stringify will throw an error
+  // We want the actual file path anyway, not the matching pattern
+  const instructionsWasm: JSONSerializable<PackageFileInstrumentationInstructionJSON> =
+    {
+      ...fileInstructions,
+      path: path,
+    };
+
   try {
     const result = wasm_transform_code_str(
       pkgName,
       pkgVersion,
       code,
-      JSON.stringify(fileInstructions),
+      JSON.stringify(instructionsWasm),
       getSourceType(path, pkgLoadFormat)
     );
 
@@ -43,3 +51,19 @@ export function transformCode(
     throw error;
   }
 }
+
+// There's no nice way to create types like these
+// Since we stringify the JSON instructions, we need to ensure that they are serializable
+// e.g. cannot contain RegExp
+type JSONPrimitive = string | number | boolean | null;
+type JSONSerializable<T> = T extends JSONPrimitive
+  ? T
+  : T extends (infer U)[]
+    ? JSONSerializable<U>[]
+    : T extends Record<string, unknown>
+      ? {
+          [K in keyof T as T[K] extends Function | symbol | undefined
+            ? never
+            : K]: JSONSerializable<T[K]>;
+        }
+      : never;

library/agent/hooks/instrumentation/instructions.ts

@@ -44,7 +44,7 @@ export function setPackagesToInstrument(_packages: Package[]) {
         return versionedPackage
           .getFileInstrumentationInstructions()
           .map((file) => {
-            const fileIdentifier = `${pkg.getName()}.${file.path}.${versionedPackage.getRange()}`;
+            const fileIdentifier = `${pkg.getName()}.${getIdentifier(file.path)}.${versionedPackage.getRange()}`;
             if (file.accessLocalVariables?.cb) {
               fileCallbackInfo.set(fileIdentifier, {
                 pkgName: pkg.getName(),
@@ -57,7 +57,7 @@ export function setPackagesToInstrument(_packages: Package[]) {
               versionRange: versionedPackage.getRange(),
               identifier: fileIdentifier,
               functions: file.functions.map((func) => {
-                const identifier = `${pkg.getName()}.${file.path}.${func.name}.${func.nodeType}.${versionedPackage.getRange()}`;
+                const identifier = `${pkg.getName()}.${getIdentifier(file.path)}.${func.name}.${func.nodeType}.${versionedPackage.getRange()}`;
 
                 // If bindContext is set to true, but no modifyArgs is defined, modifyArgs will be set to a stub function
                 // The reason for this is that the bindContext logic needs to modify the arguments
@@ -117,6 +117,25 @@ export function shouldPatchPackage(name: string): boolean {
   return packages.has(name);
 }
 
+function matchesPath(
+  pathOrPattern: string | RegExp,
+  filePath: string
+): boolean {
+  if (typeof pathOrPattern === "string") {
+    return pathOrPattern === filePath;
+  }
+
+  return pathOrPattern.test(filePath);
+}
+
+function getIdentifier(pathOrPattern: string | RegExp) {
+  if (typeof pathOrPattern === "string") {
+    return pathOrPattern;
+  }
+
+  return pathOrPattern.toString();
+}
+
 export function getPackageFileInstrumentationInstructions(
   packageName: string,
   version: string,
@@ -141,7 +160,7 @@ export function shouldPatchFile(
     return false;
   }
 
-  return instructions.some((f) => f.path === filePath);
+  return instructions.some((f) => matchesPath(f.path, filePath));
 }
 
 export function getFunctionCallbackInfo(

library/agent/hooks/instrumentation/types.ts

@@ -119,7 +119,9 @@ export type PackageFunctionInstrumentationInstruction = {
 };
 
 export type PackageFileInstrumentationInstruction = {
-  path: string; // Relative path to required file inside the package folder
+  // Relative path to required file inside the package folder
+  // You can use a regex in cases where the filename is not known in advance (e.g. chunks generated by a bundler)
+  path: string | RegExp;
   functions: PackageFunctionInstrumentationInstruction[];
   /**
    * Access module local variables
@@ -132,7 +134,9 @@ export type PackageFileInstrumentationInstruction = {
 };
 
 export type PackageFileInstrumentationInstructionJSON = {
-  path: string; // Relative path to required file inside the package folder
+  // Relative path to required file inside the package folder
+  // You can use a regex in cases where the filename is not known in advance (e.g. chunks generated by a bundler)
+  path: string | RegExp;
   versionRange: string;
   identifier: string;
   accessLocalVariables: string[];

library/agent/protect.ts

@@ -47,6 +47,7 @@ import { Postgresjs } from "../sinks/Postgresjs";
 import { Fastify } from "../sources/Fastify";
 import { Koa } from "../sources/Koa";
 import { Restify } from "../sources/Restify";
+import { ReactRouter } from "../sources/ReactRouter";
 import { ClickHouse } from "../sinks/ClickHouse";
 import { Prisma } from "../sinks/Prisma";
 import { AwsSDKVersion2 } from "../sinks/AwsSDKVersion2";
@@ -165,6 +166,7 @@ export function getWrappers() {
     new Fastify(),
     new Koa(),
     new Restify(),
+    new ReactRouter(),
     new ClickHouse(),
     new Prisma(),
     new AwsSDKVersion3(),

library/sources/ReactRouter.ts

@@ -0,0 +1,31 @@
+import { Hooks } from "../agent/hooks/Hooks";
+import { Wrapper } from "../agent/Wrapper";
+import { wrapRequestBodyParsing } from "./react-router/wrapRequestBodyParsing";
+
+export class ReactRouter implements Wrapper {
+  wrap(hooks: Hooks) {
+    hooks
+      .addPackage("react-router")
+      .withVersion("^7.0.0")
+      .addFileInstrumentation({
+        path: /^dist\/(production|development)\/chunk-[A-Z0-9]+\.mjs$/,
+        functions: [
+          {
+            // We cannot patch the `Request` global (as Request is also used by fetch calls)
+            // We're interested in the Request object that gets passed to the server actions
+            // See https://github.com/remix-run/react-router/blob/main/packages/react-router/lib/server-runtime/data.ts#L26
+            nodeType: "FunctionDeclaration",
+            name: "stripRoutesParam",
+            operationKind: undefined,
+            modifyReturnValue: (_, returnValue) => {
+              if (returnValue instanceof Request) {
+                wrapRequestBodyParsing(returnValue);
+              }
+
+              return returnValue;
+            },
+          },
+        ],
+      });
+  }
+}

library/sources/react-router/wrapRequestBodyParsing.ts

@@ -0,0 +1,37 @@
+import { getContext, updateContext } from "../../agent/Context";
+import { createWrappedFunction, isWrapped } from "../../helpers/wrap";
+
+/**
+ * Wrap the Request object's body parsing methods to update the context with the parsed body
+ * when any of the methods are called.
+ * This is needed because React Router uses the Fetch API Request object which has a stream
+ * body that can only be consumed once. We wrap the parsing methods to capture the result.
+ */
+export function wrapRequestBodyParsing(request: Request) {
+  request.formData = wrapBodyParsingFunction(request.formData);
+  request.json = wrapBodyParsingFunction(request.json);
+  request.text = wrapBodyParsingFunction(request.text);
+}
+
+function wrapBodyParsingFunction<T extends Function>(func: T) {
+  if (isWrapped(func)) {
+    return func;
+  }
+
+  return createWrappedFunction(func, function parse(parser) {
+    return async function wrap() {
+      // @ts-expect-error No type for arguments
+      // eslint-disable-next-line prefer-rest-params
+      const returnValue = await parser.apply(this, arguments);
+
+      if (returnValue) {
+        const context = getContext();
+        if (context) {
+          updateContext(context, "body", returnValue);
+        }
+      }
+
+      return returnValue;
+    };
+  }) as T;
+}