logtunnel 0.4.0 → 1.0.0

package/README.md

@@ -0,0 +1,61 @@
+# Logtunnel
+
+CLI tool that allows you to format, filter and search your log output
+
+## Requirements
+
+- [NodeJS >= 12](https://nodejs.org/en/download/)
+- [NPM](https://docs.npmjs.com/cli/v7/configuring-npm/install)
+
+## Installation
+
+``sudo npm i -g logtunnel``
+
+## Usage
+
+Find logs that contain "alice":
+``curl -s https://cdn.codetunnel.net/lt/text.log | lt alice``
+
+Find logs that contain "alice" and "purchase":
+``curl -s https://cdn.codetunnel.net/lt/text.log | lt -f alice -f purchase``
+
+Find logs that contain "alice" and ignore the ones that contain "info":
+``curl -s https://cdn.codetunnel.net/lt/text.log | lt -f alice -i info``
+
+Parse logs as JSON and output them with that template:
+``curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -o '[{{lvl}}] {{log}}'``
+
+Parse logs as JSON, apply template and find the ones containing "alice":
+``curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -o '[{{lvl}}] {{log}}' -f alice``
+
+Parse logs as JSON, apply template and show the ones with "delay > 200":
+``curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -o '[{{lvl}} in {{delay}}ms] {{log}}' -F 'delay > 200'``
+
+Parse logs as JSON, apply template and show the ones with "log" containing "Alice":
+``curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -o '[{{lvl}}] {{log}}' -F 'log.toLowerCase().includes("alice")'``
+
+Parse logs as logfmt, show the ones with "delay > 200" and show their original line (as if no parsing happened):
+``curl -s https://cdn.codetunnel.net/lt/logfmt.log | lt -p logfmt -o original -F 'delay > 200'``
+
+Parse logs as JSON and output them as a table:
+``curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -o table``
+
+Parse logs with regex, and output in logfmt:
+``curl -s https://cdn.codetunnel.net/lt/text.log | lt -p '\[(?<lvl>\S*) in\s*(?<delay>\d*)ms\] (?<log>.*)' -o logfmt``
+
+Parse logs with regex, and show the ones with "delay > 200":
+``curl -s https://cdn.codetunnel.net/lt/text.log | lt -p '(?<delay>\d+)ms' -o original -F 'delay > 200'``
+
+Parse table and show rows containing "cilium":
+``curl -s https://cdn.codetunnel.net/lt/table.log | lt -p table -o original -f cilium``
+
+Parse table, show rows containing "cilium" and the first headers row:
+``curl -s https://cdn.codetunnel.net/lt/table.log | lt -p table -o original -f cilium -H``
+
+Parse table, show rows with RESTARTS > 0:
+``curl -s https://cdn.codetunnel.net/lt/table.log | lt -p table -o original -F 'RESTARTS > 0' -H``
+
+Show rows that are not ready:
+``curl -s https://cdn.codetunnel.net/lt/table.log | lt -p '(?<up>\d)/(?<total>\d)' -o original -F 'up < total' -H``
+
+For more information ``lt --help``

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logtunnel",
-  "version": "0.4.0",
+  "version": "1.0.0",
   "description": "CLI tool that allows you to format, filter and search your log output",
   "main": "src/main.js",
   "bin": {
@@ -34,9 +34,9 @@
     "@hapi/bossy": "^5.1.0",
     "@hapi/hoek": "^9.2.0",
     "@hapi/podium": "^4.1.3",
+    "bigodon": "^2.3.0",
     "colors": "^1.4.0",
     "debug": "^4.3.2",
-    "jstache": "^0.1.0",
     "logfmt": "^1.3.2",
     "semver": "^7.3.5"
   }

package/src/definition.js

@@ -29,7 +29,7 @@ const definition = {
         type: 'string',
     },
     o: {
-        description: 'Formats the output using this template. Allowed: json, logfmt, original or a mustache template.',
+        description: 'Formats the output using this template. Allowed: json, logfmt, inspect, original, table or a bigodon template.',
         alias: 'output',
         type: 'string',
     },
@@ -65,6 +65,8 @@ const examples = [
     $ + 'curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -o \'[{{lvl}}] {{log}}\' -F \'log.toLowerCase().includes("alice")\'',
     'Parse logs as logfmt, show the ones with "delay > 200" and show their original line (as if no parsing happened)'.dim,
     $ + 'curl -s https://cdn.codetunnel.net/lt/logfmt.log | lt -p logfmt -o original -F \'delay > 200\'',
+    'Parse logs as JSON and output them as a table'.dim,
+    $ + 'curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -o table',
     'Parse logs with regex, and output in logfmt'.dim,
     $ + 'curl -s https://cdn.codetunnel.net/lt/text.log | lt -p \'\\[(?<lvl>\\S*) in\\s*(?<delay>\\d*)ms\\] (?<log>.*)\' -o logfmt',
     'Parse logs with regex, and show the ones with "delay > 200"'.dim,

package/src/log-source.js

@@ -7,7 +7,7 @@ module.exports.logSource = emitter => {
     emitter.on('data', data => {
         const lines = data.toString()
             .split(/[\r\n|\n]/);
-    
+
         lines[0] = incompleteLine + lines[0];
         incompleteLine = lines.pop(); // Either an incomplete line or an empty string due to the last \n
 

package/src/main.js

@@ -32,7 +32,9 @@ function run() {
         debug('building pipeline');
         const pipeline = new LogPipeline(args, process.stdout);
         debug('registering stdin');
-        logSource(process.stdin).on('log-line', l => pipeline.onLogLine(l));
+        logSource(process.stdin)
+            .on('log-line', l => pipeline.onLogLine(l))
+            .on('end', () => pipeline.onEnd());
     } catch(e) {
         console.error('Error:', e.message);
         process.exit(1);

package/src/pipeline.js

@@ -1,18 +1,22 @@
 'use strict';
-const debug = require('debug')('logtunnel:pipeline');
 
-const filter = require('./transformers/filter');
-const ignore = require('./transformers/ignore');
-const parse = require('./transformers/parse');
-const field = require('./transformers/field');
-const output = require('./transformers/output');
+const { FieldFilter } = require('./transformers/filters/field');
+const { FindFilter } = require('./transformers/filters/find');
+const { IgnoreFilter } = require('./transformers/filters/ignore');
+const { outputFactory } = require('./transformers/outputs/factory');
+const { parseFactory } = require('./transformers/parsers/factory');
+
+const debug = require('debug')('logtunnel:pipeline');
 
 class LogPipeline {
     constructor(args, stdout) {
         this.firstLine = null;
         this.args = args;
         this.stdout = stdout;
-        this.transformers = this._buildTransformers().filter(t => t !== null);
+        this.outputTransformer = outputFactory(this.args.output);
+        this.isOutputBuffered = Boolean(this.outputTransformer.flush);
+        this.transformers = this._buildTransformers()
+                .filter(t => t !== null);
     }
 
     onLogLine(line) {
@@ -29,11 +33,11 @@ class LogPipeline {
         }
     }
 
-    _logLine(line) {
+    async _logLine(line) {
         let output = line;
 
         for (let transformer of this.transformers) {
-            const result = transformer(output, line, this);
+            const result = await transformer.run(output, line, this);
 
             // Transformer accepted the line
             if(result === true) {
@@ -49,7 +53,11 @@ class LogPipeline {
 
             // Transformer modified the line
             output = result;
-            debug('line transformed: ' + JSON.stringify(output)); 
+            debug('line transformed: ' + JSON.stringify(output));
+        }
+
+        if (this.isOutputBuffered) {
+            return;
         }
 
         this.stdout.write(output + '\n');
@@ -61,23 +69,32 @@ class LogPipeline {
         }
 
         this.firstLine = line;
-        if(this.args.headers) {
+        if(this.args.headers && !this.isOutputBuffered) {
             this.stdout.write(this.firstLine + '\n');
         }
     }
 
+    onEnd() {
+        if (!this.isOutputBuffered) {
+            return;
+        }
+
+        const lines = this.outputTransformer.flush();
+        lines.forEach(line => this.stdout.write(line + '\n'));
+    }
+
     _buildTransformers() {
         return [
             // First of all, filter which lines to accept
-            this.args._ ? filter(this.args._) : null,
-            ...this.args.filter.map(filter),
-            ...this.args.ignore.map(ignore),
+            this.args._ ? new FindFilter(this.args._) : null,
+            ...this.args.filter.map(f => new FindFilter(f)),
+            ...this.args.ignore.map(i => new IgnoreFilter(i)),
             // Parse them...
-            parse(this.args.parser),
+            parseFactory(this.args.parser),
             // ...and apply field filters
-            ...this.args.field.map(field),
+            ...this.args.field.map(f => new FieldFilter(f)),
             // And finally format the output
-            output(this.args.output),
+            this.outputTransformer,
         ];
     }
 }

package/src/transformers/filters/field.js

@@ -0,0 +1,18 @@
+const { compileExpression } = require('bigodon');
+
+class FieldFilter {
+    constructor(expression) {
+        this.expression = compileExpression(expression);
+    }
+
+    async run(line) {
+        if(typeof line !== 'object') {
+            throw new Error("To use a field filter, you need to specify a parser like '-p json' ");
+        }
+
+        const result = await this.expression(line);
+        return Boolean(result);
+    }
+}
+
+module.exports = { FieldFilter };

package/src/transformers/filters/find.js

@@ -0,0 +1,11 @@
+class FindFilter {
+    constructor(regexStr) {
+        this.regex = new RegExp(regexStr, 'i');
+    }
+
+    run(line) {
+        return this.regex.test(line);
+    }
+}
+
+module.exports = { FindFilter };

package/src/transformers/filters/ignore.js

@@ -0,0 +1,11 @@
+class IgnoreFilter {
+    constructor(regexStr) {
+        this.regex = new RegExp(regexStr, 'i');
+    }
+
+    run(line) {
+        return !this.regex.test(line);
+    }
+}
+
+module.exports = { IgnoreFilter };

package/src/transformers/outputs/bigodon.js

@@ -0,0 +1,17 @@
+const { compile } = require('bigodon');
+
+class BigodonOutput {
+    constructor(template) {
+        this.template = compile(template);
+    }
+
+    async run(line) {
+        if (typeof line !== 'object') {
+            throw new Error("To use an output transformer, you need to specify a parser like '-p json' ");
+        }
+
+        return this.template(line);
+    }
+}
+
+module.exports = { BigodonOutput };

package/src/transformers/outputs/factory.js

@@ -0,0 +1,21 @@
+const { JsonOutput } = require('./json');
+const { LogfmtOutput } = require('./logfmt');
+const { BigodonOutput } = require('./bigodon');
+const { OriginalOutput } = require('./original');
+const { InspectOutput } = require('./inspect');
+const { TableOutput } = require('./table');
+
+
+function outputFactory(format) {
+    switch(format?.toLowerCase()) {
+        case  undefined: return new InspectOutput(false);
+        case     'json': return new JsonOutput();
+        case    'table': return new TableOutput();
+        case   'logfmt': return new LogfmtOutput();
+        case  'inspect': return new InspectOutput(true);
+        case 'original': return new OriginalOutput();
+        default:         return new BigodonOutput(format);
+    }
+}
+
+module.exports = { outputFactory };

package/src/transformers/outputs/inspect.js

@@ -0,0 +1,22 @@
+const util = require('util');
+
+class InspectOutput {
+    constructor(breakLines = false) {
+        this.options = {
+            colors: true,
+            depth: null,
+            breakLength: breakLines ? 80 : Infinity,
+            compact: !breakLines,
+        };
+    }
+
+    run(line) {
+        if (typeof line === 'string') {
+            return true;
+        }
+
+        return util.inspect({ ...line }, this.options);
+    }
+}
+
+module.exports = { InspectOutput };

package/src/transformers/outputs/json.js

@@ -0,0 +1,11 @@
+class JsonOutput {
+    run(line) {
+        if (typeof line !== 'object') {
+            throw new Error("To use an output transformer, you need to specify a parser like '-p json'");
+        }
+
+        return JSON.stringify(line);
+    }
+}
+
+module.exports = { JsonOutput };

package/src/transformers/outputs/logfmt.js

@@ -0,0 +1,13 @@
+const logfmt = require('logfmt');
+
+class LogfmtOutput {
+    run(line) {
+        if (typeof line !== 'object') {
+            throw new Error("To use an output transformer, you need to specify a parser like '-p json'");
+        }
+
+        return logfmt.stringify(line);
+    }
+}
+
+module.exports = { LogfmtOutput };

package/src/transformers/outputs/original.js

@@ -0,0 +1,7 @@
+class OriginalOutput {
+    run(_line, original) {
+        return original;
+    }
+}
+
+module.exports = { OriginalOutput };

package/src/transformers/outputs/table.js

@@ -0,0 +1,67 @@
+class TableOutput {
+    constructor() {
+        this.rows = [];
+        this.columns = [];
+        this.columnWidths = new Map();
+    }
+
+    run(line) {
+        if (typeof line !== 'object') {
+            throw new Error("To use an output transformer, you need to specify a parser like '-p json'");
+        }
+
+        this.rows.push(line);
+
+        Object.keys(line).forEach(column => {
+            if (!this.columnWidths.has(column)) {
+                this.columns.push(column);
+                this.columnWidths.set(column, column.length);
+            }
+
+            const cell = this._toCell(line[column]);
+            const width = this.columnWidths.get(column);
+            if (cell.length > width) {
+                this.columnWidths.set(column, cell.length);
+            }
+        });
+        return true;
+    }
+
+    flush() {
+        if (this.rows.length === 0) {
+            return [];
+        }
+
+        const columns = this.columns;
+        const widths = columns.map(column => this.columnWidths.get(column));
+
+        const lines = [];
+        lines.push(this._formatRow(columns, widths));
+        this.rows.forEach(row => {
+            const cells = columns.map(column => this._toCell(row[column]));
+            lines.push(this._formatRow(cells, widths));
+        });
+
+        return lines;
+    }
+
+    _toCell(value) {
+        if (value === null || value === undefined) {
+            return '';
+        }
+        if (typeof value === 'object') {
+            return JSON.stringify(value);
+        }
+
+        return String(value);
+    }
+
+    _formatRow(cells, widths) {
+        return cells
+            .map((cell, index) => cell.padEnd(widths[index]))
+            .join('  ')
+            .trimEnd();
+    }
+}
+
+module.exports = { TableOutput };

package/src/transformers/parsers/factory.js

@@ -0,0 +1,16 @@
+const { JsonParse } = require("./json");
+const { LogfmtParse } = require("./logfmt");
+const { TableParse } = require("./table");
+const { RegexParse } = require("./regex");
+
+function parseFactory(format) {
+    switch(format?.toLowerCase()) {
+        case   void 0: return null;
+        case   'json': return new JsonParse();
+        case 'logfmt': return new LogfmtParse();
+        case  'table': return new TableParse();
+        default:       return new RegexParse(format);
+    }
+}
+
+module.exports = { parseFactory };

package/src/transformers/parsers/json.js

@@ -0,0 +1,16 @@
+class JsonParse {
+    run(line) {
+        try {
+            const obj = JSON.parse(line);
+            if (typeof obj !== 'object') {
+                return false;
+            }
+
+            return obj;
+        } catch {
+            return false;
+        }
+    }
+}
+
+module.exports = { JsonParse };

package/src/transformers/parsers/logfmt.js

@@ -0,0 +1,13 @@
+const logfmt = require('logfmt');
+
+class LogfmtParse {
+    run(line) {
+        try {
+            return logfmt.parse(line);
+        } catch {
+            return false;
+        }
+    }
+}
+
+module.exports = { LogfmtParse };

package/src/transformers/parsers/regex.js

@@ -0,0 +1,11 @@
+class RegexParse {
+    constructor(regexStr) {
+        this.regex = new RegExp(regexStr, 'i');
+    }
+
+    run(line) {
+        return this.regex.exec(line)?.groups ?? false;
+    }
+}
+
+module.exports = { RegexParse };

package/src/transformers/parsers/table.js

@@ -0,0 +1,30 @@
+class TableParse {
+    constructor() {
+        this.headers = null;
+    }
+
+    run(line, _original, pipeline) {
+        if (!pipeline.firstLine) {
+            // Ignore first line, it's the headers
+            return false;
+        }
+        if (!this.headers) {
+            this.headers = this._splitColumns(pipeline.firstLine);
+        }
+
+        const columns = this._splitColumns(line);
+        const obj = {};
+
+        this.headers.forEach((header, i) => {
+            obj[header] = columns[i];
+        });
+
+        return obj;
+    }
+
+    _splitColumns(line) {
+        return line.replace(/\s+/g, ' ').split(' ');
+    }
+}
+
+module.exports = { TableParse };

package/test/filters.spec.js

@@ -1,9 +1,9 @@
 const Lab = require('@hapi/lab');
 const Code = require('@hapi/code');
 
-const filter = require('../src/transformers/filter');
-const ignore = require('../src/transformers/ignore');
-const field = require('../src/transformers/field');
+const { FindFilter } = require('../src/transformers/filters/find');
+const { IgnoreFilter } = require('../src/transformers/filters/ignore');
+const { FieldFilter } = require('../src/transformers/filters/field');
 
 const { describe, it } = exports.lab = Lab.script();
 const { expect } = Code;
@@ -11,76 +11,76 @@ const { expect } = Code;
 describe('filters', () => {
     describe('--filter', () => {
         it('should accept matching strings', () => {
-            const transformer = filter('psu');
-            const result = transformer('lorem ipsum dolor sit amet');
+            const transformer = new FindFilter('psu');
+            const result = transformer.run('lorem ipsum dolor sit amet');
             expect(result).to.be.true();
         });
-    
+
         it('should reject non-matching strings', () => {
-            const transformer = filter('aaa');
-            const result = transformer('lorem ipsum dolor sit amet');
+            const transformer = new FindFilter('aaa');
+            const result = transformer.run('lorem ipsum dolor sit amet');
             expect(result).to.be.false();
         });
-    
+
         it('should be case insensitive', () => {
-            const transformer = filter('PsU');
-            const result = transformer('lorem ipSUm dolor sit amet');
+            const transformer = new FindFilter('PsU');
+            const result = transformer.run('lorem ipSUm dolor sit amet');
             expect(result).to.be.true();
         });
-    
+
         it('should support regex', () => {
-            const transformer = filter('i.*m');
-            const result = transformer('lorem ipsum dolor sit amet');
+            const transformer = new FindFilter('i.*m');
+            const result = transformer.run('lorem ipsum dolor sit amet');
             expect(result).to.be.true();
         });
     });
     describe('--ignore', () => {
         it('should reject matching strings', () => {
-            const transformer = ignore('psu');
-            const result = transformer('lorem ipsum dolor sit amet');
+            const transformer = new IgnoreFilter('psu');
+            const result = transformer.run('lorem ipsum dolor sit amet');
             expect(result).to.be.false();
         });
-    
+
         it('should accept non-matching strings', () => {
-            const transformer = ignore('aaa');
-            const result = transformer('lorem ipsum dolor sit amet');
+            const transformer = new IgnoreFilter('aaa');
+            const result = transformer.run('lorem ipsum dolor sit amet');
             expect(result).to.be.true();
         });
-    
+
         it('should be case insensitive', () => {
-            const transformer = ignore('PsU');
-            const result = transformer('lorem ipSUm dolor sit amet');
+            const transformer = new IgnoreFilter('PsU');
+            const result = transformer.run('lorem ipSUm dolor sit amet');
             expect(result).to.be.false();
         });
-    
+
         it('should support regex', () => {
-            const transformer = ignore('i.*m');
-            const result = transformer('lorem ipsum dolor sit amet');
+            const transformer = new IgnoreFilter('i.*m');
+            const result = transformer.run('lorem ipsum dolor sit amet');
             expect(result).to.be.false();
         });
     });
     describe('--field', () => {
-        it('should error when strings wasn\'t parsed into object', () => {
-            const transformer = field('a');
-            expect(() => transformer('a')).to.throw();
+        it('should error when strings wasn\'t parsed into object', async () => {
+            const transformer = new FieldFilter('a');
+            expect(transformer.run('a')).to.reject();
         });
 
-        it('should compare equality', () => {
-            const transformer = field('foo == "bar"');
-            expect(transformer({ foo: 'bar' })).to.be.true();
-            expect(transformer({ foo: 'baz' })).to.be.false();
+        it('should compare equality', async () => {
+            const transformer = new FieldFilter('eq foo "bar"');
+            expect(await transformer.run({ foo: 'bar' })).to.be.true();
+            expect(await transformer.run({ foo: 'baz' })).to.be.false();
         });
 
-        it('should compare inequality with strings', () => {
-            const transformer = field('foo >= 3');
-            expect(transformer({ foo: '3' })).to.be.true();
-            expect(transformer({ foo: '2' })).to.be.false();
+        it('should compare inequality with strings', async () => {
+            const transformer = new FieldFilter('gte foo 3');
+            expect(await transformer.run({ foo: '3' })).to.be.true();
+            expect(await transformer.run({ foo: '2' })).to.be.false();
         });
 
-        it('should accept javascript', () => {
-            const transformer = field('foo.toLowerCase().includes("bar")');
-            expect(transformer({ foo: 'ABARA' })).to.be.true();
-            expect(transformer({ foo: 'ABADA' })).to.be.false();
+        it('should accept javascript', async () => {
+            const transformer = new FieldFilter('includes (lower foo) "bar"');
+            expect(await transformer.run({ foo: 'ABARA' })).to.be.true();
+            expect(await transformer.run({ foo: 'ABADA' })).to.be.false();
         });
     });
 });

package/test/output.spec.js

@@ -1,57 +1,96 @@
 const Lab = require('@hapi/lab');
 const Code = require('@hapi/code');
 
-const output = require('../src/transformers/output');
+const { outputFactory } = require('../src/transformers/outputs/factory');
 
 const { describe, it } = exports.lab = Lab.script();
 const { expect } = Code;
 
 describe('outputs', () => {
     it('should should not modify unparsed when unset', () => {
-        const format = output();
-        expect(format('foo')).to.be.true();
+        const format = outputFactory();
+        expect(format.run('foo')).to.be.true();
     });
 
-    it('should prettify parsed lines when unset', () => {
-        const format = output();
-        const line = format({ foo: 'bar' });
+    it('should inspect parsed lines single-line when unset', () => {
+        const format = outputFactory();
+        const line = format.run({ foo: 'bar' });
         expect(line).to.be.a.string();
         expect(line).to.match(/\{.*foo.*:.*bar.*\}/);
+        expect(line.split('\n').length).to.equal(1);
+    });
+
+    it('should inspect parsed lines multi-line', () => {
+        const format = outputFactory('inspect');
+        const line = format.run({ foo: 'bar' });
+        expect(line).to.be.a.string();
+        expect(line.split('\n').join(' ')).to.match(/\{.*foo.*:.*bar.*\}/);
+        expect(line.split('\n').length).to.equal(3);
     });
 
     it('should format as json', () => {
-        const format = output('json');
-        const line = format({ foo: 'bar' });
+        const format = outputFactory('json');
+        const line = format.run({ foo: 'bar' });
         expect(line).to.equal('{"foo":"bar"}');
     });
 
     it('should format as logfmt', () => {
-        const format = output('logfmt');
-        const line = format({ foo: 'bar' });
+        const format = outputFactory('logfmt');
+        const line = format.run({ foo: 'bar' });
         expect(line).to.equal('foo=bar');
     });
 
     it('should format as original', () => {
-        const format = output('original');
-        const line = format({ foo: 'bar' }, 'fubá');
+        const format = outputFactory('original');
+        const line = format.run({ foo: 'bar' }, 'fubá');
         expect(line).to.equal('fubá');
     });
 
-    it('should format with mustache', () => {
-        const format = output('[{{foo}}]');
-        const line = format({ foo: 'bar' });
+    it('should format as table', () => {
+        const format = outputFactory('table');
+        format.run({ foo: 'bar', baz: 'qux' });
+        format.run({ foo: 'longer' });
+        const lines = format.flush();
+
+        expect(lines).to.equal([
+            'foo     baz',
+            'bar     qux',
+            'longer',
+        ]);
+    });
+
+    it('should return empty table output when no rows were provided', () => {
+        const format = outputFactory('table');
+        expect(format.flush()).to.equal([]);
+    });
+
+    it('should stringify object and null table cells', () => {
+        const format = outputFactory('table');
+        format.run({ foo: null, bar: { baz: 1 } });
+        const lines = format.flush();
+
+        expect(lines).to.equal([
+            'foo  bar',
+            '     {"baz":1}',
+        ]);
+    });
+
+    it('should format with bigodon', async () => {
+        const format = outputFactory('[{{foo}}]');
+        const line = await format.run({ foo: 'bar' });
         expect(line).to.equal('[bar]');
     });
 
-    it('should allow js in mustache', () => {
-        const format = output('[{{ foo.toUpperCase() }}]');
-        const line = format({ foo: 'bar' });
+    it('should allow bigodon helpers', async () => {
+        const format = outputFactory('[{{upper foo }}]');
+        const line = await format.run({ foo: 'bar' });
         expect(line).to.equal('[BAR]');
     });
 
-    it('should refuse to format unparsed lines', () => {
-        expect(() => output('json')('foo')).to.throw();
-        expect(() => output('logfmt')('foo')).to.throw();
-        expect(() => output('{{foo}}')('foo')).to.throw();
+    it('should refuse to format unparsed lines', async () => {
+        expect(() => outputFactory('json').run('foo')).to.throw();
+        expect(() => outputFactory('logfmt').run('foo')).to.throw();
+        expect(() => outputFactory('table').run('foo')).to.throw();
+        await expect(outputFactory('{{foo}}').run('foo')).to.reject();
     });
 });

package/test/parse.spec.js

@@ -1,46 +1,46 @@
 const Lab = require('@hapi/lab');
 const Code = require('@hapi/code');
 
-const parse = require('../src/transformers/parse');
+const { parseFactory } = require('../src/transformers/parsers/factory');
 
 const { describe, it } = exports.lab = Lab.script();
 const { expect } = Code;
 
 describe('parsers', () => {
     it('should return null when no format is specified', () => {
-        expect(parse(void 0)).to.be.null();
+        expect(parseFactory(void 0)).to.be.null();
     });
 
     it('should parse json', () => {
-        const parser = parse('json');
-        expect(parser('{"foo": "bar"}')).to.equal({ foo: 'bar' });
+        const parser = parseFactory('json');
+        expect(parser.run('{"foo": "bar"}')).to.equal({ foo: 'bar' });
     });
 
     it('should ignore invalid json lines when parsing json', () => {
-        const parser = parse('json');
-        expect(parser('Oy')).to.be.false();
-        expect(parser('"Oy"')).to.be.false();
+        const parser = parseFactory('json');
+        expect(parser.run('Oy')).to.be.false();
+        expect(parser.run('"Oy"')).to.be.false();
     });
 
     it('should parse logfmt', () => {
-        const parser = parse('logfmt');
-        expect(parser('foo=bar')).to.equal({ foo: 'bar' });
+        const parser = parseFactory('logfmt');
+        expect(parser.run('foo=bar')).to.equal({ foo: 'bar' });
     });
 
     it('should ignore invalid logfmt lines when parsing logfmt', () => {
-        const parser = parse('logfmt');
-        expect(parser(void 0)).to.be.false();
+        const parser = parseFactory('logfmt');
+        expect(parser.run(void 0)).to.be.false();
     });
 
     it('should parse regex', () => {
-        const parser = parse('\\[(?<severity>\\S+)\\s*(?<delay>\\d+)ms\\] (?<message>.*)');
-        expect(parser('[info 20ms] lorem ipsum dolor')).to.equal({
+        const parser = parseFactory('\\[(?<severity>\\S+)\\s*(?<delay>\\d+)ms\\] (?<message>.*)');
+        expect(parser.run('[info 20ms] lorem ipsum dolor')).to.equal({
             severity: 'info',
             delay: '20',
             message: 'lorem ipsum dolor',
         });
 
-        expect(parser('foo')).to.be.false();
+        expect(parser.run('foo')).to.be.false();
     });
 
     describe('tables', () => {
@@ -52,21 +52,21 @@ describe('parsers', () => {
 
         it('should ignore headers', () => {
             const pipeline = { firstLine: null };
-            const parser = parse('table');
+            const parser = parseFactory('table');
             const line = tableRows[0];
-        
-            expect(parser(line, line, pipeline)).to.be.false();
+
+            expect(parser.run(line, line, pipeline)).to.be.false();
         });
 
         it('should parse subsequent rows', () => {
             const pipeline = { firstLine: tableRows[0] };
-            const parser = parse('table');
+            const parser = parseFactory('table');
             let line;
 
             line = tableRows[1];
-            expect(parser(line, line, pipeline)).to.equal({ NAME: 'foo', TYPE: 'bar' });
+            expect(parser.run(line, line, pipeline)).to.equal({ NAME: 'foo', TYPE: 'bar' });
             line = tableRows[2];
-            expect(parser(line, line, pipeline)).to.equal({ NAME: 'baz', TYPE: 'qux' });
+            expect(parser.run(line, line, pipeline)).to.equal({ NAME: 'baz', TYPE: 'qux' });
         });
     });
 });

package/test/pipeline.spec.js

@@ -6,11 +6,11 @@ const { describe, it } = exports.lab = Lab.script();
 const { expect } = Code;
 
 describe('pipeline', () => {
-    it('should remove rejected lines and keep accepted ones', () => {
+    it('should remove rejected lines and keep accepted ones', async () => {
         const args = [
             f('potato')
         ];
-        const actual = runPipeline([
+        const actual = await runPipeline([
             'yada yada yada',
             'lorem ipsum POTATO dolor',
             'ablueblue POTATO',
@@ -24,13 +24,13 @@ describe('pipeline', () => {
         expect(actual).to.equal(expected);
     });
 
-    it('should apply multiple filters', () => {
+    it('should apply multiple filters', async () => {
         const args = [
             f('foo'),
             f('bar'),
             i('nope'),
         ];
-        const actual = runPipeline([
+        const actual = await runPipeline([
             '1. foo',
             '2. foo bar nope',
             '3. foo bar',
@@ -43,12 +43,12 @@ describe('pipeline', () => {
         expect(actual).to.equal(expected);
     });
 
-    it('should apply default argument as filter', () => {
+    it('should apply default argument as filter', async () => {
         const args = [
             _('foo'),
             i('bar'),
         ];
-        const actual = runPipeline([
+        const actual = await runPipeline([
             '1. foo',
             '2. foo bar',
             '3. baz',
@@ -60,12 +60,12 @@ describe('pipeline', () => {
         expect(actual).to.equal(expected);
     });
 
-    it('should parse and format correctly', () => {
+    it('should parse and format correctly', async () => {
         const args = [
             p('logfmt'),
             o('json'),
         ];
-        const actual = runPipeline([
+        const actual = await runPipeline([
             'foo=bar baz=qux',
         ], args);
         const expected = [
@@ -75,13 +75,31 @@ describe('pipeline', () => {
         expect(actual).to.equal(expected);
     });
 
-    it('should filter by the original line even when parsers and outputs are provided', () => {
+    it('should buffer and format tables when requested', async () => {
+        const args = [
+            p('logfmt'),
+            o('table'),
+        ];
+        const actual = await runPipeline([
+            'foo=bar baz=qux',
+            'foo=longer',
+        ], args);
+        const expected = [
+            'foo     baz',
+            'bar     qux',
+            'longer',
+        ];
+
+        expect(actual).to.equal(expected);
+    });
+
+    it('should filter by the original line even when parsers and outputs are provided', async () => {
         const args = [
             p('logfmt'),
             o('json'),
             i('o=n'),
         ];
-        const actual = runPipeline([
+        const actual = await runPipeline([
             'foo=bar baz=qux',
             'foo=nope baz=qux',
         ], args);
@@ -92,13 +110,13 @@ describe('pipeline', () => {
         expect(actual).to.equal(expected);
     });
 
-    it('should apply field filters after parse', () => {
+    it('should apply field filters after parse', async () => {
         const args = [
             p('logfmt'),
             o('json'),
-            F('foo.startsWith("b")'),
+            F('startsWith foo "b"'),
         ];
-        const actual = runPipeline([
+        const actual = await runPipeline([
             'foo=bar baz=qux',
             'foo=nope baz=qux',
         ], args);
@@ -109,14 +127,14 @@ describe('pipeline', () => {
         expect(actual).to.equal(expected);
     });
 
-    it('should apply multiple field filters', () => {
+    it('should apply multiple field filters', async () => {
         const args = [
             p('logfmt'),
             o('json'),
-            F('foo.startsWith("b")'),
-            F('foo.endsWith("r")'),
+            F('startsWith foo "b"'),
+            F('endsWith foo "r"'),
         ];
-        const actual = runPipeline([
+        const actual = await runPipeline([
             'foo=baz baz=qux',
             'foo=bar baz=qux',
             'foo=tar baz=qux',
@@ -128,14 +146,14 @@ describe('pipeline', () => {
         expect(actual).to.equal(expected);
     });
 
-    it('should log headers when -H is provided', () => {
+    it('should log headers when -H is provided', async () => {
         const args = [
             p('table'),
             o('original'),
-            F('NAME === "foo"'),
+            F('eq NAME "foo"'),
             H(),
         ];
-        const actual = runPipeline([
+        const actual = await runPipeline([
             'NAME',
             'foo',
             'bar',
@@ -147,4 +165,35 @@ describe('pipeline', () => {
 
         expect(actual).to.equal(expected);
     });
+
+    it('should log headers only once when both -H and -o table is provided', async () => {
+        const args = [
+            p('table'),
+            o('table'),
+            F('eq NAME "foo"'),
+            H(),
+        ];
+        const actual = await runPipeline([
+            'NAME',
+            'foo',
+            'bar',
+        ], args);
+        const expected = [
+            'NAME',
+            'foo',
+        ];
+
+        expect(actual).to.equal(expected);
+    });
+
+    it('should not specify null prototype of regex parser', async () => {
+        const args = [
+            p('(?<num>\\d*)'),
+        ];
+        const [actual] = await runPipeline([
+            '12',
+        ], args);
+
+        expect(actual).not.to.include('null prototype');
+    });
 });

package/test/utils.js

@@ -31,7 +31,7 @@ function slowPod(...strs) {
     return emitter;
 }
 
-function runPipeline(inputLines, args) {
+async function runPipeline(inputLines, args) {
     const lines = [];
 
     const stdout = { write: (line) => lines.push(line) };
@@ -39,6 +39,11 @@ function runPipeline(inputLines, args) {
 
     inputLines.forEach(line => pipeline.onLogLine(line));
 
+    // Waiting for nextTick promises to resolve
+    await Hoek.wait(0);
+
+    pipeline.onEnd();
+
     // Removing \n from the end of each line
     return lines.map(line => line.slice(0, -1));
 }

package/src/transformers/field.js

@@ -1,11 +0,0 @@
-const vm = require('vm');
-
-module.exports = filter =>  line => {
-    if(typeof line !== 'object') {
-        throw new Error("To use a field filter, you need to specify a parser like '-p json' ");
-    }
-
-    vm.createContext(line);
-    const result = vm.runInContext(filter, line);
-    return Boolean(result);
-};

package/src/transformers/filter.js

@@ -1,4 +0,0 @@
-module.exports = regexStr => line => {
-    const regex = new RegExp(regexStr, 'i');
-    return regex.test(line);
-};

package/src/transformers/ignore.js

@@ -1,4 +0,0 @@
-module.exports = regexStr => line => {
-    const regex = new RegExp(regexStr, 'i');
-    return !regex.test(line);
-};

package/src/transformers/output-json.js

@@ -1,7 +0,0 @@
-module.exports = () => line => {
-    if(typeof line !== 'object') {
-        throw new Error("To use an output transformer, you need to specify a parser like '-p json'");
-    }
-
-    return JSON.stringify(line);
-};

package/src/transformers/output-logfmt.js

@@ -1,9 +0,0 @@
-const logfmt = require('logfmt');
-
-module.exports = () => line => {
-    if(typeof line !== 'object') {
-        throw new Error("To use an output transformer, you need to specify a parser like '-p json'");
-    }
-
-    return logfmt.stringify(line);
-};

package/src/transformers/output-mustache.js

@@ -1,13 +0,0 @@
-const { compile } = require('jstache');
-
-module.exports = format => {
-    const template = compile(format);
-
-    return line => {
-        if(typeof line !== 'object') {
-            throw new Error("To use an output transformer, you need to specify a parser like '-p json' ");
-        }
-
-        return template(line);
-    };
-}

package/src/transformers/output-original.js

@@ -1,3 +0,0 @@
-module.exports = () => (_line, original) => {
-    return original;
-};

package/src/transformers/output-unset.js

@@ -1,12 +0,0 @@
-const util = require('util');
-
-module.exports = () => line => {
-    if(typeof line === 'string') {
-        return true;
-    }
-
-    return util.inspect({ ...line }, {
-        colors: true,
-        depth: null,
-    });
-};

package/src/transformers/output.js

@@ -1,15 +0,0 @@
-const json = require('./output-json');
-const logfmt = require('./output-logfmt');
-const mustache = require('./output-mustache');
-const original = require('./output-original');
-const unset = require('./output-unset');
-
-module.exports = format => {
-    switch(format?.toLowerCase()) {
-        case     void 0: return unset();
-        case     'json': return json();
-        case   'logfmt': return logfmt();
-        case 'original': return original();
-        default:         return mustache(format);
-    }
-};

package/src/transformers/parse-json.js

@@ -1,12 +0,0 @@
-module.exports = () => line => {
-    try {
-        const obj = JSON.parse(line);
-        if(typeof obj !== 'object') {
-            return false;
-        }
-
-        return obj;
-    } catch {
-        return false;
-    }
-};

package/src/transformers/parse-logfmt.js

@@ -1,9 +0,0 @@
-const logfmt = require('logfmt');
-
-module.exports = () => line => {
-    try {
-        return logfmt.parse(line);
-    } catch {
-        return false;
-    }
-};

package/src/transformers/parse-regex.js

@@ -1,4 +0,0 @@
-module.exports = regexStr => {
-    const regex = new RegExp(regexStr, 'i');
-    return line => regex.exec(line)?.groups ?? false;
-};

package/src/transformers/parse-table.js

@@ -1,26 +0,0 @@
-function splitColumns(line) {
-    return line.replace(/\s+/g, ' ').split(' ');
-}
-
-module.exports = () => {
-    let headers;
-
-    return (line, _original, pipeline) => {
-        if(!pipeline.firstLine) {
-            // Ignore first line, it's the headers
-            return false;
-        }
-        if(!headers) {
-            headers = splitColumns(pipeline.firstLine);
-        }
-
-        const columns = splitColumns(line);
-        const obj = {};
-
-        headers.forEach((header, i) => {
-            obj[header] = columns[i];
-        });
-
-        return obj;
-    };
-};

package/src/transformers/parse.js

@@ -1,14 +0,0 @@
-const json = require('./parse-json');
-const logfmt = require('./parse-logfmt');
-const regex = require('./parse-regex');
-const table = require('./parse-table');
-
-module.exports = format => {
-    switch(format?.toLowerCase()) {
-        case   void 0: return null;
-        case   'json': return json();
-        case 'logfmt': return logfmt();
-        case  'table': return table();
-        default:       return regex(format);
-    }
-};