feat: agentIdentifier removal (#1712)

Author: metal-messiah

src/common/config/configurable.js

@@ -1,5 +1,5 @@
 /**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 import { warn } from '../util/console'
@@ -20,6 +20,7 @@ export function getModeledObject (obj, model) {
         if (obj[key] === null) { output[key] = null; continue }
 
         if (Array.isArray(obj[key]) && Array.isArray(model[key])) output[key] = Array.from(new Set([...obj[key], ...model[key]]))
+        else if (obj[key] instanceof Map || obj[key] instanceof Set || obj[key] instanceof Date || obj[key] instanceof RegExp) output[key] = obj[key]
         else if (typeof obj[key] === 'object' && typeof model[key] === 'object') output[key] = getModeledObject(obj[key], model[key])
         else output[key] = obj[key]
       } catch (e) {

src/common/config/runtime.js

@@ -1,5 +1,5 @@
 /**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 import { getModeledObject } from './configurable'
@@ -24,17 +24,23 @@ const hiddenState = {
 }
 
 const RuntimeModel = {
+  /** @type {{[key: string]: number} | undefined} */
+  activatedFeatures: undefined,
   /** Agent-specific metadata found in the RUM call response. ex. entityGuid */
   appMetadata: {},
+  /** @type {boolean} */
+  configured: false,
   get consented () {
     return this.session?.state?.consent || hiddenState.consented
   },
   set consented (value) {
     hiddenState.consented = value
   },
   customTransaction: undefined,
-  denyList: undefined,
+  denyList: [],
   disabled: false,
+  /** @type {Map<string, {staged: boolean, priority: number}>} */
+  drainRegistry: new Map(),
   harvester: undefined,
   isolatedBacklog: false,
   isRecording: false, // true when actively recording, false when paused or stopped

src/common/drain/__mocks__/drain.js

@@ -1,6 +1,7 @@
 /**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 export const drain = jest.fn()
 export const registerDrain = jest.fn()
+export const deregisterDrain = jest.fn()

src/common/drain/drain.js

@@ -4,81 +4,71 @@
  */
 
 import { dispatchGlobalEvent } from '../../common/dispatch/global-event'
-import { ee } from '../event-emitter/contextual-ee'
 import { registerHandler as defaultRegister } from '../event-emitter/register-handler'
 import { featurePriority } from '../../loaders/features/features'
 import { EventContext } from '../event-emitter/event-context'
 
-const registry = {}
-
 /**
  * Adds an entry to the centralized drain registry specifying that a particular agent has events of a particular named
  * event-group "bucket" that should be drained at the time the agent drains all its buffered events. Buffered events
  * accumulate because instrumentation begins as soon as possible, before the agent has finished lazy-loading the code
  * responsible for aggregating and reporting captured data.
- * @param {string} agentIdentifier - A 16 character string uniquely identifying the agent.
+ * @param {Object} agentRef - The agent reference object.
  * @param {string} group - The named "bucket" for the events this feature will be bucketing for later collection.
  */
-export function registerDrain (agentIdentifier, group) {
+export function registerDrain (agentRef, group) {
+  if (!agentRef) return
   // Here `item` captures the registered properties of a feature-group: whether it is ready for its buffered events
   // to be drained (`staged`) and the `priority` order in which it should be drained relative to other feature groups.
   const item = { staged: false, priority: featurePriority[group] || 0 }
-  curateRegistry(agentIdentifier)
-  if (!registry[agentIdentifier].get(group)) registry[agentIdentifier].set(group, item)
+  if (!agentRef.runtime.drainRegistry.get(group)) agentRef.runtime.drainRegistry.set(group, item)
 }
 
 /**
  * Removes an item from the registry and immediately re-checks if the registry is ready to "drain all"
- * @param {*} agentIdentifier - A 16 character string uniquely identifying the agent.
+ * @param {Object} agentRef - The agent reference object.
  * @param {*} group - The named "bucket" to be removed from the registry
  */
-export function deregisterDrain (agentIdentifier, group) {
-  if (!agentIdentifier || !registry[agentIdentifier]) return
-  if (registry[agentIdentifier].get(group)) registry[agentIdentifier].delete(group)
-  drainGroup(agentIdentifier, group, false)
-  if (registry[agentIdentifier].size) checkCanDrainAll(agentIdentifier)
-}
-
-/**
- * Registers the specified agent with the centralized event buffer registry if it is not already registered.
- * Agents without an identifier (as in the case of some tests) will be excluded from the registry.
- * @param {string} agentIdentifier - A 16 character string uniquely identifying an agent.
- */
-function curateRegistry (agentIdentifier) {
-  if (!agentIdentifier) throw new Error('agentIdentifier required')
-  if (!registry[agentIdentifier]) registry[agentIdentifier] = new Map()
+export function deregisterDrain (agentRef, group) {
+  if (!agentRef) return
+  const drainRegistry = agentRef.runtime.drainRegistry
+  if (!drainRegistry) return
+  if (drainRegistry.get(group)) drainRegistry.delete(group)
+  drainGroup(agentRef, group, false)
+  if (drainRegistry.size) checkCanDrainAll(agentRef)
 }
 
 /**
  * Drain buffered events out of the event emitter. Each feature should have its events bucketed by "group" and drain
  * its own named group explicitly, when ready.
- * @param {string} agentIdentifier - A unique 16 character ID corresponding to an instantiated agent.
+ * @param {Object} agentRef - The agent reference object.
  * @param {string} featureName - A named group into which the feature's buffered events are bucketed.
  * @param {boolean} force - Whether to force the drain to occur immediately, bypassing the registry and staging logic.
  */
-export function drain (agentIdentifier = '', featureName = 'feature', force = false) {
-  curateRegistry(agentIdentifier)
+export function drain (agentRef, featureName = 'feature', force = false) {
+  if (!agentRef) return
   // If the feature for the specified agent is not in the registry, that means the instrument file was bypassed.
   // This could happen in tests, or loaders that directly import the aggregator. In these cases it is safe to
   // drain the feature group immediately rather than waiting to drain all at once.
-  if (!agentIdentifier || !registry[agentIdentifier].get(featureName) || force) return drainGroup(agentIdentifier, featureName)
+  if (!agentRef.runtime.drainRegistry.get(featureName) || force) return drainGroup(agentRef, featureName)
 
   // When `drain` is called, this feature is ready to drain (staged).
-  registry[agentIdentifier].get(featureName).staged = true
+  agentRef.runtime.drainRegistry.get(featureName).staged = true
 
-  checkCanDrainAll(agentIdentifier)
+  checkCanDrainAll(agentRef)
 }
 
 /** Checks all items in the registry to see if they have been "staged".  If ALL items are staged, it will drain all registry items (drainGroup).  It not, nothing will happen */
-function checkCanDrainAll (agentIdentifier) {
+function checkCanDrainAll (agentRef) {
+  if (!agentRef) return
   // Only when the event-groups for all features are ready to drain (staged) do we execute the drain. This has the effect
   // that the last feature to call drain triggers drain for all features.
-  const items = Array.from(registry[agentIdentifier])
+  const items = Array.from(agentRef.runtime.drainRegistry)
   if (items.every(([key, values]) => values.staged)) {
     items.sort((a, b) => a[1].priority - b[1].priority)
     items.forEach(([group]) => {
-      registry[agentIdentifier].delete(group)
-      drainGroup(agentIdentifier, group)
+      agentRef.runtime.drainRegistry.delete(group)
+      drainGroup(agentRef, group)
     })
   }
 }
@@ -88,13 +78,13 @@ function checkCanDrainAll (agentIdentifier) {
    * the subscribed handlers for the group.
    * @param {*} group - The name of a particular feature's event "bucket".
    */
-function drainGroup (agentIdentifier, group, activateGroup = true) {
-  const baseEE = agentIdentifier ? ee.get(agentIdentifier) : ee
+function drainGroup (agentRef, group, activateGroup = true) {
+  if (!agentRef) return
+  const baseEE = agentRef.ee
   const handlers = defaultRegister.handlers // other storage in registerHandler
-  if (baseEE.aborted || !baseEE.backlog || !handlers) return
+  if (!baseEE || baseEE.aborted || !baseEE.backlog || !handlers) return
 
   dispatchGlobalEvent({
-    agentIdentifier,
     type: 'lifecycle',
     name: 'drain',
     feature: group

src/common/harvest/harvester.js

@@ -15,7 +15,6 @@ import { obj, param } from '../url/encode'
 import { warn } from '../util/console'
 import { stringify } from '../util/stringify'
 import { getSubmitMethod, xhr as xhrMethod, xhrFetch as fetchMethod } from '../util/submit-data'
-import { activatedFeatures } from '../util/feature-flags'
 import { dispatchGlobalEvent } from '../dispatch/global-event'
 
 const RETRY = 'Harvester/Retry/'
@@ -198,8 +197,7 @@ export function send (agentRef, { endpoint, payload, localOpts = {}, submitMetho
   }
 
   dispatchGlobalEvent({
-    agentIdentifier: agentRef.agentIdentifier,
-    drained: !!activatedFeatures?.[agentRef.agentIdentifier],
+    drained: !!agentRef.runtime?.activatedFeatures,
     type: 'data',
     name: 'harvest',
     feature: featureName,

src/common/session/session-entity.js

@@ -5,7 +5,6 @@
 import { generateRandomHexString } from '../ids/unique-id'
 import { warn } from '../util/console'
 import { stringify } from '../util/stringify'
-import { ee } from '../event-emitter/contextual-ee'
 import { Timer } from '../timer/timer'
 import { isBrowserScope } from '../constants/runtime'
 import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS, MODE, PREFIX, SESSION_EVENTS, SESSION_EVENT_TYPES } from './constants'
@@ -39,25 +38,25 @@ const model = {
 
 export class SessionEntity {
   /**
-   * Create a self-managing Session Entity. This entity is scoped to the agent identifier which triggered it, allowing for multiple simultaneous session objects to exist.
+   * Create a self-managing Session Entity. This entity is scoped to the agent which triggered it, allowing for multiple simultaneous session objects to exist.
    * There is one "namespace" an agent can store data in LS -- NRBA_{key}. If there are two agents on one page, and they both use the same key, they could overwrite each other since they would both use the same namespace in LS by default.
    * The value can be overridden in the constructor, but will default to a unique 16 character hex string
    * expiresMs and inactiveMs are used to "expire" the session, but can be overridden in the constructor. Pass 0 to disable expiration timers.
    */
   constructor (opts) {
-    const { agentIdentifier, key, storage } = opts
+    const { agentRef, key, storage } = opts
 
-    if (!agentIdentifier || !key || !storage) {
-      throw new Error(`Missing required field(s):${!agentIdentifier ? ' agentID' : ''}${!key ? ' key' : ''}${!storage ? ' storage' : ''}`)
+    if (!agentRef || !key || !storage) {
+      throw new Error(`Missing required field(s):${!agentRef ? ' agentRef' : ''}${!key ? ' key' : ''}${!storage ? ' storage' : ''}`)
     }
-    this.agentIdentifier = agentIdentifier
+    this.agentRef = agentRef
     this.storage = storage
     this.state = {}
 
     // key is intended to act as the k=v pair
     this.key = key
 
-    this.ee = ee.get(agentIdentifier)
+    this.ee = agentRef.ee
     wrapEvents(this.ee)
     this.setup(opts)
 
@@ -243,7 +242,7 @@ export class SessionEntity {
       delete this.isNew
 
       this.setup({
-        agentIdentifier: this.agentIdentifier,
+        agentRef: this.agentRef,
         key: this.key,
         storage: this.storage,
         expiresMs: this.expiresMs,

src/common/util/console.js

@@ -1,5 +1,5 @@
 /**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -17,7 +17,6 @@ export function warn (code, secondary) {
   if (typeof console.debug !== 'function') return
   console.debug(`New Relic Warning: https://github.com/newrelic/newrelic-browser-agent/blob/main/docs/warning-codes.md#${code}`, secondary)
   dispatchGlobalEvent({
-    agentIdentifier: null,
     drained: null,
     type: 'data',
     name: 'warn',

src/common/util/feature-flags.js

@@ -1,35 +1,23 @@
 /**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 import { dispatchGlobalEvent } from '../dispatch/global-event'
 
-const sentIds = new Set()
-
-/** A map of feature flags and their values as provided by the rum call -- scoped by agent ID */
-export const activatedFeatures = {}
-
 /**
- * Sets the activatedFeatures object, dispatches the global loaded event,
+ * Sets the activatedFeatures on the agentRef, dispatches the global loaded event,
  * and emits the rumresp flag to features
  * @param {{[key:string]:number}} flags key-val pair of flag names and numeric
- * @param {string} agentIdentifier agent instance identifier
+ * @param {Object} agentRef agent reference
  * @returns {void}
  */
 export function activateFeatures (flags, agentRef) {
-  const agentIdentifier = agentRef.agentIdentifier
-  activatedFeatures[agentIdentifier] ??= {}
-  if (!flags || typeof flags !== 'object') return
-  if (sentIds.has(agentIdentifier)) return
-
+  if (!flags || typeof flags !== 'object' || !!agentRef.runtime.activatedFeatures) return
   agentRef.ee.emit('rumresp', [flags])
-  activatedFeatures[agentIdentifier] = flags
-
-  sentIds.add(agentIdentifier)
+  agentRef.runtime.activatedFeatures = flags
 
   // let any window level subscribers know that the agent is running, per install docs
   dispatchGlobalEvent({
-    agentIdentifier,
     loaded: true,
     drained: true,
     type: 'lifecycle',

src/features/jserrors/aggregate/index.js

@@ -187,10 +187,6 @@ export class Aggregate extends AggregateBase {
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return
 
-    if (err.__newrelic?.[this.agentIdentifier]) {
-      params._interactionId = err.__newrelic[this.agentIdentifier].interactionId
-      params._interactionNodeId = err.__newrelic[this.agentIdentifier].interactionNodeId
-    }
     if (err.__newrelic?.socketId) {
       customAttributes.socketId = err.__newrelic.socketId
     }

src/features/page_view_event/aggregate/index.js

@@ -79,7 +79,7 @@ export class Aggregate extends AggregateBase {
       us: info.user,
       ac: info.account,
       pr: info.product,
-      af: getActivatedFeaturesFlags(this.agentIdentifier).join(','),
+      af: getActivatedFeaturesFlags(this.agentRef).join(','),
       ...measures,
       xx: info.extra,
       ua: info.userAttributes,