@newrelic/browser-agent 0.1.231 → 1.232.0

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

@@ -0,0 +1,214 @@
+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/dist/esm/common/timer/timer.js

@@ -0,0 +1,25 @@
+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/dist/esm/common/timer/timer.test.js

@@ -0,0 +1,103 @@
+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/dist/esm/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';
 if (isWorkerScope) {

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

@@ -4,6 +4,13 @@
  */
 
 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/dist/esm/common/util/data-size.test.js

@@ -0,0 +1,45 @@
+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/dist/esm/common/util/invoke.js

@@ -0,0 +1,66 @@
+/**
+ * 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) {
+  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.
+ */
+export 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/esm/common/util/invoke.test.js

@@ -0,0 +1,47 @@
+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/dist/esm/common/util/obfuscate.js

@@ -7,10 +7,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/dist/esm/common/window/page-visibility.js

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

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

@@ -25,7 +25,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/dist/esm/features/ajax/aggregate/index.js

@@ -9,12 +9,12 @@ 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';
-export class Aggregate extends AggregateBase {
+import { FeatureBase } from '../../utils/feature-base';
+export class Aggregate extends FeatureBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME);

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

@@ -16,11 +16,11 @@ import { mapOwn } from '../../../common/util/map-own';
 import { getInfo, getConfigurationValue, getRuntime } from '../../../common/config/config';
 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';
-export class Aggregate extends AggregateBase {
+import { FeatureBase } from '../../utils/feature-base';
+export class Aggregate extends FeatureBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     var _this;
@@ -210,6 +210,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] || [];
@@ -217,7 +218,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/dist/esm/features/metrics/aggregate/index.js

@@ -1,7 +1,6 @@
-import { getRuntime } from '../../../common/config/config';
+import { getRuntime, getInfo } from '../../../common/config/config';
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
-import { AggregateBase } from '../../utils/aggregate-base';
 import { FEATURE_NAME, SUPPORTABILITY_METRIC, CUSTOM_METRIC, SUPPORTABILITY_METRIC_CHANNEL, CUSTOM_METRIC_CHANNEL } from '../constants';
 import { drain } from '../../../common/drain/drain';
 import { getFrameworks } from '../../../common/metrics/framework-detection';
@@ -11,7 +10,9 @@ import { VERSION } from "../../../common/constants/env.npm";
 import { onDOMContentLoaded } from '../../../common/window/load';
 import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts';
 import { isBrowserScope } from '../../../common/util/global-scope';
-export class Aggregate extends AggregateBase {
+import { FeatureBase } from '../../utils/feature-base';
+import { stringify } from '../../../common/util/stringify';
+export class Aggregate extends FeatureBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME);
@@ -103,6 +104,7 @@ export class Aggregate extends AggregateBase {
     try {
       if (this.resourcesSent) return;
       const agentRuntime = getRuntime(this.agentIdentifier);
+      const info = getInfo(this.agentIdentifier);
       // make sure this only gets sent once
       this.resourcesSent = true;
       // differentiate between internal+external and ajax+non-ajax
@@ -128,10 +130,19 @@ export class Aggregate extends AggregateBase {
         this.storeSupportabilityMetrics("PageSession/Endpoint/".concat(endpoint.charAt(0).toUpperCase() + endpoint.slice(1), "/BytesSent"), agentRuntime.bytesSent[endpoint]);
       });
 
+      // Capture per-agent query bytes sent for each endpoint (see harvest) and RUM call (see page_view_event aggregator).
+      Object.keys(agentRuntime.bytesSent).forEach(endpoint => {
+        this.storeSupportabilityMetrics("PageSession/Endpoint/".concat(endpoint.charAt(0).toUpperCase() + endpoint.slice(1), "/QueryBytesSent"), agentRuntime.queryBytesSent[endpoint]);
+      });
+
       // Capture metrics for session trace if active (`ptid` is set when returned by replay ingest).
       if (agentRuntime.ptid) {
         this.storeSupportabilityMetrics('PageSession/Feature/SessionTrace/DurationMs', Math.round(performance.now()));
       }
+
+      // Capture metrics for size of custom attributes
+      const jsAttributes = stringify(info.jsAttributes);
+      this.storeSupportabilityMetrics('PageSession/Feature/CustomData/Bytes', jsAttributes === '{}' ? 0 : jsAttributes.length);
     } catch (e) {
       // do nothing
     }

package/dist/esm/features/page_action/aggregate/index.js

@@ -9,11 +9,11 @@ import { registerHandler as register } from '../../../common/event-emitter/regis
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { cleanURL } from '../../../common/url/clean-url';
 import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config';
-import { AggregateBase } from '../../utils/aggregate-base';
 import { FEATURE_NAME } from '../constants';
 import { drain } from '../../../common/drain/drain';
 import { isBrowserScope } from '../../../common/util/global-scope';
-export class Aggregate extends AggregateBase {
+import { FeatureBase } from '../../utils/feature-base';
+export class Aggregate extends FeatureBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     var _this;