@newrelic/browser-agent 1.257.0 → 1.258.1

package/dist/cjs/features/jserrors/shared/cast-error.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.castError = castError;
+exports.castErrorEvent = castErrorEvent;
+exports.castPromiseRejectionEvent = castPromiseRejectionEvent;
+var _uncaughtError = require("./uncaught-error");
+/**
+   * Any value can be used with the `throw` keyword. This function ensures that the value is
+   * either a proper Error instance or attempts to convert it to an UncaughtError instance.
+   * @param {any} error The value thrown
+   * @returns {Error|UncaughtError} The converted error instance
+   */
+function castError(error) {
+  /** Sometimes a browser can emit an error object with no stack */
+  if (canTrustError(error)) {
+    return error;
+  }
+
+  /**
+     * The thrown value may contain a message property. If it does, try to treat the thrown
+     * value as an Error-like object.
+     */
+  return new _uncaughtError.UncaughtError(error?.message !== undefined ? error.message : error, error?.filename || error?.sourceURL, error?.lineno || error?.line, error?.colno || error?.col, error?.__newrelic);
+}
+
+/**
+   * Attempts to convert a PromiseRejectionEvent object to an Error object
+   * @param {PromiseRejectionEvent} unhandledRejectionEvent The unhandled promise rejection event
+   * @returns {Error} An Error object with the message as the casted reason
+   */
+function castPromiseRejectionEvent(promiseRejectionEvent) {
+  let prefix = 'Unhandled Promise Rejection';
+  if (canTrustError(promiseRejectionEvent?.reason)) {
+    try {
+      promiseRejectionEvent.reason.message = prefix + ': ' + promiseRejectionEvent.reason.message;
+      return castError(promiseRejectionEvent.reason);
+    } catch (e) {
+      return castError(promiseRejectionEvent.reason);
+    }
+  }
+  if (typeof promiseRejectionEvent.reason === 'undefined') return castError(prefix);
+  const error = castError(promiseRejectionEvent.reason);
+  error.message = prefix + ': ' + error?.message;
+  return error;
+}
+
+/**
+   * Attempts to convert an ErrorEvent object to an Error object
+   * @param {ErrorEvent} errorEvent The error event
+   * @returns {Error|UncaughtError} The error event converted to an Error object
+   */
+function castErrorEvent(errorEvent) {
+  if (errorEvent.error instanceof SyntaxError && !/:\d+$/.test(errorEvent.error.stack?.trim())) {
+    const error = new _uncaughtError.UncaughtError(errorEvent.message, errorEvent.filename, errorEvent.lineno, errorEvent.colno, errorEvent.error.__newrelic);
+    error.name = SyntaxError.name;
+    return error;
+  }
+  if (canTrustError(errorEvent.error)) return errorEvent.error;
+  return castError(errorEvent);
+}
+function canTrustError(error) {
+  return error instanceof Error && !!error.stack;
+}

package/dist/cjs/features/jserrors/{instrument → shared}/uncaught-error.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.UncaughtError = void 0;
+var _stringify = require("../../../common/util/stringify");
 /**
  * Represents an uncaught non Error type error. This class does
  * not extend the Error class to prevent an invalid stack trace
@@ -11,12 +12,13 @@ exports.UncaughtError = void 0;
  * do not use the Error class (strings, etc) to an object.
  */
 class UncaughtError {
-  constructor(message, filename, lineno, colno) {
+  constructor(message, filename, lineno, colno, newrelic) {
     this.name = 'UncaughtError';
-    this.message = message;
+    this.message = typeof message === 'string' ? message : (0, _stringify.stringify)(message);
     this.sourceURL = filename;
     this.line = lineno;
     this.column = colno;
+    this.__newrelic = newrelic;
   }
 }
 exports.UncaughtError = UncaughtError;

package/dist/cjs/features/page_view_event/aggregate/index.js

@@ -103,14 +103,14 @@ class Aggregate extends _aggregateBase.AggregateBase {
         // Navigation Timing level 2 API that replaced PerformanceTiming & PerformanceNavigation
         const navTimingEntry = _runtime.globalScope?.performance?.getEntriesByType('navigation')?.[0];
         const perf = {
-          timing: (0, _navTiming.addPT)(agentRuntime.offset, navTimingEntry, {}),
+          timing: (0, _navTiming.addPT)(_runtime.originTime, navTimingEntry, {}),
           navigation: (0, _navTiming.addPN)(navTimingEntry, {})
         };
         queryParameters.perf = (0, _stringify.stringify)(perf);
       } else if (typeof PerformanceTiming !== 'undefined') {
         // Safari pre-15 did not support level 2 timing
         const perf = {
-          timing: (0, _navTiming.addPT)(agentRuntime.offset, _runtime.globalScope.performance.timing, {}, true),
+          timing: (0, _navTiming.addPT)(_runtime.originTime, _runtime.globalScope.performance.timing, {}, true),
           navigation: (0, _navTiming.addPN)(_runtime.globalScope.performance.navigation, {})
         };
         queryParameters.perf = (0, _stringify.stringify)(perf);
@@ -142,7 +142,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
           return;
         }
         try {
-          const timeKeeper = new _timeKeeper.TimeKeeper();
+          const timeKeeper = new _timeKeeper.TimeKeeper(this.agentIdentifier);
           timeKeeper.processRumRequest(xhr, rumStartTime, rumEndTime);
           if (!timeKeeper.ready) throw new Error('TimeKeeper not ready');
           agentRuntime.timeKeeper = timeKeeper;

package/dist/cjs/features/session_replay/aggregate/index.js

@@ -373,6 +373,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
           ...(agentMetadata.entityGuid && {
             entityGuid: agentMetadata.entityGuid
           }),
+          harvestId: [agentRuntime.session?.state.value, agentRuntime.ptid, agentRuntime.harvestCount].filter(x => x).join('_'),
           'replay.firstTimestamp': firstTimestamp,
           'replay.lastTimestamp': lastTimestamp,
           'replay.nodes': events.length,

package/dist/cjs/features/session_replay/shared/utils.js

@@ -32,8 +32,8 @@ function buildNRMetaNode(timestamp, timeKeeper) {
     originalTimestamp: timestamp,
     correctedTimestamp,
     timestampDiff: timestamp - correctedTimestamp,
-    timeKeeperOriginTime: timeKeeper.originTime,
-    timeKeeperCorrectedOriginTime: timeKeeper.correctedOriginTime,
-    timeKeeperDiff: Math.floor(timeKeeper.originTime - timeKeeper.correctedOriginTime)
+    originTime: _runtime.originTime,
+    correctedOriginTime: timeKeeper.correctedOriginTime,
+    originTimeDiff: Math.floor(_runtime.originTime - timeKeeper.correctedOriginTime)
   };
 }

package/dist/cjs/features/session_trace/aggregate/index.js

@@ -14,6 +14,7 @@ var _replayMode = require("../../session_replay/shared/replay-mode");
 var _aggregateBase = require("../../utils/aggregate-base");
 var _constants2 = require("../../../common/session/constants");
 var _now = require("../../../common/timing/now");
+var _runtime = require("../../../common/constants/runtime");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -53,14 +54,12 @@ class Aggregate extends _aggregateBase.AggregateBase {
     super(agentIdentifier, aggregator, _constants.FEATURE_NAME);
     _this = this;
     this.agentRuntime = (0, _config.getRuntime)(agentIdentifier);
-
-    // Very unlikely, but in case the existing XMLHttpRequest.prototype object on the page couldn't be wrapped.
-    if (!this.agentRuntime.xhrWrappable) return;
     this.resourceObserver = argsObj?.resourceObserver; // undefined if observer couldn't be created
     this.ptid = '';
     this.trace = {};
     this.nodeCount = 0;
     this.sentTrace = null;
+    this.prevStoredEvents = new Set();
     this.harvestTimeSeconds = (0, _config.getConfigurationValue)(agentIdentifier, 'session_trace.harvestTimeSeconds') || 10;
     this.maxNodesPerHarvest = (0, _config.getConfigurationValue)(agentIdentifier, 'session_trace.maxNodesPerHarvest') || 1000;
     /**
@@ -128,7 +127,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
         return controlTraceOp(on);
       }, this.featureName, this.ee);
     } else {
-      (0, _registerHandler.registerHandler)('errorAgg', () => {
+      (0, _registerHandler.registerHandler)('trace-jserror', () => {
         seenAnError = true;
         switchToFull();
       }, this.featureName, this.ee);
@@ -223,7 +222,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       }
       return operationalGate.settle(() => _this.storeSTN(...args));
     }, this.featureName, this.ee);
-    (0, _registerHandler.registerHandler)('errorAgg', function () {
+    (0, _registerHandler.registerHandler)('trace-jserror', function () {
       for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
         args[_key6] = arguments[_key6];
       }
@@ -272,6 +271,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
   }
   #prepareHarvest(options) {
+    this.prevStoredEvents.clear(); // release references to past events for GC
     if (this.isStandalone) {
       if (this.ptid && (0, _now.now)() >= MAX_TRACE_DURATION) {
         // Perform a final harvest once we hit or exceed the max session trace time
@@ -338,6 +338,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
   // Tracks the events and their listener's duration on objects wrapped by wrap-events.
   storeEvent(currentEvent, target, start, end) {
     if (this.shouldIgnoreEvent(currentEvent, target)) return;
+    if (this.prevStoredEvents.has(currentEvent)) return; // prevent multiple listeners of an event from creating duplicate trace nodes per occurrence. Cleared every harvest. near-zero chance for re-duplication after clearing per harvest since the timestamps of the event are considered for uniqueness.
+    this.prevStoredEvents.add(currentEvent);
     const evt = {
       n: this.evtName(currentEvent.type),
       s: start,
@@ -538,13 +540,13 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
     return {
       qs: {
-        st: this.agentRuntime.offset,
+        st: _runtime.originTime,
         /** hr === "hasReplay" in NR1, standalone is always checked and processed before harvesting
          * so a race condition between ST and SR states should not be a concern if implemented here */
         hr: Number(!this.isStandalone),
         /** fts === "firstTimestamp" in NR1, indicates what the earliest NODE timestamp was
          * so that blob parsing doesn't need to happen to support UI/API functions  */
-        fts: this.agentRuntime.offset + earliestTimeStamp,
+        fts: _runtime.originTime + earliestTimeStamp,
         /** n === "nodeCount" in NR1, a count of nodes in the ST payload, so that blob parsing doesn't need to happen to support UI/API functions */
         n: stns.length,
         // node count

package/dist/cjs/features/spa/aggregate/index.js

@@ -651,7 +651,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
         state.interactionsSent = [];
       }
     }
-    baseEE.on('errorAgg', function (type, name, params, metrics) {
+    baseEE.on('spa-jserror', function (type, name, params, metrics) {
       if (!state.currentNode) return;
       params._interactionId = state.currentNode.interaction.id;
       // do not capture parentNodeId when in root node
@@ -659,6 +659,16 @@ class Aggregate extends _aggregateBase.AggregateBase {
         params._interactionNodeId = state.currentNode.id;
       }
     });
+    (0, _registerHandler.registerHandler)('function-err', function (args, obj, error) {
+      if (!state.currentNode) return;
+      error.__newrelic ??= {};
+      error.__newrelic[agentIdentifier] = {
+        interactionId: state.currentNode.interaction.id
+      };
+      if (state.currentNode.type && state.currentNode.type !== 'interaction') {
+        error.__newrelic[agentIdentifier].interactionNodeId = state.currentNode.id;
+      }
+    }, this.featureName, baseEE);
     baseEE.on('interaction', saveInteraction);
     function getActionText(node) {
       var nodeType = node.tagName.toLowerCase();

package/dist/cjs/features/spa/instrument/index.js

@@ -7,10 +7,10 @@ exports.Instrument = void 0;
 var _wrap = require("../../../common/wrap");
 var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
 var _instrumentBase = require("../../utils/instrument-base");
-var _config = require("../../../common/config/config");
 var CONSTANTS = _interopRequireWildcard(require("../constants"));
 var _runtime = require("../../../common/constants/runtime");
 var _now = require("../../../common/timing/now");
+var _handle = require("../../../common/event-emitter/handle");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 /*
@@ -33,11 +33,12 @@ const {
 class Instrument extends _instrumentBase.InstrumentBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
+    var _this;
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+    _this = this;
     if (!_runtime.isBrowserScope) return; // SPA not supported outside web env
 
-    if (!(0, _config.getRuntime)(agentIdentifier).xhrWrappable) return;
     try {
       this.removeOnAbort = new AbortController();
     } catch (e) {}
@@ -58,6 +59,12 @@ class Instrument extends _instrumentBase.InstrumentBase {
     this.ee.on(FN_END, endTimestamp);
     promiseEE.on(CB_END, endTimestamp);
     jsonpEE.on(CB_END, endTimestamp);
+    this.ee.on('fn-err', function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      if (!args[2]?.__newrelic?.[agentIdentifier]) (0, _handle.handle)('function-err', [...args], undefined, _this.featureName, _this.ee);
+    });
     this.ee.buffer([FN_START, FN_END, 'xhr-resolved'], this.featureName);
     eventsEE.buffer([FN_START], this.featureName);
     timerEE.buffer(['setTimeout' + END, 'clearTimeout' + START, FN_START], this.featureName);

package/dist/cjs/features/utils/agent-session.js

@@ -10,20 +10,16 @@ var _contextualEe = require("../../common/event-emitter/contextual-ee");
 var _registerHandler = require("../../common/event-emitter/register-handler");
 var _sessionEntity = require("../../common/session/session-entity");
 var _localStorage = require("../../common/storage/local-storage.js");
-var _firstPartyCookies = require("../../common/storage/first-party-cookies");
 var _constants = require("../../common/session/constants");
 let ranOnce = 0;
 function setupAgentSession(agentIdentifier) {
   const agentRuntime = (0, _config.getRuntime)(agentIdentifier);
   if (ranOnce++) return agentRuntime.session;
   const sessionInit = (0, _config.getConfiguration)(agentIdentifier).session;
-  /* Domain is a string that can be specified by customer. The only way to keep the session object across subdomains is using first party cookies.
-    This determines which storage wrapper the session manager will use to keep state. */
-  const storageTypeInst = sessionInit?.domain ? new _firstPartyCookies.FirstPartyCookies(sessionInit.domain) : new _localStorage.LocalStorage();
   agentRuntime.session = new _sessionEntity.SessionEntity({
     agentIdentifier,
     key: _constants.DEFAULT_KEY,
-    storage: storageTypeInst,
+    storage: new _localStorage.LocalStorage(),
     expiresMs: sessionInit?.expiresMs,
     inactiveMs: sessionInit?.inactiveMs
   });

package/dist/cjs/features/utils/instrument-base.js

@@ -57,7 +57,7 @@ class InstrumentBase extends _featureBase.FeatureBase {
     if ((0, _config.getConfigurationValue)(this.agentIdentifier, "".concat(this.featureName, ".autoStart")) === false) this.auto = false;
     /** if the feature requires opt-in (!auto-start), it will get registered once the api has been called */
     if (this.auto) (0, _drain.registerDrain)(agentIdentifier, featureName);else {
-      this.ee.on("".concat(this.featureName, "-opt-in"), (0, _invoke.single)(() => {
+      this.ee.on('manual-start-all', (0, _invoke.single)(() => {
         // register the feature to drain only once the API has been called, it will drain when importAggregator finishes for all the features
         // called by the api in that cycle
         (0, _drain.registerDrain)(this.agentIdentifier, this.featureName);

package/dist/cjs/loaders/api/api.js

@@ -133,19 +133,10 @@ function setAPI(agentIdentifier, forceDrain) {
     }
     return appendJsAttribute('application.version', value, 'setApplicationVersion', false);
   };
-  apiInterface.start = features => {
+  apiInterface.start = () => {
     try {
-      const smTag = !features ? 'undefined' : 'defined';
-      (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ["API/start/".concat(smTag, "/called")], undefined, _features.FEATURE_NAMES.metrics, instanceEE);
-      const featNames = Object.values(_features.FEATURE_NAMES);
-      if (features === undefined) features = featNames;else {
-        features = Array.isArray(features) && features.length ? features : [features];
-        if (features.some(f => !featNames.includes(f))) return (0, _console.warn)("Invalid feature name supplied. Acceptable feature names are: ".concat(featNames));
-        if (!features.includes(_features.FEATURE_NAMES.pageViewEvent)) features.push(_features.FEATURE_NAMES.pageViewEvent);
-      }
-      features.forEach(feature => {
-        instanceEE.emit("".concat(feature, "-opt-in"));
-      });
+      (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['API/start/called'], undefined, _features.FEATURE_NAMES.metrics, instanceEE);
+      instanceEE.emit('manual-start-all');
     } catch (err) {
       (0, _console.warn)('An unexpected issue occurred', err);
     }
@@ -176,9 +167,10 @@ function setAPI(agentIdentifier, forceDrain) {
           try {
             return cb.apply(this, arguments);
           } catch (err) {
-            tracerEE.emit('fn-err', [arguments, this, err], contextStore);
+            const error = typeof err === 'string' ? new Error(err) : err;
+            tracerEE.emit('fn-err', [arguments, this, error], contextStore);
             // the error came from outside the agent, so don't swallow
-            throw err;
+            throw error;
           } finally {
             tracerEE.emit('fn-end', [(0, _now.now)()], contextStore);
           }

package/dist/cjs/loaders/api/apiAsync.js

@@ -11,6 +11,7 @@ var _handle = require("../../common/event-emitter/handle");
 var _registerHandler = require("../../common/event-emitter/register-handler");
 var _invoke = require("../../common/util/invoke");
 var _constants = require("../../features/metrics/constants");
+var _runtime = require("../../common/constants/runtime");
 function setAPI(agentIdentifier) {
   var instanceEE = _contextualEe.ee.get(agentIdentifier);
   var api = {
@@ -30,13 +31,13 @@ function setAPI(agentIdentifier) {
   // first parameter. These functions can be called asynchronously.
 
   function finished(t, providedTime) {
-    var time = providedTime ? providedTime - (0, _config.getRuntime)(agentIdentifier).offset : t;
+    var time = providedTime ? providedTime - _runtime.originTime : t;
     (0, _handle.handle)(_constants.CUSTOM_METRIC_CHANNEL, ['finished', {
       time
     }], undefined, _features.FEATURE_NAMES.metrics, instanceEE);
     addToTrace(t, {
       name: 'finished',
-      start: time + (0, _config.getRuntime)(agentIdentifier).offset,
+      start: time + _runtime.originTime,
       origin: 'nr'
     });
     (0, _handle.handle)('api-addPageAction', [time, 'finished'], undefined, _features.FEATURE_NAMES.pageAction, instanceEE);
@@ -45,8 +46,8 @@ function setAPI(agentIdentifier) {
     if (!(evt && typeof evt === 'object' && evt.name && evt.start)) return;
     var report = {
       n: evt.name,
-      s: evt.start - (0, _config.getRuntime)(agentIdentifier).offset,
-      e: (evt.end || evt.start) - (0, _config.getRuntime)(agentIdentifier).offset,
+      s: evt.start - _runtime.originTime,
+      e: (evt.end || evt.start) - _runtime.originTime,
       o: evt.origin || '',
       t: 'api'
     };

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

@@ -7,12 +7,15 @@ export function getModeledObject(obj, model) {
     const output = Object.create(Object.getPrototypeOf(model), Object.getOwnPropertyDescriptors(model));
     const target = Object.keys(output).length === 0 ? obj : output;
     for (let key in target) {
-      if (obj[key] !== undefined) {
-        try {
-          if (Array.isArray(obj[key]) && Array.isArray(model[key])) output[key] = Array.from(new Set([...obj[key], ...model[key]]));else if (typeof obj[key] === 'object' && typeof model[key] === 'object') output[key] = getModeledObject(obj[key], model[key]);else output[key] = obj[key];
-        } catch (e) {
-          warn('An error occurred while setting a property of a Configurable', e);
+      if (obj[key] === undefined) continue;
+      try {
+        if (obj[key] === null) {
+          output[key] = null;
+          continue;
         }
+        if (Array.isArray(obj[key]) && Array.isArray(model[key])) output[key] = Array.from(new Set([...obj[key], ...model[key]]));else if (typeof obj[key] === 'object' && typeof model[key] === 'object') output[key] = getModeledObject(obj[key], model[key]);else output[key] = obj[key];
+      } catch (e) {
+        warn('An error occurred while setting a property of a Configurable', e);
       }
     }
     return output;

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

@@ -54,8 +54,6 @@ const model = () => {
       allowed_origins: undefined
     },
     session: {
-      domain: undefined,
-      // used by first party cookies to set the top-level domain
       expiresMs: DEFAULT_EXPIRES_MS,
       inactiveMs: DEFAULT_INACTIVE_MS
     },

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

@@ -1,18 +1,19 @@
 import { getModeledObject } from './configurable';
 import { getNREUMInitializedAgent } from '../../window/nreum';
-import { globalScope } from '../../constants/runtime';
+import { globalScope, originTime } from '../../constants/runtime';
 import { BUILD_ENV, DIST_METHOD, VERSION } from "../../constants/env.npm";
-const model = {
+const readonly = {
   buildEnv: BUILD_ENV,
+  distMethod: DIST_METHOD,
+  version: VERSION,
+  originTime
+};
+const model = {
   customTransaction: undefined,
   disabled: false,
-  distMethod: 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?.performance?.timeOrigin || globalScope?.performance?.timing?.navigationStart || Date.now()),
   onerror: undefined,
   origin: '' + globalScope.location,
   ptid: undefined,
@@ -20,8 +21,6 @@ const model = {
   /** Agent-specific metadata found in the RUM call response. ex. entityGuid */
   appMetadata: {},
   session: undefined,
-  xhrWrappable: typeof globalScope.XMLHttpRequest?.prototype?.addEventListener === 'function',
-  version: VERSION,
   denyList: undefined,
   harvestCount: 0,
   timeKeeper: undefined
@@ -34,7 +33,10 @@ export function getRuntime(id) {
 }
 export function setRuntime(id, obj) {
   if (!id) throw new Error('All runtime objects require an agent identifier!');
-  _cache[id] = getModeledObject(obj, model);
+  _cache[id] = {
+    ...getModeledObject(obj, model),
+    ...readonly
+  };
   const agentInst = getNREUMInitializedAgent(id);
   if (agentInst) agentInst.runtime = _cache[id];
 }

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

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.257.0";
+export const VERSION = "1.258.1";
 
 /**
  * Exposes the build type of the agent

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

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.257.0";
+export const VERSION = "1.258.1";
 
 /**
  * Exposes the build type of the agent

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

@@ -38,4 +38,10 @@ export const ffVersion = (() => {
 export const isIE = Boolean(isBrowserScope && window.document.documentMode); // deprecated property that only works in IE
 
 export const supportsSendBeacon = !!globalScope.navigator?.sendBeacon;
-export const offset = Math.floor(Date.now() - performance.now());
+
+/**
+ * Represents the absolute timestamp in milliseconds that the page was loaded
+ * according to the browser's local clock.
+ * @type {number}
+ */
+export const originTime = Math.floor(Date.now() - performance.now());

package/dist/esm/common/deny-list/deny-list.js

@@ -10,14 +10,8 @@ var denyList = [];
  * @returns {boolean} `true` if request does not match any entries of {@link denyList|deny list}; else `false`
  */
 export function shouldCollectEvent(params) {
-  if (denyList.length === 0) {
-    return true;
-  }
-
-  // XHR requests with an undefined hostname (e.g., data URLs) should not be collected.
-  if (params.hostname === undefined) {
-    return false;
-  }
+  if (hasUndefinedHostname(params)) return false;
+  if (denyList.length === 0) return true;
   for (var i = 0; i < denyList.length; i++) {
     var parsed = denyList[i];
     if (parsed.hostname === '*') {
@@ -29,6 +23,9 @@ export function shouldCollectEvent(params) {
   }
   return true;
 }
+export function hasUndefinedHostname(params) {
+  return params.hostname === undefined; // requests with an undefined hostname (e.g., data URLs) should not be collected.
+}
 
 /**
  * Initializes the {@link denyList|XHR deny list} by extracting hostname and pathname from an array of filter strings.

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

@@ -3,6 +3,7 @@ export const DEFAULT_KEY = 'SESSION';
 export const DEFAULT_EXPIRES_MS = 14400000;
 export const DEFAULT_INACTIVE_MS = 1800000;
 export const SESSION_EVENTS = {
+  STARTED: 'session-started',
   PAUSE: 'session-pause',
   RESET: 'session-reset',
   RESUME: 'session-resume',

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

@@ -24,6 +24,8 @@ const model = {
   sessionReplaySentFirstChunk: false,
   sessionTraceMode: MODE.OFF,
   traceHarvestStarted: false,
+  serverTimeDiff: null,
+  // set by TimeKeeper; "undefined" value will not be stringified and stored but "null" will
   custom: {}
 };
 export class SessionEntity {
@@ -138,6 +140,7 @@ export class SessionEntity {
     // we can use a modeled object here to help us know and manage what values are being used. -- see "model" above
     if (this.isNew) this.write(getModeledObject(this.state, model), true);else this.sync(initialRead);
     this.initialized = true;
+    this.ee.emit(SESSION_EVENTS.STARTED, [this.isNew]);
   }
 
   // This is the actual key appended to the storage API

package/dist/esm/common/timing/time-keeper.js

@@ -1,3 +1,8 @@
+import { originTime } from '../constants/runtime';
+import { ee as baseEE } from '../event-emitter/contextual-ee';
+import { getRuntime } from '../config/config';
+import { SESSION_EVENT_TYPES, SESSION_EVENTS } from '../session/constants';
+
 /**
  * Class used to adjust the timestamp of harvested data to New Relic server time. This
  * is done by tracking the performance timings of the RUM call and applying a calculation
@@ -5,10 +10,10 @@
  */
 export class TimeKeeper {
   /**
-   * Represents the browser origin time.
-   * @type {number}
+   * Pointer to the current agent session if it exists.
+   * @type {import('../session/session-entity').SessionEntity}
    */
-  #originTime;
+  #session;
 
   /**
    * Represents the browser origin time corrected to NR server time.
@@ -29,15 +34,24 @@ export class TimeKeeper {
    * @type {number}
    */
   #ready = false;
-  constructor() {
-    this.#originTime = Date.now() - performance.now();
+  constructor(agentIdentifier) {
+    this.#session = getRuntime(agentIdentifier)?.session;
+    if (this.#session) {
+      const ee = baseEE.get(agentIdentifier);
+      ee.on(SESSION_EVENTS.UPDATE, this.#processSessionUpdate.bind(this));
+      ee.on(SESSION_EVENTS.STARTED, () => {
+        if (this.#ready) {
+          this.#session.write({
+            serverTimeDiff: this.#localTimeDiff
+          });
+        }
+      });
+      this.#processSessionUpdate(null, this.#session.read());
+    }
   }
   get ready() {
     return this.#ready;
   }
-  get originTime() {
-    return this.#originTime;
-  }
   get correctedOriginTime() {
     return this.#correctedOriginTime;
   }
@@ -49,6 +63,8 @@ export class TimeKeeper {
    * @param endTime {number} The end time of the RUM request
    */
   processRumRequest(rumRequest, startTime, endTime) {
+    if (this.#ready) return; // Server time calculated from session entity
+
     const responseDateHeader = rumRequest.getResponseHeader('Date');
     if (!responseDateHeader) {
       throw new Error('Missing date header on rum response.');
@@ -58,10 +74,13 @@ export class TimeKeeper {
 
     // Corrected page origin time
     this.#correctedOriginTime = Math.floor(Date.parse(responseDateHeader) - serverOffset);
-    this.#localTimeDiff = this.#originTime - this.#correctedOriginTime;
+    this.#localTimeDiff = originTime - this.#correctedOriginTime;
     if (Number.isNaN(this.#correctedOriginTime)) {
       throw new Error('Date header invalid format.');
     }
+    if (this.#session) this.#session.write({
+      serverTimeDiff: this.#localTimeDiff
+    });
     this.#ready = true;
   }
 
@@ -83,4 +102,22 @@ export class TimeKeeper {
   correctAbsoluteTimestamp(timestamp) {
     return Math.floor(timestamp - this.#localTimeDiff);
   }
+
+  /**
+   * Processes a session entity update payload to extract the server time calculated.
+   * @param {import('../session/constants').SESSION_EVENT_TYPES | null} type
+   * @param {Object} data
+   */
+  #processSessionUpdate(type, data) {
+    if (typeof data?.serverTimeDiff !== 'number') return;
+    if (!type && !this.#ready ||
+    // This captures the initial read from the session entity when the timekeeper first initializes
+    type === SESSION_EVENT_TYPES.CROSS_TAB // This captures any cross-tab write of the session entity
+    ) {
+      // This captures the initial read from the session entity when the timekeeper first initializes
+      this.#localTimeDiff = data.serverTimeDiff;
+      this.#correctedOriginTime = originTime - this.#localTimeDiff;
+      this.#ready = true;
+    }
+  }
 }