@newrelic/browser-agent 1.271.0 → 1.273.0

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

@@ -5,7 +5,6 @@ export class TraceStorage {
     trace: {};
     earliestTimeStamp: number;
     latestTimeStamp: number;
-    tempStorage: any[];
     prevStoredEvents: Set<any>;
     parent: any;
     /** Central function called by all the other store__ & addToTrace API to append a trace node. */
@@ -18,10 +17,6 @@ export class TraceStorage {
     trimSTNs(lookbackDuration: number): number;
     /** Used by session trace's harvester to create the payload body. */
     takeSTNs(): {
-        stns?: undefined;
-        earliestTimeStamp?: undefined;
-        latestTimeStamp?: undefined;
-    } | {
         stns: any[];
         earliestTimeStamp: number;
         latestTimeStamp: number;
@@ -37,7 +32,16 @@ export class TraceStorage {
     storeResources(resources: any): void;
     storeErrorAgg(type: any, name: any, params: any, metrics: any): void;
     storeXhrAgg(type: any, name: any, params: any, metrics: any): void;
-    restoreNode(name: any, listOfSTNodes: any): void;
+    isEmpty(): boolean;
+    save(): void;
+    get: () => {
+        stns: any[];
+        earliestTimeStamp: number;
+        latestTimeStamp: number;
+    };
+    clear(): void;
+    reloadSave(): void;
+    clearSave(): void;
     #private;
 }
 //# sourceMappingURL=storage.d.ts.map

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.271.0",
+  "version": "1.273.0",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",
@@ -201,7 +201,8 @@
   "devDependencies": {
     "@babel/cli": "^7.23.4",
     "@babel/core": "^7.23.7",
-    "@babel/eslint-parser": "^7.23.3",
+    "@babel/eslint-parser": "^7.25.9",
+    "@babel/plugin-syntax-import-attributes": "^7.26.0",
     "@babel/plugin-transform-template-literals": "^7.24.7",
     "@babel/preset-env": "^7.23.8",
     "@babel/register": "^7.23.7",

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/config/init.js

@@ -48,9 +48,12 @@ const model = () => {
     metrics: { enabled: true, autoStart: true },
     obfuscate: undefined,
     page_action: { enabled: true },
-    user_actions: { enabled: true },
     page_view_event: { enabled: true, autoStart: true },
     page_view_timing: { enabled: true, harvestTimeSeconds: 30, autoStart: true },
+    performance: {
+      capture_marks: false,
+      capture_measures: false // false by default through experimental phase, but flipped to true once GA'd
+    },
     privacy: { cookies_enabled: true }, // *cli - per discussion, default should be true
     proxy: {
       assets: undefined, // if this value is set, it will be used to overwrite the webpack asset path used to fetch assets
@@ -105,7 +108,8 @@ const model = () => {
     session_trace: { enabled: true, harvestTimeSeconds: 10, autoStart: true },
     soft_navigations: { enabled: true, harvestTimeSeconds: 10, autoStart: true },
     spa: { enabled: true, harvestTimeSeconds: 10, autoStart: true },
-    ssl: undefined
+    ssl: undefined,
+    user_actions: { enabled: true }
   }
 }
 

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.
  */
 
 /**