@newrelic/browser-agent 1.301.0 → 1.302.0-rc.1

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

@@ -12,10 +12,10 @@ var _constants = require("../constants");
 var _log = require("../shared/log");
 var _utils = require("../shared/utils");
 var _traverse = require("../../../common/util/traverse");
-var _target = require("../../../common/util/target");
 var _constants2 = require("../../../common/session/constants");
 var _constants3 = require("../../session_replay/constants");
 var _featureGates = require("../../utils/feature-gates");
+var _mfe = require("../../../common/util/mfe");
 /**
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -26,6 +26,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
   constructor(agentRef) {
     super(agentRef, _constants.FEATURE_NAME);
     this.isSessionTrackingEnabled = (0, _featureGates.canEnableSessionTracking)(agentRef.init) && agentRef.runtime.session;
+
+    /** set up agg-level behaviors specific to this feature */
+    this.harvestOpts.raw = true;
     super.customAttributesAreSeparate = true;
 
     // The SessionEntity class can emit a message indicating the session was cleared and reset (expiry, inactivity). This feature must abort and never resume if that occurs.
@@ -36,7 +39,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
       if (this.blocked || type !== _constants2.SESSION_EVENT_TYPES.CROSS_TAB) return;
       if (this.loggingMode !== _constants.LOGGING_MODE.OFF && data.loggingMode === _constants.LOGGING_MODE.OFF) this.abort(_constants3.ABORT_REASONS.CROSS_TAB);else this.loggingMode = data.loggingMode;
     });
-    this.harvestOpts.raw = true;
     this.waitForFlags(['log']).then(([loggingMode]) => {
       const session = this.agentRef.runtime.session ?? {};
       if (this.loggingMode === _constants.LOGGING_MODE.OFF || session.isNew && loggingMode === _constants.LOGGING_MODE.OFF) {
@@ -63,10 +65,14 @@ class Aggregate extends _aggregateBase.AggregateBase {
       loggingMode: this.loggingMode
     });
   }
-  handleLog(timestamp, message, attributes = {}, level = _constants.LOG_LEVELS.INFO, targetEntityGuid) {
-    if (!this.agentRef.runtime.entityManager.get(targetEntityGuid)) return (0, _console.warn)(56, this.featureName);
+  handleLog(timestamp, message, attributes = {}, level = _constants.LOG_LEVELS.INFO, target) {
     if (this.blocked || !this.loggingMode) return;
     if (!attributes || typeof attributes !== 'object') attributes = {};
+    attributes = {
+      ...attributes,
+      /** Specific attributes only supplied if harvesting to endpoint version 2 */
+      ...(0, _mfe.getVersion2Attributes)(target, this)
+    };
     if (typeof level === 'string') level = level.toUpperCase();
     if (!(0, _utils.isValidLogLevel)(level)) return (0, _console.warn)(30, level);
     if (this.loggingMode < (_constants.LOGGING_MODE[level] || Infinity)) {
@@ -90,10 +96,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
     if (typeof message !== 'string' || !message) return (0, _console.warn)(32);
     const log = new _log.Log(Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(timestamp)), message, attributes, level);
-    this.events.add(log, targetEntityGuid);
+    this.events.add(log);
   }
-  serializer(eventBuffer, targetEntityGuid) {
-    const target = this.agentRef.runtime.entityManager.get(targetEntityGuid);
+  serializer(eventBuffer) {
     const sessionEntity = this.agentRef.runtime.session;
     return [{
       common: {
@@ -101,19 +106,19 @@ class Aggregate extends _aggregateBase.AggregateBase {
         attributes: {
           ...this.agentRef.info.jsAttributes,
           // user-provided custom attributes
-          'entity.guid': target.entityGuid,
-          // browser entity guid as provided API target OR the default from RUM response if not supplied
+          ...(this.harvestEndpointVersion === 1 && {
+            'entity.guid': this.agentRef.runtime.appMetadata.agents[0].entityGuid,
+            appId: this.agentRef.info.applicationID
+          }),
           ...(sessionEntity && {
             session: sessionEntity.state.value || '0',
             // The session ID that we generate and keep across page loads
-            hasReplay: sessionEntity.state.sessionReplayMode === 1 && (0, _target.isContainerAgentTarget)(target, this.agentRef),
+            hasReplay: sessionEntity.state.sessionReplayMode === 1,
             // True if a session replay recording is running
             hasTrace: sessionEntity.state.sessionTraceMode === 1 // True if a session trace recording is running
           }),
           ptid: this.agentRef.runtime.ptid,
           // page trace id
-          appId: target.applicationID || this.agentRef.info.applicationID,
-          // Application ID from info object,
           standalone: Boolean(this.agentRef.info.sa),
           // copy paste (true) vs APM (false)
           agentVersion: this.agentRef.runtime.version,
@@ -128,10 +133,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
       logs: (0, _traverse.applyFnToProps)(eventBuffer, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
     }];
   }
-  queryStringsBuilder(_, targetEntityGuid) {
-    const target = this.agentRef.runtime.entityManager.get(targetEntityGuid);
+  queryStringsBuilder() {
     return {
-      browser_monitoring_key: target.licenseKey
+      browser_monitoring_key: this.agentRef.info.licenseKey
     };
   }
 

package/dist/cjs/features/logging/shared/utils.js

@@ -20,11 +20,11 @@ var _constants2 = require("../constants");
    * @param {string} message - the log message string
    * @param {{[key: string]: *}} customAttributes - The log's custom attributes if any
    * @param {enum} level - the log level enum
-   * @param {object=} targetEntityGuid - the optional target entity guid provided by an api call
+   * @param {object=} target - the optional target provided by an api call
    */
-function bufferLog(ee, message, customAttributes = {}, level = _constants2.LOG_LEVELS.INFO, targetEntityGuid, timestamp = (0, _now.now)()) {
+function bufferLog(ee, message, customAttributes = {}, level = _constants2.LOG_LEVELS.INFO, target, timestamp = (0, _now.now)()) {
   (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ["API/logging/".concat(level.toLowerCase(), "/called")], undefined, _features.FEATURE_NAMES.metrics, ee);
-  (0, _handle.handle)(_constants2.LOGGING_EVENT_EMITTER_CHANNEL, [timestamp, message, customAttributes, level, targetEntityGuid], undefined, _features.FEATURE_NAMES.logging, ee);
+  (0, _handle.handle)(_constants2.LOGGING_EVENT_EMITTER_CHANNEL, [timestamp, message, customAttributes, level, target], undefined, _features.FEATURE_NAMES.logging, ee);
 }
 
 /**

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

@@ -19,8 +19,6 @@ var _timeToFirstByte = require("../../../common/vitals/time-to-first-byte");
 var _now = require("../../../common/timing/now");
 var _timeKeeper = require("../../../common/timing/time-keeper");
 var _traverse = require("../../../common/util/traverse");
-var _registerHandler = require("../../../common/event-emitter/register-handler");
-var _target = require("../../../common/util/target");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 /**
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
@@ -35,9 +33,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.firstByteToWindowLoad = 0; // our "frontend" duration
     this.firstByteToDomContent = 0; // our "dom processing" duration
 
-    (0, _registerHandler.registerHandler)('send-rum', (customAttibutes, target) => {
-      this.sendRum(customAttibutes, target);
-    }, this.featureName, this.ee);
     if (!(0, _info.isValid)(agentRef.info)) {
       this.ee.abort();
       return (0, _console.warn)(43);
@@ -65,7 +60,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
    *
    * @param {Function} cb A function to run once the RUM call has finished - Defaults to activateFeatures
    * @param {*} customAttributes custom attributes to attach to the RUM call - Defaults to info.js
-   * @param {*} target The target to harvest to - Since we will not know the entityGuid before harvesting, this must be an object directly supplied from the info object or API, not an entityGuid string for lookup with the entityManager - Defaults to { licenseKey: this.agentRef.info.licenseKey, applicationID: this.agentRef.info.applicationID }
+   * @param {*} target The target to harvest to
    */
   sendRum(customAttributes = this.agentRef.info.jsAttributes, target = {
     licenseKey: this.agentRef.info.licenseKey,
@@ -128,7 +123,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.rumStartTime = (0, _now.now)();
     this.agentRef.runtime.harvester.triggerHarvestFor(this, {
       directSend: {
-        targetApp: target,
+        target,
         payload: {
           qs: queryParameters,
           body
@@ -141,8 +136,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
   postHarvestCleanup({
     status,
     responseText,
-    xhr,
-    targetApp
+    xhr
   }) {
     const rumEndTime = (0, _now.now)();
     let app, flags;
@@ -151,14 +145,10 @@ class Aggregate extends _aggregateBase.AggregateBase {
         app,
         ...flags
       } = JSON.parse(responseText));
-      this.processEntities(app.agents, targetApp);
     } catch (error) {
       // wont set entity stuff here, if main agent will later abort, if registered agent, nothing will happen
       (0, _console.warn)(53, error);
     }
-
-    /** Only run agent-wide side-effects if the harvest was for the main agent */
-    if (!(0, _target.isContainerAgentTarget)(targetApp, this.agentRef)) return;
     if (status >= 400 || status === 0) {
       (0, _console.warn)(18, status);
       // Adding retry logic for the rum call will be a separate change; this.blocked will need to be changed since that prevents another triggerHarvestFor()
@@ -189,25 +179,5 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.agentRef.runtime.harvester.startTimer();
     (0, _featureFlags.activateFeatures)(flags, this.agentRef);
   }
-  processEntities(entities, targetApp) {
-    if (!entities || !targetApp) return;
-    entities.forEach(agent => {
-      const entityManager = this.agentRef.runtime.entityManager;
-      const entityGuid = agent.entityGuid;
-      const entity = entityManager.get(entityGuid);
-      if (entity) return; // already processed
-
-      if ((0, _target.isContainerAgentTarget)(targetApp, this.agentRef)) {
-        entityManager.setDefaultEntity({
-          ...targetApp,
-          entityGuid
-        });
-      }
-      entityManager.set(agent.entityGuid, {
-        ...targetApp,
-        entityGuid
-      });
-    });
-  }
 }
 exports.Aggregate = Aggregate;

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

@@ -40,6 +40,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.gzipper = undefined;
     /** populated with the u8 string lib async */
     this.u8 = undefined;
+    /** flips to false if the compressor libraries cannot import */
+    this.shouldCompress = true;
 
     /** set by BCS response */
     this.entitled = false;
@@ -211,23 +213,22 @@ class Aggregate extends _aggregateBase.AggregateBase {
       this.gzipper = gzipSync;
       this.u8 = strToU8;
     } catch (err) {
-      // compressor failed to load, but we can still record without compression as a last ditch effort
+      this.shouldCompress = false;
+      // compressor failed to load, but we can still try to record without compression as a last ditch effort
     }
   }
-  makeHarvestPayload(shouldRetryOnFail) {
-    const payloadOutput = {
-      targetApp: undefined,
-      payload: undefined
-    };
-    if (this.mode !== _constants2.MODE.FULL || this.blocked) return;
-    if (!this.recorder || !this.timeKeeper?.ready || !this.recorder.hasSeenSnapshot) return;
+  makeHarvestPayload() {
+    if (this.mode !== _constants2.MODE.FULL || this.blocked) return; // harvests should only be made in FULL mode, and not if the feature is blocked
+    if (this.shouldCompress && !this.gzipper) return; // if compression is enabled, but the libraries have not loaded, wait for them to load
+    if (!this.recorder || !this.timeKeeper?.ready || !(this.recorder.hasSeenSnapshot && this.recorder.hasSeenMeta)) return; // if the recorder or the timekeeper is not ready, or the recorder has not yet seen a snapshot, do not harvest
+
     const recorderEvents = this.recorder.getEvents();
     // get the event type and use that to trigger another harvest if needed
     if (!recorderEvents.events.length) return;
     const payload = this.getHarvestContents(recorderEvents);
     if (!payload.body.length) {
       this.recorder.clearBuffer();
-      return [payloadOutput];
+      return;
     }
     this.reportSupportabilityMetric('SessionReplay/Harvest/Attempts');
     let len = 0;
@@ -242,19 +243,18 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
     if (len > _agentConstants.MAX_PAYLOAD_SIZE) {
       this.abort(_constants.ABORT_REASONS.TOO_BIG, len);
-      return [payloadOutput];
+      return;
     }
+
     // TODO -- Gracefully handle the buffer for retries.
     if (!this.agentRef.runtime.session.state.sessionReplaySentFirstChunk) this.syncWithSessionManager({
       sessionReplaySentFirstChunk: true
     });
     this.recorder.clearBuffer();
-    if (recorderEvents.type === 'preloaded') this.agentRef.runtime.harvester.triggerHarvestFor(this);
-    payloadOutput.payload = payload;
     if (!this.agentRef.runtime.session.state.traceHarvestStarted) {
       (0, _console.warn)(59, JSON.stringify(this.agentRef.runtime.session.state));
     }
-    return [payloadOutput];
+    return payload;
   }
 
   /**

package/dist/cjs/features/session_replay/shared/recorder.js

@@ -49,6 +49,7 @@ class Recorder {
     this.backloggedEvents = new _recorderEvents.RecorderEvents(this.shouldFix);
     /** Only set to true once a snapshot node has been processed.  Used to block harvests from sending before we know we have a snapshot */
     this.hasSeenSnapshot = false;
+    this.hasSeenMeta = false;
     /** Hold on to the last meta node, so that it can be re-inserted if the meta and snapshot nodes are broken up due to harvesting */
     this.lastMeta = false;
     /** The method to stop recording. This defaults to a noop, but is overwritten once the recording library is imported and initialized */
@@ -203,9 +204,9 @@ class Recorder {
     }
 
     // meta event
-    this.events.hasMeta ||= event.type === _constants.RRWEB_EVENT_TYPES.Meta;
+    this.hasSeenMeta ||= this.events.hasMeta ||= event.type === _constants.RRWEB_EVENT_TYPES.Meta;
     // snapshot event
-    this.events.hasSnapshot ||= this.hasSeenSnapshot ||= event.type === _constants.RRWEB_EVENT_TYPES.FullSnapshot;
+    this.hasSeenSnapshot ||= this.events.hasSnapshot ||= event.type === _constants.RRWEB_EVENT_TYPES.FullSnapshot;
 
     //* dont let the EventBuffer class double evaluate the event data size, it's a performance burden and we have special reasons to do it outside the event buffer */
     this.events.add(event, eventBytes);

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

@@ -98,8 +98,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
       sessionTraceMode: this.mode
     });
     this.drain();
-    /** try to harvest immediately. This will not send if the trace is not running in FULL mode due to the pre-harvest checks. */
-    this.agentRef.runtime.harvester.triggerHarvestFor(this);
   }
   preHarvestChecks() {
     if (this.blocked || this.mode !== _constants2.MODE.FULL) return; // only allow harvest if running in full mode

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

@@ -53,7 +53,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.waitForFlags(['spa']).then(([spaOn]) => {
       if (spaOn) {
         this.drain();
-        setTimeout(() => agentRef.runtime.harvester.triggerHarvestFor(this), 0); // send the IPL ixn on next tick, giving some time for any ajax to finish; we may want to just remove this?
       } else {
         this.blocked = true; // if rum response determines that customer lacks entitlements for spa endpoint, this feature shouldn't harvest
         this.deregisterDrain();
@@ -148,7 +147,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     */
     if (this.interactionInProgress?.isActiveDuring(timestamp)) return this.interactionInProgress;
     let saveIxn;
-    const interactionsBuffer = this.interactionsToHarvest.get()?.[0]?.data;
+    const interactionsBuffer = this.interactionsToHarvest.get();
     if (!interactionsBuffer) return undefined; // no interactions have been staged yet, so nothing to search through)
     for (let idx = interactionsBuffer.length - 1; idx >= 0; idx--) {
       // reverse search for the latest completed interaction for efficiency

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

@@ -12,10 +12,7 @@ var _drain = require("../../common/drain/drain");
 var _featureFlags = require("../../common/util/feature-flags");
 var _obfuscate = require("../../common/util/obfuscate");
 var _features = require("../../loaders/features/features");
-var _eventStoreManager = require("./event-store-manager");
 var _harvester = require("../../common/harvest/harvester");
-var _console = require("../../common/util/console");
-var _entityManager = require("./entity-manager");
 var _eventBuffer = require("./event-buffer");
 var _handle = require("../../common/event-emitter/handle");
 var _constants = require("../metrics/constants");
@@ -46,16 +43,8 @@ class AggregateBase extends _featureBase.FeatureBase {
     this.isRetrying = false;
     this.harvestOpts = {}; // features aggregate classes can define custom opts for when their harvest is called
 
-    const agentEntityGuid = this.agentRef?.runtime?.appMetadata?.agents?.[0]?.entityGuid;
-    this.#setupEventStore(agentEntityGuid);
-    if (!agentEntityGuid) {
-      /** wait for the entity guid from the rum response and use to it to further configure things to set the default entity to share an indexed entity with entityGuid */
-      this.ee.on('entity-added', entity => {
-        // not all event managers have this fn, like ST and SR
-        // this allows the lookup to work for the default and an entityGuid without creating two separate buffers
-        this.events?.setEventStore?.(entity.entityGuid);
-      });
-    }
+    this.#setupEventStore();
+    this.waitForDrain();
   }
 
   /**
@@ -63,7 +52,7 @@ class AggregateBase extends _featureBase.FeatureBase {
    * @param {string} entityGuid
    * @returns {void}
    */
-  #setupEventStore(entityGuid) {
+  #setupEventStore() {
     if (this.events) return;
     switch (this.featureName) {
       // SessionReplay has its own storage mechanisms.
@@ -72,19 +61,39 @@ class AggregateBase extends _featureBase.FeatureBase {
       // 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 = this.agentRef.sharedAggregator ??= new _eventStoreManager.EventStoreManager(this.agentRef, _eventAggregator.EventAggregator, entityGuid, {
-          featureName: 'shared_aggregator'
-        });
+        this.events = this.agentRef.sharedAggregator ??= new _eventAggregator.EventAggregator();
         break;
-      /** All other features get EventBuffer in the ESM by default. Note: PVE is included here, but event buffer will always be empty so future harvests will still not happen by interval or EOL.
+      /** All other features get EventBuffer by default. Note: PVE is included here, but event buffer will always be empty so future harvests will still not happen by interval or EOL.
       This was necessary to prevent race cond. issues where the event buffer was checked before the feature could "block" itself.
       Its easier to just keep an empty event buffer in place. */
       default:
-        this.events = new _eventStoreManager.EventStoreManager(this.agentRef, _eventBuffer.EventBuffer, entityGuid, this);
+        this.events = new _eventBuffer.EventBuffer(_agentConstants.MAX_PAYLOAD_SIZE, this);
         break;
     }
   }
 
+  /** @type {Boolean} indicates if the feature supports registered entities and the harvest requirements therein. Also read by getter "harvestEndpointVersion". Controlled by feature flag in pre-release phase. */
+  get supportsRegisteredEntities() {
+    return this.featureName in _agentConstants.SUPPORTS_REGISTERED_ENTITIES && (_agentConstants.SUPPORTS_REGISTERED_ENTITIES[this.featureName] || this.agentRef.init.feature_flags.includes('register.' + this.featureName));
+  }
+
+  /**
+   * the endpoint version the feature uses during harvests
+   * @type {number}
+   * @returns {boolean}
+   */
+  get harvestEndpointVersion() {
+    return this.supportsRegisteredEntities && !!this.agentRef.runtime.registeredEntities.length ? 2 : 1;
+  }
+  waitForDrain() {
+    /** emitted when the feature successfully drains */
+    this.ee.on('drain-' + this.featureName, () => {
+      /** make an immediate harvest for all the features to help with harvestability for pre-load dervied data on short lived pages */
+      if (!this.drained) setTimeout(() => this.agentRef.runtime.harvester.triggerHarvestFor(this), 1);
+      this.drained = true;
+    });
+  }
+
   /**
    * Evaluates whether a harvest should be made early by estimating the size of the current payload.  Currently, this only happens if the event storage is EventBuffer, since that triggers this method directly.
    * If conditions are met, a new harvest will be triggered immediately.
@@ -132,7 +141,6 @@ class AggregateBase extends _featureBase.FeatureBase {
    */
   drain() {
     (0, _drain.drain)(this.agentIdentifier, this.featureName);
-    this.drained = true;
   }
   preHarvestChecks(opts) {
     return !this.blocked;
@@ -142,47 +150,38 @@ 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
    * @param {object|undefined} opts - opts passed from the harvester to help form the payload
-   * @param {string} opts.targetEntityGuid - the entity guid of the target app
+   * @param {string} opts.target - the target app metadata
    * @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 || this.events.isEmpty(this.harvestOpts, opts.targetEntityGuid)) return;
+    if (!this.events || this.events.isEmpty(this.harvestOpts)) return;
     // Other conditions and things to do when preparing harvest that is required.
     if (this.preHarvestChecks && !this.preHarvestChecks(opts)) return;
-    if (shouldRetryOnFail) this.events.save(this.harvestOpts, opts.targetEntityGuid);
-    const returnedDataArr = this.events.get(this.harvestOpts, opts.targetEntityGuid);
-    if (!returnedDataArr.length) return (0, _console.warn)(52);
-    this.events.clear(this.harvestOpts, opts.targetEntityGuid);
-    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, targetApp?.entityGuid) : data;
-      const payload = {
-        body
-      };
-      // Constructs the payload `qs` for relevant features on harvest.
-      if (this.queryStringsBuilder) payload.qs = this.queryStringsBuilder(data, targetApp?.entityGuid);
-      return {
-        targetApp,
-        payload
-      };
-    });
+    if (shouldRetryOnFail) this.events.save(this.harvestOpts);
+    const data = this.events.get(this.harvestOpts);
+    if (!data) return;
+    this.events.clear(this.harvestOpts);
+
+    // 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 payload;
   }
 
   /**
    * Cleanup task after a harvest.
    * @param {object} result - the cbResult object from the harvester's send method
-   * @param {object=} result.targetApp - the target app object that was used to point the harvest to the correct app
-   * @param {string=} result.targetApp.entityGuid - the entity guid of the target app
    * @param {boolean=} result.sent - whether the harvest was sent successfully
    * @param {boolean=} result.retry - whether the harvest should be retried
    */
   postHarvestCleanup(result = {}) {
     this.isRetrying = result.sent && result.retry;
-    if (this.isRetrying) this.events.reloadSave(this.harvestOpts, result.targetApp?.entityGuid);
-    this.events.clearSave(this.harvestOpts, result.targetApp?.entityGuid);
+    if (this.isRetrying) this.events.reloadSave(this.harvestOpts);
+    this.events.clearSave(this.harvestOpts);
   }
 
   /**
@@ -222,7 +221,6 @@ class AggregateBase extends _featureBase.FeatureBase {
   doOnceForAllAggregate(agentRef) {
     if (!agentRef.runtime.obfuscator) agentRef.runtime.obfuscator = new _obfuscate.Obfuscator(agentRef);
     this.obfuscator = agentRef.runtime.obfuscator;
-    if (!agentRef.runtime.entityManager) agentRef.runtime.entityManager = new _entityManager.EntityManager(this.agentRef);
     if (!agentRef.runtime.harvester) agentRef.runtime.harvester = new _harvester.Harvester(agentRef);
   }
 

package/dist/cjs/loaders/api/addPageAction.js

@@ -18,6 +18,6 @@ var _sharedHandlers = require("./sharedHandlers");
 function setupAddPageActionAPI(agent) {
   (0, _sharedHandlers.setupAPI)(_constants.ADD_PAGE_ACTION, (name, attributes) => addPageAction(name, attributes, agent), agent);
 }
-function addPageAction(name, attributes, agentRef, targetEntityGuid, timestamp = (0, _now.now)()) {
-  (0, _handle.handle)(_constants.prefix + _constants.ADD_PAGE_ACTION, [timestamp, name, attributes, targetEntityGuid], undefined, _features.FEATURE_NAMES.genericEvents, agentRef.ee);
+function addPageAction(name, attributes, agentRef, target, timestamp = (0, _now.now)()) {
+  (0, _handle.handle)(_constants.prefix + _constants.ADD_PAGE_ACTION, [timestamp, name, attributes, target], undefined, _features.FEATURE_NAMES.genericEvents, agentRef.ee);
 }

package/dist/cjs/loaders/api/log.js

@@ -21,6 +21,6 @@ function setupLogAPI(agent) {
 function log(message, {
   customAttributes = {},
   level = _constants.LOG_LEVELS.INFO
-} = {}, agentRef, targetEntityGuid, timestamp = (0, _now.now)()) {
-  (0, _utils.bufferLog)(agentRef.ee, message, customAttributes, level, targetEntityGuid, timestamp);
+} = {}, agentRef, target, timestamp = (0, _now.now)()) {
+  (0, _utils.bufferLog)(agentRef.ee, message, customAttributes, level, target, timestamp);
 }

package/dist/cjs/loaders/api/noticeError.js

@@ -18,8 +18,8 @@ var _sharedHandlers = require("./sharedHandlers");
 function setupNoticeErrorAPI(agent) {
   (0, _sharedHandlers.setupAPI)(_constants.NOTICE_ERROR, (err, customAttributes) => noticeError(err, customAttributes, agent), agent);
 }
-function noticeError(err, customAttributes, agentRef, targetEntityGuid, timestamp = (0, _now.now)()) {
+function noticeError(err, customAttributes, agentRef, target, timestamp = (0, _now.now)()) {
   if (typeof err === 'string') err = new Error(err);
-  (0, _handle.handle)('err', [err, timestamp, false, customAttributes, agentRef.runtime.isRecording, undefined, targetEntityGuid], undefined, _features.FEATURE_NAMES.jserrors, agentRef.ee);
+  (0, _handle.handle)('err', [err, timestamp, false, customAttributes, agentRef.runtime.isRecording, undefined, target], undefined, _features.FEATURE_NAMES.jserrors, agentRef.ee);
   (0, _handle.handle)('uaErr', [], undefined, _features.FEATURE_NAMES.genericEvents, agentRef.ee);
 }

package/dist/cjs/loaders/api/register-api-types.js

@@ -21,15 +21,15 @@ exports.default = void 0;
 /**
  * @typedef {Object} RegisterAPIConstructor
  * @property {Object} opts - The options for the registered entity.
- * @property {string} opts.licenseKey - The license key for the registered entity.
- * @property {string} opts.applicationID - The application ID for the registered entity.
+ * @property {string} opts.id - The unique id for the registered entity. This will be assigned to any synthesized entities.
+ * @property {string} opts.name - The readable name for the registered entity. This will be assigned to any synthesized entities.
  */
 /**
  * @typedef {Object} RegisterAPIMetadata
  * @property {Object} customAttributes - The custom attributes for the registered entity.
  * @property {Object} target - The options for the registered entity.
- * @property {string} target.licenseKey - The license key for the registered entity.
- * @property {string} target.applicationID - The application ID for the registered entity.
- * @property {string} target.entityGuid - The entity guid returned for the registered entity.
+ * @property {string} target.licenseKey - The license key for the registered entity. If none was supplied, it will assume the license key from the main agent.
+ * @property {string} target.id - The ID for the registered entity.
+ * @property {string} target.name - The name returned for the registered entity.
  */
 var _default = exports.default = {};