@sentry/bundler-plugin-core 2.1.0 → 2.2.1

package/dist/esm/index.mjs

@@ -12,6 +12,7 @@ import childProcess from 'child_process';
 import { glob } from 'glob';
 import * as util from 'util';
 import { promisify } from 'util';
+import { dynamicSamplingContextToSentryBaggageHeader } from '@sentry/utils';
 import { NodeClient, defaultStackParser, makeNodeTransport, Hub } from '@sentry/node';
 
 function ownKeys(object, enumerableOnly) {
@@ -671,16 +672,22 @@ function createDebugIdUploadFunction(_ref) {
     deleteFilesAfterUpload = _ref.deleteFilesAfterUpload;
   return /*#__PURE__*/function () {
     var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(buildArtifactPaths) {
-      var folderToCleanUp, cliInstance, tmpUploadFolder, globAssets, debugIdChunkFilePaths, filePathsToDelete;
+      var artifactBundleUploadTransaction, folderToCleanUp, mkdtempSpan, tmpUploadFolder, globAssets, globSpan, globResult, debugIdChunkFilePaths, prepareSpan, files, stats, uploadSize, uploadSpan, cliInstance, deleteGlobSpan, filePathsToDelete, deleteSpan, cleanupSpan;
       return _regeneratorRuntime().wrap(function _callee2$(_context2) {
         while (1) switch (_context2.prev = _context2.next) {
           case 0:
-            cliInstance = new SentryCli(null, sentryCliOptions);
+            artifactBundleUploadTransaction = sentryHub.startTransaction({
+              name: "debug-id-sourcemap-upload"
+            });
             _context2.prev = 1;
-            _context2.next = 4;
+            mkdtempSpan = artifactBundleUploadTransaction.startChild({
+              description: "mkdtemp"
+            });
+            _context2.next = 5;
             return fs__default.promises.mkdtemp(path__default.join(os.tmpdir(), "sentry-bundler-plugin-upload-"));
-          case 4:
+          case 5:
             tmpUploadFolder = _context2.sent;
+            mkdtempSpan.finish();
             folderToCleanUp = tmpUploadFolder;
             if (assets) {
               globAssets = assets;
@@ -688,33 +695,41 @@ function createDebugIdUploadFunction(_ref) {
               logger.debug("No `sourcemaps.assets` option provided, falling back to uploading detected build artifacts.");
               globAssets = buildArtifactPaths;
             }
-            _context2.next = 9;
+            globSpan = artifactBundleUploadTransaction.startChild({
+              description: "glob"
+            });
+            _context2.next = 12;
             return glob(globAssets, {
               absolute: true,
               nodir: true,
               ignore: ignore
             });
-          case 9:
-            debugIdChunkFilePaths = _context2.sent.filter(function (debugIdChunkFilePath) {
+          case 12:
+            globResult = _context2.sent;
+            globSpan.finish();
+            debugIdChunkFilePaths = globResult.filter(function (debugIdChunkFilePath) {
               return debugIdChunkFilePath.endsWith(".js") || debugIdChunkFilePath.endsWith(".mjs") || debugIdChunkFilePath.endsWith(".cjs");
             });
             if (!(Array.isArray(assets) && assets.length === 0)) {
-              _context2.next = 14;
+              _context2.next = 19;
               break;
             }
             logger.debug("Empty `sourcemaps.assets` option provided. Will not upload sourcemaps with debug ID.");
-            _context2.next = 22;
+            _context2.next = 41;
             break;
-          case 14:
+          case 19:
             if (!(debugIdChunkFilePaths.length === 0)) {
-              _context2.next = 18;
+              _context2.next = 23;
               break;
             }
             logger.warn("Didn't find any matching sources for debug ID upload. Please check the `sourcemaps.assets` option.");
-            _context2.next = 22;
+            _context2.next = 41;
             break;
-          case 18:
-            _context2.next = 20;
+          case 23:
+            prepareSpan = artifactBundleUploadTransaction.startChild({
+              description: "prepare-bundles"
+            });
+            _context2.next = 26;
             return Promise.all(debugIdChunkFilePaths.map( /*#__PURE__*/function () {
               var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(chunkFilePath, chunkIndex) {
                 return _regeneratorRuntime().wrap(function _callee$(_context) {
@@ -732,8 +747,35 @@ function createDebugIdUploadFunction(_ref) {
                 return _ref3.apply(this, arguments);
               };
             }()));
-          case 20:
-            _context2.next = 22;
+          case 26:
+            prepareSpan.finish();
+            _context2.next = 29;
+            return fs__default.promises.readdir(tmpUploadFolder);
+          case 29:
+            files = _context2.sent;
+            stats = files.map(function (file) {
+              return fs__default.promises.stat(path__default.join(tmpUploadFolder, file));
+            });
+            _context2.next = 33;
+            return Promise.all(stats);
+          case 33:
+            uploadSize = _context2.sent.reduce(function (accumulator, _ref4) {
+              var size = _ref4.size;
+              return accumulator + size;
+            }, 0);
+            artifactBundleUploadTransaction.setMeasurement("files", files.length, "none");
+            artifactBundleUploadTransaction.setMeasurement("upload_size", uploadSize, "byte");
+            uploadSpan = artifactBundleUploadTransaction.startChild({
+              description: "upload"
+            });
+            cliInstance = new SentryCli(null, _objectSpread2(_objectSpread2({}, sentryCliOptions), {}, {
+              headers: _objectSpread2({
+                "sentry-trace": uploadSpan.toTraceparent(),
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                baggage: dynamicSamplingContextToSentryBaggageHeader(artifactBundleUploadTransaction.getDynamicSamplingContext())
+              }, sentryCliOptions.headers)
+            }));
+            _context2.next = 40;
             return cliInstance.releases.uploadSourceMaps(releaseName !== null && releaseName !== void 0 ? releaseName : "undefined",
             // unfortunetly this needs a value for now but it will not matter since debug IDs overpower releases anyhow
             {
@@ -744,52 +786,71 @@ function createDebugIdUploadFunction(_ref) {
               }],
               useArtifactBundle: true
             });
-          case 22:
+          case 40:
+            uploadSpan.finish();
+          case 41:
             if (!deleteFilesAfterUpload) {
-              _context2.next = 29;
+              _context2.next = 52;
               break;
             }
-            _context2.next = 25;
+            deleteGlobSpan = artifactBundleUploadTransaction.startChild({
+              description: "delete-glob"
+            });
+            _context2.next = 45;
             return glob(deleteFilesAfterUpload, {
               absolute: true,
               nodir: true
             });
-          case 25:
+          case 45:
             filePathsToDelete = _context2.sent;
+            deleteGlobSpan.finish();
             filePathsToDelete.forEach(function (filePathToDelete) {
               logger.debug("Deleting asset after upload: ".concat(filePathToDelete));
             });
-            _context2.next = 29;
+            deleteSpan = artifactBundleUploadTransaction.startChild({
+              description: "delete-files-after-upload"
+            });
+            _context2.next = 51;
             return Promise.all(filePathsToDelete.map(function (filePathToDelete) {
               return fs__default.promises.rm(filePathToDelete, {
                 force: true
               });
             }));
-          case 29:
-            _context2.next = 37;
+          case 51:
+            deleteSpan.finish();
+          case 52:
+            _context2.next = 58;
             break;
-          case 31:
-            _context2.prev = 31;
+          case 54:
+            _context2.prev = 54;
             _context2.t0 = _context2["catch"](1);
-            sentryHub.captureException('Error in "debugIdUploadPlugin" writeBundle hook');
-            _context2.next = 36;
-            return sentryClient.flush();
-          case 36:
+            sentryHub.withScope(function (scope) {
+              scope.setSpan(artifactBundleUploadTransaction);
+              sentryHub.captureException('Error in "debugIdUploadPlugin" writeBundle hook');
+            });
             handleRecoverableError(_context2.t0);
-          case 37:
-            _context2.prev = 37;
+          case 58:
+            _context2.prev = 58;
             if (folderToCleanUp) {
+              cleanupSpan = artifactBundleUploadTransaction.startChild({
+                description: "cleanup"
+              });
               void fs__default.promises.rm(folderToCleanUp, {
                 recursive: true,
                 force: true
               });
+              cleanupSpan.finish();
             }
-            return _context2.finish(37);
-          case 40:
+            artifactBundleUploadTransaction.finish();
+            _context2.next = 63;
+            return sentryClient.flush();
+          case 63:
+            return _context2.finish(58);
+          case 64:
           case "end":
             return _context2.stop();
         }
-      }, _callee2, null, [[1, 31, 37, 40]]);
+      }, _callee2, null, [[1, 54, 58, 64]]);
     }));
     return function (_x) {
       return _ref2.apply(this, arguments);
@@ -837,7 +898,7 @@ function _prepareBundleForDebugIdUpload() {
           bundleContent += "\n//# debugId=".concat(debugId);
           writeSourceFilePromise = fs__default.promises.writeFile(path__default.join(uploadFolder, "".concat(uniqueUploadName, ".js")), bundleContent, "utf-8");
           writeSourceMapFilePromise = determineSourceMapPathFromBundle(bundleFilePath, bundleContent, logger).then( /*#__PURE__*/function () {
-            var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(sourceMapPath) {
+            var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(sourceMapPath) {
               return _regeneratorRuntime().wrap(function _callee3$(_context3) {
                 while (1) switch (_context3.prev = _context3.next) {
                   case 0:
@@ -856,7 +917,7 @@ function _prepareBundleForDebugIdUpload() {
               }, _callee3);
             }));
             return function (_x17) {
-              return _ref4.apply(this, arguments);
+              return _ref5.apply(this, arguments);
             };
           }());
           return _context4.abrupt("return", Promise.all([writeSourceFilePromise, writeSourceMapFilePromise]));
@@ -920,7 +981,7 @@ function _determineSourceMapPathFromBundle() {
           _context5.t0 = _context5["catch"](8);
         case 17:
           // This is just a debug message because it can be quite spammy for some frameworks
-          logger.debug("Could not determine source map path for bundle: ".concat(bundlePath));
+          logger.debug("Could not determine source map path for bundle: ".concat(bundlePath, " - Did you turn on source map generation in your bundler?"));
           return _context5.abrupt("return", undefined);
         case 19:
         case "end":
@@ -1105,29 +1166,31 @@ function releaseManagementPlugin(_ref) {
 }
 
 function telemetryPlugin(_ref) {
-  var sentryClient = _ref.sentryClient,
-    pluginExecutionTransaction = _ref.pluginExecutionTransaction,
+  var sentryHub = _ref.sentryHub,
+    sentryClient = _ref.sentryClient,
     shouldSendTelemetry = _ref.shouldSendTelemetry,
     logger = _ref.logger;
   return {
     name: "sentry-telemetry-plugin",
     buildStart: function buildStart() {
-      void shouldSendTelemetry.then(function (willSendTelemetry) {
-        if (willSendTelemetry) {
-          logger.info("Sending error and performance telemetry data to Sentry. To disable telemetry, set `options.telemetry` to `false`.");
-        }
-      });
-      pluginExecutionTransaction.startTimestamp = Date.now() / 1000;
-    },
-    writeBundle: function writeBundle() {
       return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              pluginExecutionTransaction.finish();
-              _context.next = 3;
-              return sentryClient.flush();
-            case 3:
+              _context.next = 2;
+              return shouldSendTelemetry;
+            case 2:
+              if (!_context.sent) {
+                _context.next = 7;
+                break;
+              }
+              logger.info("Sending error and performance telemetry data to Sentry. To disable telemetry, set `options.telemetry` to `false`.");
+              sentryHub.startTransaction({
+                name: "Sentry Bundler Plugin execution"
+              }).finish();
+              _context.next = 7;
+              return sentryClient.flush(3000);
+            case 7:
             case "end":
               return _context.stop();
           }
@@ -1188,7 +1251,7 @@ function createSentryInstance(options, shouldSendTelemetry, bundler) {
     dsn: "https://4c2bae7d9fbc413e8f7385f55c515d51@o1.ingest.sentry.io/6690737",
     tracesSampleRate: 1,
     sampleRate: 1,
-    release: "2.1.0",
+    release: "2.2.1",
     integrations: [],
     tracePropagationTargets: ["sentry.io/api"],
     stackParser: defaultStackParser,
@@ -1254,35 +1317,27 @@ function setTelemetryDataOnHub(options, hub, bundler) {
     release = options.release,
     errorHandler = options.errorHandler,
     sourcemaps = options.sourcemaps;
+  hub.setTag("upload-legacy-sourcemaps", !!release.uploadLegacySourcemaps);
   if (release.uploadLegacySourcemaps) {
     hub.setTag("uploadLegacySourcemapsEntries", Array.isArray(release.uploadLegacySourcemaps) ? release.uploadLegacySourcemaps.length : 1);
   }
 
   // Optional release pipeline steps
-  if (release.cleanArtifacts) {
-    hub.setTag("clean-artifacts", true);
-  }
+  hub.setTag("clean-artifacts", release.cleanArtifacts);
   if (release.setCommits) {
     hub.setTag("set-commits", release.setCommits.auto === true ? "auto" : "manual");
+  } else {
+    hub.setTag("set-commits", "undefined");
   }
-  if (release.finalize) {
-    hub.setTag("finalize-release", true);
-  }
-  if (release.deploy) {
-    hub.setTag("add-deploy", true);
-  }
+  hub.setTag("finalize-release", release.finalize);
+  hub.setTag("deploy-options", !!release.deploy);
 
   // Miscelaneous options
-  if (errorHandler) {
-    hub.setTag("error-handler", "custom");
-  }
-  if (sourcemaps !== null && sourcemaps !== void 0 && sourcemaps.assets) {
-    hub.setTag("debug-id-upload", true);
-  }
-  if (sourcemaps !== null && sourcemaps !== void 0 && sourcemaps.deleteFilesAfterUpload) {
-    hub.setTag("delete-after-upload", true);
-  }
+  hub.setTag("custom-error-handler", !!errorHandler);
+  hub.setTag("sourcemaps-assets", !!(sourcemaps !== null && sourcemaps !== void 0 && sourcemaps.assets));
+  hub.setTag("delete-after-upload", !!(sourcemaps !== null && sourcemaps !== void 0 && sourcemaps.deleteFilesAfterUpload));
   hub.setTag("node", process.version);
+  hub.setTag("platform", process.platform);
   hub.setTags({
     organization: org,
     project: project,
@@ -1395,25 +1450,44 @@ function sentryUnpluginFactory(_ref) {
     var _createSentryInstance = createSentryInstance(options, shouldSendTelemetry, unpluginMetaContext.framework),
       sentryHub = _createSentryInstance.sentryHub,
       sentryClient = _createSentryInstance.sentryClient;
-    var pluginExecutionTransaction = sentryHub.startTransaction({
-      name: "Sentry Bundler Plugin execution"
+    var sentrySession = sentryHub.startSession();
+    sentryHub.captureSession();
+    var sentEndSession = false; // Just to prevent infinite loops with beforeExit, which is called whenever the event loop empties out
+    // We also need to manually end sesisons on errors because beforeExit is not called on crashes
+    process.on("beforeExit", function () {
+      if (!sentEndSession) {
+        sentryHub.endSession();
+        sentEndSession = true;
+      }
     });
-    sentryHub.getScope().setSpan(pluginExecutionTransaction);
     var logger = createLogger({
       prefix: "[sentry-".concat(unpluginMetaContext.framework, "-plugin]"),
       silent: options.silent,
       debug: options.debug
     });
+
+    // Set the User-Agent that Sentry CLI will use when interacting with Sentry
+    process.env["SENTRY_PIPELINE"] = "".concat(unpluginMetaContext.framework, "-plugin/", "2.2.1");
     function handleRecoverableError(unknownError) {
-      pluginExecutionTransaction.setStatus("internal_error");
-      if (options.errorHandler) {
-        if (unknownError instanceof Error) {
-          options.errorHandler(unknownError);
+      sentrySession.status = "abnormal";
+      try {
+        if (options.errorHandler) {
+          try {
+            if (unknownError instanceof Error) {
+              options.errorHandler(unknownError);
+            } else {
+              options.errorHandler(new Error("An unknown error occured"));
+            }
+          } catch (e) {
+            sentrySession.status = "crashed";
+            throw e;
+          }
         } else {
-          options.errorHandler(new Error("An unknown error occured"));
+          sentrySession.status = "crashed";
+          throw unknownError;
         }
-      } else {
-        throw unknownError;
+      } finally {
+        sentryHub.endSession();
       }
     }
     if (!validateOptions(options, logger)) {
@@ -1424,10 +1498,10 @@ function sentryUnpluginFactory(_ref) {
     }
     var plugins = [];
     plugins.push(telemetryPlugin({
-      pluginExecutionTransaction: pluginExecutionTransaction,
+      sentryClient: sentryClient,
+      sentryHub: sentryHub,
       logger: logger,
-      shouldSendTelemetry: shouldSendTelemetry,
-      sentryClient: sentryClient
+      shouldSendTelemetry: shouldSendTelemetry
     }));
     if (!options.release.inject) {
       logger.debug("Release injection disabled via `release.inject` option. Will not inject release.");
@@ -1597,11 +1671,10 @@ function createRollupDebugIdInjectionHooks() {
         var commentUseStrictRegex =
         // Note: CodeQL complains that this regex potentially has n^2 runtime. This likely won't affect realistic files.
         /^(?:\s*|\/\*(?:.|\r|\n)*\*\/|\/\/.*[\n\r])*(?:"[^"]*";|'[^']*';)?/;
-        if ((_code$match = code.match(commentUseStrictRegex)) !== null && _code$match !== void 0 && _code$match[0]) {
+        var match = (_code$match = code.match(commentUseStrictRegex)) === null || _code$match === void 0 ? void 0 : _code$match[0];
+        if (match) {
           // Add injected code after any comments or "use strict" at the beginning of the bundle.
-          ms.replace(commentUseStrictRegex, function (match) {
-            return "".concat(match).concat(codeToInject);
-          });
+          ms.appendLeft(match.length, codeToInject);
         } else {
           // ms.replace() doesn't work when there is an empty string match (which happens if
           // there is neither, a comment, nor a "use strict" at the top of the chunk) so we