@newrelic/browser-agent 1.277.0 → 1.278.1

package/dist/cjs/features/spa/aggregate/index.js

@@ -11,7 +11,6 @@ var _navTiming = require("../../../common/timing/nav-timing");
 var _uniqueId = require("../../../common/ids/unique-id");
 var _interaction = require("./interaction");
 var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
-var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
 var _serializer = require("./serializer");
 var _contextualEe = require("../../../common/event-emitter/contextual-ee");
 var CONSTANTS = _interopRequireWildcard(require("../constants"));
@@ -67,13 +66,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
       pageLoaded: false,
       childTime: 0,
       depth: 0,
-      harvestTimeSeconds: agentRef.init.spa.harvestTimeSeconds || 10,
       // The below feature flag is used to disable the SPA ajax fix for specific customers, see https://new-relic.atlassian.net/browse/NR-172169
       disableSpaFix: (agentRef.init.feature_flags || []).indexOf('disable-spa-fix') > -1
     };
     this.spaSerializerClass = new _serializer.Serializer(this);
     const classThis = this;
-    let scheduler;
     const baseEE = _contextualEe.ee.get(agentRef.agentIdentifier); // <-- parent baseEE
     const mutationEE = baseEE.get('mutation');
     const promiseEE = baseEE.get('promise');
@@ -117,13 +114,10 @@ class Aggregate extends _aggregateBase.AggregateBase {
     //  | click ending:                   |   65  |    50    |        |           |           |
     // click fn-end                       |   70  |    0     |    0   |     70    |     20    |
 
+    let harvester;
     this.waitForFlags(['spa']).then(([spaFlag]) => {
       if (spaFlag) {
-        scheduler = new _harvestScheduler.HarvestScheduler(_features.FEATURE_TO_ENDPOINT[this.featureName], {
-          onFinished: result => this.postHarvestCleanup(result.sent && result.retry),
-          getPayload: options => this.makeHarvestPayload(options.retry),
-          retryDelay: state.harvestTimeSeconds
-        }, this);
+        harvester = agentRef.runtime.harvester; // since this is after RUM call, PVE would've initialized harvester by now
         this.drain();
       } else {
         this.blocked = true;
@@ -664,8 +658,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
       let smCategory;
       if (interaction.root?.attrs?.trigger === 'initialPageLoad') smCategory = 'InitialPageLoad';else if (interaction.routeChange) smCategory = 'RouteChange';else smCategory = 'Custom';
       (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ["Spa/Interaction/".concat(smCategory, "/Duration/Ms"), Math.max((interaction.root?.end || 0) - (interaction.root?.start || 0), 0)], undefined, _features.FEATURE_NAMES.metrics, baseEE);
-      scheduler?.scheduleHarvest(0);
-      if (!scheduler) (0, _console.warn)(19);
+      if (!harvester) {
+        (0, _console.warn)(19);
+        return;
+      }
+      harvester.triggerHarvestFor(classThis);
     }
   }
   serializer(eventBuffer) {

package/dist/cjs/features/utils/aggregate-base.js

@@ -11,18 +11,33 @@ var _nreum = require("../../common/window/nreum");
 var _drain = require("../../common/drain/drain");
 var _featureFlags = require("../../common/util/feature-flags");
 var _obfuscate = require("../../common/util/obfuscate");
-var _eventBuffer = require("./event-buffer");
 var _features = require("../../loaders/features/features");
+var _eventStoreManager = require("./event-store-manager");
+var _harvester = require("../../common/harvest/harvester");
 class AggregateBase extends _featureBase.FeatureBase {
   constructor(agentRef, featureName) {
     super(agentRef.agentIdentifier, featureName);
     this.agentRef = agentRef;
-    // Jserror and Metric features uses a singleton EventAggregator instead of a regular EventBuffer.
-    if ([_features.FEATURE_NAMES.jserrors, _features.FEATURE_NAMES.metrics].includes(this.featureName)) this.events = agentRef.sharedAggregator;
-    // PVE has no need for eventBuffer, and SessionTrace has its own storage mechanism.
-    else if (![_features.FEATURE_NAMES.pageViewEvent, _features.FEATURE_NAMES.sessionTrace].includes(this.featureName)) this.events = new _eventBuffer.EventBuffer();
     this.checkConfiguration(agentRef);
-    this.obfuscator = agentRef.runtime.obfuscator;
+    this.doOnceForAllAggregate(agentRef);
+
+    // This switch needs to be after doOnceForAllAggregate which may new sharedAggregator and reset mainAppKey.
+    switch (this.featureName) {
+      // PVE has no need for eventBuffer, and SessionTrace + Replay have their own storage mechanisms.
+      case _features.FEATURE_NAMES.pageViewEvent:
+      case _features.FEATURE_NAMES.sessionTrace:
+      case _features.FEATURE_NAMES.sessionReplay:
+        break;
+      // Jserror and Metric features uses a singleton EventAggregator instead of a regular EventBuffer.
+      case _features.FEATURE_NAMES.jserrors:
+      case _features.FEATURE_NAMES.metrics:
+        this.events = agentRef.sharedAggregator;
+        break;
+      default:
+        this.events = new _eventStoreManager.EventStoreManager(agentRef.mainAppKey, 1);
+        break;
+    }
+    this.harvestOpts = {}; // features aggregate classes can define custom opts for when their harvest is called
   }
 
   /**
@@ -60,32 +75,43 @@ class AggregateBase extends _featureBase.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} opts.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 = false, opts = {}) {
-    if (this.events.isEmpty(opts)) return;
+    if (this.events.isEmpty(this.harvestOpts, opts.target)) return;
     // Other conditions and things to do when preparing harvest that is required.
-    if (this.preHarvestChecks && !this.preHarvestChecks()) return;
-    if (shouldRetryOnFail) this.events.save(opts);
-    const returnedData = this.events.get(opts);
-    // A serializer or formatter assists in creating the payload `body` from stored events on harvest when defined by derived feature class.
-    const body = this.serializer ? this.serializer(returnedData) : returnedData;
-    this.events.clear(opts);
-    const payload = {
-      body
-    };
-    // Constructs the payload `qs` for relevant features on harvest.
-    if (this.queryStringsBuilder) payload.qs = this.queryStringsBuilder(returnedData);
-    return payload;
+    if (this.preHarvestChecks && !this.preHarvestChecks(opts)) return;
+    if (shouldRetryOnFail) this.events.save(this.harvestOpts, opts.target);
+    const returnedDataArr = this.events.get(this.harvestOpts, opts.target);
+    if (!returnedDataArr.length) throw new Error('Unexpected problem encountered. There should be at least one app for harvest!');
+    this.events.clear(this.harvestOpts, opts.target);
+    return returnedDataArr.map(({
+      targetApp,
+      data
+    }) => {
+      // A serializer or formatter assists in creating the payload `body` from stored events on harvest when defined by derived feature class.
+      const body = this.serializer ? this.serializer(data) : data;
+      const payload = {
+        body
+      };
+      // Constructs the payload `qs` for relevant features on harvest.
+      if (this.queryStringsBuilder) payload.qs = this.queryStringsBuilder(data);
+      return {
+        targetApp,
+        payload
+      };
+    });
   }
 
   /**
    * 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 = false, opts = {}) {
-    if (harvestFailed) this.events.reloadSave(opts);
-    this.events.clearSave(opts);
+  postHarvestCleanup(result = {}) {
+    const harvestFailed = result.sent && result.retry;
+    if (harvestFailed) this.events.reloadSave(this.harvestOpts, result.targetApp);
+    this.events.clearSave(this.harvestOpts, result.targetApp);
   }
 
   /**
@@ -118,9 +144,22 @@ class AggregateBase extends _featureBase.FeatureBase {
         runtime: existingAgent.runtime
       });
     }
-    if (!existingAgent.runtime.obfuscator) {
-      existingAgent.runtime.obfuscator = new _obfuscate.Obfuscator(this.agentIdentifier);
-    }
+  }
+
+  /**
+   * 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) {
+    if (!agentRef.runtime.obfuscator) agentRef.runtime.obfuscator = new _obfuscate.Obfuscator(this.agentIdentifier);
+    this.obfuscator = agentRef.runtime.obfuscator;
+    if (!agentRef.mainAppKey) agentRef.mainAppKey = {
+      licenseKey: agentRef.info.licenseKey,
+      appId: agentRef.info.applicationID
+    };
+    // Create a single Aggregator for this agent if DNE yet; to be used by jserror endpoint features.
+    if (!agentRef.sharedAggregator) agentRef.sharedAggregator = new _eventStoreManager.EventStoreManager(agentRef.mainAppKey, 2);
+    if (!agentRef.runtime.harvester) agentRef.runtime.harvester = new _harvester.Harvester(agentRef);
   }
 }
 exports.AggregateBase = AggregateBase;

package/dist/cjs/features/utils/event-buffer.js

@@ -54,7 +54,6 @@ class EventBuffer {
 
   /**
    * Backup the buffered data and clear the main buffer
-   * @returns {Array} the events being backed up
    */
   save() {
     this.#bufferBackup = this.#buffer;

package/dist/cjs/features/utils/event-store-manager.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EventStoreManager = void 0;
+var _eventAggregator = require("../../common/aggregate/event-aggregator");
+var _eventBuffer = require("./event-buffer");
+/**
+ * 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.
+ */
+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, storageChoice) {
+    this.mainApp = defaultTarget;
+    this.StorageClass = storageChoice === 1 ? _eventBuffer.EventBuffer : _eventAggregator.EventAggregator;
+    this.appStorageMap = new Map();
+    this.appStorageMap.set(defaultTarget, new this.StorageClass());
+  }
+
+  // This class must contain an union of all methods from all supported storage classes and conceptualize away the target app argument.
+
+  /**
+   * @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, target) {
+    if (target) {
+      if (!this.appStorageMap.has(target)) return true;else return this.appStorageMap.get(target).isEmpty(optsIfPresent);
+    }
+    for (const eventStore of this.appStorageMap.values()) {
+      if (!eventStore.isEmpty(optsIfPresent)) return false;
+    }
+    return true;
+  }
+
+  /**
+   * @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, target) {
+    if (target && !this.appStorageMap.has(target)) this.appStorageMap.set(target, new this.StorageClass());
+    return this.appStorageMap.get(target || this.mainApp).add(event);
+  }
+
+  /** This is only used by the Metrics feature which has no need to add metric under a different app atm. */
+  addMetric(type, name, params, value) {
+    return this.appStorageMap.get(this.mainApp).addMetric(type, name, params, value);
+  }
+
+  /**
+   * @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, target) {
+    if (target) return [{
+      targetApp: target,
+      data: this.appStorageMap.get(target)?.get(optsIfPresent)
+    }];
+    const allPayloads = [];
+    this.appStorageMap.forEach((eventStore, recordedTarget) => {
+      allPayloads.push({
+        targetApp: recordedTarget,
+        data: eventStore.get(optsIfPresent)
+      });
+    });
+    return allPayloads;
+  }
+  byteSize(target) {
+    return this.appStorageMap.get(target || this.mainApp).byteSize();
+  }
+  wouldExceedMaxSize(incomingSize, target) {
+    return this.appStorageMap.get(target || this.mainApp).wouldExceedMaxSize(incomingSize);
+  }
+  save(optsIfPresent, target) {
+    if (target) return this.appStorageMap.get(target)?.save(optsIfPresent);
+    this.appStorageMap.forEach(eventStore => eventStore.save(optsIfPresent));
+  }
+  clear(optsIfPresent, target) {
+    if (target) return this.appStorageMap.get(target)?.clear(optsIfPresent);
+    this.appStorageMap.forEach(eventStore => eventStore.clear(optsIfPresent));
+  }
+
+  // Unlike the methods above, the following will have a target as they are called by AggregateBase.postHarvestCleanup callback on harvest finish after getting & sending the data.
+  reloadSave(optsIfPresent, target) {
+    if (!target) {
+      // -- remove this block once the old harvest.js & harvest-schedule.js are deleted!
+      this.appStorageMap.forEach(eventStore => eventStore.reloadSave(optsIfPresent));
+      return;
+    }
+    return this.appStorageMap.get(target)?.reloadSave(optsIfPresent);
+  }
+  clearSave(optsIfPresent, target) {
+    if (!target) {
+      // -- remove this block once the old harvest.js & harvest-schedule.js are deleted!
+      this.appStorageMap.forEach(eventStore => eventStore.clearSave(optsIfPresent));
+      return;
+    }
+    return this.appStorageMap.get(target)?.clearSave(optsIfPresent);
+  }
+}
+exports.EventStoreManager = EventStoreManager;

package/dist/cjs/features/utils/instrument-base.js

@@ -48,7 +48,6 @@ class InstrumentBase extends _featureBase.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.
     */
     this.onAggregateImported = undefined;
 
@@ -100,15 +99,6 @@ class InstrumentBase extends _featureBase.FeatureBase {
        * it's only responsible for aborting its one specific feature, rather than all.
        */
       try {
-        // Create a single Aggregator for this agent if DNE yet; to be used by jserror endpoint features.
-        if (!agentRef.sharedAggregator) {
-          agentRef.sharedAggregator = Promise.resolve().then(() => _interopRequireWildcard(require(/* webpackChunkName: "shared-aggregator" */'../../common/aggregate/event-aggregator')));
-          const {
-            EventAggregator
-          } = await agentRef.sharedAggregator;
-          agentRef.sharedAggregator = new EventAggregator();
-        } else await agentRef.sharedAggregator; // if another feature is already importing the aggregator, wait for it to finish
-
         if (!this.#shouldImportAgg(this.featureName, session)) {
           (0, _drain.drain)(this.agentIdentifier, this.featureName);
           loadedSuccessfully(false); // aggregate module isn't loaded at all
@@ -121,6 +111,7 @@ class InstrumentBase extends _featureBase.FeatureBase {
           Aggregate
         } = await lazyFeatureLoader(this.featureName, 'aggregate');
         this.featAggregate = new Aggregate(agentRef, argsObjFromInstrument);
+        agentRef.runtime.harvester.initializedAggregates.push(this.featAggregate); // "subscribe" the feature to future harvest intervals (PVE will start the timer)
         loadedSuccessfully(true);
       } catch (e) {
         (0, _console.warn)(34, e);

package/dist/cjs/loaders/features/features.js

@@ -3,11 +3,16 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.featurePriority = exports.FEATURE_TO_ENDPOINT = exports.FEATURE_NAMES = void 0;
+exports.featurePriority = exports.RUM = exports.JSERRORS = exports.FEATURE_TO_ENDPOINT = exports.FEATURE_NAMES = exports.EVENTS = void 0;
+// To reduce build size a bit:
+const EVENTS = exports.EVENTS = 'events';
+const JSERRORS = exports.JSERRORS = 'jserrors';
+const BLOBS = 'browser/blobs';
+const RUM = exports.RUM = 'rum';
 const FEATURE_NAMES = exports.FEATURE_NAMES = {
   ajax: 'ajax',
   genericEvents: 'generic_events',
-  jserrors: 'jserrors',
+  jserrors: JSERRORS,
   logging: 'logging',
   metrics: 'metrics',
   /**
@@ -40,14 +45,15 @@ const featurePriority = exports.featurePriority = {
   [FEATURE_NAMES.genericEvents]: 11
 };
 const FEATURE_TO_ENDPOINT = exports.FEATURE_TO_ENDPOINT = {
-  [FEATURE_NAMES.pageViewTiming]: 'events',
-  [FEATURE_NAMES.ajax]: 'events',
-  [FEATURE_NAMES.spa]: 'events',
-  [FEATURE_NAMES.softNav]: 'events',
-  [FEATURE_NAMES.metrics]: 'jserrors',
-  [FEATURE_NAMES.jserrors]: 'jserrors',
-  [FEATURE_NAMES.sessionTrace]: 'browser/blobs',
-  [FEATURE_NAMES.sessionReplay]: 'browser/blobs',
+  [FEATURE_NAMES.pageViewEvent]: RUM,
+  [FEATURE_NAMES.pageViewTiming]: EVENTS,
+  [FEATURE_NAMES.ajax]: EVENTS,
+  [FEATURE_NAMES.spa]: EVENTS,
+  [FEATURE_NAMES.softNav]: EVENTS,
+  [FEATURE_NAMES.metrics]: JSERRORS,
+  [FEATURE_NAMES.jserrors]: JSERRORS,
+  [FEATURE_NAMES.sessionTrace]: BLOBS,
+  [FEATURE_NAMES.sessionReplay]: BLOBS,
   [FEATURE_NAMES.logging]: 'browser/logs',
   [FEATURE_NAMES.genericEvents]: 'ins'
 };

package/dist/cjs/loaders/micro-agent.js

@@ -68,6 +68,7 @@ class MicroAgent extends _microAgentBase.MicroAgentBase {
                 Aggregate
               }) => {
                 this.features[f] = new Aggregate(this);
+                this.runtime.harvester.initializedAggregates.push(this.features[f]); // so that harvester will poll this feature agg on interval
               }).catch(err => (0, _console.warn)(25, err));
             }
           });

package/dist/esm/common/aggregate/event-aggregator.js

@@ -13,7 +13,7 @@ export class EventAggregator {
     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) {
+  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/dist/esm/common/config/init.js

@@ -41,7 +41,6 @@ const model = () => {
       deny_list: undefined,
       block_internal: true,
       enabled: true,
-      harvestTimeSeconds: 10,
       autoStart: true
     },
     distributed_tracing: {
@@ -59,20 +58,17 @@ const model = () => {
     },
     generic_events: {
       enabled: true,
-      harvestTimeSeconds: 30,
       autoStart: true
     },
     harvest: {
-      tooManyRequestsDelay: 60
+      interval: 30
     },
     jserrors: {
       enabled: true,
-      harvestTimeSeconds: 10,
       autoStart: true
     },
     logging: {
       enabled: true,
-      harvestTimeSeconds: 10,
       autoStart: true,
       level: LOG_LEVELS.INFO
     },
@@ -90,7 +86,6 @@ const model = () => {
     },
     page_view_timing: {
       enabled: true,
-      harvestTimeSeconds: 30,
       autoStart: true
     },
     performance: {
@@ -138,7 +133,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,
@@ -191,17 +185,14 @@ 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,

package/dist/esm/common/config/runtime.js

@@ -28,7 +28,8 @@ const model = {
   session: undefined,
   denyList: undefined,
   timeKeeper: undefined,
-  obfuscator: undefined
+  obfuscator: undefined,
+  harvester: undefined
 };
 const _cache = {};
 export function getRuntime(id) {

package/dist/esm/common/constants/env.cdn.js

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.277.0";
+export const VERSION = "1.278.1";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/constants/env.npm.js

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.277.0";
+export const VERSION = "1.278.1";
 
 /**
  * Exposes the build type of the agent