@newrelic/browser-agent 1.232.1 → 1.233.0

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

@@ -75,7 +75,7 @@ function wrapFetch(sharedEE) {
     var fn = target[name];
     if (typeof fn === 'function') {
       target[name] = function () {
-        var args = Array.from(arguments);
+        var args = [...arguments];
         var ctx = {};
         // we are wrapping args in an array so we can preserve the reference
         ee.emit(prefix + 'before-start', [args], ctx);

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

@@ -81,7 +81,7 @@ function createWrapperWithEmitter(emitter, always) {
       var result;
       try {
         originalThis = this;
-        args = Array.from(arguments);
+        args = [...arguments];
         if (typeof getContext === 'function') {
           ctx = getContext(args, originalThis);
         } else {

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

@@ -76,7 +76,7 @@ function wrapPromise(sharedEE) {
       WrappedPromise[method] = function (subPromises) {
         // use our own wrapped version of "Promise.all" and ".race" static fns
         let finalized = false;
-        Array.from(subPromises || []).forEach(sub => {
+        [...(subPromises || [])].forEach(sub => {
           this.resolve(sub).then(setNrId(method === 'all'), setNrId(false));
         });
         const origFnCallWithThis = prevStaticFn.apply(this, arguments);

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

@@ -15,13 +15,13 @@ 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");
+var _aggregateBase = require("../../utils/aggregate-base");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
-class Aggregate extends _featureBase.FeatureBase {
+class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, _constants.FEATURE_NAME);

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

@@ -19,7 +19,7 @@ var _globalScope = require("../../../common/util/global-scope");
 var _constants = require("../constants");
 var _drain = require("../../../common/drain/drain");
 var _features = require("../../../loaders/features/features");
-var _featureBase = require("../../utils/feature-base");
+var _aggregateBase = require("../../utils/aggregate-base");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -29,7 +29,7 @@ var _featureBase = require("../../utils/feature-base");
  * @typedef {import('./compute-stack-trace.js').StackInfo} StackInfo
  */
 
-class Aggregate extends _featureBase.FeatureBase {
+class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     var _this;
@@ -188,10 +188,12 @@ class Aggregate extends _featureBase.FeatureBase {
       time: time
     };
 
-    // stn and spa aggregators listen to this event - stn sends the error in its payload,
+    // sr, stn and spa aggregators listen to this event - stn sends the error in its payload,
     // and spa annotates the error with interaction info
-    (0, _handle.handle)('errorAgg', [type, bucketHash, params, newMetrics], undefined, _features.FEATURE_NAMES.sessionTrace, this.ee);
-    (0, _handle.handle)('errorAgg', [type, bucketHash, params, newMetrics], undefined, _features.FEATURE_NAMES.spa, this.ee);
+    const msg = [type, bucketHash, params, newMetrics];
+    (0, _handle.handle)('errorAgg', msg, undefined, _features.FEATURE_NAMES.sessionTrace, this.ee);
+    (0, _handle.handle)('errorAgg', msg, undefined, _features.FEATURE_NAMES.spa, this.ee);
+    (0, _handle.handle)('errorAgg', msg, undefined, _features.FEATURE_NAMES.sessionReplay, this.ee);
 
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return;

package/dist/cjs/features/metrics/aggregate/framework-detection.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getFrameworks = getFrameworks;
+var _globalScope = require("../../../common/util/global-scope");
+const FRAMEWORKS = {
+  REACT: 'React',
+  ANGULAR: 'Angular',
+  ANGULARJS: 'AngularJS',
+  BACKBONE: 'Backbone',
+  EMBER: 'Ember',
+  VUE: 'Vue',
+  METEOR: 'Meteor',
+  ZEPTO: 'Zepto',
+  JQUERY: 'Jquery',
+  MOOTOOLS: 'MooTools'
+};
+function getFrameworks() {
+  if (!_globalScope.isBrowserScope) return []; // don't bother detecting frameworks if not in the main window context
+
+  const frameworks = [];
+  try {
+    if (detectReact()) frameworks.push(FRAMEWORKS.REACT);
+    if (detectAngularJs()) frameworks.push(FRAMEWORKS.ANGULARJS);
+    if (detectAngular()) frameworks.push(FRAMEWORKS.ANGULAR);
+    if (Object.prototype.hasOwnProperty.call(window, 'Backbone')) frameworks.push(FRAMEWORKS.BACKBONE);
+    if (Object.prototype.hasOwnProperty.call(window, 'Ember')) frameworks.push(FRAMEWORKS.EMBER);
+    if (Object.prototype.hasOwnProperty.call(window, 'Vue')) frameworks.push(FRAMEWORKS.VUE);
+    if (Object.prototype.hasOwnProperty.call(window, 'Meteor')) frameworks.push(FRAMEWORKS.METEOR);
+    if (Object.prototype.hasOwnProperty.call(window, 'Zepto')) frameworks.push(FRAMEWORKS.ZEPTO);
+    if (Object.prototype.hasOwnProperty.call(window, 'jQuery')) frameworks.push(FRAMEWORKS.JQUERY);
+    if (Object.prototype.hasOwnProperty.call(window, 'MooTools')) frameworks.push(FRAMEWORKS.MOOTOOLS);
+  } catch (err) {
+    // Possibly not supported
+  }
+  return frameworks;
+}
+function detectReact() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, 'React') || Object.prototype.hasOwnProperty.call(window, 'ReactDOM') || Object.prototype.hasOwnProperty.call(window, 'ReactRedux') || document.querySelector('[data-reactroot], [data-reactid]') || (() => {
+      const divs = document.querySelectorAll('body > div');
+      for (let i = 0; i < divs.length; i++) {
+        if (Object.prototype.hasOwnProperty.call(divs[i], '_reactRootContainer')) {
+          return true;
+        }
+      }
+    })();
+  } catch (err) {
+    return false;
+  }
+}
+function detectAngularJs() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, 'angular') || document.querySelector('.ng-binding, [ng-app], [data-ng-app], [ng-controller], [data-ng-controller], [ng-repeat], [data-ng-repeat]') || document.querySelector('script[src*="angular.js"], script[src*="angular.min.js"]');
+  } catch (err) {
+    return false;
+  }
+}
+function detectAngular() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, 'ng') || document.querySelector('[ng-version]');
+  } catch (err) {
+    return false;
+  }
+}

package/dist/cjs/features/metrics/aggregate/framework-detection.test.js

@@ -0,0 +1,137 @@
+"use strict";
+
+var _faker = require("@faker-js/faker");
+var _frameworkDetection = require("./framework-detection");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+jest.mock('../../../common/util/global-scope', () => ({
+  isBrowserScope: true
+}));
+afterEach(() => {
+  document.body.innerHTML = '';
+});
+test('framework detection should not happen in non-browser scope', async () => {
+  global.React = {};
+  jest.resetModules();
+  jest.doMock('../../../common/util/global-scope', () => ({
+    isBrowserScope: false
+  }));
+  const frameworkDetector = await Promise.resolve().then(() => _interopRequireWildcard(require('./framework-detection')));
+  expect(frameworkDetector.getFrameworks()).toEqual([]);
+  delete global.React;
+});
+test('should detect react from global React property', () => {
+  global.React = {};
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['React']);
+  delete global.React;
+});
+test('should detect react from global ReactDOM property', () => {
+  global.ReactDOM = {};
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['React']);
+  delete global.ReactDOM;
+});
+test('should detect react from global ReactRedux property', () => {
+  global.ReactRedux = {};
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['React']);
+  delete global.ReactRedux;
+});
+test('should detect react from html [data-reactroot] property', () => {
+  document.body.innerHTML = '<div data-reactroot=""></div>';
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['React']);
+});
+test('should detect react from html [data-reactid] property', () => {
+  document.body.innerHTML = '<div data-reactid=""></div>';
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['React']);
+});
+test('should detect react from element _reactRootContainer property', () => {
+  const element = document.createElement('div');
+  element._reactRootContainer = {};
+  document.body.innerHTML = '<html><body></body></html>';
+  document.body.appendChild(element);
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['React']);
+});
+test('should detect angularjs from global angular property', () => {
+  global.angular = {};
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['AngularJS']);
+  delete global.angular;
+});
+test('should detect angularjs from html .ng-binding property', () => {
+  document.body.innerHTML = '<div class="ng-binding"></div>';
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['AngularJS']);
+});
+test('should detect angularjs from html [ng-app] property', () => {
+  document.body.innerHTML = '<div ng-app=""></div>';
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['AngularJS']);
+});
+test('should detect angularjs from html [data-ng-app] property', () => {
+  document.body.innerHTML = '<div data-ng-app=""></div>';
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['AngularJS']);
+});
+test('should detect angularjs from html [ng-controller] property', () => {
+  document.body.innerHTML = '<div ng-controller=""></div>';
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['AngularJS']);
+});
+test('should detect angularjs from html [data-ng-controller] property', () => {
+  document.body.innerHTML = '<div data-ng-controller=""></div>';
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['AngularJS']);
+});
+test('should detect angularjs from html [ng-repeat] property', () => {
+  document.body.innerHTML = '<div ng-repeat=""></div>';
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['AngularJS']);
+});
+test('should detect angularjs from html [data-ng-repeat] property', () => {
+  document.body.innerHTML = '<div data-ng-repeat=""></div>';
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['AngularJS']);
+});
+test('should detect angularjs from angular.js script element', () => {
+  document.body.innerHTML = "<script src=\"".concat(_faker.faker.internet.url(), "/angular.js\"></script>");
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['AngularJS']);
+});
+test('should detect angularjs from angular.min.js script element', () => {
+  document.body.innerHTML = "<script src=\"".concat(_faker.faker.internet.url(), "/angular.min.js\"></script>");
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['AngularJS']);
+});
+test('should detect angular from global ng property', () => {
+  global.ng = {};
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['Angular']);
+  delete global.ng;
+});
+test('should detect angular from html [ng-version] property', () => {
+  document.body.innerHTML = '<div ng-version=""></div>';
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['Angular']);
+});
+test('should detect backbone from global Backbone property', () => {
+  global.Backbone = {};
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['Backbone']);
+  delete global.Backbone;
+});
+test('should detect ember from global Ember property', () => {
+  global.Ember = {};
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['Ember']);
+  delete global.Ember;
+});
+test('should detect vue from global Vue property', () => {
+  global.Vue = {};
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['Vue']);
+  delete global.Vue;
+});
+test('should detect meteor from global Meteor property', () => {
+  global.Meteor = {};
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['Meteor']);
+  delete global.Meteor;
+});
+test('should detect zepto from global Zepto property', () => {
+  global.Zepto = {};
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['Zepto']);
+  delete global.Zepto;
+});
+test('should detect jquery from global jQuery property', () => {
+  global.jQuery = {};
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['Jquery']);
+  delete global.jQuery;
+});
+test('should detect mootools from global MooTools property', () => {
+  global.MooTools = {};
+  expect((0, _frameworkDetection.getFrameworks)()).toEqual(['MooTools']);
+  delete global.MooTools;
+});

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

@@ -9,16 +9,17 @@ var _registerHandler = require("../../../common/event-emitter/register-handler")
 var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
 var _constants = require("../constants");
 var _drain = require("../../../common/drain/drain");
-var _frameworkDetection = require("../../../common/metrics/framework-detection");
+var _frameworkDetection = require("./framework-detection");
+var _polyfillDetection = require("./polyfill-detection");
 var _protocol = require("../../../common/url/protocol");
 var _obfuscate = require("../../../common/util/obfuscate");
 var _env = require("../../../common/constants/env.npm");
 var _load = require("../../../common/window/load");
 var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
 var _globalScope = require("../../../common/util/global-scope");
-var _featureBase = require("../../utils/feature-base");
+var _aggregateBase = require("../../utils/aggregate-base");
 var _stringify = require("../../../common/util/stringify");
-class Aggregate extends _featureBase.FeatureBase {
+class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, _constants.FEATURE_NAME);
@@ -82,6 +83,9 @@ class Aggregate extends _featureBase.FeatureBase {
         });
       });
     }
+    (0, _polyfillDetection.getPolyfills)().forEach(polyfill => {
+      this.storeSupportabilityMetrics('Polyfill/' + polyfill + '/Detected');
+    });
 
     // file protocol detection
     if ((0, _protocol.isFileProtocol)()) {

package/dist/cjs/features/metrics/aggregate/polyfill-detection.es5.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPolyfills = getPolyfills;
+/**
+ * This file is used as a replacement for the polyfill-detection.es5.js
+ * file when running the polyfills webpack build.
+ * @returns {string[]} an empty array
+ */
+function getPolyfills() {
+  return [];
+}

package/dist/cjs/features/metrics/aggregate/polyfill-detection.es5.test.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _polyfillDetection = require("./polyfill-detection.es5");
+afterEach(() => {
+  jest.resetAllMocks();
+});
+test('should always return an empty array', () => {
+  const originalFn = Array.from;
+  Array.from = jest.fn(function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return originalFn.apply(this, args);
+  });
+  expect((0, _polyfillDetection.getPolyfills)()).toEqual([]);
+  Array.from = originalFn;
+});

package/dist/cjs/features/metrics/aggregate/polyfill-detection.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPolyfills = getPolyfills;
+const detectionRegex = /\{ \[native code\] \}/;
+const POLYFILLS = {
+  FUNCTION_BIND: 'Function.bind',
+  FUNCTION_APPLY: 'Function.apply',
+  FUNCTION_CALL: 'Function.call',
+  ARRAY_INCLUDES: 'Array.includes',
+  ARRAY_FROM: 'Array.from',
+  ARRAY_FIND: 'Array.find',
+  ARRAY_FLAT: 'Array.flat',
+  ARRAY_FLATMAP: 'Array.flatMap',
+  OBJECT_ASSIGN: 'Object.assign',
+  OBJECT_ENTRIES: 'Object.entries',
+  OBJECT_VALUES: 'Object.values',
+  MAP: 'Map',
+  SET: 'Set',
+  WEAK_MAP: 'WeakMap',
+  WEAK_SET: 'WeakSet'
+};
+
+/**
+ * Checks for native globals to see if they have been polyfilled by customer code.
+ * @returns {string[]} Array of methods that were detected to have been polyfilled
+ */
+function getPolyfills() {
+  const polyfills = [];
+  const mockFunction = function () {/* noop */};
+  try {
+    if (typeof mockFunction.bind === 'function' && !detectionRegex.test(mockFunction.bind.toString())) polyfills.push(POLYFILLS.FUNCTION_BIND);
+    if (typeof mockFunction.apply === 'function' && !detectionRegex.test(mockFunction.apply.toString())) polyfills.push(POLYFILLS.FUNCTION_APPLY);
+    if (typeof mockFunction.call === 'function' && !detectionRegex.test(mockFunction.call.toString())) polyfills.push(POLYFILLS.FUNCTION_CALL);
+    if (typeof [].includes === 'function' && !detectionRegex.test([].includes.toString())) polyfills.push(POLYFILLS.ARRAY_INCLUDES);
+    if (typeof Array.from === 'function' && !detectionRegex.test(Array.from.toString())) polyfills.push(POLYFILLS.ARRAY_FROM);
+    if (typeof [].find === 'function' && !detectionRegex.test([].find.toString())) polyfills.push(POLYFILLS.ARRAY_FIND);
+    if (typeof [].flat === 'function' && !detectionRegex.test([].flat.toString())) polyfills.push(POLYFILLS.ARRAY_FLAT);
+    if (typeof [].flatMap === 'function' && !detectionRegex.test([].flatMap.toString())) polyfills.push(POLYFILLS.ARRAY_FLATMAP);
+    if (typeof Object.assign === 'function' && !detectionRegex.test(Object.assign.toString())) polyfills.push(POLYFILLS.OBJECT_ASSIGN);
+    if (typeof Object.entries === 'function' && !detectionRegex.test(Object.entries.toString())) polyfills.push(POLYFILLS.OBJECT_ENTRIES);
+    if (typeof Object.values === 'function' && !detectionRegex.test(Object.values.toString())) polyfills.push(POLYFILLS.OBJECT_VALUES);
+    if (typeof Map === 'function' && !detectionRegex.test(Map.toString())) polyfills.push(POLYFILLS.MAP);
+    if (typeof Set === 'function' && !detectionRegex.test(Set.toString())) polyfills.push(POLYFILLS.SET);
+    if (typeof WeakMap === 'function' && !detectionRegex.test(WeakMap.toString())) polyfills.push(POLYFILLS.WEAK_MAP);
+    if (typeof WeakSet === 'function' && !detectionRegex.test(WeakSet.toString())) polyfills.push(POLYFILLS.WEAK_SET);
+  } catch (err) {
+    // Possibly not supported
+  }
+  return polyfills;
+}

package/dist/cjs/features/metrics/aggregate/polyfill-detection.test.js

@@ -0,0 +1,165 @@
+"use strict";
+
+var _polyfillDetection = require("./polyfill-detection");
+/* eslint-disable no-global-assign */
+/* eslint-disable no-extend-native */
+
+// DO NOT test Function.prototype.apply, it causes recursion in Jest
+
+test('should return an empty array when nothing is polyfilled', () => {
+  expect((0, _polyfillDetection.getPolyfills)()).toEqual([]);
+});
+test('should indicate Function.prototype.bind is polyfilled', () => {
+  const originalFn = Function.prototype.bind;
+  Function.prototype.bind = jest.fn(function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return originalFn.apply(this, args);
+  });
+  expect((0, _polyfillDetection.getPolyfills)()).toEqual(['Function.bind']);
+  Function.prototype.bind = originalFn;
+});
+test('should indicate Function.prototype.call is polyfilled', () => {
+  const originalFn = Function.prototype.call;
+  Function.prototype.call = jest.fn(function () {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    return originalFn.apply(this, args);
+  });
+  expect((0, _polyfillDetection.getPolyfills)()).toEqual(['Function.call']);
+  Function.prototype.call = originalFn;
+});
+test('should indicate Array.prototype.includes is polyfilled', () => {
+  const originalFn = Array.prototype.includes;
+  Array.prototype.includes = jest.fn(function () {
+    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      args[_key3] = arguments[_key3];
+    }
+    return originalFn.apply(this, args);
+  });
+  expect((0, _polyfillDetection.getPolyfills)()).toEqual(['Array.includes']);
+  Array.prototype.includes = originalFn;
+});
+test('should indicate Array.from is polyfilled', () => {
+  const originalFn = Array.from;
+  Array.from = jest.fn(function () {
+    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      args[_key4] = arguments[_key4];
+    }
+    return originalFn.apply(this, args);
+  });
+  expect((0, _polyfillDetection.getPolyfills)()).toEqual(['Array.from']);
+  Array.from = originalFn;
+});
+test('should indicate Array.prototype.find is polyfilled', () => {
+  const originalFn = Array.prototype.find;
+  Array.prototype.find = jest.fn(function () {
+    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+      args[_key5] = arguments[_key5];
+    }
+    return originalFn.apply(this, args);
+  });
+  expect((0, _polyfillDetection.getPolyfills)()).toEqual(['Array.find']);
+  Array.prototype.find = originalFn;
+});
+test('should indicate Array.prototype.flat is polyfilled', () => {
+  const originalFn = Array.prototype.flat;
+  Array.prototype.flat = jest.fn(function () {
+    for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+      args[_key6] = arguments[_key6];
+    }
+    return originalFn.apply(this, args);
+  });
+  expect((0, _polyfillDetection.getPolyfills)()).toEqual(['Array.flat']);
+  Array.prototype.flat = originalFn;
+});
+test('should indicate Array.prototype.flatMap is polyfilled', () => {
+  const originalFn = Array.prototype.flatMap;
+  Array.prototype.flatMap = jest.fn(function () {
+    for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
+      args[_key7] = arguments[_key7];
+    }
+    return originalFn.apply(this, args);
+  });
+  expect((0, _polyfillDetection.getPolyfills)()).toEqual(['Array.flatMap']);
+  Array.prototype.flatMap = originalFn;
+});
+test('should indicate Object.assign is polyfilled', () => {
+  const originalFn = Object.assign;
+  Object.assign = jest.fn(function () {
+    for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
+      args[_key8] = arguments[_key8];
+    }
+    return originalFn.apply(this, args);
+  });
+  expect((0, _polyfillDetection.getPolyfills)()).toEqual(['Object.assign']);
+  Object.assign = originalFn;
+});
+test('should indicate Object.entries is polyfilled', () => {
+  const originalFn = Object.entries;
+  Object.entries = jest.fn(function () {
+    for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
+      args[_key9] = arguments[_key9];
+    }
+    return originalFn.apply(this, args);
+  });
+  expect((0, _polyfillDetection.getPolyfills)()).toEqual(['Object.entries']);
+  Object.entries = originalFn;
+});
+test('should indicate Object.values is polyfilled', () => {
+  const originalFn = Object.values;
+  Object.values = jest.fn(function () {
+    for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {
+      args[_key10] = arguments[_key10];
+    }
+    return originalFn.apply(this, args);
+  });
+  expect((0, _polyfillDetection.getPolyfills)()).toEqual(['Object.values']);
+  Object.values = originalFn;
+});
+test('should indicate Map constructor is polyfilled', () => {
+  const originalFn = Map;
+  Map = jest.fn(function () {
+    for (var _len11 = arguments.length, args = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) {
+      args[_key11] = arguments[_key11];
+    }
+    return originalFn.apply(this, args);
+  });
+  expect((0, _polyfillDetection.getPolyfills)()).toEqual(['Map']);
+  Map = originalFn;
+});
+test('should indicate Set constructor is polyfilled', () => {
+  const originalFn = Set;
+  Set = jest.fn(function () {
+    for (var _len12 = arguments.length, args = new Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {
+      args[_key12] = arguments[_key12];
+    }
+    return originalFn.apply(this, args);
+  });
+  expect((0, _polyfillDetection.getPolyfills)()).toEqual(['Set']);
+  Set = originalFn;
+});
+test('should indicate WeakMap constructor is polyfilled', () => {
+  const originalFn = WeakMap;
+  WeakMap = jest.fn(function () {
+    for (var _len13 = arguments.length, args = new Array(_len13), _key13 = 0; _key13 < _len13; _key13++) {
+      args[_key13] = arguments[_key13];
+    }
+    return originalFn.apply(this, args);
+  });
+  expect((0, _polyfillDetection.getPolyfills)()).toEqual(['WeakMap']);
+  WeakMap = originalFn;
+});
+test('should indicate WeakSet constructor is polyfilled', () => {
+  const originalFn = WeakSet;
+  WeakSet = jest.fn(function () {
+    for (var _len14 = arguments.length, args = new Array(_len14), _key14 = 0; _key14 < _len14; _key14++) {
+      args[_key14] = arguments[_key14];
+    }
+    return originalFn.apply(this, args);
+  });
+  expect((0, _polyfillDetection.getPolyfills)()).toEqual(['WeakSet']);
+  WeakSet = originalFn;
+});

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

@@ -13,13 +13,13 @@ var _config = require("../../../common/config/config");
 var _constants = require("../constants");
 var _drain = require("../../../common/drain/drain");
 var _globalScope = require("../../../common/util/global-scope");
-var _featureBase = require("../../utils/feature-base");
+var _aggregateBase = require("../../utils/aggregate-base");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
-class Aggregate extends _featureBase.FeatureBase {
+class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     var _this;

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

@@ -20,11 +20,11 @@ var CONSTANTS = _interopRequireWildcard(require("../constants"));
 var _initializedFeatures = require("./initialized-features");
 var _globalScope = require("../../../common/util/global-scope");
 var _drain = require("../../../common/drain/drain");
-var _featureBase = require("../../utils/feature-base");
+var _aggregateBase = require("../../utils/aggregate-base");
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 const jsonp = 'NREUM.setToken';
-class Aggregate extends _featureBase.FeatureBase {
+class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = CONSTANTS.FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, CONSTANTS.FEATURE_NAME);
@@ -142,7 +142,10 @@ class Aggregate extends _featureBase.FeatureBase {
 
     // Capture query bytes sent to RUM call endpoint (currently `1`) as a supportability metric. See metrics aggregator (on unload).
     agentRuntime.queryBytesSent[protocol] = (agentRuntime.queryBytesSent[protocol] || 0) + queryString?.length || 0;
-    const isValidJsonp = _submitData.submitData.jsonp(this.getScheme() + '://' + info.beacon + '/' + protocol + '/' + info.licenseKey + queryString, jsonp);
+    const isValidJsonp = _submitData.submitData.jsonp({
+      url: this.getScheme() + '://' + info.beacon + '/' + protocol + '/' + info.licenseKey + '?' + queryString,
+      jsonp
+    });
     // Usually `drain` is invoked automatically after processing feature flags contained in the JSONP callback from
     // ingest (see `activateFeatures`), so when JSONP cannot execute (as with module workers), we drain manually.
     if (!isValidJsonp) (0, _drain.drain)(this.agentIdentifier, CONSTANTS.FEATURE_NAME);

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

@@ -18,13 +18,13 @@ var _config = require("../../../common/config/config");
 var _constants = require("../constants");
 var _drain = require("../../../common/drain/drain");
 var _features = require("../../../loaders/features/features");
-var _featureBase = require("../../utils/feature-base");
+var _aggregateBase = require("../../utils/aggregate-base");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
-class Aggregate extends _featureBase.FeatureBase {
+class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     var _this;