winston

---

1. Basic Usage

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

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

logger.info('Hello world!');

2. Custom Format

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

const myFormat = format.printf(({ level, message }) => {
  return `${level}: ${message}`;
});

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

logger.info('Hello world!'); // Output: "info: Hello world!"

3. Multiple Transports

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

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

logger.info('Hello world!'); // Output: Writes to both console and log file

4. Exception Handling

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

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

try {
  throw new Error('This is an exception');
} catch (err) {
  logger.error(err); // Output: Writes exception to "exceptions.log" file
}

5. Rotating Files

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

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new transports.File({ filename: 'mylog.log', maxFiles: 5, maxSize: '20mb' })
  ]
});

logger.info('Hello world!'); // Output: Rotates log files when they reach the specified size or number

6. Cloud Logging

const { createLogger, format, transports } = require('winston');
const { LoggingWinston } = require('@google-cloud/logging-winston');

const loggingWinston = new LoggingWinston();

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

logger.info('Hello world!'); // Output: Writes to Google Cloud Logging

7. Filtering Logs

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

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

logger.error('This is an error'); // Output: Writes only errors to the console and log file

8. Local Storage

const { createLogger, format, transports } = require('winston');
const { LocalStorage } = require('winston-mongodb');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new transports.LocalStorage({ db: 'myDb', collection: 'myLogs' })
  ]
});

logger.info('Hello world!'); // Output: Stores logs in a MongoDB database

9. Remote Logging

const { createLogger, format, transports } = require('winston');
const { Loggly } = require('winston-loggly-bulk');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new Loggly({
      token: 'YOUR_LOGGLY_TOKEN',
      subdomain: 'YOUR_LOGGLY_SUBDOMAIN',
      tags: ['your', 'tags'],
      json: true
    })
  ]
});

logger.info('Hello world!'); // Output: Sends logs to Loggly

10. Custom Transports

const { createLogger, format, transports } = require('winston');
const customTransport = new transports.Http({
  host: 'localhost',
  port: 8080,
  path: '/api/logs'
});

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

logger.info('Hello world!'); // Output: Custom transport for sending logs to an HTTP endpoint

11. Throttling

const { createLogger, format, transports } = require('winston');
const { ThrottleTransport } = require('winston-transport');

const transport = new ThrottleTransport({
  host: 'localhost',
  port: 8080,
  path: '/api/logs',
  throttle: {
    delay: 1000,
    count: 5
  }
});

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

logger.info('Hello world!'); // Output: Throttles log messages to an HTTP endpoint

12. Aggregating Logs

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

const errorLogger = createLogger({
  level: 'error',
  format: format.json(),
  transports: [
    new transports.File({ filename: 'errors.log' })
  ]
});

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

logger.info('Hello world!');
errorLogger.error('This is an error'); // Output: Aggregates errors from both loggers into a single file

13. Contextual Logging

const { createLogger, format, transports } = require('winston');
const { LoggerWithContext } = require('winston-ctx');

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

logger.info('Hello world!', { user: 'John Doe' }); // Output: Adds contextual information to log messages

14. Correlated Logging

const { createLogger, format, transports } = require('winston');
const { CorrelationId } = require('winston-correlation-id');

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

logger.info('Hello world!'); // Output: Adds a correlation ID to all log messages

15. Profiling

const { createLogger, format, transports } = require('winston');
const { Profile } = require('winston-profile');

const profile = new Profile();

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

logger.profile('My Profile'); // Output: Profiles the execution time of a block of code

16. HTTP Request Logging

const { createLogger, format, transports } = require('winston');
const { HttpLogger } = require('winston-http-logger');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console()
  ],
  requestWhitelist: ['url', 'method', 'headers', 'statusCode']
});

const httpLogger = new HttpLogger({ logger });

app.use(httpLogger.requestLogger()); // Output: Logs incoming HTTP requests

17. Error Handling Middleware

const { createLogger, format, transports } = require('winston');
const { ErrorHandler } = require('winston-express-middleware');

const logger = createLogger({
  level: 'error',
  format: format.json(),
  transports: [
    new transports.File({ filename: 'errors.log' })
  ]
});

const errorHandler = new ErrorHandler({ logger });

app.use(errorHandler); // Output: Logs unhandled errors from Express applications

18. Rolling File

const { createLogger, format, transports } = require('winston');
const { RollingFile } = require('winston-daily-rotate-file');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new RollingFile({ filename: 'mylog-%DATE%.log', datePattern: 'YYYY-MM-DD' })
  ]
});

logger.info('Hello world!'); // Output: Rolls log files daily

19. MySQL

const { createLogger, format, transports } = require('winston');
const { MySQL } = require('winston-mysql');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new MySQL({
      host: 'localhost',
      user: 'root',
      password: 'password',
      database: 'myDb',
      table: 'myLogs'
    })
  ]
});

logger.info('Hello world!'); // Output: Stores logs in a MySQL database

20. InfluxDB

const { createLogger, format, transports } = require('winston');
const { InfluxDB } = require('winston-influxdb3');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new InfluxDB({
      host: 'localhost',
      port: 8086,
      database: 'myDb',
      measurement: 'myLogs'
    })
  ]
});

logger.info('Hello world!'); // Output: Stores logs in an InfluxDB database

21. MongoDB Atlas

const { createLogger, format, transports } = require('winston');
const { MongoDB } = require('winston-mongodb');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new MongoDB({
      connectionString: 'mongodb+srv://user:[e-mail]/myDb',
      collection: 'myLogs'
    })
  ]
});

logger.info('Hello world!'); // Output: Stores logs in a MongoDB Atlas database

22. Kubernetes Event Recorder

const { createLogger, format, transports } = require('winston');
const { KubeEventRecorder } = require('winston-kube-event-recorder');

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

logger.info('Hello world!'); // Output: Records events in Kubernetes events API

23. Vector

const { createLogger, format, transports } = require('winston');
const { Vector } = require('winston-vector');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new Vector({
      hostname: 'localhost',
      port: 8900,
      sampleRate: 1
    })
  ]
});

logger.info('Hello world!'); // Output: Sends logs to a Vector database

24. OpenCensus

const { createLogger, format, transports } = require('winston');
const { OpenCensus } = require('winston-opentracing');

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

logger.info('Hello world!'); // Output: Integrates with OpenCensus tracing

25. Jaeger

const { createLogger, format, transports } = require('winston');
const { Jaeger } = require('winston-jaeger');

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

logger.info('Hello world!'); // Output: Integrates with Jaeger tracing