@newrelic/browser-agent 0.1.231 → 1.232.0

package/src/common/storage/local-storage.test.js

@@ -0,0 +1,17 @@
+import { LocalStorage } from './local-storage'
+
+test('Local-memory', () => {
+  const LS = new LocalStorage()
+
+  LS.set('test', 1)
+  expect(LS.get('test')).toEqual('1')
+
+  LS.set('test')
+  expect(LS.get('test')).toEqual(undefined)
+
+  LS.set('test', 2)
+  expect(LS.get('test')).toEqual('2')
+
+  LS.remove('test')
+  expect(LS.get('test')).toEqual(undefined)
+})

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

@@ -0,0 +1,75 @@
+import { Timer } from './timer'
+import { subscribeToVisibilityChange } from '../window/page-visibility'
+import { debounce } from '../util/invoke'
+import { isBrowserScope } from '../util/global-scope'
+
+export class InteractionTimer extends Timer {
+  constructor (opts, ms) {
+    super(opts, ms)
+    this.onRefresh = opts.onRefresh
+    this.onPause = opts.onPause
+
+    // used by pause/resume
+    this.remainingMs = undefined
+
+    if (!opts.refreshEvents) opts.refreshEvents = ['click', 'keydown', 'scroll']
+
+    // the abort controller is used to "reset" the event listeners and prevent them from duplicating when new sessions are created
+    try {
+      this.abortController = new AbortController()
+    } catch (e) {
+      // this try-catch can be removed when IE11 is completely unsupported & gone
+    }
+
+    if (isBrowserScope && opts.ee) {
+      if (opts.ee) {
+        const debouncedRefresh = debounce(this.refresh.bind(this), 500, { leading: true })
+        opts.ee.on('fn-end', (evts) => {
+          if (opts.refreshEvents.includes(evts?.[0]?.type)) {
+            debouncedRefresh()
+          }
+        })
+      }
+
+      // watch for the vis state changing.  If the page is hidden, the local inactivity timer should be paused
+      // if the page is brought BACK to visibility and the timer hasnt "naturally" expired, refresh the timer...
+      // this is to support the concept that other tabs could be experiencing activity.  The thought would be that
+      // "backgrounded" tabs would pause, while "closed" tabs that "reopen" will just instantiate a new SessionEntity class if restored
+      // which will do a "hard" check of the timestamps.
+
+      // NOTE -- this does not account for 2 browser windows open side by side, blurring/focusing between them
+      // IF DEEMED necessary, more event handling would be needed to account for this.
+      subscribeToVisibilityChange((state) => {
+        if (state === 'hidden') this.pause()
+        // vis change --> visible is treated like a new interaction with the page
+        else this.refresh()
+      }, false, false, this.abortController?.signal)
+    }
+  }
+
+  abort () {
+    this.clear()
+    this.abortController?.abort()
+  }
+
+  pause () {
+    this.onPause?.()
+    clearTimeout(this.timer)
+    this.remainingMs = this.initialMs - (Date.now() - this.startTimestamp)
+  }
+
+  refresh (cb, ms) {
+    this.clear()
+    this.timer = this.create(cb, ms)
+    this.startTimestamp = Date.now()
+    this.remainingMs = undefined
+    this.onRefresh?.()
+  }
+
+  // NOT CURRENTLY UTILIZED BY ANYTHING
+  // resume () {
+  //   if (!this.remainingMs || !this.isValid()) return
+  //   this.timer = this.create(this.cb, this.remainingMs)
+  //   this.remainingMs = undefined
+  // }
+}

package/src/common/timer/interaction-timer.test.js

@@ -0,0 +1,167 @@
+import { InteractionTimer } from './interaction-timer'
+
+jest.useFakeTimers()
+
+let now
+
+beforeEach(() => {
+  now = Date.now()
+  jest.setSystemTime(now)
+})
+
+afterEach(() => {
+  jest.clearAllMocks()
+})
+
+describe('constructor', () => {
+  test('appropriate properties are set with valid values -- no refresh', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    const requiredKeys = ['onEnd', 'initialMs', 'startTimestamp', 'timer']
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy()
+  })
+
+  test('appropriate properties are set with valid values -- with refresh', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    const requiredKeys = ['onEnd', 'refresh', 'initialMs', 'startTimestamp', 'timer']
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy()
+  })
+
+  test('required keys are enforced', () => {
+    try {
+      new InteractionTimer({}, 100)
+    } catch (e) {
+      expect(e).toEqual(new Error('onEnd handler is required'))
+    }
+
+    try {
+      new InteractionTimer({ onEnd: jest.fn() })
+    } catch (e) {
+      expect(e).toEqual(new Error('ms duration is required'))
+    }
+  })
+
+  test('refresh type timers set event listeners', () => {
+    // eslint-disable-next-line
+    let ee = { on: jest.fn().mockImplementation((evt, cb) => { cb([{ type: 'click' }]) }) }
+    let it = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn(), ee }, 100)
+    // scroll, keypress, click
+    expect(ee.on).toHaveBeenCalledTimes(1)
+    expect(it.onRefresh).toHaveBeenCalledTimes(1)
+
+    // eslint-disable-next-line
+     ee = { on: jest.fn().mockImplementation((evt, cb) => { cb([{ type: 'scroll' }]) }) }
+    it = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn(), ee }, 100)
+    // scroll, keypress, click
+    expect(ee.on).toHaveBeenCalledTimes(1)
+    expect(it.onRefresh).toHaveBeenCalledTimes(1)
+
+    // eslint-disable-next-line
+     ee = { on: jest.fn().mockImplementation((evt, cb) => { cb([{ type: 'keydown' }]) }) }
+    it = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn(), ee }, 100)
+    // scroll, keypress, click
+    expect(ee.on).toHaveBeenCalledTimes(1)
+    expect(it.onRefresh).toHaveBeenCalledTimes(1)
+
+    const aelSpy = jest.spyOn(document, 'addEventListener')
+    // eslint-disable-next-line
+    ee = { on: jest.fn().mockImplementation((evt, cb) => { cb([{ type: 'keydown' }]) }) }
+    it = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn(), ee }, 100)
+    // visibility change
+    expect(aelSpy).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('create()', () => {
+  test('Create sets a timeout that can execute a cb', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    expect(timer.timer).toBeTruthy()
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    jest.runOnlyPendingTimers()
+    expect(timer.onEnd).toHaveBeenCalledTimes(1)
+  })
+
+  test('Create can fallback to use defaults', () => {
+    let called = 0
+    const timer1 = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    timer1.create()
+
+    const timer2 = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    timer2.create(timer2.onEnd)
+
+    const timer3 = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    timer3.create(undefined, 100)
+
+    jest.runAllTimers(200)
+
+    expect(timer1.onEnd).toHaveBeenCalledTimes(1)
+    expect(timer2.onEnd).toHaveBeenCalledTimes(1)
+    expect(timer3.onEnd).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('refresh()', () => {
+  test('refresh prevents the callback from firing', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn() }, 100)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    jest.advanceTimersByTime(75)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    timer.refresh()
+    jest.advanceTimersByTime(75)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    jest.advanceTimersByTime(100)
+    expect(timer.onEnd).toHaveBeenCalledTimes(1)
+  })
+
+  test('refresh executes a callback for consumers', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn() }, 100)
+    timer.refresh()
+    expect(timer.onRefresh).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('pause()', () => {
+  test('pause prevents the callback from firing', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    timer.pause()
+    jest.advanceTimersByTime(150)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+  })
+
+  test('pause sets remainingMs timestamp', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    expect(timer.remainingMs).toEqual(undefined)
+    timer.pause()
+    expect(timer.remainingMs).toEqual(timer.initialMs - (now - timer.startTimestamp))
+  })
+})
+
+describe('clear()', () => {
+  test('clear prevents the callback from firing and deletes the pointer', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    timer.clear()
+    jest.advanceTimersByTime(150)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    expect(timer.timer).toEqual(null)
+  })
+})
+
+describe('end()', () => {
+  test('end clears the callback and calls the onEnd callback', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    timer.end()
+    expect(timer.onEnd).toHaveBeenCalledTimes(1)
+    expect(timer.timer).toEqual(null)
+  })
+})
+
+describe('isValid', () => {
+  test('isValid validates timeStamps', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    expect(timer.isValid()).toEqual(true)
+    timer.startTimestamp -= 100
+    expect(timer.isValid()).toEqual(false)
+  })
+})

package/src/common/timer/timer.js

@@ -0,0 +1,31 @@
+
+export class Timer {
+  constructor (opts, ms) {
+    if (!opts.onEnd) throw new Error('onEnd handler is required')
+    if (!ms) throw new Error('ms duration is required')
+    this.onEnd = opts.onEnd
+    this.initialMs = ms
+    this.startTimestamp = Date.now()
+
+    this.timer = this.create(this.onEnd, ms)
+  }
+
+  create (cb, ms) {
+    if (this.timer) this.clear()
+    return setTimeout(() => cb ? cb() : this.onEnd(), ms || this.initialMs)
+  }
+
+  clear () {
+    clearTimeout(this.timer)
+    this.timer = null
+  }
+
+  end () {
+    this.clear()
+    this.onEnd()
+  }
+
+  isValid () {
+    return this.initialMs - (Date.now() - this.startTimestamp) > 0
+  }
+}

package/src/common/timer/timer.test.js

@@ -0,0 +1,100 @@
+import { Timer } from './timer'
+
+jest.useFakeTimers()
+
+let now
+
+beforeEach(() => {
+  now = Date.now()
+  jest.setSystemTime(now)
+})
+
+afterEach(() => {
+  jest.clearAllMocks()
+})
+
+describe('constructor', () => {
+  test('appropriate properties are set with valid values -- no refresh', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    const requiredKeys = ['onEnd', 'initialMs', 'startTimestamp', 'timer']
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy()
+  })
+
+  test('appropriate properties are set with valid values -- with refresh', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    const requiredKeys = ['onEnd', 'initialMs', 'startTimestamp', 'timer']
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy()
+  })
+
+  test('required keys are enforced', () => {
+    try {
+      new Timer({}, 100)
+    } catch (e) {
+      expect(e).toEqual(new Error('onEnd handler is required'))
+    }
+
+    try {
+      new Timer({ onEnd: jest.fn() })
+    } catch (e) {
+      expect(e).toEqual(new Error('ms duration is required'))
+    }
+  })
+})
+
+describe('create()', () => {
+  test('Create sets a timeout that can execute a cb', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    expect(timer.timer).toBeTruthy()
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    jest.runOnlyPendingTimers()
+    expect(timer.onEnd).toHaveBeenCalledTimes(1)
+  })
+
+  test('Create can fallback to use defaults', () => {
+    let called = 0
+    const timer1 = new Timer({ onEnd: jest.fn() }, 100)
+    timer1.create()
+
+    const timer2 = new Timer({ onEnd: jest.fn() }, 100)
+    timer2.create(timer2.onEnd)
+
+    const timer3 = new Timer({ onEnd: jest.fn() }, 100)
+    timer3.create(undefined, 100)
+
+    jest.runAllTimers(200)
+
+    expect(timer1.onEnd).toHaveBeenCalledTimes(1)
+    expect(timer2.onEnd).toHaveBeenCalledTimes(1)
+    expect(timer3.onEnd).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('clear()', () => {
+  test('clear prevents the callback from firing and deletes the pointer', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    timer.clear()
+    jest.advanceTimersByTime(150)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    expect(timer.timer).toEqual(null)
+  })
+})
+
+describe('end()', () => {
+  test('end clears the callback and calls the onEnd callback', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    timer.end()
+    expect(timer.onEnd).toHaveBeenCalledTimes(1)
+    expect(timer.timer).toEqual(null)
+  })
+})
+
+describe('isValid', () => {
+  test('isValid validates timeStamps', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    expect(timer.isValid()).toEqual(true)
+    timer.startTimestamp -= 100
+    expect(timer.isValid()).toEqual(false)
+  })
+})

package/src/common/unload/eol.js

@@ -4,7 +4,7 @@
  */
 import { ffVersion } from '../browser-version/firefox-version'
 import { windowAddEventListener } from '../event-listener/event-listener-opts'
-import { single } from '../util/single'
+import { single } from '../util/invoke'
 import { globalScope, isWorkerScope, isBrowserScope } from '../util/global-scope'
 import { subscribeToVisibilityChange } from '../window/page-visibility'
 

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/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

@@ -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
   }

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

@@ -10,8 +10,8 @@ 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 () {

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

@@ -26,7 +26,7 @@ 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)
 

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/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)