exframe-cache-manager 2.0.3 → 2.0.4

package/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:14-alpine
+FROM node:16-alpine
 
 LABEL maintainer=Exzeo
 

package/index.js

@@ -4,6 +4,10 @@ const CacheManager = require('cache-manager');
 const RedisStore = require('cache-manager-redis-store');
 const util = require('util');
 const { lazyInstrument } = require('exframe-metrics');
+const health = require('exframe-health');
+const service = require('exframe-service');
+const { generateShortId } = require('exframe-utilities');
+const { setTimeout: waitTimeout } = require('timers/promises');
 
 const db = 0;
 
@@ -42,6 +46,7 @@ function cachemanager(options) {
   });
 
   const instance = {
+    id: generateShortId(),
     get cacheStorePool() {
       return redisClient;
     },
@@ -166,6 +171,28 @@ function cachemanager(options) {
     redisClient
   };
 
+  health.add(`redis-${instance.id}`, async () => {
+    try {
+      const controller = new AbortController();
+
+      const result = await Promise.race([
+        instance.healthCheck(),
+        waitTimeout(3000, false, { signal: controller.signal, ref: false })
+      ]);
+
+      if (!result) {
+        throw new Error('Timed out waiting to verify health status');
+      }
+
+      controller.abort();
+      return { status: 200, message: 'OK' };
+    } catch (ex) {
+      return { status: 503, message: 'Error connecting to Redis' };
+    }
+  }, { promotionTimeout: 60000 });
+
+  service.registerResource(`exframe-cache-manager-${instance.id}`, { onSignal: () => instance.close(), order: 'last' });
+
   Object.keys(instance).forEach((key) => {
     if (typeof instance[key] === 'function') {
       instance[key] = lazyInstrument(instance[key].bind(instance), { metricPrefix: 'cache' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exframe-cache-manager",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "description": "Managing the cache",
   "main": "index.js",
   "config": {
@@ -13,7 +13,7 @@
     "pretest": "npm-install-peers && npm run lint",
     "lint": "eslint ./",
     "peers": "npm-install-peers",
-    "test": "docker-compose -f docker-compose.yml up --abort-on-container-exit --exit-code-from exframe-cache-manager",
+    "test": "docker-compose -f docker-compose.yml up --build --abort-on-container-exit --exit-code-from exframe-cache-manager",
     "unit-test": "./node_modules/.bin/nyc -r lcov --report-dir ./documentation/coverage -t ./documentation/coverage mocha --exit --reporter $npm_package_config_reporter \"./test/**/*.test.js\""
   },
   "author": "Exzeo",
@@ -27,7 +27,8 @@
     "@types/cache-manager": "^3.4.2",
     "cache-manager": "^3.6.0",
     "cache-manager-redis-store": "^2.0.0",
-    "exframe-metrics": "^1.1.0"
+    "exframe-metrics": "^1.1.0",
+    "exframe-utilities": "^1.1.0"
   },
   "devDependencies": {
     "chai": "*",
@@ -45,5 +46,5 @@
     "url": "https://bitbucket.org/exzeo-usa/exframe",
     "directory": "packages/exframe-cache-manager"
   },
-  "gitHead": "846806709f00dedc764c794b3ee05ca3c7297244"
+  "gitHead": "6c09763669b90802745d12200803ac186a6dc5ae"
 }

package/test/cacheManager.test.js

@@ -1,135 +1,154 @@
 'use strict';
 
-const expect = require('chai').expect;
-const { prometheusClient } = require('exframe-service');
+const { expect } = require('chai');
+const sinon = require('sinon');
+const service = require('exframe-service');
+const health = require('exframe-health');
 const cacheManager = require('../index');
 
+const { prometheusClient } = service;
 const userId = 'auth0|1234567890';
 const cacheKey = `${userId}_profiletest`;
 
-const options =  {
-  "host": process.env.HOST || "localhost",
-  "port": process.env.PORT || 6379,
-  "auth_pass": "",
-  "db": 0,
-  "ttl": 60
-};
-
-const userProfileResponse = {
-  userId: userId,
-  userName: 'CSRMickey',
-  email: 'CMM@discsr.com',
-  profile: {
-    family_name: 'Mickey',
-    given_name: ' Mouse CSR'
-  },
-  resources: [{
-    uri: 'TTIC:FL:HO3:CSR1',
-    right: 'READ'
-  }, {
-    uri: 'TTIC:FL:HO3:CSR2',
-    right: 'WRITE'
-  }]
+const options = {
+  host: process.env.HOST || 'localhost',
+  port: process.env.PORT || 6379,
+  auth_pass: '',
+  db: 0,
+  ttl: 60
 };
 
 context('Test User Profile Middleware', () => {
   describe('Cache Manager', () => {
-    const app = cacheManager.create(options);
-
-    beforeEach(() => {
-      prometheusClient.register.clear();
-      expect(prometheusClient.register.getMetricsAsArray()).to.have.lengthOf(0);
-    });
-
-    it('validate the setItem function on the basis of key and value', async () => {
-      const data = await app.setItem(cacheKey, "value1");
-      expect(data).to.not.eql(null);
-      expect(data).to.eql("value1");
-      const metrics = prometheusClient.register.getMetricsAsArray().filter((m) => m.name.includes('setItem'));
-      expect(metrics).to.be.an('array').and.to.have.lengthOf.above(0);
-      await app.flushCache({log:{info:(info)=>{console.log(info)}}}, cacheKey);
-    });
-
-    it('validate the getItem function on the basis of key', async () => {
-      await app.setItem(cacheKey,"someValue");
-      const value = await app.getItem(cacheKey);
-      expect(value).to.eql("someValue");
-      const metrics = prometheusClient.register.getMetricsAsArray().filter((m) => m.name.includes('getItem'));
-      expect(metrics).to.be.an('array').and.to.have.lengthOf.above(0);
-      await app.flushCache({log:{info:(info)=>{console.log(info)}}}, cacheKey);
-    });
-
-    it('validate the addSetItem function on the basis of key', async () => {
-      const key = 'SetTestKey';
-      await app.addSetItem(key, "someSetValue");
-      const value = await app.isSetMember(key, "someSetValue");
-      expect(value).to.eql(true);
-      const metrics = prometheusClient.register.getMetricsAsArray().filter((m) => m.name.includes('addSetItem'));
-      expect(metrics).to.be.an('array').and.to.have.lengthOf.above(0);
-      await app.flushCache({log:{info:(info)=>{console.log(info)}}}, key);
+    describe('create', () => {
+      let sinonInstance;
+
+      beforeEach(() => {
+        sinonInstance = sinon.createSandbox();
+      });
+
+      afterEach(() => {
+        sinonInstance.restore();
+      });
+
+      it('adds a health check with the instance ID in the name, check function, and liveness timeout of 60 seconds', () => {
+        const healthAddSpy = sinonInstance.spy(health, 'add');
+
+        const instance = cacheManager.create(options);
+        expect(healthAddSpy.calledOnce).to.equal(true);
+        expect(healthAddSpy.calledWithMatch(`redis-${instance.id}`, sinon.match.func, { promotionTimeout: 60000 })).to.be.true;
+      });
+
+      it('registers a service resource with the instance ID in the name, onSignal function, and order of "last"', () => {
+        const registerSpy = sinonInstance.spy(service, 'registerResource');
+
+        const instance = cacheManager.create(options);
+        expect(registerSpy.calledOnce).to.equal(true);
+        expect(registerSpy.calledWithMatch(`exframe-cache-manager-${instance.id}`, sinon.match({
+          onSignal: sinon.match.func,
+          order: 'last'
+        }))).to.be.true;
+      });
     });
 
-    it('validate the isSetMember function on the basis of key', async () => {
-      const key = 'SetTestKey2';
-      await app.addSetItem(key, "someSetValue");
-      const value1 = await app.isSetMember(key, "someSetValue");
-      expect(value1).to.eql(true);
-      const value2 = await app.isSetMember(key, "notSetValue");
-      expect(value2).to.eql(false, 'expected non-member key to return false for isSetMember');
-      const metrics = prometheusClient.register.getMetricsAsArray().filter((m) => m.name.includes('isSetMember'));
-      expect(metrics).to.be.an('array').and.to.have.lengthOf.above(0);
-      await app.flushCache({log:{info:(info)=>{console.log(info)}}}, key);
-    });
+    describe('instance', () => {
+      const app = cacheManager.create(options);
 
-    it('validate the removeSetMember function on the basis of key', async () => {
-      const key = 'SetTestKey3';
-      await app.addSetItem(key, "someSetValue");
-      let value = await app.isSetMember(key, "someSetValue");
-      expect(value).to.eql(true);
-      await app.removeSetItem(key, "someSetValue");
-      value = await app.isSetMember(key, "someSetValue");
-      expect(value).to.eql(false, 'expected non-member key to return false for isSetMember');
-      const metrics = prometheusClient.register.getMetricsAsArray().filter((m) => m.name.includes('removeSetItem'));
-      expect(metrics).to.be.an('array').and.to.have.lengthOf.above(0);
-      await app.flushCache({log:{info:(info)=>{console.log(info)}}}, key);
-    });
+      beforeEach(() => {
+        prometheusClient.register.clear();
+        expect(prometheusClient.register.getMetricsAsArray()).to.have.lengthOf(0);
+      });
 
-    it('close drains the redis pool', async () => {
-      const app1 = cacheManager.create(options);
-      await app1.setItem(cacheKey,"someValue");
-      const value = await app1.getItem(cacheKey);
-      expect(value).to.eql("someValue");
-      await app1.close();
-
-      try {
-        const result = await app1.getItem(cacheKey);
-        expect(result).to.not.be.ok();
-      } catch (ex) {
-        expect(ex.message).to.be.equal('GET can\'t be processed. The connection is already closed.');
-        const metrics = prometheusClient.register.getMetricsAsArray().filter((m) => m.name.includes('close'));
+      it('validate the setItem function on the basis of key and value', async () => {
+        const data = await app.setItem(cacheKey, 'value1');
+        expect(data).to.not.eql(null);
+        expect(data).to.eql('value1');
+        const metrics = prometheusClient.register.getMetricsAsArray().filter((m) => m.name.includes('setItem'));
         expect(metrics).to.be.an('array').and.to.have.lengthOf.above(0);
-      }
-    });
-
-    it('validate the flushCache function', async () => {
-      await app.flushCache({log:{info:(info)=>{console.log(info)}}}, '*_profiletest');
-      const value = await app.getItem(cacheKey);
-      expect(value).to.eql(null);
-      const metrics = prometheusClient.register.getMetricsAsArray().filter((m) => m.name.includes('flushCache'));
-      expect(metrics).to.be.an('array').and.to.have.lengthOf.above(0);
-  });
-
-    it('validate the cacheStorePool', () => {
-      const catchepool = app.cacheStorePool;
-      expect(app).to.not.eql(null);
-      expect(catchepool._maxListeners).to.eql(0);
-    });
-
-    it('validate the healthCheck function', async () => {
-      const healthCheck = await app.healthCheck();
-      expect(healthCheck).to.eql(true);
-      const metrics = prometheusClient.register.getMetricsAsArray().filter((m) => m.name.includes('healthCheck'));
-      expect(metrics).to.be.an('array').and.to.have.lengthOf.above(0);
+        await app.flushCache({ log: { info: (info) => { console.log(info); } } }, cacheKey);
+      });
+
+      it('validate the getItem function on the basis of key', async () => {
+        await app.setItem(cacheKey, 'someValue');
+        const value = await app.getItem(cacheKey);
+        expect(value).to.eql('someValue');
+        const metrics = prometheusClient.register.getMetricsAsArray().filter((m) => m.name.includes('getItem'));
+        expect(metrics).to.be.an('array').and.to.have.lengthOf.above(0);
+        await app.flushCache({ log: { info: (info) => { console.log(info); } } }, cacheKey);
+      });
+
+      it('validate the addSetItem function on the basis of key', async () => {
+        const key = 'SetTestKey';
+        await app.addSetItem(key, 'someSetValue');
+        const value = await app.isSetMember(key, 'someSetValue');
+        expect(value).to.eql(true);
+        const metrics = prometheusClient.register.getMetricsAsArray().filter((m) => m.name.includes('addSetItem'));
+        expect(metrics).to.be.an('array').and.to.have.lengthOf.above(0);
+        await app.flushCache({ log: { info: (info) => { console.log(info); } } }, key);
+      });
+
+      it('validate the isSetMember function on the basis of key', async () => {
+        const key = 'SetTestKey2';
+        await app.addSetItem(key, 'someSetValue');
+        const value1 = await app.isSetMember(key, 'someSetValue');
+        expect(value1).to.eql(true);
+        const value2 = await app.isSetMember(key, 'notSetValue');
+        expect(value2).to.eql(false, 'expected non-member key to return false for isSetMember');
+        const metrics = prometheusClient.register.getMetricsAsArray().filter((m) => m.name.includes('isSetMember'));
+        expect(metrics).to.be.an('array').and.to.have.lengthOf.above(0);
+        await app.flushCache({ log: { info: (info) => { console.log(info); } } }, key);
+      });
+
+      it('validate the removeSetMember function on the basis of key', async () => {
+        const key = 'SetTestKey3';
+        await app.addSetItem(key, 'someSetValue');
+        let value = await app.isSetMember(key, 'someSetValue');
+        expect(value).to.eql(true);
+        await app.removeSetItem(key, 'someSetValue');
+        value = await app.isSetMember(key, 'someSetValue');
+        expect(value).to.eql(false, 'expected non-member key to return false for isSetMember');
+        const metrics = prometheusClient.register.getMetricsAsArray().filter((m) => m.name.includes('removeSetItem'));
+        expect(metrics).to.be.an('array').and.to.have.lengthOf.above(0);
+        await app.flushCache({ log: { info: (info) => { console.log(info); } } }, key);
+      });
+
+      it('close drains the redis pool', async () => {
+        const app1 = cacheManager.create(options);
+        await app1.setItem(cacheKey, 'someValue');
+        const value = await app1.getItem(cacheKey);
+        expect(value).to.eql('someValue');
+        await app1.close();
+
+        try {
+          const result = await app1.getItem(cacheKey);
+          expect(result).to.not.be.ok();
+        } catch (ex) {
+          expect(ex.message).to.be.equal('GET can\'t be processed. The connection is already closed.');
+          const metrics = prometheusClient.register.getMetricsAsArray().filter((m) => m.name.includes('close'));
+          expect(metrics).to.be.an('array').and.to.have.lengthOf.above(0);
+        }
+      });
+
+      it('validate the flushCache function', async () => {
+        await app.flushCache({ log: { info: (info) => { console.log(info); } } }, '*_profiletest');
+        const value = await app.getItem(cacheKey);
+        expect(value).to.eql(null);
+        const metrics = prometheusClient.register.getMetricsAsArray().filter((m) => m.name.includes('flushCache'));
+        expect(metrics).to.be.an('array').and.to.have.lengthOf.above(0);
+      });
+
+      it('validate the cacheStorePool', () => {
+        const catchepool = app.cacheStorePool;
+        expect(app).to.not.eql(null);
+        expect(catchepool._maxListeners).to.eql(0);
+      });
+
+      it('validate the healthCheck function', async () => {
+        const healthCheck = await app.healthCheck();
+        expect(healthCheck).to.eql(true);
+        const metrics = prometheusClient.register.getMetricsAsArray().filter((m) => m.name.includes('healthCheck'));
+        expect(metrics).to.be.an('array').and.to.have.lengthOf.above(0);
+      });
     });
   });
-});
+});