feat: Sensible non-Error exception serializer

lib/client.js

@@ -9,6 +9,7 @@ var transports = require('./transports');
 var nodeUtil = require('util'); // nodeUtil to avoid confusion with "utils"
 var events = require('events');
 var domain = require('domain');
+var md5 = require('md5');
 
 var instrumentor = require('./instrumentation/instrumentor');
 
@@ -355,20 +356,36 @@ extend(Raven.prototype, {
   },
 
   captureException: function captureException(err, kwargs, cb) {
-    if (!(err instanceof Error)) {
-      // This handles when someone does:
-      //   throw "something awesome";
-      // We synthesize an Error here so we can extract a (rough) stack trace.
-      err = new Error(err);
-    }
-
     if (!cb && typeof kwargs === 'function') {
       cb = kwargs;
       kwargs = {};
     } else {
       kwargs = kwargs || {};
     }
 
+    if (!(err instanceof Error)) {
+      if (utils.isPlainObject(err)) {
+        // This will allow us to group events based on top-level keys
+        // which is much better than creating new group when any key/value change
+        var hash = md5(Object.keys(err).sort());
+        var message = 'Sentry: non-Error exception captured [' + hash + ']';
+        var serializedException = utils.serializeException(err);
+
+        kwargs.message = message;
+        kwargs.fingerprint = [hash];
+        kwargs.extra = {
+          __serialized__: serializedException
+        };
+
+        err = new Error(message);
+      } else {
+        // This handles when someone does:
+        //   throw "something awesome";
+        // We synthesize an Error here so we can extract a (rough) stack trace.
+        err = new Error(err);
+      }
+    }
+
     var self = this;
     var eventId = this.generateEventId();
     parsers.parseError(err, kwargs, function(kw) {

lib/utils.js

@@ -6,6 +6,7 @@ var transports = require('./transports');
 var path = require('path');
 var lsmod = require('lsmod');
 var stacktrace = require('stack-trace');
+var stringify = require('../vendor/json-stringify-safe');
 
 var ravenVersion = require('../package.json').version;
 
@@ -16,6 +17,79 @@ var protocolMap = {
 
 var consoleAlerts = {};
 
+var MAX_SERIALIZE_EXCEPTION_DEPTH = 4;
+var MAX_SERIALIZE_EXCEPTION_SIZE = 50 * 1024; // 50kB
+
+function utf8Length(value) {
+  return ~-encodeURI(value).split(/%..|./).length;
+}
+
+function jsonSize(value) {
+  return utf8Length(JSON.stringify(value));
+}
+
+function isPlainObject(what) {
+  return Object.prototype.toString.call(what) === '[object Object]';
+}
+
+module.exports.isPlainObject = isPlainObject;
+
+function serializeValue(value) {
+  var maxLength = 40;
+
+  if (typeof value === 'string') {
+    return value.length <= maxLength ? value : value.substr(0, maxLength) + '\u2026';
+  } else if (
+    typeof value === 'number' ||
+    typeof value === 'boolean' ||
+    typeof value === 'undefined'
+  ) {
+    return value;
+  } else {
+    return Object.prototype.toString.call(value);
+  }
+}
+
+function serializeObject(value, depth) {
+  if (depth === 0) return serializeValue(value);
+
+  if (isPlainObject(value)) {
+    return Object.keys(value).reduce(function(acc, key) {
+      acc[key] = serializeObject(value[key], depth - 1);
+      return acc;
+    }, {});
+  } else if (Array.isArray(value)) {
+    return value.map(function(val) {
+      return serializeObject(val, depth - 1);
+    });
+  } else {
+    return serializeValue(value);
+  }
+}
+
+function serializeException(ex, depth, maxSize) {
+  if (!isPlainObject(ex)) return ex;
+
+  depth =
+    depth === undefined || typeof depth !== 'number'
+      ? MAX_SERIALIZE_EXCEPTION_DEPTH
+      : depth;
+  maxSize =
+    maxSize === undefined || typeof depth !== 'number'
+      ? MAX_SERIALIZE_EXCEPTION_SIZE
+      : maxSize;
+
+  var serialized = serializeObject(ex, depth);
+
+  if (jsonSize(stringify(serialized)) > maxSize) {
+    return serializeException(ex, depth - 1);
+  } else {
+    return serialized;
+  }
+}
+
+module.exports.serializeException = serializeException;
+
 module.exports.disableConsoleAlerts = function disableConsoleAlerts() {
   consoleAlerts = false;
 };

test/raven.utils.js

@@ -2,6 +2,7 @@
 'use strict';
 
 var raven = require('../');
+var stringify = require('../vendor/json-stringify-safe');
 
 describe('raven.utils', function() {
   describe('#parseDSN()', function() {
@@ -330,4 +331,175 @@ describe('raven.utils', function() {
       raven.utils.getModule(filename).should.eql('lol');
     });
   });
+
+  describe.only('#serializeException()', function() {
+    it('return [object Object] when reached depth=0', function() {
+      var actual = raven.utils.serializeException(
+        {
+          a: 42,
+          b: 'asd',
+          c: true
+        },
+        0
+      );
+      var expected = stringify('[object Object]');
+
+      actual.should.eql(expected);
+    });
+
+    it('should serialize one level deep with depth=1', function() {
+      var actual = raven.utils.serializeException(
+        {
+          a: 42,
+          b: 'asd',
+          c: true,
+          d: undefined,
+          e:
+            'very long string that is definitely over 120 characters, which is default for now but can be changed anytime because why not?',
+          f: {foo: 42},
+          g: [1, 'a', true],
+          h: function() {}
+        },
+        1
+      );
+      var expected = stringify({
+        a: 42,
+        b: 'asd',
+        c: true,
+        d: undefined,
+        e: 'very long string that is definitely over\u2026',
+        f: '[object Object]',
+        g: '[object Array]',
+        h: '[object Function]'
+      });
+
+      actual.should.eql(expected);
+    });
+
+    it('should serialize arbitrary number of depths', function() {
+      var actual = raven.utils.serializeException(
+        {
+          a: 42,
+          b: 'asd',
+          c: true,
+          d: undefined,
+          e:
+            'very long string that is definitely over 40 characters, which is default for now but can be changed',
+          f: {
+            foo: 42,
+            bar: {
+              foo: 42,
+              bar: {
+                bar: {
+                  bar: {
+                    bar: 42
+                  }
+                }
+              },
+              baz: ['hello']
+            },
+            baz: [1, 'a', true]
+          },
+          g: [1, 'a', true],
+          h: function() {}
+        },
+        5
+      );
+      var expected = stringify({
+        a: 42,
+        b: 'asd',
+        c: true,
+        d: undefined,
+        e: 'very long string that is definitely over\u2026',
+        f: {
+          foo: 42,
+          bar: {
+            foo: 42,
+            bar: {
+              bar: {
+                bar: '[object Object]'
+              }
+            },
+            baz: ['hello']
+          },
+          baz: [1, 'a', true]
+        },
+        g: [1, 'a', true],
+        h: '[object Function]'
+      });
+
+      actual.should.eql(expected);
+    });
+
+    it('should reduce depth if payload size was exceeded', function() {
+      var actual = raven.utils.serializeException(
+        {
+          a: {
+            a: '50kB worth of payload pickle rick',
+            b: '50kB worth of payload pickle rick'
+          },
+          b: '50kB worth of payload pickle rick'
+        },
+        2,
+        100
+      );
+      var expected = stringify({
+        a: '[object Object]',
+        b: '50kB worth of payload pickle rick'
+      });
+
+      actual.should.eql(expected);
+    });
+
+    it('should reduce depth only one level at the time', function() {
+      var actual = raven.utils.serializeException(
+        {
+          a: {
+            a: {
+              a: {
+                a: [
+                  '50kB worth of payload pickle rick',
+                  '50kB worth of payload pickle rick',
+                  '50kB worth of payload pickle rick'
+                ]
+              }
+            },
+            b: '50kB worth of payload pickle rick'
+          },
+          b: '50kB worth of payload pickle rick'
+        },
+        4,
+        200
+      );
+      var expected = stringify({
+        a: {
+          a: {
+            a: {
+              a: '[object Array]'
+            }
+          },
+          b: '50kB worth of payload pickle rick'
+        },
+        b: '50kB worth of payload pickle rick'
+      });
+
+      actual.should.eql(expected);
+    });
+
+    it('should fallback to [object Object] if cannot reduce payload size enough', function() {
+      var actual = raven.utils.serializeException(
+        {
+          a: '50kB worth of payload pickle rick',
+          b: '50kB worth of payload pickle rick',
+          c: '50kB worth of payload pickle rick',
+          d: '50kB worth of payload pickle rick'
+        },
+        1,
+        100
+      );
+      var expected = stringify('[object Object]');
+
+      actual.should.eql(expected);
+    });
+  });
 });