@kubesense/kubesense-browser-rum-core 1.0.0

package/src/domain/contexts/ciVisibilityContext.ts

@@ -0,0 +1,50 @@
+import { getInitCookie, HookNames, SKIPPED } from '@kubesense/kubesense-browser-core'
+import type { Configuration } from '@kubesense/kubesense-browser-core'
+import { createCookieObservable } from '../../browser/cookieObservable'
+import { SessionType } from '../rumSessionManager'
+import type { DefaultRumEventAttributes, Hooks } from '../hooks'
+
+export const CI_VISIBILITY_TEST_ID_COOKIE_NAME = 'kubesense-ci-visibility-test-execution-id'
+
+export interface CiTestWindow extends Window {
+  Cypress?: {
+    env: (key: string) => string | undefined
+  }
+}
+
+export type CiVisibilityContext = ReturnType<typeof startCiVisibilityContext>
+
+export function startCiVisibilityContext(
+  configuration: Configuration,
+  hooks: Hooks,
+  cookieObservable = createCookieObservable(configuration, CI_VISIBILITY_TEST_ID_COOKIE_NAME)
+) {
+  let testExecutionId =
+    getInitCookie(CI_VISIBILITY_TEST_ID_COOKIE_NAME) || (window as CiTestWindow).Cypress?.env('traceId')
+
+  const cookieObservableSubscription = cookieObservable.subscribe((value) => {
+    testExecutionId = value
+  })
+
+  hooks.register(HookNames.Assemble, ({ eventType }): DefaultRumEventAttributes | SKIPPED => {
+    if (typeof testExecutionId !== 'string') {
+      return SKIPPED
+    }
+
+    return {
+      type: eventType,
+      session: {
+        type: SessionType.CI_TEST,
+      },
+      ci_test: {
+        test_execution_id: testExecutionId,
+      },
+    }
+  })
+
+  return {
+    stop: () => {
+      cookieObservableSubscription.unsubscribe()
+    },
+  }
+}

package/src/domain/contexts/connectivityContext.ts

@@ -0,0 +1,12 @@
+import { getConnectivity, HookNames } from '@kubesense/kubesense-browser-core'
+import type { DefaultRumEventAttributes, Hooks } from '../hooks'
+
+export function startConnectivityContext(hooks: Hooks) {
+  hooks.register(
+    HookNames.Assemble,
+    ({ eventType }): DefaultRumEventAttributes => ({
+      type: eventType,
+      connectivity: getConnectivity(),
+    })
+  )
+}

package/src/domain/contexts/defaultContext.ts

@@ -0,0 +1,43 @@
+import { canUseEventBridge, currentDrift, HookNames, round, timeStampNow } from '@kubesense/kubesense-browser-core'
+import type { RumConfiguration } from '../configuration'
+import type { DefaultRumEventAttributes, DefaultTelemetryEventAttributes, Hooks } from '../hooks'
+
+// replaced at build time
+declare const __BUILD_ENV__SDK_VERSION__: string
+
+export type SdkName = 'rum' | 'rum-slim' | 'rum-synthetics'
+
+export function startDefaultContext(hooks: Hooks, configuration: RumConfiguration, sdkName: SdkName | undefined) {
+  hooks.register(HookNames.Assemble, ({ eventType }): DefaultRumEventAttributes => {
+    const source = configuration.source
+
+    return {
+      type: eventType,
+      _kubesense: {
+        format_version: 2,
+        drift: currentDrift(),
+        configuration: {
+          session_sample_rate: round(configuration.sessionSampleRate, 3),
+          session_replay_sample_rate: round(configuration.sessionReplaySampleRate, 3),
+          profiling_sample_rate: round(configuration.profilingSampleRate, 3),
+          trace_sample_rate: round(configuration.traceSampleRate, 3),
+          beta_encode_cookie_options: configuration.betaEncodeCookieOptions,
+        },
+        browser_sdk_version: canUseEventBridge() ? __BUILD_ENV__SDK_VERSION__ : undefined,
+        sdk_name: sdkName,
+      },
+      application: {
+        id: configuration.applicationId,
+      },
+      date: timeStampNow(),
+      source,
+    }
+  })
+
+  hooks.register(
+    HookNames.AssembleTelemetry,
+    (): DefaultTelemetryEventAttributes => ({
+      application: { id: configuration.applicationId },
+    })
+  )
+}

package/src/domain/contexts/displayContext.ts

@@ -0,0 +1,38 @@
+import { HookNames, monitor } from '@kubesense/kubesense-browser-core'
+import type { RumConfiguration } from '../configuration'
+import type { ViewportDimension } from '../../browser/viewportObservable'
+import { getViewportDimension, initViewportObservable } from '../../browser/viewportObservable'
+import type { DefaultRumEventAttributes, Hooks } from '../hooks'
+
+export type DisplayContext = ReturnType<typeof startDisplayContext>
+
+export function startDisplayContext(hooks: Hooks, configuration: RumConfiguration) {
+  let viewport: ViewportDimension | undefined
+  // Use requestAnimationFrame to delay the calculation of viewport dimensions until after SDK initialization, preventing long tasks.
+  const animationFrameId = requestAnimationFrame(
+    monitor(() => {
+      viewport = getViewportDimension()
+    })
+  )
+
+  const unsubscribeViewport = initViewportObservable(configuration).subscribe((viewportDimension) => {
+    viewport = viewportDimension
+  }).unsubscribe
+
+  hooks.register(
+    HookNames.Assemble,
+    ({ eventType }): DefaultRumEventAttributes => ({
+      type: eventType,
+      display: viewport ? { viewport } : undefined,
+    })
+  )
+
+  return {
+    stop: () => {
+      unsubscribeViewport()
+      if (animationFrameId) {
+        cancelAnimationFrame(animationFrameId)
+      }
+    },
+  }
+}

package/src/domain/contexts/featureFlagContext.ts

@@ -0,0 +1,71 @@
+import type { ContextValue, Context } from '@kubesense/kubesense-browser-core'
+import { HookNames, SESSION_TIME_OUT_DELAY, SKIPPED, createValueHistory, isEmptyObject } from '@kubesense/kubesense-browser-core'
+import type { LifeCycle } from '../lifeCycle'
+import { LifeCycleEventType } from '../lifeCycle'
+import { RumEventType } from '../../rawRumEvent.types'
+import type { RumConfiguration } from '../configuration'
+import type { DefaultRumEventAttributes, Hooks } from '../hooks'
+
+export const FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY
+export const BYTES_COMPUTATION_THROTTLING_DELAY = 200
+
+export type FeatureFlagContext = Context
+
+export interface FeatureFlagContexts {
+  addFeatureFlagEvaluation: (key: string, value: ContextValue) => void
+}
+
+/**
+ * Start feature flag contexts
+ *
+ * Feature flag contexts follow the life of views.
+ * A new context is added when a view is created and ended when the view is ended
+ *
+ * Note: we choose not to add a new context at each evaluation to save memory
+ */
+export function startFeatureFlagContexts(
+  lifeCycle: LifeCycle,
+  hooks: Hooks,
+  configuration: RumConfiguration
+): FeatureFlagContexts {
+  const featureFlagContexts = createValueHistory<FeatureFlagContext>({
+    expireDelay: FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY,
+  })
+
+  lifeCycle.subscribe(LifeCycleEventType.BEFORE_VIEW_CREATED, ({ startClocks }) => {
+    featureFlagContexts.add({}, startClocks.relative)
+  })
+
+  lifeCycle.subscribe(LifeCycleEventType.AFTER_VIEW_ENDED, ({ endClocks }) => {
+    featureFlagContexts.closeActive(endClocks.relative)
+  })
+
+  hooks.register(HookNames.Assemble, ({ startTime, eventType }): DefaultRumEventAttributes | SKIPPED => {
+    const trackFeatureFlagsForEvents = (configuration.trackFeatureFlagsForEvents as RumEventType[]).concat([
+      RumEventType.VIEW,
+      RumEventType.ERROR,
+    ])
+    if (!trackFeatureFlagsForEvents.includes(eventType as RumEventType)) {
+      return SKIPPED
+    }
+
+    const featureFlagContext = featureFlagContexts.find(startTime)
+    if (!featureFlagContext || isEmptyObject(featureFlagContext)) {
+      return SKIPPED
+    }
+
+    return {
+      type: eventType,
+      feature_flags: featureFlagContext,
+    }
+  })
+
+  return {
+    addFeatureFlagEvaluation: (key: string, value: ContextValue) => {
+      const currentContext = featureFlagContexts.find()
+      if (currentContext) {
+        currentContext[key] = value
+      }
+    },
+  }
+}

package/src/domain/contexts/internalContext.ts

@@ -0,0 +1,34 @@
+import type { RelativeTime, RumInternalContext } from '@kubesense/kubesense-browser-core'
+import type { ActionContexts } from '../action/actionCollection'
+import type { RumSessionManager } from '../rumSessionManager'
+import type { ViewHistory } from './viewHistory'
+import type { UrlContexts } from './urlContexts'
+
+/**
+ * Internal context keep returning v1 format
+ * to not break compatibility with logs data format
+ */
+export function startInternalContext(
+  applicationId: string,
+  sessionManager: RumSessionManager,
+  viewHistory: ViewHistory,
+  actionContexts: ActionContexts,
+  urlContexts: UrlContexts
+) {
+  return {
+    get: (startTime?: number): RumInternalContext | undefined => {
+      const viewContext = viewHistory.findView(startTime as RelativeTime)
+      const urlContext = urlContexts.findUrl(startTime as RelativeTime)
+      const session = sessionManager.findTrackedSession(startTime as RelativeTime)
+      if (session && viewContext && urlContext) {
+        const actionId = actionContexts.findActionId(startTime as RelativeTime)
+        return {
+          application_id: applicationId,
+          session_id: session.id,
+          user_action: actionId ? { id: actionId } : undefined,
+          view: { id: viewContext.id, name: viewContext.name, referrer: urlContext.referrer, url: urlContext.url },
+        }
+      }
+    },
+  }
+}

package/src/domain/contexts/pageStateHistory.ts

@@ -0,0 +1,171 @@
+import type { Duration, RelativeTime } from '@kubesense/kubesense-browser-core'
+import {
+  SKIPPED,
+  elapsed,
+  createValueHistory,
+  SESSION_TIME_OUT_DELAY,
+  toServerDuration,
+  addEventListeners,
+  relativeNow,
+  DOM_EVENT,
+  HookNames,
+} from '@kubesense/kubesense-browser-core'
+import type { RumConfiguration } from '../configuration'
+import { supportPerformanceTimingEvent, RumPerformanceEntryType } from '../../browser/performanceObservable'
+import type { PageStateServerEntry } from '../../rawRumEvent.types'
+import { RumEventType } from '../../rawRumEvent.types'
+import type { DefaultRumEventAttributes, Hooks } from '../hooks'
+
+// Arbitrary value to cap number of element for memory consumption in the browser
+export const MAX_PAGE_STATE_ENTRIES = 4000
+// Arbitrary value to cap number of element for backend & to save bandwidth
+export const MAX_PAGE_STATE_ENTRIES_SELECTABLE = 500
+
+export const PAGE_STATE_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY
+
+export const enum PageState {
+  ACTIVE = 'active',
+  PASSIVE = 'passive',
+  HIDDEN = 'hidden',
+  FROZEN = 'frozen',
+  TERMINATED = 'terminated',
+}
+
+export interface PageStateEntry {
+  state: PageState
+  startTime: RelativeTime
+}
+
+export interface PageStateHistory {
+  wasInPageStateDuringPeriod: (state: PageState, startTime: RelativeTime, duration: Duration) => boolean
+  addPageState(nextPageState: PageState, startTime?: RelativeTime): void
+  stop: () => void
+}
+
+export function startPageStateHistory(
+  hooks: Hooks,
+  configuration: RumConfiguration,
+  maxPageStateEntriesSelectable = MAX_PAGE_STATE_ENTRIES_SELECTABLE
+): PageStateHistory {
+  const pageStateEntryHistory = createValueHistory<PageStateEntry>({
+    expireDelay: PAGE_STATE_CONTEXT_TIME_OUT_DELAY,
+    maxEntries: MAX_PAGE_STATE_ENTRIES,
+  })
+
+  let currentPageState: PageState
+
+  if (supportPerformanceTimingEvent(RumPerformanceEntryType.VISIBILITY_STATE)) {
+    const visibilityEntries = performance.getEntriesByType(
+      RumPerformanceEntryType.VISIBILITY_STATE
+    ) as PerformanceEntry[]
+
+    visibilityEntries.forEach((entry) => {
+      const state = entry.name === 'hidden' ? PageState.HIDDEN : PageState.ACTIVE
+      addPageState(state, entry.startTime as RelativeTime)
+    })
+  }
+
+  addPageState(getPageState(), relativeNow())
+
+  const { stop: stopEventListeners } = addEventListeners(
+    configuration,
+    window,
+    [
+      DOM_EVENT.PAGE_SHOW,
+      DOM_EVENT.FOCUS,
+      DOM_EVENT.BLUR,
+      DOM_EVENT.VISIBILITY_CHANGE,
+      DOM_EVENT.RESUME,
+      DOM_EVENT.FREEZE,
+      DOM_EVENT.PAGE_HIDE,
+    ],
+    (event) => {
+      addPageState(computePageState(event), event.timeStamp as RelativeTime)
+    },
+    { capture: true }
+  )
+
+  function addPageState(nextPageState: PageState, startTime = relativeNow()) {
+    if (nextPageState === currentPageState) {
+      return
+    }
+
+    currentPageState = nextPageState
+    pageStateEntryHistory.closeActive(startTime)
+    pageStateEntryHistory.add({ state: currentPageState, startTime }, startTime)
+  }
+
+  function wasInPageStateDuringPeriod(state: PageState, startTime: RelativeTime, duration: Duration) {
+    return pageStateEntryHistory.findAll(startTime, duration).some((pageState) => pageState.state === state)
+  }
+
+  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,
+          _kubesense: { page_states: processPageStates(pageStates, startTime, maxPageStateEntriesSelectable) },
+        }
+      }
+
+      if (eventType === RumEventType.ACTION || eventType === RumEventType.ERROR) {
+        return {
+          type: eventType,
+          view: { in_foreground: wasInPageStateDuringPeriod(PageState.ACTIVE, startTime, 0 as Duration) },
+        }
+      }
+
+      return SKIPPED
+    }
+  )
+
+  return {
+    wasInPageStateDuringPeriod,
+    addPageState,
+    stop: () => {
+      stopEventListeners()
+      pageStateEntryHistory.stop()
+    },
+  }
+}
+
+function processPageStates(
+  pageStateEntries: PageStateEntry[],
+  eventStartTime: RelativeTime,
+  maxPageStateEntriesSelectable: number
+): PageStateServerEntry[] | undefined {
+  if (pageStateEntries.length === 0) {
+    return
+  }
+
+  return pageStateEntries
+    .slice(-maxPageStateEntriesSelectable)
+    .reverse()
+    .map(({ state, startTime }) => ({
+      state,
+      start: toServerDuration(elapsed(eventStartTime, startTime)),
+    }))
+}
+
+function computePageState(event: Event & { type: DOM_EVENT }) {
+  if (event.type === DOM_EVENT.FREEZE) {
+    return PageState.FROZEN
+  } else if (event.type === DOM_EVENT.PAGE_HIDE) {
+    return (event as PageTransitionEvent).persisted ? PageState.FROZEN : PageState.TERMINATED
+  }
+  return getPageState()
+}
+
+function getPageState() {
+  if (document.visibilityState === 'hidden') {
+    return PageState.HIDDEN
+  }
+
+  if (document.hasFocus()) {
+    return PageState.ACTIVE
+  }
+
+  return PageState.PASSIVE
+}

package/src/domain/contexts/sessionContext.ts

@@ -0,0 +1,59 @@
+import { DISCARDED, HookNames, SKIPPED } from '@kubesense/kubesense-browser-core'
+import { SessionReplayState, SessionType } from '../rumSessionManager'
+import type { RumSessionManager } 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'
+
+export function startSessionContext(
+  hooks: Hooks,
+  sessionManager: RumSessionManager,
+  recorderApi: RecorderApi,
+  viewHistory: ViewHistory
+) {
+  hooks.register(HookNames.Assemble, ({ eventType, startTime }): DefaultRumEventAttributes | DISCARDED => {
+    const session = sessionManager.findTrackedSession(startTime)
+    const view = viewHistory.findView(startTime)
+
+    if (!session || !view) {
+      return DISCARDED
+    }
+
+    let hasReplay
+    let sampledForReplay
+    let isActive
+    if (eventType === RumEventType.VIEW) {
+      hasReplay = recorderApi.getReplayStats(view.id) ? true : undefined
+      sampledForReplay = session.sessionReplay === SessionReplayState.SAMPLED
+      isActive = view.sessionIsActive ? undefined : false
+    } else {
+      hasReplay = recorderApi.isRecording() ? true : undefined
+    }
+
+    return {
+      type: eventType,
+      session: {
+        id: session.id,
+        type: SessionType.USER,
+        has_replay: hasReplay,
+        sampled_for_replay: sampledForReplay,
+        is_active: isActive,
+      },
+    }
+  })
+
+  hooks.register(HookNames.AssembleTelemetry, ({ startTime }): DefaultTelemetryEventAttributes | SKIPPED => {
+    const session = sessionManager.findTrackedSession(startTime)
+
+    if (!session) {
+      return SKIPPED
+    }
+
+    return {
+      session: {
+        id: session.id,
+      },
+    }
+  })
+}

package/src/domain/contexts/syntheticsContext.ts

@@ -0,0 +1,33 @@
+import {
+  SKIPPED,
+  getSyntheticsResultId,
+  getSyntheticsTestId,
+  HookNames,
+  willSyntheticsInjectRum,
+  isSyntheticsTest,
+} from '@kubesense/kubesense-browser-core'
+import { SessionType } from '../rumSessionManager'
+import type { DefaultRumEventAttributes, Hooks } from '../hooks'
+
+export function startSyntheticsContext(hooks: Hooks) {
+  hooks.register(HookNames.Assemble, ({ eventType }): DefaultRumEventAttributes | SKIPPED => {
+    if (!isSyntheticsTest()) {
+      return SKIPPED
+    }
+
+    const testId = getSyntheticsTestId()
+    const resultId = getSyntheticsResultId()
+
+    return {
+      type: eventType,
+      session: {
+        type: SessionType.SYNTHETICS,
+      },
+      synthetics: {
+        test_id: testId!,
+        result_id: resultId!,
+        injected: willSyntheticsInjectRum(),
+      },
+    }
+  })
+}

package/src/domain/contexts/trackingConsentContext.ts

@@ -0,0 +1,15 @@
+import { DISCARDED, HookNames, SKIPPED } from '@kubesense/kubesense-browser-core'
+import type { TrackingConsentState } from '@kubesense/kubesense-browser-core'
+import type { Hooks } from '../hooks'
+
+export function startTrackingConsentContext(hooks: Hooks, trackingConsentState: TrackingConsentState) {
+  hooks.register(HookNames.AssembleTelemetry, () => {
+    const wasConsented = trackingConsentState.isGranted()
+
+    if (!wasConsented) {
+      return DISCARDED
+    }
+
+    return SKIPPED
+  })
+}

package/src/domain/contexts/urlContexts.ts

@@ -0,0 +1,97 @@
+import type { RelativeTime, Observable } from '@kubesense/kubesense-browser-core'
+import { SESSION_TIME_OUT_DELAY, relativeNow, createValueHistory, HookNames, DISCARDED } from '@kubesense/kubesense-browser-core'
+import type { LocationChange } from '../../browser/locationChangeObservable'
+import type { LifeCycle } from '../lifeCycle'
+import { LifeCycleEventType } from '../lifeCycle'
+import type { DefaultRumEventAttributes, Hooks } from '../hooks'
+
+/**
+ * We want to attach to an event:
+ * - the url corresponding to its start
+ * - the referrer corresponding to the previous view url (or document referrer for initial view)
+ */
+
+export const URL_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY
+
+export interface UrlContext {
+  url: string
+  referrer: string
+}
+
+export interface UrlContexts {
+  findUrl: (startTime?: RelativeTime) => UrlContext | undefined
+  stop: () => void
+}
+
+export function startUrlContexts(
+  lifeCycle: LifeCycle,
+  hooks: Hooks,
+  locationChangeObservable: Observable<LocationChange>,
+  location: Location
+) {
+  const urlContextHistory = createValueHistory<UrlContext>({ expireDelay: URL_CONTEXT_TIME_OUT_DELAY })
+
+  let previousViewUrl: string | undefined
+
+  lifeCycle.subscribe(LifeCycleEventType.BEFORE_VIEW_CREATED, ({ startClocks }) => {
+    const viewUrl = location.href
+    urlContextHistory.add(
+      buildUrlContext({
+        url: viewUrl,
+        referrer: !previousViewUrl ? document.referrer : previousViewUrl,
+      }),
+      startClocks.relative
+    )
+    previousViewUrl = viewUrl
+  })
+
+  lifeCycle.subscribe(LifeCycleEventType.AFTER_VIEW_ENDED, ({ endClocks }) => {
+    urlContextHistory.closeActive(endClocks.relative)
+  })
+
+  const locationChangeSubscription = locationChangeObservable.subscribe(({ newLocation }) => {
+    const current = urlContextHistory.find()
+    if (current) {
+      const changeTime = relativeNow()
+      urlContextHistory.closeActive(changeTime)
+      urlContextHistory.add(
+        buildUrlContext({
+          url: newLocation.href,
+          referrer: current.referrer,
+        }),
+        changeTime
+      )
+    }
+  })
+
+  function buildUrlContext({ url, referrer }: { url: string; referrer: string }) {
+    return {
+      url,
+      referrer,
+    }
+  }
+
+  hooks.register(HookNames.Assemble, ({ startTime, eventType }): DefaultRumEventAttributes | DISCARDED => {
+    const urlContext = urlContextHistory.find(startTime)
+
+    if (!urlContext) {
+      return DISCARDED
+    }
+
+    return {
+      type: eventType,
+      view: {
+        url: urlContext.url,
+        referrer: urlContext.referrer,
+      },
+    }
+  })
+
+  return {
+    findUrl: (startTime?: RelativeTime) => urlContextHistory.find(startTime),
+    stop: () => {
+      locationChangeSubscription.unsubscribe()
+      urlContextHistory.stop()
+    },
+  }
+}

package/src/domain/contexts/userAgentDataContext.ts

@@ -0,0 +1,36 @@
+import type { UserAgentContext } from '@kubesense/kubesense-browser-core'
+import {
+  getSyncUserAgentContext,
+  HookNames,
+  resolveHighEntropyUserAgentContext,
+} from '@kubesense/kubesense-browser-core'
+import type { DefaultRumEventAttributes, Hooks } from '../hooks'
+
+// On Chromium, the classic User-Agent is frozen (browser major capped, macOS
+// pinned to 10.15.7, Windows pinned to 10.0). UA Client Hints let us recover
+// the real values client-side and ship them in the payload, bypassing the
+// cross-origin Accept-CH negotiation that doesn't fire for fetch/sendBeacon.
+//
+// Non-Chromium browsers (Safari, Firefox) don't expose userAgentData; we send
+// nothing and the server's UA parser handles them — their UA isn't frozen.
+export function startUserAgentDataContext(hooks: Hooks) {
+  let context: UserAgentContext | undefined = getSyncUserAgentContext()
+
+  resolveHighEntropyUserAgentContext().then((highEntropy) => {
+    if (highEntropy) {
+      context = highEntropy
+    }
+  })
+
+  hooks.register(HookNames.Assemble, ({ eventType }): DefaultRumEventAttributes => {
+    if (!context) {
+      return { type: eventType }
+    }
+    return {
+      type: eventType,
+      ...(context.browser && { browser: context.browser }),
+      ...(context.os && { os: context.os }),
+      ...(context.device && { device: context.device }),
+    } as DefaultRumEventAttributes
+  })
+}