@newrelic/browser-agent 0.1.229 → 0.1.231

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

@@ -0,0 +1,278 @@
+import { faker } from '@faker-js/faker';
+let mockNREUM;
+let runtime;
+beforeEach(() => {
+  mockNREUM = {};
+  runtime = {};
+  jest.doMock('../window/nreum', () => ({
+    __esModule: true,
+    gosNREUM: jest.fn(() => mockNREUM)
+  }));
+  jest.doMock('../config/config', () => ({
+    __esModule: true,
+    getRuntime: jest.fn(() => runtime)
+  }));
+});
+afterEach(() => {
+  jest.resetModules();
+  jest.resetAllMocks();
+});
+describe('global event-emitter', () => {
+  test('it returns the event-emitter defined on window.NREUM', async () => {
+    const mockEE = {};
+    mockNREUM.ee = mockEE;
+    const {
+      ee
+    } = await import('./contextual-ee');
+    expect(ee).toEqual(mockEE);
+  });
+  test('it sets the global event-emitter on window.NREUM', async () => {
+    const {
+      ee
+    } = await import('./contextual-ee');
+    expect(ee).toEqual(mockNREUM.ee);
+  });
+});
+describe('scoping event-emitter', () => {
+  test('it creates a new child event-emitter', async () => {
+    const {
+      ee
+    } = await import('./contextual-ee');
+    const childName = faker.datatype.uuid();
+    const result = ee.get(childName);
+    expect(result).not.toEqual(mockNREUM.ee);
+    expect(result).toEqual(ee.get(childName)); // Should always return the same event-emitter
+    expect(result.debugId).toEqual(childName);
+  });
+  test('it creates a child event-emitter with an isolated backlog', async () => {
+    const childName = faker.random.alphaNumeric(16);
+    jest.doMock('../config/config', () => ({
+      __esModule: true,
+      getRuntime: jest.fn(id => {
+        if (id === childName) {
+          return {
+            isolatedBacklog: true
+          };
+        }
+        return runtime;
+      })
+    }));
+    const {
+      ee
+    } = await import('./contextual-ee');
+    const result = ee.get(childName);
+    expect(ee.backlog).not.toBe(result.backlog);
+  });
+});
+describe('event-emitter context', () => {
+  test('it returns a new context', async () => {
+    const {
+      ee
+    } = await import('./contextual-ee');
+    const result = ee.context();
+    expect(result).toEqual({});
+  });
+  test('it returns the same context', async () => {
+    const {
+      ee
+    } = await import('./contextual-ee');
+    const result = ee.context();
+    expect(result).toEqual(ee.context(result));
+  });
+  test('it adds the context to the provided object', async () => {
+    const {
+      ee
+    } = await import('./contextual-ee');
+    const obj = {};
+    const result = ee.context(obj);
+    expect(result).toEqual(obj['nr@context']);
+  });
+});
+describe('event-emitter buffer', () => {
+  it('it should create a new buffer for the given group', async () => {
+    const {
+      ee
+    } = await import('./contextual-ee');
+    const eventType = faker.datatype.uuid();
+    const group = faker.datatype.uuid();
+    ee.buffer([eventType], group);
+    expect(ee.backlog).toEqual(expect.objectContaining({
+      [group]: []
+    }));
+    expect(ee.isBuffering(eventType)).toEqual(true);
+  });
+  it('it should default group to "feature"', async () => {
+    const {
+      ee
+    } = await import('./contextual-ee');
+    const eventType = faker.datatype.uuid();
+    ee.buffer([eventType]);
+    expect(ee.backlog).toEqual(expect.objectContaining({
+      feature: []
+    }));
+    expect(ee.isBuffering(eventType)).toEqual(true);
+  });
+  it('it should not create buffer if event-emitter is aborted', async () => {
+    const {
+      ee
+    } = await import('./contextual-ee');
+    const eventType = faker.datatype.uuid();
+    const group = faker.datatype.uuid();
+    ee.backlog = {
+      api: ['foo', 'bar', 'baz']
+    };
+    ee.abort();
+    ee.buffer([eventType], group);
+    expect(ee.backlog).toEqual({});
+    expect(ee.isBuffering(eventType)).toEqual(false);
+  });
+});
+describe('event-emitter abort', () => {
+  test('it aborts if there is an API backlog', async () => {
+    const {
+      ee
+    } = await import('./contextual-ee');
+    ee.backlog = {
+      api: ['foo', 'bar', 'baz']
+    };
+    ee.abort();
+    expect(ee.aborted).toEqual(true);
+    expect(ee.backlog).toEqual({});
+  });
+  test('it aborts if there is a feature backlog', async () => {
+    const {
+      ee
+    } = await import('./contextual-ee');
+    ee.backlog = {
+      feature: ['foo', 'bar', 'baz']
+    };
+    ee.abort();
+    expect(ee.aborted).toEqual(true);
+    expect(ee.backlog).toEqual({});
+  });
+});
+describe('event-emitter emit', () => {
+  it('should execute the listener', async () => {
+    const {
+      ee
+    } = await import('./contextual-ee');
+    const mockListener = jest.fn();
+    const eventType = faker.datatype.uuid();
+    const eventArgs = ['a', 'b', 'c'];
+    ee.on(eventType, mockListener);
+    ee.emit(eventType, eventArgs);
+    expect(mockListener).toHaveBeenCalledWith(eventArgs[0], eventArgs[1], eventArgs[2]);
+  });
+  it('should not execute the listener after removal', async () => {
+    const {
+      ee
+    } = await import('./contextual-ee');
+    const mockListener = jest.fn();
+    const eventType = faker.datatype.uuid();
+    const eventArgs = ['a', 'b', 'c'];
+    ee.on(eventType, mockListener);
+    ee.emit(eventType, eventArgs);
+    ee.removeEventListener(eventType, mockListener);
+    ee.emit(eventType, eventArgs);
+    expect(mockListener).toHaveBeenCalledTimes(1);
+  });
+  it('should return early if global event-emitter is aborted', async () => {
+    const {
+      ee
+    } = await import('./contextual-ee');
+    const mockListener = jest.fn();
+    const eventType = faker.datatype.uuid();
+    const eventArgs = ['a', 'b', 'c'];
+    ee.backlog = {
+      api: ['foo', 'bar', 'baz']
+    };
+    ee.abort();
+    ee.on(eventType, mockListener);
+    ee.emit(eventType, eventArgs);
+    expect(mockListener).toHaveBeenCalledTimes(0);
+  });
+  it('should still emit if global event-emitter is aborted but force flag is true', async () => {
+    const {
+      ee
+    } = await import('./contextual-ee');
+    const scopeEE = ee.get(faker.datatype.uuid());
+    const mockScopeListener = jest.fn();
+    const eventType = faker.datatype.uuid();
+    const eventArgs = ['a', 'b', 'c'];
+    ee.backlog = {
+      api: ['foo', 'bar', 'baz']
+    };
+    ee.abort();
+    scopeEE.on(eventType, mockScopeListener);
+    scopeEE.emit(eventType, eventArgs, {}, true);
+    expect(mockScopeListener).toHaveBeenCalledTimes(1);
+  });
+  it('should bubble the event if bubble flag is true', async () => {
+    const {
+      ee
+    } = await import('./contextual-ee');
+    const scopeEE = ee.get(faker.datatype.uuid());
+    const mockListener = jest.fn();
+    const mockScopeListener = jest.fn();
+    const eventType = faker.datatype.uuid();
+    const eventArgs = ['a', 'b', 'c'];
+    ee.on(eventType, mockListener);
+    scopeEE.on(eventType, mockScopeListener);
+    scopeEE.emit(eventType, eventArgs, {}, false, true);
+    expect(mockScopeListener).toHaveBeenCalledTimes(1);
+    expect(mockListener).toHaveBeenCalledTimes(1);
+  });
+  it('should not bubble the event if bubble flag is false', async () => {
+    const {
+      ee
+    } = await import('./contextual-ee');
+    const scopeEE = ee.get(faker.datatype.uuid());
+    const mockListener = jest.fn();
+    const mockScopeListener = jest.fn();
+    const eventType = faker.datatype.uuid();
+    const eventArgs = ['a', 'b', 'c'];
+    ee.on(eventType, mockListener);
+    scopeEE.on(eventType, mockScopeListener);
+    scopeEE.emit(eventType, eventArgs, {}, false, false);
+    expect(mockScopeListener).toHaveBeenCalledTimes(1);
+    expect(mockListener).not.toHaveBeenCalled();
+  });
+  it('should buffer the event on the scoped event-emitter', async () => {
+    const {
+      ee
+    } = await import('./contextual-ee');
+    const scopeEE = ee.get(faker.datatype.uuid());
+    const mockListener = jest.fn();
+    const mockScopeListener = jest.fn();
+    const eventType = faker.datatype.uuid();
+    const eventArgs = ['a', 'b', 'c'];
+    ee.on(eventType, mockListener);
+    ee.buffer([eventType]);
+    scopeEE.on(eventType, mockScopeListener);
+    scopeEE.buffer([eventType]);
+    scopeEE.emit(eventType, eventArgs, {}, false, false);
+    expect(mockScopeListener).toHaveBeenCalledTimes(1);
+    expect(mockListener).not.toHaveBeenCalled();
+    expect(scopeEE.backlog['feature']).toEqual(expect.arrayContaining([expect.arrayContaining([scopeEE, eventType, eventArgs, {}])]));
+    expect(ee.backlog['feature']).toEqual(scopeEE.backlog['feature']);
+  });
+});
+describe('getOrSetContext', () => {
+  test('it returns a new context', async () => {
+    const {
+      getOrSetContext
+    } = await import('./contextual-ee');
+    const obj = {};
+    const result = getOrSetContext(obj);
+    expect(result).toEqual({});
+    expect(result).toEqual(obj['nr@context']);
+  });
+  test('it returns the same context', async () => {
+    const {
+      getOrSetContext
+    } = await import('./contextual-ee');
+    const obj = {};
+    const result = getOrSetContext(obj);
+    expect(getOrSetContext(obj)).toEqual(result);
+  });
+});

package/dist/esm/common/event-emitter/handle.test.js

@@ -0,0 +1,54 @@
+import { faker } from '@faker-js/faker';
+jest.mock('./contextual-ee', () => ({
+  __esModule: true,
+  ee: {
+    buffer: jest.fn(),
+    emit: jest.fn(),
+    get: jest.fn(() => ({
+      buffer: jest.fn(),
+      emit: jest.fn()
+    }))
+  }
+}));
+afterEach(() => {
+  jest.resetModules();
+  jest.resetAllMocks();
+});
+test('it should create and use a default event-emitter', async () => {
+  const {
+    ee
+  } = await import('./contextual-ee');
+  const {
+    handle
+  } = await import('./handle');
+  const handleEE = jest.mocked(ee.get).mock.results[0].value;
+  const eventType = faker.datatype.uuid();
+  const eventArgs = ['a', 'b', 'c'];
+  const eventContext = {};
+  const eventGroup = faker.datatype.uuid();
+  handle(eventType, eventArgs, eventContext, eventGroup);
+  expect(handleEE.buffer).toHaveBeenCalledWith([eventType], eventGroup);
+  expect(handleEE.emit).toHaveBeenCalledWith(eventType, eventArgs, eventContext);
+});
+test('it should use the provided scoped event-emitter', async () => {
+  const {
+    ee
+  } = await import('./contextual-ee');
+  const {
+    handle
+  } = await import('./handle');
+  const scopedEE = {
+    buffer: jest.fn(),
+    emit: jest.fn()
+  };
+  const handleEE = jest.mocked(ee.get).mock.results[0].value;
+  const eventType = faker.datatype.uuid();
+  const eventArgs = ['a', 'b', 'c'];
+  const eventContext = {};
+  const eventGroup = faker.datatype.uuid();
+  handle(eventType, eventArgs, eventContext, eventGroup, scopedEE);
+  expect(handleEE.buffer).not.toHaveBeenCalled();
+  expect(handleEE.emit).not.toHaveBeenCalled();
+  expect(scopedEE.buffer).toHaveBeenCalledWith([eventType], eventGroup);
+  expect(scopedEE.emit).toHaveBeenCalledWith(eventType, eventArgs, eventContext);
+});

package/dist/esm/common/event-emitter/register-handler.test.js

@@ -0,0 +1,51 @@
+import { faker } from '@faker-js/faker';
+jest.mock('./handle', () => ({
+  __esModule: true,
+  handleEE: {}
+}));
+afterEach(() => {
+  jest.resetModules();
+  jest.resetAllMocks();
+});
+test('should default group to "feature"', async () => {
+  const {
+    handleEE
+  } = await import('./handle');
+  const {
+    registerHandler
+  } = await import('./register-handler');
+  const eventType = faker.datatype.uuid();
+  const eventHandler = jest.fn();
+  registerHandler(eventType, eventHandler);
+  expect(registerHandler.handlers['feature']).toEqual(expect.objectContaining({
+    [eventType]: [expect.arrayContaining([handleEE, eventHandler])]
+  }));
+});
+test('should use the provided group', async () => {
+  const {
+    handleEE
+  } = await import('./handle');
+  const {
+    registerHandler
+  } = await import('./register-handler');
+  const eventType = faker.datatype.uuid();
+  const eventGroup = faker.datatype.uuid();
+  const eventHandler = jest.fn();
+  registerHandler(eventType, eventHandler, eventGroup);
+  expect(registerHandler.handlers[eventGroup]).toEqual(expect.objectContaining({
+    [eventType]: [expect.arrayContaining([handleEE, eventHandler])]
+  }));
+});
+test('should use the provided event-emitter', async () => {
+  const {
+    registerHandler
+  } = await import('./register-handler');
+  const scopedEE = {};
+  const eventType = faker.datatype.uuid();
+  const eventGroup = faker.datatype.uuid();
+  const eventHandler = jest.fn();
+  registerHandler(eventType, eventHandler, eventGroup, scopedEE);
+  expect(registerHandler.handlers[eventGroup]).toEqual(expect.objectContaining({
+    [eventType]: [expect.arrayContaining([scopedEE, eventHandler])]
+  }));
+});

package/dist/esm/common/event-listener/event-listener-opts.js

@@ -30,10 +30,12 @@ export function eventListenerOpts(useCapture, abortSignal) {
 }
 
 /** Do not use this within the worker context. */
-export function windowAddEventListener(event, listener, capture = false) {
+export function windowAddEventListener(event, listener) {
+  let capture = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   window.addEventListener(event, listener, eventListenerOpts(capture));
 }
 /** Do not use this within the worker context. */
-export function documentAddEventListener(event, listener, capture = false) {
+export function documentAddEventListener(event, listener) {
+  let capture = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   document.addEventListener(event, listener, eventListenerOpts(capture));
 }

package/dist/esm/common/harvest/harvest-scheduler.js

@@ -38,7 +38,8 @@ export class HarvestScheduler extends SharedContext {
     this.started = true;
     this.scheduleHarvest(initialDelay != null ? initialDelay : this.interval);
   }
-  stopTimer(permanently = false) {
+  stopTimer() {
+    let permanently = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
     this.aborted = permanently; // stopping permanently is same as aborting, but this function also cleans up the setTimeout loop
     this.started = false;
     if (this.timeoutHandle) {

package/dist/esm/common/harvest/harvest.js

@@ -15,7 +15,7 @@ import { eventListenerOpts } from '../event-listener/event-listener-opts';
 import { Obfuscator } from '../util/obfuscate';
 import { applyFnToProps } from '../util/traverse';
 import { SharedContext } from '../context/shared-context';
-import { VERSION } from '../constants/environment-variables';
+import { VERSION } from "../constants/env.npm";
 import { isBrowserScope, isWorkerScope } from '../util/global-scope';
 const haveSendBeacon = !!navigator.sendBeacon; // only the web window obj has sendBeacon at this time, so 'false' for other envs
 
@@ -64,6 +64,7 @@ export class Harvest extends SharedContext {
   * @param {bool} opts.unload - Specify whether the call is a final harvest during page unload.
   */
   send(endpoint, singlePayload, opts, submitMethod, cbFinished) {
+    var _this = this;
     var makeBody = createAccumulator();
     var makeQueryString = createAccumulator();
     if (singlePayload.body) mapOwn(singlePayload.body, makeBody);
@@ -72,11 +73,18 @@ export class Harvest extends SharedContext {
       body: makeBody(),
       qs: makeQueryString()
     };
-    var caller = this.obfuscator.shouldObfuscate() ? (...args) => this.obfuscateAndSend(...args) : (...args) => this._send(...args);
+    var caller = this.obfuscator.shouldObfuscate() ? function () {
+      return _this.obfuscateAndSend(...arguments);
+    } : function () {
+      return _this._send(...arguments);
+    };
     return caller(endpoint, payload, opts, submitMethod, cbFinished);
   }
   obfuscateAndSend(endpoint, payload, opts, submitMethod, cbFinished) {
-    applyFnToProps(payload, (...args) => this.obfuscator.obfuscateString(...args), 'string', ['e']);
+    var _this2 = this;
+    applyFnToProps(payload, function () {
+      return _this2.obfuscator.obfuscateString(...arguments);
+    }, 'string', ['e']);
     return this._send(endpoint, payload, opts, submitMethod, cbFinished);
   }
   _send(endpoint, payload, opts, submitMethod, cbFinished) {
@@ -110,6 +118,9 @@ export class Harvest extends SharedContext {
       fullUrl = url + encodeObj(payload.body, agentRuntime.maxBytes);
     }
 
+    // Get bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
+    agentRuntime.bytesSent[endpoint] = (agentRuntime.bytesSent[endpoint] || 0) + body?.length || 0;
+
     /* Since workers don't support sendBeacon right now, or Image(), they can only use XHR method.
         Because they still do permit synch XHR, the idea is that at final harvest time (worker is closing),
         we just make a BLOCKING request--trivial impact--with the remaining data as a temp fill-in for sendBeacon. */

package/dist/esm/common/ids/id.js

@@ -3,16 +3,26 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-// Start assigning ids at 1 so 0 can always be used for WindowOrWorkerGlobalScope, without
-// actually setting it (which would create a global variable).
 import { getOrSet } from '../util/get-or-set';
 import { globalScope } from '../util/global-scope';
-var index = 1;
-var prop = 'nr@id';
 
-// Always returns id of obj, may tag obj with an id in the process.
+// Start assigning ids at 1 so 0 can always be used for Window or WorkerGlobalScope, without
+// actually setting it (which would create a global variable).
+let index = 1;
+const prop = 'nr@id';
+
+/**
+ * Tags a specified object with an identifier if it does not already
+ * have one. If the object is the global scope, zero will be returned
+ * and the object will not be modified. If the object already contains
+ * an identifier, it will be returned without modification. If the passed
+ * value is not an object, function, or array, -1 will be returned without
+ * modifying the passed value.
+ * @param {object|function|array} obj Object to be tagged with an identifier
+ * @returns {number} Identifier of the given object
+ */
 export function id(obj) {
-  var type = typeof obj;
+  const type = typeof obj;
   // We can only tag objects, functions, and arrays with ids.
   // For all primitive values we instead return -1.
   if (!obj || !(type === 'object' || type === 'function')) return -1;

package/dist/esm/common/ids/id.test.js

@@ -0,0 +1,81 @@
+let idFn;
+beforeEach(async () => {
+  idFn = (await import('./id')).id;
+});
+afterEach(() => {
+  jest.resetModules();
+  jest.clearAllMocks();
+});
+test.each([{
+  input: undefined,
+  expected: -1,
+  title: 'id of undefined is -1'
+}, {
+  input: null,
+  expected: -1,
+  title: 'id of null is -1'
+}, {
+  input: 2,
+  expected: -1,
+  title: 'id of number is -1'
+}, {
+  input: 'foo',
+  expected: -1,
+  title: 'id of string is -1'
+}])('$title', _ref => {
+  let {
+    input,
+    expected
+  } = _ref;
+  const result = idFn(input);
+  expect(typeof result).toEqual('number');
+  expect(result).toEqual(expected);
+});
+test('id values increment sequentially', () => {
+  const inputA = {};
+  const inputB = {};
+  const resultA = idFn(inputA);
+  const resultB = idFn(inputB);
+  expect(resultA - resultB).toEqual(-1);
+});
+test('id is correctly assigned to function type', () => {
+  const input = jest.fn();
+  const result = idFn(input);
+  expect(result).toEqual(1);
+  expect(input['nr@id']).toEqual(1);
+});
+test('id is correctly assigned to object type', () => {
+  const input = {};
+  const result = idFn(input);
+  expect(result).toEqual(1);
+  expect(input['nr@id']).toEqual(1);
+});
+test('id is the same when called twice on the same input', () => {
+  const input = {};
+  const result1 = idFn(input);
+  const result2 = idFn(input);
+  expect(result1).toEqual(1);
+  expect(result2).toEqual(1);
+  expect(input['nr@id']).toEqual(1);
+});
+test('id is zero on global scope', async () => {
+  const result = idFn(global);
+  expect(result).toEqual(0);
+});
+test('id on prototype is correctly inherited', () => {
+  const fn = jest.fn();
+  const a = {};
+  idFn(a);
+  fn.prototype = a;
+  const b = new fn();
+  expect(b['nr@id']).toEqual(a['nr@id']);
+});
+test('id on prototype is different from instance', () => {
+  const fn = jest.fn();
+  const a = {};
+  idFn(a);
+  fn.prototype = a;
+  const b = new fn();
+  const result = idFn(b);
+  expect(b['nr@id']).toEqual(result);
+});