logtunnel 0.4.0 → 1.1.0

package/README.md

@@ -0,0 +1,259 @@
+# logtunnel
+
+`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.
+
+## Installation
+
+```bash
+npm i -g logtunnel
+```
+
+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`):
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/table.log | lt -p '(?<up>\d+)/(?<total>\d+)' -F 'lt up total' -H -o original
+```
+
+Or, combining multiple lts to re-format the table:
+
+```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
+```
+
+Or, using just templates:
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/table.log | lt -k -F 'lt (itemAt (split READY "/") 0) (itemAt (split READY "/") 1)'
+```
+
+Convert `kubectl` table output to logfmt for easier downstream filtering:
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/table.log | lt -p table -o logfmt
+```
+
+### Custom regex parsing (`-p '(?<name>...)'`)
+
+Use a regex with named groups to “extract fields” from unstructured text:
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/text.log | lt -p '(?<ts>\S+) \[(?<level>\w+)\] (?<message>.*)' -o logfmt
+```
+
+Then field-filter on extracted fields:
+
+```bash
+curl -s https://cdn.codetunnel.net/lt/text.log | lt -p '(?<delay_ms>\d+)ms' -F 'gt delay_ms 200' -o original
+```
+
+## Reference
+
+### Options
+
+- `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
+
+### Formats at a glance
+
+- `-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 the built-in help (includes examples): `lt --help`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logtunnel",
-  "version": "0.4.0",
+  "version": "1.1.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,12 +29,12 @@ 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',
     },
     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,39 +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 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/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,25 +1,29 @@
 '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.args = this._normalizeArgs(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) {
         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$ */
@@ -29,11 +33,15 @@ class LogPipeline {
         }
     }
 
-    _logLine(line) {
+    async _logLine(line, isFirstLine) {
         let output = line;
 
         for (let transformer of this.transformers) {
-            const result = transformer(output, line, this);
+            const result = await transformer.run(
+                output,
+                line,
+                isFirstLine ? null : this.firstLine,
+            );
 
             // Transformer accepted the line
             if(result === true) {
@@ -49,7 +57,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');
@@ -57,29 +69,51 @@ class LogPipeline {
 
     _updateFirstLine(line) {
         if (this.firstLine) {
-            return;
+            return false;
         }
 
         this.firstLine = line;
-        if(this.args.headers) {
+        if(this.args.headers && !this.isOutputBuffered) {
             this.stdout.write(this.firstLine + '\n');
         }
+
+        return true;
+    }
+
+    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,
         ];
     }
+
+    _normalizeArgs(args) {
+        const normalized = { ...args };
+
+        if (normalized.kubectl) {
+            normalized.parser = 'table';
+            normalized.output = 'table';
+        }
+
+        return normalized;
+    }
 }
 
 module.exports.LogPipeline = LogPipeline;

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 };