We Keep Coding

What is the best use of process.on('uncaughtException', ...)?

I am learning error/exception handling and I do not understand how process.on('uncaughtException', ...) is used. Can you use it the same way as try and catch, or does it only handle exceptions?

As said in the Process Documentation provide information and control over, the current (node) process.
I'd use it a lot on backend development with node/express, a simple example? logging the errors of my application
// ERROR LOG MANAGEMENT
// =====================================================================
let errorLogStream = fs.createWriteStream(__dirname + '/logs/error.log', {
flags: 'a'
})
// ERROR HANDLING
// =====================================================================
process.on('uncaughtException', (err, next) => {
var date = new Date()
console.error(`+++++++ ${date} error found, logging event +++++++`)
console.error(err.stack)
errorLogStream.write(`Date: ${date}. Err: ${err.stack}`)
return
})
I think the main difference its said by the event name itself, if you are executing some task and have an error, handle it, why do you would throw it to catch it there? i mainly use it for non-related issues with my logic

Express.js: Does calling next(error) from a route handler call a global error handling middleware?

Let's say I have defined the following middleware and route handlers:
app.use(function(err,req,res,next) {
res.status(500).send('Something broke!');
});
app.get('/test',function(req,res) {
//some error happens here, and ther "error" object is defined
next(error);
});
Doe the error handling middleware get called?
If not, would the error handling middleware be called if
the error handling middleware was defined BELOW the route handler?
I use throw error; instead of next(error);?
both of the above are true?
Or should I do something like that:
//route.js
module.exports=function(req,res,next) {
//error happens here
next(error);
}
//errorHandler.js
module.exports=function(err,req,res,next) {
res.status(500).send('Something broke!');
}
//app.js
var route=require('route');
var errorHandler=require('erorHandler');
app.get('/test',[route,errorHandler]);
I'm a bit confused right now...

The order of middlewares, app.get, app.post, etc. matters, they are processed in the order they are added in your code.
So when you define it like you did
app.use(function(err,req,res,next) {
res.status(500).send('Something broke!');
});
app.get('/test',function(req,res) {
//some error happens here, and ther "error" object is defined
next(error);
});
the first middleware will catch all the requests and returns status 500 so it never reaches the app.get('test'...
the error handler should always be at the bottom of your code, so if there's an error in some route handler you call next(error) and the error handler will respond to client with some message like yours res.status(500).send('Something broke!');
And this
app.get('/test',[route,errorHandler]);
is actualy bad since you would need to use it in every route
Good:
app.get('/test',function(req,res,next) {
//some error happens here, and ther "error" object is defined
next(error);
});
app.use(function(err,req,res,next) {
res.status(500).send('Something broke!');
});
app.listen(8000);

expressJS promise and error handling

I have a route that first need to query the database, then with the results, query another web service, then with that result render the page.
I have that flow worked out and am trying to figure out the error handling. Given that i talk to multiple service, I'm trying to massage the error before returning them to express.
Here is the structure of the code for the route:
Models.Episode.findById(request.params.episodeID)
.catch(function (error) {
throw (throwjs.notFound());
})
.then(function (episode) {
if (episode.getUser().id !== request.user.href) {
return next(throwjs.unauthorized("You do not have access to this podcast"));
}
return doSomeOtherAsyncStuff();
})
.then(function (queryResponse) {
renderPage();
})
.catch(function (error) {
next(error);
});
My problem is with the first catch. My goal in this catch is to repackage the error and stop the execution and send the error to express middleware.
With the way it is written above, the execution stops, but my express error handler are not called.
I tried rewriting the first catch as
.catch(function(error){
return next(error);
})
But that does not solve the issue. The only solution i found is to move the catch to the end. But then i lose context of the failure location.
Any clue as to what i'm doing wrong?
Thanks, olivier

I'd recommend taking a different approach so you don't have to rely on long running promise chains. With the following approach, you've decoupled your authorization and and validation to separate middleware, since they're not necessarily a concern of the actual episode handler itself. Plus this approach is more idiomatic to express.
An added bonus is that you're free to pass errors down to an error handler so you further decouple your errors from your route handlers.
function validateEpisode(req, res, next) {
Models.Episode
.findById(req.params.episodeID)
.then(function(episode) {
req.yourApp.episode = episode;
next() // everything's good
})
.catch(function(error) {
// would be better to pass error in next
// so you can have a general error handler
// do something with the actual error
next(throwjs.notFound());
});
}
function authUserByEpisode(req, res, next) {
if (req.yourApp.episode.getUser().id !== req.user.href) {
next(throwjs.unauthorized("You do not have access to this podcast"));
}
next(); // authorized
}
function episodeController(req, res) {
// do something with req.yourApp.episode
}
app.get('/episode/:id', validateEpisode, authUserByEpisode, episodeController)

Well after all, this is related to the throwjs framework I'm using and the fact that I'm using incorrectly
throw (throwjs.notFound());
should be
throw (new throwjs.notFound());
...

How do I properly issue response to post when waiting for async method to complete?

Here's the setup in a module. See, esp., comments marked by ****:
exports.saveWall = function (req, res) {
var status;
mongoClient.connect(connectionString, function (err, db) {
if (err) { return console.dir(err); }
db.collection(pictureWallsCollectionName).insert(
{ _id: req.body.wallId, pictures: req.body.pictures },
function (err, res) {
db.close();
if (err) {
status = 500;
console.dir(err);
}
else {
status = 200;
//*****can't do this here, because res is out of scope!
res.status(status).send(http.STATUS_CODES[status])
console.log('Inserted into the ' + pictureWallsCollectionName + ' collection');
}
});
});
//*****can't do this yet because the above isn't done.
res.status(status).send(http.STATUS_CODES[status])
}
I basically want to call the line res.status(status).send(http.STATUS_CODES[status]) in my callback, but I can't because res.status is null at that point.
All I want to do is respond to a POST, but I am not getting anywhere.

Even though you solved your scope issue (which is awesome), nesting callbacks can get kind of tricky quickly (as you saw). A good way to deal with this is to use promises. The two main packages for promises are Q and Bluebird (with Bluebird being my favorite).
You can also use a package that has already promise-ified mongo calls for you, like promised-mongo
Once you have that all set up, it's just a matter of chaining .then for successive steps, and then sending your response when the promise is resolved.
For a specific example, check out this answer and see if that helps.

Ugh...
It turns out my issue was that "res" was defined both here:
exports.saveWall = function (req, res) {
...and here:
db.collection(pictureWallsCollectionName).insert(...,
function (err, res) {
...so it turns out I could call "res" all along, I was just trying to call the wrong "res" because it got redefined.
On a side note, f*** you, javascript!

exit from express middleware with specific http status

Hopefully this is a simple one, but I have some custom middleware which I want to return a 404 or 401 etc to the user and stop the propagation of other handlers etc.
I was expecting I could do something like:
function SomeMiddleware(req, res, next) {
if(user.notRealOrSomething)
{ throw new HttpException(401, "Tough luck buddy"); }
return next();
}
However cannot find any specific info about how is best to do this.

You are suppose to pass errors to the next() function.
function SomeMiddleware(req, res, next) {
if(user.notRealOrSomething) {
return next(throw new HttpException(401, "Tough luck buddy"));
}
next();
}
Any argument you pass to next will be considered an error except 'route' which will skip to the next route.
When next is called with an error the error middleware will be execute.
function (err, req, res, next) {
// err === your HttpException
}
Express.js will treat any middleware with 4 arguments as error middleware.
Error-handling middleware are defined just like regular middleware, however must be defined with an arity of 4, that is the signature (err, req, res, next):
All of this is pretty well documented at: http://expressjs.com/guide/error-handling.html

Nothing prevents you from using the response object:
res.send(401, "Tough luck buddy");
next('invalid user');

The code as written in the answer should work just fine, since the code is synchronous - that is, it's not async and it doesn't hand next() off to a callback anywhere. Per the Express.js docs (emphasis mine):
Errors that occur in synchronous code inside route handlers and middleware require no extra work. If synchronous code throws an error, then Express will catch and process it.
So in synchronous middlewares and handlers, just throw the error, Express will catch it and pass it to the error middleware.
For asynchronous middlewares, you need to pass the error object to the next() function without throwing it. The example from the docs applies just as well to middlewares as it does to route handlers (which are in fact also middleware), to adapt it to your example:
function SomeMiddleware(req, res, next) {
user.checkRealOrSomethingAsync(isReal => {
if(!isReal) {
// Note: Pass the exception, do not throw it!
next(new HttpException(401, "Tough luck buddy"))
}
next()
})
}
Note that, as per the Express docs, this means you must catch any errors thrown in async middlewares or routes and pass them into next().
However! Starting in Express 5, you don't need to catch errors thrown within async methods, the error will be propagated as normal without you doing anything. express-async-errors package will patch Express.js 4 to work similarly. Note this only applies to errors at the "top level" of the async function - if you're mixing async and callbacks, you'll still have to catch errors inside the callbacks.