A namespaced stylish logger primarily for the browser
npm install driftwoodA namespaced stylish logger for the browser and node.
``js
var driftwood = require('driftwood')
var log = driftwood('a-module')
log.trace('It supports node and the browser!')
log.debug('You can', { also: 'send some arbitrary metadata!' })
var subLog = log('a-sub-module')
subLog.info('You can create loggers off loggers')
subLog.warn('So that your logs remain under the same top namespace')
subLog.error('Isn\'t this cool?')
`
Enabling log output globally:
`jspersist: true
driftwood.enable() // defaults to { '*': 'info' }
driftwood.enable({
'foo': 'info',
'bar:*': 'debug'
}, { persist: true }) // pass when in the browser to keep logging enabled across pages`
Enabling log output for specific loggers or subloggers:
`js
var log = driftwood('a-module')
var subLog = log('a-sub-module')
log.enable() // enables log and subLog
var log = driftwood('a-module')
var subLog = log('a-sub-module')
subLog.enable() // enables just subLog
log.disable() // disables log and sublog
`
Enables all loggers globally using the optional log level config. The config is a map of name patterns to log level, defaulting to { '*': 'info' }. See below for more pattern examples. You can also pass an options object to the enable function. Currently it only supports the persist option, which lets keep logging enabled across page views (defaults to false, only supports the browser).
Disables all loggers globally and clears the global log config.
Creates a new named log instance, optionally supplying additional loggers (e.g. sentry or devtools). additionalLoggers should be an array of functions accepting 4 arguments:
`js`
function (name, level, now, { message, error, metadata }) {
// do whatever
}
interceptors is an array of functions used to change those arguments before they pass into the loggers:
`js`
function (name, level, now, { message, error, metadata }) {
return [newName, newLevel, newDate, {
message: newMessage,
error: newError,
metadata: newMetadata
}]
}
For convenience, the return value can be one of:
* [name, level, now, { message, error, metadata }], to transform each of the four arguments,{ message, error, metadata }
* , to transform only the main components of the message,message
* , to transform only the main message, or
* a falsey value, to transform nothing.
The interceptors are run sequentially from left to right, _before_ any (additional) loggers.
Creates a sub logger that inherits the namespace of its parent.
`js`
var log = driftwood('foo') // namespace will be foo
var subLog = log('bar') // namespace will be foo:bar
When using the sub logger, any additionalLoggers and/or interceptors provided will run _alongside_ the ones provided to the original logger. When using the original logger, the new functions are not run. All interceptors run _before_ all additional loggers. Within those groups, the original functions run _before_ the new functions. For example:
`js`
function makeImportant(name, level, now, { message }) { return 'important ' + message }
function capitalize(name, level, now, { message }) { return message.toUpperCase() }
var log = driftwood('foo', [], [makeImportant])
var subLog = log('bar', [], [capitalize])
log.info('message') // logs: important message
subLog.info('proclamation') // logs: IMPORTANT PROCLAMATION
Enables a specific logger with a config object (see driftwood.enable). This will be applied to the logger and all of it's descendants.
Disables a specific logger and all of it's descendants.
Logs a message at a level, optionally with a metadata object or error instance. Available levels:
- trace
-
-
-
-
The last argument of the log call can be an object or an instance of Error, which Driftwood will attempt to present in a more readable fashion. All preceding arguments will be concatenated together into a string.
By default the logger will not output anything. You need to enable it first, as specified above. Below are some examples of log configs you can pass (you can use * as a wildcard:
- { '*': null } - will log everything at the default level (info){ 'foo': 'trace' }
- - will log anything from the logger with the name foo at the trace level{ 'foo': 'trace', 'bar': 'warn' }
- - will log foo at trace and bar at warn
- - will only log up to error from foo* and up to info from everything else
When running in the browser, you can pass a persist flag to persist the log configuration into localStorage:
`js`
driftwood.enable({ '*': 'info' }, { persist: true })
If you prefer to not have timestamps on your logs, you can turn them off in a nodejs environment by setting the DRIFTWOOD_NO_TIMESTAMP environment variable to a truthy value.
`sh`
$ DRIFTWOOD_NO_TIMESTAMP=1 node ./myApp.js
Create a main logger.js file in your module/app:
`js`
// logger.js
var driftwood = require('driftwood')
module.exports = driftwood('my-app')
In the main part of your app, use the main logger:
`js`
// index.js
var log = require('./logger')
log.debug('We are in the entry of the app!')
In each of your submodules, create a sub logger:
`js``
// subModuleA.js
var log = require('./logger')('sub-module-a')
log.debug('We are in a submodule of the app!')
This project was created by the Engineering team at Qubit. As we use open source libraries, we make our projects public where possible.
We’re currently looking to grow our team, so if you’re a JavaScript engineer and keen on ES2016 React+Redux applications and Node micro services, why not get in touch? Work with like minded engineers in an environment that has fantastic perks, including an annual ski trip, yoga, a competitive foosball league, and copious amounts of yogurt.
Find more details on our Engineering site. Don’t have an up to date CV? Just link us your Github profile! Better yet, send us a pull request that improves this project.