LogLens Performance Benchmarks 🚀

We don't just claim it's fast. We prove it against the tools you use every day.

The Test Environment

All benchmarks were run on a modern developer desktop (Intel(R) Core(TM) i7-9700F CPU @ 3.00GHz, 8 vCores). The test file was a 5.6 GB line-delimited JSON log file containing over 16 million log entries. All tests were run multiple times with a warm disk cache to measure pure processing speed.

Benchmark 1: LogLens `query` vs. `jq` for Structured Queries

This is the most common use case for modern log analysis: filtering millions of JSON entries based on the value of a specific field.

Result: LogLens is 2.4 times faster than a standard `cat | jq` pipeline for typical structured queries.

Command	Mean Time (± σ)
`loglens query ... 'level == "ERROR"'`	57.188 s ± 0.234 s
`cat ... \| jq 'select(.level == "ERROR")'`	137.713 s ± 0.528 s

Benchmark 2: Querying Compressed Logs (`.gz`)

Logs are often compressed to save space. We benchmarked LogLens's ability to query a gzipped file directly against the standard `gunzip | jq` workflow, which requires manual decompression.

Result: LogLens is 2.2 times faster and provides a much simpler, single-command workflow.

Command	Mean Time (± σ)
`loglens query ... .gz 'level == "ERROR"'`	60.268 s ± 1.065 s
`gunzip -c ... .gz \| jq 'select(...)'`	137.003 s ± 0.776 s

Benchmark 3: LogLens `search` vs. `grep` for Raw Text

To calibrate the raw speed of our file scanning engine, we compared a simple `loglens search` to `grep`, the undisputed gold standard for raw text searching.

Result: While `grep` remains the specialized champion for simple string matching, LogLens's parallelized Rust engine is still exceptionally fast, scanning the entire 5.6 GB file in under 9 seconds.

Command	Mean Time (± σ)
`loglens search ... "usr_456"`	8.805 s ± 0.100 s
`grep "usr_456" ...`	0.6 ms ± 0.2 ms

The Verdict: Speed Where It Matters Most

The benchmarks are clear. For the complex, real-world task of querying structured and compressed logs, LogLens is over 2x faster than the common `jq` and `gunzip` pipelines. This performance gain comes from its purpose-built design:

Parallel Processing: LogLens reads, decompresses, and parses chunks of the file across all available CPU cores simultaneously.
Optimized Rust Engine: Built in Rust, the core logic is memory-efficient and compiled down to machine code, avoiding the overhead of interpreted tools.
Single Process: Unlike a `gunzip | jq` pipe which involves two separate processes and data transfer between them, LogLens does everything in a single, efficient operation.

LogLens combines a highly-optimized engine that is exceptionally fast for simple tasks with a structured query processor that provides a superior experience for modern log analysis.