@mparticle/web-sdk 2.19.2 → 2.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.19.2",
+    "version": "2.20.0",
     "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

@@ -9,17 +9,35 @@ import { convertEvents } from './sdkToEventsApiConverter';
 import Types from './types';
 import { isEmpty } from './utils';
 
+/**
+ * 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.
+ */
+
 export class BatchUploader {
-    //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
     static readonly CONTENT_TYPE: string = 'text/plain;charset=UTF-8';
     static readonly MINIMUM_INTERVAL_MILLIS: number = 500;
     uploadIntervalMillis: number;
-    pendingEvents: SDKEvent[];
-    pendingUploads: Batch[];
+    eventsQueuedForProcessing: SDKEvent[];
+    batchesQueuedForProcessing: Batch[];
     mpInstance: MParticleWebSDK;
     uploadUrl: string;
     batchingEnabled: boolean;
+    private uploader: AsyncUploader;
 
+    /**
+     * Creates an instance of a BatchUploader
+     * @param {MParticleWebSDK} mpInstance - the mParticle SDK instance
+     * @param {number} uploadInterval - the desired upload interval in milliseconds
+     */
     constructor(mpInstance: MParticleWebSDK, uploadInterval: number) {
         this.mpInstance = mpInstance;
         this.uploadIntervalMillis = uploadInterval;
@@ -28,8 +46,8 @@ export class BatchUploader {
         if (this.uploadIntervalMillis < BatchUploader.MINIMUM_INTERVAL_MILLIS) {
             this.uploadIntervalMillis = BatchUploader.MINIMUM_INTERVAL_MILLIS;
         }
-        this.pendingEvents = [];
-        this.pendingUploads = [];
+        this.eventsQueuedForProcessing = [];
+        this.batchesQueuedForProcessing = [];
 
         const { SDKConfig, devToken } = this.mpInstance._Store;
         const baseUrl = this.mpInstance._Helpers.createServiceUrl(
@@ -38,15 +56,20 @@ export class BatchUploader {
         );
         this.uploadUrl = `${baseUrl}/events`;
 
-        setTimeout(() => {
-            this.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
     private addEventListeners() {
         const _this = this;
 
+        // visibility change is a document property, not window
         document.addEventListener('visibilitychange', () => {
             _this.prepareAndUpload(false, _this.isBeaconAvailable());
         });
@@ -65,16 +88,32 @@ export class BatchUploader {
         return false;
     }
 
+    // Triggers a setTimeout for prepareAndUpload
+    private triggerUploadInterval(
+        triggerFuture: boolean = false,
+        useBeacon: boolean = false
+    ): void {
+        setTimeout(() => {
+            this.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
+     */
     queueEvent(event: SDKEvent): void {
         if (!isEmpty(event)) {
-            this.pendingEvents.push(event);
+            this.eventsQueuedForProcessing.push(event);
             this.mpInstance.Logger.verbose(
                 `Queuing event: ${JSON.stringify(event)}`
             );
             this.mpInstance.Logger.verbose(
-                `Queued event count: ${this.pendingEvents.length}`
+                `Queued event count: ${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]
@@ -93,7 +132,7 @@ export class BatchUploader {
      * @param sdkEvents current pending events
      * @param defaultUser the user to reference for events that are missing data
      */
-    private static createNewUploads(
+    private static createNewBatches(
         sdkEvents: SDKEvent[],
         defaultUser: MParticleUser,
         mpInstance: MParticleWebSDK
@@ -141,9 +180,8 @@ export class BatchUploader {
                     mpInstance._Store.SDKConfig.onCreateBatch;
 
                 if (onCreateBatchCallback) {
-                    uploadBatchObject = onCreateBatchCallback(
-                        uploadBatchObject
-                    );
+                    uploadBatchObject =
+                        onCreateBatchCallback(uploadBatchObject);
                     if (uploadBatchObject) {
                         uploadBatchObject.modified = true;
                     } else {
@@ -169,47 +207,58 @@ export class BatchUploader {
      * @param triggerFuture whether to trigger the loop again - for manual/forced uploads this should be false
      * @param useBeacon whether to use the beacon API - used when the page is being unloaded
      */
-    private async prepareAndUpload(triggerFuture: boolean, useBeacon: boolean) {
+    private async prepareAndUpload(
+        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.pendingEvents;
-        this.pendingEvents = [];
-        const newUploads = BatchUploader.createNewUploads(
+        const currentEvents = this.eventsQueuedForProcessing;
+        this.eventsQueuedForProcessing = [];
+
+        const newBatches = BatchUploader.createNewBatches(
             currentEvents,
             currentUser,
             this.mpInstance
         );
-        if (newUploads && newUploads.length) {
-            this.pendingUploads.push(...newUploads);
+
+        if (!isEmpty(newBatches)) {
+            this.batchesQueuedForProcessing.push(...newBatches);
         }
 
-        const currentUploads = this.pendingUploads;
-        this.pendingUploads = [];
-        const remainingUploads: Batch[] = await this.upload(
+        // Clear out pending batches to avoid any potential duplication
+        const batchesToUpload = this.batchesQueuedForProcessing;
+        this.batchesQueuedForProcessing = [];
+
+        const batchesThatDidNotUpload = await this.uploadBatches(
             this.mpInstance.Logger,
-            currentUploads,
+            batchesToUpload,
             useBeacon
         );
-        if (remainingUploads && remainingUploads.length) {
-            this.pendingUploads.unshift(...remainingUploads);
+
+        // 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) {
-            setTimeout(() => {
-                this.prepareAndUpload(true, false);
-            }, this.uploadIntervalMillis);
+            this.triggerUploadInterval(triggerFuture, false);
         }
     }
 
-    private async upload(
+    // TODO: Refactor to use logger as a class method
+    // https://go.mparticle.com/work/SQDSDKS-5167
+    private async uploadBatches(
         logger: SDKLoggerApi,
-        _uploads: Batch[],
+        batches: Batch[],
         useBeacon: boolean
-    ): Promise<Batch[]> {
-        let uploader;
-
+    ): Promise<Batch[] | null> {
         // Filter out any batches that don't have events
-        const uploads = _uploads.filter(upload => !isEmpty(upload.events));
+        const uploads = batches.filter((batch) => !isEmpty(batch.events));
 
         if (isEmpty(uploads)) {
             return null;
@@ -235,19 +284,8 @@ export class BatchUploader {
                 });
                 navigator.sendBeacon(this.uploadUrl, blob);
             } else {
-                if (!uploader) {
-                    if (window.fetch) {
-                        uploader = new FetchUploader(this.uploadUrl, logger);
-                    } else {
-                        uploader = new XHRUploader(this.uploadUrl, logger);
-                    }
-                }
                 try {
-                    const response = await uploader.upload(
-                        fetchPayload,
-                        uploads,
-                        i
-                    );
+                    const response = await this.uploader.upload(fetchPayload);
 
                     if (response.status >= 200 && response.status < 300) {
                         logger.verbose(
@@ -260,7 +298,7 @@ export class BatchUploader {
                         logger.error(
                             `HTTP error status ${response.status} received`
                         );
-                        //server error, add back current events and try again later
+                        // Server error, add back current batches and try again later
                         return uploads.slice(i, uploads.length);
                     } else if (response.status >= 401) {
                         logger.error(
@@ -268,6 +306,16 @@ export class BatchUploader {
                         );
                         //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
+                        );
+
+                        throw new Error(
+                            `Uncaught HTTP Error ${response.status}.  Batch upload will be re-attempted.`
+                        );
                     }
                 } catch (e) {
                     logger.error(
@@ -283,34 +331,24 @@ export class BatchUploader {
 
 abstract class AsyncUploader {
     url: string;
-    logger: SDKLoggerApi;
+    public abstract upload(fetchPayload: fetchPayload): Promise<XHRResponse>;
 
-    constructor(url: string, logger: SDKLoggerApi) {
+    constructor(url: string) {
         this.url = url;
-        this.logger = logger;
     }
 }
 
 class FetchUploader extends AsyncUploader {
-    private async upload(
-        fetchPayload: fetchPayload,
-        uploads: Batch[],
-        i: number
-    ) {
+    public async upload(fetchPayload: fetchPayload): Promise<XHRResponse> {
         const response: XHRResponse = await fetch(this.url, fetchPayload);
         return response;
     }
 }
 
 class XHRUploader extends AsyncUploader {
-    private async upload(
-        fetchPayload: fetchPayload,
-        uploads: Batch[],
-        i: number
-    ) {
+    public async upload(fetchPayload: fetchPayload): Promise<XHRResponse> {
         const response: XHRResponse = await this.makeRequest(
             this.url,
-            this.logger,
             fetchPayload.body
         );
         return response;
@@ -318,7 +356,6 @@ class XHRUploader extends AsyncUploader {
 
     private async makeRequest(
         url: string,
-        logger: SDKLoggerApi,
         data: string
     ): Promise<XMLHttpRequest> {
         const xhr: XMLHttpRequest = new XMLHttpRequest();

package/src/forwarders.js

@@ -1,8 +1,15 @@
 import Types from './types';
 import filteredMparticleUser from './filteredMparticleUser';
+import { isEmpty } from './utils';
 
 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 (
@@ -53,7 +60,6 @@ export default function Forwarders(mpInstance, kitBlocker) {
                         user ? user.getAllUserAttributes() : {},
                         forwarder.userAttributeFilters
                     );
-
                     if (!forwarder.initialized) {
                         forwarder.logger = mpInstance.Logger;
                         forwarder.init(
@@ -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) {
@@ -504,19 +524,59 @@ export default function Forwarders(mpInstance, kitBlocker) {
         mpInstance._Persistence.forwardingStatsBatches.forwardingStatsEventQueue = queue;
     };
 
-    this.configureForwarder = function(configuration) {
+    // 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.configureUIEnabledKit = function(configuration) {
         var newForwarder = null,
             config = configuration,
             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 there are kits inside of mpInstance._Store.SDKConfig.kits, then mParticle is self hosted
+        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
             ) {
@@ -532,38 +592,10 @@ export default function Forwarders(mpInstance, kitBlocker) {
                     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);
                     break;
@@ -572,6 +604,84 @@ export default function Forwarders(mpInstance, kitBlocker) {
         }
     };
 
+    // 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)) {
+                const 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 (const registeredKitKey in sideloadedKits.kits) {
+                    const 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, config = {}) {
+        const 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) {
         if (
             settings.isDebug ===
@@ -583,39 +693,18 @@ export default function Forwarders(mpInstance, kitBlocker) {
         }
     };
 
-    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
+            );
         }
     };
 }

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)) {