logtunnel 1.0.0 → 1.1.0

package/README.md

@@ -1,61 +1,259 @@
-# Logtunnel
+# logtunnel
 
-CLI tool that allows you to format, filter and search your log output
+`logtunnel` (`lt`) is a CLI tool that helps you search logs, parse them into structured data, filter by fields, and reformat them for reading or other tools.
 
-## Requirements
+## Installation
 
-- [NodeJS >= 12](https://nodejs.org/en/download/)
-- [NPM](https://docs.npmjs.com/cli/v7/configuring-npm/install)
+```bash
+npm i -g logtunnel
+```
 
-## Installation
+If you are on Linux, you might need `sudo` depending on your setup.
+
+## Tutorial
+
+### The simplest form: find lines
+
+`lt <filter>` is shorthand for “keep only lines that match this regex” (case-insensitive).
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/text.log | lt error
+```
+
+You can also use `-f`/`--filter` multiple times (AND behavior, all filters must match). For lines containing both checkout and alice, you could use:
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/text.log | lt -f checkout -f alice
+```
+
+### Ignore noise
+
+Use `-i`/`--ignore` to drop lines that match those regexes:
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/text.log | lt -i healthz -i metrics
+```
+
+Find something while ignoring other things:
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/text.log | lt -f error -i NullPointer -i "retrying in"
+```
+
+Tip: `-f` and `-i` always run against the original input line (before parsing). If you want “filter by JSON fields”, use `-F` with a parser.
+
+### Parse logs (turn text into structured data)
+
+Parsing makes each line become an “event object”, enabling field filters (`-F`) and structured outputs (`-o json`, `-o logfmt`, `-o table`, templates, etc).
+
+Supported parsers:
+
+- `-p json` (one JSON object per line)
+- `-p logfmt` (key=value log lines)
+- `-p table` (space-aligned tables like `kubectl get pods`)
+- `-p '<regex with named groups>'` (custom parsing using RegExp named groups)
+
+#### Parse JSON and format a clean line
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -o '[{{ts}} {{upper level}}] {{message}}'
+```
+
+#### Parse logfmt and convert to JSON (great for piping into other tools)
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/logfmt.log | lt -p logfmt -o json
+```
+
+#### Parse JSON and show “human friendly structured output”
+
+Default output (no `-o`) is “inspect”, objects are pretty-printed with colors.
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json
+```
+
+Use `-o inspect` to force multi-line output (useful for large or nested objects):
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -o inspect
+```
+
+### Custom formats
+
+When you pass a string to `-o` that isn’t one of `json|logfmt|inspect|original|table`, `lt` treats it as a Bigodon template (a safe Mustache/Handlebars-like language).
+
+It supports:
+
+- Variables: `{{message}}`, `{{ts}}`, `{{kubernetes.pod}}`
+- Helpers: `{{upper level}}`, `{{lower user.email}}`, `{{toFixed delay_ms 2}}`
+- Nested expressions: `{{capitalize (lower level)}}`
+
+Example (compact “service log line”):
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -o '[{{ts}}] {{service}} {{kubernetes.namespace}}/{{kubernetes.pod}} {{upper level}} {{message}}'
+```
+
+You can find the bigodon language reference [here](https://github.com/gabriel-pinheiro/bigodon/blob/main/LANGUAGE.md) and the available helpers [here](https://github.com/gabriel-pinheiro/bigodon/blob/main/HELPERS.md).
+
+### Field filters (`-F <expression>`)
+
+`-F/--field` filters *parsed objects* (so it requires `-p ...`). You can specify `-F` multiple times; all field filters must match (AND behavior).
+
+Common helpers you’ll use in field filters:
+
+- comparisons: `gt`, `gte`, `lt`, `lte`, `eq`, `and`, `or`, `not`
+- strings: `lower`, `upper`, `startsWith`, `endsWith`
+- `includes` works for strings and arrays
+
+Show only slow requests (delay over 200ms):
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -F 'gt delay_ms 200' -o inspect
+```
+
+Case-insensitive “message contains alice”:
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -F 'includes (lower message) "alice"' -o '[{{ts} {{upper level}}] {{message}}'
+```
+
+Combine multiple conditions:
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -F 'and (eq level "error") (gt http.status 499)' -o '[{{ts}} {{upper level}}] {{message}}'
+```
+
+Show the *original raw line* after field filtering:
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -F 'gt delay_ms 200' -o original
+```
+
+#### Tip: General filter combined with expression filters
+
+Inclusion (`-f`) and exclusion (`-i`) filters are ~5x faster than field filters (`-F`) because they skip the parsing step. If you can apply a broader filter with `-f`/`-i` before the more specific `-F` filter, it'll be much quicker on large files. If you are seeing poor performance on filters like:
+
+```
+curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -F 'eq level "error"' -o original
+```
+
+And you can't use filters like this because they'd show loglines that are of level INFO but contain the "error" string on the message:
+
+```
+curl -s https://cdn.codetunnel.net/lt/json.log | lt -f error
+```
+
+You can combine both to reduce the amount of parsed lines with the `-f` filter before the more specific `-F`:
+
+```
+curl -s https://cdn.codetunnel.net/lt/json.log | lt -f error -p json -F 'eq level "error"' -o original
+```
+
+### Kubernetes tables
+
+`-p table` is designed for outputs like `kubectl get pods -A` (space-separated columns).
+
+Find all pods (`kubectl get pods -A`) but ignore lines containing kube-system:
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/table.log | lt -i kube-system
+```
+
+As the pods on the kube-system namespace had longer names, this log will be wider (requiring a wider terminal before wrapping) because kubernetes still considered their length to build the table, other things like the time since the last restart, longer status names (CrashLoopBackOff) can make the original table wider.
+
+You can use `-p table` to parse the table, filters to include/exclude lines, and `-o table` to output a new table, considering the length of the selected lines, only. The command above printed the table as wide as kubernetes generated, this one prints a narrower one:
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/table.log | lt -p table -o table -i kube-system
+```
+
+If you are looking for all pods containing the word `gateway`, you might end up excluding the headers row:
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/table.log | lt gateway
+```
+
+You can always print the headers row with `-H`:
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/table.log | lt -H gateway
+```
+
+### Kubernetes -k option and more examples
+
+On kubectl commands, you most likely want to parse the table (`-p table`) and reformat as a new table (`-o table`). You can use the `-k` as an alias to `-p table -o table`:
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/table.log | lt -k payment
+```
+
+When parsing the table with `-p table`, you can filter with custom logic using the field filters (`-F`), you can get pods with at least one restart:
+```bash
+curl -s https://cdn.codetunnel.net/lt/table.log | lt -k -F 'gt RESTARTS 0'
+```
+
+Show pods that are not fully ready (`READY` looks like `1/2`):
 
-``sudo npm i -g logtunnel``
+```bash
+curl -s https://cdn.codetunnel.net/lt/table.log | lt -p '(?<up>\d+)/(?<total>\d+)' -F 'lt up total' -H -o original
+```
 
-## Usage
+Or, combining multiple lts to re-format the table:
 
-Find logs that contain "alice":
-``curl -s https://cdn.codetunnel.net/lt/text.log | lt alice``
+```bash
+curl -s https://cdn.codetunnel.net/lt/table.log | lt -p '(?<up>\d+)/(?<total>\d+)' -F 'lt up total' -H -o original | lt -k
+```
 
-Find logs that contain "alice" and "purchase":
-``curl -s https://cdn.codetunnel.net/lt/text.log | lt -f alice -f purchase``
+Or, using just templates:
 
-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``
+```bash
+curl -s https://cdn.codetunnel.net/lt/table.log | lt -k -F 'lt (itemAt (split READY "/") 0) (itemAt (split READY "/") 1)'
+```
 
-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}}'``
+Convert `kubectl` table output to logfmt for easier downstream filtering:
 
-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``
+```bash
+curl -s https://cdn.codetunnel.net/lt/table.log | lt -p table -o logfmt
+```
 
-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'``
+### Custom regex parsing (`-p '(?<name>...)'`)
 
-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")'``
+Use a regex with named groups to “extract fields” from unstructured text:
 
-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'``
+```bash
+curl -s https://cdn.codetunnel.net/lt/text.log | lt -p '(?<ts>\S+) \[(?<level>\w+)\] (?<message>.*)' -o logfmt
+```
 
-Parse logs as JSON and output them as a table:
-``curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -o table``
+Then field-filter on extracted fields:
 
-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``
+```bash
+curl -s https://cdn.codetunnel.net/lt/text.log | lt -p '(?<delay_ms>\d+)ms' -F 'gt delay_ms 200' -o original
+```
 
-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'``
+## Reference
 
-Parse table and show rows containing "cilium":
-``curl -s https://cdn.codetunnel.net/lt/table.log | lt -p table -o original -f cilium``
+### Options
 
-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``
+- `lt <filter>`: shorthand for a single text filter
+- `-f, --filter <regex>`: keep lines that match this regex (repeatable)
+- `-i, --ignore <regex>`: drop lines that match this regex (repeatable)
+- `-p, --parser <json|logfmt|table|regex>`: parse each line into an object
+- `-F, --field <bigodon expression>`: filter parsed objects by expression (repeatable)
+- `-o, --output <format|template>`: output `json|logfmt|inspect|original|table` or a Bigodon template
+- `-H, --headers`: always output the first input line (table headers)
+- `-k, --kubectl`: shortcut for `-p table -o table`
+- `-h, --help`: show help
+- `-v, --version`: show version
 
-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``
+### Formats at a glance
 
-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``
+- `-o original`: print the original input line (even after parsing/filtering)
+- `-o inspect` (or default): print objects with colors for humans
+- `-o json`: emit JSON objects
+- `-o logfmt`: emit `key=value` lines
+- `-o table`: render a table from parsed objects (buffers until EOF)
+- `-o '<bigodon template>'`: render a custom line from parsed objects
 
-For more information ``lt --help``
+For the built-in help (includes examples): `lt --help`.

package/package.json

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

package/src/definition.js

@@ -34,7 +34,7 @@ const definition = {
         type: 'string',
     },
     F: {
-        description: 'Show only logs that match the field filter. You can use JavaScript.',
+        description: 'Show only logs that match the field filter (Bigodon expression). Requires a parser like -p json.',
         alias: 'field',
         type: 'string',
         multiple: true,
@@ -44,41 +44,42 @@ const definition = {
         alias: 'headers',
         type: 'boolean',
     },
+    k: {
+        description: 'Shortcut for kubectl tables (equivalent to -p table -o table).',
+        alias: 'kubectl',
+        type: 'boolean',
+    },
 };
 
 const $ = '$ '.gray;
 const examples = [
     '\n\nExamples:\n',
-    'Find logs that contain "alice":'.dim,
-    $ + 'curl -s https://cdn.codetunnel.net/lt/text.log | lt alice',
-    'Find logs that contain "alice" and "purchase":'.dim,
-    $ + '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"'.dim,
-    $ + 'curl -s https://cdn.codetunnel.net/lt/text.log | lt -f alice -i info',
-    'Parse logs as JSON and output them with that template'.dim,
-    $ + '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"'.dim,
-    $ + '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"'.dim,
-    $ + '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"'.dim,
-    $ + '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,
-    $ + '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"'.dim,
-    $ + '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'.dim,
-    $ + 'curl -s https://cdn.codetunnel.net/lt/table.log | lt -p table -o original -f cilium -H',
-    'Parse table, show rows with RESTARTS > 0'.dim,
-    $ + 'curl -s https://cdn.codetunnel.net/lt/table.log | lt -p table -o original -F \'RESTARTS > 0\' -H',
-    'Show rows that are not ready'.dim,
-    $ + 'curl -s https://cdn.codetunnel.net/lt/table.log | lt -p \'(?<up>\\d)/(?<total>\\d)\' -o original -F \'up < total\' -H',
+    'Find lines containing "error" (shorthand for a single -f filter):'.dim,
+    $ + 'curl -s https://cdn.codetunnel.net/lt/text.log | lt error',
+    'Find lines containing "checkout" and "alice" (AND):'.dim,
+    $ + 'curl -s https://cdn.codetunnel.net/lt/text.log | lt -f checkout -f alice',
+    'Ignore noise (drop health/metrics lines):'.dim,
+    $ + 'curl -s https://cdn.codetunnel.net/lt/text.log | lt -i healthz -i metrics',
+    'Find errors while ignoring known spam:'.dim,
+    $ + 'curl -s https://cdn.codetunnel.net/lt/text.log | lt -f error -i NullPointer -i "retrying in"',
+    'Parse JSON (default output is inspect):'.dim,
+    $ + 'curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json',
+    'Parse JSON and format a clean line:'.dim,
+    $ + 'curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -o \'[{{ts}} {{upper level}}] {{message}}\'',
+    'Field filter: only slow requests (delay_ms > 200):'.dim,
+    $ + 'curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -F \'gt delay_ms 200\' -o original',
+    'Field filter: combine conditions:'.dim,
+    $ + 'curl -s https://cdn.codetunnel.net/lt/json.log | lt -p json -F \'and (eq level "error") (gt http.status 499)\' -o \'[{{ts}} {{upper level}}] {{message}}\'',
+    'Parse logfmt and convert to JSON:'.dim,
+    $ + 'curl -s https://cdn.codetunnel.net/lt/logfmt.log | lt -p logfmt -o json',
+    'Kubernetes tables: find rows containing "gateway", keep headers:'.dim,
+    $ + '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: 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,
+    $ + 'curl -s https://cdn.codetunnel.net/lt/text.log | lt -p \'(?<ts>\\S+) \\[(?<level>\\w+)\\] (?<message>.*)\' -o logfmt',
 ];
 
 const usage = Bossy.usage(definition, 'lt [options]\n   Or: lt <filter>') + examples.join('\n');

package/src/pipeline.js

@@ -11,7 +11,7 @@ const debug = require('debug')('logtunnel:pipeline');
 class LogPipeline {
     constructor(args, stdout) {
         this.firstLine = null;
-        this.args = args;
+        this.args = this._normalizeArgs(args);
         this.stdout = stdout;
         this.outputTransformer = outputFactory(this.args.output);
         this.isOutputBuffered = Boolean(this.outputTransformer.flush);
@@ -22,8 +22,8 @@ class LogPipeline {
     onLogLine(line) {
         try {
             debug('got line: ' + line)
-            this._logLine(line);
-            this._updateFirstLine(line);
+            const isFirstLine = this._updateFirstLine(line);
+            this._logLine(line, isFirstLine);
         } catch (e) {
             // Covering this would kill the process
             /* $lab:coverage:off$ */
@@ -33,11 +33,15 @@ class LogPipeline {
         }
     }
 
-    async _logLine(line) {
+    async _logLine(line, isFirstLine) {
         let output = line;
 
         for (let transformer of this.transformers) {
-            const result = await transformer.run(output, line, this);
+            const result = await transformer.run(
+                output,
+                line,
+                isFirstLine ? null : this.firstLine,
+            );
 
             // Transformer accepted the line
             if(result === true) {
@@ -65,13 +69,15 @@ class LogPipeline {
 
     _updateFirstLine(line) {
         if (this.firstLine) {
-            return;
+            return false;
         }
 
         this.firstLine = line;
         if(this.args.headers && !this.isOutputBuffered) {
             this.stdout.write(this.firstLine + '\n');
         }
+
+        return true;
     }
 
     onEnd() {
@@ -97,6 +103,17 @@ class LogPipeline {
             this.outputTransformer,
         ];
     }
+
+    _normalizeArgs(args) {
+        const normalized = { ...args };
+
+        if (normalized.kubectl) {
+            normalized.parser = 'table';
+            normalized.output = 'table';
+        }
+
+        return normalized;
+    }
 }
 
 module.exports.LogPipeline = LogPipeline;

package/src/transformers/parsers/table.js

@@ -3,13 +3,14 @@ class TableParse {
         this.headers = null;
     }
 
-    run(line, _original, pipeline) {
-        if (!pipeline.firstLine) {
+    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(pipeline.firstLine);
+            this.headers = this._splitColumns(firstLine);
         }
 
         const columns = this._splitColumns(line);

package/test/parse.spec.js

@@ -51,22 +51,20 @@ describe('parsers', () => {
         ];
 
         it('should ignore headers', () => {
-            const pipeline = { firstLine: null };
             const parser = parseFactory('table');
             const line = tableRows[0];
 
-            expect(parser.run(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 = parseFactory('table');
             let line;
 
             line = tableRows[1];
-            expect(parser.run(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.run(line, line, pipeline)).to.equal({ NAME: 'baz', TYPE: 'qux' });
+            expect(parser.run(line, line, tableRows[0])).to.equal({ NAME: 'baz', TYPE: 'qux' });
         });
     });
 });

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 } = require('./utils');
+const { runPipeline, _, f, i, F, p, o, H, k } = require('./utils');
 
 const { describe, it } = exports.lab = Lab.script();
 const { expect } = Code;
@@ -186,6 +186,25 @@ describe('pipeline', () => {
         expect(actual).to.equal(expected);
     });
 
+    it('should not duplicate headers when parsing and reformatting tables with ignore filters', async () => {
+        const args = [
+            p('table'),
+            o('table'),
+            i('kube'),
+        ];
+        const actual = await runPipeline([
+            'NAMESPACE NAME',
+            'kube-system coredns',
+            'default api',
+        ], args);
+        const expected = [
+            'NAMESPACE  NAME',
+            'default    api',
+        ];
+
+        expect(actual).to.equal(expected);
+    });
+
     it('should not specify null prototype of regex parser', async () => {
         const args = [
             p('(?<num>\\d*)'),
@@ -196,4 +215,22 @@ describe('pipeline', () => {
 
         expect(actual).not.to.include('null prototype');
     });
+
+    it('should parse and format kubectl tables with -k', async () => {
+        const args = [
+            k(),
+        ];
+        const actual = await runPipeline([
+            'NAME AGE',
+            'foo 1',
+            'bar 22',
+        ], args);
+        const expected = [
+            'NAME  AGE',
+            'foo   1',
+            'bar   22',
+        ];
+
+        expect(actual).to.equal(expected);
+    });
 });

package/test/utils.js

@@ -67,5 +67,6 @@ const F = str => ({ field: [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 };
+module.exports = { pod, slowPod, runPipeline, _, f, i, F, p, o, H, k };