npm - @newrelic/browser-agent - Versions diffs - 1.234.0 → 1.235.0 - Mend

@newrelic/browser-agent 1.234.0 → 1.235.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (196) hide show

package/src/common/util/submit-data.test.js CHANGED Viewed

@@ -3,30 +3,30 @@
  * @jest-environment-options {"html": "<html><head><script></script></head><body></body></html>", "url": "https://example.com/"}
  */
+import { faker } from '@faker-js/faker'
 import { submitData } from './submit-data'
+import * as globalScope from './global-scope'
-const mockWorkerScope = jest.fn().mockImplementation(() => false)
-jest.mock('./global-scope', () => ({
-  __esModule: true,
-  get isWorkerScope () {
-    return mockWorkerScope()
-  }
-}))
+jest.mock('./global-scope')
 const url = 'https://example.com/api'
-beforeEach(() => {
+afterEach(() => {
   jest.restoreAllMocks()
-  mockWorkerScope.mockReturnValue(false)
 })
 describe('submitData.jsonp', () => {
-  // This test requires a script tag to exist in the html set by this file's jest-environment-options header block.
-  test('should return an HTMLScriptElement when called from a web window environment', () => {
-    mockWorkerScope.mockReturnValue(false)
+  beforeEach(() => {
+    jest.replaceProperty(globalScope, 'isWorkerScope', false)
+  })
-    const jsonp = 'callback'
+  afterEach(() => {
+    delete global.importScripts
+  })
+  // This test requires a script tag to exist in the html set by this file's jest-environment-options header block.
+  test('should return an HTMLScriptElement when called from a web window environment', () => {
+    const jsonp = faker.datatype.uuid()
     const result = submitData.jsonp({ url, jsonp })
     expect(result).toBeInstanceOf(HTMLScriptElement)
@@ -35,125 +35,141 @@ describe('submitData.jsonp', () => {
   })
   test('should try to use importScripts when called from a worker scope', () => {
-    mockWorkerScope.mockReturnValueOnce(true)
-    const jsonp = 'callback'
+    jest.replaceProperty(globalScope, 'isWorkerScope', true)
     global.importScripts = jest.fn()
+    const jsonp = faker.datatype.uuid()
     submitData.jsonp({ url, jsonp })
-    expect(importScripts).toHaveBeenCalledWith(url + '&jsonp=' + jsonp)
-    delete global.importScripts
+    expect(global.importScripts).toHaveBeenCalledWith(url + '&jsonp=' + jsonp)
   })
-  test('should fall back to an xhrGet call and return false when called from a worker scope', () => {
-    mockWorkerScope.mockReturnValueOnce(true)
-    const jsonp = 'callback'
+  test('should fall back to an xhrGet call and return false when importScripts throws an error', () => {
+    jest.replaceProperty(globalScope, 'isWorkerScope', true)
     jest.spyOn(submitData, 'xhrGet').mockImplementation(jest.fn())
+    global.importScripts = jest.fn().mockImplementation(() => { throw new Error(faker.lorem.sentence()) })
+    const jsonp = faker.datatype.uuid()
     const result = submitData.jsonp({ url, jsonp })
     expect(result).toBe(false)
-    expect(submitData.xhrGet).toHaveBeenCalledTimes(1)
+    expect(global.importScripts).toHaveBeenCalledWith(url + '&jsonp=' + jsonp)
+    expect(submitData.xhrGet).toHaveBeenCalledWith({ url: url + '&jsonp=' + jsonp })
   })
-  test('should not throw an error if any error occurs during execution', () => {
-    jest.spyOn(document, 'createElement').mockImplementation(() => { throw new Error('message') })
+  test('should not throw an error when xhrGet throws an error', () => {
+    jest.replaceProperty(globalScope, 'isWorkerScope', true)
+    jest.spyOn(submitData, 'xhrGet').mockImplementation(() => { throw new Error(faker.lorem.sentence()) })
+    global.importScripts = jest.fn().mockImplementation(() => { throw new Error(faker.lorem.sentence()) })
-    const jsonp = 'callback'
+    const jsonp = faker.datatype.uuid()
-    expect(() => {
-      submitData.jsonp({ url, jsonp })
-    }).not.toThrow()
+    expect(() => submitData.jsonp({ url, jsonp })).not.toThrow()
   })
-})
-describe('submitData.xhrGet', () => {
-  test('should return an XMLHttpRequest object', () => {
-    const result = submitData.xhrGet({ url })
-    expect(result).toBeInstanceOf(XMLHttpRequest)
-  })
+  test('should not throw an error when element insertion fails', () => {
+    jest.spyOn(document, 'createElement').mockImplementation(() => { throw new Error(faker.lorem.sentence()) })
-  test('should not throw an error if URL is not provided', () => {
-    expect(() => {
-      submitData.xhrGet({})
-    }).not.toThrow()
-  })
+    const jsonp = faker.datatype.uuid()
-  test('should not throw an error if an invalid URL is provided', () => {
-    expect(() => {
-      submitData.xhrGet({ url: 'invalid url' })
-    }).not.toThrow()
+    expect(() => submitData.jsonp({ url, jsonp })).not.toThrow()
   })
 })
-describe('submitData.xhr', () => {
-  test('should return an XMLHttpRequest object', () => {
+describe('submitData.xhrGet', () => {
+  test('xhrGet should call xhr with GET as the method', () => {
+    jest.spyOn(submitData, 'xhr').mockReturnValue(new XMLHttpRequest())
     const result = submitData.xhrGet({ url })
-    expect(result).toBeInstanceOf(XMLHttpRequest)
-  })
-  test('should not throw an error if URL is not provided', () => {
-    expect(() => {
-      submitData.xhr({})
-    }).not.toThrow()
+    expect(result).toBeInstanceOf(XMLHttpRequest)
+    expect(submitData.xhr).toHaveBeenCalledWith({ url, sync: false, method: 'GET' })
   })
+})
-  test('should not throw an error if an invalid URL is provided', () => {
-    expect(() => {
-      submitData.xhr({ url: 'invalid url' })
-    }).not.toThrow()
+describe('submitData.xhr', () => {
+  beforeEach(() => {
+    jest.spyOn(global, 'XMLHttpRequest').mockImplementation(function () {
+      this.prototype = XMLHttpRequest.prototype
+      this.open = jest.fn()
+      this.send = jest.fn()
+      this.setRequestHeader = jest.fn()
+      this._withCredentials = false
+      Object.defineProperty(this, 'withCredentials', {
+        get: jest.fn(() => this._withCredentials),
+        set: jest.fn((val) => this._withCredentials = val)
+      })
+    })
   })
-  test('should send a POST request by default', () => {
-    jest.spyOn(XMLHttpRequest.prototype, 'open')
+  test('should make and send an xhr with default values', () => {
+    const result = submitData.xhr({ url })
+    const xhr = jest.mocked(global.XMLHttpRequest).mock.instances[0]
-    submitData.xhr({ url })
-    expect(XMLHttpRequest.prototype.open).toHaveBeenCalledWith('POST', url, true)
+    expect(result).toBeInstanceOf(XMLHttpRequest)
+    expect(result.withCredentials).toBe(true)
+    expect(xhr.open).toHaveBeenCalledWith('POST', url, true)
+    expect(xhr.setRequestHeader).toHaveBeenCalledWith('content-type', 'text/plain')
+    expect(xhr.send).toHaveBeenCalledWith(null)
   })
-  test('should send a GET request if specified', () => {
-    jest.spyOn(XMLHttpRequest.prototype, 'open')
-    submitData.xhr({ url, method: 'GET' })
+  test('should send the body when provided', () => {
+    const body = faker.lorem.paragraph()
+    submitData.xhr({ url, body })
+    const xhr = jest.mocked(global.XMLHttpRequest).mock.instances[0]
-    expect(XMLHttpRequest.prototype.open).toHaveBeenCalledWith('GET', url, true)
+    expect(xhr.send).toHaveBeenCalledWith(body)
   })
-  // This test requires a same-origin url to be set by this file's jest-environment-options header block.
-  test('should send a request synchronously if specified', () => {
-    jest.spyOn(XMLHttpRequest.prototype, 'open')
+  test('should set async to false', () => {
     submitData.xhr({ url, sync: true })
+    const xhr = jest.mocked(global.XMLHttpRequest).mock.instances[0]
-    expect(XMLHttpRequest.prototype.open).toHaveBeenCalledWith('POST', url, false)
+    expect(xhr.open).toHaveBeenCalledWith('POST', url, false)
   })
-  test('should set custom headers if provided', () => {
-    const headers = [{ key: 'Content-Type', value: 'application/json' }]
+  test('should use the provided method', () => {
+    submitData.xhr({ url, method: 'HEAD' })
+    const xhr = jest.mocked(global.XMLHttpRequest).mock.instances[0]
-    jest.spyOn(XMLHttpRequest.prototype, 'setRequestHeader')
+    expect(xhr.open).toHaveBeenCalledWith('HEAD', url, true)
+  })
+  test('should use the provided headers', () => {
+    const headers = [{ key: faker.lorem.word(), value: faker.datatype.uuid() }]
     submitData.xhr({ url, headers })
+    const xhr = jest.mocked(global.XMLHttpRequest).mock.instances[0]
-    headers.forEach((header) => {
-      expect(XMLHttpRequest.prototype.setRequestHeader).toHaveBeenCalledWith(header.key, header.value)
-    })
+    expect(xhr.setRequestHeader).not.toHaveBeenCalledWith('content-type', 'text/plain')
+    expect(xhr.setRequestHeader).toHaveBeenCalledWith(headers[0].key, headers[0].value)
   })
-  test('should send a request with the specified body', () => {
-    const body = JSON.stringify({ key: 'value' })
+  test('should not throw an error if withCredentials is not supported', () => {
+    jest.spyOn(global, 'XMLHttpRequest').mockImplementation(function () {
+      this.prototype = XMLHttpRequest.prototype
+      this.open = jest.fn()
+      this.send = jest.fn()
+      this.setRequestHeader = jest.fn()
+    })
-    jest.spyOn(XMLHttpRequest.prototype, 'send')
+    expect(() => submitData.xhr({ url })).not.toThrow()
+  })
-    submitData.xhr({ url, body })
+  test('should not throw an error if setRequestHeader throws an error', () => {
+    jest.spyOn(global, 'XMLHttpRequest').mockImplementation(function () {
+      this.prototype = XMLHttpRequest.prototype
+      this.open = jest.fn()
+      this.send = jest.fn()
+      this.setRequestHeader = jest.fn()
-    expect(XMLHttpRequest.prototype.send).toHaveBeenCalledWith(body)
+      Object.defineProperty(this, 'withCredentials', {
+        get: jest.fn().mockImplementation(() => { throw new Error(faker.lorem.sentence()) }),
+        set: jest.fn().mockImplementation(() => { throw new Error(faker.lorem.sentence()) })
+      })
+    })
+    expect(() => submitData.xhr({ url })).not.toThrow()
   })
 })
@@ -164,55 +180,47 @@ describe('submitData.img', () => {
     const result = submitData.img({ url: imageUrl })
     expect(result).toBeInstanceOf(HTMLImageElement)
-  })
-  test('should not throw an error if URL is not provided', () => {
-    expect(() => {
-      submitData.img({})
-    }).not.toThrow()
-  })
-  test('should set the src attribute of the image element to the provided URL', () => {
-    const imageUrl = 'https://example.com/image.png'
-    const result = submitData.img({ url: imageUrl })
     expect(result.src).toBe(imageUrl)
   })
 })
 describe('submitData.beacon', () => {
-  test('should return true when beacon request succeeds', () => {
-    const body = JSON.stringify({ key: 'value' })
+  afterEach(() => {
+    delete window.navigator.sendBeacon
+  })
-    window.navigator.sendBeacon = {
-      bind: jest.fn(() => () => true)
-    }
+  test('should return true when beacon request succeeds', () => {
+    window.navigator.sendBeacon = jest.fn().mockReturnValue(true)
+    const body = faker.lorem.paragraph()
     const result = submitData.beacon({ url, body })
     expect(result).toBe(true)
+    expect(window.navigator.sendBeacon).toHaveBeenCalledWith(url, body)
   })
-  test('should return false when beacon request fails', () => {
-    const body = JSON.stringify({ key: 'value' })
+  test('should return false when beacon request returns false', () => {
+    window.navigator.sendBeacon = jest.fn().mockReturnValue(false)
-    window.navigator.sendBeacon = {
-      bind: jest.fn(() => () => { throw new Error('message') })
-    }
+    const result = submitData.beacon({ url })
-    const result = submitData.beacon({ url, body })
+    expect(result).toBe(false)
+  })
+  test('should return false when beacon request throws an error', () => {
+    window.navigator.sendBeacon = jest.fn(() => { throw new Error(faker.lorem.sentence()) })
+    const result = submitData.beacon({ url })
     expect(result).toBe(false)
   })
-  test('should error if sendBeacon is not supported', () => {
-    const body = JSON.stringify({ key: 'value' })
+  test('should always bind window.navigator to the sendBeacon function', () => {
+    window.navigator.sendBeacon = jest.fn().mockReturnValue(true)
+    window.navigator.sendBeacon.bind = jest.fn(() => {})
-    window.navigator.sendBeacon = undefined
+    submitData.beacon({ url })
-    expect(() => {
-      submitData.beacon({ url, body })
-    }).toThrow()
+    expect(window.navigator.sendBeacon.bind).toHaveBeenCalledWith(window.navigator)
   })
 })

package/src/common/wrap/wrap-raf.js CHANGED Viewed

@@ -4,7 +4,7 @@
  */
 /**
  * @file Wraps `window.requestAnimationFrame` for instrumentation.
- * This module is used by: jserror, session_trace.
+ * This module is used by: jserror.
  */
 import { ee as baseEE } from '../event-emitter/contextual-ee'

package/src/common/wrap/wrap-timer.js CHANGED Viewed

@@ -4,7 +4,7 @@
  */
 /**
  * @file Wraps native timeout and interval methods for instrumentation.
- * This module is used by: jserrors, session_trace, spa.
+ * This module is used by: jserrors, spa.
  */
 import { ee as baseEE } from '../event-emitter/contextual-ee'

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

@@ -32,6 +32,7 @@ export class Aggregate extends AggregateBase {
     super(agentIdentifier, aggregator, FEATURE_NAME)
     this.stackReported = {}
+    this.observedAt = {}
     this.pageviewReported = {}
     this.errorCache = {}
     this.currentBody
@@ -171,6 +172,7 @@ export class Aggregate extends AggregateBase {
     if (!this.stackReported[bucketHash]) {
       this.stackReported[bucketHash] = true
       params.stack_trace = truncateSize(stackInfo.stackString)
+      this.observedAt[bucketHash] = agentRuntime.offset + time
     } else {
       params.browser_stack_hash = stringHashCode(stackInfo.stackString)
     }
@@ -186,6 +188,9 @@ export class Aggregate extends AggregateBase {
       this.pageviewReported[bucketHash] = true
     }
+    if (agentRuntime?.session?.state?.sessionReplay) params.hasReplay = true
+    params.firstOccurrenceTimestamp = this.observedAt[bucketHash]
     var type = internal ? 'ierr' : 'err'
     var newMetrics = { time: time }

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

@@ -38,7 +38,7 @@ export class Instrument extends InstrumentBase {
           return true
         })
         this.thrown = true
-        notice(err, undefined, thisInstrument.ee)
+        handle('err', [err, now()], undefined, FEATURE_NAMES.jserrors, thisInstrument.ee)
       }
     })
     thisInstrument.ee.on('fn-end', function () {
@@ -89,7 +89,7 @@ export class Instrument extends InstrumentBase {
     try {
       if (this.skipNext) this.skipNext -= 1
-      else notice(errorObj || new UncaughtException(message, filename, lineno), true, this.ee)
+      else handle('err', [errorObj || new UncaughtException(message, filename, lineno), now()], undefined, FEATURE_NAMES.jserrors, this.ee)
     } catch (e) {
       try {
         handle('ierr', [e, now(), true], undefined, FEATURE_NAMES.jserrors, this.ee)
@@ -113,19 +113,6 @@ function UncaughtException (message, filename, lineno) {
   this.line = lineno
 }
-/**
- * Adds a timestamp and emits the 'err' event, which the error aggregator listens for
- * @param {Error} err
- * @param {boolean} doNotStamp
- * @param {ContextualEE} ee
- */
-function notice (err, doNotStamp, ee) {
-  // by default add timestamp, unless specifically told not to
-  // this is to preserve existing behavior
-  var time = (!doNotStamp) ? now() : null
-  handle('err', [err, time], undefined, FEATURE_NAMES.jserrors, ee)
-}
 /**
  * Attempts to cast an unhandledPromiseRejection reason (reject(...)) to an Error object
  * @param {*} reason - The reason property from an unhandled promise rejection