mixpanel-browser 2.56.0 → 2.58.0

package/dist/mixpanel.amd.js

@@ -4509,11 +4509,9 @@ define((function () { 'use strict';
 
     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') {
@@ -4533,6 +4531,370 @@ define((function () { 'use strict';
         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
     // Maximum allowed value for minimum session recording length
@@ -5594,7 +5956,7 @@ define((function () { 'use strict';
 
         var supported = true;
         try {
-            storage = storage || window.localStorage;
+            storage = storage || win.localStorage;
             var key = '__mplss_' + cheap_guid(8),
                 val = 'xyz';
             storage.setItem(key, val);
@@ -5626,7 +5988,7 @@ define((function () { 'use strict';
 
         get: function(name) {
             try {
-                return window.localStorage.getItem(name);
+                return win.localStorage.getItem(name);
             } catch (err) {
                 _.localStorage.error(err);
             }
@@ -5644,7 +6006,7 @@ define((function () { 'use strict';
 
         set: function(name, value) {
             try {
-                window.localStorage.setItem(name, value);
+                win.localStorage.setItem(name, value);
             } catch (err) {
                 _.localStorage.error(err);
             }
@@ -5652,7 +6014,7 @@ define((function () { 'use strict';
 
         remove: function(name) {
             try {
-                window.localStorage.removeItem(name);
+                win.localStorage.removeItem(name);
             } catch (err) {
                 _.localStorage.error(err);
             }
@@ -5691,7 +6053,7 @@ define((function () { 'use strict';
 
         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
@@ -6246,6 +6608,7 @@ define((function () { 'use strict';
     _['info']['browser']        = _.info.browser;
     _['info']['browserVersion'] = _.info.browserVersion;
     _['info']['properties']     = _.info.properties;
+    _['NPO']                    = NpoPromise;
 
     /**
      * GDPR utils
@@ -6575,121 +6938,175 @@ define((function () { 'use strict';
         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$4.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$4.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);
+            var loop = function() {
+                storage.setItem(keyX, i);
 
-            waitFor(getSetY, function() {
-                if (storage.getItem(keyX) === i) {
-                    criticalSection();
-                    return;
-                }
-
-                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$3 = console_with_prefix('batch');
@@ -6710,19 +7127,38 @@ define((function () { 'use strict';
      * 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$3.error, logger$3);
 
         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));
     };
 
     /**
@@ -6737,7 +7173,7 @@ define((function () { 'use strict';
      * 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,
@@ -6746,33 +7182,37 @@ define((function () { 'use strict';
 
         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));
         }
     };
 
@@ -6782,31 +7222,41 @@ define((function () { 'use strict';
      * 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;
     };
 
     /**
@@ -6814,9 +7264,9 @@ define((function () { 'use strict';
      * 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);
             }
@@ -6828,78 +7278,80 @@ define((function () { 'use strict';
      * 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];
@@ -6919,79 +7371,95 @@ define((function () { 'use strict';
      * 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();
         }
     };
 
@@ -7010,7 +7478,8 @@ define((function () { 'use strict';
         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
         });
 
@@ -7038,8 +7507,8 @@ define((function () { 'use strict';
     /**
      * 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);
     };
 
     /**
@@ -7049,7 +7518,7 @@ define((function () { 'use strict';
     RequestBatcher.prototype.start = function() {
         this.stopped = false;
         this.consecutiveRemovalFailures = 0;
-        this.flush();
+        return this.flush();
     };
 
     /**
@@ -7067,7 +7536,7 @@ define((function () { 'use strict';
      * Clear out queue.
      */
     RequestBatcher.prototype.clear = function() {
-        this.queue.clear();
+        return this.queue.clear();
     };
 
     /**
@@ -7098,6 +7567,17 @@ define((function () { 'use strict';
         }
     };
 
+    /**
+     * 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
@@ -7109,183 +7589,191 @@ define((function () { 'use strict';
      * sendBeacon offers no callbacks or status indications)
      */
     RequestBatcher.prototype.flush = function(options) {
-        try {
+        if (this.requestInProgress) {
+            logger$2.log('Flush: Request already in progress');
+            return PromisePolyfill.resolve();
+        }
 
-            if (this.requestInProgress) {
-                logger$2.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$2.log('MIXPANEL REQUEST:', dataForRequest);
-            this.sendRequest(dataForRequest, requestOptions, batchSendCallback);
-        } catch(err) {
-            this.reportError('Error flushing request queue', err);
-            this.resetFlush();
-        }
+                logger$2.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));
     };
 
     /**
@@ -7352,6 +7840,7 @@ define((function () { 'use strict';
 
         this.seqNo = 0;
         this.replayStartTime = null;
+        this.replayStartUrl = null;
         this.batchStartUrl = null;
 
         this.idleTimeoutId = null;
@@ -7403,6 +7892,7 @@ define((function () { 'use strict';
 
         this.replayStartTime = new Date().getTime();
         this.batchStartUrl = _.info.currentUrl();
+        this.replayStartUrl = _.info.currentUrl();
 
         if (shouldStopBatcher || this.recordMinMs > 0) {
             // the primary case for shouldStopBatcher is when we're starting recording after a reset
@@ -7439,9 +7929,17 @@ define((function () { 'use strict';
             'blockClass': this.getConfig('record_block_class'),
             'blockSelector': blockSelector,
             'collectFonts': this.getConfig('record_collect_fonts'),
+            'dataURLOptions': { // canvas image options (https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toDataURL)
+                'type': 'image/webp',
+                'quality': 0.6
+            },
             'maskAllInputs': true,
             'maskTextClass': this.getConfig('record_mask_text_class'),
-            'maskTextSelector': this.getConfig('record_mask_text_selector')
+            'maskTextSelector': this.getConfig('record_mask_text_selector'),
+            'recordCanvas': this.getConfig('record_canvas'),
+            'sampling': {
+                'canvas': 15
+            }
         });
 
         if (typeof this._stopRecording !== 'function') {
@@ -7559,6 +8057,7 @@ define((function () { 'use strict';
                 'replay_id': replayId,
                 'replay_length_ms': replayLengthMs,
                 'replay_start_time': this.replayStartTime / 1000,
+                'replay_start_url': this.replayStartUrl,
                 'seq': this.seqNo
             };
             var eventsJson = _.JSONEncode(data);
@@ -9131,6 +9630,7 @@ define((function () { 'use strict';
         '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)$'),
@@ -9908,7 +10408,7 @@ define((function () { 'use strict';
         }, 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 {