@sentry/browser 6.7.2 → 6.8.0

package/build/bundle.es6.js

@@ -1,4 +1,4 @@
-/*! @sentry/browser 6.7.2 (35498a6) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 6.8.0 (e93d96f) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
   /** Console logging verbosity for the SDK. */
   var LogLevel;
@@ -286,7 +286,7 @@ var Sentry = (function (exports) {
    * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]
    * @returns generated DOM path
    */
-  function htmlTreeAsString(elem, keyAttr) {
+  function htmlTreeAsString(elem, keyAttrs) {
       // try/catch both:
       // - accessing event.target (see getsentry/raven-js#838, #768)
       // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly
@@ -303,7 +303,7 @@ var Sentry = (function (exports) {
           let nextStr;
           // eslint-disable-next-line no-plusplus
           while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {
-              nextStr = _htmlElementAsString(currentElem, keyAttr);
+              nextStr = _htmlElementAsString(currentElem, keyAttrs);
               // bail out if
               // - nextStr is the 'html' element
               // - the length of the string that would be created exceeds MAX_OUTPUT_LEN
@@ -326,7 +326,8 @@ var Sentry = (function (exports) {
    * e.g. [HTMLElement] => input#foo.btn[name=baz]
    * @returns generated DOM path
    */
-  function _htmlElementAsString(el, keyAttr) {
+  function _htmlElementAsString(el, keyAttrs) {
+      var _a, _b;
       const elem = el;
       const out = [];
       let className;
@@ -338,9 +339,13 @@ var Sentry = (function (exports) {
           return '';
       }
       out.push(elem.tagName.toLowerCase());
-      const keyAttrValue = keyAttr ? elem.getAttribute(keyAttr) : null;
-      if (keyAttrValue) {
-          out.push(`[${keyAttr}="${keyAttrValue}"]`);
+      // Pairs of attribute keys defined in `serializeAttribute` and their values on element.
+      const keyAttrPairs = ((_a = keyAttrs) === null || _a === void 0 ? void 0 : _a.length) ? keyAttrs.filter(keyAttr => elem.getAttribute(keyAttr)).map(keyAttr => [keyAttr, elem.getAttribute(keyAttr)])
+          : null;
+      if ((_b = keyAttrPairs) === null || _b === void 0 ? void 0 : _b.length) {
+          keyAttrPairs.forEach(keyAttrPair => {
+              out.push(`[${keyAttrPair[0]}="${keyAttrPair[1]}"]`);
+          });
       }
       else {
           if (elem.id) {
@@ -1987,13 +1992,15 @@ var Sentry = (function (exports) {
       /**
        * Add a promise to the queue.
        *
-       * @param task Can be any PromiseLike<T>
+       * @param taskProducer A function producing any PromiseLike<T>; In previous versions this used to be `task: PromiseLike<T>`,
+       *        however, Promises were instantly created on the call-site, making them fall through the buffer limit.
        * @returns The original promise.
        */
-      add(task) {
+      add(taskProducer) {
           if (!this.isReady()) {
               return SyncPromise.reject(new SentryError('Not adding Promise due to buffer limit reached.'));
           }
+          const task = taskProducer();
           if (this._buffer.indexOf(task) === -1) {
               this._buffer.push(task);
           }
@@ -4216,7 +4223,7 @@ var Sentry = (function (exports) {
       hub.bindClient(client);
   }
 
-  const SDK_VERSION = '6.7.2';
+  const SDK_VERSION = '6.8.0';
 
   let originalFunctionToString;
   /** Patch toString calls to return proper name for wrapped functions */
@@ -5059,7 +5066,7 @@ var Sentry = (function (exports) {
           if (this.options.headers !== undefined) {
               options.headers = this.options.headers;
           }
-          return this._buffer.add(new SyncPromise((resolve, reject) => {
+          return this._buffer.add(() => new SyncPromise((resolve, reject) => {
               void this._fetch(sentryRequest.url, options)
                   .then(response => {
                   const headers = {
@@ -5106,7 +5113,7 @@ var Sentry = (function (exports) {
                   status: 429,
               });
           }
-          return this._buffer.add(new SyncPromise((resolve, reject) => {
+          return this._buffer.add(() => new SyncPromise((resolve, reject) => {
               const request = new XMLHttpRequest();
               request.onreadystatechange = () => {
                   if (request.readyState === 4) {
@@ -5371,9 +5378,9 @@ var Sentry = (function (exports) {
                       return;
                   }
                   const client = currentHub.getClient();
-                  const event = isPrimitive(error)
+                  const event = error === undefined && isString(data.msg)
                       ? this._eventFromIncompleteOnError(data.msg, data.url, data.line, data.column)
-                      : this._enhanceEventWithInitialFrame(eventFromUnknownInput(error, undefined, {
+                      : this._enhanceEventWithInitialFrame(eventFromUnknownInput(error || data.msg, undefined, {
                           attachStacktrace: client && client.getOptions().attachStacktrace,
                           rejection: false,
                       }), data.url, data.line, data.column);
@@ -5453,12 +5460,10 @@ var Sentry = (function (exports) {
           // If 'message' is ErrorEvent, get real message from inside
           let message = isErrorEvent(msg) ? msg.message : msg;
           let name;
-          if (isString(message)) {
-              const groups = message.match(ERROR_TYPES_RE);
-              if (groups) {
-                  name = groups[1];
-                  message = groups[2];
-              }
+          const groups = message.match(ERROR_TYPES_RE);
+          if (groups) {
+              name = groups[1];
+              message = groups[2];
           }
           const event = {
               exception: {
@@ -5853,12 +5858,15 @@ var Sentry = (function (exports) {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       _domBreadcrumb(handlerData) {
           let target;
-          const keyAttr = typeof this._options.dom === 'object' ? this._options.dom.serializeAttribute : undefined;
+          let keyAttrs = typeof this._options.dom === 'object' ? this._options.dom.serializeAttribute : undefined;
+          if (typeof keyAttrs === 'string') {
+              keyAttrs = [keyAttrs];
+          }
           // Accessing event.target can throw (see getsentry/raven-js#838, #768)
           try {
               target = handlerData.event.target
-                  ? htmlTreeAsString(handlerData.event.target, keyAttr)
-                  : htmlTreeAsString(handlerData.event, keyAttr);
+                  ? htmlTreeAsString(handlerData.event.target, keyAttrs)
+                  : htmlTreeAsString(handlerData.event, keyAttrs);
           }
           catch (e) {
               target = '<unknown>';
@@ -6065,6 +6073,169 @@ var Sentry = (function (exports) {
    */
   UserAgent.id = 'UserAgent';
 
+  /** Deduplication filter */
+  class Dedupe {
+      constructor() {
+          /**
+           * @inheritDoc
+           */
+          this.name = Dedupe.id;
+      }
+      /**
+       * @inheritDoc
+       */
+      setupOnce(addGlobalEventProcessor, getCurrentHub) {
+          addGlobalEventProcessor((currentEvent) => {
+              const self = getCurrentHub().getIntegration(Dedupe);
+              if (self) {
+                  // Juuust in case something goes wrong
+                  try {
+                      if (self._shouldDropEvent(currentEvent, self._previousEvent)) {
+                          return null;
+                      }
+                  }
+                  catch (_oO) {
+                      return (self._previousEvent = currentEvent);
+                  }
+                  return (self._previousEvent = currentEvent);
+              }
+              return currentEvent;
+          });
+      }
+      /** JSDoc */
+      _shouldDropEvent(currentEvent, previousEvent) {
+          if (!previousEvent) {
+              return false;
+          }
+          if (this._isSameMessageEvent(currentEvent, previousEvent)) {
+              return true;
+          }
+          if (this._isSameExceptionEvent(currentEvent, previousEvent)) {
+              return true;
+          }
+          return false;
+      }
+      /** JSDoc */
+      _isSameMessageEvent(currentEvent, previousEvent) {
+          const currentMessage = currentEvent.message;
+          const previousMessage = previousEvent.message;
+          // If neither event has a message property, they were both exceptions, so bail out
+          if (!currentMessage && !previousMessage) {
+              return false;
+          }
+          // If only one event has a stacktrace, but not the other one, they are not the same
+          if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {
+              return false;
+          }
+          if (currentMessage !== previousMessage) {
+              return false;
+          }
+          if (!this._isSameFingerprint(currentEvent, previousEvent)) {
+              return false;
+          }
+          if (!this._isSameStacktrace(currentEvent, previousEvent)) {
+              return false;
+          }
+          return true;
+      }
+      /** JSDoc */
+      _getFramesFromEvent(event) {
+          const exception = event.exception;
+          if (exception) {
+              try {
+                  // @ts-ignore Object could be undefined
+                  return exception.values[0].stacktrace.frames;
+              }
+              catch (_oO) {
+                  return undefined;
+              }
+          }
+          else if (event.stacktrace) {
+              return event.stacktrace.frames;
+          }
+          return undefined;
+      }
+      /** JSDoc */
+      _isSameStacktrace(currentEvent, previousEvent) {
+          let currentFrames = this._getFramesFromEvent(currentEvent);
+          let previousFrames = this._getFramesFromEvent(previousEvent);
+          // If neither event has a stacktrace, they are assumed to be the same
+          if (!currentFrames && !previousFrames) {
+              return true;
+          }
+          // If only one event has a stacktrace, but not the other one, they are not the same
+          if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {
+              return false;
+          }
+          currentFrames = currentFrames;
+          previousFrames = previousFrames;
+          // If number of frames differ, they are not the same
+          if (previousFrames.length !== currentFrames.length) {
+              return false;
+          }
+          // Otherwise, compare the two
+          for (let i = 0; i < previousFrames.length; i++) {
+              const frameA = previousFrames[i];
+              const frameB = currentFrames[i];
+              if (frameA.filename !== frameB.filename ||
+                  frameA.lineno !== frameB.lineno ||
+                  frameA.colno !== frameB.colno ||
+                  frameA.function !== frameB.function) {
+                  return false;
+              }
+          }
+          return true;
+      }
+      /** JSDoc */
+      _getExceptionFromEvent(event) {
+          return event.exception && event.exception.values && event.exception.values[0];
+      }
+      /** JSDoc */
+      _isSameExceptionEvent(currentEvent, previousEvent) {
+          const previousException = this._getExceptionFromEvent(previousEvent);
+          const currentException = this._getExceptionFromEvent(currentEvent);
+          if (!previousException || !currentException) {
+              return false;
+          }
+          if (previousException.type !== currentException.type || previousException.value !== currentException.value) {
+              return false;
+          }
+          if (!this._isSameFingerprint(currentEvent, previousEvent)) {
+              return false;
+          }
+          if (!this._isSameStacktrace(currentEvent, previousEvent)) {
+              return false;
+          }
+          return true;
+      }
+      /** JSDoc */
+      _isSameFingerprint(currentEvent, previousEvent) {
+          let currentFingerprint = currentEvent.fingerprint;
+          let previousFingerprint = previousEvent.fingerprint;
+          // If neither event has a fingerprint, they are assumed to be the same
+          if (!currentFingerprint && !previousFingerprint) {
+              return true;
+          }
+          // If only one event has a fingerprint, but not the other one, they are not the same
+          if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {
+              return false;
+          }
+          currentFingerprint = currentFingerprint;
+          previousFingerprint = previousFingerprint;
+          // Otherwise, compare the two
+          try {
+              return !!(currentFingerprint.join('') === previousFingerprint.join(''));
+          }
+          catch (_oO) {
+              return false;
+          }
+      }
+  }
+  /**
+   * @inheritDoc
+   */
+  Dedupe.id = 'Dedupe';
+
 
 
   var BrowserIntegrations = /*#__PURE__*/Object.freeze({
@@ -6073,7 +6244,8 @@ var Sentry = (function (exports) {
     TryCatch: TryCatch,
     Breadcrumbs: Breadcrumbs,
     LinkedErrors: LinkedErrors,
-    UserAgent: UserAgent
+    UserAgent: UserAgent,
+    Dedupe: Dedupe
   });
 
   /**
@@ -6145,6 +6317,7 @@ var Sentry = (function (exports) {
       new Breadcrumbs(),
       new GlobalHandlers(),
       new LinkedErrors(),
+      new Dedupe(),
       new UserAgent(),
   ];
   /**