@sentry/browser 6.6.0 → 6.8.0

package/build/bundle.js

@@ -1,4 +1,4 @@
-/*! @sentry/browser 6.6.0 (9a13c8b) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 6.8.0 (e93d96f) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation. All rights reserved.
@@ -370,7 +370,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
@@ -387,7 +387,7 @@ var Sentry = (function (exports) {
             var nextStr = void 0;
             // 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
@@ -410,7 +410,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;
         var elem = el;
         var out = [];
         var className;
@@ -422,9 +423,13 @@ var Sentry = (function (exports) {
             return '';
         }
         out.push(elem.tagName.toLowerCase());
-        var keyAttrValue = keyAttr ? elem.getAttribute(keyAttr) : null;
-        if (keyAttrValue) {
-            out.push("[" + keyAttr + "=\"" + keyAttrValue + "\"]");
+        // Pairs of attribute keys defined in `serializeAttribute` and their values on element.
+        var keyAttrPairs = ((_a = keyAttrs) === null || _a === void 0 ? void 0 : _a.length) ? keyAttrs.filter(function (keyAttr) { return elem.getAttribute(keyAttr); }).map(function (keyAttr) { return [keyAttr, elem.getAttribute(keyAttr)]; })
+            : null;
+        if ((_b = keyAttrPairs) === null || _b === void 0 ? void 0 : _b.length) {
+            keyAttrPairs.forEach(function (keyAttrPair) {
+                out.push("[" + keyAttrPair[0] + "=\"" + keyAttrPair[1] + "\"]");
+            });
         }
         else {
             if (elem.id) {
@@ -2156,14 +2161,16 @@ 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.
          */
-        PromiseBuffer.prototype.add = function (task) {
+        PromiseBuffer.prototype.add = function (taskProducer) {
             var _this = this;
             if (!this.isReady()) {
                 return SyncPromise.reject(new SentryError('Not adding Promise due to buffer limit reached.'));
             }
+            var task = taskProducer();
             if (this._buffer.indexOf(task) === -1) {
                 this._buffer.push(task);
             }
@@ -2349,6 +2356,11 @@ var Sentry = (function (exports) {
         return dateNow;
     })();
 
+    /**
+     * Absolute maximum number of breadcrumbs added to an event.
+     * The `maxBreadcrumbs` option cannot be higher than this value.
+     */
+    var MAX_BREADCRUMBS = 100;
     /**
      * Holds additional event information. {@link Scope.applyToEvent} will be
      * called by the client before an event will be sent.
@@ -2640,11 +2652,13 @@ var Sentry = (function (exports) {
          * @inheritDoc
          */
         Scope.prototype.addBreadcrumb = function (breadcrumb, maxBreadcrumbs) {
+            var maxCrumbs = typeof maxBreadcrumbs === 'number' ? Math.min(maxBreadcrumbs, MAX_BREADCRUMBS) : MAX_BREADCRUMBS;
+            // No data has been changed, so don't notify scope listeners
+            if (maxCrumbs <= 0) {
+                return this;
+            }
             var mergedBreadcrumb = __assign({ timestamp: dateTimestampInSeconds() }, breadcrumb);
-            this._breadcrumbs =
-                maxBreadcrumbs !== undefined && maxBreadcrumbs >= 0
-                    ? __spread(this._breadcrumbs, [mergedBreadcrumb]).slice(-maxBreadcrumbs)
-                    : __spread(this._breadcrumbs, [mergedBreadcrumb]);
+            this._breadcrumbs = __spread(this._breadcrumbs, [mergedBreadcrumb]).slice(-maxCrumbs);
             this._notifyScopeListeners();
             return this;
         };
@@ -2806,10 +2820,10 @@ var Sentry = (function (exports) {
         Session.prototype.update = function (context) {
             if (context === void 0) { context = {}; }
             if (context.user) {
-                if (context.user.ip_address) {
+                if (!this.ipAddress && context.user.ip_address) {
                     this.ipAddress = context.user.ip_address;
                 }
-                if (!context.did) {
+                if (!this.did && !context.did) {
                     this.did = context.user.id || context.user.email || context.user.username;
                 }
             }
@@ -2824,7 +2838,7 @@ var Sentry = (function (exports) {
             if (context.init !== undefined) {
                 this.init = context.init;
             }
-            if (context.did) {
+            if (!this.did && context.did) {
                 this.did = "" + context.did;
             }
             if (typeof context.started === 'number') {
@@ -2846,10 +2860,10 @@ var Sentry = (function (exports) {
             if (context.environment) {
                 this.environment = context.environment;
             }
-            if (context.ipAddress) {
+            if (!this.ipAddress && context.ipAddress) {
                 this.ipAddress = context.ipAddress;
             }
-            if (context.userAgent) {
+            if (!this.userAgent && context.userAgent) {
                 this.userAgent = context.userAgent;
             }
             if (typeof context.errors === 'number') {
@@ -2908,11 +2922,6 @@ var Sentry = (function (exports) {
      * with {@link Options.maxBreadcrumbs}.
      */
     var DEFAULT_BREADCRUMBS = 100;
-    /**
-     * Absolute maximum number of breadcrumbs added to an event. The
-     * `maxBreadcrumbs` option cannot be higher than this value.
-     */
-    var MAX_BREADCRUMBS = 100;
     /**
      * @inheritDoc
      */
@@ -3085,7 +3094,7 @@ var Sentry = (function (exports) {
                 : mergedBreadcrumb;
             if (finalBreadcrumb === null)
                 return;
-            scope.addBreadcrumb(finalBreadcrumb, Math.min(maxBreadcrumbs, MAX_BREADCRUMBS));
+            scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);
         };
         /**
          * @inheritDoc
@@ -3218,8 +3227,11 @@ var Sentry = (function (exports) {
         Hub.prototype.startSession = function (context) {
             var _a = this.getStackTop(), scope = _a.scope, client = _a.client;
             var _b = (client && client.getOptions()) || {}, release = _b.release, environment = _b.environment;
-            var session = new Session(__assign(__assign({ release: release,
-                environment: environment }, (scope && { user: scope.getUser() })), context));
+            // Will fetch userAgent if called from browser sdk
+            var global = getGlobalObject();
+            var userAgent = (global.navigator || {}).userAgent;
+            var session = new Session(__assign(__assign(__assign({ release: release,
+                environment: environment }, (scope && { user: scope.getUser() })), (userAgent && { userAgent: userAgent })), context));
             if (scope) {
                 // End existing session if there's one
                 var currentSession = scope.getSession && scope.getSession();
@@ -3572,19 +3584,24 @@ var Sentry = (function (exports) {
      **/
     var API = /** @class */ (function () {
         /** Create a new instance of API */
-        function API(dsn, metadata) {
+        function API(dsn, metadata, tunnel) {
             if (metadata === void 0) { metadata = {}; }
             this.dsn = dsn;
             this._dsnObject = new Dsn(dsn);
             this.metadata = metadata;
+            this._tunnel = tunnel;
         }
         /** Returns the Dsn object. */
         API.prototype.getDsn = function () {
             return this._dsnObject;
         };
+        /** Does this transport force envelopes? */
+        API.prototype.forceEnvelope = function () {
+            return !!this._tunnel;
+        };
         /** Returns the prefix to construct Sentry ingestion API endpoints. */
         API.prototype.getBaseApiEndpoint = function () {
-            var dsn = this._dsnObject;
+            var dsn = this.getDsn();
             var protocol = dsn.protocol ? dsn.protocol + ":" : '';
             var port = dsn.port ? ":" + dsn.port : '';
             return protocol + "//" + dsn.host + port + (dsn.path ? "/" + dsn.path : '') + "/api/";
@@ -3607,11 +3624,14 @@ var Sentry = (function (exports) {
          * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.
          */
         API.prototype.getEnvelopeEndpointWithUrlEncodedAuth = function () {
+            if (this.forceEnvelope()) {
+                return this._tunnel;
+            }
             return this._getEnvelopeEndpoint() + "?" + this._encodedAuth();
         };
         /** Returns only the path component for the store endpoint. */
         API.prototype.getStoreEndpointPath = function () {
-            var dsn = this._dsnObject;
+            var dsn = this.getDsn();
             return (dsn.path ? "/" + dsn.path : '') + "/api/" + dsn.projectId + "/store/";
         };
         /**
@@ -3620,7 +3640,7 @@ var Sentry = (function (exports) {
          */
         API.prototype.getRequestHeaders = function (clientName, clientVersion) {
             // CHANGE THIS to use metadata but keep clientName and clientVersion compatible
-            var dsn = this._dsnObject;
+            var dsn = this.getDsn();
             var header = ["Sentry sentry_version=" + SENTRY_API_VERSION];
             header.push("sentry_client=" + clientName + "/" + clientVersion);
             header.push("sentry_key=" + dsn.publicKey);
@@ -3635,7 +3655,7 @@ var Sentry = (function (exports) {
         /** Returns the url to the report dialog endpoint. */
         API.prototype.getReportDialogEndpoint = function (dialogOptions) {
             if (dialogOptions === void 0) { dialogOptions = {}; }
-            var dsn = this._dsnObject;
+            var dsn = this.getDsn();
             var endpoint = this.getBaseApiEndpoint() + "embed/error-page/";
             var encodedOptions = [];
             encodedOptions.push("dsn=" + dsn.toString());
@@ -3669,13 +3689,16 @@ var Sentry = (function (exports) {
         };
         /** Returns the ingest API endpoint for target. */
         API.prototype._getIngestEndpoint = function (target) {
+            if (this._tunnel) {
+                return this._tunnel;
+            }
             var base = this.getBaseApiEndpoint();
-            var dsn = this._dsnObject;
+            var dsn = this.getDsn();
             return "" + base + dsn.projectId + "/" + target + "/";
         };
         /** Returns a URL-encoded string with auth config suitable for a query string. */
         API.prototype._encodedAuth = function () {
-            var dsn = this._dsnObject;
+            var dsn = this.getDsn();
             var auth = {
                 // We send only the minimum set of required information. See
                 // https://github.com/getsentry/sentry-javascript/issues/2572.
@@ -3841,6 +3864,10 @@ var Sentry = (function (exports) {
          * @inheritDoc
          */
         BaseClient.prototype.captureSession = function (session) {
+            if (!this._isEnabled()) {
+                logger.warn('SDK not enabled, will not capture session.');
+                return;
+            }
             if (!(typeof session.release === 'string')) {
                 logger.warn('Discarded session because of missing or non-string release');
             }
@@ -3909,7 +3936,6 @@ var Sentry = (function (exports) {
             var e_1, _a;
             var crashed = false;
             var errored = false;
-            var userAgent;
             var exceptions = event.exception && event.exception.values;
             if (exceptions) {
                 errored = true;
@@ -3931,19 +3957,15 @@ var Sentry = (function (exports) {
                     finally { if (e_1) throw e_1.error; }
                 }
             }
-            var user = event.user;
-            if (!session.userAgent) {
-                var headers = event.request ? event.request.headers : {};
-                for (var key in headers) {
-                    if (key.toLowerCase() === 'user-agent') {
-                        userAgent = headers[key];
-                        break;
-                    }
-                }
+            // A session is updated and that session update is sent in only one of the two following scenarios:
+            // 1. Session with non terminal status and 0 errors + an error occurred -> Will set error count to 1 and send update
+            // 2. Session with non terminal status and 1 error + a crash occurred -> Will set status crashed and send update
+            var sessionNonTerminal = session.status === SessionStatus.Ok;
+            var shouldUpdateAndSend = (sessionNonTerminal && session.errors === 0) || (sessionNonTerminal && crashed);
+            if (shouldUpdateAndSend) {
+                session.update(__assign(__assign({}, (crashed && { status: SessionStatus.Crashed })), { errors: session.errors || Number(errored || crashed) }));
+                this.captureSession(session);
             }
-            session.update(__assign(__assign({}, (crashed && { status: SessionStatus.Crashed })), { user: user,
-                userAgent: userAgent, errors: session.errors + Number(errored || crashed) }));
-            this.captureSession(session);
         };
         /** Deliver captured session to Sentry */
         BaseClient.prototype._sendSession = function (session) {
@@ -4137,7 +4159,7 @@ var Sentry = (function (exports) {
             // eslint-disable-next-line @typescript-eslint/unbound-method
             var _a = this.getOptions(), beforeSend = _a.beforeSend, sampleRate = _a.sampleRate;
             if (!this._isEnabled()) {
-                return SyncPromise.reject(new SentryError('SDK not enabled, will not send event.'));
+                return SyncPromise.reject(new SentryError('SDK not enabled, will not capture event.'));
             }
             var isTransaction = event.type === 'transaction';
             // 1.0 === 100% events are sent
@@ -4156,15 +4178,7 @@ var Sentry = (function (exports) {
                     return prepared;
                 }
                 var beforeSendResult = beforeSend(prepared, hint);
-                if (typeof beforeSendResult === 'undefined') {
-                    throw new SentryError('`beforeSend` method has to return `null` or a valid event.');
-                }
-                else if (isThenable(beforeSendResult)) {
-                    return beforeSendResult.then(function (event) { return event; }, function (e) {
-                        throw new SentryError("beforeSend rejected with " + e);
-                    });
-                }
-                return beforeSendResult;
+                return _this._ensureBeforeSendRv(beforeSendResult);
             })
                 .then(function (processedEvent) {
                 if (processedEvent === null) {
@@ -4204,6 +4218,26 @@ var Sentry = (function (exports) {
                 return reason;
             });
         };
+        /**
+         * Verifies that return value of configured `beforeSend` is of expected type.
+         */
+        BaseClient.prototype._ensureBeforeSendRv = function (rv) {
+            var nullErr = '`beforeSend` method has to return `null` or a valid event.';
+            if (isThenable(rv)) {
+                return rv.then(function (event) {
+                    if (!(isPlainObject(event) || event === null)) {
+                        throw new SentryError(nullErr);
+                    }
+                    return event;
+                }, function (e) {
+                    throw new SentryError("beforeSend rejected with " + e);
+                });
+            }
+            else if (!(isPlainObject(rv) || rv === null)) {
+                throw new SentryError(nullErr);
+            }
+            return rv;
+        };
         return BaseClient;
     }());
 
@@ -4316,7 +4350,7 @@ var Sentry = (function (exports) {
     /** Creates a SentryRequest from a Session. */
     function sessionToSentryRequest(session, api) {
         var sdkInfo = getSdkMetadataForEnvelopeHeader(api);
-        var envelopeHeaders = JSON.stringify(__assign({ sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })));
+        var envelopeHeaders = JSON.stringify(__assign(__assign({ sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (api.forceEnvelope() && { dsn: api.getDsn().toString() })));
         // I know this is hacky but we don't want to add `session` to request type since it's never rate limited
         var type = 'aggregates' in session ? 'sessions' : 'session';
         var itemHeaders = JSON.stringify({
@@ -4332,7 +4366,7 @@ var Sentry = (function (exports) {
     function eventToSentryRequest(event, api) {
         var sdkInfo = getSdkMetadataForEnvelopeHeader(api);
         var eventType = event.type || 'event';
-        var useEnvelope = eventType === 'transaction';
+        var useEnvelope = eventType === 'transaction' || api.forceEnvelope();
         var _a = event.debug_meta || {}, transactionSampling = _a.transactionSampling, metadata = __rest(_a, ["transactionSampling"]);
         var _b = transactionSampling || {}, samplingMethod = _b.method, sampleRate = _b.rate;
         if (Object.keys(metadata).length === 0) {
@@ -4352,9 +4386,9 @@ var Sentry = (function (exports) {
         // deserialization. Instead, we only implement a minimal subset of the spec to
         // serialize events inline here.
         if (useEnvelope) {
-            var envelopeHeaders = JSON.stringify(__assign({ event_id: event.event_id, sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })));
+            var envelopeHeaders = JSON.stringify(__assign(__assign({ event_id: event.event_id, sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (api.forceEnvelope() && { dsn: api.getDsn().toString() })));
             var itemHeaders = JSON.stringify({
-                type: event.type,
+                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 }],
@@ -4387,7 +4421,7 @@ var Sentry = (function (exports) {
         hub.bindClient(client);
     }
 
-    var SDK_VERSION = '6.6.0';
+    var SDK_VERSION = '6.8.0';
 
     var originalFunctionToString;
     /** Patch toString calls to return proper name for wrapped functions */
@@ -5029,7 +5063,7 @@ var Sentry = (function (exports) {
             this._buffer = new PromiseBuffer(30);
             /** Locks transport after receiving rate limits in a response */
             this._rateLimits = {};
-            this._api = new API(options.dsn, options._metadata);
+            this._api = new API(options.dsn, options._metadata, options.tunnel);
             // eslint-disable-next-line deprecation/deprecation
             this.url = this._api.getStoreEndpointWithUrlEncodedAuth();
         }
@@ -5057,7 +5091,7 @@ var Sentry = (function (exports) {
              */
             var limited = this._handleRateLimit(headers);
             if (limited)
-                logger.warn("Too many requests, backing off until: " + this._disabledUntil(requestType));
+                logger.warn("Too many " + requestType + " requests, backing off until: " + this._disabledUntil(requestType));
             if (status === exports.Status.Success) {
                 resolve({ status: status });
                 return;
@@ -5232,7 +5266,7 @@ var Sentry = (function (exports) {
                 return Promise.reject({
                     event: originalPayload,
                     type: sentryRequest.type,
-                    reason: "Transport locked till " + this._disabledUntil(sentryRequest.type) + " due to too many requests.",
+                    reason: "Transport for " + sentryRequest.type + " requests locked till " + this._disabledUntil(sentryRequest.type) + " due to too many requests.",
                     status: 429,
                 });
             }
@@ -5251,23 +5285,25 @@ var Sentry = (function (exports) {
             if (this.options.headers !== undefined) {
                 options.headers = this.options.headers;
             }
-            return this._buffer.add(new SyncPromise(function (resolve, reject) {
-                void _this._fetch(sentryRequest.url, options)
-                    .then(function (response) {
-                    var headers = {
-                        'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),
-                        'retry-after': response.headers.get('Retry-After'),
-                    };
-                    _this._handleResponse({
-                        requestType: sentryRequest.type,
-                        response: response,
-                        headers: headers,
-                        resolve: resolve,
-                        reject: reject,
-                    });
-                })
-                    .catch(reject);
-            }));
+            return this._buffer.add(function () {
+                return new SyncPromise(function (resolve, reject) {
+                    void _this._fetch(sentryRequest.url, options)
+                        .then(function (response) {
+                        var headers = {
+                            'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),
+                            'retry-after': response.headers.get('Retry-After'),
+                        };
+                        _this._handleResponse({
+                            requestType: sentryRequest.type,
+                            response: response,
+                            headers: headers,
+                            resolve: resolve,
+                            reject: reject,
+                        });
+                    })
+                        .catch(reject);
+                });
+            });
         };
         return FetchTransport;
     }(BaseTransport));
@@ -5300,29 +5336,31 @@ var Sentry = (function (exports) {
                 return Promise.reject({
                     event: originalPayload,
                     type: sentryRequest.type,
-                    reason: "Transport locked till " + this._disabledUntil(sentryRequest.type) + " due to too many requests.",
+                    reason: "Transport for " + sentryRequest.type + " requests locked till " + this._disabledUntil(sentryRequest.type) + " due to too many requests.",
                     status: 429,
                 });
             }
-            return this._buffer.add(new SyncPromise(function (resolve, reject) {
-                var request = new XMLHttpRequest();
-                request.onreadystatechange = function () {
-                    if (request.readyState === 4) {
-                        var headers = {
-                            'x-sentry-rate-limits': request.getResponseHeader('X-Sentry-Rate-Limits'),
-                            'retry-after': request.getResponseHeader('Retry-After'),
-                        };
-                        _this._handleResponse({ requestType: sentryRequest.type, response: request, headers: headers, resolve: resolve, reject: reject });
-                    }
-                };
-                request.open('POST', sentryRequest.url);
-                for (var header in _this.options.headers) {
-                    if (_this.options.headers.hasOwnProperty(header)) {
-                        request.setRequestHeader(header, _this.options.headers[header]);
+            return this._buffer.add(function () {
+                return new SyncPromise(function (resolve, reject) {
+                    var request = new XMLHttpRequest();
+                    request.onreadystatechange = function () {
+                        if (request.readyState === 4) {
+                            var headers = {
+                                'x-sentry-rate-limits': request.getResponseHeader('X-Sentry-Rate-Limits'),
+                                'retry-after': request.getResponseHeader('Retry-After'),
+                            };
+                            _this._handleResponse({ requestType: sentryRequest.type, response: request, headers: headers, resolve: resolve, reject: reject });
+                        }
+                    };
+                    request.open('POST', sentryRequest.url);
+                    for (var header in _this.options.headers) {
+                        if (_this.options.headers.hasOwnProperty(header)) {
+                            request.setRequestHeader(header, _this.options.headers[header]);
+                        }
                     }
-                }
-                request.send(sentryRequest.body);
-            }));
+                    request.send(sentryRequest.body);
+                });
+            });
         };
         return XHRTransport;
     }(BaseTransport));
@@ -5366,7 +5404,7 @@ var Sentry = (function (exports) {
                 // We return the noop transport here in case there is no Dsn.
                 return _super.prototype._setupTransport.call(this);
             }
-            var transportOptions = __assign(__assign({}, this._options.transportOptions), { dsn: this._options.dsn, _metadata: this._options._metadata });
+            var transportOptions = __assign(__assign({}, this._options.transportOptions), { dsn: this._options.dsn, tunnel: this._options.tunnel, _metadata: this._options._metadata });
             if (this._options.transport) {
                 return new this._options.transport(transportOptions);
             }
@@ -5578,9 +5616,9 @@ var Sentry = (function (exports) {
                         return;
                     }
                     var client = currentHub.getClient();
-                    var event = isPrimitive(error)
+                    var 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);
@@ -5661,12 +5699,10 @@ var Sentry = (function (exports) {
             // If 'message' is ErrorEvent, get real message from inside
             var message = isErrorEvent(msg) ? msg.message : msg;
             var name;
-            if (isString(message)) {
-                var groups = message.match(ERROR_TYPES_RE);
-                if (groups) {
-                    name = groups[1];
-                    message = groups[2];
-                }
+            var groups = message.match(ERROR_TYPES_RE);
+            if (groups) {
+                name = groups[1];
+                message = groups[2];
             }
             var event = {
                 exception: {
@@ -6091,12 +6127,15 @@ var Sentry = (function (exports) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         Breadcrumbs.prototype._domBreadcrumb = function (handlerData) {
             var target;
-            var keyAttr = typeof this._options.dom === 'object' ? this._options.dom.serializeAttribute : undefined;
+            var 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>';
@@ -6308,6 +6347,170 @@ var Sentry = (function (exports) {
         return UserAgent;
     }());
 
+    /** Deduplication filter */
+    var Dedupe = /** @class */ (function () {
+        function Dedupe() {
+            /**
+             * @inheritDoc
+             */
+            this.name = Dedupe.id;
+        }
+        /**
+         * @inheritDoc
+         */
+        Dedupe.prototype.setupOnce = function (addGlobalEventProcessor, getCurrentHub) {
+            addGlobalEventProcessor(function (currentEvent) {
+                var 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 */
+        Dedupe.prototype._shouldDropEvent = function (currentEvent, previousEvent) {
+            if (!previousEvent) {
+                return false;
+            }
+            if (this._isSameMessageEvent(currentEvent, previousEvent)) {
+                return true;
+            }
+            if (this._isSameExceptionEvent(currentEvent, previousEvent)) {
+                return true;
+            }
+            return false;
+        };
+        /** JSDoc */
+        Dedupe.prototype._isSameMessageEvent = function (currentEvent, previousEvent) {
+            var currentMessage = currentEvent.message;
+            var 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 */
+        Dedupe.prototype._getFramesFromEvent = function (event) {
+            var 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 */
+        Dedupe.prototype._isSameStacktrace = function (currentEvent, previousEvent) {
+            var currentFrames = this._getFramesFromEvent(currentEvent);
+            var 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 (var i = 0; i < previousFrames.length; i++) {
+                var frameA = previousFrames[i];
+                var 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 */
+        Dedupe.prototype._getExceptionFromEvent = function (event) {
+            return event.exception && event.exception.values && event.exception.values[0];
+        };
+        /** JSDoc */
+        Dedupe.prototype._isSameExceptionEvent = function (currentEvent, previousEvent) {
+            var previousException = this._getExceptionFromEvent(previousEvent);
+            var 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 */
+        Dedupe.prototype._isSameFingerprint = function (currentEvent, previousEvent) {
+            var currentFingerprint = currentEvent.fingerprint;
+            var 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';
+        return Dedupe;
+    }());
+
 
 
     var BrowserIntegrations = /*#__PURE__*/Object.freeze({
@@ -6316,7 +6519,8 @@ var Sentry = (function (exports) {
         TryCatch: TryCatch,
         Breadcrumbs: Breadcrumbs,
         LinkedErrors: LinkedErrors,
-        UserAgent: UserAgent
+        UserAgent: UserAgent,
+        Dedupe: Dedupe
     });
 
     /**
@@ -6394,6 +6598,7 @@ var Sentry = (function (exports) {
         new Breadcrumbs(),
         new GlobalHandlers(),
         new LinkedErrors(),
+        new Dedupe(),
         new UserAgent(),
     ];
     /**