@newrelic/browser-agent 0.1.230 → 0.1.231

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

@@ -4,72 +4,96 @@
  */
 
 import { globalScope } from '../util/global-scope';
+const uuidv4Template = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
+
+/**
+ * Creates a random single hexadecimal value from a provided random value
+ * table and corresponding index. If a random value table is not provided,
+ * Math.random will be used to generate the value.
+ *
+ * @param {Uint8Array} valueTable Random value table typically generated using
+ * the built-in crypto engine.
+ * @param {int} tableIndex The index of the value table to use for generating
+ * the hexadecimal value.
+ * @returns {int} single hexadecimal value in decimal format
+ */
+function getRandomValue(valueTable, tableIndex) {
+  if (valueTable) {
+    /**
+     * The value table could have any number value in the given index. Use
+     * bitwise AND to ensure the value we generate is a valid hex value.
+     * x & 15 will ensure the value converted to hex using `toString(16)`
+     * falls within the range of 0 and 15 inclusively.
+     */
+    return valueTable[tableIndex] & 15;
+  } else {
+    return Math.random() * 16 | 0;
+  }
+}
+
+/**
+ * Generates a RFC compliant UUIDv4 using native browser crypto engine. If the browser
+ * does not support the crypto engine, the function will fallback to insecure Math.random()
+ * @returns {string} uuid version 4 string
+ */
 export function generateUuid() {
-  var randomVals = null;
-  var rvIndex = 0;
-  var crypto = globalScope?.crypto || globalScope?.msCrypto;
+  const crypto = globalScope?.crypto || globalScope?.msCrypto;
+  let randomValueTable;
+  let randomValueIndex = 0;
   if (crypto && crypto.getRandomValues) {
     // eslint-disable-next-line
-    randomVals = crypto.getRandomValues(new Uint8Array(31));
-  }
-  function getRandomValue() {
-    if (randomVals) {
-      // same as % 16
-      return randomVals[rvIndex++] & 15;
-    } else {
-      return Math.random() * 16 | 0;
-    }
+    randomValueTable = crypto.getRandomValues(new Uint8Array(31));
   }
-
-  // v4 UUID
-  var template = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
-  var id = '';
-  var c;
-  for (var i = 0; i < template.length; i++) {
-    c = template[i];
-    if (c === 'x') {
-      id += getRandomValue().toString(16);
-    } else if (c === 'y') {
+  return uuidv4Template.split('').map(templateInput => {
+    if (templateInput === 'x') {
+      return getRandomValue(randomValueTable, ++randomValueIndex).toString(16);
+    } else if (templateInput === 'y') {
       // this is the uuid variant per spec (8, 9, a, b)
       // % 4, then shift to get values 8-11
-      c = getRandomValue() & 0x3 | 0x8;
-      id += c.toString(16);
+      return (getRandomValue() & 0x3 | 0x8).toString(16);
     } else {
-      id += c;
+      return templateInput;
     }
+  }).join('');
+}
+
+/**
+ * Generates a string of the given length containing only hexadecimal
+ * value 0-9 and a-f.
+ * @param {int} length length of the string to generate
+ * @returns {string} generated hex string
+ */
+export function generateRandomHexString(length) {
+  const crypto = globalScope?.crypto || globalScope?.msCrypto;
+  let randomValueTable;
+  let randomValueIndex = 0;
+  if (crypto && crypto.getRandomValues) {
+    // eslint-disable-next-line
+    randomValueTable = crypto.getRandomValues(new Uint8Array(31));
   }
-  return id;
+  const chars = [];
+  for (var i = 0; i < length; i++) {
+    chars.push(getRandomValue(randomValueTable, ++randomValueIndex).toString(16));
+  }
+  return chars.join('');
 }
 
-// 16-character hex string (per DT spec)
+/**
+ * Generates a 16 character length hexadecimal string.
+ * per DT-spec.
+ * @see generateRandomHexString
+ * @returns {string} generated hex string
+ */
 export function generateSpanId() {
   return generateRandomHexString(16);
 }
 
-// 32-character hex string (per DT spec)
+/**
+ * Generates a 32 character length hexadecimal string.
+ * per DT-spec.
+ * @see generateRandomHexString
+ * @returns {string} generated hex string
+ */
 export function generateTraceId() {
   return generateRandomHexString(32);
-}
-export function generateRandomHexString(length) {
-  var randomVals = null;
-  var rvIndex = 0;
-  var crypto = self.crypto || self.msCrypto;
-  // eslint-disable-next-line
-  if (crypto && crypto.getRandomValues && Uint8Array) {
-    // eslint-disable-next-line
-    randomVals = crypto.getRandomValues(new Uint8Array(31));
-  }
-  var chars = [];
-  for (var i = 0; i < length; i++) {
-    chars.push(getRandomValue().toString(16));
-  }
-  return chars.join('');
-  function getRandomValue() {
-    if (randomVals) {
-      // same as % 16
-      return randomVals[rvIndex++] & 15;
-    } else {
-      return Math.random() * 16 | 0;
-    }
-  }
 }

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

@@ -0,0 +1,44 @@
+import crypto from 'crypto';
+import * as uniqueId from './unique-id';
+const getRandomValues = jest.fn(arr => crypto.randomBytes(arr.length));
+afterEach(() => {
+  delete global.crypto;
+});
+describe('generateUuid', () => {
+  const uuidv4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+  test('should generate a uuidv4 that matches the expected format', () => {
+    const id = uniqueId.generateUuid();
+    expect(uuidv4Regex.test(id)).toEqual(true);
+  });
+  test('should support using native crypto library', () => {
+    global.crypto = {
+      getRandomValues
+    };
+    const id = uniqueId.generateUuid();
+    expect(uuidv4Regex.test(id)).toEqual(true);
+    expect(getRandomValues).toHaveBeenCalledTimes(1);
+  });
+});
+describe('generateRandomHexString', () => {
+  const hexRegex = /^[0-9a-f]{8}$/;
+  test('should generate a valid hex string', () => {
+    const id = uniqueId.generateRandomHexString(8);
+    expect(hexRegex.test(id)).toEqual(true);
+  });
+  test('should support using native crypto library', () => {
+    global.crypto = {
+      getRandomValues
+    };
+    const id = uniqueId.generateRandomHexString(8);
+    expect(hexRegex.test(id)).toEqual(true);
+    expect(getRandomValues).toHaveBeenCalledTimes(1);
+  });
+});
+test('generateSpanId should generate a 16 character hex string', () => {
+  const id = uniqueId.generateSpanId();
+  expect(/^[0-9a-f]{16}$/.test(id)).toEqual(true);
+});
+test('generateTraceId should generate a 32 character hex string', () => {
+  const id = uniqueId.generateTraceId();
+  expect(/^[0-9a-f]{32}$/.test(id)).toEqual(true);
+});

package/dist/esm/common/timing/nav-timing.js

@@ -25,43 +25,65 @@ var RESPONSE = 'response';
 var LOAD_EVENT = 'loadEvent';
 var DOM_CONTENT_LOAD_EVENT = 'domContentLoadedEvent';
 export var navTimingValues = [];
-export function addPT(offset, pt, v) {
+function getPntType(type) {
+  if (typeof type == 'number') return type;
+  const types = {
+    navigate: undefined,
+    reload: 1,
+    back_forward: 2,
+    prerender: 3
+  };
+  return types[type];
+}
+export function addPT(offset, pt) {
+  let v = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let isL1Api = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  if (!pt) return;
   v.of = offset;
-  addRel(offset, offset, v, 'n');
-  addRel(pt[UNLOAD_EVENT + START], offset, v, 'u');
-  addRel(pt[REDIRECT + START], offset, v, 'r');
-  addRel(pt[UNLOAD_EVENT + END], offset, v, 'ue');
-  addRel(pt[REDIRECT + END], offset, v, 're');
-  addRel(pt['fetch' + START], offset, v, 'f');
-  addRel(pt[DOMAIN_LOOKUP + START], offset, v, 'dn');
-  addRel(pt[DOMAIN_LOOKUP + END], offset, v, 'dne');
-  addRel(pt['c' + ONNECT + START], offset, v, 'c');
-  addRel(pt['secureC' + ONNECT + 'ion' + START], offset, v, 's');
-  addRel(pt['c' + ONNECT + END], offset, v, 'ce');
-  addRel(pt[REQUEST + START], offset, v, 'rq');
-  addRel(pt[RESPONSE + START], offset, v, 'rp');
-  addRel(pt[RESPONSE + END], offset, v, 'rpe');
-  addRel(pt.domLoading, offset, v, 'dl');
-  addRel(pt.domInteractive, offset, v, 'di');
-  addRel(pt[DOM_CONTENT_LOAD_EVENT + START], offset, v, 'ds');
-  addRel(pt[DOM_CONTENT_LOAD_EVENT + END], offset, v, 'de');
-  addRel(pt.domComplete, offset, v, 'dc');
-  addRel(pt[LOAD_EVENT + START], offset, v, 'l');
-  addRel(pt[LOAD_EVENT + END], offset, v, 'le');
+  handleValue(v.of, v, 'n', true);
+  handleValue(pt[UNLOAD_EVENT + START], v, 'u', isL1Api);
+  handleValue(pt[REDIRECT + START], v, 'r', isL1Api);
+  handleValue(pt[UNLOAD_EVENT + END], v, 'ue', isL1Api);
+  handleValue(pt[REDIRECT + END], v, 're', isL1Api);
+  handleValue(pt['fetch' + START], v, 'f', isL1Api);
+  handleValue(pt[DOMAIN_LOOKUP + START], v, 'dn', isL1Api);
+  handleValue(pt[DOMAIN_LOOKUP + END], v, 'dne', isL1Api);
+  handleValue(pt['c' + ONNECT + START], v, 'c', isL1Api);
+  handleValue(pt['secureC' + ONNECT + 'ion' + START], v, 's', isL1Api);
+  handleValue(pt['c' + ONNECT + END], v, 'ce', isL1Api);
+  handleValue(pt[REQUEST + START], v, 'rq', isL1Api);
+  handleValue(pt[RESPONSE + START], v, 'rp', isL1Api);
+  handleValue(pt[RESPONSE + END], v, 'rpe', isL1Api);
+  handleValue(pt.domLoading, v, 'dl', isL1Api);
+  handleValue(pt.domInteractive, v, 'di', isL1Api);
+  handleValue(pt[DOM_CONTENT_LOAD_EVENT + START], v, 'ds', isL1Api);
+  handleValue(pt[DOM_CONTENT_LOAD_EVENT + END], v, 'de', isL1Api);
+  handleValue(pt.domComplete, v, 'dc', isL1Api);
+  handleValue(pt[LOAD_EVENT + START], v, 'l', isL1Api);
+  handleValue(pt[LOAD_EVENT + END], v, 'le', isL1Api);
   return v;
 }
 
 // Add Performance Navigation values to the given object
 export function addPN(pn, v) {
-  addRel(pn.type, 0, v, 'ty');
-  addRel(pn.redirectCount, 0, v, 'rc');
+  handleValue(getPntType(pn.type), v, 'ty');
+  handleValue(pn.redirectCount, v, 'rc');
   return v;
 }
-export function addRel(value, offset, obj, prop) {
-  var relativeValue;
+function handleValue(value, obj, prop, isOldApi) {
+  /*
+  For L2 Timing API, the value will already be a relative-to-previous-document DOMHighResTimeStamp.
+  For L1 (deprecated) Timing, the value is an UNIX epoch timestamp, which we will convert to a relative time using our offset.
+  PNT.type is reported as undefined, 1, 2, etc -- note that zero-value properties will be recorded as 'undefined', however DEM interprets undefined "types" as "navigate"
+  */
   if (typeof value === 'number' && value > 0) {
-    relativeValue = Math.max(Math.round(value - offset), 0);
-    obj[prop] = relativeValue;
+    // note that zero-value properties will be recorded as 'undefined'
+    if (isOldApi) {
+      const offset = obj?.of > 0 ? obj.of : 0; // expect an epoch timestamp, if called by addPT
+      value = Math.max(value - offset, 0);
+    }
+    value = Math.round(value);
+    obj[prop] = value;
   }
-  navTimingValues.push(relativeValue);
+  navTimingValues.push(value);
 }

package/dist/esm/common/timing/nav-timing.test.js

@@ -0,0 +1,190 @@
+import { addPT, addPN, navTimingValues } from './nav-timing';
+const offset = 123;
+const testValues = {
+  unloadEventStart: 1,
+  redirectStart: 2,
+  unloadEventEnd: 3,
+  redirectEnd: 4,
+  fetchStart: 5,
+  domainLookupStart: 6,
+  domainLookupEnd: 7,
+  connectStart: 8,
+  secureConnectionStart: 9,
+  connectEnd: 10,
+  requestStart: 11,
+  responseStart: 12,
+  responseEnd: 13,
+  domLoading: 14,
+  domInteractive: 15,
+  domContentLoadedEventStart: 16,
+  domContentLoadedEventEnd: 17,
+  domComplete: 18,
+  loadEventStart: 19,
+  loadEventEnd: 20,
+  type: 'reload',
+  redirectCount: 22
+};
+const legacyTestValues = {
+  unloadEventStart: offset + 1,
+  redirectStart: offset + 2,
+  unloadEventEnd: offset + 3,
+  redirectEnd: offset + 4,
+  fetchStart: offset + 5,
+  domainLookupStart: offset + 6,
+  domainLookupEnd: offset + 7,
+  connectStart: offset + 8,
+  secureConnectionStart: offset + 9,
+  connectEnd: offset + 10,
+  requestStart: offset + 11,
+  responseStart: offset + 12,
+  responseEnd: offset + 13,
+  domLoading: offset + 14,
+  domInteractive: offset + 15,
+  domContentLoadedEventStart: offset + 16,
+  domContentLoadedEventEnd: offset + 17,
+  domComplete: offset + 18,
+  loadEventStart: offset + 19,
+  loadEventEnd: offset + 20,
+  type: 'reload',
+  redirectCount: offset + 22
+};
+const expectedPT = {
+  of: offset,
+  n: 0,
+  u: 1,
+  r: 2,
+  ue: 3,
+  re: 4,
+  f: 5,
+  dn: 6,
+  dne: 7,
+  c: 8,
+  s: 9,
+  ce: 10,
+  rq: 11,
+  rp: 12,
+  rpe: 13,
+  dl: 14,
+  di: 15,
+  ds: 16,
+  de: 17,
+  dc: 18,
+  l: 19,
+  le: 20
+};
+const expectedPN = {
+  ty: 1,
+  rc: 22
+};
+describe('addPT()', () => {
+  test('an output object is populated with valid values', () => {
+    const output = addPT(offset, testValues, {});
+    expect(output).toEqual(expectedPT);
+  });
+  test('an object with invalid values is handled', () => {
+    const output = addPT(offset, {
+      ...testValues,
+      invalidValue: 'test'
+    }, {});
+    expect(output).toEqual(expectedPT);
+    const output2 = addPT(offset, {
+      ...testValues,
+      loadEventEnd: -1
+    }, {});
+    let expected = {
+      ...expectedPT
+    };
+    delete expected.le;
+    expect(output2).toEqual(expected);
+    const output3 = addPT(offset, {
+      ...testValues,
+      loadEventEnd: 'test'
+    }, {});
+    expected = {
+      ...expectedPT
+    };
+    delete expected.le;
+    expect(output3).toEqual(expected);
+    const output4 = addPT(offset, {
+      ...testValues,
+      loadEventEnd: null
+    }, {});
+    expected = {
+      ...expectedPT
+    };
+    delete expected.le;
+    expect(output4).toEqual(expected);
+    const legacyoutput = addPT(offset, {
+      ...legacyTestValues,
+      invalidValue: 'test'
+    }, {}, true);
+    expect(legacyoutput).toEqual(expectedPT);
+    const legacyoutput2 = addPT(offset, {
+      ...legacyTestValues,
+      loadEventEnd: -1
+    }, {}, true);
+    let legacyexpected = {
+      ...expectedPT
+    };
+    delete legacyexpected.le;
+    expect(legacyoutput2).toEqual(expected);
+    const legacyoutput3 = addPT(offset, {
+      ...legacyTestValues,
+      loadEventEnd: 'test'
+    }, {}, true);
+    legacyexpected = {
+      ...expectedPT
+    };
+    delete legacyexpected.le;
+    expect(legacyoutput3).toEqual(legacyexpected);
+    const legacyoutput4 = addPT(offset, {
+      ...legacyTestValues,
+      loadEventEnd: null
+    }, {}, true);
+    legacyexpected = {
+      ...expectedPT
+    };
+    delete legacyexpected.le;
+    expect(legacyoutput4).toEqual(legacyexpected);
+  });
+  test('rounds values to integers', () => {
+    const output = addPT(offset, {
+      unloadEventStart: 3.14159
+    }, {});
+    expect(output.u).toEqual(3);
+    const legacyoutput = addPT(0, {
+      unloadEventStart: 3.14159
+    }, {}, true);
+    expect(legacyoutput.u).toEqual(3);
+  });
+  test('adds entries to navTimingValues', () => {
+    const beforeLength = navTimingValues.length;
+    addPT(offset, {
+      testValues
+    }, {});
+    const afterLength = navTimingValues.length;
+    expect(afterLength - beforeLength).toEqual(21); // 20 + value of n
+
+    const legacybeforeLength = navTimingValues.length;
+    addPT(offset, {
+      legacyTestValues
+    }, {}, true);
+    const legacyafterLength = navTimingValues.length;
+    expect(legacyafterLength - legacybeforeLength).toEqual(21); // 20 + value of n
+  });
+});
+
+describe('addPN()', () => {
+  test('an output object is populated with valid values', () => {
+    const output = addPN(testValues, {});
+    expect(output).toEqual(expectedPN);
+  });
+  test('adds entries to navTimingValues', () => {
+    const beforeLength = navTimingValues.length;
+    addPN(offset, {
+      testValues
+    }, {});
+    const afterLength = navTimingValues.length;
+    expect(afterLength - beforeLength).toEqual(2);
+  });
+});

package/dist/esm/common/url/clean-url.test.js

@@ -0,0 +1,7 @@
+import { cleanURL } from './clean-url';
+test.each([['http://domain.com/path?query=5', 'http://domain.com/path'], ['http://domain.com/path#fragment', 'http://domain.com/path'], ['http://domain.com/path?query=5#fragment', 'http://domain.com/path'], ['http://domain.com/path?query=5?dumb#fragment', 'http://domain.com/path'], ['http://domain.com/path?query=5#fragment#dumb', 'http://domain.com/path'], ['http://domain.com/path?query=5#fragment#dumb?additional_query', 'http://domain.com/path'], ['http://domain.com/path?query=5#fragment/silly/dumber#dumbest?additional_query=silly#what_is_this_even', 'http://domain.com/path']])('cleanURL should remove hash', (input, expected) => {
+  expect(cleanURL(input)).toEqual(expected);
+});
+test.each([['http://domain.com/path?query=5', 'http://domain.com/path'], ['http://domain.com/path#fragment', 'http://domain.com/path#fragment'], ['http://domain.com/path?query=5#fragment', 'http://domain.com/path#fragment'], ['http://domain.com/path?query=5?dumb#fragment', 'http://domain.com/path#fragment'], ['http://domain.com/path?query=5#fragment#dumb', 'http://domain.com/path#fragment#dumb'], ['http://domain.com/path?query=5#fragment#dumb?additional_query', 'http://domain.com/path#fragment#dumb'], ['http://domain.com/path?query=5#fragment/silly/dumber#dumbest?additional_query=silly#what_is_this_even', 'http://domain.com/path#fragment/silly/dumber#dumbest']])('cleanURL should retain hash if second argument is true', (input, expected) => {
+  expect(cleanURL(input, true)).toEqual(expected);
+});

package/dist/esm/common/url/encode.test.js

@@ -0,0 +1,70 @@
+import * as encode from './encode';
+describe('query string encoding', () => {
+  test('escapes string components except safe characters', () => {
+    const input = 'Asdf:, :, /@$;';
+    const expected = 'Asdf:,%20:,%20/@$;';
+    expect(encode.qs(input)).toEqual(expected);
+  });
+  test('null and undefined value returns \'null\'', () => {
+    expect(encode.qs(null)).toEqual('null');
+    expect(encode.qs(undefined)).toEqual('null');
+  });
+});
+describe('fromArray encoding', () => {
+  test('cuts cleanly at end of byte', () => {
+    const input = ['a', 'b', 'c'];
+    const expected = 'ab';
+    expect(encode.fromArray(input, 2)).toEqual(expected);
+  });
+  test('fall back to largest whole chunk', () => {
+    const input = ['aa', 'bb', 'cc'];
+    const expected = 'aabb';
+    expect(encode.fromArray(input, 5)).toEqual(expected);
+  });
+});
+describe('object encoding', () => {
+  test('cuts cleanly at end of byte', () => {
+    const input = {
+      foo: [1, 2, 3]
+    };
+    const expected = '&foo=%5B1,2%5D';
+    expect(encode.obj(input, 12)).toEqual(expected);
+  });
+  test('fall back to largest whole chunk', () => {
+    const input = {
+      bar: ['a', 'b', 'c']
+    };
+    const expected = '&bar=%5B%22a%22,%22b%22%5D';
+    expect(encode.obj(input, 30)).toEqual(expected);
+  });
+  test('handles circular objects', () => {
+    const circular = {};
+    circular.circular = circular;
+    const input = {
+      bar: ['a', circular, 'c']
+    };
+    const expected = '&bar=%5B%22a%22,%7B%7D,%22c%22%5D';
+    expect(encode.obj(input, 1000)).toEqual(expected);
+  });
+  test('handles circular arrays', () => {
+    const circular = [];
+    circular.push(circular);
+    const input = {
+      bar: ['a', circular, 'c']
+    };
+    const expected = '&bar=%5B%22a%22,%5Bnull%5D,%22c%22%5D';
+    expect(encode.obj(input, 1000)).toEqual(expected);
+  });
+});
+describe('encode key value pairs as query params', () => {
+  test('ignores input when value is null or undefined', () => {
+    expect(encode.param('foo', null)).toEqual('');
+    expect(encode.param('foo', undefined)).toEqual('');
+  });
+  test('encodes key value pair correctly', () => {
+    expect(encode.param('foo', 'bar')).toEqual('&foo=bar');
+  });
+  test('ignores input when value is not a string', () => {
+    expect(encode.param('foo', {})).toEqual('');
+  });
+});

package/dist/esm/common/url/location.js

@@ -3,6 +3,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+/**
+ * This method only exists to support testing in JIL and can be removed once tests are migrated to WDIO.
+ * @returns global scope location
+ */
 export function getLocation() {
   return '' + location;
 }

package/dist/esm/common/url/location.test.js

@@ -0,0 +1,11 @@
+import { faker } from '@faker-js/faker';
+import { getLocation } from './location';
+test('should always return a string', () => {
+  jest.spyOn(window, 'location', 'get').mockReturnValue({});
+  expect(typeof getLocation()).toEqual('string');
+});
+test('should return window location', () => {
+  const expected = faker.internet.url();
+  jest.spyOn(window, 'location', 'get').mockReturnValue(expected);
+  expect(getLocation()).toEqual(expected);
+});