Logging interceptor in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

Output of a simple NestJS logging interceptor

Given the following NestJS logging interceptor code, what will be logged when a controller method returns 'Hello World'?

NestJS

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable, tap } from 'rxjs';

@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    console.log('Before handler execution');
    return next.handle().pipe(
      tap(() => console.log('After handler execution'))
    );
  }
}

A Does not log anything

B Logs only 'Before handler execution' before the method

C Logs only 'After handler execution' after the method

D Logs 'Before handler execution' before the method and 'After handler execution' after the method

💡 Hint

Think about when the tap operator runs in an RxJS observable pipeline.

The interceptor logs a message before the handler runs, then uses tap to log after the handler completes.

🧠 Conceptual

intermediate

Purpose of a logging interceptor in NestJS

What is the main purpose of using a logging interceptor in a NestJS application?

A To modify the response body before sending it to the client

B To log details about incoming requests and outgoing responses centrally

C To handle exceptions thrown by controller methods

D To authenticate users before accessing routes

💡 Hint

Think about what interceptors can do with requests and responses.

Logging interceptors are used to capture and log information about requests and responses in one place.

❓ Configuration

advanced

Correct way to apply a global logging interceptor in NestJS

Which code snippet correctly applies a logging interceptor globally in a NestJS application?

NestJS

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { LoggingInterceptor } from './logging.interceptor';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  // Apply interceptor here
  await app.listen(3000);
}
bootstrap();

A app.useGlobalInterceptors(new LoggingInterceptor());

B app.useGlobalInterceptor(new LoggingInterceptor());

C app.applyGlobalInterceptors(new LoggingInterceptor());

D app.useInterceptorGlobally(new LoggingInterceptor());

💡 Hint

Check the exact method name for applying global interceptors in NestJS.

The correct method to apply global interceptors is useGlobalInterceptors.

❓ Troubleshoot

advanced

Why does the logging interceptor not log after handler execution?

A developer notices that their NestJS logging interceptor logs the message before the handler but never logs the message after the handler execution. What is the most likely cause?

A The controller method returns a Promise instead of an Observable

B The tap operator is missing in the interceptor's pipe

C The interceptor forgot to return next.handle() observable

D The interceptor is not decorated with @Injectable()

💡 Hint

Check the return statement in the intercept method.

The interceptor must return the Observable from next.handle().pipe(...); otherwise, the framework does not subscribe to it, and operators like tap never execute.

🔀 Workflow

expert

Order of execution in multiple NestJS interceptors

Given two global interceptors, LoggingInterceptor and TimingInterceptor, applied in this order: app.useGlobalInterceptors(new LoggingInterceptor(), new TimingInterceptor()); Which order will their 'before' and 'after' logs appear when a controller method is called?

A LoggingInterceptor before, TimingInterceptor before, controller runs, TimingInterceptor after, LoggingInterceptor after

B TimingInterceptor before, LoggingInterceptor before, controller runs, LoggingInterceptor after, TimingInterceptor after

C LoggingInterceptor before, TimingInterceptor before, controller runs, LoggingInterceptor after, TimingInterceptor after

D TimingInterceptor before, LoggingInterceptor before, controller runs, TimingInterceptor after, LoggingInterceptor after

💡 Hint

Think of interceptors like nested layers wrapping the controller method.

Interceptors execute in the order they are applied before the handler, and in reverse order after the handler.