@devrev/ts-adaas 1.13.4-beta.3 → 1.13.4-beta.4

package/dist/multithreading/worker-adapter/worker-adapter.js

@@ -12,6 +12,7 @@ const constants_1 = require("../../common/constants");
 const control_protocol_1 = require("../../common/control-protocol");
 const worker_adapter_helpers_1 = require("./worker-adapter.helpers");
 const logger_1 = require("../../logger/logger");
+const logger_context_1 = require("../../logger/logger.context");
 const mappers_1 = require("../../mappers/mappers");
 const mappers_interface_1 = require("../../mappers/mappers.interface");
 const repo_1 = require("../../repo/repo");
@@ -94,15 +95,19 @@ class WorkerAdapter {
         });
     }
     getRepo(itemType) {
-        const repo = this.repos.find((repo) => repo.itemType === itemType);
-        if (!repo) {
-            console.error(`Repo for item type ${itemType} not found.`);
-            return;
-        }
-        return repo;
+        return (0, logger_context_1.runWithSdkLogContext)(() => {
+            const repo = this.repos.find((repo) => repo.itemType === itemType);
+            if (!repo) {
+                console.error(`Repo for item type ${itemType} not found.`);
+                return;
+            }
+            return repo;
+        });
     }
     async postState() {
-        await this.adapterState.postState();
+        return (0, logger_context_1.runWithSdkLogContext)(async () => {
+            await this.adapterState.postState();
+        });
     }
     get artifacts() {
         return this._artifacts;
@@ -119,64 +124,66 @@ class WorkerAdapter {
      * @param data - The data to be sent with the event
      */
     async emit(newEventType, data) {
-        newEventType = (0, event_type_translation_1.translateOutgoingEventType)(newEventType);
-        if (this.hasWorkerEmitted) {
-            console.warn(`Trying to emit event with event type: ${newEventType}. Ignoring emit request because it has already been emitted.`);
-            return;
-        }
-        // We want to upload all the repos before emitting the event, except for the external sync units done event
-        if (newEventType !== extraction_1.ExtractorEventType.ExternalSyncUnitExtractionDone) {
-            console.log(`Uploading all repos before emitting event with event type: ${newEventType}.`);
-            try {
-                await this.uploadAllRepos();
-            }
-            catch (error) {
-                console.error('Error while uploading repos', error);
-                node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(workers_1.WorkerMessageSubject.WorkerMessageExit);
-                this.hasWorkerEmitted = true;
+        return (0, logger_context_1.runWithSdkLogContext)(async () => {
+            newEventType = (0, event_type_translation_1.translateOutgoingEventType)(newEventType);
+            if (this.hasWorkerEmitted) {
+                console.warn(`Trying to emit event with event type: ${newEventType}. Ignoring emit request because it has already been emitted.`);
                 return;
             }
-        }
-        // If the extraction is done, we want to save the timestamp of the last successful sync
-        if (newEventType === extraction_1.ExtractorEventType.AttachmentExtractionDone) {
-            console.log(`Overwriting lastSuccessfulSyncStarted with lastSyncStarted (${this.state.lastSyncStarted}).`);
-            this.state.lastSuccessfulSyncStarted = this.state.lastSyncStarted;
-            this.state.lastSyncStarted = '';
-        }
-        // We want to save the state every time we emit an event, except for the start and delete events
-        if (!constants_1.STATELESS_EVENT_TYPES.includes(this.event.payload.event_type)) {
-            console.log(`Saving state before emitting event with event type: ${newEventType}.`);
+            // We want to upload all the repos before emitting the event, except for the external sync units done event
+            if (newEventType !== extraction_1.ExtractorEventType.ExternalSyncUnitExtractionDone) {
+                console.log(`Uploading all repos before emitting event with event type: ${newEventType}.`);
+                try {
+                    await this.uploadAllRepos();
+                }
+                catch (error) {
+                    console.error('Error while uploading repos', error);
+                    node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(workers_1.WorkerMessageSubject.WorkerMessageExit);
+                    this.hasWorkerEmitted = true;
+                    return;
+                }
+            }
+            // If the extraction is done, we want to save the timestamp of the last successful sync
+            if (newEventType === extraction_1.ExtractorEventType.AttachmentExtractionDone) {
+                console.log(`Overwriting lastSuccessfulSyncStarted with lastSyncStarted (${this.state.lastSyncStarted}).`);
+                this.state.lastSuccessfulSyncStarted = this.state.lastSyncStarted;
+                this.state.lastSyncStarted = '';
+            }
+            // We want to save the state every time we emit an event, except for the start and delete events
+            if (!constants_1.STATELESS_EVENT_TYPES.includes(this.event.payload.event_type)) {
+                console.log(`Saving state before emitting event with event type: ${newEventType}.`);
+                try {
+                    await this.adapterState.postState(this.state);
+                }
+                catch (error) {
+                    console.error('Error while posting state', error);
+                    node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(workers_1.WorkerMessageSubject.WorkerMessageExit);
+                    this.hasWorkerEmitted = true;
+                    return;
+                }
+            }
             try {
-                await this.adapterState.postState(this.state);
+                await (0, control_protocol_1.emit)({
+                    eventType: newEventType,
+                    event: this.event,
+                    data: Object.assign(Object.assign({}, data), (constants_1.ALLOWED_EXTRACTION_EVENT_TYPES.includes(this.event.payload.event_type)
+                        ? { artifacts: this.artifacts }
+                        : {})),
+                });
+                const message = {
+                    subject: workers_1.WorkerMessageSubject.WorkerMessageEmitted,
+                    payload: { eventType: newEventType },
+                };
+                this.artifacts = [];
+                node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(message);
+                this.hasWorkerEmitted = true;
             }
             catch (error) {
-                console.error('Error while posting state', error);
+                console.error(`Error while emitting event with event type: ${newEventType}.`, (0, logger_1.serializeError)(error));
                 node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(workers_1.WorkerMessageSubject.WorkerMessageExit);
                 this.hasWorkerEmitted = true;
-                return;
             }
-        }
-        try {
-            await (0, control_protocol_1.emit)({
-                eventType: newEventType,
-                event: this.event,
-                data: Object.assign(Object.assign({}, data), (constants_1.ALLOWED_EXTRACTION_EVENT_TYPES.includes(this.event.payload.event_type)
-                    ? { artifacts: this.artifacts }
-                    : {})),
-            });
-            const message = {
-                subject: workers_1.WorkerMessageSubject.WorkerMessageEmitted,
-                payload: { eventType: newEventType },
-            };
-            this.artifacts = [];
-            node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(message);
-            this.hasWorkerEmitted = true;
-        }
-        catch (error) {
-            console.error(`Error while emitting event with event type: ${newEventType}.`, (0, logger_1.serializeError)(error));
-            node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(workers_1.WorkerMessageSubject.WorkerMessageExit);
-            this.hasWorkerEmitted = true;
-        }
+        });
     }
     async uploadAllRepos() {
         for (const repo of this.repos) {
@@ -191,383 +198,393 @@ class WorkerAdapter {
         this.isTimeout = true;
     }
     async loadItemTypes({ itemTypesToLoad, }) {
-        var _a;
-        if (this.event.payload.event_type === extraction_1.EventType.StartLoadingData) {
-            const itemTypes = itemTypesToLoad.map((itemTypeToLoad) => itemTypeToLoad.itemType);
-            if (!itemTypes.length) {
-                console.warn('No item types to load, returning.');
+        return (0, logger_context_1.runWithSdkLogContext)(async () => {
+            var _a;
+            if (this.event.payload.event_type === extraction_1.EventType.StartLoadingData) {
+                const itemTypes = itemTypesToLoad.map((itemTypeToLoad) => itemTypeToLoad.itemType);
+                if (!itemTypes.length) {
+                    console.warn('No item types to load, returning.');
+                    return {
+                        reports: this.reports,
+                        processed_files: this.processedFiles,
+                    };
+                }
+                const filesToLoad = await this.getLoaderBatches({
+                    supportedItemTypes: itemTypes,
+                });
+                this.adapterState.state.fromDevRev = {
+                    filesToLoad,
+                };
+            }
+            if (!this.adapterState.state.fromDevRev ||
+                !this.adapterState.state.fromDevRev.filesToLoad.length) {
+                console.warn('No files to load, returning.');
                 return {
                     reports: this.reports,
                     processed_files: this.processedFiles,
                 };
             }
-            const filesToLoad = await this.getLoaderBatches({
-                supportedItemTypes: itemTypes,
-            });
-            this.adapterState.state.fromDevRev = {
-                filesToLoad,
-            };
-        }
-        if (!this.adapterState.state.fromDevRev ||
-            !this.adapterState.state.fromDevRev.filesToLoad.length) {
-            console.warn('No files to load, returning.');
-            return {
-                reports: this.reports,
-                processed_files: this.processedFiles,
-            };
-        }
-        console.log('Files to load in state', (_a = this.adapterState.state.fromDevRev) === null || _a === void 0 ? void 0 : _a.filesToLoad);
-        outerloop: for (const fileToLoad of this.adapterState.state.fromDevRev
-            .filesToLoad) {
-            const itemTypeToLoad = itemTypesToLoad.find((itemTypeToLoad) => itemTypeToLoad.itemType === fileToLoad.itemType);
-            if (!itemTypeToLoad) {
-                console.error(`Item type to load not found for item type: ${fileToLoad.itemType}.`);
-                await this.emit(loading_1.LoaderEventType.DataLoadingError, {
-                    error: {
-                        message: `Item type to load not found for item type: ${fileToLoad.itemType}.`,
-                    },
-                });
-                break;
-            }
-            if (!fileToLoad.completed) {
-                const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
-                    artifactId: fileToLoad.id,
-                    isGzipped: true,
-                });
-                if (transformerFileError) {
-                    console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
+            console.log('Files to load in state', (_a = this.adapterState.state.fromDevRev) === null || _a === void 0 ? void 0 : _a.filesToLoad);
+            outerloop: for (const fileToLoad of this.adapterState.state.fromDevRev
+                .filesToLoad) {
+                const itemTypeToLoad = itemTypesToLoad.find((itemTypeToLoad) => itemTypeToLoad.itemType === fileToLoad.itemType);
+                if (!itemTypeToLoad) {
+                    console.error(`Item type to load not found for item type: ${fileToLoad.itemType}.`);
                     await this.emit(loading_1.LoaderEventType.DataLoadingError, {
                         error: {
-                            message: `Transformer file not found for artifact ID: ${fileToLoad.id}.`,
+                            message: `Item type to load not found for item type: ${fileToLoad.itemType}.`,
                         },
                     });
+                    break;
                 }
-                const transformerFile = response;
-                for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
-                    const { report, rateLimit } = await this.loadItem({
-                        item: transformerFile[i],
-                        itemTypeToLoad,
+                if (!fileToLoad.completed) {
+                    const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
+                        artifactId: fileToLoad.id,
+                        isGzipped: true,
                     });
-                    if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
-                        await this.emit(loading_1.LoaderEventType.DataLoadingDelayed, {
-                            delay: rateLimit.delay,
-                            reports: this.reports,
-                            processed_files: this.processedFiles,
+                    if (transformerFileError) {
+                        console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
+                        await this.emit(loading_1.LoaderEventType.DataLoadingError, {
+                            error: {
+                                message: `Transformer file not found for artifact ID: ${fileToLoad.id}.`,
+                            },
                         });
-                        break outerloop;
                     }
-                    if (report) {
-                        (0, worker_adapter_helpers_1.addReportToLoaderReport)({
-                            loaderReports: this.loaderReports,
-                            report,
+                    const transformerFile = response;
+                    for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
+                        const { report, rateLimit } = await this.loadItem({
+                            item: transformerFile[i],
+                            itemTypeToLoad,
                         });
-                        fileToLoad.lineToProcess = fileToLoad.lineToProcess + 1;
+                        if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
+                            await this.emit(loading_1.LoaderEventType.DataLoadingDelayed, {
+                                delay: rateLimit.delay,
+                                reports: this.reports,
+                                processed_files: this.processedFiles,
+                            });
+                            break outerloop;
+                        }
+                        if (report) {
+                            (0, worker_adapter_helpers_1.addReportToLoaderReport)({
+                                loaderReports: this.loaderReports,
+                                report,
+                            });
+                            fileToLoad.lineToProcess = fileToLoad.lineToProcess + 1;
+                        }
                     }
+                    fileToLoad.completed = true;
+                    this._processedFiles.push(fileToLoad.id);
                 }
-                fileToLoad.completed = true;
-                this._processedFiles.push(fileToLoad.id);
-            }
-        }
-        return {
-            reports: this.reports,
-            processed_files: this.processedFiles,
-        };
-    }
-    async getLoaderBatches({ supportedItemTypes, }) {
-        var _a;
-        const statsFileArtifactId = (_a = this.event.payload.event_data) === null || _a === void 0 ? void 0 : _a.stats_file;
-        if (statsFileArtifactId) {
-            const { response, error: statsFileError } = await this.uploader.getJsonObjectByArtifactId({
-                artifactId: statsFileArtifactId,
-            });
-            const statsFile = response;
-            if (statsFileError || statsFile.length === 0) {
-                return [];
             }
-            const filesToLoad = (0, worker_adapter_helpers_1.getFilesToLoad)({
-                supportedItemTypes,
-                statsFile,
-            });
-            return filesToLoad;
-        }
-        return [];
-    }
-    async loadAttachments({ create, }) {
-        var _a, _b;
-        if (this.event.payload.event_type === extraction_1.EventType.StartLoadingAttachments) {
-            this.adapterState.state.fromDevRev = {
-                filesToLoad: await this.getLoaderBatches({
-                    supportedItemTypes: ['attachment'],
-                }),
-            };
-        }
-        if (!this.adapterState.state.fromDevRev ||
-            ((_a = this.adapterState.state.fromDevRev) === null || _a === void 0 ? void 0 : _a.filesToLoad.length) === 0) {
-            console.log('No files to load, returning.');
             return {
                 reports: this.reports,
                 processed_files: this.processedFiles,
             };
-        }
-        const filesToLoad = (_b = this.adapterState.state.fromDevRev) === null || _b === void 0 ? void 0 : _b.filesToLoad;
-        outerloop: for (const fileToLoad of filesToLoad) {
-            if (!fileToLoad.completed) {
-                const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
-                    artifactId: fileToLoad.id,
-                    isGzipped: true,
+        });
+    }
+    async getLoaderBatches({ supportedItemTypes, }) {
+        return (0, logger_context_1.runWithSdkLogContext)(async () => {
+            var _a;
+            const statsFileArtifactId = (_a = this.event.payload.event_data) === null || _a === void 0 ? void 0 : _a.stats_file;
+            if (statsFileArtifactId) {
+                const { response, error: statsFileError } = await this.uploader.getJsonObjectByArtifactId({
+                    artifactId: statsFileArtifactId,
                 });
-                const transformerFile = response;
-                if (transformerFileError) {
-                    console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
-                    break outerloop;
+                const statsFile = response;
+                if (statsFileError || statsFile.length === 0) {
+                    return [];
                 }
-                for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
-                    const { report, rateLimit } = await this.loadAttachment({
-                        item: transformerFile[i],
-                        create,
+                const filesToLoad = (0, worker_adapter_helpers_1.getFilesToLoad)({
+                    supportedItemTypes,
+                    statsFile,
+                });
+                return filesToLoad;
+            }
+            return [];
+        });
+    }
+    async loadAttachments({ create, }) {
+        return (0, logger_context_1.runWithSdkLogContext)(async () => {
+            var _a, _b;
+            if (this.event.payload.event_type === extraction_1.EventType.StartLoadingAttachments) {
+                this.adapterState.state.fromDevRev = {
+                    filesToLoad: await this.getLoaderBatches({
+                        supportedItemTypes: ['attachment'],
+                    }),
+                };
+            }
+            if (!this.adapterState.state.fromDevRev ||
+                ((_a = this.adapterState.state.fromDevRev) === null || _a === void 0 ? void 0 : _a.filesToLoad.length) === 0) {
+                console.log('No files to load, returning.');
+                return {
+                    reports: this.reports,
+                    processed_files: this.processedFiles,
+                };
+            }
+            const filesToLoad = (_b = this.adapterState.state.fromDevRev) === null || _b === void 0 ? void 0 : _b.filesToLoad;
+            outerloop: for (const fileToLoad of filesToLoad) {
+                if (!fileToLoad.completed) {
+                    const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
+                        artifactId: fileToLoad.id,
+                        isGzipped: true,
                     });
-                    if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
-                        await this.emit(loading_1.LoaderEventType.DataLoadingDelayed, {
-                            delay: rateLimit.delay,
-                            reports: this.reports,
-                            processed_files: this.processedFiles,
-                        });
+                    const transformerFile = response;
+                    if (transformerFileError) {
+                        console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
                         break outerloop;
                     }
-                    if (report) {
-                        (0, worker_adapter_helpers_1.addReportToLoaderReport)({
-                            loaderReports: this.loaderReports,
-                            report,
+                    for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
+                        const { report, rateLimit } = await this.loadAttachment({
+                            item: transformerFile[i],
+                            create,
                         });
-                        fileToLoad.lineToProcess = fileToLoad.lineToProcess + 1;
+                        if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
+                            await this.emit(loading_1.LoaderEventType.DataLoadingDelayed, {
+                                delay: rateLimit.delay,
+                                reports: this.reports,
+                                processed_files: this.processedFiles,
+                            });
+                            break outerloop;
+                        }
+                        if (report) {
+                            (0, worker_adapter_helpers_1.addReportToLoaderReport)({
+                                loaderReports: this.loaderReports,
+                                report,
+                            });
+                            fileToLoad.lineToProcess = fileToLoad.lineToProcess + 1;
+                        }
                     }
+                    fileToLoad.completed = true;
+                    this._processedFiles.push(fileToLoad.id);
                 }
-                fileToLoad.completed = true;
-                this._processedFiles.push(fileToLoad.id);
             }
-        }
-        return {
-            reports: this.reports,
-            processed_files: this.processedFiles,
-        };
+            return {
+                reports: this.reports,
+                processed_files: this.processedFiles,
+            };
+        });
     }
     async loadItem({ item, itemTypeToLoad, }) {
-        var _a;
-        const devrevId = item.id.devrev;
-        try {
-            const syncMapperRecordResponse = await this._mappers.getByTargetId({
-                sync_unit: this.event.payload.event_context.sync_unit,
-                target: devrevId,
-            });
-            const syncMapperRecord = syncMapperRecordResponse.data;
-            if (!syncMapperRecord) {
-                console.warn('Failed to get sync mapper record from response.');
-                return {
-                    error: {
-                        message: 'Failed to get sync mapper record from response.',
-                    },
-                };
-            }
-            // Update item in external system
-            const { id, modifiedDate, delay, error } = await itemTypeToLoad.update({
-                item,
-                mappers: this._mappers,
-                event: this.event,
-            });
-            if (id) {
-                try {
-                    const syncMapperRecordUpdateResponse = await this._mappers.update(Object.assign(Object.assign({ id: syncMapperRecord.sync_mapper_record.id, sync_unit: this.event.payload.event_context.sync_unit, status: mappers_interface_1.SyncMapperRecordStatus.OPERATIONAL }, (modifiedDate && {
-                        external_versions: {
-                            add: [
-                                {
-                                    modified_date: modifiedDate,
-                                    recipe_version: 0,
-                                },
-                            ],
-                        },
-                    })), { external_ids: {
-                            add: [id],
-                        }, targets: {
-                            add: [devrevId],
-                        } }));
-                    console.log('Successfully updated sync mapper record.', syncMapperRecordUpdateResponse.data);
-                }
-                catch (error) {
-                    console.warn('Failed to update sync mapper record.', (0, logger_1.serializeError)(error));
+        return (0, logger_context_1.runWithSdkLogContext)(async () => {
+            var _a;
+            const devrevId = item.id.devrev;
+            try {
+                const syncMapperRecordResponse = await this._mappers.getByTargetId({
+                    sync_unit: this.event.payload.event_context.sync_unit,
+                    target: devrevId,
+                });
+                const syncMapperRecord = syncMapperRecordResponse.data;
+                if (!syncMapperRecord) {
+                    console.warn('Failed to get sync mapper record from response.');
                     return {
                         error: {
-                            message: 'Failed to update sync mapper record' + (0, logger_1.serializeError)(error),
+                            message: 'Failed to get sync mapper record from response.',
                         },
                     };
                 }
-                return {
-                    report: {
-                        item_type: itemTypeToLoad.itemType,
-                        [loading_1.ActionType.UPDATED]: 1,
-                    },
-                };
-            }
-            else if (delay) {
-                console.log(`Rate limited while updating item in external system, delaying for ${delay} seconds.`);
-                return {
-                    rateLimit: {
-                        delay,
-                    },
-                };
-            }
-            else {
-                console.warn('Failed to update item in external system', error);
-                return {
-                    report: {
-                        item_type: itemTypeToLoad.itemType,
-                        [loading_1.ActionType.FAILED]: 1,
-                    },
-                };
-            }
-            // TODO: Update mapper (optional)
-        }
-        catch (error) {
-            if (axios_1.default.isAxiosError(error)) {
-                if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
-                    // Create item in external system if mapper record not found
-                    const { id, modifiedDate, delay, error } = await itemTypeToLoad.create({
-                        item,
-                        mappers: this._mappers,
-                        event: this.event,
-                    });
-                    if (id) {
-                        // Create mapper
-                        try {
-                            const syncMapperRecordCreateResponse = await this._mappers.create(Object.assign({ sync_unit: this.event.payload.event_context.sync_unit, status: mappers_interface_1.SyncMapperRecordStatus.OPERATIONAL, external_ids: [id], targets: [devrevId] }, (modifiedDate && {
-                                external_versions: [
+                // Update item in external system
+                const { id, modifiedDate, delay, error } = await itemTypeToLoad.update({
+                    item,
+                    mappers: this._mappers,
+                    event: this.event,
+                });
+                if (id) {
+                    try {
+                        const syncMapperRecordUpdateResponse = await this._mappers.update(Object.assign(Object.assign({ id: syncMapperRecord.sync_mapper_record.id, sync_unit: this.event.payload.event_context.sync_unit, status: mappers_interface_1.SyncMapperRecordStatus.OPERATIONAL }, (modifiedDate && {
+                            external_versions: {
+                                add: [
                                     {
                                         modified_date: modifiedDate,
                                         recipe_version: 0,
                                     },
                                 ],
-                            })));
-                            console.log('Successfully created sync mapper record.', syncMapperRecordCreateResponse.data);
+                            },
+                        })), { external_ids: {
+                                add: [id],
+                            }, targets: {
+                                add: [devrevId],
+                            } }));
+                        console.log('Successfully updated sync mapper record.', syncMapperRecordUpdateResponse.data);
+                    }
+                    catch (error) {
+                        console.warn('Failed to update sync mapper record.', (0, logger_1.serializeError)(error));
+                        return {
+                            error: {
+                                message: 'Failed to update sync mapper record' + (0, logger_1.serializeError)(error),
+                            },
+                        };
+                    }
+                    return {
+                        report: {
+                            item_type: itemTypeToLoad.itemType,
+                            [loading_1.ActionType.UPDATED]: 1,
+                        },
+                    };
+                }
+                else if (delay) {
+                    console.log(`Rate limited while updating item in external system, delaying for ${delay} seconds.`);
+                    return {
+                        rateLimit: {
+                            delay,
+                        },
+                    };
+                }
+                else {
+                    console.warn('Failed to update item in external system', error);
+                    return {
+                        report: {
+                            item_type: itemTypeToLoad.itemType,
+                            [loading_1.ActionType.FAILED]: 1,
+                        },
+                    };
+                }
+                // TODO: Update mapper (optional)
+            }
+            catch (error) {
+                if (axios_1.default.isAxiosError(error)) {
+                    if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+                        // Create item in external system if mapper record not found
+                        const { id, modifiedDate, delay, error } = await itemTypeToLoad.create({
+                            item,
+                            mappers: this._mappers,
+                            event: this.event,
+                        });
+                        if (id) {
+                            // Create mapper
+                            try {
+                                const syncMapperRecordCreateResponse = await this._mappers.create(Object.assign({ sync_unit: this.event.payload.event_context.sync_unit, status: mappers_interface_1.SyncMapperRecordStatus.OPERATIONAL, external_ids: [id], targets: [devrevId] }, (modifiedDate && {
+                                    external_versions: [
+                                        {
+                                            modified_date: modifiedDate,
+                                            recipe_version: 0,
+                                        },
+                                    ],
+                                })));
+                                console.log('Successfully created sync mapper record.', syncMapperRecordCreateResponse.data);
+                                return {
+                                    report: {
+                                        item_type: itemTypeToLoad.itemType,
+                                        [loading_1.ActionType.CREATED]: 1,
+                                    },
+                                };
+                            }
+                            catch (error) {
+                                console.warn('Failed to create sync mapper record.', (0, logger_1.serializeError)(error));
+                                return {
+                                    error: {
+                                        message: 'Failed to create sync mapper record. ' +
+                                            (0, logger_1.serializeError)(error),
+                                    },
+                                };
+                            }
+                        }
+                        else if (delay) {
                             return {
-                                report: {
-                                    item_type: itemTypeToLoad.itemType,
-                                    [loading_1.ActionType.CREATED]: 1,
+                                rateLimit: {
+                                    delay,
                                 },
                             };
                         }
-                        catch (error) {
-                            console.warn('Failed to create sync mapper record.', (0, logger_1.serializeError)(error));
+                        else {
+                            console.warn('Failed to create item in external system.', (0, logger_1.serializeError)(error));
                             return {
-                                error: {
-                                    message: 'Failed to create sync mapper record. ' +
-                                        (0, logger_1.serializeError)(error),
+                                report: {
+                                    item_type: itemTypeToLoad.itemType,
+                                    [loading_1.ActionType.FAILED]: 1,
                                 },
                             };
                         }
                     }
-                    else if (delay) {
-                        return {
-                            rateLimit: {
-                                delay,
-                            },
-                        };
-                    }
                     else {
-                        console.warn('Failed to create item in external system.', (0, logger_1.serializeError)(error));
+                        console.warn('Failed to get sync mapper record.', (0, logger_1.serializeError)(error));
                         return {
-                            report: {
-                                item_type: itemTypeToLoad.itemType,
-                                [loading_1.ActionType.FAILED]: 1,
+                            error: {
+                                message: error.message,
                             },
                         };
                     }
                 }
-                else {
-                    console.warn('Failed to get sync mapper record.', (0, logger_1.serializeError)(error));
-                    return {
-                        error: {
-                            message: error.message,
-                        },
-                    };
-                }
+                console.warn('Failed to get sync mapper record.', (0, logger_1.serializeError)(error));
+                return {
+                    error: {
+                        message: 'Failed to get sync mapper record. ' + (0, logger_1.serializeError)(error),
+                    },
+                };
             }
-            console.warn('Failed to get sync mapper record.', (0, logger_1.serializeError)(error));
-            return {
-                error: {
-                    message: 'Failed to get sync mapper record. ' + (0, logger_1.serializeError)(error),
-                },
-            };
-        }
+        });
     }
     async processAttachment(attachment, stream) {
-        var _a;
-        const { httpStream, delay, error } = await stream({
-            item: attachment,
-            event: this.event,
-        });
-        if (error) {
-            return { error };
-        }
-        else if (delay) {
-            return { delay };
-        }
-        if (httpStream) {
-            const fileType = httpStream.headers['content-type'] || 'application/octet-stream';
-            const fileSize = httpStream.headers['content-length']
-                ? parseInt(httpStream.headers['content-length'])
-                : undefined;
-            // Get upload URL
-            const { error: artifactUrlError, response: artifactUrlResponse } = await this.uploader.getArtifactUploadUrl(attachment.file_name, fileType, fileSize);
-            if (artifactUrlError) {
-                console.warn(`Error while preparing artifact for attachment ID ${attachment.id}. Skipping attachment. ` +
-                    (0, logger_1.serializeError)(artifactUrlError));
-                this.destroyHttpStream(httpStream);
-                return;
-            }
-            if (this.isTimeout) {
-                this.destroyHttpStream(httpStream);
-                return;
-            }
-            // Stream attachment
-            const { error: uploadedArtifactError } = await this.uploader.streamArtifact(artifactUrlResponse, httpStream);
-            if (uploadedArtifactError) {
-                console.warn(`Error while streaming to artifact for attachment ID ${attachment.id}. Skipping attachment. ` +
-                    (0, logger_1.serializeError)(uploadedArtifactError));
-                this.destroyHttpStream(httpStream);
-                return;
+        return (0, logger_context_1.runWithSdkLogContext)(async () => {
+            var _a;
+            const { httpStream, delay, error } = await stream({
+                item: attachment,
+                event: this.event,
+            });
+            if (error) {
+                return { error };
             }
-            // Confirm attachment upload
-            const { error: confirmArtifactUploadError } = await this.uploader.confirmArtifactUpload(artifactUrlResponse.artifact_id);
-            if (confirmArtifactUploadError) {
-                console.warn('Error while confirming upload for attachment ID ' +
-                    attachment.id +
-                    '.', confirmArtifactUploadError);
-                return;
+            else if (delay) {
+                return { delay };
             }
-            const ssorAttachment = {
-                id: {
-                    devrev: artifactUrlResponse.artifact_id,
-                    external: attachment.id,
-                },
-                parent_id: {
-                    external: attachment.parent_id,
-                },
-            };
-            if (attachment.author_id) {
-                ssorAttachment.actor_id = {
-                    external: attachment.author_id,
+            if (httpStream) {
+                const fileType = httpStream.headers['content-type'] || 'application/octet-stream';
+                const fileSize = httpStream.headers['content-length']
+                    ? parseInt(httpStream.headers['content-length'])
+                    : undefined;
+                // Get upload URL
+                const { error: artifactUrlError, response: artifactUrlResponse } = await this.uploader.getArtifactUploadUrl(attachment.file_name, fileType, fileSize);
+                if (artifactUrlError) {
+                    console.warn(`Error while preparing artifact for attachment ID ${attachment.id}. Skipping attachment. ` +
+                        (0, logger_1.serializeError)(artifactUrlError));
+                    this.destroyHttpStream(httpStream);
+                    return;
+                }
+                if (this.isTimeout) {
+                    this.destroyHttpStream(httpStream);
+                    return;
+                }
+                // Stream attachment
+                const { error: uploadedArtifactError } = await this.uploader.streamArtifact(artifactUrlResponse, httpStream);
+                if (uploadedArtifactError) {
+                    console.warn(`Error while streaming to artifact for attachment ID ${attachment.id}. Skipping attachment. ` +
+                        (0, logger_1.serializeError)(uploadedArtifactError));
+                    this.destroyHttpStream(httpStream);
+                    return;
+                }
+                // Confirm attachment upload
+                const { error: confirmArtifactUploadError } = await this.uploader.confirmArtifactUpload(artifactUrlResponse.artifact_id);
+                if (confirmArtifactUploadError) {
+                    console.warn('Error while confirming upload for attachment ID ' +
+                        attachment.id +
+                        '.', confirmArtifactUploadError);
+                    return;
+                }
+                const ssorAttachment = {
+                    id: {
+                        devrev: artifactUrlResponse.artifact_id,
+                        external: attachment.id,
+                    },
+                    parent_id: {
+                        external: attachment.parent_id,
+                    },
                 };
+                if (attachment.author_id) {
+                    ssorAttachment.actor_id = {
+                        external: attachment.author_id,
+                    };
+                }
+                // This will set inline flag in ssor_attachment only if it is explicity
+                // set in the attachment object.
+                if (attachment.inline === true) {
+                    ssorAttachment.inline = true;
+                }
+                else if (attachment.inline === false) {
+                    ssorAttachment.inline = false;
+                }
+                await ((_a = this.getRepo('ssor_attachment')) === null || _a === void 0 ? void 0 : _a.push([ssorAttachment]));
             }
-            // This will set inline flag in ssor_attachment only if it is explicity
-            // set in the attachment object.
-            if (attachment.inline === true) {
-                ssorAttachment.inline = true;
-            }
-            else if (attachment.inline === false) {
-                ssorAttachment.inline = false;
-            }
-            await ((_a = this.getRepo('ssor_attachment')) === null || _a === void 0 ? void 0 : _a.push([ssorAttachment]));
-        }
-        return;
+            return;
+        });
     }
     /**
      * Destroys a stream to prevent memory leaks.
@@ -589,48 +606,50 @@ class WorkerAdapter {
         }
     }
     async loadAttachment({ item, create, }) {
-        // Create item
-        const { id, delay, error } = await create({
-            item,
-            mappers: this._mappers,
-            event: this.event,
-        });
-        if (delay) {
-            return {
-                rateLimit: {
-                    delay,
-                },
-            };
-        }
-        else if (id) {
-            try {
-                const syncMapperRecordCreateResponse = await this._mappers.create({
-                    sync_unit: this.event.payload.event_context.sync_unit,
-                    external_ids: [id],
-                    targets: [item.reference_id],
-                    status: mappers_interface_1.SyncMapperRecordStatus.OPERATIONAL,
-                });
-                console.log('Successfully created sync mapper record.', syncMapperRecordCreateResponse.data);
+        return (0, logger_context_1.runWithSdkLogContext)(async () => {
+            // Create item
+            const { id, delay, error } = await create({
+                item,
+                mappers: this._mappers,
+                event: this.event,
+            });
+            if (delay) {
+                return {
+                    rateLimit: {
+                        delay,
+                    },
+                };
             }
-            catch (error) {
-                console.warn('Failed to create sync mapper record.', (0, logger_1.serializeError)(error));
+            else if (id) {
+                try {
+                    const syncMapperRecordCreateResponse = await this._mappers.create({
+                        sync_unit: this.event.payload.event_context.sync_unit,
+                        external_ids: [id],
+                        targets: [item.reference_id],
+                        status: mappers_interface_1.SyncMapperRecordStatus.OPERATIONAL,
+                    });
+                    console.log('Successfully created sync mapper record.', syncMapperRecordCreateResponse.data);
+                }
+                catch (error) {
+                    console.warn('Failed to create sync mapper record.', (0, logger_1.serializeError)(error));
+                }
+                return {
+                    report: {
+                        item_type: 'attachment',
+                        [loading_1.ActionType.CREATED]: 1,
+                    },
+                };
             }
-            return {
-                report: {
-                    item_type: 'attachment',
-                    [loading_1.ActionType.CREATED]: 1,
-                },
-            };
-        }
-        else {
-            console.warn('Failed to create attachment in external system', error);
-            return {
-                report: {
-                    item_type: 'attachment',
-                    [loading_1.ActionType.FAILED]: 1,
-                },
-            };
-        }
+            else {
+                console.warn('Failed to create attachment in external system', error);
+                return {
+                    report: {
+                        item_type: 'attachment',
+                        [loading_1.ActionType.FAILED]: 1,
+                    },
+                };
+            }
+        });
     }
     /**
      * Streams the attachments to the DevRev platform.
@@ -641,86 +660,88 @@ class WorkerAdapter {
      */
     async streamAttachments({ stream, processors, batchSize = 1, // By default, we want to stream one attachment at a time
      }) {
-        var _a, _b;
-        if (batchSize <= 0) {
-            console.warn(`The specified batch size (${batchSize}) is invalid. Using 1 instead.`);
-            batchSize = 1;
-        }
-        if (batchSize > 50) {
-            console.warn(`The specified batch size (${batchSize}) is too large. Using 50 instead.`);
-            batchSize = 50;
-        }
-        const repos = [
-            {
-                itemType: 'ssor_attachment',
-            },
-        ];
-        this.initializeRepos(repos);
-        const attachmentsMetadata = (_a = this.state.toDevRev) === null || _a === void 0 ? void 0 : _a.attachmentsMetadata;
-        // If there are no attachments metadata artifact IDs in state, finish here
-        if (!((_b = attachmentsMetadata === null || attachmentsMetadata === void 0 ? void 0 : attachmentsMetadata.artifactIds) === null || _b === void 0 ? void 0 : _b.length)) {
-            console.log(`No attachments metadata artifact IDs found in state.`);
-            return;
-        }
-        else {
-            console.log(`Found ${attachmentsMetadata.artifactIds.length} attachments metadata artifact IDs in state.`);
-        }
-        // Loop through the attachments metadata artifact IDs
-        while (attachmentsMetadata.artifactIds.length > 0) {
-            const attachmentsMetadataArtifactId = attachmentsMetadata.artifactIds[0];
-            console.log(`Started processing attachments for attachments metadata artifact ID: ${attachmentsMetadataArtifactId}.`);
-            const { attachments, error } = await this.uploader.getAttachmentsFromArtifactId({
-                artifact: attachmentsMetadataArtifactId,
-            });
-            if (error) {
-                console.error(`Failed to get attachments for artifact ID: ${attachmentsMetadataArtifactId}.`);
-                return { error };
+        return (0, logger_context_1.runWithSdkLogContext)(async () => {
+            var _a, _b;
+            if (batchSize <= 0) {
+                console.warn(`The specified batch size (${batchSize}) is invalid. Using 1 instead.`);
+                batchSize = 1;
             }
-            if (!attachments || attachments.length === 0) {
-                console.warn(`No attachments found for artifact ID: ${attachmentsMetadataArtifactId}.`);
-                // Remove empty artifact and reset lastProcessed
-                attachmentsMetadata.artifactIds.shift();
-                attachmentsMetadata.lastProcessed = 0;
-                continue;
+            if (batchSize > 50) {
+                console.warn(`The specified batch size (${batchSize}) is too large. Using 50 instead.`);
+                batchSize = 50;
             }
-            console.log(`Found ${attachments.length} attachments for artifact ID: ${attachmentsMetadataArtifactId}.`);
-            let response;
-            if (processors) {
-                console.log(`Using custom processors for attachments.`);
-                const reducer = processors.reducer;
-                const iterator = processors.iterator;
-                const reducedAttachments = reducer({
-                    attachments,
-                    adapter: this,
-                    batchSize,
-                });
-                response = await iterator({
-                    reducedAttachments,
-                    adapter: this,
-                    stream,
-                });
+            const repos = [
+                {
+                    itemType: 'ssor_attachment',
+                },
+            ];
+            this.initializeRepos(repos);
+            const attachmentsMetadata = (_a = this.state.toDevRev) === null || _a === void 0 ? void 0 : _a.attachmentsMetadata;
+            // If there are no attachments metadata artifact IDs in state, finish here
+            if (!((_b = attachmentsMetadata === null || attachmentsMetadata === void 0 ? void 0 : attachmentsMetadata.artifactIds) === null || _b === void 0 ? void 0 : _b.length)) {
+                console.log(`No attachments metadata artifact IDs found in state.`);
+                return;
             }
             else {
-                console.log(`Using attachments streaming pool for attachments streaming.`);
-                const attachmentsPool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                    adapter: this,
-                    attachments,
-                    batchSize,
-                    stream,
-                });
-                response = await attachmentsPool.streamAll();
-            }
-            if ((response === null || response === void 0 ? void 0 : response.delay) || (response === null || response === void 0 ? void 0 : response.error)) {
-                return response;
+                console.log(`Found ${attachmentsMetadata.artifactIds.length} attachments metadata artifact IDs in state.`);
             }
-            console.log(`Finished processing all attachments for artifact ID: ${attachmentsMetadataArtifactId}.`);
-            attachmentsMetadata.artifactIds.shift();
-            attachmentsMetadata.lastProcessed = 0;
-            if (attachmentsMetadata.lastProcessedAttachmentsIdsList) {
-                attachmentsMetadata.lastProcessedAttachmentsIdsList.length = 0;
+            // Loop through the attachments metadata artifact IDs
+            while (attachmentsMetadata.artifactIds.length > 0) {
+                const attachmentsMetadataArtifactId = attachmentsMetadata.artifactIds[0];
+                console.log(`Started processing attachments for attachments metadata artifact ID: ${attachmentsMetadataArtifactId}.`);
+                const { attachments, error } = await this.uploader.getAttachmentsFromArtifactId({
+                    artifact: attachmentsMetadataArtifactId,
+                });
+                if (error) {
+                    console.error(`Failed to get attachments for artifact ID: ${attachmentsMetadataArtifactId}.`);
+                    return { error };
+                }
+                if (!attachments || attachments.length === 0) {
+                    console.warn(`No attachments found for artifact ID: ${attachmentsMetadataArtifactId}.`);
+                    // Remove empty artifact and reset lastProcessed
+                    attachmentsMetadata.artifactIds.shift();
+                    attachmentsMetadata.lastProcessed = 0;
+                    continue;
+                }
+                console.log(`Found ${attachments.length} attachments for artifact ID: ${attachmentsMetadataArtifactId}.`);
+                let response;
+                if (processors) {
+                    console.log(`Using custom processors for attachments.`);
+                    const reducer = processors.reducer;
+                    const iterator = processors.iterator;
+                    const reducedAttachments = reducer({
+                        attachments,
+                        adapter: this,
+                        batchSize,
+                    });
+                    response = await iterator({
+                        reducedAttachments,
+                        adapter: this,
+                        stream,
+                    });
+                }
+                else {
+                    console.log(`Using attachments streaming pool for attachments streaming.`);
+                    const attachmentsPool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
+                        adapter: this,
+                        attachments,
+                        batchSize,
+                        stream,
+                    });
+                    response = await attachmentsPool.streamAll();
+                }
+                if ((response === null || response === void 0 ? void 0 : response.delay) || (response === null || response === void 0 ? void 0 : response.error)) {
+                    return response;
+                }
+                console.log(`Finished processing all attachments for artifact ID: ${attachmentsMetadataArtifactId}.`);
+                attachmentsMetadata.artifactIds.shift();
+                attachmentsMetadata.lastProcessed = 0;
+                if (attachmentsMetadata.lastProcessedAttachmentsIdsList) {
+                    attachmentsMetadata.lastProcessedAttachmentsIdsList.length = 0;
+                }
             }
-        }
-        return;
+            return;
+        });
     }
 }
 exports.WorkerAdapter = WorkerAdapter;