@newrelic/browser-agent 1.301.0-rc.0 → 1.301.0-rc.2

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

@@ -14,6 +14,16 @@ export class AggregateBase extends FeatureBase {
     isRetrying: boolean;
     harvestOpts: {};
     events: any;
+    /** @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(): boolean;
+    /**
+     * the endpoint version the feature uses during harvests
+     * @type {number}
+     * @returns {boolean}
+     */
+    get harvestEndpointVersion(): number;
+    waitForDrain(): void;
+    drained: boolean | undefined;
     /**
      * 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.
@@ -30,26 +40,24 @@ export class AggregateBase extends FeatureBase {
      * Stages the feature to be drained
      */
     drain(): void;
-    drained: boolean | undefined;
     preHarvestChecks(opts: any): boolean;
     /**
      * 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?: boolean, opts?: object | undefined): any[];
     /**
      * 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?: {
-        targetApp?: object | undefined;
+        sent?: boolean | undefined;
+        retry?: boolean | undefined;
     }): void;
     /**
      * Checks for additional `jsAttributes` items to support backward compatibility with implementations of the agent where

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":"AAsBA;IACE;;;;OAIG;IACH,sBAHW,MAAM,eACN,MAAM,EA2BhB;IAvBC,iBAAwB;IAIxB,uOAAuO;IACvO,qCAAwC;IACxC,gLAAgL;IAChL,yBAA2B;IAC3B,sFAAsF;IACtF,oBAAuB;IAEvB,gBAAqB;IA4BjB,YAAwJ;IAW9J;;;;OAIG;IACH,2BAOC;IAED;;;;OAIG;IACH,yBAHW,MAAM,EAAE,gBAwBlB;IAED;;OAEG;IACH,cAGC;IADC,6BAAmB;IAGrB,qCAEC;IAED;;;;;;OAMG;IACH,uDAJW,MAAM,GAAC,SAAS,SAyB1B;IAED;;;;;;;OAOG;IACH,4BALG;QAAwB,SAAS,GAAzB,MAAM,YAAC;KACf,QAQF;IAED;;;OAGG;IACH,6CAsBC;IAED;;;OAGG;IACH,2CAOC;IALC,gBAA6C;IAO/C;;;;OAIG;IACH,uCAHW,GAAC,UACD,GAAC,QAIX;;CACF;4BA/N2B,gBAAgB"}
+{"version":3,"file":"aggregate-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/aggregate-base.js"],"names":[],"mappings":"AAmBA;IACE;;;;OAIG;IACH,sBAHW,MAAM,eACN,MAAM,EAoBhB;IAhBC,iBAAwB;IAIxB,uOAAuO;IACvO,qCAAwC;IACxC,gLAAgL;IAChL,yBAA2B;IAC3B,sFAAsF;IACtF,oBAAuB;IAEvB,gBAAqB;IAqBjB,YAAsE;IAW5E,iNAAiN;IACjN,0CAEC;IAED;;;;OAIG;IACH,8BAHU,MAAM,CAKf;IAED,qBAOC;IAFG,6BAAmB;IAIvB;;;;OAIG;IACH,2BAOC;IAED;;;;OAIG;IACH,yBAHW,MAAM,EAAE,gBAwBlB;IAED;;OAEG;IACH,cAEC;IAED,qCAEC;IAED;;;;;;OAMG;IACH,uDAJW,MAAM,GAAC,SAAS,SAsB1B;IAED;;;;;OAKG;IACH,4BAHG;QAAyB,IAAI,GAArB,OAAO,YAAC;QACS,KAAK,GAAtB,OAAO,YAAC;KAClB,QAKA;IAED;;;OAGG;IACH,6CAsBC;IAED;;;OAGG;IACH,2CAKC;IAHC,gBAA6C;IAK/C;;;;OAIG;IACH,uCAHW,GAAC,UACD,GAAC,QAIX;;CACF;4BApO2B,gBAAgB"}

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

@@ -1,3 +1,3 @@
 export function setupAddPageActionAPI(agent: any): void;
-export function addPageAction(name: any, attributes: any, agentRef: any, targetEntityGuid: any, timestamp?: number): void;
+export function addPageAction(name: any, attributes: any, agentRef: any, target: any, timestamp?: number): void;
 //# sourceMappingURL=addPageAction.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"addPageAction.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/addPageAction.js"],"names":[],"mappings":"AAUA,wDAEC;AAED,0HAEC"}
+{"version":3,"file":"addPageAction.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/addPageAction.js"],"names":[],"mappings":"AAUA,wDAEC;AAED,gHAEC"}

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

@@ -2,5 +2,5 @@ export function setupLogAPI(agent: any): void;
 export function log(message: any, { customAttributes, level }: {
     customAttributes?: {} | undefined;
     level?: string | undefined;
-} | undefined, agentRef: any, targetEntityGuid: any, timestamp?: number): void;
+} | undefined, agentRef: any, target: any, timestamp?: number): void;
 //# sourceMappingURL=log.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/log.js"],"names":[],"mappings":"AAWA,8CAEC;AAED;;;+EAEC"}
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/log.js"],"names":[],"mappings":"AAWA,8CAEC;AAED;;;qEAEC"}

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

@@ -1,3 +1,3 @@
 export function setupNoticeErrorAPI(agent: any): void;
-export function noticeError(err: any, customAttributes: any, agentRef: any, targetEntityGuid: any, timestamp?: number): void;
+export function noticeError(err: any, customAttributes: any, agentRef: any, target: any, timestamp?: number): void;
 //# sourceMappingURL=noticeError.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"noticeError.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/noticeError.js"],"names":[],"mappings":"AAUA,sDAEC;AAED,6HAIC"}
+{"version":3,"file":"noticeError.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/noticeError.js"],"names":[],"mappings":"AAUA,sDAEC;AAED,mHAIC"}

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

@@ -35,8 +35,8 @@ export type RegisterAPIConstructor = {
      * - The options for the registered entity.
      */
     opts: {
-        licenseKey: string;
-        applicationID: string;
+        id: string;
+        name: string;
     };
 };
 export type RegisterAPIMetadata = {
@@ -49,8 +49,8 @@ export type RegisterAPIMetadata = {
      */
     target: {
         licenseKey: string;
-        applicationID: string;
-        entityGuid: string;
+        id: string;
+        name: string;
     };
 };
 //# sourceMappingURL=register-api-types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"register-api-types.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/register-api-types.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAac,mBAAmB;;;;;;UAM9B;QAAwB,UAAU,EAAvB,MAAM;QACO,aAAa,EAA1B,MAAM;KACnB;;;;;;sBAIa,MAAM;;;;YAEjB;QAA0B,UAAU,EAAzB,MAAM;QACS,aAAa,EAA5B,MAAM;QACS,UAAU,EAAzB,MAAM;KACnB"}
+{"version":3,"file":"register-api-types.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/register-api-types.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAac,mBAAmB;;;;;;UAM9B;QAAwB,EAAE,EAAf,MAAM;QACO,IAAI,EAAjB,MAAM;KACnB;;;;;;sBAIa,MAAM;;;;YAEjB;QAA0B,UAAU,EAAzB,MAAM;QACS,EAAE,EAAjB,MAAM;QACS,IAAI,EAAnB,MAAM;KACnB"}

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

@@ -13,8 +13,15 @@ export function setupRegisterAPI(agent: any): void;
  * @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
  */
-export function buildRegisterApi(agentRef: Object, target: Object): RegisterAPI;
+export function buildRegisterApi(agentRef: Object, target: {
+    licenseKey?: string | undefined;
+    id: string;
+    name: string;
+}): RegisterAPI;
 export type RegisterAPI = import("./register-api-types").RegisterAPI;
 //# sourceMappingURL=register.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/register.js"],"names":[],"mappings":"AAgBA;;GAEG;AAEH;;;;GAIG;AACH,mDAIC;AAED;;;;;;;GAOG;AACH,2CALW,MAAM,UAEN,MAAM,GACJ,WAAW,CAkIvB;0BAtJY,OAAO,sBAAsB,EAAE,WAAW"}
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/register.js"],"names":[],"mappings":"AAiBA;;GAEG;AAEH;;;;GAIG;AACH,mDAIC;AAED;;;;;;;;;;GAUG;AACH,2CARW,MAAM,UAGd;IAAwB,UAAU;IACX,EAAE,EAAjB,MAAM;IACS,IAAI,EAAnB,MAAM;CACd,GAAU,WAAW,CAmGvB;0BA1HY,OAAO,sBAAsB,EAAE,WAAW"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.301.0-rc.0",
+  "version": "1.301.0-rc.2",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",

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

@@ -21,6 +21,7 @@ const InitModelFn = () => {
   const hiddenState = {
     feature_flags: [],
     experimental: {
+      allow_registered_children: false,
       resources: false
     },
     mask_selector: '*',
@@ -48,7 +49,8 @@ const InitModelFn = () => {
   return {
     ajax: { deny_list: undefined, block_internal: true, enabled: true, 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/src/common/config/runtime.js

@@ -25,7 +25,6 @@ const RuntimeModel = {
   customTransaction: undefined,
   denyList: undefined,
   disabled: false,
-  entityManager: undefined,
   harvester: undefined,
   isolatedBacklog: false,
   isRecording: false, // true when actively recording, false when paused or stopped
@@ -37,6 +36,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 },
   get harvestCount () { return ++_harvestCount }

package/src/common/constants/agent-constants.js

@@ -2,7 +2,17 @@
  * 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 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/src/common/drain/drain.js

@@ -123,7 +123,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/src/common/harvest/harvester.js

@@ -55,34 +55,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.
@@ -112,13 +108,13 @@ const warnings = {}
   * @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.
   */
-export function send (agentRef, { endpoint, targetApp, payload, localOpts = {}, submitMethod, cbFinished, raw, featureName }) {
+export function send (agentRef, { endpoint, payload, localOpts = {}, submitMethod, cbFinished, raw, featureName, endpointVersion = 1 }) {
   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 })
+    if (cbFinished) cbFinished({ sent: false })
     return false
   }
 
@@ -126,8 +122,8 @@ export function send (agentRef, { endpoint, targetApp, payload, localOpts = {},
   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.applicationID) : ''
+    : `${protocol}://${perceivedBeacon}${endpoint !== RUM ? '/' + endpoint : ''}/${endpointVersion}/${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)
@@ -159,7 +155,7 @@ export function send (agentRef, { endpoint, targetApp, payload, localOpts = {},
       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), fullUrl, xhr: this, targetApp }
+        const cbResult = { sent: this.status !== 0, status: this.status, retry: shouldRetry(this.status), fullUrl, xhr: this }
         if (localOpts.needResponse) cbResult.responseText = this.responseText
         cbFinished(cbResult)
 
@@ -169,7 +165,7 @@ export function send (agentRef, { endpoint, targetApp, payload, localOpts = {},
     } 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 }
+        const cbResult = { sent: true, status, retry: shouldRetry(status), fullUrl, fetchResponse: response }
         if (localOpts.needResponse) cbResult.responseText = await response.text()
         cbFinished(cbResult)
         /** temporary audit of consistency of harvest metadata flags */
@@ -207,7 +203,6 @@ export function send (agentRef, { endpoint, targetApp, payload, localOpts = {},
     data: {
       endpoint,
       headers,
-      targetApp,
       payload,
       submitMethod: getSubmitMethodName(),
       raw,
@@ -264,14 +259,14 @@ 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,
+    'a=' + agentRef.info.applicationID,
     param('sa', (agentRef.info.sa ? '' + agentRef.info.sa : '')),
     param('v', VERSION),
     transactionNameParam(),

package/src/common/util/mfe.js

@@ -0,0 +1,35 @@
+/**
+ * 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/src/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
@@ -42,8 +43,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',
@@ -55,7 +55,7 @@ export class Aggregate extends AggregateBase {
               browserWidth: window.document.documentElement?.clientWidth,
               browserHeight: window.document.documentElement?.clientHeight
             })
-          }, targetEntityGuid)
+          }, target)
         }, this.featureName, this.ee)
       }
 
@@ -242,7 +242,6 @@ export class Aggregate extends AggregateBase {
         this.addEvent(event)
       }, this.featureName, this.ee)
 
-      agentRef.runtime.harvester.triggerHarvestFor(this)
       this.drain()
     })
   }
@@ -258,10 +257,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)
@@ -278,7 +277,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 = {
@@ -290,7 +291,7 @@ export class Aggregate extends AggregateBase {
       ...obj
     }
 
-    this.events.add(eventAttributes, targetEntityGuid)
+    this.events.add(eventAttributes)
   }
 
   serializer (eventBuffer) {

package/src/features/generic_events/constants.js

@@ -17,5 +17,7 @@ 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
 }

package/src/features/jserrors/aggregate/index.js

@@ -19,8 +19,7 @@ import { AggregateBase } from '../../utils/aggregate-base'
 import { now } from '../../../common/timing/now'
 import { applyFnToProps } from '../../../common/util/traverse'
 import { evaluateInternalError } from './internal-errors'
-import { isContainerAgentTarget } from '../../../common/util/target'
-import { warn } from '../../../common/util/console'
+import { getVersion2Attributes } from '../../../common/util/mfe'
 import { buildCauseString } from './cause-string'
 
 /**
@@ -32,6 +31,8 @@ export class Aggregate extends AggregateBase {
   constructor (agentRef) {
     super(agentRef, FEATURE_NAME)
 
+    /** set up agg-level behaviors specific to this feature */
+    this.harvestOpts.aggregatorTypes = ['err', 'ierr', 'xhr'] // the types in EventAggregator this feature cares about
     this.stackReported = {}
     this.observedAt = {}
     this.pageviewReported = {}
@@ -46,8 +47,6 @@ export class Aggregate extends AggregateBase {
     register('softNavFlush', (interactionId, wasFinished, softNavAttrs, interactionEndTime) =>
       this.onSoftNavNotification(interactionId, wasFinished, softNavAttrs, interactionEndTime), this.featureName, this.ee) // when an ixn is done or cancelled
 
-    this.harvestOpts.aggregatorTypes = ['err', 'ierr', 'xhr'] // the types in EventAggregator this feature cares about
-
     // 0 == off, 1 == on
     this.waitForFlags(['err']).then(([errFlag]) => {
       if (errFlag) {
@@ -113,10 +112,8 @@ export class Aggregate extends AggregateBase {
    * @param {object=} target the target to buffer and harvest to, if undefined the default configuration target is used
    * @returns
    */
-  storeError (err, time, internal, customAttributes, hasReplay, swallowReason, targetEntityGuid) {
+  storeError (err, time, internal, customAttributes, hasReplay, swallowReason, target) {
     if (!err) return
-    const target = this.agentRef.runtime.entityManager.get(targetEntityGuid)
-    if (!target) return warn(56, this.featureName)
     // are we in an interaction
     time = time || now()
     let filterOutput
@@ -155,7 +152,7 @@ export class Aggregate extends AggregateBase {
     if (filterOutput?.group) params.errorGroup = filterOutput.group
 
     // Should only decorate "hasReplay" for the container agent, so check if the target matches the config
-    if (hasReplay && isContainerAgentTarget(target, this.agentRef)) params.hasReplay = hasReplay
+    if (hasReplay && !target) params.hasReplay = hasReplay
     /**
      * The bucketHash is different from the params.stackHash because the params.stackHash is based on the canonicalized
      * stack trace and is used downstream in NR1 to attempt to group the same errors across different browsers. However,
@@ -191,7 +188,7 @@ export class Aggregate extends AggregateBase {
 
     // Trace sends the error in its payload, and both trace & replay simply listens for any error to occur.
     const jsErrorEvent = [type, bucketHash, params, newMetrics, customAttributes]
-    if (this.shouldAllowMainAgentToCapture(targetEntityGuid)) handle('trace-jserror', jsErrorEvent, undefined, FEATURE_NAMES.sessionTrace, this.ee)
+    if (this.shouldAllowMainAgentToCapture(target)) handle('trace-jserror', jsErrorEvent, undefined, FEATURE_NAMES.sessionTrace, this.ee)
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return
 
@@ -200,7 +197,7 @@ export class Aggregate extends AggregateBase {
       params._interactionNodeId = err.__newrelic[this.agentIdentifier].interactionNodeId
     }
 
-    if (this.shouldAllowMainAgentToCapture(targetEntityGuid)) {
+    if (this.shouldAllowMainAgentToCapture(target)) {
       const softNavInUse = Boolean(this.agentRef.features?.[FEATURE_NAMES.softNav])
       // Note: the following are subject to potential race cond wherein if the other feature aren't fully initialized, it'll be treated as there being no associated interaction.
       // They each will also tack on their respective properties to the params object as part of the decision flow.
@@ -221,12 +218,15 @@ export class Aggregate extends AggregateBase {
     }
 
     // always add directly if scoped to a sub-entity, the other pathways above will be deterministic if the main agent should procede
-    if (targetEntityGuid) this.#storeJserrorForHarvest([...jsErrorEvent, targetEntityGuid], false, params._softNavAttributes)
+    if (target) this.#storeJserrorForHarvest([...jsErrorEvent, target], false, params._softNavAttributes)
   }
 
   #storeJserrorForHarvest (errorInfoArr, softNavOccurredFinished, softNavCustomAttrs = {}) {
-    let [type, bucketHash, params, newMetrics, localAttrs, targetEntityGuid] = errorInfoArr
-    const allCustomAttrs = {}
+    let [type, bucketHash, params, newMetrics, localAttrs, target] = errorInfoArr
+    const allCustomAttrs = {
+      /** MFE specific attributes if in "multiple" mode (ie consumer version 2) */
+      ...getVersion2Attributes(target, this)
+    }
 
     if (softNavOccurredFinished) {
       Object.entries(softNavCustomAttrs).forEach(([k, v]) => setCustom(k, v)) // when an ixn finishes, it'll include stuff in jsAttributes + attrs specific to the ixn
@@ -243,7 +243,7 @@ export class Aggregate extends AggregateBase {
     const jsAttributesHash = stringHashCode(stringify(allCustomAttrs))
     const aggregateHash = bucketHash + ':' + jsAttributesHash
 
-    this.events.add([type, aggregateHash, params, newMetrics, allCustomAttrs], targetEntityGuid)
+    this.events.add([type, aggregateHash, params, newMetrics, allCustomAttrs])
 
     function setCustom (key, val) {
       allCustomAttrs[key] = (val && typeof val === 'object' ? stringify(val) : val)
@@ -253,11 +253,11 @@ export class Aggregate extends AggregateBase {
   /**
   * If the event lacks an entityGuid (the default behavior), the main agent should capture the data. If the data is assigned to a sub-entity target
   * the main agent should not capture events unless it is configured to do so.
-  * @param {string} entityGuid - the context object for the event
+  * @param {string} target - the context object for the event
   * @returns {boolean} - whether the main agent should capture the event to its internal target
   */
-  shouldAllowMainAgentToCapture (entityGuid) {
-    return (!entityGuid || this.agentRef.init.api.duplicate_registered_data)
+  shouldAllowMainAgentToCapture (target) {
+    return (!target || this.agentRef.init.api.duplicate_registered_data)
   }
 
   // TO-DO: Remove this function when old spa is taken out. #storeJserrorForHarvest handles the work with the softnav feature.