@sentry/browser 6.18.1-beta.0 → 6.19.0

package/{build → bundles}/bundle.es6.js

@@ -1,4 +1,4 @@
-/*! @sentry/browser 6.18.1-beta.0 (8443996) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 6.19.0 (b93e8d4) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
 
   /**
@@ -36,14 +36,11 @@ var Sentry = (function (exports) {
   }
 
   /**
-   * This module mostly exists for optimizations in the build process
-   * through rollup and terser.  We define some global constants which
-   * are normally undefined.  However terser overrides these with global
-   * definitions which can be evaluated by the static analyzer when
-   * creating a bundle.
-   *
-   * In turn the `isDebugBuild` and `isBrowserBundle` functions are pure
-   * and can help us remove unused code from the bundles.
+   * This module exists for optimizations in the build process through rollup and terser.  We define some global
+   * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these
+   * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will
+   * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to
+   * `logger` and preventing node-related code from appearing in browser bundles.
    */
   /**
    * Figures out if we're building with debug functionality.
@@ -51,7 +48,7 @@ var Sentry = (function (exports) {
    * @returns true if this is a debug build
    */
   function isDebugBuild() {
-      return typeof __SENTRY_NO_DEBUG__ !== 'undefined' && !true;
+      return true;
   }
 
   /**
@@ -415,9 +412,6 @@ var Sentry = (function (exports) {
       };
   }
   function validateDsn(dsn) {
-      if (!isDebugBuild()) {
-          return;
-      }
       const { port, projectId, protocol } = dsn;
       const requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];
       requiredComponents.forEach(component => {
@@ -449,6 +443,7 @@ var Sentry = (function (exports) {
   const global$6 = getGlobalObject();
   /** Prefix for logging strings */
   const PREFIX = 'Sentry Logger ';
+  const CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert'];
   /**
    * Temporarily unwrap `console.log` and friends in order to perform the given callback using the original methods.
    * Restores wrapping after the callback completes.
@@ -458,7 +453,6 @@ var Sentry = (function (exports) {
    */
   function consoleSandbox(callback) {
       const global = getGlobalObject();
-      const levels = ['debug', 'info', 'warn', 'error', 'log', 'assert'];
       if (!('console' in global)) {
           return callback();
       }
@@ -466,7 +460,7 @@ var Sentry = (function (exports) {
       const originalConsole = global.console;
       const wrappedLevels = {};
       // Restore all wrapped console methods
-      levels.forEach(level => {
+      CONSOLE_LEVELS.forEach(level => {
           // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
           if (level in global.console && originalConsole[level].__sentry_original__) {
               wrappedLevels[level] = originalConsole[level];
@@ -501,7 +495,7 @@ var Sentry = (function (exports) {
               return;
           }
           consoleSandbox(() => {
-              global$6.console.log(`${PREFIX}[Log]: ${args.join(' ')}`);
+              global$6.console.log(`${PREFIX}[Log]:`, ...args);
           });
       }
       /** JSDoc */
@@ -510,7 +504,7 @@ var Sentry = (function (exports) {
               return;
           }
           consoleSandbox(() => {
-              global$6.console.warn(`${PREFIX}[Warn]: ${args.join(' ')}`);
+              global$6.console.warn(`${PREFIX}[Warn]:`, ...args);
           });
       }
       /** JSDoc */
@@ -519,13 +513,17 @@ var Sentry = (function (exports) {
               return;
           }
           consoleSandbox(() => {
-              global$6.console.error(`${PREFIX}[Error]: ${args.join(' ')}`);
+              global$6.console.error(`${PREFIX}[Error]:`, ...args);
           });
       }
   }
-  // Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used
-  global$6.__SENTRY__ = global$6.__SENTRY__ || {};
-  const logger = global$6.__SENTRY__.logger || (global$6.__SENTRY__.logger = new Logger());
+  const sentryGlobal = global$6.__SENTRY__ || {};
+  const logger = sentryGlobal.logger || new Logger();
+  {
+      // Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used
+      sentryGlobal.logger = logger;
+      global$6.__SENTRY__ = sentryGlobal;
+  }
 
   /* eslint-disable @typescript-eslint/no-unsafe-member-access */
   /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -576,12 +574,13 @@ var Sentry = (function (exports) {
    * StackFrames are returned in the correct order for Sentry Exception
    * frames and with Sentry SDK internal frames removed from the top and bottom
    *
-   * */
+   */
   function createStackParser(...parsers) {
+      const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);
       return (stack, skipFirst = 0) => {
           const frames = [];
           for (const line of stack.split('\n').slice(skipFirst)) {
-              for (const parser of parsers) {
+              for (const parser of sortedParsers) {
                   const frame = parser(line);
                   if (frame) {
                       frames.push(frame);
@@ -865,19 +864,19 @@ var Sentry = (function (exports) {
       if (type === '[object Array]') {
           return '[Array]';
       }
-      const normalized = normalizeValue(value);
-      return isPrimitive(normalized) ? normalized : type;
+      // `makeSerializable` provides a string representation of certain non-serializable values. For all others, it's a
+      // pass-through.
+      const serializable = makeSerializable(value);
+      return isPrimitive(serializable) ? serializable : type;
   }
   /**
-   * normalizeValue()
+   * makeSerializable()
    *
-   * Takes unserializable input and make it serializable friendly
+   * Takes unserializable input and make it serializer-friendly.
    *
-   * - translates undefined/NaN values to "[undefined]"/"[NaN]" respectively,
-   * - serializes Error objects
-   * - filter global objects
+   * Handles globals, functions, `undefined`, `NaN`, and other non-serializable values.
    */
-  function normalizeValue(value, key) {
+  function makeSerializable(value, key) {
       if (key === 'domain' && value && typeof value === 'object' && value._events) {
           return '[Domain]';
       }
@@ -925,24 +924,25 @@ var Sentry = (function (exports) {
    * @param key of object that's walked in current iteration
    * @param value object to be walked
    * @param depth Optional number indicating how deep should walking be performed
+   * @param maxProperties Optional maximum  number of properties/elements included in any single object/array
    * @param memo Optional Memo class handling decycling
    */
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  function walk(key, value, depth = +Infinity, memo = memoBuilder()) {
+  function walk(key, value, depth = +Infinity, maxProperties = +Infinity, memo = memoBuilder()) {
+      const [memoize, unmemoize] = memo;
       // If we reach the maximum depth, serialize whatever is left
       if (depth === 0) {
           return serializeValue(value);
       }
-      /* eslint-disable @typescript-eslint/no-unsafe-member-access */
       // If value implements `toJSON` method, call it and return early
       if (value !== null && value !== undefined && typeof value.toJSON === 'function') {
           return value.toJSON();
       }
-      /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-      // If normalized value is a primitive, there are no branches left to walk, so bail out
-      const normalized = normalizeValue(value, key);
-      if (isPrimitive(normalized)) {
-          return normalized;
+      // `makeSerializable` provides a string representation of certain non-serializable values. For all others, it's a
+      // pass-through. If what comes back is a primitive (either because it's been stringified or because it was primitive
+      // all along), we're done.
+      const serializable = makeSerializable(value, key);
+      if (isPrimitive(serializable)) {
+          return serializable;
       }
       // Create source that we will use for the next iteration. It will either be an objectified error object (`Error` type
       // with extracted key:value pairs) or the input itself.
@@ -950,39 +950,53 @@ var Sentry = (function (exports) {
       // Create an accumulator that will act as a parent for all future itterations of that branch
       const acc = Array.isArray(value) ? [] : {};
       // If we already walked that branch, bail out, as it's circular reference
-      if (memo[0](value)) {
+      if (memoize(value)) {
           return '[Circular ~]';
       }
+      let propertyCount = 0;
       // Walk all keys of the source
       for (const innerKey in source) {
           // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.
           if (!Object.prototype.hasOwnProperty.call(source, innerKey)) {
               continue;
           }
+          if (propertyCount >= maxProperties) {
+              acc[innerKey] = '[MaxProperties ~]';
+              break;
+          }
+          propertyCount += 1;
           // Recursively walk through all the child nodes
-          acc[innerKey] = walk(innerKey, source[innerKey], depth - 1, memo);
+          const innerValue = source[innerKey];
+          acc[innerKey] = walk(innerKey, innerValue, depth - 1, maxProperties, memo);
       }
       // Once walked through all the branches, remove the parent from memo storage
-      memo[1](value);
+      unmemoize(value);
       // Return accumulated values
       return acc;
   }
   /**
-   * normalize()
+   * Recursively normalizes the given object.
    *
    * - Creates a copy to prevent original input mutation
-   * - Skip non-enumerablers
-   * - Calls `toJSON` if implemented
+   * - Skips non-enumerable properties
+   * - When stringifying, calls `toJSON` if implemented
    * - Removes circular references
-   * - Translates non-serializeable values (undefined/NaN/Functions) to serializable format
-   * - Translates known global objects/Classes to a string representations
-   * - Takes care of Error objects serialization
-   * - Optionally limit depth of final output
+   * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format
+   * - Translates known global objects/classes to a string representations
+   * - Takes care of `Error` object serialization
+   * - Optionally limits depth of final output
+   * - Optionally limits number of properties/elements included in any single object/array
+   *
+   * @param input The object to be normalized.
+   * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)
+   * @param maxProperties The max number of elements or properties to be included in any single array or
+   * object in the normallized output..
+   * @returns A normalized version of the object, or `"**non-serializable**"` if any errors are thrown during normalization.
    */
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  function normalize(input, depth) {
+  function normalize(input, depth = +Infinity, maxProperties = +Infinity) {
       try {
-          return JSON.parse(JSON.stringify(input, (key, value) => walk(key, value, depth)));
+          // since we're at the outermost level, there is no key
+          return walk('', input, depth, maxProperties);
       }
       catch (_oO) {
           return '**non-serializable**';
@@ -1084,7 +1098,7 @@ var Sentry = (function (exports) {
       let result = false;
       const doc = global.document;
       // eslint-disable-next-line deprecation/deprecation
-      if (doc && typeof doc.createElement === `function`) {
+      if (doc && typeof doc.createElement === 'function') {
           try {
               const sandbox = doc.createElement('iframe');
               sandbox.hidden = true;
@@ -1096,9 +1110,7 @@ var Sentry = (function (exports) {
               doc.head.removeChild(sandbox);
           }
           catch (err) {
-              if (isDebugBuild()) {
-                  logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);
-              }
+              logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);
           }
       }
       return result;
@@ -1190,6 +1202,7 @@ var Sentry = (function (exports) {
               break;
           default:
               logger.warn('unknown instrumentation type:', type);
+              return;
       }
   }
   /**
@@ -1212,9 +1225,7 @@ var Sentry = (function (exports) {
               handler(data);
           }
           catch (e) {
-              if (isDebugBuild()) {
-                  logger.error(`Error while triggering instrumentation handler.\nType: ${type}\nName: ${getFunctionName(handler)}\nError: ${e}`);
-              }
+              logger.error(`Error while triggering instrumentation handler.\nType: ${type}\nName: ${getFunctionName(handler)}\nError:`, e);
           }
       }
   }
@@ -1223,7 +1234,7 @@ var Sentry = (function (exports) {
       if (!('console' in global$5)) {
           return;
       }
-      ['debug', 'info', 'warn', 'error', 'log', 'assert'].forEach(function (level) {
+      CONSOLE_LEVELS.forEach(function (level) {
           if (!(level in global$5.console)) {
               return;
           }
@@ -1741,26 +1752,6 @@ var Sentry = (function (exports) {
           firstException.mechanism.data = mergedData;
       }
   }
-  const defaultRetryAfter = 60 * 1000; // 60 seconds
-  /**
-   * Extracts Retry-After value from the request header or returns default value
-   * @param now current unix timestamp
-   * @param header string representation of 'Retry-After' header
-   */
-  function parseRetryAfterHeader(now, header) {
-      if (!header) {
-          return defaultRetryAfter;
-      }
-      const headerDelay = parseInt(`${header}`, 10);
-      if (!isNaN(headerDelay)) {
-          return headerDelay * 1000;
-      }
-      const headerDate = Date.parse(`${header}`);
-      if (!isNaN(headerDate)) {
-          return headerDate - now;
-      }
-      return defaultRetryAfter;
-  }
   /**
    * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object
    * in question), and marks it captured if not.
@@ -2211,7 +2202,9 @@ var Sentry = (function (exports) {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       return items.reduce((acc, item) => {
           const [itemHeaders, payload] = item;
-          return `${acc}\n${JSON.stringify(itemHeaders)}\n${JSON.stringify(payload)}`;
+          // We do not serialize payloads that are primitives
+          const serializedPayload = isPrimitive(payload) ? String(payload) : JSON.stringify(payload);
+          return `${acc}\n${JSON.stringify(itemHeaders)}\n${serializedPayload}`;
       }, serializedHeaders);
   }
 
@@ -2231,6 +2224,79 @@ var Sentry = (function (exports) {
       return createEnvelope(dsn ? { dsn } : {}, [clientReportItem]);
   }
 
+  const DEFAULT_RETRY_AFTER = 60 * 1000; // 60 seconds
+  /**
+   * Extracts Retry-After value from the request header or returns default value
+   * @param header string representation of 'Retry-After' header
+   * @param now current unix timestamp
+   *
+   */
+  function parseRetryAfterHeader(header, now = Date.now()) {
+      const headerDelay = parseInt(`${header}`, 10);
+      if (!isNaN(headerDelay)) {
+          return headerDelay * 1000;
+      }
+      const headerDate = Date.parse(`${header}`);
+      if (!isNaN(headerDate)) {
+          return headerDate - now;
+      }
+      return DEFAULT_RETRY_AFTER;
+  }
+  /**
+   * Gets the time that given category is disabled until for rate limiting
+   */
+  function disabledUntil(limits, category) {
+      return limits[category] || limits.all || 0;
+  }
+  /**
+   * Checks if a category is rate limited
+   */
+  function isRateLimited(limits, category, now = Date.now()) {
+      return disabledUntil(limits, category) > now;
+  }
+  /**
+   * Update ratelimits from incoming headers.
+   * Returns true if headers contains a non-empty rate limiting header.
+   */
+  function updateRateLimits(limits, headers, now = Date.now()) {
+      const updatedRateLimits = Object.assign({}, limits);
+      // "The name is case-insensitive."
+      // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get
+      const rateLimitHeader = headers['x-sentry-rate-limits'];
+      const retryAfterHeader = headers['retry-after'];
+      if (rateLimitHeader) {
+          /**
+           * rate limit headers are of the form
+           *     <header>,<header>,..
+           * where each <header> is of the form
+           *     <retry_after>: <categories>: <scope>: <reason_code>
+           * where
+           *     <retry_after> is a delay in seconds
+           *     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form
+           *         <category>;<category>;...
+           *     <scope> is what's being limited (org, project, or key) - ignored by SDK
+           *     <reason_code> is an arbitrary string like "org_quota" - ignored by SDK
+           */
+          for (const limit of rateLimitHeader.trim().split(',')) {
+              const parameters = limit.split(':', 2);
+              const headerDelay = parseInt(parameters[0], 10);
+              const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default
+              if (!parameters[1]) {
+                  updatedRateLimits.all = now + delay;
+              }
+              else {
+                  for (const category of parameters[1].split(';')) {
+                      updatedRateLimits[category] = now + delay;
+                  }
+              }
+          }
+      }
+      else if (retryAfterHeader) {
+          updatedRateLimits.all = now + parseRetryAfterHeader(retryAfterHeader, now);
+      }
+      return updatedRateLimits;
+  }
+
   /**
    * Absolute maximum number of breadcrumbs added to an event.
    * The `maxBreadcrumbs` option cannot be higher than this value.
@@ -3262,13 +3328,7 @@ var Sentry = (function (exports) {
    */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
   function captureException(exception, captureContext) {
-      let syntheticException;
-      try {
-          throw new Error('Sentry syntheticException');
-      }
-      catch (exception) {
-          syntheticException = exception;
-      }
+      const syntheticException = new Error('Sentry syntheticException');
       return callOnHub('captureException', exception, {
           captureContext,
           originalException: exception,
@@ -3283,13 +3343,7 @@ var Sentry = (function (exports) {
    * @returns The generated eventId.
    */
   function captureMessage(message, captureContext) {
-      let syntheticException;
-      try {
-          throw new Error(message);
-      }
-      catch (exception) {
-          syntheticException = exception;
-      }
+      const syntheticException = new Error(message);
       // This is necessary to provide explicit scopes upgrade, without changing the original
       // arity of the `captureMessage(message, level)` method.
       const level = typeof captureContext === 'string' ? captureContext : undefined;
@@ -3661,15 +3715,11 @@ var Sentry = (function (exports) {
        */
       captureSession(session) {
           if (!this._isEnabled()) {
-              if (isDebugBuild()) {
-                  logger.warn('SDK not enabled, will not capture session.');
-              }
+              logger.warn('SDK not enabled, will not capture session.');
               return;
           }
           if (!(typeof session.release === 'string')) {
-              if (isDebugBuild()) {
-                  logger.warn('Discarded session because of missing or non-string release');
-              }
+              logger.warn('Discarded session because of missing or non-string release');
           }
           else {
               this._sendSession(session);
@@ -3815,7 +3865,7 @@ var Sentry = (function (exports) {
        * @returns A new event with more information.
        */
       _prepareEvent(event, scope, hint) {
-          const { normalizeDepth = 3 } = this.getOptions();
+          const { normalizeDepth = 3, normalizeMaxBreadth = 1000 } = this.getOptions();
           const prepared = Object.assign(Object.assign({}, event), { event_id: event.event_id || (hint && hint.event_id ? hint.event_id : uuid4()), timestamp: event.timestamp || dateTimestampInSeconds() });
           this._applyClientOptions(prepared);
           this._applyIntegrationsMetadata(prepared);
@@ -3840,7 +3890,7 @@ var Sentry = (function (exports) {
                   evt.sdkProcessingMetadata = Object.assign(Object.assign({}, evt.sdkProcessingMetadata), { normalizeDepth: normalize(normalizeDepth) });
               }
               if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {
-                  return this._normalizeEvent(evt, normalizeDepth);
+                  return this._normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);
               }
               return evt;
           });
@@ -3855,20 +3905,20 @@ var Sentry = (function (exports) {
        * @param event Event
        * @returns Normalized event
        */
-      _normalizeEvent(event, depth) {
+      _normalizeEvent(event, depth, maxBreadth) {
           if (!event) {
               return null;
           }
           const normalized = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, event), (event.breadcrumbs && {
               breadcrumbs: event.breadcrumbs.map(b => (Object.assign(Object.assign({}, b), (b.data && {
-                  data: normalize(b.data, depth),
+                  data: normalize(b.data, depth, maxBreadth),
               })))),
           })), (event.user && {
-              user: normalize(event.user, depth),
+              user: normalize(event.user, depth, maxBreadth),
           })), (event.contexts && {
-              contexts: normalize(event.contexts, depth),
+              contexts: normalize(event.contexts, depth, maxBreadth),
           })), (event.extra && {
-              extra: normalize(event.extra, depth),
+              extra: normalize(event.extra, depth, maxBreadth),
           }));
           // event.contexts.trace stores information about a Transaction. Similarly,
           // event.spans[] stores information about child Spans. Given that a
@@ -4059,7 +4109,7 @@ var Sentry = (function (exports) {
        */
       sendEvent(_) {
           return resolvedSyncPromise({
-              reason: `NoopTransport: Event has been skipped because no Dsn is configured.`,
+              reason: 'NoopTransport: Event has been skipped because no Dsn is configured.',
               status: 'skipped',
           });
       }
@@ -4102,9 +4152,7 @@ var Sentry = (function (exports) {
        */
       sendEvent(event) {
           void this._transport.sendEvent(event).then(null, reason => {
-              if (isDebugBuild()) {
-                  logger.error(`Error while sending event: ${reason}`);
-              }
+              logger.error('Error while sending event:', reason);
           });
       }
       /**
@@ -4112,15 +4160,11 @@ var Sentry = (function (exports) {
        */
       sendSession(session) {
           if (!this._transport.sendSession) {
-              if (isDebugBuild()) {
-                  logger.warn("Dropping session because custom transport doesn't implement sendSession");
-              }
+              logger.warn("Dropping session because custom transport doesn't implement sendSession");
               return;
           }
           void this._transport.sendSession(session).then(null, reason => {
-              if (isDebugBuild()) {
-                  logger.error(`Error while sending session: ${reason}`);
-              }
+              logger.error('Error while sending session:', reason);
           });
       }
       /**
@@ -4163,14 +4207,14 @@ var Sentry = (function (exports) {
   /** Creates a SentryRequest from a Session. */
   function sessionToSentryRequest(session, api) {
       const sdkInfo = getSdkMetadataForEnvelopeHeader(api);
-      const envelopeHeaders = JSON.stringify(Object.assign(Object.assign({ sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (!!api.tunnel && { dsn: dsnToString(api.dsn) })));
-      // I know this is hacky but we don't want to add `session` to request type since it's never rate limited
+      const envelopeHeaders = Object.assign(Object.assign({ sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (!!api.tunnel && { dsn: dsnToString(api.dsn) }));
+      // I know this is hacky but we don't want to add `sessions` to request type since it's never rate limited
       const type = 'aggregates' in session ? 'sessions' : 'session';
-      const itemHeaders = JSON.stringify({
-          type,
-      });
+      // TODO (v7) Have to cast type because envelope items do not accept a `SentryRequestType`
+      const envelopeItem = [{ type }, session];
+      const envelope = createEnvelope(envelopeHeaders, [envelopeItem]);
       return {
-          body: `${envelopeHeaders}\n${itemHeaders}\n${JSON.stringify(session)}`,
+          body: serializeEnvelope(envelope),
           type,
           url: getEnvelopeEndpointWithUrlEncodedAuth(api.dsn, api.tunnel),
       };
@@ -4248,19 +4292,16 @@ var Sentry = (function (exports) {
       // deserialization. Instead, we only implement a minimal subset of the spec to
       // serialize events inline here.
       if (useEnvelope) {
-          const envelopeHeaders = JSON.stringify(Object.assign(Object.assign({ event_id: event.event_id, sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (!!api.tunnel && { dsn: dsnToString(api.dsn) })));
-          const itemHeaders = JSON.stringify({
-              type: eventType,
-              // TODO: Right now, sampleRate may or may not be defined (it won't be in the cases of inheritance and
-              // explicitly-set sampling decisions). Are we good with that?
-              sample_rates: [{ id: samplingMethod, rate: sampleRate }],
-          });
-          // The trailing newline is optional. We intentionally don't send it to avoid
-          // sending unnecessary bytes.
-          //
-          // const envelope = `${envelopeHeaders}\n${itemHeaders}\n${req.body}\n`;
-          const envelope = `${envelopeHeaders}\n${itemHeaders}\n${req.body}`;
-          req.body = envelope;
+          const envelopeHeaders = Object.assign(Object.assign({ event_id: event.event_id, sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (!!api.tunnel && { dsn: dsnToString(api.dsn) }));
+          const eventItem = [
+              {
+                  type: eventType,
+                  sample_rates: [{ id: samplingMethod, rate: sampleRate }],
+              },
+              req.body,
+          ];
+          const envelope = createEnvelope(envelopeHeaders, [eventItem]);
+          req.body = serializeEnvelope(envelope);
       }
       return req;
   }
@@ -4274,7 +4315,9 @@ var Sentry = (function (exports) {
    */
   function initAndBind(clientClass, options) {
       if (options.debug === true) {
-          logger.enable();
+          {
+              logger.enable();
+          }
       }
       const hub = getCurrentHub();
       const scope = hub.getScope();
@@ -4285,7 +4328,7 @@ var Sentry = (function (exports) {
       hub.bindClient(client);
   }
 
-  const SDK_VERSION = '6.18.1-beta.0';
+  const SDK_VERSION = '6.19.0';
 
   let originalFunctionToString;
   /** Patch toString calls to return proper name for wrapped functions */
@@ -4356,27 +4399,19 @@ var Sentry = (function (exports) {
       /** JSDoc */
       _shouldDropEvent(event, options) {
           if (this._isSentryError(event, options)) {
-              if (isDebugBuild()) {
-                  logger.warn(`Event dropped due to being internal Sentry Error.\nEvent: ${getEventDescription(event)}`);
-              }
+              logger.warn(`Event dropped due to being internal Sentry Error.\nEvent: ${getEventDescription(event)}`);
               return true;
           }
           if (this._isIgnoredError(event, options)) {
-              if (isDebugBuild()) {
-                  logger.warn(`Event dropped due to being matched by \`ignoreErrors\` option.\nEvent: ${getEventDescription(event)}`);
-              }
+              logger.warn(`Event dropped due to being matched by \`ignoreErrors\` option.\nEvent: ${getEventDescription(event)}`);
               return true;
           }
           if (this._isDeniedUrl(event, options)) {
-              if (isDebugBuild()) {
-                  logger.warn(`Event dropped due to being matched by \`denyUrls\` option.\nEvent: ${getEventDescription(event)}.\nUrl: ${this._getEventFilterUrl(event)}`);
-              }
+              logger.warn(`Event dropped due to being matched by \`denyUrls\` option.\nEvent: ${getEventDescription(event)}.\nUrl: ${this._getEventFilterUrl(event)}`);
               return true;
           }
           if (!this._isAllowedUrl(event, options)) {
-              if (isDebugBuild()) {
-                  logger.warn(`Event dropped due to not being matched by \`allowUrls\` option.\nEvent: ${getEventDescription(event)}.\nUrl: ${this._getEventFilterUrl(event)}`);
-              }
+              logger.warn(`Event dropped due to not being matched by \`allowUrls\` option.\nEvent: ${getEventDescription(event)}.\nUrl: ${this._getEventFilterUrl(event)}`);
               return true;
           }
           return false;
@@ -4461,9 +4496,7 @@ var Sentry = (function (exports) {
                   return [`${value}`, `${type}: ${value}`];
               }
               catch (oO) {
-                  if (isDebugBuild()) {
-                      logger.error(`Cannot extract message for event ${getEventDescription(event)}`);
-                  }
+                  logger.error(`Cannot extract message for event ${getEventDescription(event)}`);
                   return [];
               }
           }
@@ -4496,9 +4529,7 @@ var Sentry = (function (exports) {
               return frames ? this._getLastValidUrl(frames) : null;
           }
           catch (oO) {
-              if (isDebugBuild()) {
-                  logger.error(`Cannot extract url for event ${getEventDescription(event)}`);
-              }
+              logger.error(`Cannot extract url for event ${getEventDescription(event)}`);
               return null;
           }
       }
@@ -4516,6 +4547,11 @@ var Sentry = (function (exports) {
 
   // global reference to slice
   const UNKNOWN_FUNCTION = '?';
+  const OPERA10_PRIORITY = 10;
+  const OPERA11_PRIORITY = 20;
+  const CHROME_PRIORITY = 30;
+  const WINJS_PRIORITY = 40;
+  const GECKO_PRIORITY = 50;
   function createFrame(filename, func, lineno, colno) {
       const frame = {
           filename,
@@ -4554,6 +4590,7 @@ var Sentry = (function (exports) {
       }
       return;
   };
+  const chromeStackParser = [CHROME_PRIORITY, chrome];
   // gecko regex: `(?:bundle|\d+\.js)`: `bundle` is for react native, `\d+\.js` also but specifically for ram bundles because it
   // generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js
   // We need this specific case for now because we want no other regex to match.
@@ -4567,7 +4604,7 @@ var Sentry = (function (exports) {
               const subMatch = geckoEvalRegex.exec(parts[3]);
               if (subMatch) {
                   // throw out eval line/column and use top-most line number
-                  parts[1] = parts[1] || `eval`;
+                  parts[1] = parts[1] || 'eval';
                   parts[3] = subMatch[1];
                   parts[4] = subMatch[2];
                   parts[5] = ''; // no column when eval
@@ -4580,6 +4617,7 @@ var Sentry = (function (exports) {
       }
       return;
   };
+  const geckoStackParser = [GECKO_PRIORITY, gecko];
   const winjsRegex = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
   const winjs = line => {
       const parts = winjsRegex.exec(line);
@@ -4587,16 +4625,19 @@ var Sentry = (function (exports) {
           ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)
           : undefined;
   };
+  const winjsStackParser = [WINJS_PRIORITY, winjs];
   const opera10Regex = / line (\d+).*script (?:in )?(\S+)(?:: in function (\S+))?$/i;
   const opera10 = line => {
       const parts = opera10Regex.exec(line);
       return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;
   };
+  const opera10StackParser = [OPERA10_PRIORITY, opera10];
   const opera11Regex = / line (\d+), column (\d+)\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\(.*\))? in (.*):\s*$/i;
   const opera11 = line => {
       const parts = opera11Regex.exec(line);
       return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;
   };
+  const opera11StackParser = [OPERA11_PRIORITY, opera11];
   /**
    * Safari web extensions, starting version unknown, can produce "frames-only" stacktraces.
    * What it means, is that instead of format like:
@@ -4640,7 +4681,7 @@ var Sentry = (function (exports) {
           type: ex && ex.name,
           value: extractMessage(ex),
       };
-      if (frames && frames.length) {
+      if (frames.length) {
           exception.stacktrace = { frames };
       }
       if (exception.type === undefined && exception.value === '') {
@@ -4651,13 +4692,13 @@ var Sentry = (function (exports) {
   /**
    * @hidden
    */
-  function eventFromPlainObject(exception, syntheticException, rejection) {
+  function eventFromPlainObject(exception, syntheticException, isUnhandledRejection) {
       const event = {
           exception: {
               values: [
                   {
-                      type: isEvent(exception) ? exception.constructor.name : rejection ? 'UnhandledRejection' : 'Error',
-                      value: `Non-Error ${rejection ? 'promise rejection' : 'exception'} captured with keys: ${extractExceptionKeysForMessage(exception)}`,
+                      type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',
+                      value: `Non-Error ${isUnhandledRejection ? 'promise rejection' : 'exception'} captured with keys: ${extractExceptionKeysForMessage(exception)}`,
                   },
               ],
           },
@@ -4691,8 +4732,7 @@ var Sentry = (function (exports) {
       const stacktrace = ex.stacktrace || ex.stack || '';
       const popSize = getPopSize(ex);
       try {
-          // The order of the parsers in important
-          return createStackParser(opera10, opera11, chrome, winjs, gecko)(stacktrace, popSize);
+          return createStackParser(opera10StackParser, opera11StackParser, chromeStackParser, winjsStackParser, geckoStackParser)(stacktrace, popSize);
       }
       catch (e) {
           // no-empty
@@ -4717,7 +4757,6 @@ var Sentry = (function (exports) {
    * https://github.com/getsentry/sentry-javascript/issues/1949
    * In this specific case we try to extract stacktrace.message.error.message
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   function extractMessage(ex) {
       const message = ex && ex.message;
       if (!message) {
@@ -4727,17 +4766,14 @@ var Sentry = (function (exports) {
           return message.error.message;
       }
       return message;
-  }
-
+  }
   /**
    * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.
    * @hidden
    */
-  function eventFromException(options, exception, hint) {
+  function eventFromException(exception, hint, attachStacktrace) {
       const syntheticException = (hint && hint.syntheticException) || undefined;
-      const event = eventFromUnknownInput(exception, syntheticException, {
-          attachStacktrace: options.attachStacktrace,
-      });
+      const event = eventFromUnknownInput(exception, syntheticException, attachStacktrace);
       addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }
       event.level = exports.Severity.Error;
       if (hint && hint.event_id) {
@@ -4749,11 +4785,9 @@ var Sentry = (function (exports) {
    * Builds and Event from a Message
    * @hidden
    */
-  function eventFromMessage(options, message, level = exports.Severity.Info, hint) {
+  function eventFromMessage(message, level = exports.Severity.Info, hint, attachStacktrace) {
       const syntheticException = (hint && hint.syntheticException) || undefined;
-      const event = eventFromString(message, syntheticException, {
-          attachStacktrace: options.attachStacktrace,
-      });
+      const event = eventFromString(message, syntheticException, attachStacktrace);
       event.level = level;
       if (hint && hint.event_id) {
           event.event_id = hint.event_id;
@@ -4763,7 +4797,7 @@ var Sentry = (function (exports) {
   /**
    * @hidden
    */
-  function eventFromUnknownInput(exception, syntheticException, options = {}) {
+  function eventFromUnknownInput(exception, syntheticException, attachStacktrace, isUnhandledRejection) {
       let event;
       if (isErrorEvent(exception) && exception.error) {
           // If it is an ErrorEvent with `error` property, extract it to get actual Error
@@ -4785,7 +4819,7 @@ var Sentry = (function (exports) {
           else {
               const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');
               const message = domException.message ? `${name}: ${domException.message}` : name;
-              event = eventFromString(message, syntheticException, options);
+              event = eventFromString(message, syntheticException, attachStacktrace);
               addExceptionTypeValue(event, message);
           }
           if ('code' in domException) {
@@ -4802,7 +4836,7 @@ var Sentry = (function (exports) {
           // it manually. This will allow us to group events based on top-level keys which is much better than creating a new
           // group on any key/value change.
           const objectException = exception;
-          event = eventFromPlainObject(objectException, syntheticException, options.isRejection);
+          event = eventFromPlainObject(objectException, syntheticException, isUnhandledRejection);
           addExceptionMechanism(event, {
               synthetic: true,
           });
@@ -4817,7 +4851,7 @@ var Sentry = (function (exports) {
       // - a plain Object
       //
       // So bail out and capture it as a simple message:
-      event = eventFromString(exception, syntheticException, options);
+      event = eventFromString(exception, syntheticException, attachStacktrace);
       addExceptionTypeValue(event, `${exception}`, undefined);
       addExceptionMechanism(event, {
           synthetic: true,
@@ -4827,11 +4861,11 @@ var Sentry = (function (exports) {
   /**
    * @hidden
    */
-  function eventFromString(input, syntheticException, options = {}) {
+  function eventFromString(input, syntheticException, attachStacktrace) {
       const event = {
           message: input,
       };
-      if (options.attachStacktrace && syntheticException) {
+      if (attachStacktrace && syntheticException) {
           const frames = parseStackFrames(syntheticException);
           if (frames.length) {
               event.stacktrace = { frames };
@@ -4892,7 +4926,7 @@ var Sentry = (function (exports) {
       const document = global$4.document;
       let fetchImpl = global$4.fetch;
       // eslint-disable-next-line deprecation/deprecation
-      if (document && typeof document.createElement === `function`) {
+      if (document && typeof document.createElement === 'function') {
           try {
               const sandbox = document.createElement('iframe');
               sandbox.hidden = true;
@@ -4904,9 +4938,7 @@ var Sentry = (function (exports) {
               document.head.removeChild(sandbox);
           }
           catch (e) {
-              if (isDebugBuild()) {
-                  logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', e);
-              }
+              logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', e);
           }
       }
       return (cachedFetchImpl = fetchImpl.bind(global$4));
@@ -5035,13 +5067,11 @@ var Sentry = (function (exports) {
        */
       _handleResponse({ requestType, response, headers, resolve, reject, }) {
           const status = eventStatusFromHttpCode(response.status);
-          /**
-           * "The name is case-insensitive."
-           * https://developer.mozilla.org/en-US/docs/Web/API/Headers/get
-           */
-          const limited = this._handleRateLimit(headers);
-          if (limited && isDebugBuild()) {
-              logger.warn(`Too many ${requestType} requests, backing off until: ${this._disabledUntil(requestType)}`);
+          this._rateLimits = updateRateLimits(this._rateLimits, headers);
+          // eslint-disable-next-line deprecation/deprecation
+          if (this._isRateLimited(requestType) && isDebugBuild()) {
+              // eslint-disable-next-line deprecation/deprecation
+                  logger.warn(`Too many ${requestType} requests, backing off until: ${this._disabledUntil(requestType)}`);
           }
           if (status === 'success') {
               resolve({ status });
@@ -5051,50 +5081,21 @@ var Sentry = (function (exports) {
       }
       /**
        * Gets the time that given category is disabled until for rate limiting
+       *
+       * @deprecated Please use `disabledUntil` from @sentry/utils
        */
       _disabledUntil(requestType) {
           const category = requestTypeToCategory(requestType);
-          return this._rateLimits[category] || this._rateLimits.all;
+          return new Date(disabledUntil(this._rateLimits, category));
       }
       /**
        * Checks if a category is rate limited
+       *
+       * @deprecated Please use `isRateLimited` from @sentry/utils
        */
       _isRateLimited(requestType) {
-          return this._disabledUntil(requestType) > new Date(Date.now());
-      }
-      /**
-       * Sets internal _rateLimits from incoming headers. Returns true if headers contains a non-empty rate limiting header.
-       */
-      _handleRateLimit(headers) {
-          const now = Date.now();
-          const rlHeader = headers['x-sentry-rate-limits'];
-          const raHeader = headers['retry-after'];
-          if (rlHeader) {
-              // rate limit headers are of the form
-              //     <header>,<header>,..
-              // where each <header> is of the form
-              //     <retry_after>: <categories>: <scope>: <reason_code>
-              // where
-              //     <retry_after> is a delay in ms
-              //     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form
-              //         <category>;<category>;...
-              //     <scope> is what's being limited (org, project, or key) - ignored by SDK
-              //     <reason_code> is an arbitrary string like "org_quota" - ignored by SDK
-              for (const limit of rlHeader.trim().split(',')) {
-                  const parameters = limit.split(':', 2);
-                  const headerDelay = parseInt(parameters[0], 10);
-                  const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default
-                  for (const category of parameters[1].split(';')) {
-                      this._rateLimits[category || 'all'] = new Date(now + delay);
-                  }
-              }
-              return true;
-          }
-          else if (raHeader) {
-              this._rateLimits.all = new Date(now + parseRetryAfterHeader(now, raHeader));
-              return true;
-          }
-          return false;
+          const category = requestTypeToCategory(requestType);
+          return isRateLimited(this._rateLimits, category);
       }
   }
 
@@ -5109,11 +5110,13 @@ var Sentry = (function (exports) {
        * @param originalPayload Original payload used to create SentryRequest
        */
       _sendRequest(sentryRequest, originalPayload) {
+          // eslint-disable-next-line deprecation/deprecation
           if (this._isRateLimited(sentryRequest.type)) {
               this.recordLostEvent('ratelimit_backoff', sentryRequest.type);
               return Promise.reject({
                   event: originalPayload,
                   type: sentryRequest.type,
+                  // eslint-disable-next-line deprecation/deprecation
                   reason: `Transport for ${sentryRequest.type} requests locked till ${this._disabledUntil(sentryRequest.type)} due to too many requests.`,
                   status: 429,
               });
@@ -5171,11 +5174,13 @@ var Sentry = (function (exports) {
        * @param originalPayload Original payload used to create SentryRequest
        */
       _sendRequest(sentryRequest, originalPayload) {
+          // eslint-disable-next-line deprecation/deprecation
           if (this._isRateLimited(sentryRequest.type)) {
               this.recordLostEvent('ratelimit_backoff', sentryRequest.type);
               return Promise.reject({
                   event: originalPayload,
                   type: sentryRequest.type,
+                  // eslint-disable-next-line deprecation/deprecation
                   reason: `Transport for ${sentryRequest.type} requests locked till ${this._disabledUntil(sentryRequest.type)} due to too many requests.`,
                   status: 429,
               });
@@ -5229,13 +5234,13 @@ var Sentry = (function (exports) {
        * @inheritDoc
        */
       eventFromException(exception, hint) {
-          return eventFromException(this._options, exception, hint);
+          return eventFromException(exception, hint, this._options.attachStacktrace);
       }
       /**
        * @inheritDoc
        */
       eventFromMessage(message, level = exports.Severity.Info, hint) {
-          return eventFromMessage(this._options, message, level, hint);
+          return eventFromMessage(message, level, hint, this._options.attachStacktrace);
       }
       /**
        * @inheritDoc
@@ -5381,15 +5386,11 @@ var Sentry = (function (exports) {
           return;
       }
       if (!options.eventId) {
-          if (isDebugBuild()) {
-              logger.error(`Missing eventId option in showReportDialog call`);
-          }
+          logger.error('Missing eventId option in showReportDialog call');
           return;
       }
       if (!options.dsn) {
-          if (isDebugBuild()) {
-              logger.error(`Missing dsn option in showReportDialog call`);
-          }
+          logger.error('Missing dsn option in showReportDialog call');
           return;
       }
       const script = global$2.document.createElement('script');
@@ -5462,10 +5463,7 @@ var Sentry = (function (exports) {
           }
           const event = error === undefined && isString(msg)
               ? _eventFromIncompleteOnError(msg, url, line, column)
-              : _enhanceEventWithInitialFrame(eventFromUnknownInput(error || msg, undefined, {
-                  attachStacktrace,
-                  isRejection: false,
-              }), url, line, column);
+              : _enhanceEventWithInitialFrame(eventFromUnknownInput(error || msg, undefined, attachStacktrace, false), url, line, column);
           event.level = exports.Severity.Error;
           addMechanismAndCapture(hub, error, event, 'onerror');
       });
@@ -5504,10 +5502,7 @@ var Sentry = (function (exports) {
           }
           const event = isPrimitive(error)
               ? _eventFromRejectionWithPrimitive(error)
-              : eventFromUnknownInput(error, undefined, {
-                  attachStacktrace,
-                  isRejection: true,
-              });
+              : eventFromUnknownInput(error, undefined, attachStacktrace, true);
           event.level = exports.Severity.Error;
           addMechanismAndCapture(hub, error, event, 'onunhandledrejection');
           return;
@@ -5587,9 +5582,7 @@ var Sentry = (function (exports) {
       return event;
   }
   function globalHandlerLog(type) {
-      if (isDebugBuild()) {
-          logger.log(`Global Handler attached: ${type}`);
-      }
+      logger.log(`Global Handler attached: ${type}`);
   }
   function addMechanismAndCapture(hub, error, event, type) {
       addExceptionMechanism(event, {
@@ -5700,16 +5693,18 @@ var Sentry = (function (exports) {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       return function (callback) {
           // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-          return original.call(this, wrap$1(callback, {
-              mechanism: {
-                  data: {
-                      function: 'requestAnimationFrame',
-                      handler: getFunctionName(original),
+          return original.apply(this, [
+              wrap$1(callback, {
+                  mechanism: {
+                      data: {
+                          function: 'requestAnimationFrame',
+                          handler: getFunctionName(original),
+                      },
+                      handled: true,
+                      type: 'instrument',
                   },
-                  handled: true,
-                  type: 'instrument',
-              },
-          }));
+              }),
+          ]);
       };
   }
   /** JSDoc */
@@ -5776,19 +5771,22 @@ var Sentry = (function (exports) {
               catch (err) {
                   // can sometimes get 'Permission denied to access property "handle Event'
               }
-              return original.call(this, eventName, 
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              wrap$1(fn, {
-                  mechanism: {
-                      data: {
-                          function: 'addEventListener',
-                          handler: getFunctionName(fn),
-                          target,
+              return original.apply(this, [
+                  eventName,
+                  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                  wrap$1(fn, {
+                      mechanism: {
+                          data: {
+                              function: 'addEventListener',
+                              handler: getFunctionName(fn),
+                              target,
+                          },
+                          handled: true,
+                          type: 'instrument',
                       },
-                      handled: true,
-                      type: 'instrument',
-                  },
-              }), options);
+                  }),
+                  options,
+              ]);
           };
       });
       fill(proto, 'removeEventListener', function (originalRemoveEventListener) {
@@ -6150,7 +6148,7 @@ var Sentry = (function (exports) {
                   // Juuust in case something goes wrong
                   try {
                       if (_shouldDropEvent(currentEvent, self._previousEvent)) {
-                          logger.warn(`Event dropped due to being a duplicate of previously captured event.`);
+                          logger.warn('Event dropped due to being a duplicate of previously captured event.');
                           return null;
                       }
                   }
@@ -6511,9 +6509,7 @@ var Sentry = (function (exports) {
       if (client) {
           return client.flush(timeout);
       }
-      if (isDebugBuild()) {
-          logger.warn('Cannot flush events. No client defined.');
-      }
+      logger.warn('Cannot flush events. No client defined.');
       return resolvedSyncPromise(false);
   }
   /**
@@ -6529,9 +6525,7 @@ var Sentry = (function (exports) {
       if (client) {
           return client.close(timeout);
       }
-      if (isDebugBuild()) {
-          logger.warn('Cannot flush events and disable SDK. No client defined.');
-      }
+      logger.warn('Cannot flush events and disable SDK. No client defined.');
       return resolvedSyncPromise(false);
   }
   /**
@@ -6556,9 +6550,7 @@ var Sentry = (function (exports) {
       const window = getGlobalObject();
       const document = window.document;
       if (typeof document === 'undefined') {
-          if (isDebugBuild()) {
-              logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');
-          }
+          logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');
           return;
       }
       const hub = getCurrentHub();