@sentry/replay 7.66.0 → 7.67.0

package/cjs/index.js

@@ -19,9 +19,6 @@ const SESSION_IDLE_PAUSE_DURATION = 300000; // 5 minutes in ms
 // The idle limit for a session after which the session expires.
 const SESSION_IDLE_EXPIRE_DURATION = 900000; // 15 minutes in ms
 
-// The maximum length of a session
-const MAX_SESSION_LIFE = 3600000; // 60 minutes in ms
-
 /** Default flush delays */
 const DEFAULT_FLUSH_MIN_DELAY = 5000;
 // XXX: Temp fix for our debounce logic where `maxWait` would never occur if it
@@ -53,6 +50,9 @@ const MIN_REPLAY_DURATION = 4999;
 /* The max. allowed value that the minReplayDuration can be set to. */
 const MIN_REPLAY_DURATION_LIMIT = 15000;
 
+/** The max. length of a replay. */
+const MAX_REPLAY_DURATION = 3600000; // 60 minutes in ms;
+
 var NodeType$1;
 (function (NodeType) {
     NodeType[NodeType["Document"] = 0] = "Document";
@@ -4656,13 +4656,20 @@ function isExpired(
 /**
  * Checks to see if session is expired
  */
-function isSessionExpired(session, timeouts, targetTime = +new Date()) {
+function isSessionExpired(
+  session,
+  {
+    maxReplayDuration,
+    sessionIdleExpire,
+    targetTime = Date.now(),
+  },
+) {
   return (
     // First, check that maximum session length has not been exceeded
-    isExpired(session.started, timeouts.maxSessionLife, targetTime) ||
+    isExpired(session.started, maxReplayDuration, targetTime) ||
     // check that the idle timeout has not been exceeded (i.e. user has
     // performed an action within the last `sessionIdleExpire` ms)
-    isExpired(session.lastActivity, timeouts.sessionIdleExpire, targetTime)
+    isExpired(session.lastActivity, sessionIdleExpire, targetTime)
   );
 }
 
@@ -4674,15 +4681,16 @@ function isSessionExpired(session, timeouts, targetTime = +new Date()) {
 function maybeRefreshSession(
   session,
   {
-    timeouts,
     traceInternals,
+    maxReplayDuration,
+    sessionIdleExpire,
   }
 
 ,
   sessionOptions,
 ) {
   // If not expired, all good, just keep the session
-  if (!isSessionExpired(session, timeouts)) {
+  if (!isSessionExpired(session, { sessionIdleExpire, maxReplayDuration })) {
     return session;
   }
 
@@ -4715,8 +4723,9 @@ function maybeRefreshSession(
 function loadOrCreateSession(
   currentSession,
   {
-    timeouts,
     traceInternals,
+    sessionIdleExpire,
+    maxReplayDuration,
   }
 
 ,
@@ -4731,9 +4740,11 @@ function loadOrCreateSession(
     return createSession(sessionOptions);
   }
 
-  return maybeRefreshSession(existingSession, { timeouts, traceInternals }, sessionOptions);
+  return maybeRefreshSession(existingSession, { sessionIdleExpire, traceInternals, maxReplayDuration }, sessionOptions);
 }
 
+const ReplayEventTypeCustom = 5;
+
 function isCustomEvent(event) {
   return event.type === EventType.Custom;
 }
@@ -4768,9 +4779,9 @@ async function addEvent(
   }
 
   // Throw out events that are +60min from the initial timestamp
-  if (timestampInMs > replay.getContext().initialTimestamp + replay.timeouts.maxSessionLife) {
+  if (timestampInMs > replay.getContext().initialTimestamp + replay.getOptions().maxReplayDuration) {
     logInfo(
-      `[Replay] Skipping event with timestamp ${timestampInMs} because it is after maxSessionLife`,
+      `[Replay] Skipping event with timestamp ${timestampInMs} because it is after maxReplayDuration`,
       replay.getOptions()._experiments.traceInternals,
     );
     return null;
@@ -7256,7 +7267,6 @@ class ReplayContainer  {
     this.timeouts = {
       sessionIdlePause: SESSION_IDLE_PAUSE_DURATION,
       sessionIdleExpire: SESSION_IDLE_EXPIRE_DURATION,
-      maxSessionLife: MAX_SESSION_LIFE,
     } ;
     this._lastActivity = Date.now();
     this._isEnabled = false;
@@ -7383,7 +7393,8 @@ class ReplayContainer  {
     const session = loadOrCreateSession(
       this.session,
       {
-        timeouts: this.timeouts,
+        maxReplayDuration: this._options.maxReplayDuration,
+        sessionIdleExpire: this.timeouts.sessionIdleExpire,
         traceInternals: this._options._experiments.traceInternals,
       },
       {
@@ -7413,7 +7424,8 @@ class ReplayContainer  {
     const session = loadOrCreateSession(
       this.session,
       {
-        timeouts: this.timeouts,
+        sessionIdleExpire: this.timeouts.sessionIdleExpire,
+        maxReplayDuration: this._options.maxReplayDuration,
         traceInternals: this._options._experiments.traceInternals,
       },
       {
@@ -7589,7 +7601,7 @@ class ReplayContainer  {
       // `shouldRefresh`, the session could be considered expired due to
       // lifespan, which is not what we want. Update session start date to be
       // the current timestamp, so that session is not considered to be
-      // expired. This means that max replay duration can be MAX_SESSION_LIFE +
+      // expired. This means that max replay duration can be MAX_REPLAY_DURATION +
       // (length of buffer), which we are ok with.
       this._updateUserActivity(activityTime);
       this._updateSessionActivity(activityTime);
@@ -7752,7 +7764,11 @@ class ReplayContainer  {
     }
 
     // Session is expired, trigger a full snapshot (which will create a new session)
-    this._triggerFullSnapshot();
+    if (this.isPaused()) {
+      this.resume();
+    } else {
+      this._triggerFullSnapshot();
+    }
 
     return false;
   }
@@ -7795,7 +7811,7 @@ class ReplayContainer  {
 
       this.addUpdate(() => {
         void addEvent(this, {
-          type: EventType.Custom,
+          type: ReplayEventTypeCustom,
           timestamp: breadcrumb.timestamp || 0,
           data: {
             tag: 'breadcrumb',
@@ -7866,7 +7882,8 @@ class ReplayContainer  {
     const session = loadOrCreateSession(
       this.session,
       {
-        timeouts: this.timeouts,
+        sessionIdleExpire: this.timeouts.sessionIdleExpire,
+        maxReplayDuration: this._options.maxReplayDuration,
         traceInternals: this._options._experiments.traceInternals,
       },
       {
@@ -7895,8 +7912,9 @@ class ReplayContainer  {
     const newSession = maybeRefreshSession(
       currentSession,
       {
-        timeouts: this.timeouts,
+        sessionIdleExpire: this.timeouts.sessionIdleExpire,
         traceInternals: this._options._experiments.traceInternals,
+        maxReplayDuration: this._options.maxReplayDuration,
       },
       {
         stickySession: Boolean(this._options.stickySession),
@@ -8031,7 +8049,10 @@ class ReplayContainer  {
       return;
     }
 
-    const expired = isSessionExpired(this.session, this.timeouts);
+    const expired = isSessionExpired(this.session, {
+      maxReplayDuration: this._options.maxReplayDuration,
+      ...this.timeouts,
+    });
 
     if (breadcrumb && !expired) {
       this._createCustomBreadcrumb(breadcrumb);
@@ -8210,7 +8231,7 @@ class ReplayContainer  {
       // Check total duration again, to avoid sending outdated stuff
       // We leave 30s wiggle room to accomodate late flushing etc.
       // This _could_ happen when the browser is suspended during flushing, in which case we just want to stop
-      if (timestamp - this._context.initialTimestamp > this.timeouts.maxSessionLife + 30000) {
+      if (timestamp - this._context.initialTimestamp > this._options.maxReplayDuration + 30000) {
         throw new Error('Session is too long, not sending replay');
       }
 
@@ -8278,10 +8299,10 @@ class ReplayContainer  {
     // A flush is about to happen, cancel any queued flushes
     this._debouncedFlush.cancel();
 
-    // If session is too short, or too long (allow some wiggle room over maxSessionLife), do not send it
+    // If session is too short, or too long (allow some wiggle room over maxReplayDuration), do not send it
     // This _should_ not happen, but it may happen if flush is triggered due to a page activity change or similar
     const tooShort = duration < this._options.minReplayDuration;
-    const tooLong = duration > this.timeouts.maxSessionLife + 5000;
+    const tooLong = duration > this._options.maxReplayDuration + 5000;
     if (tooShort || tooLong) {
       logInfo(
         `[Replay] Session duration (${Math.floor(duration / 1000)}s) is too ${
@@ -8501,6 +8522,7 @@ class Replay  {
     flushMinDelay = DEFAULT_FLUSH_MIN_DELAY,
     flushMaxDelay = DEFAULT_FLUSH_MAX_DELAY,
     minReplayDuration = MIN_REPLAY_DURATION,
+    maxReplayDuration = MAX_REPLAY_DURATION,
     stickySession = true,
     useCompression = true,
     _experiments = {},
@@ -8580,6 +8602,7 @@ class Replay  {
       flushMinDelay,
       flushMaxDelay,
       minReplayDuration: Math.min(minReplayDuration, MIN_REPLAY_DURATION_LIMIT),
+      maxReplayDuration: Math.min(maxReplayDuration, MAX_REPLAY_DURATION),
       stickySession,
       sessionSampleRate,
       errorSampleRate,