@newrelic/browser-agent 1.301.0 → 1.302.0-alpha.0

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

@@ -7,7 +7,7 @@ exports.buildRegisterApi = buildRegisterApi;
 exports.setupRegisterAPI = setupRegisterAPI;
 var _handle = require("../../common/event-emitter/handle");
 var _console = require("../../common/util/console");
-var _target = require("../../common/util/target");
+var _mfe = require("../../common/util/mfe");
 var _features = require("../features/features");
 var _now = require("../../common/timing/now");
 var _constants = require("../../features/metrics/constants");
@@ -16,6 +16,7 @@ var _constants2 = require("./constants");
 var _log = require("./log");
 var _addPageAction = require("./addPageAction");
 var _noticeError = require("./noticeError");
+var _invoke = require("../../common/util/invoke");
 /**
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -42,138 +43,120 @@ function setupRegisterAPI(agent) {
  * @param {Object} agentRef the reference to the base agent instance
  * @param {Object} handlers the shared handlers to be used by both the base agent's API and the external target's API
  * @param {Object} target the target information to be used by the external target's API to send data to the correct location
+ * @param {string} [target.licenseKey] the license key of the target to report data to
+ * @param {string} target.id the entity ID of the target to report data to
+ * @param {string} target.name the entity name of the target to report data to
  * @returns {RegisterAPI} the api object to be returned from the register api method
  */
 function buildRegisterApi(agentRef, target) {
   const attrs = {};
   (0, _console.warn)(54, 'newrelic.register');
+  target ||= {};
+  target.licenseKey ||= agentRef.info.licenseKey; // will inherit the license key from the container agent if not provided for brevity. A future state may dictate that we need different license keys to do different things.
+  target.blocked = false;
 
-  /** @type {Function|undefined} a function that is set and reports when APIs are triggered -- warns the customer of the invalid state  */
-  let invalidApiResponse;
+  /** @type {Function} a function that is set and reports when APIs are triggered -- warns the customer of the invalid state  */
+  let invalidApiResponse = () => {};
+  /** @type {Array} the array of registered target APIs */
+  const registeredEntities = agentRef.runtime.registeredEntities;
+
+  /** if we have already registered this target, go ahead and re-use it */
+  const preregisteredEntity = registeredEntities.find(({
+    metadata: {
+      target: {
+        id,
+        name
+      }
+    }
+  }) => id === target.id);
+  if (preregisteredEntity) {
+    if (preregisteredEntity.metadata.target.name !== target.name) preregisteredEntity.metadata.target.name = target.name;
+    return preregisteredEntity;
+  }
 
   /**
-       * A promise that indicates when all needed connections for the registered child to be ready to report data
-       * 1. The main agent to be ready (made a RUM call and got its entity guid)
-       * 2. The child to be registered with the main agent (made its own RUM call and got its entity guid)
-       * @type {Promise<RegisterAPI>}
-       */
-  let _connected;
-  if (!agentRef.init.api.allow_registered_children) invalidApiResponse = () => (0, _console.warn)(55);
-  if (!target || !(0, _target.isValidTarget)(target)) invalidApiResponse = () => (0, _console.warn)(48, target);
+   * Block the API, and supply a warning function to display a message to end users
+   * @param {Function} warning
+   */
+  const block = warning => {
+    target.blocked = true;
+    invalidApiResponse = warning;
+  };
+
+  /** primary cases that can block the register API from working at init time */
+  if (!agentRef.init.api.allow_registered_children) block((0, _invoke.single)(() => (0, _console.warn)(55)));
+  if (!(0, _mfe.isValidMFETarget)(target)) block((0, _invoke.single)(() => (0, _console.warn)(48, target)));
 
   /** @type {RegisterAPI} */
   const api = {
-    addPageAction: (name, attributes = {}) => {
-      report(_addPageAction.addPageAction, [name, {
+    addPageAction: (name, attributes = {}) => report(_addPageAction.addPageAction, [name, {
+      ...attrs,
+      ...attributes
+    }, agentRef], target),
+    log: (message, options = {}) => report(_log.log, [message, {
+      ...options,
+      customAttributes: {
         ...attrs,
-        ...attributes
-      }, agentRef], target);
-    },
-    log: (message, options = {}) => {
-      report(_log.log, [message, {
-        ...options,
-        customAttributes: {
-          ...attrs,
-          ...(options.customAttributes || {})
-        }
-      }, agentRef], target);
-    },
-    noticeError: (error, attributes = {}) => {
-      report(_noticeError.noticeError, [error, {
-        ...attrs,
-        ...attributes
-      }, agentRef], target);
-    },
-    setApplicationVersion: value => {
-      attrs['application.version'] = value;
-    },
-    setCustomAttribute: (key, value) => {
-      attrs[key] = value;
-    },
-    setUserId: value => {
-      attrs['enduser.id'] = value;
-    },
+        ...(options.customAttributes || {})
+      }
+    }, agentRef], target),
+    noticeError: (error, attributes = {}) => report(_noticeError.noticeError, [error, {
+      ...attrs,
+      ...attributes
+    }, agentRef], target),
+    setApplicationVersion: value => setLocalValue('application.version', value),
+    setCustomAttribute: (key, value) => setLocalValue(key, value),
+    setUserId: value => setLocalValue('enduser.id', value),
     /** metadata */
     metadata: {
       customAttributes: attrs,
-      target,
-      /** set in a getter so that later access of the Promise is not polluted before customer is allowed to set a catch block */
-      get connected() {
-        return _connected || Promise.reject(new Error('Failed to connect'));
-      }
+      target
     }
   };
-  if (invalidApiResponse) {
-    invalidApiResponse();
-  } else {
-    _connected = new Promise((resolve, reject) => {
-      try {
-        const entityManager = agentRef.runtime?.entityManager;
-        /** check if main agent already has main agent entity guid */
-        let mainAgentReady = !!entityManager?.get().entityGuid;
-        /** check if registered target already has entity guid */
-        let registeredEntityGuid = entityManager?.getEntityGuidFor(target.licenseKey, target.applicationID);
-        let registrationReady = !!registeredEntityGuid;
-
-        /** check if we can just resolve immediately without making another connect call */
-        if (mainAgentReady && registrationReady) {
-          target.entityGuid = registeredEntityGuid;
-          resolve(api);
-        } else {
-          /** we need to make a new connection call since we dont already have a registered entity for this call */
 
-          /** if the connect callback doesnt resolve in 15 seconds... reject */
-          const timeout = setTimeout(() => reject(new Error('Failed to connect - Timeout')), 15000);
+  /**
+   * Check if the API is blocked and emit a warning message describing the blockage
+   * @returns {boolean}
+   */
+  const isBlocked = () => {
+    if (target.blocked) invalidApiResponse();
+    return target.blocked;
+  };
 
-          // tell the main agent to send a rum call for this target
-          // when the rum call resolves, it will emit an "entity-added" event, see below
-          agentRef.ee.emit('api-send-rum', [attrs, target]);
+  /** only allow registered APIs to be tracked in the agent runtime */
+  if (!isBlocked()) registeredEntities.push(api);
 
-          // wait for entity events to emit to see when main agent and/or API registration is ready
-          agentRef.ee.on('entity-added', entityEventHandler);
-          function entityEventHandler(entity) {
-            if ((0, _target.isContainerAgentTarget)(entity, agentRef)) mainAgentReady ||= true;else {
-              if (target.licenseKey === entity.licenseKey && target.applicationID === entity.applicationID) {
-                registrationReady = true;
-                target.entityGuid = entity.entityGuid;
-              }
-            }
-            if (mainAgentReady && registrationReady) {
-              clearTimeout(timeout);
-              // unsubscribe from the event emitter
-              agentRef.ee.removeEventListener('entity-added', entityEventHandler);
-              resolve(api);
-            }
-          }
-        }
-      } catch (err) {
-        reject(err);
-      }
-    });
-  }
+  /**
+   * Sets a value local to the registered API attrs. Will do nothing if APIs are deregistered.
+   * @param {string} key The attribute key
+   * @param {*} value the attribute value
+   * @returns {void}
+   */
+  const setLocalValue = (key, value) => {
+    if (isBlocked()) return;
+    attrs[key] = value;
+  };
 
   /**
      * The reporter method that will be used to report the data to the container agent's API method. If invalid, will log a warning and not execute.
      * If the api.duplicate_registered_data configuration value is set to true, the data will be reported to BOTH the container and the external target
      * @param {*} methodToCall the container agent's API method to call
      * @param {*} args the arguments to supply to the container agent's API method
-     * @param {string} targetEntityGuid the target entity guid, which looks up the target to report the data to from the entity manager. If undefined, will report to the container agent's target.
+     * @param {string} target the target to report the data to. If undefined, will report to the container agent's target.
      * @returns
      */
-  const report = async (methodToCall, args, target) => {
-    if (invalidApiResponse) return invalidApiResponse();
+  const report = (methodToCall, args, target) => {
+    if (isBlocked()) return;
     /** set the timestamp before the async part of waiting for the rum response for better accuracy */
     const timestamp = (0, _now.now)();
     (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ["API/register/".concat(methodToCall.name, "/called")], undefined, _features.FEATURE_NAMES.metrics, agentRef.ee);
     try {
-      await _connected;
-      // target should be decorated with entityGuid by the rum resp at this point
       const shouldDuplicate = agentRef.init.api.duplicate_registered_data;
-      if (shouldDuplicate === true || Array.isArray(shouldDuplicate) && shouldDuplicate.includes(target.entityGuid)) {
+      if (shouldDuplicate === true || Array.isArray(shouldDuplicate)) {
         // also report to container by providing undefined target
         methodToCall(...args, undefined, timestamp);
       }
-      methodToCall(...args, target.entityGuid, timestamp); // always report to target
+      return methodToCall(...args, target, timestamp); // always report to target
     } catch (err) {
       (0, _console.warn)(50, err);
     }

package/dist/esm/common/config/init-types.js

@@ -35,7 +35,7 @@
  * @property {Object} [metrics]
  * @property {boolean} [metrics.enabled] - Turn on/off the metrics feature (on by default).
  * @property {boolean} [metrics.autoStart] - If true, the agent will automatically start the metrics feature. Otherwise, it will be in a deferred state until the `start` API method is called.
- * @property {Array<Object>} [obfuscate] - Array of regexp and corresponding replacement patterns for obfuscating data.
+ * @property {{regex: RegExp | string, replacement: string}[]} [obfuscate] - Array of regexp and corresponding replacement patterns for obfuscating data.
  * @property {Object} [page_action]
  * @property {boolean} [page_action.enabled] - Must be true to allow PageAction events to be captured.
  * @property {Object} [page_view_event]

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

@@ -21,6 +21,7 @@ const InitModelFn = () => {
   const hiddenState = {
     feature_flags: [],
     experimental: {
+      allow_registered_children: false,
       resources: false
     },
     mask_selector: '*',
@@ -53,7 +54,12 @@ const InitModelFn = () => {
       autoStart: true
     },
     api: {
-      allow_registered_children: true,
+      get allow_registered_children() {
+        return hiddenState.feature_flags.includes(FEATURE_FLAGS.REGISTER) || hiddenState.experimental.allow_registered_children;
+      },
+      set allow_registered_children(val) {
+        hiddenState.experimental.allow_registered_children = val;
+      },
       duplicate_registered_data: false
     },
     distributed_tracing: {

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

@@ -23,7 +23,6 @@ const RuntimeModel = {
   customTransaction: undefined,
   denyList: undefined,
   disabled: false,
-  entityManager: undefined,
   harvester: undefined,
   isolatedBacklog: false,
   isRecording: false,
@@ -36,6 +35,7 @@ const RuntimeModel = {
   releaseIds: {},
   session: undefined,
   timeKeeper: undefined,
+  registeredEntities: [],
   /** a proxy is set in agent-session to track jsAttributes changes for harvesting mechanics */
   jsAttributesMetadata: {
     bytes: 0

package/dist/esm/common/constants/agent-constants.js

@@ -2,7 +2,15 @@
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
+import { FEATURE_NAMES } from '../../loaders/features/features';
 export const IDEAL_PAYLOAD_SIZE = 16000;
 export const MAX_PAYLOAD_SIZE = 1000000;
 export const DEFAULT_KEY = 'NR_CONTAINER_AGENT';
-export const SESSION_ERROR = 'SESSION_ERROR';
+export const SESSION_ERROR = 'SESSION_ERROR';
+export const SUPPORTS_REGISTERED_ENTITIES = {
+  [FEATURE_NAMES.logging]: true,
+  // flip other features here when they are supported by DEM consumers
+  [FEATURE_NAMES.genericEvents]: false,
+  [FEATURE_NAMES.jserrors]: false,
+  [FEATURE_NAMES.ajax]: false
+};

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

@@ -11,7 +11,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.301.0";
+export const VERSION = "1.302.0-alpha.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -11,7 +11,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.301.0";
+export const VERSION = "1.302.0-alpha.0";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/drain/drain.js

@@ -122,7 +122,7 @@ function drainGroup(agentIdentifier, group, activateGroup = true) {
   }
   if (!baseEE.isolatedBacklog) delete handlers[group];
   baseEE.backlog[group] = null;
-  baseEE.emit('drain-' + group, []); // TODO: Code exists purely for a unit test and needs to be refined
+  baseEE.emit('drain-' + group, []); // Informs the feature that it has drained its backlog of events, this kicks off an immediate harvest to capture any load-driven events that were buffered.
 }
 
 /**

package/dist/esm/common/harvest/harvester.js

@@ -53,35 +53,30 @@ export class Harvester {
    * @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 output = {
+      ranSend: false,
+      payload: undefined,
+      endpointVersion: aggregateInst.harvestEndpointVersion || 1
+    };
+    if (aggregateInst.blocked) return output;
     const submitMethod = getSubmitMethod(localOpts);
-    if (!submitMethod) return false;
+    if (!submitMethod) return output;
     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, localOpts); // 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,
-        featureName: aggregateInst.featureName
-      });
-      ranSend = true;
+    output.payload = !localOpts.directSend ? aggregateInst.makeHarvestPayload(shouldRetryOnFail, localOpts) : localOpts.directSend?.payload; // features like PVE can define the payload directly, bypassing the makeHarvestPayload logic
+
+    if (!output.payload) return output;
+    send(this.agentRef, {
+      endpoint: FEATURE_TO_ENDPOINT[aggregateInst.featureName],
+      payload: output.payload,
+      localOpts,
+      submitMethod,
+      cbFinished,
+      raw: aggregateInst.harvestOpts.raw,
+      featureName: aggregateInst.featureName,
+      endpointVersion: output.endpointVersion
     });
-    return ranSend;
+    output.ranSend = true;
+    return output;
 
     /**
      * 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.
@@ -114,13 +109,13 @@ const warnings = {};
   */
 export function send(agentRef, {
   endpoint,
-  targetApp,
   payload,
   localOpts = {},
   submitMethod,
   cbFinished,
   raw,
-  featureName
+  featureName,
+  endpointVersion = 1
 }) {
   if (!agentRef.info.errorBeacon) return false;
   let {
@@ -130,15 +125,14 @@ export function send(agentRef, {
   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
+      sent: false
     });
     return false;
   }
   const protocol = agentRef.init.ssl === false ? 'http' : 'https';
   const perceivedBeacon = agentRef.init.proxy.beacon || agentRef.info.errorBeacon;
-  const url = raw ? "".concat(protocol, "://").concat(perceivedBeacon, "/").concat(endpoint) : "".concat(protocol, "://").concat(perceivedBeacon).concat(endpoint !== RUM ? '/' + endpoint : '', "/1/").concat(targetApp.licenseKey);
-  const baseParams = !raw ? baseQueryString(agentRef, qs, endpoint, targetApp.applicationID) : '';
+  const url = raw ? "".concat(protocol, "://").concat(perceivedBeacon, "/").concat(endpoint) : "".concat(protocol, "://").concat(perceivedBeacon).concat(endpoint !== RUM ? '/' + endpoint : '', "/").concat(endpointVersion, "/").concat(agentRef.info.licenseKey);
+  const baseParams = !raw ? baseQueryString(agentRef, qs, endpoint) : '';
   let payloadParams = obj(qs, agentRef.runtime.maxBytes);
   if (baseParams === '' && payloadParams.startsWith('&')) {
     payloadParams = payloadParams.substring(1);
@@ -181,8 +175,7 @@ export function send(agentRef, {
           status: this.status,
           retry: shouldRetry(this.status),
           fullUrl,
-          xhr: this,
-          targetApp
+          xhr: this
         };
         if (localOpts.needResponse) cbResult.responseText = this.responseText;
         cbFinished(cbResult);
@@ -198,8 +191,7 @@ export function send(agentRef, {
           status,
           retry: shouldRetry(status),
           fullUrl,
-          fetchResponse: response,
-          targetApp
+          fetchResponse: response
         };
         if (localOpts.needResponse) cbResult.responseText = await response.text();
         cbFinished(cbResult);
@@ -240,7 +232,6 @@ export function send(agentRef, {
     data: {
       endpoint,
       headers,
-      targetApp,
       payload,
       submitMethod: getSubmitMethodName(),
       raw,
@@ -290,12 +281,12 @@ function cleanPayload(payload = {}) {
 }
 
 // The stuff that gets sent every time.
-function baseQueryString(agentRef, qs, endpoint, applicationID) {
+function baseQueryString(agentRef, qs, endpoint) {
   const ref = agentRef.runtime.obfuscator.obfuscateString(cleanURL('' + globalScope.location));
   const session = agentRef.runtime.session;
   const hr = !!session?.state.sessionReplaySentFirstChunk && session?.state.sessionReplayMode === 1 && endpoint !== JSERRORS;
   const ht = !!session?.state.traceHarvestStarted && session?.state.sessionTraceMode === 1 && ![LOGS, BLOBS].includes(endpoint);
-  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',
+  const qps = ['a=' + agentRef.info.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=' + (session?.state.value || '0'),
   // the 0 id encaps all untrackable and default traffic

package/dist/esm/common/util/mfe.js

@@ -0,0 +1,38 @@
+/**
+ * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @param {Object} [target] - the target to be validated
+ * @returns {boolean}
+ */
+export function isValidMFETarget(target = {}) {
+  return !!(target.id && target.name);
+}
+
+/**
+ * When given a valid target, returns an object with the MFE payload attributes.  Returns an empty object otherwise.
+ * @param {Object} [target] the registered target
+ * @param {AggregateInstance} [aggregateInstance] the aggregate instance calling the method
+ * @returns {{'mfe.id': *, 'mfe.name': String}|{}} returns an empty object if args are not supplied or the aggregate instance is not supporting version 2
+ */
+export function getVersion2Attributes(target, aggregateInstance) {
+  if (aggregateInstance?.harvestEndpointVersion !== 2) return {};
+  const containerAgentEntityGuid = aggregateInstance.agentRef.runtime.appMetadata.agents[0].entityGuid;
+  if (!isValidMFETarget(target)) {
+    return {
+      'entity.guid': containerAgentEntityGuid,
+      appId: aggregateInstance.agentRef.info.applicationID
+    };
+  }
+  return {
+    'mfe.id': target.id,
+    // these field names may change as the schema is finalized
+    'mfe.name': target.name,
+    // these field names may change as the schema is finalized
+    eventSource: 'MicroFrontendBrowserAgent',
+    // these field names may change as the schema is finalized
+    'parent.id': containerAgentEntityGuid
+  };
+}

package/dist/esm/features/ajax/aggregate/index.js

@@ -124,9 +124,13 @@ export class Aggregate extends AggregateBase {
     if (!eventBuffer.length) return;
     const addString = getAddStringContext(this.agentRef.runtime.obfuscator);
     let payload = 'bel.7;';
+    let firstTimestamp = 0;
     for (let i = 0; i < eventBuffer.length; i++) {
       const event = eventBuffer[i];
-      const fields = [numeric(event.startTime), numeric(event.endTime - event.startTime), numeric(0),
+      // ajax nodes are relative to the first node (or page origin if no previous node), so we need to calculate the relative start time
+      const relativeStartTime = event.startTime - firstTimestamp;
+      if (i === 0) firstTimestamp = event.startTime;
+      const fields = [numeric(relativeStartTime), numeric(event.endTime - event.startTime), numeric(0),
       // callbackEnd
       numeric(0),
       // no callbackDuration for non-SPA events

package/dist/esm/features/generic_events/aggregate/index.js

@@ -14,6 +14,7 @@ import { applyFnToProps } from '../../../common/util/traverse';
 import { UserActionsAggregator } from './user-actions/user-actions-aggregator';
 import { isIFrameWindow } from '../../../common/dom/iframe';
 import { isPureObject } from '../../../common/util/type-check';
+import { getVersion2Attributes } from '../../../common/util/mfe';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   #userActionAggregator;
@@ -36,8 +37,7 @@ export class Aggregate extends AggregateBase {
         });
       }, this.featureName, this.ee);
       if (agentRef.init.page_action.enabled) {
-        registerHandler('api-addPageAction', (timestamp, name, attributes, targetEntityGuid) => {
-          if (!this.agentRef.runtime.entityManager.get(targetEntityGuid)) return warn(56, this.featureName);
+        registerHandler('api-addPageAction', (timestamp, name, attributes, target) => {
           this.addEvent({
             ...attributes,
             eventType: 'PageAction',
@@ -49,7 +49,7 @@ export class Aggregate extends AggregateBase {
               browserWidth: window.document.documentElement?.clientWidth,
               browserHeight: window.document.documentElement?.clientHeight
             })
-          }, targetEntityGuid);
+          }, target);
         }, this.featureName, this.ee);
       }
       let addUserAction = () => {/** no-op */};
@@ -247,7 +247,6 @@ export class Aggregate extends AggregateBase {
         };
         this.addEvent(event);
       }, this.featureName, this.ee);
-      agentRef.runtime.harvester.triggerHarvestFor(this);
       this.drain();
     });
   }
@@ -263,10 +262,10 @@ export class Aggregate extends AggregateBase {
    * * sessionTraceId: set by the `ptid=` query param
    * * userAgent*: set by the userAgent header
    * @param {object=} obj the event object for storing in the event buffer
-   * @param {string=} targetEntityGuid the target entity guid for the event to scope buffering and harvesting. Defaults to agent config if undefined
+   * @param {string=} target the target metadata for the event to scope buffering and harvesting. Defaults to container agent config if undefined
    * @returns void
    */
-  addEvent(obj = {}, targetEntityGuid) {
+  addEvent(obj = {}, target) {
     if (!obj || !Object.keys(obj).length) return;
     if (!obj.eventType) {
       warn(44);
@@ -281,7 +280,9 @@ export class Aggregate extends AggregateBase {
       timestamp: Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(now())),
       /** all generic events require pageUrl(s) */
       pageUrl: cleanURL('' + initialLocation),
-      currentUrl: cleanURL('' + location)
+      currentUrl: cleanURL('' + location),
+      /** Specific attributes only supplied if harvesting to endpoint version 2 */
+      ...getVersion2Attributes(target, this)
     };
     const eventAttributes = {
       /** Agent-level custom attributes */
@@ -291,7 +292,7 @@ export class Aggregate extends AggregateBase {
       /** Event-specific attributes take precedence over agent-level custom attributes and fallbacks */
       ...obj
     };
-    this.events.add(eventAttributes, targetEntityGuid);
+    this.events.add(eventAttributes);
   }
   serializer(eventBuffer) {
     return applyFnToProps({

package/dist/esm/features/generic_events/constants.js

@@ -11,5 +11,7 @@ export const RAGE_CLICK_THRESHOLD_MS = 1000;
 export const FRUSTRATION_TIMEOUT_MS = 2000;
 export const RESERVED_EVENT_TYPES = ['PageAction', 'UserAction', 'BrowserPerformance'];
 export const FEATURE_FLAGS = {
-  RESOURCES: 'experimental.resources'
+  RESOURCES: 'experimental.resources',
+  REGISTER: 'register'
+  // register.jserrors and register.generic_events are also used, but not referenced directly so no need to represent here
 };