Obliterate Sentry

scripts/generateReport.ts

@@ -289,6 +289,8 @@ page.on("console", async e => {
 
 page.on("error", e => console.error("[Error]", e.message));
 page.on("pageerror", e => {
+    if (e.message.includes("Sentry successfully disabled")) return;
+
     if (!e.message.startsWith("Object") && !e.message.includes("Cannot find module")) {
         console.error("[Page Error]", e.message);
         report.otherErrors.push(e.message);

src/plugins/_core/noTrack.ts

@@ -18,6 +18,7 @@
 
 import { definePluginSettings } from "@api/Settings";
 import { Devs } from "@utils/constants";
+import { Logger } from "@utils/Logger";
 import definePlugin, { OptionType, StartAt } from "@utils/types";
 
 const settings = definePluginSettings({
@@ -71,9 +72,64 @@ export default definePlugin({
 
     startAt: StartAt.Init,
     start() {
+        // Sentry is initialized in its own WebpackInstance.
+        // It has everything it needs preloaded, so, it doesn't include any chunk loading functionality.
+        // Because of that, its WebpackInstance doesnt export wreq.m or wreq.c
+
+        // To circuvent this and disable Sentry we are gonna hook when wreq.g of its WebpackInstance is set.
+        // When that happens we are gonna obtain a reference to its internal module cache (wreq.c) and proxy its prototype,
+        // so, when the first require to initialize the Sentry is attempted, we are gonna forcefully throw an error and abort everything.
+        Object.defineProperty(Function.prototype, "g", {
+            configurable: true,
+
+            set(v: any) {
+                Object.defineProperty(this, "g", {
+                    value: v,
+                    configurable: true,
+                    enumerable: true,
+                    writable: true
+                });
+
+                // Ensure this is most likely the Sentry WebpackInstance.
+                // Function.g is a very generic property and is not uncommon for another WebpackInstance (or even a React component: <g></g>) to include it
+                const { stack } = new Error();
+                if (!(stack?.includes("discord.com") || stack?.includes("discordapp.com")) || this.c != null || !String(this).includes("exports:{}")) {
+                    return;
+                }
+
+                const cacheExtractSym = Symbol("vencord.cacheExtract");
+                Object.defineProperty(Object.prototype, cacheExtractSym, {
+                    configurable: true,
+
+                    get() {
+                        // One more condition to check if this is the Sentry WebpackInstance
+                        if (Array.isArray(this)) {
+                            return { exports: {} };
+                        }
+
+                        new Logger("NoTrack", "#8caaee").info("Disabling Sentry by proxying its WebpackInstance cache");
+                        Object.setPrototypeOf(this, new Proxy(this, {
+                            get() {
+                                throw new Error("Sentry successfully disabled");
+                            }
+                        }));
+
+                        Reflect.deleteProperty(Object.prototype, cacheExtractSym);
+                        Reflect.deleteProperty(window, "DiscordSentry");
+                        return { exports: {} };
+                    }
+                });
+
+                // WebpackRequire our fake module id
+                this(cacheExtractSym);
+            }
+        });
+
         Object.defineProperty(window, "DiscordSentry", {
             configurable: true,
+
             set() {
+                new Logger("NoTrack", "#8caaee").error("Failed to disable Sentry. Falling back to deleting window.DiscordSentry");
                 Reflect.deleteProperty(window, "DiscordSentry");
             }
         });

src/webpack/patchWebpack.ts

@@ -56,20 +56,27 @@ Object.defineProperty(window, WEBPACK_CHUNK, {
 // normally, this is populated via webpackGlobal.push, which we patch below.
 // However, Discord has their .m prepopulated.
 // Thus, we use this hack to immediately access their wreq.m and patch all already existing factories
-//
-// Update: Discord now has TWO webpack instances. Their normal one and sentry
-// Sentry does not push chunks to the global at all, so this same patch now also handles their sentry modules
 Object.defineProperty(Function.prototype, "m", {
     configurable: true,
 
     set(v: any) {
+        Object.defineProperty(this, "m", {
+            value: v,
+            configurable: true,
+            enumerable: true,
+            writable: true
+        });
+
         // When using react devtools or other extensions, we may also catch their webpack here.
         // This ensures we actually got the right one
         const { stack } = new Error();
-        if ((stack?.includes("discord.com") || stack?.includes("discordapp.com")) && !Array.isArray(v)) {
-            const fileName = stack.match(/\/assets\/(.+?\.js)/)?.[1] ?? "";
+        if (!(stack?.includes("discord.com") || stack?.includes("discordapp.com")) || Array.isArray(v)) {
+            return;
+        }
 
+        const fileName = stack.match(/\/assets\/(.+?\.js)/)?.[1] ?? "";
         logger.info("Found Webpack module factory", fileName);
+
         patchFactories(v);
 
         // Define a setter for the bundlePath property of WebpackRequire. Only the main Webpack has this property.
@@ -86,7 +93,6 @@ Object.defineProperty(Function.prototype, "m", {
                 });
 
                 clearTimeout(setterTimeout);
-
                 if (bundlePath !== "/assets/") return;
 
                 logger.info(`Main Webpack found in ${fileName}, initializing internal references to WebpackRequire`);
@@ -101,14 +107,6 @@ Object.defineProperty(Function.prototype, "m", {
         // If this is the main Webpack, wreq.p will always be set before the timeout runs.
         const setterTimeout = setTimeout(() => Reflect.deleteProperty(this, "p"), 0);
     }
-
-        Object.defineProperty(this, "m", {
-            value: v,
-            configurable: true,
-            enumerable: true,
-            writable: true
-        });
-    }
 });
 
 function patchPush(webpackGlobal: any) {