@tiledesk/tiledesk-server 2.26.0 → 2.27.1

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/models/chat21SyncTrace.js

@@ -0,0 +1,53 @@
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+const TTL_SECONDS = 60 * 60 * 24 * 7; // 1 week
+
+const Chat21SyncTraceSchema = new Schema(
+  {
+    request_id: {
+      type: String,
+      required: false
+    },
+    id_project: {
+      type: String,
+      required: false
+    },
+    event: {
+      type: String,
+      required: true
+    },
+    step: {
+      type: String,
+      required: true
+    },
+    outcome: {
+      type: String,
+      enum: ['info', 'success', 'error', 'skipped'],
+      default: 'info'
+    },
+    data: {
+      type: Schema.Types.Mixed,
+      required: false
+    },
+    host: {
+      type: String,
+      required: false
+    },
+    pid: {
+      type: Number,
+      required: false
+    },
+    createdAt: {
+      type: Date,
+      default: Date.now
+    }
+  }
+);
+
+Chat21SyncTraceSchema.index({ request_id: 1, createdAt: 1 });
+Chat21SyncTraceSchema.index({ createdAt: 1 }, { expireAfterSeconds: TTL_SECONDS });
+
+const Chat21SyncTrace = mongoose.model('Chat21SyncTrace', Chat21SyncTraceSchema);
+
+module.exports = Chat21SyncTrace;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiledesk/tiledesk-server",
   "description": "The Tiledesk server module",
-  "version": "2.26.0",
+  "version": "2.27.1",
   "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
+};