@sentry/browser 6.18.0 → 6.18.2

package/build/bundle.es6.js

@@ -1,4 +1,4 @@
-/*! @sentry/browser 6.18.0 (70c1d77) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 6.18.2 (22f518e) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
 
   /**
@@ -501,7 +501,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 +510,7 @@ var Sentry = (function (exports) {
               return;
           }
           consoleSandbox(() => {
-              global$6.console.warn(`${PREFIX}[Warn]: ${args.join(' ')}`);
+              global$6.console.warn(`${PREFIX}[Warn]:`, ...args);
           });
       }
       /** JSDoc */
@@ -519,7 +519,7 @@ var Sentry = (function (exports) {
               return;
           }
           consoleSandbox(() => {
-              global$6.console.error(`${PREFIX}[Error]: ${args.join(' ')}`);
+              global$6.console.error(`${PREFIX}[Error]:`, ...args);
           });
       }
   }
@@ -576,12 +576,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 +866,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]';
       }
@@ -929,6 +930,7 @@ var Sentry = (function (exports) {
    */
   // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
   function walk(key, value, depth = +Infinity, memo = memoBuilder()) {
+      const [memoize, unmemoize] = memo;
       // If we reach the maximum depth, serialize whatever is left
       if (depth === 0) {
           return serializeValue(value);
@@ -939,10 +941,12 @@ var Sentry = (function (exports) {
           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,7 +954,7 @@ 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 ~]';
       }
       // Walk all keys of the source
@@ -960,10 +964,11 @@ var Sentry = (function (exports) {
               continue;
           }
           // 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, memo);
       }
       // Once walked through all the branches, remove the parent from memo storage
-      memo[1](value);
+      unmemoize(value);
       // Return accumulated values
       return acc;
   }
@@ -982,7 +987,8 @@ var Sentry = (function (exports) {
   // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
   function normalize(input, depth) {
       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);
       }
       catch (_oO) {
           return '**non-serializable**';
@@ -1084,7 +1090,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;
@@ -1213,7 +1219,7 @@ var Sentry = (function (exports) {
           }
           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);
               }
           }
       }
@@ -1741,26 +1747,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.
@@ -2190,6 +2176,68 @@ var Sentry = (function (exports) {
       return dateNow;
   })();
 
+  /**
+   * Creates an envelope.
+   * Make sure to always explicitly provide the generic to this function
+   * so that the envelope types resolve correctly.
+   */
+  function createEnvelope(headers, items = []) {
+      return [headers, items];
+  }
+  /**
+   * Serializes an envelope into a string.
+   */
+  function serializeEnvelope(envelope) {
+      const [headers, items] = envelope;
+      const serializedHeaders = JSON.stringify(headers);
+      // Have to cast items to any here since Envelope is a union type
+      // Fixed in Typescript 4.2
+      // TODO: Remove any[] cast when we upgrade to TS 4.2
+      // https://github.com/microsoft/TypeScript/issues/36390
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return items.reduce((acc, item) => {
+          const [itemHeaders, payload] = item;
+          // 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);
+  }
+
+  /**
+   * Creates client report envelope
+   * @param discarded_events An array of discard events
+   * @param dsn A DSN that can be set on the header. Optional.
+   */
+  function createClientReportEnvelope(discarded_events, dsn, timestamp) {
+      const clientReportItem = [
+          { type: 'client_report' },
+          {
+              timestamp: timestamp || dateTimestampInSeconds(),
+              discarded_events,
+          },
+      ];
+      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;
+  }
+
   /**
    * Absolute maximum number of breadcrumbs added to an event.
    * The `maxBreadcrumbs` option cannot be higher than this value.
@@ -4018,7 +4066,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',
           });
       }
@@ -4062,7 +4110,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);
               }
           });
       }
@@ -4078,7 +4126,7 @@ var Sentry = (function (exports) {
           }
           void this._transport.sendSession(session).then(null, reason => {
               if (isDebugBuild()) {
-                  logger.error(`Error while sending session: ${reason}`);
+                  logger.error('Error while sending session:', reason);
               }
           });
       }
@@ -4122,14 +4170,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),
       };
@@ -4207,19 +4255,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;
   }
@@ -4244,7 +4289,7 @@ var Sentry = (function (exports) {
       hub.bindClient(client);
   }
 
-  const SDK_VERSION = '6.18.0';
+  const SDK_VERSION = '6.18.2';
 
   let originalFunctionToString;
   /** Patch toString calls to return proper name for wrapped functions */
@@ -4475,6 +4520,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,
@@ -4513,6 +4563,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.
@@ -4526,7 +4577,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
@@ -4539,6 +4590,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);
@@ -4546,16 +4598,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:
@@ -4599,7 +4654,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 === '') {
@@ -4610,13 +4665,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)}`,
                   },
               ],
           },
@@ -4650,8 +4705,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
@@ -4676,7 +4730,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) {
@@ -4686,17 +4739,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) {
@@ -4708,11 +4758,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;
@@ -4722,7 +4770,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
@@ -4744,7 +4792,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) {
@@ -4761,7 +4809,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,
           });
@@ -4776,7 +4824,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,
@@ -4786,11 +4834,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 };
@@ -4851,7 +4899,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;
@@ -4972,25 +5020,18 @@ var Sentry = (function (exports) {
           }
           logger.log(`Flushing outcomes:\n${JSON.stringify(outcomes, null, 2)}`);
           const url = getEnvelopeEndpointWithUrlEncodedAuth(this._api.dsn, this._api.tunnel);
-          // Envelope header is required to be at least an empty object
-          const envelopeHeader = JSON.stringify(Object.assign({}, (this._api.tunnel && { dsn: dsnToString(this._api.dsn) })));
-          const itemHeaders = JSON.stringify({
-              type: 'client_report',
-          });
-          const item = JSON.stringify({
-              timestamp: dateTimestampInSeconds(),
-              discarded_events: Object.keys(outcomes).map(key => {
-                  const [category, reason] = key.split(':');
-                  return {
-                      reason,
-                      category,
-                      quantity: outcomes[key],
-                  };
-              }),
+          const discardedEvents = Object.keys(outcomes).map(key => {
+              const [category, reason] = key.split(':');
+              return {
+                  reason,
+                  category,
+                  quantity: outcomes[key],
+              };
+              // TODO: Improve types on discarded_events to get rid of cast
           });
-          const envelope = `${envelopeHeader}\n${itemHeaders}\n${item}`;
+          const envelope = createClientReportEnvelope(discardedEvents, this._api.tunnel && dsnToString(this._api.dsn));
           try {
-              sendReport(url, envelope);
+              sendReport(url, serializeEnvelope(envelope));
           }
           catch (e) {
               logger.error(e);
@@ -5057,7 +5098,7 @@ var Sentry = (function (exports) {
               return true;
           }
           else if (raHeader) {
-              this._rateLimits.all = new Date(now + parseRetryAfterHeader(now, raHeader));
+              this._rateLimits.all = new Date(now + parseRetryAfterHeader(raHeader, now));
               return true;
           }
           return false;
@@ -5195,13 +5236,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
@@ -5348,13 +5389,13 @@ var Sentry = (function (exports) {
       }
       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;
       }
@@ -5428,10 +5469,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');
       });
@@ -5470,10 +5508,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;
@@ -6116,7 +6151,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;
                       }
                   }