@newrelic/browser-agent 1.232.1 → 1.233.0

package/dist/cjs/common/session/session-entity.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.SessionEntity = void 0;
+exports.SessionEntity = exports.SESSION_EVENTS = void 0;
 var _uniqueId = require("../ids/unique-id");
 var _console = require("../util/console");
 var _stringify = require("../util/stringify");
@@ -18,15 +18,23 @@ var _configurable = require("../config/state/configurable");
 var _handle = require("../event-emitter/handle");
 var _constants2 = require("../../features/metrics/constants");
 var _features = require("../../loaders/features/features");
+// this is what can be stored in local storage (not enforced but probably should be)
+// these values should sync between local storage and the parent class props
 const model = {
   value: '',
   inactiveAt: 0,
   expiresAt: 0,
   updatedAt: Date.now(),
-  sessionReplayActive: false,
+  sessionReplay: 0,
   sessionTraceActive: false,
   custom: {}
 };
+const SESSION_EVENTS = {
+  PAUSE: 'session-pause',
+  RESET: 'session-reset',
+  RESUME: 'session-resume'
+};
+exports.SESSION_EVENTS = SESSION_EVENTS;
 class SessionEntity {
   /**
    * Create a self-managing Session Entity. This entity is scoped to the agent identifier which triggered it, allowing for multiple simultaneous session objects to exist.
@@ -48,13 +56,13 @@ class SessionEntity {
     } = _ref;
     if (!agentIdentifier || !key) throw new Error('Missing Required Fields');
     if (!_globalScope.isBrowserScope) this.storage = new _localMemory.LocalMemory();else this.storage = storageAPI;
+    this.state = {};
     this.sync(model);
     this.agentIdentifier = agentIdentifier;
-
     // key is intended to act as the k=v pair
     this.key = key;
     // value is intended to act as the primary value of the k=v pair
-    this.value = value;
+    this.state.value = value;
     this.expiresMs = expiresMs;
     this.inactiveMs = inactiveMs;
     this.ee = _contextualEe.ee.get(agentIdentifier);
@@ -71,7 +79,7 @@ class SessionEntity {
     // the set-up of the timer used to expire the session "naturally" at a certain time
     // this gets ignored if the value is falsy, allowing for session entities that do not expire
     if (expiresMs) {
-      this.expiresAt = initialRead?.expiresAt || this.getFutureTimestamp(expiresMs);
+      this.state.expiresAt = initialRead?.expiresAt || this.getFutureTimestamp(expiresMs);
       this.expiresTimer = new _timer.Timer({
         // When the inactive timer ends, collect a SM and reset the session
         onEnd: () => {
@@ -79,16 +87,16 @@ class SessionEntity {
           this.collectSM('duration', this);
           this.reset();
         }
-      }, this.expiresAt - Date.now());
+      }, this.state.expiresAt - Date.now());
     } else {
-      this.expiresAt = Infinity;
+      this.state.expiresAt = Infinity;
     }
 
     // the set-up of the timer used to expire the session due to "inactivity" at a certain time
     // this gets ignored if the value is falsy, allowing for session entities that do not expire
     // this gets "refreshed" when "activity" is observed
     if (inactiveMs) {
-      this.inactiveAt = initialRead?.inactiveAt || this.getFutureTimestamp(inactiveMs);
+      this.state.inactiveAt = initialRead?.inactiveAt || this.getFutureTimestamp(inactiveMs);
       this.inactiveTimer = new _interactionTimer.InteractionTimer({
         // When the inactive timer ends, collect a SM and reset the session
         onEnd: () => {
@@ -98,21 +106,27 @@ class SessionEntity {
         },
         // When the inactive timer refreshes, it will update the storage values with an update timestamp
         onRefresh: this.refresh.bind(this),
+        onResume: () => {
+          this.ee.emit(SESSION_EVENTS.RESUME);
+        },
         // When the inactive timer pauses, update the storage values with an update timestamp
-        onPause: () => this.write(new _configurable.Configurable(this.read(), model)),
+        onPause: () => {
+          if (this.initialized) this.ee.emit(SESSION_EVENTS.PAUSE);
+          this.write((0, _configurable.getModeledObject)(this.state, model));
+        },
         ee: this.ee,
         refreshEvents: ['click', 'keydown', 'scroll']
-      }, this.inactiveAt - Date.now());
+      }, this.state.inactiveAt - Date.now());
     } else {
-      this.inactiveAt = Infinity;
+      this.state.inactiveAt = Infinity;
     }
 
     // The fact that the session is "new" or pre-existing is used in some places in the agent.  Session Replay and Trace
     // can use this info to inform whether to trust a new sampling decision vs continue a previous tracking effort.
-    this.isNew = !Object.keys(initialRead).length;
+    if (this.isNew === undefined) this.isNew = !Object.keys(initialRead).length;
     // if its a "new" session, we write to storage API with the default values.  These values may change over the lifespan of the agent run.
-    // we can use configurable here to help us know and manage what values are being used. -- see "model" above
-    if (this.isNew) this.write(new _configurable.Configurable(this, model), true);else this.sync(initialRead);
+    // we can use a modeled object here to help us know and manage what values are being used. -- see "model" above
+    if (this.isNew) this.write((0, _configurable.getModeledObject)(this.state, model), true);else this.sync(initialRead);
     this.initialized = true;
   }
 
@@ -121,7 +135,7 @@ class SessionEntity {
     return "".concat(_constants.PREFIX, "_").concat(this.key);
   }
   sync(data) {
-    Object.assign(this, data);
+    Object.assign(this.state, data);
   }
 
   /**
@@ -168,7 +182,8 @@ class SessionEntity {
       if (!data || typeof data !== 'object') return;
       // everytime we update, we can update a timestamp for sanity
       data.updatedAt = Date.now();
-      this.sync(data);
+      this.sync(data); // update the parent class "state" properties with the local storage values
+      //
       // TODO - compression would need happen here if we decide to do it
       this.storage.set(this.lookupKey, (0, _stringify.stringify)(data));
       return data;
@@ -184,12 +199,11 @@ class SessionEntity {
     // * stop recording (stn and sr)...
     // * delete the session and start over
     try {
-      if (this.initialized) this.ee.emit('session-reset');
+      if (this.initialized) this.ee.emit(SESSION_EVENTS.RESET);
       this.storage.remove(this.lookupKey);
       this.inactiveTimer?.abort?.();
       this.expiresTimer?.clear?.();
-      delete this.custom;
-      delete this.value;
+      delete this.isNew;
       this.setup({
         agentIdentifier: this.agentIdentifier,
         key: this.key,
@@ -209,10 +223,9 @@ class SessionEntity {
   refresh() {
     // read here & invalidate
     const existingData = this.read();
-    this.inactiveAt = this.getFutureTimestamp(this.inactiveMs);
     this.write({
       ...existingData,
-      inactiveAt: this.inactiveAt
+      inactiveAt: this.getFutureTimestamp(this.inactiveMs)
     });
   }
 
@@ -229,7 +242,7 @@ class SessionEntity {
    * @returns {boolean}
    */
   isInvalid(data) {
-    const requiredKeys = ['value', 'expiresAt', 'inactiveAt'];
+    const requiredKeys = Object.keys(model);
     return !requiredKeys.every(x => Object.keys(data).includes(x));
   }
   collectSM(type, data, useUpdatedAt) {

package/dist/cjs/common/session/session-entity.test.js

@@ -38,17 +38,19 @@ describe('constructor', () => {
     expect(session).toMatchObject({
       agentIdentifier: expect.any(String),
       key: expect.any(String),
-      value: expect.any(String),
       expiresMs: expect.any(Number),
-      expiresAt: expect.any(Number),
       expiresTimer: expect.any(Object),
       inactiveMs: expect.any(Number),
-      inactiveAt: expect.any(Number),
       inactiveTimer: expect.any(Object),
       isNew: expect.any(Boolean),
-      sessionReplayActive: expect.any(Boolean),
-      sessionTraceActive: expect.any(Boolean),
-      storage: expect.any(Object)
+      storage: expect.any(Object),
+      state: expect.objectContaining({
+        value: expect.any(String),
+        expiresAt: expect.any(Number),
+        inactiveAt: expect.any(Number),
+        sessionReplay: expect.any(Number),
+        sessionTraceActive: expect.any(Boolean)
+      })
     });
   });
   test('can use sane defaults', () => {
@@ -56,11 +58,12 @@ describe('constructor', () => {
       agentIdentifier,
       key
     });
-    expect(session).toEqual(expect.objectContaining({
+    expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      updatedAt: expect.any(Number),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }));
   });
@@ -81,7 +84,7 @@ describe('constructor', () => {
       key,
       expiresMs: 100
     });
-    expect(session.expiresAt).toEqual(now + 100);
+    expect(session.state.expiresAt).toEqual(now + 100);
   });
   test('expiresAt is the correct future timestamp - existing session', () => {
     const now = Date.now();
@@ -90,7 +93,11 @@ describe('constructor', () => {
       ["".concat(_constants.PREFIX, "_").concat(key)]: {
         value,
         expiresAt: now + 5000,
-        inactiveAt: Infinity
+        inactiveAt: Infinity,
+        updatedAt: now,
+        sessionReplay: 0,
+        sessionTraceActive: false,
+        custom: {}
       }
     });
     const session = new _sessionEntity.SessionEntity({
@@ -99,7 +106,7 @@ describe('constructor', () => {
       expiresMs: 100,
       storageAPI: existingData
     });
-    expect(session.expiresAt).toEqual(now + 5000);
+    expect(session.state.expiresAt).toEqual(now + 5000);
   });
   test('expiresAt never expires if 0', () => {
     const session = new _sessionEntity.SessionEntity({
@@ -107,7 +114,7 @@ describe('constructor', () => {
       key,
       expiresMs: 0
     });
-    expect(session.expiresAt).toEqual(Infinity);
+    expect(session.state.expiresAt).toEqual(Infinity);
   });
   test('inactiveAt is the correct future timestamp - new session', () => {
     const now = Date.now();
@@ -117,7 +124,7 @@ describe('constructor', () => {
       key,
       inactiveMs: 100
     });
-    expect(session.inactiveAt).toEqual(now + 100);
+    expect(session.state.inactiveAt).toEqual(now + 100);
   });
   test('inactiveAt is the correct future timestamp - existing session', () => {
     const now = Date.now();
@@ -126,7 +133,11 @@ describe('constructor', () => {
       ["".concat(_constants.PREFIX, "_").concat(key)]: {
         value,
         inactiveAt: now + 5000,
-        expiresAt: Infinity
+        expiresAt: Infinity,
+        updatedAt: now,
+        sessionReplay: 0,
+        sessionTraceActive: false,
+        custom: {}
       }
     });
     const session = new _sessionEntity.SessionEntity({
@@ -135,7 +146,7 @@ describe('constructor', () => {
       inactiveMs: 100,
       storageAPI: existingData
     });
-    expect(session.inactiveAt).toEqual(now + 5000);
+    expect(session.state.inactiveAt).toEqual(now + 5000);
   });
   test('inactiveAt never expires if 0', () => {
     const session = new _sessionEntity.SessionEntity({
@@ -143,7 +154,7 @@ describe('constructor', () => {
       key,
       inactiveMs: 0
     });
-    expect(session.inactiveAt).toEqual(Infinity);
+    expect(session.state.inactiveAt).toEqual(Infinity);
   });
   test('should handle isNew', () => {
     const newSession = new _sessionEntity.SessionEntity({
@@ -156,7 +167,11 @@ describe('constructor', () => {
       ["".concat(_constants.PREFIX, "_").concat(key)]: {
         value,
         expiresAt: Infinity,
-        inactiveAt: Infinity
+        inactiveAt: Infinity,
+        updatedAt: Date.now(),
+        sessionReplay: 0,
+        sessionTraceActive: false,
+        custom: {}
       }
     });
     const existingSession = new _sessionEntity.SessionEntity({
@@ -179,11 +194,12 @@ describe('constructor', () => {
       key,
       storageAPI
     });
-    expect(session).toEqual(expect.objectContaining({
+    expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      updatedAt: expect.any(Number),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }));
   });
@@ -202,11 +218,12 @@ describe('constructor', () => {
       key,
       storageAPI
     });
-    expect(session).toEqual(expect.objectContaining({
+    expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      updatedAt: expect.any(Number),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }));
   });
@@ -225,11 +242,12 @@ describe('constructor', () => {
       key,
       storageAPI
     });
-    expect(session).toEqual(expect.objectContaining({
+    expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      updatedAt: expect.any(Number),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }));
   });
@@ -244,10 +262,10 @@ describe('reset()', () => {
       expiresMs: 10
     });
     const sessionVal = session.value;
-    expect(session.value).toBeTruthy();
+    expect(session.state.value).toBeTruthy();
     session.reset();
-    expect(session.value).toBeTruthy();
-    expect(session.value).not.toEqual(sessionVal);
+    expect(session.state.value).toBeTruthy();
+    expect(session.state.value).not.toEqual(sessionVal);
   });
   test('custom data should be wiped on reset', () => {
     const now = Date.now();
@@ -258,12 +276,12 @@ describe('reset()', () => {
       expiresMs: 10
     });
     session.syncCustomAttribute('test', 123);
-    expect(session.custom.test).toEqual(123);
+    expect(session.state.custom.test).toEqual(123);
     expect(session.read().custom.test).toEqual(123);
 
     // simulate a timer expiring
     session.reset();
-    expect(session.custom?.test).toEqual(undefined);
+    expect(session.state.custom?.test).toEqual(undefined);
     expect(session.read()?.custom?.test).toEqual(undefined);
   });
 });
@@ -279,7 +297,7 @@ describe('read()', () => {
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }));
   });
@@ -288,7 +306,11 @@ describe('read()', () => {
       ["".concat(_constants.PREFIX, "_").concat(key)]: {
         value,
         expiresAt: Infinity,
-        inactiveAt: Infinity
+        inactiveAt: Infinity,
+        updatedAt: Date.now(),
+        sessionReplay: 0,
+        sessionTraceActive: false,
+        custom: {}
       }
     });
     const session = new _sessionEntity.SessionEntity({
@@ -310,17 +332,18 @@ describe('write()', () => {
       agentIdentifier,
       key
     });
-    expect(session.value).not.toEqual(value);
-    expect(session.expiresAt).not.toEqual(Infinity);
-    expect(session.inactiveAt).not.toEqual(Infinity);
+    expect(session.state.value).not.toEqual(value);
+    expect(session.state.expiresAt).not.toEqual(Infinity);
+    expect(session.state.inactiveAt).not.toEqual(Infinity);
     session.write({
+      ...session.state,
       value,
       expiresAt: Infinity,
       inactiveAt: Infinity
     });
-    expect(session.value).toEqual(value);
-    expect(session.expiresAt).toEqual(Infinity);
-    expect(session.inactiveAt).toEqual(Infinity);
+    expect(session.state.value).toEqual(value);
+    expect(session.state.expiresAt).toEqual(Infinity);
+    expect(session.state.inactiveAt).toEqual(Infinity);
   });
   test('write() sets data that read() can access', () => {
     const now = Date.now();
@@ -330,6 +353,7 @@ describe('write()', () => {
       key
     });
     session.write({
+      ...session.state,
       value,
       expiresAt: now + 100,
       inactiveAt: now + 100
@@ -365,10 +389,10 @@ describe('refresh()', () => {
       key,
       inactiveMs: 100
     });
-    expect(session.inactiveAt).toEqual(now + 100);
+    expect(session.state.inactiveAt).toEqual(now + 100);
     jest.setSystemTime(now + 1000);
     session.refresh();
-    expect(session.inactiveAt).toEqual(now + 100 + 1000);
+    expect(session.state.inactiveAt).toEqual(now + 100 + 1000);
   });
   test('refresh resets the entity if expiresTimer is invalid', () => {
     const now = Date.now();
@@ -378,13 +402,13 @@ describe('refresh()', () => {
       key,
       value
     });
-    expect(session.value).toEqual(value);
+    expect(session.state.value).toEqual(value);
     session.write({
-      ...session.read(),
+      ...session.state,
       expiresAt: now - 1
     });
     session.refresh();
-    expect(session.value).not.toEqual(value);
+    expect(session.state.value).not.toEqual(value);
   });
   test('refresh resets the entity if inactiveTimer is invalid', () => {
     const now = Date.now();
@@ -394,13 +418,13 @@ describe('refresh()', () => {
       key,
       value
     });
-    expect(session.value).toEqual(value);
+    expect(session.state.value).toEqual(value);
     session.write({
-      ...session.read(),
+      ...session.state,
       inactiveAt: now - 1
     });
     session.refresh();
-    expect(session.value).not.toEqual(value);
+    expect(session.state.value).not.toEqual(value);
   });
 });
 describe('syncCustomAttribute()', () => {
@@ -412,17 +436,17 @@ describe('syncCustomAttribute()', () => {
 
     // if custom has never been set, and a "delete" action is triggered, do nothing
     session.syncCustomAttribute('test', null);
-    expect(session?.custom?.test).toEqual(undefined);
+    expect(session?.state?.custom?.test).toEqual(undefined);
     session.syncCustomAttribute('test', 1);
-    expect(session?.custom?.test).toEqual(1);
+    expect(session?.state?.custom?.test).toEqual(1);
     session.syncCustomAttribute('test', 'string');
-    expect(session?.custom?.test).toEqual('string');
+    expect(session?.state?.custom?.test).toEqual('string');
     session.syncCustomAttribute('test', false);
-    expect(session?.custom?.test).toEqual(false);
+    expect(session?.state?.custom?.test).toEqual(false);
 
     // null specifically deletes the object completely
     session.syncCustomAttribute('test', null);
-    expect(session?.custom?.test).toEqual(undefined);
+    expect(session?.state?.custom?.test).toEqual(undefined);
   });
   test('Only runs in browser scope', () => {
     mockBrowserScope.mockReturnValue(false);

package/dist/cjs/common/timer/interaction-timer.js

@@ -11,8 +11,9 @@ var _globalScope = require("../util/global-scope");
 class InteractionTimer extends _timer.Timer {
   constructor(opts, ms) {
     super(opts, ms);
-    this.onRefresh = opts.onRefresh;
-    this.onPause = opts.onPause;
+    this.onPause = typeof opts.onPause === 'function' ? opts.onPause : () => {/* noop */};
+    this.onRefresh = typeof opts.onRefresh === 'function' ? opts.onRefresh : () => {/* noop */};
+    this.onResume = typeof opts.onResume === 'function' ? opts.onResume : () => {/* noop */};
 
     // used by pause/resume
     this.remainingMs = undefined;
@@ -47,7 +48,10 @@ class InteractionTimer extends _timer.Timer {
       (0, _pageVisibility.subscribeToVisibilityChange)(state => {
         if (state === 'hidden') this.pause();
         // vis change --> visible is treated like a new interaction with the page
-        else this.refresh();
+        else {
+          this.onResume();
+          this.refresh();
+        }
       }, false, false, this.abortController?.signal);
     }
   }
@@ -56,7 +60,7 @@ class InteractionTimer extends _timer.Timer {
     this.abortController?.abort();
   }
   pause() {
-    this.onPause?.();
+    this.onPause();
     clearTimeout(this.timer);
     this.remainingMs = this.initialMs - (Date.now() - this.startTimestamp);
   }
@@ -65,14 +69,7 @@ class InteractionTimer extends _timer.Timer {
     this.timer = this.create(cb, ms);
     this.startTimestamp = Date.now();
     this.remainingMs = undefined;
-    this.onRefresh?.();
+    this.onRefresh();
   }
-
-  // NOT CURRENTLY UTILIZED BY ANYTHING
-  // resume () {
-  //   if (!this.remainingMs || !this.isValid()) return
-  //   this.timer = this.create(this.cb, this.remainingMs)
-  //   this.remainingMs = undefined
-  // }
 }
 exports.InteractionTimer = InteractionTimer;

package/dist/cjs/common/url/protocol.test.js

@@ -1,6 +1,5 @@
 "use strict";
 
-var _faker = require("@faker-js/faker");
 var _protocol = require("./protocol");
 test('should return true when location url contains file protocol', () => {
   jest.spyOn(window, 'location', 'get').mockReturnValue({

package/dist/cjs/common/util/feature-flags.js

@@ -19,7 +19,8 @@ const bucketMap = {
   stn: [_features.FEATURE_NAMES.sessionTrace],
   err: [_features.FEATURE_NAMES.jserrors, _features.FEATURE_NAMES.metrics],
   ins: [_features.FEATURE_NAMES.pageAction],
-  spa: [_features.FEATURE_NAMES.spa]
+  spa: [_features.FEATURE_NAMES.spa],
+  sr: [_features.FEATURE_NAMES.sessionReplay]
 };
 function activateFeatures(flags, agentIdentifier) {
   var sharedEE = _contextualEe.ee.get(agentIdentifier);

package/dist/cjs/common/util/submit-data.js

@@ -14,12 +14,18 @@ const submitData = {};
 
 /**
  * Send via JSONP. Do NOT call this function outside of a guaranteed web window environment.
- * @param {string} url
- * @param {string} jsonp
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @param {string} args.jsonp - The string name of the jsonp cb method
+ * @returns {XMLHttpRequest}
  * @returns {Element}
  */
 exports.submitData = submitData;
-submitData.jsonp = function jsonp(url, jsonp) {
+submitData.jsonp = function jsonp(_ref) {
+  let {
+    url,
+    jsonp
+  } = _ref;
   try {
     if (_globalScope.isWorkerScope) {
       try {
@@ -27,7 +33,9 @@ submitData.jsonp = function jsonp(url, jsonp) {
       } catch (e) {
         // for now theres no other way to execute the callback from ingest without jsonp, or unsafe eval / new Function calls
         // future work needs to be conducted to allow ingest to return a more traditional JSON API-like experience for the entitlement flags
-        submitData.xhrGet(url + '&jsonp=' + jsonp);
+        submitData.xhrGet({
+          url: url + '&jsonp=' + jsonp
+        });
         return false;
       }
     } else {
@@ -42,19 +50,38 @@ submitData.jsonp = function jsonp(url, jsonp) {
     // do nothing
   }
 };
-submitData.xhrGet = function xhrGet(url) {
-  return submitData.xhr(url, undefined, false, 'GET');
+submitData.xhrGet = function xhrGet(_ref2) {
+  let {
+    url
+  } = _ref2;
+  return submitData.xhr({
+    url,
+    sync: false,
+    method: 'GET'
+  });
 };
 
 /**
  * Send via XHR
- * @param {string} url
- * @param {string} body
- * @param {boolean} sync
+ * @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
  * @returns {XMLHttpRequest}
  */
-submitData.xhr = function xhr(url, body, sync) {
-  let method = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'POST';
+submitData.xhr = function xhr(_ref3) {
+  let {
+    url,
+    body,
+    sync,
+    method = 'POST',
+    headers = [{
+      key: 'content-type',
+      value: 'text/plain'
+    }]
+  } = _ref3;
   var request = new XMLHttpRequest();
   request.open(method, url, !sync);
   try {
@@ -63,7 +90,9 @@ submitData.xhr = function xhr(url, body, sync) {
   } catch (e) {
     // do nothing
   }
-  request.setRequestHeader('content-type', 'text/plain');
+  headers.forEach(header => {
+    request.setRequestHeader(header.key, header.value);
+  });
   request.send(body);
   return request;
 };
@@ -77,10 +106,15 @@ submitData.xhr = function xhr(url, body, sync) {
 
 /**
  * Send by appending an <img> element to the page. Do NOT call this function outside of a guaranteed web window environment.
- * @param {string} url
- * @returns {Element}
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @returns {HTMLImageElement}
  */
-submitData.img = function img(url) {
+submitData.img = function img(_ref4) {
+  let {
+    url
+  } = _ref4;
+  console.log('img url', url);
   var element = new Image();
   element.src = url;
   return element;
@@ -88,11 +122,16 @@ submitData.img = function img(url) {
 
 /**
  * Send via sendBeacon. Do NOT call this function outside of a guaranteed web window environment.
- * @param {string} url
- * @param {string} body
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @param {string=} args.body - The Stringified body
  * @returns {boolean}
  */
-submitData.beacon = function (url, body) {
+submitData.beacon = function (_ref5) {
+  let {
+    url,
+    body
+  } = _ref5;
   // Navigator has to be bound to ensure it does not error in some browsers
   // https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch
   const send = window.navigator.sendBeacon.bind(window.navigator);