@devrev/ts-adaas 1.11.1-beta.24 → 1.11.1-beta.25

package/dist/common/constants.d.ts

@@ -22,5 +22,7 @@ export declare const DEFAULT_LAMBDA_TIMEOUT: number;
 export declare const HARD_TIMEOUT_MULTIPLIER = 1.3;
 export declare const MEMORY_LOG_INTERVAL: number;
 export declare const DEFAULT_SLEEP_DELAY_MS: number;
-export declare const MAX_STRING_LENGTH = 10000;
+export declare const MAX_LOG_DEPTH = 10;
+export declare const MAX_LOG_ARRAY_LENGTH = 100;
+export declare const MAX_LOG_STRING_LENGTH = 10000;
 //# sourceMappingURL=constants.d.ts.map

package/dist/common/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/common/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGhD,eAAO,MAAM,8BAA8B,aAS1C,CAAC;AAEF,eAAO,MAAM,2BAA2B,aAKvC,CAAC;AAEF,eAAO,MAAM,mBAAmB,aAG/B,CAAC;AAEF,eAAO,MAAM,gCAAgC,aAI5C,CAAC;AAEF,eAAO,MAAM,6BAA6B,aAGzC,CAAC;AAEF,eAAO,MAAM,qBAAqB,aAGjC,CAAC;AAEF,eAAO,MAAM,+BAA+B,aAGzC,CAAC;AAEJ,eAAO,MAAM,4BAA4B,aAExC,CAAC;AAEF,eAAO,MAAM,oBAAoB,aAGhC,CAAC;AAEF,eAAO,MAAM,mBAAmB,OAAO,CAAC;AACxC,eAAO,MAAM,wBAAwB,YAAY,CAAC;AAClD,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAC9C,eAAO,MAAM,oCAAoC,KAAK,CAAC;AAEvD,eAAO,MAAM,0BAA0B;;;;CAItC,CAAC;AAEF,eAAO,MAAM,eAAe,KAAsB,CAAC;AAEnD,eAAO,MAAM,sBAAsB,QAAiB,CAAC;AACrD,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAC3C,eAAO,MAAM,mBAAmB,QAAY,CAAC;AAE7C,eAAO,MAAM,sBAAsB,QAAgB,CAAC;AAEpD,eAAO,MAAM,iBAAiB,QAAQ,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/common/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGhD,eAAO,MAAM,8BAA8B,aAS1C,CAAC;AAEF,eAAO,MAAM,2BAA2B,aAKvC,CAAC;AAEF,eAAO,MAAM,mBAAmB,aAG/B,CAAC;AAEF,eAAO,MAAM,gCAAgC,aAI5C,CAAC;AAEF,eAAO,MAAM,6BAA6B,aAGzC,CAAC;AAEF,eAAO,MAAM,qBAAqB,aAGjC,CAAC;AAEF,eAAO,MAAM,+BAA+B,aAGzC,CAAC;AAEJ,eAAO,MAAM,4BAA4B,aAExC,CAAC;AAEF,eAAO,MAAM,oBAAoB,aAGhC,CAAC;AAEF,eAAO,MAAM,mBAAmB,OAAO,CAAC;AACxC,eAAO,MAAM,wBAAwB,YAAY,CAAC;AAClD,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAC9C,eAAO,MAAM,oCAAoC,KAAK,CAAC;AAEvD,eAAO,MAAM,0BAA0B;;;;CAItC,CAAC;AAEF,eAAO,MAAM,eAAe,KAAsB,CAAC;AAEnD,eAAO,MAAM,sBAAsB,QAAiB,CAAC;AACrD,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAC3C,eAAO,MAAM,mBAAmB,QAAY,CAAC;AAE7C,eAAO,MAAM,sBAAsB,QAAgB,CAAC;AAEpD,eAAO,MAAM,aAAa,KAAK,CAAC;AAChC,eAAO,MAAM,oBAAoB,MAAM,CAAC;AACxC,eAAO,MAAM,qBAAqB,QAAQ,CAAC"}

package/dist/common/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_STRING_LENGTH = exports.DEFAULT_SLEEP_DELAY_MS = exports.MEMORY_LOG_INTERVAL = exports.HARD_TIMEOUT_MULTIPLIER = exports.DEFAULT_LAMBDA_TIMEOUT = exports.LIBRARY_VERSION = exports.AIRDROP_DEFAULT_ITEM_TYPES = exports.MAX_DEVREV_FILENAME_EXTENSION_LENGTH = exports.MAX_DEVREV_FILENAME_LENGTH = exports.MAX_DEVREV_ARTIFACT_SIZE = exports.ARTIFACT_BATCH_SIZE = exports.STATEFUL_EVENT_TYPES = exports.STATEFUL_LOADING_EVENT_TYPES = exports.STATEFUL_EXTRACTION_EVENT_TYPES = exports.STATELESS_EVENT_TYPES = exports.STATELESS_LOADING_EVENT_TYPES = exports.STATELESS_EXTRACTION_EVENT_TYPES = exports.ALLOWED_EVENT_TYPES = exports.ALLOWED_LOADING_EVENT_TYPES = exports.ALLOWED_EXTRACTION_EVENT_TYPES = void 0;
+exports.MAX_LOG_STRING_LENGTH = exports.MAX_LOG_ARRAY_LENGTH = exports.MAX_LOG_DEPTH = exports.DEFAULT_SLEEP_DELAY_MS = exports.MEMORY_LOG_INTERVAL = exports.HARD_TIMEOUT_MULTIPLIER = exports.DEFAULT_LAMBDA_TIMEOUT = exports.LIBRARY_VERSION = exports.AIRDROP_DEFAULT_ITEM_TYPES = exports.MAX_DEVREV_FILENAME_EXTENSION_LENGTH = exports.MAX_DEVREV_FILENAME_LENGTH = exports.MAX_DEVREV_ARTIFACT_SIZE = exports.ARTIFACT_BATCH_SIZE = exports.STATEFUL_EVENT_TYPES = exports.STATEFUL_LOADING_EVENT_TYPES = exports.STATEFUL_EXTRACTION_EVENT_TYPES = exports.STATELESS_EVENT_TYPES = exports.STATELESS_LOADING_EVENT_TYPES = exports.STATELESS_EXTRACTION_EVENT_TYPES = exports.ALLOWED_EVENT_TYPES = exports.ALLOWED_LOADING_EVENT_TYPES = exports.ALLOWED_EXTRACTION_EVENT_TYPES = void 0;
 const extraction_1 = require("../types/extraction");
 const helpers_1 = require("./helpers");
 exports.ALLOWED_EXTRACTION_EVENT_TYPES = [
@@ -56,4 +56,6 @@ exports.DEFAULT_LAMBDA_TIMEOUT = 10 * 60 * 1000; // 10 minutes
 exports.HARD_TIMEOUT_MULTIPLIER = 1.3;
 exports.MEMORY_LOG_INTERVAL = 30 * 1000; // 30 seconds
 exports.DEFAULT_SLEEP_DELAY_MS = 3 * 60 * 1000; // 3 minutes
-exports.MAX_STRING_LENGTH = 10000;
+exports.MAX_LOG_DEPTH = 10;
+exports.MAX_LOG_ARRAY_LENGTH = 100;
+exports.MAX_LOG_STRING_LENGTH = 10000;

package/dist/logger/logger.d.ts

@@ -7,7 +7,7 @@ export declare class Logger extends Console {
     private tags;
     constructor({ event, options }: LoggerFactoryInterface);
     private valueToString;
-    logFn(args: unknown[], level: LogLevel): void;
+    logFn(args: unknown[], level: LogLevel, skipSanitization?: boolean): void;
     log(...args: unknown[]): void;
     info(...args: unknown[]): void;
     warn(...args: unknown[]): void;

package/dist/logger/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/logger/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,OAAO,EAAE,UAAU,EAAyC,MAAM,OAAO,CAAC;AAG1E,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EAEtB,QAAQ,EAER,cAAc,EACf,MAAM,qBAAqB,CAAC;AAE7B,qBAAa,MAAO,SAAQ,OAAO;IACjC,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,OAAO,CAAC,CAAuB;IACvC,OAAO,CAAC,IAAI,CAAa;gBAEb,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,sBAAsB;IAUtD,OAAO,CAAC,aAAa;IAerB,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI;IA0BpC,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAI7B,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAI9B,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAI9B,KAAK,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;CAGzC;AAID,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,cAAc,CAyB5E;AACD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAE1D;AAED,eAAO,MAAM,cAAc,GAAI,OAAO,OAAO,YAK5C,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,kBAAkB,CAwBzE"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/logger/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,OAAO,EAAE,UAAU,EAAyC,MAAM,OAAO,CAAC;AAQ1E,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EAEtB,QAAQ,EAER,cAAc,EACf,MAAM,qBAAqB,CAAC;AAE7B,qBAAa,MAAO,SAAQ,OAAO;IACjC,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,OAAO,CAAC,CAAuB;IACvC,OAAO,CAAC,IAAI,CAAa;gBAEb,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,sBAAsB;IAUtD,OAAO,CAAC,aAAa;IAsBrB,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,gBAAgB,UAAQ,GAAG,IAAI;IA4B9D,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAI7B,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAI9B,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAI9B,KAAK,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;CAGzC;AAID,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,cAAc,CAyB5E;AACD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAE1D;AAED,eAAO,MAAM,cAAc,GAAI,OAAO,OAAO,YAK5C,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,kBAAkB,CAwBzE"}

package/dist/logger/logger.js

@@ -19,38 +19,47 @@ class Logger extends node_console_1.Console {
         this.tags = Object.assign(Object.assign({}, event.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION });
     }
     valueToString(value) {
-        // If the value is a string, return it as-is
+        // If the value is a string, return the first MAX_LOG_STRING_LENGTH characters
         if (typeof value === 'string') {
-            return value;
+            if (value.length > constants_1.MAX_LOG_STRING_LENGTH) {
+                return `${value.substring(0, constants_1.MAX_LOG_STRING_LENGTH)}... ${value.length - constants_1.MAX_LOG_STRING_LENGTH} more characters`;
+            }
+            else {
+                return value;
+            }
         }
         // Use inspect for everything else
         return (0, node_util_1.inspect)(value, {
             compact: true,
-            depth: 10,
-            maxArrayLength: 100,
-            maxStringLength: 10000,
+            breakLength: 80,
+            depth: constants_1.MAX_LOG_DEPTH,
+            maxArrayLength: constants_1.MAX_LOG_ARRAY_LENGTH,
+            maxStringLength: constants_1.MAX_LOG_STRING_LENGTH,
         });
     }
-    logFn(args, level) {
+    logFn(args, level, skipSanitization = false) {
         var _a;
-        // Worker thread sends the log to the main thread to log it
-        if (!node_worker_threads_1.isMainThread && node_worker_threads_1.parentPort) {
-            const sanitizedArgs = args.map((arg) => this.valueToString(arg));
-            node_worker_threads_1.parentPort.postMessage({
-                subject: workers_1.WorkerMessageSubject.WorkerMessageLog,
-                payload: { args: sanitizedArgs, level },
-            });
-            return;
-        }
-        // Main thread logs the log normally
+        const message = skipSanitization
+            ? args.join(' ')
+            : args.map((arg) => this.valueToString(arg)).join(' ');
+        // If local development, log the message to the console and don't add the tags
         if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.isLocalDevelopment) {
-            this.originalConsole[level](...args);
+            this.originalConsole[level](message);
+            return;
         }
-        else {
-            const message = args.map((arg) => this.valueToString(arg)).join(' ');
+        if (node_worker_threads_1.isMainThread) {
+            // If main thread, log the message to the console and add the tags
             const logObject = Object.assign({ message }, this.tags);
             this.originalConsole[level](JSON.stringify(logObject));
         }
+        else {
+            // If worker thread, send the message to the main thread to log it
+            const sanitizedArgs = args.map((arg) => this.valueToString(arg));
+            node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage({
+                subject: workers_1.WorkerMessageSubject.WorkerMessageLog,
+                payload: { args: sanitizedArgs, level },
+            });
+        }
     }
     log(...args) {
         this.logFn(args, logger_interfaces_1.LogLevel.INFO);

package/dist/logger/logger.test.js

@@ -9,7 +9,6 @@ const logger_1 = require("./logger");
 const mockConsoleInfo = jest.spyOn(console, 'info').mockImplementation();
 const mockConsoleWarn = jest.spyOn(console, 'warn').mockImplementation();
 const mockConsoleError = jest.spyOn(console, 'error').mockImplementation();
-/* eslint-disable @typescript-eslint/no-require-imports */
 // Mock worker_threads
 jest.mock('node:worker_threads', () => ({
     isMainThread: true,
@@ -46,207 +45,430 @@ describe(logger_1.Logger.name, () => {
     afterAll(() => {
         jest.restoreAllMocks();
     });
-    describe('constructor', () => {
-        it('should initialize logger with event context and sdk_version', () => {
-            const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
-            // Access private property for testing
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const tags = logger.tags;
-            expect(tags).toEqual(Object.assign(Object.assign({}, mockEvent.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION }));
-        });
+    it('should initialize with event context and SDK version in tags', () => {
+        // Arrange & Act
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Assert
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const tags = logger.tags;
+        expect(tags).toEqual(Object.assign(Object.assign({}, mockEvent.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION }));
     });
-    describe('production logging', () => {
-        let logger;
-        beforeEach(() => {
-            mockOptions.isLocalDevelopment = false;
-            logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
-        });
-        it('should log single string message without backslashes', () => {
-            const message = 'Worker is online. Started processing the task.';
-            logger.info(message);
-            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message }, mockEvent.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION })));
-        });
-        it('should log single object message with JSON stringify', () => {
-            const data = { id: 123, name: 'test' };
-            logger.info(data);
-            const expectedMessage = (0, node_util_1.inspect)(data, {
-                compact: true,
-                breakLength: Infinity,
-                depth: 10,
-                maxArrayLength: 100,
-                maxStringLength: 10000,
-            });
-            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: expectedMessage }, mockEvent.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION })));
-        });
-        it('should log multiple arguments joined with space', () => {
-            const text = 'Successfully fetched';
-            const data = { count: 42 };
-            logger.info(text, data);
-            const expectedDataMessage = (0, node_util_1.inspect)(data, {
-                compact: true,
-                breakLength: Infinity,
-                depth: 10,
-                maxArrayLength: 100,
-                maxStringLength: 10000,
-            });
-            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: `${text} ${expectedDataMessage}` }, mockEvent.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION })));
-        });
-        it('should handle mixed string and object arguments', () => {
-            const text1 = 'Processing';
-            const data = { id: 123 };
-            const text2 = 'completed';
-            logger.info(text1, data, text2);
-            const expectedDataMessage = (0, node_util_1.inspect)(data, {
-                compact: true,
-                breakLength: Infinity,
-                depth: 10,
-                maxArrayLength: 100,
-                maxStringLength: 10000,
-            });
-            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: `${text1} ${expectedDataMessage} ${text2}` }, mockEvent.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION })));
-        });
+    it('should log string message as JSON with event context tags in production mode', () => {
+        // Arrange
+        const message = 'Worker is online. Started processing the task.';
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.info(message);
+        // Assert
+        expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message }, mockEvent.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION })));
     });
-    describe('local development logging', () => {
-        let logger;
-        beforeEach(() => {
-            mockOptions.isLocalDevelopment = true;
-            logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
-        });
-        it('should use regular console methods in local development', () => {
-            const message = 'Test message';
-            const data = { test: true };
-            logger.info(message, data);
-            expect(mockConsoleInfo).toHaveBeenCalledWith(message, data);
+    it('should log object message using inspect with proper formatting in production mode', () => {
+        // Arrange
+        const data = { id: 123, name: 'test' };
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedMessage = (0, node_util_1.inspect)(data, {
+            compact: true,
+            depth: 10,
+            maxArrayLength: 100,
+            maxStringLength: 10000,
         });
+        // Act
+        logger.info(data);
+        // Assert
+        expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: expectedMessage }, mockEvent.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION })));
     });
-    describe('log levels', () => {
-        let logger;
-        beforeEach(() => {
-            mockOptions.isLocalDevelopment = false;
-            logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
-        });
-        it('should call console.info for info level', () => {
-            logger.info('test message');
-            expect(mockConsoleInfo).toHaveBeenCalled();
-        });
-        it('should call console.warn for warn level', () => {
-            logger.warn('test warning');
-            expect(mockConsoleWarn).toHaveBeenCalled();
-        });
-        it('should call console.error for error level', () => {
-            logger.error('test error');
-            expect(mockConsoleError).toHaveBeenCalled();
-        });
-        it('should call console.info for log level', () => {
-            logger.log('test log');
-            expect(mockConsoleInfo).toHaveBeenCalled();
+    it('should join multiple arguments with space when logging in production mode', () => {
+        // Arrange
+        const text = 'Successfully fetched';
+        const data = { count: 42 };
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedDataMessage = (0, node_util_1.inspect)(data, {
+            compact: true,
+            depth: 10,
+            maxArrayLength: 100,
+            maxStringLength: 10000,
         });
+        // Act
+        logger.info(text, data);
+        // Assert
+        expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: `${text} ${expectedDataMessage}` }, mockEvent.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION })));
     });
-    describe('edge cases', () => {
-        let logger;
-        beforeEach(() => {
-            mockOptions.isLocalDevelopment = false;
-            logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+    it('should log mixed string and object arguments joined with spaces in production mode', () => {
+        // Arrange
+        const text1 = 'Processing';
+        const data = { id: 123 };
+        const text2 = 'completed';
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedDataMessage = (0, node_util_1.inspect)(data, {
+            compact: true,
+            depth: 10,
+            maxArrayLength: 100,
+            maxStringLength: 10000,
         });
-        it('[edge] should handle empty string message', () => {
-            logger.info('');
-            expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
-            const callArgs = mockConsoleInfo.mock.calls[0][0];
-            const logObject = JSON.parse(callArgs);
-            // Empty string is returned as-is
-            expect(logObject.message).toBe('');
-            expect(logObject.sdk_version).toBe(constants_1.LIBRARY_VERSION);
-            expect(logObject.request_id).toBe(mockEvent.payload.event_context.request_id);
+        // Act
+        logger.info(text1, data, text2);
+        // Assert
+        expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: `${text1} ${expectedDataMessage} ${text2}` }, mockEvent.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION })));
+    });
+    it('should log directly without JSON wrapping in local development mode', () => {
+        // Arrange
+        const message = 'Test message';
+        const data = { test: true };
+        mockOptions.isLocalDevelopment = true;
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedDataMessage = (0, node_util_1.inspect)(data, {
+            compact: true,
+            depth: 10,
+            maxArrayLength: 100,
+            maxStringLength: 10000,
         });
-        it('[edge] should handle null and undefined values', () => {
-            logger.info('test', null, undefined);
-            expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
-            const callArgs = mockConsoleInfo.mock.calls[0][0];
-            const logObject = JSON.parse(callArgs);
-            // Strings returned as-is, null/undefined shown via inspect
-            expect(logObject.message).toBe('test null undefined');
-            expect(logObject.sdk_version).toBe(constants_1.LIBRARY_VERSION);
+        // Act
+        logger.info(message, data);
+        // Assert
+        expect(mockConsoleInfo).toHaveBeenCalledWith(`${message} ${expectedDataMessage}`);
+    });
+    it('should truncate long strings and show remaining character count', () => {
+        // Arrange
+        const longString = 'C'.repeat(20000);
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedTruncatedMessage = `${longString.substring(0, constants_1.MAX_LOG_STRING_LENGTH)}... ${20000 - constants_1.MAX_LOG_STRING_LENGTH} more characters`;
+        // Act
+        logger.info(longString);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe(expectedTruncatedMessage);
+    });
+    it('should not truncate strings shorter than maximum length', () => {
+        // Arrange
+        const shortString = 'Short message';
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.info(shortString);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe(shortString);
+    });
+    it('should skip sanitization when skipSanitization flag is true', () => {
+        // Arrange
+        const alreadySanitizedArgs = ['Sanitized message 1', 'Sanitized message 2'];
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        logger.logFn(alreadySanitizedArgs, 'info', true);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe('Sanitized message 1 Sanitized message 2');
+    });
+    it('should apply sanitization when skipSanitization flag is false', () => {
+        // Arrange
+        const data = { id: 123 };
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedMessage = (0, node_util_1.inspect)(data, {
+            compact: true,
+            depth: 10,
+            maxArrayLength: 100,
+            maxStringLength: 10000,
         });
-        it('[edge] should handle complex nested objects', () => {
-            const complexObject = {
-                level1: {
-                    level2: {
-                        array: [1, 2, 3],
-                        string: 'nested',
-                    },
+        // Act
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        logger.logFn([data], 'info', false);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe(expectedMessage);
+    });
+    it('should call info method for log level', () => {
+        // Arrange
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.log('test log');
+        // Assert
+        expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
+    });
+    it('should call info method for info level', () => {
+        // Arrange
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.info('test info');
+        // Assert
+        expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
+    });
+    it('should call warn method for warn level', () => {
+        // Arrange
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.warn('test warning');
+        // Assert
+        expect(mockConsoleWarn).toHaveBeenCalledTimes(1);
+    });
+    it('should call error method for error level', () => {
+        // Arrange
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.error('test error');
+        // Assert
+        expect(mockConsoleError).toHaveBeenCalledTimes(1);
+    });
+    it('[edge] should handle empty string as valid log message', () => {
+        // Arrange
+        const emptyString = '';
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.info(emptyString);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe('');
+        expect(logObject.sdk_version).toBe(constants_1.LIBRARY_VERSION);
+    });
+    it('[edge] should handle null and undefined values in log arguments', () => {
+        // Arrange
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.info('test', null, undefined);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe('test null undefined');
+    });
+    it('[edge] should handle deeply nested objects with inspect', () => {
+        // Arrange
+        const complexObject = {
+            level1: {
+                level2: {
+                    array: [1, 2, 3],
+                    string: 'nested',
                 },
-            };
-            logger.info(complexObject);
-            expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
-            const callArgs = mockConsoleInfo.mock.calls[0][0];
-            const logObject = JSON.parse(callArgs);
-            // The logger uses inspect() with compact: true settings
-            const expectedMessage = require('util').inspect(complexObject, {
-                compact: true,
-                breakLength: Infinity,
-                depth: 10,
-                maxArrayLength: 100,
-                maxStringLength: 10000,
-            });
-            expect(logObject.message).toBe(expectedMessage);
-            expect(logObject.sdk_version).toBe(constants_1.LIBRARY_VERSION);
-            expect(typeof logObject.callback_url).toBe('string');
+            },
+        };
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedMessage = (0, node_util_1.inspect)(complexObject, {
+            compact: true,
+            depth: 10,
+            maxArrayLength: 100,
+            maxStringLength: 10000,
         });
+        // Act
+        logger.info(complexObject);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe(expectedMessage);
+    });
+    it('[edge] should handle circular references in objects', () => {
+        // Arrange
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const circularObject = { name: 'test' };
+        circularObject.self = circularObject;
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act & Assert
+        expect(() => logger.info(circularObject)).not.toThrow();
+        expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
     });
 });
-it('getPrintableState should return printable state', () => {
-    const state = {
-        test_key: 'test_value',
-        big_array: Array.from({ length: 1000 }, (_, index) => index),
-        nested_object: {
-            nested_key: 'nested_value',
-            nested_array: Array.from({ length: 1000 }, (_, index) => index),
-        },
-    };
-    const printableState = (0, logger_1.getPrintableState)(state);
-    expect(printableState).toEqual({
-        test_key: 'test_value',
-        big_array: {
-            type: 'array',
-            length: 1000,
-            firstItem: 0,
-            lastItem: 999,
-        },
-        nested_object: {
-            nested_key: 'nested_value',
-            nested_array: {
+describe(logger_1.getPrintableState.name, () => {
+    it('should convert arrays to summary objects with type, length, and boundary items', () => {
+        // Arrange
+        const state = {
+            test_key: 'test_value',
+            big_array: Array.from({ length: 1000 }, (_, index) => index),
+        };
+        // Act
+        const printableState = (0, logger_1.getPrintableState)(state);
+        // Assert
+        expect(printableState).toEqual({
+            test_key: 'test_value',
+            big_array: {
                 type: 'array',
                 length: 1000,
                 firstItem: 0,
                 lastItem: 999,
             },
-        },
+        });
+    });
+    it('should recursively process nested objects and arrays', () => {
+        // Arrange
+        const state = {
+            test_key: 'test_value',
+            nested_object: {
+                nested_key: 'nested_value',
+                nested_array: Array.from({ length: 1000 }, (_, index) => index),
+            },
+        };
+        // Act
+        const printableState = (0, logger_1.getPrintableState)(state);
+        // Assert
+        expect(printableState).toEqual({
+            test_key: 'test_value',
+            nested_object: {
+                nested_key: 'nested_value',
+                nested_array: {
+                    type: 'array',
+                    length: 1000,
+                    firstItem: 0,
+                    lastItem: 999,
+                },
+            },
+        });
+    });
+    it('should preserve primitive values without modification', () => {
+        // Arrange
+        const state = {
+            string_key: 'string_value',
+            number_key: 42,
+            boolean_key: true,
+            null_key: null,
+        };
+        // Act
+        const printableState = (0, logger_1.getPrintableState)(state);
+        // Assert
+        expect(printableState).toEqual(state);
+    });
+    it('[edge] should handle empty arrays with no first or last items', () => {
+        // Arrange
+        const state = {
+            empty_array: [],
+        };
+        // Act
+        const printableState = (0, logger_1.getPrintableState)(state);
+        // Assert
+        expect(printableState).toEqual({
+            empty_array: {
+                type: 'array',
+                length: 0,
+                firstItem: undefined,
+                lastItem: undefined,
+            },
+        });
+    });
+    it('[edge] should handle single-item arrays with same first and last item', () => {
+        // Arrange
+        const state = {
+            single_item_array: [42],
+        };
+        // Act
+        const printableState = (0, logger_1.getPrintableState)(state);
+        // Assert
+        expect(printableState).toEqual({
+            single_item_array: {
+                type: 'array',
+                length: 1,
+                firstItem: 42,
+                lastItem: undefined,
+            },
+        });
     });
 });
-it('serializeAxiosError should return formatted error', () => {
-    const error = {
-        response: {
-            status: 500,
-            data: 'Internal server error',
-        },
-        config: {
-            method: 'GET',
-        },
-    };
-    const formattedError = (0, logger_1.serializeAxiosError)(error);
-    expect(formattedError).toEqual({
-        config: {
-            method: 'GET',
-            params: undefined,
-            url: undefined,
-        },
-        isAxiosError: true,
-        isCorsOrNoNetworkError: false,
-        response: {
-            data: 'Internal server error',
-            headers: undefined,
-            status: 500,
-            statusText: undefined,
-        },
+describe(logger_1.serializeAxiosError.name, () => {
+    it('should serialize Axios error with response data', () => {
+        // Arrange
+        const error = {
+            response: {
+                status: 500,
+                statusText: 'Internal Server Error',
+                data: 'Internal server error',
+                headers: { 'content-type': 'application/json' },
+            },
+            config: {
+                method: 'GET',
+                url: '/api/test',
+                params: { id: 123 },
+            },
+        };
+        // Act
+        const formattedError = (0, logger_1.serializeAxiosError)(error);
+        // Assert
+        expect(formattedError).toEqual({
+            config: {
+                method: 'GET',
+                params: { id: 123 },
+                url: '/api/test',
+            },
+            isAxiosError: true,
+            isCorsOrNoNetworkError: false,
+            response: {
+                data: 'Internal server error',
+                headers: { 'content-type': 'application/json' },
+                status: 500,
+                statusText: 'Internal Server Error',
+            },
+        });
+    });
+    it('should serialize Axios error without response as CORS or network error', () => {
+        // Arrange
+        const error = {
+            code: 'ERR_NETWORK',
+            message: 'Network Error',
+            config: {
+                method: 'POST',
+                url: '/api/create',
+            },
+        };
+        // Act
+        const formattedError = (0, logger_1.serializeAxiosError)(error);
+        // Assert
+        expect(formattedError).toEqual({
+            config: {
+                method: 'POST',
+                params: undefined,
+                url: '/api/create',
+            },
+            isAxiosError: true,
+            isCorsOrNoNetworkError: true,
+            code: 'ERR_NETWORK',
+            message: 'Network Error',
+        });
+    });
+    it('[edge] should handle Axios error with minimal config information', () => {
+        // Arrange
+        const error = {
+            response: {
+                status: 404,
+                data: 'Not Found',
+            },
+            config: {},
+        };
+        // Act
+        const formattedError = (0, logger_1.serializeAxiosError)(error);
+        // Assert
+        expect(formattedError).toEqual({
+            config: {
+                method: undefined,
+                params: undefined,
+                url: undefined,
+            },
+            isAxiosError: true,
+            isCorsOrNoNetworkError: false,
+            response: {
+                data: 'Not Found',
+                headers: undefined,
+                status: 404,
+                statusText: undefined,
+            },
+        });
+    });
+    it('[edge] should handle Axios error with no config', () => {
+        // Arrange
+        const error = {
+            code: 'ERR_TIMEOUT',
+            message: 'Request timeout',
+        };
+        // Act
+        const formattedError = (0, logger_1.serializeAxiosError)(error);
+        // Assert
+        expect(formattedError).toEqual({
+            config: {
+                method: undefined,
+                params: undefined,
+                url: undefined,
+            },
+            isAxiosError: true,
+            isCorsOrNoNetworkError: true,
+            code: 'ERR_TIMEOUT',
+            message: 'Request timeout',
+        });
     });
 });

package/dist/workers/spawn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../src/workers/spawn.ts"],"names":[],"mappings":"AAWA,OAAO,EAEL,qBAAqB,EACrB,cAAc,EAGf,MAAM,kBAAkB,CAAC;AA4D1B;;;;;;;;;;GAUG;AACH,wBAAsB,KAAK,CAAC,cAAc,EAAE,EAC1C,KAAK,EACL,YAAY,EACZ,UAAU,EACV,oBAAoB,EACpB,OAAO,GACR,EAAE,qBAAqB,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAyEvD;AAED,qBAAa,KAAK;IAChB,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,cAAc,CAAU;IAChC,OAAO,CAAC,oBAAoB,CAAkC;IAC9D,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,wBAAwB,CAA6C;IAC7E,OAAO,CAAC,OAAO,CAA4C;IAC3D,OAAO,CAAC,eAAe,CAAU;gBACrB,EACV,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,eAAe,GAChB,EAAE,cAAc;IA8FjB,OAAO,CAAC,aAAa;YAYP,kBAAkB;CAiCjC"}
+{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../src/workers/spawn.ts"],"names":[],"mappings":"AAWA,OAAO,EAEL,qBAAqB,EACrB,cAAc,EAGf,MAAM,kBAAkB,CAAC;AA4D1B;;;;;;;;;;GAUG;AACH,wBAAsB,KAAK,CAAC,cAAc,EAAE,EAC1C,KAAK,EACL,YAAY,EACZ,UAAU,EACV,oBAAoB,EACpB,OAAO,GACR,EAAE,qBAAqB,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAyEvD;AAED,qBAAa,KAAK;IAChB,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,cAAc,CAAU;IAChC,OAAO,CAAC,oBAAoB,CAAkC;IAC9D,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,wBAAwB,CAA6C;IAC7E,OAAO,CAAC,OAAO,CAA4C;IAC3D,OAAO,CAAC,eAAe,CAAU;gBACrB,EACV,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,eAAe,GAChB,EAAE,cAAc;IA+FjB,OAAO,CAAC,aAAa;YAYP,kBAAkB;CAiCjC"}

package/dist/workers/spawn.js

@@ -186,7 +186,8 @@ class Spawn {
             if ((message === null || message === void 0 ? void 0 : message.subject) === workers_1.WorkerMessageSubject.WorkerMessageLog) {
                 const args = (_a = message.payload) === null || _a === void 0 ? void 0 : _a.args;
                 const level = (_b = message.payload) === null || _b === void 0 ? void 0 : _b.level;
-                console.logFn(args, level);
+                // Args are already sanitized in the worker thread, skip double sanitization
+                console.logFn(args, level, true);
             }
             // If worker sends a message that it has emitted an event, then set alreadyEmitted to true.
             if ((message === null || message === void 0 ? void 0 : message.subject) === workers_1.WorkerMessageSubject.WorkerMessageEmitted) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devrev/ts-adaas",
-  "version": "1.11.1-beta.24",
+  "version": "1.11.1-beta.25",
   "description": "Typescript library containing the ADaaS(AirDrop as a Service) control protocol.",
   "type": "commonjs",
   "main": "./dist/index.js",