feat: Create Logging Service

gtamanaha · alexs-mparticle · commit 307f7523208c · 2025-12-16T15:00:55.000-05:00
diff --git a/src/apiClient.ts b/src/apiClient.ts
@@ -10,6 +10,7 @@ import { IMParticleUser, ISDKUserAttributes } from './identity-user-interfaces';
 import { AsyncUploader, FetchUploader, XHRUploader } from './uploaders';
 import { IMParticleWebSDKInstance } from './mp-instance';
 import { appendUserInfo } from './user-utils';
+import { LogRequest } from './logging/logRequest';
 
 export interface IAPIClient {
     uploader: BatchUploader | null;
@@ -27,6 +28,7 @@ export interface IAPIClient {
         forwarder: MPForwarder,
         event: IUploadObject
     ) => void;
+    sendLogToServer: (log: LogRequest) => void;
 }
 
 export interface IForwardingStatsData {
@@ -231,4 +233,26 @@ export default function APIClient(
             }
         }
     };
+
+    this.sendLogToServer = function(logRequest: LogRequest) {
+        const baseUrl = mpInstance._Helpers.createServiceUrl(
+            mpInstance._Store.SDKConfig.v2SecureServiceUrl,
+            mpInstance._Store.devToken
+        );
+        const uploadUrl = `apps.stage.rokt.com/v1/log/v1/log`;
+        // const uploadUrl = `${baseUrl}/v1/log`;
+
+        const uploader = window.fetch
+            ? new FetchUploader(uploadUrl)
+            : new XHRUploader(uploadUrl);
+
+        uploader.upload({
+            method: 'POST',
+            headers: {
+                Accept: 'text/plain;charset=UTF-8',
+                'Content-Type': 'text/plain;charset=UTF-8',
+            },
+            body: JSON.stringify(logRequest),
+        });
+    };
 }
diff --git a/src/logging/errorCodes.ts b/src/logging/errorCodes.ts
@@ -0,0 +1,5 @@
+export type ErrorCodes = (typeof ErrorCodes)[keyof typeof ErrorCodes];
+
+export const ErrorCodes = {
+    UNHANDLED_EXCEPTION: 'UNHANDLED_EXCEPTION',
+} as const;
diff --git a/src/logging/logMessage.ts b/src/logging/logMessage.ts
diff --git a/src/logging/logRequest.ts b/src/logging/logRequest.ts
@@ -0,0 +1,21 @@
+import { ErrorCodes } from "./errorCodes";
+
+export enum LogRequestSeverity {
+    Error = 'error',
+    Warning = 'warning',
+    Info = 'info',
+}
+
+export interface LogRequest {
+    additionalInformation: {
+        message: string;
+        version: string;
+    };
+    severity: LogRequestSeverity;
+    code: ErrorCodes;
+    url: string;
+    deviceInfo: string;
+    stackTrace: string;
+    reporter: string;
+    integration: string;
+}
diff --git a/src/logging/reportingLogger.ts b/src/logging/reportingLogger.ts
@@ -0,0 +1,128 @@
+import { LogLevelType, SDKLoggerApi } from "../sdkRuntimeModels";
+import { IAPIClient } from "../apiClient";
+import { ErrorCodes } from "./errorCodes";
+import { LogRequest, LogRequestSeverity } from "./logRequest";
+
+export interface IReportingLogger {
+    error(msg: string, code?: ErrorCodes, stackTrace?: string): void;
+    warning(msg: string, code?: ErrorCodes): void;
+}
+
+export class ReportingLogger implements IReportingLogger {
+    private readonly isEnabled: boolean;
+    private readonly apiClient: IAPIClient;
+    private readonly reporter: string = 'mp-wsdk';
+    private readonly integration: string = 'mp-wsdk';
+    private readonly rateLimiter: RateLimiter = new RateLimiter();
+
+    constructor(
+        apiClient: IAPIClient,
+        private readonly sdkVersion: string,
+    ) {
+        this.isEnabled = this.isReportingEnabled();
+        this.apiClient = apiClient;
+        this.rateLimiter = new RateLimiter();
+    }
+
+    public error(msg: string, code?: ErrorCodes, stackTrace?: string) {
+        this.sendLog(LogRequestSeverity.Error, msg, code ?? ErrorCodes.UNHANDLED_EXCEPTION, stackTrace);
+    };
+
+    public warning(msg: string, code?: ErrorCodes) { 
+        this.sendLog(LogRequestSeverity.Warning, msg, code ?? ErrorCodes.UNHANDLED_EXCEPTION);
+    };
+    
+    private sendLog(
+        severity: LogRequestSeverity,
+        msg: string,
+        code: ErrorCodes,
+        stackTrace?: string
+    ): void {
+        if(!this.canSendLog(severity))
+            return;
+
+        const logRequest: LogRequest = {
+            additionalInformation: {
+                message: msg,
+                version: this.sdkVersion,
+            },
+            severity: severity,
+            code: code,
+            url: this.getUrl(),
+            deviceInfo: this.getUserAgent(),
+            stackTrace: stackTrace ?? '',
+            reporter: this.reporter,
+            integration: this.integration,
+        };
+        
+        this.apiClient.sendLogToServer(logRequest);
+    }
+
+    private isReportingEnabled() {
+        return (
+            this.isRoktDomainPresent() && 
+            (this.isFeatureFlagEnabled() ||
+            this.isDebugModeEnabled())
+        );
+    }
+
+    private isRoktDomainPresent() {
+        return window['ROKT_DOMAIN'];
+    }
+
+    private isFeatureFlagEnabled() {
+        return window.
+                mParticle?.
+                config?.
+                isWebSdkLoggingEnabled ?? false;
+    }
+
+    private isDebugModeEnabled() {
+        return (
+            window.
+                location?.
+                search?.
+                toLowerCase()?.
+                includes('mp_enable_logging=true') ?? false
+        );
+    }
+    
+    private canSendLog(severity: LogRequestSeverity): boolean {
+        return this.isEnabled && !this.isRateLimited(severity);
+    }
+
+    private isRateLimited(severity: LogRequestSeverity): boolean {
+        return this.rateLimiter.incrementAndCheck(severity);
+    }
+
+    private getUrl(): string {
+        return window.location.href;
+    }
+
+    private getUserAgent(): string {
+        return window.navigator.userAgent;
+    }
+}
+
+export interface IRateLimiter {
+    incrementAndCheck(severity: LogRequestSeverity): boolean;
+}
+
+export class RateLimiter implements IRateLimiter {
+    private readonly rateLimits: Map<LogRequestSeverity, number> = new Map([
+        [LogRequestSeverity.Error, 10],
+        [LogRequestSeverity.Warning, 10],
+        [LogRequestSeverity.Info, 10],
+    ]);
+    private logCount: Map<LogRequestSeverity, number> = new Map();
+
+    public incrementAndCheck(severity: LogRequestSeverity): 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;
+    }
+}
diff --git a/src/mp-instance.ts b/src/mp-instance.ts
@@ -162,7 +162,10 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
             );
         }
 
-        runPreConfigFetchInitialization(this, apiKey, config);
+        const kitBlocker = createKitBlocker(config, this);
+        runPreConfigFetchInitialization(this, apiKey, config, kitBlocker);
+        debugger;
+        this.Logger.error('gt error test');
 
         // config code - Fetch config when requestConfig = true, otherwise, proceed with SDKInitialization
         // Since fetching the configuration is asynchronous, we must pass completeSDKInitialization
@@ -185,10 +188,10 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
                         result
                     );
 
-                    completeSDKInitialization(apiKey, mergedConfig, this);
+                    completeSDKInitialization(apiKey, mergedConfig, this, kitBlocker);
                 });
             } else {
-                completeSDKInitialization(apiKey, config, this);
+                completeSDKInitialization(apiKey, config, this, kitBlocker);
             }
         } else {
             console.error(
@@ -1361,11 +1364,9 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
 }
 
 // Some (server) config settings need to be returned before they are set on SDKConfig in a self hosted environment
-function completeSDKInitialization(apiKey, config, mpInstance) {
-    const kitBlocker = createKitBlocker(config, mpInstance);
+function completeSDKInitialization(apiKey, config, mpInstance, kitBlocker: KitBlocker) {
     const { getFeatureFlag } = mpInstance._Helpers;
 
-    mpInstance._APIClient = new APIClient(mpInstance, kitBlocker);
     mpInstance._Forwarders = new Forwarders(mpInstance, kitBlocker);
     mpInstance._Store.processConfig(config);
 
@@ -1549,8 +1550,9 @@ function createIdentityCache(mpInstance) {
     });
 }
 
-function runPreConfigFetchInitialization(mpInstance, apiKey, config) {
-    mpInstance.Logger = new Logger(config);
+function runPreConfigFetchInitialization(mpInstance, apiKey, config, kitBlocker: KitBlocker) {
+    mpInstance._APIClient = new APIClient(mpInstance, kitBlocker);
+    mpInstance.Logger = new Logger(config, mpInstance._APIClient);
     mpInstance._Store = new Store(config, mpInstance, apiKey);
     window.mParticle.Store = mpInstance._Store;
     mpInstance.Logger.verbose(StartingInitialization);
diff --git a/src/sdkRuntimeModels.ts b/src/sdkRuntimeModels.ts
@@ -311,6 +311,7 @@ export interface SDKInitConfig
     identityCallback?: IdentityCallback;
 
     launcherOptions?: IRoktLauncherOptions;
+    isWebSdkLoggingEnabled?: boolean;
 
     rq?: Function[] | any[];
     logger?: IConsoleLogger;
diff --git a/test/jest/reportingLogger.spec.ts b/test/jest/reportingLogger.spec.ts
@@ -0,0 +1,116 @@
+import { RateLimiter, ReportingLogger } from '../../src/logging/reportingLogger';
+import { LogRequestSeverity } from '../../src/logging/logRequest';
+import { ErrorCodes } from '../../src/logging/errorCodes';
+
+describe('ReportingLogger', () => {
+    let apiClient: any;
+    let logger: ReportingLogger;
+    const sdkVersion = '1.2.3';
+
+    beforeEach(() => {
+        apiClient = { sendLogToServer: jest.fn() };
+        
+        // Mock location object to allow modifying search property
+        delete (window as any).location;
+        (window as any).location = {
+            href: 'https://e.com',
+            search: ''
+        };
+        
+        Object.assign(window, {
+            navigator: { userAgent: 'ua' },
+            mParticle: { config: { isWebSdkLoggingEnabled: true } },
+            ROKT_DOMAIN: 'set'
+        });
+        logger = new ReportingLogger(apiClient, sdkVersion);
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+        delete (window as any).ROKT_DOMAIN;
+        delete (window as any).mParticle;
+    });
+
+    it('sends error logs with correct params', () => {
+        logger.error('msg', ErrorCodes.UNHANDLED_EXCEPTION, 'stack');
+        expect(apiClient.sendLogToServer).toHaveBeenCalledWith(expect.objectContaining({
+            severity: LogRequestSeverity.Error,
+            code: ErrorCodes.UNHANDLED_EXCEPTION,
+            stackTrace: 'stack'
+        }));
+    });
+
+    it('sends warning logs with correct params', () => {
+        logger.warning('warn');
+        expect(apiClient.sendLogToServer).toHaveBeenCalledWith(expect.objectContaining({
+            severity: LogRequestSeverity.Warning
+        }));
+    });
+
+    it('does not log if ROKT_DOMAIN missing', () => {
+        delete (window as any).ROKT_DOMAIN;
+        logger = new ReportingLogger(apiClient, sdkVersion);
+        logger.error('x');
+        expect(apiClient.sendLogToServer).not.toHaveBeenCalled();
+    });
+
+    it('does not log if feature flag and debug mode off', () => {
+        window.mParticle.config.isWebSdkLoggingEnabled = false;
+        window.location.search = '';
+        logger = new ReportingLogger(apiClient, sdkVersion);
+        logger.error('x');
+        expect(apiClient.sendLogToServer).not.toHaveBeenCalled();
+    });
+
+    it('logs if debug mode on even if feature flag off', () => {
+        window.mParticle.config.isWebSdkLoggingEnabled = false;
+        window.location.search = '?mp_enable_logging=true';
+        logger = new ReportingLogger(apiClient, sdkVersion);
+        logger.error('x');
+        expect(apiClient.sendLogToServer).toHaveBeenCalled();
+    });
+
+    it('rate limits after 10 errors', () => {
+        for (let i = 0; i < 12; i++) logger.error('err');
+        expect(apiClient.sendLogToServer).toHaveBeenCalledTimes(10);
+    });
+});
+
+describe('RateLimiter', () => {
+    let rateLimiter: RateLimiter;
+    beforeEach(() => {
+        rateLimiter = new RateLimiter();
+    });
+
+    it('allows up to 10 error logs then rate limits', () => {
+        for (let i = 0; i < 10; i++) {
+            expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Error)).toBe(false);
+        }
+        expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Error)).toBe(true);
+        expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Error)).toBe(true);
+    });
+
+    it('allows up to 10 warning logs then rate limits', () => {
+        for (let i = 0; i < 10; i++) {
+            expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Warning)).toBe(false);
+        }
+        expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Warning)).toBe(true);
+        expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Warning)).toBe(true);
+    });
+
+    it('allows up to 10 info logs then rate limits', () => {
+        for (let i = 0; i < 10; i++) {
+            expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Info)).toBe(false);
+        }
+        expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Info)).toBe(true);
+        expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Info)).toBe(true);
+    });
+
+    it('tracks rate limits independently per severity', () => {
+        for (let i = 0; i < 10; i++) {
+            rateLimiter.incrementAndCheck(LogRequestSeverity.Error);
+        }
+        expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Error)).toBe(true);
+        expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Warning)).toBe(false);
+    });
+});
