Refactor logging configuration in BaseConfigType

packages/sdk/src/tests/utils/EventSubscription.test.ts

@@ -124,82 +124,99 @@ describe('EventHelper', () => {
     });
 });
 
-
 describe('EventSubscription Error Handling', () => {
     let mockLogger: jest.Mock;
     let legacyEventHandler: jest.Mock;
-  
+
     beforeEach(() => {
-      mockLogger = jest.fn();
-      legacyEventHandler = jest.fn();
+        mockLogger = jest.fn();
+        legacyEventHandler = jest.fn();
     });
-  
+
     it('logs an error when a callback errors out with LOG behavior', () => {
-      const eventSubscription = new EventSubscription(() => undefined, mockLogger);
-      const errorCallback = jest.fn(() => { throw new Error('Test Error'); });
-
-      eventSubscription.registerCallback(errorCallback, CallbackErrorBehavior.LOG);
-
-      eventSubscription.trigger();
-
-      expect(mockLogger).toHaveBeenCalledWith(LogLevel.ERROR, LogCategory.EVENT, expect.stringContaining('Error in callback'));
-      expect(errorCallback).toHaveBeenCalled();
-    });
-
+        const eventSubscription = new EventSubscription(() => undefined, mockLogger);
+        const errorCallback = jest.fn(() => {
+            throw new Error('Test Error');
+        });
+
+        eventSubscription.registerCallback(errorCallback, CallbackErrorBehavior.LOG);
+
+        eventSubscription.trigger();
+
+        expect(mockLogger).toHaveBeenCalledWith(
+            LogLevel.ERROR,
+            LogCategory.EVENT,
+            expect.stringContaining('Error in callback'),
+        );
+        expect(errorCallback).toHaveBeenCalled();
+    });
+
     it('throws an error when a callback errors out with THROW behavior', () => {
-      const eventSubscription = new EventSubscription(() => undefined, mockLogger);
-      const errorCallback = jest.fn(() => { throw new Error('Test Error'); });
-
-      eventSubscription.registerCallback(errorCallback, CallbackErrorBehavior.THROW);
-
-      expect(() => eventSubscription.trigger()).toThrow('Test Error');
-      expect(errorCallback).toHaveBeenCalled();
-    });
-
+        const eventSubscription = new EventSubscription(() => undefined, mockLogger);
+        const errorCallback = jest.fn(() => {
+            throw new Error('Test Error');
+        });
+
+        eventSubscription.registerCallback(errorCallback, CallbackErrorBehavior.THROW);
+
+        expect(() => eventSubscription.trigger()).toThrow('Test Error');
+        expect(errorCallback).toHaveBeenCalled();
+    });
+
     it('removes the callback when a callback errors out with REMOVE behavior', () => {
-      const eventSubscription = new EventSubscription(() => undefined, mockLogger);
-      const errorCallback = jest.fn(() => { throw new Error('Test Error'); });
-
-      const callbackName = eventSubscription.registerCallback(errorCallback, CallbackErrorBehavior.REMOVE);
-
-      eventSubscription.trigger();
-
-      expect(mockLogger).toHaveBeenCalledWith(LogLevel.WARN, LogCategory.EVENT, expect.stringContaining('Removed callback'));
-      expect(errorCallback).toHaveBeenCalled();
-      expect(() => eventSubscription.trigger()).not.toThrow();
-    });
-
+        const eventSubscription = new EventSubscription(() => undefined, mockLogger);
+        const errorCallback = jest.fn(() => {
+            throw new Error('Test Error');
+        });
+
+        eventSubscription.registerCallback(errorCallback, CallbackErrorBehavior.REMOVE);
+
+        eventSubscription.trigger();
+
+        expect(mockLogger).toHaveBeenCalledWith(
+            LogLevel.WARN,
+            LogCategory.EVENT,
+            expect.stringContaining('Removed callback'),
+        );
+        expect(errorCallback).toHaveBeenCalled();
+        expect(() => eventSubscription.trigger()).not.toThrow();
+    });
+
     it('executes legacy event handler if provided', () => {
-      const legacyCallback = jest.fn();
-      legacyEventHandler.mockReturnValue(legacyCallback);
-  
-      const eventSubscription = new EventSubscription(legacyEventHandler, mockLogger);
-  
-      eventSubscription.trigger();
-  
-      expect(legacyEventHandler).toHaveBeenCalled();
-      expect(legacyCallback).toHaveBeenCalled();
-    });
-  
+        const legacyCallback = jest.fn();
+        legacyEventHandler.mockReturnValue(legacyCallback);
+
+        const eventSubscription = new EventSubscription(legacyEventHandler, mockLogger);
+
+        eventSubscription.trigger();
+
+        expect(legacyEventHandler).toHaveBeenCalled();
+        expect(legacyCallback).toHaveBeenCalled();
+    });
+
     it('does not log if no logger provided for LOG behavior', () => {
-      const eventSubscription = new EventSubscription(() => undefined);
-      const errorCallback = jest.fn(() => { throw new Error('Test Error'); });
-
-      eventSubscription.registerCallback(errorCallback, CallbackErrorBehavior.LOG);
-
-      eventSubscription.trigger();
-
-      expect(mockLogger).not.toHaveBeenCalled();
-    });
-
+        const eventSubscription = new EventSubscription(() => undefined);
+        const errorCallback = jest.fn(() => {
+            throw new Error('Test Error');
+        });
+
+        eventSubscription.registerCallback(errorCallback, CallbackErrorBehavior.LOG);
+
+        eventSubscription.trigger();
+
+        expect(mockLogger).not.toHaveBeenCalled();
+    });
+
     it('does not log if no logger provided for REMOVE behavior', () => {
-      const eventSubscription = new EventSubscription(() => undefined);
-      const errorCallback = jest.fn(() => { throw new Error('Test Error'); });
-
-      eventSubscription.registerCallback(errorCallback, CallbackErrorBehavior.REMOVE);
-
-      eventSubscription.trigger();
-
-      expect(mockLogger).not.toHaveBeenCalled();
-    });
-  });
+        const eventSubscription = new EventSubscription(() => undefined);
+        const errorCallback = jest.fn(() => {
+            throw new Error('Test Error');
+        });
+
+        eventSubscription.registerCallback(errorCallback, CallbackErrorBehavior.REMOVE);
+
+        eventSubscription.trigger();
+
+        expect(mockLogger).not.toHaveBeenCalled();
+    });
+});

packages/sdk/src/tests/utils/Logging.test.ts

@@ -0,0 +1,115 @@
+import { LogLevel, RuntimeConfigType, ConfigType, LoggerFunction, LogCategory } from '../../types/CommonTypes';
+import { ConfigHelper } from '../../utils/ConfigHelper';
+
+describe('ConfigHelper', () => {
+    let originalConsoleError: unknown;
+    let originalConsoleWarn: unknown;
+    let originalConsoleLog: unknown;
+
+    beforeEach(() => {
+        originalConsoleError = console.error;
+        originalConsoleWarn = console.warn;
+        originalConsoleLog = console.log;
+
+        console.error = jest.fn();
+        console.warn = jest.fn();
+        console.log = jest.fn();
+    });
+
+    afterEach(() => {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        console.error = originalConsoleError;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        console.warn = originalConsoleWarn;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        console.log = originalConsoleLog;
+    });
+
+    const createConfigWithLogLevel = (logLevel: LogLevel): RuntimeConfigType => {
+        const config: ConfigType = {
+            logging: {
+                logLevel: logLevel,
+            },
+        };
+        return ConfigHelper.createRuntimeConfig(config);
+    };
+
+    it('should log error messages when log level is ERROR', () => {
+        const runtimeConfig = createConfigWithLogLevel(LogLevel.ERROR);
+        getLogger(runtimeConfig)(LogLevel.ERROR, LogCategory.GENERAL, 'This is an error message');
+        getLogger(runtimeConfig)(LogLevel.WARN, LogCategory.GENERAL, 'This is a warning message');
+        getLogger(runtimeConfig)(LogLevel.INFO, LogCategory.GENERAL, 'This is an info message');
+
+        expect(console.error).toHaveBeenCalledWith('[general] [error] This is an error message');
+        expect(console.warn).not.toHaveBeenCalled();
+        expect(console.log).not.toHaveBeenCalled();
+    });
+
+    it('should log warning and error messages when log level is WARN', () => {
+        const runtimeConfig = createConfigWithLogLevel(LogLevel.WARN);
+        getLogger(runtimeConfig)(LogLevel.ERROR, LogCategory.GENERAL, 'This is an error message');
+        getLogger(runtimeConfig)(LogLevel.WARN, LogCategory.GENERAL, 'This is a warning message');
+        getLogger(runtimeConfig)(LogLevel.INFO, LogCategory.GENERAL, 'This is an info message');
+
+        expect(console.error).toHaveBeenCalledWith('[general] [error] This is an error message');
+        expect(console.warn).toHaveBeenCalledWith('[general] [warn] This is a warning message');
+        expect(console.log).not.toHaveBeenCalled();
+    });
+
+    it('should log info, warning, and error messages when log level is INFO', () => {
+        const runtimeConfig = createConfigWithLogLevel(LogLevel.INFO);
+        getLogger(runtimeConfig)(LogLevel.ERROR, LogCategory.GENERAL, 'This is an error message');
+        getLogger(runtimeConfig)(LogLevel.WARN, LogCategory.GENERAL, 'This is a warning message');
+        getLogger(runtimeConfig)(LogLevel.INFO, LogCategory.GENERAL, 'This is an info message');
+
+        expect(console.error).toHaveBeenCalledWith('[general] [error] This is an error message');
+        expect(console.warn).toHaveBeenCalledWith('[general] [warn] This is a warning message');
+        expect(console.log).toHaveBeenCalledWith('[general] [info] This is an info message');
+    });
+
+    it('should log only ERROR when loglevel is undefined', () => {
+        const runtimeConfig = createConfigWithLogLevel(undefined as unknown as LogLevel);
+        getLogger(runtimeConfig)(LogLevel.ERROR, LogCategory.GENERAL, 'This is an error message');
+        getLogger(runtimeConfig)(LogLevel.WARN, LogCategory.GENERAL, 'This is a warning message');
+        getLogger(runtimeConfig)(LogLevel.INFO, LogCategory.GENERAL, 'This is an info message');
+
+        expect(console.error).toHaveBeenCalledTimes(1);
+        expect(console.warn).not.toHaveBeenCalled();
+        expect(console.log).not.toHaveBeenCalled();
+    });
+
+    it('should adopt functionality when loglevel changes', () => {
+        const runtimeConfig = createConfigWithLogLevel(LogLevel.ERROR);
+        getLogger(runtimeConfig)(LogLevel.ERROR, LogCategory.GENERAL, 'This is an error message');
+        getLogger(runtimeConfig)(LogLevel.WARN, LogCategory.GENERAL, 'This is a warning message');
+        getLogger(runtimeConfig)(LogLevel.INFO, LogCategory.GENERAL, 'This is an info message');
+
+        expect(console.error).toHaveBeenCalledWith('[general] [error] This is an error message');
+        expect(console.warn).not.toHaveBeenCalled();
+        expect(console.log).not.toHaveBeenCalled();
+
+        if (runtimeConfig.logging) {
+            runtimeConfig.logging.logLevel = LogLevel.WARN;
+        } else {
+            throw new Error('runtimeConfig.logging is undefined');
+        }
+        getLogger(runtimeConfig)(LogLevel.ERROR, LogCategory.GENERAL, 'This is an error message');
+        getLogger(runtimeConfig)(LogLevel.WARN, LogCategory.GENERAL, 'This is a warning message');
+        getLogger(runtimeConfig)(LogLevel.INFO, LogCategory.GENERAL, 'This is an info message');
+
+        expect(console.error).toHaveBeenCalledTimes(2);
+        expect(console.warn).toHaveBeenCalledTimes(1);
+        expect(console.log).not.toHaveBeenCalled();
+    });
+});
+
+function getLogger(runtimeConfig?: RuntimeConfigType): LoggerFunction {
+    if (runtimeConfig?.logging?.logger === undefined) {
+        throw new Error('Logger is undefined');
+    }
+
+    return runtimeConfig.logging.logger;
+}

packages/sdk/src/types/CommonTypes.ts

@@ -29,7 +29,10 @@ export type BaseConfigType = {
     enableNextSubscribers?: {
         onVariableListChanged: boolean;
     };
-    logger?: LoggerFunction;
+    logging?: {
+        logLevel?: LogLevel;
+        logger?: LoggerFunction;
+    };
 };
 
 export type LoggerFunction = (logLevel: LogLevel, category: LogCategory, message: string) => void;
@@ -44,6 +47,7 @@ export enum LogCategory {
     GENERAL = 'general',
     CONNECTOR = 'connector',
     EVENT = 'event',
+    ENGINE = 'engine',
 }
 
 /**