⚗ Collect scroll metrics

packages/core/src/tools/experimentalFeatures.ts

@@ -17,6 +17,7 @@ export enum ExperimentalFeature {
   PAGE_STATES = 'page_states',
   COLLECT_FLUSH_REASON = 'collect_flush_reason',
   NO_RESOURCE_DURATION_FROZEN_STATE = 'no_resource_duration_frozen_state',
+  SCROLLMAP = 'scrollmap',
 }
 
 const enabledExperimentalFeatures: Set<ExperimentalFeature> = new Set()

packages/rum/src/domain/record/viewports.spec.ts → packages/rum-core/src/browser/scroll.spec.ts

@@ -1,11 +1,11 @@
 import { addEventListener, DOM_EVENT, isIE } from '@datadog/browser-core'
-import { getScrollX, getScrollY } from './viewports'
+import { getScrollX, getScrollY } from './scroll'
 
 function isMobileSafari12() {
   return /iPhone OS 12.* like Mac OS.* Version\/12.* Mobile.*Safari/.test(navigator.userAgent)
 }
 
-describe('layout viewport', () => {
+describe('scroll', () => {
   let shouldWaitForWindowScrollEvent: boolean
 
   const addVerticalScrollBar = () => {

packages/rum-core/src/browser/scroll.ts

@@ -0,0 +1,25 @@
+export function getScrollX() {
+  let scrollX
+  const visual = window.visualViewport
+  if (visual) {
+    scrollX = visual.pageLeft - visual.offsetLeft
+  } else if (window.scrollX !== undefined) {
+    scrollX = window.scrollX
+  } else {
+    scrollX = window.pageXOffset || 0
+  }
+  return Math.round(scrollX)
+}
+
+export function getScrollY() {
+  let scrollY
+  const visual = window.visualViewport
+  if (visual) {
+    scrollY = visual.pageTop - visual.offsetTop
+  } else if (window.scrollY !== undefined) {
+    scrollY = window.scrollY
+  } else {
+    scrollY = window.pageYOffset || 0
+  }
+  return Math.round(scrollY)
+}

packages/rum-core/src/domain/rumEventsCollection/view/trackViewMetrics.spec.ts

@@ -1,5 +1,14 @@
-import type { Context, RelativeTime, Duration } from '@datadog/browser-core'
-import { addDuration, relativeNow } from '@datadog/browser-core'
+import type { Context, RelativeTime, TimeStamp, Duration } from '@datadog/browser-core'
+import {
+  ExperimentalFeature,
+  addExperimentalFeatures,
+  resetExperimentalFeatures,
+  DOM_EVENT,
+  addDuration,
+  relativeNow,
+} from '@datadog/browser-core'
+import type { Clock } from '@datadog/browser-core/test'
+import { createNewEvent, mockClock } from '@datadog/browser-core/test'
 import type { RumEvent } from '../../../rumEvent.types'
 import type { TestSetupBuilder } from '../../../../test'
 import { setup } from '../../../../test'
@@ -11,6 +20,8 @@ import { PAGE_ACTIVITY_END_DELAY, PAGE_ACTIVITY_VALIDATION_DELAY } from '../../w
 import { THROTTLE_VIEW_UPDATE_PERIOD } from './trackViews'
 import type { ViewTest } from './setupViewTest.specHelper'
 import { setupViewTest } from './setupViewTest.specHelper'
+import type { ScrollMetrics } from './trackViewMetrics'
+import { THROTTLE_SCROLL_DURATION, trackScrollMetrics } from './trackViewMetrics'
 
 const BEFORE_PAGE_ACTIVITY_VALIDATION_DELAY = (PAGE_ACTIVITY_VALIDATION_DELAY * 0.8) as Duration
 
@@ -519,4 +530,161 @@ describe('rum track view metrics', () => {
       expect(getViewUpdate(2).cumulativeLayoutShift).toBe(0.5)
     })
   })
+
+  describe('scroll metrics', () => {
+    describe('on scroll', () => {
+      let scrollMetrics: ScrollMetrics = {}
+      let stopTrackScrollMetrics: () => void
+      let clock: Clock
+      const getMetrics = jasmine.createSpy('getMetrics')
+
+      const newScroll = (scrollParams: { scrollHeight: number; scrollDepth: number; scrollTop: number }) => {
+        getMetrics.and.returnValue(scrollParams)
+
+        window.dispatchEvent(createNewEvent(DOM_EVENT.SCROLL))
+
+        clock.tick(THROTTLE_SCROLL_DURATION)
+      }
+      describe('with flag enabled', () => {
+        beforeEach(() => {
+          clock = mockClock()
+          addExperimentalFeatures([ExperimentalFeature.SCROLLMAP])
+          stopTrackScrollMetrics = trackScrollMetrics(
+            { relative: 0 as RelativeTime, timeStamp: 0 as TimeStamp },
+            (s) => (scrollMetrics = s),
+            getMetrics
+          ).stop
+        })
+
+        afterEach(() => {
+          stopTrackScrollMetrics()
+          resetExperimentalFeatures()
+          scrollMetrics = {}
+          clock.cleanup()
+        })
+
+        it('should update scroll metrics when scrolling the first time', () => {
+          newScroll({ scrollHeight: 1000, scrollDepth: 500, scrollTop: 100 })
+
+          expect(scrollMetrics).toEqual({
+            maxScrollHeight: 1000,
+            maxScrollDepth: 500,
+            maxScrollTop: 100,
+            maxScrollDepthTime: 1000 as Duration,
+          })
+        })
+
+        it('should update scroll metrics when scroll depth has increased', () => {
+          newScroll({ scrollHeight: 1000, scrollDepth: 500, scrollTop: 100 })
+
+          newScroll({ scrollHeight: 1000, scrollDepth: 600, scrollTop: 200 })
+
+          expect(scrollMetrics).toEqual({
+            maxScrollHeight: 1000,
+            maxScrollDepth: 600,
+            maxScrollTop: 200,
+            maxScrollDepthTime: 2000 as Duration,
+          })
+        })
+
+        it('should NOT update scroll metrics when scroll depth has not increased', () => {
+          newScroll({ scrollHeight: 1000, scrollDepth: 600, scrollTop: 200 })
+
+          newScroll({ scrollHeight: 1000, scrollDepth: 450, scrollTop: 50 })
+
+          expect(scrollMetrics).toEqual({
+            maxScrollHeight: 1000,
+            maxScrollDepth: 600,
+            maxScrollTop: 200,
+            maxScrollDepthTime: 1000 as Duration,
+          })
+        })
+      })
+
+      describe('with flag disabled', () => {
+        beforeEach(() => {
+          clock = mockClock()
+          stopTrackScrollMetrics = trackScrollMetrics(
+            { relative: 1 as RelativeTime, timeStamp: 2 as TimeStamp },
+            (s) => (scrollMetrics = s),
+            getMetrics
+          ).stop
+        })
+
+        afterEach(() => {
+          stopTrackScrollMetrics()
+          resetExperimentalFeatures()
+          scrollMetrics = {}
+          clock.cleanup()
+        })
+        it('should NOT update scroll metrics when scrolling the first time', () => {
+          newScroll({ scrollHeight: 1000, scrollDepth: 500, scrollTop: 100 })
+
+          expect(scrollMetrics).toEqual({})
+        })
+      })
+    })
+
+    describe('on load', () => {
+      beforeEach(() => {
+        setupBuilder.withFakeClock()
+      })
+
+      describe('with flag enabled', () => {
+        beforeEach(() => {
+          addExperimentalFeatures([ExperimentalFeature.SCROLLMAP])
+        })
+
+        afterEach(() => {
+          resetExperimentalFeatures()
+        })
+        it('should have an undefined loading time and empty scroll metrics if there is no activity on a route change', () => {
+          const { clock } = setupBuilder.build()
+          const { getViewUpdate, getViewUpdateCount, startView } = viewTest
+
+          startView()
+          clock.tick(THROTTLE_VIEW_UPDATE_PERIOD)
+
+          expect(getViewUpdateCount()).toEqual(3)
+          expect(getViewUpdate(2).loadingTime).toBeUndefined()
+          expect(getViewUpdate(2).scrollMetrics).toEqual({})
+        })
+
+        it('should have a loading time equal to the activity time and scroll metrics if there is a unique activity on a route change', () => {
+          const { domMutationObservable, clock } = setupBuilder.build()
+          const { getViewUpdate, startView } = viewTest
+
+          startView()
+          clock.tick(BEFORE_PAGE_ACTIVITY_VALIDATION_DELAY)
+          domMutationObservable.notify()
+          clock.tick(AFTER_PAGE_ACTIVITY_END_DELAY)
+          clock.tick(THROTTLE_VIEW_UPDATE_PERIOD)
+
+          expect(getViewUpdate(3).loadingTime).toEqual(BEFORE_PAGE_ACTIVITY_VALIDATION_DELAY)
+          expect(getViewUpdate(3).scrollMetrics).toEqual({
+            maxScrollHeight: 600,
+            maxScrollDepth: 600,
+            maxScrollDepthTime: 80 as Duration,
+            maxScrollTop: 0,
+          })
+        })
+      })
+
+      describe('with flag disabled', () => {
+        it('should have a loading time equal to the activity time but no scroll metrics if there is a unique activity on a route change', () => {
+          const { domMutationObservable, clock } = setupBuilder.build()
+          const { getViewUpdate, startView } = viewTest
+
+          startView()
+          clock.tick(BEFORE_PAGE_ACTIVITY_VALIDATION_DELAY)
+          domMutationObservable.notify()
+          clock.tick(AFTER_PAGE_ACTIVITY_END_DELAY)
+          clock.tick(THROTTLE_VIEW_UPDATE_PERIOD)
+
+          expect(getViewUpdate(3).loadingTime).toEqual(BEFORE_PAGE_ACTIVITY_VALIDATION_DELAY)
+          expect(getViewUpdate(3).scrollMetrics).toEqual({})
+        })
+      })
+    })
+  })
 })

packages/rum-core/src/domain/rumEventsCollection/view/trackViewMetrics.ts

@@ -1,5 +1,16 @@
-import type { Duration, RelativeTime, Observable, ClocksState } from '@datadog/browser-core'
-import { noop, round, ONE_SECOND, elapsed } from '@datadog/browser-core'
+import type { ClocksState, Duration, Observable, RelativeTime } from '@datadog/browser-core'
+import {
+  ExperimentalFeature,
+  isExperimentalFeatureEnabled,
+  DOM_EVENT,
+  ONE_SECOND,
+  addEventListener,
+  elapsed,
+  noop,
+  relativeNow,
+  round,
+  throttle,
+} from '@datadog/browser-core'
 import type { RumLayoutShiftTiming } from '../../../browser/performanceCollection'
 import { supportPerformanceTimingEvent } from '../../../browser/performanceCollection'
 import { ViewLoadingType } from '../../../rawRumEvent.types'
@@ -8,6 +19,70 @@ import type { LifeCycle } from '../../lifeCycle'
 import { LifeCycleEventType } from '../../lifeCycle'
 import { waitPageActivityEnd } from '../../waitPageActivityEnd'
 
+import { getScrollY } from '../../../browser/scroll'
+import { getViewportDimension } from '../../../browser/viewportObservable'
+
+export interface ScrollMetrics {
+  maxScrollDepth?: number
+  maxScrollHeight?: number
+  maxScrollDepthTime?: Duration
+  maxScrollTop?: number
+}
+
+export const THROTTLE_SCROLL_DURATION = ONE_SECOND
+
+function computeScrollMetrics() {
+  const scrollTop = getScrollY()
+
+  const { height } = getViewportDimension()
+
+  const scrollHeight = Math.round((document.scrollingElement || document.documentElement).scrollHeight)
+  const scrollDepth = Math.round(height + scrollTop)
+
+  return {
+    scrollHeight,
+    scrollDepth,
+    scrollTop,
+  }
+}
+
+export function trackScrollMetrics(
+  viewStart: ClocksState,
+  callback: (scrollMetrics: ScrollMetrics) => void,
+  getMetrics = computeScrollMetrics
+) {
+  if (!isExperimentalFeatureEnabled(ExperimentalFeature.SCROLLMAP)) {
+    return { stop: noop }
+  }
+  const trackedScrollMetrics: ScrollMetrics = {}
+  const handleScrollEvent = throttle(
+    () => {
+      const { scrollHeight, scrollDepth, scrollTop } = getMetrics()
+
+      if (scrollDepth > (trackedScrollMetrics.maxScrollDepth || 0)) {
+        const now = relativeNow()
+        const timeStamp = elapsed(viewStart.relative, now)
+        trackedScrollMetrics.maxScrollDepth = scrollDepth
+        trackedScrollMetrics.maxScrollHeight = scrollHeight
+        trackedScrollMetrics.maxScrollDepthTime = timeStamp
+        trackedScrollMetrics.maxScrollTop = scrollTop
+        callback(trackedScrollMetrics)
+      }
+    },
+    THROTTLE_SCROLL_DURATION,
+    { leading: false, trailing: true }
+  )
+
+  const { stop } = addEventListener(window, DOM_EVENT.SCROLL, handleScrollEvent.throttled, { passive: true })
+
+  return {
+    stop: () => {
+      handleScrollEvent.cancel()
+      stop()
+    },
+  }
+}
+
 export interface ViewMetrics {
   loadingTime?: Duration
   cumulativeLayoutShift?: number
@@ -23,6 +98,8 @@ export function trackViewMetrics(
 ) {
   const viewMetrics: ViewMetrics = {}
 
+  let scrollMetrics: ScrollMetrics = {}
+
   const { stop: stopLoadingTimeTracking, setLoadEvent } = trackLoadingTime(
     lifeCycle,
     domMutationObservable,
@@ -31,10 +108,28 @@ export function trackViewMetrics(
     viewStart,
     (newLoadingTime) => {
       viewMetrics.loadingTime = newLoadingTime
+
+      // We compute scroll metrics at loading time to ensure we have scroll data when loading the view initially
+      // This is to ensure that we have the depth data even if the user didn't scroll or if the view is not scrollable.
+      if (isExperimentalFeatureEnabled(ExperimentalFeature.SCROLLMAP)) {
+        const { scrollHeight, scrollDepth, scrollTop } = computeScrollMetrics()
+        scrollMetrics.maxScrollHeight = scrollHeight
+        scrollMetrics.maxScrollDepth = scrollDepth
+        scrollMetrics.maxScrollDepthTime = newLoadingTime
+        scrollMetrics.maxScrollTop = scrollTop
+      }
       scheduleViewUpdate()
     }
   )
 
+  const { stop: stopScrollMetricsTracking } = trackScrollMetrics(
+    viewStart,
+    (newScrollMetrics) => {
+      scrollMetrics = newScrollMetrics
+    },
+    computeScrollMetrics
+  )
+
   let stopCLSTracking: () => void
   if (isLayoutShiftSupported()) {
     viewMetrics.cumulativeLayoutShift = 0
@@ -49,9 +144,11 @@ export function trackViewMetrics(
     stop: () => {
       stopLoadingTimeTracking()
       stopCLSTracking()
+      stopScrollMetricsTracking()
     },
     setLoadEvent,
     viewMetrics,
+    scrollMetrics,
   }
 }