@newrelic/browser-agent 0.1.231 → 1.232.0

package/dist/cjs/common/timer/interaction-timer.test.js

@@ -0,0 +1,216 @@
+"use strict";
+
+var _interactionTimer = require("./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.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.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.InteractionTimer({}, 100);
+    } catch (e) {
+      expect(e).toEqual(new Error('onEnd handler is required'));
+    }
+    try {
+      new _interactionTimer.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.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.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.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.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.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.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    timer1.create();
+    const timer2 = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    timer2.create(timer2.onEnd);
+    const timer3 = new _interactionTimer.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.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.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.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.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.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.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.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.isValid()).toEqual(true);
+    timer.startTimestamp -= 100;
+    expect(timer.isValid()).toEqual(false);
+  });
+});

package/dist/cjs/common/timer/timer.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Timer = void 0;
+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;
+  }
+}
+exports.Timer = Timer;

package/dist/cjs/common/timer/timer.test.js

@@ -0,0 +1,105 @@
+"use strict";
+
+var _timer = require("./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.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.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.Timer({}, 100);
+    } catch (e) {
+      expect(e).toEqual(new Error('onEnd handler is required'));
+    }
+    try {
+      new _timer.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.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.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    timer1.create();
+    const timer2 = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    timer2.create(timer2.onEnd);
+    const timer3 = new _timer.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.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.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.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.isValid()).toEqual(true);
+    timer.startTimestamp -= 100;
+    expect(timer.isValid()).toEqual(false);
+  });
+});

package/dist/cjs/common/unload/eol.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.subscribeToEOL = subscribeToEOL;
 var _firefoxVersion = require("../browser-version/firefox-version");
 var _eventListenerOpts = require("../event-listener/event-listener-opts");
-var _single = require("../util/single");
+var _invoke = require("../util/invoke");
 var _globalScope = require("../util/global-scope");
 var _pageVisibility = require("../window/page-visibility");
 /*
@@ -40,7 +40,7 @@ function subscribeToEOL(cb, allowBFCache) {
       (0, _eventListenerOpts.windowAddEventListener)('pagehide', cb); // when user navigates away, and because safari iOS v14.4- doesn't fully support vis change
       // --this ought to be removed once support for version below 14.5 phases out
     } else {
-      var oneCall = (0, _single.single)(cb);
+      var oneCall = (0, _invoke.single)(cb);
 
       // Firefox has a bug wherein a slow-loading resource loaded from the 'pagehide'
       // or 'unload' event will delay the 'load' event firing on the next page load.

package/dist/cjs/common/util/data-size.js

@@ -10,6 +10,12 @@ var _stringify = require("./stringify");
  * SPDX-License-Identifier: Apache-2.0
  */
 
+/**
+ * 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.
+ */
 function dataSize(data) {
   if (typeof data === 'string' && data.length) return data.length;
   if (typeof data !== 'object') return undefined;

package/dist/cjs/common/util/data-size.test.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _dataSize = require("./data-size");
+describe('dataSize', () => {
+  test('returns length of string', () => {
+    const str = 'Hello, world!';
+    expect((0, _dataSize.dataSize)(str)).toBe(str.length);
+  });
+  test('returns undefined for non-object, number, or empty string', () => {
+    expect((0, _dataSize.dataSize)(Infinity)).toBeUndefined();
+    expect((0, _dataSize.dataSize)(12345)).toBeUndefined(); // might not actually be by design, but this is how it works today
+    expect((0, _dataSize.dataSize)('')).toBeUndefined();
+  });
+  test('returns byte length of ArrayBuffer object', () => {
+    const buffer = new ArrayBuffer(8);
+    expect((0, _dataSize.dataSize)(buffer)).toBe(8);
+  });
+  test('returns size of Blob object', () => {
+    const blob = new Blob(['Hello, world!'], {
+      type: 'text/plain'
+    });
+    expect((0, _dataSize.dataSize)(blob)).toBe(blob.size);
+  });
+  test('returns undefined for FormData object', () => {
+    const formData = new FormData();
+    expect((0, _dataSize.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((0, _dataSize.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((0, _dataSize.dataSize)(obj)).toBeUndefined();
+  });
+});

package/dist/cjs/common/util/invoke.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.debounce = debounce;
+exports.single = single;
+/**
+ * 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.
+ */
+function debounce(func) {
+  var _this = this;
+  let timeout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 500;
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const leading = options?.leading || false;
+  let timer;
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    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.
+ */
+function single(func) {
+  var _this2 = this;
+  let called = false;
+  return function () {
+    if (!called) {
+      called = true;
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      func.apply(_this2, args);
+    }
+  };
+}

package/dist/cjs/common/util/invoke.test.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _invoke = require("./invoke");
+jest.useFakeTimers();
+describe('debounce', () => {
+  test('should run the supplied function after 100ms', () => {
+    let mockCallback = jest.fn();
+    let debouncedMethod = (0, _invoke.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 = (0, _invoke.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 = (0, _invoke.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 = (0, _invoke.single)(mockCallback, 100);
+    execFnTimes(singleMethod, 100);
+    expect(mockCallback).toHaveBeenCalledTimes(1);
+  });
+});
+function execFnTimes(fn, count) {
+  for (let i = 0; i < count; i++) {
+    fn();
+  }
+}

package/dist/cjs/common/util/obfuscate.js

@@ -15,10 +15,6 @@ var fileProtocolRule = {
   replacement: 'file://OBFUSCATED'
 };
 class Obfuscator extends _sharedContext.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/dist/cjs/common/window/page-visibility.js

@@ -17,7 +17,9 @@ var _eventListenerOpts = require("../event-listener/event-listener-opts");
  */
 function subscribeToVisibilityChange(cb) {
   let toHiddenOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  (0, _eventListenerOpts.documentAddEventListener)('visibilitychange', handleVisibilityChange);
+  let capture = arguments.length > 2 ? arguments[2] : undefined;
+  let abortSignal = arguments.length > 3 ? arguments[3] : undefined;
+  (0, _eventListenerOpts.documentAddEventListener)('visibilitychange', handleVisibilityChange, capture, abortSignal);
   return;
   function handleVisibilityChange() {
     if (toHiddenOnly) {

package/dist/cjs/common/wrap/wrap-timer.js

@@ -32,7 +32,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
 function wrapTimer(sharedEE) {
   const ee = scopedEE(sharedEE);
 

package/dist/cjs/features/ajax/aggregate/index.js

@@ -11,17 +11,17 @@ var _handle = require("../../../common/event-emitter/handle");
 var _config = require("../../../common/config/config");
 var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
 var _denyList = require("../../../common/deny-list/deny-list");
-var _aggregateBase = require("../../utils/aggregate-base");
 var _constants = require("../constants");
 var _drain = require("../../../common/drain/drain");
 var _features = require("../../../loaders/features/features");
 var _constants2 = require("../../metrics/constants");
+var _featureBase = require("../../utils/feature-base");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
-class Aggregate extends _aggregateBase.AggregateBase {
+class Aggregate extends _featureBase.FeatureBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, _constants.FEATURE_NAME);

package/dist/cjs/features/jserrors/aggregate/index.js

@@ -17,16 +17,16 @@ var _mapOwn = require("../../../common/util/map-own");
 var _config = require("../../../common/config/config");
 var _now = require("../../../common/timing/now");
 var _globalScope = require("../../../common/util/global-scope");
-var _aggregateBase = require("../../utils/aggregate-base");
 var _constants = require("../constants");
 var _drain = require("../../../common/drain/drain");
 var _features = require("../../../loaders/features/features");
+var _featureBase = require("../../utils/feature-base");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
-class Aggregate extends _aggregateBase.AggregateBase {
+class Aggregate extends _featureBase.FeatureBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     var _this;
@@ -216,6 +216,7 @@ class Aggregate extends _aggregateBase.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 = (0, _config.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] || [];
@@ -223,7 +224,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
     } else {
       // store custom attributes
       var customParams = {};
-      var att = (0, _config.getInfo)(this.agentIdentifier).jsAttributes;
       (0, _mapOwn.mapOwn)(att, setCustom);
       if (customAttributes) {
         (0, _mapOwn.mapOwn)(customAttributes, setCustom);