@sentry/browser 6.19.2 → 6.19.3

package/bundles/bundle.js

@@ -1,4 +1,4 @@
-/*! @sentry/browser 6.19.2 (f49c509) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 6.19.3 (fe6f7b3) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
 
     /*! *****************************************************************************
@@ -279,6 +279,16 @@ var Sentry = (function (exports) {
     function isSyntheticEvent(wat) {
         return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;
     }
+    /**
+     * Checks whether given value is NaN
+     * {@link isNaN}.
+     *
+     * @param wat A value to be checked.
+     * @returns A boolean representing the result.
+     */
+    function isNaN$1(wat) {
+        return typeof wat === 'number' && wat !== wat;
+    }
     /**
      * Checks whether given value's type is an instance of provided constructor.
      * {@link isInstanceOf}.
@@ -764,55 +774,38 @@ var Sentry = (function (exports) {
      *
      * @param value Initial source that we have to transform in order for it to be usable by the serializer
      */
-    function getWalkSource(value) {
+    function convertToPlainObject(value) {
+        var newObj = value;
         if (isError(value)) {
-            var error = value;
-            var err = {
-                message: error.message,
-                name: error.name,
-                stack: error.stack,
-            };
-            for (var i in error) {
-                if (Object.prototype.hasOwnProperty.call(error, i)) {
-                    err[i] = error[i];
-                }
-            }
-            return err;
+            newObj = __assign({ message: value.message, name: value.name, stack: value.stack }, getOwnProperties(value));
         }
-        if (isEvent(value)) {
+        else if (isEvent(value)) {
             var event_1 = value;
-            var source = {};
-            // Accessing event attributes can throw (see https://github.com/getsentry/sentry-javascript/issues/768 and
-            // https://github.com/getsentry/sentry-javascript/issues/838), but accessing `type` hasn't been wrapped in a
-            // try-catch in at least two years and no one's complained, so that's likely not an issue anymore
-            source.type = event_1.type;
-            try {
-                source.target = isElement(event_1.target)
-                    ? htmlTreeAsString(event_1.target)
-                    : Object.prototype.toString.call(event_1.target);
-            }
-            catch (_oO) {
-                source.target = '<unknown>';
-            }
-            try {
-                source.currentTarget = isElement(event_1.currentTarget)
-                    ? htmlTreeAsString(event_1.currentTarget)
-                    : Object.prototype.toString.call(event_1.currentTarget);
-            }
-            catch (_oO) {
-                source.currentTarget = '<unknown>';
-            }
+            newObj = __assign({ type: event_1.type, target: serializeEventTarget(event_1.target), currentTarget: serializeEventTarget(event_1.currentTarget) }, getOwnProperties(event_1));
             if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {
-                source.detail = event_1.detail;
+                newObj.detail = event_1.detail;
             }
-            for (var attr in event_1) {
-                if (Object.prototype.hasOwnProperty.call(event_1, attr)) {
-                    source[attr] = event_1[attr];
-                }
+        }
+        return newObj;
+    }
+    /** Creates a string representation of the target of an `Event` object */
+    function serializeEventTarget(target) {
+        try {
+            return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);
+        }
+        catch (_oO) {
+            return '<unknown>';
+        }
+    }
+    /** Filters out all but an object's own properties */
+    function getOwnProperties(obj) {
+        var extractedProps = {};
+        for (var property in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, property)) {
+                extractedProps[property] = obj[property];
             }
-            return source;
         }
-        return value;
+        return extractedProps;
     }
     /**
      * Given any captured exception, extract its keys and create a sorted
@@ -822,7 +815,7 @@ var Sentry = (function (exports) {
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
     function extractExceptionKeysForMessage(exception, maxLength) {
         if (maxLength === void 0) { maxLength = 40; }
-        var keys = Object.keys(getWalkSource(exception));
+        var keys = Object.keys(convertToPlainObject(exception));
         keys.sort();
         if (!keys.length) {
             return '[object has no keys]';
@@ -849,13 +842,12 @@ var Sentry = (function (exports) {
     function dropUndefinedKeys(val) {
         var e_1, _a;
         if (isPlainObject(val)) {
-            var obj = val;
             var rv = {};
             try {
-                for (var _b = __values(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                for (var _b = __values(Object.keys(val)), _c = _b.next(); !_c.done; _c = _b.next()) {
                     var key = _c.value;
-                    if (typeof obj[key] !== 'undefined') {
-                        rv[key] = dropUndefinedKeys(obj[key]);
+                    if (typeof val[key] !== 'undefined') {
+                        rv[key] = dropUndefinedKeys(val[key]);
                     }
                 }
             }
@@ -1813,10 +1805,10 @@ var Sentry = (function (exports) {
         if (maxProperties === void 0) { maxProperties = +Infinity; }
         try {
             // since we're at the outermost level, there is no key
-            return walk('', input, depth, maxProperties);
+            return visit('', input, depth, maxProperties);
         }
-        catch (_oO) {
-            return '**non-serializable**';
+        catch (err) {
+            return { ERROR: "**non-serializable** (" + err + ")" };
         }
     }
     /** JSDoc */
@@ -1827,145 +1819,145 @@ var Sentry = (function (exports) {
     maxSize) {
         if (depth === void 0) { depth = 3; }
         if (maxSize === void 0) { maxSize = 100 * 1024; }
-        var serialized = normalize(object, depth);
-        if (jsonSize(serialized) > maxSize) {
+        var normalized = normalize(object, depth);
+        if (jsonSize(normalized) > maxSize) {
             return normalizeToSize(object, depth - 1, maxSize);
         }
-        return serialized;
+        return normalized;
     }
     /**
-     * Walks an object to perform a normalization on it
+     * Visits a node to perform normalization on it
      *
-     * @param key of object that's walked in current iteration
-     * @param value object to be walked
-     * @param depth Optional number indicating how deep should walking be performed
-     * @param maxProperties Optional maximum  number of properties/elements included in any single object/array
+     * @param key The key corresponding to the given node
+     * @param value The node to be visited
+     * @param depth Optional number indicating the maximum recursion depth
+     * @param maxProperties Optional maximum number of properties/elements included in any single object/array
      * @param memo Optional Memo class handling decycling
      */
-    function walk(key, value, depth, maxProperties, memo) {
+    function visit(key, value, depth, maxProperties, memo) {
         if (depth === void 0) { depth = +Infinity; }
         if (maxProperties === void 0) { maxProperties = +Infinity; }
         if (memo === void 0) { memo = memoBuilder(); }
         var _a = __read(memo, 2), memoize = _a[0], unmemoize = _a[1];
-        // If we reach the maximum depth, serialize whatever is left
+        // If the value has a `toJSON` method, see if we can bail and let it do the work
+        var valueWithToJSON = value;
+        if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {
+            try {
+                return valueWithToJSON.toJSON();
+            }
+            catch (err) {
+                // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)
+            }
+        }
+        // Get the simple cases out of the way first
+        if (value === null || (['number', 'boolean', 'string'].includes(typeof value) && !isNaN$1(value))) {
+            return value;
+        }
+        var stringified = stringifyValue(key, value);
+        // Anything we could potentially dig into more (objects or arrays) will have come back as `"[object XXXX]"`.
+        // Everything else will have already been serialized, so if we don't see that pattern, we're done.
+        if (!stringified.startsWith('[object ')) {
+            return stringified;
+        }
+        // We're also done if we've reached the max depth
         if (depth === 0) {
-            return serializeValue(value);
-        }
-        // If value implements `toJSON` method, call it and return early
-        if (value !== null && value !== undefined && typeof value.toJSON === 'function') {
-            return value.toJSON();
-        }
-        // `makeSerializable` provides a string representation of certain non-serializable values. For all others, it's a
-        // pass-through. If what comes back is a primitive (either because it's been stringified or because it was primitive
-        // all along), we're done.
-        var serializable = makeSerializable(value, key);
-        if (isPrimitive(serializable)) {
-            return serializable;
-        }
-        // Create source that we will use for the next iteration. It will either be an objectified error object (`Error` type
-        // with extracted key:value pairs) or the input itself.
-        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) ? [] : {};
-        // If we already walked that branch, bail out, as it's circular reference
+            // At this point we know `serialized` is a string of the form `"[object XXXX]"`. Clean it up so it's just `"[XXXX]"`.
+            return stringified.replace('object ', '');
+        }
+        // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.
         if (memoize(value)) {
             return '[Circular ~]';
         }
-        var propertyCount = 0;
-        // Walk all keys of the source
-        for (var innerKey in source) {
+        // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse
+        // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each
+        // property/entry, and keep track of the number of items we add to it.
+        var normalized = (Array.isArray(value) ? [] : {});
+        var numAdded = 0;
+        // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant
+        // properties are non-enumerable and otherwise would get missed.
+        var visitable = (isError(value) || isEvent(value) ? convertToPlainObject(value) : value);
+        for (var visitKey in visitable) {
             // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.
-            if (!Object.prototype.hasOwnProperty.call(source, innerKey)) {
+            if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {
                 continue;
             }
-            if (propertyCount >= maxProperties) {
-                acc[innerKey] = '[MaxProperties ~]';
+            if (numAdded >= maxProperties) {
+                normalized[visitKey] = '[MaxProperties ~]';
                 break;
             }
-            propertyCount += 1;
-            // Recursively walk through all the child nodes
-            var innerValue = source[innerKey];
-            acc[innerKey] = walk(innerKey, innerValue, depth - 1, maxProperties, memo);
+            // Recursively visit all the child nodes
+            var visitValue = visitable[visitKey];
+            normalized[visitKey] = visit(visitKey, visitValue, depth - 1, maxProperties, memo);
+            numAdded += 1;
         }
-        // Once walked through all the branches, remove the parent from memo storage
+        // Once we've visited all the branches, remove the parent from memo storage
         unmemoize(value);
         // Return accumulated values
-        return acc;
+        return normalized;
     }
     /**
-     * Transform any non-primitive, BigInt, or Symbol-type value into a string. Acts as a no-op on strings, numbers,
-     * booleans, null, and undefined.
+     * Stringify the given value. Handles various known special values and types.
      *
-     * @param value The value to stringify
-     * @returns For non-primitive, BigInt, and Symbol-type values, a string denoting the value's type, type and value, or
-     *  type and `description` property, respectively. For non-BigInt, non-Symbol primitives, returns the original value,
-     *  unchanged.
-     */
-    function serializeValue(value) {
-        // Node.js REPL notation
-        if (typeof value === 'string') {
-            return value;
-        }
-        var type = Object.prototype.toString.call(value);
-        if (type === '[object Object]') {
-            return '[Object]';
-        }
-        if (type === '[object Array]') {
-            return '[Array]';
-        }
-        // `makeSerializable` provides a string representation of certain non-serializable values. For all others, it's a
-        // pass-through.
-        var serializable = makeSerializable(value);
-        return isPrimitive(serializable) ? serializable : type;
-    }
-    /**
-     * makeSerializable()
+     * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn
+     * the number 1231 into "[Object Number]", nor on `null`, as it will throw.
      *
-     * Takes unserializable input and make it serializer-friendly.
-     *
-     * Handles globals, functions, `undefined`, `NaN`, and other non-serializable values.
+     * @param value The value to stringify
+     * @returns A stringified representation of the given value
      */
-    function makeSerializable(value, key) {
-        if (key === 'domain' && value && typeof value === 'object' && value._events) {
-            return '[Domain]';
-        }
-        if (key === 'domainEmitter') {
-            return '[DomainEmitter]';
-        }
-        if (typeof global !== 'undefined' && value === global) {
-            return '[Global]';
-        }
-        // It's safe to use `window` and `document` here in this manner, as we are asserting using `typeof` first
-        // which won't throw if they are not present.
-        // eslint-disable-next-line no-restricted-globals
-        if (typeof window !== 'undefined' && value === window) {
-            return '[Window]';
-        }
-        // eslint-disable-next-line no-restricted-globals
-        if (typeof document !== 'undefined' && value === document) {
-            return '[Document]';
-        }
-        // React's SyntheticEvent thingy
-        if (isSyntheticEvent(value)) {
-            return '[SyntheticEvent]';
-        }
-        if (typeof value === 'number' && value !== value) {
-            return '[NaN]';
-        }
-        if (value === void 0) {
-            return '[undefined]';
-        }
-        if (typeof value === 'function') {
-            return "[Function: " + getFunctionName(value) + "]";
-        }
-        // symbols and bigints are considered primitives by TS, but aren't natively JSON-serilaizable
-        if (typeof value === 'symbol') {
-            return "[" + String(value) + "]";
+    function stringifyValue(key, 
+    // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for
+    // our internal use, it'll do
+    value) {
+        try {
+            if (key === 'domain' && value && typeof value === 'object' && value._events) {
+                return '[Domain]';
+            }
+            if (key === 'domainEmitter') {
+                return '[DomainEmitter]';
+            }
+            // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first
+            // which won't throw if they are not present.
+            if (typeof global !== 'undefined' && value === global) {
+                return '[Global]';
+            }
+            // eslint-disable-next-line no-restricted-globals
+            if (typeof window !== 'undefined' && value === window) {
+                return '[Window]';
+            }
+            // eslint-disable-next-line no-restricted-globals
+            if (typeof document !== 'undefined' && value === document) {
+                return '[Document]';
+            }
+            // React's SyntheticEvent thingy
+            if (isSyntheticEvent(value)) {
+                return '[SyntheticEvent]';
+            }
+            if (typeof value === 'number' && value !== value) {
+                return '[NaN]';
+            }
+            // this catches `undefined` (but not `null`, which is a primitive and can be serialized on its own)
+            if (value === void 0) {
+                return '[undefined]';
+            }
+            if (typeof value === 'function') {
+                return "[Function: " + getFunctionName(value) + "]";
+            }
+            if (typeof value === 'symbol') {
+                return "[" + String(value) + "]";
+            }
+            // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion
+            if (typeof value === 'bigint') {
+                return "[BigInt: " + String(value) + "]";
+            }
+            // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting
+            // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as
+            // `"[object Object]"`. If we instead look at the constructor's name (which is the same as the name of the class),
+            // we can make sure that only plain objects come out that way.
+            return "[object " + Object.getPrototypeOf(value).constructor.name + "]";
         }
-        if (typeof value === 'bigint') {
-            return "[BigInt: " + String(value) + "]";
+        catch (err) {
+            return "**non-serializable** (" + err + ")";
         }
-        return value;
     }
     /** Calculates bytes size of input string */
     function utf8Length(value) {
@@ -2384,6 +2376,13 @@ var Sentry = (function (exports) {
         if (items === void 0) { items = []; }
         return [headers, items];
     }
+    /**
+     * Get the type of the envelope. Grabs the type from the first envelope item.
+     */
+    function getEnvelopeType(envelope) {
+        var _a = __read(envelope, 2), _b = __read(_a[1], 1), _c = __read(_b[0], 1), firstItemHeader = _c[0];
+        return firstItemHeader.type;
+    }
     /**
      * Serializes an envelope into a string.
      */
@@ -4190,7 +4189,7 @@ var Sentry = (function (exports) {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                 normalized.contexts.trace = event.contexts.trace;
             }
-            event.sdkProcessingMetadata = __assign(__assign({}, event.sdkProcessingMetadata), { baseClientNormalized: true });
+            normalized.sdkProcessingMetadata = __assign(__assign({}, normalized.sdkProcessingMetadata), { baseClientNormalized: true });
             return normalized;
         };
         /**
@@ -4416,6 +4415,32 @@ var Sentry = (function (exports) {
         var eventType = event.type || 'event';
         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,
+        // https://github.com/getsentry/sentry-javascript/pull/4425, and
+        // https://github.com/getsentry/sentry-javascript/pull/4574.
+        //
+        // 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 either of the PR URLs above and pull out the companion hacks in the browser playwright tests and the
+        //    baseClient tests in this package
+        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/extra data
+        if (!(event.sdkProcessingMetadata && event.sdkProcessingMetadata.baseClientNormalized)) {
+            event.tags.skippedNormalization = true;
+            event.extra.normalizeDepth = event.sdkProcessingMetadata ? event.sdkProcessingMetadata.normalizeDepth : 'unset';
+        }
+        // prevent this data from being sent to sentry
+        // TODO: This is NOT part of the hack - DO NOT DELETE
+        delete event.sdkProcessingMetadata;
         var envelopeHeaders = __assign(__assign({ event_id: event.event_id, sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (!!api.tunnel && { dsn: dsnToString(api.dsn) }));
         var eventItem = [
             {
@@ -4644,7 +4669,61 @@ var Sentry = (function (exports) {
         hub.bindClient(client);
     }
 
-    var SDK_VERSION = '6.19.2';
+    var DEFAULT_TRANSPORT_BUFFER_SIZE = 30;
+    /**
+     * Creates a `NewTransport`
+     *
+     * @param options
+     * @param makeRequest
+     */
+    function createTransport(options, makeRequest, buffer) {
+        if (buffer === void 0) { buffer = makePromiseBuffer(options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE); }
+        var rateLimits = {};
+        var flush = function (timeout) { return buffer.drain(timeout); };
+        function send(envelope) {
+            var envCategory = getEnvelopeType(envelope);
+            var category = envCategory === 'event' ? 'error' : envCategory;
+            var request = {
+                category: category,
+                body: serializeEnvelope(envelope),
+            };
+            // Don't add to buffer if transport is already rate-limited
+            if (isRateLimited(rateLimits, category)) {
+                return rejectedSyncPromise({
+                    status: 'rate_limit',
+                    reason: getRateLimitReason(rateLimits, category),
+                });
+            }
+            var requestTask = function () {
+                return makeRequest(request).then(function (_a) {
+                    var body = _a.body, headers = _a.headers, reason = _a.reason, statusCode = _a.statusCode;
+                    var status = eventStatusFromHttpCode(statusCode);
+                    if (headers) {
+                        rateLimits = updateRateLimits(rateLimits, headers);
+                    }
+                    if (status === 'success') {
+                        return resolvedSyncPromise({ status: status, reason: reason });
+                    }
+                    return rejectedSyncPromise({
+                        status: status,
+                        reason: reason ||
+                            body ||
+                            (status === 'rate_limit' ? getRateLimitReason(rateLimits, category) : 'Unknown transport error'),
+                    });
+                });
+            };
+            return buffer.add(requestTask);
+        }
+        return {
+            send: send,
+            flush: flush,
+        };
+    }
+    function getRateLimitReason(rateLimits, category) {
+        return "Too many " + category + " requests, backing off until: " + new Date(disabledUntil(rateLimits, category)).toISOString();
+    }
+
+    var SDK_VERSION = '6.19.3';
 
     var originalFunctionToString;
     /** Patch toString calls to return proper name for wrapped functions */
@@ -5527,11 +5606,77 @@ var Sentry = (function (exports) {
         return XHRTransport;
     }(BaseTransport));
 
+    /**
+     * Creates a Transport that uses the Fetch API to send events to Sentry.
+     */
+    function makeNewFetchTransport(options, nativeFetch) {
+        if (nativeFetch === void 0) { nativeFetch = getNativeFetchImplementation(); }
+        function makeRequest(request) {
+            var requestOptions = __assign({ body: request.body, method: 'POST', referrerPolicy: 'origin' }, options.requestOptions);
+            return nativeFetch(options.url, requestOptions).then(function (response) {
+                return response.text().then(function (body) { return ({
+                    body: body,
+                    headers: {
+                        'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),
+                        'retry-after': response.headers.get('Retry-After'),
+                    },
+                    reason: response.statusText,
+                    statusCode: response.status,
+                }); });
+            });
+        }
+        return createTransport({ bufferSize: options.bufferSize }, makeRequest);
+    }
+
+    /**
+     * The DONE ready state for XmlHttpRequest
+     *
+     * Defining it here as a constant b/c XMLHttpRequest.DONE is not always defined
+     * (e.g. during testing, it is `undefined`)
+     *
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState}
+     */
+    var XHR_READYSTATE_DONE = 4;
+    /**
+     * Creates a Transport that uses the XMLHttpRequest API to send events to Sentry.
+     */
+    function makeNewXHRTransport(options) {
+        function makeRequest(request) {
+            return new SyncPromise(function (resolve, _reject) {
+                var xhr = new XMLHttpRequest();
+                xhr.onreadystatechange = function () {
+                    if (xhr.readyState === XHR_READYSTATE_DONE) {
+                        var response = {
+                            body: xhr.response,
+                            headers: {
+                                'x-sentry-rate-limits': xhr.getResponseHeader('X-Sentry-Rate-Limits'),
+                                'retry-after': xhr.getResponseHeader('Retry-After'),
+                            },
+                            reason: xhr.statusText,
+                            statusCode: xhr.status,
+                        };
+                        resolve(response);
+                    }
+                };
+                xhr.open('POST', options.url);
+                for (var header in options.headers) {
+                    if (Object.prototype.hasOwnProperty.call(options.headers, header)) {
+                        xhr.setRequestHeader(header, options.headers[header]);
+                    }
+                }
+                xhr.send(request.body);
+            });
+        }
+        return createTransport({ bufferSize: options.bufferSize }, makeRequest);
+    }
+
     var index = /*#__PURE__*/Object.freeze({
         __proto__: null,
         BaseTransport: BaseTransport,
         FetchTransport: FetchTransport,
-        XHRTransport: XHRTransport
+        XHRTransport: XHRTransport,
+        makeNewFetchTransport: makeNewFetchTransport,
+        makeNewXHRTransport: makeNewXHRTransport
     });
 
     /**
@@ -5565,12 +5710,20 @@ var Sentry = (function (exports) {
                 return _super.prototype._setupTransport.call(this);
             }
             var transportOptions = __assign(__assign({}, this._options.transportOptions), { dsn: this._options.dsn, tunnel: this._options.tunnel, sendClientReports: this._options.sendClientReports, _metadata: this._options._metadata });
+            var api = initAPIDetails(transportOptions.dsn, transportOptions._metadata, transportOptions.tunnel);
+            var url = getEnvelopeEndpointWithUrlEncodedAuth(api.dsn, api.tunnel);
             if (this._options.transport) {
                 return new this._options.transport(transportOptions);
             }
             if (supportsFetch()) {
+                var requestOptions = __assign({}, transportOptions.fetchParameters);
+                this._newTransport = makeNewFetchTransport({ requestOptions: requestOptions, url: url });
                 return new FetchTransport(transportOptions);
             }
+            this._newTransport = makeNewXHRTransport({
+                url: url,
+                headers: transportOptions.headers,
+            });
             return new XHRTransport(transportOptions);
         };
         return BrowserBackend;