feat(onSendFailureDuringShutdown): enable to run an operation before sending the failure message

Author: jacob-hd

README.md

@@ -60,10 +60,11 @@ const options = {
   // cleanup options
   timeout: 1000,                   // [optional = 1000] number of milliseconds before forcefull exiting
   signal,                          // [optional = 'SIGTERM'] what signal to listen for relative to shutdown
-  signals,                          // [optional = []] array of signals to listen for relative to shutdown
+  signals,                         // [optional = []] array of signals to listen for relative to shutdown
   beforeShutdown,                  // [optional] called before the HTTP server starts its shutdown
   onSignal,                        // [optional] cleanup function, returning a promise (used to be onSigterm)
   onShutdown,                      // [optional] called right before exiting
+  onSendFailureDuringShutdown,     // [optional] called before sending each 503 during shutdowns
 
   // both
   logger                           // [optional] logger function to be called with errors

lib/standalone-tests/terminus.onsendfailureduringshutdown.failed-health.js

@@ -0,0 +1,18 @@
+'use strict'
+const http = require('http')
+const server = http.createServer((req, res) => res.end('hello'))
+
+const { createTerminus } = require('../../')
+
+createTerminus(server, {
+  healthChecks: {
+    '/health': () => Promise.reject(new Error('failure'))
+  },
+  onSendFailureDuringShutdown: async () => {
+    console.log('onSendFailureDuringShutdown')
+  }
+})
+
+server.listen(8000, () => {
+  setTimeout(() => process.kill(process.pid, 'SIGTERM'), 600)
+})

lib/standalone-tests/terminus.onsendfailureduringshutdown.js

@@ -0,0 +1,23 @@
+'use strict'
+const http = require('http')
+const server = http.createServer((req, res) => res.end('hello'))
+
+const { createTerminus } = require('../../')
+
+createTerminus(server, {
+  healthChecks: {
+    '/health': () => Promise.resolve()
+  },
+  onSendFailureDuringShutdown: async () => {
+    console.log('onSendFailureDuringShutdown')
+  },
+  beforeShutdown: () => {
+    return new Promise((resolve) => {
+      setTimeout(resolve, 1000)
+    })
+  }
+})
+
+server.listen(8000, () => {
+  process.kill(process.pid, 'SIGTERM')
+})

lib/terminus.js

@@ -15,7 +15,9 @@ function noopResolves () {
   return Promise.resolve()
 }
 
-function sendSuccess (res, info) {
+async function sendSuccess (res, options) {
+  const { info } = options
+
   res.statusCode = 200
   res.setHeader('Content-Type', 'application/json')
   if (info) {
@@ -27,7 +29,12 @@ function sendSuccess (res, info) {
   res.end(SUCCESS_RESPONSE)
 }
 
-function sendFailure (res, error) {
+async function sendFailure (res, options) {
+  const { error, onSendFailureDuringShutdown } = options
+
+  if (onSendFailureDuringShutdown) {
+    await onSendFailureDuringShutdown()
+  }
   res.statusCode = 503
   res.setHeader('Content-Type', 'application/json')
   if (error) {
@@ -46,23 +53,23 @@ const intialState = {
 function noop () {}
 
 function decorateWithHealthCheck (server, state, options) {
-  const { healthChecks, logger } = options
+  const { healthChecks, logger, onSendFailureDuringShutdown } = options
 
   server.listeners('request').forEach((listener) => {
     server.removeListener('request', listener)
     server.on('request', async (req, res) => {
       if (healthChecks[req.url]) {
         if (state.isShuttingDown) {
-          return sendFailure(res)
+          return sendFailure(res, { onSendFailureDuringShutdown })
         }
         let info
         try {
           info = await healthChecks[req.url]()
         } catch (error) {
           logger('healthcheck failed', error)
-          return sendFailure(res, error.causes)
+          return sendFailure(res, { error: error.causes })
         }
-        sendSuccess(res, info)
+        return sendSuccess(res, { info })
       } else {
         listener(req, res)
       }
@@ -103,6 +110,7 @@ function terminus (server, options = {}) {
     signals = [],
     timeout = 1000,
     healthChecks = {},
+    onSendFailureDuringShutdown,
     onShutdown = noopResolves,
     beforeShutdown = noopResolves,
     logger = noop } = options
@@ -112,7 +120,8 @@ function terminus (server, options = {}) {
   if (Object.keys(healthChecks).length > 0) {
     decorateWithHealthCheck(server, state, {
       healthChecks,
-      logger
+      logger,
+      onSendFailureDuringShutdown
     })
   }
 

lib/terminus.spec.js

@@ -136,16 +136,70 @@ describe('Terminus', () => {
     })
 
     it('returns 503 once signal received', (done) => {
-      execFile('node', ['lib/standalone-tests/terminus.onsignal.fail.js'])
+      let responseAssertionsComplete = false
+
+      // We're only truly finished when the response has been analyzed and the forked http process has exited,
+      // freeing up port 8000 for future tests
+      execFile('node', ['lib/standalone-tests/terminus.onsignal.fail.js'], (error) => {
+        expect(error.signal).to.eql('SIGINT')
+        expect(responseAssertionsComplete).to.eql(true)
+        done()
+      })
+
+      // let the process start up
+      setTimeout(() => {
+        fetch('http://localhost:8000/health')
+          .then(res => {
+            expect(res.status).to.eql(503)
+            responseAssertionsComplete = true
+          })
+      }, 300)
+    })
+
+    it('calls onSendFailureDuringShutdown when sending 503 during shutdown', (done) => {
+      let responseAssertionsComplete = false
+
+      // We're only truly finished when the response has been analyzed and the forked http process has exited,
+      // freeing up port 8000 for future tests
+      execFile('node', ['lib/standalone-tests/terminus.onsendfailureduringshutdown.js'],
+        (error, stdout) => {
+          expect(error.signal).to.eql('SIGTERM')
+          expect(stdout).to.eql('onSendFailureDuringShutdown\n')
+          expect(responseAssertionsComplete).to.eql(true)
+          done()
+        })
+
+      // let the process start up
+      setTimeout(() => {
+        fetch('http://localhost:8000/health')
+          .then(res => {
+            expect(res.status).to.eql(503)
+            responseAssertionsComplete = true
+          })
+      }, 300)
+    })
+
+    it('does NOT call onSendFailureDuringShutdown when sending 503 during failed healthcheck', (done) => {
+      let responseAssertionsComplete = false
+
+      // We're only truly finished when the response has been analyzed and the forked http process has exited,
+      // freeing up port 8000 for future tests
+      execFile('node', ['lib/standalone-tests/terminus.onsendfailureduringshutdown.failed-health.js'],
+        (error, stdout) => {
+          expect(error.signal).to.eql('SIGTERM')
+          // Here, we expect NOT to see "onSendFailureDuringShutdown"
+          expect(stdout).to.eql('')
+          expect(responseAssertionsComplete).to.eql(true)
+          done()
+        })
 
       // let the process start up
       setTimeout(() => {
         fetch('http://localhost:8000/health')
           .then(res => {
             expect(res.status).to.eql(503)
-            done()
+            responseAssertionsComplete = true
           })
-          .catch(done)
       }, 300)
     })
   })