@newrelic/browser-agent 0.1.230 → 0.1.231

package/dist/esm/common/config/state/loader-config.js

@@ -11,7 +11,7 @@ const model = {
 const _cache = {};
 export function getLoaderConfig(id) {
   if (!id) throw new Error('All loader-config objects require an agent identifier!');
-  if (!_cache[id]) throw new Error(`LoaderConfig for ${id} was never set`);
+  if (!_cache[id]) throw new Error("LoaderConfig for ".concat(id, " was never set"));
   return _cache[id];
 }
 export function setLoaderConfig(id, obj) {

package/dist/esm/common/config/state/runtime.js

@@ -4,7 +4,7 @@ import { gosNREUMInitializedAgents } from '../../window/nreum';
 import { getCurrentSessionIdOrMakeNew } from '../../window/session-storage';
 import { getConfigurationValue } from '../config';
 import { globalScope } from '../../util/global-scope';
-import { BUILD_ENV, DIST_METHOD, VERSION } from '../../constants/environment-variables';
+import { BUILD_ENV, DIST_METHOD, VERSION } from "../../constants/env.npm";
 const model = agentId => {
   return {
     buildEnv: BUILD_ENV,
@@ -32,7 +32,7 @@ const model = agentId => {
 const _cache = {};
 export function getRuntime(id) {
   if (!id) throw new Error('All runtime objects require an agent identifier!');
-  if (!_cache[id]) throw new Error(`Runtime for ${id} was never set`);
+  if (!_cache[id]) throw new Error("Runtime for ".concat(id, " was never set"));
   return _cache[id];
 }
 export function setRuntime(id, obj) {

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

@@ -0,0 +1,20 @@
+/**
+ * @file This file exposes CDN build environment variables. These variables will
+ * be overridden with babel.
+ */
+
+/**
+ * Exposes the version of the agent
+ */
+export const VERSION = "1.231.0";
+
+/**
+ * Exposes the build type of the agent
+ * Valid values are LOCAL, PROD, DEV
+ */
+export const BUILD_ENV = undefined;
+
+/**
+ * Exposes the distribution method of the agent
+ */
+export const DIST_METHOD = 'CDN';

package/dist/esm/common/constants/env.js

@@ -0,0 +1,23 @@
+/**
+ * @file This file exposes build time environment variables that will be included in the
+ * build output of the agent. This file specifically contains the normal environment variables
+ * for the NPM agent build and will be overridden by webpack/babel during the build based on the
+ * type of build being performed.
+ */
+
+import pkgJSON from '../../../package.json';
+
+/**
+ * Exposes the version of the agent
+ */
+export const VERSION = pkgJSON.version;
+
+/**
+ * Exposes the build type of the agent
+ */
+export const BUILD_ENV = 'NPM';
+
+/**
+ * Exposes the distribution method of the agent
+ */
+export const DIST_METHOD = 'NPM';

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

@@ -0,0 +1,21 @@
+/**
+ * @file This file exposes NPM build environment variables. These variables will
+ * be overridden with babel.
+ */
+
+/**
+ * Exposes the version of the agent
+ */
+export const VERSION = "1.231.0";
+
+/**
+ * Exposes the build type of the agent
+ * Valid values are LOCAL, PROD, DEV
+ */
+export const BUILD_ENV = 'NPM';
+
+/**
+ * Exposes the distribution method of the agent
+ * Valid valuse are CDN, NPM
+ */
+export const DIST_METHOD = 'NPM';

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/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
 

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);
+});