@newrelic/browser-agent 0.1.231 → 1.232.0

package/README.md

@@ -4,11 +4,11 @@
 
 The New Relic browser agent instruments your web application or site and provides observability into performance, errors, and other behaviors.
 
-- The instructions on this page pertain to installing the browser agent as an NPM package (currently in pre-release).
+- The instructions on this page pertain to installing the browser agent as an NPM package.
 
 - The browser agent is also generally available as a copy-paste JavaScript snippet and via auto-injection by backend apps. See *[Install the browser agent](https://docs.newrelic.com/docs/browser/browser-monitoring/installation/install-browser-monitoring-agent/)* for info on these alternatives.
 
-- For questions and feedback on this pre-release package, please visit the [Explorer's Hub](https://forum.newrelic.com/s/), New Relic's community support forum.
+- For questions and feedback on this package, please visit the [Explorer's Hub](https://forum.newrelic.com/s/), New Relic's community support forum.
 
 - Looking to contribute to the browser agent code base? See [DEVELOPING.md](DEVELOPING.md) for instructions on building and testing the browser agent library, and [CONTRIBUTING.md](CONTRIBUTING.md) for general guidance.
 

package/dist/cjs/common/config/state/configurable.js

@@ -8,26 +8,32 @@ var _featureDependencies = require("../../../loaders/features/featureDependencie
 var _console = require("../../util/console");
 class Configurable {
   constructor(obj, model) {
-    try {
-      if (!obj || typeof obj !== 'object') return (0, _console.warn)('New setting a Configurable requires an object as input');
-      if (!model || typeof model !== 'object') return (0, _console.warn)('Setting a Configurable requires a model to set its initial properties');
-      Object.assign(this, model);
-      Object.entries(obj).forEach(_ref => {
-        let [key, value] = _ref;
-        const frozenAttrs = (0, _featureDependencies.getFrozenAttributes)(key);
-        if (frozenAttrs.length && value && typeof value === 'object') {
-          frozenAttrs.forEach(attr => {
-            if (attr in value) {
-              (0, _console.warn)("\"".concat(attr, "\" is a protected attribute and can not be changed in feature ").concat(key, ".  It will have no effect."));
-              delete value[attr];
-            }
-          });
-        }
-        this[key] = value;
-      });
-    } catch (err) {
-      (0, _console.warn)('An error occured while setting a Configurable', err);
-    }
+    Object.assign(this, setValues(obj, model));
   }
 }
-exports.Configurable = Configurable;
+exports.Configurable = Configurable;
+function setValues(obj, model) {
+  const state = {};
+  try {
+    if (!obj || typeof obj !== 'object') return (0, _console.warn)('New setting a Configurable requires an object as input');
+    if (!model || typeof model !== 'object') return (0, _console.warn)('Setting a Configurable requires a model to set its initial properties');
+    Object.assign(state, model);
+    Object.entries(obj).forEach(_ref => {
+      let [key, value] = _ref;
+      if (!Object.keys(model).includes(key)) return;
+      const frozenAttrs = (0, _featureDependencies.getFrozenAttributes)(key);
+      if (frozenAttrs.length && value && typeof value === 'object') {
+        frozenAttrs.forEach(attr => {
+          if (attr in value) {
+            (0, _console.warn)("\"".concat(attr, "\" is a protected attribute and can not be changed in feature ").concat(key, ".  It will have no effect."));
+            delete value[attr];
+          }
+        });
+      }
+      state[key] = value;
+    });
+    return state;
+  } catch (err) {
+    (0, _console.warn)('An error occured while setting a Configurable', err);
+  }
+}

package/dist/cjs/common/config/state/init.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.getConfiguration = getConfiguration;
 exports.getConfigurationValue = getConfigurationValue;
 exports.setConfiguration = setConfiguration;
+var _constants = require("../../session/constants");
+var _globalScope = require("../../util/global-scope");
 var _nreum = require("../../window/nreum");
 var _configurable = require("./configurable");
 const model = {
@@ -27,6 +29,12 @@ const model = {
     cors_use_tracecontext_headers: undefined,
     allowed_origins: undefined
   },
+  session: {
+    domain: undefined,
+    // used by first party cookies to set the top-level domain
+    expiresMs: _constants.DEFAULT_EXPIRES_MS,
+    inactiveMs: _constants.DEFAULT_INACTIVE_MS
+  },
   ssl: undefined,
   obfuscate: undefined,
   jserrors: {

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

@@ -8,35 +8,33 @@ exports.setRuntime = setRuntime;
 var userAgent = _interopRequireWildcard(require("../../util/user-agent"));
 var _configurable = require("./configurable");
 var _nreum = require("../../window/nreum");
-var _sessionStorage = require("../../window/session-storage");
-var _config = require("../config");
 var _globalScope = require("../../util/global-scope");
 var _env = require("../../constants/env.npm");
 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; }
-const model = agentId => {
-  return {
-    buildEnv: _env.BUILD_ENV,
-    bytesSent: {},
-    customTransaction: undefined,
-    disabled: false,
-    distMethod: _env.DIST_METHOD,
-    isolatedBacklog: false,
-    loaderType: undefined,
-    maxBytes: 30000,
-    // The "timeOrigin" property is the new standard timestamp property shared across main frame and workers, but is not supported in some early Safari browsers (safari<15) + IE
-    // ingest expects an integer value, and timeOrigin can return a float.
-    offset: Math.floor(_globalScope.globalScope?.performance?.timeOrigin || _globalScope.globalScope?.performance?.timing?.navigationStart || Date.now()),
-    onerror: undefined,
-    origin: '' + _globalScope.globalScope.location,
-    ptid: undefined,
-    releaseIds: {},
-    sessionId: (0, _config.getConfigurationValue)(agentId, 'privacy.cookies_enabled') == true ? (0, _sessionStorage.getCurrentSessionIdOrMakeNew)() : null,
-    // if cookies (now session tracking) is turned off or can't get session ID, this is null
-    xhrWrappable: typeof _globalScope.globalScope.XMLHttpRequest?.prototype?.addEventListener === 'function',
-    userAgent,
-    version: _env.VERSION
-  };
+const model = {
+  buildEnv: _env.BUILD_ENV,
+  bytesSent: {},
+  // Used for SM to capture body bytes sent per endpoint
+  queryBytesSent: {},
+  // Used for SM to capture query parameter bytes sent per endpoint
+  customTransaction: undefined,
+  disabled: false,
+  distMethod: _env.DIST_METHOD,
+  isolatedBacklog: false,
+  loaderType: undefined,
+  maxBytes: 30000,
+  // The "timeOrigin" property is the new standard timestamp property shared across main frame and workers, but is not supported in some early Safari browsers (safari<15) + IE
+  // ingest expects an integer value, and timeOrigin can return a float.
+  offset: Math.floor(_globalScope.globalScope?.performance?.timeOrigin || _globalScope.globalScope?.performance?.timing?.navigationStart || Date.now()),
+  onerror: undefined,
+  origin: '' + _globalScope.globalScope.location,
+  ptid: undefined,
+  releaseIds: {},
+  session: undefined,
+  xhrWrappable: typeof _globalScope.globalScope.XMLHttpRequest?.prototype?.addEventListener === 'function',
+  userAgent,
+  version: _env.VERSION
 };
 const _cache = {};
 function getRuntime(id) {
@@ -46,6 +44,6 @@ function getRuntime(id) {
 }
 function setRuntime(id, obj) {
   if (!id) throw new Error('All runtime objects require an agent identifier!');
-  _cache[id] = new _configurable.Configurable(obj, model(id));
+  _cache[id] = new _configurable.Configurable(obj, model);
   (0, _nreum.gosNREUMInitializedAgents)(id, _cache[id], 'runtime');
 }

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

@@ -12,7 +12,7 @@ exports.VERSION = exports.DIST_METHOD = exports.BUILD_ENV = void 0;
 /**
  * Exposes the version of the agent
  */
-const VERSION = "1.231.0";
+const VERSION = "1.232.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -12,7 +12,7 @@ exports.VERSION = exports.DIST_METHOD = exports.BUILD_ENV = void 0;
 /**
  * Exposes the version of the agent
  */
-const VERSION = "1.231.0";
+const VERSION = "1.232.0";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/context/shared-context.js

@@ -6,7 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.SharedContext = void 0;
 var _console = require("../util/console");
 const model = {
-  agentIdentifier: ''
+  agentIdentifier: '',
+  ee: undefined
 };
 class SharedContext {
   constructor(context) {

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

@@ -257,8 +257,8 @@ describe('event-emitter emit', () => {
     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']);
+    expect(scopeEE.backlog.feature).toEqual(expect.arrayContaining([expect.arrayContaining([scopeEE, eventType, eventArgs, {}])]));
+    expect(ee.backlog.feature).toEqual(scopeEE.backlog.feature);
   });
 });
 describe('getOrSetContext', () => {

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

@@ -21,7 +21,7 @@ test('should default group to "feature"', async () => {
   const eventType = _faker.faker.datatype.uuid();
   const eventHandler = jest.fn();
   registerHandler(eventType, eventHandler);
-  expect(registerHandler.handlers['feature']).toEqual(expect.objectContaining({
+  expect(registerHandler.handlers.feature).toEqual(expect.objectContaining({
     [eventType]: [expect.arrayContaining([handleEE, 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

@@ -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),
@@ -167,7 +169,7 @@ class Harvest extends _sharedContext.SharedContext {
     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', _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/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;

package/dist/cjs/common/session/session-entity.js

@@ -0,0 +1,278 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SessionEntity = void 0;
+var _uniqueId = require("../ids/unique-id");
+var _console = require("../util/console");
+var _stringify = require("../util/stringify");
+var _contextualEe = require("../event-emitter/contextual-ee");
+var _timer = require("../timer/timer");
+var _globalScope = require("../util/global-scope");
+var _constants = require("./constants");
+var _localMemory = require("../storage/local-memory");
+var _interactionTimer = require("../timer/interaction-timer");
+var _wrap = require("../wrap");
+var _configurable = require("../config/state/configurable");
+var _handle = require("../event-emitter/handle");
+var _constants2 = require("../../features/metrics/constants");
+var _features = require("../../loaders/features/features");
+const model = {
+  value: '',
+  inactiveAt: 0,
+  expiresAt: 0,
+  updatedAt: Date.now(),
+  sessionReplayActive: false,
+  sessionTraceActive: false,
+  custom: {}
+};
+class SessionEntity {
+  /**
+   * Create a self-managing Session Entity. This entity is scoped to the agent identifier which triggered it, allowing for multiple simultaneous session objects to exist.
+   * There is one "namespace" an agent can store data in LS -- NRBA_{key}. If there are two agents on one page, and they both use the same key, they could overwrite each other since they would both use the same namespace in LS by default.
+   * The value can be overridden in the constructor, but will default to a unique 16 character hex string
+   * expiresMs and inactiveMs are used to "expire" the session, but can be overridden in the constructor. Pass 0 to disable expiration timers.
+   */
+  constructor(opts) {
+    this.setup(opts);
+  }
+  setup(_ref) {
+    let {
+      agentIdentifier,
+      key,
+      value = (0, _uniqueId.generateRandomHexString)(16),
+      expiresMs = _constants.DEFAULT_EXPIRES_MS,
+      inactiveMs = _constants.DEFAULT_INACTIVE_MS,
+      storageAPI = new _localMemory.LocalMemory()
+    } = _ref;
+    if (!agentIdentifier || !key) throw new Error('Missing Required Fields');
+    if (!_globalScope.isBrowserScope) this.storage = new _localMemory.LocalMemory();else this.storage = storageAPI;
+    this.sync(model);
+    this.agentIdentifier = agentIdentifier;
+
+    // key is intended to act as the k=v pair
+    this.key = key;
+    // value is intended to act as the primary value of the k=v pair
+    this.value = value;
+    this.expiresMs = expiresMs;
+    this.inactiveMs = inactiveMs;
+    this.ee = _contextualEe.ee.get(agentIdentifier);
+    (0, _wrap.wrapEvents)(this.ee);
+
+    // the first time the session entity class is instantiated, we check the storage API for an existing
+    // object. If it exists, the values inside the object are used to inform the timers that run locally.
+    // if the initial read is empty, it allows us to set a "fresh" "new" session immediately.
+    // the local timers are used after the session is running to "expire" the session, allowing for pausing timers etc.
+    // the timestamps stored in the storage API can be checked at initial run, and when the page is restored, otherwise we lean
+    // on the local timers to expire the session
+    const initialRead = this.read();
+
+    // the set-up of the timer used to expire the session "naturally" at a certain time
+    // this gets ignored if the value is falsy, allowing for session entities that do not expire
+    if (expiresMs) {
+      this.expiresAt = initialRead?.expiresAt || this.getFutureTimestamp(expiresMs);
+      this.expiresTimer = new _timer.Timer({
+        // When the inactive timer ends, collect a SM and reset the session
+        onEnd: () => {
+          this.collectSM('expired', this);
+          this.collectSM('duration', this);
+          this.reset();
+        }
+      }, this.expiresAt - Date.now());
+    } else {
+      this.expiresAt = Infinity;
+    }
+
+    // the set-up of the timer used to expire the session due to "inactivity" at a certain time
+    // this gets ignored if the value is falsy, allowing for session entities that do not expire
+    // this gets "refreshed" when "activity" is observed
+    if (inactiveMs) {
+      this.inactiveAt = initialRead?.inactiveAt || this.getFutureTimestamp(inactiveMs);
+      this.inactiveTimer = new _interactionTimer.InteractionTimer({
+        // When the inactive timer ends, collect a SM and reset the session
+        onEnd: () => {
+          this.collectSM('inactive', this);
+          this.collectSM('duration', this);
+          this.reset();
+        },
+        // When the inactive timer refreshes, it will update the storage values with an update timestamp
+        onRefresh: this.refresh.bind(this),
+        // When the inactive timer pauses, update the storage values with an update timestamp
+        onPause: () => this.write(new _configurable.Configurable(this.read(), model)),
+        ee: this.ee,
+        refreshEvents: ['click', 'keydown', 'scroll']
+      }, this.inactiveAt - Date.now());
+    } else {
+      this.inactiveAt = Infinity;
+    }
+
+    // The fact that the session is "new" or pre-existing is used in some places in the agent.  Session Replay and Trace
+    // can use this info to inform whether to trust a new sampling decision vs continue a previous tracking effort.
+    this.isNew = !Object.keys(initialRead).length;
+    // if its a "new" session, we write to storage API with the default values.  These values may change over the lifespan of the agent run.
+    // we can use configurable here to help us know and manage what values are being used. -- see "model" above
+    if (this.isNew) this.write(new _configurable.Configurable(this, model), true);else this.sync(initialRead);
+    this.initialized = true;
+  }
+
+  // This is the actual key appended to the storage API
+  get lookupKey() {
+    return "".concat(_constants.PREFIX, "_").concat(this.key);
+  }
+  sync(data) {
+    Object.assign(this, data);
+  }
+
+  /**
+   * Fetch the stored values from the storage API tied to this entity
+   * @returns {Object}
+   */
+  read() {
+    try {
+      const val = this.storage.get(this.lookupKey);
+      if (!val) return {};
+      // TODO - decompression would need to happen here if we decide to do it
+      const obj = typeof val === 'string' ? JSON.parse(val) : val;
+      if (this.isInvalid(obj)) return {};
+      // if the session expires, collect a SM count before resetting
+      if (this.isExpired(obj.expiresAt)) {
+        this.collectSM('expired', this);
+        this.collectSM('duration', obj, true);
+        return this.reset();
+      }
+      // if "inactive" timer is expired at "read" time -- esp. initial read -- reset
+      // collect a SM count before resetting
+      if (this.isExpired(obj.inactiveAt)) {
+        this.collectSM('inactive', this);
+        this.collectSM('duration', obj, true);
+        return this.reset();
+      }
+      return obj;
+    } catch (e) {
+      (0, _console.warn)('Failed to read from storage API', e);
+      // storage is inaccessible
+      return {};
+    }
+  }
+
+  /**
+   * Store data to the storage API tied to this entity
+   * To preseve existing attributes, the output of ...session.read()
+   * should be appended to the data argument
+   * @param {Object} data
+   * @returns {Object}
+   */
+  write(data) {
+    try {
+      if (!data || typeof data !== 'object') return;
+      // everytime we update, we can update a timestamp for sanity
+      data.updatedAt = Date.now();
+      this.sync(data);
+      // TODO - compression would need happen here if we decide to do it
+      this.storage.set(this.lookupKey, (0, _stringify.stringify)(data));
+      return data;
+    } catch (e) {
+      // storage is inaccessible
+      (0, _console.warn)('Failed to write to the storage API', e);
+      return null;
+    }
+  }
+  reset() {
+    // this method should set off a chain of actions across the features by emitting 'new-session'
+    // * send off pending payloads
+    // * stop recording (stn and sr)...
+    // * delete the session and start over
+    try {
+      if (this.initialized) this.ee.emit('session-reset');
+      this.storage.remove(this.lookupKey);
+      this.inactiveTimer?.abort?.();
+      this.expiresTimer?.clear?.();
+      delete this.custom;
+      delete this.value;
+      this.setup({
+        agentIdentifier: this.agentIdentifier,
+        key: this.key,
+        storageAPI: this.storage,
+        expiresMs: this.expiresMs,
+        inactiveMs: this.inactiveMs
+      });
+      return this.read();
+    } catch (e) {
+      return {};
+    }
+  }
+
+  /**
+   * Refresh the inactivity timer data
+   */
+  refresh() {
+    // read here & invalidate
+    const existingData = this.read();
+    this.inactiveAt = this.getFutureTimestamp(this.inactiveMs);
+    this.write({
+      ...existingData,
+      inactiveAt: this.inactiveAt
+    });
+  }
+
+  /**
+   * @param {number} timestamp
+   * @returns {boolean}
+   */
+  isExpired(timestamp) {
+    return Date.now() > timestamp;
+  }
+
+  /**
+   * @param {Object} data
+   * @returns {boolean}
+   */
+  isInvalid(data) {
+    const requiredKeys = ['value', 'expiresAt', 'inactiveAt'];
+    return !requiredKeys.every(x => Object.keys(data).includes(x));
+  }
+  collectSM(type, data, useUpdatedAt) {
+    let value, tag;
+    if (type === 'duration') {
+      const startingTimestamp = data.expiresAt - data.expiresMs;
+      const endingTimestamp = useUpdatedAt ? data.updatedAt : Date.now();
+      value = endingTimestamp - startingTimestamp;
+      tag = 'Session/Duration/Ms';
+    }
+    if (type === 'expired') tag = 'Session/Expired/Seen';
+    if (type === 'inactive') tag = 'Session/Inactive/Seen';
+    if (tag) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, [tag, value], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+  }
+
+  /**
+   * @param {number} futureMs - The number of ms to use to generate a future timestamp
+   * @returns {number}
+   */
+  getFutureTimestamp(futureMs) {
+    return Date.now() + futureMs;
+  }
+  syncCustomAttribute(key, value) {
+    if (!_globalScope.isBrowserScope) return;
+    if (value === null) {
+      const curr = this.read();
+      if (curr.custom) {
+        delete curr.custom[key];
+        this.write({
+          ...curr
+        });
+      }
+    } else {
+      const curr = this.read();
+      this.custom = {
+        ...(curr?.custom || {}),
+        [key]: value
+      };
+      this.write({
+        ...curr,
+        custom: this.custom
+      });
+    }
+  }
+}
+exports.SessionEntity = SessionEntity;