@mparticle/web-sdk 2.19.1 → 2.19.3

package/dist/mparticle.js

@@ -725,7 +725,7 @@ var mParticle = (function () {
       Environment: Environment
     };
 
-    var version = "2.19.1";
+    var version = "2.19.3";
 
     var Constants = {
       sdkVersion: version,
@@ -2304,132 +2304,144 @@ var mParticle = (function () {
 
       BatchUploader.prototype.prepareAndUpload = function (triggerFuture, useBeacon) {
         return __awaiter(this, void 0, void 0, function () {
-          var currentUser, currentEvents, newBatches, batchesToUpload, batchesThatDidNotUpload, promises;
+          var currentUser, currentEvents, newBatches, batchesToUpload, batchesThatDidNotUpload;
 
-          var _a;
-
-          var _this_1 = this;
-
-          return __generator(this, function (_b) {
-            currentUser = this.mpInstance.Identity.getCurrentUser();
-            currentEvents = this.eventsQueuedForProcessing;
-            this.eventsQueuedForProcessing = [];
-            newBatches = BatchUploader.createNewBatches(currentEvents, currentUser, this.mpInstance);
+          var _a, _b;
 
-            if (!isEmpty(newBatches)) {
-              (_a = this.batchesQueuedForProcessing).push.apply(_a, newBatches);
-            }
+          return __generator(this, function (_c) {
+            switch (_c.label) {
+              case 0:
+                currentUser = this.mpInstance.Identity.getCurrentUser();
+                currentEvents = this.eventsQueuedForProcessing;
+                this.eventsQueuedForProcessing = [];
+                newBatches = BatchUploader.createNewBatches(currentEvents, currentUser, this.mpInstance);
 
-            batchesToUpload = this.batchesQueuedForProcessing;
-            batchesThatDidNotUpload = [];
-            this.batchesQueuedForProcessing = [];
-            promises = batchesToUpload.map(function (upload) {
-              return _this_1.upload(_this_1.mpInstance.Logger, upload, useBeacon);
-            }); // Iterate through fulfilled promises and store any remaining batches
-            // for future re-transmission attempts
+                if (!isEmpty(newBatches)) {
+                  (_a = this.batchesQueuedForProcessing).push.apply(_a, newBatches);
+                }
 
-            if (!isEmpty(promises)) {
-              Promise.all(promises).then(function (batchResponses) {
-                batchResponses.forEach(function (batch) {
-                  return !isEmpty(batch) ? batchesThatDidNotUpload.push(batch) : null;
-                });
-              })["catch"](function (error) {
-                _this_1.mpInstance.Logger.error("Error processing batches during upload attempt: ".concat(error));
-              })["finally"](function () {
-                var _a; // Any batches that did not upload should be put back into the queue for processing
+                batchesToUpload = this.batchesQueuedForProcessing;
+                this.batchesQueuedForProcessing = [];
+                return [4
+                /*yield*/
+                , this.uploadBatches(this.mpInstance.Logger, batchesToUpload, useBeacon)];
 
+              case 1:
+                batchesThatDidNotUpload = _c.sent(); // Batches that do not successfully upload are added back to the process queue
+                // in the order they were created so that we can attempt re-transmission in
+                // the same sequence. This is to prevent any potential data corruption.
 
                 if (!isEmpty(batchesThatDidNotUpload)) {
-                  (_a = _this_1.batchesQueuedForProcessing).unshift.apply(_a, batchesThatDidNotUpload);
+                  // TODO: https://go.mparticle.com/work/SQDSDKS-5165
+                  (_b = this.batchesQueuedForProcessing).unshift.apply(_b, batchesThatDidNotUpload);
                 }
-              });
-            }
 
-            if (triggerFuture) {
-              this.triggerUploadInterval(triggerFuture, false);
-            }
+                if (triggerFuture) {
+                  this.triggerUploadInterval(triggerFuture, false);
+                }
 
-            return [2
-            /*return*/
-            ];
+                return [2
+                /*return*/
+                ];
+            }
           });
         });
-      };
+      }; // TODO: Refactor to use logger as a class method
+      // https://go.mparticle.com/work/SQDSDKS-5167
+
 
-      BatchUploader.prototype.upload = function (logger, batch, useBeacon) {
+      BatchUploader.prototype.uploadBatches = function (logger, batches, useBeacon) {
         return __awaiter(this, void 0, void 0, function () {
-          var fetchPayload, blob, response, error_1;
+          var uploads, i, fetchPayload, blob, response, e_1;
           return __generator(this, function (_a) {
             switch (_a.label) {
               case 0:
-                if (isEmpty(batch) || isEmpty(batch.events)) {
+                uploads = batches.filter(function (batch) {
+                  return !isEmpty(batch.events);
+                });
+
+                if (isEmpty(uploads)) {
                   return [2
                   /*return*/
                   , null];
                 }
 
-                logger.verbose("Uploading batches: ".concat(JSON.stringify(batch)));
+                logger.verbose("Uploading batches: ".concat(JSON.stringify(uploads)));
+                logger.verbose("Batch count: ".concat(uploads.length));
+                i = 0;
+                _a.label = 1;
+
+              case 1:
+                if (!(i < uploads.length)) return [3
+                /*break*/
+                , 6];
                 fetchPayload = {
                   method: 'POST',
                   headers: {
                     Accept: BatchUploader.CONTENT_TYPE,
                     'Content-Type': 'text/plain;charset=UTF-8'
                   },
-                  body: JSON.stringify(batch)
+                  body: JSON.stringify(uploads[i])
                 };
                 if (!(useBeacon && this.isBeaconAvailable())) return [3
                 /*break*/
-                , 1];
+                , 2];
                 blob = new Blob([fetchPayload.body], {
                   type: 'text/plain;charset=UTF-8'
                 });
                 navigator.sendBeacon(this.uploadUrl, blob);
                 return [3
                 /*break*/
-                , 4];
+                , 5];
 
-              case 1:
-                _a.trys.push([1, 3,, 4]);
+              case 2:
+                _a.trys.push([2, 4,, 5]);
 
                 return [4
                 /*yield*/
                 , this.uploader.upload(fetchPayload)];
 
-              case 2:
-                response = _a.sent(); // TODO: Should we make this a switch statement instead?
+              case 3:
+                response = _a.sent();
 
                 if (response.status >= 200 && response.status < 300) {
-                  logger.verbose("Upload success for request ID: ".concat(batch.source_request_id));
-                  return [2
-                  /*return*/
-                  , null];
+                  logger.verbose("Upload success for request ID: ".concat(uploads[i].source_request_id));
                 } else if (response.status >= 500 || response.status === 429) {
-                  logger.error("HTTP error status ".concat(response.status, " received")); // Server error, return current batch and try again later
+                  logger.error("HTTP error status ".concat(response.status, " received")); // Server error, add back current batches and try again later
 
                   return [2
                   /*return*/
-                  , batch];
+                  , uploads.slice(i, uploads.length)];
                 } else if (response.status >= 401) {
-                  logger.error("HTTP error status ".concat(response.status, " while uploading - please verify your API key.")); // if we're getting a 401, assume we'll keep getting a 401
-                  // so return the upload so it can be stored for later use
+                  logger.error("HTTP error status ".concat(response.status, " while uploading - please verify your API key.")); //if we're getting a 401, assume we'll keep getting a 401 and clear the uploads.
 
                   return [2
                   /*return*/
-                  , batch];
+                  , null];
+                } else {
+                  // In case there is an HTTP error we did not anticipate.
+                  console.error("HTTP error status ".concat(response.status, " while uploading events."), response);
+                  throw new Error("Uncaught HTTP Error ".concat(response.status, ".  Batch upload will be re-attempted."));
                 }
 
                 return [3
                 /*break*/
-                , 4];
+                , 5];
 
-              case 3:
-                error_1 = _a.sent();
-                logger.error("Error sending event to mParticle servers. ".concat(error_1));
+              case 4:
+                e_1 = _a.sent();
+                logger.error("Error sending event to mParticle servers. ".concat(e_1));
                 return [2
                 /*return*/
-                , batch];
+                , uploads.slice(i, uploads.length)];
 
-              case 4:
+              case 5:
+                i++;
+                return [3
+                /*break*/
+                , 1];
+
+              case 6:
                 return [2
                 /*return*/
                 , null];
@@ -3193,6 +3205,11 @@ var mParticle = (function () {
         return filteredUserAttributes;
       };
 
+      this.isFilteredUserAttribute = function (userAttributeKey, filterList) {
+        var hashedUserAttribute = self.generateHash(userAttributeKey);
+        return filterList && self.inArray(filterList, hashedUserAttribute);
+      };
+
       this.isEventType = function (type) {
         for (var prop in Types.EventType) {
           if (Types.EventType.hasOwnProperty(prop)) {
@@ -6171,6 +6188,10 @@ var mParticle = (function () {
 
     function Forwarders(mpInstance, kitBlocker) {
       var self = this;
+      var UserAttributeActionTypes = {
+        setUserAttribute: 'setUserAttribute',
+        removeUserAttribute: 'removeUserAttribute'
+      };
 
       this.initForwarders = function (userIdentities, forwardingStatsCallback) {
         var user = mpInstance.Identity.getCurrentUser();
@@ -6405,26 +6426,34 @@ var mParticle = (function () {
         }
       };
 
-      this.callSetUserAttributeOnForwarders = function (key, value) {
-        if (kitBlocker && kitBlocker.isAttributeKeyBlocked(key)) {
+      this.handleForwarderUserAttributes = function (functionNameKey, key, value) {
+        if (kitBlocker && kitBlocker.isAttributeKeyBlocked(key) || !mpInstance._Store.activeForwarders.length) {
           return;
         }
 
-        if (mpInstance._Store.activeForwarders.length) {
-          mpInstance._Store.activeForwarders.forEach(function (forwarder) {
-            if (forwarder.setUserAttribute && forwarder.userAttributeFilters && !mpInstance._Helpers.inArray(forwarder.userAttributeFilters, mpInstance._Helpers.generateHash(key))) {
-              try {
-                var result = forwarder.setUserAttribute(key, value);
+        mpInstance._Store.activeForwarders.forEach(function (forwarder) {
+          var forwarderFunction = forwarder[functionNameKey];
 
-                if (result) {
-                  mpInstance.Logger.verbose(result);
-                }
-              } catch (e) {
-                mpInstance.Logger.error(e);
-              }
+          if (!forwarderFunction || mpInstance._Helpers.isFilteredUserAttribute(key, forwarder.userAttributeFilters)) {
+            return;
+          }
+
+          try {
+            var result;
+
+            if (functionNameKey === UserAttributeActionTypes.setUserAttribute) {
+              result = forwarder.setUserAttribute(key, value);
+            } else if (functionNameKey === UserAttributeActionTypes.removeUserAttribute) {
+              result = forwarder.removeUserAttribute(key);
             }
-          });
-        }
+
+            if (result) {
+              mpInstance.Logger.verbose(result);
+            }
+          } catch (e) {
+            mpInstance.Logger.error(e);
+          }
+        });
       };
 
       this.setForwarderUserIdentities = function (userIdentities) {
@@ -7629,7 +7658,7 @@ var mParticle = (function () {
 
                 mpInstance._Forwarders.initForwarders(self.IdentityAPI.getCurrentUser().getUserIdentities(), mpInstance._APIClient.prepareForwardingStats);
 
-                mpInstance._Forwarders.callSetUserAttributeOnForwarders(key, newValue);
+                mpInstance._Forwarders.handleForwarderUserAttributes('setUserAttribute', key, newValue);
               }
             }
           },
@@ -7698,7 +7727,7 @@ var mParticle = (function () {
 
               mpInstance._Forwarders.initForwarders(self.IdentityAPI.getCurrentUser().getUserIdentities(), mpInstance._APIClient.prepareForwardingStats);
 
-              mpInstance._Forwarders.applyToForwarders('removeUserAttribute', key);
+              mpInstance._Forwarders.handleForwarderUserAttributes('removeUserAttribute', key, null);
             }
           },
 
@@ -7776,7 +7805,7 @@ var mParticle = (function () {
 
               mpInstance._Forwarders.initForwarders(self.IdentityAPI.getCurrentUser().getUserIdentities(), mpInstance._APIClient.prepareForwardingStats);
 
-              mpInstance._Forwarders.callSetUserAttributeOnForwarders(key, arrayCopy);
+              mpInstance._Forwarders.handleForwarderUserAttributes('setUserAttribute', key, arrayCopy);
             }
           },
 
@@ -7799,7 +7828,7 @@ var mParticle = (function () {
               if (userAttributes) {
                 for (var prop in userAttributes) {
                   if (userAttributes.hasOwnProperty(prop)) {
-                    mpInstance._Forwarders.applyToForwarders('removeUserAttribute', prop);
+                    mpInstance._Forwarders.handleForwarderUserAttributes('removeUserAttribute', prop, null);
                   }
 
                   this.removeUserAttribute(prop);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.19.1",
+    "version": "2.19.3",
     "description": "mParticle core SDK for web applications",
     "license": "Apache-2.0",
     "keywords": [
@@ -28,13 +28,14 @@
         "build:esm": "cross-env ENVIRONMENT=prod BUILD=esm rollup --config rollup.config.js",
         "build:stub": "cross-env ENVIRONMENT=prod BUILD=stub rollup --config rollup.config.js",
         "build:snippet": "uglifyjs snippet.js -nm -o snippet.min.js",
+        "build:test-bundle": "cross-env TESTTYPE=main ENVIRONMENT=prod rollup --config rollup.test.config.js",
         "build:browserify:cjs": "browserify test/integrations/cjs/browserify/index.js -o test/integrations/cjs/dist/browserify-output.js  && npm run test:karma:browserify:cjs",
         "build:rollup:cjs": "rollup --config test/integrations/cjs/rollup/rollup.config.js  && npm run test:karma:rollup:cjs",
         "build:webpack:cjs": "webpack --config test/integrations/cjs/webpack/webpack.config.js && npm run test:karma:webpack:cjs",
         "build:rollup:module": "rollup --config test/integrations/module/rollup/rollup.config.js  && npm run test:karma:rollup:module",
         "build:webpack:module": "webpack --config test/integrations/module/webpack/webpack.config.js && npm run test:karma:webpack:module",
         "build:ts": "tsc -p .",
-        "test": "npm run build && cross-env TESTTYPE=main ENVIRONMENT=prod rollup --config rollup.test.config.js && cross-env DEBUG=false karma start test/karma.config.js",
+        "test": "npm run build && npm run build:test-bundle && cross-env DEBUG=false karma start test/karma.config.js",
         "test:debug": "cross-env DEBUG=true karma start test/karma.config.js",
         "test:stub": "cross-env TESTTYPE=stub ENVIRONMENT=prod rollup --config rollup.test.config.js && karma start test/stub/karma.stub.config.js",
         "test:integrations": "npm run test:requirejs && npm run test:integrations:cjs && npm run test:integrations:module",

package/src/batchUploader.ts

@@ -211,6 +211,7 @@ export class BatchUploader {
         triggerFuture: boolean,
         useBeacon: boolean
     ): Promise<void> {
+        // Fetch current user so that events can be grouped by MPID
         const currentUser = this.mpInstance.Identity.getCurrentUser();
 
         const currentEvents = this.eventsQueuedForProcessing;
@@ -221,43 +222,27 @@ export class BatchUploader {
             currentUser,
             this.mpInstance
         );
+
         if (!isEmpty(newBatches)) {
             this.batchesQueuedForProcessing.push(...newBatches);
         }
 
+        // Clear out pending batches to avoid any potential duplication
         const batchesToUpload = this.batchesQueuedForProcessing;
-        const batchesThatDidNotUpload: Batch[] = [];
         this.batchesQueuedForProcessing = [];
 
-        // Create an array of promises as we try to upload each batch indvidually
-        const promises: Promise<Batch>[] = batchesToUpload.map((upload) => {
-            return this.upload(this.mpInstance.Logger, upload, useBeacon);
-        });
+        const batchesThatDidNotUpload = await this.uploadBatches(
+            this.mpInstance.Logger,
+            batchesToUpload,
+            useBeacon
+        );
 
-        // Iterate through fulfilled promises and store any remaining batches
-        // for future re-transmission attempts
-        if (!isEmpty(promises)) {
-            Promise.all(promises)
-                .then((batchResponses) => {
-                    batchResponses.forEach((batch) =>
-                        !isEmpty(batch)
-                            ? batchesThatDidNotUpload.push(batch)
-                            : null
-                    );
-                })
-                .catch((error) => {
-                    this.mpInstance.Logger.error(
-                        `Error processing batches during upload attempt: ${error}`
-                    );
-                })
-                .finally(() => {
-                    // Any batches that did not upload should be put back into the queue for processing
-                    if (!isEmpty(batchesThatDidNotUpload)) {
-                        this.batchesQueuedForProcessing.unshift(
-                            ...batchesThatDidNotUpload
-                        );
-                    }
-                });
+        // Batches that do not successfully upload are added back to the process queue
+        // in the order they were created so that we can attempt re-transmission in
+        // the same sequence. This is to prevent any potential data corruption.
+        if (!isEmpty(batchesThatDidNotUpload)) {
+            // TODO: https://go.mparticle.com/work/SQDSDKS-5165
+            this.batchesQueuedForProcessing.unshift(...batchesThatDidNotUpload);
         }
 
         if (triggerFuture) {
@@ -265,64 +250,79 @@ export class BatchUploader {
         }
     }
 
-    private async upload(
+    // TODO: Refactor to use logger as a class method
+    // https://go.mparticle.com/work/SQDSDKS-5167
+    private async uploadBatches(
         logger: SDKLoggerApi,
-        batch: Batch,
+        batches: Batch[],
         useBeacon: boolean
-    ): Promise<Batch | null> {
-        if (isEmpty(batch) || isEmpty(batch.events)) {
+    ): Promise<Batch[] | null> {
+        // Filter out any batches that don't have events
+        const uploads = batches.filter((batch) => !isEmpty(batch.events));
+
+        if (isEmpty(uploads)) {
             return null;
         }
 
-        logger.verbose(`Uploading batches: ${JSON.stringify(batch)}`);
-
-        const fetchPayload: fetchPayload = {
-            method: 'POST',
-            headers: {
-                Accept: BatchUploader.CONTENT_TYPE,
-                'Content-Type': 'text/plain;charset=UTF-8',
-            },
-            body: JSON.stringify(batch),
-        };
-
-        // TODO: Make beacon its own function
-        // beacon is only used on onbeforeunload onpagehide events
-        if (useBeacon && this.isBeaconAvailable()) {
-            let blob = new Blob([fetchPayload.body], {
-                type: 'text/plain;charset=UTF-8',
-            });
-            navigator.sendBeacon(this.uploadUrl, blob);
-        } else {
-            try {
-                const response = await this.uploader.upload(fetchPayload);
-
-                // TODO: Should we make this a switch statement instead?
-                if (response.status >= 200 && response.status < 300) {
-                    logger.verbose(
-                        `Upload success for request ID: ${batch.source_request_id}`
-                    );
+        logger.verbose(`Uploading batches: ${JSON.stringify(uploads)}`);
+        logger.verbose(`Batch count: ${uploads.length}`);
+
+        for (let i = 0; i < uploads.length; i++) {
+            const fetchPayload: fetchPayload = {
+                method: 'POST',
+                headers: {
+                    Accept: BatchUploader.CONTENT_TYPE,
+                    'Content-Type': 'text/plain;charset=UTF-8',
+                },
+                body: JSON.stringify(uploads[i]),
+            };
 
-                    return null;
-                } else if (response.status >= 500 || response.status === 429) {
-                    logger.error(
-                        `HTTP error status ${response.status} received`
-                    );
+            // beacon is only used on onbeforeunload onpagehide events
+            if (useBeacon && this.isBeaconAvailable()) {
+                let blob = new Blob([fetchPayload.body], {
+                    type: 'text/plain;charset=UTF-8',
+                });
+                navigator.sendBeacon(this.uploadUrl, blob);
+            } else {
+                try {
+                    const response = await this.uploader.upload(fetchPayload);
+
+                    if (response.status >= 200 && response.status < 300) {
+                        logger.verbose(
+                            `Upload success for request ID: ${uploads[i].source_request_id}`
+                        );
+                    } else if (
+                        response.status >= 500 ||
+                        response.status === 429
+                    ) {
+                        logger.error(
+                            `HTTP error status ${response.status} received`
+                        );
+                        // Server error, add back current batches and try again later
+                        return uploads.slice(i, uploads.length);
+                    } else if (response.status >= 401) {
+                        logger.error(
+                            `HTTP error status ${response.status} while uploading - please verify your API key.`
+                        );
+                        //if we're getting a 401, assume we'll keep getting a 401 and clear the uploads.
+                        return null;
+                    } else {
+                        // In case there is an HTTP error we did not anticipate.
+                        console.error(
+                            `HTTP error status ${response.status} while uploading events.`,
+                            response
+                        );
 
-                    // Server error, return current batch and try again later
-                    return batch;
-                } else if (response.status >= 401) {
+                        throw new Error(
+                            `Uncaught HTTP Error ${response.status}.  Batch upload will be re-attempted.`
+                        );
+                    }
+                } catch (e) {
                     logger.error(
-                        `HTTP error status ${response.status} while uploading - please verify your API key.`
+                        `Error sending event to mParticle servers. ${e}`
                     );
-                    // if we're getting a 401, assume we'll keep getting a 401
-                    // so return the upload so it can be stored for later use
-                    return batch;
+                    return uploads.slice(i, uploads.length);
                 }
-            } catch (error) {
-                logger.error(
-                    `Error sending event to mParticle servers. ${error}`
-                );
-                return batch;
             }
         }
         return null;

package/src/forwarders.js

@@ -3,6 +3,12 @@ import filteredMparticleUser from './filteredMparticleUser';
 
 export default function Forwarders(mpInstance, kitBlocker) {
     var self = this;
+
+    const UserAttributeActionTypes = {
+        setUserAttribute: 'setUserAttribute',
+        removeUserAttribute: 'removeUserAttribute',
+    };
+
     this.initForwarders = function(userIdentities, forwardingStatsCallback) {
         var user = mpInstance.Identity.getCurrentUser();
         if (
@@ -387,33 +393,47 @@ export default function Forwarders(mpInstance, kitBlocker) {
         }
     };
 
-    this.callSetUserAttributeOnForwarders = function(key, value) {
-        if (kitBlocker && kitBlocker.isAttributeKeyBlocked(key)) {
+    this.handleForwarderUserAttributes = function(functionNameKey, key, value) {
+        if (
+            (kitBlocker && kitBlocker.isAttributeKeyBlocked(key)) ||
+            !mpInstance._Store.activeForwarders.length
+        ) {
             return;
         }
 
-        if (mpInstance._Store.activeForwarders.length) {
-            mpInstance._Store.activeForwarders.forEach(function(forwarder) {
+        mpInstance._Store.activeForwarders.forEach(function(forwarder) {
+            const forwarderFunction = forwarder[functionNameKey];
+            if (
+                !forwarderFunction ||
+                mpInstance._Helpers.isFilteredUserAttribute(
+                    key,
+                    forwarder.userAttributeFilters
+                )
+            ) {
+                return;
+            }
+            try {
+                let result;
+
                 if (
-                    forwarder.setUserAttribute &&
-                    forwarder.userAttributeFilters &&
-                    !mpInstance._Helpers.inArray(
-                        forwarder.userAttributeFilters,
-                        mpInstance._Helpers.generateHash(key)
-                    )
+                    functionNameKey ===
+                    UserAttributeActionTypes.setUserAttribute
                 ) {
-                    try {
-                        var result = forwarder.setUserAttribute(key, value);
+                    result = forwarder.setUserAttribute(key, value);
+                } else if (
+                    functionNameKey ===
+                    UserAttributeActionTypes.removeUserAttribute
+                ) {
+                    result = forwarder.removeUserAttribute(key);
+                }
 
-                        if (result) {
-                            mpInstance.Logger.verbose(result);
-                        }
-                    } catch (e) {
-                        mpInstance.Logger.error(e);
-                    }
+                if (result) {
+                    mpInstance.Logger.verbose(result);
                 }
-            });
-        }
+            } catch (e) {
+                mpInstance.Logger.error(e);
+            }
+        });
     };
 
     this.setForwarderUserIdentities = function(userIdentities) {

package/src/helpers.js

@@ -387,6 +387,11 @@ export default function Helpers(mpInstance) {
         return filteredUserAttributes;
     };
 
+    this.isFilteredUserAttribute = function(userAttributeKey, filterList) {
+        const hashedUserAttribute = self.generateHash(userAttributeKey);
+        return filterList && self.inArray(filterList, hashedUserAttribute);
+    };
+
     this.isEventType = function(type) {
         for (var prop in Types.EventType) {
             if (Types.EventType.hasOwnProperty(prop)) {