Error handling and logging are crucial aspects of building robust Node.js applications, especially in production environments. Let’s dive into some advanced techniques to manage these effectively.

First off, it’s important to understand that errors in Node.js can be broadly categorized into operational errors and programmer errors. Operational errors are things like network failures or invalid user input, while programmer errors are bugs in your code.

For operational errors, you’ll want to handle them gracefully. This often means catching them, logging relevant information, and potentially retrying the operation or presenting a user-friendly message. Programmer errors, on the other hand, should typically cause the application to crash and restart.

Now, let’s talk about error handling. One common approach is to use a try-catch block. This works well for synchronous code:

try {
  // Some code that might throw an error
} catch (error) {
  console.error('An error occurred:', error);
}

But what about asynchronous code? For Promise-based operations, you can use .catch():

someAsyncOperation()
  .then(result => {
    // Handle success
  })
  .catch(error => {
    console.error('Async operation failed:', error);
  });

And with async/await, you can combine it with try-catch:

async function doSomething() {
  try {
    const result = await someAsyncOperation();
    // Handle success
  } catch (error) {
    console.error('Async operation failed:', error);
  }
}

But here’s where it gets tricky. In real-world applications, you’ll often have multiple layers of async operations. You don’t want to litter your code with try-catch blocks everywhere. This is where error middleware comes in handy.

In Express.js, for example, you can create a middleware function to handle errors:

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

This middleware will catch any errors that occur in your route handlers. But what if you’re not using Express? No worries, you can create your own error handling system.

One approach I’ve found useful is to create a wrapper function for your async operations:

function asyncHandler(fn) {
  return (req, res, next) => {
    Promise.resolve(fn(req, res, next)).catch(next);
  };
}

You can then use this wrapper around your route handlers:

app.get('/users', asyncHandler(async (req, res) => {
  const users = await getUsers();
  res.json(users);
}));

Now, if getUsers() throws an error, it will be caught and passed to your error handling middleware.

But error handling isn’t just about catching errors. It’s also about providing meaningful information when errors occur. This is where logging comes in.

Console.log is fine for development, but in production, you’ll want something more robust. Enter logging libraries like Winston or Bunyan.

Here’s a quick example of setting up Winston:

const winston = require('winston');

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  defaultMeta: { service: 'user-service' },
  transports: [
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' }),
  ],
});

if (process.env.NODE_ENV !== 'production') {
  logger.add(new winston.transports.Console({
    format: winston.format.simple(),
  }));
}

Now you can use logger.info(), logger.error(), etc., instead of console.log. This gives you much more control over your logging, including the ability to log to files, send logs to external services, and more.

But logging isn’t just about errors. It’s also about understanding what’s happening in your application. This is where structured logging comes in. Instead of logging strings, you log objects with specific fields. This makes it much easier to search and analyze your logs later.

For example, instead of:

logger.info('User logged in');

You might do:

logger.info({
  event: 'USER_LOGIN',
  userId: user.id,
  timestamp: new Date().toISOString(),
});

This approach makes it much easier to track specific events and patterns in your application.

Now, let’s talk about some advanced error handling techniques. One powerful approach is to create custom error classes. This allows you to add additional context to your errors and handle them more specifically.

Here’s an example:

class DatabaseError extends Error {
  constructor(message, query) {
    super(message);
    this.name = 'DatabaseError';
    this.query = query;
  }
}

// Usage
try {
  const result = await db.query('SELECT * FROM users');
} catch (error) {
  if (error instanceof DatabaseError) {
    logger.error({
      message: 'Database query failed',
      query: error.query,
      error: error.message,
    });
  } else {
    logger.error('An unexpected error occurred', error);
  }
}

This approach allows you to handle different types of errors differently, and log more contextual information when errors occur.

Another advanced technique is to use domain-driven error handling. This involves creating error types that match your domain model. For example, if you’re building an e-commerce site, you might have errors like ProductNotFoundError, InsufficientStockError, etc. This makes your error handling more meaningful and easier to understand.

Now, let’s talk about some common pitfalls in error handling. One big one is swallowing errors. This happens when you catch an error but don’t do anything with it:

try {
  // Some operation
} catch (error) {
  // Do nothing
}

This is almost always a bad idea. If you catch an error, you should at least log it. Otherwise, you’re losing valuable information about what’s going wrong in your application.

Another common issue is not handling Promise rejections. If you’re using Promises without .catch() or try-catch with async/await, unhandled rejections can crash your application. Always make sure to handle potential rejections.

Speaking of crashes, let’s talk about crash recovery. In a production environment, you want your application to be resilient. This often means automatically restarting when a crash occurs. Tools like PM2 or Docker can help with this.

But before we restart, we should log the crash. Node.js provides some global handlers for uncaught exceptions and unhandled rejections:

process.on('uncaughtException', (error) => {
  logger.error('Uncaught Exception:', error);
  process.exit(1);
});

process.on('unhandledRejection', (reason, promise) => {
  logger.error('Unhandled Rejection at:', promise, 'reason:', reason);
  process.exit(1);
});

Remember, though, that these should be used as a last resort. It’s always better to handle errors where they occur.

Now, let’s talk about logging in more detail. One important aspect is log levels. Most logging libraries support multiple levels like debug, info, warn, error. Use these appropriately to make it easier to filter your logs later.

Another key point is to be careful about what you log. Avoid logging sensitive information like passwords or API keys. Also, be mindful of performance. Excessive logging can slow down your application.

One technique I’ve found useful is to use a correlation ID for each request. This is a unique identifier that you generate for each incoming request and pass through all your function calls. When you log, include this ID. This makes it much easier to trace the path of a request through your system.

Here’s a simple middleware to add a correlation ID:

const uuid = require('uuid');

app.use((req, res, next) => {
  req.correlationId = uuid.v4();
  next();
});

Then in your logging:

logger.info({
  message: 'Processing user request',
  correlationId: req.correlationId,
  userId: user.id,
});

This approach is particularly useful in microservices architectures where a single user request might span multiple services.

Let’s also talk about logging in production. In a production environment, you’ll likely want to send your logs to a centralized logging service like ELK (Elasticsearch, Logstash, Kibana) stack, Splunk, or cloud services like AWS CloudWatch or Google Cloud Logging.

These services allow you to aggregate logs from multiple instances of your application, search through them easily, and set up alerts based on log patterns. This is crucial for monitoring and debugging production issues.

Another important aspect of production logging is log rotation. You don’t want your log files to grow indefinitely and fill up your disk. Most logging libraries have built-in support for log rotation, or you can use a separate tool like logrotate.

Now, let’s circle back to error handling and talk about validation. Proper input validation can prevent a lot of errors from occurring in the first place. Libraries like Joi or Yup can help with this:

const Joi = require('joi');

const schema = Joi.object({
  username: Joi.string().alphanum().min(3).max(30).required(),
  password: Joi.string().pattern(new RegExp('^[a-zA-Z0-9]{3,30}$')),
  repeat_password: Joi.ref('password'),
  email: Joi.string().email(),
});

try {
  const value = await schema.validateAsync(req.body);
} catch (error) {
  logger.warn({
    message: 'Invalid input',
    error: error.details[0].message,
    correlationId: req.correlationId,
  });
  res.status(400).json({ error: 'Invalid input' });
}

This approach allows you to catch and handle validation errors before they cause issues deeper in your application logic.

Lastly, let’s talk about testing your error handling. It’s important to not only test the happy path of your application, but also how it behaves when things go wrong. Write unit tests that deliberately cause errors and check that they’re handled correctly. This includes testing your logging – you can use a library like sinon to mock your logger and assert that the right messages are being logged.

In conclusion, effective error handling and logging are crucial for building robust Node.js applications. By implementing these advanced techniques, you can create applications that are more resilient, easier to debug, and provide a better experience for your users. Remember, the goal isn’t just to handle errors when they occur, but to provide meaningful information that helps you understand and fix issues quickly. Happy coding!