feat: Migrate Logger to TypeScript

src/audienceManager.ts

@@ -1,4 +1,4 @@
-import { SDKLoggerApi } from './sdkRuntimeModels';
+import Logger from './logger';
 import {
     FetchUploader,
     XHRUploader,
@@ -21,12 +21,12 @@ export interface IAudienceMemberships {
 export default class AudienceManager {
     public url: string = '';
     public userAudienceAPI: AsyncUploader;
-    public logger: SDKLoggerApi;
+    public logger: Logger;
 
     constructor(
         userAudienceUrl: string,
         apiKey: string,
-        logger: SDKLoggerApi,
+        logger: Logger,
     ) {
         this.logger = logger;
         this.url = `https://${userAudienceUrl}${apiKey}/audience`;

src/batchUploader.ts

@@ -1,6 +1,6 @@
 import { Batch } from '@mparticle/event-models';
 import Constants from './constants';
-import { SDKEvent, SDKLoggerApi } from './sdkRuntimeModels';
+import { SDKEvent } from './sdkRuntimeModels';
 import { convertEvents } from './sdkToEventsApiConverter';
 import { MessageType, EventType } from './types';
 import { getRampNumber, isEmpty } from './utils';
@@ -14,6 +14,7 @@ import {
 import { IMParticleUser } from './identity-user-interfaces';
 import { IMParticleWebSDKInstance } from './mp-instance';
 import { appendUserInfo } from './user-utils';
+import Logger from './logger';
 /**
  * BatchUploader contains all the logic to store/retrieve events and batches
  * to/from persistence, and upload batches to mParticle.
@@ -418,7 +419,7 @@ export class BatchUploader {
     // TODO: Refactor to use logger as a class method
     // https://go.mparticle.com/work/SQDSDKS-5167
     private async uploadBatches(
-        logger: SDKLoggerApi,
+        logger: Logger,
         batches: Batch[],
         useBeacon: boolean
     ): Promise<Batch[] | null> {

src/logger.js → src/logger.ts

@@ -1,21 +1,32 @@
-function Logger(config) {
+import { SDKInitConfig } from "./sdkRuntimeModels";
+
+interface Logger {
+    verbose: (msg: string) => void;
+    warning: (msg: string) => void;
+    error: (msg: string) => void;
+    setLogLevel: (msg: string) => void;
+    logLevel: string;
+    logger: this;
+}
+
+function Logger(this: Logger, config: SDKInitConfig): void {
     var self = this;
-    var logLevel = config.logLevel || 'warning';
+    var logLevel: string = config.logLevel || 'warning';
     if (config.hasOwnProperty('logger')) {
-        this.logger = config.logger;
+        this.logger = config.logger as Logger;
     } else {
         this.logger = new ConsoleLogger();
     }
 
-    this.verbose = function(msg) {
+    this.verbose = function(msg: string) {
         if (logLevel !== 'none') {
             if (self.logger.verbose && logLevel === 'verbose') {
                 self.logger.verbose(msg);
             }
         }
     };
 
-    this.warning = function(msg) {
+    this.warning = function(msg: string) {
         if (logLevel !== 'none') {
             if (
                 self.logger.warning &&
@@ -26,36 +37,37 @@ function Logger(config) {
         }
     };
 
-    this.error = function(msg) {
+    this.error = function(msg: string) {
         if (logLevel !== 'none') {
             if (self.logger.error) {
                 self.logger.error(msg);
             }
         }
     };
 
-    this.setLogLevel = function(newLogLevel) {
+    this.setLogLevel = function(newLogLevel: string) {
         logLevel = newLogLevel;
+        this.logLevel = logLevel;
     };
 }
 
-function ConsoleLogger() {
-    this.verbose = function(msg) {
+function ConsoleLogger(this: Logger): void {
+    this.verbose = function(msg: string) {
         if (console && console.info) {
             console.info(msg);
         }
     };
 
-    this.error = function(msg) {
+    this.error = function(msg: string) {
         if (console && console.error) {
             console.error(msg);
         }
     };
-    this.warning = function(msg) {
+    this.warning = function(msg: string) {
         if (console && console.warn) {
             console.warn(msg);
         }
     };
 }
 
-export default Logger;
+export default Logger;

src/roktManager.ts

@@ -4,7 +4,7 @@ import { IMParticleUser } from "./identity-user-interfaces";
 import KitFilterHelper from "./kitFilterHelper";
 import { Dictionary, parseSettingsString, generateUniqueId, isFunction } from "./utils";
 import { SDKIdentityApi } from "./identity.interfaces";
-import { SDKLoggerApi } from "./sdkRuntimeModels";
+import Logger from "./logger";
 
 // https://docs.rokt.com/developers/integration-guides/web/library/attributes
 export interface IRoktPartnerAttributes {
@@ -84,15 +84,15 @@ export default class RoktManager {
     private placementAttributesMapping: Dictionary<string>[] = [];
     private identityService: SDKIdentityApi;
     private launcherOptions?: IRoktLauncherOptions;
-    private logger: SDKLoggerApi;
+    private logger: Logger;
     private domain?: string;
     /**
      * Initializes the RoktManager with configuration settings and user data.
      * 
      * @param {IKitConfigs} roktConfig - Configuration object containing user attribute filters and settings
      * @param {IMParticleUser} filteredUser - User object with filtered attributes
      * @param {SDKIdentityApi} identityService - The mParticle Identity instance
-     * @param {SDKLoggerApi} logger - The mParticle Logger instance
+     * @param {Logger} logger - The mParticle Logger instance
      * @param {IRoktOptions} options - Options for the RoktManager
      * 
      * @throws Logs error to console if placementAttributesMapping parsing fails
@@ -101,7 +101,7 @@ export default class RoktManager {
         roktConfig: IKitConfigs, 
         filteredUser: IMParticleUser, 
         identityService: SDKIdentityApi,
-        logger?: SDKLoggerApi,
+        logger?: Logger,
         options?: IRoktOptions
     ): void {
         const { userAttributeFilters, settings } = roktConfig || {};

src/sdkRuntimeModels.ts

@@ -13,6 +13,7 @@ import { Dictionary, valueof } from './utils';
 import { IKitConfigs } from './configAPIClient';
 import { SDKConsentApi, SDKConsentState } from './consent';
 import MPSideloadedKit from './sideloadedKit';
+import Logger  from './logger'
 import { ISessionManager } from './sessionManager';
 import { ConfiguredKit, MPForwarder, UnregisteredKit } from './forwarders.interfaces';
 import {
@@ -172,7 +173,7 @@ export interface MParticleWebSDK {
     PromotionType: typeof PromotionActionType;
     ProductActionType: typeof ProductActionType;
     Identity: SDKIdentityApi;
-    Logger: SDKLoggerApi;
+    Logger: Logger;
     Consent: SDKConsentApi;
     _resetForTests(
         MPConfig?: SDKInitConfig,
@@ -352,13 +353,6 @@ export interface SDKHelpersApi {
     Validators: typeof Validators;
 }
 
-export interface SDKLoggerApi {
-    error(arg0: string): void;
-    verbose(arg0: string): void;
-    warning(arg0: string): void;
-    setLogLevel(logLevel: LogLevelType): void;
-}
-
 // TODO: Merge this with IStore in store.ts
 export interface SDKStoreApi {
     isEnabled: boolean;

test/jest/logger.spec.ts

@@ -0,0 +1,61 @@
+import Logger from "../../src/logger";
+import { SDKInitConfig } from "../../src/sdkRuntimeModels";
+
+describe('ConsoleLogger', () => {
+    it('should set logger level to warning', () => {
+        // create a dummy config
+        let sampleConfig = {
+            appName: 'Store Test',
+            appVersion: '1.x',
+            package: 'com.mparticle.test',
+            flags: {},
+        } as SDKInitConfig;
+
+        // create a new Logger instance
+        const logger = new Logger(sampleConfig);
+
+        // setLogLevel to warning
+        logger.setLogLevel('warning');
+
+        // insure the logLevel is set to warning
+        expect(logger.logLevel).toBe('warning')
+    });
+
+    it('should set logger level to verbose', () => {
+        // create a dummy config
+        let sampleConfig = {
+            appName: 'Store Test',
+            appVersion: '1.x',
+            package: 'com.mparticle.test',
+            flags: {},
+        } as SDKInitConfig;
+
+        // create a new Logger instance
+        const logger = new Logger(sampleConfig);
+
+        // setLogLevel to verbose
+        logger.setLogLevel('verbose');
+
+        // insure the logLevel is set to verbose
+        expect(logger.logLevel).toBe('verbose')
+    })
+
+    it('should set logger level to error', () => {
+        // create a dummy config
+        let sampleConfig = {
+            appName: 'Store Test',
+            appVersion: '1.x',
+            package: 'com.mparticle.test',
+            flags: {},
+        } as SDKInitConfig;
+
+        // create a new Logger instance
+        const logger = new Logger(sampleConfig);
+
+        // setLogLevel to error
+        logger.setLogLevel('error');
+
+        // insure the logLevel is set to error
+        expect(logger.logLevel).toBe('error')
+    })
+});

test/src/tests-audience-manager.ts

@@ -3,11 +3,11 @@ import fetchMock from 'fetch-mock/esm/client';
 import { expect } from 'chai';
 import { urls, apiKey, testMPID } from './config/constants';
 import Constants from '../../src/constants';
-import { IMParticleInstanceManager, SDKLoggerApi } from '../../src/sdkRuntimeModels';
+import { IMParticleInstanceManager } from '../../src/sdkRuntimeModels';
 import AudienceManager, {
     IAudienceMemberships, IAudienceMembershipsServerResponse
 } from '../../src/audienceManager';
-import Logger from '../../src/logger.js';
+import Logger from '../../src/logger';
 import Utils from './config/utils';
 const { fetchMockSuccess } = Utils;
 
@@ -45,7 +45,7 @@ describe('AudienceManager', () => {
 
     describe('initialization', () => {
         it('should have proper properties on AudienceManager', () => {
-            const newLogger: SDKLoggerApi = new Logger(window.mParticle.config);
+            const newLogger: Logger = new Logger(window.mParticle.config);
             const audienceManager = new AudienceManager(
                 Constants.DefaultBaseUrls.userAudienceUrl,
                 apiKey,