Rustrak

Ultra-lightweight, self-hosted error tracking compatible with Sentry SDKs

Documentation · Report Bug · Request Feature

---

Why Rustrak?

Most error tracking solutions are either expensive SaaS products or heavy self-hosted applications. Rustrak is different:

• Sentry Compatible - Works with any existing Sentry SDK (Python, JavaScript, Go, Rust, etc.)
• Lightweight - Server runs with ~50MB memory footprint
• Fast - <50ms P99 ingestion latency, 10k+ events/second
• Simple - Single binary, no Redis or complex infrastructure
• Flexible - SQLite (zero setup) or PostgreSQL (production scale)

Quick Start

SQLite (default — no external database)

The default image uses SQLite. No PostgreSQL needed.

services:
  server:
    image: abians7/rustrak-server:latest
    ports:
      - "8080:8080"
    volumes:
      - rustrak_data:/data
    environment:
      - SESSION_SECRET_KEY=${SESSION_SECRET_KEY}
      - CREATE_SUPERUSER=${CREATE_SUPERUSER}
    restart: unless-stopped

  ui:
    image: abians7/rustrak-ui:latest
    ports:
      - "3000:3000"
    environment:
      - RUSTRAK_API_URL=http://server:8080
    depends_on:
      - server
    restart: unless-stopped

volumes:
  rustrak_data:

SESSION_SECRET_KEY=$(openssl rand -hex 32)
CREATE_SUPERUSER=admin@example.com:changeme123
docker compose up -d

Open http://localhost:3000 and login with your CREATE_SUPERUSER credentials.

PostgreSQL (production)

Use the :postgres image tag when you need PostgreSQL.

1. Create docker-compose.yml

services:
  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
      interval: 5s
      timeout: 5s
      retries: 5
    restart: unless-stopped

  server:
    image: abians7/rustrak-server:postgres
    ports:
      - "${SERVER_PORT}:8080"
    environment:
      - HOST=0.0.0.0
      - PORT=8080
      - RUST_LOG=${RUST_LOG}
      - DATABASE_URL=postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
      - SESSION_SECRET_KEY=${SESSION_SECRET_KEY}
      - CREATE_SUPERUSER=${CREATE_SUPERUSER}
    depends_on:
      postgres:
        condition: service_healthy
    restart: unless-stopped

  ui:
    image: abians7/rustrak-ui:latest
    ports:
      - "${UI_PORT}:3000"
    environment:
      - RUSTRAK_API_URL=${RUSTRAK_API_URL}
    depends_on:
      - server
    restart: unless-stopped

volumes:
  postgres_data:

2. Create .env file

# Database
POSTGRES_USER=rustrak
POSTGRES_PASSWORD=rustrak
POSTGRES_DB=rustrak

# Server
SERVER_PORT=8080
RUST_LOG=info
SESSION_SECRET_KEY=<run: openssl rand -hex 32>
CREATE_SUPERUSER=admin@example.com:changeme123

# Dashboard
UI_PORT=3000
RUSTRAK_API_URL=http://server:8080

3. Start Rustrak

docker compose up -d

Open http://localhost:3000 and login with your CREATE_SUPERUSER credentials

Connect Your App

Create a project in the UI, copy your DSN, and add it to your application:

# Python
import sentry_sdk
sentry_sdk.init(dsn="http://<key>@localhost:8080/<project_id>")

// JavaScript
import * as Sentry from "@sentry/browser";
Sentry.init({ dsn: "http://<key>@localhost:8080/<project_id>" });

// Go
sentry.Init(sentry.ClientOptions{Dsn: "http://<key>@localhost:8080/<project_id>"})

Works with any Sentry SDK - no code changes needed if you're migrating from Sentry.

Architecture

┌─────────────────┐     ┌─────────────────┐     ┌──────────────┐
│   Sentry SDK    │────▶│  Rustrak Server │────▶│  PostgreSQL  │
│   (your app)    │     │   (Rust/Actix)  │     │              │
└─────────────────┘     └─────────────────┘     └──────────────┘
                               │
                               ▼
                        ┌─────────────┐
                        │  Rustrak UI │
                        │  (Next.js)  │
                        └─────────────┘

Component	Tech	Purpose
Server	Rust + Actix-web	API & event ingestion
UI	Next.js 16	Dashboard
Database	SQLite or PostgreSQL	Storage

Docker Images

Available on Docker Hub:

docker pull abians7/rustrak-server         # SQLite (default)
docker pull abians7/rustrak-server:postgres # PostgreSQL
docker pull abians7/rustrak-ui

Image	Tag	Size	Description
rustrak-server	latest, vX.Y.Z	~20MB	SQLite backend (no external DB)
rustrak-server	postgres, vX.Y.Z-postgres	~20MB	PostgreSQL backend
rustrak-ui	latest, vX.Y.Z	~50MB	Next.js dashboard

Development

# Prerequisites: Rust, Node.js 20+, pnpm, Docker

# Install dependencies
pnpm install

# Start PostgreSQL
docker-compose -f docker-compose.dev.yml up -d postgres

# Run server (terminal 1)
cd apps/server && cargo run

# Run UI (terminal 2)
cd apps/webview-ui && pnpm dev

API Reference (OpenAPI spec)

The interactive API explorer is served by the server at /docs when built with the openapi feature, and is also embedded in the documentation site.

The spec file must be regenerated and committed whenever the API changes (new endpoints, changed request/response shapes, added parameters):

cd apps/server
cargo run --bin gen_openapi --features openapi
git add openapi.json
git commit -m "chore(openapi): update spec"

The docs site copies the spec automatically at build time — apps/docs/public/openapi.json is not committed.

Documentation

Full documentation is available at docs

• Getting Started
• Configuration
• API Reference
• Self-Hosting Guide

Contributing

Contributions are welcome! Please read our Contributing Guide before submitting a PR.

# Run tests
pnpm test

# Run linter
pnpm lint

# Format code
pnpm format

License

GPL-3.0 License - see LICENSE for details.