npm - @newrelic/browser-agent - Versions diffs - 1.232.0 → 1.233.0 - Mend

@newrelic/browser-agent 1.232.0 → 1.233.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (273) hide show

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

@@ -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 CHANGED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

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