@newrelic/browser-agent 1.233.1 → 1.234.0

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.233.1";
+const VERSION = "1.234.0";
 
 /**
  * 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.233.1";
+const VERSION = "1.234.0";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/event-emitter/contextual-ee.test.js

@@ -93,7 +93,7 @@ describe('event-emitter context', () => {
   });
 });
 describe('event-emitter buffer', () => {
-  it('it should create a new buffer for the given group', async () => {
+  test('it should create a new buffer for the given group', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -105,7 +105,7 @@ describe('event-emitter buffer', () => {
     }));
     expect(ee.isBuffering(eventType)).toEqual(true);
   });
-  it('it should default group to "feature"', async () => {
+  test('it should default group to "feature"', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -116,7 +116,7 @@ describe('event-emitter buffer', () => {
     }));
     expect(ee.isBuffering(eventType)).toEqual(true);
   });
-  it('it should not create buffer if event-emitter is aborted', async () => {
+  test('it should not create buffer if event-emitter is aborted', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -156,7 +156,7 @@ describe('event-emitter abort', () => {
   });
 });
 describe('event-emitter emit', () => {
-  it('should execute the listener', async () => {
+  test('should execute the listener', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -167,7 +167,7 @@ describe('event-emitter emit', () => {
     ee.emit(eventType, eventArgs);
     expect(mockListener).toHaveBeenCalledWith(eventArgs[0], eventArgs[1], eventArgs[2]);
   });
-  it('should not execute the listener after removal', async () => {
+  test('should not execute the listener after removal', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -180,7 +180,7 @@ describe('event-emitter emit', () => {
     ee.emit(eventType, eventArgs);
     expect(mockListener).toHaveBeenCalledTimes(1);
   });
-  it('should return early if global event-emitter is aborted', async () => {
+  test('should return early if global event-emitter is aborted', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -195,7 +195,7 @@ describe('event-emitter emit', () => {
     ee.emit(eventType, eventArgs);
     expect(mockListener).toHaveBeenCalledTimes(0);
   });
-  it('should still emit if global event-emitter is aborted but force flag is true', async () => {
+  test('should still emit if global event-emitter is aborted but force flag is true', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -211,7 +211,7 @@ describe('event-emitter emit', () => {
     scopeEE.emit(eventType, eventArgs, {}, true);
     expect(mockScopeListener).toHaveBeenCalledTimes(1);
   });
-  it('should bubble the event if bubble flag is true', async () => {
+  test('should bubble the event if bubble flag is true', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -226,7 +226,7 @@ describe('event-emitter emit', () => {
     expect(mockScopeListener).toHaveBeenCalledTimes(1);
     expect(mockListener).toHaveBeenCalledTimes(1);
   });
-  it('should not bubble the event if bubble flag is false', async () => {
+  test('should not bubble the event if bubble flag is false', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -241,7 +241,7 @@ describe('event-emitter emit', () => {
     expect(mockScopeListener).toHaveBeenCalledTimes(1);
     expect(mockListener).not.toHaveBeenCalled();
   });
-  it('should buffer the event on the scoped event-emitter', async () => {
+  test('should buffer the event on the scoped event-emitter', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));

package/dist/cjs/common/harvest/harvest-scheduler.test.js

@@ -3,7 +3,7 @@
 var _init = require("../config/state/init");
 var _harvestScheduler = require("./harvest-scheduler");
 describe('runHarvest', () => {
-  it('should re-schedule harvest even if there is no accumulated data', () => {
+  test('should re-schedule harvest even if there is no accumulated data', () => {
     (0, _init.setConfiguration)('asdf', {});
     const scheduler = new _harvestScheduler.HarvestScheduler('events', {
       getPayload: jest.fn()
@@ -19,7 +19,7 @@ describe('runHarvest', () => {
     expect(scheduler.opts.getPayload()).toBeFalsy();
     expect(scheduler.scheduleHarvest).toHaveBeenCalledTimes(1);
   });
-  it('should also re-schedule harvest if there is accumulated data', () => {
+  test('should also re-schedule harvest if there is accumulated data', () => {
     (0, _init.setConfiguration)('asdf', {});
     const scheduler = new _harvestScheduler.HarvestScheduler('events', {
       getPayload: jest.fn().mockImplementation(() => 'payload')

package/dist/cjs/common/harvest/harvest.js

@@ -131,7 +131,7 @@ class Harvest extends _sharedContext.SharedContext {
     var info = (0, _config.getInfo)(this.sharedContext.agentIdentifier);
     if (!info.errorBeacon) return false;
     var agentRuntime = (0, _config.getRuntime)(this.sharedContext.agentIdentifier);
-    if (!payload.body) {
+    if (!payload.body && !opts?.sendEmptyBody) {
       // no payload body? nothing to send, just run onfinish stuff and return
       if (cbFinished) {
         cbFinished({
@@ -141,7 +141,7 @@ class Harvest extends _sharedContext.SharedContext {
       return false;
     }
     let url = '';
-    if (customUrl) url = customUrl;else if (raw) url = "".concat(this.getScheme(), "://").concat(info.errorBeacon, "/").concat(endpoint);else url = "".concat(this.getScheme(), "://").concat(info.errorBeacon, "/").concat(endpoint, "/1/").concat(info.licenseKey);
+    if (customUrl) url = customUrl;else if (raw) url = "".concat(this.getScheme(), "://").concat(info.errorBeacon, "/").concat(endpoint);else url = "".concat(this.getScheme(), "://").concat(info.errorBeacon).concat(endpoint !== 'rum' ? "/".concat(endpoint) : '', "/1/").concat(info.licenseKey);
     var baseParams = !raw && includeBaseParams ? this.baseQueryString() : '';
     var payloadParams = payload.qs ? (0, _encode.obj)(payload.qs, agentRuntime.maxBytes) : '';
     if (!submitMethod) {
@@ -250,18 +250,11 @@ class Harvest extends _sharedContext.SharedContext {
   }
 }
 exports.Harvest = Harvest;
-function or(a, b) {
-  return a || b;
-}
 function getSubmitMethod(endpoint, opts) {
   opts = opts || {};
   var method;
   var useBody;
-  if (opts.needResponse) {
-    // currently: only STN needs a response
-    useBody = true;
-    method = _submitData.submitData.xhr;
-  } else if (opts.unload && _globalScope.isBrowserScope) {
+  if (opts.unload && _globalScope.isBrowserScope) {
     // all the features' final harvest; neither methods work outside window context
     useBody = haveSendBeacon;
     method = haveSendBeacon ? _submitData.submitData.beacon : _submitData.submitData.img; // really only IE doesn't have Beacon API for web browsers
@@ -291,7 +284,7 @@ function createAccumulator() {
   var accumulator = {};
   var hasData = false;
   return function (key, val) {
-    if (val !== null && val !== undefined && val.length) {
+    if (val !== null && val !== undefined && val.toString()?.length) {
       accumulator[key] = val;
       hasData = true;
     }

package/dist/cjs/common/harvest/harvest.test.js

@@ -0,0 +1,224 @@
+"use strict";
+
+var _submitData = require("../util/submit-data");
+var _harvest = require("./harvest");
+jest.mock('../context/shared-context', () => ({
+  __esModule: true,
+  SharedContext: function () {
+    this.sharedContext = {
+      agentIdentifier: 'abcd'
+    };
+  }
+}));
+jest.mock('../config/config', () => ({
+  __esModule: true,
+  getConfigurationValue: jest.fn(),
+  getInfo: jest.fn().mockReturnValue({
+    errorBeacon: 'example.com',
+    licenseKey: 'abcd'
+  }),
+  getRuntime: jest.fn().mockReturnValue({
+    bytesSent: {},
+    queryBytesSent: {}
+  })
+}));
+jest.mock('../util/submit-data', () => ({
+  __esModule: true,
+  submitData: {
+    xhr: jest.fn(() => ({
+      addEventListener: jest.fn()
+    })),
+    beacon: jest.fn(),
+    img: jest.fn()
+  }
+}));
+describe('sendX', () => {
+  test.each([null, undefined, false])('should not send request when body is empty and sendEmptyBody is %s', sendEmptyBody => {
+    const sendCallback = jest.fn();
+    const harvester = new _harvest.Harvest();
+    harvester.on('jserrors', () => ({
+      body: {},
+      qs: {}
+    }));
+    harvester.sendX({
+      endpoint: 'jserrors',
+      cbFinished: sendCallback
+    });
+    expect(sendCallback).toHaveBeenCalledWith({
+      sent: false
+    });
+    expect(_submitData.submitData.xhr).not.toHaveBeenCalled();
+    expect(_submitData.submitData.img).not.toHaveBeenCalled();
+    expect(_submitData.submitData.beacon).not.toHaveBeenCalled();
+  });
+  test('should send request when body is empty and sendEmptyBody is true', () => {
+    const harvester = new _harvest.Harvest();
+    harvester.on('jserrors', () => ({
+      body: {},
+      qs: {}
+    }));
+    harvester.sendX({
+      endpoint: 'jserrors',
+      opts: {
+        sendEmptyBody: true
+      },
+      cbFinished: jest.fn()
+    });
+    expect(_submitData.submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('https://example.com/jserrors/1/abcd?'),
+      body: undefined
+    }));
+    expect(_submitData.submitData.img).not.toHaveBeenCalled();
+    expect(_submitData.submitData.beacon).not.toHaveBeenCalled();
+  });
+  test.each([null, undefined, []])('should remove %s values from the body and query string when sending', emptyValue => {
+    const harvester = new _harvest.Harvest();
+    harvester.on('jserrors', () => ({
+      body: {
+        bar: 'foo',
+        empty: emptyValue
+      },
+      qs: {
+        foo: 'bar',
+        empty: emptyValue
+      }
+    }));
+    harvester.sendX({
+      endpoint: 'jserrors',
+      cbFinished: jest.fn()
+    });
+    expect(_submitData.submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('&foo=bar'),
+      body: JSON.stringify({
+        bar: 'foo'
+      })
+    }));
+    expect(_submitData.submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.not.stringContaining('&empty'),
+      body: expect.not.stringContaining('empty')
+    }));
+    expect(_submitData.submitData.img).not.toHaveBeenCalled();
+    expect(_submitData.submitData.beacon).not.toHaveBeenCalled();
+  });
+  test.each([1, false, true])('should not remove value %s (when it doesn\'t have a length) from the body and query string when sending', nonStringValue => {
+    const harvester = new _harvest.Harvest();
+    harvester.on('jserrors', () => ({
+      body: {
+        bar: 'foo',
+        nonString: nonStringValue
+      },
+      qs: {
+        foo: 'bar',
+        nonString: nonStringValue
+      }
+    }));
+    harvester.sendX({
+      endpoint: 'jserrors',
+      cbFinished: jest.fn()
+    });
+    expect(_submitData.submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining("&nonString=".concat(nonStringValue)),
+      body: JSON.stringify({
+        bar: 'foo',
+        nonString: nonStringValue
+      })
+    }));
+    expect(_submitData.submitData.img).not.toHaveBeenCalled();
+    expect(_submitData.submitData.beacon).not.toHaveBeenCalled();
+  });
+});
+describe('send', () => {
+  test.each([null, undefined, false])('should not send request when body is empty and sendEmptyBody is %s', sendEmptyBody => {
+    const sendCallback = jest.fn();
+    const harvester = new _harvest.Harvest();
+    harvester.send({
+      endpoint: 'rum',
+      payload: {
+        qs: {},
+        body: {}
+      },
+      opts: {
+        sendEmptyBody
+      },
+      cbFinished: sendCallback
+    });
+    expect(sendCallback).toHaveBeenCalledWith({
+      sent: false
+    });
+    expect(_submitData.submitData.xhr).not.toHaveBeenCalled();
+    expect(_submitData.submitData.img).not.toHaveBeenCalled();
+    expect(_submitData.submitData.beacon).not.toHaveBeenCalled();
+  });
+  test('should send request when body is empty and sendEmptyBody is true', () => {
+    const harvester = new _harvest.Harvest();
+    harvester.send({
+      endpoint: 'rum',
+      payload: {
+        qs: {},
+        body: {}
+      },
+      opts: {
+        sendEmptyBody: true
+      }
+    });
+    expect(_submitData.submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('https://example.com/1/abcd?'),
+      body: undefined
+    }));
+    expect(_submitData.submitData.img).not.toHaveBeenCalled();
+    expect(_submitData.submitData.beacon).not.toHaveBeenCalled();
+  });
+  test.each([null, undefined, []])('should remove %s values from the body and query string when sending', emptyValue => {
+    const harvester = new _harvest.Harvest();
+    harvester.send({
+      endpoint: 'rum',
+      payload: {
+        qs: {
+          foo: 'bar',
+          empty: emptyValue
+        },
+        body: {
+          bar: 'foo',
+          empty: emptyValue
+        }
+      }
+    });
+    expect(_submitData.submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('&foo=bar'),
+      body: JSON.stringify({
+        bar: 'foo'
+      })
+    }));
+    expect(_submitData.submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.not.stringContaining('&empty'),
+      body: expect.not.stringContaining('empty')
+    }));
+    expect(_submitData.submitData.img).not.toHaveBeenCalled();
+    expect(_submitData.submitData.beacon).not.toHaveBeenCalled();
+  });
+  test.each([1, false, true])('should not remove value %s (when it doesn\'t have a length) from the body and query string when sending', nonStringValue => {
+    const harvester = new _harvest.Harvest();
+    harvester.send({
+      endpoint: 'rum',
+      payload: {
+        qs: {
+          foo: 'bar',
+          nonString: nonStringValue
+        },
+        body: {
+          bar: 'foo',
+          nonString: nonStringValue
+        }
+      }
+    });
+    expect(_submitData.submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining("&nonString=".concat(nonStringValue)),
+      body: JSON.stringify({
+        bar: 'foo',
+        nonString: nonStringValue
+      })
+    }));
+    expect(_submitData.submitData.img).not.toHaveBeenCalled();
+    expect(_submitData.submitData.beacon).not.toHaveBeenCalled();
+  });
+});

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

@@ -52,11 +52,11 @@ function obj(payload, maxBytes) {
     var intermediate = [];
     var next;
     var i;
-    if (typeof dataArray === 'string') {
+    if (typeof dataArray === 'string' || !Array.isArray(dataArray) && dataArray !== null && dataArray !== undefined && dataArray.toString().length) {
       next = '&' + feature + '=' + qs(dataArray);
       total += next.length;
       result += next;
-    } else if (dataArray.length) {
+    } else if (Array.isArray(dataArray) && dataArray.length) {
       total += 9;
       for (i = 0; i < dataArray.length; i++) {
         next = qs((0, _stringify.stringify)(dataArray[i]));

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

@@ -0,0 +1,30 @@
+"use strict";
+
+var _console = require("./console");
+beforeEach(() => {
+  console.warn = jest.fn();
+});
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+describe('warn', () => {
+  test('should not call console.warn if it is not a function', () => {
+    const spy = jest.spyOn(console, 'warn');
+    console.warn = undefined;
+    (0, _console.warn)('test message');
+    expect(spy).not.toHaveBeenCalled();
+  });
+  test('should call console.warn with a prefixed message', () => {
+    (0, _console.warn)('test message');
+    expect(console.warn).toHaveBeenCalledWith('New Relic: test message');
+  });
+  test('should call console.warn with secondary argument if provided', () => {
+    const secondary = 'secondary value';
+    (0, _console.warn)('test message', secondary);
+    expect(console.warn).toHaveBeenCalledWith(secondary);
+  });
+  test('should not call console.warn with secondary argument if not provided', () => {
+    (0, _console.warn)('test message');
+    expect(console.warn).toHaveBeenCalledTimes(1);
+  });
+});

package/dist/cjs/common/util/get-or-set.js

@@ -11,7 +11,14 @@ exports.getOrSet = getOrSet;
 
 var has = Object.prototype.hasOwnProperty;
 
-// Always returns the current value of obj[prop], even if it has to set it first
+/**
+ * Always returns the current value of obj[prop], even if it has to set it first. Sets properties as non-enumerable if possible.
+ *
+ * @param {Object} obj - The object to get or set the property on.
+ * @param {string} prop - The name of the property.
+ * @param {Function} getVal - A function that returns the value to be set if the property does not exist.
+ * @returns {*} The value of the property in the object.
+ */
 function getOrSet(obj, prop, getVal) {
   // If the value exists return it.
   if (has.call(obj, prop)) return obj[prop];

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

@@ -0,0 +1,47 @@
+"use strict";
+
+var _getOrSet = require("./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 = (0, _getOrSet.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 = (0, _getOrSet.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 = (0, _getOrSet.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 = (0, _getOrSet.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/cjs/common/util/stringify.test.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var _stringify = require("./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 = (0, _stringify.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 = (0, _stringify.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 = (0, _stringify.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');
+  });
+  (0, _stringify.stringify)(obj);
+  expect(mockEmit).toHaveBeenCalledWith('internal-error', expect.any(Array));
+});

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

@@ -50,6 +50,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
@@ -63,18 +71,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 = [{
@@ -97,13 +105,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
@@ -114,7 +115,6 @@ submitData.img = function img(_ref4) {
   let {
     url
   } = _ref4;
-  console.log('img url', url);
   var element = new Image();
   element.src = url;
   return element;