@newrelic/browser-agent 1.234.0 → 1.236.0

package/src/features/utils/instrument-base.test.js

@@ -0,0 +1,209 @@
+import { faker } from '@faker-js/faker'
+import { InstrumentBase } from './instrument-base'
+import { FeatureBase } from './feature-base'
+import { drain, registerDrain } from '../../common/drain/drain'
+import { onWindowLoad } from '../../common/window/load'
+import { lazyFeatureLoader } from './lazy-feature-loader'
+import { getConfigurationValue } from '../../common/config/config'
+import { setupAgentSession } from './agent-session'
+import { warn } from '../../common/util/console'
+import * as globalScopeModule from '../../common/constants/runtime'
+import { FEATURE_NAMES } from '../../loaders/features/features'
+
+jest.enableAutomock()
+jest.unmock('./instrument-base')
+jest.unmock('../../loaders/features/features')
+jest.mock('../../common/drain/drain', () => ({
+  __esModule: true,
+  drain: jest.fn(),
+  registerDrain: jest.fn()
+}))
+jest.mock('../../common/window/load', () => ({
+  __esModule: true,
+  onWindowLoad: jest.fn()
+}))
+jest.mock('../../common/constants/runtime', () => ({
+  __esModule: true,
+  isBrowserScope: undefined,
+  isWorkerScope: undefined
+}))
+jest.mock('../../common/config/config', () => ({
+  __esModule: true,
+  getConfigurationValue: jest.fn()
+}))
+jest.mock('./feature-base', () => ({
+  __esModule: true,
+  FeatureBase: jest.fn(function (...args) {
+    this.agentIdentifier = args[0]
+    this.aggregator = args[1]
+    this.featureName = args[2]
+  })
+}))
+jest.mock('./agent-session', () => ({
+  __esModule: true,
+  setupAgentSession: jest.fn()
+}))
+
+let agentIdentifier
+let aggregator
+let featureName
+let mockAggregate
+
+beforeEach(() => {
+  jest.replaceProperty(globalScopeModule, 'isBrowserScope', true)
+  jest.replaceProperty(globalScopeModule, 'isWorkerScope', false)
+
+  agentIdentifier = faker.datatype.uuid()
+  aggregator = {}
+  featureName = faker.datatype.uuid()
+
+  mockAggregate = jest.fn()
+  jest.mocked(lazyFeatureLoader).mockResolvedValue({ Aggregate: mockAggregate })
+})
+
+test('should construct a new instrument', () => {
+  const instrument = new InstrumentBase(agentIdentifier, aggregator, featureName)
+
+  expect(FeatureBase).toHaveBeenCalledWith(agentIdentifier, aggregator, featureName)
+  expect(instrument.featAggregate).toBeUndefined()
+  expect(instrument.auto).toEqual(true)
+  expect(instrument.abortHandler).toBeUndefined()
+  expect(registerDrain).toHaveBeenCalledWith(agentIdentifier, featureName)
+})
+
+test('should not immediately drain', () => {
+  const instrument = new InstrumentBase(agentIdentifier, aggregator, featureName, false)
+
+  expect(registerDrain).not.toHaveBeenCalled()
+})
+
+test('should import aggregator on window load', async () => {
+  const instrument = new InstrumentBase(agentIdentifier, aggregator, featureName)
+  const aggregateArgs = { [faker.datatype.uuid()]: faker.lorem.sentence() }
+  instrument.importAggregator(aggregateArgs)
+
+  const windowLoadCallback = jest.mocked(onWindowLoad).mock.calls[0][0]
+  await windowLoadCallback()
+
+  expect(onWindowLoad).toHaveBeenCalledWith(expect.any(Function), true)
+  expect(lazyFeatureLoader).toHaveBeenCalledWith(featureName, 'aggregate')
+  expect(mockAggregate).toHaveBeenCalledWith(agentIdentifier, aggregator, aggregateArgs)
+})
+
+test('should immediately import aggregator in worker scope', async () => {
+  jest.replaceProperty(globalScopeModule, 'isBrowserScope', false)
+  jest.replaceProperty(globalScopeModule, 'isWorkerScope', true)
+
+  const instrument = new InstrumentBase(agentIdentifier, aggregator, featureName)
+  const aggregateArgs = { [faker.datatype.uuid()]: faker.lorem.sentence() }
+  instrument.importAggregator(aggregateArgs)
+
+  // In worker scope, we cannot wait on importLater method
+  await new Promise(process.nextTick)
+
+  expect(onWindowLoad).not.toHaveBeenCalled()
+  expect(lazyFeatureLoader).toHaveBeenCalledWith(featureName, 'aggregate')
+  expect(mockAggregate).toHaveBeenCalledWith(agentIdentifier, aggregator, aggregateArgs)
+})
+
+test('should import the session manager and replay aggregate for new session', async () => {
+  jest.mocked(getConfigurationValue).mockReturnValue(true)
+  jest.mocked(setupAgentSession).mockReturnValue({
+    isNew: true
+  })
+
+  const instrument = new InstrumentBase(agentIdentifier, aggregator, FEATURE_NAMES.sessionReplay)
+  const aggregateArgs = { [faker.datatype.uuid()]: faker.lorem.sentence() }
+  instrument.importAggregator(aggregateArgs)
+
+  const windowLoadCallback = jest.mocked(onWindowLoad).mock.calls[0][0]
+  await windowLoadCallback()
+
+  expect(getConfigurationValue).toHaveBeenCalledWith(agentIdentifier, 'privacy.cookies_enabled')
+  expect(setupAgentSession).toHaveBeenCalledWith(agentIdentifier)
+  expect(lazyFeatureLoader).toHaveBeenCalledWith(FEATURE_NAMES.sessionReplay, 'aggregate')
+  expect(mockAggregate).toHaveBeenCalledWith(agentIdentifier, aggregator, aggregateArgs)
+})
+
+test('should import the session manager and replay aggregate when a recording is active', async () => {
+  jest.mocked(getConfigurationValue).mockReturnValue(true)
+  jest.mocked(setupAgentSession).mockReturnValue({
+    isNew: false,
+    state: {
+      sessionReplay: 1
+    }
+  })
+
+  const instrument = new InstrumentBase(agentIdentifier, aggregator, FEATURE_NAMES.sessionReplay)
+  const aggregateArgs = { [faker.datatype.uuid()]: faker.lorem.sentence() }
+  instrument.importAggregator(aggregateArgs)
+
+  const windowLoadCallback = jest.mocked(onWindowLoad).mock.calls[0][0]
+  await windowLoadCallback()
+
+  expect(getConfigurationValue).toHaveBeenCalledWith(agentIdentifier, 'privacy.cookies_enabled')
+  expect(setupAgentSession).toHaveBeenCalledWith(agentIdentifier)
+  expect(lazyFeatureLoader).toHaveBeenCalledWith(FEATURE_NAMES.sessionReplay, 'aggregate')
+  expect(mockAggregate).toHaveBeenCalledWith(agentIdentifier, aggregator, aggregateArgs)
+})
+
+test('should not import session aggregate when session is not new and a recording is not active', async () => {
+  jest.mocked(getConfigurationValue).mockReturnValue(true)
+  jest.mocked(setupAgentSession).mockReturnValue({
+    isNew: false,
+    state: {
+      sessionReplay: 0
+    }
+  })
+
+  const instrument = new InstrumentBase(agentIdentifier, aggregator, FEATURE_NAMES.sessionReplay)
+  const aggregateArgs = { [faker.datatype.uuid()]: faker.lorem.sentence() }
+  instrument.importAggregator(aggregateArgs)
+
+  const windowLoadCallback = jest.mocked(onWindowLoad).mock.calls[0][0]
+  await windowLoadCallback()
+
+  expect(getConfigurationValue).toHaveBeenCalledWith(agentIdentifier, 'privacy.cookies_enabled')
+  expect(setupAgentSession).toHaveBeenCalledWith(agentIdentifier)
+  expect(drain).toHaveBeenCalledWith(agentIdentifier, FEATURE_NAMES.sessionReplay)
+  expect(lazyFeatureLoader).not.toHaveBeenCalled()
+  expect(mockAggregate).not.toHaveBeenCalled()
+})
+
+test('feature still imports by default even when setupAgentSession throws an error', async () => {
+  jest.mocked(getConfigurationValue).mockReturnValue(true)
+  jest.mocked(setupAgentSession).mockImplementation(() => { throw new Error(faker.lorem.sentence()) })
+
+  const instrument = new InstrumentBase(agentIdentifier, aggregator, featureName)
+  const aggregateArgs = { [faker.datatype.uuid()]: faker.lorem.sentence() }
+  instrument.abortHandler = jest.fn()
+  instrument.importAggregator(aggregateArgs)
+
+  const windowLoadCallback = jest.mocked(onWindowLoad).mock.calls[0][0]
+  await windowLoadCallback()
+
+  expect(onWindowLoad).toHaveBeenCalledWith(expect.any(Function), true)
+  expect(instrument.abortHandler).not.toHaveBeenCalled()
+  expect(warn).toHaveBeenCalledWith(expect.stringContaining('A problem occurred when starting up session manager'), expect.any(Error))
+  expect(lazyFeatureLoader).toHaveBeenCalled()
+  expect(mockAggregate).toHaveBeenCalled()
+  await expect(instrument.onAggregateImported).resolves.toBe(true)
+})
+
+test('no uncaught async exception is thrown when an import fails', async () => {
+  jest.mocked(lazyFeatureLoader).mockRejectedValue(new Error('ChunkLoadError')) // () => { throw new Error('ChunkLoadError: loading chunk xxx failed.') })
+  const mockOnError = jest.fn()
+  global.onerror = mockOnError
+
+  const instrument = new InstrumentBase(agentIdentifier, aggregator, featureName)
+  instrument.abortHandler = jest.fn()
+  instrument.importAggregator()
+
+  const windowLoadCallback = jest.mocked(onWindowLoad).mock.calls[0][0]
+  await windowLoadCallback()
+
+  expect(warn).toHaveBeenNthCalledWith(2, expect.stringContaining(`Downloading and initializing ${featureName} failed`), expect.any(Error))
+  expect(instrument.abortHandler).toHaveBeenCalled()
+  await expect(instrument.onAggregateImported).resolves.toBe(false)
+  expect(mockOnError).not.toHaveBeenCalled()
+})

package/src/features/utils/lazy-feature-loader.test.js

@@ -0,0 +1,37 @@
+import { faker } from '@faker-js/faker'
+import { FEATURE_NAMES } from '../../loaders/features/features'
+import { lazyFeatureLoader } from './lazy-feature-loader'
+
+// Use enableAutomock to make it easier to mock all the things that get imported by the aggregators
+jest.enableAutomock()
+// Unmock the file under test and the constants file
+jest.unmock('../../loaders/features/features')
+jest.unmock('./lazy-feature-loader')
+
+test.each(Object.keys(FEATURE_NAMES))('should import the aggregate for feature %s', async (key) => {
+  const featureName = FEATURE_NAMES[key]
+  const randomId = faker.datatype.uuid()
+
+  jest.setMock(`../${featureName}/aggregate`, {
+    id: randomId,
+    featureName
+  })
+
+  const result = await lazyFeatureLoader(featureName, 'aggregate')
+
+  expect(result.id).toEqual(randomId)
+  expect(result.featureName).toEqual(featureName)
+})
+
+test('should throw an error when the featureName is not supported', async () => {
+  const featureName = faker.datatype.uuid()
+
+  expect(() => lazyFeatureLoader(featureName, 'aggregate')).toThrow()
+})
+
+test('should return undefined when the featurePart is not supported', async () => {
+  const featureName = faker.datatype.uuid()
+  const featurePart = faker.datatype.uuid()
+
+  expect(lazyFeatureLoader(featureName, featurePart)).toBeUndefined()
+})

package/src/index.js

@@ -1,9 +1,7 @@
 export { Agent } from './loaders/agent'
 export { BrowserAgent } from './loaders/browser-agent'
 export { WorkerAgent } from './loaders/worker-agent'
-
-/** IN-PROGRESS -- DOES NOT CURRENTLY WORK CORRECTLY */
-// export { MicroAgent } from './loaders/micro-agent'
+export { MicroAgent } from './loaders/micro-agent'
 
 export { Ajax } from './features/ajax'
 export { JSErrors } from './features/jserrors'

package/src/loaders/agent.js

@@ -12,6 +12,7 @@ import { generateRandomHexString } from '../common/ids/unique-id'
 import { getConfiguration, getInfo, getLoaderConfig, getRuntime } from '../common/config/config'
 import { warn } from '../common/util/console'
 import { stringify } from '../common/util/stringify'
+import { globalScope } from '../common/constants/runtime'
 
 /**
  * A flexible class that may be used to compose an agent from a select subset of feature modules. In applications
@@ -19,12 +20,18 @@ import { stringify } from '../common/util/stringify'
  */
 export class Agent {
   constructor (options, agentIdentifier = generateRandomHexString(16)) {
+    if (!globalScope) {
+      // We could not determine the runtime environment. Short-circuite the agent here
+      // to avoid possible exceptions later that may cause issues with customer's application.
+      warn('Failed to initial the agent. Could not determine the runtime environment.')
+      return
+    }
+
     this.agentIdentifier = agentIdentifier
     this.sharedAggregator = new Aggregator({ agentIdentifier: this.agentIdentifier })
     this.features = {}
 
     this.desiredFeatures = new Set(options.features || []) // expected to be a list of static Instrument/InstrumentBase classes, see "spa.js" for example
-
     // For Now... ALL agents must make the rum call whether the page_view_event feature was enabled or not.
     // NR1 creates an index on the rum call, and if not seen for a few days, will remove the browser app!
     // Future work is being planned to evaluate removing this behavior from the backend, but for now we must ensure this call is made

package/src/loaders/api/api.js

@@ -9,7 +9,7 @@ import { ee } from '../../common/event-emitter/contextual-ee'
 import { now } from '../../common/timing/now'
 import { drain, registerDrain } from '../../common/drain/drain'
 import { onWindowLoad } from '../../common/window/load'
-import { isWorkerScope } from '../../common/util/global-scope'
+import { isBrowserScope } from '../../common/constants/runtime'
 import { warn } from '../../common/util/console'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants'
 import { gosCDN } from '../../common/window/nreum'
@@ -157,7 +157,7 @@ export function setAPI (agentIdentifier, forceDrain) {
   }
 
   // theres no window.load event on non-browser scopes, lazy load immediately
-  if (isWorkerScope) lazyLoad()
+  if (!isBrowserScope) lazyLoad()
   // try to stay out of the way of the window.load event, lazy load once that has finished.
   else onWindowLoad(() => lazyLoad(), true)
 

package/src/loaders/api/apiAsync.js

@@ -4,8 +4,8 @@ import { ee } from '../../common/event-emitter/contextual-ee'
 import { handle } from '../../common/event-emitter/handle'
 import { registerHandler } from '../../common/event-emitter/register-handler'
 import { single } from '../../common/util/invoke'
-import { submitData } from '../../common/util/submit-data'
-import { isBrowserScope } from '../../common/util/global-scope'
+import * as submitData from '../../common/util/submit-data'
+import { isBrowserScope } from '../../common/constants/runtime'
 import { CUSTOM_METRIC_CHANNEL } from '../../features/metrics/constants'
 
 export function setAPI (agentIdentifier) {
@@ -78,7 +78,7 @@ export function setAPI (agentIdentifier) {
     url += 'fe=' + ~~fe_time + '&'
     url += 'c=' + cycle
 
-    submitData.img({ url })
+    submitData.xhr({ url })
   }
 
   function setErrorHandler (t, handler) {

package/src/loaders/configure/configure.js

@@ -2,7 +2,7 @@ import { setAPI, setTopLevelCallers } from '../api/api'
 import { addToNREUM, gosCDN, gosNREUMInitializedAgents } from '../../common/window/nreum'
 import { setConfiguration, setInfo, setLoaderConfig, setRuntime } from '../../common/config/config'
 import { activateFeatures, activatedFeatures } from '../../common/util/feature-flags'
-import { isWorkerScope } from '../../common/util/global-scope'
+import { isWorkerScope } from '../../common/constants/runtime'
 
 export function configure (agentIdentifier, opts = {}, loaderType, forceDrain) {
   let { init, info, loader_config, runtime = { loaderType }, exposed = true } = opts

package/src/loaders/features/featureDependencies.js

@@ -6,6 +6,8 @@ export function getFeatureDependencyNames (feature) {
       return [FEATURE_NAMES.jserrors]
     case FEATURE_NAMES.sessionTrace:
       return [FEATURE_NAMES.ajax, FEATURE_NAMES.pageViewEvent]
+    case FEATURE_NAMES.sessionReplay:
+      return [FEATURE_NAMES.sessionTrace]
     case FEATURE_NAMES.pageViewTiming:
       return [FEATURE_NAMES.pageViewEvent] // this could change if we disconnect window load timings
     default:

package/src/loaders/micro-agent.js

@@ -1,4 +1,5 @@
 // loader files
+import { Instrument as PVE } from '../features/page_view_event/instrument'
 import { getEnabledFeatures } from './features/enabled-features'
 import { configure } from './configure/configure'
 // core files
@@ -8,21 +9,18 @@ import { generateRandomHexString } from '../common/ids/unique-id'
 import { getConfiguration, getInfo, getLoaderConfig, getRuntime } from '../common/config/config'
 import { FEATURE_NAMES } from './features/features'
 import { warn } from '../common/util/console'
+import { onWindowLoad } from '../common/window/load'
 
 const nonAutoFeatures = [
   FEATURE_NAMES.jserrors,
-  FEATURE_NAMES.pageAction
-]
-
-const autoFeatures = [
+  FEATURE_NAMES.pageAction,
   FEATURE_NAMES.metrics
 ]
 
 /**
- * A minimal agent class designed to be loaded multiple times on the same page, each instance narrowly scoped to the
- * concerns of a particular component, as with the micro-frontend architectural pattern. This class does not
- * automatically instrument. Instead, each MicroAgent instance may be configured to lazy-load specific
- * instrumentations at runtime, and to report desired data, events, and errors programatically.
+ * A minimal agent class designed to only respond to manual user input. As such, this class does not
+ * automatically instrument. Instead, each MicroAgent instance will lazy load the required features and can support loading multiple instances on one page.
+ * Out of the box, it can manually handle and report Page View, Page Action, and Error events.
  */
 export class MicroAgent {
   /**
@@ -51,28 +49,26 @@ export class MicroAgent {
   start () {
     try {
       const enabledFeatures = getEnabledFeatures(this.agentIdentifier)
-      autoFeatures.forEach(f => {
-        if (enabledFeatures[f]) {
-          // TODO - THIS does not work, the instrument switch in lazy loader increases the size of the worker build.  Needs to be revisited
-          import(/* webpackChunkName: "lazy-feature-loader" */ '../features/utils/lazy-feature-loader').then(({ lazyFeatureLoader }) => {
-            return lazyFeatureLoader(f, 'instrument')
-          }).then(({ Instrument }) => {
-            this.features[f] = new Instrument(this.agentIdentifier, this.sharedAggregator)
-          }).catch(err =>
-            warn('Something prevented the agent from being downloaded.'))
-        }
-      })
-      nonAutoFeatures.forEach(f => {
-        if (enabledFeatures[f]) {
-          // TODO - THIS does not work, the instrument switch in lazy loader increases the size of the worker build.  Needs to be revisited
-          // Parts of the lazy-loader were removed because webpack was transpiling them into the worker build, errantly inflating the build size.
-          import(/* webpackChunkName: "lazy-feature-loader" */ '../features/utils/lazy-feature-loader').then(({ lazyFeatureLoader }) => {
-            return lazyFeatureLoader(f, 'aggregate')
-          }).then(({ Aggregate }) => {
-            this.features[f] = new Aggregate(this.agentIdentifier, this.sharedAggregator)
-          }).catch(err =>
-            warn('Something prevented the agent from being downloaded.'))
-        }
+
+      try {
+        // a biproduct of doing this is that the "session manager" is automatically handled through importing this feature
+        this.features.page_view_event = new PVE(this.agentIdentifier, this.sharedAggregator)
+      } catch (err) {
+        warn('Something prevented the agent from instrumenting.', err)
+      }
+
+      onWindowLoad(() => {
+        // these features do not import an "instrument" file, meaning they are only hooked up to the API.
+        nonAutoFeatures.forEach(f => {
+          if (enabledFeatures[f]) {
+            import(/* webpackChunkName: "lazy-feature-loader" */ '../features/utils/lazy-feature-loader').then(({ lazyFeatureLoader }) => {
+              return lazyFeatureLoader(f, 'aggregate')
+            }).then(({ Aggregate }) => {
+              this.features[f] = new Aggregate(this.agentIdentifier, this.sharedAggregator)
+            }).catch(err =>
+              warn('Something prevented the agent from being downloaded.', err))
+          }
+        })
       })
       gosNREUMInitializedAgents(this.agentIdentifier, this.features, 'features')
       return this

package/dist/cjs/common/browser-version/firefox-version.js

@@ -1,17 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ffVersion = void 0;
-/*
- * Copyright 2020 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/* eslint-disable no-useless-escape */
-
-var ffVersion = 0;
-exports.ffVersion = ffVersion;
-var match = navigator.userAgent.match(/Firefox[\/\s](\d+\.\d+)/);
-if (match) exports.ffVersion = ffVersion = +match[1];

package/dist/cjs/common/browser-version/ios-version.js

@@ -1,19 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isiOS = exports.iOS_below16 = void 0;
-const isiOS = /(iPad|iPhone|iPod)/g.test(navigator.userAgent);
-
-/* Feature detection to get our version(s). */
-
-// Shared Web Workers introduced in iOS 16.0+ and n/a in 15.6-
-exports.isiOS = isiOS;
-const iOS_below16 = isiOS && Boolean(typeof SharedWorker === 'undefined');
-/*
-  ^ It was discovered in Safari 14 (https://bugs.webkit.org/show_bug.cgi?id=225305) that the buffered flag in PerformanceObserver
-  did not work. This affects our onFCP metric in particular since web-vitals uses that flag to retrieve paint timing entries.
-  This was fixed in v16+.
-*/
-exports.iOS_below16 = iOS_below16;