@newrelic/browser-agent 0.1.230 → 1.232.0

package/src/common/event-emitter/contextual-ee.test.js

@@ -0,0 +1,310 @@
+import { faker } from '@faker-js/faker'
+
+let mockNREUM
+let runtime
+
+beforeEach(() => {
+  mockNREUM = {}
+  runtime = {}
+
+  jest.doMock('../window/nreum', () => ({
+    __esModule: true,
+    gosNREUM: jest.fn(() => mockNREUM)
+  }))
+
+  jest.doMock('../config/config', () => ({
+    __esModule: true,
+    getRuntime: jest.fn(() => runtime)
+  }))
+})
+
+afterEach(() => {
+  jest.resetModules()
+  jest.resetAllMocks()
+})
+
+describe('global event-emitter', () => {
+  test('it returns the event-emitter defined on window.NREUM', async () => {
+    const mockEE = {}
+    mockNREUM.ee = mockEE
+
+    const { ee } = await import('./contextual-ee')
+
+    expect(ee).toEqual(mockEE)
+  })
+
+  test('it sets the global event-emitter on window.NREUM', async () => {
+    const { ee } = await import('./contextual-ee')
+
+    expect(ee).toEqual(mockNREUM.ee)
+  })
+})
+
+describe('scoping event-emitter', () => {
+  test('it creates a new child event-emitter', async () => {
+    const { ee } = await import('./contextual-ee')
+
+    const childName = faker.datatype.uuid()
+    const result = ee.get(childName)
+
+    expect(result).not.toEqual(mockNREUM.ee)
+    expect(result).toEqual(ee.get(childName)) // Should always return the same event-emitter
+    expect(result.debugId).toEqual(childName)
+  })
+
+  test('it creates a child event-emitter with an isolated backlog', async () => {
+    const childName = faker.random.alphaNumeric(16)
+
+    jest.doMock('../config/config', () => ({
+      __esModule: true,
+      getRuntime: jest.fn(id => {
+        if (id === childName) {
+          return { isolatedBacklog: true }
+        }
+
+        return runtime
+      })
+    }))
+
+    const { ee } = await import('./contextual-ee')
+    const result = ee.get(childName)
+
+    expect(ee.backlog).not.toBe(result.backlog)
+  })
+})
+
+describe('event-emitter context', () => {
+  test('it returns a new context', async () => {
+    const { ee } = await import('./contextual-ee')
+
+    const result = ee.context()
+
+    expect(result).toEqual({})
+  })
+
+  test('it returns the same context', async () => {
+    const { ee } = await import('./contextual-ee')
+
+    const result = ee.context()
+
+    expect(result).toEqual(ee.context(result))
+  })
+
+  test('it adds the context to the provided object', async () => {
+    const { ee } = await import('./contextual-ee')
+
+    const obj = {}
+    const result = ee.context(obj)
+
+    expect(result).toEqual(obj['nr@context'])
+  })
+})
+
+describe('event-emitter buffer', () => {
+  it('it should create a new buffer for the given group', async () => {
+    const { ee } = await import('./contextual-ee')
+    const eventType = faker.datatype.uuid()
+    const group = faker.datatype.uuid()
+
+    ee.buffer([eventType], group)
+
+    expect(ee.backlog).toEqual(expect.objectContaining({
+      [group]: []
+    }))
+    expect(ee.isBuffering(eventType)).toEqual(true)
+  })
+
+  it('it should default group to "feature"', async () => {
+    const { ee } = await import('./contextual-ee')
+    const eventType = faker.datatype.uuid()
+
+    ee.buffer([eventType])
+
+    expect(ee.backlog).toEqual(expect.objectContaining({
+      feature: []
+    }))
+    expect(ee.isBuffering(eventType)).toEqual(true)
+  })
+
+  it('it should not create buffer if event-emitter is aborted', async () => {
+    const { ee } = await import('./contextual-ee')
+    const eventType = faker.datatype.uuid()
+    const group = faker.datatype.uuid()
+
+    ee.backlog = {
+      api: ['foo', 'bar', 'baz']
+    }
+    ee.abort()
+    ee.buffer([eventType], group)
+
+    expect(ee.backlog).toEqual({})
+    expect(ee.isBuffering(eventType)).toEqual(false)
+  })
+})
+
+describe('event-emitter abort', () => {
+  test('it aborts if there is an API backlog', async () => {
+    const { ee } = await import('./contextual-ee')
+
+    ee.backlog = {
+      api: ['foo', 'bar', 'baz']
+    }
+    ee.abort()
+
+    expect(ee.aborted).toEqual(true)
+    expect(ee.backlog).toEqual({})
+  })
+
+  test('it aborts if there is a feature backlog', async () => {
+    const { ee } = await import('./contextual-ee')
+
+    ee.backlog = {
+      feature: ['foo', 'bar', 'baz']
+    }
+    ee.abort()
+
+    expect(ee.aborted).toEqual(true)
+    expect(ee.backlog).toEqual({})
+  })
+})
+
+describe('event-emitter emit', () => {
+  it('should execute the listener', async () => {
+    const { ee } = await import('./contextual-ee')
+    const mockListener = jest.fn()
+    const eventType = faker.datatype.uuid()
+    const eventArgs = ['a', 'b', 'c']
+
+    ee.on(eventType, mockListener)
+    ee.emit(eventType, eventArgs)
+
+    expect(mockListener).toHaveBeenCalledWith(eventArgs[0], eventArgs[1], eventArgs[2])
+  })
+
+  it('should not execute the listener after removal', async () => {
+    const { ee } = await import('./contextual-ee')
+    const mockListener = jest.fn()
+    const eventType = faker.datatype.uuid()
+    const eventArgs = ['a', 'b', 'c']
+
+    ee.on(eventType, mockListener)
+    ee.emit(eventType, eventArgs)
+    ee.removeEventListener(eventType, mockListener)
+    ee.emit(eventType, eventArgs)
+
+    expect(mockListener).toHaveBeenCalledTimes(1)
+  })
+
+  it('should return early if global event-emitter is aborted', async () => {
+    const { ee } = await import('./contextual-ee')
+    const mockListener = jest.fn()
+    const eventType = faker.datatype.uuid()
+    const eventArgs = ['a', 'b', 'c']
+
+    ee.backlog = {
+      api: ['foo', 'bar', 'baz']
+    }
+    ee.abort()
+    ee.on(eventType, mockListener)
+    ee.emit(eventType, eventArgs)
+
+    expect(mockListener).toHaveBeenCalledTimes(0)
+  })
+
+  it('should still emit if global event-emitter is aborted but force flag is true', async () => {
+    const { ee } = await import('./contextual-ee')
+    const scopeEE = ee.get(faker.datatype.uuid())
+    const mockScopeListener = jest.fn()
+    const eventType = faker.datatype.uuid()
+    const eventArgs = ['a', 'b', 'c']
+
+    ee.backlog = {
+      api: ['foo', 'bar', 'baz']
+    }
+    ee.abort()
+    scopeEE.on(eventType, mockScopeListener)
+    scopeEE.emit(eventType, eventArgs, {}, true)
+
+    expect(mockScopeListener).toHaveBeenCalledTimes(1)
+  })
+
+  it('should bubble the event if bubble flag is true', async () => {
+    const { ee } = await import('./contextual-ee')
+    const scopeEE = ee.get(faker.datatype.uuid())
+    const mockListener = jest.fn()
+    const mockScopeListener = jest.fn()
+    const eventType = faker.datatype.uuid()
+    const eventArgs = ['a', 'b', 'c']
+
+    ee.on(eventType, mockListener)
+    scopeEE.on(eventType, mockScopeListener)
+    scopeEE.emit(eventType, eventArgs, {}, false, true)
+
+    expect(mockScopeListener).toHaveBeenCalledTimes(1)
+    expect(mockListener).toHaveBeenCalledTimes(1)
+  })
+
+  it('should not bubble the event if bubble flag is false', async () => {
+    const { ee } = await import('./contextual-ee')
+    const scopeEE = ee.get(faker.datatype.uuid())
+    const mockListener = jest.fn()
+    const mockScopeListener = jest.fn()
+    const eventType = faker.datatype.uuid()
+    const eventArgs = ['a', 'b', 'c']
+
+    ee.on(eventType, mockListener)
+    scopeEE.on(eventType, mockScopeListener)
+    scopeEE.emit(eventType, eventArgs, {}, false, false)
+
+    expect(mockScopeListener).toHaveBeenCalledTimes(1)
+    expect(mockListener).not.toHaveBeenCalled()
+  })
+
+  it('should buffer the event on the scoped event-emitter', async () => {
+    const { ee } = await import('./contextual-ee')
+    const scopeEE = ee.get(faker.datatype.uuid())
+    const mockListener = jest.fn()
+    const mockScopeListener = jest.fn()
+    const eventType = faker.datatype.uuid()
+    const eventArgs = ['a', 'b', 'c']
+
+    ee.on(eventType, mockListener)
+    ee.buffer([eventType])
+    scopeEE.on(eventType, mockScopeListener)
+    scopeEE.buffer([eventType])
+    scopeEE.emit(eventType, eventArgs, {}, false, false)
+
+    expect(mockScopeListener).toHaveBeenCalledTimes(1)
+    expect(mockListener).not.toHaveBeenCalled()
+    expect(scopeEE.backlog.feature).toEqual(expect.arrayContaining([
+      expect.arrayContaining([
+        scopeEE,
+        eventType,
+        eventArgs,
+        {}
+      ])
+    ]))
+    expect(ee.backlog.feature).toEqual(scopeEE.backlog.feature)
+  })
+})
+
+describe('getOrSetContext', () => {
+  test('it returns a new context', async () => {
+    const { getOrSetContext } = await import('./contextual-ee')
+
+    const obj = {}
+    const result = getOrSetContext(obj)
+
+    expect(result).toEqual({})
+    expect(result).toEqual(obj['nr@context'])
+  })
+
+  test('it returns the same context', async () => {
+    const { getOrSetContext } = await import('./contextual-ee')
+
+    const obj = {}
+    const result = getOrSetContext(obj)
+
+    expect(getOrSetContext(obj)).toEqual(result)
+  })
+})

package/src/common/event-emitter/handle.test.js

@@ -0,0 +1,56 @@
+import { faker } from '@faker-js/faker'
+
+jest.mock('./contextual-ee', () => ({
+  __esModule: true,
+  ee: {
+    buffer: jest.fn(),
+    emit: jest.fn(),
+    get: jest.fn(() => ({
+      buffer: jest.fn(),
+      emit: jest.fn()
+    }))
+  }
+}))
+
+afterEach(() => {
+  jest.resetModules()
+  jest.resetAllMocks()
+})
+
+test('it should create and use a default event-emitter', async () => {
+  const { ee } = await import('./contextual-ee')
+  const { handle } = await import('./handle')
+
+  const handleEE = jest.mocked(ee.get).mock.results[0].value
+  const eventType = faker.datatype.uuid()
+  const eventArgs = ['a', 'b', 'c']
+  const eventContext = {}
+  const eventGroup = faker.datatype.uuid()
+
+  handle(eventType, eventArgs, eventContext, eventGroup)
+
+  expect(handleEE.buffer).toHaveBeenCalledWith([eventType], eventGroup)
+  expect(handleEE.emit).toHaveBeenCalledWith(eventType, eventArgs, eventContext)
+})
+
+test('it should use the provided scoped event-emitter', async () => {
+  const { ee } = await import('./contextual-ee')
+  const { handle } = await import('./handle')
+  const scopedEE = {
+    buffer: jest.fn(),
+    emit: jest.fn()
+  }
+
+  const handleEE = jest.mocked(ee.get).mock.results[0].value
+  const eventType = faker.datatype.uuid()
+  const eventArgs = ['a', 'b', 'c']
+  const eventContext = {}
+  const eventGroup = faker.datatype.uuid()
+
+  handle(eventType, eventArgs, eventContext, eventGroup, scopedEE)
+
+  expect(handleEE.buffer).not.toHaveBeenCalled()
+  expect(handleEE.emit).not.toHaveBeenCalled()
+  expect(scopedEE.buffer).toHaveBeenCalledWith([eventType], eventGroup)
+  expect(scopedEE.emit).toHaveBeenCalledWith(eventType, eventArgs, eventContext)
+})

package/src/common/event-emitter/register-handler.test.js

@@ -0,0 +1,61 @@
+import { faker } from '@faker-js/faker'
+
+jest.mock('./handle', () => ({
+  __esModule: true,
+  handleEE: {}
+}))
+
+afterEach(() => {
+  jest.resetModules()
+  jest.resetAllMocks()
+})
+
+test('should default group to "feature"', async () => {
+  const { handleEE } = await import('./handle')
+  const { registerHandler } = await import('./register-handler')
+
+  const eventType = faker.datatype.uuid()
+  const eventHandler = jest.fn()
+
+  registerHandler(eventType, eventHandler)
+
+  expect(registerHandler.handlers.feature).toEqual(expect.objectContaining({
+    [eventType]: [expect.arrayContaining([
+      handleEE, eventHandler
+    ])]
+  }))
+})
+
+test('should use the provided group', async () => {
+  const { handleEE } = await import('./handle')
+  const { registerHandler } = await import('./register-handler')
+
+  const eventType = faker.datatype.uuid()
+  const eventGroup = faker.datatype.uuid()
+  const eventHandler = jest.fn()
+
+  registerHandler(eventType, eventHandler, eventGroup)
+
+  expect(registerHandler.handlers[eventGroup]).toEqual(expect.objectContaining({
+    [eventType]: [expect.arrayContaining([
+      handleEE, eventHandler
+    ])]
+  }))
+})
+
+test('should use the provided event-emitter', async () => {
+  const { registerHandler } = await import('./register-handler')
+
+  const scopedEE = {}
+  const eventType = faker.datatype.uuid()
+  const eventGroup = faker.datatype.uuid()
+  const eventHandler = jest.fn()
+
+  registerHandler(eventType, eventHandler, eventGroup, scopedEE)
+
+  expect(registerHandler.handlers[eventGroup]).toEqual(expect.objectContaining({
+    [eventType]: [expect.arrayContaining([
+      scopedEE, eventHandler
+    ])]
+  }))
+})

package/src/common/event-listener/event-listener-opts.js

@@ -32,10 +32,10 @@ export function eventListenerOpts (useCapture, abortSignal) {
 }
 
 /** Do not use this within the worker context. */
-export function windowAddEventListener (event, listener, capture = false) {
-  window.addEventListener(event, listener, eventListenerOpts(capture))
+export function windowAddEventListener (event, listener, capture = false, abortSignal) {
+  window.addEventListener(event, listener, eventListenerOpts(capture, abortSignal))
 }
 /** Do not use this within the worker context. */
-export function documentAddEventListener (event, listener, capture = false) {
-  document.addEventListener(event, listener, eventListenerOpts(capture))
+export function documentAddEventListener (event, listener, capture = false, abortSignal) {
+  document.addEventListener(event, listener, eventListenerOpts(capture, abortSignal))
 }

package/src/common/harvest/harvest-scheduler.js

@@ -23,13 +23,18 @@ export class HarvestScheduler extends SharedContext {
 
     this.harvest = new Harvest(this.sharedContext)
 
-    subscribeToEOL(() => {
-      if (this.aborted) return
+    // unload if EOL mechanism fires
+    subscribeToEOL(this.unload.bind(this), getConfigurationValue(this.sharedContext.agentIdentifier, 'allow_bfcache')) // TO DO: remove feature flag after rls stable
 
-      // If opts.onUnload is defined, these are special actions to execute before attempting to send the final payload.
-      if (this.opts.onUnload) this.opts.onUnload()
-      this.runHarvest({ unload: true })
-    }, getConfigurationValue(this.sharedContext.agentIdentifier, 'allow_bfcache')) // TO DO: remove feature flag after rls stable
+    // unload if session resets
+    this.sharedContext?.ee.on('session-reset', this.unload.bind(this))
+  }
+
+  unload () {
+    if (this.aborted) return
+    // If opts.onUnload is defined, these are special actions to execute before attempting to send the final payload.
+    if (this.opts.onUnload) this.opts.onUnload()
+    this.runHarvest({ unload: true })
   }
 
   startTimer (interval, initialDelay) {
@@ -76,8 +81,7 @@ export class HarvestScheduler extends SharedContext {
         }
       }
     } else {
-      const runAfterSending = opts?.unload ? undefined : onHarvestFinished // don't bother running onFinish handler if this is the final harvest
-      this.harvest.sendX(this.endpoint, opts, runAfterSending)
+      this.harvest.sendX(this.endpoint, opts, onHarvestFinished)
     }
 
     if (this.started) {

package/src/common/harvest/harvest.js

@@ -15,7 +15,7 @@ import { eventListenerOpts } from '../event-listener/event-listener-opts'
 import { Obfuscator } from '../util/obfuscate'
 import { applyFnToProps } from '../util/traverse'
 import { SharedContext } from '../context/shared-context'
-import { VERSION } from '../constants/environment-variables'
+import { VERSION } from '../constants/env'
 import { isBrowserScope, isWorkerScope } from '../util/global-scope'
 
 const haveSendBeacon = !!navigator.sendBeacon // only the web window obj has sendBeacon at this time, so 'false' for other envs
@@ -118,6 +118,8 @@ export class Harvest extends SharedContext {
 
     // Get bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
     agentRuntime.bytesSent[endpoint] = (agentRuntime.bytesSent[endpoint] || 0) + body?.length || 0
+    // Get query bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
+    agentRuntime.queryBytesSent[endpoint] = (agentRuntime.queryBytesSent[endpoint] || 0) + fullUrl.split('?').slice(-1)[0]?.length || 0
 
     /* Since workers don't support sendBeacon right now, or Image(), they can only use XHR method.
         Because they still do permit synch XHR, the idea is that at final harvest time (worker is closing),
@@ -167,7 +169,7 @@ export class Harvest extends SharedContext {
       encodeParam('ct', runtime.customTransaction),
       '&rst=' + now(),
       '&ck=0', // ck param DEPRECATED - still expected by backend
-      '&s=' + (runtime.sessionId || '0'), // the 0 id encaps all untrackable and default traffic
+      '&s=' + (runtime.session?.value || '0'), // the 0 id encaps all untrackable and default traffic
       encodeParam('ref', ref),
       encodeParam('ptid', (runtime.ptid ? '' + runtime.ptid : ''))
     ].join(''))
@@ -176,7 +178,7 @@ export class Harvest extends SharedContext {
   createPayload (type, options) {
     var makeBody = createAccumulator()
     var makeQueryString = createAccumulator()
-    var listeners = (this._events[type] && this._events[type] || [])
+    var listeners = ((this._events[type] && this._events[type]) || [])
 
     for (var i = 0; i < listeners.length; i++) {
       var singlePayload = listeners[i](options)

package/src/common/ids/id.js

@@ -3,17 +3,26 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-// Start assigning ids at 1 so 0 can always be used for WindowOrWorkerGlobalScope, without
-// actually setting it (which would create a global variable).
 import { getOrSet } from '../util/get-or-set'
 import { globalScope } from '../util/global-scope'
 
-var index = 1
-var prop = 'nr@id'
+// Start assigning ids at 1 so 0 can always be used for Window or WorkerGlobalScope, without
+// actually setting it (which would create a global variable).
+let index = 1
+const prop = 'nr@id'
 
-// Always returns id of obj, may tag obj with an id in the process.
+/**
+ * Tags a specified object with an identifier if it does not already
+ * have one. If the object is the global scope, zero will be returned
+ * and the object will not be modified. If the object already contains
+ * an identifier, it will be returned without modification. If the passed
+ * value is not an object, function, or array, -1 will be returned without
+ * modifying the passed value.
+ * @param {object|function|array} obj Object to be tagged with an identifier
+ * @returns {number} Identifier of the given object
+ */
 export function id (obj) {
-  var type = typeof obj
+  const type = typeof obj
   // We can only tag objects, functions, and arrays with ids.
   // For all primitive values we instead return -1.
   if (!obj || !(type === 'object' || type === 'function')) return -1

package/src/common/ids/id.test.js

@@ -0,0 +1,92 @@
+let idFn
+
+beforeEach(async () => {
+  idFn = (await import('./id')).id
+})
+
+afterEach(() => {
+  jest.resetModules()
+  jest.clearAllMocks()
+})
+
+test.each([
+  { input: undefined, expected: -1, title: 'id of undefined is -1' },
+  { input: null, expected: -1, title: 'id of null is -1' },
+  { input: 2, expected: -1, title: 'id of number is -1' },
+  { input: 'foo', expected: -1, title: 'id of string is -1' }
+])('$title', ({ input, expected }) => {
+  const result = idFn(input)
+
+  expect(typeof result).toEqual('number')
+  expect(result).toEqual(expected)
+})
+
+test('id values increment sequentially', () => {
+  const inputA = {}
+  const inputB = {}
+
+  const resultA = idFn(inputA)
+  const resultB = idFn(inputB)
+
+  expect(resultA - resultB).toEqual(-1)
+})
+
+test('id is correctly assigned to function type', () => {
+  const input = jest.fn()
+
+  const result = idFn(input)
+
+  expect(result).toEqual(1)
+  expect(input['nr@id']).toEqual(1)
+})
+
+test('id is correctly assigned to object type', () => {
+  const input = {}
+
+  const result = idFn(input)
+
+  expect(result).toEqual(1)
+  expect(input['nr@id']).toEqual(1)
+})
+
+test('id is the same when called twice on the same input', () => {
+  const input = {}
+
+  const result1 = idFn(input)
+  const result2 = idFn(input)
+
+  expect(result1).toEqual(1)
+  expect(result2).toEqual(1)
+  expect(input['nr@id']).toEqual(1)
+})
+
+test('id is zero on global scope', async () => {
+  const result = idFn(global)
+
+  expect(result).toEqual(0)
+})
+
+test('id on prototype is correctly inherited', () => {
+  const fn = jest.fn()
+  const a = {}
+
+  idFn(a)
+  fn.prototype = a
+
+  const b = new fn()
+
+  expect(b['nr@id']).toEqual(a['nr@id'])
+})
+
+test('id on prototype is different from instance', () => {
+  const fn = jest.fn()
+  const a = {}
+
+  idFn(a)
+  fn.prototype = a
+
+  const b = new fn()
+  const result = idFn(b)
+
+  expect(b['nr@id']).toEqual(result)
+})