Fix propagation of options in Raven.context and Raven.captureException.

Options passed to Raven.context or Raven.captureException weren't getting
propagated (there are unit tests for that, but they only test that the options
get passed to TraceKit.report). This means that options like 'tags' or 'extra'
never actually got passed on to Sentry.

The root of the issue was in TraceKit:

- Parameters passed to TraceKit.report() didn't get passed to notification
  handlers (unless the exception was swallowed and window.onerror didn't get
  called).
- Notification handlers for TraceKit.report() didn't get called at all when
  TraceKit.collectWindowErrors was set to false (unless the exception was
  swallowed, window.onerror didn't get called, and a second call to
  TraceKit.report() was made).

Author: russell-stripe

test/raven.test.js

@@ -40,6 +40,91 @@ function generateUUID4() {
     return 'abc123';
 }
 
+describe('TraceKit', function(){
+    describe('error notifications', function(){
+        var testMessage = "__mocha_ignore__";
+        var subscriptionHandler;
+        // TraceKit waits 2000ms for window.onerror to fire, so give the tests
+        // some extra time.
+        this.timeout(3000);
+
+        before(function() {
+            // Prevent the onerror call that's part of our tests from getting to
+            // mocha's handler, which would treat it as a test failure.
+            //
+            // We set this up here and don't ever restore the old handler, because
+            // we can't do that without clobbering TraceKit's handler, which can only
+            // be installed once.
+            var oldOnError = window.onerror;
+            window.onerror = function(message) {
+                if (message == testMessage) {
+                    return true;
+                }
+                return oldOnError.apply(this, arguments);
+            };
+        });
+
+        afterEach(function() {
+            if (subscriptionHandler) {
+                TraceKit.report.unsubscribe(subscriptionHandler);
+                subscriptionHandler = null;
+            }
+        });
+
+        function testErrorNotification(collectWindowErrors, callOnError, numReports, done) {
+            var extraVal = "foo";
+            var numDone = 0;
+            // TraceKit's collectWindowErrors flag shouldn't affect direct calls
+            // to TraceKit.report, so we parameterize it for the tests.
+            TraceKit.collectWindowErrors = collectWindowErrors;
+
+            subscriptionHandler = function(stackInfo, extra) {
+                assert.equal(extra, extraVal);
+                numDone++;
+                if (numDone == numReports) {
+                    done();
+                }
+            }
+            TraceKit.report.subscribe(subscriptionHandler);
+
+            // TraceKit.report always throws an exception in order to trigger
+            // window.onerror so it can gather more stack data. Mocha treats
+            // uncaught exceptions as errors, so we catch it via assert.throws
+            // here (and manually call window.onerror later if appropriate).
+            //
+            // We test multiple reports because TraceKit has special logic for when
+            // report() is called a second time before either a timeout elapses or
+            // window.onerror is called (which is why we always call window.onerror
+            // only once below, after all calls to report()).
+            for (var i=0; i < numReports; i++) {
+                var e = new Error('testing');
+                assert.throws(function() {
+                    TraceKit.report(e, extraVal);
+                }, e);
+            }
+            // The call to report should work whether or not window.onerror is
+            // triggered, so we parameterize it for the tests. We only call it
+            // once, regardless of numReports, because the case we want to test for
+            // multiple reports is when window.onerror is *not* called between them.
+            if (callOnError) {
+                window.onerror(testMessage);
+            }
+        }
+
+        Mocha.utils.forEach([false, true], function(collectWindowErrors) {
+            Mocha.utils.forEach([false, true], function(callOnError) {
+                Mocha.utils.forEach([1, 2], function(numReports) {
+                    it('it should receive arguments from report() when' +
+                       ' collectWindowErrors is ' + collectWindowErrors +
+                       ' and callOnError is ' + callOnError +
+                       ' and numReports is ' + numReports, function(done) {
+                        testErrorNotification(collectWindowErrors, callOnError, numReports, done);
+                    });
+                });
+            });
+        });
+    });
+});
 
 describe('globals', function() {
     beforeEach(function() {

vendor/TraceKit/tracekit.js

@@ -75,6 +75,7 @@ TraceKit.wrap = function traceKitWrapper(func) {
  */
 TraceKit.report = (function reportModuleWrapper() {
     var handlers = [],
+        lastArgs = null,
         lastException = null,
         lastExceptionStack = null;
 
@@ -111,9 +112,9 @@ TraceKit.report = (function reportModuleWrapper() {
      * Dispatch stack information to all handlers.
      * @param {Object.<string, *>} stack
      */
-    function notifyHandlers(stack, windowError) {
+    function notifyHandlers(stack, isWindowError) {
         var exception = null;
-        if (windowError && !TraceKit.collectWindowErrors) {
+        if (isWindowError && !TraceKit.collectWindowErrors) {
           return;
         }
         for (var i in handlers) {
@@ -145,19 +146,16 @@ TraceKit.report = (function reportModuleWrapper() {
      * @param {?Error} ex The actual Error object.
      */
     function traceKitWindowOnError(message, url, lineNo, colNo, ex) {
-        var stack = null, skipNotify = false;
+        var stack = null;
 
         if (!isUndefined(ex)) {
             // New chrome and blink send along a real error object
             // Let's just report that like a normal error.
             // See: https://mikewest.org/2013/08/debugging-runtime-errors-with-window-onerror
             report(ex, false);
-            skipNotify = true;
         } else if (lastExceptionStack) {
             TraceKit.computeStackTrace.augmentStackTraceWithInitialElement(lastExceptionStack, url, lineNo, message);
-            stack = lastExceptionStack;
-            lastExceptionStack = null;
-            lastException = null;
+            processLastException();
         } else {
             var location = {
                 'url': url,
@@ -173,10 +171,7 @@ TraceKit.report = (function reportModuleWrapper() {
                 'stack': [location],
                 'useragent': navigator.userAgent
             };
-        }
-
-        if (!skipNotify) {
-            notifyHandlers(stack, 'from window.onerror');
+            notifyHandlers(stack, true);
         }
 
         if (_oldOnerrorHandler) {
@@ -206,6 +201,15 @@ TraceKit.report = (function reportModuleWrapper() {
         _oldOnerrorHandler = undefined;
     }
 
+    function processLastException() {
+        var _lastExceptionStack = lastExceptionStack,
+            _lastArgs = lastArgs;
+        lastArgs = null;
+        lastExceptionStack = null;
+        lastException = null;
+        notifyHandlers.apply(null, [_lastExceptionStack, false].concat(_lastArgs));
+    }
+
     /**
      * Reports an unhandled Error to TraceKit.
      * @param {Error} ex
@@ -219,26 +223,22 @@ TraceKit.report = (function reportModuleWrapper() {
             if (lastException === ex) {
                 return; // already caught by an inner catch block, ignore
             } else {
-                var s = lastExceptionStack;
-                lastExceptionStack = null;
-                lastException = null;
-                notifyHandlers.apply(null, [s, null].concat(args));
+              processLastException();
             }
         }
 
         var stack = TraceKit.computeStackTrace(ex);
         lastExceptionStack = stack;
         lastException = ex;
+        lastArgs = args;
 
         // If the stack trace is incomplete, wait for 2 seconds for
         // slow slow IE to see if onerror occurs or not before reporting
         // this exception; otherwise, we will end up with an incomplete
         // stack trace
         window.setTimeout(function () {
             if (lastException === ex) {
-                lastExceptionStack = null;
-                lastException = null;
-                notifyHandlers.apply(null, [stack, null].concat(args));
+                processLastException();
             }
         }, (stack.incomplete ? 2000 : 0));