@sentry/browser 6.17.0-beta.0 → 6.17.3

package/build/bundle.js

@@ -1,4 +1,4 @@
-/*! @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) {
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation. All rights reserved.
@@ -40,16 +40,6 @@ var Sentry = (function (exports) {
         return __assign.apply(this, arguments);
     };
 
-    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;
-    }
-
     function __values(o) {
         var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
         if (m) return m.call(o);
@@ -84,6 +74,27 @@ var Sentry = (function (exports) {
         return ar;
     }
 
+    /**
+     * 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 = {}));
+    var SeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug', 'critical'];
+
     /**
      * Consumes the promise and logs the error when it rejects.
      * @param promise A promise to forget.
@@ -235,7 +246,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.
@@ -483,7 +494,7 @@ var Sentry = (function (exports) {
     function dsnFromString(str) {
         var match = DSN_REGEX.exec(str);
         if (!match) {
-            throw new SentryError('Invalid Dsn');
+            throw new SentryError("Invalid Sentry Dsn: " + str);
         }
         var _a = __read(match.slice(1), 6), protocol = _a[0], publicKey = _a[1], _b = _a[2], pass = _b === void 0 ? '' : _b, host = _a[3], _c = _a[4], port = _c === void 0 ? '' : _c, lastPath = _a[5];
         var path = '';
@@ -525,17 +536,17 @@ var Sentry = (function (exports) {
         var requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];
         requiredComponents.forEach(function (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;
     }
@@ -999,7 +1010,7 @@ var Sentry = (function (exports) {
     function walk(key, value, depth, memo) {
         if (depth === void 0) { depth = +Infinity; }
         if (memo === void 0) { 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);
         }
@@ -1009,12 +1020,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
         var 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.
         var source = getWalkSource(value);
         // Create an accumulator that will act as a parent for all future itterations of that branch
         var acc = Array.isArray(value) ? [] : {};
@@ -1191,9 +1203,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;
@@ -1397,9 +1409,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.
-        var requestKeys = [];
-        var requestValues = [];
         var xhrproto = XMLHttpRequest.prototype;
         fill(xhrproto, 'open', function (originalOpen) {
             return function () {
@@ -1430,20 +1439,6 @@ var Sentry = (function (exports) {
                         catch (e) {
                             /* do nothing */
                         }
-                        try {
-                            var requestPos = requestKeys.indexOf(xhr);
-                            if (requestPos !== -1) {
-                                // Make sure to pop both key and value to keep it in sync.
-                                requestKeys.splice(requestPos);
-                                var args_1 = requestValues.splice(requestPos)[0];
-                                if (args_1[0] !== undefined) {
-                                    xhrInfo.body = args_1[0];
-                                }
-                            }
-                        }
-                        catch (e) {
-                            /* do nothing */
-                        }
                         triggerHandlers('xhr', {
                             args: args,
                             endTimestamp: Date.now(),
@@ -1476,8 +1471,9 @@ var Sentry = (function (exports) {
                 for (var _i = 0; _i < arguments.length; _i++) {
                     args[_i] = arguments[_i];
                 }
-                requestKeys.push(this);
-                requestValues.push(args);
+                if (this.__sentry_xhr__ && args[0] !== undefined) {
+                    this.__sentry_xhr__.body = args[0];
+                }
                 triggerHandlers('xhr', {
                     args: args,
                     startTimestamp: Date.now(),
@@ -2179,28 +2175,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 = {}));
-    var SeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug', 'critical'];
-
     function isSupportedSeverity(level) {
         return SeverityLevels.indexOf(level) !== -1;
     }
@@ -2212,11 +2186,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;
     }
 
     /**
@@ -2397,6 +2371,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.
@@ -2562,18 +2541,10 @@ var Sentry = (function (exports) {
          * @inheritDoc
          */
         Scope.prototype.getTransaction = function () {
-            // 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.
             var 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
@@ -2723,8 +2694,16 @@ var Sentry = (function (exports) {
             this._applyFingerprint(event);
             event.breadcrumbs = __spread((event.breadcrumbs || []), this._breadcrumbs);
             event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;
+            event.sdkProcessingMetadata = this._sdkProcessingMetadata;
             return this._notifyEventProcessors(__spread(getGlobalEventProcessors(), this._eventProcessors), event, hint);
         };
+        /**
+         * Add data which will be accessible during event processing but won't get sent to Sentry
+         */
+        Scope.prototype.setSDKProcessingMetadata = function (newData) {
+            this._sdkProcessingMetadata = __assign(__assign({}, this._sdkProcessingMetadata), newData);
+            return this;
+        };
         /**
          * This will be called after {@link applyToEvent} is finished.
          */
@@ -3468,7 +3447,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) {
@@ -4079,10 +4058,7 @@ var Sentry = (function (exports) {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                 normalized.contexts.trace = event.contexts.trace;
             }
-            var _a = this.getOptions()._experiments, _experiments = _a === void 0 ? {} : _a;
-            if (_experiments.ensureNoCircularStructures) {
-                return normalize(normalized);
-            }
+            event.sdkProcessingMetadata = __assign(__assign({}, event.sdkProcessingMetadata), { baseClientNormalized: true });
             return normalized;
         };
         /**
@@ -4388,16 +4364,58 @@ var Sentry = (function (exports) {
         var sdkInfo = getSdkMetadataForEnvelopeHeader(api);
         var eventType = event.type || 'event';
         var useEnvelope = eventType === 'transaction' || !!api.tunnel;
-        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) {
-            delete event.debug_meta;
+        var transactionSampling = (event.sdkProcessingMetadata || {}).transactionSampling;
+        var _a = transactionSampling || {}, samplingMethod = _a.method, sampleRate = _a.rate;
+        // 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;
+        var 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.
+                var 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 },
+                });
+            }
         }
         var 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: body,
             type: eventType,
             url: useEnvelope
                 ? getEnvelopeEndpointWithUrlEncodedAuth(api.dsn, api.tunnel)
@@ -4446,7 +4464,7 @@ var Sentry = (function (exports) {
         hub.bindClient(client);
     }
 
-    var SDK_VERSION = '6.17.0-beta.0';
+    var SDK_VERSION = '6.17.3';
 
     var originalFunctionToString;
     /** Patch toString calls to return proper name for wrapped functions */
@@ -5014,7 +5032,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) {
@@ -5023,7 +5041,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;
         }
@@ -5034,7 +5052,7 @@ var Sentry = (function (exports) {
      * @hidden
      */
     function eventFromMessage(options, message, level, hint) {
-        if (level === void 0) { level = 'info'; }
+        if (level === void 0) { level = exports.Severity.Info; }
         var syntheticException = (hint && hint.syntheticException) || undefined;
         var event = eventFromString(message, syntheticException, {
             attachStacktrace: options.attachStacktrace,
@@ -5088,11 +5106,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.
             var objectException = exception;
-            event = eventFromPlainObject(objectException, syntheticException, options.rejection);
+            event = eventFromPlainObject(objectException, syntheticException, options.isRejection);
             addExceptionMechanism(event, {
                 synthetic: true,
             });
@@ -5448,9 +5466,9 @@ var Sentry = (function (exports) {
             var 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' : ''),
             };
@@ -5579,7 +5597,7 @@ var Sentry = (function (exports) {
          * @inheritDoc
          */
         BrowserBackend.prototype.eventFromMessage = function (message, level, hint) {
-            if (level === void 0) { level = 'info'; }
+            if (level === void 0) { level = exports.Severity.Info; }
             return eventFromMessage(this._options, message, level, hint);
         };
         /**
@@ -5812,7 +5830,7 @@ var Sentry = (function (exports) {
                 ? _eventFromIncompleteOnError(msg, url, line, column)
                 : _enhanceEventWithInitialFrame(eventFromUnknownInput(error || msg, undefined, {
                     attachStacktrace: attachStacktrace,
-                    rejection: false,
+                    isRejection: false,
                 }), url, line, column);
             addMechanismAndCapture(hub, error, event, 'onerror');
         });
@@ -5853,9 +5871,9 @@ var Sentry = (function (exports) {
                 ? _eventFromRejectionWithPrimitive(error)
                 : eventFromUnknownInput(error, undefined, {
                     attachStacktrace: attachStacktrace,
-                    rejection: true,
+                    isRejection: true,
                 });
-            event.level = 'error';
+            event.level = exports.Severity.Error;
             addMechanismAndCapture(hub, error, event, 'onunhandledrejection');
             return;
         });
@@ -6351,7 +6369,7 @@ var Sentry = (function (exports) {
             getCurrentHub().addBreadcrumb({
                 category: 'fetch',
                 data: handlerData.fetchData,
-                level: 'error',
+                level: exports.Severity.Error,
                 type: 'http',
             }, {
                 data: handlerData.error,