logtunnel 1.1.0 → 1.2.0

package/README.md

@@ -218,6 +218,20 @@ Convert `kubectl` table output to logfmt for easier downstream filtering:
 curl -s https://cdn.codetunnel.net/lt/table.log | lt -p table -o logfmt
 ```
 
+### Pick columns (`-P`)
+
+Pick specific columns to be displayed after parsing (works with any parser):
+
+List kubernetes pods and show only the specified columns:
+```bash
+cat ./examples/table.log | lt -p table -P NAME,STATUS,AGE -o table
+```
+
+Find logs containing "error", parse as JSON and keep just the specified columns:
+```bash
+curl -s https://cdn.codetunnel.net/lt/text.log | lt -f error -p json -P ts,level,message -o json
+```
+
 ### Custom regex parsing (`-p '(?<name>...)'`)
 
 Use a regex with named groups to “extract fields” from unstructured text:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logtunnel",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "CLI tool that allows you to format, filter and search your log output",
   "main": "src/main.js",
   "bin": {

package/src/definition.js

@@ -49,6 +49,11 @@ const definition = {
         alias: 'kubectl',
         type: 'boolean',
     },
+    P: {
+        description: 'Pick only these columns from parsed objects (comma-separated). Requires a parser like -p json.',
+        alias: 'pick',
+        type: 'string',
+    },
 };
 
 const $ = '$ '.gray;
@@ -76,6 +81,8 @@ const examples = [
     $ + 'curl -s https://cdn.codetunnel.net/lt/table.log | lt -H gateway',
     'Kubernetes tables: -k is shorthand for -p table -o table:'.dim,
     $ + 'curl -s https://cdn.codetunnel.net/lt/table.log | lt -k payment',
+    'Kubernetes tables: pick columns (NAME, STATUS, AGE):'.dim,
+    $ + 'cat ./examples/table.log | lt -p table -P NAME,STATUS,AGE -o table',
     'Kubernetes tables: show pods that are not fully ready:'.dim,
     $ + 'curl -s https://cdn.codetunnel.net/lt/table.log | lt -k -F \'lt (itemAt (split READY "/") 0) (itemAt (split READY "/") 1)\'',
     'Custom regex parsing (extract fields) and output as logfmt:'.dim,

package/src/main.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 const semver = require('semver');
-if(!semver.satisfies(process.version, '>=12')) {
-    console.error(`Your NodeJS version (${process.version}) is too old for logtunnel :(\nUse at least NodeJS 12`);
+if(!semver.satisfies(process.version, '>=16')) {
+    console.error(`Your NodeJS version (${process.version}) is too old for logtunnel :(\nUse at least NodeJS 16`);
     process.exit(1);
 }
 

package/src/pipeline.js

@@ -3,6 +3,7 @@
 const { FieldFilter } = require('./transformers/filters/field');
 const { FindFilter } = require('./transformers/filters/find');
 const { IgnoreFilter } = require('./transformers/filters/ignore');
+const { PickFilter } = require('./transformers/filters/pick');
 const { outputFactory } = require('./transformers/outputs/factory');
 const { parseFactory } = require('./transformers/parsers/factory');
 
@@ -20,17 +21,16 @@ class LogPipeline {
     }
 
     onLogLine(line) {
-        try {
-            debug('got line: ' + line)
-            const isFirstLine = this._updateFirstLine(line);
-            this._logLine(line, isFirstLine);
-        } catch (e) {
-            // Covering this would kill the process
-            /* $lab:coverage:off$ */
-            console.error('Error:', e.message);
-            process.exit(1);
-            /* $lab:coverage:on$ */
-        }
+        debug('got line: ' + line)
+        const isFirstLine = this._updateFirstLine(line);
+        this._logLine(line, isFirstLine)
+            .catch(error => {
+                // Covering this would kill the process
+                /* $lab:coverage:off$ */
+                console.error('Error:', error.message);
+                process.exit(1);
+                /* $lab:coverage:on$ */
+            });
     }
 
     async _logLine(line, isFirstLine) {
@@ -99,6 +99,8 @@ class LogPipeline {
             parseFactory(this.args.parser),
             // ...and apply field filters
             ...this.args.field.map(f => new FieldFilter(f)),
+            // ...optionally pick specific columns
+            this.args.pick ? new PickFilter(this.args.pick) : null,
             // And finally format the output
             this.outputTransformer,
         ];

package/src/transformers/filters/pick.js

@@ -0,0 +1,22 @@
+class PickFilter {
+    constructor(columns) {
+        this.columns = columns
+            .split(',')
+            .map(column => column.trim())
+            .filter(Boolean);
+    }
+
+    async run(line) {
+        if (typeof line !== 'object') {
+            throw new Error("To use -P/--pick, you need to specify a parser like '-p json'");
+        }
+
+        return Object.fromEntries(
+            this.columns
+                .filter(column => line[column] !== undefined)
+                .map(column => [column, line[column]])
+        );
+    }
+}
+
+module.exports = { PickFilter };

package/test/filters.spec.js

@@ -4,6 +4,7 @@ const Code = require('@hapi/code');
 const { FindFilter } = require('../src/transformers/filters/find');
 const { IgnoreFilter } = require('../src/transformers/filters/ignore');
 const { FieldFilter } = require('../src/transformers/filters/field');
+const { PickFilter } = require('../src/transformers/filters/pick');
 
 const { describe, it } = exports.lab = Lab.script();
 const { expect } = Code;
@@ -83,4 +84,35 @@ describe('filters', () => {
             expect(await transformer.run({ foo: 'ABADA' })).to.be.false();
         });
     });
+
+    describe('--pick', () => {
+        it('should error when strings weren\'t parsed into object', async () => {
+            const transformer = new PickFilter('foo');
+            expect(transformer.run('a')).to.reject();
+        });
+
+        it('should pick only selected field (1 field)', async () => {
+            const transformer = new PickFilter('foo');
+            const result = await transformer.run({ foo: 'bar', baz: 'qux', extra: 'nope' });
+            expect(result).to.equal({ foo: 'bar' });
+        });
+
+        it('should pick only selected fields (2 fields)', async () => {
+            const transformer = new PickFilter('foo,baz');
+            const result = await transformer.run({ foo: 'bar', baz: 'qux', extra: 'nope' });
+            expect(result).to.equal({ foo: 'bar', baz: 'qux' });
+        });
+
+        it('should not break with undefined fields', async () => {
+            const transformer = new PickFilter('foo,bar');
+            const result = await transformer.run({ foo: 'bar', baz: 'qux', extra: 'nope' });
+            expect(result).to.equal({ foo: 'bar' });
+        });
+
+        it('should include falsy values', async () => {
+            const transformer = new PickFilter('foo,baz');
+            const result = await transformer.run({ foo: 0, baz: null, extra: 'nope' });
+            expect(result).to.equal({ foo: 0, baz: null });
+        });
+    });
 });

package/test/pipeline.spec.js

@@ -1,6 +1,6 @@
 const Lab = require('@hapi/lab');
 const Code = require('@hapi/code');
-const { runPipeline, _, f, i, F, p, o, H, k } = require('./utils');
+const { runPipeline, _, f, i, F, P, p, o, H, k } = require('./utils');
 
 const { describe, it } = exports.lab = Lab.script();
 const { expect } = Code;
@@ -146,6 +146,22 @@ describe('pipeline', () => {
         expect(actual).to.equal(expected);
     });
 
+    it('should pick columns before formatting', async () => {
+        const args = [
+            p('logfmt'),
+            o('json'),
+            P('foo,baz'),
+        ];
+        const actual = await runPipeline([
+            'foo=bar baz=qux extra=nope',
+        ], args);
+        const expected = [
+            '{"foo":"bar","baz":"qux"}',
+        ];
+
+        expect(actual).to.equal(expected);
+    });
+
     it('should log headers when -H is provided', async () => {
         const args = [
             p('table'),

package/test/utils.js

@@ -64,9 +64,10 @@ const _ = str => ({ _: str });
 const f = str => ({ filter: [str] });
 const i = str => ({ ignore: [str] });
 const F = str => ({ field: [str] });
+const P = str => ({ pick: str });
 const p = str => ({ parser: str });
 const o = str => ({ output: str });
 const H = () => ({ headers: true });
 const k = () => ({ kubectl: true });
 
-module.exports = { pod, slowPod, runPipeline, _, f, i, F, p, o, H, k };
+module.exports = { pod, slowPod, runPipeline, _, f, i, F, P, p, o, H, k };