Overview

No dependency logging utility wrapper with customisable consumer

Installation

yarn install @kksiuda/logger

or

npm install @kksiuda/logger

API

Logger

Creates a Logger instance.

• input
  • consumer?: LogConsumer (default: consoleLogConsumerFactory return value);
  • logLevel: LogLevel (default: 'info');
  • logNamespace: string; (default: '')
  • transformer: Transformer (default: identity function)
• output
  • Logger instance

Example

import { Logger } from '@kksiuda/logger';

const log = new Logger();
log.debug('debug data');
log.info('some information');
log.warn('warning');
log.error(new Error('error message'));
// by default these logs will be output to console using consoleLogConsumerFactory default parameters

consoleLogConsumerFactory

• input
• params?:
  • useColors?: boolean; default: true; adds colors when logging to console:
    • debug: gray
    • info: green
    • warn: yellow
    • error: red
  • useTimestamp?: boolean; default: true; adds timestamp at the beginning of the log; see useUTC
  • useLogLevel?: boolean; default: true; adds logLevel in square brackets padded to length 5
  • useNamespace?: boolean; default: true; adds namespace in square brackets if it's not empty
  • useUTC?: boolean; default: true; formats timestamp using UTC when true, local time when false
  • console?: ConsoleLike; default: console; used for testing and debugging
• output
  • LogConsumer

Example

import { consoleLogConsumerFactory } from '@kksiuda/logger';
const logConsumer = consoleLogConsumerFactory({ useUTC: false, useNamespace: false });
logConsumer({ namespace: 'NS', timestamp: Date.now(), logLevel: 'info', payload: '' });

Types

Logger

class Logger<T = string | Error, I extends any[] = [T]> {
  constructor(options?: {
    consumer?: LogConsumer<T>;
    logLevel?: LogLevel;
    logNamespace?: string;
    transformer?: Transformer<I, T>;
  })
  debug: (...payload: T) => void;
  info: (...payload: T) => void;
  warn: (...payload: T) => void;
  error: (...payload: T) => void;
  namespace: <I extends any[]>(logNamespace: string, transformer?: Transformer<I, T>): Logger<T, I>

• logLevel defaults to 'info'; anything with logLevel lower than the one provided will not call the consumer; when set to 'silent' it will do nothing
• debug, info, warn, error call consumer with LogMessage
• type T is inferred from the consumer; it can be anything, for example { message: string, additionalData?: string }
• namespace creates a new Logger instance; the instance's namespace will be:
  • if parent namespace is empty -> child namespace
  • else "[parent namespace].[child namespace]"
  • it also allows to use a different logging format where a provided transformer outputs log payload in format accepted by parent

LogLevel

type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';

LogConsumer

type LogConsumer<T = string | Error> = (msg: LogMessage<T>) => any;

LogMessage

interface LogMessage<T = string | Error> {
  namespace: string;
  timestamp: number;
  logLevel: 'debug' | 'info' | 'warn' | 'error';
  payload: T;
}

Transformer

type Transformer<I extends any[], O> = (...args: I) => O;