@newrelic/browser-agent 1.258.2 → 1.260.0

package/dist/types/features/session_trace/aggregate/index.d.ts

@@ -1,61 +1,48 @@
 export class Aggregate extends AggregateBase {
     static featureName: string;
-    constructor(agentIdentifier: any, aggregator: any, argsObj: any);
+    constructor(agentIdentifier: any, aggregator: any);
     agentRuntime: any;
-    resourceObserver: any;
-    ptid: string;
-    trace: {};
-    nodeCount: number;
-    sentTrace: {} | null;
-    prevStoredEvents: Set<any>;
+    agentInfo: any;
+    /** A buffer to hold on to harvested traces in the case that a retry must be made later */
+    sentTrace: any[] | null | undefined;
     harvestTimeSeconds: any;
-    maxNodesPerHarvest: any;
-    /**
-     * Standalone (mode) refers to the legacy version of ST before the idea of 'session' or the Replay feature existed.
-     * It has some different behavior vs when used in tandem with replay. */
-    isStandalone: boolean;
-    operationalGate: HandlerCache;
-    startTracing(startupBuffer: any, dontStartHarvestYet?: boolean): void;
-    processPVT(name: any, value: any, attrs: any): void;
-    storeTiming(timingEntry: any): void;
-    storeEvent(currentEvent: any, target: any, start: any, end: any): void;
-    shouldIgnoreEvent(event: any, target: any): boolean;
-    evtName(type: any): any;
-    evtOrigin(t: any, target: any): string;
-    storeHist(path: any, old: any, time: any): void;
-    storeResources(resources: any): void;
-    storeErrorAgg(type: any, name: any, params: any, metrics: any): void;
-    storeXhrAgg(type: any, name: any, params: any, metrics: any): void;
-    storeSTN(stn: any): void;
-    /**
-     * Trim the collection of nodes awaiting harvest such that those seen outside a certain span of time are discarded.
-     * @param {number} lookbackDuration Past length of time until now for which we care about nodes, in milliseconds
-     * @returns {number} However many nodes were discarded after trimming.
-     */
-    trimSTNs(lookbackDuration: number): number;
-    takeSTNs(retry: any): {
-        qs?: undefined;
-        body?: undefined;
-    } | {
+    /** Tied to the entitlement flag response from BCS.  Will short circuit operations of the agg if false  */
+    entitled: any;
+    /** A flag used to decide if the 30 node threshold should be ignored on the first harvest to ensure sending on the first payload */
+    everHarvested: boolean;
+    /** If the harvest module is harvesting */
+    harvesting: boolean;
+    /** TraceStorage is the mechanism that holds, normalizes and aggregates ST nodes.  It will be accessed and purged when harvests occur */
+    traceStorage: TraceStorage;
+    /** Sets up event listeners, and initializes this module to run in the correct "mode".  Can be triggered from a few places, but makes an effort to only set up listeners once */
+    initialize(stMode: any, stEntitled: any, ignoreSession: any): void;
+    mode: any;
+    initialized: boolean | undefined;
+    scheduler: HarvestScheduler | undefined;
+    /** This module does not auto harvest by default -- it needs to be kicked off.  Once this method is called, it will then harvest on an interval */
+    startHarvesting(): void;
+    /** Called by the harvest scheduler at harvest time to retrieve the payload.  This will only actually return a payload if running in full mode */
+    prepareHarvest(options?: {}): {
         qs: {
-            fsh?: number | undefined;
-            st: number;
-            /** 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;
-            /** 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: number;
-            /** 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: number;
-        };
-        body: {
-            res: any[];
+            browser_monitoring_key: any;
+            type: string;
+            app_id: any;
+            protocol_version: string;
+            timestamp: any;
+            attributes: string;
         };
-    };
-    smearEvtsByOrigin(name: any): (byOrigin: any, evtNode: any) => any;
-    #private;
+        body: any[] | undefined;
+    } | undefined;
+    /** When the harvest scheduler finishes, this callback is executed. It's main purpose is to determine if the payload needs to be retried
+     * and if so, it will take all data from the temporary buffer and place it back into the traceStorage module
+     */
+    onHarvestFinished(result: any): void;
+    /** Switch from "off" or "error" to full mode (if entitled) */
+    switchToFull(): void;
+    /** Stop running for the remainder of the page lifecycle */
+    abort(): void;
 }
 import { AggregateBase } from '../../utils/aggregate-base';
-import { HandlerCache } from '../../utils/handler-cache';
+import { TraceStorage } from './trace/storage';
+import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/features/session_trace/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_trace/aggregate/index.js"],"names":[],"mappings":"AAkCA;IACE,2BAAiC;IAGjC,iEAyIC;IAvIC,kBAA+C;IAC/C,sBAAiD;IACjD,aAAc;IACd,UAAe;IACf,kBAAkB;IAClB,qBAAqB;IACrB,2BAAiC;IACjC,wBAA0G;IAC1G,wBAA4G;IAC5G;;4EAEwE;IACxE,sBAAyB;IAGzB,8BAAsC;IA0HxC,sEAcC;IA8CD,oDAOC;IAGD,oCAwBC;IAGD,uEAoBC;IAED,oDAKC;IAED,wBAwBC;IAED,uCAuBC;IAGD,gDASC;IAID,qCAkBC;IAGD,qEAUC;IAGD,mEAUC;IAGD,yBAeC;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAsBlB;IAGD;;;;;;;YAkCM;0GAC8F;;YAE9F;0FAC8E;;YAE9E,4IAA4I;;;;;;MAMjJ;IAED,mEA6BC;;CACF;8BA/gB6B,4BAA4B;6BAF7B,2BAA2B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_trace/aggregate/index.js"],"names":[],"mappings":"AAcA;IACE,2BAAiC;IAEjC,mDAmBC;IAjBC,kBAA+C;IAC/C,eAAyC;IAEzC,0FAA0F;IAC1F,oCAAqB;IACrB,wBAA0G;IAC1G,0GAA0G;IAC1G,cAAyB;IACzB,mIAAmI;IACnI,uBAA0B;IAC1B,0CAA0C;IAC1C,oBAAuB;IACvB,wIAAwI;IACxI,2BAA0C;IAM5C,gLAAgL;IAChL,mEA6DC;IA1CyD,UAA4D;IAGpH,iCAAuB;IAOvB,wCAKQ;IA6BV,kJAAkJ;IAClJ,wBAIC;IAED,iJAAiJ;IACjJ;;;;;;;;;;kBA4DC;IAED;;OAEG;IACH,qCAKC;IAED,8DAA8D;IAC9D,qBAUC;IAED,2DAA2D;IAC3D,cAKC;CACF;8BAtM6B,4BAA4B;6BAC7B,iBAAiB;iCAJb,2CAA2C"}

package/dist/types/features/session_trace/aggregate/trace/node.d.ts

@@ -0,0 +1,12 @@
+/**
+ * All nodes reported to the consumer must take this shape
+ */
+export class TraceNode {
+    constructor(name: any, start: any, end: any, origin: any, type: any);
+    n: any;
+    s: any;
+    e: any;
+    o: any;
+    t: any;
+}
+//# sourceMappingURL=node.d.ts.map

package/dist/types/features/session_trace/aggregate/trace/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../../../../src/features/session_trace/aggregate/trace/node.js"],"names":[],"mappings":"AAAA;;GAEG;AACH;IACE,qEAMC;IALC,OAAa;IACb,OAAc;IACd,OAAY;IACZ,OAAe;IACf,OAAa;CAEhB"}

package/dist/types/features/session_trace/aggregate/trace/storage.d.ts

@@ -0,0 +1,43 @@
+/** The purpose of this class is to manage, normalize, and retrieve ST nodes as needed without polluting the main ST modules */
+export class TraceStorage {
+    constructor(parent: any);
+    nodeCount: number;
+    trace: {};
+    earliestTimeStamp: number;
+    latestTimeStamp: number;
+    tempStorage: any[];
+    prevStoredEvents: Set<any>;
+    parent: any;
+    /** Central function called by all the other store__ & addToTrace API to append a trace node. */
+    storeSTN(stn: any): void;
+    /**
+     * Trim the collection of nodes awaiting harvest such that those seen outside a certain span of time are discarded.
+     * @param {number} lookbackDuration Past length of time until now for which we care about nodes, in milliseconds
+     * @returns {number} However many nodes were discarded after trimming.
+     */
+    trimSTNs(lookbackDuration: number): number;
+    /** Used by session trace's harvester to create the payload body. */
+    takeSTNs(): {
+        stns?: undefined;
+        earliestTimeStamp?: undefined;
+        latestTimeStamp?: undefined;
+    } | {
+        stns: any[];
+        earliestTimeStamp: number;
+        latestTimeStamp: number;
+    };
+    smearEvtsByOrigin(name: any): (byOrigin: any, evtNode: any) => any;
+    processPVT(name: any, value: any, attrs: any): void;
+    storeTiming(timingEntry: any): void;
+    storeEvent(currentEvent: any, target: any, start: any, end: any): void;
+    shouldIgnoreEvent(event: any, target: any): boolean;
+    evtName(type: any): any;
+    evtOrigin(t: any, target: any): string;
+    storeHist(path: any, old: any, time: any): void;
+    storeResources(resources: any): void;
+    storeErrorAgg(type: any, name: any, params: any, metrics: any): void;
+    storeXhrAgg(type: any, name: any, params: any, metrics: any): void;
+    restoreNode(name: any, listOfSTNodes: any): void;
+    #private;
+}
+//# sourceMappingURL=storage.d.ts.map

package/dist/types/features/session_trace/aggregate/trace/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../../../../src/features/session_trace/aggregate/trace/storage.js"],"names":[],"mappings":"AAyBA,+HAA+H;AAC/H;IAQE,yBAEC;IATD,kBAAa;IACb,UAAU;IACV,0BAA4B;IAC5B,wBAAmB;IACnB,mBAAgB;IAChB,2BAA4B;IAG1B,YAAoB;IAGtB,gGAAgG;IAChG,yBAiBC;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAsBlB;IAED,oEAAoE;IACpE;;;;;;;;MAsBC;IAED,mEA6BC;IAED,oDAOC;IAED,oCAkBC;IAGD,uEAcC;IAED,oDAKC;IAED,wBAwBC;IAED,uCAuBC;IAGD,gDAEC;IAID,qCAaC;IAGD,qEAGC;IAGD,mEAIC;IAED,iDAKC;;CACF"}

package/dist/types/features/session_trace/constants.d.ts

@@ -6,4 +6,5 @@ export const END: "-end";
 export const FN_START: string;
 export const FN_END: string;
 export const PUSH_STATE: "pushState";
+export const MAX_NODES_PER_HARVEST: 1000;
 //# sourceMappingURL=constants.d.ts.map

package/dist/types/features/session_trace/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/session_trace/constants.js"],"names":[],"mappings":"AAEA,kCAAsD;AACtD,yCAAyC;AACzC,kCAAkC;AAClC,6BAA6B;AAC7B,yBAAyB;AACzB,8BAAoC;AACpC,4BAAgC;AAChC,qCAAqC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/session_trace/constants.js"],"names":[],"mappings":"AAEA,kCAAsD;AACtD,yCAAyC;AACzC,kCAAkC;AAClC,6BAA6B;AAC7B,yBAAyB;AACzB,8BAAoC;AACpC,4BAAgC;AAChC,qCAAqC;AACrC,yCAAyC"}

package/dist/types/features/session_trace/instrument/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_trace/instrument/index.js"],"names":[],"mappings":"AAgBA;IACE,2BAAiC;IACjC,mEAsCC;IAhCC,6BAA4C;CAiC/C;+BAnD8B,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_trace/instrument/index.js"],"names":[],"mappings":"AAiBA;IACE,2BAAiC;IACjC,mEA0CC;IAhCC,6BAA4C;CAiC/C;+BAxD8B,6BAA6B"}

package/dist/types/features/utils/aggregate-base.d.ts

@@ -7,6 +7,7 @@ export class AggregateBase extends FeatureBase {
      */
     waitForFlags(flagNames?: string[]): Promise<any>;
     drain(): void;
+    drained: boolean | undefined;
     /**
      * Checks for additional `jsAttributes` items to support backward compatibility with implementations of the agent where
      * loader configurations may appear after the loader code is executed.

package/dist/types/features/utils/aggregate-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aggregate-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/aggregate-base.js"],"names":[],"mappings":"AAOA;IACE,4BAGC;IAED;;;;OAIG;IACH,yBAHW,MAAM,EAAE,gBAmBlB;IAED,cAEC;IAED;;;OAGG;IACH,2BAqBC;CACF;4BAlE2B,gBAAgB"}
+{"version":3,"file":"aggregate-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/aggregate-base.js"],"names":[],"mappings":"AAOA;IACE,4BAGC;IAED;;;;OAIG;IACH,yBAHW,MAAM,EAAE,gBAmBlB;IAED,cAGC;IADC,6BAAmB;IAGrB;;;OAGG;IACH,2BAqBC;CACF;4BAnE2B,gBAAgB"}

package/dist/types/features/utils/feature-gates.d.ts

@@ -0,0 +1,2 @@
+export function canEnableSessionTracking(agentId: string): boolean;
+//# sourceMappingURL=feature-gates.d.ts.map

package/dist/types/features/utils/feature-gates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-gates.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/feature-gates.js"],"names":[],"mappings":"AAQO,kDAHI,MAAM,GACJ,OAAO,CAInB"}

package/dist/types/features/utils/instrument-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instrument-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/instrument-base.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH;IACE;;;;;;;;OAQG;IACH,6BAPW,MAAM,cACN,OAAO,mCAAmC,EAAE,UAAU,eACtD,MAAM,8BAqChB;IA9BC,cAAgB;IAEhB,8IAA8I;IAC9I,cADW,WAAW,SAAS,CACF;IAE7B;;;MAGE;IACF,eAHU,OAAO,kBAAkB,EAAE,aAAa,CAGpB;IAE9B;;;MAGE;IACF,kCAAoC;IAiBtC;;;;;OAKG;IACH,mEAgDC;;CAYF;4BA3H2B,gBAAgB"}
+{"version":3,"file":"instrument-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/instrument-base.js"],"names":[],"mappings":"AAiBA;;;GAGG;AACH;IACE;;;;;;;;OAQG;IACH,6BAPW,MAAM,cACN,OAAO,mCAAmC,EAAE,UAAU,eACtD,MAAM,8BAqChB;IA9BC,cAAgB;IAEhB,8IAA8I;IAC9I,cADW,WAAW,SAAS,CACF;IAE7B;;;MAGE;IACF,eAHU,OAAO,kBAAkB,EAAE,aAAa,CAGpB;IAE9B;;;MAGE;IACF,kCAAoC;IAiBtC;;;;;OAKG;IACH,mEAgDC;;CAYF;4BA5H2B,gBAAgB"}

package/dist/types/loaders/agent-base.d.ts

@@ -4,6 +4,7 @@
 export class AgentBase {
     constructor(agentIdentifier?: string);
     agentIdentifier: string;
+    ee: any;
     /**
      * Reports a browser PageAction event along with a name and optional attributes.
      * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/addpageaction/}

package/dist/types/loaders/agent-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-base.d.ts","sourceRoot":"","sources":["../../../src/loaders/agent-base.js"],"names":[],"mappings":"AAMA;;GAEG;AAEH;IAGE,sCAEC;IAJD,wBAAe;IAgBf;;;;;OAKG;IACH,oBAHW,MAAM,wCAKhB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,kCAKhB;IAED;;;;;;OAMG;IACH,yBAJW,MAAM,SACN,MAAM,GAAC,MAAM,GAAC,IAAI,sCAK5B;IAED;;;;;OAKG;IACH,mBAHW,KAAK,GAAC,MAAM,8CAKtB;IAED;;;;OAIG;IACH,iBAFW,MAAM,GAAC,IAAI,OAIrB;IAED;;;;;;;OAOG;IACH,6BAJW,MAAM,GAAC,IAAI,OAMrB;IAED;;;;OAIG;IACH,kCAFmB,KAAK,GAAC,MAAM,KAAK,OAAO,GAAG;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,OAI9D;IAED;;;;OAIG;IACH,8CAEC;IAED;;;;;OAKG;IACH,iBAHW,MAAM,MACN,MAAM,OAIhB;IAED;;;;OAIG;IACH,yDAEC;IAED;;;;OAIG;IACH,oBAEC;IAED;;;;;OAKG;IACH,mBAEC;IAED;;;;;;;;;;OAUG;IACH,6BARW;QAAC,MAAM,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,OAUrF;IAED;;;;;OAKG;IACH,0BAHW,MAAM,OAKhB;IAED;;;;;MAKE;IACF,eAHa,mBAAmB,CAK/B;;CACF;kCA5KY,OAAO,yBAAyB,EAAE,mBAAmB"}
+{"version":3,"file":"agent-base.d.ts","sourceRoot":"","sources":["../../../src/loaders/agent-base.js"],"names":[],"mappings":"AAOA;;GAEG;AAEH;IAGE,sCAKC;IAPD,wBAAe;IAMb,QAAiC;IAanC;;;;;OAKG;IACH,oBAHW,MAAM,wCAKhB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,kCAKhB;IAED;;;;;;OAMG;IACH,yBAJW,MAAM,SACN,MAAM,GAAC,MAAM,GAAC,IAAI,sCAK5B;IAED;;;;;OAKG;IACH,mBAHW,KAAK,GAAC,MAAM,8CAKtB;IAED;;;;OAIG;IACH,iBAFW,MAAM,GAAC,IAAI,OAIrB;IAED;;;;;;;OAOG;IACH,6BAJW,MAAM,GAAC,IAAI,OAMrB;IAED;;;;OAIG;IACH,kCAFmB,KAAK,GAAC,MAAM,KAAK,OAAO,GAAG;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,OAI9D;IAED;;;;OAIG;IACH,8CAEC;IAED;;;;;OAKG;IACH,iBAHW,MAAM,MACN,MAAM,OAIhB;IAED;;;;OAIG;IACH,yDAEC;IAED;;;;OAIG;IACH,oBAEC;IAED;;;;;OAKG;IACH,mBAEC;IAED;;;;;;;;;;OAUG;IACH,6BARW;QAAC,MAAM,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,OAUrF;IAED;;;;;OAKG;IACH,0BAHW,MAAM,OAKhB;IAED;;;;;MAKE;IACF,eAHa,mBAAmB,CAK/B;;CACF;kCA/KY,OAAO,yBAAyB,EAAE,mBAAmB"}

package/dist/types/loaders/configure/configure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../../../../src/loaders/configure/configure.js"],"names":[],"mappings":"AASA;;GAEG;AACH,oGA+CC"}
+{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../../../../src/loaders/configure/configure.js"],"names":[],"mappings":"AASA;;GAEG;AACH,oGAgDC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.258.2",
+  "version": "1.260.0",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",

package/src/cdn/polyfills.js

@@ -10,6 +10,7 @@ import 'core-js/stable/array/flat'
 import 'core-js/stable/array/flat-map'
 import 'core-js/stable/array/from'
 import 'core-js/stable/array/some'
+import 'core-js/stable/array/find-index'
 import 'core-js/stable/object/assign'
 import 'core-js/stable/object/entries'
 import 'core-js/stable/object/values'
@@ -23,3 +24,4 @@ import 'core-js/stable/url'
 import 'core-js/stable/url-search-params'
 import 'core-js/stable/string/starts-with'
 import 'core-js/stable/number/is-nan'
+import 'core-js/stable/string/includes'

package/src/common/drain/drain.js

@@ -71,7 +71,7 @@ export function drain (agentIdentifier = '', featureName = 'feature', force = fa
 function checkCanDrainAll (agentIdentifier) {
 // Only when the event-groups for all features are ready to drain (staged) do we execute the drain. This has the effect
   // that the last feature to call drain triggers drain for all features.
-  const items = [...registry[agentIdentifier]]
+  const items = Array.from(registry[agentIdentifier])
   if (items.every(([key, values]) => values.staged)) {
     items.sort((a, b) => a[1].priority - b[1].priority)
     items.forEach(([group]) => {

package/src/common/harvest/harvest-scheduler.js

@@ -31,7 +31,7 @@ export class HarvestScheduler extends SharedContext {
     this.started = false
     this.timeoutHandle = null
     this.aborted = false // this controls the per-interval and final harvests for the scheduler (currently per feature specific!)
-
+    this.harvesting = false
     this.harvest = new Harvest(this.sharedContext)
 
     // unload if EOL mechanism fires
@@ -82,12 +82,14 @@ export class HarvestScheduler extends SharedContext {
 
   runHarvest (opts) {
     if (this.aborted) return
+    this.harvesting = true
 
     /**
      * This is executed immediately after harvest sends the data via XHR, or if there's nothing to send. Note that this excludes on unloading / sendBeacon.
      * @param {Object} result
      */
     const cbRanAfterSend = (result) => {
+      this.harvesting = false
       if (opts?.forceNoRetry) result.retry = false // discard unsent data rather than re-queuing for next harvest attempt
       this.onHarvestFinished(opts, result)
     }
@@ -102,7 +104,7 @@ export class HarvestScheduler extends SharedContext {
       if (!submitMethod) return false
 
       const retry = !opts?.unload && submitMethod === submitData.xhr
-      payload = this.opts.getPayload({ retry, opts })
+      payload = this.opts.getPayload({ retry, ...opts })
 
       if (!payload) {
         if (this.started) {

package/src/common/session/session-entity.js

@@ -64,8 +64,10 @@ export class SessionEntity {
   }
 
   setup ({ value = generateRandomHexString(16), expiresMs = DEFAULT_EXPIRES_MS, inactiveMs = DEFAULT_INACTIVE_MS }) {
+    /** Ensure that certain properties are preserved across a reset if already set */
+    const persistentAttributes = { serverTimeDiff: this.state.serverTimeDiff || model.serverTimeDiff }
     this.state = {}
-    this.sync(model)
+    this.sync({ ...model, ...persistentAttributes })
 
     // value is intended to act as the primary value of the k=v pair
     this.state.value = value

package/src/common/timing/time-keeper.js

@@ -1,7 +1,5 @@
 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
@@ -37,17 +35,7 @@ export class TimeKeeper {
 
   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())
-    }
+    this.processStoredDiff()
   }
 
   get ready () {
@@ -65,8 +53,8 @@ export class TimeKeeper {
    * @param endTime {number} The end time of the RUM request
    */
   processRumRequest (rumRequest, startTime, endTime) {
+    this.processStoredDiff()
     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.')
@@ -79,11 +67,11 @@ export class TimeKeeper {
     this.#correctedOriginTime = Math.floor(Date.parse(responseDateHeader) - serverOffset)
     this.#localTimeDiff = originTime - this.#correctedOriginTime
 
-    if (Number.isNaN(this.#correctedOriginTime)) {
+    if (isNaN(this.#correctedOriginTime)) {
       throw new Error('Date header invalid format.')
     }
 
-    if (this.#session) this.#session.write({ serverTimeDiff: this.#localTimeDiff })
+    this.#session?.write({ serverTimeDiff: this.#localTimeDiff })
     this.#ready = true
   }
 
@@ -106,20 +94,11 @@ export class TimeKeeper {
     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
+  /** Process the session entity and use the info to set the main time calculations if present */
+  processStoredDiff () {
+    const storedServerTimeDiff = this.#session?.read()?.serverTimeDiff
+    if (typeof storedServerTimeDiff === 'number' && !isNaN(storedServerTimeDiff)) {
+      this.#localTimeDiff = storedServerTimeDiff
       this.#correctedOriginTime = originTime - this.#localTimeDiff
       this.#ready = true
     }

package/src/features/ajax/constants.js

@@ -1,3 +1,5 @@
 import { FEATURE_NAMES } from '../../loaders/features/features'
 
 export const FEATURE_NAME = FEATURE_NAMES.ajax
+
+export const MAX_PAYLOAD_SIZE = 1000000

package/src/features/jserrors/instrument/index.js

@@ -6,7 +6,6 @@
 import { handle } from '../../../common/event-emitter/handle'
 import { InstrumentBase } from '../../utils/instrument-base'
 import { FEATURE_NAME } from '../constants'
-import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { globalScope } from '../../../common/constants/runtime'
 import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts'
 import { now } from '../../../common/timing/now'
@@ -28,7 +27,7 @@ export class Instrument extends InstrumentBase {
 
     this.ee.on('internal-error', (error) => {
       if (!this.abortHandler) return
-      handle('ierr', [castError(error), now(), true, {}, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee)
+      handle('ierr', [castError(error), now(), true, {}, this.#replayRunning], undefined, this.featureName, this.ee)
     })
 
     this.ee.on(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, (isRunning) => {
@@ -37,12 +36,12 @@ export class Instrument extends InstrumentBase {
 
     globalScope.addEventListener('unhandledrejection', (promiseRejectionEvent) => {
       if (!this.abortHandler) return
-      handle('err', [castPromiseRejectionEvent(promiseRejectionEvent), now(), false, { unhandledPromiseRejection: 1 }, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee)
+      handle('err', [castPromiseRejectionEvent(promiseRejectionEvent), now(), false, { unhandledPromiseRejection: 1 }, this.#replayRunning], undefined, this.featureName, this.ee)
     }, eventListenerOpts(false, this.removeOnAbort?.signal))
 
     globalScope.addEventListener('error', (errorEvent) => {
       if (!this.abortHandler) return
-      handle('err', [castErrorEvent(errorEvent), now(), false, {}, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee)
+      handle('err', [castErrorEvent(errorEvent), now(), false, {}, this.#replayRunning], undefined, this.featureName, this.ee)
     }, eventListenerOpts(false, this.removeOnAbort?.signal))
 
     this.abortHandler = this.#abort // we also use this as a flag to denote that the feature is active or on and handling errors

package/src/features/metrics/aggregate/index.js

@@ -112,8 +112,6 @@ export class Aggregate extends AggregateBase {
       if (this.resourcesSent) return
       this.resourcesSent = true // make sure this only gets sent once
 
-      const agentRuntime = getRuntime(this.agentIdentifier)
-
       // Capture SMs around network resources using the performance API to assess
       // work to split this out from the ST nodes
       // differentiate between internal+external and ajax+non-ajax
@@ -132,12 +130,6 @@ export class Aggregate extends AggregateBase {
         }
       })
 
-      // Capture SMs for session trace if active (`ptid` is set when returned by replay ingest).
-      // Retain these SMs while we are working through the session_replay feature
-      if (agentRuntime.ptid) {
-        this.storeSupportabilityMetrics('PageSession/Feature/SessionTrace/DurationMs', Math.round(performance.now()))
-      }
-
       // Capture SMs for performance markers and measures to assess the usage and possible inclusion of this
       // data in the agent for use in NR
       if (typeof performance !== 'undefined') {

package/src/features/page_view_event/aggregate/index.js

@@ -26,6 +26,7 @@ export class Aggregate extends AggregateBase {
     this.timeToFirstByte = 0
     this.firstByteToWindowLoad = 0 // our "frontend" duration
     this.firstByteToDomContent = 0 // our "dom processing" duration
+    this.timeKeeper = new TimeKeeper(this.agentIdentifier)
 
     if (isBrowserScope) {
       timeToFirstByte.subscribe(({ value, attrs }) => {
@@ -102,6 +103,10 @@ export class Aggregate extends AggregateBase {
     queryParameters.fp = firstPaint.current.value
     queryParameters.fcp = firstContentfulPaint.current.value
 
+    if (this.timeKeeper?.ready) {
+      queryParameters.timestamp = this.timeKeeper.convertRelativeTimestamp(now())
+    }
+
     const rumStartTime = now()
     harvester.send({
       endpoint: 'rum',
@@ -117,16 +122,15 @@ export class Aggregate extends AggregateBase {
         }
 
         try {
-          const timeKeeper = new TimeKeeper(this.agentIdentifier)
-          timeKeeper.processRumRequest(xhr, rumStartTime, rumEndTime)
-          if (!timeKeeper.ready) throw new Error('TimeKeeper not ready')
+          this.timeKeeper.processRumRequest(xhr, rumStartTime, rumEndTime)
+          if (!this.timeKeeper.ready) throw new Error('TimeKeeper not ready')
 
-          agentRuntime.timeKeeper = timeKeeper
+          agentRuntime.timeKeeper = this.timeKeeper
         } catch (error) {
           handle(SUPPORTABILITY_METRIC_CHANNEL, ['PVE/NRTime/Calculation/Failed'], undefined, FEATURE_NAMES.metrics, this.ee)
           drain(this.agentIdentifier, FEATURE_NAMES.metrics, true)
           this.ee.abort()
-          warn('Could not calculate New Relic server time. Agent shutting down.')
+          warn('Could not calculate New Relic server time. Agent shutting down.', error)
           return
         }
 

package/src/features/session_replay/aggregate/index.js

@@ -12,7 +12,7 @@
 
 import { registerHandler } from '../../../common/event-emitter/register-handler'
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
-import { ABORT_REASONS, FEATURE_NAME, MAX_PAYLOAD_SIZE, QUERY_PARAM_PADDING, RRWEB_EVENT_TYPES, SR_EVENT_EMITTER_TYPES } from '../constants'
+import { ABORT_REASONS, FEATURE_NAME, MAX_PAYLOAD_SIZE, QUERY_PARAM_PADDING, RRWEB_EVENT_TYPES, SR_EVENT_EMITTER_TYPES, TRIGGERS } from '../constants'
 import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { sharedChannel } from '../../../common/constants/shared-channel'
@@ -97,16 +97,6 @@ export class Aggregate extends AggregateBase {
       raw: true
     }, this)
 
-    registerHandler(SR_EVENT_EMITTER_TYPES.RECORD, () => {
-      // if it has aborted or BCS returned bad entitlements, do not allow
-      if (this.blocked || !this.entitled) return
-      // if it isnt already (fully) initialized... initialize it
-      if (!this.recorder) this.initializeRecording(false, true, true)
-      // its been initialized and imported the recorder but its not recording (mode === off || error)
-      else if (this.mode !== MODE.FULL) this.switchToFull()
-      // if it gets all the way to here, that means a full session is already recording... do nothing
-    }, this.featureName, this.ee)
-
     registerHandler(SR_EVENT_EMITTER_TYPES.PAUSE, () => {
       this.forceStop(this.mode !== MODE.ERROR)
     }, this.featureName, this.ee)
@@ -117,8 +107,8 @@ export class Aggregate extends AggregateBase {
 
     const { error_sampling_rate, sampling_rate, autoStart, block_selector, mask_text_selector, mask_all_inputs, inline_stylesheet, inline_images, collect_fonts } = getConfigurationValue(this.agentIdentifier, 'session_replay')
 
-    this.waitForFlags(['sr']).then(([flagOn]) => {
-      this.entitled = flagOn
+    this.waitForFlags(['srs', 'sr']).then(([srMode, entitled]) => {
+      this.entitled = !!entitled
       if (!this.entitled) {
         deregisterDrain(this.agentIdentifier, this.featureName)
         if (this.recorder?.recording) {
@@ -128,14 +118,14 @@ export class Aggregate extends AggregateBase {
         return
       }
       this.drain()
-      this.initializeRecording(
-        (Math.random() * 100) < error_sampling_rate,
-        (Math.random() * 100) < sampling_rate
-      )
+      this.initializeRecording(srMode)
     }).then(() => {
-      if (this.mode === MODE.OFF) args?.recorder?.stopRecording() // stop any conservative preload recording launched by instrument
-      sharedChannel.onReplayReady(this.mode) // notify watchers that replay started with the mode
-    })
+      if (this.mode === MODE.OFF) {
+        this.recorder?.stopRecording() // stop any conservative preload recording launched by instrument
+        while (this.recorder?.getEvents().events.length) this.recorder?.clearBuffer?.()
+      }
+      sharedChannel.onReplayReady(this.mode)
+    }) // notify watchers that replay started with the mode
 
     /** Detect if the default configs have been altered and report a SM.  This is useful to evaluate what the reasonable defaults are across a customer base over time */
     if (!autoStart) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/AutoStart/Modified'], undefined, FEATURE_NAMES.metrics, this.ee)
@@ -179,7 +169,7 @@ export class Aggregate extends AggregateBase {
    * @param {boolean} ignoreSession - whether to force the method to ignore the session state and use just the sample flags
    * @returns {void}
    */
-  async initializeRecording (errorSample, fullSample, ignoreSession) {
+  async initializeRecording (srMode, ignoreSession) {
     this.initialized = true
     if (!this.entitled) return
 
@@ -191,23 +181,16 @@ export class Aggregate extends AggregateBase {
     // session replays can continue if already in progress
     const { session, timeKeeper } = getRuntime(this.agentIdentifier)
     this.timeKeeper = timeKeeper
-    if (!session.isNew && !ignoreSession) { // inherit the mode of the existing session
+    if (this.recorder?.parent.trigger === TRIGGERS.API && this.recorder?.recording) {
+      this.mode = MODE.FULL
+    } else if (!session.isNew && !ignoreSession) { // inherit the mode of the existing session
       this.mode = session.state.sessionReplayMode
     } else {
       // The session is new... determine the mode the new session should start in
-      if (fullSample) this.mode = MODE.FULL // full mode has precedence over error mode
-      else if (errorSample) this.mode = MODE.ERROR
-      // If neither are selected, then don't record (early return)
-      else {
-        return
-      }
-    }
-
-    if (this.recorder?.getEvents().type === 'preloaded') {
-      this.prepUtils().then(() => {
-        this.scheduler.runHarvest()
-      })
+      this.mode = srMode
     }
+    // If off, then don't record (early return)
+    if (this.mode === MODE.OFF) return
 
     if (!this.recorder) {
       try {
@@ -225,12 +208,20 @@ export class Aggregate extends AggregateBase {
     // If an error was noticed before the mode could be set (like in the early lifecycle of the page), immediately set to FULL mode
     if (this.mode === MODE.ERROR && this.errorNoticed) this.mode = MODE.FULL
 
-    // FULL mode records AND reports from the beginning, while ERROR mode only records (but does not report).
-    // ERROR mode will do this until an error is thrown, and then switch into FULL mode.
-    // If an error happened in ERROR mode before we've gotten to this stage, it will have already set the mode to FULL
-    if (this.mode === MODE.FULL && !this.scheduler.started) {
+    if (this.mode === MODE.FULL) {
+      // If theres preloaded events and we are in full mode, just harvest immediately to clear up space and for consistency
+      if (this.recorder?.getEvents().type === 'preloaded') {
+        this.prepUtils().then(() => {
+          this.scheduler.runHarvest()
+        })
+      }
+      // FULL mode records AND reports from the beginning, while ERROR mode only records (but does not report).
+      // ERROR mode will do this until an error is thrown, and then switch into FULL mode.
+      // If an error happened in ERROR mode before we've gotten to this stage, it will have already set the mode to FULL
+      if (!this.scheduler.started) {
       // We only report (harvest) in FULL mode
-      this.scheduler.startTimer(this.harvestTimeSeconds)
+        this.scheduler.startTimer(this.harvestTimeSeconds)
+      }
     }
 
     await this.prepUtils()