@newrelic/browser-agent 1.235.0 → 1.237.0

package/src/features/session_replay/aggregate/index.component-test.js

@@ -40,6 +40,14 @@ const agentIdentifier = 'abcd'
 const info = { licenseKey: 1234, applicationID: 9876 }
 const init = { session_replay: { enabled: true, sampleRate: 1, errorSampleRate: 0 } }
 
+const anyQuery = {
+  browser_monitoring_key: info.licenseKey,
+  type: 'SessionReplay',
+  app_id: Number(info.applicationID),
+  protocol_version: '0',
+  attributes: expect.any(String)
+}
+
 describe('Session Replay', () => {
   beforeEach(async () => {
     primeSessionAndReplay()
@@ -221,28 +229,11 @@ describe('Session Replay', () => {
       await wait(1)
       const harvestContents = sr.getHarvestContents()
       // query attrs
-      expect(harvestContents.qs).toMatchObject({
-        protocol_version: '0',
-        content_encoding: 'gzip',
-        browser_monitoring_key: info.licenseKey
-      })
+      expect(harvestContents.qs).toMatchObject(anyQuery)
 
-      expect(harvestContents.body).toMatchObject({
-        type: 'SessionReplay',
-        appId: info.applicationID,
-        timestamp: expect.any(Number),
-        blob: expect.any(String),
-        attributes: {
-          session: session.state.value,
-          hasSnapshot: expect.any(Boolean),
-          hasError: expect.any(Boolean),
-          agentVersion: expect.any(String),
-          isFirstChunk: expect.any(Boolean),
-          'nr.rrweb.version': expect.any(String)
-        }
-      })
+      expect(harvestContents.body).toEqual(expect.any(Array))
 
-      expect(JSON.parse(harvestContents.body.blob).length).toBeGreaterThan(0)
+      expect(harvestContents.body.length).toBeGreaterThan(0)
     })
   })
 
@@ -253,26 +244,10 @@ describe('Session Replay', () => {
       sr.ee.emit('rumresp-sr', [true])
       await wait(1)
       const [harvestContents] = sr.prepareHarvest()
-      expect(harvestContents.qs).toMatchObject({
-        protocol_version: '0',
-        content_encoding: 'gzip',
-        browser_monitoring_key: info.licenseKey
-      })
+      expect(harvestContents.qs).toMatchObject(anyQuery)
+      expect(harvestContents.qs.attributes.includes('content_encoding=gzip')).toEqual(true)
       expect(harvestContents.body).toEqual(expect.any(Uint8Array))
-      expect(JSON.parse(strFromU8(gunzipSync(harvestContents.body)))).toMatchObject({
-        type: 'SessionReplay',
-        appId: info.applicationID,
-        timestamp: expect.any(Number),
-        blob: expect.any(String),
-        attributes: {
-          session: session.state.value,
-          hasSnapshot: expect.any(Boolean),
-          hasError: expect.any(Boolean),
-          agentVersion: expect.any(String),
-          isFirstChunk: expect.any(Boolean),
-          'nr.rrweb.version': expect.any(String)
-        }
-      })
+      expect(JSON.parse(strFromU8(gunzipSync(harvestContents.body)))).toMatchObject(expect.any(Array))
     })
 
     test('Uncompressed payload is provided to harvester', async () => {
@@ -289,24 +264,10 @@ describe('Session Replay', () => {
       const [harvestContents] = sr.prepareHarvest()
       expect(harvestContents.qs).toMatchObject({
         protocol_version: '0',
-        // content_encoding is omitted when the payload is not compressed
         browser_monitoring_key: info.licenseKey
       })
-      expect(harvestContents.qs.content_encoding).toBeUndefined()
-      expect(harvestContents.body).toMatchObject({
-        type: 'SessionReplay',
-        appId: info.applicationID,
-        timestamp: expect.any(Number),
-        blob: expect.any(String),
-        attributes: {
-          session: session.state.value,
-          hasSnapshot: expect.any(Boolean),
-          hasError: expect.any(Boolean),
-          agentVersion: expect.any(String),
-          isFirstChunk: expect.any(Boolean),
-          'nr.rrweb.version': expect.any(String)
-        }
-      })
+      expect(harvestContents.qs.attributes.includes('content_encoding')).toEqual(false)
+      expect(harvestContents.body).toEqual(expect.any(Array))
     })
 
     test('Clears the event buffer when staged for harvesting', async () => {
@@ -363,6 +324,6 @@ function wait (ms = 0) {
 
 function primeSessionAndReplay (sess = new SessionEntity({ agentIdentifier, key: 'SESSION', storage: new LocalMemory() })) {
   session = sess
-  configure(agentIdentifier, { info, runtime: { session } }, 'test', true)
+  configure(agentIdentifier, { info, runtime: { session }, init: {} }, 'test', true)
   sr = new SessionReplayAgg(agentIdentifier, new Aggregator({}))
 }

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

@@ -19,6 +19,7 @@ import { getConfigurationValue, getInfo, getRuntime } from '../../../common/conf
 import { SESSION_EVENTS, MODE } from '../../../common/session/session-entity'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { sharedChannel } from '../../../common/constants/shared-channel'
+import { obj as encodeObj } from '../../../common/url/encode'
 
 // would be better to get this dynamically in some way
 export const RRWEB_VERSION = '2.0.0-alpha.8'
@@ -31,8 +32,8 @@ let recorder, gzipper, u8
 export const MAX_PAYLOAD_SIZE = 1000000
 /** Unloading caps around 64kb */
 export const IDEAL_PAYLOAD_SIZE = 64000
-/** Interval between forcing new full snapshots in "error" mode */
-const CHECKOUT_MS = 30000
+/** Interval between forcing new full snapshots -- 30 seconds in error mode, 5 minutes in full mode */
+const CHECKOUT_MS = { [MODE.ERROR]: 30000, [MODE.FULL]: 300000, [MODE.OFF]: 0 }
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
@@ -65,6 +66,9 @@ export class Aggregate extends AggregateBase {
     /** Payload metadata -- Should indicate that the payload being sent contains an error.  Used for query/filter purposes in UI */
     this.hasError = false
 
+    /** Payload metadata -- Should indicate when a replay blob started recording.  Resets each time a harvest occurs. */
+    this.timestamp = { first: undefined, last: undefined }
+
     /** A value which increments with every new mutation node reported. Resets after a harvest is sent */
     this.payloadBytesEstimation = 0
 
@@ -91,7 +95,7 @@ export class Aggregate extends AggregateBase {
       })
 
       // Bespoke logic for new endpoint.  This will change as downstream dependencies become solidified.
-      this.scheduler = new HarvestScheduler('blob', {
+      this.scheduler = new HarvestScheduler('browser/blobs', {
         onFinished: this.onHarvestFinished.bind(this),
         retryDelay: this.harvestTimeSeconds,
         getPayload: this.prepareHarvest.bind(this),
@@ -112,8 +116,7 @@ export class Aggregate extends AggregateBase {
             this.startRecording()
             this.scheduler.startTimer(this.harvestTimeSeconds)
 
-            const { session } = getRuntime(this.agentIdentifier)
-            session.state.sessionReplay = this.mode
+            this.syncWithSessionManager({ sessionReplay: this.mode })
           }
         }
       }, this.featureName, this.ee)
@@ -187,11 +190,11 @@ export class Aggregate extends AggregateBase {
 
     this.isFirstChunk = !!session.isNew
 
-    session.state.sessionReplay = this.mode
+    this.syncWithSessionManager({ sessionReplay: this.mode })
   }
 
   prepareHarvest () {
-    if (this.events.length === 0) return
+    if (this.events.length === 0 || (this.mode !== MODE.FULL && !this.blocked)) return
     const payload = this.getHarvestContents()
 
     if (this.shouldCompress) {
@@ -199,7 +202,6 @@ export class Aggregate extends AggregateBase {
       this.scheduler.opts.gzip = true
     } else {
       this.scheduler.opts.gzip = false
-      delete payload.qs.content_encoding
     }
     // TODO -- Gracefully handle the buffer for retries.
     this.clearBuffer()
@@ -211,24 +213,25 @@ export class Aggregate extends AggregateBase {
     const info = getInfo(this.agentIdentifier)
     return {
       qs: {
-        protocol_version: '0',
-        content_encoding: 'gzip',
-        browser_monitoring_key: info.licenseKey
-      },
-      body: {
+        browser_monitoring_key: info.licenseKey,
         type: 'SessionReplay',
-        appId: Number(info.applicationID),
-        timestamp: Date.now(),
-        blob: JSON.stringify(this.events), // this needs to be a stringified JSON array of rrweb nodes
-        attributes: {
+        app_id: info.applicationID,
+        protocol_version: '0',
+        attributes: encodeObj({
+          ...(this.shouldCompress && { content_encoding: 'gzip' }),
+          'replay.firstTimestamp': this.timestamp.first,
+          'replay.lastTimestamp': this.timestamp.last,
+          'replay.durationMs': this.timestamp.last - this.timestamp.first,
+          agentVersion: agentRuntime.version,
           session: agentRuntime.session.state.value,
           hasSnapshot: this.hasSnapshot,
           hasError: this.hasError,
-          agentVersion: agentRuntime.version,
           isFirstChunk: this.isFirstChunk,
+          decompressedBytes: this.payloadBytesEstimation,
           'nr.rrweb.version': RRWEB_VERSION
-        }
-      }
+        }, MAX_PAYLOAD_SIZE - this.payloadBytesEstimation).substring(1) // remove the leading '&'
+      },
+      body: this.events
     }
   }
 
@@ -248,6 +251,7 @@ export class Aggregate extends AggregateBase {
     this.hasSnapshot = false
     this.hasError = false
     this.payloadBytesEstimation = 0
+    this.clearTimestamps()
   }
 
   /** Begin recording using configured recording lib */
@@ -256,8 +260,8 @@ export class Aggregate extends AggregateBase {
       warn('Recording library was never imported')
       return this.abort()
     }
+    this.recording = true
     const { blockClass, ignoreClass, maskTextClass, blockSelector, maskInputOptions, maskTextSelector, maskAllInputs } = getConfigurationValue(this.agentIdentifier, 'session_replay')
-    this.hasSnapshot = true
     // set up rrweb configurations for maximum privacy --
     // https://newrelic.atlassian.net/wiki/spaces/O11Y/pages/2792293280/2023+02+28+Browser+-+Session+Replay#Configuration-options
     const stop = recorder({
@@ -269,11 +273,9 @@ export class Aggregate extends AggregateBase {
       maskInputOptions,
       maskTextSelector,
       maskAllInputs,
-      ...(this.mode === MODE.ERROR && { checkoutEveryNms: CHECKOUT_MS })
+      checkoutEveryNms: CHECKOUT_MS[this.mode]
     })
 
-    this.recording = true
-
     this.stopRecording = () => {
       this.recording = false
       stop()
@@ -299,12 +301,15 @@ export class Aggregate extends AggregateBase {
       this.clearBuffer()
     }
 
+    this.setTimestamps(event)
+    if (event.type === 2) this.hasSnapshot = true
+
     this.events.push(event)
     this.payloadBytesEstimation += eventBytes
 
     // We are making an effort to try to keep payloads manageable for unloading.  If they reach the unload limit before their interval,
     // it will send immediately.  This often happens on the first snapshot, which can be significantly larger than the other payloads.
-    if (payloadSize > IDEAL_PAYLOAD_SIZE) {
+    if (payloadSize > IDEAL_PAYLOAD_SIZE && this.mode !== MODE.ERROR) {
       // if we've made it to the ideal size of ~64kb before the interval timer, we should send early.
       this.scheduler.runHarvest()
     }
@@ -314,7 +319,16 @@ export class Aggregate extends AggregateBase {
   takeFullSnapshot () {
     if (!recorder) return
     recorder.takeFullSnapshot()
-    this.hasSnapshot = true
+  }
+
+  setTimestamps (rrwebEvent) {
+    if (!rrwebEvent) return
+    if (!this.timestamp.first) this.timestamp.first = rrwebEvent.timestamp
+    this.timestamp.last = rrwebEvent.timestamp
+  }
+
+  clearTimestamps () {
+    this.timestamp = { first: undefined, last: undefined }
   }
 
   /** Estimate the payload size */
@@ -328,9 +342,9 @@ export class Aggregate extends AggregateBase {
     this.blocked = true
     this.mode = MODE.OFF
     this.stopRecording()
+    this.syncWithSessionManager({ sessionReplay: this.mode })
+    this.clearTimestamps()
     this.ee.emit('REPLAY_ABORTED')
-    const { session } = getRuntime(this.agentIdentifier)
-    session.state.sessionReplay = this.mode
   }
 
   /** Extensive research has yielded about an 88% compression factor on these payloads.
@@ -341,4 +355,9 @@ export class Aggregate extends AggregateBase {
     if (this.shouldCompress) return data * AVG_COMPRESSION
     return data
   }
+
+  syncWithSessionManager (state = {}) {
+    const { session } = getRuntime(this.agentIdentifier)
+    session.write(state)
+  }
 }

package/src/features/session_replay/replay-mode.js

@@ -15,8 +15,8 @@ export async function getSessionReplayMode (agentId) {
     const newrelic = gosNREUM()
     // Should be enabled by configuration and using an agent build that includes it (via checking that the instrument class was initialized).
     if (getConfigurationValue(agentId, 'session_replay.enabled') && typeof newrelic.initializedAgents[agentId].features.session_replay === 'object') {
-      await newrelic.initializedAgents[agentId].features.session_replay.onAggregateImported // if Replay could not initialize, this throws a (uncaught) rejection
-      return await sharedChannel.sessionReplayInitialized // wait for replay to determine which mode it's after running its sampling logic
+      const srInitialized = await newrelic.initializedAgents[agentId].features.session_replay.onAggregateImported
+      if (srInitialized) return await sharedChannel.sessionReplayInitialized // wait for replay to determine which mode it's after running its sampling logic
     }
   } catch (e) { /* exception ==> off */ }
   return MODE.OFF // at any step of the way s.t. SR cannot be on by implication or is explicitly off

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

@@ -97,8 +97,8 @@ export class Aggregate extends AggregateBase {
       const stopTracePerm = () => {
         if (sessionEntity.state.sessionTraceMode !== MODE.OFF) sessionEntity.write({ sessionTraceMode: MODE.OFF })
         operationalGate.permanentlyDecide(false)
-        this.#scheduler?.stopTimer(true)
         if (mostRecentModeKnown === MODE.FULL) this.#scheduler?.runHarvest() // allow queued nodes (past opGate) to final harvest, unless they were buffered in other modes
+        this.#scheduler?.stopTimer(true) // the 'true' arg here will forcibly block any future call to runHarvest, so the last runHarvest above must be prior
         this.#scheduler = null
       }
 
@@ -122,9 +122,8 @@ export class Aggregate extends AggregateBase {
           this.ee.on(SESSION_EVENTS.PAUSE, () => mostRecentModeKnown = sessionEntity.state.sessionTraceMode)
 
           if (!sessionEntity.isNew) { // inherit the same mode as existing session's Trace
-            const existingTraceMode = mostRecentModeKnown = sessionEntity.state.sessionTraceMode
-            if (existingTraceMode === MODE.OFF) this.isStandalone = true
-            controlTraceOp(existingTraceMode)
+            if (sessionEntity.state.sessionReplay === MODE.OFF) this.isStandalone = true
+            controlTraceOp(mostRecentModeKnown = sessionEntity.state.sessionTraceMode)
           } else { // for new sessions, see the truth table associated with NEWRELIC-8662 wrt the new Trace behavior under session management
             const replayMode = await getSessionReplayMode(agentIdentifier)
             if (replayMode === MODE.OFF) this.isStandalone = true // without SR, Traces are still subject to old harvest limits

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

@@ -8,7 +8,7 @@ import { now } from '../../../common/timing/now'
 import { InstrumentBase } from '../../utils/instrument-base'
 import * as CONSTANTS from '../constants'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
-import { isBrowserScope } from '../../../common/util/global-scope'
+import { isBrowserScope } from '../../../common/constants/runtime'
 
 const {
   BST_RESOURCE, RESOURCE, START, END, FEATURE_NAME, FN_END, FN_START, PUSH_STATE

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

@@ -674,7 +674,7 @@ export class Aggregate extends AggregateBase {
     function onHarvestFinished (result) {
       if (result.sent && result.retry && state.interactionsSent.length > 0) {
         state.interactionsSent.forEach(function (interaction) {
-          state.interactionsToHarvest.push(interaction)
+          state.interactionsToHarvest.unshift(interaction)
         })
         state.interactionsSent = []
       }

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

@@ -10,7 +10,7 @@ import { InstrumentBase } from '../../utils/instrument-base'
 import { getRuntime } from '../../../common/config/config'
 import { now } from '../../../common/timing/now'
 import * as CONSTANTS from '../constants'
-import { isBrowserScope } from '../../../common/util/global-scope'
+import { isBrowserScope } from '../../../common/constants/runtime'
 
 const {
   FEATURE_NAME, START, END, BODY, CB_END, JS_TIME, FETCH, FN_START, CB_START, FN_END

package/src/features/utils/agent-session.test.js

@@ -35,7 +35,7 @@ beforeEach(() => {
     __esModule: true,
     registerHandler: jest.fn()
   }))
-  jest.doMock('../../common/util/global-scope', () => ({
+  jest.doMock('../../common/constants/runtime', () => ({
     __esModule: true,
     isBrowserScope: true
   }))
@@ -161,7 +161,7 @@ test('should set custom session data', async () => {
 })
 
 test('should not set custom session data in worker scope', async () => {
-  const globalScope = await import('../../common/util/global-scope')
+  const globalScope = await import('../../common/constants/runtime')
   jest.replaceProperty(globalScope, 'isBrowserScope', false)
 
   const { setInfo } = await import('../../common/config/config')

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

@@ -7,10 +7,10 @@
 import { drain, registerDrain } from '../../common/drain/drain'
 import { FeatureBase } from './feature-base'
 import { onWindowLoad } from '../../common/window/load'
-import { isBrowserScope } from '../../common/util/global-scope'
+import { isBrowserScope } from '../../common/constants/runtime'
 import { warn } from '../../common/util/console'
 import { FEATURE_NAMES } from '../../loaders/features/features'
-import { getConfigurationValue } from '../../common/config/config'
+import { getConfigurationValue, originals } from '../../common/config/config'
 
 /**
  * Base class for instrumenting a feature.
@@ -55,9 +55,9 @@ export class InstrumentBase extends FeatureBase {
   importAggregator (argsObjFromInstrument = {}) {
     if (this.featAggregate || !this.auto) return
     const enableSessionTracking = isBrowserScope && getConfigurationValue(this.agentIdentifier, 'privacy.cookies_enabled') === true
-    let loadedSuccessfully, loadFailed
-    this.onAggregateImported = new Promise((resolve, reject) => {
-      loadedSuccessfully = resolve; loadFailed = reject
+    let loadedSuccessfully
+    this.onAggregateImported = new Promise(resolve => {
+      loadedSuccessfully = resolve
     })
 
     const importLater = async () => {
@@ -78,17 +78,18 @@ export class InstrumentBase extends FeatureBase {
       try {
         if (!this.shouldImportAgg(this.featureName, session)) {
           drain(this.agentIdentifier, this.featureName)
+          loadedSuccessfully(false) // aggregate module isn't loaded at all
           return
         }
         const { lazyFeatureLoader } = await import(/* webpackChunkName: "lazy-feature-loader" */ './lazy-feature-loader')
         const { Aggregate } = await lazyFeatureLoader(this.featureName, 'aggregate')
         this.featAggregate = new Aggregate(this.agentIdentifier, this.aggregator, argsObjFromInstrument)
-        loadedSuccessfully()
+        loadedSuccessfully(true)
       } catch (e) {
         warn(`Downloading and initializing ${this.featureName} failed...`, e)
         this.abortHandler?.() // undo any important alterations made to the page
         // not supported yet but nice to do: "abort" this agent's EE for this feature specifically
-        loadFailed()
+        loadedSuccessfully(false)
       }
     }
 
@@ -105,15 +106,11 @@ export class InstrumentBase extends FeatureBase {
  * @returns
  */
   shouldImportAgg (featureName, session) {
-  // if this isnt the FIRST load of a session AND
-  // we are not actively recording SR... DO NOT run the aggregator
-  // session replay samples can only be decided on the first load of a session
-  // session replays can continue if in progress
     if (featureName === FEATURE_NAMES.sessionReplay) {
-      if (getConfigurationValue(this.agentIdentifier, 'session_trace.enabled') === false) return false
-      return !!session?.isNew || !!session?.state.sessionReplay
+      if (!originals.MO) return false // Session Replay cannot work without Mutation Observer
+      if (getConfigurationValue(this.agentIdentifier, 'session_trace.enabled') === false) return false // Session Replay as of now is tightly coupled with Session Trace in the UI
+      return !!session?.isNew || !!session?.state.sessionReplay // Session Replay should only try to run if already running from a previous page, or at the beginning of a session
     }
-    // todo -- add case like above for session trace
     return true
   }
 }

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

@@ -7,7 +7,7 @@ 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/util/global-scope'
+import * as globalScopeModule from '../../common/constants/runtime'
 import { FEATURE_NAMES } from '../../loaders/features/features'
 
 jest.enableAutomock()
@@ -22,7 +22,7 @@ jest.mock('../../common/window/load', () => ({
   __esModule: true,
   onWindowLoad: jest.fn()
 }))
-jest.mock('../../common/util/global-scope', () => ({
+jest.mock('../../common/constants/runtime', () => ({
   __esModule: true,
   isBrowserScope: undefined,
   isWorkerScope: undefined
@@ -31,6 +31,13 @@ jest.mock('../../common/config/config', () => ({
   __esModule: true,
   getConfigurationValue: jest.fn()
 }))
+jest.mock('../../common/config/config', () => ({
+  __esModule: true,
+  getConfigurationValue: jest.fn(),
+  originals: {
+    MO: jest.fn()
+  }
+}))
 jest.mock('./feature-base', () => ({
   __esModule: true,
   FeatureBase: jest.fn(function (...args) {
@@ -57,7 +64,7 @@ beforeEach(() => {
   aggregator = {}
   featureName = faker.datatype.uuid()
 
-  mockAggregate = jest.fn(() => { /* noop */ })
+  mockAggregate = jest.fn()
   jest.mocked(lazyFeatureLoader).mockResolvedValue({ Aggregate: mockAggregate })
 })
 
@@ -187,4 +194,23 @@ test('feature still imports by default even when setupAgentSession throws an err
   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/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-base.js

@@ -0,0 +1,81 @@
+import { warn } from '../common/util/console'
+
+export class AgentBase {
+  /**
+   * Reports a browser PageAction event along with a name and optional attributes.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/addpageaction/}
+   * @param {string} name Name or category of the action. Reported as the actionName attribute.
+   * @param {object} [attributes] JSON object with one or more key/value pairs. For example: {key:"value"}. The key is reported as its own PageAction attribute with the specified values.
+   */
+  addPageAction (name, attributes) {
+    warn('Call to agent api addPageAction failed. The session trace feature is not currently initialized.')
+  }
+
+  /**
+   * Groups page views to help URL structure or to capture the URL's routing information.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setpageviewname/}
+   * @param {string} name The page name you want to use. Use alphanumeric characters.
+   * @param {string} [host] Default is http://custom.transaction. Typically set host to your site's domain URI.
+   */
+  setPageViewName (name, host) {
+    warn('Call to agent api setPageViewName failed. The page view feature is not currently initialized.')
+  }
+
+  /**
+   * Adds a user-defined attribute name and value to subsequent events on the page.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setcustomattribute/}
+   * @param {string} name Name of the attribute. Appears as column in the PageView event. It will also appear as a column in the PageAction event if you are using it.
+   * @param {string|number|null} value Value of the attribute. Appears as the value in the named attribute column in the PageView event. It will appear as a column in the PageAction event if you are using it. Custom attribute values cannot be complex objects, only simple types such as Strings and Integers.
+   * @param {boolean} [persist] Default false. f set to true, the name-value pair will also be set into the browser's storage API. Then on the following instrumented pages that load within the same session, the pair will be re-applied as a custom attribute.
+   */
+  setCustomAttribute (name, value, persist) {
+    warn('Call to agent api setCustomAttribute failed. The js errors feature is not currently initialized.')
+  }
+
+  /**
+   * Identifies a browser error without disrupting your app's operations.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/noticeerror/}
+   * @param {Error|string} error Provide a meaningful error message that you can use when analyzing data on browser's JavaScript errors page.
+   * @param {object} [customAttributes] An object containing name/value pairs representing custom attributes.
+   */
+  noticeError (error, customAttributes) {
+    warn('Call to agent api noticeError failed. The js errors feature is not currently initialized.')
+  }
+
+  /**
+   * Adds a user-defined identifier string to subsequent events on the page.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setuserid/}
+   * @param {string|null} value A string identifier for the end-user, useful for tying all browser events to specific users. The value parameter does not have to be unique. If IDs should be unique, the caller is responsible for that validation. Passing a null value unsets any existing user ID.
+   */
+  setUserId (value) {
+    warn('Call to agent api setUserId failed. The js errors feature is not currently initialized.')
+  }
+
+  /**
+   * Allows selective ignoring and grouping of known errors that the browser agent captures.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/seterrorhandler/}
+   * @param {(error: Error|string) => boolean | { group: string }} callback When an error occurs, the callback is called with the error object as a parameter. The callback will be called with each error, so it is not specific to one error.
+   */
+  setErrorHandler (callback) {
+    warn('Call to agent api setErrorHandler failed. The js errors feature is not currently initialized.')
+  }
+
+  /**
+   * Records an additional time point as "finished" in a session trace, and sends the event to New Relic.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/finished/}
+   * @param {number} [timeStamp] Defaults to the current time of the call. If used, this marks the time that the page is "finished" according to your own criteria.
+   */
+  finished (timeStamp) {
+    warn('Call to agent api finished failed. The page action feature is not currently initialized.')
+  }
+
+  /**
+   * Adds a unique name and ID to identify releases with multiple JavaScript bundles on the same page.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/addrelease/}
+   * @param {string} name A short description of the component; for example, the name of a project, application, file, or library.
+   * @param {string} id The ID or version of this release; for example, a version number, build number from your CI environment, GitHub SHA, GUID, or a hash of the contents.
+   */
+  addRelease (name, id) {
+    warn('Call to agent api addRelease failed. The agent is not currently initialized.')
+  }
+}