fliplog
Advanced tools
Readme
all-in-one logging tool
------- new ------
var obj = {property: {}}
obj.circularReference = obj
obj[Symbol('foo')] = 'foo'
obj.map = new Map()
obj.map.set('prop', 'value')
obj.array = [1, NaN, Infinity]
log.prettyformat(obj).echo()
const cleaner = log
.cleaner(true)
.keys([/array|circularReference|map|property/])
.data(obj)
.clean()
.echo()
yarn add fliplog
npm i fliplog --save
const log = require('fliplog')
fluent logging with verbose insight, colors, tables, emoji, filtering, spinners, progress bars, timestamps, capturing, stack traces, clearing, boxen, stringifying, code highlighting, notifications, beeping, sparkles, slow-mode, formatting, bar charts, & presets
log
.data({anyKindOfData: true}) // .json, .stringify, .tosource, .verbose
.text('text to use, this is what gets colored')
.color('bold') // any cli-color, chalk, available as shorthands
.echo() // outputs the log, .return to return the formatted values
🆕 lightweight configurable dependencies
// optional second arg for options passed into pretty json
log.json({eh: 'prettified'})
// args are the same as javascript-stringify
log.stringify({data: 'can stringify deep things'})
.silence() (optional true/false arg).shush().unshush()capture output of all console logs everywhere
log.startCapturing()
console.log('this will be captured')
log.stopCapturing()
// captured data is available here
const saved = log.savedLog
return only echos from fliplogs, useful for getting formatted data.
// formatted data
const {text, data} = log
.data({catchMeIfYouCan: true})
.text('gingerbread man')
.returnVals()
// this returns everything inside, it will call .filter first
const everything = log
.color('blue.underline')
.data({canYouHandleIt: true})
.text('M')
.return()
all chalk colors available with .color
log
.text('\n========================================\n')
.color('bold')
.echo()
log
.bold('same as calling .color(bold).text(all this text)')
.echo()
all cli-color are available by calling .xterm
log
.time(true)
.xterm(202, 236).text(' orange!!! ')
.echo()
because it's javascript, the log is an object... but it can be called as a function for convenience
log({data: true}, 'text', 'color')
stack
names using emoji-commits are available with .emoji (currently 🚧 not all have been ported yet)
log
.emoji('phone')
.text('et')
.data('phone home')
.echo()
comma separated strings, or arrays
a function can also be passed in, the argument will be an object containing the entries see flipchain/ChainedMap.entries
verbose enables everythingsilent silences everything! means disabledlog
.filter('!nope, yes')
log
.tag('unrelated,nope')
.cyan('you will never see me :-(')
.echo()
log
.tag('yes')
.underline('yay!')
.echo()
this can also be done using cli flags
yourprogram --flipdebug="!nope,yes"
yourprogram --flipdebug=verbose
quickly log data and exit if you want to stop execution at a certain point for debugging
log.quick({give: 'me'}, 'everything', 'and quit')
// or
log.data({now: 'die'}).exit(1)
extending cli-table2
log
.table(['header1', 'header2'], ['row1', 'row2'])
.echo()
log
.table(['header1', 'header2'])
.row({'key1': 'val1'})
.row({'key2': 'val2'})
.echo()
using deep-diff, you can compare before and after data differences as tables. Data will be cloned so it can be mutated and then compared.
const royalty = {
posh: true,
}
const lowlyPeasant = {
pauper: true,
}
log.diff(royalty)
const abomination = deepmerge(royalty, lowlyPeasant)
log.diff(abomination)
log.diffs().echo()
.Spinner is available on fliplog as the instantiated spinner// easy to color spinners
log.bold().startSpinner('loading...')
setTimeout(() => log.stopSpinner(), 2000)
// instance available on log.Spinner
log.startSpinner('spinner message', {
// optional spinner args
onTick: () => {},
// where to output the logs, default process.stdout
stream: () => {}
// default 60
delay: 80,
})
console.log('log this, then spinner shows up again - it is sticky.')
log.stopSpinner()
// instance available on log.spinners
log
.addSpinner('key1', 'spinner 1 msg')
.addSpinner('key2', 'spinner 2 msg')
.addSpinner('key3', 'spinner 3 msg')
// arg is optionally a string for frames
// or an object for multi-spinner options
.startSpinners()
// string arg removes by name
setTimeout(() => log.removeSpinner('key1'), 1000)
// empty args removes all
setTimeout(() => log.removeSpinner(), 20000)
.ora is available as a method with the same options.fliplog to the ora instance to allow chaining back to fliplogora instance// call .ora
log.ora('loading...').start()
// or
log.spinner('loading...', {ora: true})
log.progress()
total, cb(bar, interval), interval time
log.progress(20, (bar, interval) => {
bar.tick()
if (bar.complete) clearInterval(interval)
}, 1000)
let contentLength = 128 * 1024
const bar = log.progress(' downloading [:bar] :percent :etas', {
complete: '=',
incomplete: ' ',
width: 20,
total: contentLength,
}).progressBar
function next() {
if (!contentLength) return
bar.tick(Math.random() * 10 * 1024)
if (!bar.complete) setTimeout(next, Math.random() * 1000)
}
next()
or a string for title
log
.notify('woot!', 'super long and not as important description')
.echo()
log.notify('woot!', true)
will output the stack trace formatted and inspected deeply with the error preset
const ForeverAndEver = new Promise(resolve => Promise.resolve())
.then(() => Promise.reject('💍'))
.catch(log.catch)
in your entry point, calling log.track() will output the location all of the next logs output from.
log.track()
// later on...
log.bold('I cannot be found... oh wait, I was tracked.').echo()
you can also track every console.log anywhere
log.trackConsole()
// becomes `eh 'at your-file#the-line-number'`
console.log('me!')
calling .trace will output a shortened stack trace to the current location.
log.data({bigData: 'oh'}).trace().echo()
defines properties on the console global and automatically calls echo where applicable, for easier access:
log.registerConsole()
console.time('so easy')
console.bold('hullabaloo')
console.error(new Error('eh-rar'))
console.timeEnd('so easy')
console.quick('toodaloo')
// also available
// verbose, info, error, track, trace, note, warning, spinner, time, timeEnd, timeLap timeLapEcho, box, beep, timer, table, diff, diffs, stringify, stack, json, filter, tags, quick, exit, reset, sleep, slow, red, yellow, cyan, underline, magenta, bold
catches uncaught promises and errors, displays them verbosely.
log.registerCatch()
throw new Error('eh')
Promise.reject('eh')
this will clear the terminal (at least, move it down so it is clear)
log.clear()
| goal | winner |
|---|---|
| code source | tosource |
| deep inside objects | verbose |
| colors | verbose |
using inspector-gadget, objects are inspected and colorized as deep as configured
log
.bold('verbose:')
.data({
numbers: 1000,
booleans: true,
functions: () => {},
strings: 'wacky wavy fun',
})
.verbose(/* optional number for how deep to go */)
.echo()
see the code source using tosource for nodejs you can look at the source of a variable
log
.bold('tosource:')
.data({
numbers: 1000,
booleans: true,
functions: () => {},
strings: 'wacky wavy fun',
})
.tosource()
.echo()
function highlitedWithColors() { return 'notice me' }
log
.data(highlitedWithColors)
.tosource()
.highlight()
.echo()
log.addPreset('warning', (chain) => {
return chain.text('⚠ warning:').color('bgYellow.black').verbose(10)
})
log
.preset('warning')
.data('nananenano!')
.echo()
log
.preset('error')
.data(new Error('prettyfull!'))
.echo()
log
.time(true)
.color('cyan')
.text('🕳 so deep, so colorful, so meta 🎨 ')
.data(log)
.verbose()
.echo()
to use logging from a pure js object, .from is available
log.from({
data: 'data',
text: 'eh',
color: 'bold',
echo: true,
})
^ is the same as
log
.text('eh')
.data('data')
.color('bold')
.echo()
these will all be silent by default, so you can easily disable them by filtering your logs or setting silent output which can be exceedingly helpful.
log.sparkly().echo()
log.bar().echo()
const points = []
for (var i = 0; i < Math.PI * 2; i += Math.PI / 1000) {
points.push([i, Math.cos(i)]);
}
log.bar(points).echo()
log
.bar([[0, 1], [1, 5], [2, 5], [3, 1], [4, 6]])
.barStyles({
width: 80,
height: 10,
color: 'yellow',
maxY: 100
})
.echo()
all options from beeper
log.beep(1).echo()
// with bold colors
log.bold().box('fliplog').echo()
// echos right away
log.box('fliplog', true)
// use boxen box styles
log
.boxStyles({borderColor: 'blue'})
.box('fliplog')
.echo()
log.data({}).bold('text')
// returns the currently formatted text and data
const {text, data} = log.returnVals()
// returns every single setting as an object, resets
const everything = log.return()
will output number of spaces after your log
log.text('followed by 2 empty lines').space(2).echo()
slow mode allows debugging each log step-by-step, and will force a sleep usable across all environments using sleepfor
log.slow(1000)
log.emoji('snail').yellow('slow...').echo()
const start = Date.now()
log.emoji('snail').yellow('...slow').echo()
const end = Date.now() - start
start, stop, lap, and timer instance using fliptime
log
.startTimer('named')
.sleep(1000)
.stopTimer('named')
.echoTimer('named')
or for more customized usage
log.startTimer('named')
sleepfor(1000)
log.stopTimer('named').echoTimer('named')
const fliptime = log.fliptime()
allows final formatting of the data before echoing
function cb(data) {
if (!data || typeof data !== 'object') return data
Object
.keys(data)
.forEach(key => {
if (typeof data[key] === 'string')
data[key] = data[key].replace(/\s{2}/gmi, ' ')
else if (Array.isArray(data[key]))
data[key] = data[key].map(a => cb(a.name))
})
return data
}
const fixture = {
str: 'I have too many spaces',
arr: [{name: 'eh'}, {noname: 'just undefined'}],
}
log
.formatter(cb)
.data(fixture)
.echo()
to keep the module lightweight, almost all functionality is added through plugins.
the dependencies that are installed can be configured by a package json config, or by using magic npm tags which contain the configs.
the available options are:
min,cli,debugging,formatting,fun,latest (default)"fliplog": ["debugging"],
npm i --save fliphub@cli
npm i --save fliphub@formatting
all non-core dependencies are required when functions are called. this way, only the used-functionality is loaded.
additionally, almost all of the functions are not formatted until .echo(), so they will not have dependencies loaded when echoing is false which means code does not have to be changed for production.
if echo(false) or filtering disables the output, they are never called.
FAQs
fluent logging with verbose insight, colors, tables, emoji, filtering, spinners, progress bars, timestamps, capturing, stack traces, clearing, & presets
The npm package fliplog receives a total of 555 weekly downloads. As such, fliplog popularity was classified as not popular.
We found that fliplog demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
In an unprecedented surge, May 2024 saw the publication of over 5,000 CVEs, marking a historic milestone in cybersecurity with an average of 164 CVEs per day, nearly double the 2023 daily average.
Security News
The White House is addressing fragmented cybersecurity regulations as CISOs report spending up to 50% of their time on compliance, aiming to harmonize requirements and improve cybersecurity outcomes.
Security News
Research
The Socket Research Team has identified a malicious Python package that is typosquatting the popular crytic-compile utility, frequently used in popular toolkits and development environments for smart contracts and crypto applications.