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

package/src/common/harvest/send.js

@@ -0,0 +1,209 @@
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { JSERRORS, RUM, EVENTS, FEATURE_NAMES, BLOBS, LOGS } from '../../loaders/features/features'
+import { VERSION } from '../constants/env'
+import { globalScope, isWorkerScope } from '../constants/runtime'
+import { handle } from '../event-emitter/handle'
+import { eventListenerOpts } from '../event-listener/event-listener-opts'
+import { now } from '../timing/now'
+import { cleanURL } from '../url/clean-url'
+import { obj, param } from '../url/encode'
+import { warn } from '../util/console'
+import { stringify } from '../util/stringify'
+import { xhr as xhrMethod, xhrFetch as fetchMethod } from '../util/submit-data'
+import { dispatchGlobalEvent } from '../dispatch/global-event'
+
+/**
+ * @typedef {import('./types.js').NetworkSendSpec} NetworkSendSpec
+ */
+
+const warnings = {}
+
+/**
+ * Initiate a harvest call.
+ * @param {object} agentRef The initialized agent reference
+ * @param {NetworkSendSpec} spec Specification for sending data
+ * @returns {boolean} True if a network call was made. Note that this does not mean or guarantee that it was successful.
+ */
+export function send (agentRef, { endpoint, payload, localOpts = {}, submitMethod, cbFinished, raw, featureName, endpointVersion = 1, harvesterObfuscator }) {
+  if (!agentRef.info.errorBeacon) return false
+
+  let { body, qs } = cleanPayload(payload)
+
+  if (Object.keys(body).length === 0 && !localOpts.sendEmptyBody) { // if there's no body to send, just run onfinish stuff and return
+    if (cbFinished) cbFinished({ sent: false })
+    return false
+  }
+
+  const protocol = agentRef.init.ssl === false ? 'http' : 'https'
+  const perceivedBeacon = agentRef.init.proxy.beacon || agentRef.info.errorBeacon
+  const url = raw
+    ? `${protocol}://${perceivedBeacon}/${endpoint}`
+    : `${protocol}://${perceivedBeacon}${endpoint !== RUM ? '/' + endpoint : ''}/${endpointVersion}/${agentRef.info.licenseKey}`
+  const baseParams = !raw ? baseQueryString(agentRef, qs, endpoint, harvesterObfuscator) : ''
+  let payloadParams = obj(qs, agentRef.runtime.maxBytes)
+  if (baseParams === '' && payloadParams.startsWith('&')) {
+    payloadParams = payloadParams.substring(1)
+  }
+
+  const fullUrl = `${url}?${baseParams}${payloadParams}`
+  const gzip = !!qs?.attributes?.includes('gzip')
+
+  // all gzipped data is already in the correct format and needs no transformation
+  // all features going to 'events' endpoint should already be serialized & stringified
+  let stringBody = gzip || endpoint === EVENTS ? body : stringify(body)
+
+  // If body is null, undefined, or an empty object or array after stringifying, send an empty string instead.
+  if (!stringBody || stringBody.length === 0 || stringBody === '{}' || stringBody === '[]') stringBody = ''
+
+  // Warn--once per endpoint--if the agent tries to send large payloads
+  if (endpoint !== BLOBS && stringBody.length > 750000 && (warnings[endpoint] = (warnings[endpoint] || 0) + 1) === 1) warn(28, endpoint)
+
+  const headers = [{ key: 'content-type', value: 'text/plain' }]
+
+  /* Since workers don't support sendBeacon right now, they can only use XHR method.
+      Because they still do permit synch XHR, the idea is that at final harvest time (worker is closing),
+      we just make a BLOCKING request--trivial impact--with the remaining data as a temp fill-in for sendBeacon.
+     Following the removal of img-element method. */
+  let result = submitMethod({ url: fullUrl, body: stringBody, sync: localOpts.isFinalHarvest && isWorkerScope, headers })
+
+  if (!localOpts.isFinalHarvest && cbFinished) { // final harvests don't hold onto buffer data (shouldRetryOnFail is false), so cleanup isn't needed
+    if (submitMethod === xhrMethod) {
+      result.addEventListener('loadend', function () {
+        // `this` here in block refers to the XHR object in this scope, do not change the anon function to an arrow function
+        // status 0 refers to a local error, such as CORS or network failure, or a blocked request by the browser (e.g. adblocker)
+        const cbResult = { sent: this.status !== 0, status: this.status, retry: shouldRetry(this.status), fullUrl, xhr: this, responseText: this.responseText }
+        cbFinished(cbResult)
+
+        /** temporary audit of consistency of harvest metadata flags */
+        if (!shouldRetry(this.status)) trackHarvestMetadata()
+      }, eventListenerOpts(false))
+    } else if (submitMethod === fetchMethod) {
+      result.then(async function (response) {
+        const status = response.status
+        const cbResult = { sent: true, status, retry: shouldRetry(status), fullUrl, fetchResponse: response, responseText: await response.text() }
+        cbFinished(cbResult)
+        /** temporary audit of consistency of harvest metadata flags */
+        if (!shouldRetry(status)) trackHarvestMetadata()
+      })
+    }
+
+    function trackHarvestMetadata () {
+      try {
+        if (featureName === FEATURE_NAMES.jserrors && !body?.err) return
+
+        const hasReplay = baseParams.includes('hr=1')
+        const hasTrace = baseParams.includes('ht=1')
+        const hasError = qs?.attributes?.includes('hasError=true')
+
+        handle('harvest-metadata', [{
+          [featureName]: {
+            ...(hasReplay && { hasReplay }),
+            ...(hasTrace && { hasTrace }),
+            ...(hasError && { hasError })
+          }
+        }], undefined, FEATURE_NAMES.metrics, agentRef.ee)
+      } catch (err) {
+        // do nothing
+      }
+    }
+  }
+
+  dispatchGlobalEvent({
+    drained: !!agentRef.runtime?.activatedFeatures,
+    type: 'data',
+    name: 'harvest',
+    feature: featureName,
+    data: {
+      endpoint,
+      headers,
+      payload,
+      submitMethod: getSubmitMethodName(),
+      raw,
+      synchronousXhr: !!(localOpts.isFinalHarvest && isWorkerScope)
+    }
+  })
+
+  return true
+
+  function shouldRetry (status) {
+    switch (status) {
+      case 408:
+      case 429:
+      case 500:
+        return true
+    }
+    return (status >= 502 && status <= 504) || (status >= 512 && status <= 530)
+  }
+
+  function getSubmitMethodName () {
+    if (submitMethod === xhrMethod) return 'xhr'
+    if (submitMethod === fetchMethod) return 'fetch'
+    return 'beacon'
+  }
+}
+
+/**
+ * Cleans and returns a payload object containing a body and qs
+ * object with key/value pairs. KV pairs where the value is null,
+ * undefined, or an empty string are removed to save on transmission
+ * size.
+ * @param {HarvestPayload} payload Payload to be sent to the endpoint.
+ * @returns {HarvestPayload} Cleaned payload payload to be sent to the endpoint.
+ */
+function cleanPayload (payload = {}) {
+  const clean = (input) => {
+    if ((typeof Uint8Array !== 'undefined' && input instanceof Uint8Array) || Array.isArray(input)) return input
+    if (typeof input === 'string') return input
+    return Object.entries(input || {}).reduce((accumulator, [key, value]) => {
+      if ((typeof value === 'number') ||
+        (typeof value === 'string' && value.length > 0) ||
+        (typeof value === 'object' && Object.keys(value || {}).length > 0)
+      ) {
+        accumulator[key] = value
+      }
+      return accumulator
+    }, {})
+  }
+
+  return {
+    body: clean(payload.body),
+    qs: clean(payload.qs)
+  }
+}
+
+// The stuff that gets sent every time.
+function baseQueryString (agentRef, qs, endpoint, harvesterObfuscator) {
+  const cleanedURL = cleanURL('' + globalScope.location)
+  const ref = harvesterObfuscator?.obfuscateString(cleanedURL) ?? cleanedURL
+  const session = agentRef.runtime.session
+  const hr = !!session?.state.sessionReplaySentFirstChunk && session?.state.sessionReplayMode === 1 && endpoint !== JSERRORS
+  const ht = !!session?.state.traceHarvestStarted && session?.state.sessionTraceMode === 1 && ![LOGS, BLOBS].includes(endpoint)
+
+  const qps = [
+    'a=' + agentRef.info.applicationID,
+    param('sa', (agentRef.info.sa ? '' + agentRef.info.sa : '')),
+    param('v', VERSION),
+    transactionNameParam(),
+    param('ct', agentRef.runtime.customTransaction),
+    '&rst=' + now(),
+    '&ck=0', // ck param DEPRECATED - still expected by backend
+    '&s=' + (session?.state.value || '0'), // the 0 id encaps all untrackable and default traffic
+    param('ref', ref),
+    param('ptid', (agentRef.runtime.ptid ? '' + agentRef.runtime.ptid : ''))
+  ]
+  if (hr) qps.push(param('hr', '1', qs))
+  if (ht) qps.push(param('ht', '1', qs))
+
+  return qps.join('')
+
+  // Constructs the transaction name param for the beacon URL.
+  // Prefers the obfuscated transaction name over the plain text.
+  // Falls back to making up a name.
+  function transactionNameParam () {
+    if (agentRef.info.transactionName) return param('to', agentRef.info.transactionName)
+    return param('t', agentRef.info.tNamePlain || 'Unnamed Transaction')
+  }
+}

package/src/common/harvest/types.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
  */
 
@@ -23,11 +23,15 @@
  * @typedef {object} NetworkSendSpec
  * @property {HarvestEndpointIdentifier} endpoint The endpoint to use (jserrors, events, resources etc.)
  * @property {HarvestPayload} payload Object representing payload.
- * @property {object} localOpts Additional options for sending data
- * @property {boolean} localOpts.isFinalHarvest Specify whether the call is a final harvest during page unload.
- * @property {boolean} localOpts.sendEmptyBody Specify whether the call should be made even if the body is empty. Useful for rum calls.
- * @property {boolean} localOpts.forceNoRetry Don't save the buffered data in the case of a need to retry the transmission.
+ * @property {object} [localOpts] Additional options for sending data
+ * @property {boolean} [localOpts.isFinalHarvest] Specify whether the call is a final harvest during page unload.
+ * @property {boolean} [localOpts.sendEmptyBody] Specify whether the call should be made even if the body is empty. Useful for rum calls.
+ * @property {boolean} [localOpts.forceNoRetry] Don't save the buffered data in the case of a need to retry the transmission.
  * @property {import('../util/submit-data.js').NetworkMethods} submitMethod The network method to use {@link ../util/submit-data.js}
+ * @property {function(object): void} [cbFinished] Callback invoked with the result once the network request completes. Receives an object with sent, status, retry, fullUrl, responseText, and either xhr or fetchResponse.
+ * @property {boolean} [raw] If true, skips standard versioned URL path construction and uses a bare endpoint URL.
+ * @property {string} [featureName] The feature name associated with this harvest, used for metadata tracking and the global harvest event.
+ * @property {number} [endpointVersion] The endpoint version included in the URL path. Defaults to 1.
  */
 
 export const unused = {}

package/src/common/session/session-entity.js

@@ -7,7 +7,7 @@ import { warn } from '../util/console'
 import { stringify } from '../util/stringify'
 import { Timer } from '../timer/timer'
 import { isBrowserScope } from '../constants/runtime'
-import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS, MODE, SESSION_EVENTS, SESSION_EVENT_TYPES, SESSION_STORAGE_KEY_PREFIX } from './constants'
+import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS, SESSION_EVENTS, SESSION_EVENT_TYPES, SESSION_STORAGE_KEY_PREFIX } from './constants'
 import { InteractionTimer } from '../timer/interaction-timer'
 import { wrapEvents } from '../wrap/wrap-events'
 import { getModeledObject } from '../config/configurable'
@@ -15,25 +15,25 @@ import { handle } from '../event-emitter/handle'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants'
 import { FEATURE_NAMES } from '../../loaders/features/features'
 import { windowAddEventListener } from '../event-listener/event-listener-opts'
-import { LOGGING_MODE } from '../../features/logging/constants'
 
-// this is what can be stored in local storage (not enforced but probably should be)
+// this is what can be stored in local storage (enforced during reads)
 // these values should sync between local storage and the parent class props
 const model = {
   value: '',
   inactiveAt: 0,
   expiresAt: 0,
   updatedAt: Date.now(),
-  sessionReplayMode: MODE.OFF,
+  sessionReplayMode: null,
   sessionReplaySentFirstChunk: false,
-  sessionTraceMode: MODE.OFF,
+  sessionTraceMode: null,
   traceHarvestStarted: false,
-  loggingMode: LOGGING_MODE.OFF,
-  logApiMode: LOGGING_MODE.OFF,
+  loggingMode: null,
+  logApiMode: null,
   serverTimeDiff: null, // set by TimeKeeper; "undefined" value will not be stringified and stored but "null" will
   custom: {},
   numOfResets: 0,
-  consent: false // set by consent() API call
+  consent: false, // set by consent() API call
+  cachedRumResponse: null
 }
 
 export class SessionEntity {
@@ -242,7 +242,6 @@ export class SessionEntity {
       delete this.isNew
 
       this.setup({
-        agentRef: this.agentRef,
         key: this.key,
         storage: this.storage,
         expiresMs: this.expiresMs,

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

@@ -0,0 +1,285 @@
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { globalScope, isBrowserScope } from '../constants/runtime'
+import { now } from '../timing/now'
+
+/**
+ * @typedef {import('./register-api-types').RegisterAPITimings} RegisterAPITimings
+ */
+
+const isObservable = (node) => {
+  try {
+    return node?.textContent?.trim() || ['img', 'video', 'canvas', 'svg'].includes(node?.nodeName?.toLowerCase())
+  } catch (e) {
+    return false
+  }
+}
+
+/**
+ * Check if node is within a specific MFE
+ * @param {Node} node - DOM node to check
+ * @param {string} id - MFE ID to match
+ * @returns {boolean}
+ */
+const isInMFE = (node, id) => {
+  if (!node || !id) return false
+  try {
+    let curr = node.nodeType === 1 ? node : node.parentElement
+    while (curr?.tagName) {
+      if (curr.dataset?.nrMfeId === id) return true
+      curr = curr.parentNode
+    }
+  } catch (e) {}
+  return false
+}
+
+/**
+ * Create mutation observer for MFE nodes
+ * @param {string} id - MFE ID to track
+ * @param {Function} onMatch - Callback when matching node is *added*
+ * @returns {MutationObserver}
+ */
+const observeMutations = (id, onMatch) => {
+  // Try to find existing MFE root
+  const mfeRoot = globalScope.document?.querySelector(`[data-nr-mfe-id="${id}"]`)
+  let observingRoot = !!mfeRoot
+
+  const obs = new globalScope.MutationObserver(mutations => {
+    mutations.forEach(m => {
+      m.addedNodes.forEach(node => {
+        // Check if this is the MFE root being added
+        const elem = node.nodeType === 1 ? node : null
+        if (elem?.dataset?.nrMfeId === id) {
+          // Found the root! Lets switch to observing just this subtree for performance reasons
+          obs.disconnect()
+          obs.observe(elem, { childList: true, subtree: true })
+          observingRoot = true
+        }
+
+        // Only check isInMFE if we're observing the whole document; skip expensive ancestor walk when observing root
+        if (isObservable(node) && (observingRoot || isInMFE(node, id))) {
+          onMatch(node, obs)
+        }
+      })
+    })
+  })
+
+  // If root exists, observe just that subtree; otherwise observe document to catch when root is added
+  obs.observe(mfeRoot || globalScope.document, { childList: true, subtree: true })
+
+  return obs
+}
+
+/**
+ * Create performance observer for MFE entries
+ * @param {Array} observers - Array to track observers
+ * @param {Object} config - Observer configuration
+ * @param {Function} onEntry - Callback for each entry
+ * @returns {PerformanceObserver|null} Observer if successful, null if unsupported
+ */
+const observePerformance = (observers, config, onEntry) => {
+  try {
+    const obs = new globalScope.PerformanceObserver(list => {
+      list.getEntries().forEach(onEntry)
+    })
+    obs.observe(config)
+    observers.push(obs)
+    return obs
+  } catch (e) {
+    return null
+  }
+}
+
+/**
+ * Tracks all Core Web Vitals for a specific MFE.
+ * @param {string} id - The MFE ID to track
+ * @returns {{fcp: object|null, lcp: object|null, cls: object|null, inp: object|null, disconnect: Function}}
+ */
+export function trackMFEVitals (id, timings) {
+  let fcpObservedAt = null
+  let lcpObservedAt = null
+
+  const getTimeRelativeToScriptStart = (capturedAt) => {
+    if (capturedAt === null) return null
+    return capturedAt - (timings?.scriptStart || timings?.registeredAt || 0)
+  }
+
+  const vitals = {
+    fcp: {
+      get value () { return getTimeRelativeToScriptStart(fcpObservedAt) }
+    },
+    lcp: {
+      get value () { return getTimeRelativeToScriptStart(lcpObservedAt) }
+    },
+    cls: {
+      value: null
+    },
+    inp: {
+      value: null
+    },
+    disconnect: () => {}
+  }
+
+  if (!id || !isBrowserScope || !globalScope.MutationObserver || !globalScope.PerformanceObserver) return vitals
+
+  const observers = []
+
+  const populateVitalMinimums = () => {
+    fcpObservedAt ??= now()
+    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
+  if (globalScope.document?.querySelector(`[data-nr-mfe-id="${id}"]`)) populateVitalMinimums()
+
+  // Track FCP - first contentful paint
+  observeMutations(id, (_, obs) => {
+    // An observed "FCP" means _something_ rendered, so at minimum we can populate all the baseline values for the vitals
+    populateVitalMinimums()
+    obs.disconnect()
+  })
+
+  // Track LCP - largest contentful paint
+  let largestSize = 0
+  let resizeObs = null
+  const observedElements = new Set()
+
+  try {
+    resizeObs = new globalScope.ResizeObserver((entries) => {
+      entries.forEach((entry) => {
+        try {
+          const size = entry.contentRect.width * entry.contentRect.height
+          if (size > largestSize) {
+            largestSize = size
+            lcpObservedAt = now()
+          }
+          resizeObs.unobserve(entry.target)
+        } catch (e) {
+          // Element may be detached from DOM
+        }
+      })
+    })
+  } catch (e) {
+    // ResizeObserver not supported
+  }
+
+  const lcpObs = observeMutations(id, (node) => {
+    // an observed "LCP" means _something_ rendered, so at minimum we can make sure all the baseline values are populated for the vitals
+    populateVitalMinimums()
+
+    if (resizeObs) {
+      try {
+        const elem = node.nodeType === 1 ? node : node.parentElement
+        if (elem && !observedElements.has(elem)) {
+          observedElements.add(elem)
+
+          // For media elements, wait for content to load before observing size
+          if (elem.tagName === 'IMG') {
+            if (elem.complete) {
+              resizeObs.observe(elem)
+            } else {
+              elem.addEventListener('load', () => {
+                resizeObs.observe(elem)
+              }, { once: true })
+            }
+          } else if (elem.tagName === 'VIDEO') {
+            // For video, wait for first frame (HAVE_CURRENT_DATA = 2)
+            if (elem.readyState >= 2) {
+              resizeObs.observe(elem)
+            } else {
+              elem.addEventListener('loadeddata', () => {
+                resizeObs.observe(elem)
+              }, { once: true })
+            }
+          } else {
+            // For other elements, observe immediately
+            resizeObs.observe(elem)
+          }
+        }
+      } catch (e) {
+        // Element may not be observable
+      }
+    }
+  })
+
+  if (resizeObs) observers.push(resizeObs)
+  observers.push(lcpObs)
+
+  // 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
+    ;(entry.sources || []).some(source => {
+      if (isInMFE(source.node, id)) {
+        // 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
+        populateVitalMinimums()
+        vitals.cls.value += entry.value
+        return true
+      }
+      return false
+    })
+  })
+
+  // Track INP - interaction to next paint
+  observePerformance(observers, { type: 'event', buffered: true, durationThreshold: 40 }, (entry) => {
+    if (!entry.interactionId || !isInMFE(entry.target, id)) return
+    if (vitals.inp.value === null || 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()
+      vitals.inp.value = entry.duration
+    }
+  })
+
+  const interactionEvents = ['pointerdown', 'keydown']
+  const disconnectInteractionListeners = () => {
+    interactionEvents.forEach(type => {
+      globalScope.removeEventListener(type, handleInteraction, { passive: true })
+    })
+  }
+
+  // Disconnect all observers
+  vitals.disconnect = () => {
+    // Disconnect all observers
+    observers.forEach(obs => {
+      try {
+        obs?.disconnect()
+      } catch (e) {
+        // Observer may already be disconnected
+      }
+    })
+    disconnectInteractionListeners()
+  }
+
+  // Auto-disconnect LCP observer on user interaction (per Web Vitals spec)
+  // CLS and INP continue tracking until visibility change or deregister
+  const disconnectLCP = () => {
+    try {
+      lcpObs?.disconnect()
+      resizeObs?.disconnect()
+    } catch (e) {
+      // Observer may already be disconnected
+    }
+  }
+
+  const handleInteraction = (event) => {
+    if (!isInMFE(event?.target, id)) return
+
+    disconnectLCP()
+    disconnectInteractionListeners()
+  }
+
+  interactionEvents.forEach(type => {
+    globalScope.addEventListener(type, handleInteraction, { passive: true })
+  })
+
+  // Disconnect all observers on visibility change or page unload
+  ;['visibilitychange', 'pagehide'].forEach(type => {
+    globalScope.addEventListener(type, vitals.disconnect, { once: true, passive: true })
+  })
+
+  return vitals
+}

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

@@ -251,7 +251,7 @@ export class Aggregate extends AggregateBase {
         this.addEvent(event, target)
       }, this.featureName, this.ee)
 
-      if (agentRef.init.feature_flags.includes('websockets')) {
+      if (agentRef.init.feature_flags.includes('websockets') || agentRef.init.web_sockets?.enabled) {
         registerHandler('ws-complete', (nrData) => {
           const event = {
             ...nrData,

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

@@ -26,7 +26,7 @@ export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME
   constructor (agentRef) {
     super(agentRef, FEATURE_NAME)
-    const websocketsEnabled = agentRef.init.feature_flags.includes('websockets')
+    const websocketsEnabled = agentRef.init.feature_flags.includes('websockets') || agentRef.init.web_sockets?.enabled
     const securityPolicyViolationEnabled = !agentRef.init.feature_flags.includes('no_spv')
 
     /** config values that gate whether the generic events aggregator should be imported at all */

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

@@ -52,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) {
@@ -163,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
     })
   }
 }