@newrelic/browser-agent 1.277.0 → 1.278.0

package/src/common/harvest/types.js

@@ -14,32 +14,16 @@
  * @property {object} body Map of values that should be sent as the body of the request.
  */
 
-/**
- * @typedef {object} FeatureHarvestCallbackOptions Options for aggregating data for harvesting.
- * @property {boolean} options.retry Indicates if the feature should store the aggregated
- * data in anticipation of a possible need to retry the transmission.
- */
-
-/**
- * @callback FeatureHarvestCallback
- * @param {FeatureHarvestCallbackOptions} options Options for aggregating data for harvesting.
- * @returns {HarvestPayload} Payload of data to transmit to bam endpoint.
- */
-
 /**
  * @typedef {object} NetworkSendSpec
  * @property {HarvestEndpointIdentifier} endpoint The endpoint to use (jserrors, events, resources etc.)
  * @property {HarvestPayload} payload Object representing payload.
- * @property {object} opts Additional options for sending data
- * @property {boolean} opts.needResponse Specify whether the caller expects a response data.
- * @property {boolean} opts.unload Specify whether the call is a final harvest during page unload.
- * @property {boolean} opts.sendEmptyBody Specify whether the call should be made even if the body is empty. Useful for rum calls.
- * @property {boolean} opts.retry Indicates if the feature should store the aggregated data in anticipation of a possible need to
- * retry the transmission.
+ * @property {object} localOpts Additional options for sending data
+ * @property {boolean} localOpts.needResponse Specify whether the caller expects a response data.
+ * @property {boolean} localOpts.isFinalHarvest Specify whether the call is a final harvest during page unload.
+ * @property {boolean} localOpts.sendEmptyBody Specify whether the call should be made even if the body is empty. Useful for rum calls.
+ * @property {boolean} localOpts.forceNoRetry Don't save the buffered data in the case of a need to retry the transmission.
  * @property {import('../util/submit-data.js').NetworkMethods} submitMethod The network method to use {@link ../util/submit-data.js}
- * @property {string} customUrl Override the beacon url the data is sent to; must include protocol if defined
- * @property {boolean} raw If true, disables adding the license key to the url
- * @property {boolean} includeBaseParams Enables the use of base query parameters in the beacon url
  */
 
 /* istanbul ignore next */

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

@@ -5,10 +5,9 @@
 import { registerHandler } from '../../../common/event-emitter/register-handler'
 import { stringify } from '../../../common/util/stringify'
 import { handle } from '../../../common/event-emitter/handle'
-import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { setDenyList, shouldCollectEvent } from '../../../common/deny-list/deny-list'
 import { FEATURE_NAME } from '../constants'
-import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
+import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { parseGQL } from './gql'
@@ -19,10 +18,7 @@ export class Aggregate extends AggregateBase {
 
   constructor (agentRef) {
     super(agentRef, FEATURE_NAME)
-
-    const harvestTimeSeconds = agentRef.init.ajax.harvestTimeSeconds || 10
     setDenyList(agentRef.runtime.denyList)
-
     this.underSpaEvents = {}
     const classThis = this
 
@@ -43,14 +39,7 @@ export class Aggregate extends AggregateBase {
       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(FEATURE_TO_ENDPOINT[this.featureName], {
-        onFinished: (result) => this.postHarvestCleanup(result.sent && result.retry),
-        getPayload: (options) => this.makeHarvestPayload(options.retry)
-      }, this)
-      scheduler.startTimer(harvestTimeSeconds)
-      this.drain()
-    })
+    this.waitForFlags(([])).then(() => this.drain())
   }
 
   storeXhr (params, metrics, startTime, endTime, type, ctx) {
@@ -70,7 +59,7 @@ export class Aggregate extends AggregateBase {
 
     // Report ajax timeslice metric (to be harvested by jserrors feature, but only if it's running).
     if (jserrorsInUse && (shouldCollect || !shouldOmitAjaxMetrics)) {
-      this.agentRef.sharedAggregator.add('xhr', hash, params, metrics)
+      this.agentRef.sharedAggregator.add(['xhr', hash, params, metrics])
     }
 
     if (!shouldCollect) {

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

@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { stringify } from '../../../common/util/stringify'
-import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { cleanURL } from '../../../common/url/clean-url'
 import { FEATURE_NAME, RESERVED_EVENT_TYPES } from '../constants'
 import { globalScope, initialLocation, isBrowserScope } from '../../../common/constants/runtime'
@@ -13,7 +12,6 @@ import { now } from '../../../common/timing/now'
 import { registerHandler } from '../../../common/event-emitter/register-handler'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 import { applyFnToProps } from '../../../common/util/traverse'
-import { FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
 import { UserActionsAggregator } from './user-actions/user-actions-aggregator'
 import { isIFrameWindow } from '../../../common/dom/iframe'
 import { handle } from '../../../common/event-emitter/handle'
@@ -22,10 +20,7 @@ export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
   constructor (agentRef) {
     super(agentRef, FEATURE_NAME)
-
     this.eventsPerHarvest = 1000
-    this.harvestTimeSeconds = agentRef.init.generic_events.harvestTimeSeconds
-
     this.referrerUrl = (isBrowserScope && document.referrer) ? cleanURL(document.referrer) : undefined
 
     this.waitForFlags(['ins']).then(([ins]) => {
@@ -66,6 +61,7 @@ export class Aggregate extends AggregateBase {
       let addUserAction
       if (isBrowserScope && agentRef.init.user_actions.enabled) {
         this.userActionAggregator = new UserActionsAggregator()
+        this.harvestOpts.beforeUnload = () => addUserAction?.(this.userActionAggregator.aggregationEvent)
 
         addUserAction = (aggregatedUserAction) => {
           try {
@@ -186,13 +182,7 @@ export class Aggregate extends AggregateBase {
         }, this.featureName, this.ee)
       }
 
-      this.harvestScheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
-        onFinished: (result) => this.postHarvestCleanup(result.sent && result.retry),
-        onUnload: () => addUserAction?.(this.userActionAggregator.aggregationEvent)
-      }, this)
-      this.harvestScheduler.harvest.on(FEATURE_TO_ENDPOINT[this.featureName], (options) => this.makeHarvestPayload(options.retry))
-      this.harvestScheduler.startTimer(this.harvestTimeSeconds, 0)
-
+      agentRef.runtime.harvester.triggerHarvestFor(this)
       this.drain()
     })
   }
@@ -246,7 +236,7 @@ export class Aggregate extends AggregateBase {
        * if it fails again, we do nothing
        */
       this.ee.emit(SUPPORTABILITY_METRIC_CHANNEL, ['GenericEvents/Harvest/Max/Seen'])
-      this.harvestScheduler.runHarvest()
+      this.agentRef.runtime.harvester.triggerHarvestFor(this)
       this.events.add(eventAttributes)
     }
   }

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

@@ -9,13 +9,12 @@ import { stringHashCode } from './string-hash-code'
 import { truncateSize } from './format-stack-trace'
 
 import { registerHandler as register } from '../../../common/event-emitter/register-handler'
-import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { stringify } from '../../../common/util/stringify'
 import { handle } from '../../../common/event-emitter/handle'
 import { globalScope } from '../../../common/constants/runtime'
 
 import { FEATURE_NAME } from '../constants'
-import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
+import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { now } from '../../../common/timing/now'
 import { applyFnToProps } from '../../../common/util/traverse'
@@ -45,17 +44,11 @@ export class Aggregate extends AggregateBase {
     register('softNavFlush', (interactionId, wasFinished, softNavAttrs) =>
       this.onSoftNavNotification(interactionId, wasFinished, softNavAttrs), this.featureName, this.ee) // when an ixn is done or cancelled
 
-    const harvestTimeSeconds = agentRef.init.jserrors.harvestTimeSeconds || 10
-    const aggregatorTypes = ['err', 'ierr', 'xhr'] // the types in EventAggregator this feature cares about
+    this.harvestOpts.aggregatorTypes = ['err', 'ierr', 'xhr'] // the types in EventAggregator this feature cares about
 
     // 0 == off, 1 == on
     this.waitForFlags(['err']).then(([errFlag]) => {
       if (errFlag) {
-        const scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
-          onFinished: (result) => this.postHarvestCleanup(result.sent && result.retry, { aggregatorTypes })
-        }, this)
-        scheduler.harvest.on(FEATURE_TO_ENDPOINT[this.featureName], (options) => this.makeHarvestPayload(options.retry, { aggregatorTypes }))
-        scheduler.startTimer(harvestTimeSeconds)
         this.drain()
       } else {
         this.blocked = true // if rum response determines that customer lacks entitlements for spa endpoint, this feature shouldn't harvest
@@ -235,7 +228,7 @@ export class Aggregate extends AggregateBase {
 
     const jsAttributesHash = stringHashCode(stringify(allCustomAttrs))
     const aggregateHash = bucketHash + ':' + jsAttributesHash
-    this.events.add(type, aggregateHash, params, newMetrics, allCustomAttrs)
+    this.events.add([type, aggregateHash, params, newMetrics, allCustomAttrs])
 
     function setCustom (key, val) {
       allCustomAttrs[key] = (val && typeof val === 'object' ? stringify(val) : val)
@@ -265,7 +258,7 @@ export class Aggregate extends AggregateBase {
       var jsAttributesHash = stringHashCode(stringify(allCustomAttrs))
       var aggregateHash = hash + ':' + jsAttributesHash
 
-      this.events.add(item[0], aggregateHash, params, item[3], allCustomAttrs)
+      this.events.add([item[0], aggregateHash, params, item[3], allCustomAttrs])
 
       function setCustom ([key, val]) {
         allCustomAttrs[key] = (val && typeof val === 'object' ? stringify(val) : val)

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

@@ -1,6 +1,5 @@
 import { handle } from '../../../common/event-emitter/handle'
 import { registerHandler } from '../../../common/event-emitter/register-handler'
-import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { warn } from '../../../common/util/console'
 import { stringify } from '../../../common/util/stringify'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
@@ -10,26 +9,19 @@ import { Log } from '../shared/log'
 import { isValidLogLevel } from '../shared/utils'
 import { applyFnToProps } from '../../../common/util/traverse'
 import { MAX_PAYLOAD_SIZE } from '../../../common/constants/agent-constants'
-import { FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
   constructor (agentRef) {
     super(agentRef, FEATURE_NAME)
-    this.harvestTimeSeconds = agentRef.init.logging.harvestTimeSeconds
+    this.harvestOpts.raw = true
 
     this.waitForFlags([]).then(() => {
-      this.scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
-        onFinished: (result) => this.postHarvestCleanup(result.sent && result.retry),
-        retryDelay: this.harvestTimeSeconds,
-        getPayload: (options) => this.makeHarvestPayload(options.retry),
-        raw: true
-      }, this)
       /** emitted by instrument class (wrapped loggers) or the api methods directly */
       registerHandler(LOGGING_EVENT_EMITTER_CHANNEL, this.handleLog.bind(this), this.featureName, this.ee)
       this.drain()
       /** harvest immediately once started to purge pre-load logs collected */
-      this.scheduler.startTimer(this.harvestTimeSeconds, 0)
+      agentRef.runtime.harvester.triggerHarvestFor(this)
     })
   }
 
@@ -73,8 +65,8 @@ export class Aggregate extends AggregateBase {
     }
 
     if (this.events.wouldExceedMaxSize(logBytes)) {
-      handle(SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Early/Seen', this.events.bytes + logBytes])
-      this.scheduler.runHarvest() // force a harvest to try adding again
+      handle(SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Early/Seen', this.events.byteSize() + logBytes])
+      this.agentRef.runtime.harvester.triggerHarvestFor(this) // force a harvest synchronously to try adding again
     }
 
     if (!this.events.add(log)) { // still failed after a harvest attempt despite not being too large would mean harvest failed with options.retry

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

@@ -1,5 +1,4 @@
 import { registerHandler } from '../../../common/event-emitter/register-handler'
-import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { FEATURE_NAME, SUPPORTABILITY_METRIC, CUSTOM_METRIC, SUPPORTABILITY_METRIC_CHANNEL, CUSTOM_METRIC_CHANNEL/*, WATCHABLE_WEB_SOCKET_EVENTS */ } from '../constants'
 import { getFrameworks } from './framework-detection'
 import { isFileProtocol } from '../../../common/url/protocol'
@@ -7,7 +6,6 @@ import { onDOMContentLoaded } from '../../../common/window/load'
 import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts'
 import { isBrowserScope, isWorkerScope } from '../../../common/constants/runtime'
 import { AggregateBase } from '../../utils/aggregate-base'
-import { FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
 import { isIFrameWindow } from '../../../common/dom/iframe'
 // import { WEBSOCKET_TAG } from '../../../common/wrap/wrap-websocket'
 // import { handleWebsocketEvents } from './websocket-detection'
@@ -16,14 +14,11 @@ export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
   constructor (agentRef) {
     super(agentRef, FEATURE_NAME)
-    const aggregatorTypes = ['cm', 'sm'] // the types in EventAggregator this feature cares about
+    this.harvestOpts.aggregatorTypes = ['cm', 'sm'] // the types in EventAggregator this feature cares about
+    // This feature only harvests once per potential EoL of the page, which is handled by the central harvester.
 
     this.waitForFlags(['err']).then(([errFlag]) => {
       if (errFlag) {
-        // *cli, Mar 23 - Per NR-94597, this feature should only harvest ONCE at the (potential) EoL time of the page.
-        const scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], { onUnload: () => this.unload() }, this)
-        // this is needed to ensure EoL is "on" and sent
-        scheduler.harvest.on(FEATURE_TO_ENDPOINT[this.featureName], () => this.makeHarvestPayload(undefined, { aggregatorTypes }))
         this.drain()
       } else {
         this.blocked = true // if rum response determines that customer lacks entitlements for spa endpoint, this feature shouldn't harvest
@@ -39,6 +34,8 @@ export class Aggregate extends AggregateBase {
     this.eachSessionChecks() // the start of every time user engages with page
   }
 
+  preHarvestChecks () { return this.drained } // only allow any metrics to be sent if we know for sure it has gotten the go-ahead RUM flag
+
   storeSupportabilityMetrics (name, value) {
     if (this.blocked) return
     const type = SUPPORTABILITY_METRIC
@@ -50,7 +47,7 @@ export class Aggregate extends AggregateBase {
     if (this.blocked) return
     const type = CUSTOM_METRIC
     const params = { name }
-    this.events.add(type, name, params, metrics)
+    this.events.add([type, name, params, metrics])
   }
 
   singleChecks () {
@@ -132,8 +129,4 @@ export class Aggregate extends AggregateBase {
       if (evt?.persisted) { this.storeSupportabilityMetrics('Generic/BFCache/PageRestored') }
     })
   }
-
-  unload () {
-    // do nothing for now, marks and measures and resources stats are now being captured by the ge feature
-  }
 }

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

@@ -2,7 +2,6 @@ import { globalScope, isBrowserScope, originTime } from '../../../common/constan
 import { addPT, addPN } from '../../../common/timing/nav-timing'
 import { stringify } from '../../../common/util/stringify'
 import { isValid } from '../../../common/config/info'
-import { Harvest } from '../../../common/harvest/harvest'
 import * as CONSTANTS from '../constants'
 import { getActivatedFeaturesFlags } from './initialized-features'
 import { activateFeatures } from '../../../common/util/feature-flags'
@@ -23,12 +22,12 @@ 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(agentRef.agentIdentifier)
 
     if (!isValid(agentRef.agentIdentifier)) {
       this.ee.abort()
       return warn(43)
     }
+    agentRef.runtime.timeKeeper = new TimeKeeper(agentRef.agentIdentifier)
 
     if (isBrowserScope) {
       timeToFirstByte.subscribe(({ value, attrs }) => {
@@ -47,7 +46,6 @@ export class Aggregate extends AggregateBase {
 
   sendRum () {
     const info = this.agentRef.info
-    const harvester = new Harvest(this)
     const measures = {}
 
     if (info.queueTime) measures.qt = info.queueTime
@@ -99,43 +97,45 @@ export class Aggregate extends AggregateBase {
     queryParameters.fp = firstPaint.current.value
     queryParameters.fcp = firstContentfulPaint.current.value
 
-    if (this.timeKeeper?.ready) {
-      queryParameters.timestamp = Math.floor(this.timeKeeper.correctRelativeTimestamp(now()))
+    const timeKeeper = this.agentRef.runtime.timeKeeper
+    if (timeKeeper?.ready) {
+      queryParameters.timestamp = Math.floor(timeKeeper.correctRelativeTimestamp(now()))
     }
 
-    const rumStartTime = now()
-    harvester.send({
-      endpoint: 'rum',
-      payload: { qs: queryParameters, body },
-      opts: { needResponse: true, sendEmptyBody: true },
-      cbFinished: ({ status, responseText, xhr }) => {
-        const rumEndTime = now()
-
-        if (status >= 400 || status === 0) {
-          // Adding retry logic for the rum call will be a separate change
-          this.ee.abort()
-          return
-        }
-
-        try {
-          const { app, ...flags } = JSON.parse(responseText)
-          try {
-            this.timeKeeper.processRumRequest(xhr, rumStartTime, rumEndTime, app.nrServerTime)
-            if (!this.timeKeeper.ready) throw new Error('TimeKeeper not ready')
-            this.agentRef.runtime.timeKeeper = this.timeKeeper
-          } catch (error) {
-            this.ee.abort()
-            warn(17, error)
-            return
-          }
-          this.agentRef.runtime.appMetadata = app
-          activateFeatures(flags, this.agentIdentifier)
-          this.drain()
-        } catch (err) {
-          this.ee.abort()
-          warn(18, err)
-        }
-      }
+    this.rumStartTime = now()
+    this.agentRef.runtime.harvester.triggerHarvestFor(this, {
+      directSend: {
+        targetApp: this.agentRef.mainAppKey,
+        payload: { qs: queryParameters, body }
+      },
+      needResponse: true,
+      sendEmptyBody: true
     })
   }
+
+  postHarvestCleanup ({ status, responseText, xhr }) {
+    const rumEndTime = now()
+    this.blocked = true // this prevents harvester from polling this feature's event buffer (DNE) on interval; in other words, harvests will skip PVE
+
+    if (status >= 400 || status === 0) {
+      warn(18, status)
+      // Adding retry logic for the rum call will be a separate change; this.blocked will need to be changed since that prevents another triggerHarvestFor()
+      this.ee.abort()
+      return
+    }
+
+    const { app, ...flags } = JSON.parse(responseText)
+    try {
+      this.agentRef.runtime.timeKeeper.processRumRequest(xhr, this.rumStartTime, rumEndTime, app.nrServerTime)
+      if (!this.agentRef.runtime.timeKeeper.ready) throw new Error('TimeKeeper not ready')
+    } catch (error) {
+      this.ee.abort()
+      warn(17, error)
+      return
+    }
+    this.agentRef.runtime.appMetadata = app
+    activateFeatures(flags, this.agentIdentifier)
+    this.drain()
+    this.agentRef.runtime.harvester.startTimer()
+  }
 }

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

@@ -4,11 +4,10 @@
  */
 
 import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer'
-import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { registerHandler } from '../../../common/event-emitter/register-handler'
 import { handle } from '../../../common/event-emitter/handle'
 import { FEATURE_NAME } from '../constants'
-import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
+import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { cumulativeLayoutShift } from '../../../common/vitals/cumulative-layout-shift'
 import { firstContentfulPaint } from '../../../common/vitals/first-contentful-paint'
@@ -35,11 +34,7 @@ export class Aggregate extends AggregateBase {
     // Add the time of _window pagehide event_ firing to the next PVT harvest == NRDB windowUnload attr:
     registerHandler('winPagehide', msTimestamp => this.addTiming('unload', msTimestamp, null), this.featureName, this.ee)
 
-    const harvestTimeSeconds = agentRef.init.page_view_timing.harvestTimeSeconds || 30
-
     this.waitForFlags(([])).then(() => {
-      /* It's important that CWV api, like "onLCP", is called before the **scheduler** is initialized. The reason is because they listen to the same
-        on vis change or pagehide events, and we'd want ex. onLCP to record the timing (win the race) before we try to send "final harvest". */
       firstPaint.subscribe(this.#handleVitalMetric)
       firstContentfulPaint.subscribe(this.#handleVitalMetric)
       firstInputDelay.subscribe(this.#handleVitalMetric)
@@ -57,12 +52,6 @@ export class Aggregate extends AggregateBase {
         this.addTiming(name, value * 1000, attrs)
       }, true) // CLS node should only reports on vis change rather than on every change
 
-      const scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
-        onFinished: (result) => this.postHarvestCleanup(result.sent && result.retry),
-        getPayload: (options) => this.makeHarvestPayload(options.retry)
-      }, this)
-      scheduler.startTimer(harvestTimeSeconds)
-
       this.drain()
     })
   }

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

@@ -7,7 +7,6 @@
  */
 
 import { registerHandler } from '../../../common/event-emitter/register-handler'
-import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { ABORT_REASONS, FEATURE_NAME, QUERY_PARAM_PADDING, RRWEB_EVENT_TYPES, SR_EVENT_EMITTER_TYPES, TRIGGERS } from '../constants'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { sharedChannel } from '../../../common/constants/shared-channel'
@@ -16,7 +15,7 @@ import { warn } from '../../../common/util/console'
 import { globalScope } from '../../../common/constants/runtime'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 import { handle } from '../../../common/event-emitter/handle'
-import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
+import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { RRWEB_VERSION } from '../../../common/constants/env'
 import { MODE, SESSION_EVENTS, SESSION_EVENT_TYPES } from '../../../common/session/constants'
 import { stringify } from '../../../common/util/stringify'
@@ -33,8 +32,6 @@ export class Aggregate extends AggregateBase {
   // pass the recorder into the aggregator
   constructor (agentRef, args) {
     super(agentRef, FEATURE_NAME)
-    /** The interval to harvest at.  This gets overridden if the size of the payload exceeds certain thresholds */
-    this.harvestTimeSeconds = agentRef.init.session_replay.harvestTimeSeconds || 60
     /** Set once the recorder has fully initialized after flag checks and sampling */
     this.initialized = false
     /** Set once the feature has been "aborted" to prevent other side-effects from continuing */
@@ -51,6 +48,7 @@ export class Aggregate extends AggregateBase {
 
     this.recorder = args?.recorder
     this.errorNoticed = args?.errorNoticed || false
+    this.harvestOpts.raw = true
 
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/Enabled'], undefined, FEATURE_NAMES.metrics, this.ee)
 
@@ -76,16 +74,8 @@ export class Aggregate extends AggregateBase {
       this.mode = data.sessionReplay
     })
 
-    // Bespoke logic for blobs endpoint.
-    this.scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
-      onFinished: (result) => this.postHarvestCleanup(result),
-      retryDelay: this.harvestTimeSeconds,
-      getPayload: ({ retry, ...opts }) => this.makeHarvestPayload(retry, opts),
-      raw: true
-    }, this)
-
     registerHandler(SR_EVENT_EMITTER_TYPES.PAUSE, () => {
-      this.forceStop(this.mode !== MODE.ERROR)
+      this.forceStop(this.mode === MODE.FULL)
     }, this.featureName, this.ee)
 
     registerHandler(SR_EVENT_EMITTER_TYPES.ERROR_DURING_REPLAY, e => {
@@ -127,7 +117,7 @@ export class Aggregate extends AggregateBase {
   }
 
   replayIsActive () {
-    return Boolean(this.scheduler?.started && this.recorder && this.mode === MODE.FULL && !this.blocked && this.entitled)
+    return Boolean(this.recorder && this.mode === MODE.FULL && !this.blocked && this.entitled)
   }
 
   handleError (e) {
@@ -144,18 +134,15 @@ export class Aggregate extends AggregateBase {
     // if the error was noticed AFTER the recorder was already imported....
     if (this.recorder && this.initialized) {
       if (!this.recorder.recording) this.recorder.startRecording()
-      this.scheduler.startTimer(this.harvestTimeSeconds)
       this.syncWithSessionManager({ sessionReplayMode: this.mode })
     } else {
-      this.initializeRecording(false, true, true)
+      this.initializeRecording(MODE.FULL, true)
     }
   }
 
   /**
    * Evaluate entitlements and sampling before starting feature mechanics, importing and configuring recording library, and setting storage state
    * @param {boolean} entitlements - the true/false state of the "sr" flag from RUM response
-   * @param {boolean} errorSample - the true/false state of the error sampling decision
-   * @param {boolean} fullSample - the true/false state of the full sampling decision
    * @param {boolean} ignoreSession - whether to force the method to ignore the session state and use just the sample flags
    * @returns {void}
    */
@@ -198,20 +185,13 @@ 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
 
-    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)
-      }
+    // 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.
+    // The makeHarvestPayload should ensure that no payload is returned if we're not in FULL mode...
+
+    // If theres preloaded events and we are in full mode, just harvest immediately to clear up space and for consistency
+    if (this.mode === MODE.FULL && this.recorder?.getEvents().type === 'preloaded') {
+      this.prepUtils().then(() => this.agentRef.runtime.harvester.triggerHarvestFor(this))
     }
 
     await this.prepUtils()
@@ -232,11 +212,13 @@ export class Aggregate extends AggregateBase {
     }
   }
 
-  makeHarvestPayload (shouldRetryOnFail, opts) {
+  makeHarvestPayload (shouldRetryOnFail) {
+    if (this.mode !== MODE.FULL || this.blocked) return
     if (!this.recorder || !this.timeKeeper?.ready || !this.recorder.hasSeenSnapshot) return
+
     const recorderEvents = this.recorder.getEvents()
     // get the event type and use that to trigger another harvest if needed
-    if (!recorderEvents.events.length || (this.mode !== MODE.FULL) || this.blocked) return
+    if (!recorderEvents.events.length) return
 
     const payload = this.getHarvestContents(recorderEvents)
     if (!payload.body.length) {
@@ -258,7 +240,6 @@ export class Aggregate extends AggregateBase {
         return stringify(output)
       }).join(',')}]`))
       len = payload.body.length
-      this.scheduler.opts.gzip = true
     } else {
       payload.body = payload.body.map(({ __serialized, ...node }) => {
         if (node.__newrelic) return node
@@ -268,7 +249,6 @@ export class Aggregate extends AggregateBase {
         return output
       })
       len = stringify(payload.body).length
-      this.scheduler.opts.gzip = false
     }
 
     if (len > MAX_PAYLOAD_SIZE) {
@@ -278,8 +258,8 @@ export class Aggregate extends AggregateBase {
     // TODO -- Gracefully handle the buffer for retries.
     if (!this.agentRef.runtime.session.state.sessionReplaySentFirstChunk) this.syncWithSessionManager({ sessionReplaySentFirstChunk: true })
     this.recorder.clearBuffer()
-    if (recorderEvents.type === 'preloaded') this.scheduler.runHarvest(opts)
-    return [payload]
+    if (recorderEvents.type === 'preloaded') this.agentRef.runtime.harvester.triggerHarvestFor(this)
+    return [{ targetApp: undefined, payload }] // SR doesn't need a targetApp as it only works for the main, but format needs to make AggregateBase
   }
 
   getCorrectedTimestamp (node) {
@@ -366,8 +346,6 @@ export class Aggregate extends AggregateBase {
     if (result.status === 429) {
       this.abort(ABORT_REASONS.TOO_MANY)
     }
-
-    if (this.blocked) this.scheduler.stopTimer(true)
   }
 
   /**
@@ -376,7 +354,7 @@ export class Aggregate extends AggregateBase {
    * the stopRecording API.
    */
   forceStop (forceHarvest) {
-    if (forceHarvest) this.scheduler.runHarvest()
+    if (forceHarvest) this.agentRef.runtime.harvester.triggerHarvestFor(this)
     this.mode = MODE.OFF
     this.recorder?.stopRecording?.()
     this.syncWithSessionManager({ sessionReplayMode: this.mode })
@@ -391,7 +369,6 @@ export class Aggregate extends AggregateBase {
     this.recorder?.stopRecording?.()
     this.syncWithSessionManager({ sessionReplayMode: this.mode })
     this.recorder?.clearTimestamps?.()
-    this.ee.emit('REPLAY_ABORTED')
     while (this.recorder?.getEvents().events.length) this.recorder?.clearBuffer?.()
   }
 

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

@@ -77,7 +77,7 @@ export class Instrument extends InstrumentBase {
 
       // 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 ??= new Recorder({ mode: this.#mode, agentIdentifier: this.agentIdentifier, trigger, ee: this.ee, agentRef: this.#agentRef })
       this.recorder.startRecording()
       this.abortHandler = this.recorder.stopRecording
     } catch (e) {}