@mparticle/web-sdk 2.59.0 → 2.60.0

package/src/mp-instance.ts

@@ -1213,7 +1213,7 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
      * @method setOptOut
      * @param {Boolean} isOptingOut boolean to opt out or not. When set to true, opt out of logging.
      */
-    this.setOptOut = function(isOptingOut) {
+    this.setOptOut = function(isOptingOut: boolean) {
         const queued = queueIfNotInitialized(function() {
             self.setOptOut(isOptingOut);
         }, self);
@@ -1619,14 +1619,10 @@ function createIdentityCache(mpInstance) {
     // Identity expects mpInstance._Identity.idCache to always exist. DisabledVault
     // ensures no identity response data is written to localStorage when noFunctional is true
     if (mpInstance._CookieConsentManager?.getNoFunctional()) {
-        return new DisabledVault(`${mpInstance._Store.storageName}-id-cache`, {
-            logger: mpInstance.Logger,
-        });
+        return new DisabledVault(`${mpInstance._Store.storageName}-id-cache`);
     }
     
-    return new LocalStorageVault(`${mpInstance._Store.storageName}-id-cache`, {
-        logger: mpInstance.Logger,
-    });
+    return new LocalStorageVault(`${mpInstance._Store.storageName}-id-cache`);
 }
 
 function runPreConfigFetchInitialization(mpInstance, apiKey, config) {

package/src/roktManager.ts

@@ -9,6 +9,7 @@ import {
     isFunction,
     AttributeValue,
     isEmpty,
+    obfuscateDevData,
 } from "./utils";
 import { SDKIdentityApi } from "./identity.interfaces";
 import { SDKLoggerApi } from "./sdkRuntimeModels";
@@ -234,7 +235,10 @@ export default class RoktManager {
             const { attributes } = options;
             const sandboxValue = attributes?.sandbox || null;
             const mappedAttributes = this.mapPlacementAttributes(attributes, this.placementAttributesMapping);
-            this.logger?.verbose(`mParticle.Rokt selectPlacements called with attributes:\n${JSON.stringify(attributes, null, 2)}`);
+            if (this.logger?.isVerbose()) {
+                const attributesToLog = obfuscateDevData(attributes, this.store?.SDKConfig?.isDevelopmentMode);
+                this.logger.verbose(`mParticle.Rokt selectPlacements called with attributes:\n${JSON.stringify(attributesToLog, null, 2)}`);
+            }
 
             this.currentUser = this.identityService.getCurrentUser();
             const currentUserIdentities = this.currentUser?.getUserIdentities()?.userIdentities || {};
@@ -273,7 +277,7 @@ export default class RoktManager {
                 newIdentities[this.mappedEmailShaIdentityType] = newHashedEmail;
                 this.logger.warning(`emailsha256 mismatch detected. Current mParticle hashedEmail differs from hashedEmail passed to selectPlacements call. Proceeding to call identify with hashedEmail from selectPlacements call. Please verify your implementation.`);
             }
-
+            
             if (!isEmpty(newIdentities)) {
                 // Call identify with the new user identities
                 try {
@@ -288,7 +292,8 @@ export default class RoktManager {
                         });
                     });
                 } catch (error) {
-                    this.logger.error('Failed to identify user with new email: ' + JSON.stringify(error));
+                    const errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+                    this.logger.error('Failed to identify user with updated identities: ' + errorMessage);
                 }
             }
             
@@ -504,7 +509,10 @@ export default class RoktManager {
                 return;
             }
 
-            this.logger?.verbose(`RoktManager: Processing queued message: ${message.methodName} with payload: ${JSON.stringify(message.payload)}`);
+            if (this.logger?.isVerbose()) {
+                const payloadToLog = obfuscateDevData(message.payload, this.store?.SDKConfig?.isDevelopmentMode);
+                this.logger.verbose(`RoktManager: Processing queued message: ${message.methodName} with payload: ${JSON.stringify(payloadToLog)}`);
+            }
 
             // Capture resolve/reject functions before async processing
             const resolve = message.resolve;

package/src/sdkRuntimeModels.ts

@@ -394,6 +394,7 @@ export interface SDKLoggerApi {
     error(msg: string, code?: ErrorCodes): void;
     verbose(msg: string): void;
     warning(msg: string): void;
+    isVerbose(): boolean;
     setLogLevel(logLevel: LogLevelType): void;
 }
 

package/src/utils.ts

@@ -426,12 +426,71 @@ const filterDictionaryWithHash = <T>(
 }
 
 const parseConfig = (config: SDKInitConfig, moduleName: string, moduleId: number): IKitConfigs | null => {
-    return config.kitConfigs?.find((kitConfig: IKitConfigs) => 
-        kitConfig.name === moduleName && 
+    return config.kitConfigs?.find((kitConfig: IKitConfigs) =>
+        kitConfig.name === moduleName &&
         kitConfig.moduleId === moduleId
     ) || null;
 }
 
+/**
+ * Obfuscates an object by replacing all primitive values with their type names,
+ * while preserving the structure of nested objects and arrays.
+ * This is useful for logging data structures without exposing PII.
+ *
+ * @param value - The value to obfuscate
+ * @returns The obfuscated value with types instead of actual values
+ *
+ * @example
+ * obfuscateData({ email: 'user@email.com', age: 30 })
+ * // Returns: { email: 'string', age: 'number' }
+ *
+ * obfuscateData({ tags: ['premium', 'verified'] })
+ * // Returns: { tags: ['string', 'string'] }
+ */
+const obfuscateData = (value: any): any => {
+    // Preserve null and undefined
+    if (value === null || value === undefined) {
+        return value;
+    }
+
+    // Handle arrays - recursively obfuscate each element
+    if (Array.isArray(value)) {
+        return value.map(item => obfuscateData(item));
+    }
+
+    // Handle objects - recursively obfuscate each property
+    if (isObject(value)) {
+        const obfuscated: Dictionary<any> = {};
+        for (const key in value) {
+            if (value.hasOwnProperty(key)) {
+                obfuscated[key] = obfuscateData(value[key]);
+            }
+        }
+        return obfuscated;
+    }
+
+    // For primitives and other types, return the type as a string
+    return typeof value;
+};
+
+/**
+ * For verbose logging: returns raw data when isDevelopmentMode is true, else obfuscated data.
+ * Used when logging payloads so PII is not exposed in production.
+ *
+ * @param data - The value to log
+ * @param isDevelopmentMode - When true, returns data unchanged, when false or undefined, returns obfuscated data
+ * @returns Raw data when isDevelopmentMode is true, otherwise obfuscated structure
+ *
+ * @example
+ * obfuscateDevData({ email: 'user@email.com' }, true)
+ * // Returns: { email: 'user@email.com' }
+ *
+ * obfuscateDevData({ email: 'user@email.com' }, false)
+ * // Returns: { email: 'string' }
+ */
+const obfuscateDevData = (data: any, isDevelopmentMode?: boolean): any =>
+    isDevelopmentMode ? data : obfuscateData(data);
+
 export {
     createCookieString,
     revertCookieString,
@@ -440,6 +499,7 @@ export {
     AttributeValue,
     converted,
     decoded,
+    obfuscateDevData,
     filterDictionaryWithHash,
     findKeyInObject,
     generateDeprecationMessage,
@@ -449,6 +509,7 @@ export {
     inArray,
     isObject,
     isStringOrNumber,
+    obfuscateData,
     parseConfig,
     parseNumber,
     parseSettingsString,

package/src/vault.ts

@@ -1,38 +1,22 @@
-import { Logger } from '@mparticle/web-sdk';
 import { isEmpty, isNumber } from './utils';
 
-export interface IVaultOptions {
-    logger?: Logger;
-    offlineStorageEnabled?: boolean;
-}
-
 export abstract class BaseVault<StorableItem> {
     public contents: StorableItem;
     protected readonly _storageKey: string;
-    protected logger?: Logger;
     protected storageObject: Storage;
 
     /**
      *
      * @param {string} storageKey the local storage key string
-     * @param {Storage} Web API Storage object that is being used
-     * @param {IVaultOptions} options A Dictionary of IVaultOptions
+     * @param {Storage} storageObject Web API Storage object that is being used
      */
     constructor(
         storageKey: string,
-        storageObject: Storage,
-        options?: IVaultOptions
+        storageObject: Storage
     ) {
         this._storageKey = storageKey;
         this.storageObject = storageObject;
 
-        // Add a fake logger in case one is not provided or needed
-        this.logger = options?.logger || {
-            verbose: () => {},
-            warning: () => {},
-            error: () => {},
-        };
-
         this.contents = this.retrieve();
     }
 
@@ -51,16 +35,7 @@ export abstract class BaseVault<StorableItem> {
             stringifiedItem = '';
         }
 
-        try {
-            this.storageObject.setItem(this._storageKey, stringifiedItem);
-
-            this.logger.verbose(`Saving item to Storage: ${stringifiedItem}`);
-        } catch (error) {
-            this.logger.error(
-                `Cannot Save items to Storage: ${stringifiedItem}`
-            );
-            this.logger.error(error as string);
-        }
+        this.storageObject.setItem(this._storageKey, stringifiedItem);
     }
 
     /**
@@ -75,8 +50,6 @@ export abstract class BaseVault<StorableItem> {
 
         this.contents = item ? JSON.parse(item) : null;
 
-        this.logger.verbose(`Retrieving item from Storage: ${item}`);
-
         return this.contents;
     }
 
@@ -86,28 +59,27 @@ export abstract class BaseVault<StorableItem> {
      * @method purge
      */
     public purge(): void {
-        this.logger.verbose('Purging Storage');
         this.contents = null;
         this.storageObject.removeItem(this._storageKey);
     }
 }
 
 export class LocalStorageVault<StorableItem> extends BaseVault<StorableItem> {
-    constructor(storageKey: string, options?: IVaultOptions) {
-        super(storageKey, window.localStorage, options);
+    constructor(storageKey: string) {
+        super(storageKey, window.localStorage);
     }
 }
 
 export class SessionStorageVault<StorableItem> extends BaseVault<StorableItem> {
-    constructor(storageKey: string, options?: IVaultOptions) {
-        super(storageKey, window.sessionStorage, options);
+    constructor(storageKey: string) {
+        super(storageKey, window.sessionStorage);
     }
 }
 
 // DisabledVault is used when persistence is disabled by privacy flags.
 export class DisabledVault<StorableItem> extends BaseVault<StorableItem> {
-    constructor(storageKey: string, options?: IVaultOptions) {
-        super(storageKey, window.localStorage, options);
+    constructor(storageKey: string) {
+        super(storageKey, window.localStorage);
         this.contents = null;
         this.storageObject.removeItem(this._storageKey);
     }