@sera4/essentia 1.0.37 → 1.0.39

package/cache/index.js

@@ -0,0 +1,188 @@
+"use strict"
+
+import { promisify } from "util";
+
+const isEmpty = obj => [Object, Array].includes((obj || {}).constructor) && !Object.entries((obj || {})).length;
+
+class CacheConfigError extends Error {
+  constructor(m) {
+    super(m);
+  }
+}
+
+/* Redis cache helper
+ * Example use: Place the following code in your project to setup redis use
+ *
+ *    import { cache } from "@sera4/essentia";
+ *    const cacheHelper = cache({ password: .., database: .., host: .., port: .. }, "service:"));
+ *
+ */
+
+const convertRedisKeyValueToJson = (v) => {
+  return (v && v.length > 0 && v[0] !== null) ? JSON.parse(v) : null;
+}
+
+const convertRedisHashToJson = (v) => {
+  if (v) {
+    var result = {};
+    for(var k in v) {
+      if (v.hasOwnProperty(k)) {
+        result[k] = JSON.parse(v[k]);
+      }
+    }
+    return result;
+  } else {
+    return null;
+  }
+}
+
+function convertJsonToRedisValue(j) {
+  var result = {};
+  for (var key in j) {
+    if (j.hasOwnProperty(key)) {
+      result[key] = JSON.stringify(j[key]);
+    }
+  }
+  return result;
+}
+
+class Cache {
+  constructor(config, servicePrefix) {
+    if ((config == undefined) || isEmpty(config)) {
+      throw new CacheConfigError("Invalid cache configuration");
+    }
+
+    if (servicePrefix == null) {
+      throw new CacheConfigError("Invalid service prefix");
+    }
+
+    if (config.fake) {
+      // used in testing
+      this.redisClient = require("fakeredis").createClient("fake backend")
+    } else {
+      this.redisClient = require("redis").createClient(config);
+    }
+
+    this.redisClient.on("error", (err) => {
+      logger.error("Cache/Redis error: ", err);
+    });
+
+    this.servicePrefix = servicePrefix;
+  }
+
+  ping() {
+    return this.redisClient.ping();
+  }
+
+  properKey(key, path) {
+    let p = this.servicePrefix + key
+    if (path)
+      p += path
+    return p
+  }
+
+  writeHash(path, key, value) {
+    return this.redisClient.hsetAsync(properKey(key), key, value);
+  }
+
+  writeHashBlocking(path, key, value) {
+    return this.redisClient.hset(properKey(key), key, value);
+  }
+
+  // write multiple hash keys and stringify every value
+  writeMultiHash(path, j) {
+    return this.redisClient.hmsetAsync(properKey(key), convertJsonToRedisValue(j));
+  }
+
+  readHashKey(obj, key, autoConvert=true) {
+    var k = autoConvert;
+
+    return new Promise((resolve, reject) => {
+      this.redisClient.hget(properKey(key, obj), key, (e, r) => {
+        if (e) {
+          logger.error("Redis hmget error:", e);
+          reject(e);
+        } else {
+          resolve(k ? convertRedisKeyValueToJson(r) : r);
+        }
+      });
+    });
+  }
+
+  readHash(path) {
+    return new Promise((resolve, reject) => {
+      this.redisClient.hgetall(properKey(key, path), (e, r) => {
+        if (e) {
+          console.log("Redis hget error:", e);
+          reject(e);
+        } else {
+          resolve(convertRedisHashToJson(r));
+        }
+      });
+    });
+  }
+
+  deleteHashKey(hash, key) {
+    return new Promise((resolve, reject) => {
+      this.redisClient.hdel(properKey(key, hash), key, (err) => {
+        if (err) {
+          logger.error("Redis hdel error:", err);
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  get(key) {
+    return this.redisClient.getAsync(properKey(key));
+  }
+
+  getAsync(key) {
+    return promisify(this.redisClient.get(key)).bind(this.redisClient)
+  }
+
+
+  /* a single key write with optional expiry */
+  // returns bluebird promise
+  writeKey(key, value, expiry) {
+    key = this.servicePrefix + key;
+    if (expiry) {
+      return this.redisClient.setAsync(key, value, "EX", expiry);
+    } else {
+      return this.redisClient.setAsync(key, value);
+    }
+  }
+
+  deleteKey(key) {
+    return redisClient.delAsync(properKey(key));
+  }
+
+  expire(path, expiry) {
+    return this.redisClient.expire(path, expiry);
+  }
+
+  exists(path) {
+    return this.redisClient.exists(path);
+  }
+
+  deleteAllKeys() {
+    return new Promise((resolve, reject) => {
+      if(process.env.NODE_ENV === "production") {
+        throw new Error("Clearing system cache is not permitted in production");
+      }
+      this.redisClient.flushdb((err, res) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(res);
+        }
+      });
+    });
+  }
+}
+
+export default function(config, servicePrefix) {
+  return new Cache(config, servicePrefix)
+}

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 = {
@@ -33,7 +35,8 @@ class HealthCheck {
     this.healthChecks = [];
   }
 
-  /* call this with an async function, must support wait capability
+  /* Deprecated and replaced by setupCheck
+   *   call this with an async function, must support wait capability
    *
    *   const dbCheck = async () => {
    *     return { name: "db", "result": "success", critical: false };
@@ -60,15 +63,38 @@ class HealthCheck {
     return router
   }
 
-  /* performs health checks and returns 200 if true and 500 if not */
+  // v2 version of health check, replaced addCheck
+  // example:
+  //  const checkRedisFcn = async () => { await cache.ping().then(() => true) }
+  //  setupCheck({ name: "redis", checkResult: false, critical: false, healthFunction: checkRedisFcn });
+  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 {
+          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 +104,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,33 +123,36 @@ 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);
       }
     } catch(error) {
+      console.debug("error: ", error)
       res.status(500).send();
     }
   }

package/package.json

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