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

package/src/loaders/api/register.js

@@ -4,7 +4,7 @@
  */
 import { handle } from '../../common/event-emitter/handle'
 import { warn } from '../../common/util/console'
-import { isContainerAgentTarget, isValidTarget } from '../../common/util/target'
+import { isValidMFETarget } from '../../common/util/mfe'
 import { FEATURE_NAMES } from '../features/features'
 import { now } from '../../common/timing/now'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants'
@@ -13,6 +13,7 @@ import { REGISTER } from './constants'
 import { log } from './log'
 import { addPageAction } from './addPageAction'
 import { noticeError } from './noticeError'
+import { single } from '../../common/util/invoke'
 
 /**
  * @typedef {import('./register-api-types').RegisterAPI} RegisterAPI
@@ -35,106 +36,80 @@ export 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
  */
 export function buildRegisterApi (agentRef, target) {
   const attrs = {}
   warn(54, 'newrelic.register')
 
-  /** @type {Function|undefined} a function that is set and reports when APIs are triggered -- warns the customer of the invalid state  */
-  let invalidApiResponse
+  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} 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 = () => warn(55)
-  if (!target || !isValidTarget(target)) invalidApiResponse = () => 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(single(() => warn(55)))
+  if (!isValidMFETarget(target)) block(single(() => warn(48, target)))
 
   /** @type {RegisterAPI} */
   const api = {
-    addPageAction: (name, attributes = {}) => {
-      report(addPageAction, [name, { ...attrs, ...attributes }, agentRef], target)
-    },
-    log: (message, options = {}) => {
-      report(log, [message, { ...options, customAttributes: { ...attrs, ...(options.customAttributes || {}) } }, agentRef], target)
-    },
-    noticeError: (error, attributes = {}) => {
-      report(noticeError, [error, { ...attrs, ...attributes }, agentRef], target)
-    },
-    setApplicationVersion: (value) => {
-      attrs['application.version'] = value
-    },
-    setCustomAttribute: (key, value) => {
-      attrs[key] = value
-    },
-    setUserId: (value) => {
-      attrs['enduser.id'] = value
-    },
+    addPageAction: (name, attributes = {}) => report(addPageAction, [name, { ...attrs, ...attributes }, agentRef], target),
+    log: (message, options = {}) => report(log, [message, { ...options, customAttributes: { ...attrs, ...(options.customAttributes || {}) } }, agentRef], target),
+    noticeError: (error, attributes = {}) => report(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)
-
-          // 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])
-
-          // wait for entity events to emit to see when main agent and/or API registration is ready
-          agentRef.ee.on('entity-added', entityEventHandler)
+  /**
+   * 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
+  }
 
-          function entityEventHandler (entity) {
-            if (isContainerAgentTarget(entity, agentRef)) mainAgentReady ||= true
-            else {
-              if (target.licenseKey === entity.licenseKey && target.applicationID === entity.applicationID) {
-                registrationReady = true
-                target.entityGuid = entity.entityGuid
-              }
-            }
+  /** only allow registered APIs to be tracked in the agent runtime */
+  if (!isBlocked()) registeredEntities.push(api)
 
-            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
   }
 
   /**
@@ -142,23 +117,21 @@ export function buildRegisterApi (agentRef, target) {
      * 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 = now()
     handle(SUPPORTABILITY_METRIC_CHANNEL, [`API/register/${methodToCall.name}/called`], undefined, 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) {
       warn(50, err)
     }

package/dist/cjs/common/util/target.js

@@ -1,34 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isContainerAgentTarget = isContainerAgentTarget;
-exports.isValidTarget = isValidTarget;
-/**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @param {Object} [target] - the target to be validated
- * @param {boolean} [allowUndefined=true]
- * @returns {boolean}
- */
-function isValidTarget(target) {
-  /** target can be undefined to support legacy/default behaviors - main agent does not supply a target */
-  if (!target) return true;
-  /** if not undefined, we require specific values */
-  return !!(target.licenseKey && target.applicationID);
-}
-
-/**
- * Checks if the target matches the container agent target
- * @param {*} target the target to be validated
- * @param {*} agentRef the agent reference to be validated
- * @returns {boolean}
- */
-function isContainerAgentTarget(target, agentRef) {
-  if (!target) return true;
-  return target.licenseKey === agentRef.info.licenseKey && target.applicationID === agentRef.info.applicationID;
-}

package/dist/cjs/features/utils/entity-manager.js

@@ -1,46 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.EntityManager = void 0;
-var _agentConstants = require("../../common/constants/agent-constants");
-/**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-class EntityManager {
-  #entities = new Map();
-  #entityGuidLookup = {};
-  constructor(agentRef) {
-    this.agentRef = agentRef;
-    this.#entities.set(_agentConstants.DEFAULT_KEY, {
-      licenseKey: agentRef.info.licenseKey,
-      applicationID: agentRef.info.applicationID
-    });
-  }
-  get(entityGuid = _agentConstants.DEFAULT_KEY) {
-    return this.#entities.get(entityGuid);
-  }
-  getEntityGuidFor(licenseKey, applicationID) {
-    if (!this.#entityGuidLookup[licenseKey] || !this.#entityGuidLookup[applicationID]) return;
-    return this.#entityGuidLookup[licenseKey].filter(x => this.#entityGuidLookup[applicationID].includes(x))[0];
-  }
-  set(entityGuid, entity) {
-    if (this.#entities.has(entityGuid)) return;
-    this.#entities.set(entityGuid, entity);
-    this.#entityGuidLookup[entity.licenseKey] ??= [];
-    this.#entityGuidLookup[entity.licenseKey].push(entityGuid);
-    this.#entityGuidLookup[entity.applicationID] ??= [];
-    this.#entityGuidLookup[entity.applicationID].push(entityGuid);
-    this.agentRef.ee.emit('entity-added', [entity]);
-  }
-  clear() {
-    this.#entities.clear();
-  }
-  setDefaultEntity(entity) {
-    this.#entities.set(_agentConstants.DEFAULT_KEY, entity);
-  }
-}
-exports.EntityManager = EntityManager;

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

@@ -1,174 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.EventStoreManager = void 0;
-var _agentConstants = require("../../common/constants/agent-constants");
-var _target = require("../../common/util/target");
-/**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * 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} agentRef - reference to base agent class
-   * @param {EventBuffer|EventAggregator} storageClass - the type of storage to use in this manager; 'EventBuffer' (1), 'EventAggregator' (2)
-   * @param {string} [defaultEntityGuid] - the entity guid to use as the default storage instance; if not provided, a new one is created
-   * @param {Object} featureAgg - the feature aggregate instance that initialized this manager
-   */
-  constructor(agentRef, storageClass, defaultEntityGuid, featureAgg) {
-    this.agentRef = agentRef;
-    this.entityManager = agentRef.runtime.entityManager;
-    this.StorageClass = storageClass;
-    this.appStorageMap = new Map([[_agentConstants.DEFAULT_KEY, new this.StorageClass(_agentConstants.MAX_PAYLOAD_SIZE, featureAgg)]]);
-    this.featureAgg = featureAgg;
-    this.setEventStore(defaultEntityGuid);
-  }
-
-  /**
-   * Always returns a storage instance.  Creates one if one does not exist.  If a lookup is not provided, uses the DEFAULT namespace
-   * @param {string=} targetEntityGuid the lookup
-   * @returns {*} ALWAYS returns a storage instance
-   */
-  #getEventStore(targetEntityGuid = _agentConstants.DEFAULT_KEY) {
-    if (!this.appStorageMap.has(targetEntityGuid)) this.setEventStore(targetEntityGuid);
-    return this.appStorageMap.get(targetEntityGuid);
-  }
-  setEventStore(targetEntityGuid) {
-    /** we should already have an event store for the default */
-    if (!targetEntityGuid) return;
-    /** if the target is the container agent, SHARE the default storage -- otherwise create a new event store */
-    const eventStorage = (0, _target.isContainerAgentTarget)(this.entityManager.get(targetEntityGuid), this.agentRef) ? this.appStorageMap.get(_agentConstants.DEFAULT_KEY) : new this.StorageClass(_agentConstants.MAX_PAYLOAD_SIZE, this.featureAgg);
-    this.appStorageMap.set(targetEntityGuid, eventStorage);
-  }
-
-  /** IMPORTANT
-   * This class must contain an union of all methods from all supported storage classes and conceptualize away the target app argument.
-   */
-
-  get length() {
-    return this.#getEventStore().length;
-  }
-
-  /**
-   * Calls the merge method on the underlying storage class.
-   * @param {*} matcher
-   * @param {*} data
-   * @param {*} targetEntityGuid
-   * @returns {boolean} True if the merge was successful
-   */
-  merge(matcher, data, targetEntityGuid) {
-    return this.#getEventStore(targetEntityGuid).merge(matcher, data);
-  }
-
-  /**
-   * Calls the isEmpty method on the underlying storage class. If target is provided, runs just for the target, otherwise runs for all apps.
-   * @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, targetEntityGuid) {
-    if (targetEntityGuid) return this.#getEventStore(targetEntityGuid).isEmpty(optsIfPresent);
-    for (const eventStore of this.appStorageMap.values()) {
-      if (!eventStore.isEmpty(optsIfPresent)) return false;
-    }
-    return true;
-  }
-
-  /**
-   * Calls the add method on the underlying storage class.
-   * @param {string} event - the event element to store
-   * @param {object} targetEntityGuid - the entity guid lookup to store event under; if not provided, this method adds to the default
-   * @returns {boolean} True if the event was successfully added
-   */
-  add(event, targetEntityGuid) {
-    return this.#getEventStore(targetEntityGuid).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.#getEventStore().addMetric(type, name, params, value);
-  }
-
-  /**
-   * Calls the get method on the underlying storage class. If target is provided, runs just for the target, otherwise runs for all apps.
-   * @param {object=} opts - 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(opts, targetEntityGuid) {
-    if (targetEntityGuid) return [{
-      targetApp: this.entityManager.get(targetEntityGuid),
-      data: this.#getEventStore(targetEntityGuid).get(opts)
-    }];
-    const allPayloads = [];
-    this.appStorageMap.forEach((eventStore, targetEntityGuid) => {
-      // We shouldnt harvest unless we have a valid entity guid.  It was ONLY stored under the default key temporarily
-      // until a real key was returned in the RUM call. The real key SHARES the event store with the default key, and
-      // should be the key that is honored to get the event store to ensure a valid connection was made.
-      if (targetEntityGuid === _agentConstants.DEFAULT_KEY) return;
-      const targetApp = this.entityManager.get(targetEntityGuid);
-      if (targetApp) allPayloads.push({
-        targetApp,
-        data: eventStore.get(opts)
-      });
-    });
-    return allPayloads;
-  }
-
-  /**
-   * Calls the byteSize method on the underlying storage class
-   * @param {*} targetEntityGuid
-   * @returns
-   */
-  byteSize(targetEntityGuid) {
-    return this.#getEventStore(targetEntityGuid).byteSize();
-  }
-
-  /**
-   * Calls the wouldExceedMaxSize method on the underlying storage class
-   * @param {*} incomingSize
-   * @param {*} targetEntityGuid
-   * @returns
-   */
-  wouldExceedMaxSize(incomingSize, targetEntityGuid) {
-    return this.#getEventStore(targetEntityGuid).wouldExceedMaxSize(incomingSize);
-  }
-
-  /**
-   * Calls the save method on the underlying storage class. If target is provided, runs just for the target, otherwise runs for all apps.
-   * @param {*} optsIfPresent
-   * @param {*} targetEntityGuid
-   * @returns
-   */
-  save(optsIfPresent, targetEntityGuid) {
-    if (targetEntityGuid) return this.#getEventStore(targetEntityGuid).save(optsIfPresent);
-    this.appStorageMap.forEach(eventStore => eventStore.save(optsIfPresent));
-  }
-
-  /**
-   * Calls the clear method on the underlying storage class. If target is provided, runs just for the target, otherwise runs for all apps.
-   * @param {*} optsIfPresent
-   * @param {*} targetEntityGuid
-   * @returns
-   */
-  clear(optsIfPresent, targetEntityGuid) {
-    if (targetEntityGuid) return this.#getEventStore(targetEntityGuid).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, targetEntityGuid) {
-    return this.#getEventStore(targetEntityGuid).reloadSave(optsIfPresent);
-  }
-  clearSave(optsIfPresent, targetEntityGuid) {
-    return this.#getEventStore(targetEntityGuid).clearSave(optsIfPresent);
-  }
-}
-exports.EventStoreManager = EventStoreManager;

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

@@ -1,165 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.buildRegisterApi = buildRegisterApi;
-var _handle = require("../../common/event-emitter/handle");
-var _console = require("../../common/util/console");
-var _target = require("../../common/util/target");
-var _features = require("../features/features");
-var _now = require("../../common/timing/now");
-var _constants = require("../../features/metrics/constants");
-/**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @typedef {import('./register-api-types').RegisterAPI} RegisterAPI
- */
-
-/**
- * Builds the api object that will be returned from the register api method.
- * Also conducts certain side-effects, such as harvesting a PageView event when triggered and gathering metadata for the registered entity.
- * @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
- * @returns {RegisterAPI} the api object to be returned from the register api method
- */
-function buildRegisterApi(agentRef, handlers, target) {
-  const attrs = {};
-  (0, _console.warn)(54, 'newrelic.register');
-
-  /** @type {Function|undefined} a function that is set and reports when APIs are triggered -- warns the customer of the invalid state  */
-  let invalidApiResponse;
-
-  /**
-       * 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);
-
-  /** @type {RegisterAPI} */
-  const api = {
-    addPageAction: (name, attributes = {}) => {
-      report(handlers.addPageAction, [name, {
-        ...attrs,
-        ...attributes
-      }], target);
-    },
-    log: (message, options = {}) => {
-      report(handlers.log, [message, {
-        ...options,
-        customAttributes: {
-          ...attrs,
-          ...(options.customAttributes || {})
-        }
-      }], target);
-    },
-    noticeError: (error, attributes = {}) => {
-      report(handlers.noticeError, [error, {
-        ...attrs,
-        ...attributes
-      }], target);
-    },
-    setApplicationVersion: value => {
-      attrs['application.version'] = value;
-    },
-    setCustomAttribute: (key, value) => {
-      attrs[key] = value;
-    },
-    setUserId: value => {
-      attrs['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'));
-      }
-    }
-  };
-  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);
-
-          // 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]);
-
-          // 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);
-      }
-    });
-  }
-
-  /**
-     * 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.
-     * @returns
-     */
-  const report = async (methodToCall, args, target) => {
-    if (invalidApiResponse) return invalidApiResponse();
-    /** 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)) {
-        // also report to container by providing undefined target
-        methodToCall(...args, undefined, timestamp);
-      }
-      methodToCall(...args, target.entityGuid, timestamp); // always report to target
-    } catch (err) {
-      (0, _console.warn)(50, err);
-    }
-  };
-  return api;
-}

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

@@ -1,27 +0,0 @@
-/**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @param {Object} [target] - the target to be validated
- * @param {boolean} [allowUndefined=true]
- * @returns {boolean}
- */
-export function isValidTarget(target) {
-  /** target can be undefined to support legacy/default behaviors - main agent does not supply a target */
-  if (!target) return true;
-  /** if not undefined, we require specific values */
-  return !!(target.licenseKey && target.applicationID);
-}
-
-/**
- * Checks if the target matches the container agent target
- * @param {*} target the target to be validated
- * @param {*} agentRef the agent reference to be validated
- * @returns {boolean}
- */
-export function isContainerAgentTarget(target, agentRef) {
-  if (!target) return true;
-  return target.licenseKey === agentRef.info.licenseKey && target.applicationID === agentRef.info.applicationID;
-}