@crowdin/app-project-module 0.94.2 → 0.94.3

package/out/modules/integration/util/webhooks.js

@@ -47,6 +47,9 @@ const index_1 = require("../../../util/index");
 const logger_1 = require("../../../util/logger");
 const prefetchCount = 10;
 const forceProcessDelay = 10000;
+const maxReconnectAttempts = 5;
+const baseReconnectDelay = 1000;
+const connectionHeartbeat = 60;
 exports.HookEvents = {
     fileAdded: 'file.added',
     fileDeleted: 'file.deleted',
@@ -341,27 +344,52 @@ function updateCrowdinFromWebhookRequest(args) {
 exports.updateCrowdinFromWebhookRequest = updateCrowdinFromWebhookRequest;
 function listenQueueMessage({ config, integration, queueName, queueUrl, }) {
     return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const connection = yield amqplib_1.default.connect(queueUrl);
-            connection.once('close', function () {
-                setTimeout(() => {
-                    listenQueueMessage({ config, integration, queueUrl, queueName });
-                }, 3000);
+        let reconnectAttempts = 0;
+        const connect = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const connection = yield amqplib_1.default.connect(queueUrl, {
+                    heartbeat: connectionHeartbeat, // 60 seconds heartbeat
+                });
+                // Reset reconnect attempts on successful connection
+                reconnectAttempts = 0;
+                connection.on('error', (err) => {
+                    (0, logger_1.logError)(`AMQP connection error: ${err.message}`);
+                });
+                connection.on('close', () => __awaiter(this, void 0, void 0, function* () {
+                    (0, logger_1.logError)('AMQP connection closed, attempting to reconnect...');
+                    yield scheduleReconnect();
+                }));
+                const channel = yield connection.createChannel();
+                if (channel) {
+                    yield channel.assertQueue(queueName, { durable: true });
+                    yield channel.prefetch(prefetchCount);
+                    channel.on('error', (err) => {
+                        (0, logger_1.logError)(`AMQP channel error: ${err.message}`);
+                    });
+                    channel.on('close', () => {
+                        (0, logger_1.logError)('AMQP channel closed');
+                    });
+                    const onMessage = consumer({ channel, config, integration });
+                    yield channel.consume(queueName, onMessage, { noAck: false });
+                }
+            }
+            catch (e) {
+                (0, logger_1.logError)(`Failed to connect to AMQP: ${e}`);
+                yield scheduleReconnect();
+            }
+        });
+        const scheduleReconnect = () => __awaiter(this, void 0, void 0, function* () {
+            if (reconnectAttempts >= maxReconnectAttempts) {
+                (0, logger_1.logError)(`Max reconnection attempts (${maxReconnectAttempts}) reached. Stopping reconnection.`);
                 return;
-            });
-            const channel = yield connection.createChannel();
-            if (channel) {
-                yield channel.assertQueue(queueName, { durable: true });
-                yield channel.prefetch(prefetchCount);
-                const onMessage = consumer({ channel, config, integration });
-                yield channel.consume(queueName, onMessage, { noAck: false });
             }
-        }
-        catch (e) {
-            setTimeout(() => {
-                listenQueueMessage({ config, integration, queueUrl, queueName });
-            }, 3000);
-        }
+            reconnectAttempts++;
+            const delay = Math.min(baseReconnectDelay * Math.pow(2, reconnectAttempts - 1), 30000); // Exponential backoff up to 30s
+            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                yield connect();
+            }), delay);
+        });
+        yield connect();
     });
 }
 exports.listenQueueMessage = listenQueueMessage;
@@ -370,18 +398,21 @@ function consumer({ channel, config, integration, }) {
     let webhooksInfo = {};
     let webhooksData = [];
     let timeoutId;
+    let messagesToAck = []; // Track messages for individual acknowledgment
     const resetStateVariables = () => {
         messagesCounter = 0;
         webhooksInfo = {};
         webhooksData = [];
+        messagesToAck = [];
     };
     return function (msg) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            messagesCounter++;
             if (!msg) {
                 return;
             }
+            messagesCounter++;
+            messagesToAck.push(msg); // Add message to acknowledgment queue
             clearTimeout(timeoutId);
             try {
                 const data = JSON.parse(msg.content.toString());
@@ -413,7 +444,7 @@ function consumer({ channel, config, integration, }) {
                             webhooksData,
                             webhooksInfo,
                             channel,
-                            msg,
+                            messagesToAck,
                         });
                         resetStateVariables();
                     }), forceProcessDelay);
@@ -424,34 +455,65 @@ function consumer({ channel, config, integration, }) {
                     webhooksData,
                     webhooksInfo,
                     channel,
-                    msg,
+                    messagesToAck,
                 });
                 resetStateVariables();
             }
             catch (e) {
-                (0, logger_1.logError)(e);
+                (0, logger_1.logError)(`Error processing message: ${e}`);
+                // Acknowledge the current message even if there's an error to prevent reprocessing
+                try {
+                    channel.ack(msg);
+                }
+                catch (ackError) {
+                    (0, logger_1.logError)(`Error acknowledging message: ${ackError}`);
+                }
             }
         });
     };
 }
-function processMessages({ channel, msg, webhooksData, webhooksInfo, }) {
+function processMessages({ channel, messagesToAck, webhooksData, webhooksInfo, }) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
+            // Prepare all webhook data first
             yield Promise.all(webhooksData);
+            // Process each client's webhook data individually
             for (const { data, integration, webhookData } of Object.values(webhooksInfo)) {
                 if (webhookData && webhookData.crowdinClient) {
-                    yield updateCrowdinFromWebhookRequest({
-                        integration: integration,
-                        webhookData: webhookData,
-                        req: data,
-                    });
+                    try {
+                        yield updateCrowdinFromWebhookRequest({
+                            integration: integration,
+                            webhookData: webhookData,
+                            req: data,
+                        });
+                    }
+                    catch (processingError) {
+                        (0, logger_1.logError)(`Error processing webhook request: ${processingError}`);
+                        // Continue processing other clients even if one fails
+                    }
+                }
+            }
+            // Acknowledge all messages individually after successful processing
+            for (const msg of messagesToAck) {
+                try {
+                    channel.ack(msg);
+                }
+                catch (ackError) {
+                    (0, logger_1.logError)(`Error acknowledging individual message: ${ackError}`);
                 }
             }
-            channel.ack(msg, true);
         }
         catch (e) {
-            (0, logger_1.logError)(e);
-            channel.nack(msg, false, false);
+            (0, logger_1.logError)(`Error in processMessages: ${e}`);
+            // On critical error, nack all messages to requeue them
+            for (const msg of messagesToAck) {
+                try {
+                    channel.nack(msg, false, true); // requeue the message
+                }
+                catch (nackError) {
+                    (0, logger_1.logError)(`Error nacking message: ${nackError}`);
+                }
+            }
         }
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crowdin/app-project-module",
-  "version": "0.94.2",
+  "version": "0.94.3",
   "description": "Module that generates for you all common endpoints for serving standalone Crowdin App",
   "main": "out/index.js",
   "types": "out/index.d.ts",