@sentry/replay 7.64.0 → 7.65.0

package/esm/index.js

@@ -4519,41 +4519,6 @@ function deleteSession() {
   }
 }
 
-/**
- * Given an initial timestamp and an expiry duration, checks to see if current
- * time should be considered as expired.
- */
-function isExpired(
-  initialTime,
-  expiry,
-  targetTime = +new Date(),
-) {
-  // Always expired if < 0
-  if (initialTime === null || expiry === undefined || expiry < 0) {
-    return true;
-  }
-
-  // Never expires if == 0
-  if (expiry === 0) {
-    return false;
-  }
-
-  return initialTime + expiry <= targetTime;
-}
-
-/**
- * Checks to see if session is expired
- */
-function isSessionExpired(session, timeouts, targetTime = +new Date()) {
-  return (
-    // First, check that maximum session length has not been exceeded
-    isExpired(session.started, timeouts.maxSessionLife, 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)
-  );
-}
-
 /**
  * Given a sample rate, returns true if replay should be sampled.
  *
@@ -4596,6 +4561,7 @@ function makeSession(session) {
   const segmentId = session.segmentId || 0;
   const sampled = session.sampled;
   const shouldRefresh = typeof session.shouldRefresh === 'boolean' ? session.shouldRefresh : true;
+  const previousSessionId = session.previousSessionId;
 
   return {
     id,
@@ -4604,6 +4570,7 @@ function makeSession(session) {
     segmentId,
     sampled,
     shouldRefresh,
+    previousSessionId,
   };
 }
 
@@ -4619,10 +4586,14 @@ function getSessionSampleType(sessionSampleRate, allowBuffering) {
  * that all replays will be saved to as attachments. Currently, we only expect
  * one of these Sentry events per "replay session".
  */
-function createSession({ sessionSampleRate, allowBuffering, stickySession = false }) {
+function createSession(
+  { sessionSampleRate, allowBuffering, stickySession = false },
+  { previousSessionId } = {},
+) {
   const sampled = getSessionSampleType(sessionSampleRate, allowBuffering);
   const session = makeSession({
     sampled,
+    previousSessionId,
   });
 
   if (stickySession) {
@@ -4659,49 +4630,106 @@ function fetchSession(traceInternals) {
 }
 
 /**
- * Get or create a session
+ * Given an initial timestamp and an expiry duration, checks to see if current
+ * time should be considered as expired.
+ */
+function isExpired(
+  initialTime,
+  expiry,
+  targetTime = +new Date(),
+) {
+  // Always expired if < 0
+  if (initialTime === null || expiry === undefined || expiry < 0) {
+    return true;
+  }
+
+  // Never expires if == 0
+  if (expiry === 0) {
+    return false;
+  }
+
+  return initialTime + expiry <= targetTime;
+}
+
+/**
+ * Checks to see if session is expired
+ */
+function isSessionExpired(session, timeouts, targetTime = +new Date()) {
+  return (
+    // First, check that maximum session length has not been exceeded
+    isExpired(session.started, timeouts.maxSessionLife, 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)
+  );
+}
+
+/**
+ * Check a session, and either return it or a refreshed version of it.
+ * The refreshed version may be unsampled.
+ * You can check if the session has changed by comparing the session IDs.
+ */
+function maybeRefreshSession(
+  session,
+  {
+    timeouts,
+    traceInternals,
+  }
+
+,
+  sessionOptions,
+) {
+  // If not expired, all good, just keep the session
+  if (!isSessionExpired(session, timeouts)) {
+    return session;
+  }
+
+  const isBuffering = session.sampled === 'buffer';
+
+  // If we are buffering & the session may be refreshed, just return it
+  if (isBuffering && session.shouldRefresh) {
+    return session;
+  }
+
+  // If we are buffering & the session may not be refreshed (=it was converted to session previously already)
+  // We return an unsampled new session
+  if (isBuffering) {
+    logInfoNextTick('[Replay] Session should not be refreshed', traceInternals);
+    return makeSession({ sampled: false });
+  }
+
+  // Else, we are not buffering, and the session is expired, so we need to create a new one
+  logInfoNextTick('[Replay] Session has expired, creating new one...', traceInternals);
+
+  const newSession = createSession(sessionOptions, { previousSessionId: session.id });
+
+  return newSession;
+}
+
+/**
+ * Get or create a session, when initializing the replay.
+ * Returns a session that may be unsampled.
  */
-function getSession({
-  timeouts,
+function loadOrCreateSession(
   currentSession,
-  stickySession,
-  sessionSampleRate,
-  allowBuffering,
-  traceInternals,
-}) {
-  // If session exists and is passed, use it instead of always hitting session storage
-  const session = currentSession || (stickySession && fetchSession(traceInternals));
-
-  if (session) {
-    // If there is a session, check if it is valid (e.g. "last activity" time
-    // should be within the "session idle time", and "session started" time is
-    // within "max session time").
-    const isExpired = isSessionExpired(session, timeouts);
-
-    if (!isExpired || (allowBuffering && session.shouldRefresh)) {
-      return { type: 'saved', session };
-    } else if (!session.shouldRefresh) {
-      // This is the case if we have an error session that is completed
-      // (=triggered an error). Session will continue as session-based replay,
-      // and when this session is expired, it will not be renewed until user
-      // reloads.
-      const discardedSession = makeSession({ sampled: false });
-      logInfoNextTick('[Replay] Session should not be refreshed', traceInternals);
-      return { type: 'new', session: discardedSession };
-    } else {
-      logInfoNextTick('[Replay] Session has expired', traceInternals);
-    }
-    // Otherwise continue to create a new session
+  {
+    timeouts,
+    traceInternals,
   }
 
-  const newSession = createSession({
-    stickySession,
-    sessionSampleRate,
-    allowBuffering,
-  });
-  logInfoNextTick('[Replay] Created new session', traceInternals);
+,
+  sessionOptions,
+) {
+  // If session exists and is passed, use it instead of always hitting session storage
+  const existingSession = currentSession || (sessionOptions.stickySession && fetchSession(traceInternals));
+
+  // No session exists yet, just create a new one
+  if (!existingSession) {
+    logInfoNextTick('[Replay] Created new session', traceInternals);
+    return createSession(sessionOptions);
+  }
 
-  return { type: 'new', session: newSession };
+  return maybeRefreshSession(existingSession, { timeouts, traceInternals }, sessionOptions);
 }
 
 function isCustomEvent(event) {
@@ -7306,13 +7334,7 @@ class ReplayContainer  {
 
     // Otherwise if there is _any_ sample rate set, try to load an existing
     // session, or create a new one.
-    const isSessionSampled = this._loadAndCheckSession();
-
-    if (!isSessionSampled) {
-      // This should only occur if `errorSampleRate` is 0 and was unsampled for
-      // session-based replay. In this case there is nothing to do.
-      return;
-    }
+    this._initializeSessionForSampling();
 
     if (!this.session) {
       // This should not happen, something wrong has occurred
@@ -7320,14 +7342,16 @@ class ReplayContainer  {
       return;
     }
 
-    if (this.session.sampled && this.session.sampled !== 'session') {
-      // If not sampled as session-based, then recording mode will be `buffer`
-      // Note that we don't explicitly check if `sampled === 'buffer'` because we
-      // could have sessions from Session storage that are still `error` from
-      // prior SDK version.
-      this.recordingMode = 'buffer';
+    if (this.session.sampled === false) {
+      // This should only occur if `errorSampleRate` is 0 and was unsampled for
+      // session-based replay. In this case there is nothing to do.
+      return;
     }
 
+    // If segmentId > 0, it means we've previously already captured this session
+    // In this case, we still want to continue in `session` recording mode
+    this.recordingMode = this.session.sampled === 'buffer' && this.session.segmentId === 0 ? 'buffer' : 'session';
+
     logInfoNextTick(
       `[Replay] Starting replay in ${this.recordingMode} mode`,
       this._options._experiments.traceInternals,
@@ -7354,19 +7378,20 @@ class ReplayContainer  {
 
     logInfoNextTick('[Replay] Starting replay in session mode', this._options._experiments.traceInternals);
 
-    const previousSessionId = this.session && this.session.id;
-
-    const { session } = getSession({
-      timeouts: this.timeouts,
-      stickySession: Boolean(this._options.stickySession),
-      currentSession: this.session,
-      // This is intentional: create a new session-based replay when calling `start()`
-      sessionSampleRate: 1,
-      allowBuffering: false,
-      traceInternals: this._options._experiments.traceInternals,
-    });
+    const session = loadOrCreateSession(
+      this.session,
+      {
+        timeouts: this.timeouts,
+        traceInternals: this._options._experiments.traceInternals,
+      },
+      {
+        stickySession: this._options.stickySession,
+        // This is intentional: create a new session-based replay when calling `start()`
+        sessionSampleRate: 1,
+        allowBuffering: false,
+      },
+    );
 
-    session.previousSessionId = previousSessionId;
     this.session = session;
 
     this._initializeRecording();
@@ -7383,18 +7408,19 @@ class ReplayContainer  {
 
     logInfoNextTick('[Replay] Starting replay in buffer mode', this._options._experiments.traceInternals);
 
-    const previousSessionId = this.session && this.session.id;
-
-    const { session } = getSession({
-      timeouts: this.timeouts,
-      stickySession: Boolean(this._options.stickySession),
-      currentSession: this.session,
-      sessionSampleRate: 0,
-      allowBuffering: true,
-      traceInternals: this._options._experiments.traceInternals,
-    });
+    const session = loadOrCreateSession(
+      this.session,
+      {
+        timeouts: this.timeouts,
+        traceInternals: this._options._experiments.traceInternals,
+      },
+      {
+        stickySession: this._options.stickySession,
+        sessionSampleRate: 0,
+        allowBuffering: true,
+      },
+    );
 
-    session.previousSessionId = previousSessionId;
     this.session = session;
 
     this.recordingMode = 'buffer';
@@ -7505,7 +7531,7 @@ class ReplayContainer  {
    * new DOM checkout.`
    */
    resume() {
-    if (!this._isPaused || !this._loadAndCheckSession()) {
+    if (!this._isPaused || !this._checkSession()) {
       return;
     }
 
@@ -7613,7 +7639,7 @@ class ReplayContainer  {
     if (!this._stopRecording) {
       // Create a new session, otherwise when the user action is flushed, it
       // will get rejected due to an expired session.
-      if (!this._loadAndCheckSession()) {
+      if (!this._checkSession()) {
         return;
       }
 
@@ -7712,7 +7738,7 @@ class ReplayContainer  {
 
     // --- There is recent user activity --- //
     // This will create a new session if expired, based on expiry length
-    if (!this._loadAndCheckSession()) {
+    if (!this._checkSession()) {
       return;
     }
 
@@ -7829,31 +7855,63 @@ class ReplayContainer  {
 
   /**
    * Loads (or refreshes) the current session.
+   */
+   _initializeSessionForSampling() {
+    // Whenever there is _any_ error sample rate, we always allow buffering
+    // Because we decide on sampling when an error occurs, we need to buffer at all times if sampling for errors
+    const allowBuffering = this._options.errorSampleRate > 0;
+
+    const session = loadOrCreateSession(
+      this.session,
+      {
+        timeouts: this.timeouts,
+        traceInternals: this._options._experiments.traceInternals,
+      },
+      {
+        stickySession: this._options.stickySession,
+        sessionSampleRate: this._options.sessionSampleRate,
+        allowBuffering,
+      },
+    );
+
+    this.session = session;
+  }
+
+  /**
+   * Checks and potentially refreshes the current session.
    * Returns false if session is not recorded.
    */
-   _loadAndCheckSession() {
-    const { type, session } = getSession({
-      timeouts: this.timeouts,
-      stickySession: Boolean(this._options.stickySession),
-      currentSession: this.session,
-      sessionSampleRate: this._options.sessionSampleRate,
-      allowBuffering: this._options.errorSampleRate > 0 || this.recordingMode === 'buffer',
-      traceInternals: this._options._experiments.traceInternals,
-    });
+   _checkSession() {
+    // If there is no session yet, we do not want to refresh anything
+    // This should generally not happen, but to be safe....
+    if (!this.session) {
+      return false;
+    }
+
+    const currentSession = this.session;
+
+    const newSession = maybeRefreshSession(
+      currentSession,
+      {
+        timeouts: this.timeouts,
+        traceInternals: this._options._experiments.traceInternals,
+      },
+      {
+        stickySession: Boolean(this._options.stickySession),
+        sessionSampleRate: this._options.sessionSampleRate,
+        allowBuffering: this._options.errorSampleRate > 0,
+      },
+    );
+
+    const isNew = newSession.id !== currentSession.id;
 
     // If session was newly created (i.e. was not loaded from storage), then
     // enable flag to create the root replay
-    if (type === 'new') {
+    if (isNew) {
       this.setInitialState();
+      this.session = newSession;
     }
 
-    const currentSessionId = this.getSessionId();
-    if (session.id !== currentSessionId) {
-      session.previousSessionId = currentSessionId;
-    }
-
-    this.session = session;
-
     if (!this.session.sampled) {
       void this.stop({ reason: 'session not refreshed' });
       return false;