@newrelic/browser-agent 1.271.0 → 1.273.0

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

@@ -8,13 +8,11 @@ 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 } from '../../../loaders/features/features'
+import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { parseGQL } from './gql'
-import { getNREUMInitializedAgent } from '../../../common/window/nreum'
-import Chunk from './chunk'
-import { EventBuffer } from '../../utils/event-buffer'
+import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
@@ -25,31 +23,30 @@ export class Aggregate extends AggregateBase {
     const harvestTimeSeconds = agentRef.init.ajax.harvestTimeSeconds || 10
     setDenyList(agentRef.runtime.denyList)
 
-    this.ajaxEvents = new EventBuffer()
-    this.spaAjaxEvents = {}
+    this.underSpaEvents = {}
     const classThis = this
 
     // --- v Used by old spa feature
     this.ee.on('interactionDone', (interaction, wasSaved) => {
-      if (!this.spaAjaxEvents[interaction.id]?.hasData) return
+      if (!this.underSpaEvents[interaction.id]) return
 
       if (!wasSaved) { // if the ixn was saved, then its ajax reqs are part of the payload whereas if it was discarded, it should still be harvested in the ajax feature itself
-        this.ajaxEvents.merge(this.spaAjaxEvents[interaction.id])
+        this.underSpaEvents[interaction.id].forEach((item) => this.events.add(item))
       }
-      delete this.spaAjaxEvents[interaction.id]
+      delete this.underSpaEvents[interaction.id]
     })
     // --- ^
     // --- v Used by new soft nav
-    registerHandler('returnAjax', event => this.ajaxEvents.add(event), this.featureName, this.ee)
+    registerHandler('returnAjax', event => this.events.add(event), this.featureName, this.ee)
     // --- ^
     registerHandler('xhr', function () { // the EE-drain system not only switches "this" but also passes a new EventContext with info. Should consider platform refactor to another system which passes a mutable context around separately and predictably to avoid problems like this.
       classThis.storeXhr(...arguments, this) // this switches the context back to the class instance while passing the NR context as an argument -- see "ctx" in storeXhr
     }, this.featureName, this.ee)
 
     this.waitForFlags(([])).then(() => {
-      const scheduler = new HarvestScheduler('events', {
-        onFinished: this.onEventsHarvestFinished.bind(this),
-        getPayload: this.prepareHarvest.bind(this)
+      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()
@@ -69,10 +66,11 @@ export class Aggregate extends AggregateBase {
 
     const shouldCollect = shouldCollectEvent(params)
     const shouldOmitAjaxMetrics = this.agentRef.init.feature_flags?.includes('ajax_metrics_deny_list')
+    const jserrorsInUse = Boolean(this.agentRef.features?.[FEATURE_NAMES.jserrors])
 
-    // store for timeslice metric (harvested by jserrors feature)
-    if (shouldCollect || !shouldOmitAjaxMetrics) {
-      this.agentRef.sharedAggregator.store('xhr', hash, params, metrics)
+    // 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)
     }
 
     if (!shouldCollect) {
@@ -119,66 +117,61 @@ export class Aggregate extends AggregateBase {
     })
     if (event.gql) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/GraphQL/Bytes-Added', stringify(event.gql).length], undefined, FEATURE_NAMES.metrics, this.ee)
 
-    const softNavInUse = Boolean(getNREUMInitializedAgent(this.agentIdentifier)?.features?.[FEATURE_NAMES.softNav])
+    const softNavInUse = Boolean(this.agentRef.features?.[FEATURE_NAMES.softNav])
     if (softNavInUse) { // For newer soft nav (when running), pass the event to it for evaluation -- either part of an interaction or is given back
       handle('ajax', [event], undefined, FEATURE_NAMES.softNav, this.ee)
     } else if (ctx.spaNode) { // For old spa (when running), if the ajax happened inside an interaction, hold it until the interaction finishes
       const interactionId = ctx.spaNode.interaction.id
-      this.spaAjaxEvents[interactionId] ??= new EventBuffer()
-      this.spaAjaxEvents[interactionId].add(event)
+      this.underSpaEvents[interactionId] ??= []
+      this.underSpaEvents[interactionId].push(event)
     } else {
-      this.ajaxEvents.add(event)
+      this.events.add(event)
     }
   }
 
-  prepareHarvest (options) {
-    options = options || {}
-    if (this.ajaxEvents.buffer.length === 0) return null
-
-    const payload = this.#getPayload(this.ajaxEvents.buffer)
-    const payloadObjs = []
-
-    for (let i = 0; i < payload.length; i++) payloadObjs.push({ body: { e: payload[i] } })
-
-    if (options.retry) this.ajaxEvents.hold()
-    else this.ajaxEvents.clear()
-
-    return payloadObjs
-  }
-
-  onEventsHarvestFinished (result) {
-    if (result.retry && this.ajaxEvents.held.hasData) this.ajaxEvents.unhold()
-    else this.ajaxEvents.held.clear()
-  }
-
-  #getPayload (events, numberOfChunks) {
-    numberOfChunks = numberOfChunks || 1
-    const payload = []
-    const chunkSize = events.length / numberOfChunks
-    const eventChunks = splitChunks.call(this, events, chunkSize)
-    let tooBig = false
-    for (let i = 0; i < eventChunks.length; i++) {
-      const currentChunk = eventChunks[i]
-      if (currentChunk.tooBig) {
-        if (currentChunk.events.length > 1) {
-          tooBig = true
-          break // if the payload is too big BUT is made of more than 1 event, we can split it down again
-        }
-        // Otherwise, if it consists of one sole event, we do not send it (discarded) since we cannot break it apart any further.
-      } else {
-        payload.push(currentChunk.payload)
-      }
-    }
-    // Check if the current payload string is too big, if so then run getPayload again with more buckets.
-    return tooBig ? this.#getPayload(events, ++numberOfChunks) : payload
-
-    function splitChunks (arr, chunkSize) {
-      chunkSize = chunkSize || arr.length
-      const chunks = []
-      for (let i = 0, len = arr.length; i < len; i += chunkSize) {
-        chunks.push(new Chunk(arr.slice(i, i + chunkSize), this))
+  serializer (eventBuffer) {
+    const addString = getAddStringContext(this.agentIdentifier)
+    let payload = 'bel.7;'
+
+    for (let i = 0; i < eventBuffer.length; i++) {
+      const event = eventBuffer[i]
+      const fields = [
+        numeric(event.startTime),
+        numeric(event.endTime - event.startTime),
+        numeric(0), // callbackEnd
+        numeric(0), // no callbackDuration for non-SPA events
+        addString(event.method),
+        numeric(event.status),
+        addString(event.domain),
+        addString(event.path),
+        numeric(event.requestSize),
+        numeric(event.responseSize),
+        event.type === 'fetch' ? 1 : '',
+        addString(0), // nodeId
+        nullable(event.spanId, addString, true) + // guid
+        nullable(event.traceId, addString, true) + // traceId
+        nullable(event.spanTimestamp, numeric, false) // timestamp
+      ]
+
+      let insert = '2,'
+
+      // Since configuration objects (like info) are created new each time they are set, we have to grab the current pointer to the attr object here.
+      const jsAttributes = this.agentRef.info.jsAttributes
+
+      // add custom attributes
+      // gql decorators are added as custom attributes to alleviate need for new BEL schema
+      const attrParts = addCustomAttributes({ ...(jsAttributes || {}), ...(event.gql || {}) }, addString)
+      fields.unshift(numeric(attrParts.length))
+
+      insert += fields.join(',')
+      if (attrParts && attrParts.length > 0) {
+        insert += ';' + attrParts.join(';')
       }
-      return chunks
+      if ((i + 1) < eventBuffer.length) insert += ';'
+
+      payload += insert
     }
+
+    return payload
   }
 }

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

@@ -12,9 +12,9 @@ import { warn } from '../../../common/util/console'
 import { now } from '../../../common/timing/now'
 import { registerHandler } from '../../../common/event-emitter/register-handler'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
-import { EventBuffer } from '../../utils/event-buffer'
 import { applyFnToProps } from '../../../common/util/traverse'
 import { IDEAL_PAYLOAD_SIZE } from '../../../common/constants/agent-constants'
+import { FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
 import { UserActionsAggregator } from './user-actions/user-actions-aggregator'
 import { isIFrameWindow } from '../../../common/dom/iframe'
 
@@ -27,7 +27,6 @@ export class Aggregate extends AggregateBase {
     this.harvestTimeSeconds = agentRef.init.generic_events.harvestTimeSeconds
 
     this.referrerUrl = (isBrowserScope && document.referrer) ? cleanURL(document.referrer) : undefined
-    this.events = new EventBuffer()
 
     this.waitForFlags(['ins']).then(([ins]) => {
       if (!ins) {
@@ -36,8 +35,6 @@ export class Aggregate extends AggregateBase {
         return
       }
 
-      const preHarvestMethods = []
-
       if (agentRef.init.page_action.enabled) {
         registerHandler('api-addPageAction', (timestamp, name, attributes) => {
           this.addEvent({
@@ -55,10 +52,11 @@ export class Aggregate extends AggregateBase {
         }, this.featureName, this.ee)
       }
 
+      let addUserAction
       if (isBrowserScope && agentRef.init.user_actions.enabled) {
         this.userActionAggregator = new UserActionsAggregator()
 
-        this.addUserAction = (aggregatedUserAction) => {
+        addUserAction = (aggregatedUserAction) => {
           try {
             /** The aggregator process only returns an event when it is "done" aggregating -
              * so we still need to validate that an event was given to this method before we try to add */
@@ -87,21 +85,50 @@ export class Aggregate extends AggregateBase {
 
         registerHandler('ua', (evt) => {
           /** the processor will return the previously aggregated event if it has been completed by processing the current event */
-          this.addUserAction(this.userActionAggregator.process(evt))
+          addUserAction(this.userActionAggregator.process(evt))
         }, this.featureName, this.ee)
+      }
 
-        preHarvestMethods.push((options = {}) => {
-          /** send whatever UserActions have been aggregated up to this point
-           * if we are in a final harvest. By accessing the aggregationEvent, the aggregation is then force-cleared */
-          if (options.isFinalHarvest) this.addUserAction(this.userActionAggregator.aggregationEvent)
-        })
+      /**
+       * is it worth complicating the agent and skipping the POs for single repeating queries? maybe,
+       * but right now it was less desirable simply because it is a nice benefit of populating the event buffer
+       * immediately as events happen for payload evaluation purposes and that becomes a little more chaotic
+       * with an arbitrary query method. note: eventTypes: [...types] does not support the 'buffered' flag so we have
+       * to create up to two PO's here.
+       */
+      const performanceTypesToCapture = [...(agentRef.init.performance.capture_marks ? ['mark'] : []), ...(agentRef.init.performance.capture_measures ? ['measure'] : [])]
+      if (performanceTypesToCapture.length) {
+        try {
+          performanceTypesToCapture.forEach(type => {
+            if (PerformanceObserver.supportedEntryTypes.includes(type)) {
+              const observer = new PerformanceObserver((list) => {
+                list.getEntries().forEach(entry => {
+                  try {
+                    this.addEvent({
+                      eventType: 'BrowserPerformance',
+                      timestamp: Math.floor(agentRef.runtime.timeKeeper.correctRelativeTimestamp(entry.startTime)),
+                      entryName: entry.name,
+                      entryDuration: entry.duration,
+                      entryType: type,
+                      ...(entry.detail && { entryDetail: entry.detail })
+                    })
+                  } catch (err) {
+                  }
+                })
+              })
+              observer.observe({ buffered: true, type })
+            }
+          })
+        } catch (err) {
+        // Something failed in our set up, likely the browser does not support PO's... do nothing
+        }
       }
 
-      this.harvestScheduler = new HarvestScheduler('ins', { onFinished: (...args) => this.onHarvestFinished(...args) }, this)
-      this.harvestScheduler.harvest.on('ins', (...args) => {
-        preHarvestMethods.forEach(fn => fn(...args))
-        return this.onHarvestStarted(...args)
-      })
+      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)
 
       this.drain()
@@ -155,34 +182,17 @@ export class Aggregate extends AggregateBase {
     this.checkEventLimits()
   }
 
-  onHarvestStarted (options) {
-    const { userAttributes, atts } = this.agentRef.info
-    if (!this.events.hasData) return
-    var payload = ({
-      qs: {
-        ua: userAttributes,
-        at: atts
-      },
-      body: applyFnToProps(
-        { ins: this.events.buffer },
-        this.obfuscator.obfuscateString.bind(this.obfuscator), 'string'
-      )
-    })
-
-    if (options.retry) this.events.hold()
-    else this.events.clear()
-
-    return payload
+  serializer (eventBuffer) {
+    return applyFnToProps({ ins: eventBuffer }, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
   }
 
-  onHarvestFinished (result) {
-    if (result && result?.sent && result?.retry && this.events.held.hasData) this.events.unhold()
-    else this.events.held.clear()
+  queryStringsBuilder () {
+    return { ua: this.agentRef.info.userAttributes, at: this.agentRef.info.atts }
   }
 
   checkEventLimits () {
     // check if we've reached any harvest limits...
-    if (this.events.bytes > IDEAL_PAYLOAD_SIZE) {
+    if (this.events.byteSize() > IDEAL_PAYLOAD_SIZE) {
       this.ee.emit(SUPPORTABILITY_METRIC_CHANNEL, ['GenericEvents/Harvest/Max/Seen'])
       this.harvestScheduler.runHarvest()
     }

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

@@ -14,6 +14,8 @@ export class Instrument extends InstrumentBase {
     super(agentRef, FEATURE_NAME, auto)
     const genericEventSourceConfigs = [
       agentRef.init.page_action.enabled,
+      agentRef.init.performance.capture_marks,
+      agentRef.init.performance.capture_measures,
       agentRef.init.user_actions.enabled
       // other future generic event source configs to go here, like M&Ms, PageResouce, etc.
     ]

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

@@ -15,9 +15,8 @@ import { handle } from '../../../common/event-emitter/handle'
 import { globalScope } from '../../../common/constants/runtime'
 
 import { FEATURE_NAME } from '../constants'
-import { FEATURE_NAMES } from '../../../loaders/features/features'
+import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
 import { AggregateBase } from '../../utils/aggregate-base'
-import { getNREUMInitializedAgent } from '../../../common/window/nreum'
 import { now } from '../../../common/timing/now'
 import { applyFnToProps } from '../../../common/util/traverse'
 import { evaluateInternalError } from './internal-errors'
@@ -36,7 +35,6 @@ export class Aggregate extends AggregateBase {
     this.observedAt = {}
     this.pageviewReported = {}
     this.bufferedErrorsUnderSpa = {}
-    this.currentBody = undefined
     this.errorOnPage = false
 
     // this will need to change to match whatever ee we use in the instrument
@@ -48,12 +46,15 @@ export class Aggregate extends AggregateBase {
       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
 
     // 0 == off, 1 == on
     this.waitForFlags(['err']).then(([errFlag]) => {
       if (errFlag) {
-        const scheduler = new HarvestScheduler('jserrors', { onFinished: (...args) => this.onHarvestFinished(...args) }, this)
-        scheduler.harvest.on('jserrors', (...args) => this.onHarvestStarted(...args))
+        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 {
@@ -63,58 +64,24 @@ export class Aggregate extends AggregateBase {
     })
   }
 
-  onHarvestStarted (options) {
-    // this gets rid of dependency in AJAX module
-    var body = applyFnToProps(
-      this.agentRef.sharedAggregator.take(['err', 'ierr', 'xhr']),
-      this.obfuscator.obfuscateString.bind(this.obfuscator), 'string'
-    )
-
-    if (options.retry) {
-      this.currentBody = body
-    }
-
-    var payload = { body, qs: {} }
-    var releaseIds = stringify(this.agentRef.runtime.releaseIds)
+  serializer (aggregatorTypeToBucketsMap) {
+    return applyFnToProps(aggregatorTypeToBucketsMap, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
+  }
 
-    if (releaseIds !== '{}') {
-      payload.qs.ri = releaseIds
-    }
+  queryStringsBuilder (aggregatorTakeReturnedData) {
+    const qs = {}
+    const releaseIds = stringify(this.agentRef.runtime.releaseIds)
+    if (releaseIds !== '{}') qs.ri = releaseIds
 
-    if (body && body.err && body.err.length) {
-      this.#runCrossFeatureChecks(body.err)
+    if (aggregatorTakeReturnedData?.err?.length) {
       if (!this.errorOnPage) {
-        payload.qs.pve = '1'
+        qs.pve = '1'
         this.errorOnPage = true
       }
+      // For assurance, erase any `hasReplay` flag from all errors if replay is not recording, not-yet imported, or not running at all.
+      if (!this.agentRef.features?.[FEATURE_NAMES.sessionReplay]?.featAggregate?.replayIsActive()) aggregatorTakeReturnedData.err.forEach(error => delete error.params.hasReplay)
     }
-
-    return payload
-  }
-
-  onHarvestFinished (result) {
-    if (result.retry && this.currentBody) {
-      Object.entries(this.currentBody || {}).forEach(([key, value]) => {
-        for (var i = 0; i < value.length; i++) {
-          var bucket = value[i]
-          var name = this.getBucketName(key, bucket.params, bucket.custom)
-          this.agentRef.sharedAggregator.merge(key, name, bucket.metrics, bucket.params, bucket.custom)
-        }
-      })
-      this.currentBody = null
-    }
-  }
-
-  nameHash (params) {
-    return stringHashCode(`${params.exceptionClass}_${params.message}_${params.stack_trace || params.browser_stack_hash}`)
-  }
-
-  getBucketName (objType, params, customParams) {
-    if (objType === 'xhr') {
-      return stringHashCode(stringify(params)) + ':' + stringHashCode(stringify(customParams))
-    }
-
-    return this.nameHash(params) + ':' + stringHashCode(stringify(customParams))
+    return qs
   }
 
   /**
@@ -230,7 +197,7 @@ export class Aggregate extends AggregateBase {
       params._interactionNodeId = err.__newrelic[this.agentIdentifier].interactionNodeId
     }
 
-    const softNavInUse = Boolean(getNREUMInitializedAgent(this.agentIdentifier)?.features[FEATURE_NAMES.softNav])
+    const softNavInUse = Boolean(this.agentRef.features?.[FEATURE_NAMES.softNav])
     // Note: the following are subject to potential race cond wherein if the other feature aren't fully initialized, it'll be treated as there being no associated interaction.
     // They each will also tack on their respective properties to the params object as part of the decision flow.
     if (softNavInUse) handle('jserror', [params, time], undefined, FEATURE_NAMES.softNav, this.ee)
@@ -267,7 +234,7 @@ export class Aggregate extends AggregateBase {
 
     const jsAttributesHash = stringHashCode(stringify(allCustomAttrs))
     const aggregateHash = bucketHash + ':' + jsAttributesHash
-    this.agentRef.sharedAggregator.store(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)
@@ -297,7 +264,7 @@ export class Aggregate extends AggregateBase {
       var jsAttributesHash = stringHashCode(stringify(allCustomAttrs))
       var aggregateHash = hash + ':' + jsAttributesHash
 
-      this.agentRef.sharedAggregator.store(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)
@@ -314,27 +281,4 @@ export class Aggregate extends AggregateBase {
     )
     delete this.bufferedErrorsUnderSpa[interactionId] // wipe the list of jserrors so they aren't duplicated by another call to the same id
   }
-
-  /**
-   * Dispatches a cross-feature communication event to allow other
-   * features to provide flags and data that can be used to mutation
-   * to the payload and to allow features to know about a feature
-   * harvest happening.
-   * @param {any[]} errors Array of errors from the payload body
-   */
-  #runCrossFeatureChecks (errors) {
-    const errorHashes = errors.map(error => error.params.stackHash)
-    const crossFeatureData = {
-      errorHashes
-    }
-    this.ee.emit(`cfc.${this.featureName}`, [crossFeatureData])
-
-    let hasReplayFlag = errors.find(err => err.params.hasReplay)
-    if (hasReplayFlag && !crossFeatureData.hasReplay) {
-      // Some errors have `hasReplay` and a replay is not being recorded
-      errors.forEach(error => {
-        delete error.params.hasReplay
-      })
-    }
-  }
 }

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

@@ -10,23 +10,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 { EventBuffer } from '../../utils/event-buffer'
+import { FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
   constructor (agentRef) {
     super(agentRef, FEATURE_NAME)
-
-    /** held logs before sending */
-    this.bufferedLogs = new EventBuffer()
-
     this.harvestTimeSeconds = agentRef.init.logging.harvestTimeSeconds
 
     this.waitForFlags([]).then(() => {
-      this.scheduler = new HarvestScheduler('browser/logs', {
-        onFinished: this.onHarvestFinished.bind(this),
+      this.scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
+        onFinished: (result) => this.postHarvestCleanup(result.sent && result.retry),
         retryDelay: this.harvestTimeSeconds,
-        getPayload: this.prepareHarvest.bind(this),
+        getPayload: (options) => this.makeHarvestPayload(options.retry),
         raw: true
       }, this)
       /** emitted by instrument class (wrapped loggers) or the api methods directly */
@@ -69,65 +65,55 @@ export class Aggregate extends AggregateBase {
     )
     const logBytes = log.message.length + stringify(log.attributes).length + log.level.length + 10 // timestamp == 10 chars
 
-    if (!this.bufferedLogs.canMerge(logBytes)) {
-      if (this.bufferedLogs.hasData) {
-        handle(SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Early/Seen', this.bufferedLogs.bytes + logBytes])
-        this.scheduler.runHarvest({})
-        if (logBytes < MAX_PAYLOAD_SIZE) this.bufferedLogs.add(log)
-      } else {
-        handle(SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Failed/Seen', logBytes])
-        warn(31, log.message.slice(0, 25) + '...')
-      }
+    const failToHarvestMessage = 'Logging/Harvest/Failed/Seen'
+    if (logBytes > MAX_PAYLOAD_SIZE) { // cannot possibly send this, even with an empty buffer
+      handle(SUPPORTABILITY_METRIC_CHANNEL, [failToHarvestMessage, logBytes])
+      warn(31, log.message.slice(0, 25) + '...')
       return
     }
 
-    this.bufferedLogs.add(log)
-  }
-
-  prepareHarvest (options = {}) {
-    if (this.blocked || !this.bufferedLogs.hasData) return
-    /** These attributes are evaluated and dropped at ingest processing time and do not get stored on NRDB */
-    const unbilledAttributes = {
-      'instrumentation.provider': 'browser',
-      'instrumentation.version': this.agentRef.runtime.version,
-      'instrumentation.name': this.agentRef.runtime.loaderType
-    }
-    /** see https://source.datanerd.us/agents/rum-specs/blob/main/browser/Log for logging spec */
-    const payload = {
-      qs: {
-        browser_monitoring_key: this.agentRef.info.licenseKey
-      },
-      body: [{
-        common: {
-          /** Attributes in the `common` section are added to `all` logs generated in the payload */
-          attributes: {
-            'entity.guid': this.agentRef.runtime.appMetadata?.agents?.[0]?.entityGuid, // browser entity guid as provided from RUM response
-            session: this.agentRef.runtime.session?.state.value || '0', // The session ID that we generate and keep across page loads
-            hasReplay: this.agentRef.runtime.session?.state.sessionReplayMode === 1, // True if a session replay recording is running
-            hasTrace: this.agentRef.runtime.session?.state.sessionTraceMode === 1, // True if a session trace recording is running
-            ptid: this.agentRef.runtime.ptid, // page trace id
-            appId: this.agentRef.info.applicationID, // Application ID from info object,
-            standalone: Boolean(this.agentRef.info.sa), // copy paste (true) vs APM (false)
-            agentVersion: this.agentRef.runtime.version, // browser agent version
-            ...unbilledAttributes
-          }
-        },
-        /** logs section contains individual unique log entries */
-        logs: applyFnToProps(
-          this.bufferedLogs.buffer,
-          this.obfuscator.obfuscateString.bind(this.obfuscator), 'string'
-        )
-      }]
+    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
     }
 
-    if (options.retry) this.bufferedLogs.hold()
-    else this.bufferedLogs.clear()
+    if (!this.events.add(log)) { // still failed after a harvest attempt despite not being too large would mean harvest failed with options.retry
+      handle(SUPPORTABILITY_METRIC_CHANNEL, [failToHarvestMessage, logBytes])
+      warn(31, log.message.slice(0, 25) + '...')
+    }
+  }
 
-    return payload
+  serializer (eventBuffer) {
+    const sessionEntity = this.agentRef.runtime.session
+    return [{
+      common: {
+        /** Attributes in the `common` section are added to `all` logs generated in the payload */
+        attributes: {
+          'entity.guid': this.agentRef.runtime.appMetadata?.agents?.[0]?.entityGuid, // browser entity guid as provided from RUM response
+          ...(sessionEntity && {
+            session: sessionEntity.state.value || '0', // The session ID that we generate and keep across page loads
+            hasReplay: sessionEntity.state.sessionReplayMode === 1, // True if a session replay recording is running
+            hasTrace: sessionEntity.state.sessionTraceMode === 1 // True if a session trace recording is running
+          }),
+          ptid: this.agentRef.runtime.ptid, // page trace id
+          appId: this.agentRef.info.applicationID, // Application ID from info object,
+          standalone: Boolean(this.agentRef.info.sa), // copy paste (true) vs APM (false)
+          agentVersion: this.agentRef.runtime.version, // browser agent version
+          // The following 3 attributes are evaluated and dropped at ingest processing time and do not get stored on NRDB:
+          'instrumentation.provider': 'browser',
+          'instrumentation.version': this.agentRef.runtime.version,
+          'instrumentation.name': this.agentRef.runtime.loaderType
+        }
+      },
+      /** logs section contains individual unique log entries */
+      logs: applyFnToProps(
+        eventBuffer,
+        this.obfuscator.obfuscateString.bind(this.obfuscator), 'string'
+      )
+    }]
   }
 
-  onHarvestFinished (result) {
-    if (result.retry) this.bufferedLogs.unhold()
-    else this.bufferedLogs.held.clear()
+  queryStringsBuilder () {
+    return { browser_monitoring_key: this.agentRef.info.licenseKey }
   }
 }