@newrelic/browser-agent 1.234.0 → 1.235.0

package/dist/esm/common/util/feature-flags.test.js

@@ -0,0 +1,80 @@
+import { faker } from '@faker-js/faker';
+import * as eventEmitterModule from '../event-emitter/contextual-ee';
+import * as handleModule from '../event-emitter/handle';
+import * as drainModule from '../drain/drain';
+import { activateFeatures, activatedFeatures } from './feature-flags';
+import { FEATURE_NAMES } from '../../loaders/features/features';
+jest.mock('../event-emitter/handle');
+jest.mock('../drain/drain');
+jest.mock('../event-emitter/contextual-ee', () => ({
+  __esModule: true,
+  ee: {
+    get: jest.fn(() => ({
+      foo: "bar_".concat(Math.random())
+    }))
+  }
+}));
+let agentIdentifier;
+beforeEach(() => {
+  agentIdentifier = faker.datatype.uuid();
+});
+afterEach(() => {
+  Object.keys(activatedFeatures).forEach(key => delete activatedFeatures[key]);
+});
+test.each([null, undefined])('should not do anything when flags is %s', input => {
+  activateFeatures(input, agentIdentifier);
+  expect(handleModule.handle).not.toHaveBeenCalled();
+  expect(drainModule.drain).not.toHaveBeenCalled();
+  expect(activatedFeatures).toEqual({});
+});
+const bucketMap = {
+  stn: [FEATURE_NAMES.sessionTrace],
+  err: [FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics],
+  ins: [FEATURE_NAMES.pageAction],
+  spa: [FEATURE_NAMES.spa],
+  sr: [FEATURE_NAMES.sessionReplay, FEATURE_NAMES.sessionTrace]
+};
+test('emits the right events when feature flag = 1', () => {
+  const flags = {};
+  Object.keys(bucketMap).forEach(flag => flags[flag] = 1);
+  activateFeatures(flags, agentIdentifier);
+  const sharedEE = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value;
+
+  // each flag gets emitted to each of its mapped features, and a feat- AND a rumresp- for every emit, so (1+2+1+1+2)*2 = 14
+  expect(handleModule.handle).toHaveBeenCalledTimes(14);
+  expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, FEATURE_NAMES.sessionTrace, sharedEE);
+  expect(handleModule.handle).toHaveBeenLastCalledWith('rumresp-sr', [true], undefined, FEATURE_NAMES.sessionTrace, sharedEE);
+  expect(drainModule.drain).toHaveBeenCalledWith(agentIdentifier, 'page_view_event');
+  Object.keys(flags).forEach(flag => flags[flag] = true);
+  expect(activatedFeatures).toEqual(flags);
+});
+test('emits the right events when feature flag = 0', () => {
+  const flags = {};
+  Object.keys(bucketMap).forEach(flag => flags[flag] = 0);
+  activateFeatures(flags, agentIdentifier);
+  const sharedEE = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value;
+
+  // each flag gets emitted to each of its mapped features, and a block- AND a rumresp- for every emit, so (1+2+1+1+2)*2 = 14
+  expect(handleModule.handle).toHaveBeenCalledTimes(14);
+  expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'block-stn', [], undefined, FEATURE_NAMES.sessionTrace, sharedEE);
+  expect(handleModule.handle).toHaveBeenLastCalledWith('rumresp-sr', [false], undefined, FEATURE_NAMES.sessionTrace, sharedEE);
+  expect(drainModule.drain).toHaveBeenCalledWith(agentIdentifier, 'page_view_event');
+  Object.keys(flags).forEach(flag => flags[flag] = false);
+  expect(activatedFeatures).toEqual(flags);
+});
+test('only the first activate of the same feature is respected', () => {
+  const flags = {
+    stn: 1
+  };
+  activateFeatures(flags, agentIdentifier);
+  flags.stn = 0;
+  activateFeatures(flags, agentIdentifier);
+  const sharedEE1 = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value;
+  const sharedEE2 = jest.mocked(eventEmitterModule.ee.get).mock.results[1].value;
+  expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, 'session_trace', sharedEE1);
+  expect(handleModule.handle).toHaveBeenNthCalledWith(2, 'rumresp-stn', [true], undefined, 'session_trace', sharedEE1);
+  expect(handleModule.handle).not.toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, 'session_trace', sharedEE2);
+  expect(drainModule.drain).toHaveBeenCalledWith(agentIdentifier, 'page_view_event');
+  expect(drainModule.drain).toHaveBeenCalledTimes(2);
+  expect(activatedFeatures.stn).toBeTruthy();
+});

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

@@ -14,32 +14,4 @@ export 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".');
 })();
-export const initialLocation = '' + globalScope.location;
-
-/**
- * The below methods are only used for testing and should be removed once the
- * reliant tests are moved to Jest.
- * tests/browser/protocol.browser.js
- * tests/browser/obfuscate.browser.js
- */
-export function setScope(obj) {
-  globalScope = {
-    ...obj
-  };
-}
-export function resetScope() {
-  if (isBrowserScope) {
-    globalScope = window;
-  } else if (isWorkerScope) {
-    if (typeof globalThis !== 'undefined' && globalThis instanceof WorkerGlobalScope) {
-      globalScope = globalThis;
-    } else if (self instanceof WorkerGlobalScope) {
-      globalScope = self;
-    }
-  } else {
-    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".');
-  }
-}
-export function getGlobalScope() {
-  return globalScope;
-}
+export const initialLocation = '' + globalScope.location;

package/dist/esm/common/util/global-scope.test.js

@@ -0,0 +1,70 @@
+/*
+The global-scope module contains exports that are defined once at the time
+of importing the module. For this reason, the module must be dynamically
+imported in each test case.
+
+A scope must always exist or importing the module will throw an error. Use
+`enableWorkerScope` to enable the worker scope. Be sure to call `disableWorkerScope`
+before any calls to `expect` or the test will fail with an error from Jest.
+*/
+
+import { faker } from '@faker-js/faker';
+afterEach(() => {
+  jest.restoreAllMocks();
+  jest.resetModules();
+});
+test('should indicate a browser scope', async () => {
+  jest.spyOn(global, 'window', 'get').mockReturnValue({
+    document: {}
+  });
+  const globalScopeModule = await import('./global-scope');
+  expect(globalScopeModule.isBrowserScope).toBe(true);
+  expect(globalScopeModule.isWorkerScope).toBe(false);
+  expect(globalScopeModule.globalScope).toBe(global.window);
+});
+test('should indicate a worker scope', async () => {
+  enableWorkerScope();
+  const globalScopeModule = await import('./global-scope');
+  const mockedGlobalThis = global.globalThis;
+  disableWorkerScope();
+  expect(globalScopeModule.isBrowserScope).toBe(false);
+  expect(globalScopeModule.isWorkerScope).toBe(true);
+  expect(globalScopeModule.globalScope).toBe(mockedGlobalThis);
+});
+test('should return the self global', async () => {
+  enableWorkerScope();
+  jest.replaceProperty(global, 'globalThis', null);
+  jest.spyOn(global, 'self', 'get').mockReturnValue(new global.WorkerGlobalScope());
+  const globalScopeModule = await import('./global-scope');
+  const mockedGlobalSelf = global.self;
+  disableWorkerScope();
+  expect(globalScopeModule.isBrowserScope).toBe(false);
+  expect(globalScopeModule.isWorkerScope).toBe(true);
+  expect(globalScopeModule.globalScope).toBe(mockedGlobalSelf);
+});
+test('should throw an error when a scope cannot be defined', async () => {
+  jest.spyOn(global, 'window', 'get').mockReturnValue(undefined);
+  await expect(() => import('./global-scope')).rejects.toThrow();
+});
+test('should immediately store the current location', async () => {
+  const url = faker.internet.url();
+  jest.spyOn(window, 'location', 'get').mockReturnValue(url);
+  const globalScopeModule = await import('./global-scope');
+  expect(globalScopeModule.initialLocation).toBe(url);
+});
+function enableWorkerScope() {
+  jest.spyOn(global, 'window', 'get').mockReturnValue(undefined);
+  class WorkerNavigator {}
+  class WorkerGlobalScope {
+    navigator = new WorkerNavigator();
+  }
+  global.WorkerGlobalScope = WorkerGlobalScope;
+  global.WorkerNavigator = WorkerNavigator;
+  jest.spyOn(global, 'navigator', 'get').mockReturnValue(new global.WorkerNavigator());
+  jest.replaceProperty(global, 'globalThis', new WorkerGlobalScope());
+}
+function disableWorkerScope() {
+  delete global.WorkerGlobalScope;
+  delete global.WorkerNavigator;
+  jest.restoreAllMocks();
+}

package/dist/esm/common/util/obfuscate.component-test.js

@@ -0,0 +1,125 @@
+import { faker } from '@faker-js/faker';
+import * as configModule from '../config/config';
+import * as urlProtocolModule from '../url/protocol';
+import * as consolModule from './console';
+import * as obfuscateModule from './obfuscate';
+jest.mock('../config/config');
+jest.mock('../context/shared-context');
+jest.mock('../url/protocol');
+jest.mock('./console');
+let agentIdentifier;
+const rules = [{
+  regex: /pii/g,
+  replacement: 'OBFUSCATED'
+}];
+beforeEach(() => {
+  agentIdentifier = faker.datatype.uuid();
+});
+afterEach(() => {
+  jest.resetAllMocks();
+});
+describe('Obfuscator', () => {
+  test('shouldObfuscate returns true when there are rules', () => {
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules);
+    const obfuscator = new obfuscateModule.Obfuscator();
+    obfuscator.sharedContext = {
+      agentIdentifier
+    };
+    expect(obfuscator.shouldObfuscate()).toEqual(true);
+  });
+  test('shouldObfuscate returns false when there are no rules', () => {
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue([]);
+    const obfuscator = new obfuscateModule.Obfuscator();
+    obfuscator.sharedContext = {
+      agentIdentifier
+    };
+    expect(obfuscator.shouldObfuscate()).toEqual(false);
+  });
+  test('obfuscateString returns the input when there are no rules', () => {
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue([]);
+    const input = faker.lorem.sentence();
+    const obfuscator = new obfuscateModule.Obfuscator();
+    obfuscator.sharedContext = {
+      agentIdentifier
+    };
+    expect(obfuscator.obfuscateString(input)).toEqual(input);
+  });
+  test('obfuscateString applies obfuscation rules to input', () => {
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules);
+    const input = 'pii';
+    const obfuscator = new obfuscateModule.Obfuscator();
+    obfuscator.sharedContext = {
+      agentIdentifier
+    };
+    expect(obfuscator.obfuscateString(input)).toEqual(rules[0].replacement);
+  });
+  test('obfuscateString replaces input with * when replacement is not set', () => {
+    const newRules = [{
+      regex: rules[0].regex
+    }];
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(newRules);
+    const input = 'pii';
+    const obfuscator = new obfuscateModule.Obfuscator();
+    obfuscator.sharedContext = {
+      agentIdentifier
+    };
+    expect(obfuscator.obfuscateString(input)).toEqual('*');
+  });
+  test.each([null, undefined, '', 123])('obfuscateString returns the input it is %s', input => {
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules);
+    const obfuscator = new obfuscateModule.Obfuscator();
+    obfuscator.sharedContext = {
+      agentIdentifier
+    };
+    expect(obfuscator.obfuscateString(input)).toEqual(input);
+  });
+});
+describe('getRules', () => {
+  test('should return configured rules', () => {
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules);
+    expect(obfuscateModule.getRules()).toEqual(rules);
+  });
+  test('should include the file protocol obfuscation', () => {
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules);
+    jest.spyOn(urlProtocolModule, 'isFileProtocol').mockReturnValue(rules);
+    expect(obfuscateModule.getRules()).toEqual(expect.arrayContaining([{
+      regex: /^file:\/\/(.*)/,
+      replacement: 'file://OBFUSCATED'
+    }]));
+  });
+  test.each([null, undefined])('should return an empty array when obfuscation rules are %s', input => {
+    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(input);
+    expect(obfuscateModule.getRules()).toEqual([]);
+  });
+});
+describe('validateRules', () => {
+  test('should return true for empty array', () => {
+    expect(obfuscateModule.validateRules([])).toEqual(true);
+  });
+  test('should return true for valid rules', () => {
+    expect(obfuscateModule.validateRules(rules)).toEqual(true);
+  });
+  test.each([null, 123, {}, []])('should warn about an invalid regex type %s', input => {
+    const newRules = [{
+      regex: input,
+      replacement: rules[0].replacement
+    }];
+    expect(obfuscateModule.validateRules(newRules)).toEqual(false);
+    expect(consolModule.warn).toHaveBeenCalledWith(expect.stringContaining('contains a "regex" value with an invalid type'));
+  });
+  test('should warn about a missing regex with value', () => {
+    const newRules = [{
+      replacement: rules[0].replacement
+    }];
+    expect(obfuscateModule.validateRules(newRules)).toEqual(false);
+    expect(consolModule.warn).toHaveBeenCalledWith(expect.stringContaining('missing a "regex" value'));
+  });
+  test.each([123, {}, []])('should warn about an invalid replacement type %s', input => {
+    const newRules = [{
+      regex: rules[0].regex,
+      replacement: input
+    }];
+    expect(obfuscateModule.validateRules(newRules)).toEqual(false);
+    expect(consolModule.warn).toHaveBeenCalledWith(expect.stringContaining('contains a "replacement" value with an invalid type'));
+  });
+});

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

@@ -4,7 +4,7 @@ import { isFileProtocol } from '../url/protocol';
 import { warn } from './console';
 var fileProtocolRule = {
   regex: /^file:\/\/(.*)/,
-  replacement: 'file://OBFUSCATED'
+  replacement: atob('ZmlsZTovL09CRlVTQ0FURUQ=')
 };
 export class Obfuscator extends SharedContext {
   shouldObfuscate() {
@@ -47,7 +47,7 @@ export function validateRules(rules) {
     if (!('regex' in rules[i])) {
       warn('An obfuscation replacement rule was detected missing a "regex" value.');
       invalidRegexDetected = true;
-    } else if (typeof rules[i].regex !== 'string' && !(rules[i].regex.constructor === RegExp)) {
+    } else if (typeof rules[i].regex !== 'string' && !(rules[i].regex instanceof RegExp)) {
       warn('An obfuscation replacement rule contains a "regex" value with an invalid type (must be a string or RegExp)');
       invalidRegexDetected = true;
     }

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

@@ -124,10 +124,10 @@ submitData.beacon = function (_ref5) {
     url,
     body
   } = _ref5;
-  // Navigator has to be bound to ensure it does not error in some browsers
-  // https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch
-  const send = window.navigator.sendBeacon.bind(window.navigator);
   try {
+    // Navigator has to be bound to ensure it does not error in some browsers
+    // https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch
+    const send = window.navigator.sendBeacon.bind(window.navigator);
     return send(url, body);
   } catch (err) {
     // if sendBeacon still trys to throw an illegal invocation error,