@newrelic/browser-agent 1.316.0 → 1.317.0-rc.0

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

@@ -10,10 +10,11 @@ import { AggregateBase } from '../../utils/aggregate-base'
 import { warn } from '../../../common/util/console'
 import { now } from '../../../common/timing/now'
 import { registerHandler } from '../../../common/event-emitter/register-handler'
-import { applyFnToProps } from '../../../common/util/traverse'
+import { Obfuscator } from '../../../common/util/obfuscate'
 import { UserActionsAggregator } from './user-actions/user-actions-aggregator'
 import { isIFrameWindow } from '../../../common/dom/iframe'
 import { isPureObject } from '../../../common/util/type-check'
+import { EVENT_TYPES } from '../../../common/constants/events'
 import { getVersion2Attributes, getVersion2DuplicationAttributes, shouldDuplicate } from '../../../common/v2/utils'
 
 export class Aggregate extends AggregateBase {
@@ -24,6 +25,10 @@ export class Aggregate extends AggregateBase {
     super(agentRef, FEATURE_NAME)
     this.referrerUrl = (isBrowserScope && document.referrer) ? cleanURL(document.referrer) : undefined
 
+    // Create generic obfuscator (no specific event types) since this feature handles multiple event types
+    // Will check each event's eventType property at runtime against obfuscation rules
+    this.obfuscator = new Obfuscator(agentRef)
+
     this.waitForFlags(['ins']).then(([ins]) => {
       if (!ins) {
         this.blocked = true
@@ -46,7 +51,7 @@ export class Aggregate extends AggregateBase {
         registerHandler('api-addPageAction', (timestamp, name, attributes, target) => {
           this.addEvent({
             ...attributes,
-            eventType: 'PageAction',
+            eventType: EVENT_TYPES.PA,
             timestamp: this.#toEpoch(timestamp),
             timeSinceLoad: timestamp / 1000,
             actionName: name,
@@ -73,7 +78,7 @@ export class Aggregate extends AggregateBase {
 
               aggregatedUserAction.targets.forEach(mfeTarget => {
                 const userActionEvent = {
-                  eventType: 'UserAction',
+                  eventType: EVENT_TYPES.UA,
                   timestamp: this.#toEpoch(timeStamp),
                   action: type,
                   actionCount: aggregatedUserAction.count,
@@ -152,7 +157,7 @@ export class Aggregate extends AggregateBase {
                     const detailObj = agentRef.init.performance.capture_detail ? createDetailAttrs(entry.detail) : {}
                     this.addEvent({
                       ...detailObj,
-                      eventType: 'BrowserPerformance',
+                      eventType: EVENT_TYPES.BP,
                       timestamp: this.#toEpoch(entry.startTime),
                       entryName: entry.name,
                       entryDuration: entry.duration,
@@ -217,7 +222,7 @@ export class Aggregate extends AggregateBase {
             this.reportSupportabilityMetric('Generic/Performance/Resource/Seen')
             const event = {
               ...entryObject,
-              eventType: 'BrowserPerformance',
+              eventType: EVENT_TYPES.BP,
               timestamp: this.#toEpoch(entryObject.startTime),
               entryName: cleanURL(name),
               entryDuration: duration,
@@ -236,7 +241,7 @@ export class Aggregate extends AggregateBase {
 
         const event = {
           ...customAttributes,
-          eventType: 'BrowserPerformance',
+          eventType: EVENT_TYPES.BP,
           timestamp: this.#toEpoch(start),
           entryName: n,
           entryDuration: duration,
@@ -250,7 +255,7 @@ export class Aggregate extends AggregateBase {
         registerHandler('ws-complete', (nrData) => {
           const event = {
             ...nrData,
-            eventType: 'WebSocket',
+            eventType: EVENT_TYPES.WS,
             timestamp: this.#toEpoch(nrData.timestamp),
             openedAt: this.#toEpoch(nrData.openedAt),
             closedAt: this.#toEpoch(nrData.closedAt)
@@ -266,7 +271,7 @@ export class Aggregate extends AggregateBase {
       if (!agentRef.init.feature_flags.includes('no_spv')) {
         registerHandler('spv', (evt) => {
           this.addEvent({
-            eventType: 'SecurityPolicyViolation',
+            eventType: EVENT_TYPES.SPV,
             timestamp: this.#toEpoch(evt.timeStamp),
             blockedUri: evt.blockedURI,
             documentUri: evt.documentURI,
@@ -335,7 +340,7 @@ export class Aggregate extends AggregateBase {
   }
 
   serializer (eventBuffer) {
-    return applyFnToProps({ ins: eventBuffer }, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
+    return this.obfuscator.traverseAndObfuscateEvents({ ins: eventBuffer })
   }
 
   queryStringsBuilder () {

package/src/features/generic_events/constants.js

@@ -1,7 +1,8 @@
 /**
- * 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 { EVENT_TYPES } from '../../common/constants/events'
 import { FEATURE_NAMES } from '../../loaders/features/features'
 
 export const FEATURE_NAME = FEATURE_NAMES.genericEvents
@@ -14,7 +15,7 @@ export const RAGE_CLICK_THRESHOLD_MS = 1000
 
 export const FRUSTRATION_TIMEOUT_MS = 2000
 
-export const RESERVED_EVENT_TYPES = ['PageAction', 'UserAction', 'BrowserPerformance']
+export const RESERVED_EVENT_TYPES = [EVENT_TYPES.PA, EVENT_TYPES.UA, EVENT_TYPES.BP]
 
 export const FEATURE_FLAGS = {
   RESOURCES: 'experimental.resources',

package/src/features/jserrors/aggregate/format-stack-trace.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
  */
 
@@ -10,7 +10,7 @@ export function formatStackTrace (stackLines) {
   return truncateStackLines(stackLines).replace(stripNewlinesRegex, '')
 }
 
-// takes array of stack lines and returns string with top 50 and buttom 50 lines
+// takes array of stack lines and returns string with top 50 and bottom 50 lines
 function truncateStackLines (stackLines) {
   var stackString
   if (stackLines.length > 100) {
@@ -26,5 +26,5 @@ function truncateStackLines (stackLines) {
 
 // truncates stack string to limit what is sent to backend
 export function truncateSize (stackString) {
-  return (stackString.length > MAX_STACK_TRACE_LENGTH) ? stackString.substr(0, MAX_STACK_TRACE_LENGTH) : stackString
+  return stackString.length > MAX_STACK_TRACE_LENGTH ? stackString.substr(0, MAX_STACK_TRACE_LENGTH) : stackString
 }

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

@@ -17,11 +17,12 @@ import { FEATURE_NAME } from '../constants'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { now } from '../../../common/timing/now'
-import { applyFnToProps } from '../../../common/util/traverse'
+import { Obfuscator } from '../../../common/util/obfuscate'
 import { evaluateInternalError } from './internal-errors'
 import { getRegisteredTargetsFromFilename, getVersion2Attributes, getVersion2DuplicationAttributes, shouldDuplicate } from '../../../common/v2/utils'
 import { buildCauseString } from './cause-string'
 import { ShortCircuit } from '../../../common/util/short-circuit'
+import { EVENT_TYPES } from '../../../common/constants/events'
 
 /**
  * @typedef {import('./compute-stack-trace.js').StackInfo} StackInfo
@@ -39,6 +40,10 @@ export class Aggregate extends AggregateBase {
     this.pageviewReported = {}
     this.errorOnPage = false
 
+    // Create obfuscators for each event type this feature handles
+    this.errorObfuscator = new Obfuscator(agentRef, EVENT_TYPES.JSE)
+    this.xhrObfuscator = new Obfuscator(agentRef, EVENT_TYPES.AJAX)
+
     register('err', this.processError.bind(this), this.featureName, this.ee)
     register('ierr', this.processError.bind(this), this.featureName, this.ee)
     register('returnJserror', (jsErrorEvent, softNavAttrs) => this.#storeJserrorForHarvest(jsErrorEvent, softNavAttrs), this.featureName, this.ee)
@@ -55,7 +60,11 @@ export class Aggregate extends AggregateBase {
   }
 
   serializer (aggregatorTypeToBucketsMap) {
-    return applyFnToProps(aggregatorTypeToBucketsMap, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
+    return {
+      err: this.errorObfuscator.traverseAndObfuscateEvents(aggregatorTypeToBucketsMap.err),
+      ierr: this.errorObfuscator.traverseAndObfuscateEvents(aggregatorTypeToBucketsMap.ierr),
+      xhr: this.xhrObfuscator.traverseAndObfuscateEvents(aggregatorTypeToBucketsMap.xhr)
+    }
   }
 
   queryStringsBuilder (aggregatorTakeReturnedData) {
@@ -258,7 +267,7 @@ export class Aggregate extends AggregateBase {
       params.stack_trace = truncateSize(stackInfo.stackString)
       this.observedAt[bucketHash] = Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(time))
     } else {
-      params.browser_stack_hash = stringHashCode(stackInfo.stackString)
+      params.browser_stack_hash = stringHashCode(truncateSize(stackInfo.stackString))
     }
     params.releaseIds = stringify(this.agentRef.runtime.releaseIds)
 

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

@@ -9,11 +9,12 @@ import { AggregateBase } from '../../utils/aggregate-base'
 import { FEATURE_NAME, LOGGING_EVENT_EMITTER_CHANNEL, LOG_LEVELS, LOGGING_MODE } from '../constants'
 import { Log } from '../shared/log'
 import { isValidLogLevel } from '../shared/utils'
-import { applyFnToProps } from '../../../common/util/traverse'
+import { Obfuscator } from '../../../common/util/obfuscate'
 import { SESSION_EVENT_TYPES, SESSION_EVENTS } from '../../../common/session/constants'
 import { ABORT_REASONS } from '../../session_replay/constants'
 import { canEnableSessionTracking } from '../../utils/feature-gates'
 import { getVersion2Attributes, getVersion2DuplicationAttributes, shouldDuplicate } from '../../../common/v2/utils'
+import { EVENT_TYPES } from '../../../common/constants/events'
 
 const LOGGING_EVENT = 'Logging/Event/'
 
@@ -31,6 +32,9 @@ export class Aggregate extends AggregateBase {
     this.harvestOpts.raw = true
     super.customAttributesAreSeparate = true
 
+    // Create obfuscator for log entries
+    this.obfuscator = new Obfuscator(agentRef, EVENT_TYPES.LOG)
+
     // The SessionEntity class can emit a message indicating the session was cleared and reset (expiry, inactivity). This feature must abort and never resume if that occurs.
     this.ee.on(SESSION_EVENTS.RESET, () => {
       this.abort(ABORT_REASONS.RESET)
@@ -48,7 +52,7 @@ export class Aggregate extends AggregateBase {
       this.loggingMode ??= { auto, api } // likewise, don't want to overwrite the mode if it was set already
       const session = this.agentRef.runtime.session
       if (canEnableSessionTracking(agentRef.init) && session) {
-        if (session.isNew) this.#syncWithSessionManager()
+        if (session.state.loggingMode === null || session.state.logApiMode === null) this.#writeToStorage(this.loggingMode)
         else updateLocalLoggingMode(session.state.loggingMode, session.state.logApiMode)
       }
       if (this.loggingMode.auto === LOGGING_MODE.OFF && this.loggingMode.api === LOGGING_MODE.OFF) {
@@ -119,7 +123,7 @@ export class Aggregate extends AggregateBase {
       common: {
         /** Attributes in the `common` section are added to `all` logs generated in the payload */
         attributes: {
-          ...(applyFnToProps(this.agentRef.info.jsAttributes, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')),
+          ...(this.obfuscator.traverseAndObfuscateEvents(this.agentRef.info.jsAttributes)),
           ...(this.harvestEndpointVersion === 1 && {
             'entity.guid': this.agentRef.runtime.appMetadata.agents[0].entityGuid,
             appId: this.agentRef.info.applicationID
@@ -139,10 +143,7 @@ export class Aggregate extends AggregateBase {
         }
       },
       /** logs section contains individual unique log entries */
-      logs: applyFnToProps(
-        eventBuffer,
-        this.obfuscator.obfuscateString.bind(this.obfuscator), 'string'
-      )
+      logs: this.obfuscator.traverseAndObfuscateEvents(eventBuffer)
     }]
   }
 
@@ -162,14 +163,14 @@ export class Aggregate extends AggregateBase {
       auto: LOGGING_MODE.OFF,
       api: LOGGING_MODE.OFF
     }
-    this.#syncWithSessionManager()
+    this.#writeToStorage(this.loggingMode)
     this.deregisterDrain()
   }
 
-  #syncWithSessionManager () {
+  #writeToStorage (logModes) {
     this.agentRef.runtime.session?.write({
-      loggingMode: this.loggingMode.auto,
-      logApiMode: this.loggingMode.api
+      loggingMode: logModes.auto,
+      logApiMode: logModes.api
     })
   }
 }

package/src/features/metrics/aggregate/index.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 { registerHandler } from '../../../common/event-emitter/register-handler'
@@ -12,6 +12,7 @@ import { isBrowserScope, isWorkerScope } from '../../../common/constants/runtime
 import { AggregateBase } from '../../utils/aggregate-base'
 import { isIFrameWindow } from '../../../common/dom/iframe'
 import { evaluateHarvestMetadata } from './harvest-metadata'
+import { Obfuscator } from '../../../common/util/obfuscate'
 // import { WEBSOCKET_TAG } from '../../../common/wrap/wrap-websocket'
 // import { handleWebsocketEvents } from './websocket-detection'
 
@@ -21,6 +22,9 @@ export class Aggregate extends AggregateBase {
     super(agentRef, FEATURE_NAME)
     this.harvestOpts.aggregatorTypes = ['cm', 'sm'] // the types in EventAggregator this feature cares about
 
+    // Create a generic obfuscator for checking if rules are configured
+    this.obfuscator = new Obfuscator(agentRef)
+
     /** all the harvest metadata metrics need to be evaluated simulataneously at unload time so just temporarily buffer them and dont make SMs immediately from the data */
     this.harvestMetadata = {}
     this.harvestOpts.beforeUnload = () => {

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

@@ -15,11 +15,13 @@ import { firstPaint } from '../../../common/vitals/first-paint'
 import { timeToFirstByte } from '../../../common/vitals/time-to-first-byte'
 import { now } from '../../../common/timing/now'
 import { TimeKeeper } from '../../../common/timing/time-keeper'
-import { applyFnToProps } from '../../../common/util/traverse'
-import { send } from '../../../common/harvest/harvester'
+import { send } from '../../../common/harvest/send'
+import { canEnableSessionTracking } from '../../utils/feature-gates'
+import { Obfuscator } from '../../../common/util/obfuscate'
 import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
 import { getSubmitMethod } from '../../../common/util/submit-data'
 import { webdriverDetected } from '../../../common/util/webdriver-detection'
+import { EVENT_TYPES } from '../../../common/constants/events'
 
 export class Aggregate extends AggregateBase {
   static featureName = CONSTANTS.FEATURE_NAME
@@ -27,6 +29,7 @@ export class Aggregate extends AggregateBase {
   constructor (agentRef) {
     super(agentRef, CONSTANTS.FEATURE_NAME)
 
+    this.isSessionTrackingEnabled = canEnableSessionTracking(agentRef.init) && !!agentRef.runtime.session
     this.sentRum = false // flag to facilitate calling sendRum() once externally (by the consent API in agent-session.js)
 
     this.timeToFirstByte = 0
@@ -34,9 +37,23 @@ export class Aggregate extends AggregateBase {
     this.firstByteToDomContent = 0 // our "dom processing" duration
     this.retries = 0
 
+    // Create obfuscator for page view events
+    this.obfuscator = new Obfuscator(agentRef, EVENT_TYPES.PVE)
+
     agentRef.runtime.timeKeeper = new TimeKeeper(agentRef.runtime.session)
 
     if (isBrowserScope) {
+      const cached = this.isSessionTrackingEnabled && agentRef.runtime.session?.state.cachedRumResponse
+      if (cached) {
+        const { app: cachedApp, ...cachedFlags } = cached
+
+        // set the agent runtime objects that require the rum response or entity guid
+        if (!Object.keys(this.agentRef.runtime.appMetadata).length) agentRef.runtime.appMetadata = cachedApp
+        this.drain()
+        agentRef.runtime.harvester.startTimer()
+        activateFeatures(cachedFlags, agentRef)
+      }
+
       timeToFirstByte.subscribe(({ value, attrs }) => {
         const navEntry = attrs.navigationEntry
         this.timeToFirstByte = Math.max(value, this.timeToFirstByte)
@@ -81,9 +98,9 @@ export class Aggregate extends AggregateBase {
       at: info.atts
     }
 
-    if (this.agentRef.runtime.session) queryParameters.fsh = Number(this.agentRef.runtime.session.isNew) // "first session harvest" aka RUM request or PageView event of a session
+    if (this.agentRef.runtime.session) queryParameters.fsh = Number(!this.agentRef.runtime.session.state.cachedRumResponse)
 
-    let body = applyFnToProps({ ja: { ...customAttributes, webdriverDetected } }, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
+    let body = this.obfuscator.traverseAndObfuscateEvents({ ja: { ...customAttributes, webdriverDetected } })
 
     if (globalScope.performance) {
       const navTimingEntry = getNavigationEntry()
@@ -127,6 +144,7 @@ export class Aggregate extends AggregateBase {
   postHarvestCleanup ({ sent, status, responseText, xhr, retry }) {
     const rumEndTime = now()
     let app, flags
+    const hasCachedRumResponse = !!this.agentRef.runtime.session?.state.cachedRumResponse
     try {
       ({ app, ...flags } = JSON.parse(responseText))
     } catch (error) {
@@ -134,16 +152,24 @@ export class Aggregate extends AggregateBase {
       warn(53, error)
     }
 
-    super.postHarvestCleanup({ sent, retry }) // this will set isRetrying & re-buffer the body if request is to be retried
+    const shouldCacheResponse = this.isSessionTrackingEnabled && !hasCachedRumResponse && !!app
+    if (hasCachedRumResponse) {
+      let { app: cachedApp, ...cachedFlags } = this.agentRef.runtime.session.state.cachedRumResponse
+      app ??= cachedApp
+      flags = cachedFlags
+    }
+
+    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
       return
     }
+
     if (status >= 400 || status === 0) {
       warn(18, status)
-      this.blocked = true
 
       // Get estimated payload size of our backlog
       const textEncoder = new TextEncoder()
@@ -155,16 +181,24 @@ export class Aggregate extends AggregateBase {
       }, 0)
       const BCSError = 'BCS/Error/'
       // Send SMs about failed RUM request
-      const body = {
-        sm: [{
-          params: {
-            name: BCSError + status
-          },
-          stats: {
-            c: 1
-          }
+      const sm = [{
+        params: {
+          name: BCSError + status
         },
-        {
+        stats: {
+          c: 1
+        }
+      }, {
+        params: {
+          name: BCSError + 'Duration/Ms'
+        },
+        stats: {
+          c: 1,
+          t: rumEndTime - this.rumStartTime
+        }
+      }]
+      if (!hasCachedRumResponse) {
+        sm.push({
           params: {
             name: BCSError + 'Dropped/Bytes'
           },
@@ -172,28 +206,23 @@ export class Aggregate extends AggregateBase {
             c: 1,
             t: payloadSize
           }
-        },
-        {
-          params: {
-            name: BCSError + 'Duration/Ms'
-          },
-          stats: {
-            c: 1,
-            t: rumEndTime - this.rumStartTime
-          }
-        }]
+        })
       }
 
       send(this.agentRef, {
         endpoint: FEATURE_TO_ENDPOINT[FEATURE_NAMES.metrics],
-        payload: { body },
+        payload: { body: { sm } },
         submitMethod: getSubmitMethod(),
         featureName: FEATURE_NAMES.metrics
       })
 
-      // Adding retry logic for the rum call will be a separate change; this.blocked will need to be changed since that prevents another triggerHarvestFor()
-      this.ee.abort()
-      return
+      if (!hasCachedRumResponse) {
+        this.blocked = true
+        this.ee.abort()
+        return
+      }
+    } else if (shouldCacheResponse) {
+      this.agentRef.runtime.session.write({ cachedRumResponse: { app, ...flags } })
     }
 
     try {

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

@@ -9,6 +9,7 @@ import { handle } from '../../../common/event-emitter/handle'
 import { FEATURE_NAME } from '../constants'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { AggregateBase } from '../../utils/aggregate-base'
+import { Obfuscator } from '../../../common/util/obfuscate'
 import { cumulativeLayoutShift } from '../../../common/vitals/cumulative-layout-shift'
 import { firstContentfulPaint } from '../../../common/vitals/first-contentful-paint'
 import { firstPaint } from '../../../common/vitals/first-paint'
@@ -21,6 +22,7 @@ import { eventOrigin } from '../../../common/util/event-origin'
 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'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
@@ -36,6 +38,9 @@ export class Aggregate extends AggregateBase {
 
     super.customAttributesAreSeparate = true
 
+    // Create obfuscator for page view timing events
+    this.obfuscator = new Obfuscator(agentRef, EVENT_TYPES.PVT)
+
     registerHandler('docHidden', msTimestamp => this.endCurrentSession(msTimestamp), this.featureName, this.ee)
     // Add the time of _window pagehide event_ firing to the next PVT harvest == NRDB windowUnload attr:
     registerHandler('winPagehide', msTimestamp => this.addTiming('unload', msTimestamp, null), this.featureName, this.ee)
@@ -141,7 +146,7 @@ export class Aggregate extends AggregateBase {
   // serialize array of timing data
   serializer (eventBuffer) {
     if (!eventBuffer?.length) return ''
-    var addString = getAddStringContext(this.agentRef.runtime.obfuscator)
+    var addString = getAddStringContext(this.obfuscator)
 
     var payload = 'bel.6;'
 

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

@@ -19,17 +19,23 @@ import { stringify } from '../../../common/util/stringify'
 import { stylesheetEvaluator } from '../shared/stylesheet-evaluator'
 import { now } from '../../../common/timing/now'
 import { MAX_PAYLOAD_SIZE } from '../../../common/constants/agent-constants'
+import { EVENT_TYPES } from '../../../common/constants/events'
 import { cleanURL } from '../../../common/url/clean-url'
 import { canEnableSessionTracking } from '../../utils/feature-gates'
 import { PAUSE_REPLAY } from '../../../loaders/api/constants'
+import { Obfuscator } from '../../../common/util/obfuscate'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
-  mode = MODE.OFF
+  mode = null
 
   // pass the recorder into the aggregator
   constructor (agentRef, args) {
     super(agentRef, FEATURE_NAME)
+
+    // Create obfuscator for session replay query params
+    this.obfuscator = new Obfuscator(agentRef, EVENT_TYPES.SR)
+
     /** Set once the recorder has fully initialized after flag checks and sampling */
     this.initialized = false
     /** Set once the feature has been "aborted" to prevent other side-effects from continuing */
@@ -68,7 +74,7 @@ export class Aggregate extends AggregateBase {
       if (!this.recorder) return
       // if the mode changed on a different tab, it needs to update this instance to match
       this.mode = agentRef.runtime.session.state.sessionReplayMode
-      if (!this.initialized || this.mode === MODE.OFF) return
+      if (!this.initialized || this.mode === MODE.OFF || !this.mode) return
       this.recorder?.startRecording(TRIGGERS.RESUME, this.mode)
     })
 
@@ -91,6 +97,8 @@ export class Aggregate extends AggregateBase {
     this.waitForFlags(['srs', 'sr']).then(([srMode, entitled]) => {
       this.entitled = !!entitled
       if (!this.entitled) {
+        this.mode = MODE.OFF
+        this.#writeToStorage({ sessionReplayMode: this.mode })
         this.deregisterDrain()
         if (this.agentRef.runtime.isRecording) {
           this.abort(ABORT_REASONS.ENTITLEMENTS)
@@ -100,7 +108,7 @@ export class Aggregate extends AggregateBase {
       }
       this.initializeRecording(srMode).then(() => { this.drain() })
     }).then(() => {
-      if (this.mode === MODE.OFF) {
+      if (!this.mode) {
         this.recorder?.stopRecording() // stop any conservative preload recording launched by instrument
         while (this.recorder?.getEvents().events.length) this.recorder?.clearBuffer?.()
       }
@@ -137,7 +145,7 @@ export class Aggregate extends AggregateBase {
     // if the error was noticed AFTER the recorder was already imported....
     if (this.recorder && this.initialized) {
       if (!this.agentRef.runtime.isRecording) this.recorder.startRecording(TRIGGERS.SWITCH_TO_FULL, this.mode) // off --> full
-      this.syncWithSessionManager({ sessionReplayMode: this.mode })
+      this.#writeToStorage({ sessionReplayMode: this.mode })
     } else {
       this.initializeRecording(MODE.FULL, true, TRIGGERS.SWITCH_TO_FULL)
     }
@@ -165,35 +173,36 @@ export class Aggregate extends AggregateBase {
 
     if (this.recorder?.trigger === TRIGGERS.API && this.agentRef.runtime.isRecording) {
       this.mode = MODE.FULL
-    } else if (!session.isNew && !ignoreSession) { // inherit the mode of the existing session
+    } else if (session.state.sessionReplayMode !== null && !ignoreSession) { // inherit the mode of the existing session
       this.mode = session.state.sessionReplayMode
     } else {
       // The session is new... determine the mode the new session should start in
       this.mode = srMode
     }
-    // If off, then don't record (early return)
-    if (this.mode === MODE.OFF) return
 
-    try {
-      /** will return a recorder instance if already imported, otherwise, will fetch the recorder and initialize it */
-      this.recorder ??= await this.instrumentClass.importRecorder()
-    } catch (err) {
-      /** if the recorder fails to import, abort the feature */
-      return this.abort(ABORT_REASONS.IMPORT, err)
-    }
-
-    // If an error was noticed before the mode could be set (like in the early lifecycle of the page), immediately set to FULL mode
-    if (this.mode === MODE.ERROR && this.instrumentClass.errorNoticed) { this.mode = MODE.FULL }
+    if (this.mode !== MODE.OFF) {
+      try {
+        /** will return a recorder instance if already imported, otherwise, will fetch the recorder and initialize it */
+        this.recorder ??= await this.instrumentClass.importRecorder()
+      } catch (err) {
+        /** if the recorder fails to import, abort the feature */
+        return this.abort(ABORT_REASONS.IMPORT, err)
+      }
 
-    // FULL mode records AND reports from the beginning, while ERROR mode only records (but does not report).
-    // ERROR mode will do this until an error is thrown, and then switch into FULL mode.
-    // The makeHarvestPayload should ensure that no payload is returned if we're not in FULL mode...
+      // If an error was noticed before the mode could be set (like in the early lifecycle of the page), immediately set to FULL mode
+      if (this.mode === MODE.ERROR && this.instrumentClass.errorNoticed) {
+        this.mode = MODE.FULL
+      }
 
-    await this.prepUtils()
+      // FULL mode records AND reports from the beginning, while ERROR mode only records (but does not report).
+      // ERROR mode will do this until an error is thrown, and then switch into FULL mode.
+      // The makeHarvestPayload should ensure that no payload is returned if we're not in FULL mode...
 
-    if (!this.agentRef.runtime.isRecording) this.recorder.startRecording(trigger, this.mode)
+      await this.prepUtils()
 
-    this.syncWithSessionManager({ sessionReplayMode: this.mode })
+      if (!this.agentRef.runtime.isRecording) this.recorder.startRecording(trigger, this.mode)
+    }
+    this.#writeToStorage({ sessionReplayMode: this.mode })
   }
 
   async prepUtils () {
@@ -240,7 +249,7 @@ export class Aggregate extends AggregateBase {
       return
     }
 
-    if (!this.agentRef.runtime.session.state.sessionReplaySentFirstChunk) this.syncWithSessionManager({ sessionReplaySentFirstChunk: true })
+    if (!this.agentRef.runtime.session.state.sessionReplaySentFirstChunk) this.#writeToStorage({ sessionReplaySentFirstChunk: true })
     this.recorder.clearBuffer()
 
     if (!this.agentRef.runtime.session.state.traceHarvestStarted) {
@@ -303,7 +312,7 @@ export class Aggregate extends AggregateBase {
     return {
       qs: {
         browser_monitoring_key: this.agentRef.info.licenseKey,
-        type: 'SessionReplay',
+        type: EVENT_TYPES.SR,
         app_id: this.agentRef.info.applicationID,
         protocol_version: '0',
         timestamp: firstTimestamp,
@@ -364,7 +373,7 @@ export class Aggregate extends AggregateBase {
     if (forceHarvest) this.agentRef.runtime.harvester.triggerHarvestFor(this)
     this.mode = MODE.OFF
     this.recorder?.stopRecording?.()
-    this.syncWithSessionManager({ sessionReplayMode: this.mode })
+    this.#writeToStorage({ sessionReplayMode: this.mode })
   }
 
   /** Abort the feature, once aborted it will not resume */
@@ -374,12 +383,12 @@ export class Aggregate extends AggregateBase {
     this.blocked = true
     this.mode = MODE.OFF
     this.recorder?.stopRecording?.()
-    this.syncWithSessionManager({ sessionReplayMode: this.mode })
+    this.#writeToStorage({ sessionReplayMode: this.mode })
     this.recorder?.clearTimestamps?.()
     while (this.recorder?.getEvents().events.length) this.recorder?.clearBuffer?.()
   }
 
-  syncWithSessionManager (state = {}) {
+  #writeToStorage (state = {}) {
     if (this.isSessionTrackingEnabled) {
       this.agentRef.runtime.session.write(state)
     }