@newrelic/browser-agent 1.233.0 → 1.234.0

package/dist/esm/common/util/get-or-set.test.js

@@ -0,0 +1,45 @@
+import { getOrSet } from './get-or-set';
+test('should return the current value of an existing property', () => {
+  const obj = {
+    foo: 'bar'
+  };
+  const prop = 'foo';
+  const getVal = jest.fn();
+  const result = getOrSet(obj, prop, getVal);
+  expect(result).toBe('bar');
+  expect(getVal).not.toHaveBeenCalled();
+});
+test('should set and return the value from getVal if the property does not exist', () => {
+  const obj = {};
+  const prop = 'foo';
+  const getVal = jest.fn().mockReturnValue('baz');
+  const result = getOrSet(obj, prop, getVal);
+  expect(result).toBe('baz');
+  expect(getVal).toHaveBeenCalled();
+  expect(obj.foo).toBe('baz');
+});
+test('should set the property as non-enumerable if Object.defineProperty is supported', () => {
+  const obj = {};
+  const prop = 'foo';
+  const getVal = jest.fn().mockReturnValue('baz');
+  jest.spyOn(Object, 'defineProperty');
+  const result = getOrSet(obj, prop, getVal);
+  expect(result).toBe('baz');
+  expect(Object.defineProperty).toHaveBeenCalledWith(obj, prop, {
+    value: 'baz',
+    writable: true,
+    enumerable: false
+  });
+});
+test('should set the property from getVal if Object.defineProperty and Object.keys are not supported', () => {
+  const obj = {};
+  const prop = 'foo';
+  const getVal = jest.fn(() => 'baz');
+  const originalFn = Object.defineProperty;
+  Object.defineProperty = null;
+  const result = getOrSet(obj, prop, getVal);
+  expect(result).toBe('baz');
+  expect(obj.foo).toBe('baz');
+  expect(Object.prototype.propertyIsEnumerable.call(obj, 'foo')).toBe(true);
+  Object.defineProperty = originalFn;
+});

package/dist/esm/common/util/stringify.test.js

@@ -0,0 +1,46 @@
+import { stringify } from './stringify';
+var mockEmit = jest.fn();
+jest.mock('../event-emitter/contextual-ee', () => ({
+  __esModule: true,
+  get ee() {
+    return {
+      emit: mockEmit
+    };
+  }
+}));
+test('should return a JSON string representation of the value', () => {
+  const obj = {
+    a: 1,
+    b: {
+      nested: true
+    }
+  };
+  const expected = '{"a":1,"b":{"nested":true}}';
+  const result = stringify(obj);
+  expect(result).toBe(expected);
+});
+test('should handle circular references and exclude them from the JSON output', () => {
+  const obj = {
+    a: 1
+  };
+  obj.b = obj; // Create a circular reference
+  const expected = '{"a":1}';
+  const result = stringify(obj);
+  expect(result).toBe(expected);
+});
+test('should handle non-object values and return their string representation', () => {
+  const value = 42;
+  const expected = '42';
+  const result = stringify(value);
+  expect(result).toBe(expected);
+});
+test('should emit an "internal-error" event if an error occurs during JSON.stringify', () => {
+  const obj = {
+    a: 1
+  };
+  jest.spyOn(JSON, 'stringify').mockImplementation(() => {
+    throw new Error('message');
+  });
+  stringify(obj);
+  expect(mockEmit).toHaveBeenCalledWith('internal-error', expect.any(Array));
+});

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

@@ -42,6 +42,14 @@ submitData.jsonp = function jsonp(_ref) {
     // do nothing
   }
 };
+
+/**
+ * Performs an asynchronous GET request using XMLHttpRequest.
+ *
+ * @param {Object} args - An object containing a `url` property.
+ * @param {string} args.url - The URL to send the GET request to.
+ * @returns {XMLHttpRequest} - An XMLHttpRequest object.
+ */
 submitData.xhrGet = function xhrGet(_ref2) {
   let {
     url
@@ -55,18 +63,18 @@ submitData.xhrGet = function xhrGet(_ref2) {
 
 /**
  * Send via XHR
- * @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
+ * @param {Object} args - The args.
+ * @param {string} args.url - The URL to send to.
+ * @param {string=} args.body - The Stringified body. Default null to prevent IE11 from breaking.
+ * @param {boolean=} args.sync - Run XHR synchronously.
+ * @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(_ref3) {
   let {
     url,
-    body,
+    body = null,
     sync,
     method = 'POST',
     headers = [{
@@ -89,13 +97,6 @@ submitData.xhr = function xhr(_ref3) {
   return request;
 };
 
-/**
- * Unused at the moment -- DEPRECATED
- */
-// submitData.xhrSync = function xhrSync (url, body) {
-//   return submitData.xhr(url, body, true)
-// }
-
 /**
  * Send by appending an <img> element to the page. Do NOT call this function outside of a guaranteed web window environment.
  * @param {Object} args - The args
@@ -106,7 +107,6 @@ submitData.img = function img(_ref4) {
   let {
     url
   } = _ref4;
-  console.log('img url', url);
   var element = new Image();
   element.src = url;
   return element;

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

@@ -0,0 +1,219 @@
+/**
+ * @jest-environment jsdom
+ * @jest-environment-options {"html": "<html><head><script></script></head><body></body></html>", "url": "https://example.com/"}
+ */
+
+import { submitData } from './submit-data';
+const mockWorkerScope = jest.fn().mockImplementation(() => false);
+jest.mock('./global-scope', () => ({
+  __esModule: true,
+  get isWorkerScope() {
+    return mockWorkerScope();
+  }
+}));
+const url = 'https://example.com/api';
+beforeEach(() => {
+  jest.restoreAllMocks();
+  mockWorkerScope.mockReturnValue(false);
+});
+describe('submitData.jsonp', () => {
+  // This test requires a script tag to exist in the html set by this file's jest-environment-options header block.
+  test('should return an HTMLScriptElement when called from a web window environment', () => {
+    mockWorkerScope.mockReturnValue(false);
+    const jsonp = 'callback';
+    const result = submitData.jsonp({
+      url,
+      jsonp
+    });
+    expect(result).toBeInstanceOf(HTMLScriptElement);
+    expect(result.type).toBe('text/javascript');
+    expect(result.src).toBe(url + '&jsonp=' + jsonp);
+  });
+  test('should try to use importScripts when called from a worker scope', () => {
+    mockWorkerScope.mockReturnValueOnce(true);
+    const jsonp = 'callback';
+    global.importScripts = jest.fn();
+    submitData.jsonp({
+      url,
+      jsonp
+    });
+    expect(importScripts).toHaveBeenCalledWith(url + '&jsonp=' + jsonp);
+    delete global.importScripts;
+  });
+  test('should fall back to an xhrGet call and return false when called from a worker scope', () => {
+    mockWorkerScope.mockReturnValueOnce(true);
+    const jsonp = 'callback';
+    jest.spyOn(submitData, 'xhrGet').mockImplementation(jest.fn());
+    const result = submitData.jsonp({
+      url,
+      jsonp
+    });
+    expect(result).toBe(false);
+    expect(submitData.xhrGet).toHaveBeenCalledTimes(1);
+  });
+  test('should not throw an error if any error occurs during execution', () => {
+    jest.spyOn(document, 'createElement').mockImplementation(() => {
+      throw new Error('message');
+    });
+    const jsonp = 'callback';
+    expect(() => {
+      submitData.jsonp({
+        url,
+        jsonp
+      });
+    }).not.toThrow();
+  });
+});
+describe('submitData.xhrGet', () => {
+  test('should return an XMLHttpRequest object', () => {
+    const result = submitData.xhrGet({
+      url
+    });
+    expect(result).toBeInstanceOf(XMLHttpRequest);
+  });
+  test('should not throw an error if URL is not provided', () => {
+    expect(() => {
+      submitData.xhrGet({});
+    }).not.toThrow();
+  });
+  test('should not throw an error if an invalid URL is provided', () => {
+    expect(() => {
+      submitData.xhrGet({
+        url: 'invalid url'
+      });
+    }).not.toThrow();
+  });
+});
+describe('submitData.xhr', () => {
+  test('should return an XMLHttpRequest object', () => {
+    const result = submitData.xhrGet({
+      url
+    });
+    expect(result).toBeInstanceOf(XMLHttpRequest);
+  });
+  test('should not throw an error if URL is not provided', () => {
+    expect(() => {
+      submitData.xhr({});
+    }).not.toThrow();
+  });
+  test('should not throw an error if an invalid URL is provided', () => {
+    expect(() => {
+      submitData.xhr({
+        url: 'invalid url'
+      });
+    }).not.toThrow();
+  });
+  test('should send a POST request by default', () => {
+    jest.spyOn(XMLHttpRequest.prototype, 'open');
+    submitData.xhr({
+      url
+    });
+    expect(XMLHttpRequest.prototype.open).toHaveBeenCalledWith('POST', url, true);
+  });
+  test('should send a GET request if specified', () => {
+    jest.spyOn(XMLHttpRequest.prototype, 'open');
+    submitData.xhr({
+      url,
+      method: 'GET'
+    });
+    expect(XMLHttpRequest.prototype.open).toHaveBeenCalledWith('GET', url, true);
+  });
+
+  // This test requires a same-origin url to be set by this file's jest-environment-options header block.
+  test('should send a request synchronously if specified', () => {
+    jest.spyOn(XMLHttpRequest.prototype, 'open');
+    submitData.xhr({
+      url,
+      sync: true
+    });
+    expect(XMLHttpRequest.prototype.open).toHaveBeenCalledWith('POST', url, false);
+  });
+  test('should set custom headers if provided', () => {
+    const headers = [{
+      key: 'Content-Type',
+      value: 'application/json'
+    }];
+    jest.spyOn(XMLHttpRequest.prototype, 'setRequestHeader');
+    submitData.xhr({
+      url,
+      headers
+    });
+    headers.forEach(header => {
+      expect(XMLHttpRequest.prototype.setRequestHeader).toHaveBeenCalledWith(header.key, header.value);
+    });
+  });
+  test('should send a request with the specified body', () => {
+    const body = JSON.stringify({
+      key: 'value'
+    });
+    jest.spyOn(XMLHttpRequest.prototype, 'send');
+    submitData.xhr({
+      url,
+      body
+    });
+    expect(XMLHttpRequest.prototype.send).toHaveBeenCalledWith(body);
+  });
+});
+describe('submitData.img', () => {
+  test('should return an HTMLImageElement', () => {
+    const imageUrl = 'https://example.com/image.png';
+    const result = submitData.img({
+      url: imageUrl
+    });
+    expect(result).toBeInstanceOf(HTMLImageElement);
+  });
+  test('should not throw an error if URL is not provided', () => {
+    expect(() => {
+      submitData.img({});
+    }).not.toThrow();
+  });
+  test('should set the src attribute of the image element to the provided URL', () => {
+    const imageUrl = 'https://example.com/image.png';
+    const result = submitData.img({
+      url: imageUrl
+    });
+    expect(result.src).toBe(imageUrl);
+  });
+});
+describe('submitData.beacon', () => {
+  test('should return true when beacon request succeeds', () => {
+    const body = JSON.stringify({
+      key: 'value'
+    });
+    window.navigator.sendBeacon = {
+      bind: jest.fn(() => () => true)
+    };
+    const result = submitData.beacon({
+      url,
+      body
+    });
+    expect(result).toBe(true);
+  });
+  test('should return false when beacon request fails', () => {
+    const body = JSON.stringify({
+      key: 'value'
+    });
+    window.navigator.sendBeacon = {
+      bind: jest.fn(() => () => {
+        throw new Error('message');
+      })
+    };
+    const result = submitData.beacon({
+      url,
+      body
+    });
+    expect(result).toBe(false);
+  });
+  test('should error if sendBeacon is not supported', () => {
+    const body = JSON.stringify({
+      key: 'value'
+    });
+    window.navigator.sendBeacon = undefined;
+    expect(() => {
+      submitData.beacon({
+        url,
+        body
+      });
+    }).toThrow();
+  });
+});

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

@@ -3,33 +3,25 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-// traverses an object and applies a fn to property values of a certain type
-export function applyFnToProps(obj, fn, type, ignoreKeys) {
+/**
+ * Applies a function to properties of a specified type in an object, recursively.
+ *
+ * @param {Object} obj - The object to apply the function to.
+ * @param {Function} fn - The function to apply to matching properties.
+ * @param {string} [type='string'] - The type of properties to apply the function to.
+ * @param {Array<string>} [ignoreKeys=[]] - The keys of properties to ignore and not modify.
+ * @returns {Object} - The object with function recursively applied.
+ */
+export 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] : [];
   if (!obj || typeof obj !== 'object') return obj;
-  type = type || 'string';
-  ignoreKeys = ignoreKeys || [];
-  return traverse(obj);
-  function traverse(obj) {
-    for (var property in obj) {
-      // eslint-disable-next-line
-      if (obj.hasOwnProperty(property)) {
-        if (typeof obj[property] === 'object') {
-          traverse(obj[property]);
-        } else {
-          if (typeof obj[property] === type && !shouldIgnore(property)) obj[property] = fn(obj[property]);
-        }
-      }
-    }
-    return obj;
-  }
-  function shouldIgnore(key) {
-    var ignore = false;
-    for (var i = 0; i < ignoreKeys.length; i++) {
-      if (ignoreKeys[i] === key) {
-        ignore = true;
-        break;
-      }
+  Object.keys(obj).forEach(property => {
+    if (typeof obj[property] === 'object') {
+      applyFnToProps(obj[property], fn, type, ignoreKeys);
+    } else {
+      if (typeof obj[property] === type && !ignoreKeys.includes(property)) obj[property] = fn(obj[property]);
     }
-    return ignore;
-  }
+  });
+  return obj;
 }

package/dist/esm/common/util/traverse.test.js

@@ -0,0 +1,42 @@
+import { applyFnToProps } from './traverse';
+test.each(['not an object', null, undefined])('should return input unchanged when input is %p', input => {
+  const result = applyFnToProps(input, jest.fn());
+  expect(result).toEqual(input);
+});
+test('should apply the provided function only to properties of the specified type', () => {
+  const obj = {
+    stringProp: 'Hello',
+    numberProp: 42,
+    arrayProp: [1, 2, 3],
+    objectProp: {
+      foo: 'bar'
+    }
+  };
+  const fn = jest.fn(value => value.toUpperCase());
+  const result = applyFnToProps(obj, fn, 'string');
+  expect(result.stringProp).toBe('HELLO');
+  expect(result.numberProp).toBe(42);
+  expect(result.arrayProp).toEqual([1, 2, 3]);
+  expect(result.objectProp).toEqual({
+    foo: 'BAR'
+  });
+  expect(fn).toHaveBeenCalledTimes(2);
+  expect(fn).toHaveBeenCalledWith('Hello');
+  expect(fn).toHaveBeenCalledWith('bar');
+});
+test('should ignore properties specified in ignoreKeys', () => {
+  const obj = {
+    a: 1,
+    b: 2,
+    c: 3
+  };
+  const fn = jest.fn(value => value + 1);
+  const ignoreKeys = ['c'];
+  const result = applyFnToProps(obj, fn, 'number', ignoreKeys);
+  expect(result.a).toBe(2);
+  expect(result.b).toBe(3);
+  expect(result.c).toBe(3);
+  expect(fn).toHaveBeenCalledTimes(2);
+  expect(fn).toHaveBeenCalledWith(1);
+  expect(fn).toHaveBeenCalledWith(2);
+});

package/dist/esm/features/metrics/aggregate/endpoint-map.js

@@ -0,0 +1,7 @@
+export const endpointMap = {
+  rum: '1',
+  events: 'Events',
+  ins: 'Ins',
+  jserrors: 'Jserrors',
+  resources: 'Resources'
+};

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

@@ -13,6 +13,7 @@ import { windowAddEventListener } from '../../../common/event-listener/event-lis
 import { isBrowserScope } from '../../../common/util/global-scope';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { stringify } from '../../../common/util/stringify';
+import { endpointMap } from './endpoint-map';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
@@ -131,12 +132,12 @@ export class Aggregate extends AggregateBase {
 
       // Capture per-agent bytes sent for each endpoint (see harvest) and RUM call (see page_view_event aggregator).
       Object.keys(agentRuntime.bytesSent).forEach(endpoint => {
-        this.storeSupportabilityMetrics("PageSession/Endpoint/".concat(endpoint.charAt(0).toUpperCase() + endpoint.slice(1), "/BytesSent"), agentRuntime.bytesSent[endpoint]);
+        this.storeSupportabilityMetrics("PageSession/Endpoint/".concat(endpointMap[endpoint], "/BytesSent"), agentRuntime.bytesSent[endpoint]);
       });
 
       // Capture per-agent query bytes sent for each endpoint (see harvest) and RUM call (see page_view_event aggregator).
       Object.keys(agentRuntime.bytesSent).forEach(endpoint => {
-        this.storeSupportabilityMetrics("PageSession/Endpoint/".concat(endpoint.charAt(0).toUpperCase() + endpoint.slice(1), "/QueryBytesSent"), agentRuntime.queryBytesSent[endpoint]);
+        this.storeSupportabilityMetrics("PageSession/Endpoint/".concat(endpointMap[endpoint], "/QueryBytesSent"), agentRuntime.queryBytesSent[endpoint]);
       });
 
       // Capture metrics for session trace if active (`ptid` is set when returned by replay ingest).

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

@@ -1,5 +1,4 @@
 import { InstrumentBase } from '../../utils/instrument-base';
-import { insertSupportMetrics } from './workers-helper';
 import { FEATURE_NAME, SUPPORTABILITY_METRIC_CHANNEL } from '../constants';
 import { handle } from '../../../common/event-emitter/handle';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
@@ -8,7 +7,6 @@ export class Instrument extends InstrumentBase {
   constructor(agentIdentifier, aggregator) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
-    insertSupportMetrics(tag => handle(SUPPORTABILITY_METRIC_CHANNEL, [tag], undefined, FEATURE_NAMES.metrics, this.ee));
     this.importAggregator();
   }
 }