@mparticle/web-sdk 2.60.0 → 2.61.0

package/src/mp-instance.ts

@@ -52,7 +52,9 @@ import ForegroundTimer from './foregroundTimeTracker';
 import RoktManager, { IRoktOptions } from './roktManager';
 import filteredMparticleUser from './filteredMparticleUser';
 import CookieConsentManager, { ICookieConsentManager } from './cookieConsentManager';
-import { ReportingLogger } from './logging/reportingLogger';
+import { ErrorReportingDispatcher } from './reporting/errorReportingDispatcher';
+import { LoggingDispatcher } from './reporting/loggingDispatcher';
+import { IErrorReportingService, ILoggingService } from './reporting/types';
 
 export interface IErrorLogMessage {
     message?: string;
@@ -85,7 +87,8 @@ export interface IMParticleWebSDKInstance extends MParticleWebSDK {
     _NativeSdkHelpers: INativeSdkHelpers;
     _Persistence: IPersistence;
     _CookieConsentManager: ICookieConsentManager;
-    _ReportingLogger: ReportingLogger;
+    _ErrorReportingDispatcher: ErrorReportingDispatcher;
+    _LoggingDispatcher: LoggingDispatcher;
     _RoktManager: RoktManager;
     _SessionManager: ISessionManager;
     _ServerModel: IServerModel;
@@ -138,6 +141,9 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
         forwarderConstructors: [],
     };
 
+    this._ErrorReportingDispatcher = new ErrorReportingDispatcher();
+    this._LoggingDispatcher = new LoggingDispatcher();
+
     this._RoktManager = new RoktManager();
     
     this._RoktManager.setOnReadyCallback(() => {
@@ -266,14 +272,16 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
         }
     };
 
-    this._resetForTests = function(config, keepPersistence, instance, reportingLogger?: ReportingLogger) {
+    this._resetForTests = function(config, keepPersistence, instance) {
         if (instance._Store) {
             delete instance._Store;
         }
-        instance.Logger = new Logger(config, reportingLogger);
+        instance._ErrorReportingDispatcher = new ErrorReportingDispatcher();
+        instance._LoggingDispatcher = new LoggingDispatcher();
+        instance.Logger = new Logger(config);
+        instance._ErrorReportingDispatcher.logger = instance.Logger;
+        instance._LoggingDispatcher.logger = instance.Logger;
         instance._Store = new Store(config, instance);
-        // Update ReportingLogger with the new Store reference to avoid stale data
-        reportingLogger?.setStore(instance._Store);
         instance._Store.isLocalStorageAvailable = instance._Persistence.determineLocalStorageAvailability(
             window.localStorage
         );
@@ -1406,6 +1414,14 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
         }
     };
 
+    this._registerErrorReportingService = function(service: IErrorReportingService) {
+        self._ErrorReportingDispatcher.register(service);
+    };
+
+    this._registerLoggingService = function(service: ILoggingService) {
+        self._LoggingDispatcher.register(service);
+    };
+
     const launcherInstanceGuidKey = Constants.Rokt.LauncherInstanceGuidKey;
     this.setLauncherInstanceGuid = function() {
         if (!window[launcherInstanceGuidKey] 
@@ -1504,7 +1520,9 @@ function completeSDKInitialization(apiKey, config, mpInstance) {
                 mpInstance._Store,
                 mpInstance.Logger,
                 roktOptions,
-                mpInstance.captureTiming
+                mpInstance.captureTiming,
+                mpInstance._ErrorReportingDispatcher,
+                mpInstance._LoggingDispatcher
             );
         }
 
@@ -1626,16 +1644,11 @@ function createIdentityCache(mpInstance) {
 }
 
 function runPreConfigFetchInitialization(mpInstance, apiKey, config) {
-    mpInstance._ReportingLogger = new ReportingLogger(
-        config,
-        Constants.sdkVersion,
-        undefined,
-        mpInstance.getLauncherInstanceGuid(),
-    );
-    mpInstance.Logger = new Logger(config, mpInstance._ReportingLogger);
+    mpInstance.Logger = new Logger(config);
+    mpInstance._ErrorReportingDispatcher.logger = mpInstance.Logger;
+    mpInstance._LoggingDispatcher.logger = mpInstance.Logger;
     mpInstance._Store = new Store(config, mpInstance, apiKey);
     window.mParticle.Store = mpInstance._Store;
-    mpInstance._ReportingLogger.setStore(mpInstance._Store);
     mpInstance.Logger.verbose(StartingInitialization);
 
     // Initialize CookieConsentManager with privacy flags from launcherOptions

package/src/mparticle-instance-manager.ts

@@ -398,7 +398,7 @@ function mParticleInstanceManager(this: IMParticleInstanceManager) {
 
     this.sessionManager = {
         getSession: function() {
-            return self.getInstance()._SessionManager.getSession();
+            return self.getInstance()._SessionManager.getSessionId();
         },
     };
 
@@ -487,6 +487,12 @@ function mParticleInstanceManager(this: IMParticleInstanceManager) {
     this._setWrapperSDKInfo = function(name, version) {
         self.getInstance()._setWrapperSDKInfo(name, version);
     };
+    this._registerErrorReportingService = function(service) {
+        self.getInstance()._registerErrorReportingService(service);
+    };
+    this._registerLoggingService = function(service) {
+        self.getInstance()._registerLoggingService(service);
+    };
 }
 
 const mParticleManager = new mParticleInstanceManager();

package/src/reporting/errorReportingDispatcher.ts

@@ -0,0 +1,21 @@
+import { SDKLoggerApi } from '../sdkRuntimeModels';
+import { IErrorReportingService, ISDKError } from './types';
+
+export class ErrorReportingDispatcher implements IErrorReportingService {
+    private readonly services: IErrorReportingService[] = [];
+    public logger?: SDKLoggerApi;
+
+    public register(service: IErrorReportingService): void {
+        this.services.push(service);
+    }
+
+    public report(error: ISDKError): void {
+        this.services.forEach(s => {
+            try {
+                s.report(error);
+            } catch (e) {
+                this.logger?.error('Error in ErrorReportingService: ' + e);
+            }
+        });
+    }
+}

package/src/reporting/loggingDispatcher.ts

@@ -0,0 +1,21 @@
+import { SDKLoggerApi } from '../sdkRuntimeModels';
+import { ILoggingService, ISDKLogEntry } from './types';
+
+export class LoggingDispatcher implements ILoggingService {
+    private readonly services: ILoggingService[] = [];
+    public logger?: SDKLoggerApi;
+
+    public register(service: ILoggingService): void {
+        this.services.push(service);
+    }
+
+    public log(entry: ISDKLogEntry): void {
+        this.services.forEach(s => {
+            try {
+                s.log(entry);
+            } catch (e) {
+                this.logger?.error('Error in LoggingService: ' + e);
+            }
+        });
+    }
+}

package/src/reporting/types.ts

@@ -0,0 +1,45 @@
+import { valueof } from '../utils';
+
+export const ErrorCodes = {
+    UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+    UNHANDLED_EXCEPTION: 'UNHANDLED_EXCEPTION',
+    IDENTITY_REQUEST: 'IDENTITY_REQUEST',
+    IDENTITY_MISMATCH: 'IDENTITY_MISMATCH',
+    ROKT_KIT_ATTACHED: 'ROKT_KIT_ATTACHED',
+} as const;
+
+export type ErrorCodes = valueof<typeof ErrorCodes>;
+
+export const WSDKErrorSeverity = {
+    ERROR: 'ERROR',
+    INFO: 'INFO',
+    WARNING: 'WARNING',
+} as const;
+
+export type WSDKErrorSeverity = (typeof WSDKErrorSeverity)[keyof typeof WSDKErrorSeverity];
+
+/** Structured error object for reporting. */
+export interface ISDKError {
+    message: string;
+    code?: ErrorCodes;
+    severity: WSDKErrorSeverity;
+    stackTrace?: string;
+    additionalInformation?: Record<string, string>;
+}
+
+/** Structured log entry for informational logging. */
+export interface ISDKLogEntry {
+    message: string;
+    code?: ErrorCodes;
+    additionalInformation?: Record<string, string>;
+}
+
+/** Contract for error/warning reporting services. */
+export interface IErrorReportingService {
+    report(error: ISDKError): void;
+}
+
+/** Contract for informational logging services. */
+export interface ILoggingService {
+    log(entry: ISDKLogEntry): void;
+}

package/src/roktManager.ts

@@ -16,6 +16,7 @@ import { SDKLoggerApi } from "./sdkRuntimeModels";
 import { IStore, LocalSessionAttributes } from "./store";
 import { UserIdentities } from "@mparticle/web-sdk";
 import { IdentityType, PerformanceMarkType } from "./types";
+import { ErrorCodes, IErrorReportingService, ILoggingService, WSDKErrorSeverity } from "./reporting/types";
 
 // https://docs.rokt.com/developers/integration-guides/web/library/attributes
 export type RoktAttributeValueArray = Array<string | number | boolean>;
@@ -108,6 +109,8 @@ export default class RoktManager {
     private store: IStore;
     private launcherOptions?: IRoktLauncherOptions;
     private logger: SDKLoggerApi;
+    private errorReporter: IErrorReportingService;
+    private loggingService: ILoggingService;
     private domain?: string;
     private mappedEmailShaIdentityType?: string | null;
     private captureTiming?: (metricsName: string) => void;
@@ -130,17 +133,21 @@ export default class RoktManager {
      * @param {SDKLoggerApi} logger - The mParticle Logger instance
      * @param {IRoktOptions} options - Options for the RoktManager
      * @param {Function} captureTiming - Function to capture performance timing marks
-     * 
+     * @param {IErrorReportingService} errorReporter - Dispatcher for error/warning reporting
+     * @param {ILoggingService} loggingService - Dispatcher for informational logging
+     *
      * @throws Logs error to console if placementAttributesMapping parsing fails
      */
     public init(
-        roktConfig: IKitConfigs, 
-        filteredUser: IMParticleUser, 
+        roktConfig: IKitConfigs,
+        filteredUser: IMParticleUser,
         identityService: SDKIdentityApi,
         store: IStore,
         logger?: SDKLoggerApi,
         options?: IRoktOptions,
-        captureTiming?: (metricsName: string) => void
+        captureTiming?: (metricsName: string) => void,
+        errorReporter?: IErrorReportingService,
+        loggingService?: ILoggingService
     ): void {
         const { userAttributeFilters, settings } = roktConfig || {};
         const { placementAttributesMapping, hashedEmailUserIdentityType } = settings || {};
@@ -149,6 +156,8 @@ export default class RoktManager {
         this.identityService = identityService;
         this.store = store;
         this.logger = logger;
+        this.errorReporter = errorReporter;
+        this.loggingService = loggingService;
         this.captureTiming = captureTiming;
 
         this.captureTiming?.(PerformanceMarkType.JointSdkRoktKitInit);
@@ -199,6 +208,11 @@ export default class RoktManager {
             this.store?.setIntegrationName(kit.integrationName);
         }
 
+        this.loggingService?.log({
+            message: 'RoktManager: Kit attached, Rokt is ready',
+            code: ErrorCodes.ROKT_KIT_ATTACHED,
+        });
+
         this.processMessageQueue();
 
         try {
@@ -269,13 +283,25 @@ export default class RoktManager {
             if (emailChanged) {
                 newIdentities.email = newEmail;
                 if (newEmail) {
-                    this.logger.warning(`Email mismatch detected. Current email differs from email passed to selectPlacements call. Proceeding to call identify with email from selectPlacements call. Please verify your implementation.`);
+                    const msg = 'Email mismatch detected. Current email differs from email passed to selectPlacements call. Proceeding to call identify with email from selectPlacements call. Please verify your implementation.';
+                    this.logger.warning(msg);
+                    this.errorReporter?.report({
+                        message: msg,
+                        code: ErrorCodes.IDENTITY_MISMATCH,
+                        severity: WSDKErrorSeverity.WARNING,
+                    });
                 }
             }
 
             if (hashedEmailChanged) {
                 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.`);
+                const msg = '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.';
+                this.logger.warning(msg);
+                this.errorReporter?.report({
+                    message: msg,
+                    code: ErrorCodes.IDENTITY_MISMATCH,
+                    severity: WSDKErrorSeverity.WARNING,
+                });
             }
             
             if (!isEmpty(newIdentities)) {

package/src/sdkRuntimeModels.ts

@@ -51,7 +51,7 @@ import {
 import Constants from './constants';
 import RoktManager, { IRoktLauncherOptions } from './roktManager';
 import { IConsoleLogger } from './logger';
-import { ErrorCodes } from './logging/types';
+import { ErrorCodes, IErrorReportingService, ILoggingService } from './reporting/types';
 
 // TODO: Resolve this with version in @mparticle/web-sdk
 export type SDKEventCustomFlags = Dictionary<any>;
@@ -260,6 +260,8 @@ export interface MParticleWebSDK {
     ): void;
     getIntegrationAttributes(integrationModuleId: number): IntegrationAttribute;
     captureTiming(metricName: string): void;
+    _registerErrorReportingService(service: IErrorReportingService): void;
+    _registerLoggingService(service: ILoggingService): void;
 }
 
 // https://go.mparticle.com/work/SQDSDKS-4805

package/src/serverModel.ts

@@ -302,7 +302,7 @@ export default function ServerModel(
                     //  events do not have names, but are denoted by their `event_type`
                     EventName:
                         event.name ||
-                        ((event.messageType as unknown) as string),
+                        String(event.messageType),
                     EventCategory: event.eventType,
                     EventAttributes: mpInstance._Helpers.sanitizeAttributes(
                         event.data,

package/src/store.ts

@@ -96,8 +96,6 @@ export interface SDKConfig {
     webviewBridgeName?: string;
     workspaceToken?: string;
     requiredWebviewBridgeName?: string;
-    loggingUrl?: string;
-    errorUrl?: string;
     isLoggingEnabled?: boolean;
 }
 
@@ -862,7 +860,7 @@ function processDirectBaseUrls(
     for (let baseUrlKey in defaultBaseUrls) {
         // Any custom endpoints passed to mpConfig will take priority over direct
         // mapping to the silo.  The most common use case is a customer provided CNAME.
-        if (baseUrlKey === 'configUrl' || baseUrlKey === 'loggingUrl' || baseUrlKey === 'errorUrl') {
+        if (baseUrlKey === 'configUrl') {
             directBaseUrls[baseUrlKey] =
                 config[baseUrlKey] || defaultBaseUrls[baseUrlKey];
             continue;

package/src/logging/reportingLogger.ts

@@ -1,192 +0,0 @@
-import { ErrorCodes, LogRequestBody, WSDKErrorSeverity } from "./types";
-import { FetchUploader, IFetchPayload } from "../uploaders";
-import { IStore, SDKConfig } from "../store";
-import { SDKInitConfig } from "../sdkRuntimeModels";
-import Constants from "../constants";
-
-// Header key constants
-const HEADER_ACCEPT = 'Accept' as const;
-const HEADER_CONTENT_TYPE = 'Content-Type' as const;
-const HEADER_ROKT_LAUNCHER_VERSION = 'rokt-launcher-version' as const;
-const HEADER_ROKT_LAUNCHER_INSTANCE_GUID = 'rokt-launcher-instance-guid' as const;
-const HEADER_ROKT_WSDK_VERSION = 'rokt-wsdk-version' as const;
-
-interface IReportingLoggerPayload extends IFetchPayload {
-    headers: IFetchPayload['headers'] & {
-        [HEADER_ROKT_LAUNCHER_INSTANCE_GUID]?: string;
-        [HEADER_ROKT_LAUNCHER_VERSION]: string;
-        [HEADER_ROKT_WSDK_VERSION]: string;
-    };
-    body: string;
-}
-
-export class ReportingLogger {
-    private readonly isEnabled: boolean;
-    private readonly reporter: string = 'mp-wsdk';
-    private readonly rateLimiter: IRateLimiter;
-    private store: IStore | null;
-    private readonly loggingUrl: string;
-    private readonly errorUrl: string;
-    private readonly isLoggingEnabled: boolean;
-
-    constructor(
-        config: SDKConfig | SDKInitConfig | any,
-        private readonly sdkVersion: string,
-        store?: IStore,
-        private readonly launcherInstanceGuid?: string,
-        rateLimiter?: IRateLimiter,
-    ) {
-        this.loggingUrl = `https://${config.loggingUrl || Constants.DefaultBaseUrls.loggingUrl}`;
-        this.errorUrl = `https://${config.errorUrl || Constants.DefaultBaseUrls.errorUrl}`;
-        this.isLoggingEnabled = config.isLoggingEnabled || false;
-        this.store = store ?? null;
-        this.isEnabled = this.isReportingEnabled();
-        this.rateLimiter = rateLimiter ?? new RateLimiter();
-    }
-
-    public setStore(store: IStore): void {
-        this.store = store;
-    }
-
-    public info(msg: string, code?: ErrorCodes) {
-        this.sendLog(WSDKErrorSeverity.INFO, msg, code);
-    }
-
-    public error(msg: string, code?: ErrorCodes, stackTrace?: string) {
-        this.sendError(WSDKErrorSeverity.ERROR, msg, code, stackTrace);
-    }
-
-    public warning(msg: string, code?: ErrorCodes) { 
-        this.sendError(WSDKErrorSeverity.WARNING, msg, code);
-    }
-    
-    private sendToServer(url: string, severity: WSDKErrorSeverity, msg: string, code?: ErrorCodes, stackTrace?: string): void {
-        if (!this.canSendLog(severity))
-            return;
-
-        try {
-            const logRequest = this.buildLogRequest(severity, msg, code, stackTrace);
-            const uploader = new FetchUploader(url);
-            const payload: IReportingLoggerPayload = {
-                method: 'POST',
-                headers: this.getHeaders(),
-                body: JSON.stringify(logRequest),
-            };
-            uploader.upload(payload).catch((error) => {
-                console.error('ReportingLogger: Failed to send log', error);
-            });
-        } catch (error) {
-            console.error('ReportingLogger: Failed to send log', error);
-        }
-    }
-
-    private sendLog(severity: WSDKErrorSeverity, msg: string, code?: ErrorCodes, stackTrace?: string): void {
-        this.sendToServer(this.loggingUrl, severity, msg, code, stackTrace);
-    }
-
-    private sendError(severity: WSDKErrorSeverity, msg: string, code?: ErrorCodes, stackTrace?: string): void {
-        this.sendToServer(this.errorUrl, severity, msg, code, stackTrace);
-    }
- 
-    private buildLogRequest(severity: WSDKErrorSeverity, msg: string, code?: ErrorCodes, stackTrace?: string): LogRequestBody {
-        return {
-            additionalInformation: {
-                message: msg,
-                version: this.getVersion(),
-            },
-            severity: severity,
-            code: code ?? ErrorCodes.UNKNOWN_ERROR,
-            url: this.getUrl(),
-            deviceInfo: this.getUserAgent(),
-            stackTrace: stackTrace,
-            reporter: this.reporter,
-            // Integration will be set to integrationName once the kit connects via RoktManager.attachKit()
-            integration: this.store?.getIntegrationName() ?? 'mp-wsdk'
-        };
-    }
-
-    private getVersion(): string {
-        return this.store?.getIntegrationName?.() ?? `mParticle_wsdkv_${this.sdkVersion}`;
-    }
-    
-    private isReportingEnabled(): boolean {
-        return this.isDebugModeEnabled() ||
-               (this.isRoktDomainPresent() && this.isFeatureFlagEnabled());
-    }
-
-    private isRoktDomainPresent(): boolean {
-        return typeof window !== 'undefined' && Boolean(window['ROKT_DOMAIN']);
-    }
-
-    private isFeatureFlagEnabled = (): boolean => this.isLoggingEnabled;
-
-    private isDebugModeEnabled(): boolean {
-        return (
-            typeof window !== 'undefined' &&
-            (window.
-                location?.
-                search?.
-                toLowerCase()?.
-                includes('mp_enable_logging=true') ?? false)
-        );
-    }
-
-    private canSendLog(severity: WSDKErrorSeverity): boolean {
-        return this.isEnabled && !this.isRateLimited(severity);
-    }
-
-    private isRateLimited(severity: WSDKErrorSeverity): boolean {
-        return this.rateLimiter.incrementAndCheck(severity);
-    }
-
-    private getUrl(): string | undefined {
-        return typeof window !== 'undefined' ? window.location?.href : undefined;
-    }
-
-    private getUserAgent(): string | undefined {
-        return typeof window !== 'undefined' ? window.navigator?.userAgent : undefined;
-    }
-
-    private getHeaders(): IReportingLoggerPayload['headers'] {
-        const headers: IReportingLoggerPayload['headers'] = {
-            [HEADER_ACCEPT]: 'text/plain;charset=UTF-8',
-            [HEADER_CONTENT_TYPE]: 'application/json',
-            [HEADER_ROKT_LAUNCHER_VERSION]: this.getVersion(),
-            [HEADER_ROKT_WSDK_VERSION]: 'joint',
-        };
-
-        if (this.launcherInstanceGuid) {
-            headers[HEADER_ROKT_LAUNCHER_INSTANCE_GUID] = this.launcherInstanceGuid;
-        }
-
-        const accountId = this.store?.getRoktAccountId?.();
-        if (accountId) {
-            headers['rokt-account-id'] = accountId;
-        }
-
-        return headers;
-    }
-}
-
-export interface IRateLimiter {
-    incrementAndCheck(severity: WSDKErrorSeverity): boolean;
-}
-
-export class RateLimiter implements IRateLimiter {
-    private readonly rateLimits: Map<WSDKErrorSeverity, number> = new Map([
-        [WSDKErrorSeverity.ERROR, 10],
-        [WSDKErrorSeverity.WARNING, 10],
-        [WSDKErrorSeverity.INFO, 10],
-    ]);
-    private logCount: Map<WSDKErrorSeverity, number> = new Map();
-
-    public incrementAndCheck(severity: WSDKErrorSeverity): boolean {
-        const count = this.logCount.get(severity) || 0;
-        const limit = this.rateLimits.get(severity) || 10;
-        
-        const newCount = count + 1;
-        this.logCount.set(severity, newCount);
-        
-        return newCount > limit;
-    }
-}

package/src/logging/types.ts

@@ -1,32 +0,0 @@
-import { valueof } from '../utils';
-
-export const ErrorCodes = {
-    UNKNOWN_ERROR: 'UNKNOWN_ERROR',
-    UNHANDLED_EXCEPTION: 'UNHANDLED_EXCEPTION',
-    IDENTITY_REQUEST: 'IDENTITY_REQUEST',
-} as const;
-
-export type ErrorCodes = valueof<typeof ErrorCodes>;
-
-export type ErrorCode = ErrorCodes | string;
-
-export const WSDKErrorSeverity = {
-    ERROR: 'ERROR',
-    INFO: 'INFO',
-    WARNING: 'WARNING',
-} as const;
-
-export type WSDKErrorSeverity = (typeof WSDKErrorSeverity)[keyof typeof WSDKErrorSeverity];
-
-export type ErrorsRequestBody = {
-    additionalInformation?: Record<string, string>;
-    code: ErrorCode;
-    severity: WSDKErrorSeverity;
-    stackTrace?: string;
-    deviceInfo?: string;
-    integration?: string;
-    reporter?: string;
-    url?: string;
-};
-
-export type LogRequestBody = ErrorsRequestBody;