@newrelic/browser-agent 1.232.0 → 1.233.0

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

@@ -7,11 +7,17 @@ export const submitData = {};
 
 /**
  * Send via JSONP. Do NOT call this function outside of a guaranteed web window environment.
- * @param {string} url
- * @param {string} jsonp
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @param {string} args.jsonp - The string name of the jsonp cb method
+ * @returns {XMLHttpRequest}
  * @returns {Element}
  */
-submitData.jsonp = function jsonp(url, jsonp) {
+submitData.jsonp = function jsonp(_ref) {
+  let {
+    url,
+    jsonp
+  } = _ref;
   try {
     if (isWorkerScope) {
       try {
@@ -19,7 +25,9 @@ submitData.jsonp = function jsonp(url, jsonp) {
       } catch (e) {
         // for now theres no other way to execute the callback from ingest without jsonp, or unsafe eval / new Function calls
         // future work needs to be conducted to allow ingest to return a more traditional JSON API-like experience for the entitlement flags
-        submitData.xhrGet(url + '&jsonp=' + jsonp);
+        submitData.xhrGet({
+          url: url + '&jsonp=' + jsonp
+        });
         return false;
       }
     } else {
@@ -34,19 +42,38 @@ submitData.jsonp = function jsonp(url, jsonp) {
     // do nothing
   }
 };
-submitData.xhrGet = function xhrGet(url) {
-  return submitData.xhr(url, undefined, false, 'GET');
+submitData.xhrGet = function xhrGet(_ref2) {
+  let {
+    url
+  } = _ref2;
+  return submitData.xhr({
+    url,
+    sync: false,
+    method: 'GET'
+  });
 };
 
 /**
  * Send via XHR
- * @param {string} url
- * @param {string} body
- * @param {boolean} sync
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @param {string=} args.body - The Stringified body
+ * @param {boolean=} args.sync - Run XHR as Synchronous
+ * @param {string=} [args.method=POST] - The XHR method to use
+ * @param {{key: string, value: string}[]} [args.headers] - The headers to attach
  * @returns {XMLHttpRequest}
  */
-submitData.xhr = function xhr(url, body, sync) {
-  let method = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'POST';
+submitData.xhr = function xhr(_ref3) {
+  let {
+    url,
+    body,
+    sync,
+    method = 'POST',
+    headers = [{
+      key: 'content-type',
+      value: 'text/plain'
+    }]
+  } = _ref3;
   var request = new XMLHttpRequest();
   request.open(method, url, !sync);
   try {
@@ -55,7 +82,9 @@ submitData.xhr = function xhr(url, body, sync) {
   } catch (e) {
     // do nothing
   }
-  request.setRequestHeader('content-type', 'text/plain');
+  headers.forEach(header => {
+    request.setRequestHeader(header.key, header.value);
+  });
   request.send(body);
   return request;
 };
@@ -69,10 +98,15 @@ submitData.xhr = function xhr(url, body, sync) {
 
 /**
  * Send by appending an <img> element to the page. Do NOT call this function outside of a guaranteed web window environment.
- * @param {string} url
- * @returns {Element}
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @returns {HTMLImageElement}
  */
-submitData.img = function img(url) {
+submitData.img = function img(_ref4) {
+  let {
+    url
+  } = _ref4;
+  console.log('img url', url);
   var element = new Image();
   element.src = url;
   return element;
@@ -80,11 +114,16 @@ submitData.img = function img(url) {
 
 /**
  * Send via sendBeacon. Do NOT call this function outside of a guaranteed web window environment.
- * @param {string} url
- * @param {string} body
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @param {string=} args.body - The Stringified body
  * @returns {boolean}
  */
-submitData.beacon = function (url, body) {
+submitData.beacon = function (_ref5) {
+  let {
+    url,
+    body
+  } = _ref5;
   // 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
   const send = window.navigator.sendBeacon.bind(window.navigator);

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

@@ -7,7 +7,6 @@
  * This module is used by: ajax, spa.
  */
 import { ee as baseEE } from '../event-emitter/contextual-ee';
-import slice from 'lodash._slice';
 import { globalScope } from '../util/global-scope';
 import { flag } from './wrap-function';
 var prefix = 'fetch-';
@@ -68,7 +67,7 @@ export function wrapFetch(sharedEE) {
     var fn = target[name];
     if (typeof fn === 'function') {
       target[name] = function () {
-        var args = slice(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/esm/common/wrap/wrap-function.js

@@ -7,7 +7,6 @@
  */
 
 import { ee } from '../event-emitter/contextual-ee';
-import slice from 'lodash._slice';
 export const flag = 'nr@original';
 
 /**
@@ -72,7 +71,7 @@ export function createWrapperWithEmitter(emitter, always) {
       var result;
       try {
         originalThis = this;
-        args = slice(arguments);
+        args = [...arguments];
         if (typeof getContext === 'function') {
           ctx = getContext(args, originalThis);
         } else {

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

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

@@ -13,8 +13,8 @@ import { FEATURE_NAME } from '../constants';
 import { drain } from '../../../common/drain/drain';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
-import { FeatureBase } from '../../utils/feature-base';
-export class Aggregate extends FeatureBase {
+import { AggregateBase } from '../../utils/aggregate-base';
+export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME);

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

@@ -91,7 +91,7 @@ function subscribeToEvents(agentIdentifier, ee, handler, dt) {
   }
   function onOpenXhrEnd(args, xhr) {
     var loader_config = getLoaderConfig(agentIdentifier);
-    if ('xpid' in loader_config && this.sameOrigin) {
+    if (loader_config.xpid && this.sameOrigin) {
       xhr.setRequestHeader('X-NewRelic-ID', loader_config.xpid);
     }
     var payload = dt.generateTracePayload(this.parsedOrigin);

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

@@ -3,10 +3,18 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-var canonicalFunctionNameRe = /([a-z0-9]+)$/i;
-export function canonicalFunctionName(orig) {
-  if (!orig) return;
-  var match = orig.match(canonicalFunctionNameRe);
+const canonicalFunctionNameRe = /([a-z0-9]+)$/i;
+
+/**
+ * Given a function name string, extracts only an alphanumeric segment at the end of the string (if one exists).
+ * This is useful for stack traces, where functions might not be named (e.g., anonymous, computed).
+ *
+ * @param {string} functionNameString - The original function name string.
+ * @returns {string|undefined} The canonical function name, or undefined if the input is falsy or no alphanumeric segments are found.
+ */
+export function canonicalFunctionName(functionNameString) {
+  if (!functionNameString) return;
+  const match = functionNameString.match(canonicalFunctionNameRe);
   if (match) return match[1];
   return;
 }

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

@@ -57,12 +57,31 @@
 // ex.message = ...
 // ex.name = ReferenceError
 import { formatStackTrace } from './format-stack-trace';
+import { canonicalizeUrl } from '../../../common/url/canonicalize-url';
 var debug = false;
 var classNameRegex = /function (.+?)\s*\(/;
 var chrome = /^\s*at (?:((?:\[object object\])?(?:[^(]*\([^)]*\))*[^()]*(?: \[as \S+\])?) )?\(?((?:file|http|https|chrome-extension):.*?)?:(\d+)(?::(\d+))?\)?\s*$/i;
 var gecko = /^\s*(?:(\S*|global code)(?:\(.*?\))?@)?((?:file|http|https|chrome|safari-extension).*?):(\d+)(?::(\d+))?\s*$/i;
 var chrome_eval = /^\s*at .+ \(eval at \S+ \((?:(?:file|http|https):[^)]+)?\)(?:, [^:]*:\d+:\d+)?\)$/i;
 var ie_eval = /^\s*at Function code \(Function code:\d+:\d+\)\s*/i;
+
+/**
+ * Represents an error with a stack trace.
+ * @typedef {Object} StackInfo
+ * @property {string} name - The name of the error (e.g. 'TypeError').
+ * @property {string} message - The error message.
+ * @property {string} stackString - The stack trace as a string.
+ * @property {Array<Object>} frames - An array of frames in the stack trace.
+ * @property {string} frames.url - The URL of the file containing the code for the frame.
+ * @property {string} frames.func - The name of the function associated with the frame.
+ * @property {number} frames.line - The line number of the code in the frame.
+ */
+
+/**
+ * Attempts to compute a stack trace for the given exception.
+ * @param {Error} ex - The exception for which to compute the stack trace.
+ * @returns {StackInfo} A stack trace object containing information about the frames on the stack.
+ */
 export function computeStackTrace(ex) {
   var stack = null;
   try {
@@ -103,9 +122,9 @@ export function computeStackTrace(ex) {
 }
 
 /**
- * Computes stack trace information from the stack property.
- * Chrome and Gecko use this property.
- * @param {Error} ex
+ * Computes stack trace information from the stack property. Chrome and Gecko use this property.
+ *
+ * @param {Error} ex - The error object to compute the stack trace for.
  * @return {?Object.<string, *>} Stack trace information.
  */
 function computeStackTraceFromStackProp(ex) {
@@ -126,17 +145,48 @@ function computeStackTraceFromStackProp(ex) {
     frames: errorInfo.frames
   };
 }
+
+/**
+ * Parses a line from a JavaScript error stack trace and adds it to the given `info` object.
+ * Ignores all stack entries thrown from one of our wrapper functions.
+ *
+ * @param {object} info - The `info` object to add the parsed line to.
+ * @param {string} line - The line to parse.
+ * @returns {object} The `info` object with the parsed line added.
+ */
 function parseStackProp(info, line) {
-  var element = getElement(line);
+  let element = getStackElement(line);
+
+  // This catches lines that aren't frames (like the first line stating the error).
   if (!element) {
     info.stackLines.push(line);
     return info;
   }
-  if (isWrapper(element.func)) info.wrapperSeen = true;else info.stackLines.push(line);
-  if (!info.wrapperSeen) info.frames.push(element);
+
+  // Once we've seen a wrapper, ignore all subsequent stack entries.
+  if (isNrWrapper(element.func)) info.wrapperSeen = true;
+  if (!info.wrapperSeen) {
+    // Query strings and fragments should be removed, and URLs matching the loader's origin should be "<inline>".
+    let canonicalUrl = canonicalizeUrl(element.url);
+    if (canonicalUrl !== element.url) {
+      line = line.replace(element.url, canonicalUrl);
+      element.url = canonicalUrl;
+    }
+    info.stackLines.push(line);
+    info.frames.push(element);
+  }
   return info;
 }
-function getElement(line) {
+
+/**
+ * Parses a line from a JavaScript error stack trace to extract information about a stack trace element, such as the
+ * URL, function name, line number, and column number.
+ *
+ * @param {string} line - A single line from a JavaScript error stack trace.
+ * @returns {object} An object containing information about the stack trace element, including the URL, function
+ *     name, line number, and column number (if available).
+ */
+function getStackElement(line) {
   var parts = line.match(gecko);
   if (!parts) parts = line.match(chrome);
   if (parts) {
@@ -153,6 +203,15 @@ function getElement(line) {
     };
   }
 }
+
+/**
+ * Computes a stack trace object from an error object, by extracting the source and line number from the error object,
+ * and using them to create a single stack frame.
+ *
+ * @param {Error} ex - The error object to compute the stack trace for.
+ * @returns {Object|null} - An object representing the computed stack trace, or null if the
+ * input error object does not contain a line number.
+ */
 function computeStackTraceBySourceAndLine(ex) {
   if (!('line' in ex)) return null;
   var className = ex.name || getClassName(ex);
@@ -169,7 +228,10 @@ function computeStackTraceBySourceAndLine(ex) {
       }]
     };
   }
-  var stackString = className + ': ' + ex.message + '\n    at ' + ex.sourceURL;
+
+  // Remove any query string and fragment
+  var canonicalUrl = canonicalizeUrl(ex.sourceURL);
+  var stackString = className + ': ' + ex.message + '\n    at ' + canonicalUrl;
   if (ex.line) {
     stackString += ':' + ex.line;
     if (ex.column) {
@@ -182,12 +244,19 @@ function computeStackTraceBySourceAndLine(ex) {
     message: ex.message,
     stackString: stackString,
     frames: [{
-      url: ex.sourceURL,
+      url: canonicalUrl,
       line: ex.line,
       column: ex.column
     }]
   };
 }
+
+/**
+ * For exceptions with no stack and only a message, derives a stack trace by extracting the class name and message.
+ *
+ * @param {Error} ex - The exception for which to compute the stack trace.
+ * @returns {StackTrace} A stack trace object containing the name and message of the exception.
+ */
 function computeStackTraceWithMessageOnly(ex) {
   var className = ex.name || getClassName(ex);
   if (!className) return null;
@@ -199,10 +268,24 @@ function computeStackTraceWithMessageOnly(ex) {
     frames: []
   };
 }
+
+/**
+ * Attempts to extract the name of the constructor function (the class) of the given object.
+ *
+ * @param {Object} obj - The object for which to extract the constructor function name.
+ * @returns {string} The name of the constructor function, or 'unknown' if the name cannot be determined.
+ */
 function getClassName(obj) {
   var results = classNameRegex.exec(String(obj.constructor));
   return results && results.length > 1 ? results[1] : 'unknown';
 }
-function isWrapper(functionName) {
+
+/**
+ * Checks whether the given function name is a New Relic wrapper function.
+ *
+ * @param {string} functionName - The name of the function to check.
+ * @returns {boolean} True if the function name includes the string 'nrWrapper', false otherwise.
+ */
+function isNrWrapper(functionName) {
   return functionName && functionName.indexOf('nrWrapper') >= 0;
 }