Logging exceptions in NestJS - Deep Dive

Overview - Logging exceptions

What is it?

Logging exceptions means recording details about errors that happen in your NestJS application. When something goes wrong, the app saves information about the error so developers can understand and fix it. This process helps keep track of problems without stopping the whole app.

Why it matters

Without logging exceptions, developers would have no clear way to know what errors occurred or why. This would make fixing bugs slow and frustrating, leading to poor user experience and unstable applications. Logging exceptions helps catch issues early and improves app reliability.

Where it fits

Before learning logging exceptions, you should understand basic NestJS concepts like modules, controllers, and providers. After this, you can explore advanced error handling, monitoring tools, and performance optimization.

Mental Model

Core Idea

Logging exceptions is like keeping a detailed diary of every problem your app faces so you can solve them faster and prevent future issues.

Think of it like...

Imagine a car dashboard that lights up when something is wrong. Logging exceptions is like the car's black box recording exactly what happened during a problem, so mechanics can fix it properly.

┌─────────────────────────────┐
│        NestJS App           │
├─────────────┬───────────────┤
│  Exception  │   Logger      │
│  Occurs     │  Records info │
├─────────────┴───────────────┤
│   Logs stored for review    │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

What is an Exception in NestJS

Concept: Learn what exceptions are and how NestJS handles them by default.

In NestJS, an exception is an error that happens during the app's operation, like a missing file or bad input. NestJS has built-in exception filters that catch these errors and send a response to the user, usually with an error message and status code.

Result

You understand that exceptions are errors that disrupt normal flow and that NestJS catches them to respond gracefully.

Knowing what exceptions are helps you realize why logging them is important to track and fix problems.

2

Foundation

Introduction to NestJS Logger

Concept: Discover the built-in Logger service NestJS provides for logging messages and errors.

NestJS includes a Logger class that lets you write messages to the console or other outputs. You can log info, warnings, errors, and debug messages. This Logger is easy to use and integrates well with the framework.

Result

You can add simple logs to your app to see messages during development or production.

Understanding the Logger is the first step to recording exceptions effectively.

3

Intermediate

Using Exception Filters for Custom Logging

🤔Before reading on: Do you think NestJS logs exceptions automatically or do you need to add custom code? Commit to your answer.

Concept: Learn how to create custom exception filters to log exceptions with more detail.

NestJS allows you to write custom exception filters by implementing the ExceptionFilter interface. Inside the filter, you can catch exceptions and use the Logger to record detailed information like error messages, stack traces, and request data before sending a response.

Result

Your app logs detailed exception info whenever an error occurs, improving debugging.

Knowing how to customize exception handling lets you capture richer logs tailored to your app's needs.

4

Intermediate

Global Exception Filters for Centralized Logging

🤔Before reading on: Should you add logging code in every controller or use a global filter? Commit to your answer.

Concept: Understand how to apply exception filters globally to log all exceptions in one place.

Instead of adding logging in each controller, NestJS lets you register a global exception filter. This filter catches all exceptions across the app, ensuring consistent logging and reducing repeated code.

Result

All exceptions are logged centrally, making maintenance easier and logs uniform.

Centralizing logging reduces errors and ensures no exceptions go unnoticed.

5

Intermediate

Integrating External Logging Libraries

🤔Before reading on: Do you think NestJS Logger is enough for production logging or should you use external tools? Commit to your answer.

Concept: Explore how to use popular logging libraries like Winston or Pino with NestJS for advanced logging features.

NestJS Logger is simple but limited. Libraries like Winston or Pino offer features like log levels, file storage, JSON formatting, and transports to external systems. You can create a custom Logger service that wraps these libraries and use it in your exception filters.

Result

Your app produces structured, persistent logs suitable for production monitoring and analysis.

Using external libraries unlocks powerful logging capabilities beyond the basics.

6

Advanced

Logging Context and Correlation IDs

🤔Before reading on: Do you think logs from different requests should be mixed or separated? Commit to your answer.

Concept: Learn how to add context like request IDs to logs to trace errors across distributed systems.

In complex apps, many requests happen at once. Adding a unique correlation ID to each request and including it in logs helps trace the flow of a single request through multiple services. You can use middleware to generate IDs and pass them to the Logger.

Result

Logs become easier to analyze because you can follow a request's journey and find related errors quickly.

Contextual logging is essential for debugging in real-world, multi-service applications.

7

Expert

Performance and Security in Exception Logging

🤔Before reading on: Should all exception details always be logged, including sensitive data? Commit to your answer.

Concept: Understand how to balance detailed logging with performance and security concerns.

Logging every detail can slow your app and expose sensitive info like passwords or personal data. Experts filter logs to exclude sensitive fields and use asynchronous logging to avoid blocking requests. They also set log levels to control verbosity in production.

Result

Your app logs useful info without risking leaks or slowdowns, maintaining user trust and performance.

Knowing how to protect data and optimize logging prevents serious production issues.

Under the Hood

When an exception occurs, NestJS passes it to exception filters. These filters receive the error object and the current request context. The Logger service formats the error details and outputs them to the console or external systems. Custom filters can enrich logs with stack traces, timestamps, and request info. The logging process is synchronous or asynchronous depending on the Logger implementation, affecting app responsiveness.

Why designed this way?

NestJS separates exception handling from logging to keep concerns clear and flexible. Built-in filters provide default behavior, but custom filters allow developers to tailor logging to their needs. This design supports modularity and extensibility, letting apps integrate with various logging tools and strategies.

┌───────────────┐
│ Exception     │
│ Occurs in App │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Exception     │
│ Filter        │
│ (Customizable)│
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Logger Service│
│ (NestJS or    │
│ External lib) │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Log Output    │
│ (Console,     │
│ Files, Remote)│
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does NestJS automatically log all exceptions with full details? Commit to yes or no.

Common Belief: NestJS logs every exception automatically with all details by default.

Reality: NestJS sends error responses but does not log detailed exception info unless you add custom logging.

Why it matters: Relying on default behavior means missing critical error details, making debugging harder.

Quick: Should you log sensitive user data in exceptions? Commit to yes or no.

Common Belief: Logging all exception details, including user data, is helpful for debugging.

Reality: Logging sensitive data risks security breaches and violates privacy best practices.

Why it matters: Exposing sensitive info in logs can lead to data leaks and legal issues.

Quick: Is it best to add logging code inside every controller method? Commit to yes or no.

Common Belief: Adding logging inside each controller method is the best way to catch exceptions.

Reality: Centralized global exception filters provide cleaner, consistent logging without repeated code.

Why it matters: Scattered logging code increases maintenance burden and risks inconsistent logs.

Quick: Does logging exceptions synchronously never affect app performance? Commit to yes or no.

Common Belief: Logging exceptions synchronously is always fine and does not impact app speed.

Reality: Synchronous logging can slow down request handling, especially under heavy load.

Why it matters: Ignoring performance impact can cause slow responses and poor user experience.

Expert Zone

1

Exception filters can rethrow exceptions after logging to let other filters or global handlers process them, enabling layered error handling.

2

Using structured logging formats like JSON allows logs to be parsed and analyzed by monitoring tools more effectively than plain text.

3

Correlation IDs should be propagated across asynchronous calls and microservices to maintain traceability in distributed systems.

When NOT to use

Avoid heavy synchronous logging in high-throughput or latency-sensitive applications; instead, use asynchronous logging or external log collectors. Also, do not log sensitive data; use data masking or omit such fields. For very simple apps, built-in Logger may suffice without external libraries.

Production Patterns

In production, teams use global exception filters combined with external logging libraries like Winston or Pino. Logs are sent to centralized systems like ELK stack or cloud monitoring services. Correlation IDs are added via middleware. Log levels are configured to reduce noise, and sensitive data is filtered out. Alerts are set up to notify on critical errors.

Connections

Observability

Logging exceptions is a key part of observability, which also includes metrics and tracing.

Understanding exception logging helps grasp how apps report their health and behavior in real time.

Middleware Pattern

Exception filters in NestJS act like middleware that intercepts errors to log them.

Knowing middleware concepts clarifies how logging fits into request processing pipelines.

Forensic Science

Logging exceptions is like forensic evidence collection after a crime to understand what happened.

This cross-domain link shows how careful data collection after an event helps solve problems, whether in apps or investigations.

Common Pitfalls

#1 Logging exceptions without filtering sensitive data.

Wrong approach:

logger.error(`User login failed: ${user.password}`);

Correct approach:

logger.error(`User login failed for user: ${user.username}`);

Root cause:

Misunderstanding that logs are visible and can expose private information.

#2 Adding logging code inside every controller method.

Wrong approach:

try { /* code */ } catch (e) { logger.error(e); throw e; } // repeated everywhere

Correct approach:

Use a global exception filter to handle and log all exceptions centrally.

Root cause:

Not knowing about global exception filters leads to repetitive and inconsistent logging.

#3 Using synchronous logging in high-load scenarios.

Wrong approach:

logger.errorSync(error); // blocks request processing

Correct approach:

Use asynchronous logging methods or external log collectors to avoid blocking.

Root cause:

Ignoring performance impact of blocking operations during request handling.

Key Takeaways

Logging exceptions records error details to help developers find and fix problems faster.

NestJS provides built-in tools like Logger and exception filters to customize how errors are logged.

Centralizing logging with global exception filters avoids repeated code and ensures consistent logs.

Using external logging libraries and adding context like correlation IDs improves production monitoring.

Balancing detailed logging with security and performance is essential for reliable, safe applications.

Practice

1. What is the main purpose of logging exceptions in a NestJS application?

easy

A. To increase the app's memory usage

B. To speed up the application runtime

C. To track and fix errors by recording error details

D. To prevent users from accessing the app

Solution

1. Step 1: Understand the role of exception logging

   Logging exceptions records error details like messages and stack traces to help developers find and fix bugs.

2. Step 2: Identify the correct purpose

   Among the options, only tracking and fixing errors matches the purpose of logging exceptions.

3. Final Answer:

   To track and fix errors by recording error details -> Option C

4. Quick Check:

   Logging exceptions = track and fix errors [OK]

Hint: Logging exceptions helps find bugs by saving error info [OK]

Common Mistakes:

• Thinking logging improves app speed
• Confusing logging with security features
• Believing logging increases memory unnecessarily

2. Which of the following is the correct way to log an error with NestJS Logger inside a catch block?

easy

A. Logger.error(error.message, error.stack, 'MyContext')

B. Logger.log(error.message, 'MyContext')

C. Logger.warn(error.stack, 'MyContext')

D. Logger.debug(error.message, error.stack)

Solution

1. Step 1: Recall Logger.error method signature

   Logger.error takes three arguments: message, stack trace, and optional context string.

2. Step 2: Match the correct syntax

   Logger.error(error.message, error.stack, 'MyContext') correctly uses Logger.error with message, stack, and context. Others use wrong methods or missing parameters.

3. Final Answer:

   Logger.error(error.message, error.stack, 'MyContext') -> Option A

4. Quick Check:

   Logger.error(message, stack, context) = Logger.error(error.message, error.stack, 'MyContext') [OK]

Hint: Use Logger.error with message, stack, and context [OK]

Common Mistakes:

• Using Logger.log or Logger.warn instead of Logger.error
• Omitting the stack trace argument
• Passing arguments in wrong order

3. Given this NestJS code snippet inside a service method:

try {
  throw new Error('Failed operation');
} catch (error) {
  Logger.error(error.message, error.stack, 'MyService');
}

What will be logged?

medium

A. An info log with stack trace only

B. A warning log with message 'Failed operation' only

C. No log will be created because throw stops execution

D. An error log with message 'Failed operation' and stack trace under 'MyService' context

Solution

1. Step 1: Understand the try-catch behavior

   The error is thrown and immediately caught by catch block, so execution continues inside catch.

2. Step 2: Analyze Logger.error call

   Logger.error logs an error message with stack trace and context 'MyService'. This creates an error-level log entry.

3. Final Answer:

   An error log with message 'Failed operation' and stack trace under 'MyService' context -> Option D

4. Quick Check:

   Throw caught and logged as error with message and stack [OK]

Hint: Catch errors to log message and stack with Logger.error [OK]

Common Mistakes:

• Thinking throw stops all logging
• Confusing log levels (warn vs error)
• Ignoring the context parameter

4. Identify the error in this NestJS exception logging code:

try {
  // some code
} catch (error) {
  Logger.error(error.stack, error.message, 'AppModule');
}

medium

A. Arguments to Logger.error are reversed; message should come first

B. Logger.error cannot be used inside catch blocks

C. Missing await keyword before Logger.error

D. Logger.error requires only one argument

Solution

1. Step 1: Check Logger.error argument order

   Logger.error expects (message, stack, context). Here, stack and message are swapped.

2. Step 2: Confirm correct usage

   Swapping arguments causes wrong log output or errors. Correct order is message first, then stack trace.

3. Final Answer:

   Arguments to Logger.error are reversed; message should come first -> Option A

4. Quick Check:

   Logger.error(message, stack, context) order matters [OK]

Hint: Logger.error needs message first, then stack, then context [OK]

Common Mistakes:

• Swapping message and stack arguments
• Thinking Logger.error is async needing await
• Assuming Logger.error takes only one argument

5. You want to log exceptions in a NestJS global exception filter to capture all errors with context 'GlobalFilter'. Which code snippet correctly implements this?

hard

A. catch(exception: any) {
Logger.log(exception.message, 'GlobalFilter');
}

B. catch(exception: any) {
Logger.error(exception.message, exception.stack, 'GlobalFilter');
}

C. catch(exception: any) {
Logger.warn(exception.stack, 'GlobalFilter');
}

D. catch(exception: any) {
Logger.debug(exception.message, exception.stack);
}

Solution

1. Step 1: Understand global exception filter logging

   Global filters catch all exceptions; logging must use Logger.error with message, stack, and context.

2. Step 2: Evaluate each option

   catch(exception: any) { Logger.error(exception.message, exception.stack, 'GlobalFilter'); } correctly calls Logger.error with message, stack, and 'GlobalFilter' context. Others use wrong log levels or miss stack/context.

3. Final Answer:

   catch(exception: any) { Logger.error(exception.message, exception.stack, 'GlobalFilter'); } -> Option B

4. Quick Check:

   Global filter logs errors with Logger.error and context [OK]

Hint: Use Logger.error with message, stack, and context in global filters [OK]

Common Mistakes:

• Using Logger.log or Logger.warn instead of Logger.error
• Omitting stack trace or context
• Using Logger.debug which is too low level