feat(errors): adding koa and express error handler support

Author: gergelyke

lib/agent/index.js

@@ -251,7 +251,10 @@ Agent.prototype.reportError = function (errorName, error) {
     type: 'us',
     data: {
       name: errorName,
-      payload: [error]
+      payload: [{
+        stack: error.stack,
+        message: error.message
+      }]
     }
   }
 

lib/instrumentations/express.js

@@ -0,0 +1,78 @@
+var debug = require('debug')('risingstack/trace')
+var Shimmer = require('../utils/shimmer')
+
+module.exports = function (express, agent) {
+  var isVersion4 = !!express &&
+    express.Router &&
+    express.Router.process_params &&
+    express.application &&
+    express.application.del
+
+  // for now support only express@4
+  if (!isVersion4) {
+    debug('express version is not supported, not wrapping error handler')
+    return express
+  }
+
+  var errorHandlerLayer
+  function expressErrorHandler (error, request, response, next) {
+    agent.reportError('express_error', error)
+    next(error)
+  }
+
+  // in express errorhandlers have 4 arguments
+  function isErrorHandler (middleware) {
+    return middleware && middleware.handle && middleware.handle.length === 4
+  }
+
+  // it will be called every time a middleware is added to express
+  // in these cases we remove our expressErrorHandler and add it later with addErrorHandler
+  function removeErrorHandler (app) {
+    var i
+    if (app.stack && app.stack.length) {
+      for (i = app.stack.length - 1; i >= 0; i -= 1) {
+        if (app.stack[i] === errorHandlerLayer) {
+          app.stack.splice(i, 1)
+          break
+        }
+      }
+    }
+  }
+
+  // look for the error handler provided by user, if found insert right before
+  // if not found insert to the end
+  function addErrorHandler (app) {
+    var errorMiddlewareFound = false
+    var i
+
+    for (i = 0; i < app.stack.length; i++) {
+      var middleware = app.stack[i]
+      if (isErrorHandler(middleware)) {
+        app.stack.splice(i, 0, errorHandlerLayer)
+        errorMiddlewareFound = true
+        break
+      }
+    }
+
+    if (!errorMiddlewareFound) {
+      app.stack.push(errorHandlerLayer)
+    }
+  }
+
+  Shimmer.wrap(express.Router, 'express.Router', 'use', function (original) {
+    return function () {
+      // magic to create an express layer from the error handler function
+      if (!errorHandlerLayer) {
+        errorHandlerLayer = original
+          .call(this, '/', expressErrorHandler)
+          .stack.pop()
+      }
+      removeErrorHandler(this)
+      var app = original.apply(this, arguments)
+      addErrorHandler(this)
+      return app
+    }
+  })
+
+  return express
+}

lib/instrumentations/express.spec.js

@@ -0,0 +1,45 @@
+var expect = require('chai').expect
+var express = require('./express')
+var Shimmer = require('../utils/shimmer')
+
+describe('The express wrapper module', function () {
+  it('only wraps express 4', function () {
+    var shimmerStub = this.sandbox.stub(Shimmer, 'wrap')
+
+    express({})
+
+    expect(shimmerStub).to.be.not.called
+  })
+
+  it('adds an error handler layer', function () {
+    var useSpy = this.sandbox.spy(function (path, handler) {
+      fakeExpress.Router.stack.push({
+        handle: handler
+      })
+      return fakeExpress.Router
+    })
+
+    var fakeExpress = {
+      Router: {
+        stack: [],
+        process_params: 'process_params',
+        use: useSpy
+      },
+      application: {
+        del: 'del'
+      }
+    }
+
+    var fakeAgent = {
+      reportError: this.sandbox.spy()
+    }
+
+    express(fakeExpress, fakeAgent)
+    fakeExpress.Router.use('/', function (a, b, c) {})
+    fakeExpress.Router.use('/', function (a, b, c) {})
+    fakeExpress.Router.use('/', function (a, b, c, d) {})
+
+    expect(fakeExpress.Router.stack.length).to.eql(4)
+    expect(fakeExpress.Router.stack[2].handle.name).to.eql('expressErrorHandler')
+  })
+})

lib/instrumentations/index.js

@@ -13,6 +13,8 @@ var INSTRUMENTED_LIBS = [
   'mysql',
   'when',
   'q',
+  'koa',
+  'express',
   // knex and bookshelf does some black magic, so we have to do this :(
   'bluebird.main'
 ]

lib/instrumentations/koa.js

@@ -0,0 +1,12 @@
+var Shimmer = require('../utils/shimmer')
+
+module.exports = function (koa, agent) {
+  Shimmer.wrap(koa.prototype, 'koa.prototype', 'onerror', function (original) {
+    return function (error) {
+      agent.reportError('koa_error', error)
+      return original.apply(this, arguments)
+    }
+  })
+
+  return koa
+}

lib/instrumentations/koa.spec.js

@@ -0,0 +1,23 @@
+var expect = require('chai').expect
+var koa = require('./koa')
+
+describe('The koa wrapper module', function () {
+  it('wraps koa onerror', function () {
+    var onerrorSpy = this.sandbox.spy()
+
+    function FakeKoa () {}
+    FakeKoa.prototype.onerror = onerrorSpy
+
+    var fakeAgent = {
+      reportError: this.sandbox.spy()
+    }
+
+    koa(FakeKoa, fakeAgent)
+
+    var error = new Error('Test error')
+    new FakeKoa().onerror(error)
+
+    expect(fakeAgent.reportError).to.be.calledWith('koa_error', error)
+    expect(onerrorSpy).to.be.calledWith(error)
+  })
+})