@mparticle/web-sdk 2.19.2 → 2.20.0

package/dist/mparticle.js

@@ -725,7 +725,7 @@ var mParticle = (function () {
       Environment: Environment
     };
 
-    var version = "2.19.2";
+    var version = "2.20.0";
 
     var Constants = {
       sdkVersion: version,
@@ -2111,12 +2111,27 @@ var mParticle = (function () {
       }
     }
 
+    /**
+     * BatchUploader contains all the logic to upload batches to mParticle.
+     * It queues events as they come in and at set intervals turns them into batches.
+     * It then attempts to upload them to mParticle.
+     *
+     * These uploads happen on an interval basis using window.fetch or XHR
+     * requests, depending on what is available in the browser.
+     *
+     * Uploads can also be triggered on browser visibility/focus changes via an
+     * event listener, which then uploads to mPartice via the browser's Beacon API.
+     */
+
     var BatchUploader =
     /** @class */
     function () {
+      /**
+       * Creates an instance of a BatchUploader
+       * @param {MParticleWebSDK} mpInstance - the mParticle SDK instance
+       * @param {number} uploadInterval - the desired upload interval in milliseconds
+       */
       function BatchUploader(mpInstance, uploadInterval) {
-        var _this_1 = this;
-
         this.mpInstance = mpInstance;
         this.uploadIntervalMillis = uploadInterval;
         this.batchingEnabled = uploadInterval >= BatchUploader.MINIMUM_INTERVAL_MILLIS;
@@ -2125,8 +2140,8 @@ var mParticle = (function () {
           this.uploadIntervalMillis = BatchUploader.MINIMUM_INTERVAL_MILLIS;
         }
 
-        this.pendingEvents = [];
-        this.pendingUploads = [];
+        this.eventsQueuedForProcessing = [];
+        this.batchesQueuedForProcessing = [];
         var _a = this.mpInstance._Store,
             SDKConfig = _a.SDKConfig,
             devToken = _a.devToken;
@@ -2134,14 +2149,16 @@ var mParticle = (function () {
         var baseUrl = this.mpInstance._Helpers.createServiceUrl(SDKConfig.v3SecureServiceUrl, devToken);
 
         this.uploadUrl = "".concat(baseUrl, "/events");
-        setTimeout(function () {
-          _this_1.prepareAndUpload(true, false);
-        }, this.uploadIntervalMillis);
+        this.uploader = window.fetch ? new FetchUploader(this.uploadUrl) : new XHRUploader(this.uploadUrl);
+        this.triggerUploadInterval(true, false);
         this.addEventListeners();
-      }
+      } // Adds listeners to be used trigger Navigator.sendBeacon if the browser
+      // loses focus for any reason, such as closing browser tab or minimizing window
+
 
       BatchUploader.prototype.addEventListeners = function () {
-        var _this = this;
+        var _this = this; // visibility change is a document property, not window
+
 
         document.addEventListener('visibilitychange', function () {
           _this.prepareAndUpload(false, _this.isBeaconAvailable());
@@ -2160,13 +2177,36 @@ var mParticle = (function () {
         }
 
         return false;
+      }; // Triggers a setTimeout for prepareAndUpload
+
+
+      BatchUploader.prototype.triggerUploadInterval = function (triggerFuture, useBeacon) {
+        var _this_1 = this;
+
+        if (triggerFuture === void 0) {
+          triggerFuture = false;
+        }
+
+        if (useBeacon === void 0) {
+          useBeacon = false;
+        }
+
+        setTimeout(function () {
+          _this_1.prepareAndUpload(triggerFuture, useBeacon);
+        }, this.uploadIntervalMillis);
       };
+      /**
+       * This method will queue a single Event which will eventually be processed into a Batch
+       * @param event event that should be queued
+       */
+
 
       BatchUploader.prototype.queueEvent = function (event) {
         if (!isEmpty(event)) {
-          this.pendingEvents.push(event);
+          this.eventsQueuedForProcessing.push(event);
           this.mpInstance.Logger.verbose("Queuing event: ".concat(JSON.stringify(event)));
-          this.mpInstance.Logger.verbose("Queued event count: ".concat(this.pendingEvents.length));
+          this.mpInstance.Logger.verbose("Queued event count: ".concat(this.eventsQueuedForProcessing.length)); // TODO: Remove this check once the v2 code path is removed
+          //       https://go.mparticle.com/work/SQDSDKS-3720
 
           if (!this.batchingEnabled || Types.TriggerUploadType[event.EventDataType]) {
             this.prepareAndUpload(false, false);
@@ -2184,7 +2224,7 @@ var mParticle = (function () {
        */
 
 
-      BatchUploader.createNewUploads = function (sdkEvents, defaultUser, mpInstance) {
+      BatchUploader.createNewBatches = function (sdkEvents, defaultUser, mpInstance) {
         if (!defaultUser || !sdkEvents || !sdkEvents.length) {
           return null;
         } //bucket by MPID, and then by session, ordered by timestamp
@@ -2264,41 +2304,40 @@ var mParticle = (function () {
 
       BatchUploader.prototype.prepareAndUpload = function (triggerFuture, useBeacon) {
         return __awaiter(this, void 0, void 0, function () {
-          var currentUser, currentEvents, newUploads, currentUploads, remainingUploads;
+          var currentUser, currentEvents, newBatches, batchesToUpload, batchesThatDidNotUpload;
 
           var _a, _b;
 
-          var _this_1 = this;
-
           return __generator(this, function (_c) {
             switch (_c.label) {
               case 0:
                 currentUser = this.mpInstance.Identity.getCurrentUser();
-                currentEvents = this.pendingEvents;
-                this.pendingEvents = [];
-                newUploads = BatchUploader.createNewUploads(currentEvents, currentUser, this.mpInstance);
+                currentEvents = this.eventsQueuedForProcessing;
+                this.eventsQueuedForProcessing = [];
+                newBatches = BatchUploader.createNewBatches(currentEvents, currentUser, this.mpInstance);
 
-                if (newUploads && newUploads.length) {
-                  (_a = this.pendingUploads).push.apply(_a, newUploads);
+                if (!isEmpty(newBatches)) {
+                  (_a = this.batchesQueuedForProcessing).push.apply(_a, newBatches);
                 }
 
-                currentUploads = this.pendingUploads;
-                this.pendingUploads = [];
+                batchesToUpload = this.batchesQueuedForProcessing;
+                this.batchesQueuedForProcessing = [];
                 return [4
                 /*yield*/
-                , this.upload(this.mpInstance.Logger, currentUploads, useBeacon)];
+                , this.uploadBatches(this.mpInstance.Logger, batchesToUpload, useBeacon)];
 
               case 1:
-                remainingUploads = _c.sent();
+                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 (remainingUploads && remainingUploads.length) {
-                  (_b = this.pendingUploads).unshift.apply(_b, remainingUploads);
+                if (!isEmpty(batchesThatDidNotUpload)) {
+                  // TODO: https://go.mparticle.com/work/SQDSDKS-5165
+                  (_b = this.batchesQueuedForProcessing).unshift.apply(_b, batchesThatDidNotUpload);
                 }
 
                 if (triggerFuture) {
-                  setTimeout(function () {
-                    _this_1.prepareAndUpload(true, false);
-                  }, this.uploadIntervalMillis);
+                  this.triggerUploadInterval(triggerFuture, false);
                 }
 
                 return [2
@@ -2307,16 +2346,18 @@ var mParticle = (function () {
             }
           });
         });
-      };
+      }; // TODO: Refactor to use logger as a class method
+      // https://go.mparticle.com/work/SQDSDKS-5167
 
-      BatchUploader.prototype.upload = function (logger, _uploads, useBeacon) {
+
+      BatchUploader.prototype.uploadBatches = function (logger, batches, useBeacon) {
         return __awaiter(this, void 0, void 0, function () {
-          var uploader, uploads, i, fetchPayload, blob, response, e_1;
+          var uploads, i, fetchPayload, blob, response, e_1;
           return __generator(this, function (_a) {
             switch (_a.label) {
               case 0:
-                uploads = _uploads.filter(function (upload) {
-                  return !isEmpty(upload.events);
+                uploads = batches.filter(function (batch) {
+                  return !isEmpty(batch.events);
                 });
 
                 if (isEmpty(uploads)) {
@@ -2333,7 +2374,7 @@ var mParticle = (function () {
               case 1:
                 if (!(i < uploads.length)) return [3
                 /*break*/
-                , 7];
+                , 6];
                 fetchPayload = {
                   method: 'POST',
                   headers: {
@@ -2351,33 +2392,22 @@ var mParticle = (function () {
                 navigator.sendBeacon(this.uploadUrl, blob);
                 return [3
                 /*break*/
-                , 6];
+                , 5];
 
               case 2:
-                if (!uploader) {
-                  if (window.fetch) {
-                    uploader = new FetchUploader(this.uploadUrl, logger);
-                  } else {
-                    uploader = new XHRUploader(this.uploadUrl, logger);
-                  }
-                }
-
-                _a.label = 3;
-
-              case 3:
-                _a.trys.push([3, 5,, 6]);
+                _a.trys.push([2, 4,, 5]);
 
                 return [4
                 /*yield*/
-                , uploader.upload(fetchPayload, uploads, i)];
+                , this.uploader.upload(fetchPayload)];
 
-              case 4:
+              case 3:
                 response = _a.sent();
 
                 if (response.status >= 200 && response.status < 300) {
                   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, add back current events 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*/
@@ -2388,33 +2418,37 @@ var mParticle = (function () {
                   return [2
                   /*return*/
                   , 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*/
-                , 6];
+                , 5];
 
-              case 5:
+              case 4:
                 e_1 = _a.sent();
                 logger.error("Error sending event to mParticle servers. ".concat(e_1));
                 return [2
                 /*return*/
                 , uploads.slice(i, uploads.length)];
 
-              case 6:
+              case 5:
                 i++;
                 return [3
                 /*break*/
                 , 1];
 
-              case 7:
+              case 6:
                 return [2
                 /*return*/
                 , null];
             }
           });
         });
-      }; //we upload JSON, but this content type is required to avoid a CORS preflight request
+      }; // We upload JSON, but this content type is required to avoid a CORS preflight request
 
 
       BatchUploader.CONTENT_TYPE = 'text/plain;charset=UTF-8';
@@ -2425,9 +2459,8 @@ var mParticle = (function () {
     var AsyncUploader =
     /** @class */
     function () {
-      function AsyncUploader(url, logger) {
+      function AsyncUploader(url) {
         this.url = url;
-        this.logger = logger;
       }
 
       return AsyncUploader;
@@ -2442,7 +2475,7 @@ var mParticle = (function () {
         return _super !== null && _super.apply(this, arguments) || this;
       }
 
-      FetchUploader.prototype.upload = function (fetchPayload, uploads, i) {
+      FetchUploader.prototype.upload = function (fetchPayload) {
         return __awaiter(this, void 0, void 0, function () {
           var response;
           return __generator(this, function (_a) {
@@ -2474,7 +2507,7 @@ var mParticle = (function () {
         return _super !== null && _super.apply(this, arguments) || this;
       }
 
-      XHRUploader.prototype.upload = function (fetchPayload, uploads, i) {
+      XHRUploader.prototype.upload = function (fetchPayload) {
         return __awaiter(this, void 0, void 0, function () {
           var response;
           return __generator(this, function (_a) {
@@ -2482,7 +2515,7 @@ var mParticle = (function () {
               case 0:
                 return [4
                 /*yield*/
-                , this.makeRequest(this.url, this.logger, fetchPayload.body)];
+                , this.makeRequest(this.url, fetchPayload.body)];
 
               case 1:
                 response = _a.sent();
@@ -2494,7 +2527,7 @@ var mParticle = (function () {
         });
       };
 
-      XHRUploader.prototype.makeRequest = function (url, logger, data) {
+      XHRUploader.prototype.makeRequest = function (url, data) {
         return __awaiter(this, void 0, void 0, function () {
           var xhr;
           return __generator(this, function (_a) {
@@ -3172,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)) {
@@ -4269,6 +4307,7 @@ var mParticle = (function () {
         prodStorageName: null,
         activeForwarders: [],
         kits: {},
+        sideloadedKits: [],
         configuredForwarders: [],
         pixelConfigurations: [],
         wrapperSDKInfo: {
@@ -4326,6 +4365,7 @@ var mParticle = (function () {
 
         this.SDKConfig.useNativeSdk = !!config.useNativeSdk;
         this.SDKConfig.kits = config.kits || {};
+        this.SDKConfig.sideloadedKits = config.sideloadedKits || [];
 
         if (config.hasOwnProperty('isIOS')) {
           this.SDKConfig.isIOS = config.isIOS;
@@ -5321,6 +5361,9 @@ var mParticle = (function () {
         if (userAttributes) {
           if (persistence) {
             if (persistence[mpid]) {
+              // TODO: Investigate why setting this to UI still shows up as UA
+              //       when running `mParticle.getInstance()._Persistence.getLocalStorage()`
+              // https://go.mparticle.com/work/SQDSDKS-5195
               persistence[mpid].ui = userAttributes;
             } else {
               persistence[mpid] = {
@@ -6150,6 +6193,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();
@@ -6384,26 +6431,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) {
@@ -6484,16 +6539,50 @@ var mParticle = (function () {
 
       this.setForwarderStatsQueue = function (queue) {
         mpInstance._Persistence.forwardingStatsBatches.forwardingStatsEventQueue = queue;
+      }; // Processing forwarders is a 2 step process:
+      //   1. Configure the kit
+      //   2. Initialize the kit
+      // There are 2 types of kits:
+      //   1. UI-enabled kits
+      //   2. Sideloaded kits.
+
+
+      this.processForwarders = function (config, forwardingStatsCallback) {
+        if (!config) {
+          mpInstance.Logger.warning('No config was passed. Cannot process forwarders');
+        } else {
+          this.processUIEnabledKits(config);
+          this.processSideloadedKits(config);
+          self.initForwarders(mpInstance._Store.SDKConfig.identifyRequest.userIdentities, forwardingStatsCallback);
+        }
+      }; // These are kits that are enabled via the mParticle UI.
+      // A kit that is UI-enabled will have a kit configuration that returns from
+      // the server, or in rare cases, is passed in by the developer.
+      // The kit configuration will be compared with the kit constructors to determine
+      // if there is a match before being initialized.
+      // Only kits that are configured properly can be active and used for kit forwarding.
+
+
+      this.processUIEnabledKits = function (config) {
+        try {
+          if (Array.isArray(config.kitConfigs) && config.kitConfigs.length) {
+            config.kitConfigs.forEach(function (kitConfig) {
+              self.configureUIEnabledKit(kitConfig);
+            });
+          }
+        } catch (e) {
+          mpInstance.Logger.error('MP Kits not configured propertly. Kits may not be initialized. ' + e);
+        }
       };
 
-      this.configureForwarder = function (configuration) {
+      this.configureUIEnabledKit = function (configuration) {
         var newForwarder = null,
             config = configuration,
-            forwarders = {}; // if there are kits inside of mpInstance._Store.SDKConfig.kits, then mParticle is self hosted
+            forwarders = {}; // If there are kits inside of mpInstance._Store.SDKConfig.kits, then mParticle is self hosted
 
-        if (mpInstance._Helpers.isObject(mpInstance._Store.SDKConfig.kits) && Object.keys(mpInstance._Store.SDKConfig.kits).length > 0) {
+        if (!isEmpty(mpInstance._Store.SDKConfig.kits)) {
           forwarders = mpInstance._Store.SDKConfig.kits; // otherwise mParticle is loaded via script tag
-        } else if (mpInstance._preInit.forwarderConstructors.length > 0) {
+        } else if (!isEmpty(mpInstance._preInit.forwarderConstructors)) {
           mpInstance._preInit.forwarderConstructors.forEach(function (forwarder) {
             forwarders[forwarder.name] = forwarder;
           });
@@ -6502,25 +6591,7 @@ var mParticle = (function () {
         for (var name in forwarders) {
           if (name === config.name) {
             if (config.isDebug === mpInstance._Store.SDKConfig.isDevelopmentMode || config.isSandbox === mpInstance._Store.SDKConfig.isDevelopmentMode) {
-              newForwarder = new forwarders[name].constructor();
-              newForwarder.id = config.moduleId;
-              newForwarder.isSandbox = config.isDebug || config.isSandbox;
-              newForwarder.hasSandbox = config.hasDebugString === 'true';
-              newForwarder.isVisible = config.isVisible;
-              newForwarder.settings = config.settings;
-              newForwarder.eventNameFilters = config.eventNameFilters;
-              newForwarder.eventTypeFilters = config.eventTypeFilters;
-              newForwarder.attributeFilters = config.attributeFilters;
-              newForwarder.screenNameFilters = config.screenNameFilters;
-              newForwarder.screenNameFilters = config.screenNameFilters;
-              newForwarder.screenAttributeFilters = config.screenAttributeFilters;
-              newForwarder.userIdentityFilters = config.userIdentityFilters;
-              newForwarder.userAttributeFilters = config.userAttributeFilters;
-              newForwarder.filteringEventAttributeValue = config.filteringEventAttributeValue;
-              newForwarder.filteringUserAttributeValue = config.filteringUserAttributeValue;
-              newForwarder.eventSubscriptionId = config.eventSubscriptionId;
-              newForwarder.filteringConsentRuleValues = config.filteringConsentRuleValues;
-              newForwarder.excludeAnonymousUser = config.excludeAnonymousUser;
+              newForwarder = this.returnConfiguredKit(forwarders[name], config);
 
               mpInstance._Store.configuredForwarders.push(newForwarder);
 
@@ -6528,6 +6599,68 @@ var mParticle = (function () {
             }
           }
         }
+      }; // Sideloaded kits are not configured in the UI and do not have kit configurations
+      // They are automatically added to active forwarders.
+      // TODO: Sideloading kits currently requires the use of a register method
+      // which requires an object on which to be registered.
+      // In the future, when all kits are moved to the config rather than
+      // there being a separate process for MP configured kits and
+      // sideloaded kits, this will need to be refactored.
+
+
+      this.processSideloadedKits = function (config) {
+        try {
+          if (Array.isArray(config.sideloadedKits)) {
+            var sideloadedKits = {
+              kits: {}
+            }; // First register each kit's constructor onto sideloadedKits,
+            // which is typed { kits: Dictionary<constructor> }.
+            // The constructors are keyed by the name of the kit.
+
+            config.sideloadedKits.forEach(function (sideloadedKit) {
+              sideloadedKit.register(sideloadedKits);
+            }); // Then configure each kit
+
+            for (var registeredKitKey in sideloadedKits.kits) {
+              var kitConstructor = sideloadedKits.kits[registeredKitKey];
+              self.configureSideloadedKit(kitConstructor);
+            }
+          }
+        } catch (e) {
+          mpInstance.Logger.error('Sideloaded Kits not configured propertly. Kits may not be initialized. ' + e);
+        }
+      }; // kits can be included via mParticle UI, or via sideloaded kit config API
+
+
+      this.configureSideloadedKit = function (kitConstructor) {
+        mpInstance._Store.configuredForwarders.push(this.returnConfiguredKit(kitConstructor));
+      };
+
+      this.returnConfiguredKit = function (forwarder) {
+        var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+        var newForwarder = new forwarder.constructor();
+        newForwarder.id = config.moduleId; // TODO: isSandbox, hasSandbox is never used in any kit or in core SDK.
+        // isVisibleInvestigate is only used in 1 place. It is always true if
+        // it is sent to JS. Investigate further to determine if these can be removed.
+        // https://go.mparticle.com/work/SQDSDKS-5156
+
+        newForwarder.isSandbox = config.isDebug || config.isSandbox;
+        newForwarder.hasSandbox = config.hasDebugString === 'true';
+        newForwarder.isVisible = config.isVisible || true;
+        newForwarder.settings = config.settings || {};
+        newForwarder.eventNameFilters = config.eventNameFilters || [];
+        newForwarder.eventTypeFilters = config.eventTypeFilters || [];
+        newForwarder.attributeFilters = config.attributeFilters || [];
+        newForwarder.screenNameFilters = config.screenNameFilters || [];
+        newForwarder.screenAttributeFilters = config.screenAttributeFilters || [];
+        newForwarder.userIdentityFilters = config.userIdentityFilters || [];
+        newForwarder.userAttributeFilters = config.userAttributeFilters || [];
+        newForwarder.filteringEventAttributeValue = config.filteringEventAttributeValue || {};
+        newForwarder.filteringUserAttributeValue = config.filteringUserAttributeValue || {};
+        newForwarder.eventSubscriptionId = config.eventSubscriptionId || null;
+        newForwarder.filteringConsentRuleValues = config.filteringConsentRuleValues || {};
+        newForwarder.excludeAnonymousUser = config.excludeAnonymousUser || false;
+        return newForwarder;
       };
 
       this.configurePixel = function (settings) {
@@ -6536,27 +6669,15 @@ var mParticle = (function () {
         }
       };
 
-      this.processForwarders = function (config, forwardingStatsCallback) {
-        if (!config) {
-          mpInstance.Logger.warning('No config was passed. Cannot process forwarders');
-        } else {
-          try {
-            if (Array.isArray(config.kitConfigs) && config.kitConfigs.length) {
-              config.kitConfigs.forEach(function (kitConfig) {
-                self.configureForwarder(kitConfig);
-              });
-            }
-
-            if (Array.isArray(config.pixelConfigs) && config.pixelConfigs.length) {
-              config.pixelConfigs.forEach(function (pixelConfig) {
-                self.configurePixel(pixelConfig);
-              });
-            }
-
-            self.initForwarders(mpInstance._Store.SDKConfig.identifyRequest.userIdentities, forwardingStatsCallback);
-          } catch (e) {
-            mpInstance.Logger.error('Config was not parsed propertly. Forwarders may not be initialized.');
+      this.processPixelConfigs = function (config) {
+        try {
+          if (!isEmpty(config.pixelConfigs)) {
+            config.pixelConfigs.forEach(function (pixelConfig) {
+              self.configurePixel(pixelConfig);
+            });
           }
+        } catch (e) {
+          mpInstance.Logger.error('Cookie Sync configs not configured propertly. Cookie Sync may not be initialized. ' + e);
         }
       };
     }
@@ -7608,7 +7729,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);
               }
             }
           },
@@ -7677,7 +7798,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);
             }
           },
 
@@ -7755,7 +7876,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);
             }
           },
 
@@ -7778,7 +7899,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);
@@ -10505,6 +10626,8 @@ var mParticle = (function () {
 
         mpInstance._Forwarders.processForwarders(config, mpInstance._APIClient.prepareForwardingStats);
 
+        mpInstance._Forwarders.processPixelConfigs(config);
+
         mpInstance._SessionManager.initialize();
 
         mpInstance._Events.logAST(); // Call mParticle._Store.SDKConfig.identityCallback when identify was not called due to a reload or a sessionId already existing
@@ -10707,6 +10830,7 @@ var mParticle = (function () {
           _SessionManager: null,
           _Store: {
             sessionId: 'mockSessionId',
+            sideloadedKits: [],
             devToken: 'test_dev_token',
             isFirstRun: true,
             isEnabled: true,