Feature/update api

README.md

@@ -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):
@@ -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
@@ -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
 

benchmarks/benchmark.js

@@ -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();

benchmarks/benchmark_string_concat.js

@@ -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();

benchmarks/benchmark_test.js

@@ -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();