mixpanel-browser 2.56.0 → 2.58.0

package/dist/mixpanel-with-async-recorder.cjs.js

@@ -2,11 +2,9 @@
 
 var Config = {
     DEBUG: false,
-    LIB_VERSION: '2.56.0'
+    LIB_VERSION: '2.58.0'
 };
 
-/* eslint camelcase: "off", eqeqeq: "off" */
-
 // since es6 imports are static and we run unit tests from the console, window won't be defined when importing this file
 var win;
 if (typeof(window) === 'undefined') {
@@ -26,6 +24,370 @@ if (typeof(window) === 'undefined') {
     win = window;
 }
 
+var setImmediate = win['setImmediate'];
+var builtInProp, cycle, schedulingQueue,
+    ToString = Object.prototype.toString,
+    timer = (typeof setImmediate !== 'undefined') ?
+        function timer(fn) { return setImmediate(fn); } :
+        setTimeout;
+
+// dammit, IE8.
+try {
+    Object.defineProperty({},'x',{});
+    builtInProp = function builtInProp(obj,name,val,config) {
+        return Object.defineProperty(obj,name,{
+            value: val,
+            writable: true,
+            configurable: config !== false
+        });
+    };
+}
+catch (err) {
+    builtInProp = function builtInProp(obj,name,val) {
+        obj[name] = val;
+        return obj;
+    };
+}
+
+// Note: using a queue instead of array for efficiency
+schedulingQueue = (function Queue() {
+    var first, last, item;
+
+    function Item(fn,self) {
+        this.fn = fn;
+        this.self = self;
+        this.next = void 0;
+    }
+
+    return {
+        add: function add(fn,self) {
+            item = new Item(fn,self);
+            if (last) {
+                last.next = item;
+            }
+            else {
+                first = item;
+            }
+            last = item;
+            item = void 0;
+        },
+        drain: function drain() {
+            var f = first;
+            first = last = cycle = void 0;
+
+            while (f) {
+                f.fn.call(f.self);
+                f = f.next;
+            }
+        }
+    };
+})();
+
+function schedule(fn,self) {
+    schedulingQueue.add(fn,self);
+    if (!cycle) {
+        cycle = timer(schedulingQueue.drain);
+    }
+}
+
+// promise duck typing
+function isThenable(o) {
+    var _then, oType = typeof o;
+
+    if (o !== null && (oType === 'object' || oType === 'function')) {
+        _then = o.then;
+    }
+    return typeof _then === 'function' ? _then : false;
+}
+
+function notify() {
+    for (var i=0; i<this.chain.length; i++) {
+        notifyIsolated(
+            this,
+            (this.state === 1) ? this.chain[i].success : this.chain[i].failure,
+            this.chain[i]
+        );
+    }
+    this.chain.length = 0;
+}
+
+// NOTE: This is a separate function to isolate
+// the `try..catch` so that other code can be
+// optimized better
+function notifyIsolated(self,cb,chain) {
+    var ret, _then;
+    try {
+        if (cb === false) {
+            chain.reject(self.msg);
+        }
+        else {
+            if (cb === true) {
+                ret = self.msg;
+            }
+            else {
+                ret = cb.call(void 0,self.msg);
+            }
+
+            if (ret === chain.promise) {
+                chain.reject(TypeError('Promise-chain cycle'));
+            }
+            // eslint-disable-next-line no-cond-assign
+            else if (_then = isThenable(ret)) {
+                _then.call(ret,chain.resolve,chain.reject);
+            }
+            else {
+                chain.resolve(ret);
+            }
+        }
+    }
+    catch (err) {
+        chain.reject(err);
+    }
+}
+
+function resolve(msg) {
+    var _then, self = this;
+
+    // already triggered?
+    if (self.triggered) { return; }
+
+    self.triggered = true;
+
+    // unwrap
+    if (self.def) {
+        self = self.def;
+    }
+
+    try {
+        // eslint-disable-next-line no-cond-assign
+        if (_then = isThenable(msg)) {
+            schedule(function(){
+                var defWrapper = new MakeDefWrapper(self);
+                try {
+                    _then.call(msg,
+                        function $resolve$(){ resolve.apply(defWrapper,arguments); },
+                        function $reject$(){ reject.apply(defWrapper,arguments); }
+                    );
+                }
+                catch (err) {
+                    reject.call(defWrapper,err);
+                }
+            });
+        }
+        else {
+            self.msg = msg;
+            self.state = 1;
+            if (self.chain.length > 0) {
+                schedule(notify,self);
+            }
+        }
+    }
+    catch (err) {
+        reject.call(new MakeDefWrapper(self),err);
+    }
+}
+
+function reject(msg) {
+    var self = this;
+
+    // already triggered?
+    if (self.triggered) { return; }
+
+    self.triggered = true;
+
+    // unwrap
+    if (self.def) {
+        self = self.def;
+    }
+
+    self.msg = msg;
+    self.state = 2;
+    if (self.chain.length > 0) {
+        schedule(notify,self);
+    }
+}
+
+function iteratePromises(Constructor,arr,resolver,rejecter) {
+    for (var idx=0; idx<arr.length; idx++) {
+        (function IIFE(idx){
+            Constructor.resolve(arr[idx])
+                .then(
+                    function $resolver$(msg){
+                        resolver(idx,msg);
+                    },
+                    rejecter
+                );
+        })(idx);
+    }
+}
+
+function MakeDefWrapper(self) {
+    this.def = self;
+    this.triggered = false;
+}
+
+function MakeDef(self) {
+    this.promise = self;
+    this.state = 0;
+    this.triggered = false;
+    this.chain = [];
+    this.msg = void 0;
+}
+
+function NpoPromise(executor) {
+    if (typeof executor !== 'function') {
+        throw TypeError('Not a function');
+    }
+
+    if (this['__NPO__'] !== 0) {
+        throw TypeError('Not a promise');
+    }
+
+    // instance shadowing the inherited "brand"
+    // to signal an already "initialized" promise
+    this['__NPO__'] = 1;
+
+    var def = new MakeDef(this);
+
+    this['then'] = function then(success,failure) {
+        var o = {
+            success: typeof success === 'function' ? success : true,
+            failure: typeof failure === 'function' ? failure : false
+        };
+            // Note: `then(..)` itself can be borrowed to be used against
+            // a different promise constructor for making the chained promise,
+            // by substituting a different `this` binding.
+        o.promise = new this.constructor(function extractChain(resolve,reject) {
+            if (typeof resolve !== 'function' || typeof reject !== 'function') {
+                throw TypeError('Not a function');
+            }
+
+            o.resolve = resolve;
+            o.reject = reject;
+        });
+        def.chain.push(o);
+
+        if (def.state !== 0) {
+            schedule(notify,def);
+        }
+
+        return o.promise;
+    };
+    this['catch'] = function $catch$(failure) {
+        return this.then(void 0,failure);
+    };
+
+    try {
+        executor.call(
+            void 0,
+            function publicResolve(msg){
+                resolve.call(def,msg);
+            },
+            function publicReject(msg) {
+                reject.call(def,msg);
+            }
+        );
+    }
+    catch (err) {
+        reject.call(def,err);
+    }
+}
+
+var PromisePrototype = builtInProp({},'constructor',NpoPromise,
+    /*configurable=*/false
+);
+
+    // Note: Android 4 cannot use `Object.defineProperty(..)` here
+NpoPromise.prototype = PromisePrototype;
+
+// built-in "brand" to signal an "uninitialized" promise
+builtInProp(PromisePrototype,'__NPO__',0,
+    /*configurable=*/false
+);
+
+builtInProp(NpoPromise,'resolve',function Promise$resolve(msg) {
+    var Constructor = this;
+
+    // spec mandated checks
+    // note: best "isPromise" check that's practical for now
+    if (msg && typeof msg === 'object' && msg['__NPO__'] === 1) {
+        return msg;
+    }
+
+    return new Constructor(function executor(resolve,reject){
+        if (typeof resolve !== 'function' || typeof reject !== 'function') {
+            throw TypeError('Not a function');
+        }
+
+        resolve(msg);
+    });
+});
+
+builtInProp(NpoPromise,'reject',function Promise$reject(msg) {
+    return new this(function executor(resolve,reject){
+        if (typeof resolve !== 'function' || typeof reject !== 'function') {
+            throw TypeError('Not a function');
+        }
+
+        reject(msg);
+    });
+});
+
+builtInProp(NpoPromise,'all',function Promise$all(arr) {
+    var Constructor = this;
+
+    // spec mandated checks
+    if (ToString.call(arr) !== '[object Array]') {
+        return Constructor.reject(TypeError('Not an array'));
+    }
+    if (arr.length === 0) {
+        return Constructor.resolve([]);
+    }
+
+    return new Constructor(function executor(resolve,reject){
+        if (typeof resolve !== 'function' || typeof reject !== 'function') {
+            throw TypeError('Not a function');
+        }
+
+        var len = arr.length, msgs = Array(len), count = 0;
+
+        iteratePromises(Constructor,arr,function resolver(idx,msg) {
+            msgs[idx] = msg;
+            if (++count === len) {
+                resolve(msgs);
+            }
+        },reject);
+    });
+});
+
+builtInProp(NpoPromise,'race',function Promise$race(arr) {
+    var Constructor = this;
+
+    // spec mandated checks
+    if (ToString.call(arr) !== '[object Array]') {
+        return Constructor.reject(TypeError('Not an array'));
+    }
+
+    return new Constructor(function executor(resolve,reject){
+        if (typeof resolve !== 'function' || typeof reject !== 'function') {
+            throw TypeError('Not a function');
+        }
+
+        iteratePromises(Constructor,arr,function resolver(idx,msg){
+            resolve(msg);
+        },reject);
+    });
+});
+
+var PromisePolyfill;
+if (typeof Promise !== 'undefined' && Promise.toString().indexOf('[native code]') !== -1) {
+    PromisePolyfill = Promise;
+} else {
+    PromisePolyfill = NpoPromise;
+}
+
+/* eslint camelcase: "off", eqeqeq: "off" */
+
 // Maximum allowed session recording length
 var MAX_RECORDING_MS = 24 * 60 * 60 * 1000; // 24 hours
 
@@ -1085,7 +1447,7 @@ var localStorageSupported = function(storage, forceCheck) {
 
     var supported = true;
     try {
-        storage = storage || window.localStorage;
+        storage = storage || win.localStorage;
         var key = '__mplss_' + cheap_guid(8),
             val = 'xyz';
         storage.setItem(key, val);
@@ -1117,7 +1479,7 @@ _.localStorage = {
 
     get: function(name) {
         try {
-            return window.localStorage.getItem(name);
+            return win.localStorage.getItem(name);
         } catch (err) {
             _.localStorage.error(err);
         }
@@ -1135,7 +1497,7 @@ _.localStorage = {
 
     set: function(name, value) {
         try {
-            window.localStorage.setItem(name, value);
+            win.localStorage.setItem(name, value);
         } catch (err) {
             _.localStorage.error(err);
         }
@@ -1143,7 +1505,7 @@ _.localStorage = {
 
     remove: function(name) {
         try {
-            window.localStorage.removeItem(name);
+            win.localStorage.removeItem(name);
         } catch (err) {
             _.localStorage.error(err);
         }
@@ -1182,7 +1544,7 @@ _.register_event = (function() {
 
     function makeHandler(element, new_handler, old_handlers) {
         var handler = function(event) {
-            event = event || fixEvent(window.event);
+            event = event || fixEvent(win.event);
 
             // this basically happens in firefox whenever another script
             // overwrites the onload callback and doesn't pass the event
@@ -1737,6 +2099,7 @@ _['info']['device']         = _.info.device;
 _['info']['browser']        = _.info.browser;
 _['info']['browserVersion'] = _.info.browserVersion;
 _['info']['properties']     = _.info.properties;
+_['NPO']                    = NpoPromise;
 
 /* eslint camelcase: "off" */
 
@@ -1918,121 +2281,175 @@ var SharedLock = function(key, options) {
     this.storage = options.storage || window.localStorage;
     this.pollIntervalMS = options.pollIntervalMS || 100;
     this.timeoutMS = options.timeoutMS || 2000;
+
+    // dependency-inject promise implementation for testing purposes
+    this.promiseImpl = options.promiseImpl || PromisePolyfill;
 };
 
 // pass in a specific pid to test contention scenarios; otherwise
 // it is chosen randomly for each acquisition attempt
-SharedLock.prototype.withLock = function(lockedCB, errorCB, pid) {
-    if (!pid && typeof errorCB !== 'function') {
-        pid = errorCB;
-        errorCB = null;
-    }
-
-    var i = pid || (new Date().getTime() + '|' + Math.random());
-    var startTime = new Date().getTime();
+SharedLock.prototype.withLock = function(lockedCB, pid) {
+    var Promise = this.promiseImpl;
+    return new Promise(_.bind(function (resolve, reject) {
+        var i = pid || (new Date().getTime() + '|' + Math.random());
+        var startTime = new Date().getTime();
 
-    var key = this.storageKey;
-    var pollIntervalMS = this.pollIntervalMS;
-    var timeoutMS = this.timeoutMS;
-    var storage = this.storage;
+        var key = this.storageKey;
+        var pollIntervalMS = this.pollIntervalMS;
+        var timeoutMS = this.timeoutMS;
+        var storage = this.storage;
 
-    var keyX = key + ':X';
-    var keyY = key + ':Y';
-    var keyZ = key + ':Z';
+        var keyX = key + ':X';
+        var keyY = key + ':Y';
+        var keyZ = key + ':Z';
 
-    var reportError = function(err) {
-        errorCB && errorCB(err);
-    };
+        var delay = function(cb) {
+            if (new Date().getTime() - startTime > timeoutMS) {
+                logger$2.error('Timeout waiting for mutex on ' + key + '; clearing lock. [' + i + ']');
+                storage.removeItem(keyZ);
+                storage.removeItem(keyY);
+                loop();
+                return;
+            }
+            setTimeout(function() {
+                try {
+                    cb();
+                } catch(err) {
+                    reject(err);
+                }
+            }, pollIntervalMS * (Math.random() + 0.1));
+        };
 
-    var delay = function(cb) {
-        if (new Date().getTime() - startTime > timeoutMS) {
-            logger$2.error('Timeout waiting for mutex on ' + key + '; clearing lock. [' + i + ']');
-            storage.removeItem(keyZ);
-            storage.removeItem(keyY);
-            loop();
-            return;
-        }
-        setTimeout(function() {
-            try {
+        var waitFor = function(predicate, cb) {
+            if (predicate()) {
                 cb();
-            } catch(err) {
-                reportError(err);
+            } else {
+                delay(function() {
+                    waitFor(predicate, cb);
+                });
             }
-        }, pollIntervalMS * (Math.random() + 0.1));
-    };
-
-    var waitFor = function(predicate, cb) {
-        if (predicate()) {
-            cb();
-        } else {
-            delay(function() {
-                waitFor(predicate, cb);
-            });
-        }
-    };
+        };
 
-    var getSetY = function() {
-        var valY = storage.getItem(keyY);
-        if (valY && valY !== i) { // if Y == i then this process already has the lock (useful for test cases)
-            return false;
-        } else {
-            storage.setItem(keyY, i);
-            if (storage.getItem(keyY) === i) {
-                return true;
+        var getSetY = function() {
+            var valY = storage.getItem(keyY);
+            if (valY && valY !== i) { // if Y == i then this process already has the lock (useful for test cases)
+                return false;
             } else {
-                if (!localStorageSupported(storage, true)) {
-                    throw new Error('localStorage support dropped while acquiring lock');
+                storage.setItem(keyY, i);
+                if (storage.getItem(keyY) === i) {
+                    return true;
+                } else {
+                    if (!localStorageSupported(storage, true)) {
+                        reject(new Error('localStorage support dropped while acquiring lock'));
+                    }
+                    return false;
                 }
-                return false;
             }
-        }
-    };
-
-    var loop = function() {
-        storage.setItem(keyX, i);
+        };
 
-        waitFor(getSetY, function() {
-            if (storage.getItem(keyX) === i) {
-                criticalSection();
-                return;
-            }
+        var loop = function() {
+            storage.setItem(keyX, i);
 
-            delay(function() {
-                if (storage.getItem(keyY) !== i) {
-                    loop();
+            waitFor(getSetY, function() {
+                if (storage.getItem(keyX) === i) {
+                    criticalSection();
                     return;
                 }
-                waitFor(function() {
-                    return !storage.getItem(keyZ);
-                }, criticalSection);
+
+                delay(function() {
+                    if (storage.getItem(keyY) !== i) {
+                        loop();
+                        return;
+                    }
+                    waitFor(function() {
+                        return !storage.getItem(keyZ);
+                    }, criticalSection);
+                });
             });
-        });
-    };
+        };
+
+        var criticalSection = function() {
+            storage.setItem(keyZ, '1');
+            var removeLock = function () {
+                storage.removeItem(keyZ);
+                if (storage.getItem(keyY) === i) {
+                    storage.removeItem(keyY);
+                }
+                if (storage.getItem(keyX) === i) {
+                    storage.removeItem(keyX);
+                }
+            };
+
+            lockedCB()
+                .then(function (ret) {
+                    removeLock();
+                    resolve(ret);
+                })
+                .catch(function (err) {
+                    removeLock();
+                    reject(err);
+                });
+        };
 
-    var criticalSection = function() {
-        storage.setItem(keyZ, '1');
         try {
-            lockedCB();
-        } finally {
-            storage.removeItem(keyZ);
-            if (storage.getItem(keyY) === i) {
-                storage.removeItem(keyY);
-            }
-            if (storage.getItem(keyX) === i) {
-                storage.removeItem(keyX);
+            if (localStorageSupported(storage, true)) {
+                loop();
+            } else {
+                throw new Error('localStorage support check failed');
             }
+        } catch(err) {
+            reject(err);
         }
-    };
+    }, this));
+};
 
-    try {
-        if (localStorageSupported(storage, true)) {
-            loop();
-        } else {
-            throw new Error('localStorage support check failed');
+/**
+ * @typedef {import('./wrapper').StorageWrapper}
+ */
+
+/**
+ * @type {StorageWrapper}
+ */
+var LocalStorageWrapper = function (storageOverride) {
+    this.storage = storageOverride || localStorage;
+};
+
+LocalStorageWrapper.prototype.init = function () {
+    return PromisePolyfill.resolve();
+};
+
+LocalStorageWrapper.prototype.setItem = function (key, value) {
+    return new PromisePolyfill(_.bind(function (resolve, reject) {
+        try {
+            this.storage.setItem(key, value);
+        } catch (e) {
+            reject(e);
         }
-    } catch(err) {
-        reportError(err);
-    }
+        resolve();
+    }, this));
+};
+
+LocalStorageWrapper.prototype.getItem = function (key) {
+    return new PromisePolyfill(_.bind(function (resolve, reject) {
+        var item;
+        try {
+            item = this.storage.getItem(key);
+        } catch (e) {
+            reject(e);
+        }
+        resolve(item);
+    }, this));
+};
+
+LocalStorageWrapper.prototype.removeItem = function (key) {
+    return new PromisePolyfill(_.bind(function (resolve, reject) {
+        try {
+            this.storage.removeItem(key);
+        } catch (e) {
+            reject(e);
+        }
+        resolve();
+    }, this));
 };
 
 var logger$1 = console_with_prefix('batch');
@@ -2053,19 +2470,38 @@ var logger$1 = console_with_prefix('batch');
  * to data loss in some situations).
  * @constructor
  */
-var RequestQueue = function(storageKey, options) {
+var RequestQueue = function (storageKey, options) {
     options = options || {};
     this.storageKey = storageKey;
     this.usePersistence = options.usePersistence;
     if (this.usePersistence) {
-        this.storage = options.storage || window.localStorage;
-        this.lock = new SharedLock(storageKey, {storage: this.storage});
+        this.queueStorage = options.queueStorage || new LocalStorageWrapper();
+        this.lock = new SharedLock(storageKey, { storage: options.sharedLockStorage || window.localStorage });
+        this.queueStorage.init();
     }
     this.reportError = options.errorReporter || _.bind(logger$1.error, logger$1);
 
     this.pid = options.pid || null; // pass pid to test out storage lock contention scenarios
 
     this.memQueue = [];
+    this.initialized = false;
+};
+
+RequestQueue.prototype.ensureInit = function () {
+    if (this.initialized) {
+        return PromisePolyfill.resolve();
+    }
+
+    return this.queueStorage
+        .init()
+        .then(_.bind(function () {
+            this.initialized = true;
+        }, this))
+        .catch(_.bind(function (err) {
+            this.reportError('Error initializing queue persistence. Disabling persistence', err);
+            this.initialized = true;
+            this.usePersistence = false;
+        }, this));
 };
 
 /**
@@ -2080,7 +2516,7 @@ var RequestQueue = function(storageKey, options) {
  * failure of the enqueue operation; it is asynchronous because the localStorage
  * lock is asynchronous.
  */
-RequestQueue.prototype.enqueue = function(item, flushInterval, cb) {
+RequestQueue.prototype.enqueue = function (item, flushInterval) {
     var queueEntry = {
         'id': cheap_guid(),
         'flushAfter': new Date().getTime() + flushInterval * 2,
@@ -2089,33 +2525,37 @@ RequestQueue.prototype.enqueue = function(item, flushInterval, cb) {
 
     if (!this.usePersistence) {
         this.memQueue.push(queueEntry);
-        if (cb) {
-            cb(true);
-        }
+        return PromisePolyfill.resolve(true);
     } else {
-        this.lock.withLock(_.bind(function lockAcquired() {
-            var succeeded;
-            try {
-                var storedQueue = this.readFromStorage();
-                storedQueue.push(queueEntry);
-                succeeded = this.saveToStorage(storedQueue);
-                if (succeeded) {
+
+        var enqueueItem = _.bind(function () {
+            return this.ensureInit()
+                .then(_.bind(function () {
+                    return this.readFromStorage();
+                }, this))
+                .then(_.bind(function (storedQueue) {
+                    storedQueue.push(queueEntry);
+                    return this.saveToStorage(storedQueue);
+                }, this))
+                .then(_.bind(function (succeeded) {
                     // only add to in-memory queue when storage succeeds
-                    this.memQueue.push(queueEntry);
-                }
-            } catch(err) {
-                this.reportError('Error enqueueing item', item);
-                succeeded = false;
-            }
-            if (cb) {
-                cb(succeeded);
-            }
-        }, this), _.bind(function lockFailure(err) {
-            this.reportError('Error acquiring storage lock', err);
-            if (cb) {
-                cb(false);
-            }
-        }, this), this.pid);
+                    if (succeeded) {
+                        this.memQueue.push(queueEntry);
+                    }
+                    return succeeded;
+                }, this))
+                .catch(_.bind(function (err) {
+                    this.reportError('Error enqueueing item', err, item);
+                    return false;
+                }, this));
+        }, this);
+
+        return this.lock
+            .withLock(enqueueItem, this.pid)
+            .catch(_.bind(function (err) {
+                this.reportError('Error acquiring storage lock', err);
+                return false;
+            }, this));
     }
 };
 
@@ -2125,31 +2565,41 @@ RequestQueue.prototype.enqueue = function(item, flushInterval, cb) {
  * in the persisted queue (items where the 'flushAfter' time has
  * already passed).
  */
-RequestQueue.prototype.fillBatch = function(batchSize) {
+RequestQueue.prototype.fillBatch = function (batchSize) {
     var batch = this.memQueue.slice(0, batchSize);
     if (this.usePersistence && batch.length < batchSize) {
         // don't need lock just to read events; localStorage is thread-safe
         // and the worst that could happen is a duplicate send of some
         // orphaned events, which will be deduplicated on the server side
-        var storedQueue = this.readFromStorage();
-        if (storedQueue.length) {
-            // item IDs already in batch; don't duplicate out of storage
-            var idsInBatch = {}; // poor man's Set
-            _.each(batch, function(item) { idsInBatch[item['id']] = true; });
-
-            for (var i = 0; i < storedQueue.length; i++) {
-                var item = storedQueue[i];
-                if (new Date().getTime() > item['flushAfter'] && !idsInBatch[item['id']]) {
-                    item.orphaned = true;
-                    batch.push(item);
-                    if (batch.length >= batchSize) {
-                        break;
+        return this.ensureInit()
+            .then(_.bind(function () {
+                return this.readFromStorage();
+            }, this))
+            .then(_.bind(function (storedQueue) {
+                if (storedQueue.length) {
+                // item IDs already in batch; don't duplicate out of storage
+                    var idsInBatch = {}; // poor man's Set
+                    _.each(batch, function (item) {
+                        idsInBatch[item['id']] = true;
+                    });
+
+                    for (var i = 0; i < storedQueue.length; i++) {
+                        var item = storedQueue[i];
+                        if (new Date().getTime() > item['flushAfter'] && !idsInBatch[item['id']]) {
+                            item.orphaned = true;
+                            batch.push(item);
+                            if (batch.length >= batchSize) {
+                                break;
+                            }
+                        }
                     }
                 }
-            }
-        }
+
+                return batch;
+            }, this));
+    } else {
+        return PromisePolyfill.resolve(batch);
     }
-    return batch;
 };
 
 /**
@@ -2157,9 +2607,9 @@ RequestQueue.prototype.fillBatch = function(batchSize) {
  * also remove any item without a valid id (e.g., malformed
  * storage entries).
  */
-var filterOutIDsAndInvalid = function(items, idSet) {
+var filterOutIDsAndInvalid = function (items, idSet) {
     var filteredItems = [];
-    _.each(items, function(item) {
+    _.each(items, function (item) {
         if (item['id'] && !idSet[item['id']]) {
             filteredItems.push(item);
         }
@@ -2171,78 +2621,80 @@ var filterOutIDsAndInvalid = function(items, idSet) {
  * Remove items with matching IDs from both in-memory queue
  * and persisted queue
  */
-RequestQueue.prototype.removeItemsByID = function(ids, cb) {
+RequestQueue.prototype.removeItemsByID = function (ids) {
     var idSet = {}; // poor man's Set
-    _.each(ids, function(id) { idSet[id] = true; });
+    _.each(ids, function (id) {
+        idSet[id] = true;
+    });
 
     this.memQueue = filterOutIDsAndInvalid(this.memQueue, idSet);
     if (!this.usePersistence) {
-        if (cb) {
-            cb(true);
-        }
+        return PromisePolyfill.resolve(true);
     } else {
-        var removeFromStorage = _.bind(function() {
-            var succeeded;
-            try {
-                var storedQueue = this.readFromStorage();
-                storedQueue = filterOutIDsAndInvalid(storedQueue, idSet);
-                succeeded = this.saveToStorage(storedQueue);
-
-                // an extra check: did storage report success but somehow
-                // the items are still there?
-                if (succeeded) {
-                    storedQueue = this.readFromStorage();
+        var removeFromStorage = _.bind(function () {
+            return this.ensureInit()
+                .then(_.bind(function () {
+                    return this.readFromStorage();
+                }, this))
+                .then(_.bind(function (storedQueue) {
+                    storedQueue = filterOutIDsAndInvalid(storedQueue, idSet);
+                    return this.saveToStorage(storedQueue);
+                }, this))
+                .then(_.bind(function () {
+                    return this.readFromStorage();
+                }, this))
+                .then(_.bind(function (storedQueue) {
+                    // an extra check: did storage report success but somehow
+                    // the items are still there?
                     for (var i = 0; i < storedQueue.length; i++) {
                         var item = storedQueue[i];
                         if (item['id'] && !!idSet[item['id']]) {
-                            this.reportError('Item not removed from storage');
-                            return false;
+                            throw new Error('Item not removed from storage');
                         }
                     }
-                }
-            } catch(err) {
-                this.reportError('Error removing items', ids);
-                succeeded = false;
-            }
-            return succeeded;
+                    return true;
+                }, this))
+                .catch(_.bind(function (err) {
+                    this.reportError('Error removing items', err, ids);
+                    return false;
+                }, this));
         }, this);
 
-        this.lock.withLock(function lockAcquired() {
-            var succeeded = removeFromStorage();
-            if (cb) {
-                cb(succeeded);
-            }
-        }, _.bind(function lockFailure(err) {
-            var succeeded = false;
-            this.reportError('Error acquiring storage lock', err);
-            if (!localStorageSupported(this.storage, true)) {
-                // Looks like localStorage writes have stopped working sometime after
-                // initialization (probably full), and so nobody can acquire locks
-                // anymore. Consider it temporarily safe to remove items without the
-                // lock, since nobody's writing successfully anyway.
-                succeeded = removeFromStorage();
-                if (!succeeded) {
-                    // OK, we couldn't even write out the smaller queue. Try clearing it
-                    // entirely.
-                    try {
-                        this.storage.removeItem(this.storageKey);
-                    } catch(err) {
-                        this.reportError('Error clearing queue', err);
-                    }
+        return this.lock
+            .withLock(removeFromStorage, this.pid)
+            .catch(_.bind(function (err) {
+                this.reportError('Error acquiring storage lock', err);
+                if (!localStorageSupported(this.queueStorage.storage, true)) {
+                    // Looks like localStorage writes have stopped working sometime after
+                    // initialization (probably full), and so nobody can acquire locks
+                    // anymore. Consider it temporarily safe to remove items without the
+                    // lock, since nobody's writing successfully anyway.
+                    return removeFromStorage()
+                        .then(_.bind(function (success) {
+                            if (!success) {
+                                // OK, we couldn't even write out the smaller queue. Try clearing it
+                                // entirely.
+                                return this.queueStorage.removeItem(this.storageKey).then(function () {
+                                    return success;
+                                });
+                            }
+                            return success;
+                        }, this))
+                        .catch(_.bind(function (err) {
+                            this.reportError('Error clearing queue', err);
+                            return false;
+                        }, this));
+                } else {
+                    return false;
                 }
-            }
-            if (cb) {
-                cb(succeeded);
-            }
-        }, this), this.pid);
+            }, this));
     }
-
 };
 
 // internal helper for RequestQueue.updatePayloads
-var updatePayloads = function(existingItems, itemsToUpdate) {
+var updatePayloads = function (existingItems, itemsToUpdate) {
     var newItems = [];
-    _.each(existingItems, function(item) {
+    _.each(existingItems, function (item) {
         var id = item['id'];
         if (id in itemsToUpdate) {
             var newPayload = itemsToUpdate[id];
@@ -2262,79 +2714,95 @@ var updatePayloads = function(existingItems, itemsToUpdate) {
  * Update payloads of given items in both in-memory queue and
  * persisted queue. Items set to null are removed from queues.
  */
-RequestQueue.prototype.updatePayloads = function(itemsToUpdate, cb) {
+RequestQueue.prototype.updatePayloads = function (itemsToUpdate) {
     this.memQueue = updatePayloads(this.memQueue, itemsToUpdate);
     if (!this.usePersistence) {
-        if (cb) {
-            cb(true);
-        }
+        return PromisePolyfill.resolve(true);
     } else {
-        this.lock.withLock(_.bind(function lockAcquired() {
-            var succeeded;
-            try {
-                var storedQueue = this.readFromStorage();
-                storedQueue = updatePayloads(storedQueue, itemsToUpdate);
-                succeeded = this.saveToStorage(storedQueue);
-            } catch(err) {
-                this.reportError('Error updating items', itemsToUpdate);
-                succeeded = false;
-            }
-            if (cb) {
-                cb(succeeded);
-            }
-        }, this), _.bind(function lockFailure(err) {
-            this.reportError('Error acquiring storage lock', err);
-            if (cb) {
-                cb(false);
-            }
-        }, this), this.pid);
+        return this.lock
+            .withLock(_.bind(function lockAcquired() {
+                return this.ensureInit()
+                    .then(_.bind(function () {
+                        return this.readFromStorage();
+                    }, this))
+                    .then(_.bind(function (storedQueue) {
+                        storedQueue = updatePayloads(storedQueue, itemsToUpdate);
+                        return this.saveToStorage(storedQueue);
+                    }, this))
+                    .catch(_.bind(function (err) {
+                        this.reportError('Error updating items', itemsToUpdate, err);
+                        return false;
+                    }, this));
+            }, this), this.pid)
+            .catch(_.bind(function (err) {
+                this.reportError('Error acquiring storage lock', err);
+                return false;
+            }, this));
     }
-
 };
 
 /**
  * Read and parse items array from localStorage entry, handling
  * malformed/missing data if necessary.
  */
-RequestQueue.prototype.readFromStorage = function() {
-    var storageEntry;
-    try {
-        storageEntry = this.storage.getItem(this.storageKey);
-        if (storageEntry) {
-            storageEntry = JSONParse(storageEntry);
-            if (!_.isArray(storageEntry)) {
-                this.reportError('Invalid storage entry:', storageEntry);
-                storageEntry = null;
+RequestQueue.prototype.readFromStorage = function () {
+    return this.ensureInit()
+        .then(_.bind(function () {
+            return this.queueStorage.getItem(this.storageKey);
+        }, this))
+        .then(_.bind(function (storageEntry) {
+            if (storageEntry) {
+                storageEntry = JSONParse(storageEntry);
+                if (!_.isArray(storageEntry)) {
+                    this.reportError('Invalid storage entry:', storageEntry);
+                    storageEntry = null;
+                }
             }
-        }
-    } catch (err) {
-        this.reportError('Error retrieving queue', err);
-        storageEntry = null;
-    }
-    return storageEntry || [];
+            return storageEntry || [];
+        }, this))
+        .catch(_.bind(function (err) {
+            this.reportError('Error retrieving queue', err);
+            return [];
+        }, this));
 };
 
 /**
  * Serialize the given items array to localStorage.
  */
-RequestQueue.prototype.saveToStorage = function(queue) {
+RequestQueue.prototype.saveToStorage = function (queue) {
     try {
-        this.storage.setItem(this.storageKey, JSONStringify(queue));
-        return true;
+        var serialized = JSONStringify(queue);
     } catch (err) {
-        this.reportError('Error saving queue', err);
-        return false;
+        this.reportError('Error serializing queue', err);
+        return PromisePolyfill.resolve(false);
     }
+
+    return this.ensureInit()
+        .then(_.bind(function () {
+            return this.queueStorage.setItem(this.storageKey, serialized);
+        }, this))
+        .then(function () {
+            return true;
+        })
+        .catch(_.bind(function (err) {
+            this.reportError('Error saving queue', err);
+            return false;
+        }, this));
 };
 
 /**
  * Clear out queues (memory and localStorage).
  */
-RequestQueue.prototype.clear = function() {
+RequestQueue.prototype.clear = function () {
     this.memQueue = [];
 
     if (this.usePersistence) {
-        this.storage.removeItem(this.storageKey);
+        return this.ensureInit()
+            .then(_.bind(function () {
+                return this.queueStorage.removeItem(this.storageKey);
+            }, this));
+    } else {
+        return PromisePolyfill.resolve();
     }
 };
 
@@ -2353,7 +2821,8 @@ var RequestBatcher = function(storageKey, options) {
     this.errorReporter = options.errorReporter;
     this.queue = new RequestQueue(storageKey, {
         errorReporter: _.bind(this.reportError, this),
-        storage: options.storage,
+        queueStorage: options.queueStorage,
+        sharedLockStorage: options.sharedLockStorage,
         usePersistence: options.usePersistence
     });
 
@@ -2381,8 +2850,8 @@ var RequestBatcher = function(storageKey, options) {
 /**
  * Add one item to queue.
  */
-RequestBatcher.prototype.enqueue = function(item, cb) {
-    this.queue.enqueue(item, this.flushInterval, cb);
+RequestBatcher.prototype.enqueue = function(item) {
+    return this.queue.enqueue(item, this.flushInterval);
 };
 
 /**
@@ -2392,7 +2861,7 @@ RequestBatcher.prototype.enqueue = function(item, cb) {
 RequestBatcher.prototype.start = function() {
     this.stopped = false;
     this.consecutiveRemovalFailures = 0;
-    this.flush();
+    return this.flush();
 };
 
 /**
@@ -2410,7 +2879,7 @@ RequestBatcher.prototype.stop = function() {
  * Clear out queue.
  */
 RequestBatcher.prototype.clear = function() {
-    this.queue.clear();
+    return this.queue.clear();
 };
 
 /**
@@ -2441,6 +2910,17 @@ RequestBatcher.prototype.scheduleFlush = function(flushMS) {
     }
 };
 
+/**
+ * Send a request using the sendRequest callback, but promisified.
+ * TODO: sendRequest should be promisified in the first place.
+ */
+RequestBatcher.prototype.sendRequestPromise = function(data, options) {
+    return new PromisePolyfill(_.bind(function(resolve) {
+        this.sendRequest(data, options, resolve);
+    }, this));
+};
+
+
 /**
  * Flush one batch to network. Depending on success/failure modes, it will either
  * remove the batch from the queue or leave it in for retry, and schedule the next
@@ -2452,183 +2932,191 @@ RequestBatcher.prototype.scheduleFlush = function(flushMS) {
  * sendBeacon offers no callbacks or status indications)
  */
 RequestBatcher.prototype.flush = function(options) {
-    try {
+    if (this.requestInProgress) {
+        logger.log('Flush: Request already in progress');
+        return PromisePolyfill.resolve();
+    }
 
-        if (this.requestInProgress) {
-            logger.log('Flush: Request already in progress');
-            return;
-        }
+    this.requestInProgress = true;
 
-        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 there's more items in the queue than the batch size, attempt
-        // to flush again after the current batch is done.
-        var attemptSecondaryFlush = batch.length === currentBatchSize;
-        var dataForRequest = [];
-        var transformedItems = {};
-        _.each(batch, function(item) {
-            var payload = item['payload'];
-            if (this.beforeSendHook && !item.orphaned) {
-                payload = this.beforeSendHook(payload);
-            }
-            if (payload) {
-                // mp_sent_by_lib_version prop captures which lib version actually
-                // sends each event (regardless of which version originally queued
-                // it for sending)
-                if (payload['event'] && payload['properties']) {
-                    payload['properties'] = _.extend(
-                        {},
-                        payload['properties'],
-                        {'mp_sent_by_lib_version': Config.LIB_VERSION}
-                    );
+    options = options || {};
+    var timeoutMS = this.libConfig['batch_request_timeout_ms'];
+    var startTime = new Date().getTime();
+    var currentBatchSize = this.batchSize;
+
+    return this.queue.fillBatch(currentBatchSize)
+        .then(_.bind(function(batch) {
+
+            // if there's more items in the queue than the batch size, attempt
+            // to flush again after the current batch is done.
+            var attemptSecondaryFlush = batch.length === currentBatchSize;
+            var dataForRequest = [];
+            var transformedItems = {};
+            _.each(batch, function(item) {
+                var payload = item['payload'];
+                if (this.beforeSendHook && !item.orphaned) {
+                    payload = this.beforeSendHook(payload);
                 }
-                var addPayload = true;
-                var itemId = item['id'];
-                if (itemId) {
-                    if ((this.itemIdsSentSuccessfully[itemId] || 0) > 5) {
-                        this.reportError('[dupe] item ID sent too many times, not sending', {
-                            item: item,
-                            batchSize: batch.length,
-                            timesSent: this.itemIdsSentSuccessfully[itemId]
-                        });
-                        addPayload = false;
+                if (payload) {
+                    // mp_sent_by_lib_version prop captures which lib version actually
+                    // sends each event (regardless of which version originally queued
+                    // it for sending)
+                    if (payload['event'] && payload['properties']) {
+                        payload['properties'] = _.extend(
+                            {},
+                            payload['properties'],
+                            {'mp_sent_by_lib_version': Config.LIB_VERSION}
+                        );
+                    }
+                    var addPayload = true;
+                    var itemId = item['id'];
+                    if (itemId) {
+                        if ((this.itemIdsSentSuccessfully[itemId] || 0) > 5) {
+                            this.reportError('[dupe] item ID sent too many times, not sending', {
+                                item: item,
+                                batchSize: batch.length,
+                                timesSent: this.itemIdsSentSuccessfully[itemId]
+                            });
+                            addPayload = false;
+                        }
+                    } else {
+                        this.reportError('[dupe] found item with no ID', {item: item});
                     }
-                } else {
-                    this.reportError('[dupe] found item with no ID', {item: item});
-                }
 
-                if (addPayload) {
-                    dataForRequest.push(payload);
+                    if (addPayload) {
+                        dataForRequest.push(payload);
+                    }
                 }
-            }
-            transformedItems[item['id']] = payload;
-        }, this);
-        if (dataForRequest.length < 1) {
-            this.resetFlush();
-            return; // nothing to do
-        }
-
-        this.requestInProgress = true;
-
-        var batchSendCallback = _.bind(function(res) {
-            this.requestInProgress = false;
+                transformedItems[item['id']] = payload;
+            }, this);
 
-            try {
+            if (dataForRequest.length < 1) {
+                this.requestInProgress = false;
+                this.resetFlush();
+                return PromisePolyfill.resolve(); // nothing to do
+            }
 
-                // handle API response in a try-catch to make sure we can reset the
-                // flush operation if something goes wrong
-
-                var removeItemsFromQueue = false;
-                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
-                ) {
-                    this.reportError('Network timeout; retrying');
-                    this.flush();
-                } else if (
-                    _.isObject(res) &&
-                    (
-                        res.httpStatusCode >= 500
-                        || res.httpStatusCode === 429
-                        || (res.httpStatusCode <= 0 && !isOnline())
-                        || res.error === 'timeout'
+            var removeItemsFromQueue = _.bind(function () {
+                return this.queue
+                    .removeItemsByID(
+                        _.map(batch, function (item) {
+                            return item['id'];
+                        })
                     )
-                ) {
-                    // network or API error, or 429 Too Many Requests, retry
-                    var retryMS = this.flushInterval * 2;
-                    if (res.retryAfter) {
-                        retryMS = (parseInt(res.retryAfter, 10) * 1000) || retryMS;
-                    }
-                    retryMS = Math.min(MAX_RETRY_INTERVAL_MS, retryMS);
-                    this.reportError('Error; retry in ' + retryMS + ' ms');
-                    this.scheduleFlush(retryMS);
-                } else if (_.isObject(res) && res.httpStatusCode === 413) {
-                    // 413 Payload Too Large
-                    if (batch.length > 1) {
-                        var halvedBatchSize = Math.max(1, Math.floor(currentBatchSize / 2));
-                        this.batchSize = Math.min(this.batchSize, halvedBatchSize, batch.length - 1);
-                        this.reportError('413 response; reducing batch size to ' + this.batchSize);
-                        this.resetFlush();
-                    } else {
-                        this.reportError('Single-event request too large; dropping', batch);
-                        this.resetBatchSize();
-                        removeItemsFromQueue = true;
-                    }
-                } else {
-                    // successful network request+response; remove each item in batch from queue
-                    // (even if it was e.g. a 400, in which case retrying won't help)
-                    removeItemsFromQueue = true;
-                }
-
-                if (removeItemsFromQueue) {
-                    this.queue.removeItemsByID(
-                        _.map(batch, function(item) { return item['id']; }),
-                        _.bind(function(succeeded) {
-                            if (succeeded) {
-                                this.consecutiveRemovalFailures = 0;
-                                if (this.flushOnlyOnInterval && !attemptSecondaryFlush) {
-                                    this.resetFlush(); // schedule next batch with a delay
-                                } else {
-                                    this.flush(); // handle next batch if the queue isn't empty
+                    .then(_.bind(function (succeeded) {
+                        // client-side dedupe
+                        _.each(batch, _.bind(function(item) {
+                            var itemId = item['id'];
+                            if (itemId) {
+                                this.itemIdsSentSuccessfully[itemId] = this.itemIdsSentSuccessfully[itemId] || 0;
+                                this.itemIdsSentSuccessfully[itemId]++;
+                                if (this.itemIdsSentSuccessfully[itemId] > 5) {
+                                    this.reportError('[dupe] item ID sent too many times', {
+                                        item: item,
+                                        batchSize: batch.length,
+                                        timesSent: this.itemIdsSentSuccessfully[itemId]
+                                    });
                                 }
                             } else {
-                                this.reportError('Failed to remove items from queue');
-                                if (++this.consecutiveRemovalFailures > 5) {
-                                    this.reportError('Too many queue failures; disabling batching system.');
-                                    this.stopAllBatching();
-                                } else {
-                                    this.resetFlush();
-                                }
+                                this.reportError('[dupe] found item with no ID while removing', {item: item});
                             }
-                        }, this)
-                    );
+                        }, this));
 
-                    // client-side dedupe
-                    _.each(batch, _.bind(function(item) {
-                        var itemId = item['id'];
-                        if (itemId) {
-                            this.itemIdsSentSuccessfully[itemId] = this.itemIdsSentSuccessfully[itemId] || 0;
-                            this.itemIdsSentSuccessfully[itemId]++;
-                            if (this.itemIdsSentSuccessfully[itemId] > 5) {
-                                this.reportError('[dupe] item ID sent too many times', {
-                                    item: item,
-                                    batchSize: batch.length,
-                                    timesSent: this.itemIdsSentSuccessfully[itemId]
-                                });
+                        if (succeeded) {
+                            this.consecutiveRemovalFailures = 0;
+                            if (this.flushOnlyOnInterval && !attemptSecondaryFlush) {
+                                this.resetFlush(); // schedule next batch with a delay
+                                return PromisePolyfill.resolve();
+                            } else {
+                                return this.flush(); // handle next batch if the queue isn't empty
                             }
                         } else {
-                            this.reportError('[dupe] found item with no ID while removing', {item: item});
+                            if (++this.consecutiveRemovalFailures > 5) {
+                                this.reportError('Too many queue failures; disabling batching system.');
+                                this.stopAllBatching();
+                            } else {
+                                this.resetFlush();
+                            }
+                            return PromisePolyfill.resolve();
                         }
                     }, this));
-                }
+            }, this);
 
-            } catch(err) {
-                this.reportError('Error handling API response', err);
-                this.resetFlush();
+            var batchSendCallback = _.bind(function(res) {
+                this.requestInProgress = false;
+
+                try {
+
+                    // handle API response in a try-catch to make sure we can reset the
+                    // flush operation if something goes wrong
+
+                    if (options.unloading) {
+                        // update persisted data to include hook transformations
+                        return this.queue.updatePayloads(transformedItems);
+                    } else if (
+                        _.isObject(res) &&
+                            res.error === 'timeout' &&
+                            new Date().getTime() - startTime >= timeoutMS
+                    ) {
+                        this.reportError('Network timeout; retrying');
+                        return this.flush();
+                    } else if (
+                        _.isObject(res) &&
+                            (
+                                res.httpStatusCode >= 500
+                                || res.httpStatusCode === 429
+                                || (res.httpStatusCode <= 0 && !isOnline())
+                                || res.error === 'timeout'
+                            )
+                    ) {
+                        // network or API error, or 429 Too Many Requests, retry
+                        var retryMS = this.flushInterval * 2;
+                        if (res.retryAfter) {
+                            retryMS = (parseInt(res.retryAfter, 10) * 1000) || retryMS;
+                        }
+                        retryMS = Math.min(MAX_RETRY_INTERVAL_MS, retryMS);
+                        this.reportError('Error; retry in ' + retryMS + ' ms');
+                        this.scheduleFlush(retryMS);
+                        return PromisePolyfill.resolve();
+                    } else if (_.isObject(res) && res.httpStatusCode === 413) {
+                        // 413 Payload Too Large
+                        if (batch.length > 1) {
+                            var halvedBatchSize = Math.max(1, Math.floor(currentBatchSize / 2));
+                            this.batchSize = Math.min(this.batchSize, halvedBatchSize, batch.length - 1);
+                            this.reportError('413 response; reducing batch size to ' + this.batchSize);
+                            this.resetFlush();
+                            return PromisePolyfill.resolve();
+                        } else {
+                            this.reportError('Single-event request too large; dropping', batch);
+                            this.resetBatchSize();
+                            return removeItemsFromQueue();
+                        }
+                    } else {
+                        // successful network request+response; remove each item in batch from queue
+                        // (even if it was e.g. a 400, in which case retrying won't help)
+                        return removeItemsFromQueue();
+                    }
+                } catch(err) {
+                    this.reportError('Error handling API response', err);
+                    this.resetFlush();
+                }
+            }, this);
+            var requestOptions = {
+                method: 'POST',
+                verbose: true,
+                ignore_json_errors: true, // eslint-disable-line camelcase
+                timeout_ms: timeoutMS // eslint-disable-line camelcase
+            };
+            if (options.unloading) {
+                requestOptions.transport = 'sendBeacon';
             }
-        }, this);
-        var requestOptions = {
-            method: 'POST',
-            verbose: true,
-            ignore_json_errors: true, // eslint-disable-line camelcase
-            timeout_ms: timeoutMS // eslint-disable-line camelcase
-        };
-        if (options.unloading) {
-            requestOptions.transport = 'sendBeacon';
-        }
-        logger.log('MIXPANEL REQUEST:', dataForRequest);
-        this.sendRequest(dataForRequest, requestOptions, batchSendCallback);
-    } catch(err) {
-        this.reportError('Error flushing request queue', err);
-        this.resetFlush();
-    }
+            logger.log('MIXPANEL REQUEST:', dataForRequest);
+            return this.sendRequestPromise(dataForRequest, requestOptions).then(batchSendCallback);
+        }, this))
+        .catch(_.bind(function(err) {
+            this.reportError('Error flushing request queue', err);
+            this.resetFlush();
+        }, this));
 };
 
 /**
@@ -4257,6 +4745,7 @@ var DEFAULT_CONFIG = {
     'hooks':                             {},
     'record_block_class':                new RegExp('^(mp-block|fs-exclude|amp-block|rr-block|ph-no-capture)$'),
     'record_block_selector':             'img, video',
+    'record_canvas':                     false,
     'record_collect_fonts':              false,
     'record_idle_timeout_ms':            30 * 60 * 1000, // 30 minutes
     'record_mask_text_class':            new RegExp('^(mp-mask|fs-mask|amp-mask|rr-mask|ph-mask)$'),
@@ -5034,7 +5523,7 @@ MixpanelLib.prototype._track_or_batch = function(options, callback) {
     }, this);
 
     if (this._batch_requests && !should_send_immediately) {
-        batcher.enqueue(truncated_data, function(succeeded) {
+        batcher.enqueue(truncated_data).then(function(succeeded) {
             if (succeeded) {
                 callback(1, truncated_data);
             } else {