Add patch timings testing to reporter

scripts/generateReport.ts

@@ -214,7 +214,7 @@ page.on("console", async e => {
 
         switch (tag) {
             case "WebpackInterceptor:":
-                const patchFailMatch = message.match(/Patch by (.+?) (had no effect|errored|found no module) \(Module id is (.+?)\): (.+)/)!;
+                const patchFailMatch = message.match(/Patch by (.+?) (had no effect|errored|found no module|took [\d.]+?ms) \(Module id is (.+?)\): (.+)/)!;
                 if (!patchFailMatch) break;
 
                 console.error(await getText());

src/Vencord.ts

@@ -23,6 +23,7 @@ export * as Util from "./utils";
 export * as QuickCss from "./utils/quickCss";
 export * as Updater from "./utils/updater";
 export * as Webpack from "./webpack";
+export * as WebpackPatcher from "./webpack/patchWebpack";
 export { PlainSettings, Settings };
 
 import "./utils/quickCss";

src/debug/Tracer.ts

@@ -23,35 +23,63 @@ if (IS_DEV || IS_REPORTER) {
     var logger = new Logger("Tracer", "#FFD166");
 }
 
-const noop = function () { };
+const Noop = () => { };
 
-export const beginTrace = !(IS_DEV || IS_REPORTER) ? noop :
+export const beginTrace = !(IS_DEV || IS_REPORTER) ? Noop :
     function beginTrace(name: string, ...args: any[]) {
-        if (name in traces)
+        if (name in traces) {
             throw new Error(`Trace ${name} already exists!`);
+        }
 
         traces[name] = [performance.now(), args];
     };
 
-export const finishTrace = !(IS_DEV || IS_REPORTER) ? noop : function finishTrace(name: string) {
+export const finishTrace = !(IS_DEV || IS_REPORTER) ? () => 0 :
+    function finishTrace(name: string) {
         const end = performance.now();
 
         const [start, args] = traces[name];
         delete traces[name];
 
-    logger.debug(`${name} took ${end - start}ms`, args);
+        const totalTime = end - start;
-};
+        logger.debug(`${name} took ${totalTime}ms`, args);
+
+        return totalTime;
+    };
 
 type Func = (...args: any[]) => any;
 type TraceNameMapper<F extends Func> = (...args: Parameters<F>) => string;
 
-const noopTracer =
+function noopTracerWithResults<F extends Func>(name: string, f: F, mapper?: TraceNameMapper<F>) {
-    <F extends Func>(name: string, f: F, mapper?: TraceNameMapper<F>) => f;
+    return function (this: unknown, ...args: Parameters<F>): [ReturnType<F>, number] {
+        return [f.apply(this, args), 0];
+    };
+}
+
+function noopTracer<F extends Func>(name: string, f: F, mapper?: TraceNameMapper<F>) {
+    return f;
+}
+
+export const traceFunctionWithResults = !(IS_DEV || IS_REPORTER)
+    ? noopTracerWithResults
+    : function traceFunctionWithResults<F extends Func>(name: string, f: F, mapper?: TraceNameMapper<F>): (this: unknown, ...args: Parameters<F>) => [ReturnType<F>, number] {
+        return function (this: unknown, ...args: Parameters<F>) {
+            const traceName = mapper?.(...args) ?? name;
+
+            beginTrace(traceName, ...arguments);
+            try {
+                return [f.apply(this, args), finishTrace(traceName)];
+            } catch (e) {
+                finishTrace(traceName);
+                throw e;
+            }
+        };
+    };
 
 export const traceFunction = !(IS_DEV || IS_REPORTER)
     ? noopTracer
     : function traceFunction<F extends Func>(name: string, f: F, mapper?: TraceNameMapper<F>): F {
-        return function (this: any, ...args: Parameters<F>) {
+        return function (this: unknown, ...args: Parameters<F>) {
             const traceName = mapper?.(...args) ?? name;
 
             beginTrace(traceName, ...arguments);

src/debug/runReporter.ts

@@ -30,6 +30,12 @@ async function runReporter() {
             }
         }
 
+        for (const [plugin, moduleId, match, totalTime] of Vencord.WebpackPatcher.patchTimings) {
+            if (totalTime > 3) {
+                new Logger("WebpackInterceptor").warn(`Patch by ${plugin} took ${totalTime}ms (Module id is ${String(moduleId)}): ${match}`);
+            }
+        }
+
         await Promise.all(Webpack.webpackSearchHistory.map(async ([searchType, args]) => {
             args = [...args];
 

src/webpack/patchWebpack.ts

@@ -10,12 +10,14 @@ import { canonicalizeReplacement } from "@utils/patches";
 import { PatchReplacement } from "@utils/types";
 import { WebpackInstance } from "discord-types/other";
 
-import { traceFunction } from "../debug/Tracer";
+import { traceFunctionWithResults } from "../debug/Tracer";
 import { patches } from "../plugins";
 import { _initWebpack, beforeInitListeners, factoryListeners, moduleListeners, waitForSubscriptions, wreq } from ".";
 
 const logger = new Logger("WebpackInterceptor", "#8caaee");
 
+export const patchTimings = [] as Array<[plugin: string, moduleId: PropertyKey, match: string | RegExp, totalTime: number]>;
+
 let webpackChunk: any[];
 
 // Patch the window webpack chunk setter to monkey patch the push method before any chunks are pushed
@@ -270,7 +272,7 @@ function patchFactories(factories: Record<string, (module: any, exports: any, re
 
             patchedBy.add(patch.plugin);
 
-            const executePatch = traceFunction(`patch by ${patch.plugin}`, (match: string | RegExp, replace: string) => code.replace(match, replace));
+            const executePatch = traceFunctionWithResults(`patch by ${patch.plugin}`, (match: string | RegExp, replace: string) => code.replace(match, replace));
             const previousMod = mod;
             const previousCode = code;
 
@@ -282,7 +284,12 @@ function patchFactories(factories: Record<string, (module: any, exports: any, re
                 canonicalizeReplacement(replacement, patch.plugin);
 
                 try {
-                    const newCode = executePatch(replacement.match, replacement.replace as string);
+                    const [newCode, totalTime] = executePatch(replacement.match, replacement.replace as string);
+
+                    if (IS_REPORTER) {
+                        patchTimings.push([patch.plugin, id, replacement.match, totalTime]);
+                    }
+
                     if (newCode === code) {
                         if (!patch.noWarn) {
                             logger.warn(`Patch by ${patch.plugin} had no effect (Module id is ${id}): ${replacement.match}`);