@newrelic/browser-agent 0.1.229 → 0.1.231

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

@@ -22,10 +22,12 @@ 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);
   var prevPromiseObj = originals.PR;
@@ -67,8 +69,7 @@ export function wrapPromise(sharedEE) {
       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
+        Array.from(subPromises || []).forEach(sub => {
           this.resolve(sub).then(setNrId(method === 'all'), setNrId(false));
         });
         const origFnCallWithThis = prevStaticFn.apply(this, arguments);
@@ -104,10 +105,13 @@ export function wrapPromise(sharedEE) {
 
     // Note that this wrapping affects the same originals.PR (prototype) object.
     const prevPromiseOrigThen = prevPromiseObj.prototype.then;
-    prevPromiseObj.prototype.then = function wrappedThen(...args) {
+    prevPromiseObj.prototype.then = function wrappedThen() {
       var originalThis = this;
       var ctx = getContext(originalThis);
       ctx.promise = originalThis;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
       args[0] = promiseWrapper(args[0], 'cb-', ctx, null, false);
       args[1] = promiseWrapper(args[1], 'cb-', ctx, null, false);
       const origFnCallWithThis = prevPromiseOrigThen.apply(this, args);

package/dist/esm/common/wrap/wrap-promise.test.js

@@ -0,0 +1,115 @@
+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 => function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    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/dist/esm/common/wrap/wrap-raf.js

@@ -8,7 +8,7 @@
  */
 
 import { ee as baseEE } from '../event-emitter/contextual-ee';
-import { createWrapperWithEmitter as wfn, unwrapFunction } from './wrap-function';
+import { createWrapperWithEmitter as wfn } from './wrap-function';
 import { isBrowserScope } from '../util/global-scope';
 const wrapped = {};
 const RAF_NAME = 'requestAnimationFrame';
@@ -21,12 +21,12 @@ 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);
   wrapFn.inPlace(window, [RAF_NAME], 'raf-');
   ee.on('raf-start', function (args) {

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

@@ -8,7 +8,7 @@
  */
 
 import { ee as baseEE } from '../event-emitter/contextual-ee';
-import { createWrapperWithEmitter as wfn, unwrapFunction } from './wrap-function';
+import { createWrapperWithEmitter as wfn } from './wrap-function';
 import { globalScope } from '../util/global-scope';
 const wrapped = {};
 const SET_TIMEOUT = 'setTimeout';
@@ -28,12 +28,12 @@ const TIMER_FNS = [SET_TIMEOUT, 'setImmediate', SET_INTERVAL, CLEAR_TIMEOUT, 'cl
 //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);
   wrapFn.inPlace(globalScope, TIMER_FNS.slice(0, 2), SET_TIMEOUT + DASH);
   wrapFn.inPlace(globalScope, TIMER_FNS.slice(2, 3), SET_INTERVAL + DASH);

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

@@ -7,10 +7,10 @@
  * This module is used by: ajax, jserrors, spa.
  */
 
-import { wrapEvents, unwrapEvents } from './wrap-events';
+import { wrapEvents } from './wrap-events';
 import { ee as contextualEE } from '../event-emitter/contextual-ee';
 import { eventListenerOpts } from '../event-listener/event-listener-opts';
-import { createWrapperWithEmitter as wfn, unwrapFunction } from './wrap-function';
+import { createWrapperWithEmitter as wfn } from './wrap-function';
 import { originals } from '../config/config';
 import { globalScope } from '../util/global-scope';
 import { warn } from '../util/console';
@@ -27,12 +27,11 @@ const XHR_PROPS = ['open', 'send']; // these are the specific funcs being wrappe
 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/dist/esm/features/ajax/aggregate/index.js

@@ -55,7 +55,7 @@ export class Aggregate extends AggregateBase {
         onFinished: onEventsHarvestFinished,
         getPayload: prepareHarvest
       }, this);
-      ee.on(`drain-${this.featureName}`, () => {
+      ee.on("drain-".concat(this.featureName), () => {
         scheduler.startTimer(harvestTimeSeconds);
       });
     }

package/dist/esm/features/ajax/instrument/index.js

@@ -23,7 +23,8 @@ var origRequest = originals.REQ;
 var origXHR = globalScope.XMLHttpRequest;
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
-  constructor(agentIdentifier, aggregator, auto = true) {
+  constructor(agentIdentifier, aggregator) {
+    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
 
     // Very unlikely, but in case the existing XMLHttpRequest.prototype object on the page couldn't be wrapped.

package/dist/esm/features/jserrors/aggregate/canonical-function-name.test.js

@@ -19,10 +19,11 @@ test.each([{
   input: '<anonymous>',
   expected: undefined,
   title: 'Return undefined ending is non-alphanumeric'
-}])('$title', ({
-  input,
-  expected
-}) => {
+}])('$title', _ref => {
+  let {
+    input,
+    expected
+  } = _ref;
   const result = canonicalFunctionName(input);
   expect(result).toEqual(expected);
 });

package/dist/esm/features/jserrors/aggregate/compute-stack-trace.js

@@ -56,7 +56,6 @@
 // INTERNET EXPLORER:
 // ex.message = ...
 // ex.name = ReferenceError
-import { reduce } from '../../../common/util/reduce';
 import { formatStackTrace } from './format-stack-trace';
 var debug = false;
 var classNameRegex = /function (.+?)\s*\(/;
@@ -113,7 +112,7 @@ function computeStackTraceFromStackProp(ex) {
   if (!ex.stack) {
     return null;
   }
-  var errorInfo = reduce(ex.stack.split('\n'), parseStackProp, {
+  var errorInfo = ex.stack.split('\n').reduce(parseStackProp, {
     frames: [],
     stackLines: [],
     wrapperSeen: false

package/dist/esm/features/jserrors/aggregate/compute-stack-trace.test.js

@@ -144,7 +144,7 @@ describe('errors without stack property and with line property', () => {
       mode: 'sourceline',
       name: mockError.name,
       message: mockError.message,
-      stackString: `${mockError.name}: ${mockError.message}\n    at ${sourceURL}:${mockError.line}`
+      stackString: "".concat(mockError.name, ": ").concat(mockError.message, "\n    at ").concat(sourceURL, ":").concat(mockError.line)
     }));
     expect(result.frames.length).toEqual(1);
     expect(result.frames).toContainEqual(expect.objectContaining({
@@ -170,7 +170,7 @@ describe('errors without stack property and with line property', () => {
       mode: 'sourceline',
       name: mockError.name,
       message: mockError.message,
-      stackString: `${mockError.name}: ${mockError.message}\n    at ${sourceURL}:${mockError.line}:${mockError.column}`
+      stackString: "".concat(mockError.name, ": ").concat(mockError.message, "\n    at ").concat(sourceURL, ":").concat(mockError.line, ":").concat(mockError.column)
     }));
     expect(result.frames.length).toEqual(1);
     expect(result.frames).toContainEqual(expect.objectContaining({
@@ -191,7 +191,7 @@ describe('errors without stack property and with line property', () => {
       mode: 'sourceline',
       name: mockError.name,
       message: mockError.message,
-      stackString: `RangeError: ${mockError.message}\n    in evaluated code`
+      stackString: "RangeError: ".concat(mockError.message, "\n    in evaluated code")
     }));
     expect(result.frames.length).toEqual(1);
     expect(result.frames).toContainEqual(expect.objectContaining({
@@ -230,7 +230,7 @@ describe('errors that are messages only or primitives', () => {
     expect(result).toEqual(expect.objectContaining({
       mode: 'nameonly',
       name: mockError.name,
-      stackString: `${mockError.name}: undefined`,
+      stackString: "".concat(mockError.name, ": undefined"),
       frames: []
     }));
   });
@@ -246,7 +246,7 @@ describe('errors that are messages only or primitives', () => {
       mode: 'nameonly',
       name: mockError.name,
       message: mockError.message,
-      stackString: `${mockError.name}: ${mockError.message}`,
+      stackString: "".concat(mockError.name, ": ").concat(mockError.message),
       frames: []
     }));
   });

package/dist/esm/features/jserrors/aggregate/format-stack-trace.test.js

@@ -13,16 +13,17 @@ describe('formatStackTrace', () => {
     input: ['line 1', 'line 2', ''],
     expected: 'line 1\nline 2',
     title: 'Strips ending empty stack frame'
-  }])('$title', ({
-    input,
-    expected
-  }) => {
+  }])('$title', _ref => {
+    let {
+      input,
+      expected
+    } = _ref;
     const result = formatStackTrace(input);
     expect(result).toEqual(expected);
   });
   test('truncates the middle of the stack lines when more than 100', () => {
     const input = Array.apply(null, Array(200)).map(() => faker.datatype.uuid());
-    const expected = input.slice(0, 50).join('\n') + `\n< ...truncated ${input.length - 100} lines... >\n` + input.slice(-50).join('\n');
+    const expected = input.slice(0, 50).join('\n') + "\n< ...truncated ".concat(input.length - 100, " lines... >\n") + input.slice(-50).join('\n');
     const result = formatStackTrace(input);
     expect(result).toEqual(expected);
   });

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

@@ -20,11 +20,12 @@ 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 { onWindowLoad } from '../../../common/window/load';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
+    var _this;
     super(agentIdentifier, aggregator, FEATURE_NAME);
+    _this = this;
     this.stackReported = {};
     this.pageviewReported = {};
     this.errorCache = {};
@@ -36,16 +37,24 @@ export class Aggregate extends AggregateBase {
 
     // this will need to change to match whatever ee we use in the instrument
     this.ee.on('interactionDiscarded', interaction => this.onInteractionDiscarded(interaction));
-    register('err', (...args) => this.storeError(...args), this.featureName, this.ee);
-    register('ierr', (...args) => this.storeError(...args), this.featureName, this.ee);
+    register('err', function () {
+      return _this.storeError(...arguments);
+    }, this.featureName, this.ee);
+    register('ierr', function () {
+      return _this.storeError(...arguments);
+    }, this.featureName, this.ee);
     const harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'jserrors.harvestTimeSeconds') || 10;
     const scheduler = new HarvestScheduler('jserrors', {
-      onFinished: (...args) => this.onHarvestFinished(...args)
+      onFinished: function () {
+        return _this.onHarvestFinished(...arguments);
+      }
     }, this);
-    scheduler.harvest.on('jserrors', (...args) => this.onHarvestStarted(...args));
+    scheduler.harvest.on('jserrors', function () {
+      return _this.onHarvestStarted(...arguments);
+    });
 
     // Don't start harvesting until "drain" for this feat has been called (which currently requires RUM response).
-    this.ee.on(`drain-${this.featureName}`, () => {
+    this.ee.on("drain-".concat(this.featureName), () => {
       if (!this.blocked) scheduler.startTimer(harvestTimeSeconds); // and only if ingest will accept jserror payloads
     });
 
@@ -89,7 +98,7 @@ export class Aggregate extends AggregateBase {
     }
   }
   nameHash(params) {
-    return stringHashCode(`${params.exceptionClass}_${params.message}_${params.stack_trace || params.browser_stack_hash}`);
+    return stringHashCode("".concat(params.exceptionClass, "_").concat(params.message, "_").concat(params.stack_trace || params.browser_stack_hash));
   }
   getBucketName(params, customParams) {
     return this.nameHash(params) + ':' + stringHashCode(stringify(customParams));
@@ -141,17 +150,29 @@ export class Aggregate extends AggregateBase {
   storeError(err, time, internal, customAttributes) {
     // are we in an interaction
     time = time || now();
-    if (!internal && getRuntime(this.agentIdentifier).onerror && getRuntime(this.agentIdentifier).onerror(err)) return;
+    const agentRuntime = getRuntime(this.agentIdentifier);
+    let filterOutput;
+    if (!internal && agentRuntime.onerror) {
+      filterOutput = agentRuntime.onerror(err);
+      if (filterOutput && !(typeof filterOutput.group === 'string' && filterOutput.group.length)) {
+        // All truthy values mean don't report (store) the error, per backwards-compatible usage,
+        // - EXCEPT if a fingerprinting label is returned, via an object with key of 'group' and value of non-empty string
+        return;
+      }
+      // Again as with previous usage, all falsey values would include the error.
+    }
+
     var stackInfo = this.canonicalizeStackURLs(computeStackTrace(err));
     var canonicalStack = this.buildCanonicalStackString(stackInfo);
-    var params = {
+    const params = {
       stackHash: stringHashCode(canonicalStack),
       exceptionClass: stackInfo.name,
       request_uri: globalScope?.location.pathname
     };
-    if (stackInfo.message) {
-      params.message = '' + stackInfo.message;
-    }
+    if (stackInfo.message) params.message = '' + stackInfo.message;
+    // Notice if filterOutput isn't false|undefined OR our specified object, this func would've returned already (so it's unnecessary to req-check group).
+    // Do not modify the name ('errorGroup') of params without DEM approval!
+    if (filterOutput?.group) params.errorGroup = filterOutput.group;
 
     /**
      * The bucketHash is different from the params.stackHash because the params.stackHash is based on the canonicalized
@@ -159,14 +180,14 @@ export class Aggregate extends AggregateBase {
      * the canonical stack trace excludes items like the column number increasing the hit-rate of different errors potentially
      * bucketing and ultimately resulting in the loss of data in NR1.
      */
-    var bucketHash = stringHashCode(`${stackInfo.name}_${stackInfo.message}_${stackInfo.stackString}`);
+    var bucketHash = stringHashCode("".concat(stackInfo.name, "_").concat(stackInfo.message, "_").concat(stackInfo.stackString));
     if (!this.stackReported[bucketHash]) {
       this.stackReported[bucketHash] = true;
       params.stack_trace = truncateSize(stackInfo.stackString);
     } else {
       params.browser_stack_hash = stringHashCode(stackInfo.stackString);
     }
-    params.releaseIds = stringify(getRuntime(this.agentIdentifier).releaseIds);
+    params.releaseIds = stringify(agentRuntime.releaseIds);
 
     // When debugging stack canonicalization/hashing, uncomment these lines for
     // more output in the test logs

package/dist/esm/features/jserrors/aggregate/string-hash-code.test.js

@@ -15,10 +15,11 @@ test.each([{
   input: 'lksjdflksjdf',
   expected: 32668720,
   title: 'Return valid hash of string'
-}])('$title', ({
-  input,
-  expected
-}) => {
+}])('$title', _ref => {
+  let {
+    input,
+    expected
+  } = _ref;
   const result = stringHashCode(input);
   expect(result).toEqual(expected);
 });

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

@@ -18,16 +18,16 @@ import { getRuntime } from '../../../common/config/config';
 import { stringify } from '../../../common/util/stringify';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
-  constructor(agentIdentifier, aggregator, auto = true) {
+  constructor(agentIdentifier, aggregator) {
+    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
     // skipNext counter to keep track of uncaught
     // errors that will be the same as caught errors.
     this.skipNext = 0;
-    this.origOnerror = globalScope.onerror;
     try {
+      // this try-catch can be removed when IE11 is completely unsupported & gone
       this.removeOnAbort = new AbortController();
-    } // this try-catch can be removed when IE11 is completely unsupported & gone
-    catch (e) {}
+    } catch (e) {}
     const thisInstrument = this;
     thisInstrument.ee.on('fn-start', function (args, obj, methodName) {
       if (thisInstrument.abortHandler) thisInstrument.skipNext += 1;
@@ -49,12 +49,9 @@ export class Instrument extends InstrumentBase {
       handle('ierr', [e, now(), true], undefined, FEATURE_NAMES.jserrors, thisInstrument.ee);
     });
 
-    // Tack on our error handler onto the existing global one.
-    globalScope.onerror = (...args) => {
-      if (this.origOnerror) this.origOnerror(...args);
-      this.onerrorHandler(...args);
-      return false;
-    };
+    // Replace global error handler with our own.
+    this.origOnerror = globalScope.onerror;
+    globalScope.onerror = this.onerrorHandler.bind(this);
     globalScope.addEventListener('unhandledrejection', e => {
       /** rejections can contain data of any type -- this is an effort to keep the message human readable */
       const err = castReasonToError(e.reason);
@@ -87,6 +84,7 @@ export class Instrument extends InstrumentBase {
    * @returns
    */
   onerrorHandler(message, filename, lineno, column, errorObj) {
+    if (typeof this.origOnerror === 'function') this.origOnerror(...arguments);
     try {
       if (this.skipNext) this.skipNext -= 1;else notice(errorObj || new UncaughtException(message, filename, lineno), true, this.ee);
     } catch (e) {
@@ -96,8 +94,7 @@ export class Instrument extends InstrumentBase {
         // do nothing
       }
     }
-    if (typeof this.origOnerror === 'function') return this.origOnerror.apply(this, slice(arguments));
-    return false;
+    return false; // maintain default behavior of the error event of Window
   }
 }
 

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

@@ -5,9 +5,9 @@ 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';
-import { protocol } from '../../../common/url/protocol';
+import { isFileProtocol } from '../../../common/url/protocol';
 import { getRules, validateRules } from '../../../common/util/obfuscate';
-import { VERSION } from '../../../common/constants/environment-variables';
+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';
@@ -58,14 +58,14 @@ export class Aggregate extends AggregateBase {
   singleChecks() {
     // report generic info about the agent itself
     // note the browser agent version
-    this.storeSupportabilityMetrics(`Generic/Version/${VERSION}/Detected`);
+    this.storeSupportabilityMetrics("Generic/Version/".concat(VERSION, "/Detected"));
     // report loaderType
     const {
       distMethod,
       loaderType
     } = getRuntime(this.agentIdentifier);
-    if (loaderType) this.storeSupportabilityMetrics(`Generic/LoaderType/${loaderType}/Detected`);
-    if (distMethod) this.storeSupportabilityMetrics(`Generic/DistMethod/${distMethod}/Detected`);
+    if (loaderType) this.storeSupportabilityMetrics("Generic/LoaderType/".concat(loaderType, "/Detected"));
+    if (distMethod) this.storeSupportabilityMetrics("Generic/DistMethod/".concat(distMethod, "/Detected"));
 
     // frameworks on page
     if (isBrowserScope) {
@@ -77,9 +77,8 @@ export class Aggregate extends AggregateBase {
     }
 
     // file protocol detection
-    if (protocol.isFileProtocol()) {
+    if (isFileProtocol()) {
       this.storeSupportabilityMetrics('Generic/FileProtocol/Detected');
-      protocol.supportabilityMetricSent = true;
     }
 
     // obfuscation rules detection
@@ -103,6 +102,7 @@ export class Aggregate extends AggregateBase {
     // TODO - these SMs are to be removed when we implement the actual resources feature
     try {
       if (this.resourcesSent) return;
+      const agentRuntime = getRuntime(this.agentIdentifier);
       // make sure this only gets sent once
       this.resourcesSent = true;
       // differentiate between internal+external and ajax+non-ajax
@@ -122,6 +122,16 @@ export class Aggregate extends AggregateBase {
           if (isAjax(entry)) this.storeSupportabilityMetrics('Generic/Resources/Ajax/External');else this.storeSupportabilityMetrics('Generic/Resources/Non-Ajax/External');
         }
       });
+
+      // Capture per-agent 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), "/BytesSent"), agentRuntime.bytesSent[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()));
+      }
     } catch (e) {
       // do nothing
     }

package/dist/esm/features/metrics/instrument/index.js

@@ -5,7 +5,8 @@ import { handle } from '../../../common/event-emitter/handle';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
-  constructor(agentIdentifier, aggregator, auto = true) {
+  constructor(agentIdentifier, aggregator) {
+    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
     insertSupportMetrics(tag => handle(SUPPORTABILITY_METRIC_CHANNEL, [tag], undefined, FEATURE_NAMES.metrics, this.ee));
     this.importAggregator();