@kubesense/kubesense-browser-rum-core 1.8.0 → 2.0.0-beta.1

package/src/boot/startRum.ts

@@ -1,35 +1,39 @@
 import type {
   Observable,
-  RawError,
   DeflateEncoderStreamId,
   Encoder,
-  TrackingConsentState,
   BufferedData,
   BufferedObservable,
+  Telemetry,
+  SessionManager,
 } from '@kubesense/kubesense-browser-core'
 import {
   sendToExtension,
   createPageMayExitObservable,
-  TelemetryService,
-  startTelemetry,
   canUseEventBridge,
   addTelemetryDebug,
   startAccountContext,
   startGlobalContext,
   startUserContext,
+  startTabContext,
+  ErrorSource,
+  DEFAULT_ERROR_TYPE,
+  isExperimentalFeatureEnabled,
+  ExperimentalFeature,
+  getSessionEndClocks,
 } from '@kubesense/kubesense-browser-core'
+import { clocksNow } from '@kubesense/kubesense-js-core/time'
 import { createDOMMutationObservable } from '../browser/domMutationObservable'
 import { createWindowOpenObservable } from '../browser/windowOpenObservable'
 import { startInternalContext } from '../domain/contexts/internalContext'
 import { LifeCycle, LifeCycleEventType } from '../domain/lifeCycle'
 import { startViewHistory } from '../domain/contexts/viewHistory'
 import { startRequestCollection } from '../domain/requestCollection'
+import { startWebSocketCollection } from '../domain/resource/webSocketCollection'
 import { startActionCollection } from '../domain/action/actionCollection'
 import { startErrorCollection } from '../domain/error/errorCollection'
 import { startResourceCollection } from '../domain/resource/resourceCollection'
 import { startViewCollection } from '../domain/view/viewCollection'
-import type { RumSessionManager } from '../domain/rumSessionManager'
-import { startRumSessionManager, startRumSessionManagerStub } from '../domain/rumSessionManager'
 import { startRumBatch } from '../transport/startRumBatch'
 import { startRumEventBridge } from '../transport/startRumEventBridge'
 import { startUrlContexts } from '../domain/contexts/urlContexts'
@@ -40,7 +44,6 @@ import { startFeatureFlagContexts } from '../domain/contexts/featureFlagContext'
 import { startCustomerDataTelemetry } from '../domain/startCustomerDataTelemetry'
 import { startPageStateHistory } from '../domain/contexts/pageStateHistory'
 import { startDisplayContext } from '../domain/contexts/displayContext'
-import type { CustomVitalsState } from '../domain/vital/vitalCollection'
 import { startVitalCollection } from '../domain/vital/vitalCollection'
 import { startCiVisibilityContext } from '../domain/contexts/ciVisibilityContext'
 import { startLongTaskCollection } from '../domain/longTask/longTaskCollection'
@@ -51,11 +54,9 @@ import { startConnectivityContext } from '../domain/contexts/connectivityContext
 import { startUserAgentDataContext } from '../domain/contexts/userAgentDataContext'
 import type { SdkName } from '../domain/contexts/defaultContext'
 import { startDefaultContext } from '../domain/contexts/defaultContext'
-import { startTrackingConsentContext } from '../domain/contexts/trackingConsentContext'
 import type { Hooks } from '../domain/hooks'
-import { createHooks } from '../domain/hooks'
 import { startEventCollection } from '../domain/event/eventCollection'
-import { startInitialViewMetricsTelemetry } from '../domain/view/viewMetrics/startInitialViewMetricsTelemetry'
+import { startSourceCodeMfeContext } from '../domain/contexts/sourceCodeMfeContext'
 import type { RecorderApi, ProfilerApi } from './rumPublicApi'
 
 export type StartRum = typeof startRum
@@ -63,79 +64,64 @@ export type StartRumResult = ReturnType<StartRum>
 
 export function startRum(
   configuration: RumConfiguration,
+  sessionManager: SessionManager,
   recorderApi: RecorderApi,
   profilerApi: ProfilerApi,
   initialViewOptions: ViewOptions | undefined,
   createEncoder: (streamId: DeflateEncoderStreamId) => Encoder,
-
-  // `startRum` and its subcomponents assume tracking consent is granted initially and starts
-  // collecting logs unconditionally. As such, `startRum` should be called with a
-  // `trackingConsentState` set to "granted".
-  trackingConsentState: TrackingConsentState,
-  customVitalsState: CustomVitalsState,
   bufferedDataObservable: BufferedObservable<BufferedData>,
+  telemetry: Telemetry,
+  hooks: Hooks,
   sdkName?: SdkName
 ) {
   const cleanupTasks: Array<() => void> = []
   const lifeCycle = new LifeCycle()
-  const hooks = createHooks()
 
   lifeCycle.subscribe(LifeCycleEventType.RUM_EVENT_COLLECTED, (event) => sendToExtension('rum', event))
 
-  const reportError = (error: RawError) => {
-    lifeCycle.notify(LifeCycleEventType.RAW_ERROR_COLLECTED, { error })
-    // monitor-until: forever, to keep an eye on the errors reported to customers
-    addTelemetryDebug('Error reported to customer', { 'error.message': error.message })
-  }
-
-  const pageMayExitObservable = createPageMayExitObservable(configuration)
-  const pageMayExitSubscription = pageMayExitObservable.subscribe((event) => {
-    lifeCycle.notify(LifeCycleEventType.PAGE_MAY_EXIT, event)
-  })
-  cleanupTasks.push(() => pageMayExitSubscription.unsubscribe())
-
-  const telemetry = startTelemetry(
-    TelemetryService.RUM,
-    configuration,
-    hooks,
-    reportError,
-    pageMayExitObservable,
-    createEncoder
+  // Dated to when the session ended rather than when this tab noticed: a hidden tab can learn of
+  // a timeout long after it happened, and ending its views then would stretch the session past
+  // SESSION_TIME_OUT_DELAY. The expiring session is still the active one while the observable
+  // notifies (the history is closed after).
+  sessionManager.expireObservable.subscribe(() =>
+    lifeCycle.notify(LifeCycleEventType.SESSION_EXPIRED, {
+      endClocks: getSessionEndClocks(sessionManager.findSession()),
+    })
   )
-  cleanupTasks.push(telemetry.stop)
+  sessionManager.renewObservable.subscribe(() => lifeCycle.notify(LifeCycleEventType.SESSION_RENEWED))
 
-  const session = !canUseEventBridge()
-    ? startRumSessionManager(configuration, lifeCycle, trackingConsentState)
-    : startRumSessionManagerStub()
+  const reportError = (message: string) => {
+    lifeCycle.notify(LifeCycleEventType.RAW_ERROR_COLLECTED, {
+      error: { message, type: DEFAULT_ERROR_TYPE, source: ErrorSource.AGENT, startClocks: clocksNow() },
+    })
+    // monitor-until: forever, to keep an eye on the errors reported to customers
+    addTelemetryDebug('Error reported to customer', { 'error.message': message })
+  }
 
   if (!canUseEventBridge()) {
-    const batch = startRumBatch(
-      configuration,
-      lifeCycle,
-      reportError,
-      pageMayExitObservable,
-      session.expireObservable,
-      createEncoder
-    )
+    const batch = startRumBatch(configuration, lifeCycle, reportError, sessionManager.expireObservable, createEncoder)
+    const preparePageExitSubscription = batch.prepareUrgentFlushObservable.subscribe((reason) => {
+      lifeCycle.notify(LifeCycleEventType.PREPARE_URGENT_FLUSH, reason)
+    })
+    cleanupTasks.push(() => preparePageExitSubscription.unsubscribe())
     cleanupTasks.push(() => batch.stop())
-    startCustomerDataTelemetry(telemetry, lifeCycle, batch.flushController.flushObservable)
+    startCustomerDataTelemetry(telemetry, lifeCycle, batch.flushObservable)
   } else {
     startRumEventBridge(lifeCycle)
+    const pageMayExitObservable = createPageMayExitObservable()
+    const pageMayExitSubscription = pageMayExitObservable.subscribe((event) => {
+      lifeCycle.notify(LifeCycleEventType.PREPARE_URGENT_FLUSH, event.reason)
+    })
+    cleanupTasks.push(() => pageMayExitSubscription.unsubscribe())
   }
 
-  startTrackingConsentContext(hooks, trackingConsentState)
-
-  const { stop: stopInitialViewMetricsTelemetry } = startInitialViewMetricsTelemetry(lifeCycle, telemetry)
-  cleanupTasks.push(stopInitialViewMetricsTelemetry)
-
   const { stop: stopRumEventCollection, ...startRumEventCollectionResult } = startRumEventCollection(
     lifeCycle,
     hooks,
     configuration,
-    session,
+    sessionManager,
     recorderApi,
     initialViewOptions,
-    customVitalsState,
     bufferedDataObservable,
     sdkName,
     reportError
@@ -149,8 +135,8 @@ export function startRum(
   return {
     ...startRumEventCollectionResult,
     lifeCycle,
-    session,
-    stopSession: () => session.expire(),
+    sessionManager,
+    stopSession: () => sessionManager.expire(),
     telemetry,
     stop: () => {
       cleanupTasks.forEach((task) => task())
@@ -163,35 +149,36 @@ export function startRumEventCollection(
   lifeCycle: LifeCycle,
   hooks: Hooks,
   configuration: RumConfiguration,
-  session: RumSessionManager,
+  sessionManager: SessionManager,
   recorderApi: RecorderApi,
   initialViewOptions: ViewOptions | undefined,
-  customVitalsState: CustomVitalsState,
   bufferedDataObservable: Observable<BufferedData>,
   sdkName: SdkName | undefined,
-  reportError: (error: RawError) => void
+  reportError: (message: string) => void
 ) {
   const cleanupTasks: Array<() => void> = []
 
   const domMutationObservable = createDOMMutationObservable()
-  const locationChangeObservable = createLocationChangeObservable(configuration, location)
+  const locationChangeObservable = createLocationChangeObservable()
   const { observable: windowOpenObservable, stop: stopWindowOpen } = createWindowOpenObservable()
   cleanupTasks.push(stopWindowOpen)
 
-  startDefaultContext(hooks, configuration, sdkName)
-  const pageStateHistory = startPageStateHistory(hooks, configuration)
+  const { assembleEventDefaults: assembleHook } = hooks
+  startDefaultContext(assembleHook, configuration, sdkName)
+  const pageStateHistory = startPageStateHistory(assembleHook)
   cleanupTasks.push(() => pageStateHistory.stop())
   const viewHistory = startViewHistory(lifeCycle)
   cleanupTasks.push(() => viewHistory.stop())
-  const urlContexts = startUrlContexts(lifeCycle, hooks, locationChangeObservable, location)
+  const urlContexts = startUrlContexts(lifeCycle, assembleHook, locationChangeObservable)
   cleanupTasks.push(() => urlContexts.stop())
-  const featureFlagContexts = startFeatureFlagContexts(lifeCycle, hooks, configuration)
-  startSessionContext(hooks, session, recorderApi, viewHistory)
-  startConnectivityContext(hooks)
-  startUserAgentDataContext(hooks)
-  const globalContext = startGlobalContext(hooks, configuration, 'rum', true)
-  const userContext = startUserContext(hooks, configuration, session, 'rum')
-  const accountContext = startAccountContext(hooks, configuration, 'rum')
+  const featureFlagContexts = startFeatureFlagContexts(lifeCycle, assembleHook, configuration)
+  startSessionContext(assembleHook, configuration, sessionManager, recorderApi, viewHistory)
+  startConnectivityContext(assembleHook)
+  startUserAgentDataContext(assembleHook)
+  startTabContext(assembleHook)
+  const globalContext = startGlobalContext(assembleHook, configuration, 'rum', true)
+  const userContext = startUserContext(assembleHook, configuration, sessionManager, 'rum')
+  const accountContext = startAccountContext(assembleHook, configuration, 'rum')
 
   const actionCollection = startActionCollection(
     lifeCycle,
@@ -204,16 +191,17 @@ export function startRumEventCollection(
 
   const eventCollection = startEventCollection(lifeCycle)
 
-  const displayContext = startDisplayContext(hooks, configuration)
+  const displayContext = startDisplayContext(assembleHook)
   cleanupTasks.push(displayContext.stop)
-  const ciVisibilityContext = startCiVisibilityContext(configuration, hooks)
+  const ciVisibilityContext = startCiVisibilityContext(assembleHook)
   cleanupTasks.push(ciVisibilityContext.stop)
-  startSyntheticsContext(hooks)
+  startSyntheticsContext(assembleHook)
 
   startRumAssembly(configuration, lifeCycle, hooks, reportError)
 
   const {
     addTiming,
+    setLoadingTime,
     startView,
     setViewName,
     setViewContext,
@@ -224,7 +212,6 @@ export function startRumEventCollection(
     lifeCycle,
     hooks,
     configuration,
-    location,
     domMutationObservable,
     windowOpenObservable,
     locationChangeObservable,
@@ -232,23 +219,34 @@ export function startRumEventCollection(
     viewHistory,
     initialViewOptions
   )
+
+  startSourceCodeMfeContext(assembleHook)
+
   cleanupTasks.push(stopViewCollection)
 
-  const { stop: stopResourceCollection } = startResourceCollection(lifeCycle, configuration, pageStateHistory)
-  cleanupTasks.push(stopResourceCollection)
+  const resourceCollection = startResourceCollection(lifeCycle, configuration)
+  cleanupTasks.push(resourceCollection.stop)
 
-  const { stop: stopLongTaskCollection, longTaskContexts } = startLongTaskCollection(lifeCycle, configuration)
+  const { stop: stopLongTaskCollection } = startLongTaskCollection(lifeCycle, configuration)
   cleanupTasks.push(stopLongTaskCollection)
 
-  const { addError } = startErrorCollection(lifeCycle, configuration, bufferedDataObservable)
+  const { addError } = startErrorCollection(lifeCycle, bufferedDataObservable)
 
-  startRequestCollection(lifeCycle, configuration, session, userContext, accountContext)
+  startRequestCollection(lifeCycle, configuration, sessionManager, userContext, accountContext, bufferedDataObservable)
 
-  const vitalCollection = startVitalCollection(lifeCycle, pageStateHistory, customVitalsState)
+  const vitalCollection = startVitalCollection(lifeCycle, pageStateHistory)
+
+  if (
+    configuration.trackResources &&
+    (configuration.betaTrackWebSockets || isExperimentalFeatureEnabled(ExperimentalFeature.TRACK_WEBSOCKETS))
+  ) {
+    const webSocketCollection = startWebSocketCollection(lifeCycle, viewHistory, vitalCollection.addDurationVital)
+    cleanupTasks.push(webSocketCollection.stop)
+  }
 
   const internalContext = startInternalContext(
     configuration.applicationId,
-    session,
+    sessionManager,
     viewHistory,
     actionCollection.actionContexts,
     urlContexts
@@ -256,9 +254,14 @@ export function startRumEventCollection(
 
   return {
     addAction: actionCollection.addAction,
+    startAction: actionCollection.startAction,
+    stopAction: actionCollection.stopAction,
+    startResource: resourceCollection.startResource,
+    stopResource: resourceCollection.stopResource,
     addEvent: eventCollection.addEvent,
     addError,
     addTiming,
+    setLoadingTime,
     addFeatureFlagEvaluation: featureFlagContexts.addFeatureFlagEvaluation,
     startView,
     setViewContext,
@@ -266,6 +269,8 @@ export function startRumEventCollection(
     getViewContext,
     setViewName,
     viewHistory,
+    sessionManager,
+    stopSession: () => sessionManager.expire(),
     getInternalContext: internalContext.get,
     startDurationVital: vitalCollection.startDurationVital,
     stopDurationVital: vitalCollection.stopDurationVital,
@@ -274,7 +279,6 @@ export function startRumEventCollection(
     globalContext,
     userContext,
     accountContext,
-    longTaskContexts,
     stop: () => cleanupTasks.forEach((task) => task()),
   }
 }

package/src/browser/cookieObservable.ts

@@ -1,47 +1,37 @@
-import type { Configuration, CookieStore } from '@kubesense/kubesense-browser-core'
+import { globalObject } from '@kubesense/kubesense-js-core/util'
+import { ONE_SECOND } from '@kubesense/kubesense-js-core/time'
 import {
   setInterval,
   clearInterval,
   Observable,
   addEventListener,
-  ONE_SECOND,
-  findCommaSeparatedValue,
   DOM_EVENT,
+  getCookie,
+  isCookieStoreSupported,
 } from '@kubesense/kubesense-browser-core'
 
-export interface CookieStoreWindow {
-  cookieStore?: CookieStore
-}
-
 export type CookieObservable = ReturnType<typeof createCookieObservable>
 
-export function createCookieObservable(configuration: Configuration, cookieName: string) {
-  const detectCookieChangeStrategy = (window as CookieStoreWindow).cookieStore
-    ? listenToCookieStoreChange(configuration)
-    : watchCookieFallback
+export function createCookieObservable(cookieName: string) {
+  const detectCookieChangeStrategy = isCookieStoreSupported() ? listenToCookieStoreChange() : watchCookieFallback
 
   return new Observable<string | undefined>((observable) =>
     detectCookieChangeStrategy(cookieName, (event) => observable.notify(event))
   )
 }
 
-function listenToCookieStoreChange(configuration: Configuration) {
+function listenToCookieStoreChange() {
   return (cookieName: string, callback: (event: string | undefined) => void) => {
-    const listener = addEventListener(
-      configuration,
-      (window as CookieStoreWindow).cookieStore!,
-      DOM_EVENT.CHANGE,
-      (event) => {
-        // Based on our experimentation, we're assuming that entries for the same cookie cannot be in both the 'changed' and 'deleted' arrays.
-        // However, due to ambiguity in the specification, we asked for clarification: https://github.com/WICG/cookie-store/issues/226
-        const changeEvent =
-          event.changed.find((event) => event.name === cookieName) ||
-          event.deleted.find((event) => event.name === cookieName)
-        if (changeEvent) {
-          callback(changeEvent.value)
-        }
+    const listener = addEventListener(globalObject.cookieStore!, DOM_EVENT.CHANGE, (event) => {
+      // Based on our experimentation, we're assuming that entries for the same cookie cannot be in both the 'changed' and 'deleted' arrays.
+      // However, due to ambiguity in the specification, we asked for clarification: https://github.com/WICG/cookie-store/issues/226
+      const changeEvent =
+        event.changed.find((event) => event.name === cookieName) ||
+        event.deleted.find((event) => event.name === cookieName)
+      if (changeEvent) {
+        callback(changeEvent.value)
       }
-    )
+    })
     return listener.stop
   }
 }
@@ -49,10 +39,11 @@ function listenToCookieStoreChange(configuration: Configuration) {
 export const WATCH_COOKIE_INTERVAL_DELAY = ONE_SECOND
 
 function watchCookieFallback(cookieName: string, callback: (event: string | undefined) => void) {
-  const previousCookieValue = findCommaSeparatedValue(document.cookie, cookieName)
+  let previousCookieValue = getCookie(cookieName)
   const watchCookieIntervalId = setInterval(() => {
-    const cookieValue = findCommaSeparatedValue(document.cookie, cookieName)
+    const cookieValue = getCookie(cookieName)
     if (cookieValue !== previousCookieValue) {
+      previousCookieValue = cookieValue
       callback(cookieValue)
     }
   }, WATCH_COOKIE_INTERVAL_DELAY)

package/src/browser/domMutationObservable.ts

@@ -1,4 +1,5 @@
-import { monitor, noop, Observable, getZoneJsOriginalValue } from '@kubesense/kubesense-browser-core'
+import { monitor } from '@kubesense/kubesense-js-core/monitor'
+import { noop, Observable, getZoneJsOriginalValue } from '@kubesense/kubesense-browser-core'
 
 // https://dom.spec.whatwg.org/#interface-mutationrecord
 export interface RumCharacterDataMutationRecord {
@@ -11,7 +12,7 @@ export interface RumAttributesMutationRecord {
   type: 'attributes'
   target: Element
   oldValue: string | null
-  attributeName: string | null
+  attributeName: string
 }
 
 export interface RumChildListMutationRecord {
@@ -22,18 +23,12 @@ export interface RumChildListMutationRecord {
 }
 
 export type RumMutationRecord =
-  | RumCharacterDataMutationRecord
-  | RumAttributesMutationRecord
-  | RumChildListMutationRecord
+  RumCharacterDataMutationRecord | RumAttributesMutationRecord | RumChildListMutationRecord
 
 export function createDOMMutationObservable() {
   const MutationObserver = getMutationObserverConstructor()
 
   return new Observable<RumMutationRecord[]>((observable) => {
-    if (!MutationObserver) {
-      return
-    }
-
     const observer = new MutationObserver(monitor((records) => observable.notify(records)))
     observer.observe(document, {
       attributes: true,
@@ -48,11 +43,11 @@ export function createDOMMutationObservable() {
 type MutationObserverConstructor = new (callback: (records: RumMutationRecord[]) => void) => MutationObserver
 
 export interface BrowserWindow extends Window {
-  MutationObserver?: MutationObserverConstructor
+  MutationObserver: MutationObserverConstructor
   Zone?: unknown
 }
 
-export function getMutationObserverConstructor(): MutationObserverConstructor | undefined {
+export function getMutationObserverConstructor(): MutationObserverConstructor {
   let constructor: MutationObserverConstructor | undefined
   const browserWindow = window as BrowserWindow
 
@@ -86,7 +81,7 @@ export function getMutationObserverConstructor(): MutationObserverConstructor |
       }
 
       const originalInstance = getZoneJsOriginalValue(patchedInstance, 'originalInstance')
-      constructor = originalInstance && originalInstance.constructor
+      constructor = originalInstance?.constructor
     }
   }
 

package/src/browser/htmlDomUtils.ts

@@ -43,3 +43,18 @@ export function forEachChildNodes(node: Node, callback: (child: Node) => void) {
 export function getParentNode(node: Node): Node | null {
   return isNodeShadowRoot(node) ? node.host : node.parentNode
 }
+
+/**
+ * Return the parent element, crossing shadow DOM boundaries.
+ * If the element is a direct child of a shadow root, returns the shadow host.
+ */
+export function getParentElement(element: Element): Element | null {
+  if (element.parentElement) {
+    return element.parentElement
+  }
+  const parentNode = element.parentNode
+  if (parentNode && isNodeShadowRoot(parentNode)) {
+    return parentNode.host
+  }
+  return null
+}

package/src/browser/locationChangeObservable.ts

@@ -1,23 +1,30 @@
-import { addEventListener, DOM_EVENT, instrumentMethod, Observable, shallowClone } from '@kubesense/kubesense-browser-core'
-import type { RumConfiguration } from '../domain/configuration'
+import { globalObject } from '@kubesense/kubesense-js-core/util'
+import {
+  addEventListener,
+  DOM_EVENT,
+  instrumentMethod,
+  mockable,
+  Observable,
+  shallowClone,
+} from '@kubesense/kubesense-browser-core'
 
 export interface LocationChange {
   oldLocation: Readonly<Location>
   newLocation: Readonly<Location>
 }
 
-export function createLocationChangeObservable(configuration: RumConfiguration, location: Location) {
-  let currentLocation = shallowClone(location)
+export function createLocationChangeObservable() {
+  let currentLocation = shallowClone(getLocation())
 
   return new Observable<LocationChange>((observable) => {
-    const { stop: stopHistoryTracking } = trackHistory(configuration, onLocationChange)
-    const { stop: stopHashTracking } = trackHash(configuration, onLocationChange)
+    const { stop: stopHistoryTracking } = trackHistory(onLocationChange)
+    const { stop: stopHashTracking } = trackHash(onLocationChange)
 
     function onLocationChange() {
-      if (currentLocation.href === location.href) {
+      if (currentLocation.href === getLocation().href) {
         return
       }
-      const newLocation = shallowClone(location)
+      const newLocation = shallowClone(getLocation())
       observable.notify({
         newLocation,
         oldLocation: currentLocation,
@@ -32,7 +39,11 @@ export function createLocationChangeObservable(configuration: RumConfiguration,
   })
 }
 
-function trackHistory(configuration: RumConfiguration, onHistoryChange: () => void) {
+function getLocation() {
+  return mockable(globalObject.location)
+}
+
+function trackHistory(onHistoryChange: () => void) {
   const { stop: stopInstrumentingPushState } = instrumentMethod(
     getHistoryInstrumentationTarget('pushState'),
     'pushState',
@@ -47,7 +58,7 @@ function trackHistory(configuration: RumConfiguration, onHistoryChange: () => vo
       onPostCall(onHistoryChange)
     }
   )
-  const { stop: removeListener } = addEventListener(configuration, window, DOM_EVENT.POP_STATE, onHistoryChange)
+  const { stop: removeListener } = addEventListener(window, DOM_EVENT.POP_STATE, onHistoryChange)
 
   return {
     stop: () => {
@@ -58,8 +69,8 @@ function trackHistory(configuration: RumConfiguration, onHistoryChange: () => vo
   }
 }
 
-function trackHash(configuration: RumConfiguration, onHashChange: () => void) {
-  return addEventListener(configuration, window, DOM_EVENT.HASH_CHANGE, onHashChange)
+function trackHash(onHashChange: () => void) {
+  return addEventListener(window, DOM_EVENT.HASH_CHANGE, onHashChange)
 }
 
 function getHistoryInstrumentationTarget(methodName: 'pushState' | 'replaceState') {