@newrelic/browser-agent 1.285.0 → 1.287.0

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

@@ -12,16 +12,42 @@ import { Obfuscator } from '../../common/util/obfuscate';
 import { FEATURE_NAMES } from '../../loaders/features/features';
 import { EventStoreManager } from './event-store-manager';
 import { Harvester } from '../../common/harvest/harvester';
+import { warn } from '../../common/util/console';
+import { EntityManager } from './entity-manager';
+import { EventBuffer } from './event-buffer';
 import { handle } from '../../common/event-emitter/handle';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../metrics/constants';
+import { EventAggregator } from '../../common/aggregate/event-aggregator';
 export class AggregateBase extends FeatureBase {
+  /**
+   * Create an AggregateBase instance.
+   * @param {Object} agentRef The reference to the agent instance.
+   * @param {string} featureName The name of the feature creating the instance.
+   */
   constructor(agentRef, featureName) {
     super(agentRef.agentIdentifier, featureName);
     this.agentRef = agentRef;
     this.checkConfiguration(agentRef);
     this.doOnceForAllAggregate(agentRef);
+    this.harvestOpts = {}; // features aggregate classes can define custom opts for when their harvest is called
+
+    const agentEntityGuid = this.agentRef?.runtime?.appMetadata?.agents?.[0]?.entityGuid;
+    if (agentEntityGuid) {
+      this.#setupEventStore(agentEntityGuid); // if there's no entity guid, wont dont anything, and will wait for rum flags
+    } else {
+      this.ee.on('entity-added', entity => {
+        this.#setupEventStore(entity.entityGuid);
+      });
+    }
+  }
 
-    // This switch needs to be after doOnceForAllAggregate which may new sharedAggregator and reset mainAppKey.
+  /**
+   * sets up the event store for the feature.  It must wait for the entity guid to be available before setting up the event store.  This is called once the rum response is received with an entityGuid.
+   * @param {string} entityGuid
+   * @returns {void}
+   */
+  #setupEventStore(entityGuid) {
+    if (this.events || !entityGuid) return;
     switch (this.featureName) {
       // SessionTrace + Replay have their own storage mechanisms.
       case FEATURE_NAMES.sessionTrace:
@@ -30,16 +56,15 @@ export class AggregateBase extends FeatureBase {
       // Jserror and Metric features uses a singleton EventAggregator instead of a regular EventBuffer.
       case FEATURE_NAMES.jserrors:
       case FEATURE_NAMES.metrics:
-        this.events = agentRef.sharedAggregator;
+        this.events = this.agentRef.sharedAggregator ??= new EventStoreManager(this.agentRef, EventAggregator, entityGuid, 'shared_aggregator');
         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.
       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(agentRef.mainAppKey, 1, agentRef.agentIdentifier, this.featureName);
+        this.events = new EventStoreManager(this.agentRef, EventBuffer, entityGuid, this.featureName);
         break;
     }
-    this.harvestOpts = {}; // features aggregate classes can define custom opts for when their harvest is called
   }
 
   /**
@@ -69,6 +94,10 @@ export class AggregateBase extends FeatureBase {
       this.deregisterDrain();
     });
   }
+
+  /**
+   * Stages the feature to be drained
+   */
   drain() {
     drain(this.agentIdentifier, this.featureName);
     this.drained = true;
@@ -80,28 +109,29 @@ export class AggregateBase extends 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.target - the target app passed onto the event store manager to determine which app's data to return; if none provided, all apps data will be returned
+   * @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
    * @returns {Array} Final payload tagged with their targeting browser app. The value of `payload` can be undefined if there are no pending events for an app. This should be a minimum length of 1.
    */
   makeHarvestPayload(shouldRetryOnFail = false, opts = {}) {
-    if (this.events.isEmpty(this.harvestOpts, opts.target)) return;
+    if (!this.events || this.events.isEmpty(this.harvestOpts, opts.targetEntityGuid)) 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.target);
-    const returnedDataArr = this.events.get(this.harvestOpts, opts.target);
-    if (!returnedDataArr.length) throw new Error('Unexpected problem encountered. There should be at least one app for harvest!');
-    this.events.clear(this.harvestOpts, opts.target);
+    if (shouldRetryOnFail) this.events.save(this.harvestOpts, opts.targetEntityGuid);
+    const returnedDataArr = this.events.get(this.harvestOpts, opts.targetEntityGuid);
+    if (!returnedDataArr.length) return 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) : data;
+      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);
+      if (this.queryStringsBuilder) payload.qs = this.queryStringsBuilder(data, targetApp?.entityGuid);
       return {
         targetApp,
         payload
@@ -112,11 +142,15 @@ export class AggregateBase extends FeatureBase {
   /**
    * 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 = {}) {
     const harvestFailed = result.sent && result.retry;
-    if (harvestFailed) this.events.reloadSave(this.harvestOpts, result.targetApp);
-    this.events.clearSave(this.harvestOpts, result.targetApp);
+    if (harvestFailed) this.events.reloadSave(this.harvestOpts, result.targetApp?.entityGuid);
+    this.events.clearSave(this.harvestOpts, result.targetApp?.entityGuid);
   }
 
   /**
@@ -138,16 +172,14 @@ export class AggregateBase extends FeatureBase {
       } catch (err) {
         // do nothing
       }
-      configure({
-        agentIdentifier: this.agentIdentifier
-      }, {
+      configure(existingAgent, {
         ...cdn,
         info: {
           ...cdn.info,
           jsAttributes
         },
         runtime: existingAgent.runtime
-      });
+      }, existingAgent.runtime.loaderType);
     }
   }
 
@@ -158,12 +190,7 @@ export class AggregateBase extends FeatureBase {
   doOnceForAllAggregate(agentRef) {
     if (!agentRef.runtime.obfuscator) agentRef.runtime.obfuscator = new Obfuscator(agentRef);
     this.obfuscator = agentRef.runtime.obfuscator;
-    if (!agentRef.mainAppKey) agentRef.mainAppKey = {
-      licenseKey: agentRef.info.licenseKey,
-      appId: agentRef.info.applicationID
-    };
-    // Create a single Aggregator for this agent if DNE yet; to be used by jserror endpoint features.
-    if (!agentRef.sharedAggregator) agentRef.sharedAggregator = new EventStoreManager(agentRef.mainAppKey, 2, agentRef.agentIdentifier, 'shared_aggregator');
+    if (!agentRef.runtime.entityManager) agentRef.runtime.entityManager = new EntityManager(this.agentRef);
     if (!agentRef.runtime.harvester) agentRef.runtime.harvester = new Harvester(agentRef);
   }
 

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

@@ -0,0 +1,40 @@
+/**
+ * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export class EntityManager {
+  #entities = new Map();
+  #entityGuidLookup = {};
+  #defaultEntity = null;
+  constructor(agentRef) {
+    this.agentRef = agentRef;
+    this.#defaultEntity = {
+      licenseKey: agentRef.info.licenseKey,
+      applicationID: agentRef.info.applicationID
+    };
+  }
+  get(entityGuid) {
+    if (!entityGuid) return this.#defaultEntity;
+    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.#defaultEntity = entity;
+  }
+}

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

@@ -2,10 +2,8 @@
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { EventAggregator } from '../../common/aggregate/event-aggregator';
 import { dispatchGlobalEvent } from '../../common/dispatch/global-event';
 import { activatedFeatures } from '../../common/util/feature-flags';
-import { EventBuffer } from './event-buffer';
 
 /**
  * This layer allows multiple browser entity apps, or "target", to each have their own segregated storage instance.
@@ -13,31 +11,39 @@ import { EventBuffer } from './event-buffer';
  */
 export class EventStoreManager {
   /**
-   * @param {object} defaultTarget - should contain licenseKey and appId of the main app from NREUM.info at startup
-   * @param {1|2} storageChoice - the type of storage to use in this manager; 'EventBuffer' (1), 'EventAggregator' (2)
-   * @param {string} agentIdentifier - agent identifier used in inspection events
-   * @param {string} featureName - feature name used in inspection events for non-shared aggregators
+   * @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)
    */
-  constructor(defaultTarget, storageChoice, agentIdentifier, featureName) {
-    this.mainApp = defaultTarget;
-    this.StorageClass = storageChoice === 1 ? EventBuffer : EventAggregator;
+  constructor(agentRef, storageClass, defaultEntityGuid, featureName) {
+    this.agentRef = agentRef;
+    this.entityManager = agentRef.runtime.entityManager;
+    this.StorageClass = storageClass;
     this.appStorageMap = new Map();
-    this.appStorageMap.set(defaultTarget, new this.StorageClass());
-    this.agentIdentifier = agentIdentifier;
+    this.defaultEntity = this.#getEventStore(defaultEntityGuid);
     this.featureName = featureName;
   }
 
+  /**
+   * 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) {
+    if (!targetEntityGuid) return this.defaultEntity;
+    if (!this.appStorageMap.has(targetEntityGuid)) this.appStorageMap.set(targetEntityGuid, new this.StorageClass());
+    return this.appStorageMap.get(targetEntityGuid);
+  }
+
   // This class must contain an union of all methods from all supported storage classes and conceptualize away the target app argument.
 
   /**
+   * 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, target) {
-    if (target) {
-      if (!this.appStorageMap.has(target)) return true;else return this.appStorageMap.get(target).isEmpty(optsIfPresent);
-    }
+  isEmpty(optsIfPresent, targetEntityGuid) {
+    if (targetEntityGuid) return this.#getEventStore(targetEntityGuid).isEmpty(optsIfPresent);
     for (const eventStore of this.appStorageMap.values()) {
       if (!eventStore.isEmpty(optsIfPresent)) return false;
     }
@@ -45,77 +51,96 @@ export class EventStoreManager {
   }
 
   /**
+   * Calls the add method on the underlying storage class.
    * @param {string} event - the event element to store
-   * @param {object} target - the app to store event under; if not provided, this method adds to the main app from NREUM.info
+   * @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, target) {
+  add(event, targetEntityGuid) {
     dispatchGlobalEvent({
-      agentIdentifier: this.agentIdentifier,
-      loaded: !!activatedFeatures?.[this.agentIdentifier],
+      agentIdentifier: this.agentRef.agentIdentifier,
+      drained: !!activatedFeatures?.[this.agentRef.agentIdentifier],
       type: 'data',
       name: 'buffer',
       feature: this.featureName,
       data: event
     });
-    if (target && !this.appStorageMap.has(target)) this.appStorageMap.set(target, new this.StorageClass());
-    return this.appStorageMap.get(target || this.mainApp).add(event);
+    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.appStorageMap.get(this.mainApp).addMetric(type, name, params, value);
+    return this.#getEventStore().addMetric(type, name, params, value);
   }
 
   /**
-   * @param {object} optsIfPresent - exists if called during harvest interval, @see AggregateBase.makeHarvestPayload
-   * @param {object} target - specific app to fetch; if not provided, this method fetches from all apps
+   * 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(optsIfPresent, target) {
-    if (target) return [{
-      targetApp: target,
-      data: this.appStorageMap.get(target)?.get(optsIfPresent)
+  get(opts, targetEntityGuid) {
+    if (targetEntityGuid) return [{
+      targetApp: this.entityManager.get(targetEntityGuid),
+      data: this.#getEventStore(targetEntityGuid).get(opts)
     }];
     const allPayloads = [];
-    this.appStorageMap.forEach((eventStore, recordedTarget) => {
-      allPayloads.push({
-        targetApp: recordedTarget,
-        data: eventStore.get(optsIfPresent)
+    this.appStorageMap.forEach((eventStore, targetEntityGuid) => {
+      const targetApp = this.entityManager.get(targetEntityGuid);
+      if (targetApp) allPayloads.push({
+        targetApp,
+        data: eventStore.get(opts)
       });
     });
     return allPayloads;
   }
-  byteSize(target) {
-    return this.appStorageMap.get(target || this.mainApp).byteSize();
+
+  /**
+   * Calls the byteSize method on the underlying storage class
+   * @param {*} targetEntityGuid
+   * @returns
+   */
+  byteSize(targetEntityGuid) {
+    return this.#getEventStore(targetEntityGuid).byteSize();
   }
-  wouldExceedMaxSize(incomingSize, target) {
-    return this.appStorageMap.get(target || this.mainApp).wouldExceedMaxSize(incomingSize);
+
+  /**
+   * Calls the wouldExceedMaxSize method on the underlying storage class
+   * @param {*} incomingSize
+   * @param {*} targetEntityGuid
+   * @returns
+   */
+  wouldExceedMaxSize(incomingSize, targetEntityGuid) {
+    return this.#getEventStore(targetEntityGuid).wouldExceedMaxSize(incomingSize);
   }
-  save(optsIfPresent, target) {
-    if (target) return this.appStorageMap.get(target)?.save(optsIfPresent);
+
+  /**
+   * 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));
   }
-  clear(optsIfPresent, target) {
-    if (target) return this.appStorageMap.get(target)?.clear(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, target) {
-    if (!target) {
-      // -- remove this block once the old harvest.js & harvest-schedule.js are deleted!
-      this.appStorageMap.forEach(eventStore => eventStore.reloadSave(optsIfPresent));
-      return;
-    }
-    return this.appStorageMap.get(target)?.reloadSave(optsIfPresent);
+  reloadSave(optsIfPresent, targetEntityGuid) {
+    return this.#getEventStore(targetEntityGuid).reloadSave(optsIfPresent);
   }
-  clearSave(optsIfPresent, target) {
-    if (!target) {
-      // -- remove this block once the old harvest.js & harvest-schedule.js are deleted!
-      this.appStorageMap.forEach(eventStore => eventStore.clearSave(optsIfPresent));
-      return;
-    }
-    return this.appStorageMap.get(target)?.clearSave(optsIfPresent);
+  clearSave(optsIfPresent, targetEntityGuid) {
+    return this.#getEventStore(targetEntityGuid).clearSave(optsIfPresent);
   }
 }

package/dist/esm/features/utils/nr1-debugger.js

@@ -6,7 +6,7 @@ import { gosCDN } from '../../common/window/nreum';
 const debugId = 1;
 const newrelic = gosCDN();
 export function debugNR1(agentIdentifier, location, event, otherprops = {}, debugName = 'SR') {
-  const api = agentIdentifier ? newrelic.initializedAgents[agentIdentifier].api.addPageAction : newrelic.addPageAction;
+  const api = agentIdentifier ? newrelic.initializedAgents[agentIdentifier].addPageAction : newrelic.addPageAction;
   let url;
   try {
     const locURL = new URL(window.location);

package/dist/esm/interfaces/registered-entity.js

@@ -0,0 +1,107 @@
+/**
+ * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { warn } from '../common/util/console';
+
+/**
+ * @typedef {import('../loaders/api/register-api-types').RegisterAPI} RegisterAPI
+ * @typedef {import('../loaders/api/register-api-types').RegisterAPIMetadata} RegisterAPIMetadata
+ * @typedef {import('../loaders/api/register-api-types').RegisterAPIConstructor} RegisterAPIConstructor
+ */
+
+/**
+ * @experimental
+ * IMPORTANT: This feature is being developed for use internally and is not in a public-facing production-ready state.
+ * It is not recommended for use in production environments and will not receive support for issues.
+ *
+ * An interface for registering an external caller to report through the base agent to a different target than the base agent.
+ */
+export class RegisteredEntity {
+  /** @type {RegisterAPIMetadata} */
+  metadata = {
+    target: {},
+    customAttributes: {}
+  };
+
+  /**
+   *
+   * @param {RegisterAPIConstructor} opts The options for setting up the registered entity.
+   */
+  constructor(opts) {
+    try {
+      if (!window?.newrelic) return warn(51);
+      Object.assign(this, window?.newrelic?.register(opts) || {});
+    } catch (err) {
+      warn(50, err);
+    }
+  }
+
+  /**
+   * Reports a browser PageAction event along with a name and optional attributes to the registered target.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/addpageaction/}
+   * @param {string} name Name or category of the action. Reported as the actionName attribute.
+   * @param {object} [attributes] JSON object with one or more key/value pairs. For example: {key:"value"}. The key is reported as its own PageAction attribute with the specified values.
+   */
+  addPageAction(name, attributes) {
+    /** this method will be overset once register is successful */
+    warn(35, 'addPageAction');
+  }
+
+  /**
+   * Adds a user-defined attribute name and value to subsequent events on the page for the registered target. Note -- the persist flag does not work with the register API.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setcustomattribute/}
+   * @param {string} name Name of the attribute. Appears as column in the PageView event. It will also appear as a column in the PageAction event if you are using it.
+   * @param {string|number|boolean|null} value Value of the attribute. Appears as the value in the named attribute column in the PageView event. It will appear as a column in the PageAction event if you are using it. Custom attribute values cannot be complex objects, only simple types such as Strings, Integers and Booleans. Passing a null value unsets any existing attribute of the same name.
+   * @param {boolean} [persist] Default false. If set to true, the name-value pair will also be set into the browser's storage API. Then on the following instrumented pages that load within the same session, the pair will be re-applied as a custom attribute.
+   */
+  setCustomAttribute(name, value, persist) {
+    /** this method will be overset once register is successful */
+    warn(35, 'setCustomAttribute');
+  }
+
+  /**
+   * Identifies a browser error without disrupting your app's operations for the registered target.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/noticeerror/}
+   * @param {Error|string} error Provide a meaningful error message that you can use when analyzing data on browser's JavaScript errors page.
+   * @param {object} [customAttributes] An object containing name/value pairs representing custom attributes.
+   */
+  noticeError(error, customAttributes) {
+    /** this method will be overset once register is successful */
+    warn(35, 'noticeError');
+  }
+
+  /**
+   * Adds a user-defined identifier string to subsequent events on the page for the registered taret.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setuserid/}
+   * @param {string|null} value A string identifier for the end-user, useful for tying all browser events to specific users. The value parameter does not have to be unique. If IDs should be unique, the caller is responsible for that validation. Passing a null value unsets any existing user ID.
+   */
+  setUserId(value) {
+    /** this method will be overset once register is successful */
+    warn(35, 'setUserId');
+  }
+
+  /**
+   * Adds a user-defined application version string to subsequent events on the page for the registered target.
+   * This decorates all payloads with an attribute of `application.version` which is queryable in NR1.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setapplicationversion/}
+   * @param {string|null} value A string identifier for the application version, useful for
+   * tying all browser events to a specific release tag. The value parameter does not
+   * have to be unique. Passing a null value unsets any existing value.
+   */
+  setApplicationVersion(value) {
+    /** this method will be overset once register is successful */
+    warn(35, 'setApplicationVersion');
+  }
+
+  /**
+   * Capture a single log for the registered target.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/log/}
+   * @param {string} message String to be captured as log message
+   * @param {{customAttributes?: object, level?: 'ERROR'|'TRACE'|'DEBUG'|'INFO'|'WARN'}} [options] customAttributes defaults to `{}` if not assigned, level defaults to `info` if not assigned.
+  */
+  log(message, options) {
+    /** this method will be overset once register is successful */
+    warn(35, 'setCustomAttribute');
+  }
+}

package/dist/esm/loaders/agent-base.js

@@ -20,7 +20,7 @@ export class AgentBase extends MicroAgentBase {
    * @param  {...any} args
    */
   #callMethod(methodName, ...args) {
-    if (typeof this.api?.[methodName] !== 'function') warn(35, methodName);else return this.api[methodName](...args);
+    if (this[methodName] === AgentBase.prototype[methodName] || this[methodName] === MicroAgentBase.prototype[methodName]) warn(35, methodName);else return this[methodName](...args);
   }
 
   /**

package/dist/esm/loaders/agent.js

@@ -67,6 +67,9 @@ export class Agent extends AgentBase {
       runtime: this.runtime
     };
   }
+  get api() {
+    return this;
+  }
   run() {
     // Attempt to initialize all the requested features (sequentially in prio order & synchronously), with any failure aborting the whole process.
     try {
@@ -94,7 +97,6 @@ export class Agent extends AgentBase {
         this.features[featName].abortHandler?.();
       }
       const newrelic = gosNREUM();
-      delete newrelic.initializedAgents[this.agentIdentifier]?.api; // prevent further calls to agent-specific APIs (see "configure.js")
       delete newrelic.initializedAgents[this.agentIdentifier]?.features; // GC mem used internally by features
       delete this.sharedAggregator;
       // Keep the initialized agent object with its configs for troubleshooting purposes.

package/dist/esm/loaders/api/api-methods.js

@@ -3,5 +3,5 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { SR_EVENT_EMITTER_TYPES } from '../../features/session_replay/constants';
-export const apiMethods = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease', 'recordCustomEvent', 'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute', 'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start', SR_EVENT_EMITTER_TYPES.RECORD, SR_EVENT_EMITTER_TYPES.PAUSE, 'log', 'wrapLogger'];
+export const apiMethods = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease', 'recordCustomEvent', 'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute', 'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start', SR_EVENT_EMITTER_TYPES.RECORD, SR_EVENT_EMITTER_TYPES.PAUSE, 'log', 'wrapLogger', 'register'];
 export const asyncApiMethods = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease'];