How to use winston with typeorm?

Using Winston and TypeORM Integration Strategy

1. Understanding Winston and TypeORM

Winston is a powerful and highly customizable logging library for Node.js. It logs at various severity levels and supports multiple transport methods, such as outputting logs to the console, writing to files, or sending over the network.

TypeORM is a TypeScript-based ORM (Object-Relational Mapping) tool that enables developers to handle database relationships and operations through object-oriented programming.

2. Configuring Winston

First, set up Winston to capture and record key application information. Here is a basic configuration example:

javascript
const { createLogger, format, transports } = require('winston');

const logger = createLogger({
  level: 'info',
  format: format.combine(
    format.timestamp({
      format: 'YYYY-MM-DD HH:mm:ss'
    }),
    format.errors({ stack: true }),
    format.splat(),
    format.json()
  ),
  transports: [
    new transports.File({ filename: 'error.log', level: 'error' }),
    new transports.File({ filename: 'combined.log' })
  ]
});

if (process.env.NODE_ENV !== 'production') {
  logger.add(new transports.Console({
    format: format.simple()
  }));
}

3. Integrating Winston and TypeORM

To integrate Winston with TypeORM, leverage TypeORM's logging functionality. TypeORM allows you to define a custom logger to replace the default one. Create an adapter to connect TypeORM's logging methods with Winston's logging methods.

javascript
class WinstonLogger {
  private logger;

  constructor() {
    this.logger = logger; // Using the Winston logger configured above
  }

  logQuery(query: string, parameters?: any[]) {
    this.logger.info(`Query: ${query} Params: ${parameters}`);
  }

  logQueryError(error: string, query: string, parameters?: any[]) {
    this.logger.error(`Error: ${error} Query: ${query} Params: ${parameters}`);
  }

  logQuerySlow(time: number, query: string, parameters?: any[]) {
    this.logger.warn(`Time: ${time} Query: ${query} Params: ${parameters}`);
  }

  logSchemaBuild(message: string) {
    this.logger.info(message);
  }

  logMigration(message: string) {
    this.logger.info(message);
  }

  log(level: 'log' | 'info' | 'warn' | 'query' | 'error', message: any) {
    const levels = {
      log: 'info',
      info: 'info',
      warn: 'warn',
      query: 'info',
      error: 'error'
    };

    this.logger[levels[level]](message);
  }
}

4. Using the Custom Logger in TypeORM Configuration

Finally, specify the custom logger in your TypeORM configuration:

typescript
import { createConnection } from 'typeorm';

createConnection({
  // Other database configuration
  logger: new WinstonLogger()
}).then(connection => {
  // Connection successful
}).catch(error => {
  logger.error('Connection error: ', error);
});

5. Summary

By following these steps, we successfully integrated Winston with TypeORM, establishing a unified logging strategy across the application. This integration enhances monitoring and analysis of database operations while maintaining code cleanliness and consistency. When issues arise, we can quickly identify the root cause, thereby improving application reliability and maintainability.