@sentry/bundler-plugin-core 0.2.0 → 0.2.2

package/dist/cjs/index.js

@@ -4,14 +4,16 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var unplugin$1 = require('unplugin');
 var MagicString = require('magic-string');
+var SentryCli = require('@sentry/cli');
 var node = require('@sentry/node');
 require('@sentry/tracing');
-var SentryCli = require('@sentry/cli');
+var path = require('path');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var MagicString__default = /*#__PURE__*/_interopDefaultLegacy(MagicString);
 var SentryCli__default = /*#__PURE__*/_interopDefaultLegacy(SentryCli);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 
 function _regeneratorRuntime() {
   /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
@@ -358,16 +360,6 @@ function _regeneratorRuntime() {
   }, exports;
 }
 
-function _typeof(obj) {
-  "@babel/helpers - typeof";
-
-  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
-    return typeof obj;
-  } : function (obj) {
-    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-  }, _typeof(obj);
-}
-
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
     var info = gen[key](arg);
@@ -831,12 +823,7 @@ function normalizeUserOptions(userOptions) {
     dist: userOptions.dist,
     errorHandler: userOptions.errorHandler,
     configFile: userOptions.configFile
-  }; // We only want to enable telemetry for SaaS users
-  // This is not the final check (we need to call Sentry CLI at a later point)
-  // but we can already at this point make a first decision.
-  // @see `turnOffTelemetryForSelfHostedSentry` (telemetry.ts) for the second check.
-
-  options.telemetry = options.telemetry && options.url === SENTRY_SAAS_URL;
+  };
   return options;
 }
 /**
@@ -949,30 +936,83 @@ function validateOptions(options, logger) {
   return true;
 }
 
-function makeSentryClient(dsn, telemetryEnabled) {
+var SENTRY_SAAS_HOSTNAME = "sentry.io";
+function makeSentryClient(dsn, allowedToSendTelemetryPromise) {
   var client = new node.NodeClient({
     dsn: dsn,
-    enabled: telemetryEnabled,
-    tracesSampleRate: telemetryEnabled ? 1.0 : 0.0,
-    sampleRate: telemetryEnabled ? 1.0 : 0.0,
-    release: "0.2.0",
-    integrations: [new node.Integrations.Http({
-      tracing: true
-    })],
+    tracesSampleRate: 1,
+    sampleRate: 1,
+    release: "0.2.2",
+    integrations: [],
     tracePropagationTargets: ["sentry.io/api"],
     stackParser: node.defaultStackParser,
-    transport: node.makeNodeTransport
-  });
-  var hub = new node.Hub(client); //TODO: This call is problematic because as soon as we set our hub as the current hub
-  //      we might interfere with other plugins that use Sentry. However, for now, we'll
-  //      leave it in because without it, we can't get distributed traces (which are pretty nice)
-  //      Let's keep it until someone complains about interference.
-  //      The ideal solution would be a code change in the JS SDK but it's not a straight-forward fix.
+    beforeSend: function beforeSend(event) {
+      var _event$exception, _event$exception$valu;
+
+      (_event$exception = event.exception) === null || _event$exception === void 0 ? void 0 : (_event$exception$valu = _event$exception.values) === null || _event$exception$valu === void 0 ? void 0 : _event$exception$valu.forEach(function (exception) {
+        delete exception.stacktrace;
+      });
+      delete event.server_name; // Server name might contain PII
+
+      return event;
+    },
+    beforeSendTransaction: function beforeSendTransaction(event) {
+      delete event.server_name; // Server name might contain PII
 
-  node.makeMain(hub);
+      return event;
+    },
+    // We create a transport that stalls sending events until we know that we're allowed to (i.e. when Sentry CLI told
+    // us that the upload URL is the Sentry SaaS URL)
+    transport: function transport(nodeTransportOptions) {
+      var nodeTransport = node.makeNodeTransport(nodeTransportOptions);
+      return {
+        flush: function flush(timeout) {
+          return nodeTransport.flush(timeout);
+        },
+        send: function () {
+          var _send = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
+            var isAllowedToSend;
+            return _regeneratorRuntime().wrap(function _callee$(_context) {
+              while (1) {
+                switch (_context.prev = _context.next) {
+                  case 0:
+                    _context.next = 2;
+                    return allowedToSendTelemetryPromise;
+
+                  case 2:
+                    isAllowedToSend = _context.sent;
+
+                    if (!isAllowedToSend) {
+                      _context.next = 7;
+                      break;
+                    }
+
+                    return _context.abrupt("return", nodeTransport.send(request));
+
+                  case 7:
+                    return _context.abrupt("return", undefined);
+
+                  case 8:
+                  case "end":
+                    return _context.stop();
+                }
+              }
+            }, _callee);
+          }));
+
+          function send(_x) {
+            return _send.apply(this, arguments);
+          }
+
+          return send;
+        }()
+      };
+    }
+  });
+  var hub = new node.Hub(client);
   return {
-    client: client,
-    hub: hub
+    sentryClient: client,
+    sentryHub: hub
   };
 }
 /**
@@ -994,28 +1034,10 @@ function addSpanToTransaction(ctx, op, description) {
   });
   return span;
 }
-function captureMinimalError(error, hub) {
-  var sentryError;
-
-  if (error && _typeof(error) === "object") {
-    var e = error;
-    sentryError = {
-      name: e.name,
-      message: e.message,
-      stack: e.stack
-    };
-  } else {
-    sentryError = {
-      name: "Error",
-      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-      message: "".concat(error)
-    };
-  }
-
-  hub.captureException(sentryError);
-}
-function addPluginOptionTags(options, hub) {
-  var cleanArtifacts = options.cleanArtifacts,
+function addPluginOptionInformationToHub(options, hub, bundler) {
+  var org = options.org,
+      project = options.project,
+      cleanArtifacts = options.cleanArtifacts,
       finalize = options.finalize,
       setCommits = options.setCommits,
       injectReleasesMap = options.injectReleasesMap,
@@ -1055,90 +1077,155 @@ function addPluginOptionTags(options, hub) {
   }
 
   hub.setTag("node", process.version);
+  hub.setTags({
+    organization: org,
+    project: project,
+    bundler: bundler
+  });
+  hub.setUser({
+    id: org
+  });
 }
-/**
- * Makes a call to SentryCLI to get the Sentry server URL the CLI uses.
- *
- * We need to check and decide to use telemetry based on the CLI's respone to this call
- * because only at this time we checked a possibly existing .sentryclirc file. This file
- * could point to another URL than the default URL.
- */
-
-function turnOffTelemetryForSelfHostedSentry(_x, _x2) {
-  return _turnOffTelemetryForSelfHostedSentry.apply(this, arguments);
+function shouldSendTelemetry(_x2) {
+  return _shouldSendTelemetry.apply(this, arguments);
 }
 
-function _turnOffTelemetryForSelfHostedSentry() {
-  _turnOffTelemetryForSelfHostedSentry = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(cli, hub) {
+function _shouldSendTelemetry() {
+  _shouldSendTelemetry = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(options) {
     var _cliInfo$split$, _cliInfo$split$$repla;
 
-    var cliInfo, url, client;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
+    var silent, org, project, authToken, url, vcsRemote, customHeader, dist, telemetry, dryRun, cli, cliInfo, cliInfoUrl;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
       while (1) {
-        switch (_context.prev = _context.next) {
+        switch (_context2.prev = _context2.next) {
           case 0:
-            _context.next = 2;
-            return cli.execute(["info"], false);
+            silent = options.silent, org = options.org, project = options.project, authToken = options.authToken, url = options.url, vcsRemote = options.vcsRemote, customHeader = options.customHeader, dist = options.dist, telemetry = options.telemetry, dryRun = options.dryRun; // `options.telemetry` defaults to true
 
-          case 2:
-            cliInfo = _context.sent;
-            url = cliInfo === null || cliInfo === void 0 ? void 0 : (_cliInfo$split$ = cliInfo.split(/(\r\n|\n|\r)/)[0]) === null || _cliInfo$split$ === void 0 ? void 0 : (_cliInfo$split$$repla = _cliInfo$split$.replace(/^Sentry Server: /, "")) === null || _cliInfo$split$$repla === void 0 ? void 0 : _cliInfo$split$$repla.trim();
+            if (!(telemetry === false)) {
+              _context2.next = 3;
+              break;
+            }
 
-            if (url !== SENTRY_SAAS_URL) {
-              client = hub.getClient();
+            return _context2.abrupt("return", false);
 
-              if (client) {
-                client.getOptions().enabled = false;
-                client.getOptions().tracesSampleRate = 0;
-                client.getOptions().sampleRate = 0;
-              }
+          case 3:
+            if (!dryRun) {
+              _context2.next = 5;
+              break;
             }
 
+            return _context2.abrupt("return", false);
+
           case 5:
+            if (!(url === SENTRY_SAAS_URL)) {
+              _context2.next = 7;
+              break;
+            }
+
+            return _context2.abrupt("return", true);
+
+          case 7:
+            cli = new SentryCli__default["default"](options.configFile, {
+              url: url,
+              authToken: authToken,
+              org: org,
+              project: project,
+              vcsRemote: vcsRemote,
+              dist: dist,
+              silent: silent,
+              customHeader: customHeader
+            });
+            _context2.prev = 8;
+            _context2.next = 11;
+            return cli.execute(["info"], false);
+
+          case 11:
+            cliInfo = _context2.sent;
+            _context2.next = 17;
+            break;
+
+          case 14:
+            _context2.prev = 14;
+            _context2.t0 = _context2["catch"](8);
+            throw new Error('Sentry CLI "info" command failed, make sure you have an auth token configured, and your `url` option is correct.');
+
+          case 17:
+            cliInfoUrl = (_cliInfo$split$ = cliInfo.split(/(\r\n|\n|\r)/)[0]) === null || _cliInfo$split$ === void 0 ? void 0 : (_cliInfo$split$$repla = _cliInfo$split$.replace(/^Sentry Server: /, "")) === null || _cliInfo$split$$repla === void 0 ? void 0 : _cliInfo$split$$repla.trim();
+
+            if (!(cliInfoUrl === undefined)) {
+              _context2.next = 20;
+              break;
+            }
+
+            return _context2.abrupt("return", false);
+
+          case 20:
+            return _context2.abrupt("return", new URL(cliInfoUrl).hostname === SENTRY_SAAS_HOSTNAME);
+
+          case 21:
           case "end":
-            return _context.stop();
+            return _context2.stop();
         }
       }
-    }, _callee);
+    }, _callee2, null, [[8, 14]]);
   }));
-  return _turnOffTelemetryForSelfHostedSentry.apply(this, arguments);
+  return _shouldSendTelemetry.apply(this, arguments);
 }
 
-function createNewRelease(_x, _x2) {
+function createNewRelease(_x, _x2, _x3) {
   return _createNewRelease.apply(this, arguments);
 }
 
 function _createNewRelease() {
-  _createNewRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(options, ctx) {
+  _createNewRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(options, ctx, releaseName) {
     var span;
     return _regeneratorRuntime().wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
             span = addSpanToTransaction(ctx, "function.plugin.create_release");
-            _context.next = 3;
-            return ctx.cli.releases["new"](options.release);
+            _context.prev = 1;
+            _context.next = 4;
+            return ctx.cli.releases["new"](releaseName);
 
-          case 3:
-            ctx.logger.info("Successfully created release.");
+          case 4:
+            _context.next = 10;
+            break;
+
+          case 6:
+            _context.prev = 6;
+            _context.t0 = _context["catch"](1);
+            ctx.hub.captureException(new Error("CLI Error: Creating new release failed"));
+            throw _context.t0;
+
+          case 10:
+            _context.prev = 10;
             span === null || span === void 0 ? void 0 : span.finish();
+            return _context.finish(10);
 
-          case 5:
+          case 13:
+            ctx.hub.addBreadcrumb({
+              level: "info",
+              message: "Successfully created release."
+            });
+            ctx.logger.info("Successfully created release.");
+
+          case 15:
           case "end":
             return _context.stop();
         }
       }
-    }, _callee);
+    }, _callee, null, [[1, 6, 10, 13]]);
   }));
   return _createNewRelease.apply(this, arguments);
 }
 
-function cleanArtifacts(_x3, _x4) {
+function cleanArtifacts(_x4, _x5, _x6) {
   return _cleanArtifacts.apply(this, arguments);
 }
 
 function _cleanArtifacts() {
-  _cleanArtifacts = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(options, ctx) {
+  _cleanArtifacts = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(options, ctx, releaseName) {
     var span;
     return _regeneratorRuntime().wrap(function _callee2$(_context2) {
       while (1) {
@@ -1154,29 +1241,48 @@ function _cleanArtifacts() {
 
           case 3:
             span = addSpanToTransaction(ctx, "function.plugin.clean_artifacts");
-            _context2.next = 6;
-            return ctx.cli.releases.execute(["releases", "files", options.release, "delete", "--all"], true);
+            _context2.prev = 4;
+            _context2.next = 7;
+            return ctx.cli.releases.execute(["releases", "files", releaseName, "delete", "--all"], true);
 
-          case 6:
-            ctx.logger.info("Successfully cleaned previous artifacts.");
+          case 7:
+            _context2.next = 13;
+            break;
+
+          case 9:
+            _context2.prev = 9;
+            _context2.t0 = _context2["catch"](4);
+            ctx.hub.captureException(new Error("CLI Error: Deleting release files failed"));
+            throw _context2.t0;
+
+          case 13:
+            _context2.prev = 13;
             span === null || span === void 0 ? void 0 : span.finish();
+            return _context2.finish(13);
 
-          case 8:
+          case 16:
+            ctx.hub.addBreadcrumb({
+              level: "info",
+              message: "Successfully cleaned previous artifacts."
+            });
+            ctx.logger.info("Successfully cleaned previous artifacts.");
+
+          case 18:
           case "end":
             return _context2.stop();
         }
       }
-    }, _callee2);
+    }, _callee2, null, [[4, 9, 13, 16]]);
   }));
   return _cleanArtifacts.apply(this, arguments);
 }
 
-function uploadSourceMaps(_x5, _x6) {
+function uploadSourceMaps(_x7, _x8, _x9) {
   return _uploadSourceMaps.apply(this, arguments);
 }
 
 function _uploadSourceMaps() {
-  _uploadSourceMaps = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(options, ctx) {
+  _uploadSourceMaps = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(options, ctx, releaseName) {
     var span;
     return _regeneratorRuntime().wrap(function _callee3$(_context3) {
       while (1) {
@@ -1186,31 +1292,50 @@ function _uploadSourceMaps() {
             ctx.logger.info("Uploading Sourcemaps."); // Since our internal include entries contain all top-level sourcemaps options,
             // we only need to pass the include option here.
 
-            _context3.next = 4;
-            return ctx.cli.releases.uploadSourceMaps(options.release, {
+            _context3.prev = 2;
+            _context3.next = 5;
+            return ctx.cli.releases.uploadSourceMaps(releaseName, {
               include: options.include
             });
 
-          case 4:
-            ctx.logger.info("Successfully uploaded Sourcemaps.");
+          case 5:
+            _context3.next = 11;
+            break;
+
+          case 7:
+            _context3.prev = 7;
+            _context3.t0 = _context3["catch"](2);
+            ctx.hub.captureException(new Error("CLI Error: Uploading source maps failed"));
+            throw _context3.t0;
+
+          case 11:
+            _context3.prev = 11;
             span === null || span === void 0 ? void 0 : span.finish();
+            return _context3.finish(11);
 
-          case 6:
+          case 14:
+            ctx.hub.addBreadcrumb({
+              level: "info",
+              message: "Successfully uploaded source maps."
+            });
+            ctx.logger.info("Successfully uploaded source maps.");
+
+          case 16:
           case "end":
             return _context3.stop();
         }
       }
-    }, _callee3);
+    }, _callee3, null, [[2, 7, 11, 14]]);
   }));
   return _uploadSourceMaps.apply(this, arguments);
 }
 
-function setCommits(_x7, _x8) {
+function setCommits(_x10, _x11, _x12) {
   return _setCommits.apply(this, arguments);
 }
 
 function _setCommits() {
-  _setCommits = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(options, ctx) {
+  _setCommits = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(options, ctx, releaseName) {
     var span, _options$setCommits, auto, repo, commit, previousCommit, ignoreMissing, ignoreEmpty;
 
     return _regeneratorRuntime().wrap(function _callee4$(_context4) {
@@ -1228,8 +1353,9 @@ function _setCommits() {
           case 3:
             span = addSpanToTransaction(ctx, "function.plugin.set_commits");
             _options$setCommits = options.setCommits, auto = _options$setCommits.auto, repo = _options$setCommits.repo, commit = _options$setCommits.commit, previousCommit = _options$setCommits.previousCommit, ignoreMissing = _options$setCommits.ignoreMissing, ignoreEmpty = _options$setCommits.ignoreEmpty;
-            _context4.next = 7;
-            return ctx.cli.releases.setCommits(options.release, {
+            _context4.prev = 5;
+            _context4.next = 8;
+            return ctx.cli.releases.setCommits(releaseName, {
               commit: commit,
               previousCommit: previousCommit,
               repo: repo,
@@ -1238,64 +1364,101 @@ function _setCommits() {
               ignoreEmpty: ignoreEmpty
             });
 
-          case 7:
-            ctx.logger.info("Successfully set commits.");
+          case 8:
+            _context4.next = 14;
+            break;
+
+          case 10:
+            _context4.prev = 10;
+            _context4.t0 = _context4["catch"](5);
+            ctx.hub.captureException(new Error("CLI Error: Setting commits failed"));
+            throw _context4.t0;
+
+          case 14:
+            _context4.prev = 14;
             span === null || span === void 0 ? void 0 : span.finish();
+            return _context4.finish(14);
 
-          case 9:
+          case 17:
+            ctx.logger.info("Successfully set commits.");
+
+          case 18:
           case "end":
             return _context4.stop();
         }
       }
-    }, _callee4);
+    }, _callee4, null, [[5, 10, 14, 17]]);
   }));
   return _setCommits.apply(this, arguments);
 }
 
-function finalizeRelease(_x9, _x10) {
+function finalizeRelease(_x13, _x14, _x15) {
   return _finalizeRelease.apply(this, arguments);
 }
 
 function _finalizeRelease() {
-  _finalizeRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(options, ctx) {
+  _finalizeRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(options, ctx, releaseName) {
     var span;
     return _regeneratorRuntime().wrap(function _callee5$(_context5) {
       while (1) {
         switch (_context5.prev = _context5.next) {
           case 0:
             if (options.finalize) {
-              _context5.next = 3;
+              _context5.next = 4;
               break;
             }
 
+            ctx.hub.addBreadcrumb({
+              level: "info",
+              message: "Skipping release finalization."
+            });
             logger.debug("Skipping release finalization.");
             return _context5.abrupt("return");
 
-          case 3:
+          case 4:
             span = addSpanToTransaction(ctx, "function.plugin.finalize_release");
-            _context5.next = 6;
-            return ctx.cli.releases.finalize(options.release);
+            _context5.prev = 5;
+            _context5.next = 8;
+            return ctx.cli.releases.finalize(releaseName);
 
-          case 6:
-            ctx.logger.info("Successfully finalized release.");
+          case 8:
+            _context5.next = 14;
+            break;
+
+          case 10:
+            _context5.prev = 10;
+            _context5.t0 = _context5["catch"](5);
+            ctx.hub.captureException(new Error("CLI Error: Finalizing release failed"));
+            throw _context5.t0;
+
+          case 14:
+            _context5.prev = 14;
             span === null || span === void 0 ? void 0 : span.finish();
+            return _context5.finish(14);
 
-          case 8:
+          case 17:
+            ctx.hub.addBreadcrumb({
+              level: "info",
+              message: "Successfully finalized release."
+            });
+            ctx.logger.info("Successfully finalized release.");
+
+          case 19:
           case "end":
             return _context5.stop();
         }
       }
-    }, _callee5);
+    }, _callee5, null, [[5, 10, 14, 17]]);
   }));
   return _finalizeRelease.apply(this, arguments);
 }
 
-function addDeploy(_x11, _x12) {
+function addDeploy(_x16, _x17, _x18) {
   return _addDeploy.apply(this, arguments);
 }
 
 function _addDeploy() {
-  _addDeploy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(options, ctx) {
+  _addDeploy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(options, ctx, releaseName) {
     var span, _options$deploy, env, started, finished, time, name, url;
 
     return _regeneratorRuntime().wrap(function _callee6$(_context6) {
@@ -1303,18 +1466,23 @@ function _addDeploy() {
         switch (_context6.prev = _context6.next) {
           case 0:
             if (options.deploy) {
-              _context6.next = 3;
+              _context6.next = 4;
               break;
             }
 
+            ctx.hub.addBreadcrumb({
+              level: "info",
+              message: "Skipping adding deploy info to release."
+            });
             logger.debug("Skipping adding deploy info to release.");
             return _context6.abrupt("return");
 
-          case 3:
+          case 4:
             span = addSpanToTransaction(ctx, "function.plugin.deploy");
             _options$deploy = options.deploy, env = _options$deploy.env, started = _options$deploy.started, finished = _options$deploy.finished, time = _options$deploy.time, name = _options$deploy.name, url = _options$deploy.url;
-            _context6.next = 7;
-            return ctx.cli.releases.newDeploy(options.release, {
+            _context6.prev = 6;
+            _context6.next = 9;
+            return ctx.cli.releases.newDeploy(releaseName, {
               env: env,
               started: started,
               finished: finished,
@@ -1323,29 +1491,39 @@ function _addDeploy() {
               url: url
             });
 
-          case 7:
-            ctx.logger.info("Successfully added deploy.");
+          case 9:
+            _context6.next = 15;
+            break;
+
+          case 11:
+            _context6.prev = 11;
+            _context6.t0 = _context6["catch"](6);
+            ctx.hub.captureException(new Error("CLI Error: Adding deploy info failed"));
+            throw _context6.t0;
+
+          case 15:
+            _context6.prev = 15;
             span === null || span === void 0 ? void 0 : span.finish();
+            return _context6.finish(15);
 
-          case 9:
+          case 18:
+            ctx.hub.addBreadcrumb({
+              level: "info",
+              message: "Successfully added deploy."
+            });
+            ctx.logger.info("Successfully added deploy.");
+
+          case 20:
           case "end":
             return _context6.stop();
         }
       }
-    }, _callee6);
+    }, _callee6, null, [[6, 11, 15, 18]]);
   }));
   return _addDeploy.apply(this, arguments);
 }
 
 function createLogger(options) {
-  function addBreadcrumb(level, message) {
-    options.hub.addBreadcrumb({
-      category: "logger",
-      level: level,
-      message: message
-    });
-  }
-
   return {
     info: function info(message) {
       if (!options.silent) {
@@ -1358,8 +1536,6 @@ function createLogger(options) {
         // eslint-disable-next-line no-console
         (_console = console).log.apply(_console, ["".concat(options.prefix, " Info: ").concat(message)].concat(params));
       }
-
-      addBreadcrumb("info", message);
     },
     warn: function warn(message) {
       if (!options.silent) {
@@ -1372,8 +1548,6 @@ function createLogger(options) {
         // eslint-disable-next-line no-console
         (_console2 = console).log.apply(_console2, ["".concat(options.prefix, " Warning: ").concat(message)].concat(params));
       }
-
-      addBreadcrumb("warning", message);
     },
     error: function error(message) {
       if (!options.silent) {
@@ -1386,8 +1560,6 @@ function createLogger(options) {
         // eslint-disable-next-line no-console
         (_console3 = console).log.apply(_console3, ["".concat(options.prefix, " Error: ").concat(message)].concat(params));
       }
-
-      addBreadcrumb("error", message);
     },
     debug: function debug(message) {
       if (!options.silent && options.debug) {
@@ -1400,8 +1572,6 @@ function createLogger(options) {
         // eslint-disable-next-line no-console
         (_console4 = console).log.apply(_console4, ["".concat(options.prefix, " Debug: ").concat(message)].concat(params));
       }
-
-      addBreadcrumb("debug", message);
     }
   };
 }
@@ -1481,9 +1651,9 @@ function getDryRunCLI(cli, logger) {
   };
 }
 
-// We prefix the polyfill id with \0 to tell other plugins not to try to load or transform it.
 // This hack is taken straight from https://rollupjs.org/guide/en/#resolveid.
 // This probably doesn't work for all bundlers but for rollup it does.
+
 var RELEASE_INJECTOR_ID = "\0sentry-release-injector";
 var ALLOWED_TRANSFORMATION_FILE_ENDINGS = [".js", ".ts", ".jsx", ".tsx", ".cjs", ".mjs"];
 /**
@@ -1516,13 +1686,20 @@ var ALLOWED_TRANSFORMATION_FILE_ENDINGS = [".js", ".ts", ".jsx", ".tsx", ".cjs",
 
 var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext) {
   var internalOptions = normalizeUserOptions(options);
+  var allowedToSendTelemetryPromise = shouldSendTelemetry(internalOptions);
 
-  var _makeSentryClient = makeSentryClient("https://4c2bae7d9fbc413e8f7385f55c515d51@o1.ingest.sentry.io/6690737", internalOptions.telemetry),
-      sentryHub = _makeSentryClient.hub;
+  var _makeSentryClient = makeSentryClient("https://4c2bae7d9fbc413e8f7385f55c515d51@o1.ingest.sentry.io/6690737", allowedToSendTelemetryPromise),
+      sentryHub = _makeSentryClient.sentryHub,
+      sentryClient = _makeSentryClient.sentryClient;
 
-  addPluginOptionTags(internalOptions, sentryHub);
+  addPluginOptionInformationToHub(internalOptions, sentryHub, unpluginMetaContext.framework); //TODO: This call is problematic because as soon as we set our hub as the current hub
+  //      we might interfere with other plugins that use Sentry. However, for now, we'll
+  //      leave it in because without it, we can't get distributed traces (which are pretty nice)
+  //      Let's keep it until someone complains about interference.
+  //      The ideal solution would be a code change in the JS SDK but it's not a straight-forward fix.
+
+  node.makeMain(sentryHub);
   var logger = createLogger({
-    hub: sentryHub,
     prefix: "[sentry-".concat(unpluginMetaContext.framework, "-plugin]"),
     silent: internalOptions.silent,
     debug: internalOptions.debug
@@ -1533,19 +1710,12 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
   }
 
   var cli = getSentryCli(internalOptions, logger);
-
-  if (internalOptions.telemetry) {
-    logger.info("Sending error and performance telemetry data to Sentry.");
-    logger.info("To disable telemetry, set `options.telemetry` to `false`.");
-  }
-
-  sentryHub.setTags({
-    organization: internalOptions.org,
-    project: internalOptions.project,
-    bundler: unpluginMetaContext.framework
-  });
-  sentryHub.setUser({
-    id: internalOptions.org
+  var releaseNamePromise = new Promise(function (resolve) {
+    if (options.release) {
+      resolve(options.release);
+    } else {
+      resolve(cli.releases.proposeVersion());
+    }
   });
   var transaction;
   var releaseInjectionSpan;
@@ -1559,29 +1729,41 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
      */
     buildStart: function buildStart() {
       return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        var isAllowedToSendToSendTelemetry, releaseName;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) {
             switch (_context.prev = _context.next) {
               case 0:
-                _context.next = 2;
-                return turnOffTelemetryForSelfHostedSentry(cli, sentryHub);
-
-              case 2:
-                if (internalOptions.release) {
-                  _context.next = 6;
-                  break;
+                logger.debug("Called 'buildStart'");
+                _context.next = 3;
+                return allowedToSendTelemetryPromise;
+
+              case 3:
+                isAllowedToSendToSendTelemetry = _context.sent;
+
+                if (isAllowedToSendToSendTelemetry) {
+                  logger.info("Sending error and performance telemetry data to Sentry.");
+                  logger.info("To disable telemetry, set `options.telemetry` to `false`.");
+                  sentryHub.addBreadcrumb({
+                    level: "info",
+                    message: "Telemetry enabled."
+                  });
+                } else {
+                  sentryHub.addBreadcrumb({
+                    level: "info",
+                    message: "Telemetry disabled. This should never show up in a Sentry event."
+                  });
                 }
 
-                _context.next = 5;
-                return cli.releases.proposeVersion();
+                _context.next = 7;
+                return releaseNamePromise;
 
-              case 5:
-                internalOptions.release = _context.sent;
+              case 7:
+                releaseName = _context.sent;
 
-              case 6:
                 // At this point, we either have determined a release or we have to bail
-                if (!internalOptions.release) {
-                  handleError(new Error("Unable to determine a release name. Make sure to set the `release` option or use an environment that supports auto-detection https://docs.sentry.io/cli/releases/#creating-releases`"), logger, internalOptions.errorHandler, sentryHub);
+                if (!releaseName) {
+                  handleError(new Error("Unable to determine a release name. Make sure to set the `release` option or use an environment that supports auto-detection https://docs.sentry.io/cli/releases/#creating-releases`"), logger, internalOptions.errorHandler);
                 }
 
                 transaction = sentryHub.startTransaction({
@@ -1595,7 +1777,7 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
                   cli: cli
                 }, "function.plugin.inject_release", "Release injection");
 
-              case 9:
+              case 11:
               case "end":
                 return _context.stop();
             }
@@ -1617,10 +1799,10 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
      */
     resolveId: function resolveId(id, importer, _ref) {
       var isEntry = _ref.isEntry;
-      sentryHub.addBreadcrumb({
-        category: "resolveId",
-        message: "isEntry: ".concat(String(isEntry)),
-        level: "info"
+      logger.debug('Called "resolveId":', {
+        id: id,
+        importer: importer,
+        isEntry: isEntry
       });
 
       if (id === RELEASE_INJECTOR_ID) {
@@ -1630,9 +1812,9 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
       }
     },
     loadInclude: function loadInclude(id) {
-      logger.info("Called \"loadInclude\": ".concat(JSON.stringify({
+      logger.debug('Called "loadInclude":', {
         id: id
-      })));
+      });
       return id === RELEASE_INJECTOR_ID;
     },
 
@@ -1644,21 +1826,47 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
      * @returns The global injector code when we load the "sentry-release-injector" module. Otherwise returns `undefined`.
      */
     load: function load(id) {
-      sentryHub.addBreadcrumb({
-        category: "load",
-        level: "info"
-      });
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                logger.debug('Called "load":', {
+                  id: id
+                });
 
-      if (id === RELEASE_INJECTOR_ID) {
-        return generateGlobalInjectorCode({
-          release: internalOptions.release,
-          injectReleasesMap: internalOptions.injectReleasesMap,
-          org: internalOptions.org,
-          project: internalOptions.project
-        });
-      } else {
-        return undefined;
-      }
+                if (!(id === RELEASE_INJECTOR_ID)) {
+                  _context2.next = 13;
+                  break;
+                }
+
+                _context2.t0 = generateGlobalInjectorCode;
+                _context2.next = 5;
+                return releaseNamePromise;
+
+              case 5:
+                _context2.t1 = _context2.sent;
+                _context2.t2 = internalOptions.injectReleasesMap;
+                _context2.t3 = internalOptions.org;
+                _context2.t4 = internalOptions.project;
+                _context2.t5 = {
+                  release: _context2.t1,
+                  injectReleasesMap: _context2.t2,
+                  org: _context2.t3,
+                  project: _context2.t4
+                };
+                return _context2.abrupt("return", (0, _context2.t0)(_context2.t5));
+
+              case 13:
+                return _context2.abrupt("return", undefined);
+
+              case 14:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }))();
     },
 
     /**
@@ -1670,32 +1878,35 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
      * want to transform the release injector file.
      */
     transformInclude: function transformInclude(id) {
-      sentryHub.addBreadcrumb({
-        category: "transformInclude",
-        level: "info"
-      }); // We don't want to transform our injected code.
+      logger.debug('Called "transformInclude":', {
+        id: id
+      }); // We normalize the id because vite always passes `id` as a unix style path which causes problems when a user passes
+      // a windows style path to `releaseInjectionTargets`
 
-      if (id === RELEASE_INJECTOR_ID) {
+      var normalizedId = path__default["default"].normalize(id); // We don't want to transform our injected code.
+
+      if (normalizedId === RELEASE_INJECTOR_ID) {
         return false;
       }
 
       if (internalOptions.releaseInjectionTargets) {
         // If there's an `releaseInjectionTargets` option transform (ie. inject the release varible) when the file path matches the option.
         if (typeof internalOptions.releaseInjectionTargets === "function") {
-          return internalOptions.releaseInjectionTargets(id);
+          return internalOptions.releaseInjectionTargets(normalizedId);
         }
 
         return internalOptions.releaseInjectionTargets.some(function (entry) {
           if (entry instanceof RegExp) {
-            return entry.test(id);
+            return entry.test(normalizedId);
           } else {
-            return id === entry;
+            var normalizedEntry = path__default["default"].normalize(entry);
+            return normalizedId === normalizedEntry;
           }
         });
       } else {
-        var pathIsOrdinary = !id.includes("?") && !id.includes("#");
+        var pathIsOrdinary = !normalizedId.includes("?") && !normalizedId.includes("#");
         var pathHasAllowedFileEnding = ALLOWED_TRANSFORMATION_FILE_ENDINGS.some(function (allowedFileEnding) {
-          return id.endsWith(allowedFileEnding);
+          return normalizedId.endsWith(allowedFileEnding);
         });
         return pathIsOrdinary && pathHasAllowedFileEnding;
       }
@@ -1709,10 +1920,9 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
      * @param id Always the absolute (fully resolved) path to the module.
      * @returns transformed code + source map
      */
-    transform: function transform(code) {
-      sentryHub.addBreadcrumb({
-        category: "transform",
-        level: "info"
+    transform: function transform(code, id) {
+      logger.debug('Called "transform":', {
+        id: id
       }); // The MagicString library allows us to generate sourcemaps for the changes we make to the user code.
 
       var ms = new MagicString__default["default"](code); // Appending instead of prepending has less probability of mucking with user's source maps.
@@ -1738,69 +1948,121 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
      * Sentry.io, uploading sourcemaps, associating commits and deploys and finalizing the release)
      */
     writeBundle: function writeBundle() {
-      var _releaseInjectionSpan;
-
-      (_releaseInjectionSpan = releaseInjectionSpan) === null || _releaseInjectionSpan === void 0 ? void 0 : _releaseInjectionSpan.finish();
-      var releasePipelineSpan = transaction && addSpanToTransaction({
-        hub: sentryHub,
-        parentSpan: transaction,
-        logger: logger,
-        cli: cli
-      }, "function.plugin.release", "Release pipeline");
-      sentryHub.addBreadcrumb({
-        category: "writeBundle:start",
-        level: "info"
-      });
-      var ctx = {
-        hub: sentryHub,
-        parentSpan: releasePipelineSpan,
-        logger: logger,
-        cli: cli
-      };
-      createNewRelease(internalOptions, ctx).then(function () {
-        return cleanArtifacts(internalOptions, ctx);
-      }).then(function () {
-        return uploadSourceMaps(internalOptions, ctx);
-      }).then(function () {
-        return setCommits(internalOptions, ctx);
-      }).then(function () {
-        return finalizeRelease(internalOptions, ctx);
-      }).then(function () {
-        return addDeploy(internalOptions, ctx);
-      }).then(function () {
-        var _transaction;
-
-        return (_transaction = transaction) === null || _transaction === void 0 ? void 0 : _transaction.setStatus("ok");
-      })["catch"](function (e) {
-        var _transaction2;
-
-        (_transaction2 = transaction) === null || _transaction2 === void 0 ? void 0 : _transaction2.setStatus("cancelled");
-        handleError(e, logger, internalOptions.errorHandler, sentryHub);
-      })["finally"](function () {
-        var _transaction3;
-
-        sentryHub.addBreadcrumb({
-          category: "writeBundle:finish",
-          level: "info"
-        });
-        releasePipelineSpan === null || releasePipelineSpan === void 0 ? void 0 : releasePipelineSpan.finish();
-        (_transaction3 = transaction) === null || _transaction3 === void 0 ? void 0 : _transaction3.finish();
-      });
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+        var _releaseInjectionSpan;
+
+        var releasePipelineSpan, ctx, releaseName, _transaction, _transaction2, _transaction3;
+
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                logger.debug('Called "writeBundle"');
+                (_releaseInjectionSpan = releaseInjectionSpan) === null || _releaseInjectionSpan === void 0 ? void 0 : _releaseInjectionSpan.finish();
+                releasePipelineSpan = transaction && addSpanToTransaction({
+                  hub: sentryHub,
+                  parentSpan: transaction,
+                  logger: logger,
+                  cli: cli
+                }, "function.plugin.release", "Release pipeline");
+                sentryHub.addBreadcrumb({
+                  category: "writeBundle:start",
+                  level: "info"
+                });
+                ctx = {
+                  hub: sentryHub,
+                  parentSpan: releasePipelineSpan,
+                  logger: logger,
+                  cli: cli
+                };
+                _context3.next = 7;
+                return releaseNamePromise;
+
+              case 7:
+                releaseName = _context3.sent;
+                _context3.prev = 8;
+                _context3.next = 11;
+                return createNewRelease(internalOptions, ctx, releaseName);
+
+              case 11:
+                _context3.next = 13;
+                return cleanArtifacts(internalOptions, ctx, releaseName);
+
+              case 13:
+                _context3.next = 15;
+                return uploadSourceMaps(internalOptions, ctx, releaseName);
+
+              case 15:
+                _context3.next = 17;
+                return setCommits(internalOptions, ctx, releaseName);
+
+              case 17:
+                _context3.next = 19;
+                return finalizeRelease(internalOptions, ctx, releaseName);
+
+              case 19:
+                _context3.next = 21;
+                return addDeploy(internalOptions, ctx, releaseName);
+
+              case 21:
+                (_transaction = transaction) === null || _transaction === void 0 ? void 0 : _transaction.setStatus("ok");
+                _context3.next = 29;
+                break;
+
+              case 24:
+                _context3.prev = 24;
+                _context3.t0 = _context3["catch"](8);
+                (_transaction2 = transaction) === null || _transaction2 === void 0 ? void 0 : _transaction2.setStatus("cancelled");
+                sentryHub.addBreadcrumb({
+                  level: "error",
+                  message: "Error during writeBundle"
+                });
+                handleError(_context3.t0, logger, internalOptions.errorHandler);
+
+              case 29:
+                _context3.prev = 29;
+                releasePipelineSpan === null || releasePipelineSpan === void 0 ? void 0 : releasePipelineSpan.finish();
+                (_transaction3 = transaction) === null || _transaction3 === void 0 ? void 0 : _transaction3.finish();
+                _context3.next = 34;
+                return sentryClient.flush().then(null, function () {
+                  logger.warn("Sending of telemetry failed");
+                });
+
+              case 34:
+                return _context3.finish(29);
+
+              case 35:
+                sentryHub.addBreadcrumb({
+                  category: "writeBundle:finish",
+                  level: "info"
+                });
+
+              case 36:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, null, [[8, 24, 29, 35]]);
+      }))();
     }
   };
 });
 
-function handleError(error, logger, errorHandler, sentryHub) {
-  logger.error(error.message);
-
-  if (sentryHub) {
-    captureMinimalError(error, sentryHub);
+function handleError(unknownError, logger, errorHandler) {
+  if (unknownError instanceof Error) {
+    logger.error(unknownError.message);
+  } else {
+    logger.error(String(unknownError));
   }
 
   if (errorHandler) {
-    errorHandler(error);
+    if (unknownError instanceof Error) {
+      errorHandler(unknownError);
+    } else {
+      errorHandler(new Error("An unknown error occured"));
+    }
   } else {
-    throw error;
+    throw unknownError;
   }
 }
 /**