@newrelic/browser-agent 0.1.230 → 1.232.0

package/src/common/url/protocol.test.js

@@ -0,0 +1,18 @@
+import { faker } from '@faker-js/faker'
+import { isFileProtocol } from './protocol'
+
+test('should return true when location url contains file protocol', () => {
+  jest.spyOn(window, 'location', 'get').mockReturnValue({
+    protocol: 'file:'
+  })
+
+  expect(isFileProtocol()).toEqual(true)
+})
+
+test('should return false when location url does not contains file protocol', () => {
+  jest.spyOn(window, 'location', 'get').mockReturnValue({
+    protocol: 'http:'
+  })
+
+  expect(isFileProtocol()).toEqual(false)
+})

package/src/common/util/data-size.js

@@ -5,6 +5,12 @@
 
 import { stringify } from './stringify'
 
+/**
+ * Returns the size of the provided data. Designed for measuring XHR responses.
+ *
+ * @param {*} data - The data to be measured.
+ * @returns {(number|undefined)} - The size of the data or undefined if size cannot be determined.
+ */
 export function dataSize (data) {
   if (typeof data === 'string' && data.length) return data.length
   if (typeof data !== 'object') return undefined

package/src/common/util/data-size.test.js

@@ -0,0 +1,50 @@
+import { dataSize } from './data-size'
+
+describe('dataSize', () => {
+  test('returns length of string', () => {
+    const str = 'Hello, world!'
+    expect(dataSize(str)).toBe(str.length)
+  })
+
+  test('returns undefined for non-object, number, or empty string', () => {
+    expect(dataSize(Infinity)).toBeUndefined()
+    expect(dataSize(12345)).toBeUndefined() // might not actually be by design, but this is how it works today
+    expect(dataSize('')).toBeUndefined()
+  })
+
+  test('returns byte length of ArrayBuffer object', () => {
+    const buffer = new ArrayBuffer(8)
+    expect(dataSize(buffer)).toBe(8)
+  })
+
+  test('returns size of Blob object', () => {
+    const blob = new Blob(['Hello, world!'], { type: 'text/plain' })
+    expect(dataSize(blob)).toBe(blob.size)
+  })
+
+  test('returns undefined for FormData object', () => {
+    const formData = new FormData()
+    expect(dataSize(formData)).toBeUndefined()
+  })
+
+  test('returns length of JSON string representation of object', () => {
+    const obj = {
+      str: 'Hello, world!',
+      num: 12345,
+      nestedObj: {
+        arr: [1, 2, 3]
+      }
+    }
+    const expectedSize = JSON.stringify(obj).length
+    expect(dataSize(obj)).toBe(expectedSize)
+  })
+
+  test('returns undefined for object with toJSON method that throws an error', () => {
+    const obj = {
+      toJSON: () => {
+        throw new Error('Error in toJSON')
+      }
+    }
+    expect(dataSize(obj)).toBeUndefined()
+  })
+})

package/src/common/util/global-scope.js

@@ -38,8 +38,7 @@ export function resetScope () {
     } else if (self instanceof WorkerGlobalScope) {
       globalScope = self
     }
-  }
-  else {
+  } else {
     throw new Error('New Relic browser agent shutting down due to error: Unable to locate global scope. This is possibly due to code redefining browser global variables like "self" and "window".')
   }
 }

package/src/common/util/invoke.js

@@ -0,0 +1,55 @@
+/**
+ * Reduce the invocation of the supplied function so that it is only invoked
+ * once within a given timeout.
+ *
+ * If `wait` is `0`, the function will be invoked during the next tick.
+ * If `options.leading` is false or not provided, the function will be invoked
+ * N milliseconds after the last invocation of the returned function where
+ * N is the `timeout` value.
+ * If `options.leading` is true, the function will be invoked immediately upon
+ * the first invocation of the returned function and not again for N milliseconds
+ * where N is the `timeout` value.
+ * @param {function} func Function whose invocation should be limited so it is only invoked
+ * once within a given timeout period.
+ * @param {number} timeout Time in milliseconds that the function should only be invoked
+ * once within.
+ * @param {object} options Debounce options
+ * @param {boolean} options.leading Forces the function to be invoked on the first
+ * invocation of the returned function instead of N milliseconds after the last
+ * invocation.
+ * @returns {function} A wrapping function that will ensure the provided function
+ * is invoked only once within the given timeout.
+ */
+export function debounce (func, timeout = 500, options = {}) {
+  const leading = options?.leading || false
+  let timer
+  return (...args) => {
+    if (leading && timer === undefined) {
+      func.apply(this, args)
+      timer = setTimeout(() => timer = clearTimeout(timer), timeout)
+    }
+
+    if (!leading) {
+      clearTimeout(timer)
+      timer = setTimeout(() => { func.apply(this, args) }, timeout)
+    }
+  }
+}
+
+/**
+ * Reduce the invocation of the supplied function so that it is only invoked
+ * once.
+ * @param {function} func Function whose invocation should be limited so it is only invoked
+ * once.
+ * @returns {function} A wrapping function that will ensure the provided function
+ * is invoked only once.
+ */
+export function single (func) {
+  let called = false
+  return (...args) => {
+    if (!called) {
+      called = true
+      func.apply(this, args)
+    }
+  }
+}

package/src/common/util/invoke.test.js

@@ -0,0 +1,65 @@
+import { debounce, single } from './invoke'
+
+jest.useFakeTimers()
+
+describe('debounce', () => {
+  test('should run the supplied function after 100ms', () => {
+    let mockCallback = jest.fn()
+
+    let debouncedMethod = debounce(mockCallback, 100)
+    execFnTimes(debouncedMethod, 100)
+
+    expect(mockCallback).not.toHaveBeenCalled()
+
+    jest.advanceTimersByTime(1000)
+    expect(mockCallback).toHaveBeenCalledTimes(1)
+  })
+
+  test('should rerun the supplied function when called again after 100ms', () => {
+    let mockCallback = jest.fn()
+
+    let debouncedMethod = debounce(mockCallback, 100)
+
+    execFnTimes(debouncedMethod, 100)
+    jest.advanceTimersByTime(200)
+    execFnTimes(debouncedMethod, 100)
+    jest.advanceTimersByTime(2000)
+
+    expect(mockCallback).toHaveBeenCalledTimes(2)
+  })
+
+  test('should run the supplied function on the first event and debounce subsequent events', () => {
+    let mockCallback = jest.fn()
+
+    let debouncedMethod = debounce(mockCallback, 100, { leading: true })
+
+    execFnTimes(debouncedMethod, 100)
+    expect(mockCallback).toHaveBeenCalledTimes(1)
+
+    jest.advanceTimersByTime(200)
+
+    expect(mockCallback).toHaveBeenCalledTimes(1)
+
+    execFnTimes(debouncedMethod, 100)
+    jest.advanceTimersByTime(200)
+
+    expect(mockCallback).toHaveBeenCalledTimes(2)
+  })
+})
+
+describe('single', () => {
+  test('should run the supplied function only once', () => {
+    let mockCallback = jest.fn()
+
+    let singleMethod = single(mockCallback, 100)
+    execFnTimes(singleMethod, 100)
+
+    expect(mockCallback).toHaveBeenCalledTimes(1)
+  })
+})
+
+function execFnTimes (fn, count) {
+  for (let i = 0; i < count; i++) {
+    fn()
+  }
+}

package/src/common/util/obfuscate.js

@@ -1,6 +1,6 @@
 import { getConfigurationValue } from '../config/config'
 import { SharedContext } from '../context/shared-context'
-import { protocol } from '../url/protocol'
+import { isFileProtocol } from '../url/protocol'
 import { warn } from './console'
 
 var fileProtocolRule = {
@@ -8,10 +8,6 @@ var fileProtocolRule = {
   replacement: 'file://OBFUSCATED'
 }
 export class Obfuscator extends SharedContext {
-  constructor (parent) {
-    super(parent) // gets any allowed properties from the parent and stores them in `sharedContext`
-  }
-
   shouldObfuscate () {
     return getRules(this.sharedContext.agentIdentifier).length > 0
   }
@@ -41,7 +37,7 @@ export function getRules (agentIdentifier) {
 
   rules = rules.concat(configRules)
 
-  if (protocol.isFileProtocol()) rules.push(fileProtocolRule)
+  if (isFileProtocol()) rules.push(fileProtocolRule)
   // could add additional runtime/environment-specific rules here
 
   return rules

package/src/common/window/page-visibility.js

@@ -10,14 +10,14 @@ import { documentAddEventListener } from '../event-listener/event-listener-opts'
  * @param {boolean} [toHiddenOnly=false] - only execute the 'cb' when the vis is changing to the hidden state; no arg is passed to 'cb' if used
  * @returns void
  */
-export function subscribeToVisibilityChange (cb, toHiddenOnly = false) {
-  documentAddEventListener('visibilitychange', handleVisibilityChange)
+export function subscribeToVisibilityChange (cb, toHiddenOnly = false, capture, abortSignal) {
+  documentAddEventListener('visibilitychange', handleVisibilityChange, capture, abortSignal)
   return
 
   function handleVisibilityChange () {
     if (toHiddenOnly) { // trigger cb on change to hidden state only
       if (document.visibilityState == 'hidden') cb()
-      else return
+      return
     }
     cb(document.visibilityState)
   }

package/src/common/wrap/index.js

@@ -2,7 +2,6 @@
  * @file Wraps assorted native objects and functions for instrumentation.
  */
 
-import { wrapConsole } from './wrap-console'
 import { wrapEvents } from './wrap-events'
 import { wrapFetch } from './wrap-fetch'
 import { wrapHistory } from './wrap-history'
@@ -14,5 +13,5 @@ import { wrapTimer } from './wrap-timer'
 import { wrapXhr } from './wrap-xhr'
 
 export {
-  wrapConsole, wrapEvents, wrapFetch, wrapHistory, wrapJsonP, wrapMutation, wrapPromise, wrapRaf, wrapTimer, wrapXhr
+  wrapEvents, wrapFetch, wrapHistory, wrapJsonP, wrapMutation, wrapPromise, wrapRaf, wrapTimer, wrapXhr
 }

package/src/common/wrap/wrap-events.js

@@ -26,16 +26,16 @@ const REMOVE_EVENT_LISTENER = 'removeEventListener'
  */
 export function wrapEvents (sharedEE) {
   var ee = scopedEE(sharedEE)
-  if (wrapped[ee.debugId]++) // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-  { return ee } // then we increment the count to track # of feats using this at runtime.
-  wrapped[ee.debugId] = 1
 
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (wrapped[ee.debugId]++) return ee
+  wrapped[ee.debugId] = 1 // otherwise, first feature to wrap events
   var wrapFn = wfn(ee, true)
 
   // Guard against instrumenting environments w/o necessary features
   if ('getPrototypeOf' in Object) {
-    if (isBrowserScope)
-    { findEventListenerProtoAndCb(document, wrapNode) }
+    if (isBrowserScope) findEventListenerProtoAndCb(document, wrapNode)
     findEventListenerProtoAndCb(globalScope, wrapNode)
     findEventListenerProtoAndCb(XHR.prototype, wrapNode)
   }

package/src/common/wrap/wrap-fetch.js

@@ -35,9 +35,10 @@ export function wrapFetch (sharedEE) {
     return ee
   }
 
-  if (wrapped[ee.debugId]++) // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-  { return ee } // then we increment the count to track # of feats using this at runtime.
-  wrapped[ee.debugId] = 1
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (wrapped[ee.debugId]++) return ee
+  wrapped[ee.debugId] = 1 // otherwise, first feature to wrap fetch
 
   bodyMethods.forEach(method => {
     wrapPromiseMethod(Req[proto], method, bodyPrefix)

package/src/common/wrap/wrap-history.js

@@ -21,9 +21,12 @@ const HISTORY_FNS = ['pushState', 'replaceState']
  */
 export function wrapHistory (sharedEE) {
   const ee = scopedEE(sharedEE)
-  if (!isBrowserScope || wrapped[ee.debugId]++) // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-  { return ee } // then we increment the count to track # of feats using this at runtime. (History API is only avail in browser DOM context.)
-  wrapped[ee.debugId] = 1
+
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime. History API is only
+  // available in browser DOM context.
+  if (!isBrowserScope || wrapped[ee.debugId]++) return ee
+  wrapped[ee.debugId] = 1 // otherwise, first feature to wrap history
 
   var wrapFn = wfn(ee)
   /*

package/src/common/wrap/wrap-jsonp.js

@@ -24,9 +24,11 @@ const domInsertMethods = ['appendChild', 'insertBefore', 'replaceChild']
 export function wrapJsonP (sharedEE) {
   const ee = scopedEE(sharedEE)
 
-  if (!isBrowserScope || wrapped[ee.debugId]) // JSONP deals with DOM tags so browser window env is req'd
-  { return ee }
-  wrapped[ee.debugId] = true
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.  JSONP deals with DOM
+  // tags so browser window env is required.
+  if (!isBrowserScope || wrapped[ee.debugId]) return ee
+  wrapped[ee.debugId] = true // otherwise, first feature to wrap JSONP
 
   var wrapFn = wfn(ee)
 

package/src/common/wrap/wrap-mutation.js

@@ -22,9 +22,12 @@ const wrapped = {}
  */
 export function wrapMutation (sharedEE) {
   const ee = scopedEE(sharedEE)
-  if (!isBrowserScope || wrapped[ee.debugId]) // relates to the DOM tree (web env only)
-  { return ee }
-  wrapped[ee.debugId] = true
+
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime. Mutations API is only
+  // available in browser DOM context.
+  if (!isBrowserScope || wrapped[ee.debugId]) return ee
+  wrapped[ee.debugId] = true // otherwise, first feature to wrap mutations
 
   var wrapFn = wfn(ee)
   var OriginalObserver = originals.MO

package/src/common/wrap/wrap-promise.js

@@ -24,9 +24,10 @@ const wrapped = {}
 export function wrapPromise (sharedEE) {
   const promiseEE = scopedEE(sharedEE)
 
-  if (wrapped[promiseEE.debugId])
-  { return promiseEE }
-  wrapped[promiseEE.debugId] = true
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (wrapped[promiseEE.debugId]) return promiseEE
+  wrapped[promiseEE.debugId] = true // otherwise, first feature to wrap promise
 
   var getContext = getOrSetContext
   var promiseWrapper = wrapFn(promiseEE)
@@ -69,9 +70,9 @@ export function wrapPromise (sharedEE) {
       const prevStaticFn = prevPromiseObj[method]
       WrappedPromise[method] = function (subPromises) { // use our own wrapped version of "Promise.all" and ".race" static fns
         let finalized = false
-        subPromises?.forEach(sub => {
-          // eslint-disable-next-line
-          this.resolve(sub).then(setNrId(method === 'all'), setNrId(false));
+
+        Array.from(subPromises || []).forEach(sub => {
+          this.resolve(sub).then(setNrId(method === 'all'), setNrId(false))
         })
 
         const origFnCallWithThis = prevStaticFn.apply(this, arguments)

package/src/common/wrap/wrap-promise.test.js

@@ -0,0 +1,140 @@
+import { faker } from '@faker-js/faker'
+import { globalScope } from '../util/global-scope'
+import { originals } from '../config/config'
+
+jest.mock('./wrap-function', () => ({
+  __esModule: true,
+  createWrapperWithEmitter: jest.fn(() => (fn) => (...args) => {
+    return fn.apply(null, args)
+  })
+}))
+jest.mock('../event-emitter/contextual-ee', () => ({
+  __esModule: true,
+  getOrSetContext: jest.fn(() => ({})),
+  ee: {
+    get: jest.fn((name) => ({
+      debugId: name,
+      on: jest.fn(),
+      context: jest.fn(() => ({})),
+      emit: jest.fn()
+    }))
+  }
+}))
+jest.mock('../config/config', () => ({
+  __esModule: true,
+  originals: {}
+}))
+jest.mock('../util/global-scope', () => ({
+  __esModule: true,
+  globalScope: {
+    NREUM: {}
+  }
+}))
+
+let promiseConstructorCalls
+
+beforeEach(async () => {
+  promiseConstructorCalls = []
+
+  // Proxy the global Promise to prevent the wrapping from
+  // messing with Jest internal promises
+  originals.PR = new Proxy(class extends Promise {}, {
+    construct (target, args) {
+      promiseConstructorCalls.push(args)
+
+      return Reflect.construct(target, args)
+    }
+  })
+
+  ;(await import('./wrap-promise')).wrapPromise()
+})
+
+afterEach(() => {
+  jest.resetModules()
+})
+
+test('should wrap promise constructor', async () => {
+  const promiseInstance = new globalScope.Promise(jest.fn())
+
+  expect(promiseInstance).toBeInstanceOf(Promise)
+  expect(promiseConstructorCalls.length).toEqual(1)
+  expect(globalScope.Promise.toString()).toMatch(/\[native code\]/)
+  expect(globalScope.Promise.name).toEqual('Promise')
+})
+
+describe('all', () => {
+  test('should work with acceptable iterables', async () => {
+    const resolveValue = faker.datatype.uuid()
+    const customIterable = new CustomIterable([
+      new globalScope.Promise(resolve => resolve(resolveValue))
+    ])
+    const arrayIterable = [
+      new globalScope.Promise(resolve => resolve(resolveValue))
+    ]
+    const setIterable = new Set()
+    setIterable.add(new globalScope.Promise(resolve => resolve(resolveValue)))
+
+    await expect(globalScope.Promise.all(customIterable)).resolves.toEqual([resolveValue])
+    await expect(globalScope.Promise.all(arrayIterable)).resolves.toEqual([resolveValue])
+    await expect(globalScope.Promise.all(setIterable)).resolves.toEqual([resolveValue])
+  })
+
+  test.each([null, undefined])('should not try to iterate a non-iterable %s', async (input) => {
+    jest.spyOn(globalScope.Promise, 'resolve')
+
+    await expect(globalScope.Promise.all(input)).rejects.toThrow()
+    expect(globalScope.Promise.resolve).not.toHaveBeenCalled()
+  })
+})
+
+describe('race', () => {
+  test('should work with acceptable iterables', async () => {
+    jest.spyOn(globalScope.Promise, 'resolve')
+
+    const resolveValue = faker.datatype.uuid()
+    const customIterable = new CustomIterable([
+      new globalScope.Promise(resolve => resolve(resolveValue))
+    ])
+    const arrayIterable = [
+      new globalScope.Promise(resolve => resolve(resolveValue))
+    ]
+    const setIterable = new Set()
+    setIterable.add(new globalScope.Promise(resolve => resolve(resolveValue)))
+
+    await expect(globalScope.Promise.race(customIterable)).resolves.toEqual(resolveValue)
+    await expect(globalScope.Promise.race(arrayIterable)).resolves.toEqual(resolveValue)
+    await expect(globalScope.Promise.race(setIterable)).resolves.toEqual(resolveValue)
+    expect(globalScope.Promise.resolve).toHaveBeenCalled()
+  })
+
+  test.each([null, undefined])('should not try to iterate a non-iterable %s', async (input) => {
+    jest.spyOn(globalScope.Promise, 'resolve')
+
+    await expect(globalScope.Promise.race(input)).rejects.toThrow()
+    expect(globalScope.Promise.resolve).not.toHaveBeenCalled()
+  })
+})
+
+class CustomIterable {
+  #iterables = []
+
+  constructor (iterables) {
+    this.#iterables = iterables
+  }
+
+  [Symbol.iterator] () {
+    return {
+      index: 0,
+      iterables: this.#iterables,
+      next () {
+        return {
+          done: this.index >= this.iterables.length,
+          value: this.iterables[this.index++] || undefined
+        }
+      },
+      [Symbol.iterator] () {
+        return this
+      }
+    }
+  }
+}

package/src/common/wrap/wrap-raf.js

@@ -22,9 +22,11 @@ const RAF_NAME = 'requestAnimationFrame'
  */
 export function wrapRaf (sharedEE) {
   const ee = scopedEE(sharedEE)
-  if (!isBrowserScope || wrapped[ee.debugId]++) // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-  { return ee } // then we increment the count to track # of feats using this at runtime. (RAF is only avail in browser DOM context.)
-  wrapped[ee.debugId] = 1
+
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (!isBrowserScope || wrapped[ee.debugId]++) return ee
+  wrapped[ee.debugId] = 1 // otherwise, first feature to wrap RAF
 
   var wrapFn = wfn(ee)
 

package/src/common/wrap/wrap-timer.js

@@ -26,12 +26,14 @@ const TIMER_FNS = [SET_TIMEOUT, 'setImmediate', SET_INTERVAL, CLEAR_TIMEOUT, 'cl
  * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.
  * @returns {Object} Scoped event emitter with a debug ID of `timer`.
  */
-//eslint-disable-next-line
+// eslint-disable-next-line
 export function wrapTimer(sharedEE) {
   const ee = scopedEE(sharedEE)
-  if (wrapped[ee.debugId]++) // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-  { return ee } // then we increment the count to track # of feats using this at runtime.
-  wrapped[ee.debugId] = 1
+
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (wrapped[ee.debugId]++) return ee
+  wrapped[ee.debugId] = 1 // otherwise, first feature to wrap timer
 
   var wrapFn = wfn(ee)
 

package/src/common/wrap/wrap-xhr.js

@@ -29,9 +29,10 @@ export function wrapXhr (sharedEE) {
   var baseEE = sharedEE || contextualEE
   const ee = scopedEE(baseEE)
 
-  if (wrapped[ee.debugId]++) // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-  { return ee } // then we increment the count to track # of feats using this at runtime.
-  wrapped[ee.debugId] = 1 // <- otherwise, first feature to wrap XHR
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (wrapped[ee.debugId]++) return ee
+  wrapped[ee.debugId] = 1 // otherwise, first feature to wrap XHR
 
   wrapEvents(baseEE) // wrap-events patches XMLHttpRequest.prototype.addEventListener for us
   var wrapFn = wfn(ee)

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

@@ -9,13 +9,13 @@ import { handle } from '../../../common/event-emitter/handle'
 import { getConfigurationValue, getInfo } from '../../../common/config/config'
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { setDenyList, shouldCollectEvent } from '../../../common/deny-list/deny-list'
-import { AggregateBase } from '../../utils/aggregate-base'
 import { FEATURE_NAME } from '../constants'
 import { drain } from '../../../common/drain/drain'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
+import { FeatureBase } from '../../utils/feature-base'
 
-export class Aggregate extends AggregateBase {
+export class Aggregate extends FeatureBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)

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

@@ -140,7 +140,7 @@ function subscribeToEvents (agentIdentifier, ee, handler, dt) {
         if (evt.type === 'abort' && !(context.loadCaptureCalled)) {
           context.params.aborted = true
         }
-        if (evt.type !== 'load' || (context.called === context.totalCbs) && (context.onloadCalled || typeof (xhr.onload) !== 'function') && typeof context.end === 'function') context.end(xhr)
+        if (evt.type !== 'load' || ((context.called === context.totalCbs) && (context.onloadCalled || typeof (xhr.onload) !== 'function') && typeof context.end === 'function')) context.end(xhr)
       } catch (e) {
         try {
           ee.emit('internal-error', [e])

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

@@ -18,12 +18,12 @@ import { getInfo, getConfigurationValue, getRuntime } from '../../../common/conf
 import { now } from '../../../common/timing/now'
 import { globalScope } from '../../../common/util/global-scope'
 
-import { AggregateBase } from '../../utils/aggregate-base'
 import { FEATURE_NAME } from '../constants'
 import { drain } from '../../../common/drain/drain'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
+import { FeatureBase } from '../../utils/feature-base'
 
-export class Aggregate extends AggregateBase {
+export class Aggregate extends FeatureBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)
@@ -222,6 +222,7 @@ export class Aggregate extends AggregateBase {
 
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return
+    var att = getInfo(this.agentIdentifier).jsAttributes
     if (params._interactionId != null) {
       // hold on to the error until the interaction finishes
       this.errorCache[params._interactionId] = this.errorCache[params._interactionId] || []
@@ -229,7 +230,6 @@ export class Aggregate extends AggregateBase {
     } else {
       // store custom attributes
       var customParams = {}
-      var att = getInfo(this.agentIdentifier).jsAttributes
       mapOwn(att, setCustom)
       if (customAttributes) {
         mapOwn(customAttributes, setCustom)

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

@@ -24,8 +24,10 @@ export class Instrument extends InstrumentBase {
     // skipNext counter to keep track of uncaught
     // errors that will be the same as caught errors.
     this.skipNext = 0
-    try { this.removeOnAbort = new AbortController() } // this try-catch can be removed when IE11 is completely unsupported & gone
-    catch (e) {}
+    try {
+      // this try-catch can be removed when IE11 is completely unsupported & gone
+      this.removeOnAbort = new AbortController()
+    } catch (e) {}
 
     const thisInstrument = this
     thisInstrument.ee.on('fn-start', function (args, obj, methodName) {