@sentry/bundler-plugin-core 0.1.0 → 0.2.1

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 */
@@ -827,29 +829,25 @@ function normalizeUserOptions(userOptions) {
     // Optional options
     setCommits: userOptions.setCommits,
     deploy: userOptions.deploy,
-    entries: normalizeEntries(userOptions.entries),
+    releaseInjectionTargets: normalizeReleaseInjectionTargets(userOptions.releaseInjectionTargets),
     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;
 }
 /**
- * Converts the user-facing `entries` option to the internal `entries` option
+ * Converts the user-facing `releaseInjectionTargets` option to the internal
+ * `releaseInjectionTargets` option
  */
 
-function normalizeEntries(userEntries) {
-  if (userEntries === undefined) {
+function normalizeReleaseInjectionTargets(userReleaseInjectionTargets) {
+  if (userReleaseInjectionTargets === undefined) {
     return undefined;
-  } else if (typeof userEntries === "function") {
-    return userEntries;
+  } else if (typeof userReleaseInjectionTargets === "function") {
+    return userReleaseInjectionTargets;
   } else {
-    return arrayify(userEntries);
+    return arrayify(userReleaseInjectionTargets);
   }
 }
 /**
@@ -948,30 +946,68 @@ 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.1.0",
-    integrations: [new node.Integrations.Http({
-      tracing: true
-    })],
+    tracesSampleRate: 1,
+    sampleRate: 1,
+    release: "0.2.1",
+    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.
+    // 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);
+          }
 
-  node.makeMain(hub);
+          return send;
+        }()
+      };
+    }
+  });
+  var hub = new node.Hub(client);
   return {
-    client: client,
-    hub: hub
+    sentryClient: client,
+    sentryHub: hub
   };
 }
 /**
@@ -1013,8 +1049,10 @@ function captureMinimalError(error, hub) {
 
   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,
@@ -1054,61 +1092,107 @@ 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) {
@@ -1116,7 +1200,7 @@ function _createNewRelease() {
           case 0:
             span = addSpanToTransaction(ctx, "function.plugin.create_release");
             _context.next = 3;
-            return ctx.cli.releases["new"](options.release);
+            return ctx.cli.releases["new"](releaseName);
 
           case 3:
             ctx.logger.info("Successfully created release.");
@@ -1132,12 +1216,12 @@ function _createNewRelease() {
   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,7 +1238,7 @@ 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);
+            return ctx.cli.releases.execute(["releases", "files", releaseName, "delete", "--all"], true);
 
           case 6:
             ctx.logger.info("Successfully cleaned previous artifacts.");
@@ -1170,12 +1254,12 @@ function _cleanArtifacts() {
   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,7 +1270,7 @@ function _uploadSourceMaps() {
             // we only need to pass the include option here.
 
             _context3.next = 4;
-            return ctx.cli.releases.uploadSourceMaps(options.release, {
+            return ctx.cli.releases.uploadSourceMaps(releaseName, {
               include: options.include
             });
 
@@ -1204,12 +1288,12 @@ function _uploadSourceMaps() {
   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,7 +1312,7 @@ function _setCommits() {
             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, {
+            return ctx.cli.releases.setCommits(releaseName, {
               commit: commit,
               previousCommit: previousCommit,
               repo: repo,
@@ -1251,12 +1335,12 @@ function _setCommits() {
   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) {
@@ -1273,7 +1357,7 @@ function _finalizeRelease() {
           case 3:
             span = addSpanToTransaction(ctx, "function.plugin.finalize_release");
             _context5.next = 6;
-            return ctx.cli.releases.finalize(options.release);
+            return ctx.cli.releases.finalize(releaseName);
 
           case 6:
             ctx.logger.info("Successfully finalized release.");
@@ -1289,12 +1373,12 @@ function _finalizeRelease() {
   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) {
@@ -1313,7 +1397,7 @@ function _addDeploy() {
             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, {
+            return ctx.cli.releases.newDeploy(releaseName, {
               env: env,
               started: started,
               finished: finished,
@@ -1397,10 +1481,9 @@ function createLogger(options) {
         }
 
         // eslint-disable-next-line no-console
-        (_console4 = console).log.apply(_console4, ["".concat(options.prefix, " Debug: ").concat(message)].concat(params));
-      }
+        (_console4 = console).log.apply(_console4, ["".concat(options.prefix, " Debug: ").concat(message)].concat(params)); // We're not creating breadcrumbs for debug logs because it is super spammy
 
-      addBreadcrumb("debug", message);
+      }
     }
   };
 }
@@ -1480,10 +1563,11 @@ 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"];
 /**
  * The sentry bundler plugin concerns itself with two things:
  * - Release injection
@@ -1491,45 +1575,11 @@ var RELEASE_INJECTOR_ID = "\0sentry-release-injector";
  *
  * Release injection:
  *
- * Per default the sentry bundler plugin will inject a global `SENTRY_RELEASE` variable into the entrypoint of all bundles.
- * On a technical level this is done by appending an import (`import "sentry-release-injector;"`) to all entrypoint files
- * of the user code (see `transformInclude` and `transform` hooks). This import is then resolved by the sentry plugin
- * to a virtual module that sets the global variable (see `resolveId` and `load` hooks).
- *
- * The resulting output approximately looks like this:
- *
- * ```text
- *                               entrypoint1.js (user file)
- *  ┌─────────────────────────┐  ┌─────────────────────────────────────────────────┐
- *  │                         │  │  import { myFunction } from "./my-library.js";  │
- *  │  sentry-bundler-plugin  │  │                                                 │
- *  │                         │  │  const myResult = myFunction();                 │
- *  └---------│---------------   │  export { myResult };                           │
- *            │                  │                                                 │
- *            │      injects     │  // injected by sentry plugin                   │
- *            ├───────────────────► import "sentry-release-injector"; ─────────────────────┐
- *            │                  └─────────────────────────────────────────────────┘       │
- *            │                                                                            │
- *            │                                                                            │
- *            │                  entrypoint2.js (user file)                                │
- *            │                  ┌─────────────────────────────────────────────────┐       │
- *            │                  │  export function myFunction() {                 │       │
- *            │                  │    return "Hello world!";                       │       │
- *            │                  │  }                                              │       │
- *            │                  │                                                 │       │
- *            │      injects     │  // injected by sentry plugin                   │       │
- *            └───────────────────► import "sentry-release-injector"; ─────────────────────┤
- *                               └─────────────────────────────────────────────────┘       │
- *                                                                                         │
- *                                                                                         │
- *                               sentry-release-injector                                   │
- *                               ┌──────────────────────────────────┐                      │
- *                               │                                  │    is resolved       │
- *                               │  global.SENTRY_RELEASE = { ... } │    by plugin         │
- *                               │  // + a little more logic        │<─────────────────────┘
- *                               │                                  │    (only once)
- *                               └──────────────────────────────────┘
- * ```
+ * Per default the sentry bundler plugin will inject a global `SENTRY_RELEASE` into each JavaScript/TypeScript module
+ * that is part of the bundle. On a technical level this is done by appending an import (`import "sentry-release-injector;"`)
+ * to all entrypoint files of the user code (see `transformInclude` and `transform` hooks). This import is then resolved
+ * by the sentry plugin to a virtual module that sets the global variable (see `resolveId` and `load` hooks).
+ * If a user wants to inject the release into a particular set of modules they can use the `releaseInjectionTargets` option.
  *
  * Source maps upload:
  *
@@ -1548,11 +1598,19 @@ var RELEASE_INJECTOR_ID = "\0sentry-release-injector";
 
 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", allowedToSendTelemetryPromise),
+      sentryHub = _makeSentryClient.sentryHub,
+      sentryClient = _makeSentryClient.sentryClient;
 
-  var _makeSentryClient = makeSentryClient("https://4c2bae7d9fbc413e8f7385f55c515d51@o1.ingest.sentry.io/6690737", internalOptions.telemetry),
-      sentryHub = _makeSentryClient.hub;
+  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.
 
-  addPluginOptionTags(internalOptions, sentryHub);
+  node.makeMain(sentryHub);
   var logger = createLogger({
     hub: sentryHub,
     prefix: "[sentry-".concat(unpluginMetaContext.framework, "-plugin]"),
@@ -1565,25 +1623,13 @@ 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
+  var releaseNamePromise = new Promise(function (resolve) {
+    if (options.release) {
+      resolve(options.release);
+    } else {
+      resolve(cli.releases.proposeVersion());
+    }
   });
-  sentryHub.setUser({
-    id: internalOptions.org
-  }); // This is `nonEntrypointSet` instead of `entrypointSet` because this set is filled in the `resolveId` hook and there
-  // we don't have guaranteed access to *absolute* paths of files if they're entrypoints. For non-entrypoints we're
-  // guaranteed to have absolute paths - we're then using the paths in later hooks to make decisions about whether a
-  // file is an entrypoint or a non-entrypoint.
-
-  var nonEntrypointSet = new Set();
   var transaction;
   var releaseInjectionSpan;
   return {
@@ -1596,28 +1642,31 @@ 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);
+                logger.debug("Called 'buildStart'");
+                _context.next = 3;
+                return allowedToSendTelemetryPromise;
 
-              case 2:
-                if (internalOptions.release) {
-                  _context.next = 6;
-                  break;
+              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`.");
                 }
 
-                _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) {
+                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, sentryHub);
                 }
 
@@ -1632,7 +1681,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();
             }
@@ -1654,16 +1703,12 @@ 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 (!isEntry) {
-        nonEntrypointSet.add(id);
-      }
-
       if (id === RELEASE_INJECTOR_ID) {
         return RELEASE_INJECTOR_ID;
       } else {
@@ -1671,9 +1716,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;
     },
 
@@ -1685,75 +1730,109 @@ 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);
+      }))();
     },
 
     /**
      * This hook determines whether we want to transform a module. In the sentry bundler plugin we want to transform every entrypoint
-     * unless configured otherwise with the `entries` option.
+     * unless configured otherwise with the `releaseInjectionTargets` option.
      *
      * @param id Always the absolute (fully resolved) path to the module.
      * @returns `true` or `false` depending on whether we want to transform the module. For the sentry bundler plugin we only
      * want to transform the release injector file.
      */
     transformInclude: function transformInclude(id) {
-      sentryHub.addBreadcrumb({
-        category: "transformInclude",
-        level: "info"
-      });
+      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 (internalOptions.entries) {
-        // If there's an `entries` option transform (ie. inject the release varible) when the file path matches the option.
-        if (typeof internalOptions.entries === "function") {
-          return internalOptions.entries(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(normalizedId);
         }
 
-        return internalOptions.entries.some(function (entry) {
+        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;
           }
         });
-      } // We want to transform (release injection) every module except for "sentry-release-injector".
-
-
-      return id !== RELEASE_INJECTOR_ID && !nonEntrypointSet.has(id);
+      } else {
+        var pathIsOrdinary = !normalizedId.includes("?") && !normalizedId.includes("#");
+        var pathHasAllowedFileEnding = ALLOWED_TRANSFORMATION_FILE_ENDINGS.some(function (allowedFileEnding) {
+          return normalizedId.endsWith(allowedFileEnding);
+        });
+        return pathIsOrdinary && pathHasAllowedFileEnding;
+      }
     },
 
     /**
      * This hook is responsible for injecting the "sentry release injector" imoprt statement into each entrypoint unless
-     * configured otherwise with the `entries` option (logic for that is in the `transformInclude` hook).
+     * configured otherwise with the `releaseInjectionTargets` option (logic for that is in the `transformInclude` hook).
      *
      * @param code Code of the file to transform.
      * @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); // Very stupid author's note: For some absurd reason, when we add a JSDoc to this hook, the TS language server starts complaining about `ms` and adding a type annotation helped so that's why it's here. (┛ಠ_ಠ)┛彡┻━┻
-      // appending instead of prepending has less probability of mucking with user'sadly
-      // source maps and import statements get to the top anyways
+      var ms = new MagicString__default["default"](code); // Appending instead of prepending has less probability of mucking with user's source maps.
+      // Luckily import statements get hoisted to the top anyways.
 
-      ms.append("import \"".concat(RELEASE_INJECTOR_ID, "\";"));
+      ms.append(";\nimport \"".concat(RELEASE_INJECTOR_ID, "\";"));
 
       if (unpluginMetaContext.framework === "esbuild") {
         // esbuild + unplugin is buggy at the moment when we return an object with a `map` (sourcemap) property.
@@ -1773,69 +1852,119 @@ 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 = 28;
+                break;
+
+              case 24:
+                _context3.prev = 24;
+                _context3.t0 = _context3["catch"](8);
+                (_transaction2 = transaction) === null || _transaction2 === void 0 ? void 0 : _transaction2.setStatus("cancelled");
+                handleError(_context3.t0, logger, internalOptions.errorHandler, sentryHub);
+
+              case 28:
+                _context3.prev = 28;
+                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();
+                _context3.next = 34;
+                return sentryClient.flush().then(null, function () {
+                  logger.warn("Sending of telemetry failed");
+                });
+
+              case 34:
+                return _context3.finish(28);
+
+              case 35:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, null, [[8, 24, 28, 35]]);
+      }))();
     }
   };
 });
 
-function handleError(error, logger, errorHandler, sentryHub) {
-  logger.error(error.message);
+function handleError(unknownError, logger, errorHandler, sentryHub) {
+  if (unknownError instanceof Error) {
+    logger.error(unknownError.message);
+  } else {
+    logger.error(String(unknownError));
+  }
 
   if (sentryHub) {
-    captureMinimalError(error, sentryHub);
+    captureMinimalError(unknownError, sentryHub);
   }
 
   if (errorHandler) {
-    errorHandler(error);
+    if (unknownError instanceof Error) {
+      errorHandler(unknownError);
+    } else {
+      errorHandler(new Error("An unknown error occured"));
+    }
   } else {
-    throw error;
+    throw unknownError;
   }
 }
 /**