@newrelic/browser-agent 1.264.0 → 1.265.1

package/dist/cjs/common/url/encode.js

@@ -45,8 +45,7 @@ function fromArray(qs, maxBytes) {
 function obj(payload, maxBytes) {
   var total = 0;
   var result = '';
-  Object.entries(payload || {}).forEach(_ref => {
-    let [feature, dataArray] = _ref;
+  Object.entries(payload || {}).forEach(([feature, dataArray]) => {
     var intermediate = [];
     var next;
     var i;
@@ -69,8 +68,7 @@ function obj(payload, maxBytes) {
 }
 
 // Constructs an HTTP parameter to add to the BAM router URL
-function param(name, value) {
-  let base = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function param(name, value, base = {}) {
   if (Object.keys(base).includes(name)) return ''; // we assume if feature supplied a matching qp to the base, we should honor what the feature sent over the default
   if (value && typeof value === 'string') {
     return '&' + name + '=' + qs(value);

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

@@ -4,6 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.warn = warn;
+/* eslint no-console: ["error", { allow: ["debug"] }] */
+
 /**
  * A helper method to warn to the console with New Relic: decoration
  * @param {string} message The primary message to warn

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

@@ -27,18 +27,12 @@ exports.single = single;
  * @returns {function} A wrapping function that will ensure the provided function
  * is invoked only once within the given timeout.
  */
-function debounce(func) {
-  var _this = this;
-  let timeout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 500;
-  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function debounce(func, timeout = 500, options = {}) {
   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];
-    }
+  return (...args) => {
     if (leading && timer === undefined) {
-      func.apply(_this, args);
+      func.apply(this, args);
       timer = setTimeout(() => {
         timer = clearTimeout(timer);
       }, timeout);
@@ -46,7 +40,7 @@ function debounce(func) {
     if (!leading) {
       clearTimeout(timer);
       timer = setTimeout(() => {
-        func.apply(_this, args);
+        func.apply(this, args);
       }, timeout);
     }
   };
@@ -61,15 +55,11 @@ function debounce(func) {
  * is invoked only once.
  */
 function single(func) {
-  var _this2 = this;
   let called = false;
-  return function () {
+  return (...args) => {
     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);
+      func.apply(this, args);
     }
   };
 }

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

@@ -4,67 +4,111 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Obfuscator = void 0;
-exports.getRules = getRules;
-exports.validateRules = validateRules;
-var _config = require("../config/config");
-var _sharedContext = require("../context/shared-context");
+var _init = require("../config/init");
 var _protocol = require("../url/protocol");
 var _console = require("./console");
-var fileProtocolRule = {
-  regex: /^file:\/\/(.*)/,
-  replacement: atob('ZmlsZTovL09CRlVTQ0FURUQ=')
-};
-class Obfuscator extends _sharedContext.SharedContext {
-  shouldObfuscate() {
-    return getRules(this.sharedContext.agentIdentifier).length > 0;
+/**
+ * Represents an obfuscation rule that can be applied to harvested payloads
+ * @typedef {object} ObfuscationRule
+ * @property {string|RegExp} regex The regular expression to match against in the payload
+ * @property {string} [replacement] The string to replace the matched regex with
+ */
+
+/**
+ * Represents an obfuscation rule validation state
+ * @typedef {object} ObfuscationRuleValidation
+ * @property {ObfuscationRule} rule The original rule validated
+ * @property {boolean} isValid Whether the rule is valid
+ * @property {object} errors Validation errors
+ * @property {boolean} errors.regexMissingDetected Whether the regex is missing
+ * @property {boolean} errors.invalidRegexDetected Whether the regex is invalid
+ * @property {boolean} errors.invalidReplacementDetected Whether the replacement is invalid
+ */
+
+class Obfuscator {
+  /**
+   * @type {ObfuscationRuleValidation[]}
+   */
+  #ruleValidationCache;
+  constructor(agentIdentifier) {
+    this.#ruleValidationCache = Obfuscator.getRuleValidationCache(agentIdentifier);
+    Obfuscator.logObfuscationRuleErrors(this.#ruleValidationCache);
+  }
+  get ruleValidationCache() {
+    return this.#ruleValidationCache;
   }
 
-  // applies all regex obfuscation rules to provided URL string and returns the result
-  obfuscateString(string) {
-    // if string is empty string, null or not a string, return unmodified
-    if (!string || typeof string !== 'string') return string;
-    var rules = getRules(this.sharedContext.agentIdentifier);
-    var obfuscated = string;
+  /**
+   * Applies all valid obfuscation rules to the provided input string
+   * @param {string} input String to obfuscate
+   * @returns {string}
+   */
+  obfuscateString(input) {
+    // if input is not of type string or is an empty string, short-circuit
+    if (typeof input !== 'string' || input.trim().length === 0) return input;
+    return this.#ruleValidationCache.filter(ruleValidation => ruleValidation.isValid).reduce((input, ruleValidation) => {
+      const {
+        rule
+      } = ruleValidation;
+      return input.replace(rule.regex, rule.replacement || '*');
+    }, input);
+  }
 
-    // apply every rule to URL string
-    for (var i = 0; i < rules.length; i++) {
-      var regex = rules[i].regex;
-      var replacement = rules[i].replacement || '*';
-      obfuscated = obfuscated.replace(regex, replacement);
+  /**
+   * Returns an array of obfuscation rules to be applied to harvested payloads
+   * @param {string} agentIdentifier The agent identifier to get rules for
+   * @returns {ObfuscationRuleValidation[]} The array of rules or validation states
+   */
+  static getRuleValidationCache(agentIdentifier) {
+    /**
+     * @type {ObfuscationRule[]}
+     */
+    let rules = (0, _init.getConfigurationValue)(agentIdentifier, 'obfuscate') || [];
+    if ((0, _protocol.isFileProtocol)()) {
+      rules.push({
+        regex: /^file:\/\/(.*)/,
+        replacement: atob('ZmlsZTovL09CRlVTQ0FURUQ=')
+      });
     }
-    return obfuscated;
+    return rules.map(rule => Obfuscator.validateObfuscationRule(rule));
   }
-}
 
-// TO DO: this function should be inside the Obfuscator class since its context relates to agentID
-exports.Obfuscator = Obfuscator;
-function getRules(agentIdentifier) {
-  var rules = [];
-  var configRules = (0, _config.getConfigurationValue)(agentIdentifier, 'obfuscate') || [];
-  rules = rules.concat(configRules);
-  if ((0, _protocol.isFileProtocol)()) rules.push(fileProtocolRule);
-  // could add additional runtime/environment-specific rules here
-
-  return rules;
-}
+  /**
+   * Validates an obfuscation rule and provides errors if any are found.
+   * @param {ObfuscationRule} rule The rule to validate
+   * @returns {ObfuscationRuleValidation} The validation state of the rule
+   */
+  static validateObfuscationRule(rule) {
+    const regexMissingDetected = Boolean(rule.regex === undefined);
+    const invalidRegexDetected = Boolean(rule.regex !== undefined && typeof rule.regex !== 'string' && !(rule.regex instanceof RegExp));
+    const invalidReplacementDetected = Boolean(rule.replacement && typeof rule.replacement !== 'string');
+    return {
+      rule,
+      isValid: !regexMissingDetected && !invalidRegexDetected && !invalidReplacementDetected,
+      errors: {
+        regexMissingDetected,
+        invalidRegexDetected,
+        invalidReplacementDetected
+      }
+    };
+  }
 
-// takes array of rule objects, logs warning and returns false if any portion of rule is invalid
-function validateRules(rules) {
-  var invalidReplacementDetected = false;
-  var invalidRegexDetected = false;
-  for (var i = 0; i < rules.length; i++) {
-    if (!('regex' in rules[i])) {
-      (0, _console.warn)(12);
-      invalidRegexDetected = true;
-    } else if (typeof rules[i].regex !== 'string' && !(rules[i].regex instanceof RegExp)) {
-      (0, _console.warn)(13);
-      invalidRegexDetected = true;
-    }
-    var replacement = rules[i].replacement;
-    if (replacement && typeof replacement !== 'string') {
-      (0, _console.warn)(14);
-      invalidReplacementDetected = true;
+  /**
+   * Logs any obfuscation rule errors to the console. This is called when an obfuscator
+   * instance is created.
+   * @param {ObfuscationRuleValidation[]} ruleValidationCache The cache of rule validation states
+   */
+  static logObfuscationRuleErrors(ruleValidationCache) {
+    for (const ruleValidation of ruleValidationCache) {
+      const {
+        rule,
+        isValid,
+        errors
+      } = ruleValidation;
+      if (isValid) continue;
+      if (errors.regexMissingDetected) (0, _console.warn)(12, rule);else if (errors.invalidRegexDetected) (0, _console.warn)(13, rule);
+      if (errors.invalidReplacementDetected) (0, _console.warn)(14, rule);
     }
   }
-  return !invalidReplacementDetected && !invalidRegexDetected;
-}
+}
+exports.Obfuscator = Obfuscator;

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

@@ -23,10 +23,9 @@ var _runtime = require("../constants/runtime");
  * @param {boolean} opts.isFinalHarvest Indicates if the data submission is due to
  * a final harvest within the agent.
  */
-function getSubmitMethod() {
-  let {
-    isFinalHarvest = false
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+function getSubmitMethod({
+  isFinalHarvest = false
+} = {}) {
   return isFinalHarvest && _runtime.isBrowserScope && _runtime.supportsSendBeacon
   // Use sendBeacon for final harvest
   ? beacon
@@ -44,17 +43,16 @@ function getSubmitMethod() {
  * @param {{key: string, value: string}[]} [args.headers] - The headers to attach.
  * @returns {XMLHttpRequest}
  */
-function xhr(_ref) {
-  let {
-    url,
-    body = null,
-    sync,
-    method = 'POST',
-    headers = [{
-      key: 'content-type',
-      value: 'text/plain'
-    }]
-  } = _ref;
+function xhr({
+  url,
+  body = null,
+  sync,
+  method = 'POST',
+  headers = [{
+    key: 'content-type',
+    value: 'text/plain'
+  }]
+}) {
   const request = new XMLHttpRequest();
   request.open(method, url, !sync);
   try {
@@ -77,11 +75,10 @@ function xhr(_ref) {
  * @param {string=} args.body - The Stringified body
  * @returns {boolean}
  */
-function beacon(_ref2) {
-  let {
-    url,
-    body
-  } = _ref2;
+function beacon({
+  url,
+  body
+}) {
   try {
     // Navigator has to be bound to ensure it does not error in some browsers
     // https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch

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

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toTitleCase = toTitleCase;
+function toTitleCase(str, regex = /\w*/g) {
+  return str.replace(regex, text => text.charAt(0).toUpperCase() + text.substring(1).toLowerCase());
+}

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

@@ -18,9 +18,7 @@ exports.applyFnToProps = applyFnToProps;
  * @param {Array<string>} [ignoreKeys=[]] - The keys of properties to ignore and not modify.
  * @returns {Object} - The object with function recursively applied.
  */
-function applyFnToProps(obj, fn) {
-  let type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'string';
-  let ignoreKeys = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+function applyFnToProps(obj, fn, type = 'string', ignoreKeys = []) {
   if (!obj || typeof obj !== 'object') return obj;
   Object.keys(obj).forEach(property => {
     if (typeof obj[property] === 'object') {

package/dist/cjs/common/vitals/cumulative-layout-shift.js

@@ -10,12 +10,11 @@ var _vitalMetric = require("./vital-metric");
 var _runtime = require("../constants/runtime");
 const cumulativeLayoutShift = exports.cumulativeLayoutShift = new _vitalMetric.VitalMetric(_constants.VITAL_NAMES.CUMULATIVE_LAYOUT_SHIFT, x => x);
 if (_runtime.isBrowserScope) {
-  (0, _attribution.onCLS)(_ref => {
-    let {
-      value,
-      attribution,
-      id
-    } = _ref;
+  (0, _attribution.onCLS)(({
+    value,
+    attribution,
+    id
+  }) => {
     const attrs = {
       metricId: id,
       largestShiftTarget: attribution.largestShiftTarget,

package/dist/cjs/common/vitals/first-contentful-paint.js

@@ -32,11 +32,10 @@ if (_runtime.isBrowserScope) {
       // ignore
     }
   } else {
-    (0, _attribution.onFCP)(_ref => {
-      let {
-        value,
-        attribution
-      } = _ref;
+    (0, _attribution.onFCP)(({
+      value,
+      attribution
+    }) => {
       if (_runtime.initiallyHidden || firstContentfulPaint.isValid) return;
       const attrs = {
         timeToFirstByte: attribution.timeToFirstByte,

package/dist/cjs/common/vitals/first-input-delay.js

@@ -10,11 +10,10 @@ var _constants = require("./constants");
 var _runtime = require("../constants/runtime");
 const firstInputDelay = exports.firstInputDelay = new _vitalMetric.VitalMetric(_constants.VITAL_NAMES.FIRST_INPUT_DELAY);
 if (_runtime.isBrowserScope) {
-  (0, _attribution.onFID)(_ref => {
-    let {
-      value,
-      attribution
-    } = _ref;
+  (0, _attribution.onFID)(({
+    value,
+    attribution
+  }) => {
     if (_runtime.initiallyHidden || firstInputDelay.isValid) return;
     const attrs = {
       type: attribution.eventType,

package/dist/cjs/common/vitals/interaction-to-next-paint.js

@@ -11,12 +11,11 @@ var _runtime = require("../constants/runtime");
 const interactionToNextPaint = exports.interactionToNextPaint = new _vitalMetric.VitalMetric(_constants.VITAL_NAMES.INTERACTION_TO_NEXT_PAINT);
 if (_runtime.isBrowserScope) {
   /* Interaction-to-Next-Paint */
-  (0, _attribution.onINP)(_ref => {
-    let {
-      value,
-      attribution,
-      id
-    } = _ref;
+  (0, _attribution.onINP)(({
+    value,
+    attribution,
+    id
+  }) => {
     const attrs = {
       metricId: id,
       eventTarget: attribution.eventTarget,

package/dist/cjs/common/vitals/largest-contentful-paint.js

@@ -11,11 +11,10 @@ var _runtime = require("../constants/runtime");
 var _cleanUrl = require("../url/clean-url");
 const largestContentfulPaint = exports.largestContentfulPaint = new _vitalMetric.VitalMetric(_constants.VITAL_NAMES.LARGEST_CONTENTFUL_PAINT);
 if (_runtime.isBrowserScope) {
-  (0, _attribution.onLCP)(_ref => {
-    let {
-      value,
-      attribution
-    } = _ref;
+  (0, _attribution.onLCP)(({
+    value,
+    attribution
+  }) => {
     /* Largest Contentful Paint - As of WV v3, it still imperfectly tries to detect document vis state asap and isn't supposed to report if page starts hidden. */
     if (_runtime.initiallyHidden || largestContentfulPaint.isValid) return;
     let attrs;

package/dist/cjs/common/vitals/time-to-first-byte.js

@@ -18,11 +18,10 @@ const timeToFirstByte = exports.timeToFirstByte = new _vitalMetric.VitalMetric(_
  * - cross-origin iframes specifically in firefox and safari
  */
 if (_runtime.isBrowserScope && typeof PerformanceNavigationTiming !== 'undefined' && !_runtime.isiOS && window === window.parent) {
-  (0, _attribution.onTTFB)(_ref => {
-    let {
-      value,
-      attribution
-    } = _ref;
+  (0, _attribution.onTTFB)(({
+    value,
+    attribution
+  }) => {
     if (timeToFirstByte.isValid) return;
     timeToFirstByte.update({
       value,

package/dist/cjs/common/vitals/vital-metric.js

@@ -5,18 +5,17 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.VitalMetric = void 0;
 class VitalMetric {
-  #subscribers = (() => new Set())();
+  #subscribers = new Set();
   history = [];
   constructor(name, roundingMethod) {
     this.name = name;
     this.attrs = {};
     this.roundingMethod = typeof roundingMethod === 'function' ? roundingMethod : Math.floor;
   }
-  update(_ref) {
-    let {
-      value,
-      attrs = {}
-    } = _ref;
+  update({
+    value,
+    attrs = {}
+  }) {
     if (value === undefined || value === null || value < 0) return;
     const state = {
       value: this.roundingMethod(value),
@@ -42,8 +41,7 @@ class VitalMetric {
   get isValid() {
     return this.current.value >= 0;
   }
-  subscribe(callback) {
-    let buffered = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  subscribe(callback, buffered = true) {
     if (typeof callback !== 'function') return;
     this.#subscribers.add(callback);
     // emit full history on subscription ("buffered" behavior)

package/dist/cjs/common/window/nreum.js

@@ -66,7 +66,8 @@ function gosNREUMOriginals() {
       PR: _runtime.globalScope.Promise,
       MO: _runtime.globalScope.MutationObserver,
       // this'll be undefined if not in a web window
-      FETCH: _runtime.globalScope.fetch
+      FETCH: _runtime.globalScope.fetch,
+      WS: _runtime.globalScope.WebSocket
     };
   }
   return nr;

package/dist/cjs/common/window/page-visibility.js

@@ -15,10 +15,7 @@ var _eventListenerOpts = require("../event-listener/event-listener-opts");
  * @param {boolean} [toHiddenOnly=false] - only execute the 'cb' when the vis is changing to the hidden state; no arg is passed to 'cb' if used
  * @returns void
  */
-function subscribeToVisibilityChange(cb) {
-  let toHiddenOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  let capture = arguments.length > 2 ? arguments[2] : undefined;
-  let abortSignal = arguments.length > 3 ? arguments[3] : undefined;
+function subscribeToVisibilityChange(cb, toHiddenOnly = false, capture, abortSignal) {
   (0, _eventListenerOpts.documentAddEventListener)('visibilitychange', handleVisibilityChange, capture, abortSignal);
   function handleVisibilityChange() {
     if (toHiddenOnly) {

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

@@ -83,14 +83,11 @@ function wrapEvents(sharedEE) {
  * @param {Function} cb - the function to run on the ancestral object once found, accepts an object as a arg
  * @param {Array} rest - [optional] any additional arguments to pass to the cb
  */
-function findEventListenerProtoAndCb(object, cb) {
+function findEventListenerProtoAndCb(object, cb, ...rest) {
   let step = object;
   while (typeof step === 'object' && !Object.prototype.hasOwnProperty.call(step, ADD_EVENT_LISTENER)) {
     step = Object.getPrototypeOf(step);
   }
-  for (var _len = arguments.length, rest = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
-    rest[_key - 2] = arguments[_key];
-  }
   if (step) cb(step, ...rest);
 }
 

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

@@ -111,13 +111,10 @@ function wrapPromise(sharedEE) {
 
     // Note that this wrapping affects the same originals.PR (prototype) object.
     const prevPromiseOrigThen = prevPromiseObj.prototype.then;
-    prevPromiseObj.prototype.then = function wrappedThen() {
+    prevPromiseObj.prototype.then = function wrappedThen(...args) {
       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/cjs/common/wrap/wrap-websocket.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WEBSOCKET_TAG = exports.ADD_EVENT_LISTENER_TAG = void 0;
+exports.wrapWebSocket = wrapWebSocket;
+var _runtime = require("../constants/runtime");
+var _now = require("../timing/now");
+var _load = require("../window/load");
+var _uniqueId = require("../ids/unique-id");
+var _nreum = require("../window/nreum");
+const WEBSOCKET_TAG = exports.WEBSOCKET_TAG = 'websocket-';
+const ADD_EVENT_LISTENER_TAG = exports.ADD_EVENT_LISTENER_TAG = 'addEventListener';
+const wrapped = {};
+function wrapWebSocket(sharedEE) {
+  if (wrapped[sharedEE.debugId]++) return sharedEE;
+  const originals = (0, _nreum.gosNREUMOriginals)().o;
+  if (!originals.WS) return sharedEE;
+  function reporter(socketId) {
+    const createdAt = (0, _now.now)();
+    return function (message, ...data) {
+      const timestamp = data[0]?.timeStamp || (0, _now.now)();
+      const isLoaded = (0, _load.checkState)();
+      sharedEE.emit(WEBSOCKET_TAG + message, [timestamp, timestamp - createdAt, isLoaded, socketId, ...data]);
+    };
+  }
+  Object.defineProperty(WrappedWebSocket, 'name', {
+    value: 'WebSocket'
+  });
+  function WrappedWebSocket() {
+    const ws = new originals.WS(...arguments);
+    const socketId = (0, _uniqueId.generateRandomHexString)(6);
+    const report = reporter(socketId);
+    report('new');
+    const events = ['message', 'error', 'open', 'close'];
+    /** add event listeners */
+    events.forEach(evt => {
+      ws.addEventListener(evt, function (e) {
+        report(ADD_EVENT_LISTENER_TAG, {
+          eventType: evt,
+          event: e
+        });
+      });
+    })
+
+    /** could also observe the on-events for runtime processing, but not implemented yet */
+
+    /** observe the static method send, but noteably not close, as that is currently observed with the event listener */;
+    ['send'].forEach(wrapStaticProperty);
+    function wrapStaticProperty(prop) {
+      const originalProp = ws[prop];
+      if (originalProp) {
+        Object.defineProperty(proxiedProp, 'name', {
+          value: prop
+        });
+        function proxiedProp() {
+          report(prop, ...arguments);
+          try {
+            return originalProp.apply(this, arguments);
+          } catch (err) {
+            report(prop + '-err', ...arguments);
+            // rethrow error so we don't effect execution by observing.
+            throw err;
+          }
+        }
+        ws[prop] = proxiedProp;
+      }
+    }
+    return ws;
+  }
+  _runtime.globalScope.WebSocket = WrappedWebSocket;
+  return sharedEE;
+}

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

@@ -5,7 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _belSerializer = require("../../../common/serialize/bel-serializer");
-var _config = require("../../../common/config/config");
+var _info = require("../../../common/config/info");
+var _agentConstants = require("../../../common/constants/agent-constants");
 class Chunk {
   constructor(events, aggregateInstance) {
     this.addString = (0, _belSerializer.getAddStringContext)(aggregateInstance.agentIdentifier); // pass agentIdentifier here
@@ -28,7 +29,7 @@ class Chunk {
       let insert = '2,';
 
       // Since configuration objects (like info) are created new each time they are set, we have to grab the current pointer to the attr object here.
-      const jsAttributes = (0, _config.getInfo)(aggregateInstance.agentIdentifier).jsAttributes;
+      const jsAttributes = (0, _info.getInfo)(aggregateInstance.agentIdentifier).jsAttributes;
 
       // add custom attributes
       // gql decorators are added as custom attributes to alleviate need for new BEL schema
@@ -44,7 +45,7 @@ class Chunk {
       if (i + 1 < events.length) insert += ';';
       this.payload += insert;
     }
-    this.tooBig = this.payload.length * 2 > aggregateInstance.MAX_PAYLOAD_SIZE;
+    this.tooBig = this.payload.length * 2 > _agentConstants.MAX_PAYLOAD_SIZE;
   }
 }
 exports.default = Chunk;

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

@@ -19,11 +19,10 @@ var _typeCheck = require("../../../common/util/type-check");
  * @param {string} query Ajax request query param string
  * @returns {GQLMetadata | undefined}
  */
-function parseGQL() {
-  let {
-    body,
-    query
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+function parseGQL({
+  body,
+  query
+} = {}) {
   if (!body && !query) return;
   try {
     const gqlBody = parseBatchGQL(parseGQLContents(body));