feat(core): Add injectRelease and uploadSourceMaps options (#190)

Co-authored-by: Luca Forstner <[email protected]>

Author: Alexandre Soro

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

@@ -225,6 +225,10 @@ const unplugin = createUnplugin<Options>((options, unpluginMetaContext) => {
     async transform(code, id) {
       logger.debug('Called "transform":', { id });
 
+      if (!internalOptions.injectRelease) {
+        return;
+      }
+
       // The MagicString library allows us to generate sourcemaps for the changes we make to the user code.
       const ms = new MagicString(code);
 

packages/bundler-plugin-core/src/options-mapping.ts

@@ -13,6 +13,8 @@ type RequiredInternalOptions = Required<
     | "telemetry"
     | "injectReleasesMap"
     | "_experiments"
+    | "injectRelease"
+    | "uploadSourceMaps"
   >
 >;
 
@@ -90,6 +92,8 @@ export function normalizeUserOptions(userOptions: UserOptions): InternalOptions
     silent: userOptions.silent ?? false,
     telemetry: userOptions.telemetry ?? true,
     injectReleasesMap: userOptions.injectReleasesMap ?? false,
+    injectRelease: userOptions.injectRelease ?? true,
+    uploadSourceMaps: userOptions.uploadSourceMaps ?? true,
     _experiments: userOptions._experiments ?? {},
 
     // These options and can also be set via env variables or the config file.

packages/bundler-plugin-core/src/sentry/releasePipeline.ts

@@ -61,6 +61,11 @@ export async function uploadSourceMaps(
   ctx: BuildContext,
   releaseName: string
 ): Promise<void> {
+  if (!options.uploadSourceMaps) {
+    logger.debug("Skipping source maps upload.");
+    return;
+  }
+
   const span = addSpanToTransaction(ctx, "function.plugin.upload_sourcemaps");
   ctx.logger.info("Uploading Sourcemaps.");
 

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

@@ -190,6 +190,13 @@ export type Options = Omit<IncludeEntry, "paths"> & {
    */
   configFile?: string;
 
+  /**
+   * Whether the plugin should inject release information into the build.
+   *
+   * Defaults to `true`.
+   */
+  injectRelease?: boolean;
+
   /**
    * If set to true, the plugin will inject an additional `SENTRY_RELEASES` variable that
    * maps from `{org}@{project}` to the `release` value. This might be helpful for webpack
@@ -199,6 +206,13 @@ export type Options = Omit<IncludeEntry, "paths"> & {
    */
   injectReleasesMap?: boolean;
 
+  /**
+   * Whether the plugin should upload source maps to Sentry.
+   *
+   * Defaults to `true`.
+   */
+  uploadSourceMaps?: boolean;
+
   /**
    * These options are considered experimental and subject to change.
    *

packages/bundler-plugin-core/test/option-mappings.test.ts

@@ -33,7 +33,9 @@ describe("normalizeUserOptions()", () => {
       release: "my-release",
       silent: false,
       telemetry: true,
+      injectRelease: true,
       injectReleasesMap: false,
+      uploadSourceMaps: true,
       _experiments: {},
       url: "https://sentry.io",
     });
@@ -77,7 +79,9 @@ describe("normalizeUserOptions()", () => {
       release: "my-release",
       silent: false,
       telemetry: true,
+      injectRelease: true,
       injectReleasesMap: false,
+      uploadSourceMaps: true,
       _experiments: {},
       url: "https://sentry.io",
     });

packages/bundler-plugin-core/test/sentry/releasePipeline.test.ts

@@ -1,4 +1,4 @@
-import { InternalOptions } from "../../src/options-mapping";
+import { InternalOptions, normalizeUserOptions } from "../../src/options-mapping";
 import {
   addDeploy,
   cleanArtifacts,
@@ -93,16 +93,32 @@ describe("Release Pipeline", () => {
   });
 
   describe("uploadSourceMaps", () => {
-    it("makes a call to Sentry CLI's sourcemaps upload command", async () => {
-      const options = {
+    it("doesn't do anything if uploadSourceMaps option is `false`", async () => {
+      const options = normalizeUserOptions({
+        uploadSourceMaps: false,
         include: [{ paths: ["dist"] }],
-      } as InternalOptions;
+      });
 
       await uploadSourceMaps(options, ctx as unknown as BuildContext, "1.0.0");
 
-      expect(mockedCLI.releases.uploadSourceMaps).toHaveBeenCalledWith("1.0.0", {
+      expect(mockedCLI.releases.uploadSourceMaps).not.toHaveBeenCalled();
+      expect(mockedAddSpanToTxn).not.toHaveBeenCalled();
+      expect(mockedChildSpan.finish).not.toHaveBeenCalled();
+    });
+
+    it("makes a call to Sentry CLI's sourcemaps upload command", async () => {
+      const options = normalizeUserOptions({
         include: [{ paths: ["dist"] }],
       });
+
+      await uploadSourceMaps(options, ctx as unknown as BuildContext, "1.0.0");
+
+      expect(mockedCLI.releases.uploadSourceMaps).toHaveBeenCalledWith(
+        "1.0.0",
+        expect.objectContaining({
+          include: [expect.objectContaining({ paths: ["dist"] })],
+        })
+      );
       expect(mockedAddSpanToTxn).toHaveBeenCalledWith(ctx, "function.plugin.upload_sourcemaps");
       expect(mockedChildSpan.finish).toHaveBeenCalled();
     });

packages/esbuild-plugin/README.md

@@ -83,7 +83,9 @@ The Sentry Esbuild Plugin takes an options argument with the following propertie
 | errorHandler                         | `function(err: Error): void`                                               | optional | When an error occurs during rlease creation or sourcemaps upload, the plugin will call this function. By default, the plugin will simply throw an error, thereby stopping the bundling process. If an `errorHandler` callback is provided, compilation will continue, unless an error is thrown in the provided callback.                                                                                                                                                                                                                                                                                                                                                                    |
 | setCommits                           | `Object`                                                                   | optional | Associates the release with its commits in Sentry. See [table below](#setCommits) for details.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | deploy                               | `Object`                                                                   | optional | Adds deployment information to the release in Sentry. See [table below](#deploy) for details.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| injectRelease                        | `boolean`                                                                  | optional | Whether the plugin should inject release information into the build. Defaults to `true`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | injectReleasesMap                    | `boolean`                                                                  | optional | If set to true, the plugin will inject an additional `SENTRY_RELEASES` variable that maps from `{org}@{project}` to the `release` value. This might be helpful for webpack module federation or micro frontend setups. Defaults to `false`.                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| uploadSourceMaps                     | `boolean`                                                                  | optional | Whether the plugin should upload source maps to Sentry. Defaults to `true`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | telemetry                            | `boolean`                                                                  | optional | If set to true, internal plugin errors and performance data will be sent to Sentry. At Sentry we like to use Sentry ourselves to deliver faster and more stable products. We're very careful of what we're sending. We won't collect anything other than error and high-level performance data. We will never collect your code or any details of the projects in which you're using this plugin. Defaults to `true`.                                                                                                                                                                                                                                                                        |
 | \_experiments.injectBuildInformation | `boolean`                                                                  | optional | If set to true, the plugin will inject an additional `SENTRY_BUILD_INFO` variable that contains information about the build that can be used to improve SDK functionality. Defaults to `false`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 

packages/integration-tests/fixtures/disabled-release-injection/disabled-release-injection.test.ts

@@ -0,0 +1,39 @@
+import childProcess from "child_process";
+import path from "path";
+import { testIfNodeMajorVersionIsLessThan18 } from "../../utils/testIf";
+
+/**
+ * Runs a node file in a seprate process.
+ *
+ * @param bundlePath Path of node file to run
+ * @returns Stdout of the process
+ */
+function checkBundle(bundlePath: string): void {
+  const processOutput = childProcess.execSync(`node ${bundlePath}`, { encoding: "utf-8" });
+  expect(processOutput).toBe("");
+}
+
+test("esbuild bundle", () => {
+  expect.assertions(1);
+  checkBundle(path.join(__dirname, "out", "esbuild", "index.js"));
+});
+
+test("rollup bundle", () => {
+  expect.assertions(1);
+  checkBundle(path.join(__dirname, "out", "rollup", "index.js"));
+});
+
+test("vite bundle", () => {
+  expect.assertions(1);
+  checkBundle(path.join(__dirname, "out", "vite", "index.js"));
+});
+
+testIfNodeMajorVersionIsLessThan18("webpack 4 bundle", () => {
+  expect.assertions(1);
+  checkBundle(path.join(__dirname, "out", "webpack4", "index.js"));
+});
+
+test("webpack 5 bundle", () => {
+  expect.assertions(1);
+  checkBundle(path.join(__dirname, "out", "webpack5", "index.js"));
+});

packages/integration-tests/fixtures/disabled-release-injection/input/entrypoint.js

@@ -0,0 +1,2 @@
+// eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+process.stdout.write((global.SENTRY_RELEASE || {}).id || "");

packages/integration-tests/fixtures/disabled-release-injection/setup.ts

@@ -0,0 +1,16 @@
+import { Options } from "@sentry/bundler-plugin-core";
+import * as path from "path";
+import { createCjsBundles } from "../../utils/create-cjs-bundles";
+
+const entryPointPath = path.resolve(__dirname, "input", "entrypoint.js");
+const outputDir = path.resolve(__dirname, "out");
+
+createCjsBundles({ index: entryPointPath }, outputDir, {
+  release: "I AM A RELEASE!",
+  project: "releasesProject",
+  org: "releasesOrg",
+  include: outputDir,
+  dryRun: true,
+  injectRelease: false,
+  injectReleasesMap: true,
+} as Options);