@newrelic/browser-agent 1.239.1 → 1.241.0

package/src/features/ajax/aggregate/index.js

@@ -67,6 +67,9 @@ export class Aggregate extends AggregateBase {
 
     this.drain()
 
+    const beacon = getInfo(agentIdentifier).errorBeacon
+    const proxyBeacon = agentInit.proxy.beacon
+
     function storeXhr (params, metrics, startTime, endTime, type) {
       metrics.time = startTime
 
@@ -86,7 +89,8 @@ export class Aggregate extends AggregateBase {
       if (!allAjaxIsEnabled) return
 
       if (!shouldCollectEvent(params)) {
-        if (params.hostname === getInfo(agentIdentifier).errorBeacon) {
+        if (params.hostname === beacon || (proxyBeacon && params.hostname === proxyBeacon)) {
+          // This doesn't make a distinction if the same-domain request is going to a different port or path...
           handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, ee)
         } else {
           handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/App'], undefined, FEATURE_NAMES.metrics, ee)

package/src/features/metrics/aggregate/index.js

@@ -1,4 +1,4 @@
-import { getRuntime } from '../../../common/config/config'
+import { getRuntime, getConfiguration } from '../../../common/config/config'
 import { registerHandler } from '../../../common/event-emitter/register-handler'
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { FEATURE_NAME, SUPPORTABILITY_METRIC, CUSTOM_METRIC, SUPPORTABILITY_METRIC_CHANNEL, CUSTOM_METRIC_CHANNEL } from '../constants'
@@ -29,9 +29,11 @@ export class Aggregate extends AggregateBase {
     this.singleChecks() // checks that are run only one time, at script load
     this.eachSessionChecks() // the start of every time user engages with page
 
-    // *cli, Mar 23 - Per NR-94597, this feature should only harvest ONCE at the (potential) EoL time of the page.
-    scheduler = new HarvestScheduler('jserrors', { onUnload: () => this.unload() }, this)
-    scheduler.harvest.on('jserrors', () => ({ body: this.aggregator.take(['cm', 'sm']) }))
+    this.ee.on(`drain-${this.featureName}`, () => {
+      // *cli, Mar 23 - Per NR-94597, this feature should only harvest ONCE at the (potential) EoL time of the page.
+      scheduler = new HarvestScheduler('jserrors', { onUnload: () => this.unload() }, this)
+      scheduler.harvest.on('jserrors', () => ({ body: this.aggregator.take(['cm', 'sm']) }))
+    }) // this is needed to ensure EoL is "on" and sent
 
     this.drain()
   }
@@ -82,6 +84,11 @@ export class Aggregate extends AggregateBase {
     const rules = getRules(this.agentIdentifier)
     if (rules.length > 0) this.storeSupportabilityMetrics('Generic/Obfuscate/Detected')
     if (rules.length > 0 && !validateRules(rules)) this.storeSupportabilityMetrics('Generic/Obfuscate/Invalid')
+
+    // Check if proxy for either chunks or beacon is being used
+    const { proxy } = getConfiguration(this.agentIdentifier)
+    if (proxy.assets) this.storeSupportabilityMetrics('Config/AssetsUrl/Changed')
+    if (proxy.beacon) this.storeSupportabilityMetrics('Config/BeaconUrl/Changed')
   }
 
   eachSessionChecks () {

package/src/features/page_view_event/aggregate/index.js

@@ -1,53 +1,41 @@
-import { handle } from '../../../common/event-emitter/handle'
-import { FEATURE_NAMES } from '../../../loaders/features/features'
-import { isiOS, globalScope, isBrowserScope } from '../../../common/constants/runtime'
-import { onTTFB } from 'web-vitals'
+import { globalScope, isBrowserScope } from '../../../common/constants/runtime'
 import { addPT, addPN } from '../../../common/timing/nav-timing'
 import { stringify } from '../../../common/util/stringify'
-import { paintMetrics } from '../../../common/metrics/paint-metrics'
-import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config'
+import { getInfo, getRuntime } from '../../../common/config/config'
 import { Harvest } from '../../../common/harvest/harvest'
 import * as CONSTANTS from '../constants'
 import { getActivatedFeaturesFlags } from './initialized-features'
 import { activateFeatures } from '../../../common/util/feature-flags'
 import { warn } from '../../../common/util/console'
 import { AggregateBase } from '../../utils/aggregate-base'
+import { firstContentfulPaint } from '../../../common/vitals/first-contentful-paint'
+import { firstPaint } from '../../../common/vitals/first-paint'
+import { timeToFirstByte } from '../../../common/vitals/time-to-first-byte'
 
 export class Aggregate extends AggregateBase {
   static featureName = CONSTANTS.FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, CONSTANTS.FEATURE_NAME)
 
-    if (typeof PerformanceNavigationTiming !== 'undefined' && !isiOS) {
-      this.alreadySent = false // we don't support timings on BFCache restores
-      const agentRuntime = getRuntime(agentIdentifier) // we'll store timing values on the runtime obj to be read by the aggregate module
+    this.timeToFirstByte = 0
+    this.firstByteToWindowLoad = 0 // our "frontend" duration
+    this.firstByteToDomContent = 0 // our "dom processing" duration
 
-      /* Time To First Byte
-        This listener must record these values *before* PVE's aggregate sends RUM. */
-      onTTFB(({ value, entries }) => {
-        if (this.alreadySent) return
-        this.alreadySent = true
-
-        agentRuntime[CONSTANTS.TTFB] = Math.round(value) // this is our "backend" duration; web-vitals will ensure it's lower bounded at 0
-
-        // Similar to what vitals does for ttfb, we have to factor in activation-start when calculating relative timings:
+    if (isBrowserScope) {
+      timeToFirstByte.subscribe(({ value, entries }) => {
         const navEntry = entries[0]
-        const respOrActivStart = Math.max(navEntry.responseStart, navEntry.activationStart || 0)
-        agentRuntime[CONSTANTS.FBTWL] = Math.max(Math.round(navEntry.loadEventEnd - respOrActivStart), 0) // our "frontend" duration
-        handle('timing', ['load', Math.round(navEntry.loadEventEnd)], undefined, FEATURE_NAMES.pageViewTiming, this.ee)
-        agentRuntime[CONSTANTS.FBTDC] = Math.max(Math.round(navEntry.domContentLoadedEventEnd - respOrActivStart), 0) // our "dom processing" duration
+        this.timeToFirstByte = Math.max(value, this.timeToFirstByte)
+        this.firstByteToWindowLoad = Math.max(Math.round(navEntry.loadEventEnd - this.timeToFirstByte), this.firstByteToWindowLoad) // our "frontend" duration
+        this.firstByteToDomContent = Math.max(Math.round(navEntry.domContentLoadedEventEnd - this.timeToFirstByte), this.firstByteToDomContent) // our "dom processing" duration
 
         this.sendRum()
       })
     } else {
-      this.sendRum() // timings either already in runtime from instrument or is meant to get 0'd.
+      // worker agent build does not get TTFB values, use default 0 values
+      this.sendRum()
     }
   }
 
-  getScheme () {
-    return getConfigurationValue(this.agentIdentifier, 'ssl') === false ? 'http' : 'https'
-  }
-
   sendRum () {
     const info = getInfo(this.agentIdentifier)
     const agentRuntime = getRuntime(this.agentIdentifier)
@@ -60,9 +48,9 @@ export class Aggregate extends AggregateBase {
     // These 3 values should've been recorded after load and before this func runs. They are part of the minimum required for PageView events to be created.
     // Following PR #428, which demands that all agents send RUM call, these need to be sent even outside of the main window context where PerformanceTiming
     // or PerformanceNavigationTiming do not exists. Hence, they'll be filled in by 0s instead in, for example, worker threads that still init the PVE module.
-    this.aggregator.store('measures', 'be', { value: isBrowserScope ? agentRuntime[CONSTANTS.TTFB] : 0 })
-    this.aggregator.store('measures', 'fe', { value: isBrowserScope ? agentRuntime[CONSTANTS.FBTWL] : 0 })
-    this.aggregator.store('measures', 'dc', { value: isBrowserScope ? agentRuntime[CONSTANTS.FBTDC] : 0 })
+    this.aggregator.store('measures', 'be', { value: this.timeToFirstByte })
+    this.aggregator.store('measures', 'fe', { value: this.firstByteToWindowLoad })
+    this.aggregator.store('measures', 'dc', { value: this.firstByteToDomContent })
 
     const queryParameters = {
       tt: info.ttGuid,
@@ -103,19 +91,8 @@ export class Aggregate extends AggregateBase {
       }
     }
 
-    try { // PVTiming sends these too, albeit using web-vitals and slightly different; it's unknown why they're duplicated, but PVT should be the truth
-      var entries = globalScope.performance.getEntriesByType('paint')
-      entries.forEach(function (entry) {
-        if (!entry.startTime || entry.startTime <= 0) return
-
-        if (entry.name === 'first-paint') {
-          queryParameters.fp = String(Math.floor(entry.startTime))
-        } else if (entry.name === 'first-contentful-paint') {
-          queryParameters.fcp = String(Math.floor(entry.startTime))
-        }
-        paintMetrics[entry.name] = Math.floor(entry.startTime) // this is consumed by Spa module
-      })
-    } catch (e) {}
+    queryParameters.fp = firstPaint.current.value
+    queryParameters.fcp = firstContentfulPaint.current.value
 
     harvester.send({
       endpoint: 'rum',

package/src/features/page_view_event/constants.js

@@ -1,6 +1,3 @@
 import { FEATURE_NAMES } from '../../loaders/features/features'
 
 export const FEATURE_NAME = FEATURE_NAMES.pageViewEvent
-export const TTFB = 'firstbyte'
-export const FBTDC = 'domcontent'
-export const FBTWL = 'windowload'

package/src/features/page_view_event/instrument/index.js

@@ -1,32 +1,11 @@
-import { handle } from '../../../common/event-emitter/handle'
-import { isiOS } from '../../../common/constants/runtime'
 import { InstrumentBase } from '../../utils/instrument-base'
 import * as CONSTANTS from '../constants'
-import { FEATURE_NAMES } from '../../../loaders/features/features'
-import { getRuntime } from '../../../common/config/config'
-import { onDOMContentLoaded, onWindowLoad } from '../../../common/window/load'
-import { now } from '../../../common/timing/now'
 
 export class Instrument extends InstrumentBase {
   static featureName = CONSTANTS.FEATURE_NAME
   constructor (agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, CONSTANTS.FEATURE_NAME, auto)
 
-    if ((typeof PerformanceNavigationTiming === 'undefined' || isiOS) && typeof PerformanceTiming !== 'undefined') {
-      // For majority browser versions in which PNT exists, we can get load timings later from the nav entry (in the aggregate portion). At minimum, PT should exist for main window.
-      // *cli Mar'23 - iOS 15.2 & 15.4 testing in Sauce still fails with onTTFB. Hence, all iOS will fallback to this for now. Unknown if this is similar in nature to iOSBelow16 bug.
-      const agentRuntime = getRuntime(agentIdentifier)
-
-      agentRuntime[CONSTANTS.TTFB] = Math.max(Date.now() - agentRuntime.offset, 0)
-      onDOMContentLoaded(() => { agentRuntime[CONSTANTS.FBTDC] = Math.max(now() - agentRuntime[CONSTANTS.TTFB], 0) })
-      onWindowLoad(() => {
-        const timeNow = now()
-        agentRuntime[CONSTANTS.FBTWL] = Math.max(timeNow - agentRuntime[CONSTANTS.TTFB], 0)
-        handle('timing', ['load', timeNow], undefined, FEATURE_NAMES.pageViewTiming, this.ee)
-      })
-    }
-    // Else, inference: inside worker or some other env where these events are irrelevant. They'll get filled in with 0s in RUM call.
-
     this.importAggregator()
   }
 }

package/src/features/page_view_timing/aggregate/index.component-test.js

@@ -0,0 +1,86 @@
+import { Aggregator } from '../../../common/aggregate/aggregator'
+import { ee } from '../../../common/event-emitter/contextual-ee'
+import { drain } from '../../../common/drain/drain'
+import { setRuntime } from '../../../common/config/config'
+
+jest.mock('web-vitals', () => ({
+  __esModule: true,
+  // eslint-disable-next-line
+  onFID: jest.fn(cb => cb({
+    value: 1234,
+    entries: [{ name: 'pointerdown', startTime: 5 }]
+  })),
+  // eslint-disable-next-line
+  onCLS: jest.fn((cb) => cb({
+    value: 1,
+    entries: [{ value: 1 }]
+  })),
+  // eslint-disable-next-line
+  onFCP: jest.fn((cb) => cb({
+    value: 1,
+    entries: [{ value: 1 }]
+  })),
+  // eslint-disable-next-line
+  onINP: jest.fn((cb) => cb({
+    value: 1,
+    entries: [{ value: 1 }]
+  })),
+  // eslint-disable-next-line
+  onLCP: jest.fn((cb) => cb({
+    value: 1,
+    entries: [{ value: 1 }]
+  }))
+})
+)
+
+let pvtAgg, cumulativeLayoutShift
+describe('pvt aggregate tests', () => {
+  beforeEach(async () => {
+    const { Aggregate } = await import('.')
+    setRuntime('abcd', {})
+    pvtAgg = new Aggregate('abcd', new Aggregator({ agentIdentifier: 'abcd', ee }))
+    pvtAgg.scheduler.harvest.send = jest.fn()
+    pvtAgg.prepareHarvest = jest.fn(() => ({}))
+    drain('abcd', 'feature')
+
+    global.navigator.connection = {
+      type: 'cellular',
+      effectiveType: '3g',
+      rtt: 270,
+      downlink: 700
+    }
+
+    const { cumulativeLayoutShift: cls } = await import('../../../common/vitals/cumulative-layout-shift')
+    cumulativeLayoutShift = cls
+  })
+  test('LCP event with CLS attribute', () => {
+    cumulativeLayoutShift.update({ value: 1 })
+    pvtAgg.addTiming('lcp', 1, { size: 1, startTime: 1 })
+
+    var timing = find(pvtAgg.timings, function (t) {
+      return t.name === 'lcp'
+    })
+
+    expect(timing.attrs.cls).toEqual(1) // 'CLS value should be the one present at the time LCP happened'
+
+    function find (arr, fn) {
+      if (arr.find) {
+        return arr.find(fn)
+      }
+      var match = null
+      arr.forEach(function (t) {
+        if (fn(t)) {
+          match = t
+        }
+      })
+      return match
+    }
+  })
+
+  test('sends expected FI attributes when available', () => {
+    expect(pvtAgg.timings.length).toBeGreaterThanOrEqual(1)
+    const fiPayload = pvtAgg.timings.find(x => x.name === 'fi')
+    expect(fiPayload.value).toEqual(5)
+    expect(fiPayload.attrs).toEqual(expect.objectContaining({ type: 'pointerdown', fid: 1234, cls: 1 }))
+  })
+})

package/src/features/page_view_timing/aggregate/index.js

@@ -3,146 +3,69 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { onFCP, onFID, onLCP, onCLS, onINP } from 'web-vitals'
-import { onFirstPaint } from '../first-paint'
-import { onLongTask } from '../long-tasks'
-import { iOSBelow16 } from '../../../common/constants/runtime'
 import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer'
 import { mapOwn } from '../../../common/util/map-own'
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { registerHandler } from '../../../common/event-emitter/register-handler'
-import { cleanURL } from '../../../common/url/clean-url'
 import { handle } from '../../../common/event-emitter/handle'
-import { getInfo, getConfigurationValue, getRuntime } from '../../../common/config/config'
+import { getInfo, getConfigurationValue } from '../../../common/config/config'
 import { FEATURE_NAME } from '../constants'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { AggregateBase } from '../../utils/aggregate-base'
+import { cumulativeLayoutShift } from '../../../common/vitals/cumulative-layout-shift'
+import { firstContentfulPaint } from '../../../common/vitals/first-contentful-paint'
+import { firstInputDelay } from '../../../common/vitals/first-input-delay'
+import { firstPaint } from '../../../common/vitals/first-paint'
+import { interactionToNextPaint } from '../../../common/vitals/interaction-to-next-paint'
+import { largestContentfulPaint } from '../../../common/vitals/largest-contentful-paint'
+import { timeToFirstByte } from '../../../common/vitals/time-to-first-byte'
+import { longTask } from '../../../common/vitals/long-task'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
+
+  #handleVitalMetric = ({ name, value, attrs }) => {
+    this.addTiming(name, value, attrs)
+  }
+
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)
 
     this.timings = []
     this.timingsSent = []
     this.curSessEndRecorded = false
-    this.cls = null // this should be null unless set to a numeric value by web-vitals so that we differentiate if CLS is supported
-
-    /* ! This is the section that used to be in the loader portion: ! */
-    /* ------------------------------------------------------------ */
-    const pageStartedHidden = getRuntime(agentIdentifier).initHidden // our attempt at recapturing initial vis state since this code runs post-load time
-    this.alreadySent = new Set() // since we don't support timings on BFCache restores, this tracks and helps cap metrics that web-vitals report more than once
-
-    /* PerformancePaintTiming API - BFC is not yet supported. */
-    onFirstPaint(({ name, value }) => {
-      if (pageStartedHidden) return
-      this.addTiming(name.toLowerCase(), Math.floor(value))
-    })
-
-    /* First Contentful Paint - As of WV v3, it still imperfectly tries to detect document vis state asap and isn't supposed to report if page starts hidden. */
-    if (iOSBelow16) {
-      try {
-        if (!pageStartedHidden) { // see ios-version.js for detail on this following bug case; tldr: buffered flag doesn't work but getEntriesByType does
-          const paintEntries = performance.getEntriesByType('paint')
-          paintEntries.forEach(entry => {
-            if (entry.name === 'first-contentful-paint') {
-              this.addTiming('fcp', Math.floor(entry.startTime))
-            }
-          })
-        }
-      } catch (e) {}
-    } else {
-      onFCP(({ name, value }) => {
-        if (pageStartedHidden || this.alreadySent.has(name)) return
-        this.alreadySent.add(name)
-        this.addTiming(name.toLowerCase(), value)
-      })
-    }
-
-    /* First Input Delay (+"First Interaction") - As of WV v3, it still imperfectly tries to detect document vis state asap and isn't supposed to report if page starts hidden. */
-    onFID(({ name, value, entries }) => {
-      if (pageStartedHidden || this.alreadySent.has(name) || entries.length === 0) return
-      this.alreadySent.add(name)
-
-      // CWV will only report one (THE) first-input entry to us; fid isn't reported if there are no user interactions occurs before the *first* page hiding.
-      const fiEntry = entries[0]
-      const attributes = {
-        type: fiEntry.name,
-        fid: Math.round(value)
-      }
-      this.addConnectionAttributes(attributes)
-      this.addTiming('fi', Math.round(fiEntry.startTime), attributes)
-    })
-
-    /* Largest Contentful Paint - As of WV v3, it still imperfectly tries to detect document vis state asap and isn't supposed to report if page starts hidden. */
-    onLCP(({ name, value, entries }) => {
-      if (pageStartedHidden || this.alreadySent.has(name)) return
-      this.alreadySent.add(name)
-
-      const attributes = {}
-      if (entries.length > 0) {
-        // CWV will only ever report one (THE) lcp entry to us; lcp is also only reported *once* on earlier(user interaction, page hidden).
-        const lcpEntry = entries[entries.length - 1] // this looks weird if we only expect one, but this is how cwv-attribution gets it so to be sure...
-        attributes.size = lcpEntry.size
-        attributes.eid = lcpEntry.id
-
-        if (lcpEntry.url) {
-          attributes.elUrl = cleanURL(lcpEntry.url)
-        }
-        if (lcpEntry.element?.tagName) {
-          attributes.elTag = lcpEntry.element.tagName
-        }
-      }
 
-      this.addConnectionAttributes(attributes)
-      this.addTiming(name.toLowerCase(), value, attributes)
+    firstPaint.subscribe(this.#handleVitalMetric)
+    firstContentfulPaint.subscribe(this.#handleVitalMetric)
+    firstInputDelay.subscribe(this.#handleVitalMetric)
+    largestContentfulPaint.subscribe(this.#handleVitalMetric)
+    interactionToNextPaint.subscribe(this.#handleVitalMetric)
+    timeToFirstByte.subscribe(({ entries }) => {
+      this.addTiming('load', Math.round(entries[0].loadEventEnd))
     })
 
-    /* Cumulative Layout Shift - We don't have to limit this callback since cls is stored as a state and only sent as attribute on other timings.
-      reportAllChanges ensures our tracked cls has the most recent rolling value to attach to 'unload' and 'pagehide'. */
-    onCLS(({ value }) => { this.cls = value }, { reportAllChanges: true })
-
-    /* Interaction-to-Next-Paint */
-    onINP(({ name, value, id }) => this.addTiming(name.toLowerCase(), value, { metricId: id }))
-
-    /* PerformanceLongTaskTiming API */
-    if (getConfigurationValue(this.agentIdentifier, 'page_view_timing.long_task') === true) {
-      onLongTask(({ name, value, info }) => this.addTiming(name.toLowerCase(), value, info)) // lt context is passed as 'info'=attrs in the timing node
-    }
-    /* ------------------------------------End of ex-loader section */
+    if (getConfigurationValue(this.agentIdentifier, 'page_view_timing.long_task') === true) longTask.subscribe(this.#handleVitalMetric)
 
     /* It's important that CWV api, like "onLCP", is called before this scheduler is initialized. The reason is because they listen to the same
       on vis change or pagehide events, and we'd want ex. onLCP to record the timing (win the race) before we try to send "final harvest". */
-    this.scheduler = new HarvestScheduler('events', {
-      onFinished: (...args) => this.onHarvestFinished(...args),
-      getPayload: (...args) => this.prepareHarvest(...args)
-    }, this)
 
-    registerHandler('timing', (name, value, attrs) => this.addTiming(name, value, attrs), this.featureName, this.ee) // notice CLS is added to all timings via 4th param
     registerHandler('docHidden', msTimestamp => this.endCurrentSession(msTimestamp), this.featureName, this.ee)
     registerHandler('winPagehide', msTimestamp => this.recordPageUnload(msTimestamp), this.featureName, this.ee)
 
     const initialHarvestSeconds = getConfigurationValue(this.agentIdentifier, 'page_view_timing.initialHarvestSeconds') || 10
     const harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'page_view_timing.harvestTimeSeconds') || 30
     // send initial data sooner, then start regular
-    this.ee.on(`drain-${this.featureName}`, () => { this.scheduler.startTimer(harvestTimeSeconds, initialHarvestSeconds) })
+    this.ee.on(`drain-${this.featureName}`, () => {
+      this.scheduler = new HarvestScheduler('events', {
+        onFinished: (...args) => this.onHarvestFinished(...args),
+        getPayload: (...args) => this.prepareHarvest(...args)
+      }, this)
+      this.scheduler.startTimer(harvestTimeSeconds, initialHarvestSeconds)
+    })
 
     this.drain()
   }
 
-  // takes an attributes object and appends connection attributes if available
-  addConnectionAttributes (attributes) {
-    var connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection // to date, both window & worker shares the same support for connection
-    if (!connection) return
-
-    if (connection.type) attributes['net-type'] = connection.type
-    if (connection.effectiveType) attributes['net-etype'] = connection.effectiveType
-    if (connection.rtt) attributes['net-rtt'] = connection.rtt
-    if (connection.downlink) attributes['net-dlink'] = connection.downlink
-
-    return attributes
-  }
-
   /**
    * Add the time of _document visibilitychange to hidden_ to the next PVT harvest == NRDB pageHide attr.
    * @param {number} timestamp
@@ -179,8 +102,8 @@ export class Aggregate extends AggregateBase {
     Mitigation: We've set initial CLS to null so that it's omitted from timings like 'pageHide' in that edge case. It should only be included if onCLS callback was executed at least once.
     Future: onCLS value changes should be reported directly & CLS separated into its own timing node so it's not beholden to 'pageHide' firing. It'd also be possible to report the real final CLS.
     */
-    if (this.cls !== null) {
-      attrs.cls = this.cls
+    if (cumulativeLayoutShift.current.value >= 0) {
+      attrs.cls = cumulativeLayoutShift.current.value
     }
 
     this.timings.push({

package/src/features/page_view_timing/instrument/index.js

@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { handle } from '../../../common/event-emitter/handle'
-import { getRuntime } from '../../../common/config/config'
 import { subscribeToVisibilityChange } from '../../../common/window/page-visibility'
 import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts'
 import { now } from '../../../common/timing/now'
@@ -17,9 +16,7 @@ export class Instrument extends InstrumentBase {
     super(agentIdentifier, aggregator, FEATURE_NAME, auto)
     if (!isBrowserScope) return // CWV is irrelevant outside web context
 
-    // Document visibility state becomes hidden; this should run as soon as possible in page life.
     // While we try to replicate web-vital's visibilitywatcher logic in an effort to defer that library to post-pageload, this isn't perfect and doesn't consider prerendering.
-    getRuntime(agentIdentifier).initHidden = Boolean(document.visibilityState === 'hidden')
     subscribeToVisibilityChange(() => handle('docHidden', [now()], undefined, FEATURE_NAME, this.ee), true)
 
     // Window fires its pagehide event (typically on navigation--this occurrence is a *subset* of vis change); don't defer this unless it's guarantee it cannot happen before load(?)

package/src/features/session_replay/aggregate/index.component-test.js

@@ -39,7 +39,7 @@ class LocalMemory {
 let sr, session
 const agentIdentifier = 'abcd'
 const info = { licenseKey: 1234, applicationID: 9876 }
-const init = { session_replay: { enabled: true, sampleRate: 1, errorSampleRate: 0 } }
+const init = { session_replay: { enabled: true, sampling_rate: 100, error_sampling_rate: 0 } }
 
 const anyQuery = {
   browser_monitoring_key: info.licenseKey,
@@ -99,14 +99,14 @@ describe('Session Replay', () => {
     })
 
     test('Session SR mode matches SR mode -- ERROR', async () => {
-      setConfiguration(agentIdentifier, { session_replay: { sampleRate: 0, errorSampleRate: 1 } })
+      setConfiguration(agentIdentifier, { session_replay: { sampling_rate: 0, error_sampling_rate: 100 } })
       sr.ee.emit('rumresp-sr', [true])
       await wait(1)
       expect(session.state.sessionReplay).toEqual(sr.mode)
     })
 
     test('Session SR mode matches SR mode -- OFF', async () => {
-      setConfiguration(agentIdentifier, { session_replay: { sampleRate: 0, errorSampleRate: 0 } })
+      setConfiguration(agentIdentifier, { session_replay: { sampling_rate: 0, error_sampling_rate: 0 } })
       sr.ee.emit('rumresp-sr', [true])
       await wait(1)
       expect(session.state.sessionReplay).toEqual(sr.mode)
@@ -149,28 +149,28 @@ describe('Session Replay', () => {
 
   describe('Session Replay Sample -> Mode Behaviors', () => {
     test('New Session -- Full 1 Error 1 === FULL', async () => {
-      setConfiguration(agentIdentifier, { session_replay: { errorSampleRate: 1, sampleRate: 1 } })
+      setConfiguration(agentIdentifier, { session_replay: { error_sampling_rate: 100, sampling_rate: 100 } })
       sr.ee.emit('rumresp-sr', [true])
       await wait(1)
       expect(sr.mode).toEqual(MODE.FULL)
     })
 
     test('New Session -- Full 1 Error 0 === FULL', async () => {
-      setConfiguration(agentIdentifier, { session_replay: { errorSampleRate: 0, sampleRate: 1 } })
+      setConfiguration(agentIdentifier, { session_replay: { error_sampling_rate: 0, sampling_rate: 100 } })
       sr.ee.emit('rumresp-sr', [true])
       await wait(1)
       expect(sr.mode).toEqual(MODE.FULL)
     })
 
     test('New Session -- Full 0 Error 1 === ERROR', async () => {
-      setConfiguration(agentIdentifier, { session_replay: { errorSampleRate: 1, sampleRate: 0 } })
+      setConfiguration(agentIdentifier, { session_replay: { error_sampling_rate: 100, sampling_rate: 0 } })
       sr.ee.emit('rumresp-sr', [true])
       await wait(1)
       expect(sr.mode).toEqual(MODE.ERROR)
     })
 
     test('New Session -- Full 0 Error 0 === OFF', async () => {
-      setConfiguration(agentIdentifier, { session_replay: { errorSampleRate: 0, sampleRate: 0 } })
+      setConfiguration(agentIdentifier, { session_replay: { error_sampling_rate: 0, sampling_rate: 0 } })
       sr.ee.emit('rumresp-sr', [true])
       await wait(1)
       expect(sr.mode).toEqual(MODE.OFF)
@@ -182,7 +182,7 @@ describe('Session Replay', () => {
       expect(session.isNew).toBeFalsy()
       primeSessionAndReplay(session)
       // configure to get "error" sample ---> but should inherit FULL from session manager
-      setConfiguration(agentIdentifier, { session_replay: { errorSampleRate: 1, sampleRate: 0 } })
+      setConfiguration(agentIdentifier, { session_replay: { error_sampling_rate: 100, sampling_rate: 0 } })
       sr.ee.emit('rumresp-sr', [true])
       await wait(1)
       expect(sr.mode).toEqual(MODE.FULL)
@@ -191,7 +191,7 @@ describe('Session Replay', () => {
 
   describe('Session Replay Error Mode Behaviors', () => {
     test('An error BEFORE rrweb import starts running in FULL from beginning', async () => {
-      setConfiguration(agentIdentifier, { session_replay: { errorSampleRate: 1, sampleRate: 0 } })
+      setConfiguration(agentIdentifier, { session_replay: { error_sampling_rate: 100, sampling_rate: 0 } })
       sr.ee.emit('errorAgg')
       sr.ee.emit('rumresp-sr', [true])
       await wait(1)
@@ -200,7 +200,7 @@ describe('Session Replay', () => {
     })
 
     test('An error AFTER rrweb import changes mode and starts harvester', async () => {
-      setConfiguration(agentIdentifier, { session_replay: { errorSampleRate: 1, sampleRate: 0 } })
+      setConfiguration(agentIdentifier, { session_replay: { error_sampling_rate: 100, sampling_rate: 0 } })
       sr.ee.emit('rumresp-sr', [true])
       await wait(1)
       expect(sr.mode).toEqual(MODE.ERROR)