Node.js Uncaught Exception - Passing more details

A synchronous exception in an Express route handler will be caught by Express itself and the exception will be passed off the default Express error handler where you can catch it yourself and the exception context is passed to that default express error handler.

You can see this code inside of Express where a route handler gets called:

Layer.prototype.handle_request = function handle(req, res, next) {
  var fn = this.handle;

  if (fn.length > 3) {
    // not a standard request handler
    return next();
  }

  try {
    fn(req, res, next);
  } catch (err) {
    next(err);
  }
};

The call to next(err) will pass the exception object off to the default Express error handler (which you can install a handler for).

If your code is throwing an exception inside of an asynchronous callback, then that is more complicated to catch in action. If you're using regular async callbacks (not promises), then the only way I know of to catch those at a meaningful spot is to put a try/catch inside of every async callback so you can capture the local stack info.

If you use promises at the lowest level and only program your logic and asynchronous code flow use promise functionality, then an exception in a promise handler will automatically turn into a rejected promise and certain promise libraries (like the Bluebird library can be configured to give you a pretty full stack trace of where things went wrong). Promises have this advantage because every promise .then() or .catch() handler is automatically wrapped in a try/catch handler and those are turned into promise rejections which propagate up the chain to the first .catch() handler they find.

For the non-Express example you just added to your question, you will just have to put a try/catch somehwere in the local neighborhood to catch a local synchronous exception:

function doTheBatman(var1) {
  try {
      var var2 = 'whatever';
      // this causes an uncaught exception later in the code
  } catch(e) {
      console.log(e);
  }
}

You can even set a debugger breakpoint in the catch handler and then examine variables in that scope when it is hit. I don't know of any way to examine the local variables at the point of the exception from the uncaughtException handler. err.stack should give you the stack trace, but not variable values.

Express/frameworks may offer more elegant/robust solutions, but if you're truly after what your question asks for... why not just capture variables outside of the functions scope? This is typically nasty and not considered best practice, but if you have a function that you know could be susceptive to failing often, perhaps the quick and dirty solution is what you need. You could always refine this later, but hopefully this demonstrates the approach...

var transactionVars = {};

function clearTransaction() {
  transactionVars = {};
}

function doTheBatman(var1) {
  transactionVars['var2'] = 'whatever';
  // [...] bunch of stuff, possibly blowing up...
  clearTransaction(); // we made it this far? cool, reset...
}

process.on('uncaughtException', function(err) {
  console.log(transactionVars['var2']); // whatever
});

Furthermore, if you want to really dirty (in case these two functions are in two files) you can always tack transactionVars on the global object.

This is essentially a poor mans event emitter pattern, which I would highly recommend refactoring into once you grasp the general flow of how this works...