@newrelic/browser-agent 1.276.0 → 1.278.0

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":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/soft_navigations/aggregate/index.js"],"names":[],"mappings":"AAYA;IACE,2BAAiC;IACjC;;OAkDC;IA/CC,2BAAwC;IACxC,iBAA8B;IAE9B,uDAA0F;IAa1F,yBAA+B;IAC/B,0CAAiC;IACjC,sBAA4B;IA+B9B,qCAUC;IAED,0EAiBC;IAED,2BAiBC;IAED;;;;;;;OAOG;IACH,6BAHW,mBAAmB,OAqB7B;;CA6FF;8BArO6B,4BAA4B;2CAGf,iCAAiC;4BAChD,eAAe"}

package/dist/types/features/soft_navigations/aggregate/initial-page-load-interaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initial-page-load-interaction.d.ts","sourceRoot":"","sources":["../../../../../src/features/soft_navigations/aggregate/initial-page-load-interaction.js"],"names":[],"mappings":"AAOA;IACE,kCAKC;IAED,sBAAqD;IACrD,gCAAyE;IAEzE;;;OAGG;IACH,oCA6BC;CACF;4BAnD2B,eAAe"}
+{"version":3,"file":"initial-page-load-interaction.d.ts","sourceRoot":"","sources":["../../../../../src/features/soft_navigations/aggregate/initial-page-load-interaction.js"],"names":[],"mappings":"AAQA;IACE,kCAKC;IAED,sBAAqD;IACrD,gCAAyE;IAEzE;;;OAGG;IACH,oCA6BC;CACF;4BApD2B,eAAe"}

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

@@ -2,11 +2,9 @@
  * link https://github.com/newrelic/nr-querypack/blob/main/schemas/bel/7.qpschema
  **/
 export class Interaction extends BelNode {
-    constructor(agentIdentifier: any, uiEvent: any, uiEventTimestamp: any, currentRouteKnown: any);
+    constructor(agentIdentifier: any, uiEvent: any, uiEventTimestamp: any, currentRouteKnown: any, currentUrl: any);
     id: string;
     initialPageURL: string;
-    oldURL: string;
-    newURL: string;
     customName: any;
     customAttributes: {};
     customDataByApi: {};
@@ -27,6 +25,8 @@ export class Interaction extends BelNode {
     eventSubscription: Map<string, never[]>;
     forceSave: boolean;
     forceIgnore: boolean;
+    newURL: any;
+    oldURL: any;
     updateDom(timestamp: any): void;
     updateHistory(timestamp: any, newUrl: any): void;
     seenHistoryAndDomChange(): boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../../../../../src/features/soft_navigations/aggregate/interaction.js"],"names":[],"mappings":"AASA;;IAEI;AACJ;IAoBE,+FAYC;IA/BD,WAAmB;IACnB,uBAAgC;IAChC,eAAmC;IACnC,eAAmC;IACnC,gBAAU;IACV,qBAAqB;IACrB,oBAAoB;IACpB,eAAS;IACT,aAAO;IACP,cAAQ;IACR,+EAA+E;IAC/E,eAA8B;IAC9B,qBAAgB;IAChB,yBAAoB;IACpB,sBAAoB;IACpB,6BAA2B;IAC3B,cAAW;IACX,uBAAiB;IAIf,gBAAoC;IACpC,aAAsB;IAEtB,cAAiC;IACjC,wCAGE;IACF,mBAAyC;IAAxB,qBAAwB;IAI3C,gCAEC;IAED,iDAGC;IAED,mCAEC;IAED,8BAIC;IAED,kCAUC;IAwBD;;;;;OAKG;IACH,0BAHW,mBAAmB,WAM7B;IAGD,uBAAoB;IACpB,iCAA8B;IAC9B,sBAAmB;IAEnB,gDA2CC;;CACF;wBAxJuB,YAAY"}
+{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../../../../../src/features/soft_navigations/aggregate/interaction.js"],"names":[],"mappings":"AASA;;IAEI;AACJ;IAkBE,gHAaC;IA9BD,WAAmB;IACnB,uBAAgC;IAChC,gBAAU;IACV,qBAAqB;IACrB,oBAAoB;IACpB,eAAS;IACT,aAAO;IACP,cAAQ;IACR,+EAA+E;IAC/E,eAA8B;IAC9B,qBAAgB;IAChB,yBAAoB;IACpB,sBAAoB;IACpB,6BAA2B;IAC3B,cAAW;IACX,uBAAiB;IAIf,gBAAoC;IACpC,aAAsB;IAEtB,cAAiC;IACjC,wCAGE;IACF,mBAAyC;IAAxB,qBAAwB;IAEzC,YAAsE;IAAxD,YAAwD;IAGxE,gCAEC;IAED,iDAGC;IAED,mCAEC;IAED,8BAIC;IAED,kCAaC;IAsBD;;;;;OAKG;IACH,0BAHW,mBAAmB,WAM7B;IAGD,uBAAoB;IACpB,iCAA8B;IAC9B,sBAAmB;IAEnB,gDA4CC;;CACF;wBAzJuB,YAAY"}

package/dist/types/features/soft_navigations/constants.d.ts

@@ -1,5 +1,6 @@
 export const INTERACTION_TRIGGERS: string[];
 export const API_TRIGGER_NAME: "api";
+export const IPL_TRIGGER_NAME: "initialPageLoad";
 export const FEATURE_NAME: string;
 export namespace INTERACTION_TYPE {
     let INITIAL_PAGE_LOAD: string;

package/dist/types/features/soft_navigations/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/soft_navigations/constants.js"],"names":[],"mappings":"AAEA,4CAIC;AACD,qCAAqC;AAErC,kCAAiD"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/soft_navigations/constants.js"],"names":[],"mappings":"AAEA,4CAKC;AACD,qCAAqC;AACrC,iDAAiD;AAEjD,kCAAiD"}

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

@@ -14,7 +14,6 @@ export class Aggregate extends AggregateBase {
         pageLoaded: boolean;
         childTime: number;
         depth: number;
-        harvestTimeSeconds: any;
         disableSpaFix: boolean;
     };
     spaSerializerClass: Serializer;

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":"AA8BA;IACE,2BAAiC;IACjC,2BA0rBC;IAvrBe;;;;;;;;;;;;;;;MAgBb;IACD,+BAA8C;IAwqBhD,qCAEC;CACF;8BA9sB6B,4BAA4B;2BAJ/B,cAAc"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/spa/aggregate/index.js"],"names":[],"mappings":"AA6BA;IACE,2BAAiC;IACjC,2BAwrBC;IArrBe;;;;;;;;;;;;;;MAeb;IACD,+BAA8C;IAuqBhD,qCAEC;CACF;8BA5sB6B,4BAA4B;2BAJ/B,cAAc"}

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

@@ -1,7 +1,7 @@
 export class AggregateBase extends FeatureBase {
     agentRef: any;
     events: any;
-    obfuscator: any;
+    harvestOpts: {};
     /**
      * New handler for waiting for multiple flags. Useful when expecting multiple flags simultaneously (ex. stn vs sr)
      * @param {string[]} flagNames
@@ -13,21 +13,26 @@ export class AggregateBase extends FeatureBase {
     /**
      * 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
+     * @param {object|undefined} target - the target app passed onto the event store manager to determine which app's data to return; if none provided, all apps data will be returned
+     * @returns {Array} Final payload tagged with their targeting browser app. The value of `payload` can be undefined if there are no pending events for an app. This should be a minimum length of 1.
      */
-    makeHarvestPayload(shouldRetryOnFail?: boolean, opts?: {}): {
-        body: any;
-    } | undefined;
+    makeHarvestPayload(shouldRetryOnFail: boolean | undefined, target: object | undefined): any[];
     /**
      * Cleanup task after a harvest.
-     * @param {Boolean} harvestFailed - harvester flag to restore events in main buffer for retry later if request failed
+     * @param {object} result - the cbResult object from the harvester's send method
      */
-    postHarvestCleanup(harvestFailed?: boolean, opts?: {}): void;
+    postHarvestCleanup(result?: object): 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.
      */
     checkConfiguration(existingAgent: any): void;
+    /**
+     * These are actions related to shared resources that should be initialized once by whichever feature Aggregate subclass loads first.
+     * This method should run after checkConfiguration, which may reset the agent's info/runtime object that is used here.
+     */
+    doOnceForAllAggregate(agentRef: any): void;
+    obfuscator: any;
 }
 import { FeatureBase } from './feature-base';
 //# sourceMappingURL=aggregate-base.d.ts.map

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":"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"}
+{"version":3,"file":"aggregate-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/aggregate-base.js"],"names":[],"mappings":"AAWA;IAGI,cAAwB;IAcpB,YAAuC;IAM3C,gBAAqB;IAGvB;;;;OAIG;IACH,yBAHW,MAAM,EAAE,gBAwBlB;IAED,cAGC;IADC,6BAAmB;IAGrB;;;;;OAKG;IACH,mEAHW,MAAM,GAAC,SAAS,SAwB1B;IAED;;;OAGG;IACH,4BAFW,MAAM,QAMhB;IAED;;;OAGG;IACH,6CAsBC;IAED;;;OAGG;IACH,2CASC;IAPC,gBAA6C;CAQhD;4BAvJ2B,gBAAgB"}

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

@@ -20,9 +20,8 @@ export class EventBuffer {
     clear(): void;
     /**
      * Backup the buffered data and clear the main buffer
-     * @returns {Array} the events being backed up
      */
-    save(): any[];
+    save(): void;
     /**
      * Wipes the backup buffer
      */

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;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"}
+{"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;;OAEG;IACH,aAGC;IAED;;OAEG;IACH,kBAGC;IAED;;OAEG;IACH,mBAKC;;CACF"}

package/dist/types/features/utils/event-store-manager.d.ts

@@ -0,0 +1,43 @@
+/**
+ * This layer allows multiple browser entity apps, or "target", to each have their own segregated storage instance.
+ * The purpose is so the harvester can send data to different apps within the same agent. Each feature should have a manager if it needs this capability.
+ */
+export class EventStoreManager {
+    /**
+     * @param {object} defaultTarget - should contain licenseKey and appId of the main app from NREUM.info at startup
+     * @param {1|2} storageChoice - the type of storage to use in this manager; 'EventBuffer' (1), 'EventAggregator' (2)
+     */
+    constructor(defaultTarget: object, storageChoice: 1 | 2);
+    mainApp: object;
+    StorageClass: typeof EventAggregator | typeof EventBuffer;
+    appStorageMap: Map<any, any>;
+    /**
+     * @param {object} optsIfPresent - exists if called during harvest interval, @see AggregateBase.makeHarvestPayload
+     * @param {object} target - specific app's storage to check; if not provided, this method takes into account all apps recorded by this manager
+     * @returns {boolean} True if the target's storage is empty, or target does not exist in map (defaults to all storages)
+     */
+    isEmpty(optsIfPresent: object, target: object): boolean;
+    /**
+     * @param {string} event - the event element to store
+     * @param {object} target - the app to store event under; if not provided, this method adds to the main app from NREUM.info
+     * @returns {boolean} True if the event was successfully added
+     */
+    add(event: string, target: object): boolean;
+    /** This is only used by the Metrics feature which has no need to add metric under a different app atm. */
+    addMetric(type: any, name: any, params: any, value: any): any;
+    /**
+     * @param {object} optsIfPresent - exists if called during harvest interval, @see AggregateBase.makeHarvestPayload
+     * @param {object} target - specific app to fetch; if not provided, this method fetches from all apps
+     * @returns {Array} Objects of `data` labeled with their respective `target` app to be sent to
+     */
+    get(optsIfPresent: object, target: object): any[];
+    byteSize(target: any): any;
+    wouldExceedMaxSize(incomingSize: any, target: any): any;
+    save(optsIfPresent: any, target: any): any;
+    clear(optsIfPresent: any, target: any): any;
+    reloadSave(optsIfPresent: any, target: any): any;
+    clearSave(optsIfPresent: any, target: any): any;
+}
+import { EventAggregator } from '../../common/aggregate/event-aggregator';
+import { EventBuffer } from './event-buffer';
+//# sourceMappingURL=event-store-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"event-store-manager.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/event-store-manager.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IACE;;;OAGG;IACH,2BAHW,MAAM,iBACN,CAAC,GAAC,CAAC,EAOb;IAJC,gBAA4B;IAC5B,0DAAuE;IACvE,6BAA8B;IAMhC;;;;OAIG;IACH,uBAJW,MAAM,UACN,MAAM,GACJ,OAAO,CAWnB;IAED;;;;OAIG;IACH,WAJW,MAAM,UACN,MAAM,GACJ,OAAO,CAKnB;IAED,0GAA0G;IAC1G,8DAEC;IAED;;;;OAIG;IACH,mBAJW,MAAM,UACN,MAAM,SAUhB;IAED,2BAEC;IAED,wDAEC;IAED,2CAGC;IAED,4CAGC;IAGD,iDAMC;IAED,gDAMC;CACF;gCApG+B,yCAAyC;4BAC7C,gBAAgB"}

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

@@ -23,7 +23,6 @@ export class InstrumentBase extends FeatureBase {
     /**
      * @type {Promise} Assigned immediately after @see importAggregator runs. Serves as a signal for when the inner async fn finishes execution. Useful for features to await
      * one another if there are inter-features dependencies.
-     * TODO: This is only used for the SPA feature component tests and should be refactored out.
     */
     onAggregateImported: Promise<any>;
     /**

package/dist/types/features/utils/instrument-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instrument-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/instrument-base.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH;IACE;;;;;;;OAOG;IACH,wCALW,MAAM,8BAsChB;IA/BC,cAAgB;IAEhB,8IAA8I;IAC9I,cADW,WAAW,SAAS,CACF;IAE7B;;;MAGE;IACF,eAHU,OAAO,kBAAkB,EAAE,aAAa,CAGpB;IAE9B;;;;MAIE;IACF,kCAAoC;IAiBtC;;;;;;OAMG;IACH,kFAwDC;;CAkBF;4BA1I2B,gBAAgB"}
+{"version":3,"file":"instrument-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/instrument-base.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH;IACE;;;;;;;OAOG;IACH,wCALW,MAAM,8BAqChB;IA9BC,cAAgB;IAEhB,8IAA8I;IAC9I,cADW,WAAW,SAAS,CACF;IAE7B;;;MAGE;IACF,eAHU,OAAO,kBAAkB,EAAE,aAAa,CAGpB;IAE9B;;;MAGE;IACF,kCAAoC;IAiBtC;;;;;;OAMG;IACH,kFAmDC;;CAkBF;4BApI2B,gBAAgB"}

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

@@ -9,6 +9,7 @@ export function setAPI(agentIdentifier: any, forceDrain: any, runSoftNavOverSpa?
         level?: string | undefined;
     }): void;
     addPageAction: (...args: any[]) => any;
+    recordCustomEvent: (...args: any[]) => any;
     setPageViewName(name: any, host: any): any;
     setCustomAttribute(name: any, value: any, persistAttribute?: boolean): any;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/api.js"],"names":[],"mappings":"AAuBA,2CAiBC;AAID;;;;;;;;;;;;IAiEE;;;;OAIG;qBAFQ,MAAM;IAWjB;;;;OAIG;iCAFQ,MAAM,GAAC,IAAI;;;;;EAiGvB"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/api.js"],"names":[],"mappings":"AAuBA,2CAiBC;AAID;;;;;;;;;;;;;IAmEE;;;;OAIG;qBAFQ,MAAM;IAWjB;;;;OAIG;iCAFQ,MAAM,GAAC,IAAI;;;;;EAiGvB"}

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

@@ -1,16 +1,19 @@
+export const EVENTS: "events";
+export const JSERRORS: "jserrors";
+export const RUM: "rum";
 export namespace FEATURE_NAMES {
-    let ajax: string;
-    let genericEvents: string;
-    let jserrors: string;
-    let logging: string;
-    let metrics: string;
-    let pageAction: string;
-    let pageViewEvent: string;
-    let pageViewTiming: string;
-    let sessionReplay: string;
-    let sessionTrace: string;
-    let softNav: string;
-    let spa: string;
+    export let ajax: string;
+    export let genericEvents: string;
+    export { JSERRORS as jserrors };
+    export let logging: string;
+    export let metrics: string;
+    export let pageAction: string;
+    export let pageViewEvent: string;
+    export let pageViewTiming: string;
+    export let sessionReplay: string;
+    export let sessionTrace: string;
+    export let softNav: string;
+    export let spa: string;
 }
 /**
  * The order in which features will be instrumented. This is the traditional order. It's unclear if the order of

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;AAED;;EAWC"}
+{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../../../src/loaders/features/features.js"],"names":[],"mappings":"AACA,8BAA8B;AAC9B,kCAAkC;AAElC,wBAAwB;;;;;;;;;;;;;;;AAoBxB;;;GAGG;AACH;;EAYC;AAED;;EAYC"}

package/dist/types/loaders/micro-agent-base.d.ts

@@ -8,6 +8,13 @@ export class MicroAgentBase {
      * @param {object} [attributes] JSON object with one or more key/value pairs. For example: {key:"value"}. The key is reported as its own PageAction attribute with the specified values.
      */
     addPageAction(name: string, attributes?: object | undefined): any;
+    /**
+     * Records a custom event with a specified eventType and attributes.
+     * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/recordCustomEvent/}
+     * @param {string} eventType The eventType to store the event as.
+     * @param {object} [attributes] JSON object with one or more key/value pairs. For example: {key:"value"}.
+     */
+    recordCustomEvent(eventType: string, attributes?: object | undefined): any;
     /**
      * Groups page views to help URL structure or to capture the URL's routing information.
      * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setpageviewname/}

package/dist/types/loaders/micro-agent-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"micro-agent-base.d.ts","sourceRoot":"","sources":["../../../src/loaders/micro-agent-base.js"],"names":[],"mappings":"AAGA;IAGE,sCAEC;IAJD,wBAAe;IAkBf;;;;;OAKG;IACH,oBAHW,MAAM,wCAKhB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,kCAKhB;IAED;;;;;;OAMG;IACH,yBAJW,MAAM,SACN,MAAM,GAAC,MAAM,GAAC,OAAO,GAAC,IAAI,sCAKpC;IAED;;;;;OAKG;IACH,mBAHW,KAAK,GAAC,MAAM,8CAKtB;IAED;;;;OAIG;IACH,iBAFW,MAAM,GAAC,IAAI,OAIrB;IAED;;;;;;;OAOG;IACH,6BAJW,MAAM,GAAC,IAAI,OAMrB;IAED;;;;OAIG;IACH,0BAFW,CAAC,KAAK,EAAE,KAAK,GAAC,MAAM,KAAK,OAAO,GAAG;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,OAI9D;IAED;;;;;OAKG;IACH,iBAHW,MAAM,MACN,MAAM,OAIhB;IAED;;;;;MAKE;IACF,aAHW,MAAM;2BACc,MAAM;gBAAU,OAAO,GAAC,OAAO,GAAC,OAAO,GAAC,MAAM,GAAC,MAAM;wBAInF;;CACF"}
+{"version":3,"file":"micro-agent-base.d.ts","sourceRoot":"","sources":["../../../src/loaders/micro-agent-base.js"],"names":[],"mappings":"AAGA;IAGE,sCAEC;IAJD,wBAAe;IAkBf;;;;;OAKG;IACH,oBAHW,MAAM,wCAKhB;IAED;;;;;OAKG;IACH,6BAHW,MAAM,wCAKhB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,kCAKhB;IAED;;;;;;OAMG;IACH,yBAJW,MAAM,SACN,MAAM,GAAC,MAAM,GAAC,OAAO,GAAC,IAAI,sCAKpC;IAED;;;;;OAKG;IACH,mBAHW,KAAK,GAAC,MAAM,8CAKtB;IAED;;;;OAIG;IACH,iBAFW,MAAM,GAAC,IAAI,OAIrB;IAED;;;;;;;OAOG;IACH,6BAJW,MAAM,GAAC,IAAI,OAMrB;IAED;;;;OAIG;IACH,0BAFW,CAAC,KAAK,EAAE,KAAK,GAAC,MAAM,KAAK,OAAO,GAAG;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,OAI9D;IAED;;;;;OAKG;IACH,iBAHW,MAAM,MACN,MAAM,OAIhB;IAED;;;;;MAKE;IACF,aAHW,MAAM;2BACc,MAAM;gBAAU,OAAO,GAAC,OAAO,GAAC,OAAO,GAAC,MAAM,GAAC,MAAM;wBAInF;;CACF"}

package/dist/types/loaders/micro-agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"micro-agent.d.ts","sourceRoot":"","sources":["../../../src/loaders/micro-agent.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH;IACE;;;OAGG;IACH,qBAHW,MAAM,oBACN,MAAM,YAAC,EAqDjB;IAhDC,aAAkB;IAMlB;;;;OAIG;IACH,iEAkCC;IAKH;;;;;MAOC;CACF;+BAhF8B,oBAAoB"}
+{"version":3,"file":"micro-agent.d.ts","sourceRoot":"","sources":["../../../src/loaders/micro-agent.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH;IACE;;;OAGG;IACH,qBAHW,MAAM,oBACN,MAAM,YAAC,EAsDjB;IAjDC,aAAkB;IAMlB;;;;OAIG;IACH,iEAmCC;IAKH;;;;;MAOC;CACF;+BAjF8B,oBAAoB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.276.0",
+  "version": "1.278.0",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",
@@ -228,9 +228,9 @@
     "@newrelic/nr-querypack": "https://git@github.com/newrelic/nr-querypack",
     "@wdio/cli": "^8.27.0",
     "@wdio/local-runner": "^8.27.0",
-    "@wdio/logger": "^8.24.12",
+    "@wdio/logger": "^9.4.4",
     "@wdio/mocha-framework": "^8.27.0",
-    "@wdio/spec-reporter": "^8.27.0",
+    "@wdio/spec-reporter": "^9.5.0",
     "babel-jest": "^29.7.0",
     "babel-loader": "^9.1.3",
     "babel-plugin-transform-inline-environment-variables": "^0.4.4",
@@ -243,7 +243,7 @@
     "eslint-plugin-promise": "^6.1.1",
     "eslint-plugin-sonarjs": "^0.23.0",
     "fastify": "^4.25.2",
-    "fastify-plugin": "^4.5.1",
+    "fastify-plugin": "^5.0.1",
     "form-data": "^4.0.0",
     "fs-extra": "^11.2.0",
     "glob": "^11.0.0",
@@ -256,7 +256,7 @@
     "jest": "^29.7.0",
     "jest-environment-jsdom": "29.7.0",
     "jest-extended": "^4.0.2",
-    "jsonpath-plus": "^9.0.0",
+    "jsonpath-plus": "^10.0.7",
     "jung": "^2.1.0",
     "node-fetch": "^3.3.2",
     "npm-run-all": "^4.1.5",
@@ -264,7 +264,7 @@
     "terser-webpack-plugin": "^5.3.10",
     "tsd": "^0.30.0",
     "typescript": "^5.3.3",
-    "uuid": "^10.0.0",
+    "uuid": "^11.0.3",
     "wait-on": "^8.0.0",
     "wdio-lambdatest-service": "^3.0.1",
     "webpack": "^5.89.0",

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

@@ -13,7 +13,7 @@ export class EventAggregator {
     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) {
+  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

package/src/common/config/init.js

@@ -39,7 +39,7 @@ const model = () => {
     }
   }
   return {
-    ajax: { deny_list: undefined, block_internal: true, enabled: true, harvestTimeSeconds: 10, autoStart: true },
+    ajax: { deny_list: undefined, block_internal: true, enabled: true, autoStart: true },
     distributed_tracing: {
       enabled: undefined,
       exclude_newrelic_header: undefined,
@@ -49,15 +49,15 @@ const model = () => {
     },
     get feature_flags () { return hiddenState.feature_flags },
     set feature_flags (val) { hiddenState.feature_flags = val },
-    generic_events: { enabled: true, harvestTimeSeconds: 30, autoStart: true },
-    harvest: { tooManyRequestsDelay: 60 },
-    jserrors: { enabled: true, harvestTimeSeconds: 10, autoStart: true },
-    logging: { enabled: true, harvestTimeSeconds: 10, autoStart: true, level: LOG_LEVELS.INFO },
+    generic_events: { enabled: true, autoStart: true },
+    harvest: { interval: 30 },
+    jserrors: { enabled: true, autoStart: true },
+    logging: { enabled: true, autoStart: true, level: LOG_LEVELS.INFO },
     metrics: { enabled: true, autoStart: true },
     obfuscate: undefined,
     page_action: { enabled: true },
     page_view_event: { enabled: true, autoStart: true },
-    page_view_timing: { enabled: true, harvestTimeSeconds: 30, autoStart: true },
+    page_view_timing: { enabled: true, autoStart: true },
     performance: {
       get capture_marks () { return hiddenState.feature_flags.includes(FEATURE_FLAGS.MARKS) || hiddenState.experimental.marks },
       set capture_marks (val) { hiddenState.experimental.marks = val },
@@ -85,7 +85,6 @@ const model = () => {
       // feature settings
       autoStart: true,
       enabled: false,
-      harvestTimeSeconds: 60,
       preload: false, // if true, enables the agent to load rrweb immediately instead of waiting to do so after the window.load event
       sampling_rate: 10, // float from 0 - 100
       error_sampling_rate: 100, // float from 0 - 100
@@ -123,9 +122,9 @@ const model = () => {
         else warn(7, val)
       }
     },
-    session_trace: { enabled: true, harvestTimeSeconds: 10, autoStart: true },
-    soft_navigations: { enabled: true, harvestTimeSeconds: 10, autoStart: true },
-    spa: { enabled: true, harvestTimeSeconds: 10, autoStart: true },
+    session_trace: { enabled: true, autoStart: true },
+    soft_navigations: { enabled: true, autoStart: true },
+    spa: { enabled: true, autoStart: true },
     ssl: undefined,
     user_actions: { enabled: true }
   }

package/src/common/config/runtime.js

@@ -30,7 +30,8 @@ const model = {
   session: undefined,
   denyList: undefined,
   timeKeeper: undefined,
-  obfuscator: undefined
+  obfuscator: undefined,
+  harvester: undefined
 }
 
 const _cache = {}

package/src/common/harvest/__mocks__/harvester.js

@@ -0,0 +1,6 @@
+// create a jest mock of the Harvester class
+export const Harvester = jest.fn().mockImplementation(() => ({
+  startTimer: jest.fn(),
+  triggerHarvestFor: jest.fn(),
+  initializedAggregates: []
+}))

package/src/common/harvest/harvester.js

@@ -0,0 +1,230 @@
+import { FEATURE_TO_ENDPOINT, JSERRORS, RUM, EVENTS } from '../../loaders/features/features'
+import { VERSION } from '../constants/env'
+import { globalScope, isWorkerScope } from '../constants/runtime'
+import { eventListenerOpts } from '../event-listener/event-listener-opts'
+import { SESSION_EVENTS } from '../session/constants'
+import { now } from '../timing/now'
+import { subscribeToEOL } from '../unload/eol'
+import { cleanURL } from '../url/clean-url'
+import { obj, param } from '../url/encode'
+import { warn } from '../util/console'
+import { stringify } from '../util/stringify'
+import { getSubmitMethod, xhr as xhrMethod, xhrFetch as fetchMethod } from '../util/submit-data'
+
+export class Harvester {
+  #started = false
+  initializedAggregates = []
+
+  constructor (agentRef) {
+    this.agentRef = agentRef
+
+    subscribeToEOL(() => { // do one last harvest round or check
+      this.initializedAggregates.forEach(aggregateInst => { // let all features wrap up things needed to do before ANY harvest in case there's last minute cross-feature data dependencies
+        if (typeof aggregateInst.harvestOpts.beforeUnload === 'function') aggregateInst.harvestOpts.beforeUnload()
+      })
+      this.initializedAggregates.forEach(aggregateInst => this.triggerHarvestFor(aggregateInst, { isFinalHarvest: true }))
+      /* This callback should run in bubble phase, so that that CWV api, like "onLCP", is called before the final harvest so that emitted timings are part of last outgoing. */
+    }, false)
+
+    /* Flush all buffered data if session resets and give up retries. This should be synchronous to ensure that the correct `session` value is sent.
+      Since session-reset generates a new session ID and the ID is grabbed at send-time, any delays or retries would cause the payload to be sent under the wrong session ID. */
+    agentRef.ee.on(SESSION_EVENTS.RESET, () => this.initializedAggregates.forEach(aggregateInst => this.triggerHarvestFor(aggregateInst, { forceNoRetry: true })))
+  }
+
+  startTimer (harvestInterval = this.agentRef.init.harvest.interval) {
+    if (this.#started) return
+    this.#started = true
+
+    const onHarvestInterval = () => {
+      this.initializedAggregates.forEach(aggregateInst => this.triggerHarvestFor(aggregateInst))
+      setTimeout(onHarvestInterval, harvestInterval * 1000) // repeat in X seconds
+    }
+    setTimeout(onHarvestInterval, harvestInterval * 1000)
+  }
+
+  /**
+   * Given a feature (aggregate), execute a harvest on-demand.
+   * @param {object} aggregateInst
+   * @param {object} localOpts
+   * @returns {boolean} True if 1+ network call was made. Note that this does not mean or guarantee that it was successful (or that all were in the case of more than 1).
+   */
+  triggerHarvestFor (aggregateInst, localOpts = {}) {
+    if (aggregateInst.blocked) return false
+
+    const submitMethod = getSubmitMethod(localOpts)
+    if (!submitMethod) return false
+
+    const shouldRetryOnFail = !localOpts.isFinalHarvest && submitMethod === xhrMethod // always retry all features harvests except for final
+    let dataToSendArr; let ranSend = false
+    if (!localOpts.directSend) { // primarily used by rum call to bypass makeHarvestPayload by providing payload directly
+      dataToSendArr = aggregateInst.makeHarvestPayload(shouldRetryOnFail) // be sure the 'this' of makeHarvestPayload is the aggregate w/ access to its harvestOpts
+      if (!dataToSendArr) return false // can be undefined if storage is empty or preharvest checks failed
+    } else dataToSendArr = [localOpts.directSend]
+
+    dataToSendArr.forEach(({ targetApp, payload }) => {
+      if (!payload) return
+
+      send(this.agentRef, {
+        endpoint: FEATURE_TO_ENDPOINT[aggregateInst.featureName],
+        targetApp,
+        payload,
+        localOpts,
+        submitMethod,
+        cbFinished,
+        raw: aggregateInst.harvestOpts.raw
+      })
+      ranSend = true
+    })
+    return ranSend
+
+    /**
+     * This is executed immediately after harvest sends the data via XHR, or if there's nothing to send. Note that this excludes on unloading / sendBeacon.
+     * @param {Object} result - information regarding the result of the harvest attempt
+     */
+    function cbFinished (result) {
+      if (localOpts.forceNoRetry) result.retry = false // discard unsent data rather than re-queuing for next harvest attempt
+      aggregateInst.postHarvestCleanup(result)
+    }
+  }
+}
+
+/**
+ * @typedef {import('./types.js').NetworkSendSpec} NetworkSendSpec
+ */
+
+const warnings = {}
+/**
+  * Initiate a harvest call.
+  * @param {NetworkSendSpec} param0 Specification for sending data
+  * @returns {boolean} True if a network call was made. Note that this does not mean or guarantee that it was successful.
+  */
+function send (agentRef, { endpoint, targetApp, payload, localOpts = {}, submitMethod, cbFinished, raw }) {
+  if (!agentRef.info.errorBeacon) return false
+
+  let { body, qs } = cleanPayload(payload)
+
+  if (Object.keys(body).length === 0 && !localOpts.sendEmptyBody) { // if there's no body to send, just run onfinish stuff and return
+    if (cbFinished) cbFinished({ sent: false, targetApp })
+    return false
+  }
+
+  const protocol = agentRef.init.ssl === false ? 'http' : 'https'
+  const perceivedBeacon = agentRef.init.proxy.beacon || agentRef.info.errorBeacon
+  const url = raw
+    ? `${protocol}://${perceivedBeacon}/${endpoint}`
+    : `${protocol}://${perceivedBeacon}${endpoint !== RUM ? '/' + endpoint : ''}/1/${targetApp.licenseKey}`
+  const baseParams = !raw ? baseQueryString(agentRef, qs, endpoint, targetApp.appId) : ''
+  let payloadParams = obj(qs, agentRef.runtime.maxBytes)
+  if (baseParams === '' && payloadParams.startsWith('&')) {
+    payloadParams = payloadParams.substring(1)
+  }
+
+  const fullUrl = `${url}?${baseParams}${payloadParams}`
+  const gzip = !!qs?.attributes?.includes('gzip')
+  if (!gzip) {
+    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)
+  }
+
+  // If body is null, undefined, or an empty object or array after stringifying, send an empty string instead.
+  if (!body || body.length === 0 || body === '{}' || body === '[]') body = ''
+
+  const headers = [{ key: 'content-type', value: 'text/plain' }]
+
+  /* Since workers don't support sendBeacon right now, they can only use XHR method.
+      Because they still do permit synch XHR, the idea is that at final harvest time (worker is closing),
+      we just make a BLOCKING request--trivial impact--with the remaining data as a temp fill-in for sendBeacon.
+     Following the removal of img-element method. */
+  let result = submitMethod({ url: fullUrl, body, sync: localOpts.isFinalHarvest && isWorkerScope, headers })
+
+  if (!localOpts.isFinalHarvest && cbFinished) { // final harvests don't hold onto buffer data (shouldRetryOnFail is false), so cleanup isn't needed
+    if (submitMethod === xhrMethod) {
+      result.addEventListener('loadend', function () {
+        // `this` here in block refers to the XHR object in this scope, do not change the anon function to an arrow function
+        // status 0 refers to a local error, such as CORS or network failure, or a blocked request by the browser (e.g. adblocker)
+        const cbResult = { sent: this.status !== 0, status: this.status, retry: shouldRetry(this.status), xhr: this, fullUrl, targetApp }
+        if (localOpts.needResponse) cbResult.responseText = this.responseText
+        cbFinished(cbResult)
+      }, eventListenerOpts(false))
+    } else if (submitMethod === fetchMethod) {
+      result.then(async function (response) {
+        const status = response.status
+        const cbResult = { sent: true, status, retry: shouldRetry(status), fullUrl, fetchResponse: response, targetApp }
+        if (localOpts.needResponse) cbResult.responseText = await response.text()
+        cbFinished(cbResult)
+      })
+    }
+  }
+  return true
+
+  function shouldRetry (status) {
+    switch (status) {
+      case 429:
+      case 408:
+      case 500:
+      case 503:
+        return true
+      default:
+        return false
+    }
+  }
+}
+
+/**
+ * Cleans and returns a payload object containing a body and qs
+ * object with key/value pairs. KV pairs where the value is null,
+ * undefined, or an empty string are removed to save on transmission
+ * size.
+ * @param {HarvestPayload} payload Payload to be sent to the endpoint.
+ * @returns {HarvestPayload} Cleaned payload payload to be sent to the endpoint.
+ */
+function cleanPayload (payload = {}) {
+  const clean = (input) => {
+    if ((typeof Uint8Array !== 'undefined' && input instanceof Uint8Array) || Array.isArray(input)) return input
+    if (typeof input === 'string') return input.length > 0 ? input : null
+    return Object.entries(input || {}).reduce((accumulator, [key, value]) => {
+      if ((typeof value === 'number') ||
+          (typeof value === 'string' && value.length > 0) ||
+          (typeof value === 'object' && Object.keys(value || {}).length > 0)
+      ) {
+        accumulator[key] = value
+      }
+      return accumulator
+    }, {})
+  }
+
+  return {
+    body: clean(payload.body),
+    qs: clean(payload.qs)
+  }
+}
+
+// The stuff that gets sent every time.
+function baseQueryString (agentRef, qs, endpoint, applicationID) {
+  const ref = agentRef.runtime.obfuscator.obfuscateString(cleanURL('' + globalScope.location))
+  const hr = agentRef.runtime.session?.state.sessionReplayMode === 1 && endpoint !== JSERRORS
+
+  const qps = [
+    'a=' + applicationID,
+    param('sa', (agentRef.info.sa ? '' + agentRef.info.sa : '')),
+    param('v', VERSION),
+    transactionNameParam(),
+    param('ct', agentRef.runtime.customTransaction),
+    '&rst=' + now(),
+    '&ck=0', // ck param DEPRECATED - still expected by backend
+    '&s=' + (agentRef.runtime.session?.state.value || '0'), // the 0 id encaps all untrackable and default traffic
+    param('ref', ref),
+    param('ptid', (agentRef.runtime.ptid ? '' + agentRef.runtime.ptid : ''))
+  ]
+  if (hr) qps.push(param('hr', '1', qs))
+  return qps.join('')
+
+  // Constructs the transaction name param for the beacon URL.
+  // Prefers the obfuscated transaction name over the plain text.
+  // Falls back to making up a name.
+  function transactionNameParam () {
+    if (agentRef.info.transactionName) return param('to', agentRef.info.transactionName)
+    return param('t', agentRef.info.tNamePlain || 'Unnamed Transaction')
+  }
+}