@newrelic/browser-agent 0.1.230 → 1.232.0

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

@@ -0,0 +1,58 @@
+"use strict";
+
+var _faker = require("@faker-js/faker");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+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 Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+  const {
+    handle
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./handle')));
+  const handleEE = jest.mocked(ee.get).mock.results[0].value;
+  const eventType = _faker.faker.datatype.uuid();
+  const eventArgs = ['a', 'b', 'c'];
+  const eventContext = {};
+  const eventGroup = _faker.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 Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+  const {
+    handle
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./handle')));
+  const scopedEE = {
+    buffer: jest.fn(),
+    emit: jest.fn()
+  };
+  const handleEE = jest.mocked(ee.get).mock.results[0].value;
+  const eventType = _faker.faker.datatype.uuid();
+  const eventArgs = ['a', 'b', 'c'];
+  const eventContext = {};
+  const eventGroup = _faker.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/cjs/common/event-emitter/register-handler.test.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var _faker = require("@faker-js/faker");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+jest.mock('./handle', () => ({
+  __esModule: true,
+  handleEE: {}
+}));
+afterEach(() => {
+  jest.resetModules();
+  jest.resetAllMocks();
+});
+test('should default group to "feature"', async () => {
+  const {
+    handleEE
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./handle')));
+  const {
+    registerHandler
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./register-handler')));
+  const eventType = _faker.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 Promise.resolve().then(() => _interopRequireWildcard(require('./handle')));
+  const {
+    registerHandler
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./register-handler')));
+  const eventType = _faker.faker.datatype.uuid();
+  const eventGroup = _faker.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 Promise.resolve().then(() => _interopRequireWildcard(require('./register-handler')));
+  const scopedEE = {};
+  const eventType = _faker.faker.datatype.uuid();
+  const eventGroup = _faker.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/cjs/common/event-listener/event-listener-opts.js

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

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

@@ -27,17 +27,21 @@ class HarvestScheduler extends _sharedContext.SharedContext {
     this.aborted = false; // this controls the per-interval and final harvests for the scheduler (currently per feature specific!)
 
     this.harvest = new _harvest.Harvest(this.sharedContext);
-    (0, _eol.subscribeToEOL)(() => {
-      if (this.aborted) return;
 
-      // If opts.onUnload is defined, these are special actions to execute before attempting to send the final payload.
-      if (this.opts.onUnload) this.opts.onUnload();
-      this.runHarvest({
-        unload: true
-      });
-    }, (0, _config.getConfigurationValue)(this.sharedContext.agentIdentifier, 'allow_bfcache')); // TO DO: remove feature flag after rls stable
-  }
+    // unload if EOL mechanism fires
+    (0, _eol.subscribeToEOL)(this.unload.bind(this), (0, _config.getConfigurationValue)(this.sharedContext.agentIdentifier, 'allow_bfcache')); // TO DO: remove feature flag after rls stable
 
+    // unload if session resets
+    this.sharedContext?.ee.on('session-reset', this.unload.bind(this));
+  }
+  unload() {
+    if (this.aborted) return;
+    // If opts.onUnload is defined, these are special actions to execute before attempting to send the final payload.
+    if (this.opts.onUnload) this.opts.onUnload();
+    this.runHarvest({
+      unload: true
+    });
+  }
   startTimer(interval, initialDelay) {
     this.interval = interval;
     this.started = true;
@@ -80,8 +84,7 @@ class HarvestScheduler extends _sharedContext.SharedContext {
         }
       }
     } else {
-      const runAfterSending = opts?.unload ? undefined : onHarvestFinished; // don't bother running onFinish handler if this is the final harvest
-      this.harvest.sendX(this.endpoint, opts, runAfterSending);
+      this.harvest.sendX(this.endpoint, opts, onHarvestFinished);
     }
     if (this.started) {
       this.scheduleHarvest();

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

@@ -17,7 +17,7 @@ var _eventListenerOpts = require("../event-listener/event-listener-opts");
 var _obfuscate = require("../util/obfuscate");
 var _traverse = require("../util/traverse");
 var _sharedContext = require("../context/shared-context");
-var _environmentVariables = require("../constants/environment-variables");
+var _env = require("../constants/env.npm");
 var _globalScope = require("../util/global-scope");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
@@ -127,6 +127,8 @@ class Harvest extends _sharedContext.SharedContext {
 
     // Get bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
     agentRuntime.bytesSent[endpoint] = (agentRuntime.bytesSent[endpoint] || 0) + body?.length || 0;
+    // Get query bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
+    agentRuntime.queryBytesSent[endpoint] = (agentRuntime.queryBytesSent[endpoint] || 0) + fullUrl.split('?').slice(-1)[0]?.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),
@@ -165,9 +167,9 @@ class Harvest extends _sharedContext.SharedContext {
     var info = (0, _config.getInfo)(this.sharedContext.agentIdentifier);
     var location = (0, _cleanUrl.cleanURL)((0, _location.getLocation)());
     var ref = this.obfuscator.shouldObfuscate() ? this.obfuscator.obfuscateString(location) : location;
-    return ['?a=' + info.applicationID, (0, _encode.param)('sa', info.sa ? '' + info.sa : ''), (0, _encode.param)('v', _environmentVariables.VERSION), transactionNameParam(info), (0, _encode.param)('ct', runtime.customTransaction), '&rst=' + (0, _now.now)(), '&ck=0',
+    return ['?a=' + info.applicationID, (0, _encode.param)('sa', info.sa ? '' + info.sa : ''), (0, _encode.param)('v', _env.VERSION), transactionNameParam(info), (0, _encode.param)('ct', runtime.customTransaction), '&rst=' + (0, _now.now)(), '&ck=0',
     // ck param DEPRECATED - still expected by backend
-    '&s=' + (runtime.sessionId || '0'),
+    '&s=' + (runtime.session?.value || '0'),
     // the 0 id encaps all untrackable and default traffic
     (0, _encode.param)('ref', ref), (0, _encode.param)('ptid', runtime.ptid ? '' + runtime.ptid : '')].join('');
   }

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

@@ -11,15 +11,23 @@ var _globalScope = require("../util/global-scope");
  * SPDX-License-Identifier: Apache-2.0
  */
 
-// Start assigning ids at 1 so 0 can always be used for WindowOrWorkerGlobalScope, without
+// 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';
 
-var index = 1;
-var prop = 'nr@id';
-
-// Always returns id of obj, may tag obj with an id in the process.
+/**
+ * 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
+ */
 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/cjs/common/ids/id.test.js

@@ -0,0 +1,85 @@
+"use strict";
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+let idFn;
+beforeEach(async () => {
+  idFn = (await Promise.resolve().then(() => _interopRequireWildcard(require('./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);
+});

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

@@ -13,72 +13,96 @@ var _globalScope = require("../util/global-scope");
  * SPDX-License-Identifier: Apache-2.0
  */
 
+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
+ */
 function generateUuid() {
-  var randomVals = null;
-  var rvIndex = 0;
-  var crypto = _globalScope.globalScope?.crypto || _globalScope.globalScope?.msCrypto;
+  const crypto = _globalScope.globalScope?.crypto || _globalScope.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
+ */
+function generateRandomHexString(length) {
+  const crypto = _globalScope.globalScope?.crypto || _globalScope.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
+ */
 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
+ */
 function generateTraceId() {
   return generateRandomHexString(32);
-}
-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/cjs/common/ids/unique-id.test.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _crypto = _interopRequireDefault(require("crypto"));
+var uniqueId = _interopRequireWildcard(require("./unique-id"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const getRandomValues = jest.fn(arr => _crypto.default.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/cjs/common/session/constants.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PREFIX = exports.DEFAULT_INACTIVE_MS = exports.DEFAULT_EXPIRES_MS = void 0;
+const PREFIX = 'NRBA';
+exports.PREFIX = PREFIX;
+const DEFAULT_EXPIRES_MS = 14400000;
+exports.DEFAULT_EXPIRES_MS = DEFAULT_EXPIRES_MS;
+const DEFAULT_INACTIVE_MS = 1800000;
+exports.DEFAULT_INACTIVE_MS = DEFAULT_INACTIVE_MS;