mixpanel-browser 2.53.0 → 2.54.1

package/dist/mixpanel.globals.js

@@ -3,7 +3,7 @@
 
     var Config = {
         DEBUG: false,
-        LIB_VERSION: '2.53.0'
+        LIB_VERSION: '2.54.1'
     };
 
     /* eslint camelcase: "off", eqeqeq: "off" */
@@ -2052,6 +2052,7 @@
         this.reportError = options.errorReporter || _.bind(logger$1.error, logger$1);
         this.lock = new SharedLock(storageKey, {storage: this.storage});
 
+        this.usePersistence = options.usePersistence;
         this.pid = options.pid || null; // pass pid to test out storage lock contention scenarios
 
         this.memQueue = [];
@@ -2076,29 +2077,36 @@
             'payload': item
         };
 
-        this.lock.withLock(_.bind(function lockAcquired() {
-            var succeeded;
-            try {
-                var storedQueue = this.readFromStorage();
-                storedQueue.push(queueEntry);
-                succeeded = this.saveToStorage(storedQueue);
-                if (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 (!this.usePersistence) {
+            this.memQueue.push(queueEntry);
             if (cb) {
-                cb(false);
+                cb(true);
             }
-        }, this), this.pid);
+        } else {
+            this.lock.withLock(_.bind(function lockAcquired() {
+                var succeeded;
+                try {
+                    var storedQueue = this.readFromStorage();
+                    storedQueue.push(queueEntry);
+                    succeeded = this.saveToStorage(storedQueue);
+                    if (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);
+        }
     };
 
     /**
@@ -2109,7 +2117,7 @@
      */
     RequestQueue.prototype.fillBatch = function(batchSize) {
         var batch = this.memQueue.slice(0, batchSize);
-        if (batch.length < 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
@@ -2158,61 +2166,67 @@
         _.each(ids, function(id) { idSet[id] = true; });
 
         this.memQueue = filterOutIDsAndInvalid(this.memQueue, idSet);
-
-        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();
-                    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;
+        if (!this.usePersistence) {
+            if (cb) {
+                cb(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();
+                        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;
+                            }
                         }
                     }
+                } catch(err) {
+                    this.reportError('Error removing items', ids);
+                    succeeded = false;
                 }
-            } catch(err) {
-                this.reportError('Error removing items', ids);
-                succeeded = false;
-            }
-            return succeeded;
-        }, this);
+                return succeeded;
+            }, 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);
+            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);
+                        }
                     }
                 }
-            }
-            if (cb) {
-                cb(succeeded);
-            }
-        }, this), this.pid);
+                if (cb) {
+                    cb(succeeded);
+                }
+            }, this), this.pid);
+        }
+
     };
 
     // internal helper for RequestQueue.updatePayloads
@@ -2240,25 +2254,32 @@
      */
     RequestQueue.prototype.updatePayloads = function(itemsToUpdate, cb) {
         this.memQueue = updatePayloads(this.memQueue, itemsToUpdate);
-        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 (!this.usePersistence) {
             if (cb) {
-                cb(succeeded);
+                cb(true);
             }
-        }, this), _.bind(function lockFailure(err) {
-            this.reportError('Error acquiring storage lock', err);
-            if (cb) {
-                cb(false);
-            }
-        }, this), this.pid);
+        } 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);
+        }
+
     };
 
     /**
@@ -2301,7 +2322,10 @@
      */
     RequestQueue.prototype.clear = function() {
         this.memQueue = [];
-        this.storage.removeItem(this.storageKey);
+
+        if (this.usePersistence) {
+            this.storage.removeItem(this.storageKey);
+        }
     };
 
     // maximum interval between request retries after exponential backoff
@@ -2319,7 +2343,8 @@
         this.errorReporter = options.errorReporter;
         this.queue = new RequestQueue(storageKey, {
             errorReporter: _.bind(this.reportError, this),
-            storage: options.storage
+            storage: options.storage,
+            usePersistence: options.usePersistence
         });
 
         this.libConfig = options.libConfig;
@@ -2336,6 +2361,11 @@
 
         // extra client-side dedupe
         this.itemIdsSentSuccessfully = {};
+
+        // Make the flush occur at the interval specified by flushIntervalMs, default behavior will attempt consecutive flushes
+        // as long as the queue is not empty. This is useful for high-frequency events like Session Replay where we might end up
+        // in a request loop and get ratelimited by the server.
+        this.flushOnlyOnInterval = options.flushOnlyOnInterval || false;
     };
 
     /**
@@ -2393,7 +2423,11 @@
     RequestBatcher.prototype.scheduleFlush = function(flushMS) {
         this.flushInterval = flushMS;
         if (!this.stopped) { // don't schedule anymore if batching has been stopped
-            this.timeoutID = setTimeout(_.bind(this.flush, this), this.flushInterval);
+            this.timeoutID = setTimeout(_.bind(function() {
+                if (!this.stopped) {
+                    this.flush();
+                }
+            }, this), this.flushInterval);
         }
     };
 
@@ -2420,6 +2454,9 @@
             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) {
@@ -2487,22 +2524,17 @@
                         this.flush();
                     } else if (
                         _.isObject(res) &&
-                        res.xhr_req &&
-                        (res.xhr_req['status'] >= 500 || res.xhr_req['status'] === 429 || res.error === 'timeout')
+                        (res.httpStatusCode >= 500 || res.httpStatusCode === 429 || res.error === 'timeout')
                     ) {
                         // network or API error, or 429 Too Many Requests, retry
                         var retryMS = this.flushInterval * 2;
-                        var headers = res.xhr_req['responseHeaders'];
-                        if (headers) {
-                            var retryAfter = headers['Retry-After'];
-                            if (retryAfter) {
-                                retryMS = (parseInt(retryAfter, 10) * 1000) || retryMS;
-                            }
+                        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.xhr_req && res.xhr_req['status'] === 413) {
+                    } else if (_.isObject(res) && res.httpStatusCode === 413) {
                         // 413 Payload Too Large
                         if (batch.length > 1) {
                             var halvedBatchSize = Math.max(1, Math.floor(currentBatchSize / 2));
@@ -2526,7 +2558,11 @@
                             _.bind(function(succeeded) {
                                 if (succeeded) {
                                     this.consecutiveRemovalFailures = 0;
-                                    this.flush(); // handle next batch if the queue isn't empty
+                                    if (this.flushOnlyOnInterval && !attemptSecondaryFlush) {
+                                        this.resetFlush(); // schedule next batch with a delay
+                                    } else {
+                                        this.flush(); // handle next batch if the queue isn't empty
+                                    }
                                 } else {
                                     this.reportError('Failed to remove items from queue');
                                     if (++this.consecutiveRemovalFailures > 5) {
@@ -2574,7 +2610,6 @@
             }
             logger.log('MIXPANEL REQUEST:', dataForRequest);
             this.sendRequest(dataForRequest, requestOptions, batchSendCallback);
-
         } catch(err) {
             this.reportError('Error flushing request queue', err);
             this.resetFlush();
@@ -4108,6 +4143,12 @@
     */
 
     var init_type;       // MODULE or SNIPPET loader
+    // allow bundlers to specify how extra code (recorder bundle) should be loaded
+    // eslint-disable-next-line no-unused-vars
+    var load_extra_bundle = function(src, _onload) {
+        throw new Error(src + ' not available in this build.');
+    };
+
     var mixpanel_master; // main mixpanel instance / object
     var INIT_MODULE  = 0;
     var INIT_SNIPPET = 1;
@@ -4201,7 +4242,9 @@
         'hooks':                             {},
         'record_block_class':                new RegExp('^(mp-block|fs-exclude|amp-block|rr-block|ph-no-capture)$'),
         'record_block_selector':             'img, video',
+        'record_collect_fonts':              false,
         'record_idle_timeout_ms':            30 * 60 * 1000, // 30 minutes
+        'record_inline_images':              false,
         'record_mask_text_class':            new RegExp('^(mp-mask|fs-mask|amp-mask|rr-mask|ph-mask)$'),
         'record_mask_text_selector':         '*',
         'record_max_ms':                     MAX_RECORDING_MS,
@@ -4437,12 +4480,7 @@
         }, this);
 
         if (_.isUndefined(win['__mp_recorder'])) {
-            var scriptEl = document$1.createElement('script');
-            scriptEl.type = 'text/javascript';
-            scriptEl.async = true;
-            scriptEl.onload = handleLoadedRecorder;
-            scriptEl.src = this.get_config('recorder_src');
-            document$1.head.appendChild(scriptEl);
+            load_extra_bundle(this.get_config('recorder_src'), handleLoadedRecorder);
         } else {
             handleLoadedRecorder();
         }
@@ -4741,7 +4779,8 @@
                             lib.report_error(error);
                             if (callback) {
                                 if (verbose_mode) {
-                                    callback({status: 0, error: error, xhr_req: req});
+                                    var response_headers = req['responseHeaders'] || {};
+                                    callback({status: 0, httpStatusCode: req['status'], error: error, retryAfter: response_headers['Retry-After']});
                                 } else {
                                     callback(0);
                                 }
@@ -4841,6 +4880,7 @@
                     attrs.queue_key,
                     {
                         libConfig: this['config'],
+                        errorReporter: this.get_config('error_reporter'),
                         sendRequestFunc: _.bind(function(data, options, cb) {
                             this._send_request(
                                 this.get_config('api_host') + attrs.endpoint,
@@ -4852,8 +4892,8 @@
                         beforeSendHook: _.bind(function(item) {
                             return this._run_hook('before_send_' + attrs.type, item);
                         }, this),
-                        errorReporter: this.get_config('error_reporter'),
-                        stopAllBatchingFunc: _.bind(this.stop_batch_senders, this)
+                        stopAllBatchingFunc: _.bind(this.stop_batch_senders, this),
+                        usePersistence: true
                     }
                 );
             }, this);
@@ -6302,7 +6342,8 @@
         _.register_event(win, 'load', dom_loaded_handler, true);
     };
 
-    function init_from_snippet() {
+    function init_from_snippet(bundle_loader) {
+        load_extra_bundle = bundle_loader;
         init_type = INIT_SNIPPET;
         mixpanel_master = win[PRIMARY_INSTANCE_NAME];
 
@@ -6342,8 +6383,19 @@
         add_dom_loaded_handler();
     }
 
+    // For loading separate bundles asynchronously via script tag
+    // so that we don't load them until they are needed at runtime.
+    function loadAsync (src, onload) {
+        var scriptEl = document.createElement('script');
+        scriptEl.type = 'text/javascript';
+        scriptEl.async = true;
+        scriptEl.onload = onload;
+        scriptEl.src = src;
+        document.head.appendChild(scriptEl);
+    }
+
     /* eslint camelcase: "off" */
 
-    init_from_snippet();
+    init_from_snippet(loadAsync);
 
 })();