@sentry/replay 7.59.3 → 7.60.1

package/cjs/index.js

@@ -48,6 +48,11 @@ const SLOW_CLICK_SCROLL_TIMEOUT = 300;
 /** When encountering a total segment size exceeding this size, stop the replay (as we cannot properly ingest it). */
 const REPLAY_MAX_EVENT_BUFFER_SIZE = 20000000; // ~20MB
 
+/** Replays must be min. 5s long before we send them. */
+const MIN_REPLAY_DURATION = 4999;
+/* The max. allowed value that the minReplayDuration can be set to. */
+const MIN_REPLAY_DURATION_LIMIT = 15000;
+
 var NodeType$1;
 (function (NodeType) {
     NodeType[NodeType["Document"] = 0] = "Document";
@@ -3272,6 +3277,22 @@ record.takeFullSnapshot = (isCheckout) => {
 };
 record.mirror = mirror;
 
+/**
+ * Converts a timestamp to ms, if it was in s, or keeps it as ms.
+ */
+function timestampToMs(timestamp) {
+  const isMs = timestamp > 9999999999;
+  return isMs ? timestamp : timestamp * 1000;
+}
+
+/**
+ * Converts a timestamp to s, if it was in ms, or keeps it as s.
+ */
+function timestampToS(timestamp) {
+  const isMs = timestamp > 9999999999;
+  return isMs ? timestamp / 1000 : timestamp;
+}
+
 /**
  * Add a breadcrumb event to replay.
  */
@@ -3471,7 +3492,7 @@ class ClickDetector  {
     }
 
     const newClick = {
-      timestamp: breadcrumb.timestamp,
+      timestamp: timestampToS(breadcrumb.timestamp),
       clickBreadcrumb: breadcrumb,
       // Set this to 0 so we know it originates from the click breadcrumb
       clickCount: 0,
@@ -3511,6 +3532,7 @@ class ClickDetector  {
         click.scrollAfter = click.timestamp <= this._lastScroll ? this._lastScroll - click.timestamp : undefined;
       }
 
+      // All of these are in seconds!
       if (click.timestamp + this._timeout <= now) {
         timedOutClicks.push(click);
       }
@@ -3518,10 +3540,10 @@ class ClickDetector  {
 
     // Remove "old" clicks
     for (const click of timedOutClicks) {
-      this._generateBreadcrumbs(click);
-
       const pos = this._clicks.indexOf(click);
-      if (pos !== -1) {
+
+      if (pos > -1) {
+        this._generateBreadcrumbs(click);
         this._clicks.splice(pos, 1);
       }
     }
@@ -3713,8 +3735,16 @@ const handleDomListener = (
 
     const isClick = handlerData.name === 'click';
     const event = isClick && (handlerData.event );
-    // Ignore clicks if ctrl/alt/meta keys are held down as they alter behavior of clicks (e.g. open in new tab)
-    if (isClick && replay.clickDetector && event && !event.altKey && !event.metaKey && !event.ctrlKey) {
+    // Ignore clicks if ctrl/alt/meta/shift keys are held down as they alter behavior of clicks (e.g. open in new tab)
+    if (
+      isClick &&
+      replay.clickDetector &&
+      event &&
+      !event.altKey &&
+      !event.metaKey &&
+      !event.ctrlKey &&
+      !event.shiftKey
+    ) {
       handleClick(
         replay.clickDetector,
         result ,
@@ -3986,14 +4016,6 @@ function t(t){let e=t.length;for(;--e>=0;)t[e]=0}const e=new Uint8Array([0,0,0,0
 
 function e(){const e=new Blob([r]);return URL.createObjectURL(e)}
 
-/**
- * Converts a timestamp to ms, if it was in s, or keeps it as ms.
- */
-function timestampToMs(timestamp) {
-  const isMs = timestamp > 9999999999;
-  return isMs ? timestamp : timestamp * 1000;
-}
-
 /** This error indicates that the event buffer size exceeded the limit.. */
 class EventBufferSizeExceededError extends Error {
    constructor() {
@@ -6606,6 +6628,11 @@ function getHandleRecordingEmit(replay) {
       if (replay.recordingMode === 'buffer' && replay.session && replay.eventBuffer) {
         const earliestEvent = replay.eventBuffer.getEarliestTimestamp();
         if (earliestEvent) {
+          // eslint-disable-next-line no-console
+          const log = replay.getOptions()._experiments.traceInternals ? console.info : utils.logger.info;
+          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+            log(`[Replay] Updating session start time to earliest event in buffer at ${earliestEvent}`);
+
           replay.session.started = earliestEvent;
 
           if (replay.getOptions().stickySession) {
@@ -7387,6 +7414,10 @@ class ReplayContainer  {
 
     const activityTime = Date.now();
 
+    // eslint-disable-next-line no-console
+    const log = this.getOptions()._experiments.traceInternals ? console.info : utils.logger.info;
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && log(`[Replay] Converting buffer to session, starting at ${activityTime}`);
+
     // Allow flush to complete before resuming as a session recording, otherwise
     // the checkout from `startRecording` may be included in the payload.
     // Prefer to keep the error replay as a separate (and smaller) segment
@@ -8056,6 +8087,23 @@ class ReplayContainer  {
       return;
     }
 
+    const start = this.session.started;
+    const now = Date.now();
+    const duration = now - start;
+
+    // If session is too short, or too long (allow some wiggle room over maxSessionLife), do not send it
+    // This _should_ not happen, but it may happen if flush is triggered due to a page activity change or similar
+    if (duration < this._options.minReplayDuration || duration > this.timeouts.maxSessionLife + 5000) {
+      // eslint-disable-next-line no-console
+      const log = this.getOptions()._experiments.traceInternals ? console.warn : utils.logger.warn;
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+        log(
+          `[Replay] Session duration (${Math.floor(duration / 1000)}s) is too short or too long, not sending replay.`,
+        );
+
+      return;
+    }
+
     // A flush is about to happen, cancel any queued flushes
     this._debouncedFlush.cancel();
 
@@ -8258,6 +8306,7 @@ class Replay  {
    constructor({
     flushMinDelay = DEFAULT_FLUSH_MIN_DELAY,
     flushMaxDelay = DEFAULT_FLUSH_MAX_DELAY,
+    minReplayDuration = MIN_REPLAY_DURATION,
     stickySession = true,
     useCompression = true,
     _experiments = {},
@@ -8334,6 +8383,7 @@ class Replay  {
     this._initialOptions = {
       flushMinDelay,
       flushMaxDelay,
+      minReplayDuration: Math.min(minReplayDuration, MIN_REPLAY_DURATION_LIMIT),
       stickySession,
       sessionSampleRate,
       errorSampleRate,