@tiledesk/tiledesk-server 2.3.6 → 2.3.7-1.2

package/pubmodules/queue/reconnectFanout.js

@@ -0,0 +1,256 @@
+var amqp = require('amqplib/callback_api');
+var winston = require('../../config/winston');
+const requestEvent = require('../../event/requestEvent');
+const messageEvent = require('../../event/messageEvent');
+const authEvent = require('../../event/authEvent');
+// https://elements.heroku.com/addons/cloudamqp
+// https://gist.github.com/carlhoerberg/006b01ac17a0a94859ba#file-reconnect-js
+// http://www.rabbitmq.com/tutorials/tutorial-one-javascript.html
+
+// if the connection is closed or fails to be established at all, we will reconnect
+var amqpConn = null;
+var url = process.env.CLOUDAMQP_URL + "?heartbeat=60" || "amqp://localhost";
+// attento devi aggiornare configMap di PRE E PROD
+// var url = process.env.AMQP_URL + "?heartbeat=60" || "amqp://localhost";
+
+// MOD0
+var exchange = 'ws';
+
+function start() {
+  amqp.connect(url, function(err, conn) {
+    if (err) {
+      winston.error("[AMQP Fanout]", err);
+      return setTimeout(start, 1000);
+    }
+    conn.on("error", function(err) {
+      if (err.message !== "Connection closing") {
+        winston.error("[AMQP Fanout] conn error", err);
+      }
+    });
+    conn.on("close", function() {
+      winston.error("[AMQP Fanout] reconnecting");
+      return setTimeout(start, 1000);
+    });
+
+    winston.info("[AMQP Fanout] connected");
+    amqpConn = conn;
+
+    whenConnected();
+  });
+}
+
+function whenConnected() {
+  startPublisher();
+  startWorker();
+}
+
+var pubChannel = null;
+var offlinePubQueue = [];
+function startPublisher() {
+  amqpConn.createConfirmChannel(function(err, ch) {
+    if (closeOnErr(err)) return;
+    ch.on("error", function(err) {
+      winston.error("[AMQP Fanout] channel error", err);
+    });
+    ch.on("close", function() {
+      winston.info("[AMQP Fanout] channel closed");
+    });
+
+    pubChannel = ch;
+    while (true) {
+      var m = offlinePubQueue.shift();
+      if (!m) break;
+      publish(m[0], m[1], m[2]);
+    }
+  });
+}
+
+// method to publish a message, will queue messages internally if the connection is down and resend later
+function publish(exchange, routingKey, content) {
+  try {
+
+    // MOD2 
+    // pubChannel.publish('logs', '', Buffer.from('Hello World!'));
+    pubChannel.publish(exchange, routingKey, content, { },
+    // pubChannel.publish(exchange, routingKey, content, { persistent: true },
+                       function(err, ok) {
+                         if (err) {
+                          winston.error("[AMQP Fanout] publish", err);
+                           offlinePubQueue.push([exchange, routingKey, content]);
+                           pubChannel.connection.close();
+                         }
+                       });
+  } catch (e) {
+    winston.error("[AMQP Fanout] publish", e);
+    offlinePubQueue.push([exchange, routingKey, content]);
+  }
+}
+
+// A worker that acks messages only if processed succesfully
+// var channel;
+function startWorker() {
+    amqpConn.createChannel(function(err, ch) {
+      if (closeOnErr(err)) return;
+      ch.on("error", function(err) {
+        winston.error("[AMQP Fanout] channel error", err);
+      });
+      ch.on("close", function() {
+        winston.info("[AMQP Fanout] channel closed");
+      });
+      ch.prefetch(10);//leggila da env
+
+      // ch.assertExchange(exchange, 'topic', {
+      //   durable: true
+      // });
+
+      // MOD1
+      ch.assertExchange(exchange, 'fanout', {durable: false});
+
+      //MOD3 
+      ch.assertQueue('', {exclusive: true}, function(err, _ok) {
+      // ch.assertQueue("jobs", { durable: true }, function(err, _ok) {
+
+        if (closeOnErr(err)) return;
+        
+      //MOD4 
+        ch.bindQueue(_ok.queue, exchange, '', {}, function(err3, oka) {
+          winston.info("Queue Fanout bind: "+_ok.queue+ " err: "+err3);
+          winston.info("Data Queue Fanout", oka)
+        });
+
+        // ch.bindQueue(_ok.queue, exchange, "request_create", {}, function(err3, oka) {
+        //     console.log("queue bind: "+_ok.queue+ " err: "+err3+ " key: request_create");
+        //     console.log("data queue", oka)
+        // });
+        // ch.bindQueue(_ok.queue, exchange, "request_update", {}, function(err3, oka) {
+        //     console.log("queue bind: "+_ok.queue+ " err: "+err3+ " key: request_update");
+        //     console.log("data queue", oka)
+        // });
+        // ch.bindQueue(_ok.queue, exchange, "message_create", {}, function(err3, oka) {
+        //       console.log("queue bind: "+_ok.queue+ " err: "+err3+ " key: message_create");
+        //       console.log("data queue", oka)
+        // });
+        // ch.bindQueue(_ok.queue, exchange, "project_user_update", {}, function(err3, oka) {
+        //   console.log("queue bind: "+_ok.queue+ " err: "+err3+ " key: project_user_update");
+        //   console.log("data queue", oka)
+        // });
+        ch.consume(_ok.queue, processMsg, { noAck: false });
+        winston.info("Worker Fanout is started");
+      });
+  
+
+    function processMsg(msg) {
+      work(msg, function(ok) {
+        try {
+          if (ok)
+            ch.ack(msg);
+          else
+            ch.reject(msg, true);
+        } catch (e) {
+          closeOnErr(e);
+        }
+      });
+    }
+  });
+}
+
+function work(msg, cb) {
+  const message_string = msg.content.toString();
+  const topic = msg.fields.routingKey //.replace(/[.]/g, '/');
+
+  winston.debug("Got Fanout msg topic:" + topic);
+  
+  winston.debug("Got Fanout msg:"+ message_string +  " topic:" + topic);
+
+  if (topic === 'request_create') {
+    winston.debug("reconnectfanout here topic:" + topic);
+    winston.debug("reconnect request.update")
+    requestEvent.emit('request.create.queue.pubsub', JSON.parse(message_string));
+  }
+  if (topic === 'request_update') {
+    winston.debug("reconnectfanout here topic:" + topic);
+    requestEvent.emit('request.update.queue.pubsub',  JSON.parse(message_string));
+  }
+  if (topic === 'message_create') {
+    winston.debug("reconnectfanout here topic:" + topic);
+    messageEvent.emit('message.create.queue.pubsub', JSON.parse(message_string));
+  }
+  if (topic === 'project_user_update') {
+    winston.debug("reconnectfanout here topic:" + topic);
+    authEvent.emit('project_user.update.queue.pubsub', JSON.parse(message_string));
+  }
+  cb(true);
+//   WebSocket.cb(true);
+//   requestEvent.on(msg.KEYYYYYYY+'.ws', msg.content);
+}
+
+
+function closeOnErr(err) {
+  if (!err) return false;
+  winston.error("[AMQP Fanout] error", err);
+  amqpConn.close();
+  return true;
+}
+
+// setInterval(function() {
+//     var d = new Date();
+//   publish(exchange, "request_create", Buffer.from("work work work: "+d));
+// }, 10000);
+
+
+
+// http://www.squaremobius.net/amqp.node/channel_api.html
+// https://docs.parseplatform.org/parse-server/guide/#scalability
+
+
+
+function listen() {
+    
+  requestEvent.on('request.create', function(request) {
+    setImmediate(() => {
+      publish(exchange, "request_create", Buffer.from(JSON.stringify(request)));
+    });
+  });
+
+  requestEvent.on('request.update', function(request) {
+    setImmediate(() => {
+      publish(exchange, "request_update", Buffer.from(JSON.stringify(request)));
+    });
+  });
+
+
+  messageEvent.on('message.create', function(message) {
+    setImmediate(() => {
+      publish(exchange, "message_create", Buffer.from(JSON.stringify(message)));
+    });
+  });
+  
+  authEvent.on('project_user.update',function(data) {
+    setImmediate(() => {
+      let user = undefined;
+      let body = undefined;
+        if (data.req ) {
+          if (data.req.user) { //i think is null from chat21webhook 
+            user = data.req.user;
+          }
+          if (data.req.body) {
+            body = data.req.body;
+          }
+        }
+        var dat = {updatedProject_userPopulated: data.updatedProject_userPopulated, req: {user: user, body: body}}; //remove request
+        winston.debug("dat",dat);
+
+      publish(exchange, "project_user_update", Buffer.from(JSON.stringify(dat)));
+    });
+  });
+}
+
+if (process.env.QUEUE_ENABLED === "true") {
+    requestEvent.queueEnabled = true;
+    messageEvent.queueEnabled = true;
+    authEvent.queueEnabled = true; 
+    listen();
+    start();
+    winston.info("Queue Fanout enabled. endpint: " + url );
+} 
+

package/pubmodules/rasa/listener.js

@@ -6,7 +6,7 @@ var configGlobal = require('../../config/global');
 
 var port = process.env.PORT || '3000';
 
-const BOT_RASA_ENDPOINT = "http://localhost:" + port+ "/modules/rasa/rasabot" ||  process.env.BOT_RASA_ENDPOINT;
+const BOT_RASA_ENDPOINT = process.env.BOT_RASA_ENDPOINT || "http://localhost:" + port+ "/modules/rasa/rasabot";
 winston.debug("BOT_RASA_ENDPOINT: " + BOT_RASA_ENDPOINT);
 
 // if (BOT_RASA_ENDPOINT) {
@@ -23,7 +23,7 @@ class Listener {
     listen(config) {
 
         winston.info('Rasa Listener listen');
-        winston.debug("config databaseUri: " + config.databaseUri);  
+        winston.debug("rasa config databaseUri: " + config.databaseUri);  
         
 
         var that = this;
@@ -34,7 +34,7 @@ class Listener {
                 KVBASE_COLLECTION : process.env.KVBASE_COLLECTION,
                 MONGODB_URI: config.databaseUri,          
                 API_ENDPOINT: apiUrl,   
-                log: true
+                log: process.env.RASABOT_LOG
             }, () => {
                 winston.info("RASA proxy server successfully started.");   
             });
@@ -44,10 +44,10 @@ class Listener {
         botEvent.on('faqbot.create', function(bot) {
             if (BOT_RASA_ENDPOINT) {
 
-                winston.info('bot.type:'+bot.type); 
+                winston.debug('bot.type:'+bot.type); 
                 if (bot.type==="rasa") {
 
-                    winston.info('qui.type:'+bot.type); 
+                    winston.debug('qui.type:'+bot.type); 
 
 
                     Faq_kb.findByIdAndUpdate(bot.id, {"url":BOT_RASA_ENDPOINT}, { new: true, upsert: true }, function (err, savedFaq_kb) {

package/pubmodules/routing-queue/index.js

@@ -0,0 +1,3 @@
+const listener = require("./listener");
+
+module.exports = {listener:listener };

package/pubmodules/routing-queue/listener.js

@@ -0,0 +1,328 @@
+const projectEvent = require('../../event/projectEvent');
+const departmentEvent = require('../../event/departmentEvent');
+const authEvent = require('../../event/authEvent');
+const requestEvent = require('../../event/requestEvent');
+var Request = require('../../models/request');
+var Project = require('../../models/project');
+var Project_user = require('../../models/project_user');
+var winston = require('../../config/winston');
+
+var ProjectUserUtil = require("../../utils/project_userUtil");
+
+// var request = require('retry-request', {
+//     request: require('request')
+//   });
+
+// TODO riabilitare questo
+
+// const ROUTE_QUEUE_ENDPOINT = process.env.ROUTE_QUEUE_ENDPOINT;
+// winston.debug("ROUTE_QUEUE_ENDPOINT: " + ROUTE_QUEUE_ENDPOINT);
+
+// if (ROUTE_QUEUE_ENDPOINT) {
+//   winston.info("Route queue endpoint: " + ROUTE_QUEUE_ENDPOINT);
+// } else {
+//    winston.info("Route queue endpoint not configured");
+// }
+
+
+class Listener {
+
+ 
+  constructor() {
+    this.enabled = true;
+    if (process.env.ROUTE_QUEUE_ENABLED=="false" || process.env.ROUTE_QUEUE_ENABLED==false) {
+        this.enabled = false;
+    }
+    winston.debug("Listener this.enabled: "+ this.enabled);
+}
+
+     nextOperator(array, index) {
+        // console.log('array: ', array);
+        // console.log('index: ' + index);
+    
+        index = index || 0;
+    
+        if (array === undefined || array === null)
+          array = [];
+        else if (!Array.isArray(array))
+          throw new Error('Expecting argument to RoundRound to be an Array');
+    
+        // return function () {
+            index++;
+          if (index >= array.length) index = 0;
+          // console.log('index: ' + index);
+          return array[index];
+        // };
+      }
+
+      // db.getCollection('project_users').find({"number_assigned_requests" : {"$lt":0}}).count()
+
+
+    updateProjectUser(id_user, id_project, operation) {
+      winston.debug("updateProjectUser start");
+      return Project_user       
+                    .findOneAndUpdate({id_user: id_user, id_project: id_project}, {$inc : {'number_assigned_requests' : operation}}, {new: true, upsert:false}, function(err, updatedPU) {
+                    if (err) {
+                     return winston.error(err);
+                    }
+                    winston.debug("number_assigned_requests +1 :" + updatedPU.id);
+
+                    updatedPU.populate({path:'id_user', select:{'firstname':1, 'lastname':1}},function (err, updatedProject_userPopulated){    
+
+                      var pu = updatedProject_userPopulated.toJSON();
+
+                      return Project.findById(id_project).exec(function(err, project) {
+                        pu.isBusy = ProjectUserUtil.isBusy(updatedProject_userPopulated, project.settings && project.settings.max_agent_assigned_chat);                  
+                        winston.debug("pu.isBusy: "+ pu.isBusy);
+                        authEvent.emit('project_user.update', {updatedProject_userPopulated:pu, req: undefined, skipArchive: true});
+                      })
+                      
+                    });
+
+                });
+    }
+
+    updateParticipatingProjectUsers(request, operation) {
+        winston.debug("request.participatingAgents", request.participatingAgents);
+        if (request.participatingAgents.length>0) {
+            request.participatingAgents.forEach(user => {
+              winston.debug("request.participatingAgents user",user); //it is a user and not a project_user
+                this.updateProjectUser(user.id, request.id_project, operation);                
+            });
+        } 
+      }  
+
+    listen() {
+
+      if (this.enabled==true) {
+        winston.info("Route queue Listener listen");
+      } else {
+          return winston.info("Route queue Listener disabled");
+      }
+
+        var that = this;
+ 
+        // TODO fai versione che passa anche project
+        requestEvent.on('request.create', async (request) => {
+            setImmediate(() => {
+              this.updateParticipatingProjectUsers(request, +1);  
+            });
+        });
+
+          // TODO usa versione complete con project per evitare query??
+        requestEvent.on('request.close', async (request) => {
+          setImmediate(() => {
+            this.updateParticipatingProjectUsers(request, -1);          
+          });
+        });
+
+
+        requestEvent.on('request.participants.join', async (data) => {
+          var request = data.request;
+          var member = data.member;
+          setImmediate(() => {
+            this.updateProjectUser(member, request.id_project, 1);          
+          });
+        });
+
+        requestEvent.on('request.participants.leave', async (data) => {
+          var request = data.request;
+          var member = data.member;
+          setImmediate(() => {
+            this.updateProjectUser(member, request.id_project, -1);          
+          });
+        });
+
+        requestEvent.on('request.participants.update', async (data) => {
+          var request = data.request;
+          var removedParticipants = data.removedParticipants;
+          var addedParticipants = data.addedParticipants;
+
+          setImmediate(() => {
+
+            addedParticipants.forEach(participant => {
+              winston.debug('addedParticipants participant', participant);
+              this.updateProjectUser(participant, request.id_project, 1);          
+            });
+
+            removedParticipants.forEach(participant => {
+              winston.debug('removedParticipants participant', participant);
+              this.updateProjectUser(participant, request.id_project, -1);          
+            });
+
+          });
+        });
+
+        departmentEvent.on('operator.select.base2', async (res) => {
+            // departmentEvent.prependListener('operator.select', async (data) => {
+            
+              var operatorsResult = res.result;
+              winston.debug('operator.select.base2 res', res);   
+          
+          
+              var disableWebHookCall = res.disableWebHookCall;
+              winston.debug("operator.select.base2 disableWebHookCall: "+ disableWebHookCall);
+          
+            if (disableWebHookCall===true) {      
+              winston.debug("operator.select.base2 disableWebHookCall enabled: "+ disableWebHookCall);
+              // return callNextEvent('operator.select', res);
+              return res.resolve(operatorsResult);
+          
+            }
+          
+          
+          
+          
+          
+          
+          
+          
+            var project = operatorsResult.project;
+            var max_agent_assigned_chat = undefined;
+          
+            
+            // console.log("project: ", project);
+          
+            if (project && project.settings && project.settings.chat_limit_on && project.settings.max_agent_assigned_chat) {
+              max_agent_assigned_chat = project.settings.max_agent_assigned_chat;
+              winston.debug('operator.select max_agent_assigned_chat: '+max_agent_assigned_chat);   
+          
+            } else {
+              winston.debug("chat_limit_on not defined calling next ");
+              return departmentEvent.callNextEvent('operator.select', res);
+            }
+          
+          
+             
+          
+            // winston.info('qui', operatorsResult.available_agents.length);   
+            operatorsResult.available_agents_request  = [];
+          
+            if (operatorsResult && operatorsResult.available_agents && operatorsResult.available_agents.length > 0) {        
+          
+              // winston.info('qui1');   
+               //  qui1000
+              var query = {id_project: operatorsResult.id_project, status: {$lt:1000}};      
+              // asyncForEach(operatorsResult.available_agents, async (aa) => {
+              for (const aa of operatorsResult.available_agents) {
+                query.participants = aa.id_user._id.toString();// attento qui
+                winston.debug("department operators query:" , query);
+
+
+                // questa cosa nn va bene. nn puoi usare ? number_assigned_requests??
+                var count =  await Request.countDocuments(query);
+                winston.debug("department operators count: "+ count);
+                operatorsResult.available_agents_request.push({project_user: aa, openRequetsCount : count});
+          
+              }
+          
+            }
+          
+          
+
+         
+             
+          
+              var available_agents_request = operatorsResult.available_agents_request;
+              var available_agents_not_busy = [];
+              if (available_agents_request && available_agents_request.length>0) {
+                for (const aa of available_agents_request) {
+                // console.log("aa.openRequetsCount ", aa.openRequetsCount, " for:", aa.project_user.id_user);
+          
+                  var maxAssignedchatForUser = max_agent_assigned_chat;
+          
+                  var max_agent_assigned_chat_specific_user = aa.project_user.max_assigned_chat;
+                  // console.log("max_agent_assigned_chat_specific_user: ", max_agent_assigned_chat_specific_user);
+          
+                  if (max_agent_assigned_chat_specific_user && max_agent_assigned_chat_specific_user!=-1 ) {
+                    maxAssignedchatForUser = max_agent_assigned_chat_specific_user;           
+                  }            
+                  
+                  winston.debug("maxAssignedchatForUser: "+ maxAssignedchatForUser);
+          
+                  if (aa.openRequetsCount < maxAssignedchatForUser) {
+                    winston.debug("adding  "+ aa.project_user.id_user+ " with openRequetsCount: "+ aa.openRequetsCount +" and with maxAssignedchatForUser " + maxAssignedchatForUser +" to available_agents_not_busy" );
+                    available_agents_not_busy.push(aa.project_user);
+                  }
+                }
+              } else {
+                winston.debug("available_agents_request not defined");
+              }
+          
+              winston.debug("available_agents_not_busy", available_agents_not_busy);
+          
+          
+
+                 // TODO non riassegnare allo stesso utente usa history oppure lastabandonedby in attributes 
+            // in project_user sengni il numero di abandoni se uguale a psettng lo metto offline
+            winston.debug("res.context",res.context);  
+
+            winston.debug("res.context.request.attributes",res.context.request.attributes);  
+
+              if (res.context && res.context.request  && res.context.request && 
+                res.context.request.attributes && res.context.request.attributes.abandoned_by_project_users ) {  //&& res.context.request.attributes.queue_important==false  (vip sla continuo reassign)
+                  
+                  // var abandoned_by_project_users= {"5ecd44cfa3f5670034109b44":true,"5ecd56a10e7d2d00343203cc":true}
+
+                  winston.debug("res.context.request.attributes.abandoned_by_project_users: ", res.context.request.attributes.abandoned_by_project_users );
+                  
+                  var abandoned_by_project_usersAsArray = Object.keys(res.context.request.attributes.abandoned_by_project_users);
+
+                  if (abandoned_by_project_usersAsArray.length>0 )  {
+                    winston.debug("abandoned_by_project_usersAsArray", abandoned_by_project_usersAsArray);
+
+                    var available_agents_not_busy = available_agents_not_busy.filter(projectUser=> !abandoned_by_project_usersAsArray.includes(projectUser._id.toString()))
+                  
+                    winston.debug("available_agents_not_busy after: ", available_agents_not_busy );                           
+                  }
+              }
+
+              // if (res.context && res.context.request  && res.context.request && 
+              //   res.context.request.attributes && res.context.request.attributes.last_abandoned_by )  {
+              //     winston.debug("res.context.request.attributes.last_abandoned_by: "+res.context.request.attributes.last_abandoned_by );
+              //     let last_abandoned_by_index = available_agents_not_busy.findIndex(projectUser => projectUser._id.toString() === res.context.request.attributes.last_abandoned_by);
+              //     winston.debug("last_abandoned_by_index: "+last_abandoned_by_index );
+              //     if (last_abandoned_by_index>-1) {
+              //       available_agents_not_busy.splice(last_abandoned_by_index, 1);
+              //       winston.debug("available_agents_not_busy after", available_agents_not_busy );
+              //     }                  
+
+              // }
+
+
+              var lastOperatorId  = operatorsResult.lastOperatorId;
+          
+              let lastOperatorIndex = available_agents_not_busy.findIndex(projectUser => projectUser.id_user.toString() === lastOperatorId);
+              winston.debug("lastOperatorIndex: "+ lastOperatorIndex);
+              var nextOper = that.nextOperator(available_agents_not_busy, lastOperatorIndex);
+              // console.log("nextOper: ", nextOper);
+              var nextOperatorId = undefined; 
+              if (nextOper && nextOper.id_user) {
+                nextOperatorId = nextOper.id_user;
+                winston.verbose("nextOperatorId: "+ nextOperatorId);
+          
+                operatorsResult.operators = [{id_user: nextOperatorId}];
+          
+                // return resolve(result);
+              } else {
+                winston.debug("nextOper is not defined");
+                operatorsResult.operators = [];
+                // return resolve(result);
+              }
+          
+          
+              return departmentEvent.callNextEvent('operator.select', res);
+          
+           
+          
+          });
+
+       
+    }
+
+}
+
+var listener = new Listener();
+
+
+module.exports = listener;

package/pubmodules/rules/conciergeBot.js

@@ -198,7 +198,7 @@ devi mandare un messaggio welcome tu altrimenti il bot inserito successivamente
                                 "Chat closed", 
                                 request.id_project,
                                 'system', 
-                                {subtype:"info/support", "updateconversation" : false, messagelabel: {key: "CHAT_CLOSED"}},  
+                                {subtype:"info/support", "updateconversation" : false, messagelabel: {key: "CHAT_CLOSED"}},   // TODO send request.closed_by <- c'è il campo l'ho verificato
                                 undefined,
                                 request.language
                             );
@@ -228,7 +228,7 @@ devi mandare un messaggio welcome tu altrimenti il bot inserito successivamente
                                 request.request_id,
                                 "Chat reopened", 
                                 request.id_project,
-                                'system',                                      
+                                'system',                                       //changed from false to true 6Aug22 because reopen from dashboard history doesn't update convs in ionic
                                 {subtype:"info/support", "updateconversation" : true, messagelabel: {key: "CHAT_REOPENED"}},
                                 undefined,
                                 request.language

package/pubmodules/scheduler/tasks/closeAgentUnresponsiveRequestTask.js

@@ -90,7 +90,12 @@ findUnresponsiveRequests() {
           winston.verbose("CloseAgentUnresponsiveRequestTask: Request closed with request_id: " + request.request_id);
           // winston.info("Request closed",updatedStatusRequest);
         }).catch(function(err) {
-          winston.error("CloseAgentUnresponsiveRequestTask: Error closing the request with request_id: " + request.request_id, err);
+          if (process.env.HIDE_CLOSE_REQUEST_ERRORS == true || process.env.HIDE_CLOSE_REQUEST_ERRORS == "true" ) {
+
+          } else {
+            winston.error("CloseAgentUnresponsiveRequestTask: Error closing the request with request_id: " + request.request_id, err);
+          }
+          
         })
      
       });

package/pubmodules/scheduler/tasks/closeBotUnresponsiveRequestTask.js

@@ -65,6 +65,7 @@ findUnresponsiveRequests() {
     
   // db.getCollection('requests').find({"hasBot":true, "status": { "$lt": 1000 }, "createdAt":  { "$lte" :new ISODate("2020-11-28T20:15:31Z")} }).count()
     
+
     var query = {hasBot:true, status: { $lt: 1000 }, createdAt:  { $lte :new Date(Date.now() - this.queryAfterTimeout ).toISOString()} };
 
     if (this.queryProject) {
@@ -101,7 +102,12 @@ findUnresponsiveRequests() {
           winston.info("CloseBotUnresponsiveRequestTask: Request closed with request_id: " + request.request_id);
           // winston.info("Request closed",updatedStatusRequest);
         }).catch(function(err) {
-          winston.error("CloseBotUnresponsiveRequestTask: Error closing the request with request_id: " + request.request_id, err);
+          if (process.env.HIDE_CLOSE_REQUEST_ERRORS == true || process.env.HIDE_CLOSE_REQUEST_ERRORS == "true" ) {
+
+          } else {
+            winston.error("CloseBotUnresponsiveRequestTask: Error closing the request with request_id: " + request.request_id, err);
+          }
+          
         })
 
       });