@newrelic/browser-agent 0.1.231 → 1.232.1

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

@@ -25,7 +25,7 @@ const TIMER_FNS = [SET_TIMEOUT, 'setImmediate', SET_INTERVAL, CLEAR_TIMEOUT, 'cl
  * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.
  * @returns {Object} Scoped event emitter with a debug ID of `timer`.
  */
-//eslint-disable-next-line
+// eslint-disable-next-line
 export function wrapTimer(sharedEE) {
   const ee = scopedEE(sharedEE);
 

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

@@ -9,12 +9,12 @@ import { handle } from '../../../common/event-emitter/handle';
 import { getConfigurationValue, getInfo } from '../../../common/config/config';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { setDenyList, shouldCollectEvent } from '../../../common/deny-list/deny-list';
-import { AggregateBase } from '../../utils/aggregate-base';
 import { FEATURE_NAME } from '../constants';
 import { drain } from '../../../common/drain/drain';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
-export class Aggregate extends AggregateBase {
+import { FeatureBase } from '../../utils/feature-base';
+export class Aggregate extends FeatureBase {
   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;
 }

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

@@ -1,14 +1,27 @@
 import { faker } from '@faker-js/faker';
 import { browserErrorUtils } from '../../../../tools/testing-utils';
-import { computeStackTrace } from './compute-stack-trace';
+const globalScopeLocation = 'https://example.com/';
+const mockGlobalScopeLocation = url => {
+  jest.doMock('../../../common/util/global-scope', () => ({
+    initialLocation: url || globalScopeLocation
+  }));
+};
+afterEach(() => {
+  jest.resetModules();
+  jest.clearAllMocks();
+});
 const baseMockError = {
   toString: 'RangeError: Invalid array length',
   name: 'RangeError',
   constructor: 'function RangeError() { [native code] }',
   message: 'Invalid array length',
-  stack: 'RangeError: Invalid array length\n    at errorTest (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:74:16)\n    at captureError (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:17:9)\n    at onload (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:70:5)'
+  stack: 'RangeError: Invalid array length\n' + '    at errorTest (' + globalScopeLocation + '?loader=spa#hello:74:16)\n' + '    at captureError (' + globalScopeLocation + 'js/script.js?loader=spa:17:9)\n' + '    at onload (' + globalScopeLocation + 'js/script.js?loader=spa:70:5)'
 };
-test('parsing should return a failure for a null error object', () => {
+test('parsing should return a failure for a null error object', async () => {
+  mockGlobalScopeLocation();
+  const {
+    computeStackTrace
+  } = await import('./compute-stack-trace');
   const result = computeStackTrace(null);
   expect(result).toEqual(expect.objectContaining({
     mode: 'failed',
@@ -17,24 +30,45 @@ test('parsing should return a failure for a null error object', () => {
   }));
 });
 describe('errors with stack property', () => {
-  test('parsed name should be unknown when name and constructor are missing', () => {
+  test('should show <inline> for same-page stack string URLs but not sub-paths', async () => {
+    const mockError = browserErrorUtils.constructError({
+      ...baseMockError
+    });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
+    const result = computeStackTrace(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      stackString:
+      // canonicalized
+      'RangeError: Invalid array length\n' + '    at errorTest (<inline>:74:16)\n' + '    at captureError (' + globalScopeLocation + 'js/script.js:17:9)\n' + '    at onload (' + globalScopeLocation + 'js/script.js:70:5)'
+    }));
+  });
+  test('parsed name should be unknown when name and constructor are missing', async () => {
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
       name: null,
       constructor: null
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'stack',
-      name: 'unknown',
-      message: mockError.message,
-      stackString: mockError.stack
+      name: 'unknown'
     }));
   });
-  test('parsed stack should not contain nrWrapper', () => {
+  test('parsed stack should not contain nrWrapper', async () => {
     const alteredError = baseMockError;
-    alteredError.stack += '\n    at nrWrapper (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:60:17)';
+    alteredError.stack += '\n    at nrWrapper (' + globalScopeLocation + '?loader=spa:60:17)';
     const mockError = browserErrorUtils.constructError(alteredError);
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'stack',
@@ -46,17 +80,21 @@ describe('errors with stack property', () => {
       func: 'nrWrapper'
     }));
   });
-  test('stack should still parse when column numbers are missing', () => {
+  test('stack should still parse when column numbers are missing', async () => {
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
-      stack: 'Error: Blocked a frame with origin "http://bam-test-1.nr-local.net:3334" from accessing a cross-origin frame.\n    at errorTest (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:60)\n    at captureError (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:17)\n    at onload (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:57)'
+      stack: 'RangeError: Invalid array length\n' + 'Error: Blocked a frame with origin "http://bam-test-1.nr-local.net:3334" from accessing a cross-origin frame.\n' + '    at errorTest (' + globalScopeLocation + '?loader=spa:60)\n' + '    at captureError (' + globalScopeLocation + '?loader=spa:17)\n' + '    at onload (' + globalScopeLocation + '?loader=spa:57)'
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'stack',
       name: mockError.name,
       message: mockError.message,
-      stackString: mockError.stack
+      stackString: 'RangeError: Invalid array length\n' + 'Error: Blocked a frame with origin "http://bam-test-1.nr-local.net:3334" from accessing a cross-origin frame.\n' + '    at errorTest (<inline>:60)\n' + '    at captureError (<inline>:17)\n' + '    at onload (<inline>:57)'
     }));
     expect(result.frames.length).toEqual(3);
     expect(result.frames).toContainEqual(expect.objectContaining({
@@ -72,11 +110,15 @@ describe('errors with stack property', () => {
       column: null
     }));
   });
-  test('parser can handle chrome eval stack', () => {
+  test('parser can handle chrome eval stack', async () => {
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
-      stack: '    at foobar (eval at foobar (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html))'
+      stack: '    at foobar (eval at foobar (' + globalScopeLocation + '))'
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'stack',
@@ -89,7 +131,7 @@ describe('errors with stack property', () => {
       func: 'evaluated code'
     }));
   });
-  test('parser can handle ie eval stack', () => {
+  test('parser can handle ie eval stack', async () => {
     const mockError = browserErrorUtils.constructError({
       toString: 'TypeError: Permission denied',
       name: 'TypeError',
@@ -97,6 +139,10 @@ describe('errors with stack property', () => {
       message: 'Permission denied',
       stack: '    at Function code (Function code:23:23)'
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'stack',
@@ -109,11 +155,15 @@ describe('errors with stack property', () => {
       func: 'evaluated code'
     }));
   });
-  test('parser can handle stack with anonymous function', () => {
+  test('parser can handle stack with anonymous function', async () => {
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
       stack: 'anonymous'
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'stack',
@@ -131,7 +181,7 @@ describe('errors without stack property and with line property', () => {
   /**
    * @deprecated sourceURL is no longer present in errors for any browsers we support
    */
-  test('parsed stack should contain sourceURL and line number', () => {
+  test('parsed stack should contain sourceURL and line number', async () => {
     const sourceURL = faker.internet.url();
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
@@ -139,6 +189,10 @@ describe('errors without stack property and with line property', () => {
       line: 100,
       sourceURL
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'sourceline',
@@ -156,7 +210,7 @@ describe('errors without stack property and with line property', () => {
   /**
    * @deprecated sourceURL is no longer present in errors for any browsers we support
    */
-  test('parsed stack should contain sourceURL, line number, and column number', () => {
+  test('parsed stack should contain sourceURL, line number, and column number', async () => {
     const sourceURL = faker.internet.url();
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
@@ -165,6 +219,10 @@ describe('errors without stack property and with line property', () => {
       stack: undefined,
       sourceURL
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'sourceline',
@@ -179,13 +237,17 @@ describe('errors without stack property and with line property', () => {
       column: mockError.column
     }));
   });
-  test('parsed stack should contain "evaluated code" if sourceURL property is not present', () => {
+  test('parsed stack should contain "evaluated code" if sourceURL property is not present', async () => {
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
       line: 100,
       column: 200,
       stack: undefined
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'sourceline',
@@ -199,6 +261,58 @@ describe('errors without stack property and with line property', () => {
     }));
   });
 
+  /**
+   * @deprecated sourceURL is no longer present in errors for any browsers we support
+   */
+  test('should show <inline> for same-page URLs', async () => {
+    const pageLocation = faker.internet.url();
+    const sourceURL = pageLocation + '?abc=123';
+    const mockError = browserErrorUtils.constructError({
+      ...baseMockError,
+      line: 100,
+      column: 200,
+      stack: undefined,
+      sourceURL: sourceURL
+    });
+    mockGlobalScopeLocation(pageLocation);
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
+    const result = computeStackTrace(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      stackString: "".concat(mockError.name, ": ").concat(mockError.message, "\n    at <inline>:").concat(mockError.line, ":").concat(mockError.column)
+    }));
+    expect(result.frames).toContainEqual(expect.objectContaining({
+      url: '<inline>'
+    }));
+  });
+
+  /**
+   * @deprecated sourceURL is no longer present in errors for any browsers we support
+   */
+  test('should NOT show <inline> for same-domain URLs with a sub-path', async () => {
+    const pageLocation = faker.internet.url();
+    const sourceURL = pageLocation + '/path/to/script.js';
+    const mockError = browserErrorUtils.constructError({
+      ...baseMockError,
+      line: 100,
+      column: 200,
+      stack: undefined,
+      sourceURL
+    });
+    mockGlobalScopeLocation(pageLocation);
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
+    const result = computeStackTrace(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      stackString: "".concat(mockError.name, ": ").concat(mockError.message, "\n    at ").concat(sourceURL, ":").concat(mockError.line, ":").concat(mockError.column)
+    }));
+    expect(result.frames).toContainEqual(expect.objectContaining({
+      url: sourceURL
+    }));
+  });
+
   // TODO: computeStackTraceBySourceAndLine does not respect firefox lineNumber and columnNumber properties when stack is empty
 });
 
@@ -207,11 +321,15 @@ describe('errors without stack property and with line property', () => {
  * error, including primitives.
  */
 describe('errors that are messages only or primitives', () => {
-  test('parser should get error name from constructor', () => {
+  test('parser should get error name from constructor', async () => {
     const mockError = browserErrorUtils.constructError({
       toString: '0',
       constructor: 'function Number() { [native code] }'
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'nameonly',
@@ -220,12 +338,16 @@ describe('errors that are messages only or primitives', () => {
       frames: []
     }));
   });
-  test('parser should get error name from name property', () => {
+  test('parser should get error name from name property', async () => {
     const mockError = browserErrorUtils.constructError({
       toString: '0',
       name: faker.datatype.uuid(),
       constructor: 'function Number() { [native code] }'
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'nameonly',
@@ -234,13 +356,17 @@ describe('errors that are messages only or primitives', () => {
       frames: []
     }));
   });
-  test('parser should include the message property', () => {
+  test('parser should include the message property', async () => {
     const mockError = browserErrorUtils.constructError({
       toString: '0',
       name: faker.datatype.uuid(),
       message: faker.datatype.uuid(),
       constructor: 'function Number() { [native code] }'
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'nameonly',
@@ -250,6 +376,4 @@ describe('errors that are messages only or primitives', () => {
       frames: []
     }));
   });
-});
-
-// describe('')
+});