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

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

@@ -278,7 +278,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
 }
 exports.Aggregate = Aggregate;
 function getActionText(elem) {
-  const tagName = elem.tagName.toLowerCase();
+  const tagName = elem.tagName?.toLowerCase();
   const elementsOfInterest = ['a', 'button', 'input'];
   if (elementsOfInterest.includes(tagName)) {
     return elem.title || elem.value || elem.innerText;

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

@@ -62,6 +62,7 @@ class Instrument extends _instrumentBase.InstrumentBase {
       });
     });
     const processUserInteraction = (0, _invoke.debounce)(event => {
+      if (document.readyState === 'loading') return; // document.body is not expected to be defined yet during loading, so only "interactive" or "complete" is considered "legit" user interaction
       (0, _handle.handle)('newUIEvent', [event], undefined, this.featureName, this.ee);
       domObserver.observe(document.body, {
         attributes: true,

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

@@ -628,7 +628,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }, this.featureName, baseEE);
     baseEE.on('interaction', saveInteraction);
     function getActionText(node) {
-      var nodeType = node.tagName.toLowerCase();
+      var nodeType = node.tagName?.toLowerCase();
       var goodNodeTypes = ['a', 'button', 'input'];
       var isGoodNode = goodNodeTypes.indexOf(nodeType) !== -1;
       if (isGoodNode) {

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

@@ -145,7 +145,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/esm/common/constants/env.cdn.js

@@ -11,7 +11,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.303.0";
+export const VERSION = "1.304.0-rc.1";
 
 /**
  * Exposes the build type of the agent

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

@@ -11,7 +11,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.303.0";
+export const VERSION = "1.304.0-rc.1";
 
 /**
  * Exposes the build type of the agent

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

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

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

@@ -13,9 +13,11 @@ const checked = new Map();
 export 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) {
-      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) {
+      warn(64, fn?.name || fnString);
     }
     checked.set(fn, isNative);
     return isNative;

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

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { documentAddEventListener } from '../event-listener/event-listener-opts';
+import { documentAddEventListener, windowAddEventListener } from '../event-listener/event-listener-opts';
 
 /**
  * @param {function} cb - called when a visibility change occurs with the vis state at that time
@@ -20,4 +20,7 @@ export function subscribeToVisibilityChange(cb, toHiddenOnly = false, capture, a
     }
     cb(document.visibilityState);
   }
+}
+export function subscribeToPageUnload(cb, capture, abortSignal) {
+  windowAddEventListener('pagehide', cb, capture, abortSignal);
 }

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

@@ -3,53 +3,284 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { globalScope } from '../constants/runtime';
-import { now } from '../timing/now';
-import { checkState } from '../window/load';
 import { generateRandomHexString } from '../ids/unique-id';
+import { now } from '../timing/now';
 import { gosNREUMOriginals } from '../window/nreum';
-export const WEBSOCKET_TAG = 'websocket-';
-export const ADD_EVENT_LISTENER_TAG = 'addEventListener';
+import { subscribeToPageUnload } from '../window/page-visibility';
 const wrapped = {};
+const openWebSockets = new Set(); // track all instances to close out metrics on page unload
+
 export function wrapWebSocket(sharedEE) {
-  if (wrapped[sharedEE.debugId]++) return sharedEE;
   const originals = gosNREUMOriginals().o;
   if (!originals.WS) return sharedEE;
-  function reporter(socketId) {
-    const createdAt = now();
-    return function (message, ...data) {
-      const timestamp = data[0]?.timeStamp || now();
-      const isLoaded = 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
+  subscribeToPageUnload(() => {
+    const unloadTime = 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 = 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 = 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 = 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);
+      });
+    }
+    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(data);
+      } catch (error) {
+        this.#tagError(error);
+        throw error;
+      }
     }
-    send(...args) {
-      this.report('send', ...args);
+    close(...args) {
       try {
-        return super.send(...args);
-      } catch (err) {
-        this.report('send-err', ...args);
-        throw err;
+        super.close(...args);
+      } catch (error) {
+        this.#tagError(error);
+        throw error;
       }
     }
   }
   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 = 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 = 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/esm/features/generic_events/aggregate/index.js

@@ -32,7 +32,7 @@ export class Aggregate extends AggregateBase {
         if (RESERVED_EVENT_TYPES.includes(eventType)) return warn(46);
         this.addEvent({
           eventType,
-          timestamp: this.toEpoch(timestamp),
+          timestamp: this.#toEpoch(timestamp),
           ...attributes
         }, target);
       }, this.featureName, this.ee);
@@ -41,7 +41,7 @@ export class Aggregate extends AggregateBase {
           this.addEvent({
             ...attributes,
             eventType: 'PageAction',
-            timestamp: this.toEpoch(timestamp),
+            timestamp: this.#toEpoch(timestamp),
             timeSinceLoad: timestamp / 1000,
             actionName: name,
             referrerUrl: this.referrerUrl,
@@ -68,7 +68,7 @@ export class Aggregate extends 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],
@@ -154,7 +154,7 @@ export class Aggregate extends AggregateBase {
                     this.addEvent({
                       ...detailObj,
                       eventType: 'BrowserPerformance',
-                      timestamp: this.toEpoch(entry.startTime),
+                      timestamp: this.#toEpoch(entry.startTime),
                       entryName: entry.name,
                       entryDuration: entry.duration,
                       entryType: type
@@ -220,7 +220,7 @@ export class Aggregate extends AggregateBase {
             const event = {
               ...entryObject,
               eventType: 'BrowserPerformance',
-              timestamp: Math.floor(agentRef.runtime.timeKeeper.correctRelativeTimestamp(entryObject.startTime)),
+              timestamp: this.#toEpoch(entryObject.startTime),
               entryName: cleanURL(name),
               entryDuration: duration,
               firstParty
@@ -240,13 +240,29 @@ export class Aggregate extends 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')) {
+        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', stringify(event).length);
+          this.addEvent(event);
+        }, this.featureName, this.ee);
+      }
       this.drain();
     });
   }
@@ -277,7 +293,7 @@ export class Aggregate extends 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(now())),
+      timestamp: this.#toEpoch(now()),
       /** all generic events require pageUrl(s) */
       pageUrl: cleanURL('' + initialLocation),
       currentUrl: cleanURL('' + location),
@@ -305,7 +321,7 @@ export class Aggregate extends AggregateBase {
       at: this.agentRef.info.atts
     };
   }
-  toEpoch(timestamp) {
+  #toEpoch(timestamp) {
     return Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(timestamp));
   }
   #trackSupportabilityMetrics() {

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

@@ -20,12 +20,16 @@ import { wrapFetch } from '../../../common/wrap/wrap-fetch';
 import { wrapXhr } from '../../../common/wrap/wrap-xhr';
 import { parseUrl } from '../../../common/url/parse-url';
 import { extractUrl } from '../../../common/url/extract-url';
+import { wrapWebSocket } from '../../../common/wrap/wrap-websocket';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, 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 */
     setupAddPageActionAPI(agentRef);
@@ -33,13 +37,13 @@ export class Instrument extends InstrumentBase {
     setupFinishedAPI(agentRef);
     setupRegisterAPI(agentRef);
     setupMeasureAPI(agentRef);
-    const ufEnabled = agentRef.init.feature_flags.includes('user_frustrations');
-    let historyEE;
+    let historyEE, websocketsEE;
     if (isBrowserScope && ufEnabled) {
       wrapFetch(this.ee);
       wrapXhr(this.ee);
       historyEE = wrapHistory(this.ee);
     }
+    if (websocketsEnabled) websocketsEE = wrapWebSocket(this.ee);
     if (isBrowserScope) {
       if (agentRef.init.user_actions.enabled) {
         OBSERVED_EVENTS.forEach(eventType => windowAddEventListener(eventType, evt => handle('ua', [evt], undefined, this.featureName, this.ee), true));
@@ -97,6 +101,12 @@ export class Instrument extends InstrumentBase {
         });
       }
     }
+    if (websocketsEnabled) {
+      // this can apply outside browser scope such as in worker
+      websocketsEE.on('ws', nrData => {
+        handle('ws-complete', [nrData], undefined, this.featureName, this.ee);
+      });
+    }
     try {
       this.removeOnAbort = new AbortController();
     } catch (e) {}

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

@@ -179,10 +179,13 @@ export class Aggregate extends AggregateBase {
     if (this.shouldAllowMainAgentToCapture(target)) handle('trace-jserror', jsErrorEvent, undefined, 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?.[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/esm/features/metrics/aggregate/index.js

@@ -143,12 +143,6 @@ export class Aggregate extends 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 */
     registerHandler('harvest-metadata', (harvestMetadataObject = {}) => {
       try {

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

@@ -2,12 +2,9 @@
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import { ADD_EVENT_LISTENER_TAG } from '../../common/wrap/wrap-websocket';
 import { FEATURE_NAMES } from '../../loaders/features/features';
 export const FEATURE_NAME = FEATURE_NAMES.metrics;
 export const SUPPORTABILITY_METRIC = 'sm';
 export const CUSTOM_METRIC = 'cm';
 export const SUPPORTABILITY_METRIC_CHANNEL = 'storeSupportabilityMetrics';
-export const CUSTOM_METRIC_CHANNEL = 'storeEventMetrics';
-export const WATCHABLE_WEB_SOCKET_EVENTS = ['new', 'send', 'close', ADD_EVENT_LISTENER_TAG];
+export const CUSTOM_METRIC_CHANNEL = 'storeEventMetrics';

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

@@ -6,24 +6,11 @@
 import { isBrowserScope } from '../../../common/constants/runtime';
 import { handle } from '../../../common/event-emitter/handle';
 import { InstrumentBase } from '../../utils/instrument-base';
-import { FEATURE_NAME,
-// WATCHABLE_WEB_SOCKET_EVENTS,
-SUPPORTABILITY_METRIC_CHANNEL } from '../constants';
-// import { handle } from '../../../common/event-emitter/handle'
-// import { WEBSOCKET_TAG, wrapWebSocket } from '../../../common/wrap/wrap-websocket'
-
+import { FEATURE_NAME, SUPPORTABILITY_METRIC_CHANNEL } from '../constants';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, 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 (isBrowserScope) {
       document.addEventListener('securitypolicyviolation', e => {
         handle(SUPPORTABILITY_METRIC_CHANNEL, ['Generic/CSPViolation/Detected'], undefined, this.featureName, this.ee);

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

@@ -3,8 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { handle } from '../../../common/event-emitter/handle';
-import { subscribeToVisibilityChange } from '../../../common/window/page-visibility';
-import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts';
+import { subscribeToPageUnload, subscribeToVisibilityChange } from '../../../common/window/page-visibility';
 import { InstrumentBase } from '../../utils/instrument-base';
 import { FEATURE_NAME } from '../constants';
 import { isBrowserScope } from '../../../common/constants/runtime';
@@ -19,7 +18,7 @@ export class Instrument extends InstrumentBase {
     subscribeToVisibilityChange(() => handle('docHidden', [now()], undefined, 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(?)
-    windowAddEventListener('pagehide', () => handle('winPagehide', [now()], undefined, FEATURE_NAME, this.ee));
+    subscribeToPageUnload(() => handle('winPagehide', [now()], undefined, FEATURE_NAME, this.ee));
     this.importAggregator(agentRef, () => import(/* webpackChunkName: "page_view_timing-aggregate" */'../aggregate'));
   }
 }

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

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