feat: Create Logging Service

src/apiClient.ts

@@ -10,6 +10,7 @@
 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 @@
         forwarder: MPForwarder,
         event: IUploadObject
     ) => void;
+    sendLogToServer: (log: LogRequest) => void;
 }
 
 export interface IForwardingStatsData {
@@ -231,4 +233,25 @@
             }
         }
     };
+
+    this.sendLogToServer = function(logRequest: LogRequest) {
+        const baseUrl = mpInstance._Helpers.createServiceUrl(
+            mpInstance._Store.SDKConfig.v2SecureServiceUrl,
+            mpInstance._Store.devToken
+        );
+
+        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),
+        });
+    };
 }

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;

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;
+}

src/logging/reportingLogger.ts

@@ -0,0 +1,128 @@
+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: IRateLimiter;
+
+    constructor(
+        apiClient: IAPIClient,
+        private readonly sdkVersion: string,
+        rateLimiter?: IRateLimiter,
+    ) {
+        this.isEnabled = this.isReportingEnabled();
+        this.apiClient = apiClient;
+        this.rateLimiter = 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(): boolean {
+        return (
+            this.isRoktDomainPresent() && 
+            (this.isFeatureFlagEnabled() ||
+            this.isDebugModeEnabled())
+        );
+    }
+
+    private isRoktDomainPresent(): boolean {
+        return Boolean(window['ROKT_DOMAIN']);
+    }
+
+    private isFeatureFlagEnabled(): boolean {
+        return window.
+                mParticle?.
+                config?.
+                isWebSdkLoggingEnabled ?? false;
+    }
+
+    private isDebugModeEnabled(): boolean {
+        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;
+    }
+}

src/sdkRuntimeModels.ts

@@ -314,6 +314,7 @@ export interface SDKInitConfig
     identityCallback?: IdentityCallback;
 
     launcherOptions?: IRoktLauncherOptions;
+    isWebSdkLoggingEnabled?: boolean;
 
     rq?: Function[] | any[];
     logger?: IConsoleLogger;

test/jest/apiClient.spec.ts

@@ -0,0 +1,129 @@
+import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { LogRequest, LogRequestSeverity } from '../../src/logging/logRequest';
+import { ErrorCodes } from '../../src/logging/errorCodes';
+import APIClient from '../../src/apiClient';
+
+jest.mock('../../src/uploaders', () => {
+    const fetchUploadMock = jest.fn(() => Promise.resolve({} as Response));
+    const xhrUploadMock = jest.fn(() => Promise.resolve({} as Response));
+
+    class MockFetchUploader {
+        constructor(public url: string) {}
+        upload = fetchUploadMock;
+    }
+    class MockXHRUploader {
+        constructor(public url: string) {}
+        upload = xhrUploadMock;
+    }
+
+    (globalThis as any).__fetchUploadSpy = fetchUploadMock;
+    (globalThis as any).__xhrUploadSpy = xhrUploadMock;
+
+    return {
+        AsyncUploader: class {},
+        FetchUploader: MockFetchUploader,
+        XHRUploader: MockXHRUploader,
+    };
+});
+
+describe('apiClient.sendLogToServer', () => {
+    let mpInstance: any;
+    let logRequest: LogRequest;
+    let originalWindow: any;
+    let originalFetch: any;
+    let kitBlocker: any = { 
+        kitBlockingEnabled: false,
+        dataPlanMatchLookups: {},
+    };
+
+    beforeEach(() => {
+        jest.resetModules();
+
+        originalWindow = (global as any).window;
+        originalFetch = (global as any).window?.fetch;
+
+        mpInstance = {
+            _Helpers: {
+                createServiceUrl: jest.fn((url: string, token: string) => `https://api.fake.com/${token}`)
+            },
+            _Store: {
+                SDKConfig: { v2SecureServiceUrl: 'someUrl' },
+                devToken: 'testToken123'
+            }
+        };
+
+        logRequest = {
+            additionalInformation: {
+                message: 'test',
+                version: '1.0.0'
+            },
+            severity: LogRequestSeverity.Error,
+            code: ErrorCodes.UNHANDLED_EXCEPTION,
+            url: 'https://example.com',
+            deviceInfo: 'test',
+            stackTrace: 'test',
+            reporter: 'test',
+            integration: 'test'
+        };
+
+        // @ts-ignore
+        (global as any).window = {};
+
+        const fetchSpy = (globalThis as any).__fetchUploadSpy as jest.Mock;
+        const xhrSpy = (globalThis as any).__xhrUploadSpy as jest.Mock;
+        if (fetchSpy) fetchSpy.mockClear();
+        if (xhrSpy) xhrSpy.mockClear();
+    });
+
+    afterEach(() => {
+        (globalThis as any).window = originalWindow;
+        if (originalFetch !== undefined) {
+            (globalThis as any).window.fetch = originalFetch;
+        }
+        jest.clearAllMocks();
+    });
+
+    test('should use FetchUploader if window.fetch is available', () => {
+        (globalThis as any).window.fetch = jest.fn();
+
+        const uploadSpy = (global as any).__fetchUploadSpy as jest.Mock;
+        const client = new APIClient(mpInstance, kitBlocker);
+
+        client.sendLogToServer(logRequest);
+
+        validateUploadCall(uploadSpy, logRequest, mpInstance);
+    });
+
+    test('should use XHRUploader if window.fetch is not available', () => {
+        delete (global as any).window.fetch;
+
+        const uploadSpy = (global as any).__xhrUploadSpy as jest.Mock;
+        const client = new APIClient(mpInstance, kitBlocker);
+
+        client.sendLogToServer(logRequest);
+
+        validateUploadCall(uploadSpy, logRequest, mpInstance);
+    });
+
+    function validateUploadCall(uploadSpy: jest.Mock, expectedLogRequest: LogRequest, mpInstance: any) {
+        expect(uploadSpy).toHaveBeenCalledTimes(1);
+        expect(uploadSpy.mock.calls.length).toBeGreaterThan(0);
+        const firstCall = uploadSpy.mock.calls[0] as any[];
+        expect(firstCall).toBeDefined();
+        const call = firstCall[0];
+        expect(call).toBeDefined();
+        expect((call as any).method).toBe('POST');
+        expect((call as any).body).toBe(JSON.stringify(expectedLogRequest));
+        expect((call as any).headers).toMatchObject({
+            Accept: 'text/plain;charset=UTF-8',
+            'Content-Type': 'text/plain;charset=UTF-8'
+        });
+        expect(mpInstance._Helpers.createServiceUrl).toHaveBeenCalledWith(
+            mpInstance._Store.SDKConfig.v2SecureServiceUrl,
+            mpInstance._Store.devToken
+        );
+    }
+});
+
+
+