@newrelic/browser-agent 1.257.0 → 1.258.0

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.0";
 
 /**
  * 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/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;
+    }
+  }
 }

package/dist/esm/common/vitals/time-to-first-byte.js

@@ -1,4 +1,4 @@
-import { globalScope, isBrowserScope, isiOS, offset } from '../constants/runtime';
+import { globalScope, isBrowserScope, isiOS, originTime } from '../constants/runtime';
 import { VITAL_NAMES } from './constants';
 import { VitalMetric } from './vital-metric';
 import { onTTFB } from 'web-vitals/attribution';
@@ -21,7 +21,7 @@ if (isBrowserScope && typeof PerformanceNavigationTiming !== 'undefined' && !isi
   if (!timeToFirstByte.isValid) {
     const entry = {};
     // convert real timestamps to relative timestamps to match web-vitals behavior
-    for (let key in globalScope?.performance?.timing || {}) entry[key] = Math.max(globalScope?.performance?.timing[key] - offset, 0);
+    for (let key in globalScope?.performance?.timing || {}) entry[key] = Math.max(globalScope?.performance?.timing[key] - originTime, 0);
 
     // ttfb is equiv to document's responseStart property in timing API --> https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming/responseStart
     timeToFirstByte.update({

package/dist/esm/common/vitals/vital-metric.js

@@ -11,7 +11,7 @@ export class VitalMetric {
       value,
       attrs = {}
     } = _ref;
-    if (value < 0) return;
+    if (value === undefined || value === null || value < 0) return;
     const state = {
       value: this.roundingMethod(value),
       name: this.name,

package/dist/esm/features/ajax/aggregate/chunk.js

@@ -0,0 +1,43 @@
+import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer';
+import { getInfo } from '../../../common/config/config';
+export default class Chunk {
+  constructor(events, aggregateInstance) {
+    this.addString = getAddStringContext(aggregateInstance.agentIdentifier); // pass agentIdentifier here
+    this.events = events;
+    this.payload = 'bel.7;';
+    for (let i = 0; i < events.length; i++) {
+      const event = events[i];
+      const fields = [numeric(event.startTime), numeric(event.endTime - event.startTime), numeric(0),
+      // callbackEnd
+      numeric(0),
+      // no callbackDuration for non-SPA events
+      this.addString(event.method), numeric(event.status), this.addString(event.domain), this.addString(event.path), numeric(event.requestSize), numeric(event.responseSize), event.type === 'fetch' ? 1 : '', this.addString(0),
+      // nodeId
+      nullable(event.spanId, this.addString, true) +
+      // guid
+      nullable(event.traceId, this.addString, true) +
+      // traceId
+      nullable(event.spanTimestamp, numeric, false) // timestamp
+      ];
+      let insert = '2,';
+
+      // Since configuration objects (like info) are created new each time they are set, we have to grab the current pointer to the attr object here.
+      const jsAttributes = getInfo(aggregateInstance.agentIdentifier).jsAttributes;
+
+      // add custom attributes
+      // gql decorators are added as custom attributes to alleviate need for new BEL schema
+      const attrParts = addCustomAttributes({
+        ...(jsAttributes || {}),
+        ...(event.gql || {})
+      }, this.addString);
+      fields.unshift(numeric(attrParts.length));
+      insert += fields.join(',');
+      if (attrParts && attrParts.length > 0) {
+        insert += ';' + attrParts.join(';');
+      }
+      if (i + 1 < events.length) insert += ';';
+      this.payload += insert;
+    }
+    this.tooBig = this.payload.length * 2 > aggregateInstance.MAX_PAYLOAD_SIZE;
+  }
+}

package/dist/esm/features/ajax/aggregate/index.js

@@ -4,7 +4,6 @@
  */
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { stringify } from '../../../common/util/stringify';
-import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer';
 import { handle } from '../../../common/event-emitter/handle';
 import { getConfiguration, getInfo, getRuntime } from '../../../common/config/config';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
@@ -15,225 +14,165 @@ import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { parseGQL } from './gql';
 import { getNREUMInitializedAgent } from '../../../common/window/nreum';
+import Chunk from './chunk';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
+  #agentInfo;
+  #agentRuntime;
+  #agentInit;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME);
-    const agentInit = getConfiguration(agentIdentifier);
-    registerHandler('xhr', storeXhr, this.featureName, this.ee);
-    this.waitForFlags([]).then(() => {
-      const scheduler = new HarvestScheduler('events', {
-        onFinished: onEventsHarvestFinished,
-        getPayload: prepareHarvest
-      }, this);
-      scheduler.startTimer(harvestTimeSeconds);
-      this.drain();
-    });
-    const agentRuntime = getRuntime(agentIdentifier);
-    const denyList = agentRuntime.denyList;
-    setDenyList(denyList);
-    let ajaxEvents = [];
-    let spaAjaxEvents = {};
-    let sentAjaxEvents = [];
-    const ee = this.ee;
-    const harvestTimeSeconds = agentInit.ajax.harvestTimeSeconds || 10;
-    const MAX_PAYLOAD_SIZE = agentInit.ajax.maxPayloadSize || 1000000;
-
-    // Exposes these methods to browser test files -- future TO DO: can be removed once these fns are extracted from the constructor into class func
-    this.storeXhr = storeXhr;
-    this.prepareHarvest = prepareHarvest;
-    this.getStoredEvents = function () {
-      return {
-        ajaxEvents,
-        spaAjaxEvents
-      };
-    };
+    this.#agentInfo = getInfo(agentIdentifier);
+    this.#agentRuntime = getRuntime(agentIdentifier);
+    this.#agentInit = getConfiguration(agentIdentifier);
+    const harvestTimeSeconds = this.#agentInit.ajax.harvestTimeSeconds || 10;
+    this.MAX_PAYLOAD_SIZE = this.#agentInit.ajax.maxPayloadSize || 1000000;
+    setDenyList(this.#agentRuntime.denyList);
+    this.ajaxEvents = [];
+    this.spaAjaxEvents = {};
+    this.sentAjaxEvents = [];
+    const classThis = this;
 
     // --- v Used by old spa feature
-    ee.on('interactionDone', (interaction, wasSaved) => {
-      if (!spaAjaxEvents[interaction.id]) return;
+    this.ee.on('interactionDone', (interaction, wasSaved) => {
+      if (!this.spaAjaxEvents[interaction.id]) return;
       if (!wasSaved) {
         // if the ixn was saved, then its ajax reqs are part of the payload whereas if it was discarded, it should still be harvested in the ajax feature itself
-        spaAjaxEvents[interaction.id].forEach(function (item) {
-          ajaxEvents.push(item);
-        });
+        this.spaAjaxEvents[interaction.id].forEach(item => this.ajaxEvents.push(item));
       }
-      delete spaAjaxEvents[interaction.id];
+      delete this.spaAjaxEvents[interaction.id];
     });
     // --- ^
     // --- v Used by new soft nav
-    registerHandler('returnAjax', event => ajaxEvents.push(event), this.featureName, this.ee);
+    registerHandler('returnAjax', event => this.ajaxEvents.push(event), this.featureName, this.ee);
     // --- ^
+    registerHandler('xhr', function () {
+      // the EE-drain system not only switches "this" but also passes a new EventContext with info. Should consider platform refactor to another system which passes a mutable context around separately and predictably to avoid problems like this.
+      classThis.storeXhr(...arguments, this); // this switches the context back to the class instance while passing the NR context as an argument -- see "ctx" in storeXhr
+    }, this.featureName, this.ee);
+    this.waitForFlags([]).then(() => {
+      const scheduler = new HarvestScheduler('events', {
+        onFinished: this.onEventsHarvestFinished.bind(this),
+        getPayload: this.prepareHarvest.bind(this)
+      }, this);
+      scheduler.startTimer(harvestTimeSeconds);
+      this.drain();
+    });
+  }
+  storeXhr(params, metrics, startTime, endTime, type, ctx) {
+    metrics.time = startTime;
 
-    const beacon = getInfo(agentIdentifier).errorBeacon;
-    const proxyBeacon = agentInit.proxy.beacon;
-    function storeXhr(params, metrics, startTime, endTime, type) {
-      metrics.time = startTime;
+    // send to session traces
+    let hash;
+    if (params.cat) {
+      hash = stringify([params.status, params.cat]);
+    } else {
+      hash = stringify([params.status, params.host, params.pathname]);
+    }
+    const shouldCollect = shouldCollectEvent(params);
+    const shouldOmitAjaxMetrics = this.#agentInit.feature_flags?.includes('ajax_metrics_deny_list');
 
-      // send to session traces
-      var hash;
-      if (params.cat) {
-        hash = stringify([params.status, params.cat]);
+    // store for timeslice metric (harvested by jserrors feature)
+    if (shouldCollect || !shouldOmitAjaxMetrics) {
+      this.aggregator.store('xhr', hash, params, metrics);
+    }
+    if (!shouldCollect) {
+      if (params.hostname === this.#agentInfo.errorBeacon || this.#agentInit.proxy?.beacon && params.hostname === this.#agentInit.proxy.beacon) {
+        // This doesn't make a distinction if the same-domain request is going to a different port or path...
+        handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, this.ee);
+        if (shouldOmitAjaxMetrics) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, this.ee);
       } else {
-        hash = stringify([params.status, params.host, params.pathname]);
+        handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/App'], undefined, FEATURE_NAMES.metrics, this.ee);
+        if (shouldOmitAjaxMetrics) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/App'], undefined, FEATURE_NAMES.metrics, this.ee);
       }
-      const shouldCollect = shouldCollectEvent(params);
-      const ajaxMetricDenyListEnabled = agentInit.feature_flags?.includes('ajax_metrics_deny_list');
+      return; // do not send this ajax as an event
+    }
+    handle('bstXhrAgg', ['xhr', hash, params, metrics], undefined, FEATURE_NAMES.sessionTrace, this.ee); // have trace feature harvest AjaxNode
 
-      // store as metric
-      if (shouldCollect || !ajaxMetricDenyListEnabled) {
-        aggregator.store('xhr', hash, params, metrics);
-      }
-      if (!shouldCollect) {
-        if (params.hostname === beacon || proxyBeacon && params.hostname === proxyBeacon) {
-          // This doesn't make a distinction if the same-domain request is going to a different port or path...
-          handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, ee);
-          if (ajaxMetricDenyListEnabled) {
-            handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, ee);
-          }
-        } else {
-          handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/App'], undefined, FEATURE_NAMES.metrics, ee);
-          if (ajaxMetricDenyListEnabled) {
-            handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/App'], undefined, FEATURE_NAMES.metrics, ee);
-          }
-        }
-        return;
-      }
-      handle('bstXhrAgg', ['xhr', hash, params, metrics], undefined, FEATURE_NAMES.sessionTrace, ee);
-      var xhrContext = this;
-      var event = {
-        method: params.method,
-        status: params.status,
-        domain: params.host,
-        path: params.pathname,
-        requestSize: metrics.txSize,
-        responseSize: metrics.rxSize,
-        type,
-        startTime,
-        endTime,
-        callbackDuration: metrics.cbTime
-      };
-      if (xhrContext.dt) {
-        event.spanId = xhrContext.dt.spanId;
-        event.traceId = xhrContext.dt.traceId;
-        event.spanTimestamp = agentRuntime.timeKeeper.correctAbsoluteTimestamp(xhrContext.dt.timestamp);
-      }
+    const event = {
+      method: params.method,
+      status: params.status,
+      domain: params.host,
+      path: params.pathname,
+      requestSize: metrics.txSize,
+      responseSize: metrics.rxSize,
+      type,
+      startTime,
+      endTime,
+      callbackDuration: metrics.cbTime
+    };
+    if (ctx.dt) {
+      event.spanId = ctx.dt.spanId;
+      event.traceId = ctx.dt.traceId;
+      event.spanTimestamp = this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(ctx.dt.timestamp);
+    }
 
-      // parsed from the AJAX body, looking for operationName param & parsing query for operationType
-      event.gql = params.gql = parseGQL({
-        body: this.body,
-        query: this?.parsedOrigin?.search
-      });
-      if (event.gql) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/GraphQL/Bytes-Added', stringify(event.gql).length], undefined, FEATURE_NAMES.metrics, ee);
-      const softNavInUse = Boolean(getNREUMInitializedAgent(agentIdentifier)?.features?.[FEATURE_NAMES.softNav]);
-      if (softNavInUse) {
-        // For newer soft nav (when running), pass the event to it for evaluation -- either part of an interaction or is given back
-        handle('ajax', [event], undefined, FEATURE_NAMES.softNav, ee);
-      } else if (this.spaNode) {
-        // For old spa (when running), if the ajax happened inside an interaction, hold it until the interaction finishes
-        const interactionId = this.spaNode.interaction.id;
-        spaAjaxEvents[interactionId] = spaAjaxEvents[interactionId] || [];
-        spaAjaxEvents[interactionId].push(event);
-      } else {
-        ajaxEvents.push(event);
-      }
+    // parsed from the AJAX body, looking for operationName param & parsing query for operationType
+    event.gql = params.gql = parseGQL({
+      body: ctx.body,
+      query: ctx.parsedOrigin?.search
+    });
+    if (event.gql) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/GraphQL/Bytes-Added', stringify(event.gql).length], undefined, FEATURE_NAMES.metrics, this.ee);
+    const softNavInUse = Boolean(getNREUMInitializedAgent(this.agentIdentifier)?.features?.[FEATURE_NAMES.softNav]);
+    if (softNavInUse) {
+      // For newer soft nav (when running), pass the event to it for evaluation -- either part of an interaction or is given back
+      handle('ajax', [event], undefined, FEATURE_NAMES.softNav, this.ee);
+    } else if (ctx.spaNode) {
+      // For old spa (when running), if the ajax happened inside an interaction, hold it until the interaction finishes
+      const interactionId = ctx.spaNode.interaction.id;
+      this.spaAjaxEvents[interactionId] = this.spaAjaxEvents[interactionId] || [];
+      this.spaAjaxEvents[interactionId].push(event);
+    } else {
+      this.ajaxEvents.push(event);
     }
-    function prepareHarvest(options) {
-      options = options || {};
-      if (ajaxEvents.length === 0) {
-        return null;
-      }
-      var payload = getPayload(ajaxEvents, options.maxPayloadSize || MAX_PAYLOAD_SIZE);
-      var payloadObjs = [];
-      for (var i = 0; i < payload.length; i++) {
-        payloadObjs.push({
-          body: {
-            e: payload[i]
-          }
-        });
-      }
-      if (options.retry) {
-        sentAjaxEvents = ajaxEvents.slice();
+  }
+  prepareHarvest(options) {
+    options = options || {};
+    if (this.ajaxEvents.length === 0) return null;
+    const payload = this.#getPayload(this.ajaxEvents);
+    const payloadObjs = [];
+    for (let i = 0; i < payload.length; i++) payloadObjs.push({
+      body: {
+        e: payload[i]
       }
-      ajaxEvents = [];
-      return payloadObjs;
+    });
+    if (options.retry) this.sentAjaxEvents = this.ajaxEvents;
+    this.ajaxEvents = [];
+    return payloadObjs;
+  }
+  onEventsHarvestFinished(result) {
+    if (result.retry && this.sentAjaxEvents.length > 0) {
+      this.ajaxEvents.unshift(...this.sentAjaxEvents);
+      this.sentAjaxEvents = [];
     }
-    function getPayload(events, maxPayloadSize, chunks) {
-      chunks = chunks || 1;
-      var payload = [];
-      var chunkSize = events.length / chunks;
-      var eventChunks = splitChunks(events, chunkSize);
-      var tooBig = false;
-      for (var i = 0; i < eventChunks.length; i++) {
-        var currentChunk = eventChunks[i];
-        if (currentChunk.tooBig(maxPayloadSize)) {
-          if (currentChunk.events.length !== 1) {
-            /* if it is too big BUT it isnt length 1, we can split it down again,
-             else we just want to NOT push it into payload
-             because if it's length 1 and still too big for the maxPayloadSize
-             it cant get any smaller and we dont want to recurse forever */
-            tooBig = true;
-            break;
-          }
-        } else {
-          payload.push(currentChunk.payload);
+  }
+  #getPayload(events, numberOfChunks) {
+    numberOfChunks = numberOfChunks || 1;
+    const payload = [];
+    const chunkSize = events.length / numberOfChunks;
+    const eventChunks = splitChunks.call(this, events, chunkSize);
+    let tooBig = false;
+    for (let i = 0; i < eventChunks.length; i++) {
+      const currentChunk = eventChunks[i];
+      if (currentChunk.tooBig) {
+        if (currentChunk.events.length > 1) {
+          tooBig = true;
+          break; // if the payload is too big BUT is made of more than 1 event, we can split it down again
         }
-      }
-      // check if the current payload string is too big, if so then run getPayload again with more buckets
-      return tooBig ? getPayload(events, maxPayloadSize, ++chunks) : payload;
-    }
-    function onEventsHarvestFinished(result) {
-      if (result.retry && sentAjaxEvents.length > 0) {
-        ajaxEvents.unshift(...sentAjaxEvents);
-        sentAjaxEvents = [];
+        // Otherwise, if it consists of one sole event, we do not send it (discarded) since we cannot break it apart any further.
+      } else {
+        payload.push(currentChunk.payload);
       }
     }
+    // Check if the current payload string is too big, if so then run getPayload again with more buckets.
+    return tooBig ? this.#getPayload(events, ++numberOfChunks) : payload;
     function splitChunks(arr, chunkSize) {
       chunkSize = chunkSize || arr.length;
-      var chunks = [];
-      for (var i = 0, len = arr.length; i < len; i += chunkSize) {
-        chunks.push(new Chunk(arr.slice(i, i + chunkSize)));
+      const chunks = [];
+      for (let i = 0, len = arr.length; i < len; i += chunkSize) {
+        chunks.push(new Chunk(arr.slice(i, i + chunkSize), this));
       }
       return chunks;
     }
-    function Chunk(events) {
-      this.addString = getAddStringContext(agentIdentifier); // pass agentIdentifier here
-      this.events = events;
-      this.payload = 'bel.7;';
-      for (var i = 0; i < events.length; i++) {
-        var event = events[i];
-        var fields = [numeric(event.startTime), numeric(event.endTime - event.startTime), numeric(0),
-        // callbackEnd
-        numeric(0),
-        // no callbackDuration for non-SPA events
-        this.addString(event.method), numeric(event.status), this.addString(event.domain), this.addString(event.path), numeric(event.requestSize), numeric(event.responseSize), event.type === 'fetch' ? 1 : '', this.addString(0),
-        // nodeId
-        nullable(event.spanId, this.addString, true) +
-        // guid
-        nullable(event.traceId, this.addString, true) +
-        // traceId
-        nullable(event.spanTimestamp, numeric, false) // timestamp
-        ];
-        var insert = '2,';
-
-        // add custom attributes
-        // gql decorators are added as custom attributes to alleviate need for new BEL schema
-        var attrParts = addCustomAttributes({
-          ...(getInfo(agentIdentifier).jsAttributes || {}),
-          ...(event.gql || {})
-        }, this.addString);
-        fields.unshift(numeric(attrParts.length));
-        insert += fields.join(',');
-        if (attrParts && attrParts.length > 0) {
-          insert += ';' + attrParts.join(';');
-        }
-        if (i + 1 < events.length) insert += ';';
-        this.payload += insert;
-      }
-      this.tooBig = function (maxPayloadSize) {
-        maxPayloadSize = maxPayloadSize || MAX_PAYLOAD_SIZE;
-        return this.payload.length * 2 > maxPayloadSize;
-      };
-    }
   }
 }

package/dist/esm/features/ajax/instrument/index.js

@@ -2,7 +2,7 @@
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { originals, getLoaderConfig, getRuntime } from '../../../common/config/config';
+import { originals, getLoaderConfig } from '../../../common/config/config';
 import { handle } from '../../../common/event-emitter/handle';
 import { id } from '../../../common/ids/id';
 import { ffVersion, globalScope, isBrowserScope } from '../../../common/constants/runtime';
@@ -26,9 +26,6 @@ export class Instrument extends InstrumentBase {
   constructor(agentIdentifier, aggregator) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
-
-    // Very unlikely, but in case the existing XMLHttpRequest.prototype object on the page couldn't be wrapped.
-    if (!getRuntime(agentIdentifier).xhrWrappable) return;
     this.dt = new DT(agentIdentifier);
     this.handler = (type, args, ctx, group) => handle(type, args, ctx, group, this.ee);
 

package/dist/esm/features/jserrors/aggregate/index.js

@@ -186,7 +186,7 @@ export class Aggregate extends AggregateBase {
       this.pageviewReported[bucketHash] = true;
     }
     params.firstOccurrenceTimestamp = this.observedAt[bucketHash];
-    params.timestamp = this.observedAt[bucketHash];
+    params.timestamp = agentRuntime.timeKeeper.convertRelativeTimestamp(time);
     var type = internal ? 'ierr' : 'err';
     var newMetrics = {
       time

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

@@ -1,4 +1,4 @@
-import { globalScope, isBrowserScope } from '../../../common/constants/runtime';
+import { globalScope, isBrowserScope, originTime } from '../../../common/constants/runtime';
 import { addPT, addPN } from '../../../common/timing/nav-timing';
 import { stringify } from '../../../common/util/stringify';
 import { getInfo, getRuntime } from '../../../common/config/config';
@@ -95,14 +95,14 @@ export class Aggregate extends AggregateBase {
         // Navigation Timing level 2 API that replaced PerformanceTiming & PerformanceNavigation
         const navTimingEntry = globalScope?.performance?.getEntriesByType('navigation')?.[0];
         const perf = {
-          timing: addPT(agentRuntime.offset, navTimingEntry, {}),
+          timing: addPT(originTime, navTimingEntry, {}),
           navigation: addPN(navTimingEntry, {})
         };
         queryParameters.perf = stringify(perf);
       } else if (typeof PerformanceTiming !== 'undefined') {
         // Safari pre-15 did not support level 2 timing
         const perf = {
-          timing: addPT(agentRuntime.offset, globalScope.performance.timing, {}, true),
+          timing: addPT(originTime, globalScope.performance.timing, {}, true),
           navigation: addPN(globalScope.performance.navigation, {})
         };
         queryParameters.perf = stringify(perf);
@@ -134,7 +134,7 @@ export class Aggregate extends AggregateBase {
           return;
         }
         try {
-          const timeKeeper = new TimeKeeper();
+          const timeKeeper = new TimeKeeper(this.agentIdentifier);
           timeKeeper.processRumRequest(xhr, rumStartTime, rumEndTime);
           if (!timeKeeper.ready) throw new Error('TimeKeeper not ready');
           agentRuntime.timeKeeper = timeKeeper;