Otelite

Lightweight OpenTelemetry receiver and dashboard for local development

Otelite is a single-binary observability tool that receives OpenTelemetry data (logs, traces, metrics) and provides a web dashboard and terminal UI for viewing it. Designed for local LLM development with minimal resource usage (<100MB memory, <5% CPU), it starts in seconds and requires no external dependencies.

Personal project — developed and maintained on a best-efforts basis by @planetf1. Not an official or supported product. Contributions and feedback welcome via GitHub issues and pull requests.

Quick Start

cargo install otelite
otelite serve

That's it. otelite serve starts three services:

• OTLP gRPC receiver on localhost:4317
• OTLP HTTP receiver on localhost:4318
• Web dashboard and REST API on http://localhost:3000

Open http://localhost:3000 in your browser to view telemetry.

Features

• Fast: Starts in <3s, <100MB memory, <5% CPU idle
• Full OTLP Support: Metrics, logs, and traces via gRPC (4317) and HTTP (4318)
• Embedded Storage: SQLite-based, no external database required
• Web Dashboard: View and filter telemetry data at http://localhost:3000
• Terminal UI: Full-featured TUI with otelite tui
• CLI: Query and export data with otelite logs, otelite traces, otelite metrics, otelite usage
• Single Binary: Zero runtime dependencies
• GenAI/LLM support: First-class OTel GenAI semconv — token counts, cache hits, tool calls, model routing

Screenshots

Logs — search, filter by severity, and inspect structured attributes

Traces — waterfall view with span-level timing and GenAI attributes (token counts, cache hits, TTFT)

Metrics — time-series counters and histogram bucket distribution

Usage — GenAI/LLM token and request summary by model and provider

Setup — live endpoint display and copy-paste configuration snippets for every SDK

The web dashboard isn't the only interface — don't miss the Terminal UI (otelite tui) and the CLI (otelite logs, otelite traces, otelite metrics). See the TUI guide and CLI reference for full documentation with examples.

Sending Data

Using otel-cli (easiest for testing)

# Install otel-cli
go install github.com/equinix-labs/otel-cli@latest

# Send a test trace
otel-cli exec --endpoint http://localhost:4318 --protocol http/protobuf -- echo "hello"

Python

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

trace.set_tracer_provider(TracerProvider())
otlp_exporter = OTLPSpanExporter(endpoint="http://localhost:4317", insecure=True)
trace.get_tracer_provider().add_span_processor(BatchSpanProcessor(otlp_exporter))

tracer = trace.get_tracer(__name__)
with tracer.start_as_current_span("my-operation"):
    # Your code here
    pass

Rust

use opentelemetry_otlp::WithExportConfig;

let tracer = opentelemetry_otlp::new_pipeline()
    .tracing()
    .with_exporter(
        opentelemetry_otlp::new_exporter()
            .tonic()
            .with_endpoint("http://localhost:4317")
    )
    .install_batch(opentelemetry_sdk::runtime::Tokio)?;

JavaScript/Node.js

const { NodeSDK } = require('@opentelemetry/sdk-node');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-grpc');

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({ url: 'http://localhost:4317' }),
});
sdk.start();

Go

import (
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
    "go.opentelemetry.io/otel/sdk/trace"
)

exporter, _ := otlptracegrpc.New(ctx,
    otlptracegrpc.WithEndpoint("localhost:4317"),
    otlptracegrpc.WithInsecure(),
)
tp := trace.NewTracerProvider(trace.WithBatcher(exporter))

CLI Usage

# Start the server (foreground)
otelite serve

# Start as background daemon
otelite start

# Stop daemon
otelite stop

# Restart daemon (picks up recompiled binary)
otelite restart

# Check daemon status
otelite status

# List recent logs
otelite logs list --severity ERROR --since 1h

# Search logs
otelite logs search "database timeout"

# List traces with duration filter
otelite traces list --min-duration 1s

# Show trace details
otelite traces show <trace-id>

# List metrics
otelite metrics list --name "http_*"

# Token usage summary (GenAI/LLM)
otelite usage --since 24h
otelite usage --since 7d --by-model

# JSON output for scripting
otelite --format json logs list | jq '.[] | select(.severity == "ERROR")'

See docs/cli-reference.md for the full reference with real example output.

Terminal UI

# Start TUI (connects to localhost:3000 by default)
otelite tui

# Connect to custom API URL
otelite tui --api-url http://localhost:3000

Keyboard shortcuts:

• l / t / m — switch to Logs / Traces / Metrics view
• Tab / Shift+Tab — cycle between views
• ↑ / ↓ or j / k — navigate items
• PgDn / PgUp — page through list / scroll detail panels
• Enter — open detail / span waterfall
• / — search
• f — filter
• ? — help
• q — quit

See docs/tui-quickstart.md for the full guide with ASCII mockups of each view.

REST API

# List logs
curl "http://localhost:3000/api/logs?severity=ERROR&limit=50"

# List traces
curl "http://localhost:3000/api/traces?min_duration_ns=1000000"

# Get trace with spans
curl "http://localhost:3000/api/traces/<trace-id>"

# List metrics
curl "http://localhost:3000/api/metrics?name=http_requests_total"

# Token usage (GenAI/LLM)
curl "http://localhost:3000/api/genai/usage?start_time=<ns>&end_time=<ns>"

# Health check
curl "http://localhost:3000/api/health"

Development

Issues and feature requests are tracked on GitHub Issues.

# Clone and build
git clone https://github.com/planetf1/otelite.git
cd otelite
cargo build --workspace

# Run directly from source
cargo run -p otelite -- serve

# Run tests
cargo test --workspace

# Run quality gates
cargo clippy --workspace --all-targets -- -D warnings
cargo fmt --check

See CONTRIBUTING.md for development workflow and docs/testing.md for testing guide.

Architecture

┌─────────────────────────────────────────────┐
│         Web Dashboard (port 3000)           │
│         + REST API (otelite-api)            │
└─────────────────┬───────────────────────────┘
                  │
┌─────────────────▼───────────────────────────┐
│       SQLite Storage (otelite-storage)      │
│            with FTS5 search                 │
└─────────────────▲───────────────────────────┘
                  │
┌─────────────────┴───────────────────────────┐
│       OTLP Receivers (otelite-receiver)     │
│    gRPC (4317) + HTTP (4318)                │
└─────────────────────────────────────────────┘

Crate structure:

• otelite-core — Domain types (LogRecord, Span, Metric, Resource, GenAiSpanInfo)
• otelite-storage — SQLite backend with async trait
• otelite-receiver — OTLP gRPC and HTTP ingest
• otelite-api — REST API and web dashboard
• otelite-client — HTTP client for the REST API
• otelite-tui — Terminal user interface
• otelite — CLI binary (serve, logs, traces, metrics, usage, tui)

See docs/architecture.md for detailed design.

Performance

Project Status

Current version: 0.1.0 — early release, core features stable. REST API may evolve.

License

Apache License 2.0 — see LICENSE