@newrelic/browser-agent 1.232.0 → 1.232.1

package/dist/cjs/common/constants/env.cdn.js

@@ -12,7 +12,7 @@ exports.VERSION = exports.DIST_METHOD = exports.BUILD_ENV = void 0;
 /**
  * Exposes the version of the agent
  */
-const VERSION = "1.232.0";
+const VERSION = "1.232.1";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/constants/env.npm.js

@@ -12,7 +12,7 @@ exports.VERSION = exports.DIST_METHOD = exports.BUILD_ENV = void 0;
 /**
  * Exposes the version of the agent
  */
-const VERSION = "1.232.0";
+const VERSION = "1.232.1";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/url/canonicalize-url.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.canonicalizeUrl = canonicalizeUrl;
+var _globalScope = require("../util/global-scope");
+var _cleanUrl = require("./clean-url");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Converts a URL to its basic form without a query string or fragment. If the resulting URL is the same as the
+ * loader's origin URL, returns '<inline>'.
+ * @param {string} url - The URL to be canonicalized.
+ * @param {string} loaderOriginUrl - The origin URL of the agent loader, used for inline detection.
+ * @returns {string} The canonicalized URL, or '<inline>' if the URL matches the loader origin URL.
+ */
+function canonicalizeUrl(url) {
+  if (typeof url !== 'string') return '';
+  const cleanedUrl = (0, _cleanUrl.cleanURL)(url);
+  const cleanedGlobalScopeUrl = (0, _cleanUrl.cleanURL)(_globalScope.initialLocation);
+
+  // If the URL matches the origin URL of the loader, we assume it originated within an inline script.
+  if (cleanedUrl === cleanedGlobalScopeUrl) {
+    return '<inline>';
+  } else {
+    return cleanedUrl;
+  }
+}

package/dist/cjs/common/url/canonicalize-url.test.js

@@ -0,0 +1,42 @@
+"use strict";
+
+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; }
+afterEach(() => {
+  jest.resetModules();
+});
+test.each([null, undefined, 34])('returns empty string when url argument is %s', async url => {
+  const {
+    canonicalizeUrl
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./canonicalize-url')));
+  expect(canonicalizeUrl(url)).toEqual('');
+});
+test('strips URLs of query strings and fragments', async () => {
+  jest.doMock('../util/global-scope', () => ({
+    initialLocation: 'http://different-domain.com/'
+  }));
+  const {
+    canonicalizeUrl
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./canonicalize-url')));
+  expect(canonicalizeUrl('http://example.com/path?query=string#fragment')).toBe('http://example.com/path');
+  expect(canonicalizeUrl('https://www.example.com/path/to/file.html?param=value')).toBe('https://www.example.com/path/to/file.html');
+  expect(canonicalizeUrl('https://www.example.com/?param=value#fragment')).toBe('https://www.example.com/');
+});
+test('returns <inline> when matching the page URL of the loader', async () => {
+  jest.doMock('../util/global-scope', () => ({
+    initialLocation: 'http://example.com/'
+  }));
+  const {
+    canonicalizeUrl
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./canonicalize-url')));
+  expect(canonicalizeUrl('http://example.com/')).toEqual('<inline>');
+});
+test('does not identify sub-paths of the loader origin as <inline>', async () => {
+  jest.doMock('../util/global-scope', () => ({
+    initialLocation: 'http://example.com/'
+  }));
+  const {
+    canonicalizeUrl
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./canonicalize-url')));
+  expect(canonicalizeUrl('http://example.com/path/to/script.js')).not.toEqual('<inline>');
+});

package/dist/cjs/common/url/clean-url.js

@@ -9,8 +9,15 @@ exports.cleanURL = cleanURL;
  * SPDX-License-Identifier: Apache-2.0
  */
 
-var withHash = /([^?#]*)[^#]*(#[^?]*|$).*/;
-var withoutHash = /([^?#]*)().*/;
+var patternWithHash = /([^?#]*)[^#]*(#[^?]*|$).*/;
+var patternWithoutHash = /([^?#]*)().*/;
+
+/**
+ * Cleans a URL by removing the query string and fragment (hash portion).
+ * @param {string} url - The original URL to be cleaned.
+ * @param {boolean} [keepHash=false] - Whether to preserve the hash portion of the URL.
+ * @returns {string} The cleaned URL.
+ */
 function cleanURL(url, keepHash) {
-  return url.replace(keepHash ? withHash : withoutHash, '$1$2');
+  return url.replace(keepHash ? patternWithHash : patternWithoutHash, '$1$2');
 }

package/dist/cjs/common/util/global-scope.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getGlobalScope = getGlobalScope;
-exports.isWorkerScope = exports.isBrowserScope = exports.globalScope = void 0;
+exports.isWorkerScope = exports.isBrowserScope = exports.initialLocation = exports.globalScope = void 0;
 exports.resetScope = resetScope;
 exports.setScope = setScope;
 /* global globalThis, WorkerGlobalScope, WorkerNavigator */
@@ -25,6 +25,8 @@ let globalScope = (() => {
   }
   throw new Error('New Relic browser agent shutting down due to error: Unable to locate global scope. This is possibly due to code redefining browser global variables like "self" and "window".');
 })();
+exports.globalScope = globalScope;
+const initialLocation = '' + globalScope.location;
 
 /**
  * The below methods are only used for testing and should be removed once the
@@ -32,7 +34,7 @@ let globalScope = (() => {
  * tests/browser/protocol.browser.js
  * tests/browser/obfuscate.browser.js
  */
-exports.globalScope = globalScope;
+exports.initialLocation = initialLocation;
 function setScope(obj) {
   exports.globalScope = globalScope = {
     ...obj

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

@@ -6,10 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.scopedEE = scopedEE;
 exports.wrapFetch = wrapFetch;
 var _contextualEe = require("../event-emitter/contextual-ee");
-var _lodash = _interopRequireDefault(require("lodash._slice"));
 var _globalScope = require("../util/global-scope");
 var _wrapFunction = require("./wrap-function");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -77,7 +75,7 @@ function wrapFetch(sharedEE) {
     var fn = target[name];
     if (typeof fn === 'function') {
       target[name] = function () {
-        var args = (0, _lodash.default)(arguments);
+        var args = Array.from(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

@@ -8,8 +8,6 @@ exports.flag = exports.default = void 0;
 exports.wrapFunction = wrapFunction;
 exports.wrapInPlace = wrapInPlace;
 var _contextualEe = require("../event-emitter/contextual-ee");
-var _lodash = _interopRequireDefault(require("lodash._slice"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -83,7 +81,7 @@ function createWrapperWithEmitter(emitter, always) {
       var result;
       try {
         originalThis = this;
-        args = (0, _lodash.default)(arguments);
+        args = Array.from(arguments);
         if (typeof getContext === 'function') {
           ctx = getContext(args, originalThis);
         } else {

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

@@ -99,7 +99,7 @@ function subscribeToEvents(agentIdentifier, ee, handler, dt) {
   }
   function onOpenXhrEnd(args, xhr) {
     var loader_config = (0, _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/cjs/features/jserrors/aggregate/canonical-function-name.js

@@ -9,10 +9,18 @@ exports.canonicalFunctionName = canonicalFunctionName;
  * SPDX-License-Identifier: Apache-2.0
  */
 
-var canonicalFunctionNameRe = /([a-z0-9]+)$/i;
-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.
+ */
+function canonicalFunctionName(functionNameString) {
+  if (!functionNameString) return;
+  const match = functionNameString.match(canonicalFunctionNameRe);
   if (match) return match[1];
   return;
 }

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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.computeStackTrace = computeStackTrace;
 var _formatStackTrace = require("./format-stack-trace");
+var _canonicalizeUrl = require("../../../common/url/canonicalize-url");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -70,6 +71,24 @@ var chrome = /^\s*at (?:((?:\[object object\])?(?:[^(]*\([^)]*\))*[^()]*(?: \[as
 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.
+ */
 function computeStackTrace(ex) {
   var stack = null;
   try {
@@ -110,9 +129,9 @@ 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) {
@@ -133,17 +152,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 = (0, _canonicalizeUrl.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) {
@@ -160,6 +210,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);
@@ -176,7 +235,10 @@ function computeStackTraceBySourceAndLine(ex) {
       }]
     };
   }
-  var stackString = className + ': ' + ex.message + '\n    at ' + ex.sourceURL;
+
+  // Remove any query string and fragment
+  var canonicalUrl = (0, _canonicalizeUrl.canonicalizeUrl)(ex.sourceURL);
+  var stackString = className + ': ' + ex.message + '\n    at ' + canonicalUrl;
   if (ex.line) {
     stackString += ':' + ex.line;
     if (ex.column) {
@@ -189,12 +251,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;
@@ -206,10 +275,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;
 }