Logging with Winston or Pino in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

What is the output of this Winston logger configuration?

Given this NestJS Winston logger setup, what will be logged when calling logger.info('Server started')?

NestJS

import { WinstonModule } from 'nest-winston';
import * as winston from 'winston';

const logger = WinstonModule.createLogger({
  transports: [
    new winston.transports.Console({
      level: 'info',
      format: winston.format.combine(
        winston.format.timestamp(),
        winston.format.printf(({ level, message, timestamp }) => `${timestamp} ${level}: ${message}`)
      )
    })
  ]
});

logger.info('Server started');

A info: Server started

B 2024-06-01T12:00:00.000Z info: Server started

C Server started

D Error: logger.info is not a function

💡 Hint

Look at the format used in the Console transport.

The logger uses a timestamp and printf format, so the output includes the ISO timestamp, the log level, and the message.

❓ Configuration

intermediate

Which Pino configuration enables pretty printing in NestJS?

Choose the correct Pino logger configuration snippet to enable pretty printing (human-readable logs) in a NestJS application.

A

import pino from 'pino';
const logger = pino({ format: 'pretty' });

B

import pino from 'pino';
const logger = pino({ prettyPrint: true });

C

import pino from 'pino';
const logger = pino({ transport: { target: 'pino-pretty' } });

D

import pino from 'pino';
const logger = pino({ pretty: true });

💡 Hint

Check the latest Pino documentation for pretty printing options.

Since Pino v7, pretty printing is enabled via the transport option with target: 'pino-pretty'.

❓ Troubleshoot

advanced

Why does this Winston logger not output any logs?

Consider this Winston logger setup in NestJS. Why does calling logger.info('Failure') produce no output?

NestJS

import { WinstonModule } from 'nest-winston';
import * as winston from 'winston';

const logger = WinstonModule.createLogger({
  transports: [
    new winston.transports.Console({ level: 'warn' })
  ]
});

logger.info('Failure');

A Because the transport level is set to 'warn', and 'info' is lower priority so it does not log.

B Because the transport level is set to 'warn', and 'info' is a higher priority so it should log.

C Because the transport level is set to 'warn', but the logger instance is not properly created.

D Because the transport level is set to 'warn', and 'info' is higher priority so it logs.

💡 Hint

Remember the log level priorities: error > warn > info.

Log levels in Winston have priorities (lower number = higher priority): 'error'(0) > 'warn'(1) > 'info'(2). With transport level 'warn', only 'warn' and 'error' log, not 'info'.

🔀 Workflow

advanced

What is the correct order to integrate Pino logger in a NestJS app?

Arrange these steps in the correct order to add Pino logging to a NestJS application.

A 2,1,3,4

B 3,1,2,4

C 1,3,2,4

D 1,2,3,4

💡 Hint

Think about installation before usage.

You first install packages, then import the module, configure it, and finally use the logger service.

✅ Best Practice

expert

Which practice improves performance when using Pino in production?

Choose the best practice to improve logging performance in a production NestJS app using Pino.

A Use asynchronous logging with a separate process or transport for log writing

B Disable logging completely in production to avoid overhead

C Use synchronous logging to ensure all logs are written immediately

D Log all debug and trace level messages in production for full details

💡 Hint

Think about how to reduce blocking operations in production.

Asynchronous logging offloads log writing to a separate process, reducing app blocking and improving performance.

Practice

1.

What is the main purpose of using Winston or Pino in a NestJS application?

easy

A. To handle HTTP requests and responses

B. To log application events and errors for monitoring and debugging

C. To manage database connections efficiently

D. To compile TypeScript code into JavaScript

Solution

1. Step 1: Understand logging role

   Logging tools like Winston or Pino record app events and errors to help developers monitor and debug the app.

2. Step 2: Identify unrelated options

   Database management, HTTP handling, and code compilation are unrelated to logging.

3. Final Answer:

   To log application events and errors for monitoring and debugging -> Option B

4. Quick Check:

   Logging = Monitoring and debugging [OK]

Hint: Logging tools track app events and errors [OK]

Common Mistakes:

• Confusing logging with database or HTTP handling
• Thinking logging compiles code
• Assuming logging manages app logic

2.

Which of the following is the correct way to import and use Logger from @nestjs/common for basic logging?

?

easy

A. import { Logger } from '@nestjs/common'; const logger = new Logger('App'); logger.log('App started');

B. import Logger from 'nestjs'; const logger = Logger(); logger.log('App started');

C. const Logger = require('@nestjs/common'); const logger = new Logger(); logger.info('App started');

D. import { Logger } from 'winston'; const logger = new Logger(); logger.log('App started');

Solution

1. Step 1: Check correct import syntax

   Correct import is from '@nestjs/common' using named import: import { Logger } from '@nestjs/common';

2. Step 2: Verify usage

   Logger is instantiated with a context string, then log method is called. import { Logger } from '@nestjs/common'; const logger = new Logger('App'); logger.log('App started'); matches this.

3. Final Answer:

   import { Logger } from '@nestjs/common'; const logger = new Logger('App'); logger.log('App started'); -> Option A

4. Quick Check:

   Correct import and usage = import { Logger } from '@nestjs/common'; const logger = new Logger('App'); logger.log('App started'); [OK]

Hint: Use named import from '@nestjs/common' for Logger [OK]

Common Mistakes:

• Using default import instead of named import
• Calling wrong method like info instead of log
• Importing Logger from wrong package

3.

Given this NestJS code using Pino logger, what will be the output in the console?

import { Logger } from 'nestjs-pino';
const logger = new Logger();
logger.info('Server started');
logger.error('Failed to connect');

medium

A. {"level":30,"msg":"Server started"} followed by {"level":50,"msg":"Failed to connect"}

B. Plain text logs: 'Server started' and 'Failed to connect' without JSON

C. SyntaxError due to missing import from '@nestjs/common'

D. No output because logger is not instantiated correctly

Solution

1. Step 1: Understand Pino output format

   Pino logs output JSON strings with level numbers (30=info, 50=error) and message keys.

2. Step 2: Analyze code behavior

   Logger instance calls info and error methods, producing JSON logs with messages.

3. Final Answer:

   {"level":30,"msg":"Server started"} followed by {"level":50,"msg":"Failed to connect"} -> Option A

4. Quick Check:

   Pino logs JSON with level and msg [OK]

Hint: Pino logs JSON with level numbers and message keys [OK]

Common Mistakes:

• Expecting plain text logs instead of JSON
• Confusing Pino with NestJS Logger
• Assuming no output due to import confusion

4.

Identify the error in this NestJS Winston logger setup:

import { WinstonModule } from 'nest-winston';
import * as winston from 'winston';

const logger = WinstonModule.forRoot({
  transports: [
    new winston.transports.Console({ level: 'info' })
  ]
});

logger.error('Error occurred');

medium

A. Incorrect transport name; should be winston.Console instead of winston.transports.Console

B. Missing import of Logger from '@nestjs/common'

C. The logger instance does not have an error method directly; it returns a module, not a logger

D. Level 'info' is invalid for Console transport

Solution

1. Step 1: Understand WinstonModule.forRoot return

   This method returns a NestJS module, not a direct logger instance with methods like error.

2. Step 2: Identify correct usage

   To log, you must inject the logger service or use winston.createLogger directly, not call error on the module.

3. Final Answer:

   The logger instance does not have an error method directly; it returns a module, not a logger -> Option C

4. Quick Check:

   WinstonModule.forRoot returns module, not logger instance [OK]

Hint: WinstonModule.forRoot returns module, not logger instance [OK]

Common Mistakes:

• Calling error method on module instead of logger instance
• Confusing transport names
• Assuming level 'info' is invalid

5.

You want to configure NestJS to use Pino for logging with JSON output and also log HTTP requests. Which setup is correct?

?

hard

A. import * as pino from 'pino';

const logger = pino({ prettyPrint: true });
logger.info('HTTP request logged');

B. import { WinstonModule } from 'nest-winston';

WinstonModule.forRoot({
transports: [new winston.transports.File({ filename: 'log.json' })]
});

C. import { Logger } from '@nestjs/common';

const logger = new Logger();
logger.log('HTTP request logged');

D. import { LoggerModule } from 'nestjs-pino';

LoggerModule.forRoot({
pinoHttp: {
level: 'info'
}
});

Solution

1. Step 1: Identify Pino module usage in NestJS

   Use LoggerModule from 'nestjs-pino' with forRoot and pinoHttp config for HTTP logging and JSON output.

2. Step 2: Check options for JSON and pretty printing

   import { LoggerModule } from 'nestjs-pino'; LoggerModule.forRoot({ pinoHttp: { level: 'info' } }); configures nestjs-pino LoggerModule with pinoHttp for HTTP request logging at info level, producing JSON output by default, matching requirements.

3. Final Answer:

   import { LoggerModule } from 'nestjs-pino'; LoggerModule.forRoot({ pinoHttp: { level: 'info' } }); -> Option D

4. Quick Check:

   nestjs-pino with pinoHttp config = import { LoggerModule } from 'nestjs-pino'; LoggerModule.forRoot({ pinoHttp: { level: 'info' } }); [OK]

Hint: Use nestjs-pino LoggerModule with pinoHttp config for HTTP logs [OK]

Common Mistakes:

• Using WinstonModule instead of nestjs-pino for Pino logging
• Using Logger from '@nestjs/common' for HTTP logs
• Using pino directly without NestJS integration