@newrelic/browser-agent 1.233.0 → 1.234.0

package/src/common/event-emitter/contextual-ee.test.js

@@ -101,7 +101,7 @@ describe('event-emitter context', () => {
 })
 
 describe('event-emitter buffer', () => {
-  it('it should create a new buffer for the given group', async () => {
+  test('it should create a new buffer for the given group', async () => {
     const { ee } = await import('./contextual-ee')
     const eventType = faker.datatype.uuid()
     const group = faker.datatype.uuid()
@@ -114,7 +114,7 @@ describe('event-emitter buffer', () => {
     expect(ee.isBuffering(eventType)).toEqual(true)
   })
 
-  it('it should default group to "feature"', async () => {
+  test('it should default group to "feature"', async () => {
     const { ee } = await import('./contextual-ee')
     const eventType = faker.datatype.uuid()
 
@@ -126,7 +126,7 @@ describe('event-emitter buffer', () => {
     expect(ee.isBuffering(eventType)).toEqual(true)
   })
 
-  it('it should not create buffer if event-emitter is aborted', async () => {
+  test('it should not create buffer if event-emitter is aborted', async () => {
     const { ee } = await import('./contextual-ee')
     const eventType = faker.datatype.uuid()
     const group = faker.datatype.uuid()
@@ -169,7 +169,7 @@ describe('event-emitter abort', () => {
 })
 
 describe('event-emitter emit', () => {
-  it('should execute the listener', async () => {
+  test('should execute the listener', async () => {
     const { ee } = await import('./contextual-ee')
     const mockListener = jest.fn()
     const eventType = faker.datatype.uuid()
@@ -181,7 +181,7 @@ describe('event-emitter emit', () => {
     expect(mockListener).toHaveBeenCalledWith(eventArgs[0], eventArgs[1], eventArgs[2])
   })
 
-  it('should not execute the listener after removal', async () => {
+  test('should not execute the listener after removal', async () => {
     const { ee } = await import('./contextual-ee')
     const mockListener = jest.fn()
     const eventType = faker.datatype.uuid()
@@ -195,7 +195,7 @@ describe('event-emitter emit', () => {
     expect(mockListener).toHaveBeenCalledTimes(1)
   })
 
-  it('should return early if global event-emitter is aborted', async () => {
+  test('should return early if global event-emitter is aborted', async () => {
     const { ee } = await import('./contextual-ee')
     const mockListener = jest.fn()
     const eventType = faker.datatype.uuid()
@@ -211,7 +211,7 @@ describe('event-emitter emit', () => {
     expect(mockListener).toHaveBeenCalledTimes(0)
   })
 
-  it('should still emit if global event-emitter is aborted but force flag is true', async () => {
+  test('should still emit if global event-emitter is aborted but force flag is true', async () => {
     const { ee } = await import('./contextual-ee')
     const scopeEE = ee.get(faker.datatype.uuid())
     const mockScopeListener = jest.fn()
@@ -228,7 +228,7 @@ describe('event-emitter emit', () => {
     expect(mockScopeListener).toHaveBeenCalledTimes(1)
   })
 
-  it('should bubble the event if bubble flag is true', async () => {
+  test('should bubble the event if bubble flag is true', async () => {
     const { ee } = await import('./contextual-ee')
     const scopeEE = ee.get(faker.datatype.uuid())
     const mockListener = jest.fn()
@@ -244,7 +244,7 @@ describe('event-emitter emit', () => {
     expect(mockListener).toHaveBeenCalledTimes(1)
   })
 
-  it('should not bubble the event if bubble flag is false', async () => {
+  test('should not bubble the event if bubble flag is false', async () => {
     const { ee } = await import('./contextual-ee')
     const scopeEE = ee.get(faker.datatype.uuid())
     const mockListener = jest.fn()
@@ -260,7 +260,7 @@ describe('event-emitter emit', () => {
     expect(mockListener).not.toHaveBeenCalled()
   })
 
-  it('should buffer the event on the scoped event-emitter', async () => {
+  test('should buffer the event on the scoped event-emitter', async () => {
     const { ee } = await import('./contextual-ee')
     const scopeEE = ee.get(faker.datatype.uuid())
     const mockListener = jest.fn()

package/src/common/harvest/harvest-scheduler.js

@@ -13,6 +13,17 @@ import { getConfigurationValue } from '../config/config'
  * Periodically invokes harvest calls and handles retries
  */
 export class HarvestScheduler extends SharedContext {
+  /**
+     * Create a HarvestScheduler
+     * @param {string} endpoint - The base BAM endpoint name -- ex. 'events'
+     * @param {object} opts - The options used to configure the HarvestScheduler
+     * @param {Function} opts.onFinished - The callback to be fired when a harvest has finished
+     * @param {Function} opts.getPayload - A callback which can be triggered to return a payload for harvesting
+     * @param {number} opts.retryDelay - The number of seconds to wait before retrying after a network failure
+     * @param {boolean} opts.raw - Use a prefabricated payload shape as the harvest payload without the need for formatting
+     * @param {string} opts.customUrl - A custom url that falls outside of the shape of the standard BAM harvester url pattern.  Will use directly instead of concatenating various pieces
+     * @param {*} parent - The parent object, whose state can be passed into SharedContext
+     */
   constructor (endpoint, opts, parent) {
     super(parent) // gets any allowed properties from the parent and stores them in `sharedContext`
     this.endpoint = endpoint
@@ -78,7 +89,12 @@ export class HarvestScheduler extends SharedContext {
       const retry = submitMethod.method === submitData.xhr
       var payload = this.opts.getPayload({ retry: retry })
 
-      if (!payload) return
+      if (!payload) {
+        if (this.started) {
+          this.scheduleHarvest()
+        }
+        return
+      }
 
       payload = Object.prototype.toString.call(payload) === '[object Array]' ? payload : [payload]
       harvests.push(...payload)
@@ -103,9 +119,8 @@ export class HarvestScheduler extends SharedContext {
         opts,
         submitMethod,
         cbFinished: onHarvestFinished,
-        includeBaseParams: this.opts.includeBaseParams,
         customUrl: this.opts.customUrl,
-        gzip: this.opts.gzip
+        raw: this.opts.raw
       })
     })
 

package/src/common/harvest/harvest-scheduler.test.js

@@ -0,0 +1,25 @@
+import { setConfiguration } from '../config/state/init'
+import { HarvestScheduler } from './harvest-scheduler'
+
+describe('runHarvest', () => {
+  test('should re-schedule harvest even if there is no accumulated data', () => {
+    setConfiguration('asdf', {})
+    const scheduler = new HarvestScheduler('events', { getPayload: jest.fn() }, { agentIdentifier: 'asdf', ee: { on: jest.fn() } })
+    scheduler.started = true
+    jest.spyOn(scheduler, 'scheduleHarvest')
+    scheduler.runHarvest()
+    expect(scheduler.opts.getPayload()).toBeFalsy()
+    expect(scheduler.scheduleHarvest).toHaveBeenCalledTimes(1)
+  })
+
+  test('should also re-schedule harvest if there is accumulated data', () => {
+    setConfiguration('asdf', {})
+    const scheduler = new HarvestScheduler('events', { getPayload: jest.fn().mockImplementation(() => 'payload') }, { agentIdentifier: 'asdf', ee: { on: jest.fn() } })
+    scheduler.started = true
+    scheduler.harvest._send = () => {}
+    jest.spyOn(scheduler, 'scheduleHarvest')
+    scheduler.runHarvest()
+    expect(scheduler.opts.getPayload()).toBeTruthy()
+    expect(scheduler.scheduleHarvest).toHaveBeenCalledTimes(1)
+  })
+})

package/src/common/harvest/harvest.js

@@ -92,23 +92,26 @@ export class Harvest extends SharedContext {
     return this._send({ ...spec, payload })
   }
 
-  _send ({ endpoint, payload = {}, opts = {}, submitMethod, cbFinished, customUrl, gzip, includeBaseParams = true }) {
+  _send ({ endpoint, payload = {}, opts = {}, submitMethod, cbFinished, customUrl, raw, includeBaseParams = true }) {
     var info = getInfo(this.sharedContext.agentIdentifier)
     if (!info.errorBeacon) return false
 
     var agentRuntime = getRuntime(this.sharedContext.agentIdentifier)
 
-    if (!payload.body) { // no payload body? nothing to send, just run onfinish stuff and return
+    if (!payload.body && !opts?.sendEmptyBody) { // no payload body? nothing to send, just run onfinish stuff and return
       if (cbFinished) {
         cbFinished({ sent: false })
       }
       return false
     }
 
-    var url = customUrl || this.getScheme() + '://' + info.errorBeacon + '/' + endpoint + '/1/' + info.licenseKey + '?'
+    let url = ''
+    if (customUrl) url = customUrl
+    else if (raw) url = `${this.getScheme()}://${info.errorBeacon}/${endpoint}`
+    else url = `${this.getScheme()}://${info.errorBeacon}${endpoint !== 'rum' ? `/${endpoint}` : ''}/1/${info.licenseKey}`
 
-    var baseParams = includeBaseParams ? this.baseQueryString() : ''
-    var params = payload.qs ? encodeObj(payload.qs, agentRuntime.maxBytes) : ''
+    var baseParams = !raw && includeBaseParams ? this.baseQueryString() : ''
+    var payloadParams = payload.qs ? encodeObj(payload.qs, agentRuntime.maxBytes) : ''
     if (!submitMethod) {
       submitMethod = getSubmitMethod(endpoint, opts)
     }
@@ -116,7 +119,9 @@ export class Harvest extends SharedContext {
     var useBody = submitMethod.useBody
 
     var body
-    var fullUrl = url + baseParams + params
+    var fullUrl = `${url}?${baseParams}${payloadParams}`
+
+    const gzip = payload?.qs?.content_encoding === 'gzip'
 
     if (!gzip) {
       if (useBody && endpoint === 'events') {
@@ -135,13 +140,7 @@ export class Harvest extends SharedContext {
 
     const headers = []
 
-    if (gzip) {
-      headers.push({ key: 'content-type', value: 'application/json' })
-      headers.push({ key: 'X-Browser-Monitoring-Key', value: info.licenseKey })
-      headers.push({ key: 'Content-Encoding', value: 'gzip' })
-    } else {
-      headers.push({ key: 'content-type', value: 'text/plain' })
-    }
+    headers.push({ key: 'content-type', value: 'text/plain' })
 
     /* Since workers don't support sendBeacon right now, or Image(), they can only use XHR method.
         Because they still do permit synch XHR, the idea is that at final harvest time (worker is closing),
@@ -209,6 +208,7 @@ export class Harvest extends SharedContext {
       if (singlePayload.body) mapOwn(singlePayload.body, makeBody)
       if (singlePayload.qs) mapOwn(singlePayload.qs, makeQueryString)
     }
+
     return { body: makeBody(), qs: makeQueryString() }
   }
 
@@ -224,17 +224,12 @@ export class Harvest extends SharedContext {
   }
 }
 
-function or (a, b) { return a || b }
-
 export function getSubmitMethod (endpoint, opts) {
   opts = opts || {}
   var method
   var useBody
 
-  if (opts.needResponse) { // currently: only STN needs a response
-    useBody = true
-    method = submitData.xhr
-  } else if (opts.unload && isBrowserScope) { // all the features' final harvest; neither methods work outside window context
+  if (opts.unload && isBrowserScope) { // all the features' final harvest; neither methods work outside window context
     useBody = haveSendBeacon
     method = haveSendBeacon ? submitData.beacon : submitData.img // really only IE doesn't have Beacon API for web browsers
   } else {
@@ -264,7 +259,7 @@ function createAccumulator () {
   var accumulator = {}
   var hasData = false
   return function (key, val) {
-    if (val !== null && val !== undefined && val.length) {
+    if (val !== null && val !== undefined && val.toString()?.length) {
       accumulator[key] = val
       hasData = true
     }

package/src/common/harvest/harvest.test.js

@@ -0,0 +1,169 @@
+import { submitData } from '../util/submit-data'
+import { Harvest } from './harvest'
+
+jest.mock('../context/shared-context', () => ({
+  __esModule: true,
+  SharedContext: function () {
+    this.sharedContext = {
+      agentIdentifier: 'abcd'
+    }
+  }
+}))
+jest.mock('../config/config', () => ({
+  __esModule: true,
+  getConfigurationValue: jest.fn(),
+  getInfo: jest.fn().mockReturnValue({
+    errorBeacon: 'example.com',
+    licenseKey: 'abcd'
+  }),
+  getRuntime: jest.fn().mockReturnValue({
+    bytesSent: {},
+    queryBytesSent: {}
+  })
+}))
+jest.mock('../util/submit-data', () => ({
+  __esModule: true,
+  submitData: {
+    xhr: jest.fn(() => ({
+      addEventListener: jest.fn()
+    })),
+    beacon: jest.fn(),
+    img: jest.fn()
+  }
+}))
+
+describe('sendX', () => {
+  test.each([null, undefined, false])('should not send request when body is empty and sendEmptyBody is %s', (sendEmptyBody) => {
+    const sendCallback = jest.fn()
+    const harvester = new Harvest()
+    harvester.on('jserrors', () => ({
+      body: {},
+      qs: {}
+    }))
+
+    harvester.sendX({ endpoint: 'jserrors', cbFinished: sendCallback })
+
+    expect(sendCallback).toHaveBeenCalledWith({ sent: false })
+    expect(submitData.xhr).not.toHaveBeenCalled()
+    expect(submitData.img).not.toHaveBeenCalled()
+    expect(submitData.beacon).not.toHaveBeenCalled()
+  })
+
+  test('should send request when body is empty and sendEmptyBody is true', () => {
+    const harvester = new Harvest()
+    harvester.on('jserrors', () => ({
+      body: {},
+      qs: {}
+    }))
+
+    harvester.sendX({ endpoint: 'jserrors', opts: { sendEmptyBody: true }, cbFinished: jest.fn() })
+
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('https://example.com/jserrors/1/abcd?'),
+      body: undefined
+    }))
+    expect(submitData.img).not.toHaveBeenCalled()
+    expect(submitData.beacon).not.toHaveBeenCalled()
+  })
+
+  test.each([null, undefined, []])('should remove %s values from the body and query string when sending', (emptyValue) => {
+    const harvester = new Harvest()
+    harvester.on('jserrors', () => ({
+      body: { bar: 'foo', empty: emptyValue },
+      qs: { foo: 'bar', empty: emptyValue }
+    }))
+
+    harvester.sendX({ endpoint: 'jserrors', cbFinished: jest.fn() })
+
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('&foo=bar'),
+      body: JSON.stringify({ bar: 'foo' })
+    }))
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.not.stringContaining('&empty'),
+      body: expect.not.stringContaining('empty')
+    }))
+    expect(submitData.img).not.toHaveBeenCalled()
+    expect(submitData.beacon).not.toHaveBeenCalled()
+  })
+
+  test.each([1, false, true])('should not remove value %s (when it doesn\'t have a length) from the body and query string when sending', (nonStringValue) => {
+    const harvester = new Harvest()
+    harvester.on('jserrors', () => ({
+      body: { bar: 'foo', nonString: nonStringValue },
+      qs: { foo: 'bar', nonString: nonStringValue }
+    }))
+
+    harvester.sendX({ endpoint: 'jserrors', cbFinished: jest.fn() })
+
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining(`&nonString=${nonStringValue}`),
+      body: JSON.stringify({ bar: 'foo', nonString: nonStringValue })
+    }))
+    expect(submitData.img).not.toHaveBeenCalled()
+    expect(submitData.beacon).not.toHaveBeenCalled()
+  })
+})
+
+describe('send', () => {
+  test.each([null, undefined, false])('should not send request when body is empty and sendEmptyBody is %s', (sendEmptyBody) => {
+    const sendCallback = jest.fn()
+    const harvester = new Harvest()
+
+    harvester.send({ endpoint: 'rum', payload: { qs: {}, body: {} }, opts: { sendEmptyBody }, cbFinished: sendCallback })
+
+    expect(sendCallback).toHaveBeenCalledWith({ sent: false })
+    expect(submitData.xhr).not.toHaveBeenCalled()
+    expect(submitData.img).not.toHaveBeenCalled()
+    expect(submitData.beacon).not.toHaveBeenCalled()
+  })
+
+  test('should send request when body is empty and sendEmptyBody is true', () => {
+    const harvester = new Harvest()
+
+    harvester.send({ endpoint: 'rum', payload: { qs: {}, body: {} }, opts: { sendEmptyBody: true } })
+
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('https://example.com/1/abcd?'),
+      body: undefined
+    }))
+    expect(submitData.img).not.toHaveBeenCalled()
+    expect(submitData.beacon).not.toHaveBeenCalled()
+  })
+
+  test.each([null, undefined, []])('should remove %s values from the body and query string when sending', (emptyValue) => {
+    const harvester = new Harvest()
+
+    harvester.send({
+      endpoint: 'rum',
+      payload: { qs: { foo: 'bar', empty: emptyValue }, body: { bar: 'foo', empty: emptyValue } }
+    })
+
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('&foo=bar'),
+      body: JSON.stringify({ bar: 'foo' })
+    }))
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.not.stringContaining('&empty'),
+      body: expect.not.stringContaining('empty')
+    }))
+    expect(submitData.img).not.toHaveBeenCalled()
+    expect(submitData.beacon).not.toHaveBeenCalled()
+  })
+
+  test.each([1, false, true])('should not remove value %s (when it doesn\'t have a length) from the body and query string when sending', (nonStringValue) => {
+    const harvester = new Harvest()
+
+    harvester.send({
+      endpoint: 'rum',
+      payload: { qs: { foo: 'bar', nonString: nonStringValue }, body: { bar: 'foo', nonString: nonStringValue } }
+    })
+
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining(`&nonString=${nonStringValue}`),
+      body: JSON.stringify({ bar: 'foo', nonString: nonStringValue })
+    }))
+    expect(submitData.img).not.toHaveBeenCalled()
+    expect(submitData.beacon).not.toHaveBeenCalled()
+  })
+})

package/src/common/session/session-entity.test.js

@@ -1,4 +1,3 @@
-
 import { LocalMemory } from '../storage/local-memory'
 import { LocalStorage } from '../storage/local-storage'
 

package/src/common/timer/timer.js

@@ -1,4 +1,3 @@
-
 export class Timer {
   constructor (opts, ms) {
     if (!opts.onEnd) throw new Error('onEnd handler is required')

package/src/common/url/encode.js

@@ -48,11 +48,11 @@ export function obj (payload, maxBytes) {
     var next
     var i
 
-    if (typeof dataArray === 'string') {
+    if (typeof dataArray === 'string' || (!Array.isArray(dataArray) && dataArray !== null && dataArray !== undefined && dataArray.toString().length)) {
       next = '&' + feature + '=' + qs(dataArray)
       total += next.length
       result += next
-    } else if (dataArray.length) {
+    } else if (Array.isArray(dataArray) && dataArray.length) {
       total += 9
       for (i = 0; i < dataArray.length; i++) {
         next = qs(stringify(dataArray[i]))

package/src/common/util/console.test.js

@@ -0,0 +1,34 @@
+import { warn } from './console'
+
+beforeEach(() => {
+  console.warn = jest.fn()
+})
+
+afterEach(() => {
+  jest.restoreAllMocks()
+})
+
+describe('warn', () => {
+  test('should not call console.warn if it is not a function', () => {
+    const spy = jest.spyOn(console, 'warn')
+    console.warn = undefined
+    warn('test message')
+    expect(spy).not.toHaveBeenCalled()
+  })
+
+  test('should call console.warn with a prefixed message', () => {
+    warn('test message')
+    expect(console.warn).toHaveBeenCalledWith('New Relic: test message')
+  })
+
+  test('should call console.warn with secondary argument if provided', () => {
+    const secondary = 'secondary value'
+    warn('test message', secondary)
+    expect(console.warn).toHaveBeenCalledWith(secondary)
+  })
+
+  test('should not call console.warn with secondary argument if not provided', () => {
+    warn('test message')
+    expect(console.warn).toHaveBeenCalledTimes(1)
+  })
+})

package/src/common/util/get-or-set.js

@@ -5,7 +5,14 @@
 
 var has = Object.prototype.hasOwnProperty
 
-// Always returns the current value of obj[prop], even if it has to set it first
+/**
+ * Always returns the current value of obj[prop], even if it has to set it first. Sets properties as non-enumerable if possible.
+ *
+ * @param {Object} obj - The object to get or set the property on.
+ * @param {string} prop - The name of the property.
+ * @param {Function} getVal - A function that returns the value to be set if the property does not exist.
+ * @returns {*} The value of the property in the object.
+ */
 export function getOrSet (obj, prop, getVal) {
   // If the value exists return it.
   if (has.call(obj, prop)) return obj[prop]

package/src/common/util/get-or-set.test.js

@@ -0,0 +1,58 @@
+import { getOrSet } from './get-or-set'
+
+test('should return the current value of an existing property', () => {
+  const obj = { foo: 'bar' }
+  const prop = 'foo'
+  const getVal = jest.fn()
+
+  const result = getOrSet(obj, prop, getVal)
+
+  expect(result).toBe('bar')
+  expect(getVal).not.toHaveBeenCalled()
+})
+
+test('should set and return the value from getVal if the property does not exist', () => {
+  const obj = {}
+  const prop = 'foo'
+  const getVal = jest.fn().mockReturnValue('baz')
+
+  const result = getOrSet(obj, prop, getVal)
+
+  expect(result).toBe('baz')
+  expect(getVal).toHaveBeenCalled()
+  expect(obj.foo).toBe('baz')
+})
+
+test('should set the property as non-enumerable if Object.defineProperty is supported', () => {
+  const obj = {}
+  const prop = 'foo'
+  const getVal = jest.fn().mockReturnValue('baz')
+
+  jest.spyOn(Object, 'defineProperty')
+
+  const result = getOrSet(obj, prop, getVal)
+
+  expect(result).toBe('baz')
+  expect(Object.defineProperty).toHaveBeenCalledWith(obj, prop, {
+    value: 'baz',
+    writable: true,
+    enumerable: false
+  })
+})
+
+test('should set the property from getVal if Object.defineProperty and Object.keys are not supported', () => {
+  const obj = {}
+  const prop = 'foo'
+  const getVal = jest.fn(() => 'baz')
+
+  const originalFn = Object.defineProperty
+  Object.defineProperty = null
+
+  const result = getOrSet(obj, prop, getVal)
+
+  expect(result).toBe('baz')
+  expect(obj.foo).toBe('baz')
+  expect(Object.prototype.propertyIsEnumerable.call(obj, 'foo')).toBe(true)
+
+  Object.defineProperty = originalFn
+})

package/src/common/util/stringify.test.js

@@ -0,0 +1,49 @@
+import { stringify } from './stringify'
+
+var mockEmit = jest.fn()
+jest.mock('../event-emitter/contextual-ee', () => ({
+  __esModule: true,
+  get ee () {
+    return { emit: mockEmit }
+  }
+}))
+
+test('should return a JSON string representation of the value', () => {
+  const obj = { a: 1, b: { nested: true } }
+  const expected = '{"a":1,"b":{"nested":true}}'
+
+  const result = stringify(obj)
+
+  expect(result).toBe(expected)
+})
+
+test('should handle circular references and exclude them from the JSON output', () => {
+  const obj = { a: 1 }
+  obj.b = obj // Create a circular reference
+  const expected = '{"a":1}'
+
+  const result = stringify(obj)
+
+  expect(result).toBe(expected)
+})
+
+test('should handle non-object values and return their string representation', () => {
+  const value = 42
+  const expected = '42'
+
+  const result = stringify(value)
+
+  expect(result).toBe(expected)
+})
+
+test('should emit an "internal-error" event if an error occurs during JSON.stringify', () => {
+  const obj = { a: 1 }
+
+  jest.spyOn(JSON, 'stringify').mockImplementation(() => {
+    throw new Error('message')
+  })
+
+  stringify(obj)
+
+  expect(mockEmit).toHaveBeenCalledWith('internal-error', expect.any(Array))
+})

package/src/common/util/submit-data.js

@@ -33,25 +33,32 @@ submitData.jsonp = function jsonp ({ url, jsonp }) {
       return element
     }
   } catch (err) {
-  // do nothing
+    // do nothing
   }
 }
 
+/**
+ * Performs an asynchronous GET request using XMLHttpRequest.
+ *
+ * @param {Object} args - An object containing a `url` property.
+ * @param {string} args.url - The URL to send the GET request to.
+ * @returns {XMLHttpRequest} - An XMLHttpRequest object.
+ */
 submitData.xhrGet = function xhrGet ({ url }) {
   return submitData.xhr({ url, sync: false, method: 'GET' })
 }
 
 /**
  * Send via XHR
- * @param {Object} args - The args
- * @param {string} args.url - The URL to send to
- * @param {string=} args.body - The Stringified body
- * @param {boolean=} args.sync - Run XHR as Synchronous
- * @param {string=} [args.method=POST] - The XHR method to use
- * @param {{key: string, value: string}[]} [args.headers] - The headers to attach
+ * @param {Object} args - The args.
+ * @param {string} args.url - The URL to send to.
+ * @param {string=} args.body - The Stringified body. Default null to prevent IE11 from breaking.
+ * @param {boolean=} args.sync - Run XHR synchronously.
+ * @param {string=} [args.method=POST] - The XHR method to use.
+ * @param {{key: string, value: string}[]} [args.headers] - The headers to attach.
  * @returns {XMLHttpRequest}
  */
-submitData.xhr = function xhr ({ url, body, sync, method = 'POST', headers = [{ key: 'content-type', value: 'text/plain' }] }) {
+submitData.xhr = function xhr ({ url, body = null, sync, method = 'POST', headers = [{ key: 'content-type', value: 'text/plain' }] }) {
   var request = new XMLHttpRequest()
 
   request.open(method, url, !sync)
@@ -70,13 +77,6 @@ submitData.xhr = function xhr ({ url, body, sync, method = 'POST', headers = [{
   return request
 }
 
-/**
- * Unused at the moment -- DEPRECATED
- */
-// submitData.xhrSync = function xhrSync (url, body) {
-//   return submitData.xhr(url, body, true)
-// }
-
 /**
  * Send by appending an <img> element to the page. Do NOT call this function outside of a guaranteed web window environment.
  * @param {Object} args - The args
@@ -84,7 +84,6 @@ submitData.xhr = function xhr ({ url, body, sync, method = 'POST', headers = [{
  * @returns {HTMLImageElement}
  */
 submitData.img = function img ({ url }) {
-  console.log('img url', url)
   var element = new Image()
   element.src = url
   return element