NestJS Enterprise Backend APIs · Lekcja

Logowanie za pomocą Winston/Pino

Skonfigurują Państwo logowanie strukturalne za pomocą popularnych bibliotek, takich jak Winston lub Pino, aby skutecznie śledzić zdarzenia i błędy aplikacji.

Lekcja 2 z 312 kroki

Logowanie za pomocą Winston/Pino to bezpłatna lekcja NestJS Enterprise Backend APIs na CoddyKit. To lekcja 2 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej NestJS Enterprise Backend APIs, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs NestJS Enterprise Backend APIs zawiera 3 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

Why Logging Matters

When building applications, knowing what's happening inside is crucial. This is where logging comes in!

Logging is the process of recording events and messages from your application as it runs. These logs help you:

Debug issues
Monitor performance
Understand user behavior

The Power of Structured Logs

Traditional logs can be hard to read and analyze. Structured logging writes log messages in a consistent, machine-readable format, usually JSON.

Why is this better?

Easy Analysis: Tools can parse JSON logs automatically.
Searchable: Quickly find specific events or errors.
Consistent: All logs follow the same pattern, making debugging faster.

Introducing Winston Logger

Winston is a highly popular and flexible logging library for Node.js. It's known for its modularity, allowing you to customize how logs are formatted and where they are sent.

Key features include:

Transports: Send logs to multiple destinations.
Formats: Control how your log messages look.
Levels: Define severity (e.g., info, warn, error).

Your First Winston Logger

Let's set up a basic Winston logger that outputs to the console. First, you'd install it: npm install winston

Here's a simple example:

const winston = require('winston');

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.Console()
  ],
});

logger.info('Hello from Winston!');
logger.warn('This is a warning.');
logger.error('Something went wrong!');

Sending Logs to Files

Winston's transports let you direct logs to different places. Besides the console, a common transport is a file.

Using a file transport helps persist logs for later review, especially in production environments.

const winston = require('winston');

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.Console(),
    new winston.transports.File({ filename: 'app.log' })
  ],
});

logger.info('This log goes to console and app.log!');
logger.error('Error details here.', { component: 'AuthService' });

Discovering Pino Logger

Pino is another powerful logging library, specifically designed for speed and low overhead. If performance is a critical concern for your application, Pino is an excellent choice.

It focuses on:

Extreme Performance: Very fast logging, minimal impact on your app.
JSON Output: By default, it logs in JSON for easy parsing.
Extensible: Though minimal, it's highly configurable.

Your First Pino Logger

Setting up Pino is straightforward. Install it first: npm install pino

Pino logs to stdout (console) by default, making it simple to pipe logs to other tools.

const pino = require('pino');

const logger = pino({
  level: 'info',
  base: null // Remove default base properties like pid, hostname
});

logger.info('Hello from Pino!');
logger.warn('A warning from Pino.');
logger.error({ error: 'DB_CONN_FAILED', message: 'Could not connect' }, 'Database error');

Custom NestJS LoggerService

NestJS uses its own LoggerService internally. To use Winston or Pino, you'll replace the default NestJS logger.

You can create a custom logger class that implements LoggerService and uses your chosen library. This makes your custom logger available throughout your NestJS application via Dependency Injection.

import { LoggerService } from '@nestjs/common';
import * as winston from 'winston';

export class MyWinstonLogger implements LoggerService {
  private logger: winston.Logger;

  constructor() {
    this.logger = winston.createLogger({
      level: 'info',
      format: winston.format.json(),
      transports: [
        new winston.transports.Console(),
      ],
    });
  }

  log(message: string, context?: string) {
    this.logger.info(message, { context });
  }

  error(message: string, trace?: string, context?: string) {
    this.logger.error(message, { trace, context });
  }

  warn(message: string, context?: string) {
    this.logger.warn(message, { context });
  }

  debug(message: string, context?: string) {
    this.logger.debug(message, { context });
  }

  verbose(message: string, context?: string) {
    this.logger.verbose(message, { context });
  }
}

Adding Context to Logs

When logs become extensive, identifying the source of a message is key. Contextual logging adds extra information (like a class name, request ID, or user ID) to each log entry.

This makes it much easier to filter and understand logs, especially in complex microservice architectures or when debugging specific user flows.

const winston = require('winston');

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.Console()
  ],
});

function processOrder(orderId) {
  logger.info('Processing order', { orderId, module: 'OrderService' });
  // ... more logic
  logger.warn('Order stock low', { orderId, sku: 'PROD-XYZ' });
}

processOrder('ORD-12345');

Choosing Your Logger

Both Winston and Pino are excellent choices, but they have different strengths:

Winston: Highly flexible with many transports and formatting options. Great for complex logging requirements.
Pino: Extremely fast and low overhead, ideal for performance-critical applications or high-throughput microservices.

Your choice often depends on your project's specific needs for flexibility versus raw performance.

Logging Library Check

You've learned about the benefits of structured logging and how to set up Winston and Pino.

Consider the following features:

High performance and low overhead.
Default JSON output.
Primarily logs to stdout.

Which logging library is best described by these characteristics?

Odpowiedz w interaktywnej lekcji

Logging Essentials Recap

Great job! In this lesson, you explored the importance of structured logging for application observability and debugging.

We introduced Winston for its flexibility and extensive transport options.
We covered Pino for its unparalleled performance and default JSON output.
You learned how to integrate these powerful libraries into your NestJS applications using a custom LoggerService.

Well-implemented logging is key to maintaining healthy and understandable applications!

Bezpłatny start

Ucz się TypeScript dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 20
Lekcje: 76

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Logowanie za pomocą Winston/Pino” jest bezpłatna?

Tak — pełny tekst „Logowanie za pomocą Winston/Pino” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu NestJS Enterprise Backend APIs, przejdź na CoddyKit PRO. Kurs NestJS Enterprise Backend APIs zawiera 3 lekcji w sumie.

Co nauczysz się w „Logowanie za pomocą Winston/Pino”?

Skonfigurują Państwo logowanie strukturalne za pomocą popularnych bibliotek, takich jak Winston lub Pino, aby skutecznie śledzić zdarzenia i błędy aplikacji. Ćwiczysz NestJS Enterprise Backend APIs z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć NestJS Enterprise Backend APIs?

Nie wymagamy żadnego doświadczenia. NestJS Enterprise Backend APIs w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 3.

Ile czasu zajmuje lekcja „Logowanie za pomocą Winston/Pino”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji NestJS Enterprise Backend APIs?

Tak. Każda lekcja NestJS Enterprise Backend APIs zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do NestJS Enterprise Backend APIs