ZenoLog — Lean, In-Memory, OTel-Native Log Buffer

17 MB

Container Image

<100 ms

Startup Time

0

Disk Required

1

Single Binary

The Problem

Your Observability Stack Costs More Than Your App

You just want to see your logs. But the industry says you need a cluster for that.

Heavy

ELK needs 3+ pods, 2 GB RAM minimum, and 50 GB disk before you see a single log line.

Expensive

Cloud logging charges per GB ingested. A medium cluster can cost more than the compute it monitors.

Complex

Loki needs object storage. Elasticsearch needs tuning. Fluentd needs configuration. All before day one.

ZenoLog: 1 pod, 15 MB RAM, 0 disk, 0 configuration.

ZERO-INFRASTRUCTURE OBSERVABILITY

Everything You Need. Nothing You Don't.

ZenoLog replaces your entire log-viewing stack with a single binary. Native OpenTelemetry ingestion, Kubernetes container log discovery, in-memory ring buffers, full-text search, live tail, trace correlation — and both a Web UI and Terminal UI baked right in.

Native OTLP ingestion

K8s container log discovery

Per-source ring buffers

Full-text search

WebSocket live tail

Trace correlation

Auto severity detection

Built-in Web UI

Terminal UI (TUI)

Prometheus metrics

Source management

See It In Action

Two Interfaces. One Binary.

A full-featured Web UI and a keyboard-driven Terminal UI — both shipped inside the same 17 MB binary.

Web UI — Search

Web UI — Live Tail

Web UI — Trace View

ZenoLog Web UI trace correlation view showing all logs for a single trace ID

Web UI — Sources

Terminal UI — Live Tail

ZenoLog Terminal UI (TUI) with Bubble Tea live tail view

Since 0.2

Native Kubernetes Integration

Two log paths into one buffer. OTLP SDKs and K8s container stdout — side by side.

Path 1

OTLP SDK

Your apps send structured OTel log records with trace IDs, severity, and attributes via gRPC or HTTP. Full fidelity.

Structured

+

Path 2

K8s Container Logs

ZenoLog discovers pods automatically, resolves owner chains (Deployment, StatefulSet, DaemonSet, CronJob), and streams container stdout/stderr via the K8s API.

Auto-discovered

Passive Discovery

Shared informers watch all namespaces. Pods appear in the catalog as they're created — no configuration needed.

Manual Activation

You choose which sources to stream. Activate with specific containers via the Web UI, TUI, or API. No surprise bandwidth.

Severity Detection

Automatically parses [INFO], [ERROR], level=warn, and other common patterns from plain-text container logs.

Owner Resolution

Pods are grouped by their owner chain: Pod → ReplicaSet → Deployment. Source key: namespace~owner.

How It Fits Together

ZenoLog architecture: OTLP and K8s container logs flowing through Ingestor to Ring Buffer to API and Web UI

New

Azure Container Apps Discovery

Auto-discover your ACA apps and stream container logs — no code changes, no agents to install.

Azure Container Apps abstracts away Kubernetes, which means you lose kubectl logs. ZenoLog brings that visibility back by discovering your apps via the Azure Resource Manager API and streaming container logs in real time.

Deploy ZenoLog as a Container App in the same environment, assign a Managed Identity, and every app in your environment appears automatically.

View ACA Setup Guide

Features

Built for Real Workflows

Every feature designed around how engineers actually debug.

Native OTLP Ingestion

Dual-protocol OpenTelemetry receivers. Point your existing OTel SDKs and they just work.

gRPC on :4317
HTTP/protobuf on :4318
Zero configuration

Per-Source Ring Buffers

Automatic per-service isolation with dual-limit eviction. No noisy neighbor problems.

Count + byte eviction
Configurable per source
Up to 100 sources

Severity Filtering & Sampling

Per-source severity thresholds with probabilistic sampling. Control what you keep.

Per-source thresholds
Probabilistic sampling
Enable/disable on the fly

Full-Text Search

Instant search across all buffered logs with rich filtering. Find the needle in real time.

Source, severity, body text
Time range filtering
Trace ID lookup

WebSocket Live Tail

Real-time log streaming as events arrive. Watch your services in real time.

Source + severity filters
Fan-out architecture
Sub-millisecond delivery

Trace Correlation

Click any trace ID to see every log from that transaction, across all services.

Cross-service correlation
Trace ID indexing
One-click drill-down

Embedded Web UI

Full-featured SvelteKit dashboard compiled into the binary. No separate frontend to deploy.

Search & filter logs
Live tail streaming
Source management

Terminal UI

Bubble Tea TUI for terminal-native workflows. SSH into a box and inspect logs instantly.

Search, tail, traces, sources
Keyboard-driven navigation
Toggle & delete sources

Kubernetes Discovery

Auto-discover pods via shared informers. Activate container log streaming with one click.

Automatic pod discovery
Owner chain resolution
Severity auto-detection

Azure Container Apps

Discover ACA apps via ARM API. Stream container logs with Managed Identity auth. No agents required.

Poll-based app discovery
Managed Identity auth
Side-by-side with K8s

Comparison

Measured. Not Marketing.

Real resource consumption compared to popular alternatives.

ZenoLog

Grafana Loki

ELK Stack

Container Image

ZenoLog

17 MB

Loki

65 MB

ELK

900 MB

Memory (idle)

ZenoLog

15 MB

Loki

512 MB

ELK

2 GB

Memory (10 services)

ZenoLog

~150 MB

Loki

~1 GB

ELK

~3 GB

Disk Required

ZenoLog

None

Loki

10 GB+

ELK

50 GB+

Startup Time

ZenoLog

<100 ms

Loki

~5 s

ELK

~30 s

Pods (Kubernetes)

ZenoLog

1

Loki

2–3

ELK

3–5

Metric	ZenoLog	Loki	ELK
Container Image	17 MB	65 MB	900 MB
Memory (idle)	15 MB	512 MB	2 GB
Memory (10 services)	~150 MB	~1 GB	~3 GB
Disk Required	None	10 GB+	50 GB+
Startup Time	<100 ms	~5 s	~30 s
Pods (Kubernetes)	1	2–3	3–5
External Dependencies	None	Object storage	JVM, storage

Loki and ELK measurements based on minimal single-node deployments with default configuration.

Architecture

How It Works

Four stages from source to screen — all in one process.

1

Ingest

OTel SDKs send logs via OTLP gRPC/HTTP. K8s container logs are streamed via the pods/log API. Both paths feed the same pipeline.

2

Filter

Per-source severity thresholds and probabilistic sampling decide what to keep. Drop noise before it enters the buffer.

3

Buffer

Per-source circular ring buffers with dual-limit eviction (count + bytes). Old logs fall off automatically.

4

View

Search, live tail, and trace correlation via the REST API — rendered in the Web UI or Terminal UI.

Port Map

:4317

OTLP gRPC

:4318

OTLP HTTP

:8080

Health Probes

:8081

API + Web UI

Deploy

Deploy in Seconds

Choose your path — all roads lead to logs.

Docker

Fastest path. Pull and run.

docker run -d \
  -p 4317:4317 \
  -p 4318:4318 \
  -p 8080:8080 \
  -p 8081:8081 \
  jimmytoenners/zenolog:0.3.4

Kubernetes

Single-pod deployment with optional K8s log discovery.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: zenolog
spec:
  replicas: 1
  selector:
    matchLabels:
      app: zenolog
  template:
    metadata:
      labels:
        app: zenolog
    spec:
      serviceAccountName: zenolog
      containers:
      - name: zenolog
        image: jimmytoenners/zenolog:0.3.4
        env:
        - name: ZENOLOG_K8S_ENABLED
          value: "true"
        ports:
        - containerPort: 4317
        - containerPort: 4318
        - containerPort: 8080
        - containerPort: 8081
        resources:
          requests:
            cpu: 50m
            memory: 128Mi
          limits:
            cpu: 500m
            memory: 512Mi
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8080
        readinessProbe:
          httpGet:
            path: /readyz
            port: 8080

Binary

Single static binary. No runtime dependencies.

# Download
curl -L -o zenolog \
  https://get.zenolog.dev/latest

chmod +x zenolog

# Run
./zenolog

# Open Web UI
open http://localhost:8081

# Or use the TUI
./zenolog tui

Point Your OTel SDKs — That's It

Works with any language. Here's .NET as an example.

// .NET — Program.cs
builder.Logging.AddOpenTelemetry(otel =>
{
    otel.SetResourceBuilder(ResourceBuilder.CreateDefault()
        .AddService("my-service"));
    otel.AddOtlpExporter(o =>
    {
        o.Endpoint = new Uri("http://localhost:4318/v1/logs");
        o.Protocol = OtlpExportProtocol.HttpProtobuf;
    });
});

// That's it. Logs appear in ZenoLog instantly.

Configuration

Configure via Environment

Sensible defaults. Override what you need.

Variable	Default	Description
ZENOLOG_GRPC_ADDR	:4317	OTLP gRPC receiver address
ZENOLOG_HTTP_ADDR	:4318	OTLP HTTP receiver address
ZENOLOG_HEALTH_ADDR	:8080	Health / readiness endpoint
ZENOLOG_API_ADDR	:8081	API + Web UI address
ZENOLOG_MAX_SOURCES	100	Maximum number of distinct sources
ZENOLOG_RING_CAP	10000	Ring buffer record capacity per source
ZENOLOG_RING_MAX_BYTES	10485760	Ring buffer byte limit per source (10 MB)
ZENOLOG_SOURCE_RATE_LIMIT	10	Max new sources per minute (0 = unlimited)
ZENOLOG_CORS_ORIGINS	*	Comma-separated CORS allowed origins
ZENOLOG_K8S_ENABLED	false	Enable K8s pod discovery (`true`, `auto`, `false`)
ZENOLOG_K8S_LOG_SINCE	5m	How far back to read on stream activation
ZENOLOG_K8S_MAX_STREAMS	100	Max concurrent container log streams

Pricing

Simple Pricing

Free forever. No credit card, no limits, no catch.

FREE FOREVER

Free Forever

Full feature set. No limits. No catch.

All OTLP ingestion protocols
Kubernetes + Azure Container Apps discovery
Unlimited sources & ring buffers
Full-text search & live tail
Trace correlation
Web UI + Terminal UI
Prometheus metrics

Get Started

Ready to See Your Logs?

Deploy ZenoLog in seconds. Point your OTel SDKs. Open the Web UI. That's the entire setup.

Get Started Now

See Everything.Deploy Nothing.

Your Observability Stack Costs More Than Your App

Heavy

Expensive

Complex

Everything You Need. Nothing You Don't.

Two Interfaces. One Binary.

Native Kubernetes Integration

OTLP SDK

K8s Container Logs

Passive Discovery

Manual Activation

Severity Detection

Owner Resolution

How It Fits Together

Azure Container Apps Discovery

Built for Real Workflows

Native OTLP Ingestion

Per-Source Ring Buffers

Severity Filtering & Sampling

Full-Text Search

WebSocket Live Tail

Trace Correlation

Embedded Web UI

Terminal UI

Kubernetes Discovery

Azure Container Apps

Measured. Not Marketing.

How It Works

Ingest

Filter

Buffer

View

Port Map

Deploy in Seconds

Docker

Kubernetes

Binary

Point Your OTel SDKs — That's It

Configure via Environment

Simple Pricing

Ready to See Your Logs?

See Everything.
Deploy Nothing.