@newrelic/browser-agent 1.320.0 → 1.320.1-rc.1

package/src/common/unload/eol.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 { globalScope, isWorkerScope, isBrowserScope } from '../constants/runtime'
@@ -22,9 +22,9 @@ if (isWorkerScope) {
  * This is used, for example, to submit a final harvest and send all remaining data on best-effort.
  * @param {function} cb - func to run before or during the last reliable event or time of an env's life span
  */
-export function subscribeToEOL (cb, capturePhase) {
+export function subscribeToEOL (cb) {
   if (isBrowserScope) {
-    subscribeToVisibilityChange(cb, true, capturePhase) // when user switches tab or hides window, esp. mobile scenario
+    subscribeToVisibilityChange(cb, true) // when user switches tab or hides window, esp. mobile scenario
   } else if (isWorkerScope) {
     globalScope.cleanupTasks.push(cb) // close() should run these tasks before quitting thread
   }

package/src/common/util/console.js

@@ -68,7 +68,7 @@ import { dispatchGlobalEvent } from '../dispatch/global-event'
  * | 50 | Failed to connect. Cannot allow registered API. |
  * | 51 | Container agent is not available to register with. Can not connect. |
  * | 52 | Unexpected problem encountered. There should be at least one app for harvest! |
- * | 53 | Did not receive a valid entityGuid from connection response. |
+ * | 53 | Failed to parse connect response. |
  * | 54 | An experimental feature is being used. Support can not be offered for issues. |
  * | 55 | Register API has been disabled on the container agent. |
  * | 56 | Could not find a matching entity to store data. |
@@ -94,6 +94,7 @@ import { dispatchGlobalEvent } from '../dispatch/global-event'
  * | 76 | Agent rejected post message, could not match with existing entity. |
  * | 77 | Agent rejected post message, could not validate origin. |
  * | 78 | RegisteredIframeEntity could not determine parent origin and will not register, to avoid trusting messages from any origin. |
+ * | 79 | Unable to initialize Connector and/or Harvester. |
  *
  * @param {number} code The warning code to emit, which will be used to link to the warning code documentation
  * @param {*} [secondary] Secondary data to include, usually an extra message, error or object

package/src/common/util/feature-flags.js

@@ -19,7 +19,7 @@ export function activateFeatures (flags, agentRef) {
   // let any window level subscribers know that the agent is running, per install docs
   dispatchGlobalEvent({
     loaded: true,
-    drained: true,
+    drained: !agentRef.init.feature_flags.includes('rum_v2'), // v2 RUM always call activateFeatures before any group is drained (in waitForFlags)
     type: 'lifecycle',
     name: 'load',
     feature: undefined,

package/src/common/v2/mfe-vitals.js

@@ -124,6 +124,9 @@ const observePerformance = (observers, config, onEntry) => {
 export function trackMFEVitals (target, timings) {
   let fcpObservedAt
   let lcpObservedAt
+  // Once disconnect() runs, no further vitals data should be written - even from an observer callback that was
+  // already in flight when disconnect() was called.
+  let disconnected = false
 
   const getTimeRelativeToScriptStart = (capturedAt) => {
     if (capturedAt == null) return capturedAt
@@ -132,12 +135,21 @@ export function trackMFEVitals (target, timings) {
 
   const vitals = {
     fcp: {
-      get value () { return getTimeRelativeToScriptStart(fcpObservedAt) },
-      set value (v) { fcpObservedAt = v }
+      // A clock freeze/tab suspend between script registration and first paint can make this value huge once the
+      // tab resumes. Rather than report a multi-hour "FCP", drop it so bad data doesn't reach the backend.
+      get value () {
+        const relative = getTimeRelativeToScriptStart(fcpObservedAt)
+        return relative > CORRELATION_STALE_THRESHOLD_MS ? undefined : relative
+      },
+      set value (v) { if (!disconnected) fcpObservedAt = v }
     },
     lcp: {
-      get value () { return getTimeRelativeToScriptStart(lcpObservedAt) },
-      set value (v) { lcpObservedAt = v }
+      // LCP can never occur before FCP, so if FCP was dropped as invalid, LCP is derived from the same untrustworthy clock and must be dropped too.
+      get value () {
+        if (vitals.fcp.value === undefined) return undefined
+        return getTimeRelativeToScriptStart(lcpObservedAt)
+      },
+      set value (v) { if (!disconnected) lcpObservedAt = v }
     },
     cls: {
       value: undefined
@@ -159,15 +171,22 @@ export function trackMFEVitals (target, timings) {
   }, CORRELATION_STALE_THRESHOLD_MS)
 
   const populateVitalMinimums = () => {
-    fcpObservedAt ??= now()
+    if (disconnected) return
+    if (fcpObservedAt == null) {
+      const capturedAt = now()
+      // If the very first observed render already exceeds the window, the clock is untrustworthy for this
+      // MFE (e.g. tab was frozen/suspended between registration and paint) - shut everything down instead
+      // of seeding vitals with data derived from it.
+      if (getTimeRelativeToScriptStart(capturedAt) > CORRELATION_STALE_THRESHOLD_MS) {
+        vitals.disconnect()
+        return
+      }
+      fcpObservedAt = capturedAt
+    }
     lcpObservedAt ??= now()
     vitals.cls.value ??= 0
   }
 
-  // if the MFE has already rendered something on the page before we could set up listeners, just populate vital minimums immediately
-  const existingRoots = globalScope.document?.querySelectorAll(`[data-nr-mfe-id="${escapeSelectorValue(target.id)}"]`)
-  if (Array.from(existingRoots || []).some(x => isMatch(x.dataset, target))) populateVitalMinimums()
-
   // Track FCP - first contentful paint
   const fcpObs = observeMutations(target, (_, obs) => {
     // An observed "FCP" means _something_ rendered, so at minimum we can populate all the baseline values for the vitals
@@ -183,12 +202,13 @@ export function trackMFEVitals (target, timings) {
 
   try {
     resizeObs = new globalScope.ResizeObserver((entries) => {
+      if (disconnected) return
       entries.forEach((entry) => {
         try {
           const size = entry.contentRect.width * entry.contentRect.height
           if (size > largestSize) {
             largestSize = size
-            lcpObservedAt = now()
+            vitals.lcp.value = now()
           }
           resizeObs.unobserve(entry.target)
         } catch (e) {
@@ -245,7 +265,7 @@ export function trackMFEVitals (target, timings) {
   // Track CLS - cumulative layout shift
   // Initialize CLS to 0 if browser supports it
   observePerformance(observers, { type: 'layout-shift', buffered: true }, (entry) => {
-    if (entry.hadRecentInput) return
+    if (disconnected || entry.hadRecentInput) return
     ;(entry.sources || []).some(source => {
       if (isInMFE(source.node, target)) {
         // an observed "CLS" means _something_ rendered for the MFE, so at minimum we can make sure all the baseline values are populated for the vitals
@@ -259,7 +279,7 @@ export function trackMFEVitals (target, timings) {
 
   // Track INP - interaction to next paint
   observePerformance(observers, { type: 'event', buffered: true, durationThreshold: 40 }, (entry) => {
-    if (!entry.interactionId || !isInMFE(entry.target, target)) return
+    if (disconnected || !entry.interactionId || !isInMFE(entry.target, target)) return
     if (vitals.inp.value === undefined || entry.duration > vitals.inp.value) {
       // an observed "INP" means _something_ rendered for the MFE, so at minimum we can make sure all the baseline values are populated for the vitals
       populateVitalMinimums()
@@ -276,6 +296,7 @@ export function trackMFEVitals (target, timings) {
 
   // Disconnect all observers
   vitals.disconnect = () => {
+    disconnected = true
     // Disconnect all observers
     observers.forEach(obs => {
       try {
@@ -317,5 +338,11 @@ export function trackMFEVitals (target, timings) {
     globalScope.addEventListener(type, vitals.disconnect, { once: true, passive: true })
   })
 
+  // If the MFE has already rendered something on the page before we could set up listeners, just populate vital
+  // minimums immediately. Done last, once `observers` is fully populated and `vitals.disconnect` has its real
+  // implementation, so a stale-clock detection here can actually tear everything down instead of no-op'ing.
+  const existingRoots = globalScope.document?.querySelectorAll(`[data-nr-mfe-id="${escapeSelectorValue(target.id)}"]`)
+  if (Array.from(existingRoots || []).some(x => isMatch(x.dataset, target))) populateVitalMinimums()
+
   return vitals
 }

package/src/common/window/page-visibility.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
  */
 

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

@@ -157,7 +157,7 @@ export class Aggregate extends AggregateBase {
   serializer (eventBuffer) {
     if (!eventBuffer.length) return
 
-    const { addString, addStringWithTruncation } = createStringAdders(getAddStringContext, this.obfuscator)
+    const { addString, addStringRaw, addStringWithTruncation } = createStringAdders(getAddStringContext, this.obfuscator)
 
     let payload = 'bel.7;'
 
@@ -174,16 +174,16 @@ export class Aggregate extends AggregateBase {
         numeric(event.endTime - event.startTime),
         numeric(0), // callbackEnd
         numeric(0), // no callbackDuration for non-SPA events
-        addString(event.method),
+        addStringRaw(event.method),
         numeric(event.status),
         addString(event.domain),
         addString(event.path),
         numeric(event.requestSize),
         numeric(event.responseSize),
         event.type === 'fetch' ? 1 : '',
-        addString(0), // nodeId
-        nullable(event.spanId, addString, true) + // guid
-        nullable(event.traceId, addString, true) + // traceId
+        addStringRaw(0), // nodeId
+        nullable(event.spanId, addStringRaw, true) + // guid
+        nullable(event.traceId, addStringRaw, true) + // traceId
         nullable(event.spanTimestamp, numeric, false) // timestamp
       ]
 
@@ -193,12 +193,15 @@ export class Aggregate extends AggregateBase {
       const jsAttributes = this.agentRef.info.jsAttributes
 
       // Regular attributes: obfuscate only
-      const regularAttrs = addCustomAttributes({
+      let regularAttrs = addCustomAttributes({
         ...(jsAttributes || {}),
-        [AJAX_ID]: event[AJAX_ID], // all AjaxRequest events should have a unique identifier to allow for easier grouping and analysis in the UI
         ...(event.targetAttributes || {}), // used to supply the version 2 attributes, either MFE target or duplication attributes for the main agent app
         ...(event.gql || {})
-      }, addString)
+      }, { addKey: addStringRaw, addVal: addString })
+
+      regularAttrs.push(...addCustomAttributes({
+        [AJAX_ID]: event[AJAX_ID] // all AjaxRequest events should have a unique identifier to allow for easier grouping and analysis in the UI
+      }, { addKey: addStringRaw, addVal: addStringRaw }))
 
       // Payload attributes: obfuscate then truncate
       const payloadAttrs = addCustomAttributes({
@@ -207,7 +210,7 @@ export class Aggregate extends AggregateBase {
         ...(event.requestQuery ? { requestQuery: event.requestQuery } : {}),
         ...(event.responseBody ? { responseBody: event.responseBody } : {}),
         ...(event.responseHeaders ? { responseHeaders: event.responseHeaders } : {})
-      }, addStringWithTruncation)
+      }, { addKey: addStringRaw, addVal: addStringWithTruncation })
 
       const attrParts = [...regularAttrs, ...payloadAttrs]
       fields.unshift(numeric(attrParts.length))

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

@@ -132,9 +132,7 @@ export class Aggregate extends AggregateBase {
     }
     this.events.add(body)
 
-    if (this.agentRef.runtime.harvester.triggerHarvestFor(this, {
-      sendEmptyBody: true
-    }).ranSend) this.sentRum = true
+    if (this.agentRef.runtime.harvester.triggerHarvestFor(this).ranSend) this.sentRum = true
   }
 
   serializer (eventBuffer) { // this is necessary because PVE sends a single item rather than an array; in the case of undefined, this prevents sending [null] as body
@@ -162,9 +160,7 @@ export class Aggregate extends AggregateBase {
     super.postHarvestCleanup({ sent, retry: retry && !hasCachedRumResponse }) // this will set isRetrying & re-buffer the body if request is to be retried
 
     if (this.isRetrying && this.retries++ < 1) { // Only retry once
-      setTimeout(() => this.agentRef.runtime.harvester.triggerHarvestFor(this, {
-        sendEmptyBody: true
-      }), 5000) // Retry sending the RUM event after 5 seconds
+      setTimeout(() => this.agentRef.runtime.harvester.triggerHarvestFor(this), 5000) // Retry sending the RUM event after 5 seconds
       return
     }
 

package/src/features/page_view_event/aggregate_v2/index.js

@@ -0,0 +1,97 @@
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { globalScope, isBrowserScope, originTime, getNavigationEntry } from '../../../common/constants/runtime'
+import { addPT, addPN } from '../../../common/timing/nav-timing'
+import { stringify } from '../../../common/util/stringify'
+import * as CONSTANTS from '../constants'
+import { getActivatedFeaturesFlags } from '../aggregate/initialized-features'
+import { AggregateBase } from '../../utils/aggregate-base'
+import { firstContentfulPaint } from '../../../common/vitals/first-contentful-paint'
+import { firstPaint } from '../../../common/vitals/first-paint'
+import { timeToFirstByte } from '../../../common/vitals/time-to-first-byte'
+import { Obfuscator } from '../../../common/util/obfuscate'
+import { webdriverDetected } from '../../../common/util/webdriver-detection'
+import { EVENT_TYPES } from '../../../common/constants/events'
+
+export class Aggregate extends AggregateBase {
+  static featureName = CONSTANTS.FEATURE_NAME
+
+  #timeToFirstByte = 0
+  #firstByteToWindowLoad = 0 // our "frontend" duration
+  #firstByteToDomContent = 0 // our "dom processing" duration
+  #obfuscator
+
+  constructor (agentRef) {
+    super(agentRef, CONSTANTS.FEATURE_NAME)
+    this.#obfuscator = new Obfuscator(agentRef, EVENT_TYPES.PVE)
+
+    if (isBrowserScope) {
+      timeToFirstByte.subscribe(({ value, attrs }) => {
+        const navEntry = attrs.navigationEntry
+        this.#timeToFirstByte = Math.max(value, this.#timeToFirstByte)
+        this.#firstByteToWindowLoad = Math.max(Math.round(navEntry.loadEventEnd - this.#timeToFirstByte), this.#firstByteToWindowLoad) // our "frontend" duration
+        this.#firstByteToDomContent = Math.max(Math.round(navEntry.domContentLoadedEventEnd - this.#timeToFirstByte), this.#firstByteToDomContent) // our "dom processing" duration
+      })
+    }
+
+    this.waitForFlags(([])).then(() => {
+      const body = this.#obfuscator.traverseAndObfuscateEvents({ ja: { ...agentRef.info.jsAttributes, webdriverDetected } })
+      this.events.add(body)
+      this.drain()
+    })
+  }
+
+  queryStringsBuilder () {
+    const info = this.agentRef.info
+    const measures = {}
+
+    if (info.queueTime) measures.qt = info.queueTime
+    if (info.applicationTime) measures.ap = info.applicationTime
+
+    // These 3 values should've been recorded after load and before this func runs. They are part of the minimum required for PageView events to be created.
+    // Following PR #428, which demands that the BA must drive entity indexing, these need to be sent even outside of the main window context where PerformanceTiming
+    // or PerformanceNavigationTiming do not exists. Hence, they'll be filled in by 0s instead in, for example, worker threads that still init the PVE module.
+    measures.be = this.#timeToFirstByte
+    measures.fe = this.#firstByteToWindowLoad
+    measures.dc = this.#firstByteToDomContent
+
+    const queryParameters = {
+      at: info.atts,
+      af: getActivatedFeaturesFlags(this.agentRef).join(','),
+      igp: this.agentRef.runtime.appMetadata.igp,
+      ...measures,
+      fp: firstPaint.current.value,
+      fcp: firstContentfulPaint.current.value
+    }
+    if (globalScope.performance) {
+      const navTimingEntry = getNavigationEntry()
+      if (navTimingEntry) { // Navigation Timing level 2 API that replaced PerformanceTiming & PerformanceNavigation
+        const perf = ({
+          timing: addPT(originTime, navTimingEntry, {}),
+          navigation: addPN(navTimingEntry, {})
+        })
+        queryParameters.perf = stringify(perf)
+      } else if (typeof PerformanceTiming !== 'undefined') { // Modern Safari iFrames and Safari pre-15 do not support level 2 timing.
+        const perf = ({
+          timing: addPT(originTime, globalScope.performance.timing, {}, true),
+          navigation: addPN(globalScope.performance.navigation, {})
+        })
+        queryParameters.perf = stringify(perf)
+      }
+    }
+    const { correctedOriginTime } = this.agentRef.runtime.timeKeeper
+    if (correctedOriginTime) queryParameters.timestamp = correctedOriginTime // a "PageView" is set to represent the page's (server adjusted) origin time rather than when event is recorded/harvested
+
+    return queryParameters
+  }
+
+  get harvestEndpointVersion () {
+    return 2
+  }
+
+  serializer (eventBuffer) { // this is necessary because PVE sends a single item rather than an array; in the case of undefined, this prevents sending [null] as body
+    return eventBuffer[0]
+  }
+}

package/src/features/page_view_event/instrument/index.js

@@ -20,7 +20,12 @@ export class Instrument extends InstrumentBase {
     /** feature specific APIs */
     setupSetPageViewNameAPI(agentRef)
 
-    this.importAggregator(agentRef, () => import(/* webpackChunkName: "page_view_event-aggregate" */ '../aggregate'))
+    this.importAggregator(agentRef, () => {
+      if (agentRef.init.feature_flags.includes('rum_v2')) {
+        return import(/* webpackChunkName: "page_view_event-aggregate" */ '../aggregate_v2')
+      }
+      return import(/* webpackChunkName: "page_view_event-aggregate" */ '../aggregate')
+    })
   }
 
   setupInspectionEvents () {

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

@@ -23,6 +23,7 @@ import { loadTime } from '../../../common/vitals/load-time'
 import { webdriverDetected } from '../../../common/util/webdriver-detection'
 import { cleanURL } from '../../../common/url/clean-url'
 import { EVENT_TYPES } from '../../../common/constants/events'
+import { createStringAdders } from '../../../common/payloads/payloads'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
@@ -58,7 +59,11 @@ export class Aggregate extends AggregateBase {
         const { name, value, attrs } = cumulativeLayoutShift.current
         if (value === undefined) return
         this.addTiming(name, value * 1000, attrs)
-      }, true, true) // CLS node should only reports on vis change rather than on every change
+      }, true, true) // CLS node should only report on vis change rather than on every change.
+      /* NOTE: the capture=true is required -- empirically verified against a real browser (Chrome) for CLS
+      timing node to reliably be in the same final harvest as the rest, alongside Harvester#startTimer's
+      queueMicrotask deferral of the EOL harvest itself. Dropping this flag caused CLS to be split into its own,
+      separate, later harvest instead of going out together with pageHide/INP. */
 
       this.drain()
     })
@@ -93,6 +98,8 @@ export class Aggregate extends AggregateBase {
       attrs.cls = cumulativeLayoutShift.current.value
     }
 
+    attrs.webdriverDetected = webdriverDetected
+
     const timing = {
       name,
       value,
@@ -125,17 +132,13 @@ export class Aggregate extends AggregateBase {
     })
   }
 
-  appendGlobalCustomAttributes (timing) {
-    var timingAttributes = timing.attrs || {}
+  #getGlobalCustomAttributes () {
+    const reservedAttributes = ['size', 'eid', 'cls', 'type', 'fid', 'elTag', 'elUrl', 'net-type',
+      'net-etype', 'net-rtt', 'net-dlink', 'webdriverDetected']
 
-    var reservedAttributes = ['size', 'eid', 'cls', 'type', 'fid', 'elTag', 'elUrl', 'net-type',
-      'net-etype', 'net-rtt', 'net-dlink']
-    Object.entries(this.agentRef.info.jsAttributes || {}).forEach(([key, val]) => {
-      if (reservedAttributes.indexOf(key) < 0) {
-        timingAttributes[key] = val
-      }
-    })
-    timingAttributes.webdriverDetected = webdriverDetected
+    return Object.fromEntries(
+      Object.entries(this.agentRef.info.jsAttributes || {}).filter(([key]) => !reservedAttributes.includes(key))
+    )
   }
 
   preHarvestChecks () {
@@ -146,7 +149,9 @@ export class Aggregate extends AggregateBase {
   // serialize array of timing data
   serializer (eventBuffer) {
     if (!eventBuffer?.length) return ''
-    var addString = getAddStringContext(this.obfuscator)
+    const { addString, addStringRaw } = createStringAdders(getAddStringContext, this.obfuscator)
+    const keepOrigValue = { addKey: addStringRaw, addVal: addStringRaw }
+    const obfuscateValue = { addKey: addStringRaw, addVal: addString }
 
     var payload = 'bel.6;'
 
@@ -154,12 +159,16 @@ export class Aggregate extends AggregateBase {
       var timing = eventBuffer[i]
 
       payload += 'e,'
-      payload += addString(timing.name) + ','
+      payload += addStringRaw(timing.name) + ','
       payload += nullable(timing.value, numeric, false) + ','
 
-      this.appendGlobalCustomAttributes(timing)
+      const userAttrs = this.#getGlobalCustomAttributes()
+
+      const { pageUrl, ...systemReservedAttrs } = timing.attrs || {}
+      var attrParts = addCustomAttributes(systemReservedAttrs, keepOrigValue)
+      attrParts.push(...addCustomAttributes(userAttrs, obfuscateValue))
+      if (pageUrl) attrParts.push(...addCustomAttributes({ pageUrl }, obfuscateValue))
 
-      var attrParts = addCustomAttributes(timing.attrs, addString)
       if (attrParts && attrParts.length > 0) {
         payload += numeric(attrParts.length) + ';' + attrParts.join(';')
       }

package/src/features/session_replay/instrument/index.js

@@ -46,6 +46,10 @@ export class Instrument extends InstrumentBase {
       }) // could handle specific fail-state behaviors with a .catch block here
     }
 
+    // If the aggregate never successfully loads (missing session prerequisite, or the aggregate module itself
+    // fails to import/construct), any preload recording that already started needs to be stopped.
+    this.abortHandler = this.#abort
+
     this.importAggregator(this.agentRef, () => import(/* webpackChunkName: "session_replay-aggregate" */ '../aggregate'), this)
 
     /** If the recorder is running, we can pass error events on to the agg to help it switch to full mode later */
@@ -109,6 +113,11 @@ export class Instrument extends InstrumentBase {
         }) // could handle specific fail-state behaviors with a .catch block here
     }
   }
+
+  /** Stops any preload recording that already started if the aggregate never ends up successfully loading. */
+  #abort () {
+    this.recorder?.stopRecording()
+  }
 }
 
 export const SessionReplay = Instrument

package/src/features/session_replay/shared/recorder.js

@@ -204,7 +204,8 @@ export class Recorder {
 
     // We are making an effort to try to keep payloads manageable for unloading.  If they reach the unload limit before their interval,
     // it will send immediately.  This often happens on the first snapshot, which can be significantly larger than the other payloads.
-    if (((this.events.hasSnapshot && this.events.hasMeta) || payloadSize > IDEAL_PAYLOAD_SIZE) && !this.isErrorMode) {
+    // (the aggregate may not exist yet/at all if its own bootstrap hasn't finished or failed -- nothing to harvest for in that case.)
+    if (((this.events.hasSnapshot && this.events.hasMeta) || payloadSize > IDEAL_PAYLOAD_SIZE) && !this.isErrorMode && this.srInstrument.featAggregate) {
       // if we've made it to the ideal size of ~16kb before the interval timer, we should send early.
       this.agentRef.runtime.harvester.triggerHarvestFor(this.srInstrument.featAggregate)
     }

package/src/features/soft_navigations/aggregate/ajax-node.js

@@ -42,7 +42,7 @@ export class AjaxNode extends BelNode {
   }
 
   serialize (parentStartTimestamp, agentRef, ajaxObfuscator) {
-    const { addString, addStringWithTruncation } = createStringAdders(getAddStringContext, ajaxObfuscator)
+    const { addString, addStringRaw, addStringWithTruncation } = createStringAdders(getAddStringContext, ajaxObfuscator)
 
     const nodeList = []
 
@@ -54,22 +54,25 @@ export class AjaxNode extends BelNode {
       numeric(this.end - this.start), // end is relative to start
       numeric(this.callbackEnd - this.end), // callbackEnd is relative to end
       numeric(this.callbackDuration), // not relative
-      addString(this.method),
+      addStringRaw(this.method),
       numeric(this.status),
       addString(this.domain),
       addString(this.path),
       numeric(this.txSize),
       numeric(this.rxSize),
       this.requestedWith,
-      addString(this.nodeId),
-      nullable(this.spanId, addString, true) + nullable(this.traceId, addString, true) + nullable(this.spanTimestamp, numeric)
+      addStringRaw(this.nodeId),
+      nullable(this.spanId, addStringRaw, true) + nullable(this.traceId, addStringRaw, true) + nullable(this.spanTimestamp, numeric)
     ]
     // Regular attributes: obfuscate only
     const regularAttrs = addCustomAttributes({
-      [AJAX_ID]: this[AJAX_ID],
       ...(this.targetAttributes || {}),
       ...(this.gql || {})
-    }, addString)
+    }, { addKey: addStringRaw, addVal: addString })
+
+    regularAttrs.push(...addCustomAttributes({
+      [AJAX_ID]: this[AJAX_ID]
+    }, { addKey: addStringRaw, addVal: addStringRaw }))
 
     // Payload attributes: obfuscate then truncate
     const payloadAttrs = addCustomAttributes({
@@ -78,7 +81,7 @@ export class AjaxNode extends BelNode {
       ...(this.requestQuery ? { requestQuery: this.requestQuery } : {}),
       ...(this.responseBody ? { responseBody: this.responseBody } : {}),
       ...(this.responseHeaders ? { responseHeaders: this.responseHeaders } : {})
-    }, addStringWithTruncation)
+    }, { addKey: addStringRaw, addVal: addStringWithTruncation })
 
     let allAttachedNodes = [...regularAttrs, ...payloadAttrs]
     this.children.forEach(node => allAttachedNodes.push(node.serialize())) // no children is expected under ajax nodes at this time

package/src/features/soft_navigations/aggregate/interaction.js

@@ -9,6 +9,7 @@ import { now } from '../../../common/timing/now'
 import { cleanURL } from '../../../common/url/clean-url'
 import { NODE_TYPE, INTERACTION_STATUS, INTERACTION_TYPE, API_TRIGGER_NAME, IPL_TRIGGER_NAME, NO_LONG_TASK_WINDOW } from '../constants'
 import { BelNode } from './bel-node'
+import { createStringAdders } from '../../../common/payloads/payloads'
 
 /**
  * link https://github.com/newrelic/nr-querypack/blob/main/schemas/bel/7.qpschema
@@ -139,7 +140,7 @@ export class Interaction extends BelNode {
    */
   serialize (firstStartTimeOfPayload, agentRef, interactionObfuscator, ajaxObfuscator) {
     const isFirstIxnOfPayload = firstStartTimeOfPayload === undefined
-    const addString = getAddStringContext(interactionObfuscator)
+    const { addString, addStringRaw } = createStringAdders(getAddStringContext, interactionObfuscator)
     const nodeList = []
     let ixnType
     if (this.trigger === IPL_TRIGGER_NAME) ixnType = INTERACTION_TYPE.INITIAL_PAGE_LOAD
@@ -154,7 +155,7 @@ export class Interaction extends BelNode {
       numeric(this.end - this.start), // end -- relative to start
       numeric(0), // callbackEnd -- relative to start; not used by BrowserInteraction events so these are always 0
       numeric(0), // not relative; always 0 for BrowserInteraction
-      addString(this.trigger),
+      addStringRaw(this.trigger),
       addString(cleanURL(this.initialPageURL, true)),
       addString(cleanURL(this.oldURL, true)),
       addString(cleanURL(this.newURL, true)),
@@ -162,12 +163,12 @@ export class Interaction extends BelNode {
       ixnType,
       nullable(this.queueTime, numeric, true) + nullable(this.appTime, numeric, true) +
       nullable(this.oldRoute, addString, true) + nullable(this.newRoute, addString, true) +
-      addString(this.id),
-      addString(this.nodeId),
+      addStringRaw(this.id),
+      addStringRaw(this.nodeId),
       nullable(this.firstPaint, numeric, true) + nullable(this.firstContentfulPaint, numeric)
     ]
     const customAttributes = { ...agentRef.info.jsAttributes, ...this.customAttributes } // attrs specific to this interaction should have precedence over the general custom attrs
-    const allAttachedNodes = addCustomAttributes(customAttributes || {}, addString) // start with all custom attributes
+    const allAttachedNodes = addCustomAttributes(customAttributes || {}, { addKey: addStringRaw, addVal: addString }) // start with all custom attributes
     if (agentRef.info.atts) allAttachedNodes.push('a,' + addString(agentRef.info.atts)) // add apm provided attributes
     /* Querypack encoder+decoder quirkiness:
        - If first ixn node of payload is being processed, its children's start time must be offset by this node's start. (firstStartTime should be undefined.)

package/src/features/utils/aggregate-base.js

@@ -5,7 +5,6 @@
 import { FeatureBase } from './feature-base'
 import { drain } from '../../common/drain/drain'
 import { FEATURE_NAMES } from '../../loaders/features/features'
-import { Harvester } from '../../common/harvest/harvester'
 import { EventBuffer } from './event-buffer'
 import { handle } from '../../common/event-emitter/handle'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../metrics/constants'
@@ -21,7 +20,6 @@ export class AggregateBase extends FeatureBase {
    */
   constructor (agentRef, featureName) {
     super(agentRef, featureName)
-    this.doOnceForAllAggregate(agentRef)
 
     /** @type {Boolean} indicates if custom attributes are combined in each event payload for size estimation purposes. this is set to true in derived classes that need to evaluate custom attributes separately from the event payload */
     this.customAttributesAreSeparate = false
@@ -178,16 +176,6 @@ export class AggregateBase extends FeatureBase {
     this.events.clearSave(this.harvestOpts)
   }
 
-  /**
-   * These are actions related to shared resources that should be initialized once by whichever feature Aggregate subclass loads first.
-   * This method should run after checkConfiguration, which may reset the agent's info/runtime object that is used here.
-   */
-  doOnceForAllAggregate (agentRef) {
-    // Note: obfuscator is now created per-feature for their specific event types
-
-    if (!agentRef.runtime.harvester) agentRef.runtime.harvester = new Harvester(agentRef)
-  }
-
   /**
    * Report a supportability metric
    * @param {*} metricName The tag of the name matching the Angler aggregation tag