@kubesense/kubesense-browser-rum-core 1.0.0

package/src/boot/startRum.ts

@@ -0,0 +1,280 @@
+import type {
+  Observable,
+  RawError,
+  DeflateEncoderStreamId,
+  Encoder,
+  TrackingConsentState,
+  BufferedData,
+  BufferedObservable,
+} from '@kubesense/kubesense-browser-core'
+import {
+  sendToExtension,
+  createPageMayExitObservable,
+  TelemetryService,
+  startTelemetry,
+  canUseEventBridge,
+  addTelemetryDebug,
+  startAccountContext,
+  startGlobalContext,
+  startUserContext,
+} from '@kubesense/kubesense-browser-core'
+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 { 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'
+import { createLocationChangeObservable } from '../browser/locationChangeObservable'
+import type { RumConfiguration } from '../domain/configuration'
+import type { ViewOptions } from '../domain/view/trackViews'
+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'
+import { startSyntheticsContext } from '../domain/contexts/syntheticsContext'
+import { startRumAssembly } from '../domain/assembly'
+import { startSessionContext } from '../domain/contexts/sessionContext'
+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 type { RecorderApi, ProfilerApi } from './rumPublicApi'
+
+export type StartRum = typeof startRum
+export type StartRumResult = ReturnType<StartRum>
+
+export function startRum(
+  configuration: RumConfiguration,
+  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>,
+  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
+  )
+  cleanupTasks.push(telemetry.stop)
+
+  const session = !canUseEventBridge()
+    ? startRumSessionManager(configuration, lifeCycle, trackingConsentState)
+    : startRumSessionManagerStub()
+
+  if (!canUseEventBridge()) {
+    const batch = startRumBatch(
+      configuration,
+      lifeCycle,
+      reportError,
+      pageMayExitObservable,
+      session.expireObservable,
+      createEncoder
+    )
+    cleanupTasks.push(() => batch.stop())
+    startCustomerDataTelemetry(telemetry, lifeCycle, batch.flushController.flushObservable)
+  } else {
+    startRumEventBridge(lifeCycle)
+  }
+
+  startTrackingConsentContext(hooks, trackingConsentState)
+
+  const { stop: stopInitialViewMetricsTelemetry } = startInitialViewMetricsTelemetry(lifeCycle, telemetry)
+  cleanupTasks.push(stopInitialViewMetricsTelemetry)
+
+  const { stop: stopRumEventCollection, ...startRumEventCollectionResult } = startRumEventCollection(
+    lifeCycle,
+    hooks,
+    configuration,
+    session,
+    recorderApi,
+    initialViewOptions,
+    customVitalsState,
+    bufferedDataObservable,
+    sdkName,
+    reportError
+  )
+  cleanupTasks.push(stopRumEventCollection)
+  bufferedDataObservable.unbuffer()
+
+  // Add Clean-up tasks for Profiler API.
+  cleanupTasks.push(() => profilerApi.stop())
+
+  return {
+    ...startRumEventCollectionResult,
+    lifeCycle,
+    session,
+    stopSession: () => session.expire(),
+    telemetry,
+    stop: () => {
+      cleanupTasks.forEach((task) => task())
+    },
+    hooks,
+  }
+}
+
+export function startRumEventCollection(
+  lifeCycle: LifeCycle,
+  hooks: Hooks,
+  configuration: RumConfiguration,
+  session: RumSessionManager,
+  recorderApi: RecorderApi,
+  initialViewOptions: ViewOptions | undefined,
+  customVitalsState: CustomVitalsState,
+  bufferedDataObservable: Observable<BufferedData>,
+  sdkName: SdkName | undefined,
+  reportError: (error: RawError) => void
+) {
+  const cleanupTasks: Array<() => void> = []
+
+  const domMutationObservable = createDOMMutationObservable()
+  const locationChangeObservable = createLocationChangeObservable(configuration, location)
+  const { observable: windowOpenObservable, stop: stopWindowOpen } = createWindowOpenObservable()
+  cleanupTasks.push(stopWindowOpen)
+
+  startDefaultContext(hooks, configuration, sdkName)
+  const pageStateHistory = startPageStateHistory(hooks, configuration)
+  cleanupTasks.push(() => pageStateHistory.stop())
+  const viewHistory = startViewHistory(lifeCycle)
+  cleanupTasks.push(() => viewHistory.stop())
+  const urlContexts = startUrlContexts(lifeCycle, hooks, locationChangeObservable, location)
+  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 actionCollection = startActionCollection(
+    lifeCycle,
+    hooks,
+    domMutationObservable,
+    windowOpenObservable,
+    configuration
+  )
+  cleanupTasks.push(actionCollection.stop)
+
+  const eventCollection = startEventCollection(lifeCycle)
+
+  const displayContext = startDisplayContext(hooks, configuration)
+  cleanupTasks.push(displayContext.stop)
+  const ciVisibilityContext = startCiVisibilityContext(configuration, hooks)
+  cleanupTasks.push(ciVisibilityContext.stop)
+  startSyntheticsContext(hooks)
+
+  startRumAssembly(configuration, lifeCycle, hooks, reportError)
+
+  const {
+    addTiming,
+    startView,
+    setViewName,
+    setViewContext,
+    setViewContextProperty,
+    getViewContext,
+    stop: stopViewCollection,
+  } = startViewCollection(
+    lifeCycle,
+    hooks,
+    configuration,
+    location,
+    domMutationObservable,
+    windowOpenObservable,
+    locationChangeObservable,
+    recorderApi,
+    viewHistory,
+    initialViewOptions
+  )
+  cleanupTasks.push(stopViewCollection)
+
+  const { stop: stopResourceCollection } = startResourceCollection(lifeCycle, configuration, pageStateHistory)
+  cleanupTasks.push(stopResourceCollection)
+
+  const { stop: stopLongTaskCollection, longTaskContexts } = startLongTaskCollection(lifeCycle, configuration)
+  cleanupTasks.push(stopLongTaskCollection)
+
+  const { addError } = startErrorCollection(lifeCycle, configuration, bufferedDataObservable)
+
+  startRequestCollection(lifeCycle, configuration, session, userContext, accountContext)
+
+  const vitalCollection = startVitalCollection(lifeCycle, pageStateHistory, customVitalsState)
+
+  const internalContext = startInternalContext(
+    configuration.applicationId,
+    session,
+    viewHistory,
+    actionCollection.actionContexts,
+    urlContexts
+  )
+
+  return {
+    addAction: actionCollection.addAction,
+    addEvent: eventCollection.addEvent,
+    addError,
+    addTiming,
+    addFeatureFlagEvaluation: featureFlagContexts.addFeatureFlagEvaluation,
+    startView,
+    setViewContext,
+    setViewContextProperty,
+    getViewContext,
+    setViewName,
+    viewHistory,
+    getInternalContext: internalContext.get,
+    startDurationVital: vitalCollection.startDurationVital,
+    stopDurationVital: vitalCollection.stopDurationVital,
+    addDurationVital: vitalCollection.addDurationVital,
+    addOperationStepVital: vitalCollection.addOperationStepVital,
+    globalContext,
+    userContext,
+    accountContext,
+    longTaskContexts,
+    stop: () => cleanupTasks.forEach((task) => task()),
+  }
+}

package/src/browser/cookieObservable.ts

@@ -0,0 +1,63 @@
+import type { Configuration, CookieStore } from '@kubesense/kubesense-browser-core'
+import {
+  setInterval,
+  clearInterval,
+  Observable,
+  addEventListener,
+  ONE_SECOND,
+  findCommaSeparatedValue,
+  DOM_EVENT,
+} 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
+
+  return new Observable<string | undefined>((observable) =>
+    detectCookieChangeStrategy(cookieName, (event) => observable.notify(event))
+  )
+}
+
+function listenToCookieStoreChange(configuration: Configuration) {
+  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)
+        }
+      }
+    )
+    return listener.stop
+  }
+}
+
+export const WATCH_COOKIE_INTERVAL_DELAY = ONE_SECOND
+
+function watchCookieFallback(cookieName: string, callback: (event: string | undefined) => void) {
+  const previousCookieValue = findCommaSeparatedValue(document.cookie, cookieName)
+  const watchCookieIntervalId = setInterval(() => {
+    const cookieValue = findCommaSeparatedValue(document.cookie, cookieName)
+    if (cookieValue !== previousCookieValue) {
+      callback(cookieValue)
+    }
+  }, WATCH_COOKIE_INTERVAL_DELAY)
+
+  return () => {
+    clearInterval(watchCookieIntervalId)
+  }
+}

package/src/browser/domMutationObservable.ts

@@ -0,0 +1,98 @@
+import { monitor, noop, Observable, getZoneJsOriginalValue } from '@kubesense/kubesense-browser-core'
+
+// https://dom.spec.whatwg.org/#interface-mutationrecord
+export interface RumCharacterDataMutationRecord {
+  type: 'characterData'
+  target: Node
+  oldValue: string | null
+}
+
+export interface RumAttributesMutationRecord {
+  type: 'attributes'
+  target: Element
+  oldValue: string | null
+  attributeName: string | null
+}
+
+export interface RumChildListMutationRecord {
+  type: 'childList'
+  target: Node
+  addedNodes: NodeList
+  removedNodes: NodeList
+}
+
+export type RumMutationRecord =
+  | 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,
+      characterData: true,
+      childList: true,
+      subtree: true,
+    })
+    return () => observer.disconnect()
+  })
+}
+
+type MutationObserverConstructor = new (callback: (records: RumMutationRecord[]) => void) => MutationObserver
+
+export interface BrowserWindow extends Window {
+  MutationObserver?: MutationObserverConstructor
+  Zone?: unknown
+}
+
+export function getMutationObserverConstructor(): MutationObserverConstructor | undefined {
+  let constructor: MutationObserverConstructor | undefined
+  const browserWindow = window as BrowserWindow
+
+  // Angular uses Zone.js to provide a context persisting across async tasks.  Zone.js replaces the
+  // global MutationObserver constructor with a patched version to support the context propagation.
+  // There is an ongoing issue[1][2] with this setup when using a MutationObserver within a Angular
+  // component: on some occasions, the callback is being called in an infinite loop, causing the
+  // page to freeze (even if the callback is completely empty).
+  //
+  // To work around this issue, we try to get the original MutationObserver constructor stored by
+  // Zone.js.
+  //
+  // [1] https://github.com/angular/angular/issues/26948
+  // [2] https://github.com/angular/angular/issues/31712
+  if (browserWindow.Zone) {
+    // Zone.js 0.8.6+ is storing original class constructors into the browser 'window' object[3].
+    //
+    // [3] https://github.com/angular/angular/blob/6375fa79875c0fe7b815efc45940a6e6f5c9c9eb/packages/zone.js/lib/common/utils.ts#L288
+    constructor = getZoneJsOriginalValue(browserWindow, 'MutationObserver')
+
+    if (browserWindow.MutationObserver && constructor === browserWindow.MutationObserver) {
+      // Anterior Zone.js versions (used in Angular 2) does not expose the original MutationObserver
+      // in the 'window' object. Luckily, the patched MutationObserver class is storing an original
+      // instance in its properties[4]. Let's get the original MutationObserver constructor from
+      // there.
+      //
+      // [4] https://github.com/angular/zone.js/blob/v0.8.5/lib/common/utils.ts#L412
+
+      const patchedInstance = new browserWindow.MutationObserver(noop) as {
+        originalInstance?: { constructor: MutationObserverConstructor }
+      }
+
+      const originalInstance = getZoneJsOriginalValue(patchedInstance, 'originalInstance')
+      constructor = originalInstance && originalInstance.constructor
+    }
+  }
+
+  if (!constructor) {
+    constructor = browserWindow.MutationObserver
+  }
+
+  return constructor
+}

package/src/browser/firstInputPolyfill.ts

@@ -0,0 +1,87 @@
+import type { Duration, RelativeTime } from '@kubesense/kubesense-browser-core'
+import { addEventListeners, dateNow, DOM_EVENT, relativeNow } from '@kubesense/kubesense-browser-core'
+import type { RumConfiguration } from '../domain/configuration'
+
+/**
+ * first-input timing entry polyfill based on
+ * https://github.com/GoogleChrome/web-vitals/blob/master/src/lib/polyfills/firstInputPolyfill.ts
+ */
+export function retrieveFirstInputTiming(
+  configuration: RumConfiguration,
+  callback: (timing: PerformanceEventTiming) => void
+) {
+  const startTimeStamp = dateNow()
+  let timingSent = false
+
+  const { stop: removeEventListeners } = addEventListeners(
+    configuration,
+    window,
+    [DOM_EVENT.CLICK, DOM_EVENT.MOUSE_DOWN, DOM_EVENT.KEY_DOWN, DOM_EVENT.TOUCH_START, DOM_EVENT.POINTER_DOWN],
+    (evt) => {
+      // Only count cancelable events, which should trigger behavior important to the user.
+      if (!evt.cancelable) {
+        return
+      }
+
+      // This timing will be used to compute the "first Input delay", which is the delta between
+      // when the system received the event (e.g. evt.timeStamp) and when it could run the callback
+      // (e.g. performance.now()).
+      const timing: PerformanceEventTiming = {
+        entryType: 'first-input',
+        processingStart: relativeNow(),
+        processingEnd: relativeNow(),
+        startTime: evt.timeStamp as RelativeTime,
+        duration: 0 as Duration, // arbitrary value to avoid nullable duration and simplify INP logic
+        name: '',
+        cancelable: false,
+        target: null,
+        toJSON: () => ({}),
+      }
+
+      if (evt.type === DOM_EVENT.POINTER_DOWN) {
+        sendTimingIfPointerIsNotCancelled(configuration, timing)
+      } else {
+        sendTiming(timing)
+      }
+    },
+    { passive: true, capture: true }
+  )
+
+  return { stop: removeEventListeners }
+
+  /**
+   * Pointer events are a special case, because they can trigger main or compositor thread behavior.
+   * We differentiate these cases based on whether or not we see a pointercancel event, which are
+   * fired when we scroll. If we're scrolling we don't need to report input delay since FID excludes
+   * scrolling and pinch/zooming.
+   */
+  function sendTimingIfPointerIsNotCancelled(configuration: RumConfiguration, timing: PerformanceEventTiming) {
+    addEventListeners(
+      configuration,
+      window,
+      [DOM_EVENT.POINTER_UP, DOM_EVENT.POINTER_CANCEL],
+      (event) => {
+        if (event.type === DOM_EVENT.POINTER_UP) {
+          sendTiming(timing)
+        }
+      },
+      { once: true }
+    )
+  }
+
+  function sendTiming(timing: PerformanceEventTiming) {
+    if (!timingSent) {
+      timingSent = true
+      removeEventListeners()
+      // In some cases the recorded delay is clearly wrong, e.g. it's negative or it's larger than
+      // the time between now and when the page was loaded.
+      // - https://github.com/GoogleChromeLabs/first-input-delay/issues/4
+      // - https://github.com/GoogleChromeLabs/first-input-delay/issues/6
+      // - https://github.com/GoogleChromeLabs/first-input-delay/issues/7
+      const delay = timing.processingStart - timing.startTime
+      if (delay >= 0 && delay < dateNow() - startTimeStamp) {
+        callback(timing)
+      }
+    }
+  }
+}

package/src/browser/htmlDomUtils.ts

@@ -0,0 +1,45 @@
+export function isTextNode(node: Node): node is Text {
+  return node.nodeType === Node.TEXT_NODE
+}
+
+export function isCommentNode(node: Node): node is Comment {
+  return node.nodeType === Node.COMMENT_NODE
+}
+
+export function isElementNode(node: Node): node is Element {
+  return node.nodeType === Node.ELEMENT_NODE
+}
+
+export function isNodeShadowHost(node: Node): node is Element & { shadowRoot: ShadowRoot } {
+  return isElementNode(node) && Boolean(node.shadowRoot)
+}
+
+export function isNodeShadowRoot(node: Node): node is ShadowRoot {
+  const shadowRoot = node as ShadowRoot
+  return !!shadowRoot.host && shadowRoot.nodeType === Node.DOCUMENT_FRAGMENT_NODE && isElementNode(shadowRoot.host)
+}
+
+export function hasChildNodes(node: Node) {
+  return node.childNodes.length > 0 || isNodeShadowHost(node)
+}
+
+export function forEachChildNodes(node: Node, callback: (child: Node) => void) {
+  let child = node.firstChild
+
+  while (child) {
+    callback(child)
+
+    child = child.nextSibling
+  }
+
+  if (isNodeShadowHost(node)) {
+    callback(node.shadowRoot)
+  }
+}
+
+/**
+ * Return `host` in case if the current node is a shadow root otherwise will return the `parentNode`
+ */
+export function getParentNode(node: Node): Node | null {
+  return isNodeShadowRoot(node) ? node.host : node.parentNode
+}

package/src/browser/locationChangeObservable.ts

@@ -0,0 +1,69 @@
+import { addEventListener, DOM_EVENT, instrumentMethod, Observable, shallowClone } from '@kubesense/kubesense-browser-core'
+import type { RumConfiguration } from '../domain/configuration'
+
+export interface LocationChange {
+  oldLocation: Readonly<Location>
+  newLocation: Readonly<Location>
+}
+
+export function createLocationChangeObservable(configuration: RumConfiguration, location: Location) {
+  let currentLocation = shallowClone(location)
+
+  return new Observable<LocationChange>((observable) => {
+    const { stop: stopHistoryTracking } = trackHistory(configuration, onLocationChange)
+    const { stop: stopHashTracking } = trackHash(configuration, onLocationChange)
+
+    function onLocationChange() {
+      if (currentLocation.href === location.href) {
+        return
+      }
+      const newLocation = shallowClone(location)
+      observable.notify({
+        newLocation,
+        oldLocation: currentLocation,
+      })
+      currentLocation = newLocation
+    }
+
+    return () => {
+      stopHistoryTracking()
+      stopHashTracking()
+    }
+  })
+}
+
+function trackHistory(configuration: RumConfiguration, onHistoryChange: () => void) {
+  const { stop: stopInstrumentingPushState } = instrumentMethod(
+    getHistoryInstrumentationTarget('pushState'),
+    'pushState',
+    ({ onPostCall }) => {
+      onPostCall(onHistoryChange)
+    }
+  )
+  const { stop: stopInstrumentingReplaceState } = instrumentMethod(
+    getHistoryInstrumentationTarget('replaceState'),
+    'replaceState',
+    ({ onPostCall }) => {
+      onPostCall(onHistoryChange)
+    }
+  )
+  const { stop: removeListener } = addEventListener(configuration, window, DOM_EVENT.POP_STATE, onHistoryChange)
+
+  return {
+    stop: () => {
+      stopInstrumentingPushState()
+      stopInstrumentingReplaceState()
+      removeListener()
+    },
+  }
+}
+
+function trackHash(configuration: RumConfiguration, onHashChange: () => void) {
+  return addEventListener(configuration, window, DOM_EVENT.HASH_CHANGE, onHashChange)
+}
+
+function getHistoryInstrumentationTarget(methodName: 'pushState' | 'replaceState') {
+  // Ideally we should always instument the method on the prototype, however some frameworks (e.g [Next.js](https://github.com/vercel/next.js/blob/d3f5532065f3e3bb84fb54bd2dfd1a16d0f03a21/packages/next/src/client/components/app-router.tsx#L429))
+  // are wrapping the instance method. In that case we should also wrap the instance method.
+  return Object.prototype.hasOwnProperty.call(history, methodName) ? history : History.prototype
+}