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

package/dist/esm/common/harvest/send.js

@@ -0,0 +1,226 @@
+/**
+ * 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.npm";
+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 ? "".concat(protocol, "://").concat(perceivedBeacon, "/").concat(endpoint) : "".concat(protocol, "://").concat(perceivedBeacon).concat(endpoint !== RUM ? '/' + endpoint : '', "/").concat(endpointVersion, "/").concat(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 = "".concat(url, "?").concat(baseParams).concat(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/dist/esm/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/dist/esm/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,26 +15,27 @@ 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 {
   /**
@@ -246,7 +247,6 @@ export class SessionEntity {
       this.expiresTimer?.clear?.();
       delete this.isNew;
       this.setup({
-        agentRef: this.agentRef,
         key: this.key,
         storage: this.storage,
         expiresMs: this.expiresMs,

package/dist/esm/common/v2/mfe-vitals.js

@@ -0,0 +1,298 @@
+/**
+ * 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=\"".concat(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=\"".concat(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/dist/esm/features/generic_events/aggregate/index.js

@@ -254,7 +254,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/dist/esm/features/generic_events/instrument/index.js

@@ -25,7 +25,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/dist/esm/features/logging/aggregate/index.js

@@ -54,7 +54,7 @@ export class Aggregate extends AggregateBase {
       }; // 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();else updateLocalLoggingMode(session.state.loggingMode, session.state.logApiMode);
+        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) {
         this.blocked = true;
@@ -162,13 +162,13 @@ 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
     });
   }
 }