Merge pull request #21 from restify/serializer

add a bunyan serializer for supporting context objects

Author: DonutEspresso

README.md

@@ -214,9 +214,30 @@ Caused by: Error: file lookup failed!
     at Function.Module.runMain (module.js:501:10)
     at startup (node.js:129:16)
     at node.js:814:3
+```
+
+### Bunyan support
+
+Since errors created via restify-errors inherit from VError, you'll get out of
+the box support via bunyan's standard serializers. If you are using the
+`context` property, you can use the serializer shipped with restify-errors:
+
+```js
 
+var bunyan = require('bunyan');
+var restifyErrors = require('restify-errors');
+
+var log = bunyan.createLogger({
+    name: 'myLogger',
+    serializers: {
+        err: restifyErrors.bunyanSerializer
+    });
 ```
 
+You can, of course, combine this with the standard set of serializers that
+bunyan ships with.
+
+
 For more information about building rich errors, check out
 [VError](https://github.com/davepacheco/node-verror).
 

lib/index.js

@@ -114,6 +114,77 @@ function makeInstance(constructor, constructorOpt, args) {
 
 
 
+
+/**
+ * built in bunyan serializer for restify errors. it's more or less the
+ * standard bunyan serializer with support for the context property. borrows
+ * liberally from:
+ * https://github.com/trentm/node-bunyan/blob/master/lib/bunyan.js
+ * @public
+ * @function serializer
+ * @param {Object} err an error object
+ * @returns {Object} serialized object for bunyan output
+ */
+function serializer(err) {
+
+    if (!err || !err.stack) {
+        return err;
+    }
+
+    function getSerializedContext(ex) {
+
+        var ret = '';
+
+        if (ex.context && _.keys(ex.context).length > -1) {
+            ret += ' (';
+            _.forEach(ex.context, function(val, key) {
+                ret += key + '=' + val.toString() + ', ';
+            });
+            // remove last comma
+            ret = ret.slice(0, -2);
+            ret += ')';
+        }
+
+        return ret + '\n';
+    }
+
+    function getFullErrorStack(ex) {
+        var e = ex;
+        var out = '';
+        var first = true;
+
+        do {
+            if (first !== true) {
+                out += '\nCaused by: ';
+            }
+
+            // parse out first new line of stack trace, append context
+            // there.
+            var stackString = (e.stack || e.toString()).split('\n');
+
+            out += stackString.shift() + getSerializedContext(e);
+            out += stackString.join('\n');
+            e = (e.cause) ? e.cause() : null;
+            first = false;
+        } while (e);
+
+        // remove last new line char
+        out = out.slice(0, -2);
+
+        return out;
+    }
+
+    return {
+        message: err.message,
+        name: err.name,
+        stack: getFullErrorStack(err),
+        code: err.code,
+        signal: err.signal
+    };
+}
+
+
+
 module.exports = _.assign({}, httpErrors, restErrors, {
     // export base classes
     HttpError: HttpError,
@@ -125,6 +196,9 @@ module.exports = _.assign({}, httpErrors, restErrors, {
 
     // deprecated method names, how long do we keep these for?
     // restify has already been updated, but what about external consumers?
-    codeToHttpError: makeErrFromCode
+    codeToHttpError: makeErrFromCode,
+
+    // built in bunyan serializer
+    bunyanSerializer: serializer
 });
 

package.json

@@ -35,6 +35,7 @@
     "test": "make test"
   },
   "devDependencies": {
+    "bunyan": "^1.5.1",
     "chai": "^3.4.1",
     "coveralls": "^2.11.4",
     "eslint": "^1.9.0",

test/index.js

@@ -8,6 +8,7 @@ var http          = require('http');
 
 // userland
 var assert        = require('chai').assert;
+var bunyan        = require('bunyan');
 var _             = require('lodash');
 var WError        = require('verror').WError;
 
@@ -710,4 +711,65 @@ describe('restify-errors node module.', function() {
             });
         });
     });
+
+    describe('bunyan serializer', function() {
+
+        var logger;
+
+        before(function() {
+            logger = bunyan.createLogger({
+                name: 'unit-test',
+                serializers: {
+                    err: restifyErrors.bunyanSerializer
+                }
+            });
+        });
+
+        it('should serialize a standard Error', function(done) {
+
+            var err = new Error('boom');
+
+            assert.doesNotThrow(function() {
+                logger.error(err, 'standard error');
+            });
+
+            done();
+        });
+
+        it('should serialize a restify-error Error', function(done) {
+
+            var err = new Error('boom');
+            var myErr = new restifyErrors.InternalServerError(err, {
+                message: 'ISE',
+                context: {
+                    foo: 'bar',
+                    baz: 1
+                }
+            });
+
+            assert.doesNotThrow(function() {
+                logger.error(myErr, 'wrapped error');
+            });
+
+            done();
+        });
+
+        it('should ignore serializer', function(done) {
+
+            // pass an error object without stack
+            assert.doesNotThrow(function() {
+                logger.error({
+                    err: null
+                }, 'wrapped error');
+            });
+
+            assert.doesNotThrow(function() {
+                logger.error({
+                    err: {}
+                }, 'wrapped error');
+            });
+
+            done();
+        });
+    });
 });