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

package/dist/esm/features/ajax/instrument/index.js

@@ -14,7 +14,7 @@ import { parseUrl } from '../../../common/url/parse-url';
 import { DT } from './distributed-tracing';
 import { responseSizeFromXhr } from './response-size';
 import { InstrumentBase } from '../../utils/instrument-base';
-import { FEATURE_NAME } from '../constants';
+import { CAPTURE_PAYLOAD_SETTINGS, FEATURE_NAME } from '../constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { SUPPORTABILITY_METRIC } from '../../metrics/constants';
 import { now } from '../../../common/timing/now';
@@ -25,6 +25,7 @@ var handlersLen = handlers.length;
 var origRequest = gosNREUMOriginals().o.REQ;
 var origXHR = gosNREUMOriginals().o.XHR;
 const NR_CAT_HEADER = 'X-NewRelic-App-Data';
+const INTERNAL_ERROR = 'internal-error';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef) {
@@ -70,10 +71,12 @@ export class Instrument extends InstrumentBase {
   }
 }
 function subscribeToEvents(agentRef, ee, handler, dt) {
+  const shouldInterceptPayloads = [CAPTURE_PAYLOAD_SETTINGS.ALL, CAPTURE_PAYLOAD_SETTINGS.FAILURES].includes(agentRef.init.ajax?.capture_payloads);
   ee.on('new-xhr', onNewXhr);
   ee.on('open-xhr-start', onOpenXhrStart);
   ee.on('open-xhr-end', onOpenXhrEnd);
   ee.on('send-xhr-start', onSendXhrStart);
+  ee.on('setRequestHeader-xhr-start', onSetRequestHeader);
   ee.on('xhr-cb-time', onXhrCbTime);
   ee.on('xhr-load-added', onXhrLoadAdded);
   ee.on('xhr-load-removed', onXhrLoadRemoved);
@@ -145,6 +148,13 @@ function subscribeToEvents(agentRef, ee, handler, dt) {
       }
     }
   }
+  function onSetRequestHeader(args, xhr) {
+    // args[0] = header name, args[1] = header value
+    if (shouldInterceptPayloads && args.length >= 2) {
+      this.requestHeaders ??= {};
+      this.requestHeaders[args[0].toLowerCase()] = args[1];
+    }
+  }
   function onSendXhrStart(args, xhr) {
     var metrics = this.metrics;
     var data = args[0];
@@ -154,7 +164,7 @@ function subscribeToEvents(agentRef, ee, handler, dt) {
       if (size) metrics.txSize = size;
     }
     this.startTime = now();
-    this.body = data;
+    this.requestBody = data;
     this.listener = function (evt) {
       try {
         if (evt.type === 'abort' && !context.loadCaptureCalled) {
@@ -163,7 +173,7 @@ function subscribeToEvents(agentRef, ee, handler, dt) {
         if (evt.type !== 'load' || context.called === context.totalCbs && (context.onloadCalled || typeof xhr.onload !== 'function') && typeof context.end === 'function') context.end(xhr);
       } catch (e) {
         try {
-          ee.emit('internal-error', [e]);
+          ee.emit(INTERNAL_ERROR, [e]);
         } catch (err) {
           // do nothing
         }
@@ -291,8 +301,27 @@ function subscribeToEvents(agentRef, ee, handler, dt) {
     addUrl(this, extractUrl(target));
     const method = ('' + (target && target instanceof origRequest && target.method || opts.method || 'GET')).toUpperCase();
     this.params.method = method;
-    this.body = opts.body;
-    this.txSize = dataSize(opts.body) || 0;
+    this.txSize = dataSize(opts.body || target?.body) || 0;
+
+    // Capture request headers
+    try {
+      var headers = opts.headers || target?.headers;
+      if (shouldInterceptPayloads && headers) {
+        this.requestHeaders ??= {};
+        if (headers instanceof Headers) {
+          headers.forEach(function (value, key) {
+            this.requestHeaders[key.toLowerCase()] = value;
+          }.bind(this));
+        } else if (typeof headers === 'object') {
+          for (var key in headers) {
+            this.requestHeaders[key.toLowerCase()] = headers[key];
+          }
+        }
+      }
+    } catch (e) {
+      // Silently fail if we can't access headers
+    }
+    this.requestBody = opts.body || target?.body;
   }
 
   // we capture failed call as status 0, the actual error is ignored
@@ -303,19 +332,45 @@ function subscribeToEvents(agentRef, ee, handler, dt) {
     if (hasUndefinedHostname(this.params)) return; // don't bother with fetch to url with no hostname
 
     this.params.status = res ? res.status : 0;
+    const finishAndReport = () => {
+      // convert rxSize to a number - handle both string (from content-length header) and number (from fallback)
+      const num = +this.rxSize;
+      const responseSize = this.rxSize != null && !isNaN(num) ? num : undefined;
+      const metrics = {
+        txSize: this.txSize,
+        rxSize: responseSize,
+        duration: this.endTime - this.startTime
+      };
+      const payload = [this.params, metrics, this.startTime, this.endTime, 'fetch'];
+      this.targets.forEach(target => reportToAgg(payload, this, target));
+    };
 
-    // convert rxSize to a number
-    let responseSize;
-    if (typeof this.rxSize === 'string' && this.rxSize.length > 0) {
-      responseSize = +this.rxSize;
+    /** Since accessing fetch bodies is an async process, these are
+     * reasonable conditions to check to not do needless extra work */
+    if (!res || !shouldInterceptPayloads) {
+      finishAndReport();
+      return;
     }
-    const metrics = {
-      txSize: this.txSize,
-      rxSize: responseSize,
-      duration: now() - this.startTime
-    };
-    const payload = [this.params, metrics, this.startTime, this.endTime, 'fetch'];
-    this.targets.forEach(target => reportToAgg(payload, this, target));
+
+    // Clone the response to read the body without consuming the original
+    res.clone().text().then(text => {
+      this.responseBody = text;
+      // Use captured payload size as fallback if content-length header was missing or is 0 with a body
+      // Only apply fallback for non-network-error responses (status !== 0)
+      if ((!this.rxSize || this.rxSize === '0' || this.rxSize === 0) && text !== undefined && this.params.status !== 0) {
+        this.rxSize = dataSize(text);
+      }
+      if (res?.headers) {
+        this.responseHeaders = {};
+        res.headers.forEach(function (value, key) {
+          this.responseHeaders[key.toLowerCase()] = value;
+        }.bind(this));
+      }
+    }).catch(err => {
+      ee.emit(INTERNAL_ERROR, [err]);
+    }).finally(() => {
+      finishAndReport();
+    });
   }
 
   // Create report for XHR request that has finished
@@ -330,7 +385,7 @@ function subscribeToEvents(agentRef, ee, handler, dt) {
     if (params.aborted) return;
     if (hasUndefinedHostname(params)) return; // don't bother with XHR of url with no hostname
 
-    metrics.duration = now() - this.startTime;
+    metrics.duration = this.endTime - this.startTime;
     if (!this.loadCaptureCalled && xhr.readyState === 4) {
       captureXhrData(this, xhr);
     } else if (params.status == null) {
@@ -339,6 +394,25 @@ function subscribeToEvents(agentRef, ee, handler, dt) {
 
     // Always send cbTime, even if no noticeable time was taken.
     metrics.cbTime = this.cbTime;
+    if (shouldInterceptPayloads) {
+      try {
+        this.responseBody = xhr.responseText;
+      } catch (e) {
+        this.responseBody = xhr.response;
+      }
+
+      // Use captured payload size as fallback if not already determined or is 0 with a body
+      // Only apply fallback for non-network-error responses (status !== 0)
+      if ((!metrics.rxSize || metrics.rxSize === 0) && this.responseBody !== undefined && params.status !== 0) {
+        const size = dataSize(this.responseBody);
+        if (size !== undefined) metrics.rxSize = size;
+      }
+      try {
+        this.responseHeaders = parseResponseHeaders(xhr.getAllResponseHeaders());
+      } catch (err) {
+        ee.emit(INTERNAL_ERROR, [err]);
+      }
+    }
     const payload = [params, metrics, this.startTime, this.endTime, 'xhr'];
     this.targets.forEach(target => reportToAgg(payload, this, target));
   }
@@ -348,7 +422,8 @@ function subscribeToEvents(agentRef, ee, handler, dt) {
   function captureXhrData(ctx, xhr) {
     ctx.params.status = xhr.status;
     var size = responseSizeFromXhr(xhr, ctx.lastSize);
-    if (size) ctx.metrics.rxSize = size;
+    // Don't set rxSize for network errors (status 0)
+    if (size !== undefined && xhr.status !== 0) ctx.metrics.rxSize = size;
     if (ctx.sameOrigin && xhr.getAllResponseHeaders().indexOf(NR_CAT_HEADER) >= 0) {
       var header = xhr.getResponseHeader(NR_CAT_HEADER);
       if (header) {
@@ -370,4 +445,17 @@ function addUrl(ctx, url) {
   ctx.parsedOrigin = parsed;
   ctx.sameOrigin = parsed.sameOrigin;
 }
+function parseResponseHeaders(headerStr) {
+  const headers = {};
+  if (!headerStr) return headers;
+  headerStr.split('\r\n').forEach(function (line) {
+    const separatorIndex = line.indexOf(': ');
+    if (separatorIndex > 0) {
+      const name = line.substring(0, separatorIndex);
+      const value = line.substring(separatorIndex + 2);
+      headers[name.toLowerCase()] = value;
+    }
+  });
+  return headers;
+}
 export const Ajax = Instrument;

package/dist/esm/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 {
   static featureName = FEATURE_NAME;
@@ -21,6 +22,10 @@ export class Aggregate extends AggregateBase {
   constructor(agentRef) {
     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;
@@ -40,7 +45,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,
@@ -68,7 +73,7 @@ export class Aggregate extends AggregateBase {
               } = aggregatedUserAction.event;
               aggregatedUserAction.targets.forEach(mfeTarget => {
                 const userActionEvent = {
-                  eventType: 'UserAction',
+                  eventType: EVENT_TYPES.UA,
                   timestamp: this.#toEpoch(timeStamp),
                   action: type,
                   actionCount: aggregatedUserAction.count,
@@ -155,7 +160,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,
@@ -221,7 +226,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,
@@ -241,7 +246,7 @@ export class Aggregate extends AggregateBase {
         } = args;
         const event = {
           ...customAttributes,
-          eventType: 'BrowserPerformance',
+          eventType: EVENT_TYPES.BP,
           timestamp: this.#toEpoch(start),
           entryName: n,
           entryDuration: duration,
@@ -253,7 +258,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)
@@ -268,7 +273,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,
@@ -337,9 +342,9 @@ export class Aggregate extends AggregateBase {
     });
   }
   serializer(eventBuffer) {
-    return applyFnToProps({
+    return this.obfuscator.traverseAndObfuscateEvents({
       ins: eventBuffer
-    }, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string');
+    });
   }
   queryStringsBuilder() {
     return {

package/dist/esm/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;
 export const OBSERVED_EVENTS = ['auxclick', 'click', 'copy', 'keydown', 'paste', 'scrollend'];
@@ -9,7 +10,7 @@ export const OBSERVED_WINDOW_EVENTS = ['focus', 'blur'];
 export const RAGE_CLICK_THRESHOLD_EVENTS = 4;
 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',
   REGISTER: 'register'

package/dist/esm/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
  */
 
@@ -9,7 +9,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) {

package/dist/esm/features/jserrors/aggregate/index.js

@@ -15,11 +15,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
@@ -36,6 +37,10 @@ export class Aggregate extends AggregateBase {
     this.observedAt = {};
     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);
@@ -51,7 +56,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) {
     const qs = {};
@@ -253,7 +262,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/dist/esm/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/';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
@@ -32,6 +33,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);
@@ -50,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;
@@ -112,7 +116,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
@@ -137,7 +141,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)
     }];
   }
   queryStringsBuilder() {
@@ -158,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
     });
   }
 }

package/dist/esm/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/dist/esm/features/page_view_event/aggregate/index.js

@@ -15,23 +15,42 @@ 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;
   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;
     this.firstByteToWindowLoad = 0; // our "frontend" duration
     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
@@ -76,14 +95,13 @@ export class Aggregate extends AggregateBase {
       ua: info.userAttributes,
       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
-
-    let body = applyFnToProps({
+    if (this.agentRef.runtime.session) queryParameters.fsh = Number(!this.agentRef.runtime.session.state.cachedRumResponse);
+    let body = this.obfuscator.traverseAndObfuscateEvents({
       ja: {
         ...customAttributes,
         webdriverDetected
       }
-    }, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string');
+    });
     if (globalScope.performance) {
       const navTimingEntry = getNavigationEntry();
       if (navTimingEntry) {
@@ -131,6 +149,7 @@ export class Aggregate extends AggregateBase {
   }) {
     const rumEndTime = now();
     let app, flags;
+    const hasCachedRumResponse = !!this.agentRef.runtime.session?.state.cachedRumResponse;
     try {
       ({
         app,
@@ -140,10 +159,20 @@ export class Aggregate extends AggregateBase {
       // wont set entity stuff here, if main agent will later abort, if registered agent, nothing will happen
       warn(53, error);
     }
+    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: 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, {
@@ -153,7 +182,6 @@ export class Aggregate extends AggregateBase {
     }
     if (status >= 400 || status === 0) {
       warn(18, status);
-      this.blocked = true;
 
       // Get estimated payload size of our backlog
       const textEncoder = new TextEncoder();
@@ -164,15 +192,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'
           },
@@ -180,28 +217,30 @@ 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
+          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 {
       const wasReady = this.agentRef.runtime.timeKeeper.ready;