tessl/npm-winston

A comprehensive, multi-transport logging library for Node.js applications providing flexible and extensible logging capabilities.

—

Pending

Overview

Eval results

Files

Default Logger

Name: tessl/npm-winston
Author: tessl

Direct logging methods available on the winston module for quick access without creating logger instances.

Capabilities

Direct Logging Methods

Winston provides a default logger instance accessible directly through the winston module, allowing for immediate logging without explicit logger creation.

/**
 * Core logging method using default logger
 * @param level - Log level string
 * @param message - Log message
 * @param meta - Additional metadata
 * @returns Default logger instance
 */
function log(level: string, message: string, ...meta: any[]): Logger;

/**
 * Log at error level using default logger
 * @param message - Error message
 * @param meta - Additional metadata
 * @returns Default logger instance
 */
function error(message: string, ...meta: any[]): Logger;

/**
 * Log at warn level using default logger
 * @param message - Warning message
 * @param meta - Additional metadata
 * @returns Default logger instance
 */
function warn(message: string, ...meta: any[]): Logger;

/**
 * Log at info level using default logger
 * @param message - Info message
 * @param meta - Additional metadata
 * @returns Default logger instance
 */
function info(message: string, ...meta: any[]): Logger;

/**
 * Log at http level using default logger
 * @param message - HTTP-related message
 * @param meta - Additional metadata
 * @returns Default logger instance
 */
function http(message: string, ...meta: any[]): Logger;

/**
 * Log at verbose level using default logger
 * @param message - Verbose message
 * @param meta - Additional metadata
 * @returns Default logger instance
 */
function verbose(message: string, ...meta: any[]): Logger;

/**
 * Log at debug level using default logger
 * @param message - Debug message
 * @param meta - Additional metadata
 * @returns Default logger instance
 */
function debug(message: string, ...meta: any[]): Logger;

/**
 * Log at silly level using default logger
 * @param message - Silly level message
 * @param meta - Additional metadata
 * @returns Default logger instance
 */
function silly(message: string, ...meta: any[]): Logger;

// CLI-specific level methods (available when using CLI levels)
/**
 * Log at help level using default logger (CLI levels)
 * @param message - Help message
 * @param meta - Additional metadata
 * @returns Default logger instance
 */
function help(message: string, ...meta: any[]): Logger;

/**
 * Log at data level using default logger (CLI levels)
 * @param message - Data message
 * @param meta - Additional metadata
 * @returns Default logger instance
 */
function data(message: string, ...meta: any[]): Logger;

/**
 * Log at prompt level using default logger (CLI levels)
 * @param message - Prompt message
 * @param meta - Additional metadata
 * @returns Default logger instance
 */
function prompt(message: string, ...meta: any[]): Logger;

/**
 * Log at input level using default logger (CLI levels)
 * @param message - Input message
 * @param meta - Additional metadata
 * @returns Default logger instance
 */
function input(message: string, ...meta: any[]): Logger;

// Syslog-specific level methods (available when using syslog levels)
/**
 * Log at emergency level using default logger (syslog levels)
 * @param message - Emergency message
 * @param meta - Additional metadata
 * @returns Default logger instance
 */
function emerg(message: string, ...meta: any[]): Logger;

/**
 * Log at alert level using default logger (syslog levels)
 * @param message - Alert message
 * @param meta - Additional metadata
 * @returns Default logger instance
 */
function alert(message: string, ...meta: any[]): Logger;

/**
 * Log at critical level using default logger (syslog levels)
 * @param message - Critical message
 * @param meta - Additional metadata
 * @returns Default logger instance
 */
function crit(message: string, ...meta: any[]): Logger;

/**
 * Log at warning level using default logger (syslog levels)
 * @param message - Warning message
 * @param meta - Additional metadata
 * @returns Default logger instance
 */
function warning(message: string, ...meta: any[]): Logger;

/**
 * Log at notice level using default logger (syslog levels)
 * @param message - Notice message
 * @param meta - Additional metadata
 * @returns Default logger instance
 */
function notice(message: string, ...meta: any[]): Logger;

Usage Examples:

const winston = require('winston');

// Direct logging using default logger
winston.error('Application error occurred');
winston.warn('This is a warning message');
winston.info('Application started successfully');
winston.debug('Debug information');

// With metadata
winston.error('Database connection failed', {
  error: 'ECONNREFUSED',
  host: 'localhost',
  port: 5432
});

winston.info('User login', {
  userId: 123,
  username: 'john_doe',
  timestamp: new Date().toISOString()
});

Default Logger Management

Methods for managing the default logger's transports and configuration.

/**
 * Add a transport to the default logger
 * @param transport - Transport instance to add
 * @returns Default logger instance
 */
function add(transport: Transport): Logger;

/**
 * Remove a transport from the default logger
 * @param transport - Transport instance to remove
 * @returns Default logger instance
 */
function remove(transport: Transport): Logger;

/**
 * Remove all transports from the default logger
 * @returns Default logger instance
 */
function clear(): Logger;

/**
 * Reconfigure the default logger
 * @param options - New configuration options
 */
function configure(options: LoggerOptions): void;

/**
 * Create a child logger from the default logger
 * @param defaultMeta - Additional metadata for child logger
 * @returns Child logger instance
 */
function child(options: object): Logger;

Usage Examples:

const winston = require('winston');

// Add console transport to default logger
winston.add(new winston.transports.Console({
  format: winston.format.simple()
}));

// Add file transport
winston.add(new winston.transports.File({
  filename: 'app.log'
}));

// Configure default logger
winston.configure({
  level: 'debug',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  transports: [
    new winston.transports.Console(),
    new winston.transports.File({ filename: 'combined.log' })
  ]
});

// Create child logger
const childLogger = winston.child({ service: 'auth' });
childLogger.info('Authentication successful');

Query and Streaming

Methods for querying logged messages and creating streams from the default logger.

/**
 * Query logged messages from the default logger
 * @param options - Query options
 * @param callback - Callback function for results
 * @returns Query results or promise
 */
function query(
  options?: QueryOptions,
  callback?: (err: Error, results: any) => void
): any;

/**
 * Create a readable stream of log messages from default logger
 * @param options - Stream options
 * @returns Readable stream of log messages
 */
function stream(options?: any): ReadableStream;

interface QueryOptions {
  /** Number of rows to return */
  rows?: number;
  /** Limit number of results */
  limit?: number;
  /** Starting index */
  start?: number;
  /** Start date filter */
  from?: Date;
  /** End date filter */
  until?: Date;
  /** Sort order ('asc' or 'desc') */
  order?: 'asc' | 'desc';
  /** Fields to include */
  fields?: any;
}

Usage Examples:

const winston = require('winston');

// Query recent error logs
winston.query({
  from: new Date(Date.now() - 24 * 60 * 60 * 1000), // Last 24 hours
  until: new Date(),
  limit: 10,
  start: 0,
  order: 'desc'
}, (err, results) => {
  if (err) {
    console.error('Query failed:', err);
  } else {
    console.log('Recent logs:', results);
  }
});

// Create log stream
const logStream = winston.stream({ start: -1 });
logStream.on('log', (log) => {
  console.log('New log entry:', log);
});

Default Logger Properties

Global properties available on the winston module for accessing default logger state.

/**
 * Current log level of default logger
 */
let level: string;

/**
 * Exception handler instance for default logger
 */
let exceptions: ExceptionHandler;

/**
 * Rejection handler instance for default logger
 */
let rejections: RejectionHandler;

/**
 * Exit behavior on error for default logger
 */
let exitOnError: Function | boolean;

/**
 * Access to default logger's transports and handlers
 */
let default: {
  exceptionHandlers: Transport[];
  rejectionHandlers: Transport[];
  transports: Transport[];
};

Usage Examples:

const winston = require('winston');

// Check current log level
console.log('Current level:', winston.level);

// Set log level
winston.level = 'debug';

// Configure exit behavior
winston.exitOnError = false;

// Access default logger transports
console.log('Active transports:', winston.default.transports.length);

// Handle exceptions with default logger
winston.exceptions.handle(
  new winston.transports.File({ filename: 'exceptions.log' })
);

// Handle rejections with default logger
winston.rejections.handle(
  new winston.transports.File({ filename: 'rejections.log' })
);

Important Notes

The default logger starts with no transports configured, which may lead to high memory usage if logs are generated without output destinations
Always add at least one transport to the default logger before logging:

const winston = require('winston');

// Add a transport before logging
winston.add(new winston.transports.Console());

// Now logging will work properly
winston.info('This will be output to console');

For production applications, consider creating dedicated logger instances rather than using the default logger for better control and isolation:

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

logger.info('Application started');

Install with Tessl CLI