@newrelic/browser-agent 1.281.0 → 1.283.0

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

@@ -27,51 +27,35 @@ export function wrapWebSocket (sharedEE) {
     }
   }
 
-  Object.defineProperty(WrappedWebSocket, 'name', {
-    value: 'WebSocket'
-  })
-
-  function WrappedWebSocket () {
-    const ws = new originals.WS(...arguments)
-    const socketId = generateRandomHexString(6)
-    const report = reporter(socketId)
-    report('new')
-
-    const events = ['message', 'error', 'open', 'close']
-    /** add event listeners */
-    events.forEach(evt => {
-      ws.addEventListener(evt, function (e) {
-        report(ADD_EVENT_LISTENER_TAG, { eventType: evt, event: e })
+  class WrappedWebSocket extends WebSocket {
+    static name = 'WebSocket'
+
+    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 })
+        })
       })
-    })
-
-    /** could also observe the on-events for runtime processing, but not implemented yet */
-
-    /** observe the static method send, but noteably not close, as that is currently observed with the event listener */
-    ;['send'].forEach(wrapStaticProperty)
+    }
 
-    function wrapStaticProperty (prop) {
-      const originalProp = ws[prop]
-      if (originalProp) {
-        Object.defineProperty(proxiedProp, 'name', {
-          value: prop
-        })
-        function proxiedProp () {
-          report(prop, ...arguments)
-          try {
-            return originalProp.apply(this, arguments)
-          } catch (err) {
-            report(prop + '-err', ...arguments)
-            // rethrow error so we don't effect execution by observing.
-            throw err
-          }
-        }
-        ws[prop] = proxiedProp
+    send (...args) {
+      this.report('send', ...args)
+      try {
+        return super.send(...args)
+      } catch (err) {
+        this.report('send-err', ...args)
+        throw err
       }
     }
-
-    return ws
   }
+
   globalScope.WebSocket = WrappedWebSocket
   return sharedEE
 }

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

@@ -8,20 +8,47 @@ import { warn } from '../../../common/util/console'
 import { stringify } from '../../../common/util/stringify'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 import { AggregateBase } from '../../utils/aggregate-base'
-import { FEATURE_NAME, LOGGING_EVENT_EMITTER_CHANNEL, LOG_LEVELS } from '../constants'
+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 { MAX_PAYLOAD_SIZE } from '../../../common/constants/agent-constants'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
+import { SESSION_EVENT_TYPES, SESSION_EVENTS } from '../../../common/session/constants'
+import { ABORT_REASONS } from '../../session_replay/constants'
+import { canEnableSessionTracking } from '../../utils/feature-gates'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
   constructor (agentRef) {
     super(agentRef, FEATURE_NAME)
+    this.isSessionTrackingEnabled = canEnableSessionTracking(this.agentIdentifier) && this.agentRef.runtime.session
+
+    // 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)
+    })
+
+    this.ee.on(SESSION_EVENTS.UPDATE, (type, data) => {
+      if (this.blocked || type !== SESSION_EVENT_TYPES.CROSS_TAB) return
+      if (this.mode !== LOGGING_MODE.OFF && data.loggingMode === LOGGING_MODE.OFF) this.abort(ABORT_REASONS.CROSS_TAB)
+      else this.mode = data.loggingMode
+    })
+
     this.harvestOpts.raw = true
+    this.waitForFlags(['log']).then(([loggingMode]) => {
+      const session = this.agentRef.runtime.session ?? {}
+      if (this.loggingMode === LOGGING_MODE.OFF || (session.isNew && loggingMode === LOGGING_MODE.OFF)) {
+        this.blocked = true
+        this.deregisterDrain()
+        return
+      }
+      if (session.isNew || !this.isSessionTrackingEnabled) {
+        this.updateLoggingMode(loggingMode)
+      } else {
+        this.loggingMode = session.state.loggingMode
+      }
 
-    this.waitForFlags([]).then(() => {
       /** emitted by instrument class (wrapped loggers) or the api methods directly */
       registerHandler(LOGGING_EVENT_EMITTER_CHANNEL, this.handleLog.bind(this), this.featureName, this.ee)
       this.drain()
@@ -30,12 +57,20 @@ export class Aggregate extends AggregateBase {
     })
   }
 
+  updateLoggingMode (loggingMode) {
+    this.loggingMode = loggingMode
+    this.syncWithSessionManager({
+      loggingMode: this.loggingMode
+    })
+  }
+
   handleLog (timestamp, message, attributes = {}, level = LOG_LEVELS.INFO) {
-    if (this.blocked) return
+    if (this.blocked || !this.loggingMode) return
 
     if (!attributes || typeof attributes !== 'object') attributes = {}
     if (typeof level === 'string') level = level.toUpperCase()
     if (!isValidLogLevel(level)) return warn(30, level)
+    if (this.loggingMode < (LOGGING_MODE[level] || Infinity)) return
 
     try {
       if (typeof message !== 'string') {
@@ -99,7 +134,9 @@ export class Aggregate extends AggregateBase {
           // The following 3 attributes are evaluated and dropped at ingest processing time and do not get stored on NRDB:
           'instrumentation.provider': 'browser',
           'instrumentation.version': this.agentRef.runtime.version,
-          'instrumentation.name': this.agentRef.runtime.loaderType
+          'instrumentation.name': this.agentRef.runtime.loaderType,
+          // Custom attributes
+          ...this.agentRef.info.jsAttributes
         }
       },
       /** logs section contains individual unique log entries */
@@ -113,4 +150,20 @@ export class Aggregate extends AggregateBase {
   queryStringsBuilder () {
     return { browser_monitoring_key: this.agentRef.info.licenseKey }
   }
+
+  /** Abort the feature, once aborted it will not resume */
+  abort (reason = {}) {
+    handle(SUPPORTABILITY_METRIC_CHANNEL, [`Logging/Abort/${reason.sm}`], undefined, FEATURE_NAMES.logging, this.ee)
+    this.blocked = true
+    this.events.clear()
+    this.events.clearSave()
+    this.updateLoggingMode(LOGGING_MODE.OFF)
+    this.deregisterDrain()
+  }
+
+  syncWithSessionManager (state = {}) {
+    if (this.isSessionTrackingEnabled) {
+      this.agentRef.runtime.session.write(state)
+    }
+  }
 }

package/src/features/logging/constants.js

@@ -12,6 +12,15 @@ export const LOG_LEVELS = {
   TRACE: 'TRACE'
 }
 
+export const LOGGING_MODE = {
+  OFF: 0,
+  ERROR: 1,
+  WARN: 2,
+  INFO: 3,
+  DEBUG: 4,
+  TRACE: 5
+}
+
 export const LOGGING_EVENT_EMITTER_CHANNEL = 'log'
 
 export const FEATURE_NAME = FEATURE_NAMES.logging

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

@@ -5,6 +5,8 @@
 import { InstrumentBase } from '../../utils/instrument-base'
 import { FEATURE_NAME } from '../constants'
 import { bufferLog } from '../shared/utils'
+import { wrapLogger } from '../../../common/wrap/wrap-logger'
+import { globalScope } from '../../../common/constants/runtime'
 
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME
@@ -12,6 +14,12 @@ export class Instrument extends InstrumentBase {
     super(agentRef, FEATURE_NAME, auto)
 
     const instanceEE = this.ee
+    wrapLogger(instanceEE, globalScope.console, 'log', { level: 'info' })
+    wrapLogger(instanceEE, globalScope.console, 'error', { level: 'error' })
+    wrapLogger(instanceEE, globalScope.console, 'warn', { level: 'warn' })
+    wrapLogger(instanceEE, globalScope.console, 'info', { level: 'info' })
+    wrapLogger(instanceEE, globalScope.console, 'debug', { level: 'debug' })
+    wrapLogger(instanceEE, globalScope.console, 'trace', { level: 'trace' })
     /** emitted by wrap-logger function */
     this.ee.on('wrap-logger-end', function handleLog ([message]) {
       const { level, customAttributes } = this

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

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { registerHandler } from '../../../common/event-emitter/register-handler'
-import { FEATURE_NAME, SUPPORTABILITY_METRIC, CUSTOM_METRIC, SUPPORTABILITY_METRIC_CHANNEL, CUSTOM_METRIC_CHANNEL/*, WATCHABLE_WEB_SOCKET_EVENTS */ } from '../constants'
+import { FEATURE_NAME, SUPPORTABILITY_METRIC, CUSTOM_METRIC, SUPPORTABILITY_METRIC_CHANNEL, CUSTOM_METRIC_CHANNEL, WATCHABLE_WEB_SOCKET_EVENTS } from '../constants'
 import { getFrameworks } from './framework-detection'
 import { isFileProtocol } from '../../../common/url/protocol'
 import { onDOMContentLoaded } from '../../../common/window/load'
@@ -11,8 +11,8 @@ import { windowAddEventListener } from '../../../common/event-listener/event-lis
 import { isBrowserScope, isWorkerScope } from '../../../common/constants/runtime'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { isIFrameWindow } from '../../../common/dom/iframe'
-// import { WEBSOCKET_TAG } from '../../../common/wrap/wrap-websocket'
-// import { handleWebsocketEvents } from './websocket-detection'
+import { WEBSOCKET_TAG } from '../../../common/wrap/wrap-websocket'
+import { handleWebsocketEvents } from './websocket-detection'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
@@ -116,11 +116,11 @@ export class Aggregate extends AggregateBase {
       mo.observe(window.document.body, { childList: true, subtree: true })
     }
 
-    // WATCHABLE_WEB_SOCKET_EVENTS.forEach(tag => {
-    //   registerHandler('buffered-' + WEBSOCKET_TAG + tag, (...args) => {
-    //     handleWebsocketEvents(this.storeSupportabilityMetrics.bind(this), tag, ...args)
-    //   }, this.featureName, this.ee)
-    // })
+    WATCHABLE_WEB_SOCKET_EVENTS.forEach(tag => {
+      registerHandler('buffered-' + WEBSOCKET_TAG + tag, (...args) => {
+        handleWebsocketEvents(this.storeSupportabilityMetrics.bind(this), tag, ...args)
+      }, this.featureName, this.ee)
+    })
   }
 
   eachSessionChecks () {

package/src/features/metrics/constants.js

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-// import { ADD_EVENT_LISTENER_TAG } from '../../common/wrap/wrap-websocket'
+import { ADD_EVENT_LISTENER_TAG } from '../../common/wrap/wrap-websocket'
 import { FEATURE_NAMES } from '../../loaders/features/features'
 
 export const FEATURE_NAME = FEATURE_NAMES.metrics
@@ -12,4 +12,4 @@ 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 WATCHABLE_WEB_SOCKET_EVENTS = ['new', 'send', 'close', ADD_EVENT_LISTENER_TAG]

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

@@ -3,22 +3,22 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-// import { handle } from '../../../common/event-emitter/handle'
-// import { WEBSOCKET_TAG, wrapWebSocket } from '../../../common/wrap/wrap-websocket'
+import { handle } from '../../../common/event-emitter/handle'
+import { WEBSOCKET_TAG, wrapWebSocket } from '../../../common/wrap/wrap-websocket'
 import { InstrumentBase } from '../../utils/instrument-base'
-import { FEATURE_NAME/*, WATCHABLE_WEB_SOCKET_EVENTS */ } from '../constants'
+import { FEATURE_NAME, WATCHABLE_WEB_SOCKET_EVENTS } from '../constants'
 
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME
   constructor (agentRef, auto = true) {
     super(agentRef, FEATURE_NAME, auto)
-    // wrapWebSocket(this.ee)
+    wrapWebSocket(this.ee)
 
-    // WATCHABLE_WEB_SOCKET_EVENTS.forEach((suffix) => {
-    //   this.ee.on(WEBSOCKET_TAG + suffix, (...args) => {
-    //     handle('buffered-' + WEBSOCKET_TAG + suffix, [...args], undefined, this.featureName, this.ee)
-    //   })
-    // })
+    WATCHABLE_WEB_SOCKET_EVENTS.forEach((suffix) => {
+      this.ee.on(WEBSOCKET_TAG + suffix, (...args) => {
+        handle('buffered-' + WEBSOCKET_TAG + suffix, [...args], undefined, this.featureName, this.ee)
+      })
+    })
 
     this.importAggregator(agentRef)
   }

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

@@ -24,6 +24,7 @@ import { now } from '../../../common/timing/now'
 import { buildNRMetaNode } from '../shared/utils'
 import { MAX_PAYLOAD_SIZE } from '../../../common/constants/agent-constants'
 import { cleanURL } from '../../../common/url/clean-url'
+import { canEnableSessionTracking } from '../../utils/feature-gates'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
@@ -50,6 +51,8 @@ export class Aggregate extends AggregateBase {
     this.errorNoticed = args?.errorNoticed || false
     this.harvestOpts.raw = true
 
+    this.isSessionTrackingEnabled = canEnableSessionTracking(this.agentIdentifier) && this.agentRef.runtime.session
+
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/Enabled'], undefined, FEATURE_NAMES.metrics, this.ee)
 
     // 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.
@@ -71,7 +74,7 @@ export class Aggregate extends AggregateBase {
     this.ee.on(SESSION_EVENTS.UPDATE, (type, data) => {
       if (!this.recorder || !this.initialized || this.blocked || type !== SESSION_EVENT_TYPES.CROSS_TAB) return
       if (this.mode !== MODE.OFF && data.sessionReplayMode === MODE.OFF) this.abort(ABORT_REASONS.CROSS_TAB)
-      this.mode = data.sessionReplay
+      this.mode = data.sessionReplayMode
     })
 
     registerHandler(SR_EVENT_EMITTER_TYPES.PAUSE, () => {
@@ -142,7 +145,7 @@ export class Aggregate extends AggregateBase {
 
   /**
    * Evaluate entitlements and sampling before starting feature mechanics, importing and configuring recording library, and setting storage state
-   * @param {boolean} entitlements - the true/false state of the "sr" flag from RUM response
+   * @param {boolean} srMode - the true/false state of the "sr" flag (aka. entitlements) from RUM response
    * @param {boolean} ignoreSession - whether to force the method to ignore the session state and use just the sample flags
    * @returns {void}
    */
@@ -373,6 +376,8 @@ export class Aggregate extends AggregateBase {
   }
 
   syncWithSessionManager (state = {}) {
-    this.agentRef.runtime.session.write(state)
+    if (this.isSessionTrackingEnabled) {
+      this.agentRef.runtime.session.write(state)
+    }
   }
 }

package/src/features/utils/aggregate-base.js

@@ -74,6 +74,10 @@ export class AggregateBase extends FeatureBase {
     this.drained = true
   }
 
+  preHarvestChecks (opts) {
+    return !this.blocked
+  }
+
   /**
    * Return harvest payload. A "serializer" function can be defined on a derived class to format the payload.
    * @param {Boolean} shouldRetryOnFail - harvester flag to backup payload for retry later if harvest request fails; this should be moved to harvester logic

package/src/loaders/agent.js

@@ -19,13 +19,24 @@ import { gosNREUM, setNREUMInitializedAgent } from '../common/window/nreum'
 import { warn } from '../common/util/console'
 import { globalScope } from '../common/constants/runtime'
 
+/**
+ * @typedef {Object} AgentOptions
+ * @property {import('../common/config/info').Info} info - An object containing operational info needed by the agent. It's strongly encouraged to define this.
+ * @property {import('../common/config/init').Init} [init] - An object containing initialization configurations for the agent.
+ * @property {Object} [loader_config] - An object containing configuration primarily passed by APM injection. This is not recommended for use if not already provided by installation.
+ * @property {Object} [runtime] - An object containing runtime references by the agent. This is not recommended for use.
+ * @property {Array<Object>} [features] - A list of feature modules to include in the agent. This is only necessary when using the `Agent` class strictly.
+ * @property {boolean} [exposed] - Whether the agent should expose its API to (be affected by) the global `newrelic` object.
+ * @property {string} [loaderType] - The type of loader that is initializing the agent. It's recommended to allow the default.
+ */
+
 /**
  * A flexible class that may be used to compose an agent from a select subset of feature modules. In applications
  * sensitive to network load, this may result in smaller builds with slightly lower performance impact.
  */
 export class Agent extends AgentBase {
   /**
-   * @param {Object} options Options to initialize agent with
+   * @param {AgentOptions} options
    */
   constructor (options) {
     super()

package/src/loaders/browser-agent.js

@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Agent } from './agent'
-
 import { Instrument as InstrumentPageViewEvent } from '../features/page_view_event/instrument'
 import { Instrument as InstrumentPageViewTiming } from '../features/page_view_timing/instrument'
 import { Instrument as InstrumentMetrics } from '../features/metrics/instrument'
@@ -21,9 +20,12 @@ import { Instrument as InstrumentSoftNav } from '../features/soft_navigations/in
  * The BrowserAgent class is the most convenient and reliable option for most use cases.
  */
 export class BrowserAgent extends Agent {
-  constructor (args) {
+  /**
+   * @param {import('./agent').AgentOptions} options
+   */
+  constructor (options) {
     super({
-      ...args,
+      ...options,
       features: [
         InstrumentXhr,
         InstrumentPageViewEvent,

package/src/loaders/micro-agent.js

@@ -27,7 +27,7 @@ const nonAutoFeatures = [
  */
 export class MicroAgent extends MicroAgentBase {
   /**
-   * @param {Object} options - Specifies features and runtime configuration,
+   * @param {import('./agent').AgentOptions} options
    */
   constructor (options) {
     super()