@devrev/airsync-sdk 2.0.0-beta.0 → 2.0.0-beta.2

package/dist/multithreading/process-task.test.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const extraction_1 = require("../types/extraction");
+const workers_1 = require("../types/workers");
+// These tests cover logic that is NOT exercised by the end-to-end integration
+// tests under src/tests/timeout-handling/:
+//   - translation of legacy wire event types into the new enum (mutates event in place)
+//   - the hasWorkerEmitted guard that prevents onTimeout from firing after a
+//     successful emit (integration tests only exercise the positive case)
+//   - the error branch that posts WorkerMessageFailed and exits(1)
+//   - the WorkerMessage handler's guard that only flips isTimeout on
+//     WorkerMessageExit (integration tests can't cleanly target non-Exit messages)
+//
+// Tests for the happy path, timeout-signal-reaches-worker behavior, and main-thread
+// early return were removed — they either duplicate what the integration suite
+// already exercises or assert mocked behavior with little signal.
+const mockParentPortPostMessage = jest.fn();
+const mockParentPortOn = jest.fn();
+let mockIsMainThread = false;
+jest.mock('node:worker_threads', () => ({
+    get isMainThread() {
+        return mockIsMainThread;
+    },
+    get parentPort() {
+        return {
+            postMessage: mockParentPortPostMessage,
+            on: mockParentPortOn,
+        };
+    },
+    get workerData() {
+        var _a;
+        return (_a = global.__workerData__) !== null && _a !== void 0 ? _a : {};
+    },
+}));
+jest.mock('../logger/logger', () => ({
+    Logger: jest.fn().mockImplementation(() => ({
+        log: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+        info: jest.fn(),
+        logFn: jest.fn(),
+    })),
+    serializeError: jest.fn((e) => String(e)),
+}));
+jest.mock('../logger/logger.context', () => ({
+    runWithSdkLogContext: jest.fn((fn) => fn()),
+    runWithUserLogContext: jest.fn((fn) => fn()),
+}));
+jest.mock('../state/state', () => ({
+    createAdapterState: jest.fn(),
+}));
+jest.mock('./worker-adapter/worker-adapter', () => ({
+    WorkerAdapter: jest.fn().mockImplementation(() => ({
+        isTimeout: false,
+        hasWorkerEmitted: false,
+    })),
+}));
+const process_task_1 = require("./process-task");
+const state_1 = require("../state/state");
+const worker_adapter_1 = require("./worker-adapter/worker-adapter");
+const test_utils_1 = require("../common/test-utils");
+function setWorkerData(data) {
+    global.__workerData__ = data;
+}
+function makeEvent(eventType = extraction_1.EventType.StartExtractingData) {
+    return (0, test_utils_1.createMockEvent)('http://localhost:0', {
+        payload: { event_type: eventType },
+    });
+}
+// Flush the microtask queue enough to let the async IIFE inside processTask run.
+const flush = async () => new Promise((r) => setTimeout(r, 0));
+describe(process_task_1.processTask.name, () => {
+    let processExitSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockIsMainThread = false;
+        processExitSpy = jest
+            .spyOn(process, 'exit')
+            .mockImplementation((() => { }));
+        state_1.createAdapterState.mockResolvedValue({});
+    });
+    afterEach(() => {
+        processExitSpy.mockRestore();
+    });
+    it('should NOT call onTimeout when the worker already emitted before timeout check', async () => {
+        // Arrange
+        const event = makeEvent();
+        setWorkerData({ event, initialState: {}, options: {} });
+        // Both flags true: a timeout arrived but the worker had already emitted —
+        // onTimeout must be skipped. This is the guard the integration suite cannot
+        // target cleanly because it requires a precise race between emit and timeout.
+        const mockAdapter = { isTimeout: true, hasWorkerEmitted: true };
+        worker_adapter_1.WorkerAdapter.mockImplementation(() => mockAdapter);
+        const task = jest.fn().mockResolvedValue(undefined);
+        const onTimeout = jest.fn().mockResolvedValue(undefined);
+        // Act
+        (0, process_task_1.processTask)({ task, onTimeout });
+        await flush();
+        // Assert
+        expect(onTimeout).not.toHaveBeenCalled();
+        expect(processExitSpy).toHaveBeenCalledWith(0);
+    });
+    it('should NOT flip adapter.isTimeout when a non-Exit WorkerMessage arrives', async () => {
+        // Arrange
+        const event = makeEvent();
+        setWorkerData({ event, initialState: {}, options: {} });
+        const mockAdapter = { isTimeout: false, hasWorkerEmitted: false };
+        worker_adapter_1.WorkerAdapter.mockImplementation(() => mockAdapter);
+        const task = jest.fn().mockResolvedValue(undefined);
+        const onTimeout = jest.fn().mockResolvedValue(undefined);
+        // Act
+        (0, process_task_1.processTask)({ task, onTimeout });
+        await flush();
+        // Grab the handler registered for WorkerMessage events and invoke it with
+        // subjects that must NOT flip isTimeout (log messages, unknown subjects).
+        const messageHandlerCall = mockParentPortOn.mock.calls.find(([eventName]) => eventName === workers_1.WorkerEvent.WorkerMessage);
+        expect(messageHandlerCall).toBeDefined();
+        const handler = messageHandlerCall[1];
+        handler({ subject: workers_1.WorkerMessageSubject.WorkerMessageLog });
+        handler({ subject: 'NONSENSE_SUBJECT' });
+        // Assert
+        expect(mockAdapter.isTimeout).toBe(false);
+    });
+    it('should post WorkerMessageFailed with the error message and exit(1) when task throws', async () => {
+        // Arrange
+        const event = makeEvent();
+        setWorkerData({ event, initialState: {}, options: {} });
+        const mockAdapter = { isTimeout: false, hasWorkerEmitted: false };
+        worker_adapter_1.WorkerAdapter.mockImplementation(() => mockAdapter);
+        const taskError = new Error('task boom');
+        const task = jest.fn().mockRejectedValue(taskError);
+        const onTimeout = jest.fn().mockResolvedValue(undefined);
+        // Act
+        (0, process_task_1.processTask)({ task, onTimeout });
+        await flush();
+        // Assert
+        expect(mockParentPortPostMessage).toHaveBeenCalledWith(expect.objectContaining({
+            subject: workers_1.WorkerMessageSubject.WorkerMessageFailed,
+            payload: expect.objectContaining({
+                message: expect.stringContaining('task boom'),
+            }),
+        }));
+        expect(processExitSpy).toHaveBeenCalledWith(1);
+        expect(onTimeout).not.toHaveBeenCalled();
+    });
+});

package/dist/multithreading/spawn/spawn.d.ts

@@ -5,16 +5,16 @@ import { SpawnFactoryInterface, SpawnInterface } from '../../types/workers';
  * The class provides utilities to emit control events to the platform and exit the worker gracefully.
  * In case of lambda timeout, the class emits a lambda timeout event to the platform.
  * @param {SpawnFactoryInterface} options - The options to create a new instance of Spawn class
- * @param {AirdropEvent} options.event - The event object received from the platform
+ * @param {AirSyncEvent} options.event - The event object received from the platform
  * @param {object} options.initialState - The initial state of the adapter
- * @param {string} [options.workerPath] Remove getWorkerPath function and use baseWorkerPath: __dirname instead of workerPath
  * @param {string} [options.baseWorkerPath] - The base path for the worker files, usually `__dirname`
  * @returns {Promise<Spawn>} - A new instance of Spawn class
  */
-export declare function spawn<ConnectorState>({ event, initialState, workerPath, initialDomainMapping, options, baseWorkerPath, }: SpawnFactoryInterface<ConnectorState>): Promise<void>;
+export declare function spawn<ConnectorState>({ event, initialState, initialDomainMapping, options, baseWorkerPath, }: SpawnFactoryInterface<ConnectorState>): Promise<void>;
 export declare class Spawn {
     private event;
     private alreadyEmitted;
+    private softTimeoutSent;
     private defaultLambdaTimeout;
     private lambdaTimeout;
     private softTimeoutTimer;
@@ -23,6 +23,7 @@ export declare class Spawn {
     private resolve;
     private originalConsole;
     private logger;
+    private workerFailedMessage;
     constructor({ event, worker, options, resolve, originalConsole, }: SpawnInterface);
     private clearTimeouts;
     private exitFromMainThread;

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

@@ -1 +1 @@
-{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../src/multithreading/spawn/spawn.ts"],"names":[],"mappings":"AAQA,OAAO,EAEL,qBAAqB,EACrB,cAAc,EAGf,MAAM,qBAAqB,CAAC;AA+C7B;;;;;;;;;;;GAWG;AACH,wBAAsB,KAAK,CAAC,cAAc,EAAE,EAC1C,KAAK,EACL,YAAY,EACZ,UAAU,EACV,oBAAoB,EACpB,OAAO,EACP,cAAc,GACf,EAAE,qBAAqB,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAwFvD;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;IACjC,OAAO,CAAC,MAAM,CAAS;gBACX,EACV,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,eAAe,GAChB,EAAE,cAAc;IAiGjB,OAAO,CAAC,aAAa;YAYP,kBAAkB;CAiCjC"}
+{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../src/multithreading/spawn/spawn.ts"],"names":[],"mappings":"AAOA,OAAO,EAEL,qBAAqB,EACrB,cAAc,EAGf,MAAM,qBAAqB,CAAC;AA+C7B;;;;;;;;;;GAUG;AACH,wBAAsB,KAAK,CAAC,cAAc,EAAE,EAC1C,KAAK,EACL,YAAY,EACZ,oBAAoB,EACpB,OAAO,EACP,cAAc,GACf,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,eAAe,CAAU;IACjC,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;IACjC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,mBAAmB,CAAqB;gBACpC,EACV,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,eAAe,GAChB,EAAE,cAAc;IAiHjB,OAAO,CAAC,aAAa;YAYP,kBAAkB;CAoCjC"}

package/dist/multithreading/spawn/spawn.helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spawn.helpers.d.ts","sourceRoot":"","sources":["../../../src/multithreading/spawn/spawn.helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,SAAS,GAAG;IAC9D,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;CACjD,CAmFA;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,SAAS;;;;EA2BxD"}
+{"version":3,"file":"spawn.helpers.d.ts","sourceRoot":"","sources":["../../../src/multithreading/spawn/spawn.helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,SAAS,GAAG;IAC9D,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;CACjD,CA2EA;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,SAAS;;;;EA2BxD"}

package/dist/multithreading/spawn/spawn.helpers.js

@@ -11,43 +11,35 @@ const loading_1 = require("../../types/loading");
  */
 function getTimeoutErrorEventType(eventType) {
     switch (eventType) {
-        // Metadata extraction (handles both old and new enum members)
+        // Metadata extraction
         case extraction_1.EventType.StartExtractingMetadata:
-        case extraction_1.EventType.ExtractionMetadataStart:
             return {
                 eventType: extraction_1.ExtractorEventType.MetadataExtractionError,
             };
-        // Data extraction (handles both old and new enum members)
+        // Data extraction
         case extraction_1.EventType.StartExtractingData:
         case extraction_1.EventType.ContinueExtractingData:
-        case extraction_1.EventType.ExtractionDataStart:
-        case extraction_1.EventType.ExtractionDataContinue:
             return {
                 eventType: extraction_1.ExtractorEventType.DataExtractionError,
             };
-        // Data deletion (handles both old and new enum members)
+        // Data deletion
         case extraction_1.EventType.StartDeletingExtractorState:
-        case extraction_1.EventType.ExtractionDataDelete:
             return {
                 eventType: extraction_1.ExtractorEventType.ExtractorStateDeletionError,
             };
-        // Attachments extraction (handles both old and new enum members)
+        // Attachments extraction
         case extraction_1.EventType.StartExtractingAttachments:
         case extraction_1.EventType.ContinueExtractingAttachments:
-        case extraction_1.EventType.ExtractionAttachmentsStart:
-        case extraction_1.EventType.ExtractionAttachmentsContinue:
             return {
                 eventType: extraction_1.ExtractorEventType.AttachmentExtractionError,
             };
-        // Attachments deletion (handles both old and new enum members)
+        // Attachments deletion
         case extraction_1.EventType.StartDeletingExtractorAttachmentsState:
-        case extraction_1.EventType.ExtractionAttachmentsDelete:
             return {
                 eventType: extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionError,
             };
-        // External sync units (handles both old and new enum members)
+        // External sync units
         case extraction_1.EventType.StartExtractingExternalSyncUnits:
-        case extraction_1.EventType.ExtractionExternalSyncUnitsStart:
             return {
                 eventType: extraction_1.ExtractorEventType.ExternalSyncUnitExtractionError,
             };

package/dist/multithreading/spawn/spawn.helpers.test.js

@@ -15,7 +15,7 @@ describe(spawn_helpers_1.getTimeoutErrorEventType.name, () => {
         });
         it('should return MetadataExtractionError for deprecated ExtractionMetadataStart', () => {
             // Arrange
-            const eventType = extraction_1.EventType.ExtractionMetadataStart;
+            const eventType = extraction_1.EventType.StartExtractingMetadata;
             // Act
             const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
             // Assert
@@ -41,7 +41,7 @@ describe(spawn_helpers_1.getTimeoutErrorEventType.name, () => {
         });
         it('should return DataExtractionError for deprecated ExtractionDataStart', () => {
             // Arrange
-            const eventType = extraction_1.EventType.ExtractionDataStart;
+            const eventType = extraction_1.EventType.StartExtractingData;
             // Act
             const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
             // Assert
@@ -49,7 +49,7 @@ describe(spawn_helpers_1.getTimeoutErrorEventType.name, () => {
         });
         it('should return DataExtractionError for deprecated ExtractionDataContinue', () => {
             // Arrange
-            const eventType = extraction_1.EventType.ExtractionDataContinue;
+            const eventType = extraction_1.EventType.ContinueExtractingData;
             // Act
             const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
             // Assert
@@ -67,7 +67,7 @@ describe(spawn_helpers_1.getTimeoutErrorEventType.name, () => {
         });
         it('should return ExtractorStateDeletionError for deprecated ExtractionDataDelete', () => {
             // Arrange
-            const eventType = extraction_1.EventType.ExtractionDataDelete;
+            const eventType = extraction_1.EventType.StartDeletingExtractorState;
             // Act
             const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
             // Assert
@@ -93,7 +93,7 @@ describe(spawn_helpers_1.getTimeoutErrorEventType.name, () => {
         });
         it('should return AttachmentExtractionError for deprecated ExtractionAttachmentsStart', () => {
             // Arrange
-            const eventType = extraction_1.EventType.ExtractionAttachmentsStart;
+            const eventType = extraction_1.EventType.StartExtractingAttachments;
             // Act
             const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
             // Assert
@@ -101,7 +101,7 @@ describe(spawn_helpers_1.getTimeoutErrorEventType.name, () => {
         });
         it('should return AttachmentExtractionError for deprecated ExtractionAttachmentsContinue', () => {
             // Arrange
-            const eventType = extraction_1.EventType.ExtractionAttachmentsContinue;
+            const eventType = extraction_1.EventType.ContinueExtractingAttachments;
             // Act
             const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
             // Assert
@@ -119,7 +119,7 @@ describe(spawn_helpers_1.getTimeoutErrorEventType.name, () => {
         });
         it('should return ExtractorAttachmentsStateDeletionError for deprecated ExtractionAttachmentsDelete', () => {
             // Arrange
-            const eventType = extraction_1.EventType.ExtractionAttachmentsDelete;
+            const eventType = extraction_1.EventType.StartDeletingExtractorAttachmentsState;
             // Act
             const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
             // Assert
@@ -137,7 +137,7 @@ describe(spawn_helpers_1.getTimeoutErrorEventType.name, () => {
         });
         it('should return ExternalSyncUnitExtractionError for deprecated ExtractionExternalSyncUnitsStart', () => {
             // Arrange
-            const eventType = extraction_1.EventType.ExtractionExternalSyncUnitsStart;
+            const eventType = extraction_1.EventType.StartExtractingExternalSyncUnits;
             // Act
             const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
             // Assert

package/dist/multithreading/spawn/spawn.js

@@ -8,7 +8,6 @@ exports.spawn = spawn;
 const yargs_1 = __importDefault(require("yargs"));
 const helpers_1 = require("yargs/helpers");
 const control_protocol_1 = require("../../common/control-protocol");
-const event_type_translation_1 = require("../../common/event-type-translation");
 const helpers_2 = require("../../common/helpers");
 const logger_1 = require("../../logger/logger");
 const extraction_1 = require("../../types/extraction");
@@ -50,42 +49,30 @@ function getWorkerPath({ event, workerBasePath, }) {
  * The class provides utilities to emit control events to the platform and exit the worker gracefully.
  * In case of lambda timeout, the class emits a lambda timeout event to the platform.
  * @param {SpawnFactoryInterface} options - The options to create a new instance of Spawn class
- * @param {AirdropEvent} options.event - The event object received from the platform
+ * @param {AirSyncEvent} options.event - The event object received from the platform
  * @param {object} options.initialState - The initial state of the adapter
- * @param {string} [options.workerPath] Remove getWorkerPath function and use baseWorkerPath: __dirname instead of workerPath
  * @param {string} [options.baseWorkerPath] - The base path for the worker files, usually `__dirname`
  * @returns {Promise<Spawn>} - A new instance of Spawn class
  */
-async function spawn({ event, initialState, workerPath, initialDomainMapping, options, baseWorkerPath, }) {
-    // Translate incoming event type for backwards compatibility. This allows the
-    // SDK to accept both old and new event type formats. Then update the event with the translated event type.
-    const originalEventType = event.payload.event_type;
-    const translatedEventType = (0, event_type_translation_1.translateIncomingEventType)(event.payload.event_type);
-    event.payload.event_type = translatedEventType;
+async function spawn({ event, initialState, initialDomainMapping, options, baseWorkerPath, }) {
     // 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')) {
+    if (argv._.includes('local') || argv.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 });
-    if (translatedEventType !== originalEventType) {
-        console.log(`Event type translated from ${originalEventType} to ${translatedEventType}.`);
-    }
     if (options === null || options === void 0 ? void 0 : options.isLocalDevelopment) {
         console.log('Snap-in is running in local development mode.');
     }
+    const eventType = event.payload.event_type;
     let script = null;
-    if (workerPath != null) {
-        script = workerPath;
-    }
-    else if (baseWorkerPath != null &&
+    if (baseWorkerPath != null &&
         (options === null || options === void 0 ? void 0 : options.workerPathOverrides) != null &&
-        options.workerPathOverrides[translatedEventType] != null) {
+        options.workerPathOverrides[eventType] != null) {
         script =
-            baseWorkerPath +
-                options.workerPathOverrides[translatedEventType];
+            baseWorkerPath + options.workerPathOverrides[eventType];
     }
     else {
         script = getWorkerPath({
@@ -137,6 +124,7 @@ class Spawn {
         this.originalConsole = originalConsole || console;
         this.logger = console;
         this.alreadyEmitted = false;
+        this.softTimeoutSent = false;
         this.event = event;
         this.lambdaTimeout = (options === null || options === void 0 ? void 0 : options.timeout)
             ? Math.min(options.timeout, this.defaultLambdaTimeout)
@@ -145,6 +133,7 @@ class Spawn {
         // If soft timeout is reached, send a message to the worker to gracefully exit.
         this.softTimeoutTimer = setTimeout(() => void (async () => {
             console.log('SOFT TIMEOUT: Sending a message to the worker to gracefully exit.');
+            this.softTimeoutSent = true;
             if (worker) {
                 worker.postMessage({
                     subject: workers_1.WorkerMessageSubject.WorkerMessageExit,
@@ -167,28 +156,45 @@ class Spawn {
             }
         })(), this.lambdaTimeout * constants_1.HARD_TIMEOUT_MULTIPLIER);
         // If worker exits with process.exit(code), clear the timeouts and exit from
-        // main thread.
-        worker.on(workers_1.WorkerEvent.WorkerExit, (code) => void (async () => {
-            console.info('Worker exited with exit code: ' + code + '.');
-            this.clearTimeouts();
-            await this.exitFromMainThread();
-        })());
+        // main thread. When a soft timeout was sent, we use setImmediate to defer
+        // processing so that any pending WorkerMessage events (e.g.
+        // WorkerMessageEmitted from onTimeout) already queued in the event loop are
+        // handled first, preventing a race condition where exitFromMainThread sees
+        // alreadyEmitted=false and emits an error even though the worker
+        // successfully emitted an event.
+        worker.on(workers_1.WorkerEvent.WorkerExit, (code) => {
+            const handler = async () => {
+                console.info('Worker exited with exit code: ' + code + '.');
+                this.clearTimeouts();
+                await this.exitFromMainThread();
+            };
+            if (this.softTimeoutSent) {
+                void setImmediate(() => void handler());
+            }
+            else {
+                void handler();
+            }
+        });
         worker.on(workers_1.WorkerEvent.WorkerMessage, (message) => {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e;
             // Since logs from the worker thread are handled differently in snap-in
             // platform,  we need to catch the log messages from worker thread and log
             // them in main thread.
             if ((message === null || message === void 0 ? void 0 : message.subject) === workers_1.WorkerMessageSubject.WorkerMessageLog) {
                 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;
-                const isSdkLog = (_d = (_c = message.payload) === null || _c === void 0 ? void 0 : _c.isSdkLog) !== null && _d !== void 0 ? _d : false;
+                const isSdkLog = (_d = (_c = message.payload) === null || _c === void 0 ? void 0 : _c.isSdkLog) !== null && _d !== void 0 ? _d : true;
                 this.logger.logFn(stringifiedArgs, level, isSdkLog);
             }
             // 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) {
-                console.info('Worker has emitted message to ADaaS.');
+                console.info('Worker has emitted message to the AirSync platform.');
                 this.alreadyEmitted = true;
             }
+            // If worker sends a failure message before exiting, capture it for use in the error event.
+            if ((message === null || message === void 0 ? void 0 : message.subject) === workers_1.WorkerMessageSubject.WorkerMessageFailed) {
+                this.workerFailedMessage = (_e = message.payload) === null || _e === void 0 ? void 0 : _e.message;
+            }
         });
         // Log memory usage every 30 seconds
         this.memoryMonitoringInterval = setInterval(() => {
@@ -235,15 +241,19 @@ class Spawn {
                 event: this.event,
                 data: {
                     error: {
-                        message: 'Worker exited the process without emitting an event. Check other logs for more information.',
+                        message: `Worker exited without emitting event. ${this.workerFailedMessage
+                            ? `Error: ${this.workerFailedMessage}`
+                            : 'Check the logs for more information.'}`,
                     },
                 },
             });
-            this.resolve();
         }
         catch (error) {
             console.error('Error while emitting event.', (0, logger_1.serializeError)(error));
         }
+        finally {
+            this.resolve();
+        }
     }
 }
 exports.Spawn = Spawn;

package/dist/multithreading/spawn/spawn.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=spawn.test.d.ts.map

package/dist/multithreading/spawn/spawn.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn.test.d.ts","sourceRoot":"","sources":["../../../src/multithreading/spawn/spawn.test.ts"],"names":[],"mappings":""}