feat: Inspection events (#1413)

ellisong · web-flow · commit 1832562f52c1 · 2025-03-14T12:40:11.000-07:00
diff --git a/src/common/harvest/harvester.js b/src/common/harvest/harvester.js
@@ -16,6 +16,8 @@ import { obj, param } from '../url/encode'
 import { warn } from '../util/console'
 import { stringify } from '../util/stringify'
 import { getSubmitMethod, xhr as xhrMethod, xhrFetch as fetchMethod } from '../util/submit-data'
+import { activatedFeatures } from '../util/feature-flags'
+import { dispatchGlobalEvent } from '../dispatch/global-event'
 
 const RETRY_FAILED = 'Harvester/Retry/Failed/'
 const RETRY_SUCCEEDED = 'Harvester/Retry/Succeeded/'
@@ -80,7 +82,8 @@ export class Harvester {
         localOpts,
         submitMethod,
         cbFinished,
-        raw: aggregateInst.harvestOpts.raw
+        raw: aggregateInst.harvestOpts.raw,
+        featureName: aggregateInst.featureName
       })
       ranSend = true
     })
@@ -114,7 +117,7 @@ const warnings = {}
   * @param {NetworkSendSpec} param0 Specification for sending data
   * @returns {boolean} True if a network call was made. Note that this does not mean or guarantee that it was successful.
   */
-function send (agentRef, { endpoint, targetApp, payload, localOpts = {}, submitMethod, cbFinished, raw }) {
+function send (agentRef, { endpoint, targetApp, payload, localOpts = {}, submitMethod, cbFinished, raw, featureName }) {
   if (!agentRef.info.errorBeacon) return false
 
   let { body, qs } = cleanPayload(payload)
@@ -172,6 +175,24 @@ function send (agentRef, { endpoint, targetApp, payload, localOpts = {}, submitM
       })
     }
   }
+
+  dispatchGlobalEvent({
+    agentIdentifier: agentRef.agentIdentifier,
+    loaded: !!activatedFeatures?.[agentRef.agentIdentifier],
+    type: 'data',
+    name: 'harvest',
+    feature: featureName,
+    data: {
+      endpoint,
+      headers,
+      targetApp,
+      payload,
+      submitMethod: getSubmitMethodName(),
+      raw,
+      synchronousXhr: !!(localOpts.isFinalHarvest && isWorkerScope)
+    }
+  })
+
   return true
 
   function shouldRetry (status) {
@@ -183,6 +204,12 @@ function send (agentRef, { endpoint, targetApp, payload, localOpts = {}, submitM
     }
     return (status >= 502 && status <= 504) || (status >= 512 && status <= 530)
   }
+
+  function getSubmitMethodName () {
+    if (submitMethod === xhrMethod) return 'xhr'
+    if (submitMethod === fetchMethod) return 'fetch'
+    return 'beacon'
+  }
 }
 
 /**
diff --git a/src/common/util/feature-flags.js b/src/common/util/feature-flags.js
@@ -29,5 +29,12 @@ export function activateFeatures (flags, agentIdentifier) {
   sentIds.add(agentIdentifier)
 
   // let any window level subscribers know that the agent is running
-  dispatchGlobalEvent({ loaded: true })
+  dispatchGlobalEvent({
+    agentIdentifier,
+    loaded: true,
+    type: 'lifecycle',
+    name: 'load',
+    feature: undefined,
+    data: flags
+  })
 }
diff --git a/src/features/utils/aggregate-base.js b/src/features/utils/aggregate-base.js
@@ -37,7 +37,7 @@ export class AggregateBase extends FeatureBase {
       This was necessary to prevent race cond. issues where the event buffer was checked before the feature could "block" itself.
       Its easier to just keep an empty event buffer in place. */
       default:
-        this.events = new EventStoreManager(agentRef.mainAppKey, 1)
+        this.events = new EventStoreManager(agentRef.mainAppKey, 1, agentRef.agentIdentifier, this.featureName)
         break
     }
     this.harvestOpts = {} // features aggregate classes can define custom opts for when their harvest is called
@@ -157,7 +157,7 @@ export class AggregateBase extends FeatureBase {
 
     if (!agentRef.mainAppKey) agentRef.mainAppKey = { licenseKey: agentRef.info.licenseKey, appId: agentRef.info.applicationID }
     // Create a single Aggregator for this agent if DNE yet; to be used by jserror endpoint features.
-    if (!agentRef.sharedAggregator) agentRef.sharedAggregator = new EventStoreManager(agentRef.mainAppKey, 2)
+    if (!agentRef.sharedAggregator) agentRef.sharedAggregator = new EventStoreManager(agentRef.mainAppKey, 2, agentRef.agentIdentifier, 'shared_aggregator')
 
     if (!agentRef.runtime.harvester) agentRef.runtime.harvester = new Harvester(agentRef)
   }
diff --git a/src/features/utils/event-store-manager.js b/src/features/utils/event-store-manager.js
@@ -3,6 +3,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { EventAggregator } from '../../common/aggregate/event-aggregator'
+import { dispatchGlobalEvent } from '../../common/dispatch/global-event'
+import { activatedFeatures } from '../../common/util/feature-flags'
 import { EventBuffer } from './event-buffer'
 
 /**
@@ -13,12 +15,16 @@ export class EventStoreManager {
   /**
    * @param {object} defaultTarget - should contain licenseKey and appId of the main app from NREUM.info at startup
    * @param {1|2} storageChoice - the type of storage to use in this manager; 'EventBuffer' (1), 'EventAggregator' (2)
+   * @param {string} agentIdentifier - agent identifier used in inspection events
+   * @param {string} featureName - feature name used in inspection events for non-shared aggregators
    */
-  constructor (defaultTarget, storageChoice) {
+  constructor (defaultTarget, storageChoice, agentIdentifier, featureName) {
     this.mainApp = defaultTarget
     this.StorageClass = storageChoice === 1 ? EventBuffer : EventAggregator
     this.appStorageMap = new Map()
     this.appStorageMap.set(defaultTarget, new this.StorageClass())
+    this.agentIdentifier = agentIdentifier
+    this.featureName = featureName
   }
 
   // This class must contain an union of all methods from all supported storage classes and conceptualize away the target app argument.
@@ -45,6 +51,14 @@ export class EventStoreManager {
    * @returns {boolean} True if the event was successfully added
    */
   add (event, target) {
+    dispatchGlobalEvent({
+      agentIdentifier: this.agentIdentifier,
+      loaded: !!activatedFeatures?.[this.agentIdentifier],
+      type: 'data',
+      name: 'buffer',
+      feature: this.featureName,
+      data: event
+    })
     if (target && !this.appStorageMap.has(target)) this.appStorageMap.set(target, new this.StorageClass())
     return this.appStorageMap.get(target || this.mainApp).add(event)
   }
diff --git a/src/loaders/api/api.js b/src/loaders/api/api.js
@@ -20,6 +20,8 @@ import { MODE } from '../../common/session/constants'
 import { LOG_LEVELS } from '../../features/logging/constants'
 import { bufferLog } from '../../features/logging/shared/utils'
 import { wrapLogger } from '../../common/wrap/wrap-logger'
+import { dispatchGlobalEvent } from '../../common/dispatch/global-event'
+import { activatedFeatures } from '../../common/util/feature-flags'
 
 export function setTopLevelCallers () {
   const nr = gosCDN()
@@ -194,6 +196,14 @@ export function setAPI (agentIdentifier, forceDrain, runSoftNavOverSpa = false)
   function apiCall (prefix, name, notSpa, bufferGroup) {
     return function () {
       handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/' + name + '/called'], undefined, FEATURE_NAMES.metrics, instanceEE)
+      dispatchGlobalEvent({
+        agentIdentifier,
+        loaded: !!activatedFeatures?.[agentIdentifier],
+        type: 'data',
+        name: 'api',
+        feature: prefix + name,
+        data: { notSpa, bufferGroup }
+      })
       if (bufferGroup) handle(prefix + name, [notSpa ? now() : performance.now(), ...arguments], notSpa ? null : this, bufferGroup, instanceEE) // no bufferGroup means only the SM is emitted
       return notSpa ? undefined : this // returns the InteractionHandle which allows these methods to be chained
     }
diff --git a/src/loaders/configure/configure.js b/src/loaders/configure/configure.js
@@ -12,6 +12,7 @@ import { activatedFeatures } from '../../common/util/feature-flags'
 import { isWorkerScope } from '../../common/constants/runtime'
 import { redefinePublicPath } from './public-path'
 import { ee } from '../../common/event-emitter/contextual-ee'
+import { dispatchGlobalEvent } from '../../common/dispatch/global-event'
 
 let alreadySetOnce = false // the configure() function can run multiple times in agent lifecycle
 
@@ -68,5 +69,17 @@ export function configure (agent, opts = {}, loaderType, forceDrain) {
 
   if (agent.api === undefined) agent.api = setAPI(agent.agentIdentifier, forceDrain, agent.runSoftNavOverSpa)
   if (agent.exposed === undefined) agent.exposed = exposed
+
+  if (!alreadySetOnce) {
+    dispatchGlobalEvent({
+      agentIdentifier: agent.agentIdentifier,
+      loaded: !!activatedFeatures?.[agent.agentIdentifier],
+      type: 'lifecycle',
+      name: 'initialize',
+      feature: undefined,
+      data: { init: updatedInit, info, loader_config, runtime }
+    })
+  }
+
   alreadySetOnce = true
 }
diff --git a/tests/assets/all-events.html b/tests/assets/all-events.html
@@ -13,7 +13,7 @@
       xhr.send()
 
       window.addEventListener('newrelic', function(event) {
-        if (event.detail.loaded) {
+        if (event?.detail?.type === 'lifecycle' && event.detail.name === 'load') {
           var xhr = new XMLHttpRequest()
           xhr.open('GET', '/json')
           xhr.send()
diff --git a/tests/assets/inspection-events.html b/tests/assets/inspection-events.html
@@ -0,0 +1,84 @@
+<!DOCTYPE html>
+<!--
+  Copyright 2020 New Relic Corporation.
+  PDX-License-Identifier: Apache-2.0
+-->
+<html>
+
+<head>
+  <title>Inspection events</title>
+  <script>
+    window.inspectionEvents = {
+      initialize: false,
+      load: false,
+      buffer: false,
+      harvest: false,
+      api: false,
+    }
+    window.addEventListener('newrelic', ({ detail }) => {
+      if (!detail || !detail.agentIdentifier) return
+      const { name, loaded, type, feature, data } = detail
+
+      if (
+        name == 'initialize' &&
+        loaded == false &&
+        type == 'lifecycle' &&
+        feature == undefined &&
+        data
+      ) {
+        window.inspectionEvents.initialize = true
+      }
+
+      if (
+        name === 'load' &&
+        loaded === true &&
+        type === 'lifecycle' &&
+        feature === undefined &&
+        data
+      ) {
+        window.inspectionEvents.load = true
+      }
+
+      if (
+        name === 'buffer' &&
+        loaded === true &&
+        type === 'data' &&
+        feature &&
+        data
+      ) {
+        window.inspectionEvents.buffer = true
+      }
+
+      if (
+        name === 'harvest' &&
+        loaded === true &&
+        type === 'data' &&
+        feature &&
+        data
+      ) {
+        window.inspectionEvents.harvest = true
+      }
+
+      // The API call in this test is called before the agent is loaded, so loaded should be false
+      if (
+        name === 'api' &&
+        loaded === false &&
+        type === 'data' &&
+        feature &&
+        data
+      ) {
+        window.inspectionEvents.api = true
+      }
+    })
+  </script>
+  {init} {config} {loader}
+</head>
+
+<body>
+  This page is used to monitor and record events from agent-specific event listeners.
+  <script>
+    newrelic.finished()
+  </script>
+</body>
+
+</html>
diff --git a/tests/components/setup-agent.js b/tests/components/setup-agent.js
@@ -39,7 +39,7 @@ export function setupAgent ({ agentOverrides = {}, info = {}, init = {}, loaderC
   const fakeAgent = {
     agentIdentifier,
     ee: eventEmitter,
-    sharedAggregator: new EventStoreManager({ licenseKey: info.licenseKey, appId: info.applicationID }, 2),
+    sharedAggregator: new EventStoreManager({ licenseKey: info.licenseKey, appId: info.applicationID }, 2, agentIdentifier),
     ...agentOverrides
   }
   setNREUMInitializedAgent(agentIdentifier, fakeAgent)
diff --git a/tests/specs/inspection-events.e2e.js b/tests/specs/inspection-events.e2e.js
@@ -0,0 +1,30 @@
+import { getDebugLogs } from './util/helpers'
+
+describe('inspection events', () => {
+  it('emits all types of inspection events', async () => {
+    await browser.url(await browser.testHandle.assetURL('inspection-events.html'))
+      .then(() => browser.waitForAgentLoad())
+      .then(() => browser.waitUntil(
+        () => browser.execute(function () {
+          return window?.inspectionEvents?.buffer &&
+            window.inspectionEvents.harvest &&
+            window.inspectionEvents.api
+        }),
+        {
+          timeout: 30000,
+          timeoutMsg: 'Timeout on inspection events'
+        }))
+
+    const inspectionEvents = await browser.execute(function () {
+      return window.inspectionEvents
+    })
+
+    console.log(await getDebugLogs())
+
+    expect(inspectionEvents.initialize).toBe(true)
+    expect(inspectionEvents.load).toBe(true)
+    expect(inspectionEvents.buffer).toBe(true)
+    expect(inspectionEvents.harvest).toBe(true)
+    expect(inspectionEvents.api).toBe(true)
+  })
+})
diff --git a/tests/unit/features/utils/aggregate-base.test.js b/tests/unit/features/utils/aggregate-base.test.js
@@ -151,7 +151,8 @@ test('does not initialized Aggregator more than once with multiple features', as
 
   new AggregateBase(mainAgent, FEATURE_NAMES.pageViewEvent)
   expect(EventStoreManager).toHaveBeenCalledTimes(2) // once for runtime.sharedAgg + once for PVE.events
-  expect(EventStoreManager).toHaveBeenCalledWith(mainAgent.mainAppKey, 2) // 2 = initialize EventAggregator
+  expect(EventStoreManager).toHaveBeenNthCalledWith(1, mainAgent.mainAppKey, 2, mainAgent.agentIdentifier, 'shared_aggregator') // 2 = initialize EventAggregator
+  expect(EventStoreManager).toHaveBeenNthCalledWith(2, mainAgent.mainAppKey, 1, mainAgent.agentIdentifier, FEATURE_NAMES.pageViewEvent)
   expect(mainAgent.mainAppKey).toBeTruthy()
   expect(mainAgent.sharedAggregator).toBeTruthy()
 
@@ -160,7 +161,7 @@ test('does not initialized Aggregator more than once with multiple features', as
 
   new AggregateBase(mainAgent, FEATURE_NAMES.pageViewTiming) // PVT should use its own EventStoreManager
   expect(EventStoreManager).toHaveBeenCalledTimes(3)
-  expect(EventStoreManager).toHaveBeenCalledWith(mainAgent.mainAppKey, 1) // 1 = initialize EventBuffer
+  expect(EventStoreManager).toHaveBeenCalledWith(mainAgent.mainAppKey, 1, mainAgent.agentIdentifier, FEATURE_NAMES.pageViewTiming) // 1 = initialize EventBuffer
 })
 
 test('does initialize separate Aggregators with multiple agents', async () => {
diff --git a/tests/unit/features/utils/event-store-manager.test.js b/tests/unit/features/utils/event-store-manager.test.js

Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ export function setupAgent ({ agentOverrides = {}, info = {}, init = {}, loaderC`
`39`	`39`	`const fakeAgent = {`
`40`	`40`	`agentIdentifier,`
`41`	`41`	`ee: eventEmitter,`
`42`		`- sharedAggregator: new EventStoreManager({ licenseKey: info.licenseKey, appId: info.applicationID }, 2),`
	`42`	`+ sharedAggregator: new EventStoreManager({ licenseKey: info.licenseKey, appId: info.applicationID }, 2, agentIdentifier),`
`43`	`43`	`...agentOverrides`
`44`	`44`	`}`
`45`	`45`	`setNREUMInitializedAgent(agentIdentifier, fakeAgent)`