@newrelic/browser-agent 1.303.0 → 1.304.0-rc.0

package/CHANGELOG.md

@@ -3,6 +3,19 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.304.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.303.0...v1.304.0) (2025-12-03)
+
+
+### Features
+
+* Reduce Session Replay snapshot sizes ([#1630](https://github.com/newrelic/newrelic-browser-agent/issues/1630)) ([7d3edc8](https://github.com/newrelic/newrelic-browser-agent/commit/7d3edc80edd421d4960b95c5d84ca5eef7fca6a4))
+* Warn message on session reset ([#1635](https://github.com/newrelic/newrelic-browser-agent/issues/1635)) ([6e2110f](https://github.com/newrelic/newrelic-browser-agent/commit/6e2110f129ad682444203a9aa65b4a4955bf7636))
+
+
+### Bug Fixes
+
+* Observe document.body after document is interactive ([#1636](https://github.com/newrelic/newrelic-browser-agent/issues/1636)) ([34c7db3](https://github.com/newrelic/newrelic-browser-agent/commit/34c7db3c695b1950e63970d0a22a2ddacd0481aa))
+
 ## [1.303.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.302.0...v1.303.0) (2025-11-13)
 
 

package/dist/cjs/common/config/init.js

@@ -151,7 +151,6 @@ const InitModelFn = () => {
       collect_fonts: false,
       inline_images: false,
       fix_stylesheets: true,
-      // recording config settings
       mask_all_inputs: true,
       // this has a getter/setter to facilitate validation of the selectors
       get mask_text_selector() {

package/dist/cjs/common/constants/env.cdn.js

@@ -17,7 +17,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.RRWEB_PACKAGE_NAME = exports.D
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.303.0";
+const VERSION = exports.VERSION = "1.304.0-rc.0";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/constants/env.npm.js

@@ -17,7 +17,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.RRWEB_PACKAGE_NAME = exports.D
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.303.0";
+const VERSION = exports.VERSION = "1.304.0-rc.0";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/session/session-entity.js

@@ -242,6 +242,7 @@ class SessionEntity {
     // * stop recording (stn and sr)...
     // * delete the session and start over
     try {
+      (0, _console.warn)(66);
       if (this.initialized) {
         this.ee.emit(_constants.SESSION_EVENTS.RESET);
         this.state.numOfResets++;

package/dist/cjs/common/util/monkey-patched.js

@@ -20,9 +20,11 @@ const checked = new Map();
 function isNative(...fns) {
   return fns.every(fn => {
     if (checked.has(fn)) return checked.get(fn);
-    const isNative = typeof fn === 'function' && fn.toString().includes('[native code]');
-    if (!isNative) {
-      (0, _console.warn)(64, fn?.name || fn?.toString());
+    const fnString = typeof fn === 'function' ? fn.toString() : '';
+    const isNative = fnString.includes('[native code]');
+    const isNr = fnString.includes('nrWrapper');
+    if (!isNative && !isNr) {
+      (0, _console.warn)(64, fn?.name || fnString);
     }
     checked.set(fn, isNative);
     return isNative;

package/dist/cjs/common/window/page-visibility.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.subscribeToPageUnload = subscribeToPageUnload;
 exports.subscribeToVisibilityChange = subscribeToVisibilityChange;
 var _eventListenerOpts = require("../event-listener/event-listener-opts");
 /**
@@ -25,4 +26,7 @@ function subscribeToVisibilityChange(cb, toHiddenOnly = false, capture, abortSig
     }
     cb(document.visibilityState);
   }
+}
+function subscribeToPageUnload(cb, capture, abortSignal) {
+  (0, _eventListenerOpts.windowAddEventListener)('pagehide', cb, capture, abortSignal);
 }

package/dist/cjs/common/wrap/wrap-websocket.js

@@ -3,61 +3,291 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.WEBSOCKET_TAG = exports.ADD_EVENT_LISTENER_TAG = void 0;
 exports.wrapWebSocket = wrapWebSocket;
 var _runtime = require("../constants/runtime");
-var _now = require("../timing/now");
-var _load = require("../window/load");
 var _uniqueId = require("../ids/unique-id");
+var _now = require("../timing/now");
 var _nreum = require("../window/nreum");
+var _pageVisibility = require("../window/page-visibility");
 /**
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
-const WEBSOCKET_TAG = exports.WEBSOCKET_TAG = 'websocket-';
-const ADD_EVENT_LISTENER_TAG = exports.ADD_EVENT_LISTENER_TAG = 'addEventListener';
 const wrapped = {};
+const openWebSockets = new Set(); // track all instances to close out metrics on page unload
+
 function wrapWebSocket(sharedEE) {
-  if (wrapped[sharedEE.debugId]++) return sharedEE;
   const originals = (0, _nreum.gosNREUMOriginals)().o;
   if (!originals.WS) return sharedEE;
-  function reporter(socketId) {
-    const createdAt = (0, _now.now)();
-    return function (message, ...data) {
-      const timestamp = data[0]?.timeStamp || (0, _now.now)();
-      const isLoaded = (0, _load.checkState)();
-      sharedEE.emit(WEBSOCKET_TAG + message, [timestamp, timestamp - createdAt, isLoaded, socketId, ...data]);
-    };
-  }
+  const wsEE = sharedEE.get('websockets');
+  if (wrapped[wsEE.debugId]++) return wsEE;
+  wrapped[wsEE.debugId] = 1; // otherwise, first feature to wrap events
+
+  // This handles page navigation scenarios where the browser closes WebSockets after pagehide fires
+  (0, _pageVisibility.subscribeToPageUnload)(() => {
+    const unloadTime = (0, _now.now)();
+    openWebSockets.forEach(ws => {
+      ws.nrData.closedAt = unloadTime;
+      ws.nrData.closeCode = 1001; // Going Away - standard code for page navigation
+      ws.nrData.closeReason = 'Page navigating away';
+      ws.nrData.closeWasClean = false;
+      if (ws.nrData.openedAt) {
+        ws.nrData.connectedDuration = unloadTime - ws.nrData.openedAt;
+      }
+      wsEE.emit('ws', [ws.nrData], ws);
+    });
+  });
   class WrappedWebSocket extends WebSocket {
     static name = 'WebSocket';
+    static toString() {
+      // fake native WebSocket when static class is stringified
+      return 'function WebSocket() { [native code] }';
+    }
+    toString() {
+      // fake [object WebSocket] when instance is stringified
+      return '[object WebSocket]';
+    }
+    get [Symbol.toStringTag]() {
+      // fake [object WebSocket] when Object.prototype.toString.call is used on instance
+      return WrappedWebSocket.name;
+    }
+
+    // Private method to tag send, close, and event listener errors with WebSocket ID for JSErrors feature
+    #tagError(error) {
+      ;
+      (error.__newrelic ??= {}).socketId = this.nrData.socketId;
+      this.nrData.hasErrors ??= true;
+    }
     constructor(...args) {
       super(...args);
-      const socketId = (0, _uniqueId.generateRandomHexString)(6);
-      this.report = reporter(socketId);
-      this.report('new');
-      const events = ['message', 'error', 'open', 'close'];
-      /** add event listeners */
-      events.forEach(evt => {
-        this.addEventListener(evt, function (e) {
-          this.report(ADD_EVENT_LISTENER_TAG, {
-            eventType: evt,
-            event: e
-          });
+      /** @type {WebSocketData} */
+      this.nrData = new WebSocketData(args[0], args[1]);
+      this.addEventListener('open', () => {
+        this.nrData.openedAt = (0, _now.now)();
+        ['protocol', 'extensions', 'binaryType'].forEach(prop => {
+          this.nrData[prop] = this[prop];
         });
+        openWebSockets.add(this);
+      });
+      this.addEventListener('message', event => {
+        const {
+          type,
+          size
+        } = getDataInfo(event.data);
+        this.nrData.messageOrigin ??= event.origin; // the origin of messages thru WS lifetime cannot be changed, so set once is sufficient
+        this.nrData.messageCount = (this.nrData.messageCount ?? 0) + 1;
+        this.nrData.messageBytes = (this.nrData.messageBytes ?? 0) + size;
+        this.nrData.messageBytesMin = Math.min(this.nrData.messageBytesMin ?? Infinity, size);
+        this.nrData.messageBytesMax = Math.max(this.nrData.messageBytesMax ?? 0, size);
+        if (!(this.nrData.messageTypes ?? '').includes(type)) {
+          this.nrData.messageTypes = this.nrData.messageTypes ? "".concat(this.nrData.messageTypes, ",").concat(type) : type;
+        }
+      });
+      this.addEventListener('close', event => {
+        this.nrData.closedAt = (0, _now.now)();
+        this.nrData.closeCode = event.code;
+        this.nrData.closeReason = event.reason;
+        this.nrData.closeWasClean = event.wasClean;
+        this.nrData.connectedDuration = this.nrData.closedAt - this.nrData.openedAt;
+        openWebSockets.delete(this); // remove from tracking set since it's now closed
+        wsEE.emit('ws', [this.nrData], this);
       });
     }
-    send(...args) {
-      this.report('send', ...args);
+    addEventListener(type, listener, ...rest) {
+      const wsInstance = this;
+      const wrappedListener = typeof listener === 'function' ? function (...args) {
+        try {
+          return listener.apply(this, args);
+        } catch (error) {
+          wsInstance.#tagError(error);
+          throw error;
+        }
+      } : listener?.handleEvent ? {
+        // case for listener === object with handleEvent
+        handleEvent: function (...args) {
+          try {
+            return listener.handleEvent.apply(listener, args);
+          } catch (error) {
+            wsInstance.#tagError(error);
+            throw error;
+          }
+        }
+      } : listener; // case for listener === null
+      return super.addEventListener(type, wrappedListener, ...rest);
+    }
+    send(data) {
+      // Only track metrics if the connection is OPEN; data sent in CONNECTING state throws, and data sent in CLOSING/CLOSED states is silently discarded
+      if (this.readyState === WebSocket.OPEN) {
+        const {
+          type,
+          size
+        } = getDataInfo(data);
+        this.nrData.sendCount = (this.nrData.sendCount ?? 0) + 1;
+        this.nrData.sendBytes = (this.nrData.sendBytes ?? 0) + size;
+        this.nrData.sendBytesMin = Math.min(this.nrData.sendBytesMin ?? Infinity, size);
+        this.nrData.sendBytesMax = Math.max(this.nrData.sendBytesMax ?? 0, size);
+        if (!(this.nrData.sendTypes ?? '').includes(type)) {
+          this.nrData.sendTypes = this.nrData.sendTypes ? "".concat(this.nrData.sendTypes, ",").concat(type) : type;
+        }
+      }
       try {
-        return super.send(...args);
-      } catch (err) {
-        this.report('send-err', ...args);
-        throw err;
+        return super.send(data);
+      } catch (error) {
+        this.#tagError(error);
+        throw error;
+      }
+    }
+    close(...args) {
+      try {
+        super.close(...args);
+      } catch (error) {
+        this.#tagError(error);
+        throw error;
       }
     }
   }
   _runtime.globalScope.WebSocket = WrappedWebSocket;
-  return sharedEE;
+  return wsEE;
+}
+
+/**
+ * Returns the data type and size of the WebSocket send data
+ * @param {*} data - The data being sent
+ * @returns {{ type: string, size: number }} - The type name and size in bytes
+ */
+function getDataInfo(data) {
+  if (typeof data === 'string') {
+    return {
+      type: 'string',
+      size: new TextEncoder().encode(data).length // efficient way to calculate the # of UTF-8 bytes that WS sends (cannot use string length)
+    };
+  }
+  if (data instanceof ArrayBuffer) {
+    return {
+      type: 'ArrayBuffer',
+      size: data.byteLength
+    };
+  }
+  if (data instanceof Blob) {
+    return {
+      type: 'Blob',
+      size: data.size
+    };
+  }
+  if (data instanceof DataView) {
+    return {
+      type: 'DataView',
+      size: data.byteLength
+    };
+  }
+  if (ArrayBuffer.isView(data)) {
+    return {
+      type: 'TypedArray',
+      size: data.byteLength
+    };
+  }
+  return {
+    type: 'unknown',
+    size: 0
+  };
+}
+
+/**
+ * WebSocket instrumentation data model
+ */
+class WebSocketData {
+  /**
+   * @param {string} requestedUrl - The URL passed to WebSocket constructor
+   * @param {string|string[]} [requestedProtocols] - The protocols passed to WebSocket constructor
+   */
+  constructor(requestedUrl, requestedProtocols) {
+    /** @type {number} Timestamp when the WebSocket was constructed (relative time); will be time corrected later when timeKeeper is available */
+    this.timestamp = (0, _now.now)();
+
+    /** @type {string} Most current URL when WebSocket was created; relevant for SPA */
+    this.currentUrl = window.location.href;
+
+    /*
+     * pageUrl will be set by addEvent later; unlike timestamp and currentUrl, it's not sensitive to *when* it is set.
+     * It should not be explicitly defined here as it will overwrite the default provided by Generic Events later.
+    */
+
+    /** @type {string} Unique identifier for this WebSocket connection */
+    this.socketId = (0, _uniqueId.generateRandomHexString)(8);
+
+    /** @type {string} The URL requested for the WebSocket connection */
+    this.requestedUrl = requestedUrl;
+
+    /** @type {string} Comma-separated list of requested protocols */
+    this.requestedProtocols = Array.isArray(requestedProtocols) ? requestedProtocols.join(',') : requestedProtocols || '';
+
+    // Properties set when connection opens
+    /** @type {number} [openedAt] Timestamp when connection opened */
+    this.openedAt = undefined;
+
+    /** @type {string} [protocol] The sub-protocol selected by the server */
+    this.protocol = undefined;
+
+    /** @type {string} [extensions] The extensions selected by the server */
+    this.extensions = undefined;
+
+    /** @type {string} [binaryType] The binary type ('blob' or 'arraybuffer') */
+    this.binaryType = undefined;
+
+    // Message received metrics
+    /** @type {string} [messageOrigin] Origin of messages (set once) */
+    this.messageOrigin = undefined;
+
+    /** @type {number} [messageCount] Total number of messages received */
+    this.messageCount = undefined;
+
+    /** @type {number} [messageBytes] Total bytes received */
+    this.messageBytes = undefined;
+
+    /** @type {number} [messageBytesMin] Minimum message size received */
+    this.messageBytesMin = undefined;
+
+    /** @type {number} [messageBytesMax] Maximum message size received */
+    this.messageBytesMax = undefined;
+
+    /** @type {string} [messageTypes] Comma-separated list of message types received */
+    this.messageTypes = undefined;
+
+    // Send metrics
+    /** @type {number} [sendCount] Total number of messages sent */
+    this.sendCount = undefined;
+
+    /** @type {number} [sendBytes] Total bytes sent */
+    this.sendBytes = undefined;
+
+    /** @type {number} [sendBytesMin] Minimum message size sent */
+    this.sendBytesMin = undefined;
+
+    /** @type {number} [sendBytesMax] Maximum message size sent */
+    this.sendBytesMax = undefined;
+
+    /** @type {string} [sendTypes] Comma-separated list of message types sent */
+    this.sendTypes = undefined;
+
+    // Close metrics
+    /** @type {number} [closedAt] Timestamp when connection closed */
+    this.closedAt = undefined;
+
+    /** @type {number} [closeCode] WebSocket close code */
+    this.closeCode = undefined;
+
+    /** @type {string} [closeReason] WebSocket close reason */
+    this.closeReason = undefined;
+
+    /** @type {boolean} [closeWasClean] Whether the connection closed cleanly */
+    this.closeWasClean = undefined;
+
+    /** @type {number} [connectedDuration] Duration of the connection in milliseconds */
+    this.connectedDuration = undefined;
+
+    // Error tracking
+    /** @type {boolean} [hasErrors] Whether any errors occurred */
+    this.hasErrors = undefined;
+  }
 }

package/dist/cjs/features/generic_events/aggregate/index.js

@@ -39,7 +39,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
         if (_constants.RESERVED_EVENT_TYPES.includes(eventType)) return (0, _console.warn)(46);
         this.addEvent({
           eventType,
-          timestamp: this.toEpoch(timestamp),
+          timestamp: this.#toEpoch(timestamp),
           ...attributes
         }, target);
       }, this.featureName, this.ee);
@@ -48,7 +48,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
           this.addEvent({
             ...attributes,
             eventType: 'PageAction',
-            timestamp: this.toEpoch(timestamp),
+            timestamp: this.#toEpoch(timestamp),
             timeSinceLoad: timestamp / 1000,
             actionName: name,
             referrerUrl: this.referrerUrl,
@@ -75,7 +75,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
               } = aggregatedUserAction.event;
               const userActionEvent = {
                 eventType: 'UserAction',
-                timestamp: this.toEpoch(timeStamp),
+                timestamp: this.#toEpoch(timeStamp),
                 action: type,
                 actionCount: aggregatedUserAction.count,
                 actionDuration: aggregatedUserAction.relativeMs[aggregatedUserAction.relativeMs.length - 1],
@@ -161,7 +161,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
                     this.addEvent({
                       ...detailObj,
                       eventType: 'BrowserPerformance',
-                      timestamp: this.toEpoch(entry.startTime),
+                      timestamp: this.#toEpoch(entry.startTime),
                       entryName: entry.name,
                       entryDuration: entry.duration,
                       entryType: type
@@ -227,7 +227,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
             const event = {
               ...entryObject,
               eventType: 'BrowserPerformance',
-              timestamp: Math.floor(agentRef.runtime.timeKeeper.correctRelativeTimestamp(entryObject.startTime)),
+              timestamp: this.#toEpoch(entryObject.startTime),
               entryName: (0, _cleanUrl.cleanURL)(name),
               entryDuration: duration,
               firstParty
@@ -247,13 +247,29 @@ class Aggregate extends _aggregateBase.AggregateBase {
         const event = {
           ...customAttributes,
           eventType: 'BrowserPerformance',
-          timestamp: Math.floor(agentRef.runtime.timeKeeper.correctRelativeTimestamp(start)),
+          timestamp: this.#toEpoch(start),
           entryName: n,
           entryDuration: duration,
           entryType: 'measure'
         };
         this.addEvent(event, target);
       }, this.featureName, this.ee);
+      if (agentRef.init.feature_flags.includes('websockets')) {
+        (0, _registerHandler.registerHandler)('ws-complete', nrData => {
+          const event = {
+            ...nrData,
+            eventType: 'WebSocket',
+            timestamp: this.#toEpoch(nrData.timestamp),
+            openedAt: this.#toEpoch(nrData.openedAt),
+            closedAt: this.#toEpoch(nrData.closedAt)
+          };
+
+          // Report supportability metrics for WebSocket completion
+          this.reportSupportabilityMetric('WebSocket/Completed/Seen');
+          this.reportSupportabilityMetric('WebSocket/Completed/Bytes', (0, _stringify.stringify)(event).length);
+          this.addEvent(event);
+        }, this.featureName, this.ee);
+      }
       this.drain();
     });
   }
@@ -284,7 +300,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
     const defaultEventAttributes = {
       /** should be overridden by the event-specific attributes, but just in case -- set it to now() */
-      timestamp: Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp((0, _now.now)())),
+      timestamp: this.#toEpoch((0, _now.now)()),
       /** all generic events require pageUrl(s) */
       pageUrl: (0, _cleanUrl.cleanURL)('' + _runtime.initialLocation),
       currentUrl: (0, _cleanUrl.cleanURL)('' + location),
@@ -312,7 +328,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       at: this.agentRef.info.atts
     };
   }
-  toEpoch(timestamp) {
+  #toEpoch(timestamp) {
     return Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(timestamp));
   }
   #trackSupportabilityMetrics() {

package/dist/cjs/features/generic_events/instrument/index.js

@@ -21,6 +21,7 @@ var _wrapFetch = require("../../../common/wrap/wrap-fetch");
 var _wrapXhr = require("../../../common/wrap/wrap-xhr");
 var _parseUrl = require("../../../common/url/parse-url");
 var _extractUrl = require("../../../common/url/extract-url");
+var _wrapWebsocket = require("../../../common/wrap/wrap-websocket");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); } /**
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -29,8 +30,11 @@ class Instrument extends _instrumentBase.InstrumentBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, _constants.FEATURE_NAME);
+    const websocketsEnabled = agentRef.init.feature_flags.includes('websockets');
+    const ufEnabled = agentRef.init.feature_flags.includes('user_frustrations');
+
     /** config values that gate whether the generic events aggregator should be imported at all */
-    const genericEventSourceConfigs = [agentRef.init.page_action.enabled, agentRef.init.performance.capture_marks, agentRef.init.performance.capture_measures, agentRef.init.user_actions.enabled, agentRef.init.performance.resources.enabled];
+    const genericEventSourceConfigs = [agentRef.init.page_action.enabled, agentRef.init.performance.capture_marks, agentRef.init.performance.capture_measures, agentRef.init.performance.resources.enabled, agentRef.init.user_actions.enabled, websocketsEnabled];
 
     /** feature specific APIs */
     (0, _addPageAction.setupAddPageActionAPI)(agentRef);
@@ -38,13 +42,13 @@ class Instrument extends _instrumentBase.InstrumentBase {
     (0, _finished.setupFinishedAPI)(agentRef);
     (0, _register.setupRegisterAPI)(agentRef);
     (0, _measure.setupMeasureAPI)(agentRef);
-    const ufEnabled = agentRef.init.feature_flags.includes('user_frustrations');
-    let historyEE;
+    let historyEE, websocketsEE;
     if (_runtime.isBrowserScope && ufEnabled) {
       (0, _wrapFetch.wrapFetch)(this.ee);
       (0, _wrapXhr.wrapXhr)(this.ee);
       historyEE = (0, _wrapHistory.wrapHistory)(this.ee);
     }
+    if (websocketsEnabled) websocketsEE = (0, _wrapWebsocket.wrapWebSocket)(this.ee);
     if (_runtime.isBrowserScope) {
       if (agentRef.init.user_actions.enabled) {
         _constants.OBSERVED_EVENTS.forEach(eventType => (0, _eventListenerOpts.windowAddEventListener)(eventType, evt => (0, _handle.handle)('ua', [evt], undefined, this.featureName, this.ee), true));
@@ -102,6 +106,12 @@ class Instrument extends _instrumentBase.InstrumentBase {
         });
       }
     }
+    if (websocketsEnabled) {
+      // this can apply outside browser scope such as in worker
+      websocketsEE.on('ws', nrData => {
+        (0, _handle.handle)('ws-complete', [nrData], undefined, this.featureName, this.ee);
+      });
+    }
     try {
       this.removeOnAbort = new AbortController();
     } catch (e) {}

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

@@ -184,10 +184,13 @@ class Aggregate extends _aggregateBase.AggregateBase {
     if (this.shouldAllowMainAgentToCapture(target)) (0, _handle.handle)('trace-jserror', jsErrorEvent, undefined, _features.FEATURE_NAMES.sessionTrace, this.ee);
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return;
-    if (err?.__newrelic?.[this.agentIdentifier]) {
+    if (err.__newrelic?.[this.agentIdentifier]) {
       params._interactionId = err.__newrelic[this.agentIdentifier].interactionId;
       params._interactionNodeId = err.__newrelic[this.agentIdentifier].interactionNodeId;
     }
+    if (err.__newrelic?.socketId) {
+      customAttributes.socketId = err.__newrelic.socketId;
+    }
     if (this.shouldAllowMainAgentToCapture(target)) {
       const softNavInUse = Boolean(this.agentRef.features?.[_features.FEATURE_NAMES.softNav]);
       // Note: the following are subject to potential race cond wherein if the other feature aren't fully initialized, it'll be treated as there being no associated interaction.

package/dist/cjs/features/metrics/aggregate/index.js

@@ -150,12 +150,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
     // webdriver detection
     if (navigator.webdriver) this.storeSupportabilityMetrics('Generic/WebDriver/Detected');
 
-    // WATCHABLE_WEB_SOCKET_EVENTS.forEach(tag => {
-    //   registerHandler('buffered-' + WEBSOCKET_TAG + tag, (...args) => {
-    //     handleWebsocketEvents(this.storeSupportabilityMetrics.bind(this), tag, ...args)
-    //   }, this.featureName, this.ee)
-    // })
-
     /** 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 */
     (0, _registerHandler.registerHandler)('harvest-metadata', (harvestMetadataObject = {}) => {
       try {

package/dist/cjs/features/metrics/constants.js

@@ -3,8 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.WATCHABLE_WEB_SOCKET_EVENTS = exports.SUPPORTABILITY_METRIC_CHANNEL = exports.SUPPORTABILITY_METRIC = exports.FEATURE_NAME = exports.CUSTOM_METRIC_CHANNEL = exports.CUSTOM_METRIC = void 0;
-var _wrapWebsocket = require("../../common/wrap/wrap-websocket");
+exports.SUPPORTABILITY_METRIC_CHANNEL = exports.SUPPORTABILITY_METRIC = exports.FEATURE_NAME = exports.CUSTOM_METRIC_CHANNEL = exports.CUSTOM_METRIC = void 0;
 var _features = require("../../loaders/features/features");
 /**
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
@@ -15,5 +14,4 @@ const FEATURE_NAME = exports.FEATURE_NAME = _features.FEATURE_NAMES.metrics;
 const SUPPORTABILITY_METRIC = exports.SUPPORTABILITY_METRIC = 'sm';
 const CUSTOM_METRIC = exports.CUSTOM_METRIC = 'cm';
 const SUPPORTABILITY_METRIC_CHANNEL = exports.SUPPORTABILITY_METRIC_CHANNEL = 'storeSupportabilityMetrics';
-const CUSTOM_METRIC_CHANNEL = exports.CUSTOM_METRIC_CHANNEL = 'storeEventMetrics';
-const WATCHABLE_WEB_SOCKET_EVENTS = exports.WATCHABLE_WEB_SOCKET_EVENTS = ['new', 'send', 'close', _wrapWebsocket.ADD_EVENT_LISTENER_TAG];
+const CUSTOM_METRIC_CHANNEL = exports.CUSTOM_METRIC_CHANNEL = 'storeEventMetrics';

package/dist/cjs/features/metrics/instrument/index.js

@@ -12,21 +12,10 @@ function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-// import { handle } from '../../../common/event-emitter/handle'
-// import { WEBSOCKET_TAG, wrapWebSocket } from '../../../common/wrap/wrap-websocket'
-
 class Instrument extends _instrumentBase.InstrumentBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, _constants.FEATURE_NAME);
-    // wrapWebSocket(this.ee) - feb'25 : removing wrapping again to avoid integration issues
-
-    // WATCHABLE_WEB_SOCKET_EVENTS.forEach((suffix) => {
-    //   this.ee.on(WEBSOCKET_TAG + suffix, (...args) => {
-    //     handle('buffered-' + WEBSOCKET_TAG + suffix, [...args], undefined, this.featureName, this.ee)
-    //   })
-    // })
-
     if (_runtime.isBrowserScope) {
       document.addEventListener('securitypolicyviolation', e => {
         (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['Generic/CSPViolation/Detected'], undefined, this.featureName, this.ee);

package/dist/cjs/features/page_view_timing/instrument/index.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", {
 exports.PageViewTiming = exports.Instrument = void 0;
 var _handle = require("../../../common/event-emitter/handle");
 var _pageVisibility = require("../../../common/window/page-visibility");
-var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
 var _instrumentBase = require("../../utils/instrument-base");
 var _constants = require("../constants");
 var _runtime = require("../../../common/constants/runtime");
@@ -25,7 +24,7 @@ class Instrument extends _instrumentBase.InstrumentBase {
     (0, _pageVisibility.subscribeToVisibilityChange)(() => (0, _handle.handle)('docHidden', [(0, _now.now)()], undefined, _constants.FEATURE_NAME, this.ee), true);
 
     // Window fires its pagehide event (typically on navigation--this occurrence is a *subset* of vis change); don't defer this unless it's guarantee it cannot happen before load(?)
-    (0, _eventListenerOpts.windowAddEventListener)('pagehide', () => (0, _handle.handle)('winPagehide', [(0, _now.now)()], undefined, _constants.FEATURE_NAME, this.ee));
+    (0, _pageVisibility.subscribeToPageUnload)(() => (0, _handle.handle)('winPagehide', [(0, _now.now)()], undefined, _constants.FEATURE_NAME, this.ee));
     this.importAggregator(agentRef, () => Promise.resolve().then(() => _interopRequireWildcard(require(/* webpackChunkName: "page_view_timing-aggregate" */'../aggregate'))));
   }
 }

package/dist/cjs/features/session_replay/shared/recorder.js

@@ -133,7 +133,8 @@ class Recorder {
         inlineImages: inline_images,
         collectFonts: collect_fonts,
         checkoutEveryNms: _constants.CHECKOUT_MS[mode],
-        recordAfter: 'DOMContentLoaded'
+        recordAfter: 'DOMContentLoaded',
+        slimDOMOptions: 'all'
       });
     } catch (err) {
       this.ee.emit('internal-error', [err]);