@sera4/essentia 1.0.36 → 1.0.38

package/health/index.js

@@ -15,10 +15,12 @@ class HealthCheckError extends Error {
  *    const router = require('express').Router();
  *
  *      ....
+ *
+ *    const checkRedis = async () => { await cache.ping(); }
+ *    hc.setupCheck({ name: "redis", checkResult: false, critical: true, healthFunction: checkRedis });
  *    app.use(hc.defaultPath(serverConfigs.api_prefix), hc.routes(router));
  *
  */
-
 class HealthCheck {
   constructor(appendData = {}) {
     this.defaultResponse = {
@@ -60,15 +62,35 @@ class HealthCheck {
     return router
   }
 
+  // v2 version of health check
+  setupCheck(config) {
+    this.healthChecks.push(config);
+  }
+
   /* performs health checks and returns 200 if true and 500 if not */
   async checkHealth(req, res) {
     const checkFormat = pathHelper.extname(req.baseUrl);
 
-    try {
-      const result = await Promise.all(this.healthChecks.map(async healthCallback => {
-        return await healthCallback();
-      }));
+    const result = await Promise.all(this.healthChecks.map(async hc => {
+      if (typeof(hc) === "function") {
+        try {
+          return await hc();
+          return { "result": "success", critical: false };
+        } catch(e) {
+          return  { name: "unknown", result: 'fail', status: e.status }
+        }
+      } else {
+        let res = { name: hc.name, critical: hc.critical }
+        try {
+          return await hc.healthFunction();
+          return { ...res, "result": "success" };
+        } catch(e) {
+          return { ...res, "result": "fail", status: e.status } 
+        }
+      }
+    }));
 
+    try {
       let callId = ++this.lastCallId;
 
       // start the counter over
@@ -78,10 +100,18 @@ class HealthCheck {
 
       let status = this.defaultResponse.status;
 
+      let nonCriticalFail = false;
+      let criticalFail = false;
+
       result.some(e => {
         if (e.result.match(/fail/)) {
-          status = 500;
-          return true; // break
+          if (e.critical == false) {
+            nonCriticalFail = true;
+          } else {
+            criticalFail = true;
+            status = 500;
+            return true; // break
+          }
         }
       })
 
@@ -89,29 +119,31 @@ class HealthCheck {
       res.setHeader('check', callId)
 
       if (checkFormat === ".json") {
-        const payload = { "check": callId }
+        const payload = { "check": callId, healthy: "true", message: "success" }
 
-        if (status === 200) {
+        if (criticalFail) {
           res.status(status).json({
             ... payload,
-            "healthy":true,
-            "message":"success"
+            "healthy": false,
+            "message": "fail",
+            "services": [result]
           });
-        } else {
+        } else if (status === 200) {
+          res.status(status).json(payload);
+        } else if (nonCriticalFailure) {
           res.status(status).json({
             ... payload,
-            "healthy": false,
             "message": "fail",
             "services": [result]
           });
         }
       } else {
         let status_message;
-        if (status === 200) {
-          status_message = "success"
-        } else {
+        if (criticalFail) {
           status_message = "fail"
-        }
+        } else if ((status === 200) || nonCriticalFail) {
+          status_message = "success"
+        } 
 
         res.status(status).send(status_message);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sera4/essentia",
-  "version": "1.0.36",
+  "version": "1.0.38",
   "description": "A library of utilities for Teleporte Web Services",
   "main": "index.js",
   "scripts": {

package/queue/index.js

@@ -29,6 +29,7 @@ class S4Queue {
    */
   async testConnection() {
     if (!this.isConnected()) {
+      this.connectionTestChannel = null;
       throw("queue service not connected")
     }
 
@@ -72,12 +73,16 @@ class S4Queue {
       amqp.connect(options.connectionUrl, socketOptions, (err, conn) => {
 
         if (err) {
-          return reject(err);
+          logger.error("Error while connecting", err)
+          logger.error("Attempting again in", this.retry, "seconds");
+          return setTimeout(() => this.openConnection(options), this.retry * 1000);
         }
 
         this.connection = conn;
         if (!this.connection) {
           return reject(new Error("Failed to obtain connection"));
+        } else {
+          this.updatePubsAndSubsConnectionRef(conn);
         }
 
         this.connection.on("error", (err) => {
@@ -91,8 +96,8 @@ class S4Queue {
           logger.error("connection closed");
           this.connection = null;
           if (err) {
-            logger.debug("connection closed due to error:", err);
-            logger.debug("Reconnecting in", this.retry, "seconds");
+            logger.error("connection closed due to error:", err);
+            logger.error("Reconnecting in", this.retry, "seconds");
             setTimeout(() => this.openConnection(options), this.retry * 1000);
           } else {
             // If there was no error, it is us who closed
@@ -327,6 +332,29 @@ class S4Queue {
       }
     });
   }
+
+  /**
+   * Updates the connection reference to all the previously
+   * registered publishers and subscribers.
+   * After we successfully establish a connection and register pubs/subs,
+   * it's possible for the connection to break. This object will try
+   * to re-establish a new connection every 3 seconds (or whatever configuration is set)
+   * and if a new connection is established, we need to pass that connection to
+   * all our pubs/subs, otherwise they'll be operating with old/stale references
+   * @param {Object} connRef a new connection reference to the AMQP service
+   */
+  updatePubsAndSubsConnectionRef(connRef) {
+    Object.keys(this.pubs).forEach(k => {
+      logger.debug(`Updating publisher ${k} with a new connection object`);
+      const p = this.pubs[k];
+      p.init(connRef);
+    });
+    Object.keys(this.subs).forEach(k => {
+      logger.debug(`Updating subscriber ${k} with a new connection object`);
+      const s = this.subs[k];
+      s.init(connRef);
+    });
+  }
 }
 
 module.exports = new S4Queue();