Logging exceptions in NestJS - Step-by-Step Execution

Concept Flow - Logging exceptions

Exception occurs in code

↓

Catch exception in catch block

↓

Log exception details

↓

Optional: Re-throw or handle gracefully

↓

Continue execution or exit

When an error happens, the program catches it, logs the details for review, then decides to continue or stop.

Execution Sample

NestJS

try {
  // code that may fail
} catch (error) {
  this.logger.error('Error caught:', error.stack);
}

This code tries to run something risky, and if it fails, it logs the error stack trace.

Execution Table

Step	Action	Code Executed	Result	Log Output
1	Start try block	try { riskyCode(); }	riskyCode runs	No log yet
2	Exception thrown	riskyCode() throws Error	Exception caught	No log yet
3	Catch block entered	catch (error) { ... }	Error object available	No log yet
4	Log error	this.logger.error('Error caught:', error.stack);	Error logged	Error caught: <stack trace>
5	End catch block	}	Catch block ends	Log recorded
6	Continue or exit	After catch block	Program continues or stops	Log remains for review

💡 Exception caught and logged, program flow continues or stops based on handling

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
error	undefined	Error instance created	Error instance available in catch	Error instance remains

Key Moments - 3 Insights

Why do we log error.stack instead of just error?

Logging error.stack shows the full trace of where the error happened, which helps debugging better than just the error message. See execution_table step 4.

What happens if we don't catch the exception?

If not caught, the program may crash or stop unexpectedly. Catching lets us log and handle errors gracefully, as shown in steps 2 and 3.

Can the program continue after logging the exception?

Yes, depending on handling after catch block (step 6), the program can continue or exit safely.

Visual Quiz - 3 Questions

Look at the execution table, at which step is the error object first available?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Check the 'Result' column for when the error object is accessible in the catch block.

At which step does the actual logging happen?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look for the 'Log error' action and the 'Log Output' showing the error message.

If the catch block did not log the error, what would be missing in the execution table?

A Error object creation

B Exception thrown

C Log Output with error details

D Try block execution

💡 Hint

Refer to the 'Log Output' column in steps 4 and 5 to see what logging adds.

Concept Snapshot

try {
  // risky code
} catch (error) {
  this.logger.error('Error caught:', error.stack);
}

- Catch exceptions to prevent crashes
- Log error.stack for full trace
- Decide to continue or exit after logging

Full Transcript

In NestJS, when code might fail, we wrap it in a try block. If an error happens, the catch block runs. Inside catch, we log the error details using this.logger.error and include error.stack to see where the error happened. This helps us understand and fix issues. After logging, we can choose to continue running or stop safely. This process prevents unexpected crashes and keeps logs for debugging.

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