@newrelic/browser-agent 1.234.0 → 1.236.0

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

@@ -11,7 +11,7 @@ import './debug'
 import { InstrumentBase } from '../../utils/instrument-base'
 import { FEATURE_NAME, NR_ERR_PROP } from '../constants'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
-import { globalScope } from '../../../common/util/global-scope'
+import { globalScope } from '../../../common/constants/runtime'
 import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts'
 import { getRuntime } from '../../../common/config/config'
 import { stringify } from '../../../common/util/stringify'
@@ -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/framework-detection.js

@@ -1,4 +1,4 @@
-import { isBrowserScope } from '../../../common/util/global-scope'
+import { isBrowserScope } from '../../../common/constants/runtime'
 
 const FRAMEWORKS = {
   REACT: 'React',

package/src/features/metrics/aggregate/framework-detection.test.js

@@ -1,7 +1,7 @@
 import { faker } from '@faker-js/faker'
 import { getFrameworks } from './framework-detection'
 
-jest.mock('../../../common/util/global-scope', () => ({
+jest.mock('../../../common/constants/runtime', () => ({
   isBrowserScope: true
 }))
 
@@ -13,7 +13,7 @@ test('framework detection should not happen in non-browser scope', async () => {
   global.React = {}
 
   jest.resetModules()
-  jest.doMock('../../../common/util/global-scope', () => ({
+  jest.doMock('../../../common/constants/runtime', () => ({
     isBrowserScope: false
   }))
   const frameworkDetector = await import('./framework-detection')

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

@@ -10,7 +10,7 @@ import { getRules, validateRules } from '../../../common/util/obfuscate'
 import { VERSION } from '../../../common/constants/env'
 import { onDOMContentLoaded } from '../../../common/window/load'
 import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts'
-import { isBrowserScope } from '../../../common/util/global-scope'
+import { isBrowserScope } from '../../../common/constants/runtime'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { stringify } from '../../../common/util/stringify'
 import { endpointMap } from './endpoint-map'

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

@@ -11,7 +11,7 @@ import { cleanURL } from '../../../common/url/clean-url'
 import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config'
 import { FEATURE_NAME } from '../constants'
 import { drain } from '../../../common/drain/drain'
-import { isBrowserScope } from '../../../common/util/global-scope'
+import { isBrowserScope } from '../../../common/constants/runtime'
 import { AggregateBase } from '../../utils/aggregate-base'
 
 export class Aggregate extends AggregateBase {

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

@@ -1,6 +1,6 @@
 import { handle } from '../../../common/event-emitter/handle'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
-import { isiOS } from '../../../common/browser-version/ios-version'
+import { isiOS, globalScope, isBrowserScope } from '../../../common/constants/runtime'
 import { onTTFB } from 'web-vitals'
 import { addPT, addPN } from '../../../common/timing/nav-timing'
 import { stringify } from '../../../common/util/stringify'
@@ -9,7 +9,6 @@ import { getConfigurationValue, getInfo, getRuntime } from '../../../common/conf
 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'

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

@@ -1,5 +1,5 @@
 import { handle } from '../../../common/event-emitter/handle'
-import { isiOS } from '../../../common/browser-version/ios-version'
+import { isiOS } from '../../../common/constants/runtime'
 import { InstrumentBase } from '../../utils/instrument-base'
 import * as CONSTANTS from '../constants'
 import { FEATURE_NAMES } from '../../../loaders/features/features'

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

@@ -6,7 +6,7 @@
 import { onFCP, onFID, onLCP, onCLS, onINP } from 'web-vitals'
 import { onFirstPaint } from '../first-paint'
 import { onLongTask } from '../long-tasks'
-import { iOS_below16 } from '../../../common/browser-version/ios-version'
+import { iOS_below16 } 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'
@@ -195,9 +195,7 @@ export class Aggregate extends AggregateBase {
 
   onHarvestFinished (result) {
     if (result.retry && this.timingsSent.length > 0) {
-      for (var i = 0; i < this.timingsSent.length; i++) {
-        this.timings.push(this.timingsSent[i])
-      }
+      this.timings.unshift(...this.timingsSent)
       this.timingsSent = []
     }
   }

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

@@ -9,7 +9,7 @@ import { windowAddEventListener } from '../../../common/event-listener/event-lis
 import { now } from '../../../common/timing/now'
 import { InstrumentBase } from '../../utils/instrument-base'
 import { FEATURE_NAME } from '../constants'
-import { isBrowserScope } from '../../../common/util/global-scope'
+import { isBrowserScope } from '../../../common/constants/runtime'
 
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME

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({}))
+}