@sentry/bundler-plugin-core 4.0.2 → 4.1.1

package/dist/cjs/index.js

@@ -433,6 +433,31 @@ function _defineProperty(obj, key, value) {
   }
   return obj;
 }
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _toPrimitive(input, hint) {
   if (typeof input !== "object" || input === null) return input;
   var prim = input[Symbol.toPrimitive];
@@ -2537,6 +2562,15 @@ function objectToBaggageHeader(object) {
   }, '');
 }
 
+// eslint-disable-next-line @sentry-internal/sdk/no-regexp-constructor -- RegExp is used for readability here
+const TRACEPARENT_REGEXP = new RegExp(
+  '^[ \\t]*' + // whitespace
+    '([0-9a-f]{32})?' + // trace_id
+    '-?([0-9a-f]{16})?' + // span_id
+    '-?([01])?' + // sampled
+    '[ \\t]*$', // whitespace
+);
+
 /**
  * Create sentry-trace header from span context values.
  */
@@ -7612,6 +7646,82 @@ function applySdkMetadata(options, name, names = [name], source = 'npm') {
   options._metadata = metadata;
 }
 
+/**
+ * Extracts trace propagation data from the current span or from the client's scope (via transaction or propagation
+ * context) and serializes it to `sentry-trace` and `baggage` values to strings. These values can be used to propagate
+ * a trace via our tracing Http headers or Html `<meta>` tags.
+ *
+ * This function also applies some validation to the generated sentry-trace and baggage values to ensure that
+ * only valid strings are returned.
+ *
+ * @returns an object with the tracing data values. The object keys are the name of the tracing key to be used as header
+ * or meta tag name.
+ */
+function getTraceData() {
+  const carrier = getMainCarrier();
+  const acs = getAsyncContextStrategy(carrier);
+  if (acs.getTraceData) {
+    return acs.getTraceData();
+  }
+
+  const client = getClient();
+  const scope = getCurrentScope();
+  const span = getActiveSpan();
+
+  const { dsc, sampled, traceId } = scope.getPropagationContext();
+  const rootSpan = span && getRootSpan(span);
+
+  const sentryTrace = span ? spanToTraceHeader(span) : generateSentryTraceHeader(traceId, undefined, sampled);
+
+  const dynamicSamplingContext = rootSpan
+    ? getDynamicSamplingContextFromSpan(rootSpan)
+    : dsc
+      ? dsc
+      : client
+        ? getDynamicSamplingContextFromClient(traceId, client)
+        : undefined;
+
+  const baggage = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);
+
+  const isValidSentryTraceHeader = TRACEPARENT_REGEXP.test(sentryTrace);
+  if (!isValidSentryTraceHeader) {
+    logger.warn('Invalid sentry-trace data. Cannot generate trace data');
+    return {};
+  }
+
+  const validBaggage = isValidBaggageString(baggage);
+  if (!validBaggage) {
+    logger.warn('Invalid baggage data. Not returning "baggage" value');
+  }
+
+  return {
+    'sentry-trace': sentryTrace,
+    ...(validBaggage && { baggage }),
+  };
+}
+
+/**
+ * Tests string against baggage spec as defined in:
+ *
+ * - W3C Baggage grammar: https://www.w3.org/TR/baggage/#definition
+ * - RFC7230 token definition: https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.6
+ *
+ * exported for testing
+ */
+function isValidBaggageString(baggage) {
+  if (!baggage || !baggage.length) {
+    return false;
+  }
+  const keyRegex = "[-!#$%&'*+.^_`|~A-Za-z0-9]+";
+  const valueRegex = '[!#-+-./0-9:<=>?@A-Z\\[\\]a-z{-}]+';
+  const spaces = '\\s*';
+  // eslint-disable-next-line @sentry-internal/sdk/no-regexp-constructor -- RegExp for readability, no user input
+  const baggageRegex = new RegExp(
+    `^${keyRegex}${spaces}=${spaces}${valueRegex}(${spaces},${spaces}${keyRegex}${spaces}=${spaces}${valueRegex})*$`,
+  );
+  return baggageRegex.test(baggage);
+}
+
 /**
  * Checks whether the given input is already an array, and if it isn't, wraps it in one.
  *
@@ -7853,13 +7963,13 @@ function generateGlobalInjectorCode(_ref2) {
     injectBuildInformation = _ref2.injectBuildInformation;
   // The code below is mostly ternary operators because it saves bundle size.
   // The checks are to support as many environments as possible. (Node.js, Browser, webworkers, etc.)
-  var code = "!function(){var e=\"undefined\"!=typeof window?window:\"undefined\"!=typeof global?global:\"undefined\"!=typeof globalThis?globalThis:\"undefined\"!=typeof self?self:{};";
+  var code = "!function(){try{var e=\"undefined\"!=typeof window?window:\"undefined\"!=typeof global?global:\"undefined\"!=typeof globalThis?globalThis:\"undefined\"!=typeof self?self:{};";
   code += "e.SENTRY_RELEASE={id:".concat(JSON.stringify(release), "};");
   if (injectBuildInformation) {
     var buildInfo = getBuildInformation();
     code += "e.SENTRY_BUILD_INFO=".concat(JSON.stringify(buildInfo), ";");
   }
-  code += "}();";
+  code += "}catch(e){}}();";
   return code;
 }
 
@@ -7868,7 +7978,8 @@ function generateModuleMetadataInjectorCode(metadata) {
   // The code below is mostly ternary operators because it saves bundle size.
   // The checks are to support as many environments as possible. (Node.js, Browser, webworkers, etc.)
   // We are merging the metadata objects in case modules are bundled twice with the plugin
-  return "!function(){var e=\"undefined\"!=typeof window?window:\"undefined\"!=typeof global?global:\"undefined\"!=typeof globalThis?globalThis:\"undefined\"!=typeof self?self:{};e._sentryModuleMetadata=e._sentryModuleMetadata||{},e._sentryModuleMetadata[(new e.Error).stack]=function(e){for(var n=1;n<arguments.length;n++){var a=arguments[n];if(null!=a)for(var t in a)a.hasOwnProperty(t)&&(e[t]=a[t])}return e}({},e._sentryModuleMetadata[(new e.Error).stack],".concat(JSON.stringify(metadata), ")}();");
+  // Use try-catch to avoid issues when bundlers rename global variables like 'window' to 'k'
+  return "!function(){try{var e=\"undefined\"!=typeof window?window:\"undefined\"!=typeof global?global:\"undefined\"!=typeof globalThis?globalThis:\"undefined\"!=typeof self?self:{};e._sentryModuleMetadata=e._sentryModuleMetadata||{},e._sentryModuleMetadata[(new e.Error).stack]=function(e){for(var n=1;n<arguments.length;n++){var a=arguments[n];if(null!=a)for(var t in a)a.hasOwnProperty(t)&&(e[t]=a[t])}return e}({},e._sentryModuleMetadata[(new e.Error).stack],".concat(JSON.stringify(metadata), ")}catch(e){}}();");
 }
 function getBuildInformation() {
   var packageJson = getPackageJson();
@@ -8196,7 +8307,7 @@ function createSentryInstance(options, shouldSendTelemetry, buildTool) {
     dsn: "https://4c2bae7d9fbc413e8f7385f55c515d51@o1.ingest.sentry.io/6690737",
     tracesSampleRate: 1,
     sampleRate: 1,
-    release: "4.0.2",
+    release: "4.1.1",
     integrations: [],
     tracePropagationTargets: ["sentry.io/api"],
     stackParser: stackParser,
@@ -8633,6 +8744,18 @@ function defaultRewriteSourcesHook(source) {
   }
 }
 
+function createCliInstance(options) {
+  return new SentryCli__default["default"](null, {
+    authToken: options.authToken,
+    org: options.org,
+    project: options.project,
+    silent: options.silent,
+    url: options.url,
+    vcsRemote: options.release.vcsRemote,
+    headers: _objectSpread2({}, getTraceData())
+  });
+}
+
 /**
  * Creates a build plugin manager that exposes primitives for everything that a Sentry JavaScript SDK or build tooling may do during a build.
  *
@@ -8737,7 +8860,22 @@ function createSentryBuildPluginManager(userOptions, bundlerPluginMetaContext) {
         return function () {
           /* noop */
         };
-      }
+      },
+      injectDebugIds: function () {
+        var _injectDebugIds = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
+          return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+            while (1) switch (_context5.prev = _context5.next) {
+              case 0:
+              case "end":
+                return _context5.stop();
+            }
+          }, _callee5);
+        }));
+        function injectDebugIds() {
+          return _injectDebugIds.apply(this, arguments);
+        }
+        return injectDebugIds;
+      }()
     };
   }
   var shouldSendTelemetry = allowedToSendTelemetry(options);
@@ -8772,7 +8910,7 @@ function createSentryBuildPluginManager(userOptions, bundlerPluginMetaContext) {
   });
 
   // Set the User-Agent that Sentry CLI will use when interacting with Sentry
-  process.env["SENTRY_PIPELINE"] = "".concat(bundlerPluginMetaContext.buildTool, "-plugin/", "4.0.2");
+  process.env["SENTRY_PIPELINE"] = "".concat(bundlerPluginMetaContext.buildTool, "-plugin/", "4.1.1");
 
   // Not a bulletproof check but should be good enough to at least sometimes determine
   // if the plugin is called in dev/watch mode or for a  prod build. The important part
@@ -8933,15 +9071,15 @@ function createSentryBuildPluginManager(userOptions, bundlerPluginMetaContext) {
        * Emits a `Sentry Bundler Plugin execution` signal.
        */
       emitBundlerPluginExecutionSignal: function emitBundlerPluginExecutionSignal() {
-        return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
-          return _regeneratorRuntime().wrap(function _callee5$(_context5) {
-            while (1) switch (_context5.prev = _context5.next) {
+        return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
+          return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+            while (1) switch (_context6.prev = _context6.next) {
               case 0:
-                _context5.next = 2;
+                _context6.next = 2;
                 return shouldSendTelemetry;
               case 2:
-                if (!_context5.sent) {
-                  _context5.next = 7;
+                if (!_context6.sent) {
+                  _context6.next = 7;
                   break;
                 }
                 logger.info("Sending telemetry data on issues and performance to Sentry. To disable telemetry, set `options.telemetry` to `false`.");
@@ -8951,13 +9089,13 @@ function createSentryBuildPluginManager(userOptions, bundlerPluginMetaContext) {
                 }, function () {
                   //
                 });
-                _context5.next = 7;
+                _context6.next = 7;
                 return safeFlushTelemetry(sentryClient);
               case 7:
               case "end":
-                return _context5.stop();
+                return _context6.stop();
             }
-          }, _callee5);
+          }, _callee6);
         }))();
       }
     },
@@ -8971,68 +9109,60 @@ function createSentryBuildPluginManager(userOptions, bundlerPluginMetaContext) {
      * - adds deploy information
      */
     createRelease: function createRelease() {
-      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7() {
         var freeWriteBundleInvocationDependencyOnSourcemapFiles, cliInstance, normalizedInclude;
-        return _regeneratorRuntime().wrap(function _callee6$(_context6) {
-          while (1) switch (_context6.prev = _context6.next) {
+        return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
             case 0:
               if (options.release.name) {
-                _context6.next = 5;
+                _context7.next = 5;
                 break;
               }
               logger.debug("No release name provided. Will not create release. Please set the `release.name` option to identify your release.");
-              return _context6.abrupt("return");
+              return _context7.abrupt("return");
             case 5:
               if (!isDevMode) {
-                _context6.next = 10;
+                _context7.next = 10;
                 break;
               }
               logger.debug("Running in development mode. Will not create release.");
-              return _context6.abrupt("return");
+              return _context7.abrupt("return");
             case 10:
               if (options.authToken) {
-                _context6.next = 15;
+                _context7.next = 15;
                 break;
               }
               logger.warn("No auth token provided. Will not create release. Please set the `authToken` option. You can find information on how to generate a Sentry auth token here: https://docs.sentry.io/api/auth/" + getTurborepoEnvPassthroughWarning("SENTRY_AUTH_TOKEN"));
-              return _context6.abrupt("return");
+              return _context7.abrupt("return");
             case 15:
               if (!(!options.org && !options.authToken.startsWith("sntrys_"))) {
-                _context6.next = 20;
+                _context7.next = 20;
                 break;
               }
               logger.warn("No organization slug provided. Will not create release. Please set the `org` option to your Sentry organization slug." + getTurborepoEnvPassthroughWarning("SENTRY_ORG"));
-              return _context6.abrupt("return");
+              return _context7.abrupt("return");
             case 20:
               if (options.project) {
-                _context6.next = 23;
+                _context7.next = 23;
                 break;
               }
               logger.warn("No project provided. Will not create release. Please set the `project` option to your Sentry project slug." + getTurborepoEnvPassthroughWarning("SENTRY_PROJECT"));
-              return _context6.abrupt("return");
+              return _context7.abrupt("return");
             case 23:
               // It is possible that this writeBundle hook is called multiple times in one build (for example when reusing the plugin, or when using build tooling like `@vitejs/plugin-legacy`)
               // Therefore we need to actually register the execution of this hook as dependency on the sourcemap files.
               freeWriteBundleInvocationDependencyOnSourcemapFiles = createDependencyOnBuildArtifacts();
-              _context6.prev = 24;
-              cliInstance = new SentryCli__default["default"](null, {
-                authToken: options.authToken,
-                org: options.org,
-                project: options.project,
-                silent: options.silent,
-                url: options.url,
-                vcsRemote: options.release.vcsRemote,
-                headers: options.headers
-              });
+              _context7.prev = 24;
+              cliInstance = createCliInstance(options);
               if (!options.release.create) {
-                _context6.next = 29;
+                _context7.next = 29;
                 break;
               }
-              _context6.next = 29;
+              _context7.next = 29;
               return cliInstance.releases["new"](options.release.name);
             case 29:
               if (!options.release.uploadLegacySourcemaps) {
-                _context6.next = 33;
+                _context7.next = 33;
                 break;
               }
               normalizedInclude = arrayify(options.release.uploadLegacySourcemaps).map(function (includeItem) {
@@ -9049,7 +9179,7 @@ function createSentryBuildPluginManager(userOptions, bundlerPluginMetaContext) {
                   ignore: includeEntry.ignore ? arrayify(includeEntry.ignore) : undefined
                 });
               });
-              _context6.next = 33;
+              _context7.next = 33;
               return cliInstance.releases.uploadSourceMaps(options.release.name, {
                 include: normalizedInclude,
                 dist: options.release.dist,
@@ -9059,124 +9189,176 @@ function createSentryBuildPluginManager(userOptions, bundlerPluginMetaContext) {
               });
             case 33:
               if (!(options.release.setCommits !== false)) {
-                _context6.next = 46;
+                _context7.next = 46;
                 break;
               }
-              _context6.prev = 34;
-              _context6.next = 37;
+              _context7.prev = 34;
+              _context7.next = 37;
               return cliInstance.releases.setCommits(options.release.name,
               // set commits always exists due to the normalize function
               // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
               options.release.setCommits);
             case 37:
-              _context6.next = 46;
+              _context7.next = 46;
               break;
             case 39:
-              _context6.prev = 39;
-              _context6.t0 = _context6["catch"](34);
+              _context7.prev = 39;
+              _context7.t0 = _context7["catch"](34);
               if (!(options.release.setCommits && "shouldNotThrowOnFailure" in options.release.setCommits && options.release.setCommits.shouldNotThrowOnFailure)) {
-                _context6.next = 45;
+                _context7.next = 45;
                 break;
               }
-              logger.debug("An error occurred setting commits on release (this message can be ignored unless you commits on release are desired):", _context6.t0);
-              _context6.next = 46;
+              logger.debug("An error occurred setting commits on release (this message can be ignored unless you commits on release are desired):", _context7.t0);
+              _context7.next = 46;
               break;
             case 45:
-              throw _context6.t0;
+              throw _context7.t0;
             case 46:
               if (!options.release.finalize) {
-                _context6.next = 49;
+                _context7.next = 49;
                 break;
               }
-              _context6.next = 49;
+              _context7.next = 49;
               return cliInstance.releases.finalize(options.release.name);
             case 49:
               if (!options.release.deploy) {
-                _context6.next = 52;
+                _context7.next = 52;
                 break;
               }
-              _context6.next = 52;
+              _context7.next = 52;
               return cliInstance.releases.newDeploy(options.release.name, options.release.deploy);
             case 52:
-              _context6.next = 60;
+              _context7.next = 60;
               break;
             case 54:
-              _context6.prev = 54;
-              _context6.t1 = _context6["catch"](24);
+              _context7.prev = 54;
+              _context7.t1 = _context7["catch"](24);
               sentryScope.captureException('Error in "releaseManagementPlugin" writeBundle hook');
-              _context6.next = 59;
+              _context7.next = 59;
               return safeFlushTelemetry(sentryClient);
             case 59:
-              handleRecoverableError(_context6.t1, false);
+              handleRecoverableError(_context7.t1, false);
             case 60:
-              _context6.prev = 60;
+              _context7.prev = 60;
               freeWriteBundleInvocationDependencyOnSourcemapFiles();
-              return _context6.finish(60);
+              return _context7.finish(60);
             case 63:
             case "end":
-              return _context6.stop();
+              return _context7.stop();
           }
-        }, _callee6, null, [[24, 54, 60, 63], [34, 39]]);
+        }, _callee7, null, [[24, 54, 60, 63], [34, 39]]);
+      }))();
+    },
+    /*
+      Injects debug IDs into the build artifacts.
+       This is a separate function from `uploadSourcemaps` because that needs to run before the sourcemaps are uploaded.
+      Usually the respective bundler-plugin will take care of this before the sourcemaps are uploaded.
+      Only use this if you need to manually inject debug IDs into the build artifacts.
+    */
+    injectDebugIds: function injectDebugIds(buildArtifactPaths) {
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9() {
+        return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              _context9.next = 2;
+              return startSpan({
+                name: "inject-debug-ids",
+                scope: sentryScope,
+                forceTransaction: true
+              }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8() {
+                var _options$debug, cliInstance;
+                return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+                  while (1) switch (_context8.prev = _context8.next) {
+                    case 0:
+                      _context8.prev = 0;
+                      cliInstance = createCliInstance(options);
+                      _context8.next = 4;
+                      return cliInstance.execute(["sourcemaps", "inject"].concat(_toConsumableArray(buildArtifactPaths)), (_options$debug = options.debug) !== null && _options$debug !== void 0 ? _options$debug : false);
+                    case 4:
+                      _context8.next = 10;
+                      break;
+                    case 6:
+                      _context8.prev = 6;
+                      _context8.t0 = _context8["catch"](0);
+                      sentryScope.captureException('Error in "debugIdInjectionPlugin" writeBundle hook');
+                      handleRecoverableError(_context8.t0, false);
+                    case 10:
+                      _context8.prev = 10;
+                      _context8.next = 13;
+                      return safeFlushTelemetry(sentryClient);
+                    case 13:
+                      return _context8.finish(10);
+                    case 14:
+                    case "end":
+                      return _context8.stop();
+                  }
+                }, _callee8, null, [[0, 6, 10, 14]]);
+              })));
+            case 2:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9);
       }))();
     },
     /**
      * Uploads sourcemaps using the "Debug ID" method. This function takes a list of build artifact paths that will be uploaded
      */
     uploadSourcemaps: function uploadSourcemaps(buildArtifactPaths) {
-      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee15() {
-        return _regeneratorRuntime().wrap(function _callee15$(_context15) {
-          while (1) switch (_context15.prev = _context15.next) {
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee18() {
+        return _regeneratorRuntime().wrap(function _callee18$(_context18) {
+          while (1) switch (_context18.prev = _context18.next) {
             case 0:
               if (canUploadSourceMaps(options, logger, isDevMode)) {
-                _context15.next = 2;
+                _context18.next = 2;
                 break;
               }
-              return _context15.abrupt("return");
+              return _context18.abrupt("return");
             case 2:
-              _context15.next = 4;
+              _context18.next = 4;
               return startSpan(
               // This is `forceTransaction`ed because this span is used in dashboards in the form of indexed transactions.
               {
                 name: "debug-id-sourcemap-upload",
                 scope: sentryScope,
                 forceTransaction: true
-              }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee14() {
+              }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee17() {
                 var folderToCleanUp, freeUploadDependencyOnBuildArtifacts, _options$sourcemaps, tmpUploadFolder, assets, globAssets, globResult, debugIdChunkFilePaths, numUploadedFiles, _process$env2;
-                return _regeneratorRuntime().wrap(function _callee14$(_context14) {
-                  while (1) switch (_context14.prev = _context14.next) {
+                return _regeneratorRuntime().wrap(function _callee17$(_context17) {
+                  while (1) switch (_context17.prev = _context17.next) {
                     case 0:
                       // It is possible that this writeBundle hook (which calls this function) is called multiple times in one build (for example when reusing the plugin, or when using build tooling like `@vitejs/plugin-legacy`)
                       // Therefore we need to actually register the execution of this hook as dependency on the sourcemap files.
                       freeUploadDependencyOnBuildArtifacts = createDependencyOnBuildArtifacts();
-                      _context14.prev = 1;
-                      _context14.next = 4;
+                      _context17.prev = 1;
+                      _context17.next = 4;
                       return startSpan({
                         name: "mkdtemp",
                         scope: sentryScope
-                      }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7() {
+                      }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10() {
                         var _process$env;
-                        return _regeneratorRuntime().wrap(function _callee7$(_context7) {
-                          while (1) switch (_context7.prev = _context7.next) {
+                        return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+                          while (1) switch (_context10.prev = _context10.next) {
                             case 0:
-                              _context7.t0 = (_process$env = process.env) === null || _process$env === void 0 ? void 0 : _process$env["SENTRY_TEST_OVERRIDE_TEMP_DIR"];
-                              if (_context7.t0) {
-                                _context7.next = 5;
+                              _context10.t0 = (_process$env = process.env) === null || _process$env === void 0 ? void 0 : _process$env["SENTRY_TEST_OVERRIDE_TEMP_DIR"];
+                              if (_context10.t0) {
+                                _context10.next = 5;
                                 break;
                               }
-                              _context7.next = 4;
+                              _context10.next = 4;
                               return fs__namespace.promises.mkdtemp(path__namespace.join(os__namespace.tmpdir(), "sentry-bundler-plugin-upload-"));
                             case 4:
-                              _context7.t0 = _context7.sent;
+                              _context10.t0 = _context10.sent;
                             case 5:
-                              return _context7.abrupt("return", _context7.t0);
+                              return _context10.abrupt("return", _context10.t0);
                             case 6:
                             case "end":
-                              return _context7.stop();
+                              return _context10.stop();
                           }
-                        }, _callee7);
+                        }, _callee10);
                       })));
                     case 4:
-                      tmpUploadFolder = _context14.sent;
+                      tmpUploadFolder = _context17.sent;
                       folderToCleanUp = tmpUploadFolder;
                       assets = (_options$sourcemaps = options.sourcemaps) === null || _options$sourcemaps === void 0 ? void 0 : _options$sourcemaps.assets;
                       if (assets) {
@@ -9185,281 +9367,264 @@ function createSentryBuildPluginManager(userOptions, bundlerPluginMetaContext) {
                         logger.debug("No `sourcemaps.assets` option provided, falling back to uploading detected build artifacts.");
                         globAssets = buildArtifactPaths;
                       }
-                      _context14.next = 10;
+                      _context17.next = 10;
                       return startSpan({
                         name: "glob",
                         scope: sentryScope
-                      }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8() {
+                      }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11() {
                         var _options$sourcemaps2;
-                        return _regeneratorRuntime().wrap(function _callee8$(_context8) {
-                          while (1) switch (_context8.prev = _context8.next) {
+                        return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+                          while (1) switch (_context11.prev = _context11.next) {
                             case 0:
-                              _context8.next = 2;
+                              _context11.next = 2;
                               return glob.glob(globAssets, {
                                 absolute: true,
                                 nodir: true,
                                 ignore: (_options$sourcemaps2 = options.sourcemaps) === null || _options$sourcemaps2 === void 0 ? void 0 : _options$sourcemaps2.ignore
                               });
                             case 2:
-                              return _context8.abrupt("return", _context8.sent);
+                              return _context11.abrupt("return", _context11.sent);
                             case 3:
                             case "end":
-                              return _context8.stop();
+                              return _context11.stop();
                           }
-                        }, _callee8);
+                        }, _callee11);
                       })));
                     case 10:
-                      globResult = _context14.sent;
+                      globResult = _context17.sent;
                       debugIdChunkFilePaths = globResult.filter(function (debugIdChunkFilePath) {
                         return !!stripQueryAndHashFromPath(debugIdChunkFilePath).match(/\.(js|mjs|cjs)$/);
                       }); // The order of the files output by glob() is not deterministic
                       // Ensure order within the files so that {debug-id}-{chunkIndex} coupling is consistent
                       debugIdChunkFilePaths.sort();
                       if (!(Array.isArray(assets) && assets.length === 0)) {
-                        _context14.next = 17;
+                        _context17.next = 17;
                         break;
                       }
                       logger.debug("Empty `sourcemaps.assets` option provided. Will not upload sourcemaps with debug ID.");
-                      _context14.next = 25;
+                      _context17.next = 25;
                       break;
                     case 17:
                       if (!(debugIdChunkFilePaths.length === 0)) {
-                        _context14.next = 21;
+                        _context17.next = 21;
                         break;
                       }
                       logger.warn("Didn't find any matching sources for debug ID upload. Please check the `sourcemaps.assets` option.");
-                      _context14.next = 25;
+                      _context17.next = 25;
                       break;
                     case 21:
-                      _context14.next = 23;
+                      _context17.next = 23;
                       return startSpan({
                         name: "prepare-bundles",
                         scope: sentryScope
                       }, /*#__PURE__*/function () {
-                        var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12(prepBundlesSpan) {
+                        var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee15(prepBundlesSpan) {
                           var preparationTasks, workers, worker, workerIndex, files, stats, uploadSize;
-                          return _regeneratorRuntime().wrap(function _callee12$(_context12) {
-                            while (1) switch (_context12.prev = _context12.next) {
+                          return _regeneratorRuntime().wrap(function _callee15$(_context15) {
+                            while (1) switch (_context15.prev = _context15.next) {
                               case 0:
                                 // Preparing the bundles can be a lot of work and doing it all at once has the potential of nuking the heap so
                                 // instead we do it with a maximum of 16 concurrent workers
                                 preparationTasks = debugIdChunkFilePaths.map(function (chunkFilePath, chunkIndex) {
-                                  return /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9() {
+                                  return /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12() {
                                     var _options$sourcemaps$r, _options$sourcemaps3, _options$sourcemaps4;
-                                    return _regeneratorRuntime().wrap(function _callee9$(_context9) {
-                                      while (1) switch (_context9.prev = _context9.next) {
+                                    return _regeneratorRuntime().wrap(function _callee12$(_context12) {
+                                      while (1) switch (_context12.prev = _context12.next) {
                                         case 0:
-                                          _context9.next = 2;
+                                          _context12.next = 2;
                                           return prepareBundleForDebugIdUpload(chunkFilePath, tmpUploadFolder, chunkIndex, logger, (_options$sourcemaps$r = (_options$sourcemaps3 = options.sourcemaps) === null || _options$sourcemaps3 === void 0 ? void 0 : _options$sourcemaps3.rewriteSources) !== null && _options$sourcemaps$r !== void 0 ? _options$sourcemaps$r : defaultRewriteSourcesHook, (_options$sourcemaps4 = options.sourcemaps) === null || _options$sourcemaps4 === void 0 ? void 0 : _options$sourcemaps4.resolveSourceMap);
                                         case 2:
                                         case "end":
-                                          return _context9.stop();
+                                          return _context12.stop();
                                       }
-                                    }, _callee9);
+                                    }, _callee12);
                                   }));
                                 });
                                 workers = [];
                                 worker = /*#__PURE__*/function () {
-                                  var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10() {
+                                  var _ref7 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13() {
                                     var task;
-                                    return _regeneratorRuntime().wrap(function _callee10$(_context10) {
-                                      while (1) switch (_context10.prev = _context10.next) {
+                                    return _regeneratorRuntime().wrap(function _callee13$(_context13) {
+                                      while (1) switch (_context13.prev = _context13.next) {
                                         case 0:
                                           if (!(preparationTasks.length > 0)) {
-                                            _context10.next = 7;
+                                            _context13.next = 7;
                                             break;
                                           }
                                           task = preparationTasks.shift();
                                           if (!task) {
-                                            _context10.next = 5;
+                                            _context13.next = 5;
                                             break;
                                           }
-                                          _context10.next = 5;
+                                          _context13.next = 5;
                                           return task();
                                         case 5:
-                                          _context10.next = 0;
+                                          _context13.next = 0;
                                           break;
                                         case 7:
                                         case "end":
-                                          return _context10.stop();
+                                          return _context13.stop();
                                       }
-                                    }, _callee10);
+                                    }, _callee13);
                                   }));
                                   return function worker() {
-                                    return _ref6.apply(this, arguments);
+                                    return _ref7.apply(this, arguments);
                                   };
                                 }();
                                 for (workerIndex = 0; workerIndex < 16; workerIndex++) {
                                   workers.push(worker());
                                 }
-                                _context12.next = 6;
+                                _context15.next = 6;
                                 return Promise.all(workers);
                               case 6:
-                                _context12.next = 8;
+                                _context15.next = 8;
                                 return fs__namespace.promises.readdir(tmpUploadFolder);
                               case 8:
-                                files = _context12.sent;
+                                files = _context15.sent;
                                 stats = files.map(function (file) {
                                   return fs__namespace.promises.stat(path__namespace.join(tmpUploadFolder, file));
                                 });
-                                _context12.next = 12;
+                                _context15.next = 12;
                                 return Promise.all(stats);
                               case 12:
-                                uploadSize = _context12.sent.reduce(function (accumulator, _ref7) {
-                                  var size = _ref7.size;
+                                uploadSize = _context15.sent.reduce(function (accumulator, _ref8) {
+                                  var size = _ref8.size;
                                   return accumulator + size;
                                 }, 0);
                                 setMeasurement("files", files.length, "none", prepBundlesSpan);
                                 setMeasurement("upload_size", uploadSize, "byte", prepBundlesSpan);
-                                _context12.next = 17;
+                                _context15.next = 17;
                                 return startSpan({
                                   name: "upload",
                                   scope: sentryScope
-                                }, /*#__PURE__*/function () {
-                                  var _ref8 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(uploadSpan) {
-                                    var _options$release$name;
-                                    var cliInstance;
-                                    return _regeneratorRuntime().wrap(function _callee11$(_context11) {
-                                      while (1) switch (_context11.prev = _context11.next) {
-                                        case 0:
-                                          cliInstance = new SentryCli__default["default"](null, {
-                                            authToken: options.authToken,
-                                            org: options.org,
-                                            project: options.project,
-                                            silent: options.silent,
-                                            url: options.url,
-                                            vcsRemote: options.release.vcsRemote,
-                                            headers: _objectSpread2({
-                                              "sentry-trace": spanToTraceHeader(uploadSpan),
-                                              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                                              baggage: dynamicSamplingContextToSentryBaggageHeader(getDynamicSamplingContextFromSpan(uploadSpan))
-                                            }, options.headers)
-                                          });
-                                          _context11.next = 3;
-                                          return cliInstance.releases.uploadSourceMaps((_options$release$name = options.release.name) !== null && _options$release$name !== void 0 ? _options$release$name : "undefined",
-                                          // unfortunately this needs a value for now but it will not matter since debug IDs overpower releases anyhow
-                                          {
-                                            include: [{
-                                              paths: [tmpUploadFolder],
-                                              rewrite: false,
-                                              dist: options.release.dist
-                                            }],
-                                            // We want this promise to throw if the sourcemaps fail to upload so that we know about it.
-                                            // see: https://github.com/getsentry/sentry-cli/pull/2605
-                                            live: "rejectOnError"
-                                          });
-                                        case 3:
-                                        case "end":
-                                          return _context11.stop();
-                                      }
-                                    }, _callee11);
-                                  }));
-                                  return function (_x2) {
-                                    return _ref8.apply(this, arguments);
-                                  };
-                                }());
+                                }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee14() {
+                                  var _options$release$name;
+                                  var cliInstance;
+                                  return _regeneratorRuntime().wrap(function _callee14$(_context14) {
+                                    while (1) switch (_context14.prev = _context14.next) {
+                                      case 0:
+                                        cliInstance = createCliInstance(options);
+                                        _context14.next = 3;
+                                        return cliInstance.releases.uploadSourceMaps((_options$release$name = options.release.name) !== null && _options$release$name !== void 0 ? _options$release$name : "undefined",
+                                        // unfortunately this needs a value for now but it will not matter since debug IDs overpower releases anyhow
+                                        {
+                                          include: [{
+                                            paths: [tmpUploadFolder],
+                                            rewrite: false,
+                                            dist: options.release.dist
+                                          }],
+                                          // We want this promise to throw if the sourcemaps fail to upload so that we know about it.
+                                          // see: https://github.com/getsentry/sentry-cli/pull/2605
+                                          live: "rejectOnError"
+                                        });
+                                      case 3:
+                                      case "end":
+                                        return _context14.stop();
+                                    }
+                                  }, _callee14);
+                                })));
                               case 17:
-                                return _context12.abrupt("return", files.length);
+                                return _context15.abrupt("return", files.length);
                               case 18:
                               case "end":
-                                return _context12.stop();
+                                return _context15.stop();
                             }
-                          }, _callee12);
+                          }, _callee15);
                         }));
                         return function (_x) {
-                          return _ref4.apply(this, arguments);
+                          return _ref5.apply(this, arguments);
                         };
                       }());
                     case 23:
-                      numUploadedFiles = _context14.sent;
+                      numUploadedFiles = _context17.sent;
                       if (numUploadedFiles > 0) {
                         logger.info("Successfully uploaded source maps to Sentry");
                       }
                     case 25:
-                      _context14.next = 31;
+                      _context17.next = 31;
                       break;
                     case 27:
-                      _context14.prev = 27;
-                      _context14.t0 = _context14["catch"](1);
+                      _context17.prev = 27;
+                      _context17.t0 = _context17["catch"](1);
                       sentryScope.captureException('Error in "debugIdUploadPlugin" writeBundle hook');
-                      handleRecoverableError(_context14.t0, false);
+                      handleRecoverableError(_context17.t0, false);
                     case 31:
-                      _context14.prev = 31;
+                      _context17.prev = 31;
                       if (folderToCleanUp && !((_process$env2 = process.env) !== null && _process$env2 !== void 0 && _process$env2["SENTRY_TEST_OVERRIDE_TEMP_DIR"])) {
                         void startSpan({
                           name: "cleanup",
                           scope: sentryScope
-                        }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13() {
-                          return _regeneratorRuntime().wrap(function _callee13$(_context13) {
-                            while (1) switch (_context13.prev = _context13.next) {
+                        }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee16() {
+                          return _regeneratorRuntime().wrap(function _callee16$(_context16) {
+                            while (1) switch (_context16.prev = _context16.next) {
                               case 0:
                                 if (!folderToCleanUp) {
-                                  _context13.next = 3;
+                                  _context16.next = 3;
                                   break;
                                 }
-                                _context13.next = 3;
+                                _context16.next = 3;
                                 return fs__namespace.promises.rm(folderToCleanUp, {
                                   recursive: true,
                                   force: true
                                 });
                               case 3:
                               case "end":
-                                return _context13.stop();
+                                return _context16.stop();
                             }
-                          }, _callee13);
+                          }, _callee16);
                         })));
                       }
                       freeUploadDependencyOnBuildArtifacts();
-                      _context14.next = 36;
+                      _context17.next = 36;
                       return safeFlushTelemetry(sentryClient);
                     case 36:
-                      return _context14.finish(31);
+                      return _context17.finish(31);
                     case 37:
                     case "end":
-                      return _context14.stop();
+                      return _context17.stop();
                   }
-                }, _callee14, null, [[1, 27, 31, 37]]);
+                }, _callee17, null, [[1, 27, 31, 37]]);
               })));
             case 4:
             case "end":
-              return _context15.stop();
+              return _context18.stop();
           }
-        }, _callee15);
+        }, _callee18);
       }))();
     },
     /**
      * Will delete artifacts based on the passed `sourcemaps.filesToDeleteAfterUpload` option.
      */
     deleteArtifacts: function deleteArtifacts() {
-      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee16() {
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee19() {
         var _options$sourcemaps5, filesToDelete, filePathsToDelete;
-        return _regeneratorRuntime().wrap(function _callee16$(_context16) {
-          while (1) switch (_context16.prev = _context16.next) {
+        return _regeneratorRuntime().wrap(function _callee19$(_context19) {
+          while (1) switch (_context19.prev = _context19.next) {
             case 0:
-              _context16.prev = 0;
-              _context16.next = 3;
+              _context19.prev = 0;
+              _context19.next = 3;
               return (_options$sourcemaps5 = options.sourcemaps) === null || _options$sourcemaps5 === void 0 ? void 0 : _options$sourcemaps5.filesToDeleteAfterUpload;
             case 3:
-              filesToDelete = _context16.sent;
+              filesToDelete = _context19.sent;
               if (!(filesToDelete !== undefined)) {
-                _context16.next = 14;
+                _context19.next = 14;
                 break;
               }
-              _context16.next = 7;
+              _context19.next = 7;
               return glob.glob(filesToDelete, {
                 absolute: true,
                 nodir: true
               });
             case 7:
-              filePathsToDelete = _context16.sent;
+              filePathsToDelete = _context19.sent;
               logger.debug("Waiting for dependencies on generated files to be freed before deleting...");
-              _context16.next = 11;
+              _context19.next = 11;
               return waitUntilBuildArtifactDependenciesAreFreed();
             case 11:
               filePathsToDelete.forEach(function (filePathToDelete) {
                 logger.debug("Deleting asset after upload: ".concat(filePathToDelete));
               });
-              _context16.next = 14;
+              _context19.next = 14;
               return Promise.all(filePathsToDelete.map(function (filePathToDelete) {
                 return fs__namespace.promises.rm(filePathToDelete, {
                   force: true
@@ -9469,23 +9634,23 @@ function createSentryBuildPluginManager(userOptions, bundlerPluginMetaContext) {
                 });
               }));
             case 14:
-              _context16.next = 22;
+              _context19.next = 22;
               break;
             case 16:
-              _context16.prev = 16;
-              _context16.t0 = _context16["catch"](0);
+              _context19.prev = 16;
+              _context19.t0 = _context19["catch"](0);
               sentryScope.captureException('Error in "sentry-file-deletion-plugin" buildEnd hook');
-              _context16.next = 21;
+              _context19.next = 21;
               return safeFlushTelemetry(sentryClient);
             case 21:
               // We throw by default if we get here b/c not being able to delete
               // source maps could leak them to production
-              handleRecoverableError(_context16.t0, true);
+              handleRecoverableError(_context19.t0, true);
             case 22:
             case "end":
-              return _context16.stop();
+              return _context19.stop();
           }
-        }, _callee16, null, [[0, 16]]);
+        }, _callee19, null, [[0, 16]]);
       }))();
     },
     createDependencyOnBuildArtifacts: createDependencyOnBuildArtifacts
@@ -9608,14 +9773,16 @@ function sentryUnpluginFactory(_ref) {
         }))();
       }
     });
-    if (!((_options$sourcemaps = options.sourcemaps) !== null && _options$sourcemaps !== void 0 && _options$sourcemaps.disable)) {
+    if (((_options$sourcemaps = options.sourcemaps) === null || _options$sourcemaps === void 0 ? void 0 : _options$sourcemaps.disable) !== true) {
+      var _options$sourcemaps2;
       plugins.push(debugIdInjectionPlugin(logger));
-
-      // This option is only strongly typed for the webpack plugin, where it is used. It has no effect on other plugins
-      var _webpack_forceExitOnBuildComplete = typeof options._experiments["forceExitOnBuildCompletion"] === "boolean" ? options._experiments["forceExitOnBuildCompletion"] : undefined;
-      plugins.push(debugIdUploadPlugin(createDebugIdUploadFunction({
-        sentryBuildPluginManager: sentryBuildPluginManager
-      }), logger, sentryBuildPluginManager.createDependencyOnBuildArtifacts, _webpack_forceExitOnBuildComplete));
+      if (((_options$sourcemaps2 = options.sourcemaps) === null || _options$sourcemaps2 === void 0 ? void 0 : _options$sourcemaps2.disable) !== "disable-upload") {
+        // This option is only strongly typed for the webpack plugin, where it is used. It has no effect on other plugins
+        var _webpack_forceExitOnBuildComplete = typeof options._experiments["forceExitOnBuildCompletion"] === "boolean" ? options._experiments["forceExitOnBuildCompletion"] : undefined;
+        plugins.push(debugIdUploadPlugin(createDebugIdUploadFunction({
+          sentryBuildPluginManager: sentryBuildPluginManager
+        }), logger, sentryBuildPluginManager.createDependencyOnBuildArtifacts, _webpack_forceExitOnBuildComplete));
+      }
     }
     if (options.reactComponentAnnotation) {
       if (!options.reactComponentAnnotation.enabled) {