Performance

evlog is designed for production. Every operation is benchmarked and tracked against regressions in CI. This page documents the methodology, current numbers, and what they mean for your application.

Methodology

Benchmarks run with Vitest bench (powered by tinybench):

• Each benchmark runs for 500ms after JIT warmup
• Results report ops/sec, mean, p75, p99, p995, and p999 latency
• All benchmarks run in silent mode (silent: true) to isolate the library overhead from I/O
• JSON output is saved for CI comparison between commits

Run benchmarks locally:

cd packages/evlog
bun run bench

Core operations

These benchmarks measure the cost of evlog's fundamental building blocks in isolation.

Logger creation

Creating a logger is essentially free — it's a closure over a plain object spread. No allocation pressure.

log.set() — accumulating context

set() uses deepDefaults — a recursive merge that preserves existing values. The cost scales linearly with object depth, not breadth.

log.emit() — building the wide event

The full request lifecycle — create a logger, accumulate context across 3 set() calls, and emit — costs about 1 microsecond. That's ~0.001ms of overhead per request.

Payload size scaling

Wide events with 50+ fields remain fast. Even at 200 deeply nested fields, emit takes under 40µs — well within budget for any HTTP request.

Formatting

evlog adds roughly 30% overhead over raw JSON.stringify — the difference is new Date().toISOString(), the spread operator for building the WideEvent, and the sampling check.

In development, the pretty printer with ANSI colors runs at the same speed when console output is mocked — the actual I/O (writing to stdout) is the bottleneck, not the formatting logic.

Sampling

Sampling adds zero measurable overhead. Both head sampling (random percentage) and tail sampling (condition evaluation) complete in under 30 nanoseconds. Even path glob matching with matchesPattern() is negligible.

Enrichers

Running the full enricher pipeline — User Agent parsing, Geo extraction, Request Size, and Trace Context — adds about 2.3µs per request. The User Agent regex parsing is the most expensive enricher.

When headers are absent (common for internal/health check requests), enrichers short-circuit immediately.

Error handling

createError() costs ~5µs, dominated by V8's Error.captureStackTrace(). parseError() is essentially free — it's just property access.

Real-world overhead

For a typical API request that creates a logger, sets context 3 times, and emits:

That's 0.003ms per request — orders of magnitude below any HTTP framework or database overhead.

CI regression tracking

Every pull request that touches packages/evlog/src/ or packages/evlog/bench/ automatically runs benchmarks against the main branch. A comparison report is posted as a PR comment showing:

• ops/sec delta for every benchmark
• p99 latency changes
• Regressions (>10% slower) are flagged with a warning

This ensures performance never silently degrades across releases.

Running benchmarks

# Run all benchmarks with table output
bun run bench

# Export results as JSON
bun run bench:json

# Compare two benchmark runs
bun bench/compare.ts baseline.json current.json

Benchmark files live in packages/evlog/bench/: