@newrelic/browser-agent 1.258.2 → 1.259.0

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.259.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/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/aggregate/index.js

@@ -201,7 +201,8 @@ export class Aggregate extends AggregateBase {
     var type = internal ? 'ierr' : 'err'
     var newMetrics = { time }
 
-    // Trace sends the error in its payload, and both trace & replay simply listens for any error to occur.
+    // sr, stn and spa aggregators listen to this event - stn sends the error in its payload,
+    // and spa annotates the error with interaction info
     const jsErrorEvent = [type, bucketHash, params, newMetrics, customAttributes]
     handle('trace-jserror', jsErrorEvent, undefined, FEATURE_NAMES.sessionTrace, this.ee)
     // still send EE events for other features such as above, but stop this one from aggregating internal data

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

@@ -126,7 +126,7 @@ export class Aggregate extends AggregateBase {
           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()

package/src/features/session_replay/constants.js

@@ -53,3 +53,7 @@ export const ABORT_REASONS = {
 }
 /** Reserved room for query param attrs */
 export const QUERY_PARAM_PADDING = 5000
+
+export const TRIGGERS = {
+  API: 'api'
+}

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

@@ -12,11 +12,13 @@
 import { handle } from '../../../common/event-emitter/handle'
 import { DEFAULT_KEY, MODE, PREFIX } from '../../../common/session/constants'
 import { InstrumentBase } from '../../utils/instrument-base'
-import { FEATURE_NAME, SR_EVENT_EMITTER_TYPES } from '../constants'
-import { isPreloadAllowed } from '../shared/utils'
+import { hasReplayPrerequisite, isPreloadAllowed } from '../shared/utils'
+import { FEATURE_NAME, SR_EVENT_EMITTER_TYPES, TRIGGERS } from '../constants'
 
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME
+
+  #mode
   constructor (agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, FEATURE_NAME, auto)
     let session
@@ -25,8 +27,13 @@ export class Instrument extends InstrumentBase {
       session = JSON.parse(localStorage.getItem(`${PREFIX}_${DEFAULT_KEY}`))
     } catch (err) { }
 
+    if (hasReplayPrerequisite(agentIdentifier)) {
+      this.ee.on('recordReplay', () => this.#apiStartOrRestartReplay())
+    }
+
     if (this.#canPreloadRecorder(session)) {
-      this.#startRecording(session?.sessionReplayMode)
+      this.#mode = session?.sessionReplayMode
+      this.#preloadStartRecording()
     } else {
       this.importAggregator()
     }
@@ -58,11 +65,44 @@ export class Instrument extends InstrumentBase {
     }
   }
 
-  async #startRecording (mode) {
-    const { Recorder } = (await import(/* webpackChunkName: "recorder" */'../shared/recorder'))
-    this.recorder = new Recorder({ mode, agentIdentifier: this.agentIdentifier, ee: this.ee })
-    this.recorder.startRecording()
-    this.abortHandler = this.recorder.stopRecording
+  #alreadyStarted = false
+  /**
+   * This func is use for early pre-load recording prior to replay feature (agg) being loaded onto the page. It should only setup once, including if already called and in-progress.
+   */
+  async #preloadStartRecording (trigger) {
+    if (this.#alreadyStarted) return
+    this.#alreadyStarted = true
+
+    try {
+      const { Recorder } = (await import(/* webpackChunkName: "recorder" */'../shared/recorder'))
+
+      // If startReplay() has been used by this point, we must record in full mode regardless of session preload:
+      // Note: recorder starts here with w/e the mode is at this time, but this may be changed later (see #apiStartOrRestartReplay else-case)
+      this.recorder ??= new Recorder({ mode: this.#mode, agentIdentifier: this.agentIdentifier, trigger, ee: this.ee })
+      this.recorder.startRecording()
+      this.abortHandler = this.recorder.stopRecording
+    } catch (e) {}
     this.importAggregator({ recorder: this.recorder, errorNoticed: this.errorNoticed })
   }
+
+  /**
+   * Called whenever startReplay API is used. That could occur any time, pre or post load.
+   */
+  #apiStartOrRestartReplay () {
+    if (this.featAggregate) { // post-load; there's possibly already an ongoing recording
+      if (this.featAggregate.mode !== MODE.FULL) this.featAggregate.initializeRecording(MODE.FULL, true)
+    } else { // pre-load
+      this.#mode = MODE.FULL
+      this.#preloadStartRecording(TRIGGERS.API)
+      // There's a race here wherein either:
+      // a. Recorder has not been initialized, and we've set the enforced mode, so we're good, or;
+      // b. Record has been initialized, possibly with the "wrong" mode, so we have to correct that + restart.
+      if (this.recorder && this.recorder.parent.mode !== MODE.FULL) {
+        this.recorder.parent.mode = MODE.FULL
+        this.recorder.stopRecording()
+        this.recorder.startRecording()
+        this.abortHandler = this.recorder.stopRecording
+      }
+    }
+  }
 }

package/src/features/session_replay/shared/__mocks__/utils.js

@@ -1,2 +1 @@
-export const enableSessionTracking = jest.fn()
 export const canImportReplayAgg = jest.fn()

package/src/features/session_replay/shared/utils.js

@@ -1,13 +1,10 @@
 import { getConfigurationValue, originals } from '../../../common/config/config'
-import { isBrowserScope, originTime } from '../../../common/constants/runtime'
+import { canEnableSessionTracking } from '../../utils/feature-gates'
+import { originTime } from '../../../common/constants/runtime'
 
-export function enableSessionTracking (agentId) {
-  return isBrowserScope && getConfigurationValue(agentId, 'privacy.cookies_enabled') === true
-}
-
-function hasReplayPrerequisite (agentId) {
+export function hasReplayPrerequisite (agentId) {
   return !!originals.MO && // Session Replay cannot work without Mutation Observer
-  enableSessionTracking(agentId) && // requires session tracking to be running (hence "session" replay...)
+  canEnableSessionTracking(agentId) && // requires session tracking to be running (hence "session" replay...)
   getConfigurationValue(agentId, 'session_trace.enabled') === true // Session Replay as of now is tightly coupled with Session Trace in the UI
 }