@sentry/browser 6.17.0-beta.0 → 6.17.3

package/build/bundle.es6.js

@@ -1,5 +1,26 @@
-/*! @sentry/browser 6.17.0-beta.0 (2a9a3d4) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 6.17.3 (42e245a) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
+  /**
+   * TODO(v7): Remove this enum and replace with SeverityLevel
+   */
+  (function (Severity) {
+      /** JSDoc */
+      Severity["Fatal"] = "fatal";
+      /** JSDoc */
+      Severity["Error"] = "error";
+      /** JSDoc */
+      Severity["Warning"] = "warning";
+      /** JSDoc */
+      Severity["Log"] = "log";
+      /** JSDoc */
+      Severity["Info"] = "info";
+      /** JSDoc */
+      Severity["Debug"] = "debug";
+      /** JSDoc */
+      Severity["Critical"] = "critical";
+  })(exports.Severity || (exports.Severity = {}));
+  const SeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug', 'critical'];
+
   /**
    * Consumes the promise and logs the error when it rejects.
    * @param promise A promise to forget.
@@ -151,7 +172,7 @@ var Sentry = (function (exports) {
       return isBuiltin(wat, 'String');
   }
   /**
-   * Checks whether given value's is a primitive (undefined, null, number, boolean, string, bigint, symbol)
+   * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)
    * {@link isPrimitive}.
    *
    * @param wat A value to be checked.
@@ -394,7 +415,7 @@ var Sentry = (function (exports) {
   function dsnFromString(str) {
       const match = DSN_REGEX.exec(str);
       if (!match) {
-          throw new SentryError('Invalid Dsn');
+          throw new SentryError(`Invalid Sentry Dsn: ${str}`);
       }
       const [protocol, publicKey, pass = '', host, port = '', lastPath] = match.slice(1);
       let path = '';
@@ -436,17 +457,17 @@ var Sentry = (function (exports) {
       const requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];
       requiredComponents.forEach(component => {
           if (!dsn[component]) {
-              throw new SentryError(`Invalid Dsn: ${component} missing`);
+              throw new SentryError(`Invalid Sentry Dsn: ${component} missing`);
           }
       });
       if (!projectId.match(/^\d+$/)) {
-          throw new SentryError(`Invalid Dsn: Invalid projectId ${projectId}`);
+          throw new SentryError(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);
       }
       if (!isValidProtocol(protocol)) {
-          throw new SentryError(`Invalid Dsn: Invalid protocol ${protocol}`);
+          throw new SentryError(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);
       }
       if (port && isNaN(parseInt(port, 10))) {
-          throw new SentryError(`Invalid Dsn: Invalid port ${port}`);
+          throw new SentryError(`Invalid Sentry Dsn: Invalid port ${port}`);
       }
       return true;
   }
@@ -892,7 +913,7 @@ var Sentry = (function (exports) {
    */
   // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
   function walk(key, value, depth = +Infinity, memo = memoBuilder()) {
-      // If we reach the maximum depth, serialize whatever has left
+      // If we reach the maximum depth, serialize whatever is left
       if (depth === 0) {
           return serializeValue(value);
       }
@@ -902,12 +923,13 @@ 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 we can just bail out, as theres no point in going down that branch any further
+      // 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;
       }
-      // Create source that we will use for next itterations, either objectified error object (Error type with extracted keys:value pairs) or the input itself
+      // 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.
       const source = getWalkSource(value);
       // Create an accumulator that will act as a parent for all future itterations of that branch
       const acc = Array.isArray(value) ? [] : {};
@@ -1072,9 +1094,9 @@ var Sentry = (function (exports) {
    * @returns Answer to the given question.
    */
   function supportsReferrerPolicy() {
-      // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default
-      // https://caniuse.com/#feat=referrer-policy
-      // It doesn't. And it throw exception instead of ignoring this parameter...
+      // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'
+      // (see https://caniuse.com/#feat=referrer-policy),
+      // it doesn't. And it throws an exception instead of ignoring this parameter...
       // REF: https://github.com/getsentry/raven-js/issues/1233
       if (!supportsFetch()) {
           return false;
@@ -1257,9 +1279,6 @@ var Sentry = (function (exports) {
       if (!('XMLHttpRequest' in global$2)) {
           return;
       }
-      // Poor man's implementation of ES6 `Map`, tracking and keeping in sync key and value separately.
-      const requestKeys = [];
-      const requestValues = [];
       const xhrproto = XMLHttpRequest.prototype;
       fill(xhrproto, 'open', function (originalOpen) {
           return function (...args) {
@@ -1286,20 +1305,6 @@ var Sentry = (function (exports) {
                       catch (e) {
                           /* do nothing */
                       }
-                      try {
-                          const requestPos = requestKeys.indexOf(xhr);
-                          if (requestPos !== -1) {
-                              // Make sure to pop both key and value to keep it in sync.
-                              requestKeys.splice(requestPos);
-                              const args = requestValues.splice(requestPos)[0];
-                              if (args[0] !== undefined) {
-                                  xhrInfo.body = args[0];
-                              }
-                          }
-                      }
-                      catch (e) {
-                          /* do nothing */
-                      }
                       triggerHandlers('xhr', {
                           args,
                           endTimestamp: Date.now(),
@@ -1324,8 +1329,9 @@ var Sentry = (function (exports) {
       });
       fill(xhrproto, 'send', function (originalSend) {
           return function (...args) {
-              requestKeys.push(this);
-              requestValues.push(args);
+              if (this.__sentry_xhr__ && args[0] !== undefined) {
+                  this.__sentry_xhr__.body = args[0];
+              }
               triggerHandlers('xhr', {
                   args,
                   startTimestamp: Date.now(),
@@ -2012,28 +2018,6 @@ var Sentry = (function (exports) {
       };
   }
 
-  /** JSDoc
-   * @deprecated Use string literals - if you require type casting, cast to SeverityLevel type
-   */
-  var Severity;
-  (function (Severity) {
-      /** JSDoc */
-      Severity["Fatal"] = "fatal";
-      /** JSDoc */
-      Severity["Error"] = "error";
-      /** JSDoc */
-      Severity["Warning"] = "warning";
-      /** JSDoc */
-      Severity["Log"] = "log";
-      /** JSDoc */
-      Severity["Info"] = "info";
-      /** JSDoc */
-      Severity["Debug"] = "debug";
-      /** JSDoc */
-      Severity["Critical"] = "critical";
-  })(Severity || (Severity = {}));
-  const SeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug', 'critical'];
-
   function isSupportedSeverity(level) {
       return SeverityLevels.indexOf(level) !== -1;
   }
@@ -2045,11 +2029,11 @@ var Sentry = (function (exports) {
    */
   function severityFromString(level) {
       if (level === 'warn')
-          return 'warning';
+          return exports.Severity.Warning;
       if (isSupportedSeverity(level)) {
           return level;
       }
-      return 'log';
+      return exports.Severity.Log;
   }
 
   /**
@@ -2230,6 +2214,11 @@ var Sentry = (function (exports) {
           this._extra = {};
           /** Contexts */
           this._contexts = {};
+          /**
+           * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get
+           * sent to Sentry
+           */
+          this._sdkProcessingMetadata = {};
       }
       /**
        * Inherit values from the parent scope.
@@ -2392,18 +2381,10 @@ var Sentry = (function (exports) {
        * @inheritDoc
        */
       getTransaction() {
-          // often, this span will be a transaction, but it's not guaranteed to be
+          // Often, this span (if it exists at all) will be a transaction, but it's not guaranteed to be. Regardless, it will
+          // have a pointer to the currently-active transaction.
           const span = this.getSpan();
-          // try it the new way first
-          if (span && span.transaction) {
-              return span.transaction;
-          }
-          // fallback to the old way (known bug: this only finds transactions with sampled = true)
-          if (span && span.spanRecorder && span.spanRecorder.spans[0]) {
-              return span.spanRecorder.spans[0];
-          }
-          // neither way found a transaction
-          return undefined;
+          return span && span.transaction;
       }
       /**
        * @inheritDoc
@@ -2553,8 +2534,16 @@ var Sentry = (function (exports) {
           this._applyFingerprint(event);
           event.breadcrumbs = [...(event.breadcrumbs || []), ...this._breadcrumbs];
           event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;
+          event.sdkProcessingMetadata = this._sdkProcessingMetadata;
           return this._notifyEventProcessors([...getGlobalEventProcessors(), ...this._eventProcessors], event, hint);
       }
+      /**
+       * Add data which will be accessible during event processing but won't get sent to Sentry
+       */
+      setSDKProcessingMetadata(newData) {
+          this._sdkProcessingMetadata = Object.assign(Object.assign({}, this._sdkProcessingMetadata), newData);
+          return this;
+      }
       /**
        * This will be called after {@link applyToEvent} is finished.
        */
@@ -3275,7 +3264,7 @@ var Sentry = (function (exports) {
    * Captures a message event and sends it to Sentry.
    *
    * @param message The message to send to Sentry.
-   * @param SeverityLevel Define the level of the message.
+   * @param Severity Define the level of the message.
    * @returns The generated eventId.
    */
   function captureMessage(message, captureContext) {
@@ -3872,10 +3861,7 @@ var Sentry = (function (exports) {
               // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
               normalized.contexts.trace = event.contexts.trace;
           }
-          const { _experiments = {} } = this.getOptions();
-          if (_experiments.ensureNoCircularStructures) {
-              return normalize(normalized);
-          }
+          event.sdkProcessingMetadata = Object.assign(Object.assign({}, event.sdkProcessingMetadata), { baseClientNormalized: true });
           return normalized;
       }
       /**
@@ -4131,31 +4117,6 @@ var Sentry = (function (exports) {
       }
   }
 
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation. All rights reserved.
-  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-  this file except in compliance with the License. You may obtain a copy of the
-  License at http://www.apache.org/licenses/LICENSE-2.0
-
-  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-  MERCHANTABLITY OR NON-INFRINGEMENT.
-
-  See the Apache Version 2.0 License for specific language governing permissions
-  and limitations under the License.
-  ***************************************************************************** */
-
-  function __rest(s, e) {
-      var t = {};
-      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-          t[p] = s[p];
-      if (s != null && typeof Object.getOwnPropertySymbols === "function")
-          for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
-              t[p[i]] = s[p[i]];
-      return t;
-  }
-
   /** Extract sdk info from from the API metadata */
   function getSdkMetadataForEnvelopeHeader(api) {
       if (!api.metadata || !api.metadata.sdk) {
@@ -4199,16 +4160,58 @@ var Sentry = (function (exports) {
       const sdkInfo = getSdkMetadataForEnvelopeHeader(api);
       const eventType = event.type || 'event';
       const useEnvelope = eventType === 'transaction' || !!api.tunnel;
-      const _a = event.debug_meta || {}, { transactionSampling } = _a, metadata = __rest(_a, ["transactionSampling"]);
+      const { transactionSampling } = event.sdkProcessingMetadata || {};
       const { method: samplingMethod, rate: sampleRate } = transactionSampling || {};
-      if (Object.keys(metadata).length === 0) {
-          delete event.debug_meta;
+      // TODO: Below is a temporary hack in order to debug a serialization error - see
+      // https://github.com/getsentry/sentry-javascript/issues/2809 and
+      // https://github.com/getsentry/sentry-javascript/pull/4425. TL;DR: even though we normalize all events (which should
+      // prevent this), something is causing `JSON.stringify` to throw a circular reference error.
+      //
+      // When it's time to remove it:
+      // 1. Delete everything between here and where the request object `req` is created, EXCEPT the line deleting
+      //    `sdkProcessingMetadata`
+      // 2. Restore the original version of the request body, which is commented out
+      // 3. Search for `skippedNormalization` and pull out the companion hack in the browser playwright tests
+      enhanceEventWithSdkInfo(event, api.metadata.sdk);
+      event.tags = event.tags || {};
+      event.extra = event.extra || {};
+      // In theory, all events should be marked as having gone through normalization and so
+      // we should never set this tag
+      if (!(event.sdkProcessingMetadata && event.sdkProcessingMetadata.baseClientNormalized)) {
+          event.tags.skippedNormalization = true;
+      }
+      // prevent this data from being sent to sentry
+      // TODO: This is NOT part of the hack - DO NOT DELETE
+      delete event.sdkProcessingMetadata;
+      let body;
+      try {
+          // 99.9% of events should get through just fine - no change in behavior for them
+          body = JSON.stringify(event);
       }
-      else {
-          event.debug_meta = metadata;
+      catch (err) {
+          // Record data about the error without replacing original event data, then force renormalization
+          event.tags.JSONStringifyError = true;
+          event.extra.JSONStringifyError = err;
+          try {
+              body = JSON.stringify(normalize(event));
+          }
+          catch (newErr) {
+              // At this point even renormalization hasn't worked, meaning something about the event data has gone very wrong.
+              // Time to cut our losses and record only the new error. With luck, even in the problematic cases we're trying to
+              // debug with this hack, we won't ever land here.
+              const innerErr = newErr;
+              body = JSON.stringify({
+                  message: 'JSON.stringify error after renormalization',
+                  // setting `extra: { innerErr }` here for some reason results in an empty object, so unpack manually
+                  extra: { message: innerErr.message, stack: innerErr.stack },
+              });
+          }
       }
       const req = {
-          body: JSON.stringify(sdkInfo ? enhanceEventWithSdkInfo(event, api.metadata.sdk) : event),
+          // this is the relevant line of code before the hack was added, to make it easy to undo said hack once we've solved
+          // the mystery
+          // body: JSON.stringify(sdkInfo ? enhanceEventWithSdkInfo(event, api.metadata.sdk) : event),
+          body,
           type: eventType,
           url: useEnvelope
               ? getEnvelopeEndpointWithUrlEncodedAuth(api.dsn, api.tunnel)
@@ -4257,7 +4260,7 @@ var Sentry = (function (exports) {
       hub.bindClient(client);
   }
 
-  const SDK_VERSION = '6.17.0-beta.0';
+  const SDK_VERSION = '6.17.3';
 
   let originalFunctionToString;
   /** Patch toString calls to return proper name for wrapped functions */
@@ -4832,7 +4835,7 @@ var Sentry = (function (exports) {
   }
 
   /**
-   * Builds and Event from a Exception
+   * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.
    * @hidden
    */
   function eventFromException(options, exception, hint) {
@@ -4841,7 +4844,7 @@ var Sentry = (function (exports) {
           attachStacktrace: options.attachStacktrace,
       });
       addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }
-      event.level = 'error';
+      event.level = exports.Severity.Error;
       if (hint && hint.event_id) {
           event.event_id = hint.event_id;
       }
@@ -4851,7 +4854,7 @@ var Sentry = (function (exports) {
    * Builds and Event from a Message
    * @hidden
    */
-  function eventFromMessage(options, message, level = 'info', hint) {
+  function eventFromMessage(options, message, level = exports.Severity.Info, hint) {
       const syntheticException = (hint && hint.syntheticException) || undefined;
       const event = eventFromString(message, syntheticException, {
           attachStacktrace: options.attachStacktrace,
@@ -4904,11 +4907,11 @@ var Sentry = (function (exports) {
           return event;
       }
       if (isPlainObject(exception) || isEvent(exception)) {
-          // If it is plain Object or Event, serialize it manually and extract options
-          // This will allow us to group events based on top-level keys
-          // which is much better than creating new group when any key/value change
+          // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize
+          // 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.rejection);
+          event = eventFromPlainObject(objectException, syntheticException, options.isRejection);
           addExceptionMechanism(event, {
               synthetic: true,
           });
@@ -5235,9 +5238,9 @@ var Sentry = (function (exports) {
           const options = {
               body: sentryRequest.body,
               method: 'POST',
-              // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default
-              // https://caniuse.com/#feat=referrer-policy
-              // It doesn't. And it throw exception instead of ignoring this parameter...
+              // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'
+              // (see https://caniuse.com/#feat=referrer-policy),
+              // it doesn't. And it throws an exception instead of ignoring this parameter...
               // REF: https://github.com/getsentry/raven-js/issues/1233
               referrerPolicy: (supportsReferrerPolicy() ? 'origin' : ''),
           };
@@ -5350,7 +5353,7 @@ var Sentry = (function (exports) {
       /**
        * @inheritDoc
        */
-      eventFromMessage(message, level = 'info', hint) {
+      eventFromMessage(message, level = exports.Severity.Info, hint) {
           return eventFromMessage(this._options, message, level, hint);
       }
       /**
@@ -5580,7 +5583,7 @@ var Sentry = (function (exports) {
               ? _eventFromIncompleteOnError(msg, url, line, column)
               : _enhanceEventWithInitialFrame(eventFromUnknownInput(error || msg, undefined, {
                   attachStacktrace,
-                  rejection: false,
+                  isRejection: false,
               }), url, line, column);
           addMechanismAndCapture(hub, error, event, 'onerror');
       });
@@ -5621,9 +5624,9 @@ var Sentry = (function (exports) {
               ? _eventFromRejectionWithPrimitive(error)
               : eventFromUnknownInput(error, undefined, {
                   attachStacktrace,
-                  rejection: true,
+                  isRejection: true,
               });
-          event.level = 'error';
+          event.level = exports.Severity.Error;
           addMechanismAndCapture(hub, error, event, 'onunhandledrejection');
           return;
       });
@@ -6110,7 +6113,7 @@ var Sentry = (function (exports) {
           getCurrentHub().addBreadcrumb({
               category: 'fetch',
               data: handlerData.fetchData,
-              level: 'error',
+              level: exports.Severity.Error,
               type: 'http',
           }, {
               data: handlerData.error,