@sentry/browser 5.25.0-beta.2 → 5.25.0

package/build/bundle.js

@@ -1,4 +1,4 @@
-/*! @sentry/browser 5.25.0-beta.2 (84e835c) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 5.25.0 (bca2c59) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation. All rights reserved.
@@ -87,21 +87,6 @@ var Sentry = (function (exports) {
         LogLevel[LogLevel["Verbose"] = 3] = "Verbose";
     })(LogLevel || (LogLevel = {}));
 
-    /**
-     * Session Status
-     */
-    var SessionStatus;
-    (function (SessionStatus) {
-        /** JSDoc */
-        SessionStatus["Ok"] = "ok";
-        /** JSDoc */
-        SessionStatus["Exited"] = "exited";
-        /** JSDoc */
-        SessionStatus["Crashed"] = "crashed";
-        /** JSDoc */
-        SessionStatus["Abnormal"] = "abnormal";
-    })(SessionStatus || (SessionStatus = {}));
-
     /** JSDoc */
     (function (Severity) {
         /** JSDoc */
@@ -941,37 +926,6 @@ var Sentry = (function (exports) {
             return truncate(serialized, maxLength);
         }
         return '';
-    }
-    /**
-     * Given any object, return the new object with removed keys that value was `undefined`.
-     * Works recursively on objects and arrays.
-     */
-    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()) {
-                    var key = _c.value;
-                    if (typeof obj[key] !== 'undefined') {
-                        rv[key] = dropUndefinedKeys(obj[key]);
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            return rv;
-        }
-        if (Array.isArray(val)) {
-            return val.map(dropUndefinedKeys);
-        }
-        return val;
     }
 
     /**
@@ -1008,13 +962,6 @@ var Sentry = (function (exports) {
                     ? self
                     : fallbackGlobalObject);
     }
-    /**
-     * Determines if running in react native
-     */
-    function isReactNative() {
-        var _a;
-        return ((_a = getGlobalObject().navigator) === null || _a === void 0 ? void 0 : _a.product) === 'ReactNative';
-    }
     /**
      * UUID4 generator
      *
@@ -1167,73 +1114,6 @@ var Sentry = (function (exports) {
             return '';
         }
     }
-    var INITIAL_TIME = Date.now();
-    var prevNow = 0;
-    var performanceFallback = {
-        now: function () {
-            var now = Date.now() - INITIAL_TIME;
-            if (now < prevNow) {
-                now = prevNow;
-            }
-            prevNow = now;
-            return now;
-        },
-        timeOrigin: INITIAL_TIME,
-    };
-    /**
-     * Performance wrapper for react native as performance.now() has been found to start off with an unusual offset.
-     */
-    function getReactNativePerformanceWrapper() {
-        // Performance only available >= RN 0.63
-        var performance = getGlobalObject().performance;
-        if (performance && typeof performance.now === 'function') {
-            var INITIAL_OFFSET_1 = performance.now();
-            return {
-                now: function () {
-                    return performance.now() - INITIAL_OFFSET_1;
-                },
-                timeOrigin: INITIAL_TIME,
-            };
-        }
-        return performanceFallback;
-    }
-    var crossPlatformPerformance = (function () {
-        // React Native's performance.now() starts with a gigantic offset, so we need to wrap it.
-        if (isReactNative()) {
-            return getReactNativePerformanceWrapper();
-        }
-        if (isNodeEnv()) {
-            try {
-                var perfHooks = dynamicRequire(module, 'perf_hooks');
-                return perfHooks.performance;
-            }
-            catch (_) {
-                return performanceFallback;
-            }
-        }
-        var performance = getGlobalObject().performance;
-        if (!performance || !performance.now) {
-            return performanceFallback;
-        }
-        // Polyfill for performance.timeOrigin.
-        //
-        // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin
-        // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.
-        if (performance.timeOrigin === undefined) {
-            // As of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always a
-            // valid fallback. In the absence of a initial time provided by the browser, fallback to INITIAL_TIME.
-            // @ts-ignore ignored because timeOrigin is a readonly property but we want to override
-            // eslint-disable-next-line deprecation/deprecation
-            performance.timeOrigin = (performance.timing && performance.timing.navigationStart) || INITIAL_TIME;
-        }
-        return performance;
-    })();
-    /**
-     * Returns a timestamp in seconds with milliseconds precision since the UNIX epoch calculated with the monotonic clock.
-     */
-    function timestampWithMs() {
-        return (crossPlatformPerformance.timeOrigin + crossPlatformPerformance.now()) / 1000;
-    }
     var defaultRetryAfter = 60 * 1000; // 60 seconds
     /**
      * Extracts Retry-After value from the request header or returns default value
@@ -1319,363 +1199,88 @@ var Sentry = (function (exports) {
     global$1.__SENTRY__ = global$1.__SENTRY__ || {};
     var logger = global$1.__SENTRY__.logger || (global$1.__SENTRY__.logger = new Logger());
 
-    /* eslint-disable @typescript-eslint/explicit-function-return-type */
-    /** SyncPromise internal states */
-    var States;
-    (function (States) {
-        /** Pending */
-        States["PENDING"] = "PENDING";
-        /** Resolved / OK */
-        States["RESOLVED"] = "RESOLVED";
-        /** Rejected / Error */
-        States["REJECTED"] = "REJECTED";
-    })(States || (States = {}));
     /**
-     * Thenable class that behaves like a Promise and follows it's interface
-     * but is not async internally
+     * Tells whether current environment supports Fetch API
+     * {@link supportsFetch}.
+     *
+     * @returns Answer to the given question.
      */
-    var SyncPromise = /** @class */ (function () {
-        function SyncPromise(executor) {
-            var _this = this;
-            this._state = States.PENDING;
-            this._handlers = [];
-            /** JSDoc */
-            this._resolve = function (value) {
-                _this._setResult(States.RESOLVED, value);
-            };
-            /** JSDoc */
-            this._reject = function (reason) {
-                _this._setResult(States.REJECTED, reason);
-            };
-            /** JSDoc */
-            this._setResult = function (state, value) {
-                if (_this._state !== States.PENDING) {
-                    return;
-                }
-                if (isThenable(value)) {
-                    value.then(_this._resolve, _this._reject);
-                    return;
-                }
-                _this._state = state;
-                _this._value = value;
-                _this._executeHandlers();
-            };
-            // TODO: FIXME
-            /** JSDoc */
-            this._attachHandler = function (handler) {
-                _this._handlers = _this._handlers.concat(handler);
-                _this._executeHandlers();
-            };
-            /** JSDoc */
-            this._executeHandlers = function () {
-                if (_this._state === States.PENDING) {
-                    return;
-                }
-                var cachedHandlers = _this._handlers.slice();
-                _this._handlers = [];
-                cachedHandlers.forEach(function (handler) {
-                    if (handler.done) {
-                        return;
-                    }
-                    if (_this._state === States.RESOLVED) {
-                        if (handler.onfulfilled) {
-                            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                            handler.onfulfilled(_this._value);
-                        }
-                    }
-                    if (_this._state === States.REJECTED) {
-                        if (handler.onrejected) {
-                            handler.onrejected(_this._value);
-                        }
-                    }
-                    handler.done = true;
-                });
-            };
+    function supportsFetch() {
+        if (!('fetch' in getGlobalObject())) {
+            return false;
+        }
+        try {
+            new Headers();
+            new Request('');
+            new Response();
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * isNativeFetch checks if the given function is a native implementation of fetch()
+     */
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    function isNativeFetch(func) {
+        return func && /^function fetch\(\)\s+\{\s+\[native code\]\s+\}$/.test(func.toString());
+    }
+    /**
+     * Tells whether current environment supports Fetch API natively
+     * {@link supportsNativeFetch}.
+     *
+     * @returns true if `window.fetch` is natively implemented, false otherwise
+     */
+    function supportsNativeFetch() {
+        if (!supportsFetch()) {
+            return false;
+        }
+        var global = getGlobalObject();
+        // Fast path to avoid DOM I/O
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        if (isNativeFetch(global.fetch)) {
+            return true;
+        }
+        // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)
+        // so create a "pure" iframe to see if that has native fetch
+        var result = false;
+        var doc = global.document;
+        // eslint-disable-next-line deprecation/deprecation
+        if (doc && typeof doc.createElement === "function") {
             try {
-                executor(this._resolve, this._reject);
+                var sandbox = doc.createElement('iframe');
+                sandbox.hidden = true;
+                doc.head.appendChild(sandbox);
+                if (sandbox.contentWindow && sandbox.contentWindow.fetch) {
+                    // eslint-disable-next-line @typescript-eslint/unbound-method
+                    result = isNativeFetch(sandbox.contentWindow.fetch);
+                }
+                doc.head.removeChild(sandbox);
             }
-            catch (e) {
-                this._reject(e);
+            catch (err) {
+                logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);
             }
         }
-        /** JSDoc */
-        SyncPromise.resolve = function (value) {
-            return new SyncPromise(function (resolve) {
-                resolve(value);
-            });
-        };
-        /** JSDoc */
-        SyncPromise.reject = function (reason) {
-            return new SyncPromise(function (_, reject) {
-                reject(reason);
-            });
-        };
-        /** JSDoc */
-        SyncPromise.all = function (collection) {
-            return new SyncPromise(function (resolve, reject) {
-                if (!Array.isArray(collection)) {
-                    reject(new TypeError("Promise.all requires an array as input."));
-                    return;
-                }
-                if (collection.length === 0) {
-                    resolve([]);
-                    return;
-                }
-                var counter = collection.length;
-                var resolvedCollection = [];
-                collection.forEach(function (item, index) {
-                    SyncPromise.resolve(item)
-                        .then(function (value) {
-                        resolvedCollection[index] = value;
-                        counter -= 1;
-                        if (counter !== 0) {
-                            return;
-                        }
-                        resolve(resolvedCollection);
-                    })
-                        .then(null, reject);
-                });
-            });
-        };
-        /** JSDoc */
-        SyncPromise.prototype.then = function (onfulfilled, onrejected) {
-            var _this = this;
-            return new SyncPromise(function (resolve, reject) {
-                _this._attachHandler({
-                    done: false,
-                    onfulfilled: function (result) {
-                        if (!onfulfilled) {
-                            // TODO: ¯\_(ツ)_/¯
-                            // TODO: FIXME
-                            resolve(result);
-                            return;
-                        }
-                        try {
-                            resolve(onfulfilled(result));
-                            return;
-                        }
-                        catch (e) {
-                            reject(e);
-                            return;
-                        }
-                    },
-                    onrejected: function (reason) {
-                        if (!onrejected) {
-                            reject(reason);
-                            return;
-                        }
-                        try {
-                            resolve(onrejected(reason));
-                            return;
-                        }
-                        catch (e) {
-                            reject(e);
-                            return;
-                        }
-                    },
-                });
-            });
-        };
-        /** JSDoc */
-        SyncPromise.prototype.catch = function (onrejected) {
-            return this.then(function (val) { return val; }, onrejected);
-        };
-        /** JSDoc */
-        SyncPromise.prototype.finally = function (onfinally) {
-            var _this = this;
-            return new SyncPromise(function (resolve, reject) {
-                var val;
-                var isRejected;
-                return _this.then(function (value) {
-                    isRejected = false;
-                    val = value;
-                    if (onfinally) {
-                        onfinally();
-                    }
-                }, function (reason) {
-                    isRejected = true;
-                    val = reason;
-                    if (onfinally) {
-                        onfinally();
-                    }
-                }).then(function () {
-                    if (isRejected) {
-                        reject(val);
-                        return;
-                    }
-                    resolve(val);
-                });
-            });
-        };
-        /** JSDoc */
-        SyncPromise.prototype.toString = function () {
-            return '[object SyncPromise]';
-        };
-        return SyncPromise;
-    }());
-
-    /** A simple queue that holds promises. */
-    var PromiseBuffer = /** @class */ (function () {
-        function PromiseBuffer(_limit) {
-            this._limit = _limit;
-            /** Internal set of queued Promises */
-            this._buffer = [];
-        }
-        /**
-         * Says if the buffer is ready to take more requests
-         */
-        PromiseBuffer.prototype.isReady = function () {
-            return this._limit === undefined || this.length() < this._limit;
-        };
-        /**
-         * Add a promise to the queue.
-         *
-         * @param task Can be any PromiseLike<T>
-         * @returns The original promise.
-         */
-        PromiseBuffer.prototype.add = function (task) {
-            var _this = this;
-            if (!this.isReady()) {
-                return SyncPromise.reject(new SentryError('Not adding Promise due to buffer limit reached.'));
-            }
-            if (this._buffer.indexOf(task) === -1) {
-                this._buffer.push(task);
-            }
-            task
-                .then(function () { return _this.remove(task); })
-                .then(null, function () {
-                return _this.remove(task).then(null, function () {
-                    // We have to add this catch here otherwise we have an unhandledPromiseRejection
-                    // because it's a new Promise chain.
-                });
-            });
-            return task;
-        };
-        /**
-         * Remove a promise to the queue.
-         *
-         * @param task Can be any PromiseLike<T>
-         * @returns Removed promise.
-         */
-        PromiseBuffer.prototype.remove = function (task) {
-            var removedTask = this._buffer.splice(this._buffer.indexOf(task), 1)[0];
-            return removedTask;
-        };
-        /**
-         * This function returns the number of unresolved promises in the queue.
-         */
-        PromiseBuffer.prototype.length = function () {
-            return this._buffer.length;
-        };
-        /**
-         * This will drain the whole queue, returns true if queue is empty or drained.
-         * If timeout is provided and the queue takes longer to drain, the promise still resolves but with false.
-         *
-         * @param timeout Number in ms to wait until it resolves with false.
-         */
-        PromiseBuffer.prototype.drain = function (timeout) {
-            var _this = this;
-            return new SyncPromise(function (resolve) {
-                var capturedSetTimeout = setTimeout(function () {
-                    if (timeout && timeout > 0) {
-                        resolve(false);
-                    }
-                }, timeout);
-                SyncPromise.all(_this._buffer)
-                    .then(function () {
-                    clearTimeout(capturedSetTimeout);
-                    resolve(true);
-                })
-                    .then(null, function () {
-                    resolve(true);
-                });
-            });
-        };
-        return PromiseBuffer;
-    }());
-
-    /**
-     * Tells whether current environment supports Fetch API
-     * {@link supportsFetch}.
-     *
-     * @returns Answer to the given question.
-     */
-    function supportsFetch() {
-        if (!('fetch' in getGlobalObject())) {
-            return false;
-        }
-        try {
-            new Headers();
-            new Request('');
-            new Response();
-            return true;
-        }
-        catch (e) {
-            return false;
-        }
-    }
-    /**
-     * isNativeFetch checks if the given function is a native implementation of fetch()
-     */
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    function isNativeFetch(func) {
-        return func && /^function fetch\(\)\s+\{\s+\[native code\]\s+\}$/.test(func.toString());
-    }
-    /**
-     * Tells whether current environment supports Fetch API natively
-     * {@link supportsNativeFetch}.
-     *
-     * @returns true if `window.fetch` is natively implemented, false otherwise
-     */
-    function supportsNativeFetch() {
-        if (!supportsFetch()) {
-            return false;
-        }
-        var global = getGlobalObject();
-        // Fast path to avoid DOM I/O
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        if (isNativeFetch(global.fetch)) {
-            return true;
-        }
-        // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)
-        // so create a "pure" iframe to see if that has native fetch
-        var result = false;
-        var doc = global.document;
-        // eslint-disable-next-line deprecation/deprecation
-        if (doc && typeof doc.createElement === "function") {
-            try {
-                var sandbox = doc.createElement('iframe');
-                sandbox.hidden = true;
-                doc.head.appendChild(sandbox);
-                if (sandbox.contentWindow && sandbox.contentWindow.fetch) {
-                    // eslint-disable-next-line @typescript-eslint/unbound-method
-                    result = isNativeFetch(sandbox.contentWindow.fetch);
-                }
-                doc.head.removeChild(sandbox);
-            }
-            catch (err) {
-                logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);
-            }
-        }
-        return result;
-    }
-    /**
-     * Tells whether current environment supports Referrer Policy API
-     * {@link supportsReferrerPolicy}.
-     *
-     * @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...
-        // REF: https://github.com/getsentry/raven-js/issues/1233
-        if (!supportsFetch()) {
-            return false;
-        }
-        try {
-            new Request('_', {
-                referrerPolicy: 'origin',
+        return result;
+    }
+    /**
+     * Tells whether current environment supports Referrer Policy API
+     * {@link supportsReferrerPolicy}.
+     *
+     * @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...
+        // REF: https://github.com/getsentry/raven-js/issues/1233
+        if (!supportsFetch()) {
+            return false;
+        }
+        try {
+            new Request('_', {
+                referrerPolicy: 'origin',
             });
             return true;
         }
@@ -1821,7 +1426,7 @@ var Sentry = (function (exports) {
                 for (var _i = 0; _i < arguments.length; _i++) {
                     args[_i] = arguments[_i];
                 }
-                var commonHandlerData = {
+                var handlerData = {
                     args: args,
                     fetchData: {
                         method: getFetchMethod(args),
@@ -1829,13 +1434,13 @@ var Sentry = (function (exports) {
                     },
                     startTimestamp: Date.now(),
                 };
-                triggerHandlers('fetch', __assign({}, commonHandlerData));
+                triggerHandlers('fetch', __assign({}, handlerData));
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                 return originalFetch.apply(global$2, args).then(function (response) {
-                    triggerHandlers('fetch', __assign(__assign({}, commonHandlerData), { endTimestamp: Date.now(), response: response }));
+                    triggerHandlers('fetch', __assign(__assign({}, handlerData), { endTimestamp: Date.now(), response: response }));
                     return response;
                 }, function (error) {
-                    triggerHandlers('fetch', __assign(__assign({}, commonHandlerData), { endTimestamp: Date.now(), error: error }));
+                    triggerHandlers('fetch', __assign(__assign({}, handlerData), { endTimestamp: Date.now(), error: error }));
                     // NOTE: If you are a Sentry user, and you are seeing this stack frame,
                     //       it means the sentry.javascript SDK caught an error invoking your application code.
                     //       This is expected behavior and NOT indicative of a bug with sentry.javascript.
@@ -1873,7 +1478,7 @@ var Sentry = (function (exports) {
         if (!('XMLHttpRequest' in global$2)) {
             return;
         }
-        // Poor man implementation of ES6 `Map` by tracking and keeping in sync key and value separately.
+        // Poor man's implementation of ES6 `Map`, tracking and keeping in sync key and value separately.
         var requestKeys = [];
         var requestValues = [];
         var xhrproto = XMLHttpRequest.prototype;
@@ -1911,7 +1516,7 @@ var Sentry = (function (exports) {
                         try {
                             var requestPos = requestKeys.indexOf(xhr);
                             if (requestPos !== -1) {
-                                // Make sure to pop both, key and value to keep it in sync.
+                                // Make sure to pop both key and value to keep it in sync.
                                 requestKeys.splice(requestPos);
                                 var args_1 = requestValues.splice(requestPos)[0];
                                 if (xhr.__sentry_xhr__ && args_1[0] !== undefined) {
@@ -2116,75 +1721,457 @@ var Sentry = (function (exports) {
         };
     }
     /**
-     * Wraps addEventListener to capture keypress UI events
-     * @param handler function that will be triggered
-     * @returns wrapped keypress events handler
-     * @hidden
+     * Wraps addEventListener to capture keypress UI events
+     * @param handler function that will be triggered
+     * @returns wrapped keypress events handler
+     * @hidden
+     */
+    function keypressEventHandler(handler) {
+        // TODO: if somehow user switches keypress target before
+        //       debounce timeout is triggered, we will only capture
+        //       a single breadcrumb from the FIRST target (acceptable?)
+        return function (event) {
+            var target;
+            try {
+                target = event.target;
+            }
+            catch (e) {
+                // just accessing event properties can throw an exception in some rare circumstances
+                // see: https://github.com/getsentry/raven-js/issues/838
+                return;
+            }
+            var tagName = target && target.tagName;
+            // only consider keypress events on actual input elements
+            // this will disregard keypresses targeting body (e.g. tabbing
+            // through elements, hotkeys, etc)
+            if (!tagName || (tagName !== 'INPUT' && tagName !== 'TEXTAREA' && !target.isContentEditable)) {
+                return;
+            }
+            // record first keypress in a series, but ignore subsequent
+            // keypresses until debounce clears
+            if (!keypressTimeout) {
+                domEventHandler('input', handler)(event);
+            }
+            clearTimeout(keypressTimeout);
+            keypressTimeout = setTimeout(function () {
+                keypressTimeout = undefined;
+            }, debounceDuration);
+        };
+    }
+    var _oldOnErrorHandler = null;
+    /** JSDoc */
+    function instrumentError() {
+        _oldOnErrorHandler = global$2.onerror;
+        global$2.onerror = function (msg, url, line, column, error) {
+            triggerHandlers('error', {
+                column: column,
+                error: error,
+                line: line,
+                msg: msg,
+                url: url,
+            });
+            if (_oldOnErrorHandler) {
+                // eslint-disable-next-line prefer-rest-params
+                return _oldOnErrorHandler.apply(this, arguments);
+            }
+            return false;
+        };
+    }
+    var _oldOnUnhandledRejectionHandler = null;
+    /** JSDoc */
+    function instrumentUnhandledRejection() {
+        _oldOnUnhandledRejectionHandler = global$2.onunhandledrejection;
+        global$2.onunhandledrejection = function (e) {
+            triggerHandlers('unhandledrejection', e);
+            if (_oldOnUnhandledRejectionHandler) {
+                // eslint-disable-next-line prefer-rest-params
+                return _oldOnUnhandledRejectionHandler.apply(this, arguments);
+            }
+            return true;
+        };
+    }
+
+    /* eslint-disable @typescript-eslint/explicit-function-return-type */
+    /** SyncPromise internal states */
+    var States;
+    (function (States) {
+        /** Pending */
+        States["PENDING"] = "PENDING";
+        /** Resolved / OK */
+        States["RESOLVED"] = "RESOLVED";
+        /** Rejected / Error */
+        States["REJECTED"] = "REJECTED";
+    })(States || (States = {}));
+    /**
+     * Thenable class that behaves like a Promise and follows it's interface
+     * but is not async internally
+     */
+    var SyncPromise = /** @class */ (function () {
+        function SyncPromise(executor) {
+            var _this = this;
+            this._state = States.PENDING;
+            this._handlers = [];
+            /** JSDoc */
+            this._resolve = function (value) {
+                _this._setResult(States.RESOLVED, value);
+            };
+            /** JSDoc */
+            this._reject = function (reason) {
+                _this._setResult(States.REJECTED, reason);
+            };
+            /** JSDoc */
+            this._setResult = function (state, value) {
+                if (_this._state !== States.PENDING) {
+                    return;
+                }
+                if (isThenable(value)) {
+                    value.then(_this._resolve, _this._reject);
+                    return;
+                }
+                _this._state = state;
+                _this._value = value;
+                _this._executeHandlers();
+            };
+            // TODO: FIXME
+            /** JSDoc */
+            this._attachHandler = function (handler) {
+                _this._handlers = _this._handlers.concat(handler);
+                _this._executeHandlers();
+            };
+            /** JSDoc */
+            this._executeHandlers = function () {
+                if (_this._state === States.PENDING) {
+                    return;
+                }
+                var cachedHandlers = _this._handlers.slice();
+                _this._handlers = [];
+                cachedHandlers.forEach(function (handler) {
+                    if (handler.done) {
+                        return;
+                    }
+                    if (_this._state === States.RESOLVED) {
+                        if (handler.onfulfilled) {
+                            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                            handler.onfulfilled(_this._value);
+                        }
+                    }
+                    if (_this._state === States.REJECTED) {
+                        if (handler.onrejected) {
+                            handler.onrejected(_this._value);
+                        }
+                    }
+                    handler.done = true;
+                });
+            };
+            try {
+                executor(this._resolve, this._reject);
+            }
+            catch (e) {
+                this._reject(e);
+            }
+        }
+        /** JSDoc */
+        SyncPromise.resolve = function (value) {
+            return new SyncPromise(function (resolve) {
+                resolve(value);
+            });
+        };
+        /** JSDoc */
+        SyncPromise.reject = function (reason) {
+            return new SyncPromise(function (_, reject) {
+                reject(reason);
+            });
+        };
+        /** JSDoc */
+        SyncPromise.all = function (collection) {
+            return new SyncPromise(function (resolve, reject) {
+                if (!Array.isArray(collection)) {
+                    reject(new TypeError("Promise.all requires an array as input."));
+                    return;
+                }
+                if (collection.length === 0) {
+                    resolve([]);
+                    return;
+                }
+                var counter = collection.length;
+                var resolvedCollection = [];
+                collection.forEach(function (item, index) {
+                    SyncPromise.resolve(item)
+                        .then(function (value) {
+                        resolvedCollection[index] = value;
+                        counter -= 1;
+                        if (counter !== 0) {
+                            return;
+                        }
+                        resolve(resolvedCollection);
+                    })
+                        .then(null, reject);
+                });
+            });
+        };
+        /** JSDoc */
+        SyncPromise.prototype.then = function (onfulfilled, onrejected) {
+            var _this = this;
+            return new SyncPromise(function (resolve, reject) {
+                _this._attachHandler({
+                    done: false,
+                    onfulfilled: function (result) {
+                        if (!onfulfilled) {
+                            // TODO: ¯\_(ツ)_/¯
+                            // TODO: FIXME
+                            resolve(result);
+                            return;
+                        }
+                        try {
+                            resolve(onfulfilled(result));
+                            return;
+                        }
+                        catch (e) {
+                            reject(e);
+                            return;
+                        }
+                    },
+                    onrejected: function (reason) {
+                        if (!onrejected) {
+                            reject(reason);
+                            return;
+                        }
+                        try {
+                            resolve(onrejected(reason));
+                            return;
+                        }
+                        catch (e) {
+                            reject(e);
+                            return;
+                        }
+                    },
+                });
+            });
+        };
+        /** JSDoc */
+        SyncPromise.prototype.catch = function (onrejected) {
+            return this.then(function (val) { return val; }, onrejected);
+        };
+        /** JSDoc */
+        SyncPromise.prototype.finally = function (onfinally) {
+            var _this = this;
+            return new SyncPromise(function (resolve, reject) {
+                var val;
+                var isRejected;
+                return _this.then(function (value) {
+                    isRejected = false;
+                    val = value;
+                    if (onfinally) {
+                        onfinally();
+                    }
+                }, function (reason) {
+                    isRejected = true;
+                    val = reason;
+                    if (onfinally) {
+                        onfinally();
+                    }
+                }).then(function () {
+                    if (isRejected) {
+                        reject(val);
+                        return;
+                    }
+                    resolve(val);
+                });
+            });
+        };
+        /** JSDoc */
+        SyncPromise.prototype.toString = function () {
+            return '[object SyncPromise]';
+        };
+        return SyncPromise;
+    }());
+
+    /** A simple queue that holds promises. */
+    var PromiseBuffer = /** @class */ (function () {
+        function PromiseBuffer(_limit) {
+            this._limit = _limit;
+            /** Internal set of queued Promises */
+            this._buffer = [];
+        }
+        /**
+         * Says if the buffer is ready to take more requests
+         */
+        PromiseBuffer.prototype.isReady = function () {
+            return this._limit === undefined || this.length() < this._limit;
+        };
+        /**
+         * Add a promise to the queue.
+         *
+         * @param task Can be any PromiseLike<T>
+         * @returns The original promise.
+         */
+        PromiseBuffer.prototype.add = function (task) {
+            var _this = this;
+            if (!this.isReady()) {
+                return SyncPromise.reject(new SentryError('Not adding Promise due to buffer limit reached.'));
+            }
+            if (this._buffer.indexOf(task) === -1) {
+                this._buffer.push(task);
+            }
+            task
+                .then(function () { return _this.remove(task); })
+                .then(null, function () {
+                return _this.remove(task).then(null, function () {
+                    // We have to add this catch here otherwise we have an unhandledPromiseRejection
+                    // because it's a new Promise chain.
+                });
+            });
+            return task;
+        };
+        /**
+         * Remove a promise to the queue.
+         *
+         * @param task Can be any PromiseLike<T>
+         * @returns Removed promise.
+         */
+        PromiseBuffer.prototype.remove = function (task) {
+            var removedTask = this._buffer.splice(this._buffer.indexOf(task), 1)[0];
+            return removedTask;
+        };
+        /**
+         * This function returns the number of unresolved promises in the queue.
+         */
+        PromiseBuffer.prototype.length = function () {
+            return this._buffer.length;
+        };
+        /**
+         * This will drain the whole queue, returns true if queue is empty or drained.
+         * If timeout is provided and the queue takes longer to drain, the promise still resolves but with false.
+         *
+         * @param timeout Number in ms to wait until it resolves with false.
+         */
+        PromiseBuffer.prototype.drain = function (timeout) {
+            var _this = this;
+            return new SyncPromise(function (resolve) {
+                var capturedSetTimeout = setTimeout(function () {
+                    if (timeout && timeout > 0) {
+                        resolve(false);
+                    }
+                }, timeout);
+                SyncPromise.all(_this._buffer)
+                    .then(function () {
+                    clearTimeout(capturedSetTimeout);
+                    resolve(true);
+                })
+                    .then(null, function () {
+                    resolve(true);
+                });
+            });
+        };
+        return PromiseBuffer;
+    }());
+
+    /**
+     * A TimestampSource implementation for environments that do not support the Performance Web API natively.
+     *
+     * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier
+     * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It
+     * is more obvious to explain "why does my span have negative duration" than "why my spans have zero duration".
+     */
+    var dateTimestampSource = {
+        nowSeconds: function () { return Date.now() / 1000; },
+    };
+    /**
+     * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not
+     * support the API.
+     *
+     * Wrapping the native API works around differences in behavior from different browsers.
+     */
+    function getBrowserPerformance() {
+        var performance = getGlobalObject().performance;
+        if (!performance || !performance.now) {
+            return undefined;
+        }
+        // Replace performance.timeOrigin with our own timeOrigin based on Date.now().
+        //
+        // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +
+        // performance.now() gives a date arbitrarily in the past.
+        //
+        // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is
+        // undefined.
+        //
+        // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to
+        // interact with data coming out of performance entries.
+        //
+        // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that
+        // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes
+        // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have
+        // observed skews that can be as long as days, weeks or months.
+        //
+        // See https://github.com/getsentry/sentry-javascript/issues/2590.
+        //
+        // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload
+        // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation
+        // transactions of long-lived web pages.
+        var timeOrigin = Date.now() - performance.now();
+        return {
+            now: function () { return performance.now(); },
+            timeOrigin: timeOrigin,
+        };
+    }
+    /**
+     * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't
+     * implement the API.
      */
-    function keypressEventHandler(handler) {
-        // TODO: if somehow user switches keypress target before
-        //       debounce timeout is triggered, we will only capture
-        //       a single breadcrumb from the FIRST target (acceptable?)
-        return function (event) {
-            var target;
-            try {
-                target = event.target;
-            }
-            catch (e) {
-                // just accessing event properties can throw an exception in some rare circumstances
-                // see: https://github.com/getsentry/raven-js/issues/838
-                return;
-            }
-            var tagName = target && target.tagName;
-            // only consider keypress events on actual input elements
-            // this will disregard keypresses targeting body (e.g. tabbing
-            // through elements, hotkeys, etc)
-            if (!tagName || (tagName !== 'INPUT' && tagName !== 'TEXTAREA' && !target.isContentEditable)) {
-                return;
-            }
-            // record first keypress in a series, but ignore subsequent
-            // keypresses until debounce clears
-            if (!keypressTimeout) {
-                domEventHandler('input', handler)(event);
-            }
-            clearTimeout(keypressTimeout);
-            keypressTimeout = setTimeout(function () {
-                keypressTimeout = undefined;
-            }, debounceDuration);
-        };
-    }
-    var _oldOnErrorHandler = null;
-    /** JSDoc */
-    function instrumentError() {
-        _oldOnErrorHandler = global$2.onerror;
-        global$2.onerror = function (msg, url, line, column, error) {
-            triggerHandlers('error', {
-                column: column,
-                error: error,
-                line: line,
-                msg: msg,
-                url: url,
-            });
-            if (_oldOnErrorHandler) {
-                // eslint-disable-next-line prefer-rest-params
-                return _oldOnErrorHandler.apply(this, arguments);
-            }
-            return false;
-        };
+    function getNodePerformance() {
+        try {
+            var perfHooks = dynamicRequire(module, 'perf_hooks');
+            return perfHooks.performance;
+        }
+        catch (_) {
+            return undefined;
+        }
     }
-    var _oldOnUnhandledRejectionHandler = null;
-    /** JSDoc */
-    function instrumentUnhandledRejection() {
-        _oldOnUnhandledRejectionHandler = global$2.onunhandledrejection;
-        global$2.onunhandledrejection = function (e) {
-            triggerHandlers('unhandledrejection', e);
-            if (_oldOnUnhandledRejectionHandler) {
-                // eslint-disable-next-line prefer-rest-params
-                return _oldOnUnhandledRejectionHandler.apply(this, arguments);
-            }
-            return true;
+    /**
+     * The Performance API implementation for the current platform, if available.
+     */
+    var platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();
+    var timestampSource = platformPerformance === undefined
+        ? dateTimestampSource
+        : {
+            nowSeconds: function () { return (platformPerformance.timeOrigin + platformPerformance.now()) / 1000; },
         };
-    }
+    /**
+     * Returns a timestamp in seconds since the UNIX epoch using the Date API.
+     */
+    var dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);
+    /**
+     * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the
+     * availability of the Performance API.
+     *
+     * See `usingPerformanceAPI` to test whether the Performance API is used.
+     *
+     * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is
+     * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The
+     * skew can grow to arbitrary amounts like days, weeks or months.
+     * See https://github.com/getsentry/sentry-javascript/issues/2590.
+     */
+    var timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);
+    /**
+     * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the
+     * performance API is available.
+     */
+    var browserPerformanceTimeOrigin = (function () {
+        var performance = getGlobalObject().performance;
+        if (!performance) {
+            return undefined;
+        }
+        if (performance.timeOrigin) {
+            return performance.timeOrigin;
+        }
+        // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin
+        // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.
+        // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always
+        // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the
+        // Date API.
+        // eslint-disable-next-line deprecation/deprecation
+        return (performance.timing && performance.timing.navigationStart) || Date.now();
+    })();
 
     /**
      * Holds additional event information. {@link Scope.applyToEvent} will be
@@ -2205,10 +2192,8 @@ var Sentry = (function (exports) {
             /** Tags */
             this._tags = {};
             /** Extra */
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             this._extra = {};
             /** Contexts */
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             this._contexts = {};
         }
         /**
@@ -2225,7 +2210,6 @@ var Sentry = (function (exports) {
                 newScope._user = scope._user;
                 newScope._level = scope._level;
                 newScope._span = scope._span;
-                newScope._session = scope._session;
                 newScope._transactionName = scope._transactionName;
                 newScope._fingerprint = scope._fingerprint;
                 newScope._eventProcessors = __spread(scope._eventProcessors);
@@ -2251,18 +2235,9 @@ var Sentry = (function (exports) {
          */
         Scope.prototype.setUser = function (user) {
             this._user = user || {};
-            if (this._session) {
-                this._session.update({ user: user });
-            }
             this._notifyScopeListeners();
             return this;
         };
-        /**
-         * @inheritDoc
-         */
-        Scope.prototype.getUser = function () {
-            return this._user;
-        };
         /**
          * @inheritDoc
          */
@@ -2331,10 +2306,15 @@ var Sentry = (function (exports) {
         /**
          * @inheritDoc
          */
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         Scope.prototype.setContext = function (key, context) {
             var _a;
-            this._contexts = __assign(__assign({}, this._contexts), (_a = {}, _a[key] = context, _a));
+            if (context === null) {
+                // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+                delete this._contexts[key];
+            }
+            else {
+                this._contexts = __assign(__assign({}, this._contexts), (_a = {}, _a[key] = context, _a));
+            }
             this._notifyScopeListeners();
             return this;
         };
@@ -2356,31 +2336,20 @@ var Sentry = (function (exports) {
          * @inheritDoc
          */
         Scope.prototype.getTransaction = function () {
+            var _a, _b, _c, _d;
+            // often, this span will be a transaction, but it's not guaranteed to be
             var span = this.getSpan();
-            if (span && span.spanRecorder && span.spanRecorder.spans[0]) {
+            // try it the new way first
+            if ((_a = span) === null || _a === void 0 ? void 0 : _a.transaction) {
+                return (_b = span) === null || _b === void 0 ? void 0 : _b.transaction;
+            }
+            // fallback to the old way (known bug: this only finds transactions with sampled = true)
+            if ((_d = (_c = span) === null || _c === void 0 ? void 0 : _c.spanRecorder) === null || _d === void 0 ? void 0 : _d.spans[0]) {
                 return span.spanRecorder.spans[0];
             }
+            // neither way found a transaction
             return undefined;
         };
-        /**
-         * @inheritDoc
-         */
-        Scope.prototype.setSession = function (session) {
-            if (!session) {
-                delete this._session;
-            }
-            else {
-                this._session = session;
-            }
-            this._notifyScopeListeners();
-            return this;
-        };
-        /**
-         * @inheritDoc
-         */
-        Scope.prototype.getSession = function () {
-            return this._session;
-        };
         /**
          * @inheritDoc
          */
@@ -2437,7 +2406,6 @@ var Sentry = (function (exports) {
             this._transactionName = undefined;
             this._fingerprint = undefined;
             this._span = undefined;
-            this._session = undefined;
             this._notifyScopeListeners();
             return this;
         };
@@ -2445,7 +2413,7 @@ var Sentry = (function (exports) {
          * @inheritDoc
          */
         Scope.prototype.addBreadcrumb = function (breadcrumb, maxBreadcrumbs) {
-            var mergedBreadcrumb = __assign({ timestamp: timestampWithMs() }, breadcrumb);
+            var mergedBreadcrumb = __assign({ timestamp: dateTimestampInSeconds() }, breadcrumb);
             this._breadcrumbs =
                 maxBreadcrumbs !== undefined && maxBreadcrumbs >= 0
                     ? __spread(this._breadcrumbs, [mergedBreadcrumb]).slice(-maxBreadcrumbs)
@@ -2579,96 +2547,6 @@ var Sentry = (function (exports) {
         getGlobalEventProcessors().push(callback);
     }
 
-    /**
-     * @inheritdoc
-     */
-    var Session = /** @class */ (function () {
-        function Session(context) {
-            this.errors = 0;
-            this.sid = uuid4();
-            this.timestamp = Date.now();
-            this.started = Date.now();
-            this.status = SessionStatus.Ok;
-            console.log('new session constructed'); // eslint-disable-line no-console
-            if (context) {
-                this.update(context);
-            }
-        }
-        /** JSDoc */
-        // eslint-disable-next-line complexity
-        Session.prototype.update = function (context) {
-            if (context.user) {
-                if (context.user.ip_address) {
-                    this.ip_address = context.user.ip_address;
-                }
-                if (!context.did) {
-                    this.did = context.user.id || context.user.email || context.user.username;
-                }
-            }
-            this.timestamp = context.timestamp || Date.now();
-            if (context.sid) {
-                // Good enough uuid validation for now
-                this.sid = context.sid.length === 32 ? context.sid : uuid4();
-            }
-            if (context.did) {
-                this.did = "" + context.did;
-            }
-            if (typeof context.started === 'number') {
-                this.started = context.started;
-            }
-            if (typeof context.duration === 'number') {
-                this.duration = context.duration;
-            }
-            if (context.release) {
-                this.release = context.release;
-            }
-            if (context.environment) {
-                this.environment = context.environment;
-            }
-            if (context.ip_address) {
-                this.ip_address = context.ip_address;
-            }
-            if (context.user_agent) {
-                this.user_agent = context.user_agent;
-            }
-            if (typeof context.errors === 'number') {
-                this.errors = context.errors;
-            }
-            if (context.status) {
-                this.status = context.status;
-            }
-        };
-        /** JSDoc */
-        Session.prototype.close = function (status) {
-            if (status) {
-                this.update({ status: status });
-            }
-            else if (this.status === SessionStatus.Ok) {
-                this.update({ status: SessionStatus.Exited });
-            }
-        };
-        /** JSDoc */
-        Session.prototype.toJSON = function () {
-            return dropUndefinedKeys({
-                sid: "" + this.sid,
-                init: true,
-                started: new Date(this.started).toISOString(),
-                timestamp: new Date(this.timestamp).toISOString(),
-                status: this.status,
-                errors: this.errors,
-                did: typeof this.did === 'number' || typeof this.did === 'string' ? "" + this.did : undefined,
-                duration: this.duration,
-                attrs: dropUndefinedKeys({
-                    release: this.release,
-                    environment: this.environment,
-                    ip_address: this.ip_address,
-                    user_agent: this.user_agent,
-                }),
-            });
-        };
-        return Session;
-    }());
-
     /**
      * API compatibility version of this hub.
      *
@@ -2855,7 +2733,7 @@ var Sentry = (function (exports) {
             if (maxBreadcrumbs <= 0) {
                 return;
             }
-            var timestamp = timestampWithMs();
+            var timestamp = dateTimestampInSeconds();
             var mergedBreadcrumb = __assign({ timestamp: timestamp }, breadcrumb);
             var finalBreadcrumb = beforeBreadcrumb
                 ? consoleSandbox(function () { return beforeBreadcrumb(mergedBreadcrumb, hint); })
@@ -2981,41 +2859,6 @@ var Sentry = (function (exports) {
         Hub.prototype.traceHeaders = function () {
             return this._callExtensionMethod('traceHeaders');
         };
-        /**
-         * @inheritDoc
-         */
-        Hub.prototype.startSession = function () {
-            var top = this.getStackTop();
-            if (!top.scope) {
-                return;
-            }
-            var client = top.client;
-            var _a = (client && client.getOptions()) || {}, release = _a.release, environment = _a.environment;
-            // End existing session if there's one
-            this.endSession();
-            top.scope.setSession(new Session({
-                release: release,
-                environment: environment,
-                user: top.scope.getUser(),
-            }));
-        };
-        /**
-         * @inheritDoc
-         */
-        Hub.prototype.endSession = function () {
-            var top = this.getStackTop();
-            if (!top.scope) {
-                return;
-            }
-            var session = top.scope.getSession();
-            if (session) {
-                session.close();
-                if (top.client) {
-                    top.client.captureSession(session);
-                }
-            }
-            top.scope.setSession(undefined);
-        };
         /**
          * Internal helper function to call a method on the top client if it exists.
          *
@@ -3615,17 +3458,6 @@ var Sentry = (function (exports) {
             });
             return eventId;
         };
-        /**
-         * @inheritDoc
-         */
-        BaseClient.prototype.captureSession = function (session) {
-            if (!session.release) {
-                logger.warn('Discarded session update because of missing release');
-            }
-            else {
-                this._sendSession(session);
-            }
-        };
         /**
          * @inheritDoc
          */
@@ -3681,49 +3513,6 @@ var Sentry = (function (exports) {
                 return null;
             }
         };
-        /** Updates existing session based on the provided event */
-        BaseClient.prototype._updateSessionFromEvent = function (session, event) {
-            var e_1, _a;
-            var crashed = false;
-            var errored = false;
-            var user_agent;
-            var exceptions = event.exception && event.exception.values;
-            if (exceptions) {
-                errored = true;
-                try {
-                    for (var exceptions_1 = __values(exceptions), exceptions_1_1 = exceptions_1.next(); !exceptions_1_1.done; exceptions_1_1 = exceptions_1.next()) {
-                        var ex = exceptions_1_1.value;
-                        var mechanism = ex.mechanism;
-                        if (mechanism && mechanism.handled === false) {
-                            crashed = true;
-                            break;
-                        }
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (exceptions_1_1 && !exceptions_1_1.done && (_a = exceptions_1.return)) _a.call(exceptions_1);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-            }
-            var user = event.user;
-            if (!session.user_agent) {
-                var headers = event.request ? event.request.headers : {};
-                for (var key in headers) {
-                    if (key.toLowerCase() === 'user-agent') {
-                        user_agent = headers[key];
-                        break;
-                    }
-                }
-            }
-            session.update(__assign(__assign({}, (crashed && { status: SessionStatus.Crashed })), { user: user, user_agent: user_agent, errors: session.errors + Number(errored || crashed) }));
-        };
-        /** Deliver captured session to Sentry */
-        BaseClient.prototype._sendSession = function (session) {
-            this._getBackend().sendSession(session);
-        };
         /** Waits for the client to be done with processing. */
         BaseClient.prototype._isClientProcessing = function (timeout) {
             var _this = this;
@@ -3776,7 +3565,7 @@ var Sentry = (function (exports) {
         BaseClient.prototype._prepareEvent = function (event, scope, hint) {
             var _this = this;
             var _a = this.getOptions().normalizeDepth, normalizeDepth = _a === void 0 ? 3 : _a;
-            var prepared = __assign(__assign({}, event), { event_id: event.event_id || (hint && hint.event_id ? hint.event_id : uuid4()), timestamp: event.timestamp || timestampWithMs() });
+            var prepared = __assign(__assign({}, event), { event_id: event.event_id || (hint && hint.event_id ? hint.event_id : uuid4()), timestamp: event.timestamp || dateTimestampInSeconds() });
             this._applyClientOptions(prepared);
             this._applyIntegrationsMetadata(prepared);
             // If we have scope given to us, use it as the base for further modifications.
@@ -3923,12 +3712,6 @@ var Sentry = (function (exports) {
                     var isInternalException = hint && hint.data && hint.data.__sentry__ === true;
                     // We skip beforeSend in case of transactions
                     if (isInternalException || !beforeSend || isTransaction) {
-                        if (!isTransaction) {
-                            var session = scope && scope.getSession();
-                            if (session) {
-                                _this._updateSessionFromEvent(session, finalEvent);
-                            }
-                        }
                         _this._sendEvent(finalEvent);
                         resolve(finalEvent);
                         return;
@@ -3947,10 +3730,6 @@ var Sentry = (function (exports) {
                             resolve(null);
                             return;
                         }
-                        var session = scope && scope.getSession();
-                        if (session) {
-                            _this._updateSessionFromEvent(session, finalEvent);
-                        }
                         // From here on we are really async
                         _this._sendEvent(finalEvent);
                         resolve(finalEvent);
@@ -4045,18 +3824,6 @@ var Sentry = (function (exports) {
                 logger.error("Error while sending event: " + reason);
             });
         };
-        /**
-         * @inheritDoc
-         */
-        BaseBackend.prototype.sendSession = function (session) {
-            if (!this._transport.sendSession) {
-                logger.warn('sendSession not implemented for a transport used');
-                return;
-            }
-            this._transport.sendSession(session).then(null, function (reason) {
-                logger.error("Error while sending session: " + reason);
-            });
-        };
         /**
          * @inheritDoc
          */
@@ -4072,19 +3839,6 @@ var Sentry = (function (exports) {
         return BaseBackend;
     }());
 
-    /** Creates a SentryRequest from an event. */
-    function sessionToSentryRequest(session, api) {
-        var envelopeHeaders = JSON.stringify({
-            sent_at: new Date(timestampWithMs() * 1000).toISOString(),
-        });
-        var itemHeaders = JSON.stringify({
-            type: 'session',
-        });
-        return {
-            body: envelopeHeaders + "\n" + itemHeaders + "\n" + JSON.stringify(session),
-            url: api.getEnvelopeEndpointWithUrlEncodedAuth(),
-        };
-    }
     /** Creates a SentryRequest from an event. */
     function eventToSentryRequest(event, api) {
         var useEnvelope = event.type === 'transaction';
@@ -4102,7 +3856,7 @@ var Sentry = (function (exports) {
                 event_id: event.event_id,
                 // We need to add * 1000 since we divide it by 1000 by default but JS works with ms precision
                 // The reason we use timestampWithMs here is that all clocks across the SDK use the same clock
-                sent_at: new Date(timestampWithMs() * 1000).toISOString(),
+                sent_at: new Date().toISOString(),
             });
             var itemHeaders = JSON.stringify({
                 type: event.type,
@@ -4827,40 +4581,6 @@ var Sentry = (function (exports) {
                     .catch(reject);
             }));
         };
-        /**
-         * @inheritDoc
-         */
-        FetchTransport.prototype.sendSession = function (session) {
-            var sentryReq = sessionToSentryRequest(session, this._api);
-            var options = {
-                body: sentryReq.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...
-                // REF: https://github.com/getsentry/raven-js/issues/1233
-                referrerPolicy: (supportsReferrerPolicy() ? 'origin' : ''),
-            };
-            if (this.options.fetchParameters !== undefined) {
-                Object.assign(options, this.options.fetchParameters);
-            }
-            if (this.options.headers !== undefined) {
-                options.headers = this.options.headers;
-            }
-            return new SyncPromise(function (resolve, reject) {
-                global$3
-                    .fetch(sentryReq.url, options)
-                    .then(function (response) {
-                    var status = exports.Status.fromHttpCode(response.status);
-                    if (status === exports.Status.Success) {
-                        resolve({ status: status });
-                        return;
-                    }
-                    reject(response);
-                })
-                    .catch(reject);
-            });
-        };
         return FetchTransport;
     }(BaseTransport));
 
@@ -4918,34 +4638,6 @@ var Sentry = (function (exports) {
                 request.send(sentryReq.body);
             }));
         };
-        /**
-         * @inheritDoc
-         */
-        XHRTransport.prototype.sendSession = function (session) {
-            var _this = this;
-            var sentryReq = sessionToSentryRequest(session, this._api);
-            return new SyncPromise(function (resolve, reject) {
-                var request = new XMLHttpRequest();
-                request.onreadystatechange = function () {
-                    if (request.readyState !== 4) {
-                        return;
-                    }
-                    var status = exports.Status.fromHttpCode(request.status);
-                    if (status === exports.Status.Success) {
-                        resolve({ status: status });
-                        return;
-                    }
-                    reject(request);
-                };
-                request.open('POST', sentryReq.url);
-                for (var header in _this.options.headers) {
-                    if (_this.options.headers.hasOwnProperty(header)) {
-                        request.setRequestHeader(header, _this.options.headers[header]);
-                    }
-                }
-                request.send(sentryReq.body);
-            });
-        };
         return XHRTransport;
     }(BaseTransport));
 
@@ -5932,7 +5624,7 @@ var Sentry = (function (exports) {
     });
 
     var SDK_NAME = 'sentry.javascript.browser';
-    var SDK_VERSION = '5.25.0-beta.2';
+    var SDK_VERSION = '5.25.0';
 
     /**
      * The Sentry Browser SDK Client.