@sentry/replay 7.59.3 → 7.60.0

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);
       }
     }
@@ -3986,14 +4008,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() {
@@ -7942,6 +7956,9 @@ class ReplayContainer  {
 
     const earliestEvent = eventBuffer.getEarliestTimestamp();
     if (earliestEvent && earliestEvent < this._context.initialTimestamp) {
+      // 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] Updating initial timestamp to ${earliestEvent}`);
       this._context.initialTimestamp = earliestEvent;
     }
   }
@@ -8056,6 +8073,23 @@ class ReplayContainer  {
       return;
     }
 
+    const start = this._context.initialTimestamp;
+    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 +8292,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 +8369,7 @@ class Replay  {
     this._initialOptions = {
       flushMinDelay,
       flushMaxDelay,
+      minReplayDuration: Math.min(minReplayDuration, MIN_REPLAY_DURATION_LIMIT),
       stickySession,
       sessionSampleRate,
       errorSampleRate,