feat: Create logging service

src/constants.ts

@@ -139,6 +139,8 @@ const Constants = {
         identityUrl: 'identity.mparticle.com/v1/',
         aliasUrl: 'jssdks.mparticle.com/v1/identity/',
         userAudienceUrl: 'nativesdks.mparticle.com/v1/',
+        loggingUrl: 'apps.rokt-api.com/v1/log',
+        errorUrl: 'apps.rokt-api.com/v1/errors',
     },
     // These are the paths that are used to construct the CNAME urls
     CNAMEUrlPaths: {
@@ -148,6 +150,8 @@ const Constants = {
         configUrl: '/tags/JS/v2/',
         identityUrl: '/identity/v1/',
         aliasUrl: '/webevents/v1/identity/',
+        loggingUrl: '/v1/log',
+        errorUrl: '/v1/errors',
     },
     Base64CookieKeys: {
         csm: 1,

src/identityApiClient.ts

@@ -25,6 +25,7 @@ import {
     IIdentityResponse,
 } from './identity-user-interfaces';
 import { IMParticleWebSDKInstance } from './mp-instance';
+import { ErrorCodes } from './logging/types';
 
 const { HTTPCodes, Messages, IdentityMethods } = Constants;
 
@@ -326,10 +327,13 @@ export default function IdentityAPIClient(
                 const requestCount = mpInstance._Store.identifyRequestCount;
                 mpInstance.captureTiming(`${requestCount}-identityRequestEnd`);
             }
-            
+
             const errorMessage = (err as Error).message || err.toString();
-            Logger.error('Error sending identity request to servers - ' + errorMessage);
-
+            Logger.error(
+                'Error sending identity request to servers' + ' - ' + errorMessage,
+                ErrorCodes.IDENTITY_REQUEST
+            );
+
             mpInstance.processQueueOnIdentityFailure?.();
             invokeCallback(callback, HTTPCodes.noHttpCoverage, errorMessage);
         }

src/logger.ts

@@ -1,15 +1,21 @@
 import { LogLevelType, SDKInitConfig, SDKLoggerApi } from './sdkRuntimeModels';
+import { ReportingLogger } from './logging/reportingLogger';
+import { ErrorCodes } from './logging/types';
 
 export type ILoggerConfig = Pick<SDKInitConfig, 'logLevel' | 'logger'>;
 export type IConsoleLogger = Partial<Pick<SDKLoggerApi, 'error' | 'warning' | 'verbose'>>;
 
 export class Logger {
     private logLevel: LogLevelType;
     private logger: IConsoleLogger;
+    private reportingLogger: ReportingLogger;
 
-    constructor(config: ILoggerConfig) {
+    constructor(config: ILoggerConfig,
+        reportingLogger?: ReportingLogger,
+    ) {
         this.logLevel = config.logLevel ?? LogLevelType.Warning;
         this.logger = config.logger ?? new ConsoleLogger();
+        this.reportingLogger = reportingLogger;
     }
 
     public verbose(msg: string): void {
@@ -22,21 +28,24 @@ export class Logger {
     }
 
     public warning(msg: string): void {
-        if(this.logLevel === LogLevelType.None) 
+        if(this.logLevel === LogLevelType.None)
             return;
 
-        if (this.logger.warning && 
+        if (this.logger.warning &&
             (this.logLevel === LogLevelType.Verbose || this.logLevel === LogLevelType.Warning)) {
             this.logger.warning(msg);
         }
     }
 
-    public error(msg: string): void {
-        if(this.logLevel === LogLevelType.None) 
+    public error(msg: string, code?: ErrorCodes): void {
+        if(this.logLevel === LogLevelType.None)
             return;
 
         if (this.logger.error) {
             this.logger.error(msg);
+            if (code) {
+                this.reportingLogger?.error(msg, code);
+            }
         }
     }
 

src/logging/reportingLogger.ts

@@ -0,0 +1,185 @@
+import { ErrorCodes, LogRequestBody, WSDKErrorSeverity } from "./types";
+import { FetchUploader, IFetchPayload } from "../uploaders";
+import { IStore, SDKConfig } from "../store";
+import { SDKInitConfig } from "../sdkRuntimeModels";
+import Constants from "../constants";
+
+interface IReportingLoggerPayload extends IFetchPayload {
+    headers: IFetchPayload['headers'] & {
+        'rokt-launcher-instance-guid'?: string;
+        'rokt-launcher-version': string;
+        'rokt-wsdk-version': string;
+    };
+    body: string;
+}
+
+export class ReportingLogger {
+    private readonly isEnabled: boolean;
+    private readonly reporter: string = 'mp-wsdk';
+    private readonly integration: string = 'mp-wsdk';
+    private readonly rateLimiter: IRateLimiter;
+    private store: IStore | null;
+    private readonly loggingUrl: string;
+    private readonly errorUrl: string;
+    private readonly isWebSdkLoggingEnabled: 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.isWebSdkLoggingEnabled = config.isWebSdkLoggingEnabled || 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: this.integration
+        };
+    }
+
+    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.isWebSdkLoggingEnabled;
+
+    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'] = {
+            Accept: 'text/plain;charset=UTF-8',
+            'Content-Type': 'application/json',
+            'rokt-launcher-version': this.getVersion(),
+            'rokt-wsdk-version': 'joint',
+        };
+
+        if (this.launcherInstanceGuid) {
+            headers['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;
+    }
+}

src/logging/types.ts

@@ -0,0 +1,32 @@
+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;