Understanding Error Handling in Node.js Jacopo Daeli Lead Software Engineer @ GoDaddy San Francisco, Feb 15th 2018 Holberton School 

Who am I? u I'm a Computer Scientist, Software Engineer and Hacker, passionate about web technologies. I develop with Node.js, Go, C/C++, React and Redux for the web. u I currently live in San Francisco and work as Software Engineer at GoDaddy. u Previously, I was Head of Engineering at Tribe App – An early backed Sequoia Capital startup based in Paris and San Francisco. 

Summary u Notion of asynchronous programming with Node.js u Guidelines for building robust applications u Error Mechanisms in Node.js u Catching, logging, dealing with errors u Express, Async Middleware and Boom ☄ 

Notion of asynchronous programming with Node.js 

This works try { throw new Error('This is not right!') } catch (e) { console.log('We caught the error.') } 

But this won’t work try { process.nextTick(() => { throw new Error('This is not right!') }) } catch (e) { console.log('We caught the error.') } 

Why? Try/Catch is synchronous, process.nextTick is asynchronous This means: • The Callback is queued and will throw the error in the next loop • The Catch block is no longer waiting to catch the exception 

What are we dealing with? u We cannot try/catch everything u We need other mechanisms to handle async errors u A not-well handled error in one single request can crash your entire application 

Errors in JavaScript u Error is a built-in object type u Error objects are first class citizens u Runtime errors throw an Error object u It has a name, message and stack property u Besides the generic Error constructor, there are seven other core error constructors in JavaScript: EvalError, InternalError, RangeError, RefrenceError, SyntaxError, TypeError, URIError. var notRightError = new Error('This is not right!') 

Exceptions in JavaScript u An Exception is what happens when you throw something u In JS it’s good practice to throw Error objects u If an exception is unhandled, your process will exit throw new Error('this is the right way') throw 'avoid throwing non-Error stuff' 

Errors in Async World u Throwing won’t work u We are passing Error objects as callback argument 

Guidelines for building robust applications Two rules to rule them all! 

Understand when and why your errors happen 

Avoid patterns like function (err, result) { if (err) { // do absolutely nothing } console.log(result) } try { // some code that can potentially throw } catch (err) { // this will never happen } Promise.catch((err) => { // ops, let's just ignore this ha ha }) socket.on('error', (err) => { // again, do nothing ! }) 

Understand Operational Errors vs Programmer Errors and learn how to deal with these 

Operational Errors u They are recoverable u Must be expected and handled in your application u Examples: Network timeouts, External service is not available or it returns errors, Unexpected or missing user inputs 

Programmer Errors u Not recoverable u Do not need to be handled u Must be fixed in your application code u Examples: Using a not defined variable, Passing a "string" where an object was expected 

Error Mechanisms in Node.js 

Try/Catch var data = "this is not a valid json serialized data” try { var parsed = JSON.parse(data) } catch (err) { console.error(err.message) // print: Unexpected token h in JSON at position 1 } 

Callbacks function fetchAndParse (url, callback) { function requestGetCallback (err, res, body) { if (err) return callback(err) if (res.statusCode > 399) { return callback(new Error(`Server returns ${res.statusCode}`)) } try { callback(null, JSON.parse(body)) } catch (err) { callback(err) } } request.get(url, requestGetCallback) } 

Promises function makeRequest (url) { return new Promise((resolve, reject) => { request.get(url, (err, res, body) => { if (err) return reject(err) if (res.statusCode > 399) { return reject(new Error(`Server returns ${res.statusCode}`)) } resolve(body) }) }) } makeRequest('http://example.com/json') .then((body) => JSON.parse(body)) .then((parsedBody) => console.log(parsedBody)) .catch((err) => { /* handle error */ }) 

Async/Await – wait what? ! try { const body = await makeRequest('http://example.com/json') const parsedBody = JSON.parse(body) console.log(parsedBody) } catch (err) { // handle error } u Just syntax sugar for promises u It allows us to use Try/Catch 

EventEmitter const server = net.createServer((socket) => { socket.end('Goodbye ! \n') }) server.on('error', (err) => { // handle error }) // grab an arbitrary unused port server.listen(() => { console.info(`TCP server listening on ${server.address()}`) }) 

Catching, logging, dealing with errors 

Example: HTTP Server const server = http.createServer((req, res) => { const query = url.parse(request.url, true).query if (!query.uid) { // do not track client errors res.writeHead(400, { 'Content-Type': 'text/plain' }) return res.end('Bad Request') } db.get(`user:${query.uid}`, (err, user) => { if (err) { return trackError(err, () => { res.writeHead(500, { 'Content-Type': 'text/plain' }) res.end('Internal Server Error') }) } if (!user) { res.writeHead(404, { 'Content-Type': 'text/plain' }) return res.end(’Not Found') } res.writeHead(200, { 'Content-Type': 'text/plain' }) res.end(`${user.firstname} ${user.lastname}`) }) }) server.listen(8080, (err) => { if (err) throw err // re-throw this and handle it in the global handler console.info('Server is listening on *:8080') }) // basic global error handler process.on('uncaughtException', (err) => { trackError(err, () => process.exit(1)) }) 

Example: trackError function (1) function trackError (err, callback) { logger.error(err.message, { stack: err.stack }) sendTextMessage(phoneNumber, err.message, (sendError) => { if (sendError) { logger.error(sendError.message, { stack: sendError.stack }) } callback() }) } 

Example: trackError function (2) const Raven = require('raven') Raven.config('https://:@sentry.io/').install() function trackError (err, callback) { logger.error(err.message, { stack: err.stack }) Raven.captureException(err, (sendErr) => { if (sendErr) { logger.error(sendErr.message, { stack: sendErr.stack }) } }) } 

Example: Graceful shutdown function closeServer (cb) { if (!server.address()) return cb() server.close(cb) } function closeDBConnection (cb) { if (!db.isConnected()) return cb() db.close(cb) } function shutdownGracefully (cb) { closeServer(() => { closeDBConnection(cb) }) } // global error handler process.on('uncaughtException', (err) => { shutdownGracefully(() => { trackError(err, () => process.exit(1)) }) }) 

Express, Async Middleware and Boom 

Example: async-middleware.js const boom = require('boom') const asyncMiddleware = fn => (req, res, next) => { Promise.resolve(fn(req, res, next)).catch((err) => { if (!err.isBoom) { // generic internal error server return next(boom.badImplementation(err)) } next(err) }) } 

Example: error-handler.js const logger = require('winston') const errorHandler = fn => (err, req, res, next) => { const shouldLog = (err.isServer || typeof err.isServer === 'undefined') if (shouldLog) { logger.error(err.message, { stack: err.stack, originalUrl: req.originalUrl }) } // handle boom errors if (err.isBoom) { return res.status(err.output.statusCode).json(err.output.payload) } res.status(500).json({ error: { message: 'Unexpected Error' } }) } 

Example: app.js (1) const boom = require('boom') const express = require('express') const joi = require('joi') const logger = require('winston') const asyncMiddleware = require('./async-middleware') const errorHandler = require('./error-handler') const shutdownGracefully = require('./shutdown-gracefully') const app = express() 

Example: app.js (2) const helloSchema = { format: joi.any().required().valid(['json', 'text']) } app.get('/hello/:format', asyncMiddleware(async (req, res, next) => { const result = joi.validate(req.params, helloSchema) // validation if (result.error) { throw boom.badRequest(result.error.message) } switch (req.params.format) { case 'json': return res.json({ hello: 'world' }) default: res.send('hello world') } })) 

Example: app.js (3) app.use(errorHandler()) app.listen(8080, (err) => { if (err) throw err logger.info('App listening on *:8080') }) // global error handler process.on('uncaughtException', (err) => { shutdownGracefully(() => { trackError(err, () => process.exit(1)) }) }) 

Conclusions u Do not simply log errors, take some actions when you can u Programmer errors should NOT be handled u Have a global uncaughtException listener for errors you cannot not handle u Do not centralize handling of operational errors u When delivering errors, use the standard Error class and its standard properties 

Further Readings u https://nodejs.org/api/errors.html u https://www.joyent.com/node-js/production/design/errors u https://blog.risingstack.com/node-js-production-checklist