@newrelic/browser-agent 1.272.0 → 1.273.0

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

@@ -1 +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,mEAuBC;IAGD,uEAcC;IAED,oDAKC;IAED,wBAwBC;IAED,uCAuBC;IAGD,gDAEC;IAID,qCAaC;IAGD,qEAGC;IAGD,mEAGC;IAED,iDAKC;;CACF"}
+{"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,2BAA4B;IAI1B,YAAoB;IAGtB,gGAAgG;IAChG,yBAcC;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAsBlB;IAED,oEAAoE;IACpE;;;;MAgBC;IAED,mEA6BC;IAED,oDAOC;IAED,mEAuBC;IAGD,uEAcC;IAED,oDAKC;IAED,wBAwBC;IAED,uCAuBC;IAGD,gDAEC;IAID,qCAaC;IAGD,qEAGC;IAGD,mEAGC;IAGD,mBAEC;IAED,aAEC;IAED;;;;MAAmB;IAEnB,cAMC;IAED,mBAEC;IAED,kBAEC;;CACF"}

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

@@ -3,17 +3,12 @@ export class Aggregate extends AggregateBase {
     constructor(agentRef: any, { domObserver }: {
         domObserver: any;
     });
-    interactionsToHarvest: EventBuffer;
+    interactionsToHarvest: any;
     domObserver: any;
     initialPageLoadInteraction: InitialPageLoadInteraction;
     latestRouteSetByApi: any;
     interactionInProgress: Interaction | null;
-    onHarvestStarted(options: any): {
-        body: {
-            e: string;
-        };
-    } | undefined;
-    onHarvestFinished(result: any): void;
+    serializer(eventBuffer: any): string;
     startUIInteraction(eventName: any, startedAt: any, sourceElem: any): void;
     setClosureHandlers(): void;
     /**
@@ -24,11 +19,10 @@ export class Aggregate extends AggregateBase {
      * @param {DOMHighResTimeStamp} timestamp
      * @returns An {@link Interaction} or undefined, if no active interaction was found.
      */
-    getInteractionFor(timestamp: DOMHighResTimeStamp): Object | undefined;
+    getInteractionFor(timestamp: DOMHighResTimeStamp): any;
     #private;
 }
 import { AggregateBase } from '../../utils/aggregate-base';
-import { EventBuffer } from '../../utils/event-buffer';
 import { InitialPageLoadInteraction } from './initial-page-load-interaction';
 import { Interaction } from './interaction';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/soft_navigations/aggregate/index.js"],"names":[],"mappings":"AAcA;IACE,2BAAiC;IACjC;;OAkDC;IA9CC,mCAA8C;IAC9C,iBAA8B;IAE9B,uDAA0F;IAW1F,yBAA+B;IAC/B,0CAAiC;IAiCnC;;;;kBAgBC;IAED,qCAGC;IAED,0EAeC;IAED,2BAiBC;IAED;;;;;;;OAOG;IACH,6BAHW,mBAAmB,sBAoB7B;;CA2FF;8BA5O6B,4BAA4B;4BAC9B,0BAA0B;2CAGX,iCAAiC;4BAChD,eAAe"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/soft_navigations/aggregate/index.js"],"names":[],"mappings":"AAaA;IACE,2BAAiC;IACjC;;OAkDC;IA9CC,2BAAwC;IACxC,iBAA8B;IAE9B,uDAA0F;IAW1F,yBAA+B;IAC/B,0CAAiC;IAiCnC,qCAUC;IAED,0EAeC;IAED,2BAiBC;IAED;;;;;;;OAOG;IACH,6BAHW,mBAAmB,OAqB7B;;CA2FF;8BAjO6B,4BAA4B;2CAGf,iCAAiC;4BAChD,eAAe"}

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/soft_navigations/instrument/index.js"],"names":[],"mappings":"AAkBA;IACE,2BAAiC;IACjC,2CA+CC;IAnCG,2CAA0C;CAoC/C;AAED,wCAAiC;+BA/DF,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/soft_navigations/instrument/index.js"],"names":[],"mappings":"AAiBA;IACE,2BAAiC;IACjC,2CA6CC;IA5BG,2CAA0C;CA6B/C;AAED,wCAAiC;+BA7DF,6BAA6B"}

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

@@ -15,12 +15,11 @@ export class Aggregate extends AggregateBase {
         childTime: number;
         depth: number;
         harvestTimeSeconds: any;
-        interactionsToHarvest: EventBuffer;
         disableSpaFix: boolean;
     };
-    serializer: Serializer;
+    spaSerializerClass: Serializer;
+    serializer(eventBuffer: any): string;
 }
 import { AggregateBase } from '../../utils/aggregate-base';
-import { EventBuffer } from '../../utils/event-buffer';
 import { Serializer } from './serializer';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/spa/aggregate/index.js"],"names":[],"mappings":"AA+BA;IACE,2BAAiC;IACjC,2BA4sBC;IAzsBC;;;;;;;;;;;;;;;;MAiBC;IAGD,uBAAsC;CAsrBzC;8BA7tB6B,4BAA4B;4BAQ9B,0BAA0B;2BAZ3B,cAAc"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/spa/aggregate/index.js"],"names":[],"mappings":"AA8BA;IACE,2BAAiC;IACjC,2BA0rBC;IAvrBe;;;;;;;;;;;;;;;MAgBb;IACD,+BAA8C;IAwqBhD,qCAEC;CACF;8BA9sB6B,4BAA4B;2BAJ/B,cAAc"}

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

@@ -1,5 +1,6 @@
 export class AggregateBase extends FeatureBase {
     agentRef: any;
+    events: any;
     obfuscator: any;
     /**
      * New handler for waiting for multiple flags. Useful when expecting multiple flags simultaneously (ex. stn vs sr)
@@ -9,6 +10,19 @@ export class AggregateBase extends FeatureBase {
     waitForFlags(flagNames?: string[]): Promise<any>;
     drain(): void;
     drained: boolean | undefined;
+    /**
+     * Return harvest payload. A "serializer" function can be defined on a derived class to format the payload.
+     * @param {Boolean} shouldRetryOnFail - harvester flag to backup payload for retry later if harvest request fails; this should be moved to harvester logic
+     * @returns final payload, or undefined if there are no pending events
+     */
+    makeHarvestPayload(shouldRetryOnFail?: boolean, opts?: {}): {
+        body: any;
+    } | undefined;
+    /**
+     * Cleanup task after a harvest.
+     * @param {Boolean} harvestFailed - harvester flag to restore events in main buffer for retry later if request failed
+     */
+    postHarvestCleanup(harvestFailed?: boolean, opts?: {}): void;
     /**
      * 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":"AAQA;IAGI,cAAwB;IAExB,gBAA6C;IAG/C;;;;OAIG;IACH,yBAHW,MAAM,EAAE,gBAwBlB;IAED,cAGC;IADC,6BAAmB;IAGrB;;;OAGG;IACH,6CA0BC;CACF;4BAhF2B,gBAAgB"}
+{"version":3,"file":"aggregate-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/aggregate-base.js"],"names":[],"mappings":"AAUA;IAGI,cAAwB;IAEwD,YAAuC;IAIvH,gBAA6C;IAG/C;;;;OAIG;IACH,yBAHW,MAAM,EAAE,gBAwBlB;IAED,cAGC;IADC,6BAAmB;IAGrB;;;;OAIG;IACH;;kBAiBC;IAED;;;OAGG;IACH,6DAGC;IAED;;;OAGG;IACH,6CA0BC;CACF;4BAvH2B,gBAAgB"}

package/dist/types/features/utils/event-buffer.d.ts

@@ -1,73 +1,36 @@
-/**
- * A container that keeps an event buffer and size with helper methods
- * @typedef {Object} EventBuffer
- * @property {number} size
- * @property {*[]} buffer
- */
-/**
- * A container that holds, evaluates, and merges event objects for harvesting
- */
 export class EventBuffer {
     /**
-     *
-     * @param {number=} maxPayloadSize
+     * @param {number} maxPayloadSize
      */
-    constructor(maxPayloadSize?: number | undefined);
+    constructor(maxPayloadSize?: number);
     maxPayloadSize: number;
+    isEmpty(): boolean;
+    get(): any[];
+    byteSize(): number;
+    wouldExceedMaxSize(incomingSize: any): boolean;
     /**
-     * buffer is read only, use the helper methods to add or clear buffer data
+     * Add feature-processed event to our buffer. If this event would cause our total raw size to exceed the set max payload size, it is dropped.
+     * @param {any} event - any primitive type or object
+     * @returns {Boolean} true if successfully added; false otherwise
      */
-    get buffer(): Object[];
+    add(event: any): boolean;
     /**
-     * bytes is read only, use the helper methods to add or clear buffer data
+     * Wipes the main buffer
      */
-    get bytes(): number;
+    clear(): void;
     /**
-     * held is another event buffer
+     * Backup the buffered data and clear the main buffer
+     * @returns {Array} the events being backed up
      */
-    get held(): EventBuffer;
+    save(): any[];
     /**
-     * Returns a boolean indicating whether the current size and buffer contain valid data
-     * @returns {boolean}
+     * Wipes the backup buffer
      */
-    get hasData(): boolean;
+    clearSave(): void;
     /**
-     * Adds an event object to the buffer while tallying size. Only adds the event if it is valid
-     * and would not make the event buffer exceed the maxPayloadSize.
-     * @param {Object} event the event object to add to the buffer
-     * @returns {EventBuffer} returns the event buffer for chaining
+     * Prepend the backup buffer back into the main buffer
      */
-    add(event: Object): EventBuffer;
-    /**
-     * clear the buffer data
-     * @returns {EventBuffer}
-     */
-    clear(): EventBuffer;
-    /**
-     * Hold the buffer data in a new (child) EventBuffer (.held) to unblock the main buffer.
-     * This action clears the main buffer
-     * @returns {EventBuffer}
-     */
-    hold(): EventBuffer;
-    /**
-     * Prepend the held EventBuffer (.held) back into the main buffer
-     * This action clears the held buffer
-     * @returns {EventBuffer}
-     */
-    unhold(): EventBuffer;
-    /**
-     * Merges an EventBuffer into this EventBuffer
-     * @param {EventBuffer} events an EventBuffer intended to merge with this EventBuffer
-     * @param {boolean} prepend if true, the supplied events will be prepended before the events of this class
-     * @returns {EventBuffer} returns the event buffer for chaining
-     */
-    merge(eventBuffer: any, prepend?: boolean): EventBuffer;
-    /**
-     * Returns a boolean indicating the resulting size of a merge would be valid. Compares against the maxPayloadSize provided at initialization time.
-     * @param {number} size
-     * @returns {boolean}
-     */
-    canMerge(size: number): boolean;
+    reloadSave(): void;
     #private;
 }
 //# sourceMappingURL=event-buffer.d.ts.map

package/dist/types/features/utils/event-buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-buffer.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/event-buffer.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AAEH;;GAEG;AACH;IAQE;;;OAGG;IACH,6BAFW,MAAM,YAAC,EAIjB;IADC,uBAAoC;IAGtC;;OAEG;IACH,uBAEC;IAED;;OAEG;IACH,oBAEC;IAED;;OAEG;IACH,wBAGC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;OAKG;IACH,WAHW,MAAM,GACJ,WAAW,CAQvB;IAED;;;OAGG;IACH,SAFa,WAAW,CAMvB;IAED;;;;OAIG;IACH,QAFa,WAAW,CAMvB;IAED;;;;OAIG;IACH,UAFa,WAAW,CAMvB;IAED;;;;;OAKG;IACH,kCAHW,OAAO,GACL,WAAW,CAOvB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;;CACF"}
+{"version":3,"file":"event-buffer.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/event-buffer.js"],"names":[],"mappings":"AAGA;IAME;;OAEG;IACH,6BAFW,MAAM,EAIhB;IADC,uBAAoC;IAGtC,mBAEC;IAED,aAEC;IAED,mBAEC;IAED,+CAEC;IAED;;;;OAIG;IACH,WAHW,GAAG,WASb;IAED;;OAEG;IACH,cAGC;IAED;;;OAGG;IACH,cAGC;IAED;;OAEG;IACH,kBAGC;IAED;;OAEG;IACH,mBAKC;;CACF"}

package/dist/types/loaders/features/features.d.ts

@@ -19,4 +19,7 @@ export namespace FEATURE_NAMES {
 export const featurePriority: {
     [x: string]: number;
 };
+export const FEATURE_TO_ENDPOINT: {
+    [x: string]: string;
+};
 //# sourceMappingURL=features.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../../../src/loaders/features/features.js"],"names":[],"mappings":";;;;;;;;;;;;;;AAkBA;;;GAGG;AACH;;EAYC"}
+{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../../../src/loaders/features/features.js"],"names":[],"mappings":";;;;;;;;;;;;;;AAkBA;;;GAGG;AACH;;EAYC;AAED;;EAWC"}

package/package.json

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

package/src/common/aggregate/aggregator.js

@@ -2,12 +2,8 @@
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import { SharedContext } from '../context/shared-context'
-
-export class Aggregator extends SharedContext {
-  constructor (parent) {
-    super(parent)
+export class Aggregator {
+  constructor () {
     this.aggregatedData = {}
   }
 
@@ -16,13 +12,14 @@ export class Aggregator extends SharedContext {
   // metrics are the numeric values to be aggregated
 
   store (type, name, params, newMetrics, customParams) {
-    var bucket = this.getBucket(type, name, params, customParams)
+    var bucket = this.#getBucket(type, name, params, customParams)
     bucket.metrics = aggregateMetrics(newMetrics, bucket.metrics)
     return bucket
   }
 
-  merge (type, name, metrics, params, customParams) {
-    var bucket = this.getBucket(type, name, params, customParams)
+  merge (type, name, metrics, params, customParams, overwriteParams = false) {
+    var bucket = this.#getBucket(type, name, params, customParams)
+    if (overwriteParams) bucket.params = params // replace current params with incoming params obj
 
     if (!bucket.metrics) {
       bucket.metrics = metrics
@@ -50,32 +47,13 @@ export class Aggregator extends SharedContext {
   }
 
   storeMetric (type, name, params, value) {
-    var bucket = this.getBucket(type, name, params)
+    var bucket = this.#getBucket(type, name, params)
     bucket.stats = updateMetric(value, bucket.stats)
     return bucket
   }
 
-  getBucket (type, name, params, customParams) {
-    if (!this.aggregatedData[type]) this.aggregatedData[type] = {}
-    var bucket = this.aggregatedData[type][name]
-    if (!bucket) {
-      bucket = this.aggregatedData[type][name] = { params: params || {} }
-      if (customParams) {
-        bucket.custom = customParams
-      }
-    }
-    return bucket
-  }
-
-  get (type, name) {
-    // if name is passed, get a single bucket
-    if (name) return this.aggregatedData[type] && this.aggregatedData[type][name]
-    // else, get all buckets of that type
-    return this.aggregatedData[type]
-  }
-
-  // Like get, but for many types and it deletes the retrieved content from the aggregatedData
-  take (types) {
+  // Get all listed types buckets and it deletes the retrieved content from the aggregatedData
+  take (types, deleteWhenRetrieved = true) {
     var results = {}
     var type = ''
     var hasData = false
@@ -84,10 +62,22 @@ export class Aggregator extends SharedContext {
       results[type] = Object.values(this.aggregatedData[type] || {})
 
       if (results[type].length) hasData = true
-      delete this.aggregatedData[type]
+      if (deleteWhenRetrieved) delete this.aggregatedData[type]
     }
     return hasData ? results : null
   }
+
+  #getBucket (type, name, params, customParams) {
+    if (!this.aggregatedData[type]) this.aggregatedData[type] = {}
+    var bucket = this.aggregatedData[type][name]
+    if (!bucket) {
+      bucket = this.aggregatedData[type][name] = { params: params || {} }
+      if (customParams) {
+        bucket.custom = customParams
+      }
+    }
+    return bucket
+  }
 }
 
 function aggregateMetrics (newMetrics, oldMetrics) {

package/src/common/aggregate/event-aggregator.js

@@ -0,0 +1,76 @@
+import { Aggregator } from './aggregator'
+
+/**
+ * An extension of the Aggregator class that provides an interface similar to that of EventBuffer class.
+ * This typecasting allow features that uses Aggregator as their event handler to share the same AggregateBase.events utilization by those features.
+ */
+export class EventAggregator {
+  #aggregator = new Aggregator()
+  #savedNamesToBuckets = {}
+
+  isEmpty ({ aggregatorTypes }) {
+    if (!aggregatorTypes) return Object.keys(this.#aggregator.aggregatedData).length === 0
+    return aggregatorTypes.every(type => !this.#aggregator.aggregatedData[type]) // no bucket exist for any of the types we're looking for
+  }
+
+  add (type, name, params, newMetrics, customParams) {
+    // Do we need to track byte size here like EventBuffer?
+    this.#aggregator.store(type, name, params, newMetrics, customParams)
+    return true
+  }
+
+  addMetric (type, name, params, value) {
+    this.#aggregator.storeMetric(type, name, params, value)
+    return true
+  }
+
+  save ({ aggregatorTypes }) {
+    const key = aggregatorTypes.toString() // the stringified types serve as the key to each save call, e.g. ['err', 'ierr', 'xhr'] => 'err,ierr,xhr'
+    const backupAggregatedDataSubset = {}
+    aggregatorTypes.forEach(type => (backupAggregatedDataSubset[type] = this.#aggregator.aggregatedData[type])) // make a subset of the aggregatedData for each of the types we want to save
+    this.#savedNamesToBuckets[key] = backupAggregatedDataSubset
+    /*
+    { 'err,ierr,xhr': {
+        'err': {
+            <aggregateHash>: { metrics: { count: 1, time, ... }, params: {}, custom: {} },
+            <otherHashName>: { metrics: { count: 1, ... }, ... }
+        },
+        'ierr': { ... },
+        'xhr': { ... }
+      }
+    }
+    */
+  }
+
+  get (opts) {
+    const aggregatorTypes = Array.isArray(opts) ? opts : opts.aggregatorTypes
+    return this.#aggregator.take(aggregatorTypes, false)
+  }
+
+  clear ({ aggregatorTypes } = {}) {
+    if (!aggregatorTypes) {
+      this.#aggregator.aggregatedData = {}
+      return
+    }
+    aggregatorTypes.forEach(type => delete this.#aggregator.aggregatedData[type])
+  }
+
+  reloadSave ({ aggregatorTypes }) {
+    const key = aggregatorTypes.toString()
+    const backupAggregatedDataSubset = this.#savedNamesToBuckets[key]
+    // Grabs the previously stored subset and merge it back into aggregatedData.
+    aggregatorTypes.forEach(type => {
+      Object.keys(backupAggregatedDataSubset[type] || {}).forEach(name => {
+        const bucket = backupAggregatedDataSubset[type][name]
+        // The older aka saved params take effect over the newer one. This is especially important when merging back for a failed harvest retry if, for example,
+        // the first-ever occurrence of an error is in the retry: it contains the params.stack_trace whereas the newer or current bucket.params would not.
+        this.#aggregator.merge(type, name, bucket.metrics, bucket.params, bucket.custom, true)
+      })
+    })
+  }
+
+  clearSave ({ aggregatorTypes }) {
+    const key = aggregatorTypes.toString()
+    delete this.#savedNamesToBuckets[key]
+  }
+}

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

@@ -98,7 +98,7 @@ export class HarvestScheduler extends SharedContext {
     let payload
 
     if (this.opts.getPayload) {
-      // Ajax & PVT & SR features provide a callback function to get data for harvesting
+      // Ajax, PVT, Softnav, Logging, SR & ST features provide a single callback function to get data for harvesting
       submitMethod = submitData.getSubmitMethod({ isFinalHarvest: opts?.unload })
       if (!submitMethod) return false
 

package/src/common/harvest/harvest.js

@@ -106,11 +106,7 @@ export class Harvest extends SharedContext {
     const gzip = !!qs?.attributes?.includes('gzip')
 
     if (!gzip) {
-      if (endpoint === 'events') {
-        body = body.e
-      } else {
-        body = stringify(body)
-      }
+      if (endpoint !== 'events') body = stringify(body) // all features going to /events/ endpoint should already be serialized & stringified
       /** Warn --once per endpoint-- if the agent tries to send large payloads */
       if (body.length > 750000 && (warnings[endpoint] = (warnings?.[endpoint] || 0) + 1) === 1) warn(28, endpoint)
     }

package/src/common/harvest/types.js

@@ -12,7 +12,6 @@
  * @typedef {object} HarvestPayload
  * @property {object} qs Map of values that should be sent as part of the request query string.
  * @property {object} body Map of values that should be sent as the body of the request.
- * @property {string} body.e Special case of body used for browser interactions.
  */
 
 /**

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
   }
 }