Merge error-session capture onto publish

CHANGELOG.md

@@ -18,6 +18,31 @@
 
 ---
 
+## Unreleased
+
+- ✨ Two new init options keep only the sessions that report an error, for customers who want every
+  error investigated without storing and paying for every session. `sessionOnError` keeps the
+  events of a session the plain `sessionSampleRate` draw missed: it records from the start, uploads
+  nothing, and is never stored unless it reports an error — on the first error the withheld history,
+  up to the last minute of it, is uploaded and collection continues. `sessionReplayOnError` does the
+  same for the Session Replay of a session the plain `sessionReplaySampleRate` draw missed. Both are
+  switches, default off, and apply only to what the plain rate did not already draw, so a session is
+  never counted twice. Both can also be set from the console when `remoteConfigurationEnabled` is on.
+  View events of such a session carry `sampled_for_error` / `sampled_for_error_replay` so a stored
+  error session can be told apart from an ordinary one.
+
+  Known limitations of the on-error switches:
+
+  - A site that gates recording on consent by calling `startSessionReplayRecording()` itself must set
+    `startSessionReplayRecordingManually: true` explicitly. With `remoteConfigurationEnabled` on and an
+    init replay rate of 0, the recorder now starts on its own so a console-delivered rate has something
+    to withhold — which would otherwise begin recording before the consent call.
+  - On a single-page app, the released replay reaches back only to the start of the view the error
+    happened in, while the released events reach back the full minute across views.
+  - With the opt-in `compressIntakeRequests`, closing the tab within a few seconds of a session's first
+    error can lose that release: the burst is then too large for `sendBeacon` and the exit fetch is
+    cancelled by the unload. The default (uncompressed) path is not affected.
+
 ## v0.2.3
 
 - ✨ A session sample rate published from the console that rises above 0 now ends the running

packages/core/src/domain/session/sessionManager.spec.ts

@@ -665,7 +665,7 @@ describe('startSessionManager', () => {
       const sessionManager = startSessionManagerWithDefaults()
       sessionManager.sessionStateUpdateObservable.subscribe(sessionStateUpdateSpy)
 
-      sessionManager.updateSessionState({ extra: 'extra' })
+      sessionManager.updateSessionState(() => ({ extra: 'extra' }))
 
       expectSessionIdToBeDefined(sessionManager)
       expect(sessionStateUpdateSpy).toHaveBeenCalledTimes(1)

packages/core/src/domain/session/sessionManager.ts

@@ -20,13 +20,19 @@ export interface SessionManager<TrackingType extends string> {
   expireObservable: Observable<void>
   sessionStateUpdateObservable: Observable<{ previousState: SessionState; newState: SessionState }>
   expire: () => void
-  updateSessionState: (state: Partial<SessionState>) => void
+  updateSessionState: (update: (state: SessionState) => Partial<SessionState> | undefined) => void
 }
 
 export interface SessionContext<TrackingType extends string> extends Context {
   id: string
   trackingType: TrackingType
   isReplayForced: boolean
+  /**
+   * Whether an error has already been reported during this session. Persisted in the session store
+   * so it survives page navigation: an error session must not go back to withholding its replay
+   * just because the user moved to another page.
+   */
+  hasError: boolean
   anonymousId: string | undefined
 }
 
@@ -92,6 +98,7 @@ export function startSessionManager<TrackingType extends string>(
       id: sessionStore.getSession().id!,
       trackingType: sessionStore.getSession()[productKey] as TrackingType,
       isReplayForced: !!sessionStore.getSession().forcedReplay,
+      hasError: !!sessionStore.getSession().hasError,
       anonymousId: sessionStore.getSession().anonymousId,
     }
   }

packages/core/src/domain/session/sessionStore.spec.ts

@@ -596,7 +596,7 @@ describe('session store', () => {
       sessionStoreManager = setupSessionStore(updateSpy)
       otherSessionStoreManager = setupSessionStore(otherUpdateSpy)
 
-      sessionStoreManager.updateSessionState({ extra: 'extra' })
+      sessionStoreManager.updateSessionState(() => ({ extra: 'extra' }))
 
       expect(updateSpy).toHaveBeenCalledTimes(1)
 

packages/core/src/domain/session/sessionStore.ts

@@ -29,7 +29,12 @@ export interface SessionStore {
   sessionStateUpdateObservable: Observable<{ previousState: SessionState; newState: SessionState }>
   expire: () => void
   stop: () => void
-  updateSessionState: (state: Partial<SessionState>) => void
+  /**
+   * Applies a change to the stored session under the store lock. The producer sees the state the
+   * change would land on and returns `undefined` to make it a no-op - which is how a write meant for
+   * one session avoids landing on the one that replaced it while the write was waiting for the lock.
+   */
+  updateSessionState: (update: (state: SessionState) => Partial<SessionState> | undefined) => void
 }
 
 /**
@@ -216,10 +221,13 @@ export function startSessionStore<TrackingType extends string>(
     renewObservable.notify()
   }
 
-  function updateSessionState(partialSessionState: Partial<SessionState>) {
+  function updateSessionState(update: (state: SessionState) => Partial<SessionState> | undefined) {
     processSessionStoreOperations(
       {
-        process: (sessionState) => ({ ...sessionState, ...partialSessionState }),
+        process: (sessionState) => {
+          const partialSessionState = update(sessionState)
+          return partialSessionState && { ...sessionState, ...partialSessionState }
+        },
         after: synchronizeSession,
       },
       sessionStoreStrategy

packages/core/src/domain/session/sessionStoreOperations.spec.ts

@@ -1,3 +1,4 @@
+import { startFakeTelemetry } from '../telemetry'
 import type { MockStorage } from '../../../test'
 import { mockClock, mockCookie, mockLocalStorage } from '../../../test'
 import type { CookieOptions } from '../../browser/cookie'
@@ -232,6 +233,7 @@ const DEFAULT_INIT_CONFIGURATION = { trackAnonymousUser: true } as Configuration
 
       it('should abort after a max number of retry', () => {
         const clock = mockClock()
+        const telemetry = startFakeTelemetry()
 
         sessionStoreStrategy.persistSession(initialSession)
         storage.setSpy.calls.reset()
@@ -246,6 +248,7 @@ const DEFAULT_INIT_CONFIGURATION = { trackAnonymousUser: true } as Configuration
         expect(processSpy).not.toHaveBeenCalled()
         expect(afterSpy).not.toHaveBeenCalled()
         expect(storage.setSpy).not.toHaveBeenCalled()
+        expect(telemetry).toContain(jasmine.objectContaining({ message: 'Session store lock retries exhausted' }))
 
         clock.cleanup()
       })

packages/core/src/domain/session/sessionStoreOperations.ts

@@ -1,3 +1,4 @@
+import { addTelemetryDebug } from '../telemetry'
 import { setTimeout } from '../../tools/timer'
 import { generateUUID } from '../../tools/utils/stringUtils'
 import type { SessionStoreStrategy } from './storeStrategies/sessionStoreStrategy'
@@ -43,6 +44,7 @@ export function processSessionStoreOperations(
     return
   }
   if (isLockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {
+    addTelemetryDebug('Session store lock retries exhausted', { retries: numberOfRetries })
     next(sessionStoreStrategy)
     return
   }

packages/core/src/domain/telemetry/telemetry.ts

@@ -4,7 +4,9 @@ import { NO_ERROR_STACK_PRESENT_MESSAGE, isError } from '../error/error'
 import { toStackTraceString } from '../../tools/stackTrace/handlingStack'
 import { getExperimentalFeatures } from '../../tools/experimentalFeatures'
 import type { Configuration } from '../configuration'
-import { INTAKE_SITE_STAGING } from '../configuration'
+// Import the constant without loading configuration construction, which uses session storage.
+// eslint-disable-next-line local-rules/disallow-protected-directory-import
+import { INTAKE_SITE_STAGING } from '../configuration/intakeSites'
 import { Observable } from '../../tools/observable'
 import { timeStampNow } from '../../tools/utils/timeUtils'
 import { displayIfDebugEnabled, startMonitorErrorCollection } from '../../tools/monitor'

packages/core/src/transport/flushController.ts

@@ -78,6 +78,7 @@ export function createFlushController({
   }
 
   return {
+    flush,
     flushObservable,
     get messagesCount() {
       return currentMessagesCount

packages/core/src/transport/startBatchWithReplica.ts

@@ -6,6 +6,7 @@ import type { RawError } from '../domain/error/error.types'
 import type { Encoder } from '../tools/encoder'
 import { createBatch } from './batch'
 import { createHttpRequest } from './httpRequest'
+import type { FlushReason } from './flushController'
 import { createFlushController } from './flushController'
 
 export interface BatchConfiguration {
@@ -45,6 +46,10 @@ export function startBatchWithReplica<T extends Context>(
   }
 
   return {
+    flush: (reason: FlushReason) => {
+      primaryBatch.flushController.flush(reason)
+      replicaBatch?.flushController.flush(reason)
+    },
     flushObservable: primaryBatch.flushController.flushObservable,
 
     add(message: T, replicated = true) {

packages/core/test/emulate/mockFlushController.ts

@@ -8,7 +8,7 @@ export function createMockFlushController() {
   let currentMessagesCount = 0
   let currentBytesCount = 0
 
-  return {
+  const controller = {
     notifyBeforeAddMessage: jasmine
       .createSpy<FlushController['notifyBeforeAddMessage']>()
       .and.callFake((messageBytesCount) => {
@@ -33,6 +33,11 @@ export function createMockFlushController() {
       return currentBytesCount
     },
     flushObservable,
+    flush(reason: FlushReason) {
+      if (currentMessagesCount > 0) {
+        controller.notifyFlush(reason)
+      }
+    },
     notifyFlush(reason: FlushReason = 'bytes_limit') {
       if (currentMessagesCount === 0) {
         throw new Error(
@@ -53,4 +58,5 @@ export function createMockFlushController() {
       })
     },
   } satisfies Record<any, any> & FlushController
+  return controller
 }

packages/rum-core/src/boot/startRum.ts

@@ -29,6 +29,7 @@ import { startErrorCollection } from '../domain/error/errorCollection'
 import { startResourceCollection } from '../domain/resource/resourceCollection'
 import { startViewCollection } from '../domain/view/viewCollection'
 import { startRumSessionManager, startRumSessionManagerStub } from '../domain/rumSessionManager'
+import { startSessionErrorTracking } from '../domain/trackSessionError'
 import { startRumBatch } from '../transport/startRumBatch'
 import { startRumEventBridge } from '../transport/startRumEventBridge'
 import { startUrlContexts } from '../domain/contexts/urlContexts'
@@ -103,6 +104,11 @@ export function startRum(
   }
 
   const pageMayExitObservable = createPageMayExitObservable(configuration)
+  // Subscribed before the batch below, and it has to stay that way. The batch flushes on this same
+  // observable, and observers run in the order they subscribed - so the withheld event buffer, which
+  // releases on the lifecycle notification raised here, has to get its events into the batch before
+  // the flush that is the page's last chance to send them. The same holds for the session expiry
+  // relay in `startRumSessionManager`, which the session manager registers just below.
   const pageMayExitSubscription = pageMayExitObservable.subscribe((event) => {
     lifeCycle.notify(LifeCycleEventType.PAGE_MAY_EXIT, event)
   })
@@ -121,6 +127,12 @@ export function startRum(
     : startRumSessionManager(configuration, lifeCycle, trackingConsentState)
   cleanupTasks.push(session.stop)
 
+  // Subscribed before the batch below, and it has to stay that way: the withheld event buffer runs
+  // on the same event, and only sees a session as released if this has already marked it. Reorder
+  // them and the release waits for whatever event happens to come next.
+  const sessionErrorTracking = startSessionErrorTracking(lifeCycle, session)
+  cleanupTasks.push(() => sessionErrorTracking.stop())
+
   if (!canUseEventBridge()) {
     // FLASHCAT FORK - keep the console's sampling rates fresh, at the rhythm the sessions read
     // them: once now and once per session renewal. It is skipped under an event bridge, where the
@@ -135,7 +147,7 @@ export function startRum(
       telemetry.observable,
       reportError,
       pageMayExitObservable,
-      session.expireObservable,
+      session,
       createEncoder
     )
     cleanupTasks.push(() => batch.stop())