@mparticle/web-sdk 2.19.2 → 2.19.3

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

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

package/src/identity.js

@@ -904,7 +904,8 @@ export default function Identity(mpInstance) {
                             self.IdentityAPI.getCurrentUser().getUserIdentities(),
                             mpInstance._APIClient.prepareForwardingStats
                         );
-                        mpInstance._Forwarders.callSetUserAttributeOnForwarders(
+                        mpInstance._Forwarders.handleForwarderUserAttributes(
+                            'setUserAttribute',
                             key,
                             newValue
                         );
@@ -990,9 +991,10 @@ export default function Identity(mpInstance) {
                         self.IdentityAPI.getCurrentUser().getUserIdentities(),
                         mpInstance._APIClient.prepareForwardingStats
                     );
-                    mpInstance._Forwarders.applyToForwarders(
+                    mpInstance._Forwarders.handleForwarderUserAttributes(
                         'removeUserAttribute',
-                        key
+                        key,
+                        null
                     );
                 }
             },
@@ -1098,7 +1100,8 @@ export default function Identity(mpInstance) {
                         self.IdentityAPI.getCurrentUser().getUserIdentities(),
                         mpInstance._APIClient.prepareForwardingStats
                     );
-                    mpInstance._Forwarders.callSetUserAttributeOnForwarders(
+                    mpInstance._Forwarders.handleForwarderUserAttributes(
+                        'setUserAttribute',
                         key,
                         arrayCopy
                     );
@@ -1127,9 +1130,10 @@ export default function Identity(mpInstance) {
                     if (userAttributes) {
                         for (var prop in userAttributes) {
                             if (userAttributes.hasOwnProperty(prop)) {
-                                mpInstance._Forwarders.applyToForwarders(
+                                mpInstance._Forwarders.handleForwarderUserAttributes(
                                     'removeUserAttribute',
-                                    prop
+                                    prop,
+                                    null
                                 );
                             }
                             this.removeUserAttribute(prop);

package/src/vault.ts

@@ -6,12 +6,10 @@ interface IVaultOptions {
     offlineStorageEnabled?: boolean;
 }
 
-export default class Vault<StorableItem extends Dictionary> {
-    public contents: Dictionary<StorableItem>;
+export default class Vault<StorableItem> {
+    public contents: StorableItem;
     private readonly _storageKey: string;
-    private readonly _itemKey: keyof StorableItem;
     private logger?: Logger;
-    private offlineStorageEnabled: boolean = false;
 
     /**
      *
@@ -19,16 +17,9 @@ export default class Vault<StorableItem extends Dictionary> {
      * @param {string} itemKey an element within your StorableItem to use as a key
      * @param {IVaultOptions} options A Dictionary of IVaultOptions
      */
-    constructor(
-        storageKey: string,
-        itemKey: keyof StorableItem,
-        options?: IVaultOptions
-    ) {
+    constructor(storageKey: string, options?: IVaultOptions) {
         this._storageKey = storageKey;
-        this._itemKey = itemKey;
-        this.contents = this.getItems() || {};
-
-        this.offlineStorageEnabled = options?.offlineStorageEnabled;
+        this.contents = this.getFromLocalStorage();
 
         // Add a fake logger in case one is not provided or needed
         this.logger = options?.logger || {
@@ -39,51 +30,16 @@ export default class Vault<StorableItem extends Dictionary> {
     }
 
     /**
-     * Stores a single Item using `itemId` as an index
+     * Stores a StorableItem to Local Storage
      * @method storeItem
-     * @param item {StorableItem} a Dictonary with key to store
-     */
-    public storeItem(item: StorableItem): void {
-        this.contents = this.getItems();
-
-        if (item[this._itemKey]) {
-            this.contents[item[this._itemKey]] = item;
-            this.logger.verbose(
-                `Saved items to vault with key: ${item[this._itemKey]}`
-            );
-        }
-
-        this.saveItems(this.contents);
-    }
-
-    /**
-     * Stores Items using `itemId` as an index
-     * @method storeItems
-     * @param {StorableItem[]} an Array of StorableItems
-     */
-    public storeItems(items: StorableItem[]): void {
-        items.forEach((item) => this.storeItem(item));
-    }
-
-    /**
-     * Removes a single StorableItem based on `indexId`
-     * @method removeItem
-     * @param {String} indexId
+     * @param item {StorableItem}
      */
-    public removeItem(indexId: string): void {
-        this.logger.verbose(`Removing from vault: ${indexId}`);
-        this.contents = this.getItems() || {};
+    public store(item: StorableItem): void {
+        this.contents = item;
 
-        try {
-            delete this.contents[indexId];
+        this.logger.verbose(`Saved to local storage: ${item}`);
 
-            this.saveItems(this.contents);
-        } catch (error) {
-            this.logger.error(
-                `Unable to remove item without a matching ID ${indexId}`
-            );
-            this.logger.error(error as string);
-        }
+        this.saveToLocalStorage(this.contents);
     }
 
     /**
@@ -91,10 +47,10 @@ export default class Vault<StorableItem extends Dictionary> {
      * @method retrieveItems
      * @returns {StorableItem[]} an array of Items
      */
-    public retrieveItems(): StorableItem[] {
-        this.contents = this.getItems();
+    public retrieve(): StorableItem {
+        this.contents = this.getFromLocalStorage();
 
-        return Object.keys(this.contents).map((item) => this.contents[item]);
+        return this.contents;
     }
 
     /**
@@ -102,14 +58,11 @@ export default class Vault<StorableItem extends Dictionary> {
      * @method purge
      */
     public purge(): void {
-        this.contents = {};
-        this.removeItems();
+        this.contents = null;
+        this.removeFromLocalStorage();
     }
 
-    private saveItems(items: Dictionary<StorableItem>): void {
-        if (!this.offlineStorageEnabled) {
-            return;
-        }
+    private saveToLocalStorage(items: StorableItem): void {
         try {
             window.localStorage.setItem(
                 this._storageKey,
@@ -121,21 +74,15 @@ export default class Vault<StorableItem extends Dictionary> {
         }
     }
 
-    private getItems(): Dictionary<StorableItem> {
-        if (!this.offlineStorageEnabled) {
-            return this.contents;
-        }
+    private getFromLocalStorage(): StorableItem | null {
         // TODO: Handle cases where Local Storage is unavailable
         // https://go.mparticle.com/work/SQDSDKS-5022
-        const itemString = window.localStorage.getItem(this._storageKey);
+        const item: string = window.localStorage.getItem(this._storageKey);
 
-        return itemString ? JSON.parse(itemString) : {};
+        return item ? JSON.parse(item) : null;
     }
 
-    private removeItems(): void {
-        if (!this.offlineStorageEnabled) {
-            return;
-        }
+    private removeFromLocalStorage(): void {
         window.localStorage.removeItem(this._storageKey);
     }
-}
+}