🔊 add telemetry for unexpected session id changes (#3815)

* 🔊 add telemetry for unexpected session id changes

* 👌 add cookie values in the telemetry log


Also, skip session state when there is no id (i.e. the cookie is
expired) because it's noisy and isn't a problematic state.

Author: BenoitZugmeyer

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

@@ -2,7 +2,7 @@ import { Observable } from '../../tools/observable'
 import type { Context } from '../../tools/serialisation/context'
 import { createValueHistory } from '../../tools/valueHistory'
 import type { RelativeTime } from '../../tools/utils/timeUtils'
-import { clocksOrigin, ONE_MINUTE, relativeNow } from '../../tools/utils/timeUtils'
+import { clocksOrigin, dateNow, ONE_MINUTE, relativeNow } from '../../tools/utils/timeUtils'
 import { addEventListener, addEventListeners, DOM_EVENT } from '../../browser/addEventListener'
 import { clearInterval, setInterval } from '../../tools/timer'
 import type { Configuration } from '../configuration'
@@ -11,10 +11,15 @@ import { addTelemetryDebug } from '../telemetry'
 import { isSyntheticsTest } from '../synthetics/syntheticsWorkerValues'
 import type { CookieStore } from '../../browser/browser.types'
 import { getCurrentSite } from '../../browser/cookie'
+import { ExperimentalFeature, isExperimentalFeatureEnabled } from '../../tools/experimentalFeatures'
+import { findLast } from '../../tools/utils/polyfills'
+import { monitorError } from '../../tools/monitor'
 import { SESSION_NOT_TRACKED, SESSION_TIME_OUT_DELAY } from './sessionConstants'
 import { startSessionStore } from './sessionStore'
 import type { SessionState } from './sessionState'
+import { toSessionState } from './sessionState'
 import { retrieveSessionCookie } from './storeStrategies/sessionInCookie'
+import { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy'
 
 export interface SessionManager<TrackingType extends string> {
   findSession: (
@@ -75,6 +80,12 @@ export function startSessionManager<TrackingType extends string>(
   // manager is started.
   sessionStore.expandOrRenewSession()
   sessionContextHistory.add(buildSessionContext(), clocksOrigin().relative)
+  if (isExperimentalFeatureEnabled(ExperimentalFeature.SHORT_SESSION_INVESTIGATION)) {
+    const session = sessionStore.getSession()
+    if (session) {
+      detectSessionIdChange(configuration, session)
+    }
+  }
 
   trackingConsentState.observable.subscribe(() => {
     if (trackingConsentState.isGranted()) {
@@ -163,24 +174,69 @@ function trackResume(configuration: Configuration, cb: () => void) {
 
 async function reportUnexpectedSessionState() {
   const rawSession = retrieveSessionCookie()
-  let sessionCookies: string[] | Awaited<ReturnType<CookieStore['getAll']>> = []
-
-  if ('cookieStore' in window) {
-    sessionCookies = await (window as { cookieStore: CookieStore }).cookieStore.getAll('_dd_s')
-  } else {
-    sessionCookies = document.cookie.split(/\s*;\s*/).filter((cookie) => cookie.startsWith('_dd_s'))
-  }
-
   addTelemetryDebug('Unexpected session state', {
     session: rawSession,
     isSyntheticsTest: isSyntheticsTest(),
     createdTimestamp: rawSession?.created,
     expireTimestamp: rawSession?.expire,
-    cookie: {
-      count: sessionCookies.length,
-      domain: getCurrentSite(),
-      ...sessionCookies,
-    },
+    cookie: await getSessionCookies(),
     currentDomain: `${window.location.protocol}//${window.location.hostname}`,
   })
 }
+
+function detectSessionIdChange(configuration: Configuration, initialSessionState: SessionState) {
+  if (!window.cookieStore || !initialSessionState.created) {
+    return
+  }
+
+  const sessionCreatedTime = Number(initialSessionState.created)
+  const sdkInitTime = dateNow()
+
+  const { stop } = addEventListener(configuration, cookieStore as CookieStore, DOM_EVENT.CHANGE, listener)
+  stopCallbacks.push(stop)
+
+  function listener(event: CookieChangeEvent) {
+    const changed = findLast(event.changed, (change): change is CookieListItem => change.name === SESSION_STORE_KEY)
+    if (!changed) {
+      return
+    }
+
+    const sessionAge = dateNow() - sessionCreatedTime
+    if (sessionAge > 14 * ONE_MINUTE) {
+      // The session might have expired just because it's too old or lack activity
+      stop()
+    } else {
+      const newSessionState = toSessionState(changed.value)
+      if (newSessionState.id && newSessionState.id !== initialSessionState.id) {
+        stop()
+        const time = dateNow() - sdkInitTime
+        getSessionCookies()
+          .then((cookie) => {
+            addTelemetryDebug('Session cookie changed', {
+              time,
+              session_age: sessionAge,
+              old: initialSessionState,
+              new: newSessionState,
+              cookie,
+            })
+          })
+          .catch(monitorError)
+      }
+    }
+  }
+}
+
+async function getSessionCookies(): Promise<{ count: number; domain: string }> {
+  let sessionCookies: string[] | Awaited<ReturnType<CookieStore['getAll']>>
+  if ('cookieStore' in window) {
+    sessionCookies = await (window as { cookieStore: CookieStore }).cookieStore.getAll(SESSION_STORE_KEY)
+  } else {
+    sessionCookies = document.cookie.split(/\s*;\s*/).filter((cookie) => cookie.startsWith(SESSION_STORE_KEY))
+  }
+
+  return {
+    count: sessionCookies.length,
+    domain: getCurrentSite(),
+    ...sessionCookies,
+  }
+}

packages/core/src/tools/experimentalFeatures.ts

@@ -19,6 +19,7 @@ export enum ExperimentalFeature {
   EARLY_REQUEST_COLLECTION = 'early_request_collection',
   WATCH_COOKIE_WITHOUT_LOCK = 'watch_cookie_without_lock',
   USE_TREE_WALKER_FOR_ACTION_NAME = 'use_tree_walker_for_action_name',
+  SHORT_SESSION_INVESTIGATION = 'short_session_investigation',
 }
 
 const enabledExperimentalFeatures: Set<ExperimentalFeature> = new Set()

packages/core/src/tools/utils/polyfills.ts

@@ -1,6 +1,6 @@
 export function findLast<T, S extends T>(
-  array: T[],
-  predicate: (item: T, index: number, array: T[]) => item is S
+  array: readonly T[],
+  predicate: (item: T, index: number, array: readonly T[]) => item is S
 ): S | undefined {
   for (let i = array.length - 1; i >= 0; i -= 1) {
     const item = array[i]