@newrelic/browser-agent 1.263.0 → 1.265.0

package/src/common/window/__mocks__/nreum.js

@@ -3,7 +3,7 @@ export const gosNREUM = jest.fn(() => ({}))
 export const gosNREUMInfo = jest.fn(() => ({}))
 export const gosNREUMLoaderConfig = jest.fn(() => ({}))
 export const gosNREUMInit = jest.fn(() => ({}))
-export const gosNREUMOriginals = jest.fn(() => ({}))
+export const gosNREUMOriginals = jest.fn(() => ({ o: {} }))
 export const setNREUMInitializedAgent = jest.fn()
 export const getNREUMInitializedAgent = jest.fn(() => ({}))
 export const addToNREUM = jest.fn(() => ({}))

package/src/common/window/nreum.js

@@ -61,7 +61,8 @@ export function gosNREUMOriginals () {
       EV: globalScope.Event,
       PR: globalScope.Promise,
       MO: globalScope.MutationObserver, // this'll be undefined if not in a web window
-      FETCH: globalScope.fetch
+      FETCH: globalScope.fetch,
+      WS: globalScope.WebSocket
     }
   }
   return nr

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

@@ -0,0 +1,73 @@
+import { globalScope } from '../constants/runtime'
+import { now } from '../timing/now'
+import { checkState } from '../window/load'
+import { generateRandomHexString } from '../ids/unique-id'
+import { gosNREUMOriginals } from '../window/nreum'
+
+export const WEBSOCKET_TAG = 'websocket-'
+export const ADD_EVENT_LISTENER_TAG = 'addEventListener'
+
+const wrapped = {}
+
+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])
+    }
+  }
+
+  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 })
+      })
+    })
+
+    /** 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
+      }
+    }
+
+    return ws
+  }
+  globalScope.WebSocket = WrappedWebSocket
+  return sharedEE
+}

package/src/features/ajax/aggregate/chunk.js

@@ -1,5 +1,6 @@
 import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer'
-import { getInfo } from '../../../common/config/config'
+import { getInfo } from '../../../common/config/info'
+import { MAX_PAYLOAD_SIZE } from '../../../common/constants/agent-constants'
 
 export default class Chunk {
   constructor (events, aggregateInstance) {
@@ -46,6 +47,6 @@ export default class Chunk {
       this.payload += insert
     }
 
-    this.tooBig = this.payload.length * 2 > aggregateInstance.MAX_PAYLOAD_SIZE
+    this.tooBig = this.payload.length * 2 > MAX_PAYLOAD_SIZE
   }
 }

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

@@ -5,7 +5,9 @@
 import { registerHandler } from '../../../common/event-emitter/register-handler'
 import { stringify } from '../../../common/util/stringify'
 import { handle } from '../../../common/event-emitter/handle'
-import { getConfiguration, getInfo, getRuntime } from '../../../common/config/config'
+import { getInfo } from '../../../common/config/info'
+import { getConfiguration } from '../../../common/config/init'
+import { getRuntime } from '../../../common/config/runtime'
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { setDenyList, shouldCollectEvent } from '../../../common/deny-list/deny-list'
 import { FEATURE_NAME } from '../constants'
@@ -15,6 +17,7 @@ import { AggregateBase } from '../../utils/aggregate-base'
 import { parseGQL } from './gql'
 import { getNREUMInitializedAgent } from '../../../common/window/nreum'
 import Chunk from './chunk'
+import { EventBuffer } from '../../utils/event-buffer'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
@@ -30,26 +33,24 @@ export class Aggregate extends AggregateBase {
     this.#agentInit = getConfiguration(agentIdentifier)
 
     const harvestTimeSeconds = this.#agentInit.ajax.harvestTimeSeconds || 10
-    this.MAX_PAYLOAD_SIZE = this.#agentInit.ajax.maxPayloadSize || 1000000
     setDenyList(this.#agentRuntime.denyList)
 
-    this.ajaxEvents = []
+    this.ajaxEvents = new EventBuffer()
     this.spaAjaxEvents = {}
-    this.sentAjaxEvents = []
     const classThis = this
 
     // --- v Used by old spa feature
     this.ee.on('interactionDone', (interaction, wasSaved) => {
-      if (!this.spaAjaxEvents[interaction.id]) return
+      if (!this.spaAjaxEvents[interaction.id]?.hasData) return
 
       if (!wasSaved) { // if the ixn was saved, then its ajax reqs are part of the payload whereas if it was discarded, it should still be harvested in the ajax feature itself
-        this.spaAjaxEvents[interaction.id].forEach((item) => this.ajaxEvents.push(item))
+        this.ajaxEvents.merge(this.spaAjaxEvents[interaction.id])
       }
       delete this.spaAjaxEvents[interaction.id]
     })
     // --- ^
     // --- v Used by new soft nav
-    registerHandler('returnAjax', event => this.ajaxEvents.push(event), this.featureName, this.ee)
+    registerHandler('returnAjax', event => this.ajaxEvents.add(event), this.featureName, this.ee)
     // --- ^
     registerHandler('xhr', function () { // the EE-drain system not only switches "this" but also passes a new EventContext with info. Should consider platform refactor to another system which passes a mutable context around separately and predictably to avoid problems like this.
       classThis.storeXhr(...arguments, this) // this switches the context back to the class instance while passing the NR context as an argument -- see "ctx" in storeXhr
@@ -116,7 +117,9 @@ export class Aggregate extends AggregateBase {
     if (ctx.dt) {
       event.spanId = ctx.dt.spanId
       event.traceId = ctx.dt.traceId
-      event.spanTimestamp = this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(ctx.dt.timestamp)
+      event.spanTimestamp = Math.floor(
+        this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(ctx.dt.timestamp)
+      )
     }
 
     // parsed from the AJAX body, looking for operationName param & parsing query for operationType
@@ -131,33 +134,31 @@ export class Aggregate extends AggregateBase {
       handle('ajax', [event], undefined, FEATURE_NAMES.softNav, this.ee)
     } else if (ctx.spaNode) { // For old spa (when running), if the ajax happened inside an interaction, hold it until the interaction finishes
       const interactionId = ctx.spaNode.interaction.id
-      this.spaAjaxEvents[interactionId] = this.spaAjaxEvents[interactionId] || []
-      this.spaAjaxEvents[interactionId].push(event)
+      this.spaAjaxEvents[interactionId] ??= new EventBuffer()
+      this.spaAjaxEvents[interactionId].add(event)
     } else {
-      this.ajaxEvents.push(event)
+      this.ajaxEvents.add(event)
     }
   }
 
   prepareHarvest (options) {
     options = options || {}
-    if (this.ajaxEvents.length === 0) return null
+    if (this.ajaxEvents.buffer.length === 0) return null
 
-    const payload = this.#getPayload(this.ajaxEvents)
+    const payload = this.#getPayload(this.ajaxEvents.buffer)
     const payloadObjs = []
 
     for (let i = 0; i < payload.length; i++) payloadObjs.push({ body: { e: payload[i] } })
 
-    if (options.retry) this.sentAjaxEvents = this.ajaxEvents
-    this.ajaxEvents = []
+    if (options.retry) this.ajaxEvents.hold()
+    else this.ajaxEvents.clear()
 
     return payloadObjs
   }
 
   onEventsHarvestFinished (result) {
-    if (result.retry && this.sentAjaxEvents.length > 0) {
-      this.ajaxEvents.unshift(...this.sentAjaxEvents)
-      this.sentAjaxEvents = []
-    }
+    if (result.retry && this.ajaxEvents.held.hasData) this.ajaxEvents.unhold()
+    else this.ajaxEvents.held.clear()
   }
 
   #getPayload (events, numberOfChunks) {

package/src/features/ajax/constants.js

@@ -1,5 +1,3 @@
 import { FEATURE_NAMES } from '../../loaders/features/features'
 
 export const FEATURE_NAME = FEATURE_NAMES.ajax
-
-export const MAX_PAYLOAD_SIZE = 1000000

package/src/features/ajax/instrument/distributed-tracing.js

@@ -2,7 +2,8 @@
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { getConfiguration, getConfigurationValue, getLoaderConfig } from '../../../common/config/config'
+import { getConfiguration, getConfigurationValue } from '../../../common/config/init'
+import { getLoaderConfig } from '../../../common/config/loader-config'
 import { generateSpanId, generateTraceId } from '../../../common/ids/unique-id'
 import { parseUrl } from '../../../common/url/parse-url'
 import { globalScope } from '../../../common/constants/runtime'

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

@@ -2,13 +2,15 @@
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { originals, getLoaderConfig } from '../../../common/config/config'
+import { gosNREUMOriginals } from '../../../common/window/nreum'
+import { getLoaderConfig } from '../../../common/config/loader-config'
 import { handle } from '../../../common/event-emitter/handle'
 import { id } from '../../../common/ids/id'
 import { ffVersion, globalScope, isBrowserScope } from '../../../common/constants/runtime'
 import { dataSize } from '../../../common/util/data-size'
 import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts'
-import { wrapFetch, wrapXhr } from '../../../common/wrap'
+import { wrapXhr } from '../../../common/wrap/wrap-xhr'
+import { wrapFetch } from '../../../common/wrap/wrap-fetch'
 import { parseUrl } from '../../../common/url/parse-url'
 import { DT } from './distributed-tracing'
 import { responseSizeFromXhr } from './response-size'
@@ -22,8 +24,8 @@ import { hasUndefinedHostname } from '../../../common/deny-list/deny-list'
 var handlers = ['load', 'error', 'abort', 'timeout']
 var handlersLen = handlers.length
 
-var origRequest = originals.REQ
-var origXHR = originals.XHR
+var origRequest = gosNREUMOriginals().o.REQ
+var origXHR = gosNREUMOriginals().o.XHR
 
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME
@@ -374,7 +376,7 @@ function subscribeToEvents (agentIdentifier, ee, handler, dt) {
     if (hasUndefinedHostname(params)) return // don't bother with XHR of url with no hostname
 
     metrics.duration = now() - this.startTime
-    if (!this.loadCaptureCalled && xhr.readyState === 4) {
+    if (!this.loadCazptureCalled && xhr.readyState === 4) {
       captureXhrData(this, xhr)
     } else if (params.status == null) {
       params.status = 0
@@ -416,3 +418,5 @@ function addUrl (ctx, url) {
   ctx.parsedOrigin = parsed
   ctx.sameOrigin = parsed.sameOrigin
 }
+
+export const Ajax = Instrument

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

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { stringify } from '../../../common/util/stringify'
+import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
+import { cleanURL } from '../../../common/url/clean-url'
+import { getInfo } from '../../../common/config/info'
+import { getConfigurationValue } from '../../../common/config/init'
+import { getRuntime } from '../../../common/config/runtime'
+import { FEATURE_NAME } from '../constants'
+import { isBrowserScope } from '../../../common/constants/runtime'
+import { AggregateBase } from '../../utils/aggregate-base'
+import { warn } from '../../../common/util/console'
+import { now } from '../../../common/timing/now'
+import { registerHandler } from '../../../common/event-emitter/register-handler'
+import { deregisterDrain } from '../../../common/drain/drain'
+import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
+import { EventBuffer } from '../../utils/event-buffer'
+import { applyFnToProps } from '../../../common/util/traverse'
+import { IDEAL_PAYLOAD_SIZE } from '../../../common/constants/agent-constants'
+
+export class Aggregate extends AggregateBase {
+  #agentRuntime
+  static featureName = FEATURE_NAME
+  constructor (agentIdentifier, aggregator) {
+    super(agentIdentifier, aggregator, FEATURE_NAME)
+
+    this.eventsPerHarvest = 1000
+    this.harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'generic_events.harvestTimeSeconds')
+
+    this.referrerUrl = (isBrowserScope && document.referrer) ? cleanURL(document.referrer) : undefined
+
+    this.events = new EventBuffer()
+
+    this.#agentRuntime = getRuntime(this.agentIdentifier)
+
+    this.waitForFlags(['ins']).then(([ins]) => {
+      if (!ins) {
+        this.blocked = true
+        deregisterDrain(this.agentIdentifier, this.featureName)
+        return
+      }
+
+      if (getConfigurationValue(this.agentIdentifier, 'page_action.enabled')) {
+        registerHandler('api-addPageAction', (timestamp, name, attributes) => {
+          this.addEvent({
+            ...attributes,
+            eventType: 'PageAction',
+            timestamp: Math.floor(this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(
+              this.#agentRuntime.timeKeeper.convertRelativeTimestamp(timestamp)
+            )),
+            timeSinceLoad: timestamp / 1000,
+            actionName: name,
+            referrerUrl: this.referrerUrl,
+            currentUrl: cleanURL('' + location),
+            ...(isBrowserScope && {
+              browserWidth: window.document.documentElement?.clientWidth,
+              browserHeight: window.document.documentElement?.clientHeight
+            })
+          })
+        }, this.featureName, this.ee)
+      }
+
+      this.harvestScheduler = new HarvestScheduler('ins', { onFinished: (...args) => this.onHarvestFinished(...args) }, this)
+      this.harvestScheduler.harvest.on('ins', (...args) => this.onHarvestStarted(...args))
+      this.harvestScheduler.startTimer(this.harvestTimeSeconds, 0)
+
+      this.drain()
+    })
+  }
+
+  // WARNING: Insights times are in seconds. EXCEPT timestamp, which is in ms.
+  addEvent (obj = {}) {
+    if (!obj || !Object.keys(obj).length) return
+    if (!obj.eventType) {
+      warn(44)
+      return
+    }
+
+    for (let key in obj) {
+      let val = obj[key]
+      obj[key] = (val && typeof val === 'object' ? stringify(val) : val)
+    }
+
+    const defaultEventAttributes = {
+      /** should be overridden by the event-specific attributes, but just in case -- set it to now() */
+      timestamp: Math.floor(this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(
+        this.#agentRuntime.timeKeeper.convertRelativeTimestamp(now())
+      )),
+      /** all generic events require a pageUrl */
+      pageUrl: cleanURL(getRuntime(this.agentIdentifier).origin)
+    }
+
+    const eventAttributes = {
+      /** Agent-level custom attributes */
+      ...(getInfo(this.agentIdentifier).jsAttributes || {}),
+      /** Fallbacks for required properties in-case the event did not supply them, should take precedence over agent-level custom attrs */
+      ...defaultEventAttributes,
+      /** Event-specific attributes take precedence over agent-level custom attributes and fallbacks */
+      ...obj
+    }
+
+    this.events.add(eventAttributes)
+
+    this.checkEventLimits()
+  }
+
+  onHarvestStarted (options) {
+    const { userAttributes, atts } = getInfo(this.agentIdentifier)
+    if (!this.events.hasData) return
+    var payload = ({
+      qs: {
+        ua: userAttributes,
+        at: atts
+      },
+      body: applyFnToProps(
+        { ins: this.events.buffer },
+        this.obfuscator.obfuscateString.bind(this.obfuscator), 'string'
+      )
+    })
+
+    if (options.retry) this.events.hold()
+    return payload
+  }
+
+  onHarvestFinished (result) {
+    if (result && result?.sent && result?.retry && this.events.held.hasData) this.events.unhold()
+    else this.events.held.clear()
+  }
+
+  checkEventLimits () {
+    // check if we've reached any harvest limits...
+    if (this.events.bytes > IDEAL_PAYLOAD_SIZE) {
+      this.ee.emit(SUPPORTABILITY_METRIC_CHANNEL, ['GenericEvents/Harvest/Max/Seen'])
+      this.harvestScheduler.runHarvest()
+    }
+  }
+}

package/src/features/generic_events/constants.js

@@ -0,0 +1,5 @@
+import { FEATURE_NAMES } from '../../loaders/features/features'
+
+export const FEATURE_NAME = FEATURE_NAMES.genericEvents
+export const IDEAL_PAYLOAD_SIZE = 64000
+export const MAX_PAYLOAD_SIZE = 1000000

package/src/features/generic_events/index.js

@@ -0,0 +1 @@
+export { Instrument as GenericEvents } from './instrument/index'

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

@@ -0,0 +1,24 @@
+/* Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { getConfigurationValue } from '../../../common/config/init'
+import { deregisterDrain } from '../../../common/drain/drain'
+import { InstrumentBase } from '../../utils/instrument-base'
+import { FEATURE_NAME } from '../constants'
+
+export class Instrument extends InstrumentBase {
+  static featureName = FEATURE_NAME
+  constructor (agentIdentifier, aggregator, auto = true) {
+    super(agentIdentifier, aggregator, FEATURE_NAME, auto)
+    const genericEventSourceConfigs = [
+      getConfigurationValue(this.agentIdentifier, 'page_action.enabled')
+      // other future generic event source configs to go here, like M&Ms, PageResouce, etc.
+    ]
+    /** If any of the sources are active, import the aggregator. otherwise deregister */
+    if (genericEventSourceConfigs.some(x => x)) this.importAggregator()
+    else deregisterDrain(this.agentIdentifier, this.featureName)
+  }
+}
+
+export const GenericEvents = Instrument

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

@@ -12,8 +12,9 @@ import { registerHandler as register } from '../../../common/event-emitter/regis
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { stringify } from '../../../common/util/stringify'
 import { handle } from '../../../common/event-emitter/handle'
-import { mapOwn } from '../../../common/util/map-own'
-import { getInfo, getConfigurationValue, getRuntime } from '../../../common/config/config'
+import { getInfo } from '../../../common/config/info'
+import { getConfigurationValue } from '../../../common/config/init'
+import { getRuntime } from '../../../common/config/runtime'
 import { globalScope } from '../../../common/constants/runtime'
 
 import { FEATURE_NAME } from '../constants'
@@ -22,6 +23,7 @@ import { AggregateBase } from '../../utils/aggregate-base'
 import { getNREUMInitializedAgent } from '../../../common/window/nreum'
 import { deregisterDrain } from '../../../common/drain/drain'
 import { now } from '../../../common/timing/now'
+import { applyFnToProps } from '../../../common/util/traverse'
 
 /**
  * @typedef {import('./compute-stack-trace.js').StackInfo} StackInfo
@@ -65,7 +67,10 @@ export class Aggregate extends AggregateBase {
 
   onHarvestStarted (options) {
     // this gets rid of dependency in AJAX module
-    var body = this.aggregator.take(['err', 'ierr', 'xhr'])
+    var body = applyFnToProps(
+      this.aggregator.take(['err', 'ierr', 'xhr']),
+      this.obfuscator.obfuscateString.bind(this.obfuscator), 'string'
+    )
 
     if (options.retry) {
       this.currentBody = body
@@ -91,7 +96,7 @@ export class Aggregate extends AggregateBase {
 
   onHarvestFinished (result) {
     if (result.retry && this.currentBody) {
-      mapOwn(this.currentBody, (key, value) => {
+      Object.entries(this.currentBody || {}).forEach(([key, value]) => {
         for (var i = 0; i < value.length; i++) {
           var bucket = value[i]
           var name = this.getBucketName(key, bucket.params, bucket.custom)
@@ -179,7 +184,9 @@ export class Aggregate extends AggregateBase {
     if (!this.stackReported[bucketHash]) {
       this.stackReported[bucketHash] = true
       params.stack_trace = truncateSize(stackInfo.stackString)
-      this.observedAt[bucketHash] = agentRuntime.timeKeeper.convertRelativeTimestamp(time)
+      this.observedAt[bucketHash] = Math.floor(agentRuntime.timeKeeper.correctAbsoluteTimestamp(
+        agentRuntime.timeKeeper.convertRelativeTimestamp(time)
+      ))
     } else {
       params.browser_stack_hash = stringHashCode(stackInfo.stackString)
     }
@@ -196,7 +203,9 @@ export class Aggregate extends AggregateBase {
     }
 
     params.firstOccurrenceTimestamp = this.observedAt[bucketHash]
-    params.timestamp = agentRuntime.timeKeeper.convertRelativeTimestamp(time)
+    params.timestamp = Math.floor(agentRuntime.timeKeeper.correctAbsoluteTimestamp(
+      agentRuntime.timeKeeper.convertRelativeTimestamp(time)
+    ))
 
     var type = internal ? 'ierr' : 'err'
     var newMetrics = { time }
@@ -264,8 +273,8 @@ export class Aggregate extends AggregateBase {
       var allCustomAttrs = {}
       const localCustomAttrs = item[4]
 
-      mapOwn(interaction.root.attrs.custom, setCustom) // tack on custom attrs from the interaction
-      mapOwn(localCustomAttrs, setCustom)
+      Object.entries(interaction.root.attrs.custom || {}).forEach(setCustom) // tack on custom attrs from the interaction
+      Object.entries(localCustomAttrs || {}).forEach(setCustom)
 
       var params = item[2]
       if (wasSaved) {
@@ -281,7 +290,7 @@ export class Aggregate extends AggregateBase {
 
       this.aggregator.store(item[0], aggregateHash, params, item[3], allCustomAttrs)
 
-      function setCustom (key, val) {
+      function setCustom ([key, val]) {
         allCustomAttrs[key] = (val && typeof val === 'object' ? stringify(val) : val)
       }
     })

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

@@ -54,3 +54,5 @@ export class Instrument extends InstrumentBase {
     this.abortHandler = undefined // weakly allow this abort op to run only once
   }
 }
+
+export const JSErrors = Instrument