add feature flag controls

Author: metal-messiah

.github/actions/build-ab/templates/released.js

@@ -1,7 +1,7 @@
 // config
 window.NREUM={
   init: {
-    feature_flags: ['soft_nav', 'user_frustrations'],
+    feature_flags: ['soft_nav', 'user_frustrations', 'register'], // add jserrors and generic events once the consumer(s) support it
     distributed_tracing: {
       enabled: true
     },

src/common/config/init.js

@@ -48,7 +48,7 @@ const InitModelFn = () => {
   return {
     ajax: { deny_list: undefined, block_internal: true, enabled: true, autoStart: true },
     api: {
-      allow_registered_children: true,
+      allow_registered_children: false,
       duplicate_registered_data: false
     },
     distributed_tracing: {

src/common/constants/agent-constants.js

@@ -10,6 +10,9 @@ export const DEFAULT_KEY = 'NR_CONTAINER_AGENT'
 export const SESSION_ERROR = 'SESSION_ERROR'
 
 export const SUPPORTS_REGISTERED_ENTITIES = {
-  [FEATURE_NAMES.logging]: true
-  // add other features here when they are supported by DEM consumers
+  [FEATURE_NAMES.logging]: true,
+  // flip other features here when they are supported by DEM consumers
+  [FEATURE_NAMES.genericEvents]: false,
+  [FEATURE_NAMES.jserrors]: false,
+  [FEATURE_NAMES.ajax]: false
 }

src/features/utils/aggregate-base.js

@@ -70,7 +70,7 @@ export class AggregateBase extends FeatureBase {
 
   /** @type {Boolean} indicates if the feature supports registered entities and the harvest requirements therein. Also read by getter "harvestEndpointVersion". Controlled by feature flag in pre-release phase. */
   get supportsRegisteredEntities () {
-    return SUPPORTS_REGISTERED_ENTITIES[this.featureName] || this.agentRef.init.feature_flags.includes('register-' + this.featureName)
+    return this.featureName in SUPPORTS_REGISTERED_ENTITIES && (SUPPORTS_REGISTERED_ENTITIES[this.featureName] || this.agentRef.init.feature_flags.includes('register.' + this.featureName))
   }
 
   /**

src/loaders/api/register.js

@@ -67,7 +67,7 @@ export function buildRegisterApi (agentRef, target) {
   }
 
   /** primary cases that can block the register API from working at init time */
-  if (!agentRef.init.api.allow_registered_children) block(() => warn(55))
+  if (!agentRef.init.api.allow_registered_children && !agentRef.init.feature_flags.includes('register')) block(() => warn(55))
   if (!isValidMFETarget(target)) block(() => warn(48, target))
 
   /** @type {RegisterAPI} */

tests/specs/api.e2e.js

@@ -1,5 +1,5 @@
 import { checkAjaxEvents, checkJsErrors, checkMetrics, checkGenericEvents, checkPVT, checkRumBody, checkRumQuery, checkSessionTrace, checkSpa } from '../util/basic-checks'
-import { testAjaxEventsRequest, testAjaxTimeSlicesRequest, testBlobTraceRequest, testCustomMetricsRequest, testErrorsRequest, testEventsRequest, testInsRequest, testInteractionEventsRequest, testLogsRequest, testMetricsRequest, testRumRequest, testTimingEventsRequest } from '../../tools/testing-server/utils/expect-tests'
+import { testAjaxEventsRequest, testAjaxTimeSlicesRequest, testBlobTraceRequest, testCustomMetricsRequest, testErrorsRequest, testEventsRequest, testInsRequest, testInteractionEventsRequest, testLogsRequest, testMetricsRequest, testMFEErrorsRequest, testMFEInsRequest, testRumRequest, testTimingEventsRequest } from '../../tools/testing-server/utils/expect-tests'
 import { rumFlags } from '../../tools/testing-server/constants'
 import { LOGGING_MODE } from '../../src/features/logging/constants'
 
@@ -8,6 +8,161 @@ describe('newrelic api', () => {
     await browser.destroyAgentSession()
   })
 
+  describe('registered-entity', () => {
+    const featureFlags = [
+      [],
+      ['register'],
+      ['register', 'register.jserrors'],
+      ['register', 'register.generic_events'],
+      ['register', 'register.jserrors', 'register.generic_events'],
+      ['register.jserrors', 'register.generic_events'],
+      ['register.jserrors'],
+      ['register.generic_events']
+    ]
+    featureFlags.forEach((testSet) => {
+      it(`RegisteredEntity -- ${testSet.join(' | ') || 'no flags'}`, async () => {
+        const [rumCapture, mfeErrorsCapture, mfeInsightsCapture, regularErrorsCapture, regularInsightsCapture, logsCapture] = await browser.testHandle.createNetworkCaptures('bamServer', [
+          { test: testRumRequest },
+          { test: testMFEErrorsRequest },
+          { test: testMFEInsRequest },
+          { test: testErrorsRequest },
+          { test: testInsRequest },
+          { test: testLogsRequest }
+        ])
+        await browser.url(await browser.testHandle.assetURL('instrumented.html', { init: { feature_flags: testSet } }))
+
+        await browser.execute(function () {
+          window.agent1 = newrelic.register({
+            id: 1,
+            name: 'agent1'
+          })
+          window.agent2 = newrelic.register({
+            id: 2,
+            name: 'agent2'
+          })
+
+          // each payload in this test is decorated with data that matches its appId for ease of testing
+          window.newrelic.setCustomAttribute('customAttr', '42') // container agent
+          window.agent1.setCustomAttribute('customAttr', '1') // micro agent (agent1)
+          window.agent2.setCustomAttribute('customAttr', '2') // micro agent (agent2)
+
+          // each payload in this test is decorated with data that matches its appId for ease of testing
+          window.newrelic.noticeError('42')
+          window.agent1.noticeError('1')
+          window.agent2.noticeError('2')
+
+          // each payload in this test is decorated with data that matches its appId for ease of testing
+          window.newrelic.addPageAction('42', { val: 42 })
+          window.agent1.addPageAction('1', { val: 1 })
+          window.agent2.addPageAction('2', { val: 2 })
+
+          // each payload in this test is decorated with data that matches its appId for ease of testing
+          window.newrelic.log('42')
+          window.agent1.log('1', { level: 'error' })
+          window.agent2.log('2', { level: 'error' })
+        })
+        const [rumHarvests, errorsHarvests, insightsHarvests, logsHarvest] = await Promise.all([
+          rumCapture.waitForResult({ totalCount: 1, timeout: 10000 }),
+          (testSet.includes('register.jserrors') ? mfeErrorsCapture : regularErrorsCapture).waitForResult({ totalCount: 1, timeout: 10000 }),
+          (testSet.includes('register.generic_events') ? mfeInsightsCapture : regularInsightsCapture).waitForResult({ totalCount: 1, timeout: 10000 }),
+          logsCapture.waitForResult({ totalCount: 1, timeout: 10000 })
+        ])
+
+        const containerAgentEntityGuid = await browser.execute(function () {
+          return Object.values(newrelic.initializedAgents)[0].runtime.appMetadata.agents[0].entityGuid
+        })
+
+        // these props will get set to true once a test has matched it
+        // if it gets tried again, the test will fail, since these should all
+        // only have one distinct matching payload
+        const tests = {
+          42: { rum: false, err: false, pa: false, log: false }, // container agent defaults to appId 42
+          1: { err: false, pa: false, log: false }, // agent1 instance
+          2: { err: false, pa: false, log: false } // agent2 instance
+        }
+
+        expect(rumHarvests).toHaveLength(1)
+        expect(errorsHarvests.length).toBeGreaterThanOrEqual(1)
+        expect(insightsHarvests.length).toBeGreaterThanOrEqual(1)
+        expect(logsHarvest.length).toBeGreaterThanOrEqual(1)
+
+        // each type of test should check that:
+        // each payload exists once per appId
+        // each payload should have internal attributes matching it to the right appId
+        rumHarvests.forEach(({ request: { query, body } }) => {
+          expect(ranOnce(query.a, 'rum')).toEqual(true)
+        })
+
+        errorsHarvests.forEach(({ request: { query, body } }) => {
+          const data = body.err
+          data.forEach((err, idx) => {
+            const id = err.custom['mfe.id'] || query.a // MFEs use mfe.id, regular agents use appId
+            if (Number(id) !== 42 && testSet.includes('register.jserrors')) {
+              expect(err.custom['mfe.name']).toEqual('agent' + id)
+              expect(err.custom.eventSource).toEqual('MicroFrontendBrowserAgent')
+              expect(err.custom['parent.id']).toEqual(containerAgentEntityGuid)
+            }
+            countRuns(id, 'err')
+            if (testSet.includes('register.jserrors')) {
+              expect(ranOnce(id, 'err')).toEqual(true)
+              expect(Number(id)).toEqual(Number(err.params.message))
+            } else {
+              expect(tests[id].err).toEqual(idx + 1) // each error gets lumped together under the same id without the feature flags
+              expect(Number(id)).toEqual(42)
+            }
+          })
+        })
+
+        insightsHarvests.forEach(({ request: { query, body } }) => {
+          const data = body.ins
+          data.forEach((ins, idx) => {
+            if (ins.eventType === 'PageAction') {
+              const id = ins['mfe.id'] || query.a // MFEs use mfe.id, regular agents use appId
+              if (Number(id) !== 42 && testSet.includes('register.generic_events')) {
+                expect(ins['mfe.name']).toEqual('agent' + id)
+                expect(ins.eventSource).toEqual('MicroFrontendBrowserAgent')
+                expect(ins['parent.id']).toEqual(containerAgentEntityGuid)
+              }
+              countRuns(id, 'pa')
+              if (testSet.includes('register.generic_events')) {
+                expect(ranOnce(id, 'pa')).toEqual(true)
+                expect(Number(id)).toEqual(Number(ins.val))
+              } else {
+                expect(tests[id].pa).toEqual(idx + 1) // each error gets lumped together under the same id without the feature flags
+                expect(Number(id)).toEqual(42)
+              }
+            }
+          })
+        })
+
+        logsHarvest.forEach(({ request: { query, body } }) => {
+          const data = JSON.parse(body)[0]
+          data.logs.forEach(log => {
+            const id = log.attributes['mfe.id'] || 42 // MFEs use mfe.id, regular agents supply entity guid so just force it to 42 here if mfe id is not present
+            if (Number(id) !== 42 && testSet.includes('register')) {
+              expect(log.attributes['mfe.name']).toEqual('agent' + id)
+              expect(log.attributes.eventSource).toEqual('MicroFrontendBrowserAgent')
+              expect(log.attributes['parent.id']).toEqual(containerAgentEntityGuid)
+            }
+            expect(ranOnce(id, 'log')).toEqual(true)
+            expect(Number(id)).toEqual(Number(log.message))
+          })
+        })
+
+        function ranOnce (appId, type) {
+          if (tests[appId][type] > 1) return false
+          countRuns(appId, type)
+          return true
+        }
+
+        function countRuns (appId, type) {
+          tests[appId][type] ??= 0
+          tests[appId][type]++
+        }
+      })
+    })
+  })
+
   it('should expose api methods', async () => {
     await browser.url(await browser.testHandle.assetURL('api/local-storage-disallowed.html')) // Setup expects before loading the page
       .then(() => browser.waitForAgentLoad())