@newrelic/browser-agent 1.233.1 → 1.235.0

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

@@ -32,6 +32,7 @@ export class Aggregate extends AggregateBase {
     super(agentIdentifier, aggregator, FEATURE_NAME)
 
     this.stackReported = {}
+    this.observedAt = {}
     this.pageviewReported = {}
     this.errorCache = {}
     this.currentBody
@@ -171,6 +172,7 @@ export class Aggregate extends AggregateBase {
     if (!this.stackReported[bucketHash]) {
       this.stackReported[bucketHash] = true
       params.stack_trace = truncateSize(stackInfo.stackString)
+      this.observedAt[bucketHash] = agentRuntime.offset + time
     } else {
       params.browser_stack_hash = stringHashCode(stackInfo.stackString)
     }
@@ -186,6 +188,9 @@ export class Aggregate extends AggregateBase {
       this.pageviewReported[bucketHash] = true
     }
 
+    if (agentRuntime?.session?.state?.sessionReplay) params.hasReplay = true
+    params.firstOccurrenceTimestamp = this.observedAt[bucketHash]
+
     var type = internal ? 'ierr' : 'err'
     var newMetrics = { time: time }
 

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

@@ -38,7 +38,7 @@ export class Instrument extends InstrumentBase {
           return true
         })
         this.thrown = true
-        notice(err, undefined, thisInstrument.ee)
+        handle('err', [err, now()], undefined, FEATURE_NAMES.jserrors, thisInstrument.ee)
       }
     })
     thisInstrument.ee.on('fn-end', function () {
@@ -89,7 +89,7 @@ export class Instrument extends InstrumentBase {
 
     try {
       if (this.skipNext) this.skipNext -= 1
-      else notice(errorObj || new UncaughtException(message, filename, lineno), true, this.ee)
+      else handle('err', [errorObj || new UncaughtException(message, filename, lineno), now()], undefined, FEATURE_NAMES.jserrors, this.ee)
     } catch (e) {
       try {
         handle('ierr', [e, now(), true], undefined, FEATURE_NAMES.jserrors, this.ee)
@@ -113,19 +113,6 @@ function UncaughtException (message, filename, lineno) {
   this.line = lineno
 }
 
-/**
- * Adds a timestamp and emits the 'err' event, which the error aggregator listens for
- * @param {Error} err
- * @param {boolean} doNotStamp
- * @param {ContextualEE} ee
- */
-function notice (err, doNotStamp, ee) {
-  // by default add timestamp, unless specifically told not to
-  // this is to preserve existing behavior
-  var time = (!doNotStamp) ? now() : null
-  handle('err', [err, time], undefined, FEATURE_NAMES.jserrors, ee)
-}
-
 /**
  * Attempts to cast an unhandledPromiseRejection reason (reject(...)) to an Error object
  * @param {*} reason - The reason property from an unhandled promise rejection

package/src/features/metrics/aggregate/endpoint-map.js

@@ -0,0 +1,7 @@
+export const endpointMap = {
+  rum: '1',
+  events: 'Events',
+  ins: 'Ins',
+  jserrors: 'Jserrors',
+  resources: 'Resources'
+}

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

@@ -13,6 +13,7 @@ import { windowAddEventListener } from '../../../common/event-listener/event-lis
 import { isBrowserScope } from '../../../common/util/global-scope'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { stringify } from '../../../common/util/stringify'
+import { endpointMap } from './endpoint-map'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
@@ -125,7 +126,7 @@ export class Aggregate extends AggregateBase {
       // Capture per-agent bytes sent for each endpoint (see harvest) and RUM call (see page_view_event aggregator).
       Object.keys(agentRuntime.bytesSent).forEach(endpoint => {
         this.storeSupportabilityMetrics(
-          `PageSession/Endpoint/${endpoint.charAt(0).toUpperCase() + endpoint.slice(1)}/BytesSent`,
+          `PageSession/Endpoint/${endpointMap[endpoint]}/BytesSent`,
           agentRuntime.bytesSent[endpoint]
         )
       })
@@ -133,7 +134,7 @@ export class Aggregate extends AggregateBase {
       // Capture per-agent query bytes sent for each endpoint (see harvest) and RUM call (see page_view_event aggregator).
       Object.keys(agentRuntime.bytesSent).forEach(endpoint => {
         this.storeSupportabilityMetrics(
-          `PageSession/Endpoint/${endpoint.charAt(0).toUpperCase() + endpoint.slice(1)}/QueryBytesSent`,
+          `PageSession/Endpoint/${endpointMap[endpoint]}/QueryBytesSent`,
           agentRuntime.queryBytesSent[endpoint]
         )
       })

package/src/features/metrics/aggregate/polyfill-detection.es5.js

@@ -1,4 +1,3 @@
-
 /**
  * This file is used as a replacement for the polyfill-detection.es5.js
  * file when running the polyfills webpack build.

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

@@ -1,5 +1,4 @@
 import { InstrumentBase } from '../../utils/instrument-base'
-import { insertSupportMetrics } from './workers-helper'
 import { FEATURE_NAME, SUPPORTABILITY_METRIC_CHANNEL } from '../constants'
 import { handle } from '../../../common/event-emitter/handle'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
@@ -8,7 +7,6 @@ export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, FEATURE_NAME, auto)
-    insertSupportMetrics(tag => handle(SUPPORTABILITY_METRIC_CHANNEL, [tag], undefined, FEATURE_NAMES.metrics, this.ee))
     this.importAggregator()
   }
 }

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

@@ -2,22 +2,19 @@ import { handle } from '../../../common/event-emitter/handle'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { isiOS } from '../../../common/browser-version/ios-version'
 import { onTTFB } from 'web-vitals'
-import { mapOwn } from '../../../common/util/map-own'
-import { param, fromArray } from '../../../common/url/encode'
 import { addPT, addPN } from '../../../common/timing/nav-timing'
 import { stringify } from '../../../common/util/stringify'
 import { paintMetrics } from '../../../common/metrics/paint-metrics'
-import { submitData } from '../../../common/util/submit-data'
 import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config'
-import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
+import { Harvest } from '../../../common/harvest/harvest'
 import * as CONSTANTS from '../constants'
 import { getActivatedFeaturesFlags } from './initialized-features'
 import { globalScope, isBrowserScope } from '../../../common/util/global-scope'
 import { drain } from '../../../common/drain/drain'
+import { activateFeatures } from '../../../common/util/feature-flags'
+import { warn } from '../../../common/util/console'
 import { AggregateBase } from '../../utils/aggregate-base'
 
-const jsonp = 'NREUM.setToken'
-
 export class Aggregate extends AggregateBase {
   static featureName = CONSTANTS.FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
@@ -55,10 +52,12 @@ export class Aggregate extends AggregateBase {
 
   sendRum () {
     const info = getInfo(this.agentIdentifier)
+    const agentRuntime = getRuntime(this.agentIdentifier)
+    const harvester = new Harvest(this)
+
     if (!info.beacon) return
     if (info.queueTime) this.aggregator.store('measures', 'qt', { value: info.queueTime })
     if (info.applicationTime) this.aggregator.store('measures', 'ap', { value: info.applicationTime })
-    const agentRuntime = getRuntime(this.agentIdentifier)
 
     // 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
@@ -67,27 +66,27 @@ export class Aggregate extends AggregateBase {
     this.aggregator.store('measures', 'fe', { value: isBrowserScope ? agentRuntime[CONSTANTS.FBTWL] : 0 })
     this.aggregator.store('measures', 'dc', { value: isBrowserScope ? agentRuntime[CONSTANTS.FBTDC] : 0 })
 
-    var measuresMetrics = this.aggregator.get('measures')
-
-    var measuresQueryString = mapOwn(measuresMetrics, function (metricName, measure) {
-      return '&' + metricName + '=' + measure.params.value
-    }).join('')
-
-    // currently we only have one version of our protocol
-    // in the future we may add more
-    var protocol = '1'
-
-    var scheduler = new HarvestScheduler('page_view_event', {}, this)
-
-    var chunksForQueryString = [scheduler.harvest.baseQueryString()]
-
-    chunksForQueryString.push(measuresQueryString)
+    const queryParameters = {
+      tt: info.ttGuid,
+      us: info.user,
+      ac: info.account,
+      pr: info.product,
+      af: getActivatedFeaturesFlags(this.agentIdentifier).join(','),
+      ...(
+        Object.entries(this.aggregator.get('measures') || {}).reduce((aggregator, [metricName, measure]) => {
+          aggregator[metricName] = measure.params?.value
+          return aggregator
+        }, {})
+      ),
+      xx: info.extra,
+      ua: info.userAttributes,
+      at: info.atts
+    }
 
-    chunksForQueryString.push(param('tt', info.ttGuid))
-    chunksForQueryString.push(param('us', info.user))
-    chunksForQueryString.push(param('ac', info.account))
-    chunksForQueryString.push(param('pr', info.product))
-    chunksForQueryString.push(param('af', getActivatedFeaturesFlags(this.agentIdentifier).join(',')))
+    let body
+    if (typeof info.jsAttributes === 'object' && Object.keys(info.jsAttributes).length > 0) {
+      body = { ja: info.jsAttributes }
+    }
 
     if (globalScope.performance) {
       if (typeof PerformanceNavigationTiming !== 'undefined') { // Navigation Timing level 2 API that replaced PerformanceTiming & PerformanceNavigation
@@ -96,13 +95,13 @@ export class Aggregate extends AggregateBase {
           timing: addPT(agentRuntime.offset, navTimingEntry, {}),
           navigation: addPN(navTimingEntry, {})
         })
-        chunksForQueryString.push(param('perf', stringify(perf)))
+        queryParameters.perf = stringify(perf)
       } else if (typeof PerformanceTiming !== 'undefined') { // Safari pre-15 did not support level 2 timing
         const perf = ({
           timing: addPT(agentRuntime.offset, globalScope.performance.timing, {}, true),
           navigation: addPN(globalScope.performance.navigation, {})
         })
-        chunksForQueryString.push(param('perf', stringify(perf)))
+        queryParameters.perf = stringify(perf)
       }
     }
 
@@ -112,35 +111,33 @@ export class Aggregate extends AggregateBase {
         if (!entry.startTime || entry.startTime <= 0) return
 
         if (entry.name === 'first-paint') {
-          chunksForQueryString.push(param('fp', String(Math.floor(entry.startTime))))
+          queryParameters.fp = String(Math.floor(entry.startTime))
         } else if (entry.name === 'first-contentful-paint') {
-          chunksForQueryString.push(param('fcp', String(Math.floor(entry.startTime))))
+          queryParameters.fcp = String(Math.floor(entry.startTime))
         }
         paintMetrics[entry.name] = Math.floor(entry.startTime) // this is consumed by Spa module
       })
     } catch (e) {}
 
-    chunksForQueryString.push(param('xx', info.extra))
-    chunksForQueryString.push(param('ua', info.userAttributes))
-    chunksForQueryString.push(param('at', info.atts))
-
-    var customJsAttributes = stringify(info.jsAttributes)
-    chunksForQueryString.push(param('ja', customJsAttributes === '{}' ? null : customJsAttributes))
-
-    var queryString = fromArray(chunksForQueryString, agentRuntime.maxBytes)
-
-    // Capture bytes sent to RUM call endpoint (currently `1`) as a supportability metric. See metrics aggregator (on unload).
-    agentRuntime.bytesSent[protocol] = 0 // Set to zero for now until RUM is moved to POST
-
-    // Capture query bytes sent to RUM call endpoint (currently `1`) as a supportability metric. See metrics aggregator (on unload).
-    agentRuntime.queryBytesSent[protocol] = (agentRuntime.queryBytesSent[protocol] || 0) + queryString?.length || 0
+    harvester.send({
+      endpoint: 'rum',
+      payload: { qs: queryParameters, body },
+      opts: { needResponse: true, sendEmptyBody: true },
+      cbFinished: ({ status, responseText }) => {
+        if (status >= 400) {
+          // Adding retry logic for the rum call will be a separate change
+          this.ee.abort()
+          return
+        }
 
-    const isValidJsonp = submitData.jsonp({
-      url: this.getScheme() + '://' + info.beacon + '/' + protocol + '/' + info.licenseKey + '?' + queryString,
-      jsonp
+        try {
+          activateFeatures(JSON.parse(responseText), this.agentIdentifier)
+          drain(this.agentIdentifier, this.featureName)
+        } catch (err) {
+          this.ee.abort()
+          warn('RUM call failed. Agent shutting down.')
+        }
+      }
     })
-    // Usually `drain` is invoked automatically after processing feature flags contained in the JSONP callback from
-    // ingest (see `activateFeatures`), so when JSONP cannot execute (as with module workers), we drain manually.
-    if (!isValidJsonp) drain(this.agentIdentifier, CONSTANTS.FEATURE_NAME)
   }
 }

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

@@ -1,4 +1,3 @@
-
 import { handle } from '../../../common/event-emitter/handle'
 import { isiOS } from '../../../common/browser-version/ios-version'
 import { InstrumentBase } from '../../utils/instrument-base'

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

@@ -0,0 +1,368 @@
+import { Aggregate as SessionReplayAgg, AVG_COMPRESSION, MAX_PAYLOAD_SIZE, IDEAL_PAYLOAD_SIZE } from '.'
+import { Aggregator } from '../../../common/aggregate/aggregator'
+import { SESSION_EVENTS, SessionEntity, MODE } from '../../../common/session/session-entity'
+import { setConfiguration } from '../../../common/config/config'
+import { configure } from '../../../loaders/configure/configure'
+
+class LocalMemory {
+  constructor (initialState = {}) {
+    this.state = initialState
+  }
+
+  get (key) {
+    try {
+      return this.state[key]
+    } catch (err) {
+      return ''
+    }
+  }
+
+  set (key, value) {
+    try {
+      if (value === undefined || value === null) return this.remove(key)
+      this.state[key] = value
+    } catch (err) {
+      return
+    }
+  }
+
+  remove (key) {
+    try {
+      delete this.state[key]
+    } catch (err) {
+      return
+    }
+  }
+}
+
+let sr, session
+const agentIdentifier = 'abcd'
+const info = { licenseKey: 1234, applicationID: 9876 }
+const init = { session_replay: { enabled: true, sampleRate: 1, errorSampleRate: 0 } }
+
+describe('Session Replay', () => {
+  beforeEach(async () => {
+    primeSessionAndReplay()
+  })
+  afterEach(async () => {
+    sr.abort()
+    jest.clearAllMocks()
+  })
+
+  describe('Session Replay Session Behavior', () => {
+    test('When Session Ends', async () => {
+      const xhrMockClass = () => ({
+        open: jest.fn(),
+        send: jest.fn(),
+        setRequestHeader: jest.fn(),
+        addEventListener: jest.fn()
+      })
+      global.XMLHttpRequest = jest.fn().mockImplementation(xhrMockClass)
+
+      setConfiguration(agentIdentifier, { ...init })
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      expect(sr.initialized).toBeTruthy()
+      expect(sr.recording).toBeTruthy()
+      sr.ee.emit(SESSION_EVENTS.RESET)
+      expect(global.XMLHttpRequest).toHaveBeenCalled()
+      expect(sr.recording).toBeFalsy()
+      expect(sr.blocked).toBeTruthy()
+    })
+
+    test('When Session Is Paused/Resumed', async () => {
+      setConfiguration(agentIdentifier, { ...init })
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      expect(sr.initialized).toBeTruthy()
+      expect(sr.recording).toBeTruthy()
+      sr.ee.emit(SESSION_EVENTS.PAUSE)
+      expect(sr.recording).toBeFalsy()
+      sr.ee.emit(SESSION_EVENTS.RESUME)
+      expect(sr.recording).toBeTruthy()
+    })
+
+    test('Session SR mode matches SR mode -- FULL', async () => {
+      setConfiguration(agentIdentifier, { ...init })
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      expect(session.state.sessionReplay).toEqual(sr.mode)
+    })
+
+    test('Session SR mode matches SR mode -- ERROR', async () => {
+      setConfiguration(agentIdentifier, { session_replay: { sampleRate: 0, errorSampleRate: 1 } })
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      expect(session.state.sessionReplay).toEqual(sr.mode)
+      return
+    })
+
+    test('Session SR mode matches SR mode -- OFF', async () => {
+      setConfiguration(agentIdentifier, { session_replay: { sampleRate: 0, errorSampleRate: 0 } })
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      expect(session.state.sessionReplay).toEqual(sr.mode)
+      return
+    })
+  })
+
+  describe('Session Replay Initialization Behavior', () => {
+    test('Waits for SR', async () => {
+      setConfiguration(agentIdentifier, { ...init })
+      // do not emit sr flag
+      await wait(1000)
+      expect(sr.initialized).toEqual(false)
+      expect(sr.recording).toEqual(false)
+
+      // emit a false flag
+      sr.ee.emit('rumresp-sr', [false])
+      await wait(1)
+      expect(sr.initialized).toEqual(true)
+      expect(sr.recording).toEqual(false)
+      return
+    })
+
+    test('Does not run if cookies_enabled is false', async () => {
+      setConfiguration(agentIdentifier, { ...init, privacy: { cookies_enabled: false } })
+      sr = new SessionReplayAgg(agentIdentifier, new Aggregator({}))
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      expect(sr.initialized).toEqual(false)
+      expect(sr.recording).toEqual(false)
+      return
+    })
+
+    test('Does not run if session_trace is disabled', async () => {
+      setConfiguration(agentIdentifier, { ...init, session_trace: { enabled: false } })
+      sr = new SessionReplayAgg(agentIdentifier, new Aggregator({}))
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      expect(sr.initialized).toEqual(false)
+      expect(sr.recording).toEqual(false)
+      return
+    })
+  })
+
+  describe('Session Replay Sample -> Mode Behaviors', () => {
+    test('New Session -- Full 1 Error 1 === FULL', async () => {
+      setConfiguration(agentIdentifier, { session_replay: { errorSampleRate: 1, sampleRate: 1 } })
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      expect(sr.mode).toEqual(MODE.FULL)
+      return
+    })
+
+    test('New Session -- Full 1 Error 0 === FULL', async () => {
+      setConfiguration(agentIdentifier, { session_replay: { errorSampleRate: 0, sampleRate: 1 } })
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      expect(sr.mode).toEqual(MODE.FULL)
+      return
+    })
+
+    test('New Session -- Full 0 Error 1 === ERROR', async () => {
+      setConfiguration(agentIdentifier, { session_replay: { errorSampleRate: 1, sampleRate: 0 } })
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      expect(sr.mode).toEqual(MODE.ERROR)
+      return
+    })
+
+    test('New Session -- Full 0 Error 0 === OFF', async () => {
+      setConfiguration(agentIdentifier, { session_replay: { errorSampleRate: 0, sampleRate: 0 } })
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      expect(sr.mode).toEqual(MODE.OFF)
+      return
+    })
+
+    test('Existing Session -- Should inherit mode from session entity and ignore samples', async () => {
+      const storage = new LocalMemory({ NRBA_SESSION: { value: 'abcdefghijklmnop', expiresAt: Date.now() + 10000, inactiveAt: Date.now() + 10000, updatedAt: Date.now(), sessionReplay: MODE.FULL, sessionTraceMode: MODE.FULL, custom: {} } })
+      session = new SessionEntity({ agentIdentifier, key: 'SESSION', storage })
+      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 } })
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      expect(sr.mode).toEqual(MODE.FULL)
+      return
+    })
+  })
+
+  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 } })
+      sr.ee.emit('errorAgg')
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      expect(sr.mode).toEqual(MODE.FULL)
+      expect(sr.scheduler.started).toEqual(true)
+      return
+    })
+
+    test('An error AFTER rrweb import changes mode and starts harvester', async () => {
+      setConfiguration(agentIdentifier, { session_replay: { errorSampleRate: 1, sampleRate: 0 } })
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      expect(sr.mode).toEqual(MODE.ERROR)
+      expect(sr.scheduler.started).toEqual(false)
+      sr.ee.emit('errorAgg')
+      expect(sr.mode).toEqual(MODE.FULL)
+      expect(sr.scheduler.started).toEqual(true)
+      return
+    })
+  })
+
+  describe('Session Replay Payload Validation', () => {
+    test('Payload', async () => {
+      setConfiguration(agentIdentifier, { ...init })
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      const harvestContents = sr.getHarvestContents()
+      // query attrs
+      expect(harvestContents.qs).toMatchObject({
+        protocol_version: '0',
+        content_encoding: 'gzip',
+        browser_monitoring_key: info.licenseKey
+      })
+
+      expect(harvestContents.body).toMatchObject({
+        type: 'SessionReplay',
+        appId: info.applicationID,
+        timestamp: expect.any(Number),
+        blob: expect.any(String),
+        attributes: {
+          session: session.state.value,
+          hasSnapshot: expect.any(Boolean),
+          hasError: expect.any(Boolean),
+          agentVersion: expect.any(String),
+          isFirstChunk: expect.any(Boolean),
+          'nr.rrweb.version': expect.any(String)
+        }
+      })
+
+      expect(JSON.parse(harvestContents.body.blob).length).toBeGreaterThan(0)
+    })
+  })
+
+  describe('Session Replay Harvest Behaviors', () => {
+    test('Compressed payload is provided to harvester', async () => {
+      const { gunzipSync, strFromU8 } = await import('fflate')
+      setConfiguration(agentIdentifier, { ...init })
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      const [harvestContents] = sr.prepareHarvest()
+      expect(harvestContents.qs).toMatchObject({
+        protocol_version: '0',
+        content_encoding: 'gzip',
+        browser_monitoring_key: info.licenseKey
+      })
+      expect(harvestContents.body).toEqual(expect.any(Uint8Array))
+      expect(JSON.parse(strFromU8(gunzipSync(harvestContents.body)))).toMatchObject({
+        type: 'SessionReplay',
+        appId: info.applicationID,
+        timestamp: expect.any(Number),
+        blob: expect.any(String),
+        attributes: {
+          session: session.state.value,
+          hasSnapshot: expect.any(Boolean),
+          hasError: expect.any(Boolean),
+          agentVersion: expect.any(String),
+          isFirstChunk: expect.any(Boolean),
+          'nr.rrweb.version': expect.any(String)
+        }
+      })
+    })
+
+    test('Uncompressed payload is provided to harvester', async () => {
+      jest.doMock('fflate', () => ({
+        __esModule: true,
+        gzipSync: jest.fn().mockImplementation(() => { throw new Error() })
+      }))
+
+      setConfiguration(agentIdentifier, { ...init })
+      sr.shouldCompress = false
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+
+      const [harvestContents] = sr.prepareHarvest()
+      expect(harvestContents.qs).toMatchObject({
+        protocol_version: '0',
+        // content_encoding is omitted when the payload is not compressed
+        browser_monitoring_key: info.licenseKey
+      })
+      expect(harvestContents.qs.content_encoding).toBeUndefined()
+      expect(harvestContents.body).toMatchObject({
+        type: 'SessionReplay',
+        appId: info.applicationID,
+        timestamp: expect.any(Number),
+        blob: expect.any(String),
+        attributes: {
+          session: session.state.value,
+          hasSnapshot: expect.any(Boolean),
+          hasError: expect.any(Boolean),
+          agentVersion: expect.any(String),
+          isFirstChunk: expect.any(Boolean),
+          'nr.rrweb.version': expect.any(String)
+        }
+      })
+    })
+
+    test('Clears the event buffer when staged for harvesting', async () => {
+      setConfiguration(agentIdentifier, { ...init })
+      sr.shouldCompress = false
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+
+      sr.prepareHarvest()
+      expect(sr.events.length).toEqual(0)
+    })
+
+    test('Harvests early if exceeds limit', async () => {
+      let after = 0
+      const spy = jest.spyOn(sr.scheduler, 'runHarvest').mockImplementation(() => { after = Date.now() })
+      setConfiguration(agentIdentifier, { ...init })
+      sr.payloadBytesEstimation = IDEAL_PAYLOAD_SIZE / AVG_COMPRESSION
+      const before = Date.now()
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      expect(spy).toHaveBeenCalled()
+      expect(after - before).toBeLessThan(sr.harvestTimeSeconds * 1000)
+    })
+
+    test('Aborts if exceeds total limit', async () => {
+      const spy = jest.spyOn(sr.scheduler, 'runHarvest')
+      setConfiguration(agentIdentifier, { ...init })
+      sr.payloadBytesEstimation = (MAX_PAYLOAD_SIZE + 1) / AVG_COMPRESSION
+      const before = Date.now()
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      expect(spy).not.toHaveBeenCalled()
+      expect(sr.blocked).toEqual(true)
+      expect(sr.mode).toEqual(MODE.OFF)
+    })
+
+    test('Aborts if 429 response', async () => {
+      setConfiguration(agentIdentifier, { ...init })
+      sr.ee.emit('rumresp-sr', [true])
+      await wait(1)
+      expect(sr.mode).toEqual(MODE.FULL)
+      sr.onHarvestFinished({ status: 429 })
+      expect(sr.blocked).toEqual(true)
+      expect(sr.mode).toEqual(MODE.OFF)
+    })
+  })
+})
+
+function wait (ms = 0) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms)
+  })
+}
+
+function primeSessionAndReplay (sess = new SessionEntity({ agentIdentifier, key: 'SESSION', storage: new LocalMemory() })) {
+  session = sess
+  configure(agentIdentifier, { info, runtime: { session } }, 'test', true)
+  sr = new SessionReplayAgg(agentIdentifier, new Aggregator({}))
+}