ts-log

What is ts-log?

The ts-log npm package provides a simple logging interface for TypeScript applications. It allows developers to create custom loggers and use them throughout their codebase. The package defines a minimal set of logging methods that can be implemented to create a logger compatible with the ts-log interface.

What are ts-log's main functionalities?

Creating a custom logger

This feature allows you to create a custom logger and use various methods like debug, info, warn, and error to log messages at different levels.

{"createLogger": "const { Logger } = require('ts-log');\nconst myLogger = new Logger();\nmyLogger.debug('This is a debug message.');\nmyLogger.info('This is an info message.');\nmyLogger.warn('This is a warning message.');\nmyLogger.error('This is an error message.');"}

Extending the logger

This feature demonstrates how to extend the Logger class to add custom logging methods such as a trace method.

{"extendLogger": "const { Logger } = require('ts-log');\nclass MyLogger extends Logger {\n  trace(message) {\n    // Custom trace method implementation\n    console.log('TRACE: ' + message);\n  }\n}\nconst myLogger = new MyLogger();\nmyLogger.trace('This is a trace message.');"}

Other packages similar to ts-log

winston

Winston is a multi-transport async logging library for Node.js. It is designed to be a simple and universal logging library with support for multiple transports. Compared to ts-log, winston offers more built-in features, including transports for logging to various outputs, custom log levels, and formatting options.

pino

Pino is a very low overhead Node.js logger, which is inspired by Bunyan. It provides a different set of trade-offs compared to ts-log, focusing on performance and including features like child loggers, custom serializers, and support for the browser.

log4js

Log4js is a logging framework for Node.js, which includes features like multiple appenders, layouts, and categories. It is more complex and configurable than ts-log, offering a more comprehensive logging solution for larger applications.

README

TypeScript Abstract Logger

Abstract logger TypeScript interface along with a dummy logger that does nothing.

Useful for libraries wanting to provide a pluggable logger that does nothing by default.

• Matches the build-in console that can be directly plugged in.
• Also matches bunyan.
• Provides usage and custom logger example.
• Written in TypeScript, no need for extra typings.

Installation

This package is distributed via npm

npm install ts-log

Example

import { dummyLogger, ILogger } from "ts-log";
import * as fs from "fs";

// example custom logger that logs to a file
class FileLogger implements ILogger {
  private readonly fd: number;

  public constructor(filename: string) {
    this.fd = fs.openSync(filename, "a");
  }

  public trace(message?: any, ...optionalParams: any[]): void {
    this.append("TRACE", `${message} ${JSON.stringify(optionalParams)}`);
  }

  public debug(message?: any, ...optionalParams: any[]): void {
    this.append("DEBUG", `${message} ${JSON.stringify(optionalParams)}`);
  }

  public info(message?: any, ...optionalParams: any[]): void {
    this.append("INFO ", `${message} ${JSON.stringify(optionalParams)}`);
  }

  public warn(message?: any, ...optionalParams: any[]): void {
    this.append("WARN ", `${message} ${JSON.stringify(optionalParams)}`);
  }

  public error(message?: any, ...optionalParams: any[]): void {
    this.append("ERROR", `${message} ${JSON.stringify(optionalParams)}`);
  }

  private append(type: string, message: string) {
    fs.writeSync(this.fd, `${new Date().toISOString()} ${type} ${message}\n`);
  }
}

// example class that uses the logger
class Calculator {
  // accept the logger in the constructor, defaulting to dummy logger
  public constructor(private readonly log: ILogger = dummyLogger) {}

  public sum(a: number, b: number) {
    const result = a + b;

    // call the logger
    this.log.info(`summing ${a} + ${b} = ${result}`, a, b, result);

    return result;
  }
}

// don't define the logger, defaults to dummy logger that does not do anything
const calculator1 = new Calculator();

// use the build-in console as the logger
const calculator2 = new Calculator(console);

// use the custom file logger
const calculator3 = new Calculator(new FileLogger("log.txt"));

// run the calculator
calculator1.sum(2, 3);
calculator2.sum(-4, 1);
calculator3.sum(6, 3);

Commands

• yarn start to start the example application.
• yarn build to build the production version.
• yarn test to run tests.
• yarn coverage to gather code coverage.
• yarn lint to lint the codebase.
• yarn prettier to run prettier.
• yarn audit to run all pre-commit checks (prettier, build, lint, test)