@devrev/ts-adaas 1.12.3-beta.6 → 1.12.3-beta.7

package/dist/tests/oom-handling/worker-memory.test.js

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_memory_1 = require("../../common/worker-memory");
+describe('worker-memory utilities', () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        jest.resetModules();
+        process.env = Object.assign({}, originalEnv);
+    });
+    afterAll(() => {
+        process.env = originalEnv;
+    });
+    describe('isLambdaEnvironment', () => {
+        it('should return false when not in Lambda', () => {
+            delete process.env.AWS_LAMBDA_FUNCTION_NAME;
+            delete process.env.AWS_EXECUTION_ENV;
+            delete process.env.LAMBDA_TASK_ROOT;
+            expect((0, worker_memory_1.isLambdaEnvironment)()).toBe(false);
+        });
+        it('should return true when AWS_LAMBDA_FUNCTION_NAME is set', () => {
+            process.env.AWS_LAMBDA_FUNCTION_NAME = 'test-function';
+            expect((0, worker_memory_1.isLambdaEnvironment)()).toBe(true);
+        });
+        it('should return true when AWS_EXECUTION_ENV is set', () => {
+            process.env.AWS_EXECUTION_ENV = 'AWS_Lambda_nodejs18.x';
+            expect((0, worker_memory_1.isLambdaEnvironment)()).toBe(true);
+        });
+        it('should return true when LAMBDA_TASK_ROOT is set', () => {
+            process.env.LAMBDA_TASK_ROOT = '/var/task';
+            expect((0, worker_memory_1.isLambdaEnvironment)()).toBe(true);
+        });
+    });
+    describe('getLambdaMemoryLimitMb', () => {
+        it('should return null when not in Lambda', () => {
+            delete process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE;
+            expect((0, worker_memory_1.getLambdaMemoryLimitMb)()).toBeNull();
+        });
+        it('should return memory limit when AWS_LAMBDA_FUNCTION_MEMORY_SIZE is set', () => {
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '1024';
+            expect((0, worker_memory_1.getLambdaMemoryLimitMb)()).toBe(1024);
+        });
+        it('should return null for invalid memory size', () => {
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = 'invalid';
+            expect((0, worker_memory_1.getLambdaMemoryLimitMb)()).toBeNull();
+        });
+    });
+    describe('getTotalAvailableMemoryMb', () => {
+        it('should use Lambda memory when in Lambda environment', () => {
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '2048';
+            const result = (0, worker_memory_1.getTotalAvailableMemoryMb)(false);
+            expect(result).toBe(2048);
+        });
+        it('should cap at LOCAL_DEV_MAX_TOTAL_MEMORY_MB for local development', () => {
+            delete process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE;
+            const result = (0, worker_memory_1.getTotalAvailableMemoryMb)(true);
+            expect(result).toBeLessThanOrEqual(worker_memory_1.MEMORY_CONSTANTS.LOCAL_DEV_MAX_TOTAL_MEMORY_MB);
+        });
+    });
+    describe('calculateWorkerMemoryConfig', () => {
+        it('should calculate memory config for local development', () => {
+            delete process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE;
+            delete process.env.AWS_LAMBDA_FUNCTION_NAME;
+            const config = (0, worker_memory_1.calculateWorkerMemoryConfig)(true);
+            expect(config.isLocalDevelopment).toBe(true);
+            expect(config.isLambda).toBe(false);
+            expect(config.workerMemoryPercentage).toBe(worker_memory_1.MEMORY_CONSTANTS.WORKER_MEMORY_PERCENTAGE);
+            expect(config.maxOldGenerationSizeMb).toBeGreaterThanOrEqual(worker_memory_1.MEMORY_CONSTANTS.MIN_WORKER_HEAP_SIZE_MB);
+            // For local dev, should be capped
+            expect(config.totalAvailableMemoryMb).toBeLessThanOrEqual(worker_memory_1.MEMORY_CONSTANTS.LOCAL_DEV_MAX_TOTAL_MEMORY_MB);
+        });
+        it('should calculate memory config for Lambda environment', () => {
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '1024';
+            process.env.AWS_LAMBDA_FUNCTION_NAME = 'test-function';
+            const config = (0, worker_memory_1.calculateWorkerMemoryConfig)(false);
+            expect(config.isLambda).toBe(true);
+            expect(config.totalAvailableMemoryMb).toBe(1024);
+            // Worker should get 75% of Lambda memory
+            expect(config.maxOldGenerationSizeMb).toBe(Math.floor(1024 * worker_memory_1.MEMORY_CONSTANTS.WORKER_MEMORY_PERCENTAGE));
+        });
+    });
+    describe('isOOMError', () => {
+        describe('with Error objects', () => {
+            it('should detect ERR_WORKER_OUT_OF_MEMORY error code on Error object', () => {
+                const error = new Error('Worker terminated due to reaching memory limit');
+                error.code = worker_memory_1.ERR_WORKER_OUT_OF_MEMORY;
+                expect((0, worker_memory_1.isOOMError)(error)).toBe(true);
+            });
+            it('should detect OOM from Error message when code is not set', () => {
+                const error = new Error('JavaScript heap out of memory');
+                expect((0, worker_memory_1.isOOMError)(error)).toBe(true);
+            });
+            it('should detect OOM from Error message with other error codes', () => {
+                const error = new Error('FATAL ERROR: Reached heap limit');
+                error.code = 'SOME_OTHER_CODE';
+                expect((0, worker_memory_1.isOOMError)(error)).toBe(true);
+            });
+            it('should return false for non-OOM Error objects', () => {
+                const error = new Error('Connection timeout');
+                error.code = 'ECONNREFUSED';
+                expect((0, worker_memory_1.isOOMError)(error)).toBe(false);
+            });
+            it('should prioritize error code over message', () => {
+                // Error with OOM code but non-OOM message - should still be detected as OOM
+                const error = new Error('Some generic error');
+                error.code = worker_memory_1.ERR_WORKER_OUT_OF_MEMORY;
+                expect((0, worker_memory_1.isOOMError)(error)).toBe(true);
+            });
+        });
+        describe('with string messages', () => {
+            it('should detect JavaScript heap out of memory', () => {
+                expect((0, worker_memory_1.isOOMError)('JavaScript heap out of memory')).toBe(true);
+                expect((0, worker_memory_1.isOOMError)('FATAL ERROR: JavaScript heap out of memory')).toBe(true);
+            });
+            it('should detect allocation failed errors', () => {
+                expect((0, worker_memory_1.isOOMError)('Allocation failed - JavaScript heap out of memory')).toBe(true);
+            });
+            it('should detect heap limit errors', () => {
+                expect((0, worker_memory_1.isOOMError)('FATAL ERROR: Reached heap limit')).toBe(true);
+            });
+            it('should detect CALL_AND_RETRY_LAST errors', () => {
+                expect((0, worker_memory_1.isOOMError)('FATAL ERROR: CALL_AND_RETRY_LAST')).toBe(true);
+            });
+            it('should detect ERR_WORKER_OUT_OF_MEMORY in string message', () => {
+                expect((0, worker_memory_1.isOOMError)('ERR_WORKER_OUT_OF_MEMORY')).toBe(true);
+                expect((0, worker_memory_1.isOOMError)('Error [ERR_WORKER_OUT_OF_MEMORY]: Worker terminated due to reaching memory limit')).toBe(true);
+            });
+            it('should detect Worker terminated due to reaching memory limit', () => {
+                expect((0, worker_memory_1.isOOMError)('Worker terminated due to reaching memory limit')).toBe(true);
+                expect((0, worker_memory_1.isOOMError)('Worker terminated due to reaching memory limit: JavaScript heap out of memory')).toBe(true);
+            });
+            it('should detect JS heap out of memory (abbreviated)', () => {
+                expect((0, worker_memory_1.isOOMError)('JS heap out of memory')).toBe(true);
+                expect((0, worker_memory_1.isOOMError)('FATAL ERROR: JS heap out of memory')).toBe(true);
+            });
+            it('should detect memory allocation failed', () => {
+                expect((0, worker_memory_1.isOOMError)('memory allocation failed')).toBe(true);
+                expect((0, worker_memory_1.isOOMError)('Error: memory allocation failed during processing')).toBe(true);
+            });
+            it('should return false for non-OOM errors', () => {
+                expect((0, worker_memory_1.isOOMError)('Connection timeout')).toBe(false);
+                expect((0, worker_memory_1.isOOMError)('File not found')).toBe(false);
+                expect((0, worker_memory_1.isOOMError)('Permission denied')).toBe(false);
+                expect((0, worker_memory_1.isOOMError)('ENOENT: no such file or directory')).toBe(false);
+                expect((0, worker_memory_1.isOOMError)('ECONNREFUSED')).toBe(false);
+                expect((0, worker_memory_1.isOOMError)('TypeError: undefined is not a function')).toBe(false);
+            });
+            it('should handle empty and undefined-like inputs', () => {
+                expect((0, worker_memory_1.isOOMError)('')).toBe(false);
+                expect((0, worker_memory_1.isOOMError)('   ')).toBe(false);
+                expect((0, worker_memory_1.isOOMError)('null')).toBe(false);
+                expect((0, worker_memory_1.isOOMError)('undefined')).toBe(false);
+            });
+            it('should be case insensitive', () => {
+                expect((0, worker_memory_1.isOOMError)('JAVASCRIPT HEAP OUT OF MEMORY')).toBe(true);
+                expect((0, worker_memory_1.isOOMError)('javascript heap out of memory')).toBe(true);
+                expect((0, worker_memory_1.isOOMError)('JavaScript Heap Out Of Memory')).toBe(true);
+            });
+        });
+    });
+    describe('edge cases for memory calculations', () => {
+        it('should handle very low Lambda memory (128MB)', () => {
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '128';
+            process.env.AWS_LAMBDA_FUNCTION_NAME = 'test-function';
+            const config = (0, worker_memory_1.calculateWorkerMemoryConfig)(false);
+            expect(config.isLambda).toBe(true);
+            expect(config.totalAvailableMemoryMb).toBe(128);
+            // Worker should get 75% of 128MB = 96MB, but MIN is 128MB
+            expect(config.maxOldGenerationSizeMb).toBe(Math.max(Math.floor(128 * worker_memory_1.MEMORY_CONSTANTS.WORKER_MEMORY_PERCENTAGE), worker_memory_1.MEMORY_CONSTANTS.MIN_WORKER_HEAP_SIZE_MB));
+        });
+        it('should enforce MIN_WORKER_HEAP_SIZE_MB when calculated value is too low', () => {
+            // Simulate a very low memory environment
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '64';
+            process.env.AWS_LAMBDA_FUNCTION_NAME = 'test-function';
+            const config = (0, worker_memory_1.calculateWorkerMemoryConfig)(false);
+            // 64MB * 0.75 = 48MB, which is below MIN_WORKER_HEAP_SIZE_MB (128MB)
+            expect(config.maxOldGenerationSizeMb).toBe(worker_memory_1.MEMORY_CONSTANTS.MIN_WORKER_HEAP_SIZE_MB);
+        });
+        it('should handle zero memory size gracefully', () => {
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '0';
+            const result = (0, worker_memory_1.getLambdaMemoryLimitMb)();
+            // 0 is not > 0, so should return null
+            expect(result).toBeNull();
+        });
+        it('should handle negative memory size gracefully', () => {
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '-512';
+            const result = (0, worker_memory_1.getLambdaMemoryLimitMb)();
+            // Negative is not > 0, so should return null
+            expect(result).toBeNull();
+        });
+        it('should handle very large Lambda memory (10240MB)', () => {
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '10240';
+            process.env.AWS_LAMBDA_FUNCTION_NAME = 'test-function';
+            const config = (0, worker_memory_1.calculateWorkerMemoryConfig)(false);
+            expect(config.isLambda).toBe(true);
+            expect(config.totalAvailableMemoryMb).toBe(10240);
+            // Worker should get 75% of 10240MB = 7680MB
+            expect(config.maxOldGenerationSizeMb).toBe(Math.floor(10240 * worker_memory_1.MEMORY_CONSTANTS.WORKER_MEMORY_PERCENTAGE));
+        });
+        it('should handle floating point memory size', () => {
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '1024.5';
+            const result = (0, worker_memory_1.getLambdaMemoryLimitMb)();
+            // parseInt should truncate to 1024
+            expect(result).toBe(1024);
+        });
+        it('should handle memory size with leading zeros', () => {
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '00512';
+            const result = (0, worker_memory_1.getLambdaMemoryLimitMb)();
+            expect(result).toBe(512);
+        });
+        it('should handle memory size with whitespace', () => {
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = ' 1024 ';
+            const result = (0, worker_memory_1.getLambdaMemoryLimitMb)();
+            // parseInt handles leading whitespace
+            expect(result).toBe(1024);
+        });
+        it('should return null for empty string memory size', () => {
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '';
+            const result = (0, worker_memory_1.getLambdaMemoryLimitMb)();
+            expect(result).toBeNull();
+        });
+    });
+    describe('Lambda environment simulation', () => {
+        it('should correctly detect Lambda environment with all env vars set', () => {
+            process.env.AWS_LAMBDA_FUNCTION_NAME = 'my-function';
+            process.env.AWS_EXECUTION_ENV = 'AWS_Lambda_nodejs18.x';
+            process.env.LAMBDA_TASK_ROOT = '/var/task';
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '512';
+            expect((0, worker_memory_1.isLambdaEnvironment)()).toBe(true);
+            expect((0, worker_memory_1.getLambdaMemoryLimitMb)()).toBe(512);
+            const config = (0, worker_memory_1.calculateWorkerMemoryConfig)(false);
+            expect(config.isLambda).toBe(true);
+            expect(config.isLocalDevelopment).toBe(false);
+            expect(config.totalAvailableMemoryMb).toBe(512);
+        });
+        it('should calculate correct worker memory for Lambda 256MB', () => {
+            process.env.AWS_LAMBDA_FUNCTION_NAME = 'test-256';
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '256';
+            const config = (0, worker_memory_1.calculateWorkerMemoryConfig)(false);
+            expect(config.totalAvailableMemoryMb).toBe(256);
+            // 256 * 0.75 = 192MB for worker, but MIN is 128MB
+            const expectedWorkerMemory = Math.max(Math.floor(256 * worker_memory_1.MEMORY_CONSTANTS.WORKER_MEMORY_PERCENTAGE), worker_memory_1.MEMORY_CONSTANTS.MIN_WORKER_HEAP_SIZE_MB);
+            expect(config.maxOldGenerationSizeMb).toBe(expectedWorkerMemory);
+        });
+        it('should calculate correct worker memory for Lambda 512MB', () => {
+            process.env.AWS_LAMBDA_FUNCTION_NAME = 'test-512';
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '512';
+            const config = (0, worker_memory_1.calculateWorkerMemoryConfig)(false);
+            expect(config.totalAvailableMemoryMb).toBe(512);
+            // 512 * 0.75 = 384MB for worker
+            expect(config.maxOldGenerationSizeMb).toBe(Math.floor(512 * worker_memory_1.MEMORY_CONSTANTS.WORKER_MEMORY_PERCENTAGE));
+        });
+        it('should calculate correct worker memory for Lambda 1024MB', () => {
+            process.env.AWS_LAMBDA_FUNCTION_NAME = 'test-1024';
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '1024';
+            const config = (0, worker_memory_1.calculateWorkerMemoryConfig)(false);
+            expect(config.totalAvailableMemoryMb).toBe(1024);
+            // 1024 * 0.75 = 768MB for worker
+            expect(config.maxOldGenerationSizeMb).toBe(Math.floor(1024 * worker_memory_1.MEMORY_CONSTANTS.WORKER_MEMORY_PERCENTAGE));
+        });
+        it('should calculate correct worker memory for Lambda 3008MB (max)', () => {
+            process.env.AWS_LAMBDA_FUNCTION_NAME = 'test-3008';
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '3008';
+            const config = (0, worker_memory_1.calculateWorkerMemoryConfig)(false);
+            expect(config.totalAvailableMemoryMb).toBe(3008);
+            // 3008 * 0.75 = 2256MB for worker
+            expect(config.maxOldGenerationSizeMb).toBe(Math.floor(3008 * worker_memory_1.MEMORY_CONSTANTS.WORKER_MEMORY_PERCENTAGE));
+        });
+        it('should use local dev memory cap even when Lambda env vars are not set', () => {
+            delete process.env.AWS_LAMBDA_FUNCTION_NAME;
+            delete process.env.AWS_EXECUTION_ENV;
+            delete process.env.LAMBDA_TASK_ROOT;
+            delete process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE;
+            const config = (0, worker_memory_1.calculateWorkerMemoryConfig)(true); // isLocalDevelopment = true
+            expect(config.isLambda).toBe(false);
+            expect(config.isLocalDevelopment).toBe(true);
+            expect(config.totalAvailableMemoryMb).toBeLessThanOrEqual(worker_memory_1.MEMORY_CONSTANTS.LOCAL_DEV_MAX_TOTAL_MEMORY_MB);
+        });
+        it('should prefer Lambda memory over local dev cap when in Lambda', () => {
+            process.env.AWS_LAMBDA_FUNCTION_NAME = 'test-function';
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '2048';
+            // Even with isLocalDevelopment=true, Lambda memory should be used
+            // because getLambdaMemoryLimitMb() returns a value
+            const config = (0, worker_memory_1.calculateWorkerMemoryConfig)(true);
+            expect(config.totalAvailableMemoryMb).toBe(2048);
+            expect(config.isLambda).toBe(true);
+        });
+    });
+    describe('memory percentage allocation', () => {
+        it('should allocate WORKER_MEMORY_PERCENTAGE to worker', () => {
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '1000';
+            process.env.AWS_LAMBDA_FUNCTION_NAME = 'test';
+            const config = (0, worker_memory_1.calculateWorkerMemoryConfig)(false);
+            expect(config.workerMemoryPercentage).toBe(worker_memory_1.MEMORY_CONSTANTS.WORKER_MEMORY_PERCENTAGE);
+            expect(config.maxOldGenerationSizeMb).toBe(Math.floor(1000 * worker_memory_1.MEMORY_CONSTANTS.WORKER_MEMORY_PERCENTAGE));
+        });
+        it('should leave ~25% for parent thread', () => {
+            process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '1000';
+            process.env.AWS_LAMBDA_FUNCTION_NAME = 'test';
+            const config = (0, worker_memory_1.calculateWorkerMemoryConfig)(false);
+            const parentMemory = config.totalAvailableMemoryMb - config.maxOldGenerationSizeMb;
+            const parentPercentage = parentMemory / config.totalAvailableMemoryMb;
+            // Parent should get approximately 25% (1 - 0.75)
+            expect(parentPercentage).toBeCloseTo(1 - worker_memory_1.MEMORY_CONSTANTS.WORKER_MEMORY_PERCENTAGE, 2);
+        });
+    });
+});

package/dist/types/common.d.ts

@@ -1,4 +1,5 @@
 import { Artifact } from '../uploader/uploader.interfaces';
+import { OOMErrorInfo } from './workers';
 /**
  * ErrorLevel is an enum that represents the level of an error.
  * @deprecated
@@ -13,6 +14,8 @@ export declare enum ErrorLevel {
  */
 export interface ErrorRecord {
     message: string;
+    /** OOM error information, present when worker died due to out-of-memory */
+    oom_error_info?: OOMErrorInfo;
 }
 /**
  * LogRecord is an interface that defines the structure of a log record.

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

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAE3D;;;GAGG;AACH,oBAAY,UAAU;IACpB,OAAO,YAAY;IACnB,KAAK,UAAU;IACf,IAAI,SAAS;CACd;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,oBAAY,QAAQ;IAClB,OAAO,YAAY;IACnB,WAAW,gBAAgB;IAC3B,OAAO,YAAY;CACpB"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC;;;GAGG;AACH,oBAAY,UAAU;IACpB,OAAO,YAAY;IACnB,KAAK,UAAU;IACf,IAAI,SAAS;CACd;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,cAAc,CAAC,EAAE,YAAY,CAAC;CAC/B;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,oBAAY,QAAQ;IAClB,OAAO,YAAY;IACnB,WAAW,gBAAgB;IAC3B,OAAO,YAAY;CACpB"}

package/dist/types/workers.d.ts

@@ -25,12 +25,17 @@ export interface WorkerAdapterInterface<ConnectorState> {
  * @param {number=} timeout - The timeout for the worker thread
  * @param {number=} batchSize - Maximum number of extracted items in a batch
  * @param {Record<EventType, string>=} workerPathOverrides - A map of event types to custom worker paths to override default worker paths
+ * @param {boolean=} enableMemoryLimits - Whether to enable automatic memory limits for worker threads (default: true)
+ * @param {number=} testMemoryLimitMb - Override memory limit for testing purposes (only used when enableMemoryLimits is true)
  */
 export interface WorkerAdapterOptions {
     isLocalDevelopment?: boolean;
     timeout?: number;
     batchSize?: number;
     workerPathOverrides?: WorkerPathOverrides;
+    enableMemoryLimits?: boolean;
+    /** Override memory limit for testing purposes (only used when enableMemoryLimits is true) */
+    testMemoryLimitMb?: number;
 }
 /**
  * SpawnInterface is an interface for Spawn class.
@@ -38,6 +43,8 @@ export interface WorkerAdapterOptions {
  * @constructor
  * @param {AirdropEvent} event - The event object received from the platform
  * @param {Worker} worker - The worker thread
+ * @param {WorkerMemoryConfig} memoryConfig - Memory configuration for the worker
+ * @param {WorkerResourceLimits} resourceLimits - Resource limits applied to the worker
  */
 export interface SpawnInterface {
     event: AirdropEvent;
@@ -45,6 +52,23 @@ export interface SpawnInterface {
     options?: WorkerAdapterOptions;
     resolve: (value: void | PromiseLike<void>) => void;
     originalConsole?: Console;
+    memoryConfig?: WorkerMemoryConfig;
+    resourceLimits?: WorkerResourceLimits;
+}
+/**
+ * Memory configuration for worker threads.
+ */
+export interface WorkerMemoryConfig {
+    /** Maximum heap size in MB for the worker thread */
+    maxOldGenerationSizeMb: number;
+    /** Total available memory in MB (for logging/debugging) */
+    totalAvailableMemoryMb: number;
+    /** Whether running in Lambda environment */
+    isLambda: boolean;
+    /** Whether running in local development mode */
+    isLocalDevelopment: boolean;
+    /** The percentage of memory allocated to the worker (0-1) */
+    workerMemoryPercentage: number;
 }
 /**
  * SpawnFactoryInterface is an interface for Spawn class factory.
@@ -145,4 +169,38 @@ export interface GetWorkerPathInterface {
  * WorkerPathOverrides represents a mapping of event types to custom worker paths.
  */
 export type WorkerPathOverrides = Partial<Record<EventType, string>>;
+/**
+ * WorkerResourceLimits represents the resource limits applied to a worker thread.
+ */
+export interface WorkerResourceLimits {
+    /** Maximum size of the main (old generation) heap in MB */
+    maxOldGenerationSizeMb: number;
+    /** Maximum size of the young generation heap in MB (optional) */
+    maxYoungGenerationSizeMb?: number;
+    /** Size of pre-allocated memory range for generated code in MB (optional) */
+    codeRangeSizeMb?: number;
+    /** Maximum stack size in MB (optional) */
+    stackSizeMb?: number;
+}
+/**
+ * OOMErrorInfo represents detailed information about an OOM (Out-Of-Memory) error.
+ */
+export interface OOMErrorInfo {
+    /** Error type identifier */
+    type: 'OOM_ERROR';
+    /** Human-readable error message */
+    message: string;
+    /** Memory limit that was configured for the worker in MB */
+    memoryLimitMb: number;
+    /** Total available memory at spawn time in MB */
+    totalAvailableMemoryMb: number;
+    /** Whether running in Lambda environment */
+    isLambda: boolean;
+    /** Whether running in local development mode */
+    isLocalDevelopment: boolean;
+    /** Exit code from the worker (if available) */
+    exitCode?: number;
+    /** The event type being processed when OOM occurred */
+    eventType?: string;
+}
 //# sourceMappingURL=workers.d.ts.map

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/uploader/uploader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uploader.d.ts","sourceRoot":"","sources":["../../src/uploader/uploader.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAG/D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAEtC,OAAO,EAEL,gBAAgB,EAChB,cAAc,EACd,wBAAwB,EACzB,MAAM,uBAAuB,CAAC;AAE/B,qBAAa,QAAQ;IACnB,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,kBAAkB,CAAC,CAAU;IACrC,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,cAAc,CAAyB;gBAEnC,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,wBAAwB;IAWxD;;;;;;;;OAQG;IACG,MAAM,CACV,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,EAAE,GAAG,MAAM,GAChC,OAAO,CAAC,cAAc,CAAC;IAwDpB,oBAAoB,CACxB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAuB7B,cAAc,CAClB,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAmB1B,cAAc,CAClB,QAAQ,EAAE,gBAAgB,EAC1B,UAAU,EAAE,aAAa,GACxB,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IA0B1B,qBAAqB,CACzB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAwBhC;;;OAGG;IACH,OAAO,CAAC,aAAa;IAef,4BAA4B,CAAC,EACjC,QAAQ,GACT,EAAE;QACD,QAAQ,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO,CAAC;QACV,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;QACrC,KAAK,CAAC,EAAE;YAAE,OAAO,EAAE,MAAM,CAAA;SAAE,CAAC;KAC7B,CAAC;YAqCY,sBAAsB;YAyBtB,gBAAgB;IAe9B,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,UAAU;IASZ,yBAAyB,CAAC,EAC9B,UAAU,EACV,SAAiB,GAClB,EAAE;QACD,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB,GAAG,OAAO,CAAC,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,CAAC;YAyBvB,eAAe;CAgC9B"}
+{"version":3,"file":"uploader.d.ts","sourceRoot":"","sources":["../../src/uploader/uploader.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAG/D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAEtC,OAAO,EAEL,gBAAgB,EAChB,cAAc,EACd,wBAAwB,EACzB,MAAM,uBAAuB,CAAC;AAE/B,qBAAa,QAAQ;IACnB,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,kBAAkB,CAAC,CAAU;IACrC,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,cAAc,CAAyB;gBAEnC,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,wBAAwB;IAWxD;;;;;;;;OAQG;IACG,MAAM,CACV,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,EAAE,GAAG,MAAM,GAChC,OAAO,CAAC,cAAc,CAAC;IAwDpB,oBAAoB,CACxB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAuB7B,cAAc,CAClB,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAmB1B,cAAc,CAClB,QAAQ,EAAE,gBAAgB,EAC1B,UAAU,EAAE,aAAa,GACxB,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAqC1B,qBAAqB,CACzB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAwBhC;;;OAGG;IACH,OAAO,CAAC,aAAa;IAef,4BAA4B,CAAC,EACjC,QAAQ,GACT,EAAE;QACD,QAAQ,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO,CAAC;QACV,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;QACrC,KAAK,CAAC,EAAE;YAAE,OAAO,EAAE,MAAM,CAAA;SAAE,CAAC;KAC7B,CAAC;YAqCY,sBAAsB;YAyBtB,gBAAgB;IAe9B,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,UAAU;IASZ,yBAAyB,CAAC,EAC9B,UAAU,EACV,SAAiB,GAClB,EAAE;QACD,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB,GAAG,OAAO,CAAC,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,CAAC;YAyBvB,eAAe;CAgC9B"}

package/dist/uploader/uploader.js

@@ -42,6 +42,7 @@ const fs_1 = __importStar(require("fs"));
 const js_jsonl_1 = require("js-jsonl");
 const zlib_1 = __importDefault(require("zlib"));
 const axios_client_internal_1 = require("../http/axios-client-internal");
+const constants_1 = require("../common/constants");
 const helpers_1 = require("../common/helpers");
 const logger_1 = require("../logger/logger");
 class Uploader {
@@ -145,13 +146,20 @@ class Uploader {
             formData.append(field, artifact.form_data[field]);
         }
         formData.append('file', fileStream.data);
+        if (fileStream.headers['content-length'] > constants_1.MAX_DEVREV_ARTIFACT_SIZE) {
+            console.warn(`File size exceeds the maximum limit of ${constants_1.MAX_DEVREV_ARTIFACT_SIZE} bytes.`);
+            this.destroyStream(fileStream);
+            return;
+        }
         try {
             const response = await axios_client_internal_1.axiosClient.post(artifact.upload_url, formData, {
-                headers: Object.assign({}, formData.getHeaders()),
-                // Prevents buffering of the response in the memory
-                maxRedirects: 0,
-                // Allow 2xx and 3xx (redirects) to be considered successful, 4xx and 5xx will throw errors and be caught in the catch block
-                validateStatus: (status) => status >= 200 && status < 400,
+                headers: Object.assign(Object.assign({}, formData.getHeaders()), (!fileStream.headers['content-length']
+                    ? {
+                        'Content-Length': constants_1.MAX_DEVREV_ARTIFACT_SIZE,
+                    }
+                    : {})),
+                maxRedirects: 0, // Prevents buffering
+                validateStatus: () => true, // Prevents errors on redirects
             });
             this.destroyStream(fileStream);
             return response;

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

@@ -1,5 +1,23 @@
 import { Worker } from 'node:worker_threads';
-import { WorkerData } from '../types/workers';
-declare function createWorker<ConnectorState>(workerData: WorkerData<ConnectorState>): Promise<Worker>;
+import { WorkerData, WorkerMemoryConfig, WorkerResourceLimits } from '../types/workers';
+/**
+ * Result of creating a worker, including memory configuration.
+ */
+export interface CreateWorkerResult {
+    worker: Worker;
+    memoryConfig: WorkerMemoryConfig;
+    resourceLimits: WorkerResourceLimits;
+}
+/**
+ * Creates a worker thread with optional memory limits.
+ * Memory limits are calculated based on the environment:
+ * - For Lambda: Uses AWS_LAMBDA_FUNCTION_MEMORY_SIZE (75% for worker)
+ * - For local development: Caps total at 1024MB (75% for worker = ~768MB)
+ * - For other environments: Uses system memory or V8 heap limit
+ *
+ * @param workerData - Worker data including event, state, and options
+ * @returns Promise resolving to CreateWorkerResult with worker and memory config
+ */
+declare function createWorker<ConnectorState>(workerData: WorkerData<ConnectorState>): Promise<CreateWorkerResult>;
 export { createWorker };
 //# sourceMappingURL=create-worker.d.ts.map

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;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"}
+{"version":3,"file":"create-worker.d.ts","sourceRoot":"","sources":["../../src/workers/create-worker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,MAAM,EAAiB,MAAM,qBAAqB,CAAC;AAG1E,OAAO,EACL,UAAU,EAEV,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,kBAAkB,CAAC;AAE1B;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,kBAAkB,CAAC;IACjC,cAAc,EAAE,oBAAoB,CAAC;CACtC;AAED;;;;;;;;;GASG;AACH,iBAAe,YAAY,CAAC,cAAc,EACxC,UAAU,EAAE,UAAU,CAAC,cAAc,CAAC,GACrC,OAAO,CAAC,kBAAkB,CAAC,CA8D7B;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/workers/create-worker.js

@@ -2,23 +2,58 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createWorker = createWorker;
 const node_worker_threads_1 = require("node:worker_threads");
+const worker_memory_1 = require("../common/worker-memory");
 const workers_1 = require("../types/workers");
+/**
+ * Creates a worker thread with optional memory limits.
+ * Memory limits are calculated based on the environment:
+ * - For Lambda: Uses AWS_LAMBDA_FUNCTION_MEMORY_SIZE (75% for worker)
+ * - For local development: Caps total at 1024MB (75% for worker = ~768MB)
+ * - For other environments: Uses system memory or V8 heap limit
+ *
+ * @param workerData - Worker data including event, state, and options
+ * @returns Promise resolving to CreateWorkerResult with worker and memory config
+ */
 async function createWorker(workerData) {
     return new Promise((resolve, reject) => {
+        var _a, _b, _c, _d;
         if (node_worker_threads_1.isMainThread) {
             const workerFile = __dirname + '/worker.js';
-            const worker = new node_worker_threads_1.Worker(workerFile, {
+            // Calculate memory configuration based on environment
+            const isLocalDevelopment = (_b = (_a = workerData.options) === null || _a === void 0 ? void 0 : _a.isLocalDevelopment) !== null && _b !== void 0 ? _b : false;
+            const enableMemoryLimits = ((_c = workerData.options) === null || _c === void 0 ? void 0 : _c.enableMemoryLimits) !== false;
+            const testMemoryLimitMb = (_d = workerData.options) === null || _d === void 0 ? void 0 : _d.testMemoryLimitMb;
+            const memoryConfig = (0, worker_memory_1.calculateWorkerMemoryConfig)(isLocalDevelopment);
+            // Allow test override for memory limit
+            const effectiveMemoryLimitMb = testMemoryLimitMb !== null && testMemoryLimitMb !== void 0 ? testMemoryLimitMb : memoryConfig.maxOldGenerationSizeMb;
+            const resourceLimits = {
+                maxOldGenerationSizeMb: effectiveMemoryLimitMb,
+            };
+            // Build worker options
+            const workerOptions = {
                 workerData,
-            });
+            };
+            // Apply resource limits if enabled
+            if (enableMemoryLimits) {
+                workerOptions.resourceLimits = {
+                    maxOldGenerationSizeMb: resourceLimits.maxOldGenerationSizeMb,
+                };
+                console.info(`Worker memory limits configured: ` +
+                    `maxOldGenerationSizeMb=${resourceLimits.maxOldGenerationSizeMb}MB, ` +
+                    `totalAvailable=${memoryConfig.totalAvailableMemoryMb.toFixed(0)}MB, ` +
+                    `isLambda=${memoryConfig.isLambda}, ` +
+                    `isLocalDevelopment=${memoryConfig.isLocalDevelopment}`);
+            }
+            const worker = new node_worker_threads_1.Worker(workerFile, workerOptions);
             worker.on(workers_1.WorkerEvent.WorkerError, (error) => {
                 console.error('Worker error', error);
                 reject(error);
             });
             worker.on(workers_1.WorkerEvent.WorkerOnline, () => {
-                resolve(worker);
                 console.info('Worker is online. Started processing the task with event type: ' +
                     workerData.event.payload.event_type +
                     '.');
+                resolve({ worker, memoryConfig, resourceLimits });
             });
         }
         else {