Skip to content
This repository was archived by the owner on Dec 21, 2022. It is now read-only.

Feature/update api #4

Merged
merged 10 commits into from
Sep 28, 2017
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
29 changes: 10 additions & 19 deletions README.md
Original file line number Diff line number Diff line change
Expand Up @@ -6,25 +6,23 @@ A [winston](https://github.com/winstonjs/winston)-wrapper to log in a
Loggerhythm exports a Logger-class, whose instances have different log-functions for different log-levels.
the avaliable loglevels are:

0. critical
1. error
2. warn
3. info
4. verbose
5. debug
6. silly

***critical* and *error* log to `stderr`, everything else logs to `stdout`!**
***error* logs to `stderr`, everything else logs to `stdout`!**

#### Example

```javascript
const Logger = require('loggerhythm').Logger;
// import {Logger} from 'loggerhythm'; // for TypeScript

const logger = new Logger('readme-namespace')
const logger = new Logger('readme-namespace');
// alias: logger = logger.createLogger('readme-namespace');

logger.info('foo');
logger.warn('bar');
```

The output would look like this (the different log-leves use different colors):
Expand All @@ -38,17 +36,10 @@ The output would look like this (the different log-leves use different colors):
### Static
The Logger-Class has static methods, that can be used to *globally* set loggerhythm-config and register global log-hooks:

```TypeScript
```javascript
const Logger = require('loggerhythm').Logger;
const Loglevel = require('loggerhythm').LogLevel;
// import {Logger, LogLevel} from 'loggerhythm'; // for TypeScript

// Set the loglevel to only log warnings, errors and critical-logs
Logger.setLogLevel(LogLevel.WARN);

// Set the max. log-depth
Logger.setMaxObjectLogDepth(3);

// get informed about all Logs everywhere
const subscription = Logger.subscribe((logLevel, namespace, message, ...logObjects) => {
// do stuff
Expand All @@ -64,25 +55,25 @@ subscription.dispose();
The Instances of the Logger-class have a log-method for every loglevel and a subscribe-method to get informed about
logs of that instance

```TypeScript
```javascript
const Logger = require('loggerhythm').Logger;
// import {Logger} from 'loggerhythm'; // for TypeScript

const logger = new Logger('readme-namespace');
const logger = Logger.createLogger('readme-namespace');

// get informed about all the logs of that instance
const subscription = Logger.subscribe((logLevel, namespace, message, ...logObjects) => {
// namespace will always be 'readme-namespace' here
// do stuff
});

logger.critical('critical log');
logger.error('error-log', new Error('hello'));
logger.warn('warning-log');
logger.info('have some info', {v1: 1, v2: 2, test: ['some', 'test', 'array']});
logger.verbose('some', 'more detailed', 'info');
logger.debug('denug-log');
logger.silly('some stupidly verbose log');

// this loggers namespace will be 'readme-namespace:child-logger-lamespace'
const logger2 = logger.createChildLogger('child-logger-lamespace');

// do stuff

Expand Down
46 changes: 46 additions & 0 deletions benchmarks/benchmark.js
Original file line number Diff line number Diff line change
@@ -0,0 +1,46 @@
const Benchmark = require('benchmark');
const suite = new Benchmark.Suite;

const logger = require('../dist/commonjs/loggerhythm').Logger;
const l1 = new logger('logger1');

const meta = {
hallo: 'welt',
lelelel: {
log: {
im: {
log: 'hallo 123 456 789',
},
},
},
};

meta.test = meta.lelelel;
meta.test123 = meta;
meta.lelelel.test1234 = meta.lelelel;

const error = new Error('someErrorMessage');

suite
.add('infomessage', () => {
l1.info('info l1');
})
.add('errorMessage', () => {
l1.error('error', error);
})
.add('objectLog', () => {
l1.info('someObject', meta);
})
.add('multiParams', () => {
l1.info('someObject', 'param1', 'param2', 'param3', 'param4', 'param5');
})
.on('cycle', function(event) {
console.log(String(event.target));
})
.on('complete', function() {
console.log('result', this.map((test) => {
return `${test.name}: ${parseInt(test.hz)}`;
}));
})

suite.run();
44 changes: 44 additions & 0 deletions benchmarks/benchmark_string_concat.js
Original file line number Diff line number Diff line change
@@ -0,0 +1,44 @@
const Benchmark = require('benchmark');
const suite = new Benchmark.Suite;
const util = require('util')

const loglevel = 'info'
const namespace = 'benchmark'
const message = 'Lorem ipsum dolor sit amet, consetetur sadipscing'
const newline = '\n';

const prepared = ` - ${loglevel}: [${namespace}] `;

suite
.add('template-string', () => {
const msg = `${new Date().toISOString()} - ${loglevel}: [${namespace}] ${message}\n`;

})
.add('util.format', () => {
const msg = util.format('%s - %s: [%s] %s\n', new Date().toISOString(), loglevel, namespace, message);
})
.add('template-string prepared', () => {
const msg = `${new Date().toISOString()}${prepared}${message}\n`;
})
.add('util.format prepared', () => {
const msg = util.format('%s%s%s\n', new Date().toISOString(), prepared, message);
})
.add('concat prepared', () => {
const msg = new Date().toISOString() + prepared + message + '\n';
})
.add('add newline string', () => {
const msg = new Date().toISOString() + '\n';
})
.add('add newline var', () => {
const msg = new Date().toISOString() + newline;
})
.on('cycle', function(event) {
console.log(String(event.target));
})
.on('complete', function() {
console.log('result', this.map((test) => {
return `${test.name}: ${parseInt(test.hz)}`;
}));
})

suite.run();
190 changes: 190 additions & 0 deletions benchmarks/benchmark_test.js
Original file line number Diff line number Diff line change
@@ -0,0 +1,190 @@
const Benchmark = require('benchmark');
const suite = new Benchmark.Suite;

var logloop = function(message, ...parameter) {
let logString = message
for (let i = 0; i < parameter.length; i++) {
logString = `${logString}${parameter[i].toString()}`;
}
}

var logmap = function(message, ...parameter) {
const logString = `${message}${parameter.map((param) => param.toString())}`
}

var logfixed = function(message, param1, param2, param3, param4, param5) {
let logString = message
if (param1 !== undefined) logString = `${logString}${param1.toString()}`;
if (param2 !== undefined) logString = `${logString}${param2.toString()}`;
if (param3 !== undefined) logString = `${logString}${param3.toString()}`;
if (param4 !== undefined) logString = `${logString}${param4.toString()}`;
if (param5 !== undefined) logString = `${logString}${param5.toString()}`;
}


var logfixedorder = function(message, param1, param2, param3, param4, param5) {
let logString = message
if (param1 !== undefined) {
logString = `${logString}${param1.toString()}`;
if (param2 !== undefined) {
logString = `${logString}${param2.toString()}`;
if (param3 !== undefined) {
logString = `${logString}${param3.toString()}`;
if (param4 !== undefined) {
logString = `${logString}${param4.toString()}`;
if (param5 !== undefined) {
logString = `${logString}${param5.toString()}`;
}
}
}
}
}
}

var logoptimal = function(message, ...parameter) {
let logString = message
if (parameter.length > 0) {
for (let i = 0; i < parameter.length; i++) {
logString = `${logString}${parameter[i].toString()}`;
}
}
}

var logfixedadd = function(message, param1, param2, param3, param4, param5) {
let logString = message
if (param1 !== undefined) logString += param1.toString();
if (param2 !== undefined) logString += param2.toString();
if (param3 !== undefined) logString += param3.toString();
if (param4 !== undefined) logString += param4.toString();
if (param5 !== undefined) logString += param5.toString();
}

const message = 'myFancyMessage'
const param1 = {'objectKey': ['some', 'value']};
const param2 = 'test';
const param3 = 120;
const param4 = ['a', 'b', 'c', {'d': 'e'}];
const param5 = 'some somewhat longer string, but it\'s not that bad yet';

suite.add('logloop0', () => {
logloop(message);
})
.add('logloop2', () => {
logloop(message, param1, param2);
})
.add('logloop4', () => {
logloop(message, param1, param2, param3, param4);
})
.add('logloop5', () => {
logloop(message, param1, param2, param3, param4, param5);
})
.add('logmap0', () => {
logmap(message);
})
.add('logmap2', () => {
logmap(message, param1, param2);
})
.add('logmap4', () => {
logloop(message, param1, param2, param3, param4);
})
.add('logmap5', () => {
logmap(message, param1, param2, param3, param4, param5);
})
.add('logfixed0', () => {
logfixed(message);
})
.add('logfixed2', () => {
logfixed(message, param1, param2);
})
.add('logfixed4', () => {
logfixed(message, param1, param2, param3, param4);
})
.add('logfixed5', () => {
logfixed(message, param1, param2, param3, param4, param5);
})
.add('logfixedadd0', () => {
logfixedadd(message);
})
.add('logfixedadd2', () => {
logfixedadd(message, param1, param2);
})
.add('logfixedadd4', () => {
logfixedadd(message, param1, param2, param3, param4);
})
.add('logfixedadd5', () => {
logfixedadd(message, param1, param2, param3, param4, param5);
})
.add('logfixedorder0', () => {
logfixedorder(message);
})
.add('logfixedorder2', () => {
logfixedorder(message, param1, param2);
})
.add('logfixedorder4', () => {
logfixedorder(message, param1, param2, param3, param4);
})
.add('logfixedorder5', () => {
logfixedorder(message, param1, param2, param3, param4, param5);
})
.add('direct0', () => {
let logString = message;
if (param1 !== undefined) {}
})
.add('direct2', () => {
let logString = message;
if (param1 !== undefined) {
logString = `${logString}${param1.toString()}`;
if (param2 !== undefined) {
logString = `${logString}${param2.toString()}`;
if (param3 !== undefined) {
}
}
}
})
.add('direct4', () => {
let logString = message;
if (param1 !== undefined) {
logString = `${logString}${param1.toString()}`;
if (param2 !== undefined) {
logString = `${logString}${param2.toString()}`;
if (param3 !== undefined) {
logString = `${logString}${param3.toString()}`;
if (param4 !== undefined) {
logString = `${logString}${param4.toString()}`;
if (param5 !== undefined) {
}
}
}
}
}
})
.add('direct5', () => {
let logString = message;
if (param1 !== undefined) {
logString = `${logString}${param1.toString()}`;
if (param2 !== undefined) {
logString = `${logString}${param2.toString()}`;
if (param3 !== undefined) {
logString = `${logString}${param3.toString()}`;
if (param4 !== undefined) {
logString = `${logString}${param4.toString()}`;
if (param5 !== undefined) {
logString = `${logString}${param5.toString()}`;
}
}
}
}
}
})
// add listeners
.on('cycle', function(event) {
console.log(String(event.target));
})
/*
.on('complete', function() {
console.log('result', this.map(test) => {
return `${test.name}: ${test.}`
});
})
*/
.run();
Loading