@newrelic/browser-agent 0.1.229 → 0.1.231

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.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ee as globalInstance } from './contextual-ee'
+export var handleEE = globalInstance.get('handle')
+
+export function handle (type, args, ctx, group, ee) {
+  if (ee) {
+    ee.buffer([type], group)
+    ee.emit(type, args, ctx)
+  } else {
+    handleEE.buffer([type], group)
+    handleEE.emit(type, args, ctx)
+  }
+}

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.js

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { handleEE } from './handle'
+
+export { defaultRegister as registerHandler }
+
+defaultRegister.on = registerWithSpecificEmitter
+
+var handlers = defaultRegister.handlers = {}
+
+export function defaultRegister (type, handler, group, ee) {
+  registerWithSpecificEmitter(ee || handleEE, handlers, type, handler, group)
+}
+
+function registerWithSpecificEmitter (ee, handlers, type, handler, group) {
+  if (!group) group = 'feature'
+  if (!ee) ee = handleEE
+
+  var groupHandlers = handlers[group] = handlers[group] || {}
+  var list = groupHandlers[type] = groupHandlers[type] || []
+  list.push([ee, handler])
+}

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

@@ -0,0 +1,41 @@
+import { globalScope } from '../util/global-scope'
+
+/*
+ * See https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#safely_detecting_option_support
+ */
+let passiveSupported = false
+let signalSupported = false
+try {
+  const options = {
+    get passive () { // this function will be called when the browser attempts to access the passive property
+      passiveSupported = true
+      return false
+    },
+    get signal () {
+      signalSupported = true
+      return false
+    }
+  }
+
+  globalScope.addEventListener('test', null, options)
+  globalScope.removeEventListener('test', null, options)
+} catch (err) {}
+
+export function eventListenerOpts (useCapture, abortSignal) {
+  return (passiveSupported || signalSupported)
+    ? {
+        capture: !!useCapture,
+        passive: passiveSupported, // passive defaults to false
+        signal: abortSignal
+      }
+    : !!useCapture // mainly just IE11 doesn't support third param options under EventTarget API
+}
+
+/** Do not use this within the worker context. */
+export function windowAddEventListener (event, listener, capture = false) {
+  window.addEventListener(event, listener, eventListenerOpts(capture))
+}
+/** Do not use this within the worker context. */
+export function documentAddEventListener (event, listener, capture = false) {
+  document.addEventListener(event, listener, eventListenerOpts(capture))
+}

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

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { submitData } from '../util/submit-data'
+import { SharedContext } from '../context/shared-context'
+import { Harvest, getSubmitMethod } from './harvest'
+import { subscribeToEOL } from '../unload/eol'
+import { getConfigurationValue } from '../config/config'
+
+/**
+ * Periodically invokes harvest calls and handles retries
+ */
+export class HarvestScheduler extends SharedContext {
+  constructor (endpoint, opts, parent) {
+    super(parent) // gets any allowed properties from the parent and stores them in `sharedContext`
+    this.endpoint = endpoint
+    this.opts = opts || {}
+    this.started = false
+    this.timeoutHandle = null
+    this.aborted = false // this controls the per-interval and final harvests for the scheduler (currently per feature specific!)
+
+    this.harvest = new Harvest(this.sharedContext)
+
+    subscribeToEOL(() => {
+      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 })
+    }, getConfigurationValue(this.sharedContext.agentIdentifier, 'allow_bfcache')) // TO DO: remove feature flag after rls stable
+  }
+
+  startTimer (interval, initialDelay) {
+    this.interval = interval
+    this.started = true
+    this.scheduleHarvest(initialDelay != null ? initialDelay : this.interval)
+  }
+
+  stopTimer (permanently = false) {
+    this.aborted = permanently // stopping permanently is same as aborting, but this function also cleans up the setTimeout loop
+    this.started = false
+    if (this.timeoutHandle) {
+      clearTimeout(this.timeoutHandle)
+    }
+  }
+
+  scheduleHarvest (delay, opts) {
+    if (this.timeoutHandle) return
+    var timer = this
+
+    if (delay == null) {
+      delay = this.interval
+    }
+    this.timeoutHandle = setTimeout(() => {
+      timer.timeoutHandle = null
+      timer.runHarvest(opts)
+    }, delay * 1000)
+  }
+
+  runHarvest (opts) {
+    if (this.aborted) return
+    var scheduler = this
+
+    if (this.opts.getPayload) { // Ajax & PVT
+      var submitMethod = getSubmitMethod(this.endpoint, opts)
+      if (!submitMethod) return false
+
+      var retry = submitMethod.method === submitData.xhr
+      var payload = this.opts.getPayload({ retry: retry })
+      if (payload) {
+        payload = Object.prototype.toString.call(payload) === '[object Array]' ? payload : [payload]
+        for (var i = 0; i < payload.length; i++) {
+          this.harvest.send(this.endpoint, payload[i], opts, submitMethod, onHarvestFinished)
+        }
+      }
+    } 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)
+    }
+
+    if (this.started) {
+      this.scheduleHarvest()
+    }
+    return
+
+    function onHarvestFinished (result) {
+      if (result.blocked) scheduler.onHarvestBlocked(opts, result)
+      else scheduler.onHarvestFinished(opts, result)
+    }
+  }
+
+  onHarvestFinished (opts, result) {
+    if (this.opts.onFinished) {
+      this.opts.onFinished(result)
+    }
+
+    if (result.sent && result.retry) {
+      var delay = result.delay || this.opts.retryDelay
+      // reschedule next harvest if should be delayed longer
+      if (this.started && delay) {
+        clearTimeout(this.timeoutHandle)
+        this.timeoutHandle = null
+        this.scheduleHarvest(delay, opts)
+      } else if (!this.started && delay) {
+        // if not running on a timer, schedule a single retry
+        this.scheduleHarvest(delay, opts)
+      }
+    }
+  }
+}