🔊 Add debug log on events sent after session expiration

Author: bcaudan

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

@@ -39,6 +39,7 @@ export interface SessionContext<TrackingType extends string> extends Context {
   trackingType: TrackingType
   isReplayForced: boolean
   anonymousId: string | undefined
+  expire: string | undefined
 }
 
 export const VISIBILITY_CHECK_DELAY = ONE_MINUTE
@@ -115,6 +116,7 @@ export function startSessionManager<TrackingType extends string>(
         trackingType: SESSION_NOT_TRACKED as TrackingType,
         isReplayForced: false,
         anonymousId: undefined,
+        expire: undefined,
       }
     }
 
@@ -123,6 +125,7 @@ export function startSessionManager<TrackingType extends string>(
       trackingType: session[productKey] as TrackingType,
       isReplayForced: !!session.forcedReplay,
       anonymousId: session.anonymousId,
+      expire: session.expire,
     }
   }
 

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

@@ -73,7 +73,7 @@ function startRumStub(
   const hooks = createHooks()
   const viewHistory = startViewHistory(lifeCycle)
   const urlContexts = startUrlContexts(lifeCycle, hooks, locationChangeObservable, location)
-  startSessionContext(hooks, sessionManager, noopRecorderApi, viewHistory)
+  startSessionContext(hooks, sessionManager, noopRecorderApi, viewHistory, pageStateHistory)
 
   const { stop: rumEventCollectionStop } = startRumEventCollection(
     lifeCycle,

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

@@ -136,7 +136,7 @@ export function startRum(
   const urlContexts = startUrlContexts(lifeCycle, hooks, locationChangeObservable, location)
   cleanupTasks.push(() => urlContexts.stop())
   const featureFlagContexts = startFeatureFlagContexts(lifeCycle, hooks, configuration)
-  startSessionContext(hooks, session, recorderApi, viewHistory)
+  startSessionContext(hooks, session, recorderApi, viewHistory, pageStateHistory)
   startConnectivityContext(hooks)
   startTrackingConsentContext(hooks, trackingConsentState)
   const globalContext = startGlobalContext(hooks, configuration, 'rum', true)

packages/rum-core/src/domain/assembly.spec.ts

@@ -8,6 +8,7 @@ import {
   mockRumConfiguration,
   mockViewHistory,
   noopRecorderApi,
+  mockPageStateHistory,
 } from '../../test'
 import type { RumEventDomainContext } from '../domainContext.types'
 import type { RawRumEvent } from '../rawRumEvent.types'
@@ -574,7 +575,7 @@ function setupAssemblyTestWithDefaults({
   const recorderApi = noopRecorderApi
   const viewHistory = { ...mockViewHistory(), findView: () => findView() }
   startGlobalContext(hooks, mockRumConfiguration(), 'rum', true)
-  startSessionContext(hooks, rumSessionManager, recorderApi, viewHistory)
+  startSessionContext(hooks, rumSessionManager, recorderApi, viewHistory, mockPageStateHistory())
   startRumAssembly(mockRumConfiguration(partialConfiguration), lifeCycle, hooks, reportErrorSpy)
 
   registerCleanupTask(() => {

packages/rum-core/src/domain/contexts/pageStateHistory.ts

@@ -39,6 +39,7 @@ export interface PageStateEntry {
 export interface PageStateHistory {
   wasInPageStateDuringPeriod: (state: PageState, startTime: RelativeTime, duration: Duration) => boolean
   addPageState(nextPageState: PageState, startTime?: RelativeTime): void
+  findPageStatesForPeriod: (startTime: RelativeTime, duration: Duration) => PageStateServerEntry[] | undefined
   stop: () => void
 }
 
@@ -99,14 +100,18 @@ export function startPageStateHistory(
     return pageStateEntryHistory.findAll(startTime, duration).some((pageState) => pageState.state === state)
   }
 
+  function findPageStatesForPeriod(startTime: RelativeTime, duration: Duration) {
+    const pageStateEntries = pageStateEntryHistory.findAll(startTime, duration)
+    return processPageStates(pageStateEntries, startTime, maxPageStateEntriesSelectable)
+  }
+
   hooks.register(
     HookNames.Assemble,
     ({ startTime, duration = 0 as Duration, eventType }): DefaultRumEventAttributes | SKIPPED => {
       if (eventType === RumEventType.VIEW) {
-        const pageStates = pageStateEntryHistory.findAll(startTime, duration)
         return {
           type: eventType,
-          _dd: { page_states: processPageStates(pageStates, startTime, maxPageStateEntriesSelectable) },
+          _dd: { page_states: findPageStatesForPeriod(startTime, duration) },
         }
       }
 
@@ -124,6 +129,7 @@ export function startPageStateHistory(
   return {
     wasInPageStateDuringPeriod,
     addPageState,
+    findPageStatesForPeriod,
     stop: () => {
       stopEventListeners()
       pageStateEntryHistory.stop()

packages/rum-core/src/domain/contexts/sessionContext.spec.ts

@@ -1,7 +1,11 @@
 import type { RelativeTime } from '@datadog/browser-core'
 import { clocksNow, DISCARDED, HookNames } from '@datadog/browser-core'
-import type { RumSessionManagerMock } from '../../../test'
-import { createRumSessionManagerMock, noopRecorderApi } from '../../../test'
+import {
+  type RumSessionManagerMock,
+  mockPageStateHistory,
+  createRumSessionManagerMock,
+  noopRecorderApi,
+} from '../../../test'
 import { SessionType } from '../rumSessionManager'
 import type { DefaultRumEventAttributes, DefaultTelemetryEventAttributes, Hooks } from '../hooks'
 import { createHooks } from '../hooks'
@@ -37,7 +41,7 @@ describe('session context', () => {
     getReplayStatsSpy = spyOn(recorderApi, 'getReplayStats')
     findViewSpy = spyOn(viewHistory, 'findView').and.returnValue(fakeView)
 
-    startSessionContext(hooks, sessionManager, recorderApi, viewHistory)
+    startSessionContext(hooks, sessionManager, recorderApi, viewHistory, mockPageStateHistory())
   })
 
   it('should set id and type', () => {

packages/rum-core/src/domain/contexts/sessionContext.ts

@@ -1,16 +1,28 @@
-import { DISCARDED, HookNames, SKIPPED } from '@datadog/browser-core'
-import { SessionReplayState, SessionType } from '../rumSessionManager'
+import type { ContextValue } from '@datadog/browser-core'
+import {
+  DISCARDED,
+  HookNames,
+  SKIPPED,
+  dateNow,
+  ONE_MINUTE,
+  addTelemetryDebug,
+  elapsed,
+  relativeNow,
+} from '@datadog/browser-core'
 import type { RumSessionManager } from '../rumSessionManager'
+import { SessionReplayState, SessionType } from '../rumSessionManager'
 import { RumEventType } from '../../rawRumEvent.types'
 import type { RecorderApi } from '../../boot/rumPublicApi'
 import type { DefaultRumEventAttributes, DefaultTelemetryEventAttributes, Hooks } from '../hooks'
 import type { ViewHistory } from './viewHistory'
+import type { PageStateHistory } from './pageStateHistory'
 
 export function startSessionContext(
   hooks: Hooks,
   sessionManager: RumSessionManager,
   recorderApi: RecorderApi,
-  viewHistory: ViewHistory
+  viewHistory: ViewHistory,
+  pageStateHistory: PageStateHistory
 ) {
   hooks.register(HookNames.Assemble, ({ eventType, startTime }): DefaultRumEventAttributes | DISCARDED => {
     const session = sessionManager.findTrackedSession(startTime)
@@ -19,6 +31,18 @@ export function startSessionContext(
     if (!session || !view) {
       return DISCARDED
     }
+    if (session.expire && dateNow() - Number(session.expire) > ONE_MINUTE) {
+      const duration = elapsed(startTime, relativeNow())
+      // monitor-until: 2026-01-01
+      addTelemetryDebug('Event sent after session expiration', {
+        debug: {
+          duration,
+          eventType,
+          expired_since: dateNow() - Number(session.expire),
+          page_state: pageStateHistory.findPageStatesForPeriod(startTime, duration) as ContextValue,
+        },
+      })
+    }
 
     let hasReplay
     let sampledForReplay

packages/rum-core/src/domain/rumSessionManager.ts

@@ -31,6 +31,7 @@ export interface RumSession {
   id: string
   sessionReplay: SessionReplayState
   anonymousId?: string
+  expire?: string
 }
 
 export const enum RumTrackingType {
@@ -88,6 +89,7 @@ export function startRumSessionManager(
               ? SessionReplayState.FORCED
               : SessionReplayState.OFF,
         anonymousId: session.anonymousId,
+        expire: session.expire,
       }
     },
     expire: sessionManager.expire,

packages/rum-core/test/mockPageStateHistory.ts

@@ -5,6 +5,7 @@ export function mockPageStateHistory(partialPageStateHistory?: Partial<PageState
   const pageStateHistory: PageStateHistory = {
     addPageState: noop,
     stop: noop,
+    findPageStatesForPeriod: () => [],
     wasInPageStateDuringPeriod: () => false,
     ...partialPageStateHistory,
   }