@devrev/ts-adaas 1.11.1-beta.8 → 1.12.0

package/dist/common/install-initial-domain-mapping.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"install-initial-domain-mapping.d.ts","sourceRoot":"","sources":["../../src/common/install-initial-domain-mapping.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEvD,wBAAsB,2BAA2B,CAC/C,KAAK,EAAE,YAAY,EACnB,wBAAwB,EAAE,oBAAoB,GAC7C,OAAO,CAAC,IAAI,CAAC,CA2Ff"}
+{"version":3,"file":"install-initial-domain-mapping.d.ts","sourceRoot":"","sources":["../../src/common/install-initial-domain-mapping.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEvD,wBAAsB,2BAA2B,CAC/C,KAAK,EAAE,YAAY,EACnB,wBAAwB,EAAE,oBAAoB,GAC7C,OAAO,CAAC,IAAI,CAAC,CA0Ff"}

package/dist/common/install-initial-domain-mapping.js

@@ -54,5 +54,5 @@ async function installInitialDomainMapping(event, initialDomainMappingJson) {
             Authorization: devrevToken,
         },
     });
-    console.log(`Successfully installed initial domain mapping ${JSON.stringify(initialDomainMappingInstallResponse.data)}`);
+    console.log('Successfully installed initial domain mapping', initialDomainMappingInstallResponse.data);
 }

package/dist/logger/logger.constants.d.ts

@@ -0,0 +1,6 @@
+import { InspectOptions } from 'node:util';
+export declare const MAX_LOG_STRING_LENGTH = 10000;
+export declare const MAX_LOG_DEPTH = 10;
+export declare const MAX_LOG_ARRAY_LENGTH = 100;
+export declare const INSPECT_OPTIONS: InspectOptions;
+//# sourceMappingURL=logger.constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger.constants.d.ts","sourceRoot":"","sources":["../../src/logger/logger.constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAE3C,eAAO,MAAM,qBAAqB,QAAQ,CAAC;AAC3C,eAAO,MAAM,aAAa,KAAK,CAAC;AAChC,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAExC,eAAO,MAAM,eAAe,EAAE,cAM7B,CAAC"}

package/dist/logger/logger.constants.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INSPECT_OPTIONS = exports.MAX_LOG_ARRAY_LENGTH = exports.MAX_LOG_DEPTH = exports.MAX_LOG_STRING_LENGTH = void 0;
+exports.MAX_LOG_STRING_LENGTH = 10000;
+exports.MAX_LOG_DEPTH = 10;
+exports.MAX_LOG_ARRAY_LENGTH = 100;
+exports.INSPECT_OPTIONS = {
+    compact: false,
+    breakLength: Infinity,
+    depth: exports.MAX_LOG_DEPTH,
+    maxArrayLength: exports.MAX_LOG_ARRAY_LENGTH,
+    maxStringLength: exports.MAX_LOG_STRING_LENGTH,
+};

package/dist/logger/logger.d.ts

@@ -1,23 +1,88 @@
-import { Console } from 'node:console';
 import { AxiosError } from 'axios';
+import { Console } from 'node:console';
 import { AxiosErrorResponse, LoggerFactoryInterface, LogLevel, PrintableState } from './logger.interfaces';
+/**
+ * Custom logger that extends Node.js Console with context-aware logging.
+ * Handles local development, main thread, and worker thread logging differently.
+ */
 export declare class Logger extends Console {
     private originalConsole;
     private options?;
     private tags;
     constructor({ event, options }: LoggerFactoryInterface);
+    /**
+     * Converts any value to a string using `util.inspect()` for complex types.
+     *
+     * @param value - The value to convert
+     * @returns String representation of the value
+     */
     private valueToString;
-    logFn(args: unknown[], level: LogLevel): void;
+    /**
+     * Truncates a message if it exceeds the maximum allowed length.
+     * Adds a suffix indicating how many characters were omitted.
+     *
+     * @param message - The message to truncate
+     * @returns Truncated message or original if within limits
+     */
+    private truncateMessage;
+    /**
+     * Logs a pre-formatted message string to the console.
+     * In production mode, wraps the message with JSON formatting and event context tags.
+     * In local development mode, logs the message directly without JSON wrapping.
+     * This is useful when you need to log already-stringified content.
+     *
+     * @param message - The pre-formatted message string to log
+     * @param level - Log level (info, warn, error)
+     */
+    logFn(message: string, level: LogLevel): void;
+    /**
+     * Stringifies and logs arguments to the appropriate destination.
+     * On main thread, converts arguments to strings and calls logFn.
+     * In worker threads, forwards stringified arguments to the main thread for processing.
+     * All arguments are converted to strings using util.inspect and joined with spaces.
+     *
+     * @param args - Values to log (will be stringified and truncated if needed)
+     * @param level - Log level (info, warn, error)
+     */
+    private stringifyAndLog;
     log(...args: unknown[]): void;
     info(...args: unknown[]): void;
     warn(...args: unknown[]): void;
     error(...args: unknown[]): void;
 }
+/**
+ * Converts a state object into a printable format where arrays are summarized.
+ * Arrays show their length, first item, and last item instead of all elements.
+ * Objects are recursively processed and primitives are returned as-is.
+ *
+ * @param state - State object to convert
+ * @returns Printable representation with summarized arrays
+ */
 export declare function getPrintableState(state: Record<string, any>): PrintableState;
 /**
- * @deprecated
+ * Serializes an error into a structured format.
+ * Automatically detects and formats Axios errors with HTTP details.
+ * Returns other error types as-is.
+ *
+ * @param error - Error to serialize
+ * @returns Serialized error or original if not an Axios error
+ */
+export declare function serializeError(error: unknown): unknown;
+/**
+ * Serializes an Axios error into a structured format with HTTP request/response details.
+ * Extracts method, URL, parameters, status code, headers, and data.
+ * Includes CORS/network failure indicator when no response is available.
+ *
+ * @param error - Axios error to serialize
+ * @returns Structured object with error details
  */
-export declare function formatAxiosError(error: AxiosError): object;
-export declare const serializeError: (error: unknown) => unknown;
 export declare function serializeAxiosError(error: AxiosError): AxiosErrorResponse;
+/**
+ * Formats an Axios error to a printable format.
+ *
+ * @param error - Axios error to format
+ * @returns Formatted error object
+ * @deprecated Use {@link serializeAxiosError} instead
+ */
+export declare function formatAxiosError(error: AxiosError): object;
 //# sourceMappingURL=logger.d.ts.map

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;AAGvC,OAAO,EAAE,UAAU,EAAyC,MAAM,OAAO,CAAC;AAG1E,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,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,CAAqC;gBAErC,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,sBAAsB;IAUtD,OAAO,CAAC,aAAa;IAerB,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI;IAepC,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,UAAU,EAAyC,MAAM,OAAO,CAAC;AAE1E,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAQvC,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EAEtB,QAAQ,EAER,cAAc,EACf,MAAM,qBAAqB,CAAC;AAE7B;;;GAGG;AACH,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;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAOrB;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IASvB;;;;;;;;OAQG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI;IAa7C;;;;;;;;OAQG;IACH,OAAO,CAAC,eAAe;IAcd,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;AAED;;;;;;;GAOG;AAEH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,cAAc,CAqB5E;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAKtD;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,kBAAkB,CAwBzE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAE1D"}

package/dist/logger/logger.interfaces.d.ts

@@ -1,5 +1,5 @@
 import { RawAxiosResponseHeaders } from 'axios';
-import { AirdropEvent } from '../types/extraction';
+import { AirdropEvent, EventContext } from '../types/extraction';
 import { WorkerAdapterOptions } from '../types/workers';
 export interface LoggerFactoryInterface {
     event: AirdropEvent;
@@ -36,4 +36,7 @@ export interface AxiosErrorResponse {
     code?: string;
     message?: string;
 }
+export interface LoggerTags extends EventContext {
+    sdk_version: string;
+}
 //# sourceMappingURL=logger.interfaces.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"logger.interfaces.d.ts","sourceRoot":"","sources":["../../src/logger/logger.interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,OAAO,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,YAAY,CAAC;IACpB,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC;AAED,oBAAY,QAAQ;IAClB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,KAAK,UAAU;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IAEf,SAAS,CAAC,EAAE,GAAG,CAAC;IAEhB,QAAQ,CAAC,EAAE,GAAG,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAE7B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,cAAc,GAAG,cAAc,CAAC;CACtD;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE;QACN,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;QAE3B,MAAM,EAAE,GAAG,CAAC;QACZ,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;KACzB,CAAC;IACF,YAAY,EAAE,OAAO,CAAC;IACtB,sBAAsB,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,EAAE;QACT,IAAI,EAAE,OAAO,CAAC;QACd,OAAO,EAAE,uBAAuB,CAAC;QACjC,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB"}
+{"version":3,"file":"logger.interfaces.d.ts","sourceRoot":"","sources":["../../src/logger/logger.interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,OAAO,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,YAAY,CAAC;IACpB,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC;AAED,oBAAY,QAAQ;IAClB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,KAAK,UAAU;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IAEf,SAAS,CAAC,EAAE,GAAG,CAAC;IAEhB,QAAQ,CAAC,EAAE,GAAG,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAE7B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,cAAc,GAAG,cAAc,CAAC;CACtD;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE;QACN,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;QAE3B,MAAM,EAAE,GAAG,CAAC;QACZ,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;KACzB,CAAC;IACF,YAAY,EAAE,OAAO,CAAC;IACtB,sBAAsB,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,EAAE;QACT,IAAI,EAAE,OAAO,CAAC;QACd,OAAO,EAAE,uBAAuB,CAAC;QACjC,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,UAAW,SAAQ,YAAY;IAC9C,WAAW,EAAE,MAAM,CAAC;CACrB"}

package/dist/logger/logger.js

@@ -1,65 +1,121 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeError = exports.Logger = void 0;
+exports.Logger = void 0;
 exports.getPrintableState = getPrintableState;
-exports.formatAxiosError = formatAxiosError;
+exports.serializeError = serializeError;
 exports.serializeAxiosError = serializeAxiosError;
+exports.formatAxiosError = formatAxiosError;
+const axios_1 = require("axios");
 const node_console_1 = require("node:console");
 const node_util_1 = require("node:util");
-const axios_1 = require("axios");
+const node_worker_threads_1 = require("node:worker_threads");
+const constants_1 = require("../common/constants");
+const workers_1 = require("../types/workers");
+const logger_constants_1 = require("./logger.constants");
 const logger_interfaces_1 = require("./logger.interfaces");
+/**
+ * Custom logger that extends Node.js Console with context-aware logging.
+ * Handles local development, main thread, and worker thread logging differently.
+ */
 class Logger extends node_console_1.Console {
     constructor({ event, options }) {
         super(process.stdout, process.stderr);
         this.originalConsole = console;
         this.options = options;
-        this.tags = Object.assign(Object.assign({}, event.payload.event_context), { dev_oid: event.payload.event_context.dev_oid });
+        this.tags = Object.assign(Object.assign({}, event.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION });
     }
+    /**
+     * Converts any value to a string using `util.inspect()` for complex types.
+     *
+     * @param value - The value to convert
+     * @returns String representation of the value
+     */
     valueToString(value) {
         if (typeof value === 'string') {
             return value;
         }
-        // Use Node.js built-in inspect for everything including errors
-        return (0, node_util_1.inspect)(value, {
-            compact: true,
-            depth: Infinity,
-            maxArrayLength: Infinity,
-            maxStringLength: Infinity,
-            breakLength: Infinity,
-        });
+        return (0, node_util_1.inspect)(value, logger_constants_1.INSPECT_OPTIONS);
     }
-    logFn(args, level) {
+    /**
+     * Truncates a message if it exceeds the maximum allowed length.
+     * Adds a suffix indicating how many characters were omitted.
+     *
+     * @param message - The message to truncate
+     * @returns Truncated message or original if within limits
+     */
+    truncateMessage(message) {
+        if (message.length > logger_constants_1.MAX_LOG_STRING_LENGTH) {
+            return `${message.substring(0, logger_constants_1.MAX_LOG_STRING_LENGTH)}... ${message.length - logger_constants_1.MAX_LOG_STRING_LENGTH} more characters`;
+        }
+        return message;
+    }
+    /**
+     * Logs a pre-formatted message string to the console.
+     * In production mode, wraps the message with JSON formatting and event context tags.
+     * In local development mode, logs the message directly without JSON wrapping.
+     * This is useful when you need to log already-stringified content.
+     *
+     * @param message - The pre-formatted message string to log
+     * @param level - Log level (info, warn, error)
+     */
+    logFn(message, level) {
         var _a;
         if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.isLocalDevelopment) {
-            this.originalConsole[level](...args);
+            this.originalConsole[level](message);
+            return;
+        }
+        const logObject = Object.assign({ message }, this.tags);
+        this.originalConsole[level](JSON.stringify(logObject));
+    }
+    /**
+     * Stringifies and logs arguments to the appropriate destination.
+     * On main thread, converts arguments to strings and calls logFn.
+     * In worker threads, forwards stringified arguments to the main thread for processing.
+     * All arguments are converted to strings using util.inspect and joined with spaces.
+     *
+     * @param args - Values to log (will be stringified and truncated if needed)
+     * @param level - Log level (info, warn, error)
+     */
+    stringifyAndLog(args, level) {
+        let stringifiedArgs = args.map((arg) => this.valueToString(arg)).join(' ');
+        stringifiedArgs = this.truncateMessage(stringifiedArgs);
+        if (node_worker_threads_1.isMainThread) {
+            this.logFn(stringifiedArgs, level);
         }
         else {
-            const message = args.map((arg) => this.valueToString(arg)).join(' ');
-            const logObject = Object.assign({ message }, this.tags);
-            this.originalConsole[level](JSON.stringify(logObject));
+            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: { stringifiedArgs, level },
+            });
         }
     }
     log(...args) {
-        this.logFn(args, logger_interfaces_1.LogLevel.INFO);
+        this.stringifyAndLog(args, logger_interfaces_1.LogLevel.INFO);
     }
     info(...args) {
-        this.logFn(args, logger_interfaces_1.LogLevel.INFO);
+        this.stringifyAndLog(args, logger_interfaces_1.LogLevel.INFO);
     }
     warn(...args) {
-        this.logFn(args, logger_interfaces_1.LogLevel.WARN);
+        this.stringifyAndLog(args, logger_interfaces_1.LogLevel.WARN);
     }
     error(...args) {
-        this.logFn(args, logger_interfaces_1.LogLevel.ERROR);
+        this.stringifyAndLog(args, logger_interfaces_1.LogLevel.ERROR);
     }
 }
 exports.Logger = Logger;
-// Helper function to process each value in the state
+/**
+ * Converts a state object into a printable format where arrays are summarized.
+ * Arrays show their length, first item, and last item instead of all elements.
+ * Objects are recursively processed and primitives are returned as-is.
+ *
+ * @param state - State object to convert
+ * @returns Printable representation with summarized arrays
+ */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function getPrintableState(state) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     function processValue(value) {
         if (Array.isArray(value)) {
-            // If the value is an array, summarize it
             return {
                 type: 'array',
                 length: value.length,
@@ -68,32 +124,38 @@ function getPrintableState(state) {
             };
         }
         else if (typeof value === 'object' && value !== null) {
-            // If the value is an object, recursively process its properties
             const processedObject = {};
             for (const key in value) {
                 processedObject[key] = processValue(value[key]);
             }
             return processedObject;
         }
-        // For primitive types, return the value as is
         return value;
     }
-    // Process the state object directly since it's guaranteed to be an object
     return processValue(state);
 }
 /**
- * @deprecated
+ * Serializes an error into a structured format.
+ * Automatically detects and formats Axios errors with HTTP details.
+ * Returns other error types as-is.
+ *
+ * @param error - Error to serialize
+ * @returns Serialized error or original if not an Axios error
  */
-function formatAxiosError(error) {
-    return serializeAxiosError(error);
-}
-const serializeError = (error) => {
+function serializeError(error) {
     if ((0, axios_1.isAxiosError)(error)) {
         return serializeAxiosError(error);
     }
     return error;
-};
-exports.serializeError = serializeError;
+}
+/**
+ * Serializes an Axios error into a structured format with HTTP request/response details.
+ * Extracts method, URL, parameters, status code, headers, and data.
+ * Includes CORS/network failure indicator when no response is available.
+ *
+ * @param error - Axios error to serialize
+ * @returns Structured object with error details
+ */
 function serializeAxiosError(error) {
     var _a, _b, _c;
     const serializedAxiosError = {
@@ -119,3 +181,13 @@ function serializeAxiosError(error) {
     }
     return serializedAxiosError;
 }
+/**
+ * Formats an Axios error to a printable format.
+ *
+ * @param error - Axios error to format
+ * @returns Formatted error object
+ * @deprecated Use {@link serializeAxiosError} instead
+ */
+function formatAxiosError(error) {
+    return serializeAxiosError(error);
+}

package/dist/logger/logger.test.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_util_1 = require("node:util");
+const constants_1 = require("../common/constants");
 const test_helpers_1 = require("../tests/test-helpers");
 const extraction_1 = require("../types/extraction");
 const logger_1 = require("./logger");
+const logger_constants_1 = require("./logger.constants");
 // Mock console methods
 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,
@@ -45,210 +46,444 @@ describe(logger_1.Logger.name, () => {
     afterAll(() => {
         jest.restoreAllMocks();
     });
-    describe('constructor', () => {
-        it('should initialize logger with event context and dev_oid', () => {
-            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), { dev_oid: mockEvent.payload.event_context.dev_oid }));
-        });
+    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);
-            const expectedLogObject = Object.assign(Object.assign({ message }, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_oid });
-            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(expectedLogObject));
-        });
-        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,
-                depth: Infinity,
-                maxArrayLength: Infinity,
-                maxStringLength: Infinity,
-                breakLength: Infinity,
-            });
-            const expectedLogObject = Object.assign(Object.assign({ message: expectedMessage }, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_oid });
-            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(expectedLogObject));
-        });
-        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,
-                depth: Infinity,
-                maxArrayLength: Infinity,
-                maxStringLength: Infinity,
-                breakLength: Infinity,
-            });
-            const expectedLogObject = Object.assign(Object.assign({ message: `${text} ${expectedDataMessage}` }, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_oid });
-            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(expectedLogObject));
-        });
-        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,
-                depth: Infinity,
-                maxArrayLength: Infinity,
-                maxStringLength: Infinity,
-                breakLength: Infinity,
-            });
-            const expectedLogObject = Object.assign(Object.assign({ message: `${text1} ${expectedDataMessage} ${text2}` }, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_oid });
-            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(expectedLogObject));
-        });
+    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, logger_constants_1.INSPECT_OPTIONS);
+        // 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, logger_constants_1.INSPECT_OPTIONS);
+        // 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('[edge] should handle empty string message', () => {
-            logger.info('');
-            expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
-            const logString = mockConsoleInfo.mock.calls[0][0];
-            const logObject = JSON.parse(logString);
-            expect(logObject.message).toBe('');
-            expect(logObject.dev_oid).toBe(mockEvent.payload.event_context.dev_oid);
-            expect(logObject.request_id).toBe(mockEvent.payload.event_context.request_id);
-        });
-        it('[edge] should handle null and undefined values', () => {
-            logger.info('test', null, undefined);
-            expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
-            const logString = mockConsoleInfo.mock.calls[0][0];
-            const logObject = JSON.parse(logString);
-            // inspect shows 'null' and 'undefined' as strings
-            expect(logObject.message).toBe('test null undefined');
-            expect(logObject.dev_oid).toBe(mockEvent.payload.event_context.dev_oid);
-        });
-        it('[edge] should handle complex nested objects', () => {
-            const complexObject = {
-                level1: {
-                    level2: {
-                        array: [1, 2, 3],
-                        string: 'nested',
-                    },
+    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, logger_constants_1.INSPECT_OPTIONS);
+        // 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, logger_constants_1.INSPECT_OPTIONS);
+        // 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, logger_constants_1.MAX_LOG_STRING_LENGTH)}... ${20000 - logger_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('[edge] should not truncate message exactly at maximum length', () => {
+        // Arrange
+        const messageAtLimit = 'A'.repeat(logger_constants_1.MAX_LOG_STRING_LENGTH);
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.info(messageAtLimit);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe(messageAtLimit);
+        expect(logObject.message.length).toBe(logger_constants_1.MAX_LOG_STRING_LENGTH);
+    });
+    it('[edge] should truncate message one character over maximum length', () => {
+        // Arrange
+        const messageOverLimit = 'B'.repeat(logger_constants_1.MAX_LOG_STRING_LENGTH + 1);
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedMessage = `${messageOverLimit.substring(0, logger_constants_1.MAX_LOG_STRING_LENGTH)}... 1 more characters`;
+        // Act
+        logger.info(messageOverLimit);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe(expectedMessage);
+    });
+    it('[edge] should handle empty string without truncation', () => {
+        // Arrange
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.info('');
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe('');
+    });
+    it('[edge] should show correct character count for very long messages', () => {
+        // Arrange
+        const veryLongString = 'X'.repeat(50000);
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedCharactersRemaining = 50000 - logger_constants_1.MAX_LOG_STRING_LENGTH;
+        const expectedMessage = `${veryLongString.substring(0, logger_constants_1.MAX_LOG_STRING_LENGTH)}... ${expectedCharactersRemaining} more characters`;
+        // Act
+        logger.info(veryLongString);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe(expectedMessage);
+        expect(logObject.message).toContain('40000 more characters');
+    });
+    it('should stringify string arguments and join them with spaces', () => {
+        // Arrange
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.info('Message 1', 'Message 2');
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe('Message 1 Message 2');
+    });
+    it('should stringify object arguments using util.inspect', () => {
+        // Arrange
+        const data = { id: 123 };
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedMessage = (0, node_util_1.inspect)(data, logger_constants_1.INSPECT_OPTIONS);
+        // Act
+        logger.info(data);
+        // 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 log empty string as valid message with tags', () => {
+        // Arrange
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.info('');
+        // 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 logString = mockConsoleInfo.mock.calls[0][0];
-            const logObject = JSON.parse(logString);
-            // The logger uses inspect() with compact: true formatting
-            const expectedMessage = require('util').inspect(complexObject, {
-                compact: true,
-                depth: Infinity,
-                maxArrayLength: Infinity,
-                maxStringLength: Infinity,
-                breakLength: Infinity,
-            });
-            expect(logObject.message).toBe(expectedMessage);
-            expect(logObject.dev_oid).toBe(mockEvent.payload.event_context.dev_oid);
-            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, logger_constants_1.INSPECT_OPTIONS);
+        // 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/types/workers.d.ts

@@ -42,6 +42,7 @@ export interface SpawnInterface {
     worker: Worker;
     options?: WorkerAdapterOptions;
     resolve: (value: void | PromiseLike<void>) => void;
+    originalConsole?: Console;
 }
 /**
  * SpawnFactoryInterface is an interface for Spawn class factory.

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

@@ -1 +1 @@
-{"version":3,"file":"workers.d.ts","sourceRoot":"","sources":["../../src/types/workers.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"workers.d.ts","sourceRoot":"","sources":["../../src/types/workers.ts"],"names":[],"mappings":"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"}

package/dist/workers/create-worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-worker.d.ts","sourceRoot":"","sources":["../../src/workers/create-worker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,UAAU,EAAe,MAAM,kBAAkB,CAAC;AAE3D,iBAAe,YAAY,CAAC,cAAc,EACxC,UAAU,EAAE,UAAU,CAAC,cAAc,CAAC,GACrC,OAAO,CAAC,MAAM,CAAC,CA6BjB;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"create-worker.d.ts","sourceRoot":"","sources":["../../src/workers/create-worker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAAE,UAAU,EAAe,MAAM,kBAAkB,CAAC;AAE3D,iBAAe,YAAY,CAAC,cAAc,EACxC,UAAU,EAAE,UAAU,CAAC,cAAc,CAAC,GACrC,OAAO,CAAC,MAAM,CAAC,CAyBjB;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/workers/create-worker.js

@@ -2,26 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createWorker = createWorker;
 const node_worker_threads_1 = require("node:worker_threads");
-const logger_1 = require("../logger/logger");
 const workers_1 = require("../types/workers");
 async function createWorker(workerData) {
     return new Promise((resolve, reject) => {
         if (node_worker_threads_1.isMainThread) {
-            const logger = new logger_1.Logger({
-                event: workerData.event,
-                options: workerData.options,
-            });
             const workerFile = __dirname + '/worker.js';
             const worker = new node_worker_threads_1.Worker(workerFile, {
                 workerData,
             });
             worker.on(workers_1.WorkerEvent.WorkerError, (error) => {
-                logger.error('Worker error', error);
+                console.error('Worker error', error);
                 reject(error);
             });
             worker.on(workers_1.WorkerEvent.WorkerOnline, () => {
                 resolve(worker);
-                logger.info('Worker is online. Started processing the task with event type: ' +
+                console.info('Worker is online. Started processing the task with event type: ' +
                     workerData.event.payload.event_type +
                     '.');
             });

package/dist/workers/spawn.d.ts

@@ -19,9 +19,9 @@ export declare class Spawn {
     private softTimeoutTimer;
     private hardTimeoutTimer;
     private memoryMonitoringInterval;
-    private logger;
     private resolve;
-    constructor({ event, worker, options, resolve }: SpawnInterface);
+    private originalConsole;
+    constructor({ event, worker, options, resolve, originalConsole, }: SpawnInterface);
     private clearTimeouts;
     private exitFromMainThread;
 }

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,CAmEvD;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,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAA4C;gBAE/C,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,cAAc;IAgG/D,OAAO,CAAC,aAAa;YAYP,kBAAkB;CA8BjC"}
+{"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

@@ -72,19 +72,21 @@ function getWorkerPath({ event, connectorWorkerPath, }) {
  * @returns {Promise<Spawn>} - A new instance of Spawn class
  */
 async function spawn({ event, initialState, workerPath, initialDomainMapping, options, }) {
-    const logger = new logger_1.Logger({ event, options });
-    const script = getWorkerPath({
-        event,
-        connectorWorkerPath: workerPath,
-    });
     if (options === null || options === void 0 ? void 0 : options.isLocalDevelopment) {
-        logger.warn('WARN: isLocalDevelopment is deprecated. Please use the -- local flag instead.');
+        console.log('Snap-in is running in local development mode.');
     }
     // read the command line arguments to check if the local flag is passed
     const argv = await (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv)).argv;
     if (argv._.includes('local')) {
         options = Object.assign(Object.assign({}, (options || {})), { isLocalDevelopment: true });
     }
+    const originalConsole = console;
+    // eslint-disable-next-line no-global-assign
+    console = new logger_1.Logger({ event, options });
+    const script = getWorkerPath({
+        event,
+        connectorWorkerPath: workerPath,
+    });
     if (script) {
         try {
             const worker = await (0, create_worker_1.createWorker)({
@@ -100,16 +102,19 @@ async function spawn({ event, initialState, workerPath, initialDomainMapping, op
                     worker,
                     options,
                     resolve,
+                    originalConsole,
                 });
             });
         }
         catch (error) {
-            logger.error('Worker error while processing task', error);
+            console.error('Worker error while processing task', error);
+            // eslint-disable-next-line no-global-assign
+            console = originalConsole;
             return Promise.reject(error);
         }
     }
     else {
-        logger.error('Script was not found for event type: ' + event.payload.event_type + '.');
+        console.error('Script was not found for event type: ' + event.payload.event_type + '.');
         try {
             await (0, control_protocol_1.emit)({
                 event,
@@ -124,25 +129,28 @@ async function spawn({ event, initialState, workerPath, initialDomainMapping, op
             });
         }
         catch (error) {
-            logger.error('Error while emitting event.', (0, logger_1.serializeError)(error));
+            console.error('Error while emitting event.', (0, logger_1.serializeError)(error));
             return Promise.reject(error);
         }
+        finally {
+            // eslint-disable-next-line no-global-assign
+            console = originalConsole;
+        }
     }
 }
 class Spawn {
-    constructor({ event, worker, options, resolve }) {
+    constructor({ event, worker, options, resolve, originalConsole, }) {
         this.defaultLambdaTimeout = constants_1.DEFAULT_LAMBDA_TIMEOUT;
+        this.originalConsole = originalConsole || console;
         this.alreadyEmitted = false;
         this.event = event;
-        this.logger = new logger_1.Logger({ event, options });
         this.lambdaTimeout = (options === null || options === void 0 ? void 0 : options.timeout)
             ? Math.min(options.timeout, this.defaultLambdaTimeout)
             : this.defaultLambdaTimeout;
         this.resolve = resolve;
-        console.log('Event in main thread', event);
         // If soft timeout is reached, send a message to the worker to gracefully exit.
         this.softTimeoutTimer = setTimeout(() => void (async () => {
-            this.logger.log('SOFT TIMEOUT: Sending a message to the worker to gracefully exit.');
+            console.log('SOFT TIMEOUT: Sending a message to the worker to gracefully exit.');
             if (worker) {
                 worker.postMessage({
                     subject: workers_1.WorkerMessageSubject.WorkerMessageExit,
@@ -155,7 +163,7 @@ class Spawn {
         })(), this.lambdaTimeout);
         // If hard timeout is reached, that means the worker did not exit in time. Terminate the worker.
         this.hardTimeoutTimer = setTimeout(() => void (async () => {
-            this.logger.error('HARD TIMEOUT: Worker did not exit in time. Terminating the worker.');
+            console.error('HARD TIMEOUT: Worker did not exit in time. Terminating the worker.');
             if (worker) {
                 await worker.terminate();
             }
@@ -167,7 +175,7 @@ class Spawn {
         // If worker exits with process.exit(code), clear the timeouts and exit from
         // main thread.
         worker.on(workers_1.WorkerEvent.WorkerExit, (code) => void (async () => {
-            this.logger.info('Worker exited with exit code: ' + code + '.');
+            console.info('Worker exited with exit code: ' + code + '.');
             this.clearTimeouts();
             await this.exitFromMainThread();
         })());
@@ -176,13 +184,14 @@ class Spawn {
             // Since it is not possible to log from the worker thread, we need to log
             // from the main thread.
             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 stringifiedArgs = (_a = message.payload) === null || _a === void 0 ? void 0 : _a.stringifiedArgs;
                 const level = (_b = message.payload) === null || _b === void 0 ? void 0 : _b.level;
-                this.logger.logFn(args, level);
+                // Args are already sanitized in the worker thread, skip double sanitization
+                console.logFn(stringifiedArgs, level);
             }
             // 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) {
-                this.logger.info('Worker has emitted message to ADaaS.');
+                console.info('Worker has emitted message to ADaaS.');
                 this.alreadyEmitted = true;
             }
         });
@@ -191,12 +200,12 @@ class Spawn {
             try {
                 const memoryInfo = (0, helpers_2.getMemoryUsage)();
                 if (memoryInfo) {
-                    this.logger.info(memoryInfo.formattedMessage);
+                    console.info(memoryInfo.formattedMessage);
                 }
             }
             catch (error) {
                 // If memory monitoring fails, log the warning and clear the interval to prevent further issues
-                this.logger.warn('Memory monitoring failed, stopping logging of memory usage interval', error);
+                console.warn('Memory monitoring failed, stopping logging of memory usage interval', error);
                 if (this.memoryMonitoringInterval) {
                     clearInterval(this.memoryMonitoringInterval);
                     this.memoryMonitoringInterval = undefined;
@@ -217,6 +226,8 @@ class Spawn {
     }
     async exitFromMainThread() {
         this.clearTimeouts();
+        // eslint-disable-next-line no-global-assign
+        console = this.originalConsole;
         if (this.alreadyEmitted) {
             this.resolve();
             return;

package/dist/workers/worker.js

@@ -1,4 +1,7 @@
 "use strict";
 const { workerData } = require('worker_threads');
 require('ts-node').register();
+const { Logger } = require('../logger/logger');
+// eslint-disable-next-line no-global-assign
+console = new Logger({ event: workerData.event, options: workerData.options });
 require(workerData.workerPath);

package/package.json

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