logger20js-ts

Logger20js-ts is a little basic framework Logger for nodeJs or typescript project. It was written in typescript language.

installation

Import from npm repository package

$ npm i logger20js-ts

Example of basic implementation :

• Typescript implementation :

import {Logger} from "logger20js-ts";

class MyClass{
    
    private static LOG : Logger = Logger.factory(MyClass.name);

    public func(){
        MyClass.LOG.log("one example with args %s - %s ", "foo",123); 
    }

}

• Javascript Implementation :

const {Logger} = require("logger20js-ts");


class MyClass{
    
    static LOG = Logger.factory(MyClass.name);

    func(){
        MyClass.LOG.log("one example with args %s - %s ", "foo",123); 
    }

}

output :

1598042191366   MyClass : LOG : one example with args foo - 123

import {Logger}  from "logger20js-ts";
Logger.setPattern("[%HH:%mm:%ss] %T/%name - %error");

class MyClass{
    
    public static LOG = Logger.factory(MyClass.name);

    public func(){
        MyClass.LOG.log("one example with args %s - %s ", "foo",123);
        MyClass.LOG.warn("second example with args %s - %s ", "foo",123);
    }    

}

output :

[22:33:40] L/MyClass - one example with args foo - 123
[22:33:40] W/MyClass - second example with args foo - 123

Usage

static constructor

• factory( name : String ) : Logger

Configuration

• setPattern( parser : String ) : void
• setOutputLog( path : string ) : void
• setSaveLog( saveInFile : boolean ) : void
• setLogStdout( stout : boolean ) : void
• level( level : Array ) : void
• popLevel( logType : strLogLevel ) : void
• pushLevel( logType : *strLogLevel ) : void
• setLogFilePattern( pattern : String ) : void
• setFileMaxSize( bytes : Number ) : void
• setColorize( status : boolean ) : void
• setCleanUpBeforeSave( status : boolean ) : void ( default true )
• setPropertiesConfigHandle( path : string, json boolean = true ) : void

To see the default configuration values go to section set your owns properties from class

Log pattern

parser	output value
type	Level type [LOG,ERROR,WARN,INFO,DEBUG,CUSTOM]
T	Level type first character [L,E,W,I,D,C]
name	Logger name
time	TimeStamp 32 bits
hours	format type → HH:mm:ss
HH	hours number type
mm	minutes number type
ss	seconds number type
file	file
line	line
column	column number
pid	process identification
ppid	parent process identification
message	log message

The default pattern look like to %time\t%name\t: %type :\t%message from DEFAULT_LOG_PATTERN_MONO property value.

It's possible to customize the output pattern as you want, like this example [%HH:%mm:%ss] %T/%name - %error. Possibility to define several same analyzers %hours - %message - %hours.

Listed below some patterns example accessible from static Logger :

static readonly property	value	usage
DEFAULT_LOG_PATTERN_MONO	%time\t%name\t: %type :\t%error	Logger
WEBDRIVER_LOG_PATTERN_COLORED	"[%hours{cyan}] %T{w?yellow}/%name - %error"	Logger
EXPRESS_MIDDLEWARE_PATTERN	"[%hours{yellow}] %name %protocol{red} - %method %url +%elapsedTime{yellow}"	Express logger middleware
STATS_MEMORY_PATTERN	[%hours{cyan}] %T{cyan}/%name{cyan} memory : heap( %heapUsed{yellow}, %heapTotal{yellow} ) : rss( %rss{yellow} ) : external( %external{yellow} )	Logger stats
CPU_USAGE_PATTERN	[%hours{cyan}] user CPUTime( %userCPUTime{yellow} ) system CPUTime( %systemCPUTime{yellow} ) maxRss( %maxRSS{yellow} )	Logger stats
VERSION_USAGE_PATTERN	[%hours{cyan}] version of : node( %node{yellow} ) - v8( %v8{yellow} )	Logger stats

It possible to colorize the output parser like this : [%hours{blue}] - %type{yellow} - %error, and below there is the list of accepted colors :

• black
• red
• green
• yellow
• blue
• magenta
• cyan
• white
• grey
• gray

For set background color add b letter in front of name color like this example : → bwhite

⚠️ Just one exception only for %T and %type parser it possible to customize the output color by type of log level [L,E,W,I,D,C] :

• %T{w?yellow;e?red} or %type{w?yellow;e?red}

You can define a default color for others log level with :colorName annotation

• %T{w?yellow;e?red:green}

Another example : %T{e?red;w?yellow;d?blue;l?blue:black}. The types 'error' will be displayed in red color, 'warning' in yellow and 'debug' and 'log' in blue color and others log level will be displayed in black color into the console.

Since the version 1.1.7 . If you define color in your pattern and you have enabled record in a log file by default the message will be clean up for have readable string. But you can disabled this option just define cleanUpBeforeSave property at false with Logger.setCleanUpBeforeSave. you could not modify this property from your own configuration object.

Since the version 1.2.0 you can customize the color before call the log method :

import {Logger} from "./Logger";

let myLogger = Logger.factory("test");

myLogger.log( "messageInRed".colorize().red, "messageInBlue".colorize().blue );

let tmp : String = "my foo bar";

console.log( tmp.colorize().yellow );

Control console output

Logger.setLogStdout( true );

Log level

• ALL default
• INFO
• LOG
• DEBUG
• WARN
• ERROR
• CUSTOM

You can customize your Stdout logging level from the static Logger access with Logger.level( ... ) or from your own properties class, but make sur you have define logLevel property.

Logger.level(["INFO","WARN"]);

Only INFO and WARN log will be displayed to the console or recorded.

for remove or add just one log level type using : Logger.popLevel("ALL") or Logger.pushLevel("ALL")

Active log recorder

By default this property is at : true

Logger.setSaveLog( true );

Define a log file directory

Logger.setOutputLog(process.cwd()+"/logs");

Log filename

parser	output value
id	uuid hash
date	LocalDate format : YYYY-dd-mm
HH	hours number type
mm	minutes number type
ss	seconds number type
rotate	overflow timestamp 32 bits

• fileNamePattern default : %date-%id

Logger.setLogFilePattern("environment-%date-%id");

Log rotate

• default : disabled

If you want enabled log rotate, define in your pattern filename use %rotate parser. %rotate value is an overflow timestamp 32 bits. By default log rotate is disabled.

Some rotate example :

• 5d → 5 days
• 1h → 1 hour
• 5m → 5 min
• 5d:10m → 5 days 10 minutes
• 5d:8h:1m → 5 days 8 hours & one minute

Logger.setLogFilePattern("%id%rotate");
Logger.setLogRotate("1d"); // new log file every day

create redirect stdout message parsed

• setPipeStdout( pipe : Object ) : void

The object passed in parameters must contain the write method.

    Logger.setPipeStdout({
        write( msg ){
            console.log(msg);
        }   
    });

set your owns properties

You can override properties configuration for your logger.

From properties file >= 1.2.4

Template example :

# pattern
loggerParser        = [%hours{cyan}] %T{w?yellow;e?red}/%name - %error
logStdout           = true
logEnabledColorize  = true
logLevel            = ["ALL"]

# Recorder Opts
saveLog             = true
logRotate           = 1d:1h
loggerOutputDir     = target/log
logFileMaxSize      = 32000
logFileNamePattern  = %id-%rotate

Logger.setPropertiesFile("./config.properties", false);

From json file >= 1.2.4

Template example :

{	
	"loggerParser":"[%hours{cyan}] %T{w?yellow;e?red}/%name - %error",
	"logStdout":"true",
	"logEnabledColorize":"true",
    "logLevel": ["ALL"],
	
	"saveLog":"true",
	"logRotate":"1d:1h",
	"loggerOutputDir":"target/log",
	"logFileMaxSize":"32000",
	"logFileNamePattern":"%id-%rotate"
}

Logger.setPropertiesFile("./config.json");

From class

• setPropertiesConfigHandle( handle : any ) : void
• reloadConfiguration( ) :void

Properties keys accepted :

These properties are setting just after have set your handle, its impossible to reload these properties after that.

• loggerOutputDir : string default
• logFileNamePattern : String default %date-%id
• logFileMaxSize : number default null

These properties are can be reloaded with method reloadConfiguration( )

• loggerParser : String default %time\t%name\t: %type :\t%error
• saveLog : boolean default false
• logStdout : boolean default true
• logLevel : String[] default ["ALL"]
• logEnabledColorize : boolean default true

These properties by default are given by the Logger define getProperty method in your properties class like below :

• prototypeOf : getProperty( key : String = "", defaultValue : String ) : any

example :

If you implement your owns properties config in Typescript, the better way is to implement your class with IPropertiesFileA interface.

import {Logger} from "logger20js-ts"; 
import {ascii, MapType} from "lib-utils-ts/src/Interface"; 
import {IPropertiesFileA} from "logger20js-ts/src/Loggable";

class PropertiesConfig implements IPropertiesFileA{
    
    private conf : MapType<string,ascii> = null;

    constructor(){
        // load conf.json    
    }

    setProperty( key: string, value: any ): void{
        // if property key is a log property 
        // you can reload the Logger configuration
        Logger.reloadConfiguration();    
    }

    getProperty( key : string , defaultValue?: any ) : any{
        if( /*...*/ ){
            // ....
        }
        return defaultValue;
    }   

}
   
let properties = new PropertiesConfig();

Logger.setPropertiesConfigHandle(properties);

example output

1581273071079	EdgeDriver	: DEBUG :	webDriver has ben launched pid = 24460
1581273071098	EdgeDriver	: LOG :	webDriver session id = d0a82e65f565878005ead66fc288a9f0
1581273074148	EdgeDriver	: LOG :	webDriver go to = https://google.com
1581273075997	EdgeDriver	: LOG :	webDriver go to = https://google.com/search?q=mdr

Express Middleware Logger >= 1.2.0

parser	output value
protocol	http or https
host	Req hostanme
method	Http query method
url	Url Endpoint
remoteAddr	Client ip
originalUrl	express req.originalUrl
elapsedTime	time gap between two query

const app = express();

app.use(Logger.expressRouteLoggerMiddleware());

• expressRouteLoggerMiddleware( [ void , pattern : string = null ] ) : Callback

For define the pattern for express middleware it's the same way that you define the pattern for the Logger just you can add these properties for him.

Loader >= 1.2.0

let loader : Loader = Logger.getLoader(30).start("Ending message");

setInterval(()=>{  
    loader.add(1);
},1000);

• end() : void

Stats >= 1.2.3

parser	output value
pid	process identification
ppid	parent process identification
heapUsed	heap memory used
heapTotal	total heap memory
rss	memory rss value
external	external memory

• pattern default : STATS_MEMORY_PATTERN
• memory( patter : string ) : void

import {Logger} from 'logger20js-ts';

Logger.stats().memory();

• userCPUTime

• systemCPUTime

• maxRSS

• sharedMemorySize

• unsharedDataSize

• unsharedStackSize

• minorPageFault

• majorPageFault

• swappedOut

• fsRead

• fsWrite

• ipcSent

• ipcReceived

• signalsCount

• voluntaryContextSwitches

• involuntaryContextSwitches

• pattern default : CPU_USAGE_PATTERN

• cpu( patter : string ) : void

import {Logger} from 'logger20js-ts';

Logger.stats().cpu();

For patterns see process.version(), to NodeJs documentation : See here

• pattern default : VERSION_USAGE_PATTERN
• version( patter : string ) : void

import {Logger} from 'logger20js-ts';

Logger.stats().version();

Features & stable version

• 1.1.2

  • initial commit

• 1.1.7

  • Fix - removing of the Stream.js file, this extension creates conflicts with many other node js libraries like, Protractor, Selenium, resulting in an exception of the native Stream object.
  • Integration of background color in cli
  • Fix/Add - cleaning message before to save in a log file

• 1.2.0

  • Add Express middleware route logger
  • Implementation - log rotate
  • Stabilization of the colors functionality
  • Implementation of a basic loader feature / [=====>.... ] 00%

• 1.2.2

  • Fix Monochrome pattern.

• 1.2.3

  • Add new parser for global logger : pid, ppid, heapUsed, heapTotal, rss, external
  • Add Stats Log : memory, cpu, version

• 1.2.4

  • Enhancement properties file *.porperties or *.json

• 2.0.0-stable :

  • Build by Jenkins in a Docker Alpine:3.12, use lib-utils-ts:2.0.0-stable

From git

$ git clone https://github.com/devGnode/logger20js.git