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.com/v1/log/',
+        errorUrl: 'apps.rokt.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/errorCodes';
 
 const { HTTPCodes, Messages, IdentityMethods } = Constants;
 
@@ -300,10 +301,13 @@ export default function IdentityAPIClient(
             );
         } catch (err) {
             mpInstance._Store.identityCallInFlight = false;
-            
+
             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
+            );
             invokeCallback(
                 callback,
                 HTTPCodes.noHttpCoverage,

src/logger.ts

@@ -1,15 +1,21 @@
 import { LogLevelType, SDKInitConfig, SDKLoggerApi } from './sdkRuntimeModels';
+import { IReportingLogger } from './logging/reportingLogger';
+import { ErrorCodes } from './logging/errorCodes';
 
 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: IReportingLogger;
 
-    constructor(config: ILoggerConfig) {
+    constructor(config: ILoggerConfig,
+        reportingLogger?: IReportingLogger,
+    ) {
         this.logLevel = config.logLevel ?? LogLevelType.Warning;
         this.logger = config.logger ?? new ConsoleLogger();
+        this.reportingLogger = reportingLogger;
     }
 
     public verbose(msg: string): void {
@@ -21,22 +27,24 @@ export class Logger {
         }
     }
 
-    public warning(msg: string): void {
+    public warning(msg: string, code?: ErrorCodes): void {
         if(this.logLevel === LogLevelType.None) 
             return;
 
         if (this.logger.warning && 
             (this.logLevel === LogLevelType.Verbose || this.logLevel === LogLevelType.Warning)) {
             this.logger.warning(msg);
+            this.reportingLogger?.warning(msg, code);
         }
     }
 
-    public error(msg: string): void {
+    public error(msg: string, code?: ErrorCodes): void {
         if(this.logLevel === LogLevelType.None) 
             return;
 
         if (this.logger.error) {
             this.logger.error(msg);
+            this.reportingLogger.error(msg, code);
         }
     }
 
@@ -63,4 +71,4 @@ export class ConsoleLogger implements IConsoleLogger {
             console.warn(msg);
         }
     }
-}
+}

src/logging/errorCodes.ts

@@ -0,0 +1,9 @@
+import { valueof } from '../utils';
+
+export type ErrorCodes = valueof<typeof ErrorCodes>;
+
+export const ErrorCodes = {
+    UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+    UNHANDLED_EXCEPTION: 'UNHANDLED_EXCEPTION',
+    IDENTITY_REQUEST: 'IDENTITY_REQUEST',
+} as const;

src/logging/logRequest.ts

@@ -0,0 +1,23 @@
+import { ErrorCodes } from "./errorCodes";
+export type ErrorCode = ErrorCodes | string;
+
+export type WSDKErrorSeverity = (typeof WSDKErrorSeverity)[keyof typeof WSDKErrorSeverity];
+export const WSDKErrorSeverity = {
+  ERROR: 'ERROR',
+  INFO: 'INFO',
+  WARNING: 'WARNING',
+} as const;
+
+
+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;

src/logging/reportingLogger.ts

@@ -0,0 +1,178 @@
+import { ErrorCodes } from "./errorCodes";
+import { LogRequestBody, WSDKErrorSeverity } from "./logRequest";
+import { FetchUploader, IFetchPayload } from "../uploaders";
+import { IStore, SDKConfig } from "../store";
+
+// QUESTION: Should we collapse the interface with the class?
+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 reporter: string = 'mp-wsdk';
+    private readonly integration: string = 'mp-wsdk';
+    private readonly rateLimiter: IRateLimiter;
+    private integrationName: string;
+    private store: IStore;
+
+    constructor(
+        private readonly config: SDKConfig,
+        private readonly sdkVersion: string,
+        private readonly launcherInstanceGuid?: string,
+        rateLimiter?: IRateLimiter,
+    ) {
+        this.isEnabled = this.isReportingEnabled();
+        this.rateLimiter = rateLimiter ?? new RateLimiter();
+    }
+
+    public setIntegrationName(integrationName: string) {
+        this.integrationName = integrationName;
+    }
+
+    public setStore(store: IStore) {
+        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;
+
+        const logRequest = this.getLogRequest(severity, msg, code, stackTrace);
+        const uploader = new FetchUploader(url);
+        const payload: IFetchPayload = {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify(logRequest),
+        };
+        uploader.upload(payload);
+    }
+
+    private sendLog(severity: WSDKErrorSeverity, msg: string, code?: ErrorCodes, stackTrace?: string): void {
+        const url = this.getLoggingUrl();
+        this.sendToServer(url, severity, msg, code, stackTrace);
+    }
+    private sendError(severity: WSDKErrorSeverity, msg: string, code?: ErrorCodes, stackTrace?: string): void {
+        const url = this.getErrorUrl();
+        this.sendToServer(url, severity, msg, code, stackTrace);
+    }
+
+    private getLogRequest(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.integrationName ?? this.sdkVersion;
+    }
+
+    private isReportingEnabled(): boolean {
+        // QUESTION: Should isDebugModeEnabled take precedence over
+        // isFeatureFlagEnabled and rokt domain present?
+        return (
+            this.isRoktDomainPresent() && 
+            (this.isFeatureFlagEnabled() ||
+            this.isDebugModeEnabled())
+        );
+    }
+
+    private isRoktDomainPresent(): boolean {
+        return Boolean(window['ROKT_DOMAIN']);
+    }
+
+    private isFeatureFlagEnabled(): boolean {
+        return this.config.isWebSdkLoggingEnabled;
+    }
+
+    private isDebugModeEnabled(): boolean {
+        return (
+            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 {
+        return window.location.href;
+    }
+
+    private getUserAgent(): string {
+        return window.navigator.userAgent;
+    }
+
+    private getLoggingUrl = (): string => `https://${this.config.loggingUrl}`;
+    private getErrorUrl = (): string => `https://${this.config.errorUrl}`;
+
+    private getHeaders(): IFetchPayload['headers'] {
+        const headers: Record<string, string> = {
+            Accept: 'text/plain;charset=UTF-8',
+            'Content-Type': 'application/json',
+            'rokt-launcher-instance-guid': this.launcherInstanceGuid,
+            'rokt-launcher-version': this.getVersion(),
+            'rokt-wsdk-version': 'joint',
+        };
+
+        if (this.store?.getRoktAccountId()) {
+            headers['rokt-account-id'] = this.store.getRoktAccountId();
+        }
+
+        return headers as IFetchPayload['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;
+    }
+}