@newrelic/browser-agent 1.303.0-rc.8 → 1.303.0-rc.9

package/dist/types/features/generic_events/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/generic_events/aggregate/index.js"],"names":[],"mappings":"AAkBA;IACE,2BAAiC;IAGjC,2BAgOC;IA9NC,gCAAkG;IAiOpG;;;;;;;;;;;;OAYG;IACH,eAJW,MAAM,YAAC,WACP,MAAM,YAAC,QAmCjB;IAED,qCAEC;IAED;;;MAEC;IAED,gCAEC;;CAkBF;8BA5T6B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/generic_events/aggregate/index.js"],"names":[],"mappings":"AAkBA;IACE,2BAAiC;IAGjC,2BAkPC;IAhPC,gCAAkG;IAmPpG;;;;;;;;;;;;OAYG;IACH,eAJW,MAAM,YAAC,WACP,MAAM,YAAC,QAmCjB;IAED,qCAEC;IAED;;;MAEC;;CAsBF;8BA9U6B,4BAA4B"}

package/dist/types/features/generic_events/instrument/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/generic_events/instrument/index.js"],"names":[],"mappings":"AAuBA;IACE,2BAAiC;IACjC,2BAgGC;IAXG,2CAA0C;IAG5C,yBAGC;CAMJ;AAED,8CAAuC;+BA9GR,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/generic_events/instrument/index.js"],"names":[],"mappings":"AAwBA;IACE,2BAAiC;IACjC,2BAyGC;IAXG,2CAA0C;IAG5C,yBAGC;CAMJ;AAED,8CAAuC;+BAxHR,6BAA6B"}

package/dist/types/features/jserrors/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/index.js"],"names":[],"mappings":"AAwBA;;GAEG;AAEH;IACE,2BAAiC;IACjC,2BA4BC;IAvBC,kBAAuB;IACvB,eAAoB;IACpB,qBAA0B;IAC1B,2BAAgC;IAChC,qBAAwB;IAqB1B,oDAEC;IAED;;;MAcC;IAED;;;;;;OAMG;IACH,qCAHW,SAAS,GACP,MAAM,CAgBlB;IAED;;;;;;;;;;OAUG;IACH,gBATW,KAAK,GAAC,aAAa,QACnB,MAAM,aACN,OAAO,YAAC,qBACR,MAAM,YAAC,cACP,OAAO,YAAC,kBACR,MAAM,YAAC,WACP,MAAM,YAAC,QA8GjB;IA+BD;;;;;MAKE;IACF,sCAHU,MAAM,GACJ,OAAO,CAIlB;IAGD,yDA6BC;IAED,8GAWC;;CACF;wBAzRY,OAAO,0BAA0B,EAAE,SAAS;8BAR3B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/index.js"],"names":[],"mappings":"AAwBA;;GAEG;AAEH;IACE,2BAAiC;IACjC,2BA4BC;IAvBC,kBAAuB;IACvB,eAAoB;IACpB,qBAA0B;IAC1B,2BAAgC;IAChC,qBAAwB;IAqB1B,oDAEC;IAED;;;MAcC;IAED;;;;;;OAMG;IACH,qCAHW,SAAS,GACP,MAAM,CAgBlB;IAED;;;;;;;;;;OAUG;IACH,gBATW,KAAK,GAAC,aAAa,QACnB,MAAM,aACN,OAAO,YAAC,qBACR,MAAM,YAAC,cACP,OAAO,YAAC,kBACR,MAAM,YAAC,WACP,MAAM,YAAC,QAiHjB;IA+BD;;;;;MAKE;IACF,sCAHU,MAAM,GACJ,OAAO,CAIlB;IAGD,yDA6BC;IAED,8GAWC;;CACF;wBA5RY,OAAO,0BAA0B,EAAE,SAAS;8BAR3B,4BAA4B"}

package/dist/types/features/metrics/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/metrics/aggregate/index.js"],"names":[],"mappings":"AAiBA;IACE,2BAAiC;IACjC,2BAgCC;IA5BC,uKAAuK;IACvK,oBAAyB;IAWzB,uCAAiE;IAkBnE,iCAAsE;IAEtE,wDAKC;IAED,iDAKC;IAED,qBAgFC;IAED,0BAOC;CACF;8BApJ6B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/metrics/aggregate/index.js"],"names":[],"mappings":"AAiBA;IACE,2BAAiC;IACjC,2BAgCC;IA5BC,uKAAuK;IACvK,oBAAyB;IAWzB,uCAAiE;IAkBnE,iCAAsE;IAEtE,wDAKC;IAED,iDAKC;IAED,qBA0EC;IAED,0BAOC;CACF;8BA9I6B,4BAA4B"}

package/dist/types/features/metrics/constants.d.ts

@@ -3,5 +3,4 @@ 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: string[];
 //# sourceMappingURL=constants.d.ts.map

package/dist/types/features/metrics/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/metrics/constants.js"],"names":[],"mappings":"AAQA,kCAAiD;AACjD,oCAAqC,IAAI,CAAA;AACzC,4BAA6B,IAAI,CAAA;AACjC,4CAA6C,4BAA4B,CAAA;AACzE,oCAAqC,mBAAmB,CAAA;AAExD,mDAA2F"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/metrics/constants.js"],"names":[],"mappings":"AAMA,kCAAiD;AACjD,oCAAqC,IAAI,CAAA;AACzC,4BAA6B,IAAI,CAAA;AACjC,4CAA6C,4BAA4B,CAAA;AACzE,oCAAqC,mBAAmB,CAAA"}

package/dist/types/features/metrics/instrument/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/metrics/instrument/index.js"],"names":[],"mappings":"AAgBA;IACE,2BAAiC;IACjC,2BAiBC;CACF;AAED,wCAAiC;+BA/BF,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/metrics/instrument/index.js"],"names":[],"mappings":"AAaA;IACE,2BAAiC;IACjC,2BAUC;CACF;AAED,wCAAiC;+BArBF,6BAA6B"}

package/dist/types/features/page_view_timing/instrument/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_timing/instrument/index.js"],"names":[],"mappings":"AAYA;IACE,2BAAiC;IACjC,2BAWC;CACF;AAED,+CAAwC;+BArBT,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_timing/instrument/index.js"],"names":[],"mappings":"AAWA;IACE,2BAAiC;IACjC,2BAWC;CACF;AAED,+CAAwC;+BArBT,6BAA6B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.303.0-rc.8",
+  "version": "1.303.0-rc.9",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",

package/src/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
@@ -21,3 +21,7 @@ export function subscribeToVisibilityChange (cb, toHiddenOnly = false, capture,
     cb(document.visibilityState)
   }
 }
+
+export function subscribeToPageUnload (cb, capture, abortSignal) {
+  windowAddEventListener('pagehide', cb, capture, abortSignal)
+}

package/src/common/wrap/wrap-websocket.js

@@ -3,59 +3,277 @@
  * 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 ? `${this.nrData.messageTypes},${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 (...args) {
-      this.report('send', ...args)
+    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 ? `${this.nrData.sendTypes},${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
       }
     }
   }
 
   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/src/features/generic_events/aggregate/index.js

@@ -37,7 +37,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)
@@ -47,7 +47,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,
@@ -72,7 +72,7 @@ export class Aggregate extends AggregateBase {
               const { target, timeStamp, type } = 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],
@@ -149,7 +149,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
@@ -214,7 +214,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
@@ -233,7 +233,7 @@ 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'
@@ -242,6 +242,24 @@ export class Aggregate extends AggregateBase {
         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()
     })
   }
@@ -274,7 +292,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),
@@ -302,7 +320,7 @@ export class Aggregate extends AggregateBase {
     return { ua: this.agentRef.info.userAttributes, at: this.agentRef.info.atts }
   }
 
-  toEpoch (timestamp) {
+  #toEpoch (timestamp) {
     return Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(timestamp))
   }
 

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

@@ -20,18 +20,23 @@ 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.performance.resources.enabled,
       agentRef.init.user_actions.enabled,
-      agentRef.init.performance.resources.enabled
+      websocketsEnabled
     ]
 
     /** feature specific APIs */
@@ -41,13 +46,13 @@ export class Instrument extends InstrumentBase {
     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) {
@@ -106,6 +111,11 @@ export class Instrument extends InstrumentBase {
         observer.observe({ type: 'resource', buffered: true })
       }
     }
+    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()

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

@@ -192,10 +192,13 @@ export class Aggregate extends AggregateBase {
     // 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])

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

@@ -131,12 +131,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/src/features/metrics/constants.js

@@ -2,8 +2,6 @@
  * 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
@@ -11,5 +9,3 @@ 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]

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

@@ -8,23 +8,13 @@ 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'
 
 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) => {

package/src/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'
@@ -20,7 +19,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/cjs/features/metrics/aggregate/websocket-detection.js

@@ -1,39 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.handleWebsocketEvents = handleWebsocketEvents;
-var _dataSize = require("../../../common/util/data-size");
-var _text = require("../../../common/util/text");
-var _wrapWebsocket = require("../../../common/wrap/wrap-websocket");
-/**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * A SM handler for web socket events, which converts them to a shape suitable for SMs and reports them.
- * @param {Function} reporter a function that reports data as a supportability metric
- * @param {string} tag the unique tag to assign to the sm
- * @param {number} timestamp ms from page origin
- * @param {number} timeSinceInit ms from class init
- * @param {boolean} isLoaded whether the even was observed before the page load event
- * @param {string} socketId a unique id assigned to the observed socket
- * @param {*} data the data reported alongside the socket event
- */
-function handleWebsocketEvents(reporter, tag, timestamp, timeSinceInit, isLoaded, socketId, data) {
-  // socketId is unused in the SMs
-  const useDataType = tag === _wrapWebsocket.ADD_EVENT_LISTENER_TAG;
-  let metricTag = (0, _text.toTitleCase)(useDataType ? data.eventType : tag);
-  if (metricTag === 'Close') {
-    if (data?.event.code === 1000 || data?.event.wasClean) metricTag += '-Clean';else metricTag += '-Dirty';
-  }
-  const bytes = metricTag === 'Message' && (0, _dataSize.dataSize)(data?.event?.data) || metricTag === 'Send' && (0, _dataSize.dataSize)(data);
-  reporter(buildSMTag(metricTag, 'Ms'), timestamp);
-  reporter(buildSMTag(metricTag, 'MsSinceClassInit'), timeSinceInit);
-  if (bytes) reporter(buildSMTag(metricTag, 'Bytes'), bytes);
-}
-function buildSMTag(tag, category) {
-  return 'WebSocket/' + tag + '/' + category;
-}