Revise implementation of ReportingLogger

Author: alexs-mparticle

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.UNHANDLED_EXCEPTION
+            );
             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/logRequest.ts

@@ -1,21 +1,23 @@
 import { ErrorCodes } from "./errorCodes";
+export type ErrorCode = ErrorCodes | string;
 
-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 {
-    additionalInformation: {
-        message: string;
-        version: string;
-    };
-    severity: LogRequestSeverity;
-    code: ErrorCodes;
-    url: string;
-    deviceInfo: string;
-    stackTrace: string;
-    reporter: string;
-    integration: string;
-}
+
+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

@@ -1,59 +1,83 @@
-
 import { ErrorCodes } from "./errorCodes";
-import { LogRequest, LogRequestSeverity } from "./logRequest";
-import { FetchUploader, XHRUploader } from "../uploaders";
+import { LogRequestBody, WSDKErrorSeverity } from "./logRequest";
+import { FetchUploader, IFetchPayload } from "../uploaders";
 
+// 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;
+    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 readonly DEFAULT_ACCOUNT_ID: string = '0';
-    private readonly DEFAULT_USER_AGENT: string = 'no-user-agent-set';
-    private readonly DEFAULT_URL: string = 'no-url-set';
-    
+    private loggingUrl: string;
+    private errorUrl: string;
+    private accountId: string;
+    private integrationName: string;
+
     constructor(
-        private baseUrl: string,
         private readonly sdkVersion: string,
-        private readonly accountId: string,
-        rateLimiter?: IRateLimiter,
+        rateLimiter?: IRateLimiter, // QUESTION: Do we need this in the constructor?
+        private readonly launcherInstanceGuid?: string,
     ) {
         this.isEnabled = this.isReportingEnabled();
+        console.warn('ReportingLogger: isEnabled', this.isEnabled);
         this.rateLimiter = rateLimiter ?? new RateLimiter();
     }
 
-    public error(msg: string, code?: ErrorCodes, stackTrace?: string) {
-        this.sendLog(LogRequestSeverity.Error, msg, code ?? ErrorCodes.UNHANDLED_EXCEPTION, stackTrace);
+    public setLoggingUrl(url: string) {
+        this.loggingUrl = url;
+    }
+
+    public setErrorUrl(url: string) {
+        this.errorUrl = url;
+    }
+    
+    public setAccountId(accountId: string) {
+        this.accountId = accountId;
+    }
+    
+    public setIntegrationName(integrationName: string) {
+        this.integrationName = integrationName;
+    }
+
+    // TODO: Add an `info` method to the logger for `/v1/log`
+
+    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 getVersion(): string {
+        return this.integrationName ?? this.sdkVersion;
+    }
+    
+    // QUESTION: Should we split this into `sendError` and `sendLog`?
     private sendLog(
-        severity: LogRequestSeverity,
+        severity: WSDKErrorSeverity,
         msg: string,
         code: ErrorCodes,
         stackTrace?: string
     ): void {
         if(!this.canSendLog(severity))
             return;
 
-        const logRequest: LogRequest = {
+        const logRequest: LogRequestBody = {
             additionalInformation: {
                 message: msg,
-                version: this.sdkVersion,
+                version: this.getVersion(),
             },
             severity: severity,
             code: code,
             url: this.getUrl(),
             deviceInfo: this.getUserAgent(),
-            stackTrace: stackTrace ?? '',
+            stackTrace: stackTrace ?? 'this is my stack trace',
             reporter: this.reporter,
             integration: this.integration,
         };
@@ -62,6 +86,8 @@ export class ReportingLogger implements IReportingLogger {
     }
 
     private isReportingEnabled(): boolean {
+        // QUESTION: Should isDebugModeEnabled take precedence over
+        // isFeatureFlagEnabled and rokt domain present?
         return (
             this.isRoktDomainPresent() && 
             (this.isFeatureFlagEnabled() ||
@@ -90,53 +116,62 @@ 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;
+        return window.location.href;
     }
 
     private getUserAgent(): string {
-        return window?.navigator?.userAgent ?? this.DEFAULT_USER_AGENT;
+        return window.navigator.userAgent;
     }
 
-    private sendLogToServer(logRequest: LogRequest) {
-        const uploadUrl = `${this.baseUrl}/v1/log`;
-        const uploader = window.fetch
-            ? new FetchUploader(uploadUrl)
-            : new XHRUploader(uploadUrl);
+    private getLoggingUrl = (): string => `https://${this.loggingUrl}`;
+    private getErrorUrl = (): string => `https://${this.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',
+        };
+        return headers as IFetchPayload['headers'];
+    }
 
-        uploader.upload({
+    private sendLogToServer(logRequest: LogRequestBody) {
+        const uploadUrl = this.getErrorUrl();
+        const uploader = new FetchUploader(uploadUrl);
+        const payload: IFetchPayload = {
             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
-            },
+            headers: this.getHeaders(),
             body: JSON.stringify(logRequest),
-        });
+        };
+            
+        uploader.upload(payload);
     };
 }
 
 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;