@tiledesk/tiledesk-server 2.26.0 → 2.27.0

package/CHANGELOG.md

@@ -5,6 +5,9 @@
 🚀        IN PRODUCTION                        🚀
 (https://www.npmjs.com/package/@tiledesk/tiledesk-server/v/2.3.77) 
 
+# 2.27.0
+- Added worker to manage events coming from Chat21 
+
 # 2.26.0
 - Added pubmodules proxy route for docsparse
 

package/jobs.js

@@ -1,3 +1,14 @@
+/**
+ * Entry point of the jobs worker (Dockerfile-jobs: `node jobs.js`).
+ * It runs the jobs that the server (app.js) skips when JOB_WORKER_ENABLED=true.
+ *
+ * Worker-specific env variables:
+ * - INCLUDE_QUEUE / EXCLUDE_QUEUE: routing keys consumed from RabbitMQ (see pubmodules/queue/reconnect.js)
+ * - TASK_SCHEDULER_ENABLED=false: disables the cron tasks (see pubmodules/scheduler/taskRunner.js)
+ * - MULTI_WORKER_ENABLED=false: disables @tiledesk/tiledesk-multi-worker
+ */
+
+// ---------- Env ----------
 
 var dotenvPath = undefined;
 
@@ -6,43 +17,35 @@ if (process.env.DOTENV_PATH) {
   console.log("load dotenv form DOTENV_PATH", dotenvPath);
 }
 
-if (process.env.LOAD_DOTENV_SUBFOLDER ) {
+if (process.env.LOAD_DOTENV_SUBFOLDER) {
   console.log("load dotenv form LOAD_DOTENV_SUBFOLDER");
-  dotenvPath = __dirname+'/confenv/.env';
+  dotenvPath = __dirname + '/confenv/.env';
 }
 
-require('dotenv').config({ path: dotenvPath});
+require('dotenv').config({ path: dotenvPath });
 
+// This process is the worker: modules reading JOB_WORKER_ENABLED must run their jobs here.
+process.env.JOB_WORKER_ENABLED = false;
 
 var mongoose = require('mongoose');
-
 let winston = require('./config/winston');
+var config = require('./config/database');
+const { TdCache } = require('./utils/TdCache');
 let JobsManager = require('./jobsManager');
 
-
 let geoService = require('./services/geoService');
-// let subscriptionNotifier = require('./services/subscriptionNotifier');
 var subscriptionNotifierQueued = require('./services/subscriptionNotifierQueued');
 var botSubscriptionNotifier = require('./services/BotSubscriptionNotifier');
-
-const botEvent = require('./event/botEvent');
-var channelManager = require('./channels/channelManager');
-
 var updateLeadQueued = require('./services/updateLeadQueued');
 var updateRequestSnapshotQueued = require('./services/updateRequestSnapshotQueued');
-
+const botEvent = require('./event/botEvent');
+var channelManager = require('./channels/channelManager');
 
 require('./services/mongoose-cache-fn')(mongoose);
 
-
-var config = require('./config/database');
-
-
-//override JOB_WORKER_ENABLED to false when you start jobs.js
-process.env.JOB_WORKER_ENABLED=false
+// ---------- MongoDB ----------
 
 var databaseUri = process.env.DATABASE_URI || process.env.MONGODB_URI || config.database;
-var autoIndex = true;
 
 if (!databaseUri) { //TODO??
   winston.warn('DATABASE_URI not specified, falling back to localhost.');
@@ -51,103 +54,102 @@ if (!databaseUri) { //TODO??
 let useUnifiedTopology = process.env.MONGOOSE_UNIFIED_TOPOLOGY === 'true';
 winston.info("DB useUnifiedTopology: ", useUnifiedTopology, typeof useUnifiedTopology);
 
-var connection = mongoose.connect(databaseUri, { "useNewUrlParser": true, "autoIndex": autoIndex, "useUnifiedTopology": useUnifiedTopology }, function(err) {
-  if (err) { 
+mongoose.connect(databaseUri, { "useNewUrlParser": true, "autoIndex": true, "useUnifiedTopology": useUnifiedTopology }, function (err) {
+  if (err) {
     winston.error('Failed to connect to MongoDB on ' + databaseUri + " ", err);
     process.exit(1);
   }
-winston.info("Mongoose connection done on host: "+mongoose.connection.host + " on port: " + mongoose.connection.port + " with name: "+ mongoose.connection.name)// , mongoose.connection.db);
+  winston.info("Mongoose connection done on host: " + mongoose.connection.host + " on port: " + mongoose.connection.port + " with name: " + mongoose.connection.name);
 });
-// winston.info("mongoose.connection",mongoose.connection);
-// module.exports = jobsManager;
 
+// ---------- Modules ----------
 
+/**
+ * Modules started directly by the worker, regardless of JobsManager.
+ */
+function startCoreModules() {
+  // Mongoose query cache.
+  require('./pubmodules/cache').cachegoose(mongoose);
 
-async function main()
-{
+  // Concierge bot.
+  require('./pubmodules/rules/appRules').start();
 
-  ////************* LOAD QUEUE ************ //
-  require('./pubmodules/cache').cachegoose(mongoose);            
-      
+  // RabbitMQ publisher and consumers: the jobs queue and the chat21 webhook queue,
+  // filtered by INCLUDE_QUEUE / EXCLUDE_QUEUE.
+  require('./pubmodules/queue');
 
-  ////************* LOAD CONCIERGE BOT ************ //
-  require('./pubmodules/rules/appRules').start();
+  // chat21Handler listens to the standard events (request.create, not request.create.queue)
+  // because the worker emits them when it closes a request.
+  channelManager.listen();
+}
+
+/**
+ * Job listeners started through JobsManager.
+ * Most of them only react to the *.queue events emitted by pubmodules/queue, so they do nothing
+ * when their routing keys are excluded. The scheduler and the multi-worker run on their own.
+ */
+function startJobListeners(tdCache) {
+  let jobsManager = new JobsManager(undefined, geoService, botEvent, subscriptionNotifierQueued, botSubscriptionNotifier, updateLeadQueued, updateRequestSnapshotQueued);
 
+  jobsManager.listen();
 
-  // require('./pubmodules/trigger/rulesTrigger').listen(); request.close trigger event is not triggered by anyone now?
-   
+  jobsManager.listenEmailNotification(require('./pubmodules/emailNotification'));
 
-  //************* LOAD QUEUE ************ //
-  require('./pubmodules/queue');   
-    // require('@tiledesk-ent/tiledesk-server-queue');     
+  jobsManager.listenActivityArchiver(require('./pubmodules/activities').activityArchiver);
 
-   //************* LOAD CHAT21 ************ //
-   channelManager.listen(); // chat21Handler is loaded with stadard events like request.create and NOT request.create.queue because it is used internally by the worker when the request is closed by ChatUnhandledRequestScheduler
+  let routingQueueQueued = require('./pubmodules/routing-queue').listenerQueued;
+  routingQueueQueued.setTdCache(tdCache);
+  jobsManager.listenRoutingQueue(routingQueueQueued);
 
-    // Same Redis client as app.js — required by routing-queue (flow attributes cache delete)
-    const { TdCache } = require('./utils/TdCache');
-    let tdCache = new TdCache({
-      host: process.env.CACHE_REDIS_HOST,
-      port: process.env.CACHE_REDIS_PORT,
-      password: process.env.CACHE_REDIS_PASSWORD
-    });
-    tdCache.connect();
+  jobsManager.listenWhatsappQueue(require('@tiledesk/tiledesk-whatsapp-jobworker'));
 
+  // Cron tasks, disabled by TASK_SCHEDULER_ENABLED=false.
+  jobsManager.listenScheduler(require('./pubmodules/scheduler'));
 
-    let jobsManager = new JobsManager(undefined, geoService, botEvent, subscriptionNotifierQueued, botSubscriptionNotifier, updateLeadQueued, updateRequestSnapshotQueued);
+  // Consumes its own RabbitMQ queues on AMQP_MANAGER_URL, disabled by MULTI_WORKER_ENABLED=false.
+  jobsManager.listenMultiWorker(require('@tiledesk/tiledesk-multi-worker'));
+}
 
-    jobsManager.listen();
+function startAnalyticsPublisher() {
+  try {
+    require('./pubmodules/analytics-publisher').listen();
+    winston.info("AnalyticsPublisher initialized.");
+  } catch (err) {
+    if (err.code === 'MODULE_NOT_FOUND') {
+      winston.info("PubModulesManager init analyticsPublisher module not found");
+    } else {
+      winston.info("PubModulesManager error initializing analyticsPublisher module", err);
+    }
+  }
+}
 
+// ---------- Main ----------
 
-    let emailNotification = require('./pubmodules/emailNotification');
-    jobsManager.listenEmailNotification(emailNotification);
+async function main() {
+  startCoreModules();
 
-   
-    let activityArchiver = require('./pubmodules/activities').activityArchiver;    
-    console.log("\n\n (jobs) activityArchiver: ", activityArchiver);
-    jobsManager.listenActivityArchiver(activityArchiver);
+  // Same Redis client as app.js, required by routing-queue (flow attributes cache delete).
+  let tdCache = new TdCache({
+    host: process.env.CACHE_REDIS_HOST,
+    port: process.env.CACHE_REDIS_PORT,
+    password: process.env.CACHE_REDIS_PASSWORD
+  });
+  tdCache.connect();
 
+  startJobListeners(tdCache);
 
-    let routingQueueQueued = require('./pubmodules/routing-queue').listenerQueued;
-    winston.debug("routingQueueQueued");
-    if (tdCache) {
-      routingQueueQueued.setTdCache(tdCache);
-    }
-    jobsManager.listenRoutingQueue(routingQueueQueued);
-
-    let whatsappQueue = require('@tiledesk/tiledesk-whatsapp-jobworker');
-    winston.info("whatsappQueue");
-    jobsManager.listenWhatsappQueue(whatsappQueue);
-
-    let scheduler = require('./pubmodules/scheduler');    
-    jobsManager.listenScheduler(scheduler);
-
-    let multiWorkerQueue = require('@tiledesk/tiledesk-multi-worker');
-    jobsManager.listenMultiWorker(multiWorkerQueue);
-
-    try {
-        this.analyticsPublisher = require('./pubmodules/analytics-publisher');
-        this.analyticsPublisher.listen();
-        winston.info("AnalyticsPublisher initialized.");
-    } catch(err) {
-        if (err.code === 'MODULE_NOT_FOUND') {
-            winston.info("PubModulesManager init analyticsPublisher module not found");
-        } else {
-            winston.info("PubModulesManager error initializing analyticsPublisher module", err);
-        }
-    }
+  startAnalyticsPublisher();
 
-    winston.info("Jobs started"); 
+  winston.info("Jobs started");
 
-    await new Promise(function () {});
-    console.log('This text will never be printed');
+  // Keeps the process alive.
+  await new Promise(function () {});
 }
 
-function panic(error)
-{
-    console.error(error);
-    process.exit(1);
+function panic(error) {
+  console.error(error);
+  process.exit(1);
 }
 
 // https://stackoverflow.com/a/46916601/1478566
-main().catch(panic).finally(clearInterval.bind(null, setInterval(a=>a, 1E9)));
+main().catch(panic).finally(clearInterval.bind(null, setInterval(a => a, 1E9)));

package/jobsManager.js

@@ -1,118 +1,90 @@
-
 var winston = require('./config/winston');
 
+/**
+ * Starts the queued job listeners, shared by the two processes:
+ * - app.js (server): jobWorkerEnabled = JOB_WORKER_ENABLED. When true every listener is skipped,
+ *   because the jobs are run by the external worker.
+ * - jobs.js (worker): jobWorkerEnabled = undefined, so every listener is started.
+ */
 class JobsManager {
     constructor(jobWorkerEnabled, geoService, botEvent, subscriptionNotifierQueued, botSubscriptionNotifier, updateLeadQueued, updateRequestSnapshotQueued) {
-        this.geoService = geoService;
-        this.botEvent = botEvent;
-        // this.subscriptionNotifier = subscriptionNotifier;
-        this.subscriptionNotifierQueued = subscriptionNotifierQueued;
-        this.botSubscriptionNotifier = botSubscriptionNotifier;
-
-        this.emailNotificatio = undefined;
-        this.activityArchiver = undefined;
-        this.whatsappWorker = undefined;
-        this.multiWorkerQueue = undefined;
-
         this.jobWorkerEnabled = jobWorkerEnabled;
-        // this.jobWorkerEnabled = false;
-        // if (process.env.JOB_WORKER_ENABLED=="true" || process.env.JOB_WORKER_ENABLED == true) {
-        //     this.jobWorkerEnabled = true;
-        // }
-        // winston.info("JobsManager jobWorkerEnabled: "+ this.jobWorkerEnabled);  
 
+        this.geoService = geoService;
+        this.subscriptionNotifierQueued = subscriptionNotifierQueued;
         this.updateLeadQueued = updateLeadQueued;
         this.updateRequestSnapshotQueued = updateRequestSnapshotQueued;
-    }
-
-
-    listen() {      
-        winston.info("JobsManager listener started");  
-        if ( this.jobWorkerEnabled == true) {
-           return winston.info("JobsManager jobWorkerEnabled is enabled. Skipping listeners");  
-        }
-        this.geoService.listen();
-        
-        // this.botEvent.listen(); // disabled
-
-        // this.subscriptionNotifier.start();
-        this.subscriptionNotifierQueued.start();
 
-        this.updateLeadQueued.listen();
+        // Kept for the constructor signature, their listeners are disabled.
+        this.botEvent = botEvent;
+        this.botSubscriptionNotifier = botSubscriptionNotifier;
+    }
 
-        if (this.updateRequestSnapshotQueued) {
-            this.updateRequestSnapshotQueued.listen();
+    /**
+     * Runs startFn unless the jobs are delegated to the external worker.
+     */
+    start(name, startFn) {
+        if (this.jobWorkerEnabled == true) {
+            return winston.info("JobsManager jobWorkerEnabled is enabled. Skipping " + name);
         }
+        winston.info("JobsManager starting " + name);
+        startFn();
+    }
 
-        // this.botSubscriptionNotifier.start(); // disabled
+    listen() {
+        this.start("geo, subscription notifier, lead and request snapshot listeners", () => {
+            this.geoService.listen();
+            this.subscriptionNotifierQueued.start();
+            this.updateLeadQueued.listen();
+            if (this.updateRequestSnapshotQueued) {
+                this.updateRequestSnapshotQueued.listen();
+            }
+        });
     }
 
-    listenEmailNotification(emailNotification) {      
-        winston.info("JobsManager listenEmailNotification started");  
-        if ( this.jobWorkerEnabled == true) {
-            return winston.info("JobsManager jobWorkerEnabled is enabled. Skipping listener for Email Notification");  
-        }
-        this.emailNotification = emailNotification;
-        this.emailNotification.requestNotification.listen();
+    listenEmailNotification(emailNotification) {
+        this.start("Email Notification", () => {
+            this.emailNotification = emailNotification;
+            this.emailNotification.requestNotification.listen();
+        });
     }
 
     listenRoutingQueue(routingQueue) {
-        winston.info("JobsManager routingQueue started");  
-        if ( this.jobWorkerEnabled == true) {
-            return winston.info("JobsManager jobWorkerEnabled is enabled. Skipping listener for routingQueue");  
-        }
-        this.routingQueue = routingQueue;
-        this.routingQueue.listen();
+        this.start("Routing Queue", () => {
+            this.routingQueue = routingQueue;
+            this.routingQueue.listen();
+        });
     }
 
     listenScheduler(scheduler) {
-        winston.info("JobsManager scheduler started");  
-        if ( this.jobWorkerEnabled == true) {
-            return winston.info("JobsManager jobWorkerEnabled is enabled. Skipping listener for scheduler");  
-        }
-        this.scheduler = scheduler;
-        this.scheduler.taskRunner.start();    
+        this.start("Scheduler", () => {
+            this.scheduler = scheduler;
+            this.scheduler.taskRunner.start();
+        });
     }
 
     listenActivityArchiver(activityArchiver) {
-        winston.info("JobsManager listenActivityArchiver started"); 
-        console.log("\n\n (jobsManager) listenActivityArchiver: ", activityArchiver);
-        console.log("\n\n (jobsManager) jobWorkerEnabled: ", this.jobWorkerEnabled);
-        if ( this.jobWorkerEnabled == true) {
-            return winston.info("JobsManager jobWorkerEnabled is enabled. Skipping listener for Activity Archiver");  
-        } 
-        this.activityArchiver = activityArchiver;
-        this.activityArchiver.listen();
+        this.start("Activity Archiver", () => {
+            this.activityArchiver = activityArchiver;
+            this.activityArchiver.listen();
+        });
     }
 
     listenWhatsappQueue(whatsappQueue) {
-        console.log("JobsManager listenWhatsappQueue started");
-        console.log("whatsappQueue is: ", whatsappQueue)
-        if ( this.jobWorkerEnabled == true) {
-            return winston.info("JobsManager jobWorkerEnabled is enabled. Skipping listener for Whatsapp Queue");  
-        }
-        // this.whatsappWorker = whatsappQueue;
-        // this.whatsappQueue.listen(); // oppure codice
+        this.start("Whatsapp Queue", () => {
+            // No listener to start yet.
+        });
     }
 
     listenMultiWorker(multiWorkerQueue) {
-        console.log("JobsManager multiWorkerQueue started");
-        console.log("multiWorkerQueue is: ", multiWorkerQueue)
-        if (this.jobWorkerEnabled == true) {
-            return winston.info("JobsManager jobWorkerEnabled is enabled. Skipping listener for MultiWorker Queue");  
-        }
-        this.multiWorkerQueue = multiWorkerQueue;
-        this.multiWorkerQueue.startJobsWorker();
+        this.start("MultiWorker Queue", () => {
+            if (process.env.MULTI_WORKER_ENABLED === "false") {
+                return winston.info("JobsManager MULTI_WORKER_ENABLED is false. Skipping MultiWorker Queue");
+            }
+            this.multiWorkerQueue = multiWorkerQueue;
+            this.multiWorkerQueue.startJobsWorker();
+        });
     }
-
-    // listenTrainingQueue(trainingQueue) {
-    //     console.log("JobsManager listenTrainingQueue started");
-    //     console.log("trainingQueue is: ", trainingQueue)
-    //     if (this.jobWorkerEnabled == true) {
-    //         return winston.info("JobsManager jobWorkerEnabled is enabled. Skipping listener for Training Queue");  
-    //     }
-    // }
 }
 
-
-module.exports = JobsManager;
+module.exports = JobsManager;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiledesk/tiledesk-server",
   "description": "The Tiledesk server module",
-  "version": "2.26.0",
+  "version": "2.27.0",
   "scripts": {
     "start": "node ./bin/www",
     "pretest": "mongodb-runner start",

package/pubmodules/activities/activityArchiver.js

@@ -149,11 +149,10 @@ class ActivityArchiver {
   listen() {
 
     winston.debug('ActivityArchiver listen');
-    console.log("\n\nActivityArchiver listen");
 
     const enabled = process.env.ACTIVITY_HISTORY_ENABLED || "false";
     winston.debug('ActivityArchiver enabled:' + enabled);
-    console.log("\n\nActivityArchiver enabled:" + enabled);
+
     if (enabled === "true") {
       winston.verbose('ActivityArchiver enabled');
     } else {

package/pubmodules/queue/chat21WebhookWorker.js

@@ -0,0 +1,145 @@
+const axios = require("axios").default;
+var winston = require('../../config/winston');
+
+// Exchange and routing key are fixed by chat21-server (WEBHOOK_MODE=queue).
+const CHAT21_WEBHOOK_EXCHANGE = 'chat21.webhooks';
+const CHAT21_WEBHOOK_ROUTING_KEY = 'chat21.webhook.event';
+
+const port = process.env.PORT || '3000';
+const apiEndpoint = process.env.API_ENDPOINT || ("http://localhost:" + port);
+
+function positiveNumber(value, defaultValue) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : defaultValue;
+}
+
+const config = {
+  queueName: process.env.CHAT21_WEBHOOK_QUEUE_NAME || 'chat21-webhooks',
+  // Max messages per second sent to the webhook API. 0 = unlimited.
+  rateLimit: positiveNumber(process.env.CHAT21_WEBHOOK_RATE_LIMIT, 0),
+  prefetch: positiveNumber(process.env.CHAT21_WEBHOOK_PREFETCH, 10),
+  apiUrl: process.env.CHAT21_WEBHOOK_API_URL || (apiEndpoint + "/chat21/requests"),
+  timeoutMs: positiveNumber(process.env.CHAT21_WEBHOOK_TIMEOUT_MS, 30000),
+  requeueDelayMs: positiveNumber(process.env.CHAT21_WEBHOOK_REQUEUE_DELAY_MS, 1000)
+};
+
+/**
+ * Spreads the executions so that at most ratePerSecond functions start every second.
+ */
+function createRateLimiter(ratePerSecond) {
+  const interval = ratePerSecond > 0 ? 1000 / ratePerSecond : 0;
+  let nextSlot = 0;
+  return {
+    schedule: function (fn) {
+      if (!interval) {
+        return fn();
+      }
+      const now = Date.now();
+      const at = Math.max(now, nextSlot);
+      nextSlot = at + interval;
+      setTimeout(fn, at - now);
+    }
+  };
+}
+
+/**
+ * Posts the chat21 event to the webhook API, the same call chat21-server makes in http mode.
+ * Resolves to 'ack' or 'requeue'.
+ */
+function handleMessage(msg, options) {
+  const opts = options || {};
+  const apiUrl = opts.apiUrl || config.apiUrl;
+  const timeoutMs = opts.timeoutMs || config.timeoutMs;
+  const post = opts.post || function (url, body) {
+    return axios.post(url, body, { timeout: timeoutMs, headers: { 'Content-Type': 'application/json' } });
+  };
+
+  let body;
+  try {
+    body = JSON.parse(msg.content.toString());
+  } catch (e) {
+    winston.error("[Chat21WebhookWorker] Discarding malformed message", e);
+    return Promise.resolve('ack');
+  }
+
+  return post(apiUrl, body).then(function (response) {
+    winston.debug("[Chat21WebhookWorker] event " + body.event_type + " delivered, status " + response.status);
+    return 'ack';
+  }).catch(function (err) {
+    const response = err && err.response;
+    if (!response) {
+      winston.error("[Chat21WebhookWorker] webhook API unreachable, requeueing event " + body.event_type + ": " + (err && err.message));
+      return 'requeue';
+    }
+    if (response.status < 500) {
+      // e.g. 400 'Not a support message': the event is not meant for tiledesk-server.
+      winston.debug("[Chat21WebhookWorker] event " + body.event_type + " rejected with status " + response.status);
+      return 'ack';
+    }
+    if (msg.fields && msg.fields.redelivered) {
+      winston.error("[Chat21WebhookWorker] event " + body.event_type + " failed again with status " + response.status + ", discarding it");
+      return 'ack';
+    }
+    winston.warn("[Chat21WebhookWorker] event " + body.event_type + " failed with status " + response.status + ", requeueing it");
+    return 'requeue';
+  });
+}
+
+function start(amqpConn, closeOnErr) {
+  const limiter = createRateLimiter(config.rateLimit);
+  winston.info("[Chat21WebhookWorker] queue: " + config.queueName + " exchange: " + CHAT21_WEBHOOK_EXCHANGE +
+    " routing key: " + CHAT21_WEBHOOK_ROUTING_KEY + " api: " + config.apiUrl +
+    " rate limit (msg/s): " + (config.rateLimit || "unlimited") + " prefetch: " + config.prefetch);
+
+  amqpConn.createChannel(function (err, ch) {
+    if (closeOnErr(err)) return;
+    ch.on("error", function (err) {
+      winston.error("[Chat21WebhookWorker] channel error", err);
+    });
+    ch.on("close", function () {
+      winston.info("[Chat21WebhookWorker] channel closed");
+    });
+    ch.prefetch(config.prefetch);
+    ch.assertExchange(CHAT21_WEBHOOK_EXCHANGE, 'topic', { durable: true });
+    ch.assertQueue(config.queueName, { durable: true }, function (err, _ok) {
+      if (closeOnErr(err)) return;
+      ch.bindQueue(_ok.queue, CHAT21_WEBHOOK_EXCHANGE, CHAT21_WEBHOOK_ROUTING_KEY, {}, function (err3, oka) {
+        winston.info("Queue bind: " + _ok.queue + " err: " + err3 + " key: " + CHAT21_WEBHOOK_ROUTING_KEY);
+      });
+
+      ch.consume(_ok.queue, function (msg) {
+        if (!msg) return;
+        limiter.schedule(function () {
+          handleMessage(msg).then(function (outcome) {
+            if (outcome === 'ack') {
+              safely(function () { ch.ack(msg); });
+            } else {
+              setTimeout(function () {
+                safely(function () { ch.nack(msg, false, true); });
+              }, config.requeueDelayMs);
+            }
+          });
+        });
+      }, { noAck: false });
+      winston.info("[Chat21WebhookWorker] Worker is started");
+    });
+  });
+}
+
+// ack/nack throw if the channel has been closed meanwhile: the broker requeues the message anyway.
+function safely(fn) {
+  try {
+    fn();
+  } catch (e) {
+    winston.warn("[Chat21WebhookWorker] ack/nack failed", e.message);
+  }
+}
+
+module.exports = {
+  CHAT21_WEBHOOK_EXCHANGE: CHAT21_WEBHOOK_EXCHANGE,
+  CHAT21_WEBHOOK_ROUTING_KEY: CHAT21_WEBHOOK_ROUTING_KEY,
+  config: config,
+  createRateLimiter: createRateLimiter,
+  handleMessage: handleMessage,
+  start: start
+};

package/pubmodules/queue/queueTopicsFilter.js

@@ -0,0 +1,36 @@
+
+function parseList(value) {
+  if (!value) {
+    return [];
+  }
+  return value.split(",").map(function (t) { return t.trim(); }).filter(function (t) { return t.length > 0; });
+}
+
+/**
+ * Selects the routing keys the worker binds to, based on INCLUDE_QUEUE / EXCLUDE_QUEUE
+ * (comma separated routing keys, mutually exclusive).
+ * Returns { enabled, disabled, unknown, filtered }.
+ */
+function resolveTopics(allTopics, includeValue, excludeValue) {
+  const include = parseList(includeValue);
+  const exclude = parseList(excludeValue);
+
+  if (include.length > 0 && exclude.length > 0) {
+    throw new Error("INCLUDE_QUEUE and EXCLUDE_QUEUE are mutually exclusive. Set only one of them.");
+  }
+
+  const selection = include.length > 0 ? include : exclude;
+  const unknown = selection.filter(function (t) { return allTopics.indexOf(t) === -1; });
+
+  let enabled;
+  if (include.length > 0) {
+    enabled = allTopics.filter(function (t) { return include.indexOf(t) !== -1; });
+  } else {
+    enabled = allTopics.filter(function (t) { return exclude.indexOf(t) === -1; });
+  }
+  const disabled = allTopics.filter(function (t) { return enabled.indexOf(t) === -1; });
+
+  return { enabled: enabled, disabled: disabled, unknown: unknown, filtered: selection.length > 0 };
+}
+
+module.exports = { parseList: parseList, resolveTopics: resolveTopics };

package/pubmodules/queue/reconnect.js

@@ -8,6 +8,8 @@ const botEvent = require('../../event/botEvent');
 const authEvent = require('../../event/authEvent');
 const kbEvent = require('../../event/kbEvent');
 const projectUserUpdateContextUtil = require('../../utils/projectUserUpdateContextUtil');
+const queueTopicsFilter = require('./queueTopicsFilter');
+const chat21WebhookWorker = require('./chat21WebhookWorker');
 // https://elements.heroku.com/addons/cloudamqp
 // https://gist.github.com/carlhoerberg/006b01ac17a0a94859ba#file-reconnect-js
 // http://www.rabbitmq.com/tutorials/tutorial-one-javascript.html
@@ -36,6 +38,63 @@ var exchange = process.env.QUEUE_EXCHANGE_TOPIC || 'amq.topic';
 var queueName = process.env.QUEUE_NAME || 'jobs';
 winston.info("Durable queue: " + durable + " Persistent queue: " + persistent + " Exchange topic: " + exchange+ " Queue name: " + queueName);
 
+// Routing keys bound to the jobs queue (QUEUE_NAME) on the tiledesk exchange.
+const JOBS_TOPICS = [
+  "request_create",
+  "request_update_preflight",
+  "request_participants_update",
+  "request_participants_join",
+  "request_participants_leave",
+  "request_assigned",
+  "request_update",
+  "request_close",
+  "request_close_extended",
+  "request_workingStatus_update",
+  "message_create",
+  "project_user_update",
+  "project_user_invite",
+  "project_user_invite_pending",
+  "project_user_delete",
+  "faqbot_update",
+  "faqbot_created",
+  "faqbot_deleted",
+  "faqbot_publish",
+  "kb_namespace_create",
+  "kb_namespace_delete",
+  "kb_contents_add",
+  "kb_contents_delete",
+  "kb_content_delete",
+  "lead_create",
+  "lead_update",
+  "lead_fullname_email_update",
+  "request_snapshot_update"
+];
+// Consumed from its own queue (CHAT21_WEBHOOK_QUEUE_NAME), see chat21WebhookWorker.js.
+const CHAT21_WEBHOOK_TOPIC = chat21WebhookWorker.CHAT21_WEBHOOK_ROUTING_KEY;
+const ALL_WORKER_TOPICS = JOBS_TOPICS.concat([CHAT21_WEBHOOK_TOPIC]);
+
+var topicsSelection = { enabled: ALL_WORKER_TOPICS, disabled: [], unknown: [], filtered: false };
+var enabledJobsTopics = JOBS_TOPICS;
+var disabledJobsTopics = [];
+var chat21WebhookEnabled = true;
+
+// Applies INCLUDE_QUEUE / EXCLUDE_QUEUE so that dedicated worker replicas can be deployed.
+// Replicas with different filters on the jobs topics must use different QUEUE_NAME values:
+// bindings belong to the queue, so replicas sharing a queue share its bindings.
+function resolveWorkerTopics() {
+  topicsSelection = queueTopicsFilter.resolveTopics(ALL_WORKER_TOPICS, process.env.INCLUDE_QUEUE, process.env.EXCLUDE_QUEUE);
+  if (topicsSelection.unknown.length > 0) {
+    winston.warn("INCLUDE_QUEUE/EXCLUDE_QUEUE contain unknown routing keys: " + topicsSelection.unknown.join(","));
+  }
+  enabledJobsTopics = JOBS_TOPICS.filter(function(t) { return topicsSelection.enabled.indexOf(t) !== -1; });
+  disabledJobsTopics = JOBS_TOPICS.filter(function(t) { return topicsSelection.enabled.indexOf(t) === -1; });
+  chat21WebhookEnabled = topicsSelection.enabled.indexOf(CHAT21_WEBHOOK_TOPIC) !== -1;
+  winston.info("Worker topics enabled: " + topicsSelection.enabled.join(","));
+  if (topicsSelection.disabled.length > 0) {
+    winston.info("Worker topics disabled: " + topicsSelection.disabled.join(","));
+  }
+}
+
 
 function start() {
   amqp.connect(url, function(err, conn) {
@@ -122,6 +181,13 @@ function publish(exchange, routingKey, content) {
 // A worker that acks messages only if processed succesfully
 // var channel;
 function startWorker() {
+    if (chat21WebhookEnabled) {
+      chat21WebhookWorker.start(amqpConn, closeOnErr);
+    }
+    if (enabledJobsTopics.length === 0) {
+      winston.info("Queue " + queueName + " not consumed: no jobs topic enabled by INCLUDE_QUEUE/EXCLUDE_QUEUE");
+      return;
+    }
     amqpConn.createChannel(function(err, ch) {
       if (closeOnErr(err)) return;
       ch.on("error", function(err) {
@@ -139,143 +205,21 @@ function startWorker() {
       ch.assertQueue(queueName, { durable: durable }, function(err, _ok) {
       // ch.assertQueue("jobs", { durable: true }, function(err, _ok) {
         if (closeOnErr(err)) return;
-        ch.bindQueue(_ok.queue, exchange, "request_create", {}, function(err3, oka) {
-            winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: request_create");
-            winston.info("Data queue", oka)
-        });
-        ch.bindQueue(_ok.queue, exchange, "request_update_preflight", {}, function(err3, oka) {
-            winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: request_update_preflight");
+        enabledJobsTopics.forEach(function(topic) {
+          ch.bindQueue(_ok.queue, exchange, topic, {}, function(err3, oka) {
+            winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: "+topic);
             winston.info("Data queue", oka)
-        });
-        ch.bindQueue(_ok.queue, exchange, "request_participants_update", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: request_participants_update");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "request_participants_join", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: request_participants_join");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "request_participants_leave", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: request_participants_leave");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "request_assigned", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: request_assigned");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "request_update", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: request_update");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "request_close", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: request_close");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "request_close_extended", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: request_close_extended");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "request_workingStatus_update", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: request_workingStatus_update");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "message_create", {}, function(err3, oka) {
-              winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: message_create");
-              winston.info("Data queue", oka)
-        });
-        ch.bindQueue(_ok.queue, exchange, "project_user_update", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: project_user_update");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "project_user_invite", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: project_user_invite");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "project_user_invite_pending", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: project_user_invite_pending");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "project_user_delete", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: project_user_delete");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "faqbot_update", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: faqbot_update");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "faqbot_created", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: faqbot_created");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "faqbot_deleted", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: faqbot_deleted");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "faqbot_publish", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: faqbot_publish");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "kb_namespace_create", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: kb_namespace_create");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "kb_namespace_delete", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: kb_namespace_delete");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "kb_contents_add", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: kb_contents_add");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "kb_contents_delete", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: kb_contents_delete");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "kb_content_delete", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: kb_content_delete");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "lead_create", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: lead_create");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "lead_update", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: lead_update");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "lead_fullname_email_update", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: lead_fullname_email_update");
-          winston.info("Data queue", oka)
-        });
-
-        ch.bindQueue(_ok.queue, exchange, "request_snapshot_update", {}, function(err3, oka) {
-          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: request_snapshot_update");
-          winston.info("Data queue", oka)
+          });
         });
 
+        if (topicsSelection.filtered) {
+          // Remove bindings left on the queue by a previous configuration.
+          disabledJobsTopics.forEach(function(topic) {
+            ch.unbindQueue(_ok.queue, exchange, topic, {}, function(err3) {
+              winston.info("Queue unbind: "+_ok.queue+ " err: "+err3+ " key: "+topic);
+            });
+          });
+        }
 
         ch.consume(queueName, processMsg, { noAck: false });
         winston.info("Worker is started");
@@ -804,6 +748,12 @@ function listen() {
 }
 
 if (process.env.QUEUE_ENABLED === "true") {
+    try {
+      resolveWorkerTopics();
+    } catch (e) {
+      winston.error("Invalid worker queue configuration: " + e.message);
+      process.exit(1);
+    }
     requestEvent.queueEnabled = true;
     messageEvent.queueEnabled = true;
     authEvent.queueEnabled = true;

package/pubmodules/queue/test/queueWorker.test.js

@@ -0,0 +1,131 @@
+// During the test the env variable is set to test
+process.env.NODE_ENV = 'test';
+
+const { expect } = require('chai');
+const queueTopicsFilter = require('../queueTopicsFilter');
+const chat21WebhookWorker = require('../chat21WebhookWorker');
+
+const TOPICS = ['request_create', 'message_create', 'chat21.webhook.event'];
+
+function makeMsg(body, redelivered) {
+  return {
+    content: Buffer.from(typeof body === 'string' ? body : JSON.stringify(body)),
+    fields: { redelivered: !!redelivered }
+  };
+}
+
+function httpError(status) {
+  const err = new Error('Request failed with status code ' + status);
+  err.response = { status: status };
+  return err;
+}
+
+describe('queue worker', function () {
+
+  describe('INCLUDE_QUEUE / EXCLUDE_QUEUE', function () {
+    it('enables every topic when no filter is set', function () {
+      const res = queueTopicsFilter.resolveTopics(TOPICS, undefined, '');
+      expect(res.enabled).to.deep.equal(TOPICS);
+      expect(res.disabled).to.deep.equal([]);
+      expect(res.filtered).to.equal(false);
+    });
+
+    it('INCLUDE_QUEUE enables only the listed topics', function () {
+      const res = queueTopicsFilter.resolveTopics(TOPICS, ' chat21.webhook.event ', undefined);
+      expect(res.enabled).to.deep.equal(['chat21.webhook.event']);
+      expect(res.disabled).to.deep.equal(['request_create', 'message_create']);
+      expect(res.filtered).to.equal(true);
+    });
+
+    it('EXCLUDE_QUEUE disables the listed topics', function () {
+      const res = queueTopicsFilter.resolveTopics(TOPICS, undefined, 'chat21.webhook.event,request_create');
+      expect(res.enabled).to.deep.equal(['message_create']);
+      expect(res.disabled).to.deep.equal(['request_create', 'chat21.webhook.event']);
+    });
+
+    it('reports unknown routing keys', function () {
+      const res = queueTopicsFilter.resolveTopics(TOPICS, 'message_create,not_a_topic', undefined);
+      expect(res.enabled).to.deep.equal(['message_create']);
+      expect(res.unknown).to.deep.equal(['not_a_topic']);
+    });
+
+    it('rejects INCLUDE_QUEUE and EXCLUDE_QUEUE set together', function () {
+      expect(function () {
+        queueTopicsFilter.resolveTopics(TOPICS, 'message_create', 'request_create');
+      }).to.throw(/mutually exclusive/);
+    });
+  });
+
+  describe('chat21 webhook event handling', function () {
+    const event = { event_type: 'message-sent', app_id: 'tilechat', data: { text: 'hello' } };
+
+    it('posts the event body to the chat21 webhook API and acks', async function () {
+      const calls = [];
+      const outcome = await chat21WebhookWorker.handleMessage(makeMsg(event), {
+        apiUrl: 'http://tiledesk/chat21/requests',
+        post: function (url, body) {
+          calls.push({ url: url, body: body });
+          return Promise.resolve({ status: 200 });
+        }
+      });
+      expect(outcome).to.equal('ack');
+      expect(calls).to.deep.equal([{ url: 'http://tiledesk/chat21/requests', body: event }]);
+    });
+
+    it('acks events rejected with a 4xx (e.g. not a support message)', async function () {
+      const outcome = await chat21WebhookWorker.handleMessage(makeMsg(event), {
+        post: function () { return Promise.reject(httpError(400)); }
+      });
+      expect(outcome).to.equal('ack');
+    });
+
+    it('requeues on 5xx the first time and discards on redelivery', async function () {
+      const post = function () { return Promise.reject(httpError(500)); };
+      expect(await chat21WebhookWorker.handleMessage(makeMsg(event, false), { post: post })).to.equal('requeue');
+      expect(await chat21WebhookWorker.handleMessage(makeMsg(event, true), { post: post })).to.equal('ack');
+    });
+
+    it('requeues when the API is unreachable', async function () {
+      const outcome = await chat21WebhookWorker.handleMessage(makeMsg(event, true), {
+        post: function () { return Promise.reject(new Error('connect ECONNREFUSED')); }
+      });
+      expect(outcome).to.equal('requeue');
+    });
+
+    it('discards malformed messages', async function () {
+      let called = false;
+      const outcome = await chat21WebhookWorker.handleMessage(makeMsg('not json'), {
+        post: function () { called = true; return Promise.resolve({ status: 200 }); }
+      });
+      expect(outcome).to.equal('ack');
+      expect(called).to.equal(false);
+    });
+  });
+
+  describe('rate limiter', function () {
+    it('runs immediately when unlimited', function () {
+      let runs = 0;
+      const limiter = chat21WebhookWorker.createRateLimiter(0);
+      for (let i = 0; i < 5; i++) limiter.schedule(function () { runs++; });
+      expect(runs).to.equal(5);
+    });
+
+    it('spreads executions according to the rate', function (done) {
+      const starts = [];
+      const limiter = chat21WebhookWorker.createRateLimiter(20); // one every 50ms
+      const begin = Date.now();
+      for (let i = 0; i < 5; i++) {
+        limiter.schedule(function () {
+          starts.push(Date.now() - begin);
+          if (starts.length === 5) {
+            expect(starts[4]).to.be.at.least(190);
+            for (let j = 1; j < starts.length; j++) {
+              expect(starts[j] - starts[j - 1]).to.be.at.least(40);
+            }
+            done();
+          }
+        });
+      }
+    });
+  });
+});