logtunnel 0.4.0 → 1.1.0

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,31 @@
+class TableParse {
+    constructor() {
+        this.headers = null;
+    }
+
+    run(line, _original, firstLine) {
+        if (!firstLine) {
+            // Ignore first line, it's the headers
+            this.headers = this._splitColumns(line);
+            return false;
+        }
+        if (!this.headers) {
+            this.headers = this._splitColumns(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', () => {
@@ -51,22 +51,20 @@ 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, null)).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, tableRows[0])).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, tableRows[0])).to.equal({ NAME: 'baz', TYPE: 'qux' });
         });
     });
 });