Logging exceptions in NestJS - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the Logger from NestJS.

NestJS

import { [1] } from '@nestjs/common';

Drag options to blanks, or click blank then click option'

AConsole

BLogger

CLogManager

DLogService

Attempts:

3 left

💡 Hint

Common Mistakes

Using a non-existent import like LogService or LogManager.

Trying to import Console which is not from NestJS.

The Logger class is imported from '@nestjs/common' to enable logging in NestJS.

2fill in blank

medium

Complete the code to create a Logger instance inside a service class.

NestJS

private readonly logger = new [1](MyService.name);

Drag options to blanks, or click blank then click option'

ALogger

BLogManager

CLogService

DConsole

Attempts:

3 left

💡 Hint

Common Mistakes

Using Console instead of Logger.

Trying to instantiate a non-existent LogService.

The Logger class is instantiated with the class name to tag logs properly.

3fill in blank

hard

Fix the error in logging an exception message inside a catch block.

NestJS

catch (error) {
  this.logger.[1]('Error occurred:', error.message);
}

Drag options to blanks, or click blank then click option'

Aerror

Blog

Cwarn

Dinfo

Attempts:

3 left

💡 Hint

Common Mistakes

Using log or info which are lower severity levels.

Using warn which is for warnings, not errors.

The error method logs error-level messages including exceptions.

4fill in blank

hard

Fill both blanks to log the stack trace of an exception.

NestJS

catch (error) {
  this.logger.[1]('Exception stack:', error.[2]);
}

Drag options to blanks, or click blank then click option'

Aerror

Bstack

Cmessage

Dlog

Attempts:

3 left

💡 Hint

Common Mistakes

Logging error.message instead of error.stack for full trace.

Using log or warn instead of error method.

Use error to log the message and stack to show the full stack trace of the exception.

5fill in blank

hard

Fill all three blanks to create a custom exception filter that logs exceptions.

NestJS

import { ExceptionFilter, Catch, ArgumentsHost, [1] } from '@nestjs/common';

@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
  private readonly logger = new [2](AllExceptionsFilter.name);

  catch(exception: any, host: [3]) {
    this.logger.error('Exception caught:', exception.stack);
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    response.status(500).json({ message: 'Internal server error' });
  }
}

Drag options to blanks, or click blank then click option'

ALogger

CArgumentsHost

DHttpException

Attempts:

3 left

💡 Hint

Common Mistakes

Importing HttpException instead of ArgumentsHost.

Using different names for Logger import and instance.

Wrong type for host parameter.

Import Logger and ArgumentsHost from '@nestjs/common'. Instantiate Logger for logging. Use ArgumentsHost type for the host parameter.

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