Merge pull request #66 from micro-analytics/healthcheck

Implement /_healthcheck

Author: mxstbr

src/db.js

@@ -4,6 +4,8 @@ function initDbAdapter(options) {
   const adapterName = options.adapter;
   const adapter = require(`micro-analytics-adapter-${adapterName}`);
 
+  module.exports.version = adapter.version;
+  module.exports.healthcheck = adapter.healthcheck;
   module.exports.get = adapter.get;
   module.exports.getAll = adapter.getAll;
   module.exports.put = adapter.put;

src/handler.js

@@ -2,6 +2,7 @@ const url = require('url');
 const { send, createError, sendError } = require('micro');
 
 const db = require('./db');
+const healthcheckHandler = require('./healthcheck');
 const { pushView } = require('./utils');
 
 let sse;
@@ -13,19 +14,18 @@ if (db.hasFeature('subscribe')) {
   sseHandler(sse);
 }
 
-module.exports = async function(req, res) {
-  const { pathname, query } = url.parse(req.url, /* parseQueryString */ true);
-
-  if (pathname === '/_realtime') {
-    if (sse) {
-      sse.addClient(req, res);
-    } else {
-      send(res, 400, {
-        error: 'The current database adapter does not support live updates.',
-      });
-    }
+function realtimeHandler(req, res) {
+  if (sse) {
+    sse.addClient(req, res);
+  } else {
+    send(res, 400, {
+      error: 'The current database adapter does not support live updates.',
+    });
   }
+}
 
+async function analyticsHandler(req, res) {
+  const { pathname, query } = url.parse(req.url, /* parseQueryString */ true);
   res.setHeader('Access-Control-Allow-Origin', '*');
   // Send all views down if "?all" is true
   if (String(query.all) === 'true') {
@@ -72,4 +72,21 @@ module.exports = async function(req, res) {
     console.log(err);
     throw createError(500, 'Internal server error.');
   }
+}
+
+module.exports = function createHandler(options) {
+  return async function(req, res) {
+    const { pathname, query } = url.parse(req.url, /* parseQueryString */ true);
+
+    switch (pathname) {
+      case '/_realtime':
+        return realtimeHandler(req, res);
+
+      case '/_healthcheck':
+        return healthcheckHandler(options, req, res);
+
+      default:
+        return analyticsHandler(req, res);
+    }
+  };
 };

src/healthcheck.js

@@ -0,0 +1,22 @@
+const { send } = require('micro');
+
+const pkg = require('../package.json');
+const db = require('./db');
+
+module.exports = async function healthcheckHandler(options, req, res) {
+  const health = db.hasFeature('healthcheck')
+    ? await db.healthcheck()
+    : 'unknown';
+
+  send(res, health === 'ok' ? 200 : 500, {
+    health,
+    version: pkg.version,
+    adapter: {
+      name: options.adapter,
+      version: db.version,
+      features: {
+        realtime: db.hasFeature('subscribe'),
+      },
+    },
+  });
+};

src/index.js

@@ -8,7 +8,7 @@ try {
 
   db.initDbAdapter(flags);
 
-  const handler = require('./handler');
+  const handler = require('./handler')(flags);
   const server = micro(handler);
 
   server.listen(flags.port, flags.host, error => {

tests/atomicity.test.js

@@ -1,33 +1,33 @@
-const request = require('request-promise')
-const { listen, mockDb } = require('./utils')
+const request = require('request-promise');
+const { listen, mockDb } = require('./utils');
 
-jest.mock('flat-file-db', () => mockDb)
-const db = require('../src/db')
-const service = require('../src/handler')
-let url
+jest.mock('flat-file-db', () => mockDb);
+const db = require('../src/db');
+const service = require('../src/handler');
+let url;
 
 beforeAll(() => {
   db.initDbAdapter({ adapter: 'flat-file-db' });
-})
+});
 
 beforeEach(async () => {
-  url = await listen(service)
-  mockDb._setDelay(10)
-})
+  url = await listen(service({ adapter: 'flat-file-db' }));
+  mockDb._setDelay(10);
+});
 
 afterEach(async () => {
-  mockDb._reset()
-  mockDb._setDelay()
-})
+  mockDb._reset();
+  mockDb._setDelay();
+});
 
 it('should atomically set two views coming in at the same time', async () => {
   // Request twice at the same time
   // NOTE: These two requests will return a wrong view count, they'll both say it's 1
-  request(`${url}/path`)
-  request(`${url}/path`)
+  request(`${url}/path`);
+  request(`${url}/path`);
   // After the data is persisted (in the mocked case after 10ms) the path shows the right view count
   setTimeout(async () => {
-    const body = JSON.parse(await request(`${url}/path`))
-    expect(body.views).toEqual(3)
-  }, 10)
-})
+    const body = JSON.parse(await request(`${url}/path`));
+    expect(body.views).toEqual(3);
+  }, 10);
+});

tests/errors.test.js

@@ -1,38 +1,40 @@
-const request = require('request-promise')
-const { listen } = require('./utils')
+const request = require('request-promise');
+const { listen } = require('./utils');
 
-const service = require('../src/handler')
-const db = require('../src/db')
-let url
+const service = require('../src/handler');
+const db = require('../src/db');
+let url;
 
 beforeAll(() => {
   db.initDbAdapter({ adapter: 'flat-file-db' });
-})
+});
 
 beforeEach(async () => {
-  url = await listen(service)
-})
+  url = await listen(service({ adapter: 'flat-file-db' }));
+});
 
 it('should throw an error if no pathname is provided', async () => {
-  const fn = jest.fn()
+  const fn = jest.fn();
   try {
-    await request(url)
-    fn()
+    await request(url);
+    fn();
   } catch (err) {
-    expect(err.statusCode).toBe(400)
-    expect(err.message.indexOf('include a path')).toBeGreaterThan(-1)
+    expect(err.statusCode).toBe(400);
+    expect(err.message.indexOf('include a path')).toBeGreaterThan(-1);
   }
-  expect(fn).not.toHaveBeenCalled()
-})
+  expect(fn).not.toHaveBeenCalled();
+});
 
 it('should throw an error if a PUT request comes in', async () => {
-  const fn = jest.fn()
+  const fn = jest.fn();
   try {
-    await request.put(`${url}/test`)
-    expect(err.message.indexOf('make a GET or a POST request')).toBeGreaterThan(-1)
-    fn()
+    await request.put(`${url}/test`);
+    expect(err.message.indexOf('make a GET or a POST request')).toBeGreaterThan(
+      -1
+    );
+    fn();
   } catch (err) {
-    expect(err.statusCode).toBe(400)
+    expect(err.statusCode).toBe(400);
   }
-  expect(fn).not.toHaveBeenCalled()
-})
+  expect(fn).not.toHaveBeenCalled();
+});

tests/healthcheck.test.js

@@ -0,0 +1,93 @@
+const request = require('request-promise');
+
+const db = require('../src/db');
+const { listen } = require('./utils');
+
+let mockStatus = 'ok';
+jest.mock('micro-analytics-adapter-flat-file-db', () => ({
+  version: '42.0.0',
+  subscribe: () => {},
+  healthcheck: async () => {
+    await new Promise(resolve => setTimeout(resolve, 20));
+    return mockStatus;
+  },
+}));
+
+jest.mock('micro-analytics-adapter-memory', () => ({
+  version: '42.0.0',
+}));
+
+const service = require('../src/handler')({ adapter: 'flat-file-db' });
+
+let url;
+
+beforeAll(() => {
+  db.initDbAdapter({ adapter: 'flat-file-db' });
+});
+
+beforeEach(async () => {
+  url = await listen(service);
+});
+
+test('GET /_healtcheck adapter healthcheck returns "ok"', async () => {
+  mockStatus = 'ok';
+  const body = JSON.parse(await request(`${url}/_healthcheck`));
+
+  expect(body).toMatchObject({
+    health: 'ok',
+    adapter: {
+      name: 'flat-file-db',
+      version: '42.0.0',
+      features: {
+        realtime: true,
+      },
+    },
+  });
+});
+
+test('GET /_healtcheck adapter healthcheck returns "critical"', async () => {
+  mockStatus = 'critical';
+  let error;
+
+  try {
+    const body = JSON.parse(await request(`${url}/_healthcheck`));
+  } catch (e) {
+    error = e;
+  }
+
+  expect(error.statusCode).toEqual(500);
+  expect(JSON.parse(error.error)).toMatchObject({
+    health: 'critical',
+    adapter: {
+      name: 'flat-file-db',
+      version: '42.0.0',
+      features: {
+        realtime: true,
+      },
+    },
+  });
+});
+
+test('GET /_healtcheck when adapter has no healthcheck', async () => {
+  let error;
+  url = await listen(require('../src/handler')({ adapter: 'memory' }));
+  db.initDbAdapter({ adapter: 'memory' });
+
+  try {
+    const body = JSON.parse(await request(`${url}/_healthcheck`));
+  } catch (e) {
+    error = e;
+  }
+
+  expect(error.statusCode).toEqual(500);
+  expect(JSON.parse(error.error)).toMatchObject({
+    health: 'unknown',
+    adapter: {
+      name: 'memory',
+      version: '42.0.0',
+      features: {
+        realtime: false,
+      },
+    },
+  });
+});