fix(core): Don't crash on recoverable CLI command error

Author: Lms24

packages/bundler-plugin-core/src/index.ts

@@ -170,8 +170,10 @@ export function sentryUnpluginFactory({
             throw e;
           }
         } else {
+          // setting the session to "crashed" b/c from a plugin perspective this run failed.
+          // However, we're intentionally not rethrowing the error to avoid breaking the user build.
           sentrySession.status = "crashed";
-          throw unknownError;
+          logger.error("An error occurred. Couldn't finish all operations:", unknownError);
         }
       } finally {
         endSession();

packages/integration-tests/fixtures/error-no-handler/error-no-handler.test.ts

@@ -0,0 +1,47 @@
+/* eslint-disable jest/no-standalone-expect */
+/* eslint-disable jest/expect-expect */
+import path from "path";
+import { createCjsBundles } from "../../utils/create-cjs-bundles-promise";
+import { spawn } from "child_process";
+
+describe("Doesn't crash when Sentry responds with HTTP errors during upload and release creation", () => {
+  test("webpack4", async () => {
+    const FAKE_SENTRY_PORT = "9876";
+
+    const sentryServer = spawn("node", ["fakeSentry.js"], {
+      stdio: "inherit",
+      env: { ...process.env, FAKE_SENTRY_PORT },
+    });
+
+    await new Promise<void>((resolve) =>
+      sentryServer.on("spawn", () => {
+        resolve();
+      })
+    );
+
+    const outputDir = path.resolve(__dirname, "out");
+
+    for (const bundler of ["webpack4", "webpack5", "esbuild", "rollup", "vite"]) {
+      await expect(
+        createCjsBundles(
+          {
+            bundle: path.resolve(__dirname, "input", "bundle.js"),
+          },
+          outputDir,
+          {
+            url: `http://localhost:${FAKE_SENTRY_PORT}`,
+            authToken: "fake-auth",
+            org: "fake-org",
+            project: "fake-project",
+            release: {
+              name: "1.0.0",
+            },
+          },
+          [bundler]
+        )
+      ).resolves.not.toThrow();
+    }
+
+    sentryServer.kill();
+  });
+});

packages/integration-tests/fixtures/error-no-handler/fakeSentry.js

@@ -0,0 +1,13 @@
+import { createServer } from "http";
+
+const port = process.env["FAKE_SENTRY_PORT"] || 3000;
+
+const server = createServer((req, res) => {
+  res.statusCode = 503;
+  res.end("Error: Santry unreachable");
+});
+
+server.listen(port, () => {
+  // eslint-disable-next-line no-console
+  console.log(`Santry running on http://localhost:${port}/`);
+});

packages/integration-tests/fixtures/error-no-handler/input/bundle.js

@@ -0,0 +1,2 @@
+// eslint-disable-next-line no-console
+console.log("whatever");

packages/integration-tests/fixtures/error-no-handler/setup.ts

@@ -0,0 +1,112 @@
+import * as vite from "vite";
+import * as path from "path";
+import * as rollup from "rollup";
+import { default as webpack4 } from "webpack4";
+import { webpack as webpack5 } from "webpack5";
+import * as esbuild from "esbuild";
+import { Options } from "@sentry/bundler-plugin-core";
+import { sentryVitePlugin } from "@sentry/vite-plugin";
+import { sentryWebpackPlugin } from "@sentry/webpack-plugin";
+import { sentryEsbuildPlugin } from "@sentry/esbuild-plugin";
+import { sentryRollupPlugin } from "@sentry/rollup-plugin";
+
+// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+const nodejsMajorversion = process.version.split(".")[0]!.slice(1);
+
+export async function createCjsBundles(
+  entrypoints: { [name: string]: string },
+  outFolder: string,
+  sentryUnpluginOptions: Options,
+  plugins: string[] = []
+): Promise<void> {
+  if (plugins.length === 0 || plugins.includes("vite")) {
+    await vite.build({
+      clearScreen: false,
+      build: {
+        sourcemap: true,
+        outDir: path.join(outFolder, "vite"),
+        rollupOptions: {
+          input: entrypoints,
+          output: {
+            format: "cjs",
+            entryFileNames: "[name].js",
+          },
+        },
+      },
+      plugins: [sentryVitePlugin(sentryUnpluginOptions)],
+    });
+  }
+  if (plugins.length === 0 || plugins.includes("rollup")) {
+    await rollup
+      .rollup({
+        input: entrypoints,
+        plugins: [sentryRollupPlugin(sentryUnpluginOptions)],
+      })
+      .then((bundle) =>
+        bundle.write({
+          sourcemap: true,
+          dir: path.join(outFolder, "rollup"),
+          format: "cjs",
+          exports: "named",
+        })
+      );
+  }
+
+  if (plugins.length === 0 || plugins.includes("esbuild")) {
+    await esbuild.build({
+      sourcemap: true,
+      entryPoints: entrypoints,
+      outdir: path.join(outFolder, "esbuild"),
+      plugins: [sentryEsbuildPlugin(sentryUnpluginOptions)],
+      minify: true,
+      bundle: true,
+      format: "cjs",
+    });
+  }
+
+  // Webpack 4 doesn't work on Node.js versions >= 18
+  if (parseInt(nodejsMajorversion) < 18 && (plugins.length === 0 || plugins.includes("webpack4"))) {
+    webpack4(
+      {
+        devtool: "source-map",
+        mode: "production",
+        entry: entrypoints,
+        cache: false,
+        output: {
+          path: path.join(outFolder, "webpack4"),
+          libraryTarget: "commonjs",
+        },
+        target: "node", // needed for webpack 4 so we can access node api
+        plugins: [sentryWebpackPlugin(sentryUnpluginOptions)],
+      },
+      (err) => {
+        if (err) {
+          throw err;
+        }
+      }
+    );
+  }
+
+  if (plugins.length === 0 || plugins.includes("webpack5")) {
+    webpack5(
+      {
+        devtool: "source-map",
+        cache: false,
+        entry: entrypoints,
+        output: {
+          path: path.join(outFolder, "webpack5"),
+          library: {
+            type: "commonjs",
+          },
+        },
+        mode: "production",
+        plugins: [sentryWebpackPlugin(sentryUnpluginOptions)],
+      },
+      (err) => {
+        if (err) {
+          throw err;
+        }
+      }
+    );
+  }
+}