refactor(reportingLogger): Replace LogRequest with IWSDKError and update severity handling; adjust tests for new error logging structure

Author: gtamanaha

src/logging/reportingLogger.ts

@@ -1,6 +1,6 @@
 
 import { ErrorCodes } from "./errorCodes";
-import { LogRequest, LogRequestSeverity } from "./logRequest";
+import { IWSDKError, WSDKErrorSeverity } from "./wsdk-error";
 import { FetchUploader, XHRUploader } from "../uploaders";
 
 export interface IReportingLogger {
@@ -13,52 +13,50 @@ export class ReportingLogger implements IReportingLogger {
     private readonly reporter: string = 'mp-wsdk';
     private readonly integration: string = 'mp-wsdk';
     private readonly rateLimiter: IRateLimiter;
-    private readonly DEFAULT_ACCOUNT_ID: string = '0';
-    private readonly DEFAULT_USER_AGENT: string = 'no-user-agent-set';
-    private readonly DEFAULT_URL: string = 'no-url-set';
 
     constructor(
         private baseUrl: string,
         private readonly sdkVersion: string,
         private readonly accountId: string,
+        private readonly roktLauncherInstanceGuid: string,
         rateLimiter?: IRateLimiter,
     ) {
         this.isEnabled = this.isReportingEnabled();
         this.rateLimiter = rateLimiter ?? new RateLimiter();
     }
 
-    public error(msg: string, code?: ErrorCodes, stackTrace?: string) {
-        this.sendLog(LogRequestSeverity.Error, msg, code ?? ErrorCodes.UNHANDLED_EXCEPTION, stackTrace);
+    public error(msg: string, code: ErrorCodes, stackTrace?: string) {
+        this.sendLog(WSDKErrorSeverity.ERROR, msg, code, stackTrace);
     };
 
-    public warning(msg: string, code?: ErrorCodes) { 
-        this.sendLog(LogRequestSeverity.Warning, msg, code ?? ErrorCodes.UNHANDLED_EXCEPTION);
+    public warning(msg: string, code: ErrorCodes) { 
+        this.sendLog(WSDKErrorSeverity.WARNING, msg, code);
     };
 
     private sendLog(
-        severity: LogRequestSeverity,
+        severity: WSDKErrorSeverity,
         msg: string,
         code: ErrorCodes,
         stackTrace?: string
     ): void {
         if(!this.canSendLog(severity))
             return;
 
-        const logRequest: LogRequest = {
+        const wsdkError: IWSDKError = {
             additionalInformation: {
                 message: msg,
                 version: this.sdkVersion,
             },
             severity: severity,
             code: code,
-            url: this.getUrl(),
-            deviceInfo: this.getUserAgent(),
+            url: window?.location?.href,
+            deviceInfo: window?.navigator?.userAgent,
             stackTrace: stackTrace ?? '',
             reporter: this.reporter,
             integration: this.integration,
         };
 
-        this.sendLogToServer(logRequest);
+        this.sendLogToServer(wsdkError);
     }
 
     private isReportingEnabled(): boolean {
@@ -90,53 +88,51 @@ export class ReportingLogger implements IReportingLogger {
         );
     }
 
-    private canSendLog(severity: LogRequestSeverity): boolean {
+    private canSendLog(severity: WSDKErrorSeverity): boolean {
         return this.isEnabled && !this.isRateLimited(severity);
     }
 
-    private isRateLimited(severity: LogRequestSeverity): boolean {
+    private isRateLimited(severity: WSDKErrorSeverity): boolean {
         return this.rateLimiter.incrementAndCheck(severity);
     }
 
-    private getUrl(): string {
-        return window?.location?.href ?? this.DEFAULT_URL;
-    }
-
-    private getUserAgent(): string {
-        return window?.navigator?.userAgent ?? this.DEFAULT_USER_AGENT;
-    }
-
-    private sendLogToServer(logRequest: LogRequest) {
+    private sendLogToServer(wsdkError: IWSDKError) {
         const uploadUrl = `${this.baseUrl}/v1/log`;
         const uploader = window.fetch
             ? new FetchUploader(uploadUrl)
             : new XHRUploader(uploadUrl);
 
+        const headers = {
+            Accept: 'text/plain;charset=UTF-8',
+            'Content-Type': 'text/plain;charset=UTF-8',
+            'rokt-launcher-instance-guid': this.roktLauncherInstanceGuid,
+        };
+
+        if (this.accountId) {
+            headers['rokt-account-id'] = this.accountId;
+        }
+
         uploader.upload({
+            headers: headers,
             method: 'POST',
-            headers: {
-                Accept: 'text/plain;charset=UTF-8',
-                'Content-Type': 'text/plain;charset=UTF-8',
-                'rokt-account-id': this.accountId || this.DEFAULT_ACCOUNT_ID
-            },
-            body: JSON.stringify(logRequest),
+            body: JSON.stringify(wsdkError),
         });
     };
 }
 
 export interface IRateLimiter {
-    incrementAndCheck(severity: LogRequestSeverity): boolean;
+    incrementAndCheck(severity: WSDKErrorSeverity): boolean;
 }
 
 export class RateLimiter implements IRateLimiter {
-    private readonly rateLimits: Map<LogRequestSeverity, number> = new Map([
-        [LogRequestSeverity.Error, 10],
-        [LogRequestSeverity.Warning, 10],
-        [LogRequestSeverity.Info, 10],
+    private readonly rateLimits: Map<WSDKErrorSeverity, number> = new Map([
+        [WSDKErrorSeverity.ERROR, 10],
+        [WSDKErrorSeverity.WARNING, 10],
+        [WSDKErrorSeverity.INFO, 10],
     ]);
-    private logCount: Map<LogRequestSeverity, number> = new Map();
+    private logCount: Map<WSDKErrorSeverity, number> = new Map();
 
-    public incrementAndCheck(severity: LogRequestSeverity): boolean {
+    public incrementAndCheck(severity: WSDKErrorSeverity): boolean {
         const count = this.logCount.get(severity) || 0;
         const limit = this.rateLimits.get(severity) || 10;
 

src/logging/logRequest.ts src/logging/wsdk-error.tssrc/logging/logRequest.ts renamed to src/logging/wsdk-error.ts

@@ -1,17 +1,18 @@
 import { ErrorCodes } from "./errorCodes";
 
-export enum LogRequestSeverity {
-    Error = 'error',
-    Warning = 'warning',
-    Info = 'info',
-}
+export type WSDKErrorSeverity = (typeof WSDKErrorSeverity)[keyof typeof WSDKErrorSeverity];
+export const WSDKErrorSeverity = {
+  ERROR: 'ERROR',
+  INFO: 'INFO',
+  WARNING: 'WARNING',
+} as const;
 
-export interface LogRequest {
+export interface IWSDKError {
     additionalInformation: {
         message: string;
         version: string;
     };
-    severity: LogRequestSeverity;
+    severity: WSDKErrorSeverity;
     code: ErrorCodes;
     url: string;
     deviceInfo: string;

test/jest/reportingLogger.spec.ts

@@ -1,5 +1,5 @@
 import { IRateLimiter, RateLimiter, ReportingLogger } from '../../src/logging/reportingLogger';
-import { LogRequestSeverity } from '../../src/logging/logRequest';
+import { WSDKErrorSeverity } from '../../src/logging/wsdk-error';
 import { ErrorCodes } from '../../src/logging/errorCodes';
 
 describe('ReportingLogger', () => {
@@ -8,6 +8,7 @@ describe('ReportingLogger', () => {
     const sdkVersion = '1.2.3';
     let mockFetch: jest.Mock;
     const accountId = '1234567890';
+    const roktLauncherInstanceGuid = '1234567890';
     beforeEach(() => {
         mockFetch = jest.fn().mockResolvedValue({ ok: true });
         global.fetch = mockFetch;
@@ -24,7 +25,7 @@ describe('ReportingLogger', () => {
             ROKT_DOMAIN: 'set',
             fetch: mockFetch
         });
-        logger = new ReportingLogger(baseUrl, sdkVersion, accountId);
+        logger = new ReportingLogger(baseUrl, sdkVersion, accountId, roktLauncherInstanceGuid);
     });
 
     afterEach(() => {
@@ -40,44 +41,55 @@ describe('ReportingLogger', () => {
         expect(fetchCall[0]).toContain('/v1/log');
         const body = JSON.parse(fetchCall[1].body);
         expect(body).toMatchObject({
-            severity: LogRequestSeverity.Error,
+            severity: WSDKErrorSeverity.ERROR,
             code: ErrorCodes.UNHANDLED_EXCEPTION,
-            stackTrace: 'stack'
+        });
+        expect(fetchCall[1].headers).toMatchObject({
+            'Accept': 'text/plain;charset=UTF-8',
+            'Content-Type': 'text/plain;charset=UTF-8',
+            'rokt-launcher-instance-guid': roktLauncherInstanceGuid,
+            'rokt-account-id': accountId,
         });
     });
 
     it('sends warning logs with correct params', () => {
-        logger.warning('warn');
+        logger.warning('warn', ErrorCodes.UNHANDLED_EXCEPTION);
         expect(mockFetch).toHaveBeenCalled();
         const fetchCall = mockFetch.mock.calls[0];
         expect(fetchCall[0]).toContain('/v1/log');
         const body = JSON.parse(fetchCall[1].body);
         expect(body).toMatchObject({
-            severity: LogRequestSeverity.Warning
+            severity: WSDKErrorSeverity.WARNING,
+            code: ErrorCodes.UNHANDLED_EXCEPTION,
+        });
+        expect(fetchCall[1].headers).toMatchObject({
+            'Accept': 'text/plain;charset=UTF-8',
+            'Content-Type': 'text/plain;charset=UTF-8',
+            'rokt-launcher-instance-guid': roktLauncherInstanceGuid,
+            'rokt-account-id': accountId,
         });
-        expect(fetchCall[1].headers['rokt-account-id']).toBe(accountId);
     });
 
     it('does not log if ROKT_DOMAIN missing', () => {
         delete (globalThis as any).ROKT_DOMAIN;
-        logger = new ReportingLogger(baseUrl, sdkVersion, accountId);
-        logger.error('x');
+        logger = new ReportingLogger(baseUrl, sdkVersion, accountId, roktLauncherInstanceGuid);
+        logger.error('x', ErrorCodes.UNHANDLED_EXCEPTION);
         expect(mockFetch).not.toHaveBeenCalled();
     });
 
     it('does not log if feature flag and debug mode off', () => {
         window.mParticle.config.isWebSdkLoggingEnabled = false;
         window.location.search = '';
-        logger = new ReportingLogger(baseUrl, sdkVersion, accountId);
-        logger.error('x');
+        logger = new ReportingLogger(baseUrl, sdkVersion, accountId, roktLauncherInstanceGuid);
+        logger.error('x', ErrorCodes.UNHANDLED_EXCEPTION);
         expect(mockFetch).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(baseUrl, sdkVersion, accountId);
-        logger.error('x');
+        logger = new ReportingLogger(baseUrl, sdkVersion, accountId, roktLauncherInstanceGuid);
+        logger.error('x', ErrorCodes.UNHANDLED_EXCEPTION);
         expect(mockFetch).toHaveBeenCalled();
     });
 
@@ -88,29 +100,18 @@ describe('ReportingLogger', () => {
                 return ++count > 3;
             }),
         };
-        logger = new ReportingLogger(baseUrl, sdkVersion, accountId, mockRateLimiter);
+        logger = new ReportingLogger(baseUrl, sdkVersion, accountId, roktLauncherInstanceGuid, mockRateLimiter);
 
-        for (let i = 0; i < 5; i++) logger.error('err');
+        for (let i = 0; i < 5; i++) logger.error('err', ErrorCodes.UNHANDLED_EXCEPTION);
         expect(mockFetch).toHaveBeenCalledTimes(3);
     });
 
-    it('uses default account id when accountId is empty', () => {
-        logger = new ReportingLogger(baseUrl, sdkVersion, undefined);
-        logger.error('msg');
+    it('does not send account id when accountId is empty', () => {
+        logger = new ReportingLogger(baseUrl, sdkVersion, '', roktLauncherInstanceGuid);
+        logger.error('msg', ErrorCodes.UNHANDLED_EXCEPTION);
         expect(mockFetch).toHaveBeenCalled();
         const fetchCall = mockFetch.mock.calls[0];
-        expect(fetchCall[1].headers['rokt-account-id']).toBe('0');
-    });
-
-    it('uses default user agent when user agent is empty', () => {
-        logger = new ReportingLogger(baseUrl, sdkVersion, accountId);
-        delete (globalThis as any).navigator;
-        delete (globalThis as any).location;
-        logger.error('msg');
-        expect(mockFetch).toHaveBeenCalled();
-        const fetchCall = mockFetch.mock.calls[0];
-        const body = JSON.parse(fetchCall[1].body);
-        expect(body).toMatchObject({ deviceInfo: 'no-user-agent-set', url: 'no-url-set' });
+        expect(fetchCall[1].headers['rokt-account-id']).toBeUndefined();
     });
 });
 
@@ -122,33 +123,33 @@ describe('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(WSDKErrorSeverity.ERROR)).toBe(false);
         }
-        expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Error)).toBe(true);
-        expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Error)).toBe(true);
+        expect(rateLimiter.incrementAndCheck(WSDKErrorSeverity.ERROR)).toBe(true);
+        expect(rateLimiter.incrementAndCheck(WSDKErrorSeverity.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(WSDKErrorSeverity.WARNING)).toBe(false);
         }
-        expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Warning)).toBe(true);
-        expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Warning)).toBe(true);
+        expect(rateLimiter.incrementAndCheck(WSDKErrorSeverity.WARNING)).toBe(true);
+        expect(rateLimiter.incrementAndCheck(WSDKErrorSeverity.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(WSDKErrorSeverity.INFO)).toBe(false);
         }
-        expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Info)).toBe(true);
-        expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Info)).toBe(true);
+        expect(rateLimiter.incrementAndCheck(WSDKErrorSeverity.INFO)).toBe(true);
+        expect(rateLimiter.incrementAndCheck(WSDKErrorSeverity.INFO)).toBe(true);
     });
 
     it('tracks rate limits independently per severity', () => {
         for (let i = 0; i < 10; i++) {
-            rateLimiter.incrementAndCheck(LogRequestSeverity.Error);
+            rateLimiter.incrementAndCheck(WSDKErrorSeverity.ERROR);
         }
-        expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Error)).toBe(true);
-        expect(rateLimiter.incrementAndCheck(LogRequestSeverity.Warning)).toBe(false);
+        expect(rateLimiter.incrementAndCheck(WSDKErrorSeverity.ERROR)).toBe(true);
+        expect(rateLimiter.incrementAndCheck(WSDKErrorSeverity.WARNING)).toBe(false);
     });
 });