mixpanel-browser 2.39.0 → 2.42.0

package/src/mixpanel-core.js

@@ -1,7 +1,6 @@
 /* eslint camelcase: "off" */
 import Config from './config';
-import { _, console, userAgent, window, document, navigator, determine_eligibility } from './utils';
-import { autotrack } from './autotrack';
+import { _, console, userAgent, window, document, navigator, slice } from './utils';
 import { FormTracker, LinkTracker } from './dom-trackers';
 import { RequestBatcher } from './request-batcher';
 import { MixpanelGroup } from './mixpanel-group';
@@ -53,6 +52,9 @@ var mixpanel_master; // main mixpanel instance / object
 var INIT_MODULE  = 0;
 var INIT_SNIPPET = 1;
 
+var IDENTITY_FUNC = function(x) {return x;};
+var NOOP_FUNC = function() {};
+
 /** @const */ var PRIMARY_INSTANCE_NAME = 'mixpanel';
 
 
@@ -85,7 +87,6 @@ var DEFAULT_CONFIG = {
     'api_method':                        'POST',
     'api_transport':                     'XHR',
     'app_host':                          'https://mixpanel.com',
-    'autotrack':                         true,
     'cdn':                               'https://cdn.mxpnl.com',
     'cross_site_cookie':                 false,
     'cross_subdomain_cookie':            true,
@@ -93,7 +94,7 @@ var DEFAULT_CONFIG = {
     'persistence_name':                  '',
     'cookie_domain':                     '',
     'cookie_name':                       '',
-    'loaded':                            function() {},
+    'loaded':                            NOOP_FUNC,
     'store_google':                      true,
     'save_referrer':                     true,
     'test':                              false,
@@ -116,10 +117,12 @@ var DEFAULT_CONFIG = {
     'inapp_protocol':                    '//',
     'inapp_link_new_window':             false,
     'ignore_dnt':                        false,
-    'batch_requests':                    false, // for now
+    'batch_requests':                    true,
     'batch_size':                        50,
     'batch_flush_interval_ms':           5000,
-    'batch_request_timeout_ms':          90000
+    'batch_request_timeout_ms':          90000,
+    'batch_autostart':                   true,
+    'hooks':                             {}
 };
 
 var DOM_LOADED = false;
@@ -166,21 +169,6 @@ var create_mplib = function(token, config, name) {
     // global debug to be true
     Config.DEBUG = Config.DEBUG || instance.get_config('debug');
 
-    instance['__autotrack_enabled'] = instance.get_config('autotrack');
-    if (instance.get_config('autotrack')) {
-        var num_buckets = 100;
-        var num_enabled_buckets = 100;
-        if (!autotrack.enabledForProject(instance.get_config('token'), num_buckets, num_enabled_buckets)) {
-            instance['__autotrack_enabled'] = false;
-            console.log('Not in active bucket: disabling Automatic Event Collection.');
-        } else if (!autotrack.isBrowserSupported()) {
-            instance['__autotrack_enabled'] = false;
-            console.log('Disabling Automatic Event Collection because this browser is not supported');
-        } else {
-            autotrack.init(instance);
-        }
-    }
-
     // if target is not defined, we called init after the lib already
     // loaded, so there won't be an array of things to execute
     if (!_.isUndefined(target) && _.isArray(target)) {
@@ -248,23 +236,13 @@ MixpanelLib.prototype._init = function(token, config, name) {
     this['config'] = {};
     this['_triggered_notifs'] = [];
 
-    // rollout: enable batch_requests by default for 30% of projects
-    // (only if they have not specified a value in their init config
-    // and they aren't using a custom API host)
-    var variable_features = {};
-    var api_host = config['api_host'];
-    var is_custom_api = !!api_host && !api_host.match(/\.mixpanel\.com$/);
-    if (!('batch_requests' in config) && !is_custom_api && determine_eligibility(token, 'batch', 30)) {
-        variable_features['batch_requests'] = true;
-    }
-
-    this.set_config(_.extend({}, DEFAULT_CONFIG, variable_features, config, {
+    this.set_config(_.extend({}, DEFAULT_CONFIG, config, {
         'name': name,
         'token': token,
         'callback_fn': ((name === PRIMARY_INSTANCE_NAME) ? name : PRIMARY_INSTANCE_NAME + '.' + name) + '._jsc'
     }));
 
-    this['_jsc'] = function() {};
+    this['_jsc'] = NOOP_FUNC;
 
     this.__dom_loaded_queue = [];
     this.__request_queue = [];
@@ -282,20 +260,40 @@ MixpanelLib.prototype._init = function(token, config, name) {
             this._batch_requests = false;
             console.log('Turning off Mixpanel request-queueing; needs XHR and localStorage support');
         } else {
-            this.start_batch_requests();
+            this.init_batchers();
             if (sendBeacon && window.addEventListener) {
-                window.addEventListener('unload', _.bind(function() {
-                    // Before page closes, attempt to flush any events queued up via navigator.sendBeacon.
-                    // Since sendBeacon doesn't report success/failure, events will not be removed from
-                    // the persistent store; if the site is loaded again, the events will be flushed again
-                    // on startup and deduplicated on the Mixpanel server side.
-                    this.request_batchers.events.flush({sendBeacon: true});
-                }, this));
+                // Before page closes or hides (user tabs away etc), attempt to flush any events
+                // queued up via navigator.sendBeacon. Since sendBeacon doesn't report success/failure,
+                // events will not be removed from the persistent store; if the site is loaded again,
+                // the events will be flushed again on startup and deduplicated on the Mixpanel server
+                // side.
+                // There is no reliable way to capture only page close events, so we lean on the
+                // visibilitychange and pagehide events as recommended at
+                // https://developer.mozilla.org/en-US/docs/Web/API/Window/unload_event#usage_notes.
+                // These events fire when the user clicks away from the current page/tab, so will occur
+                // more frequently than page unload, but are the only mechanism currently for capturing
+                // this scenario somewhat reliably.
+                var flush_on_unload = _.bind(function() {
+                    if (!this.request_batchers.events.stopped) {
+                        this.request_batchers.events.flush({unloading: true});
+                    }
+                }, this);
+                window.addEventListener('pagehide', function(ev) {
+                    if (ev['persisted']) {
+                        flush_on_unload();
+                    }
+                });
+                window.addEventListener('visibilitychange', function() {
+                    if (document['visibilityState'] === 'hidden') {
+                        flush_on_unload();
+                    }
+                });
             }
         }
     }
 
     this['persistence'] = this['cookie'] = new MixpanelPersistence(this['config']);
+    this.unpersisted_superprops = {};
     this._gdpr_init();
 
     var uuid = _.UUID();
@@ -458,6 +456,13 @@ MixpanelLib.prototype._send_request = function(url, data, options, callback) {
             console.error(e);
             succeeded = false;
         }
+        try {
+            if (callback) {
+                callback(succeeded ? 1 : 0);
+            }
+        } catch (e) {
+            console.error(e);
+        }
     } else if (USE_XHR) {
         try {
             var req = new XMLHttpRequest();
@@ -592,32 +597,53 @@ MixpanelLib.prototype._execute_array = function(array) {
 
 // request queueing utils
 
-MixpanelLib.prototype.start_batch_requests = function() {
+MixpanelLib.prototype.are_batchers_initialized = function() {
+    return !!this.request_batchers.events;
+};
+
+MixpanelLib.prototype.init_batchers = function() {
     var token = this.get_config('token');
-    if (!this.request_batchers.events) { // no batchers initialized yet
-        var batcher_config = {
-            libConfig: this['config'],
-            sendRequestFunc: _.bind(function(endpoint, data, options, cb) {
-                this._send_request(
-                    this.get_config('api_host') + endpoint,
-                    encode_data_for_request(data),
-                    options,
-                    this._prepare_callback(cb, data)
-                );
-            }, this)
-        };
+    if (!this.are_batchers_initialized()) {
+        var batcher_for = _.bind(function(attrs) {
+            return new RequestBatcher(
+                '__mpq_' + token + attrs.queue_suffix,
+                {
+                    libConfig: this['config'],
+                    sendRequestFunc: _.bind(function(data, options, cb) {
+                        this._send_request(
+                            this.get_config('api_host') + attrs.endpoint,
+                            encode_data_for_request(data),
+                            options,
+                            this._prepare_callback(cb, data)
+                        );
+                    }, this),
+                    beforeSendHook: _.bind(function(item) {
+                        return this._run_hook('before_send_' + attrs.type, item);
+                    }, this)
+                }
+            );
+        }, this);
         this.request_batchers = {
-            events: new RequestBatcher('__mpq_' + token + '_ev', '/track/', batcher_config),
-            people: new RequestBatcher('__mpq_' + token + '_pp', '/engage/', batcher_config),
-            groups: new RequestBatcher('__mpq_' + token + '_gr', '/groups/', batcher_config)
+            events: batcher_for({type: 'events', endpoint: '/track/', queue_suffix: '_ev'}),
+            people: batcher_for({type: 'people', endpoint: '/engage/', queue_suffix: '_pp'}),
+            groups: batcher_for({type: 'groups', endpoint: '/groups/', queue_suffix: '_gr'})
         };
     }
-    _.each(this.request_batchers, function(batcher) {
-        batcher.start();
-    });
+    if (this.get_config('batch_autostart')) {
+        this.start_batch_senders();
+    }
 };
 
-MixpanelLib.prototype.stop_batch_requests = function() {
+MixpanelLib.prototype.start_batch_senders = function() {
+    if (this.are_batchers_initialized()) {
+        this._batch_requests = true;
+        _.each(this.request_batchers, function(batcher) {
+            batcher.start();
+        });
+    }
+};
+
+MixpanelLib.prototype.stop_batch_senders = function() {
     this._batch_requests = false;
     _.each(this.request_batchers, function(batcher) {
         batcher.stop();
@@ -662,23 +688,30 @@ MixpanelLib.prototype.disable = function(events) {
 
 // internal method for handling track vs batch-enqueue logic
 MixpanelLib.prototype._track_or_batch = function(options, callback) {
-    var truncated_data = options.truncated_data;
+    var truncated_data = _.truncate(options.data, 255);
     var endpoint = options.endpoint;
     var batcher = options.batcher;
     var should_send_immediately = options.should_send_immediately;
     var send_request_options = options.send_request_options || {};
-    callback = callback || function() {};
+    callback = callback || NOOP_FUNC;
 
     var request_enqueued_or_initiated = true;
     var send_request_immediately = _.bind(function() {
-        console.log('MIXPANEL REQUEST:');
-        console.log(truncated_data);
-        return this._send_request(
-            endpoint,
-            encode_data_for_request(truncated_data),
-            send_request_options,
-            this._prepare_callback(callback, truncated_data)
-        );
+        if (!send_request_options.skip_hooks) {
+            truncated_data = this._run_hook('before_send_' + options.type, truncated_data);
+        }
+        if (truncated_data) {
+            console.log('MIXPANEL REQUEST:');
+            console.log(truncated_data);
+            return this._send_request(
+                endpoint,
+                encode_data_for_request(truncated_data),
+                send_request_options,
+                this._prepare_callback(callback, truncated_data)
+            );
+        } else {
+            return null;
+        }
     }, this);
 
     if (this._batch_requests && !should_send_immediately) {
@@ -731,7 +764,7 @@ MixpanelLib.prototype.track = addOptOutCheckMixpanelLib(function(event_name, pro
     }
     var should_send_immediately = options['send_immediately'];
     if (typeof callback !== 'function') {
-        callback = function() {};
+        callback = NOOP_FUNC;
     }
 
     if (_.isUndefined(event_name)) {
@@ -766,6 +799,7 @@ MixpanelLib.prototype.track = addOptOutCheckMixpanelLib(function(event_name, pro
         {},
         _.info.properties(),
         this['persistence'].properties(),
+        this.unpersisted_superprops,
         properties
     );
 
@@ -783,7 +817,8 @@ MixpanelLib.prototype.track = addOptOutCheckMixpanelLib(function(event_name, pro
         'properties': properties
     };
     var ret = this._track_or_batch({
-        truncated_data: _.truncate(data, 255),
+        type: 'events',
+        data: data,
         endpoint: this.get_config('api_host') + '/track/',
         batcher: this.request_batchers.events,
         should_send_immediately: should_send_immediately,
@@ -1030,6 +1065,27 @@ MixpanelLib.prototype.time_event = function(event_name) {
     this['persistence'].set_event_timer(event_name,  new Date().getTime());
 };
 
+var REGISTER_DEFAULTS = {
+    'persistent': true
+};
+/**
+ * Helper to parse options param for register methods, maintaining
+ * legacy support for plain "days" param instead of options object
+ * @param {Number|Object} [days_or_options] 'days' option (Number), or Options object for register methods
+ * @returns {Object} options object
+ */
+var options_for_register = function(days_or_options) {
+    var options;
+    if (_.isObject(days_or_options)) {
+        options = days_or_options;
+    } else if (!_.isUndefined(days_or_options)) {
+        options = {'days': days_or_options};
+    } else {
+        options = {};
+    }
+    return _.extend({}, REGISTER_DEFAULTS, options);
+};
+
 /**
  * Register a set of super properties, which are included with all
  * events. This will overwrite previous super property values.
@@ -1045,11 +1101,21 @@ MixpanelLib.prototype.time_event = function(event_name) {
  *         'Account Type': 'Free'
  *     });
  *
+ *     // register only for the current pageload
+ *     mixpanel.register({'Name': 'Pat'}, {persistent: false});
+ *
  * @param {Object} properties An associative array of properties to store about the user
- * @param {Number} [days] How many days since the user's last visit to store the super properties
+ * @param {Number|Object} [days_or_options] Options object or number of days since the user's last visit to store the super properties (only valid for persisted props)
+ * @param {boolean} [days_or_options.days] - number of days since the user's last visit to store the super properties (only valid for persisted props)
+ * @param {boolean} [days_or_options.persistent=true] - whether to put in persistent storage (cookie/localStorage)
  */
-MixpanelLib.prototype.register = function(props, days) {
-    this['persistence'].register(props, days);
+MixpanelLib.prototype.register = function(props, days_or_options) {
+    var options = options_for_register(days_or_options);
+    if (options['persistent']) {
+        this['persistence'].register(props, options['days']);
+    } else {
+        _.extend(this.unpersisted_superprops, props);
+    }
 };
 
 /**
@@ -1063,6 +1129,11 @@ MixpanelLib.prototype.register = function(props, days) {
  *         'First Login Date': new Date().toISOString()
  *     });
  *
+ *     // register once, only for the current pageload
+ *     mixpanel.register_once({
+ *         'First interaction time': new Date().toISOString()
+ *     }, 'None', {persistent: false});
+ *
  * ### Notes:
  *
  * If default_value is specified, current super properties
@@ -1070,19 +1141,40 @@ MixpanelLib.prototype.register = function(props, days) {
  *
  * @param {Object} properties An associative array of properties to store about the user
  * @param {*} [default_value] Value to override if already set in super properties (ex: 'False') Default: 'None'
- * @param {Number} [days] How many days since the users last visit to store the super properties
+ * @param {Number|Object} [days_or_options] Options object or number of days since the user's last visit to store the super properties (only valid for persisted props)
+ * @param {boolean} [days_or_options.days] - number of days since the user's last visit to store the super properties (only valid for persisted props)
+ * @param {boolean} [days_or_options.persistent=true] - whether to put in persistent storage (cookie/localStorage)
  */
-MixpanelLib.prototype.register_once = function(props, default_value, days) {
-    this['persistence'].register_once(props, default_value, days);
+MixpanelLib.prototype.register_once = function(props, default_value, days_or_options) {
+    var options = options_for_register(days_or_options);
+    if (options['persistent']) {
+        this['persistence'].register_once(props, default_value, options['days']);
+    } else {
+        if (typeof(default_value) === 'undefined') {
+            default_value = 'None';
+        }
+        _.each(props, function(val, prop) {
+            if (!this.unpersisted_superprops.hasOwnProperty(prop) || this.unpersisted_superprops[prop] === default_value) {
+                this.unpersisted_superprops[prop] = val;
+            }
+        }, this);
+    }
 };
 
 /**
  * Delete a super property stored with the current user.
  *
  * @param {String} property The name of the super property to remove
+ * @param {Object} [options]
+ * @param {boolean} [options.persistent=true] - whether to look in persistent storage (cookie/localStorage)
  */
-MixpanelLib.prototype.unregister = function(property) {
-    this['persistence'].unregister(property);
+MixpanelLib.prototype.unregister = function(property, options) {
+    options = options_for_register(options);
+    if (options['persistent']) {
+        this['persistence'].unregister(property);
+    } else {
+        delete this.unpersisted_superprops[property];
+    }
 };
 
 MixpanelLib.prototype._register_single = function(prop, value) {
@@ -1153,7 +1245,10 @@ MixpanelLib.prototype.identify = function(
     // send an $identify event any time the distinct_id is changing - logic on the server
     // will determine whether or not to do anything with it.
     if (new_distinct_id !== previous_distinct_id) {
-        this.track('$identify', { 'distinct_id': new_distinct_id, '$anon_distinct_id': previous_distinct_id });
+        this.track('$identify', {
+            'distinct_id': new_distinct_id,
+            '$anon_distinct_id': previous_distinct_id
+        }, {skip_hooks: true});
     }
 };
 
@@ -1242,7 +1337,12 @@ MixpanelLib.prototype.alias = function(alias, original) {
     }
     if (alias !== original) {
         this._register_single(ALIAS_ID_KEY, alias);
-        return this.track('$create_alias', { 'alias': alias, 'distinct_id': original }, function() {
+        return this.track('$create_alias', {
+            'alias': alias,
+            'distinct_id': original
+        }, {
+            skip_hooks: true
+        }, function() {
             // Flush the people queue
             _this.identify(alias);
         });
@@ -1421,6 +1521,21 @@ MixpanelLib.prototype.get_config = function(prop_name) {
     return this['config'][prop_name];
 };
 
+/**
+ * Fetch a hook function from config, with safe default, and run it
+ * against the given arguments
+ * @param {string} hook_name which hook to retrieve
+ * @returns {any|null} return value of user-provided hook, or null if nothing was returned
+ */
+MixpanelLib.prototype._run_hook = function(hook_name) {
+    var ret = (this['config']['hooks'][hook_name] || IDENTITY_FUNC).apply(this, slice.call(arguments, 1));
+    if (typeof ret === 'undefined') {
+        console.error(hook_name + ' hook did not return a value');
+        ret = null;
+    }
+    return ret;
+};
+
 /**
  * Returns the value of the super property named property_name. If no such
  * property is set, get_property() will return the undefined value.
@@ -1806,7 +1921,8 @@ MixpanelLib.prototype['set_group']                          = MixpanelLib.protot
 MixpanelLib.prototype['add_group']                          = MixpanelLib.prototype.add_group;
 MixpanelLib.prototype['remove_group']                       = MixpanelLib.prototype.remove_group;
 MixpanelLib.prototype['track_with_groups']                  = MixpanelLib.prototype.track_with_groups;
-MixpanelLib.prototype['stop_batch_requests']                = MixpanelLib.prototype.stop_batch_requests;
+MixpanelLib.prototype['start_batch_senders']                = MixpanelLib.prototype.start_batch_senders;
+MixpanelLib.prototype['stop_batch_senders']                 = MixpanelLib.prototype.stop_batch_senders;
 
 // MixpanelPersistence Exports
 MixpanelPersistence.prototype['properties']            = MixpanelPersistence.prototype.properties;
@@ -1931,7 +2047,7 @@ export function init_from_snippet() {
     }
     if (mixpanel_master['__loaded'] || (mixpanel_master['config'] && mixpanel_master['persistence'])) {
         // lib has already been loaded at least once; we don't want to override the global object this time so bomb early
-        console.error('Mixpanel library has already been downloaded at least once.');
+        console.critical('The Mixpanel library has already been downloaded at least once. Ensure that the Mixpanel code snippet only appears once on the page (and is not double-loaded by a tag manager) in order to avoid errors.');
         return;
     }
     var snippet_version = mixpanel_master['__SV'] || 0;

package/src/mixpanel-group.js

@@ -110,9 +110,13 @@ MixpanelGroup.prototype.union = addOptOutCheckMixpanelGroup(function(list_name,
  * Permanently delete a group.
  *
  * ### Usage:
+ *
  *     mixpanel.get_group('company', 'mixpanel').delete();
+ *
+ * @param {Function} [callback] If provided, the callback will be called after the tracking event
  */
 MixpanelGroup.prototype['delete'] = addOptOutCheckMixpanelGroup(function(callback) {
+    // bracket notation above prevents a minification error related to reserved words
     var data = this.delete_action();
     return this._send_request(data, callback);
 });
@@ -140,7 +144,8 @@ MixpanelGroup.prototype._send_request = function(data, callback) {
 
     var date_encoded_data = _.encodeDates(data);
     return this._mixpanel._track_or_batch({
-        truncated_data: _.truncate(date_encoded_data, 255),
+        type: 'groups',
+        data: date_encoded_data,
         endpoint: this._get_config('api_host') + '/groups/',
         batcher: this._mixpanel.request_batchers.groups
     }, callback);

package/src/mixpanel-people.js

@@ -330,7 +330,6 @@ MixpanelPeople.prototype._send_request = function(data, callback) {
     }
 
     var date_encoded_data = _.encodeDates(data);
-    var truncated_data = _.truncate(date_encoded_data, 255);
 
     if (!this._identify_called()) {
         this._enqueue(data);
@@ -341,11 +340,12 @@ MixpanelPeople.prototype._send_request = function(data, callback) {
                 callback(-1);
             }
         }
-        return truncated_data;
+        return _.truncate(date_encoded_data, 255);
     }
 
     return this._mixpanel._track_or_batch({
-        truncated_data: truncated_data,
+        type: 'people',
+        data: date_encoded_data,
         endpoint: this._get_config('api_host') + '/engage/',
         batcher: this._mixpanel.request_batchers.people
     }, callback);

package/src/request-batcher.js

@@ -12,18 +12,18 @@ var logger = console_with_prefix('batch');
  * Uses RequestQueue to manage the backing store.
  * @constructor
  */
-var RequestBatcher = function(storageKey, endpoint, options) {
+var RequestBatcher = function(storageKey, options) {
     this.queue = new RequestQueue(storageKey, {storage: options.storage});
-    this.endpoint = endpoint;
 
     this.libConfig = options.libConfig;
     this.sendRequest = options.sendRequestFunc;
+    this.beforeSendHook = options.beforeSendHook;
 
     // seed variable batch size + flush interval with configured values
     this.batchSize = this.libConfig['batch_size'];
     this.flushInterval = this.libConfig['batch_flush_interval_ms'];
 
-    this.stopped = false;
+    this.stopped = !this.libConfig['batch_autostart'];
 };
 
 /**
@@ -103,18 +103,29 @@ RequestBatcher.prototype.flush = function(options) {
         }
 
         options = options || {};
+        var timeoutMS = this.libConfig['batch_request_timeout_ms'];
+        var startTime = new Date().getTime();
         var currentBatchSize = this.batchSize;
         var batch = this.queue.fillBatch(currentBatchSize);
-        if (batch.length < 1) {
+        var dataForRequest = [];
+        var transformedItems = {};
+        _.each(batch, function(item) {
+            var payload = item['payload'];
+            if (this.beforeSendHook && !item.orphaned) {
+                payload = this.beforeSendHook(payload);
+            }
+            if (payload) {
+                dataForRequest.push(payload);
+            }
+            transformedItems[item['id']] = payload;
+        }, this);
+        if (dataForRequest.length < 1) {
             this.resetFlush();
             return; // nothing to do
         }
 
         this.requestInProgress = true;
 
-        var timeoutMS = this.libConfig['batch_request_timeout_ms'];
-        var startTime = new Date().getTime();
-        var dataForRequest = _.map(batch, function(item) { return item['payload']; });
         var batchSendCallback = _.bind(function(res) {
             this.requestInProgress = false;
 
@@ -124,7 +135,10 @@ RequestBatcher.prototype.flush = function(options) {
                 // flush operation if something goes wrong
 
                 var removeItemsFromQueue = false;
-                if (
+                if (options.unloading) {
+                    // update persisted data to include hook transformations
+                    this.queue.updatePayloads(transformedItems);
+                } else if (
                     _.isObject(res) &&
                     res.error === 'timeout' &&
                     new Date().getTime() - startTime >= timeoutMS
@@ -134,9 +148,9 @@ RequestBatcher.prototype.flush = function(options) {
                 } else if (
                     _.isObject(res) &&
                     res.xhr_req &&
-                    (res.xhr_req['status'] >= 500 || res.xhr_req['status'] <= 0)
+                    (res.xhr_req['status'] >= 500 || res.xhr_req['status'] === 429 || res.error === 'timeout')
                 ) {
-                    // network or API error, retry
+                    // network or API error, or 429 Too Many Requests, retry
                     var retryMS = this.flushInterval * 2;
                     var headers = res.xhr_req['responseHeaders'];
                     if (headers) {
@@ -184,11 +198,11 @@ RequestBatcher.prototype.flush = function(options) {
             ignore_json_errors: true, // eslint-disable-line camelcase
             timeout_ms: timeoutMS // eslint-disable-line camelcase
         };
-        if (options.sendBeacon) {
+        if (options.unloading) {
             requestOptions.transport = 'sendBeacon';
         }
-        logger.log('MIXPANEL REQUEST:', this.endpoint, dataForRequest);
-        this.sendRequest(this.endpoint, dataForRequest, requestOptions, batchSendCallback);
+        logger.log('MIXPANEL REQUEST:', dataForRequest);
+        this.sendRequest(dataForRequest, requestOptions, batchSendCallback);
 
     } catch(err) {
         logger.error('Error flushing request queue', err);