rustrak is a free, open source monitoring & observability project written in Rust and released under AGPL-3.0. It has 1,534 GitHub stars, 76 forks and 49 open issues, and was last pushed 35 hours ago. On this registry it ranks #197 of 272 tracked projects in Monitoring & Observability, with 5 head-to-head comparisons available.

What is rustrak?

Rustrak is a self-hosted, AGPL-3.0 error tracker written in Rust that speaks the Sentry protocol, giving teams already using the Sentry SDKs error tracking, performance, logs, release health and AI-agent traces in one small container.

What it is

Rustrak is a self-hosted error tracker written in Rust that also ingests logs, transactions, release health data and AI-agent traces. It lives in the Sentry ecosystem in the strict sense that it implements the Sentry protocol rather than a lookalike: an application already instrumented with a Sentry SDK is pointed at Rustrak by changing one string, with no new agent to install and no vendor library to swap. It ships as rustrak/rustrak-server, a single process that answers both the dashboard and the API, with SQLite as the default store.

The problem it addresses is the usual fork in error tracking: a SaaS bill that scales with your worst day, or a self-hosted stack that wants its own machine. Rustrak is the third option, running the same protocol on hardware you already have. Two design decisions carry it. The dashboard is static files that the server hands out, so one small process serves both the API and the UI, and an image built without the dashboard is a complete product on its own. Ingestion is two-phase: the endpoint parses the envelope, writes it to disk and returns 200, and a spawned task then does the database work, so accepting an event never waits on the database and a traffic spike does not become a timeout inside your application.

Key capabilities

  • Accepts the standard Sentry envelope, so migrating is a configuration change rather than a project.
  • Two-phase ingestion: the endpoint parses the envelope, writes it to disk and returns 200 before a spawned task performs the database write.
  • Covers error tracking, logs, transactions, release health and AI-agent traces in one process.
  • Uses SQLite by default, with PostgreSQL available through docker-compose.postgres.yml and the :postgres image.
  • rustrak/rustrak-server serves the dashboard and the API from a single container on port 8080, with no second port to configure.
  • rustrak/rustrak-ui serves the same dashboard behind nginx when the UI must live on a different host from the data.
  • On a 4-core box with SQLite, a burst of 20,000 events is accepted at about 5k events per second with the server peaking under 60 MB of memory.

Who uses it and how

  • Teams already instrumented with a Sentry SDK that want to keep their client code and change only the endpoint string.
  • Small teams running observability on a single box: one compose file, one rustrak_data volume, no broker and no database to provision.
  • Deployments that outgrow SQLite and move to the PostgreSQL compose file and :postgres image.
  • Organisations that need the dashboard on its own host, running rustrak/rustrak-ui behind nginx separately from the data.

Getting started

Rustrak runs from the repository's docker-compose.yml with docker compose up -d, using the rustrak/rustrak-server:latest image after exporting SESSION_SECRET_KEY and a CREATE_SUPERUSER credential in the form admin@example.com:changeme123. No database or broker needs to be provisioned for the default SQLite setup.

How it compares

Sentry is the tool it positions against, and the contrast is the cost model and the footprint: Sentry arrives either as a SaaS bill that scales with your worst day or as a self-hosted stack that wants its own machine, while Rustrak runs the same protocol on hardware you already have, without per-event pricing, seat counts or sampling you did not ask for. It is AGPL-3.0 licensed, so the source is available and modifications carry copyleft obligations.

When to use it — and when not to

Self-hosting means the operator owns the deployment: a container and a persistent volume, the SESSION_SECRET_KEY secret, a PostgreSQL service if SQLite is outgrown, and an nginx front end for rustrak/rustrak-ui if the dashboard is split onto its own host. Teams that want a fully managed service with no operational involvement, or that require a vendor support contract, should choose something else. The AGPL-3.0 licence also matters to anyone who intends to modify Rustrak and distribute it, because those changes must be shared under the same terms.

project readme (upstream, from github) — read inline
Rustrak, self-hosted error tracking: project overview dashboard with errors, sessions and open issues

CI Dashboard E2E Server coverage Client coverage Dashboard coverage Release License Docker pulls Sponsors

Documentation · Quickstart · Roadmap · Changelog · Report a bug

Rustrak is a self-hosted error tracker that also takes logs, transactions, release health and AI-agent traces.

It speaks the Sentry protocol rather than a lookalike of it, so the SDK you already have points at Rustrak by changing one string. No new agent to install, no vendor library to swap, no code to rewrite. It runs as a single process with SQLite by default, which means the whole install is one compose file and nothing to provision.

Rustrak project overview: error trend, new issues and crash-free sessions

Why Rustrak

Error tracking usually comes two ways: a SaaS bill that scales with your worst day, or a self-hosted stack that wants its own machine. Rustrak is the third option: the same protocol, on hardware you already have.

Two design decisions do most of that work. The dashboard is static files the server hands out, so one small process answers both the API and the UI, and an image built without the dashboard is a complete product on its own. And ingestion is two-phase. The endpoint parses the envelope, writes it to disk and returns 200; a spawned task then does the database work. Accepting an event never waits on the database, which is what stops a traffic spike from becoming a timeout inside your app. On a 4-core box with SQLite, a burst of 20,000 events is accepted at about 5k events per second with the server peaking under 60 MB of memory.

Rustrak resource numbers: memory and throughput

No per-event pricing, no sampling you did not ask for, and no seat you have to justify to anyone.

Quickstart

SQLite is the default, so this is the whole install. There is no database to provision and no broker to run.

This is the repository's docker-compose.yml:

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

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

Open and sign in with those credentials. One container answers both the dashboard and the API, so there is no second port and no address to tell one half about the other. Want the dashboard on a different host from your data? rustrak/rustrak-ui is the same dashboard behind nginx; see the production guide.

Running at scale? docker-compose.postgres.yml runs the :postgres image next to a PostgreSQL service. The installation guide has both setups and the production notes.

Point your SDK at it

Rustrak accepts the standard Sentry envelope, so migrating is a configuration change rather than a project. Create a project, copy its DSN, and change one line. Your SDK never learns it is talking to something else.

Sending events to Rustrak with a Sentry SDK DSN
# 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>"})

Any Sentry SDK works, in any language. If you are already sending to Sentry, you can point a second DSN at Rustrak and compare the two before committing.

What's inside

Errors

Events are grouped into issues by a deterministic fingerprint: the one your SDK sent if it sent one, otherwise exception type plus the first line of the message plus the transaction. Same input, same group, every time, so an issue does not split in two after a deploy.

From the list you can triage in bulk, filter by status, and read each issue's 24-hour trend without opening anything. Upload source maps and a minified frame resolves back to the line you actually wrote.

Rustrak issues list

AI agent traces

Turn on your SDK's AI integration and agent runs appear on their own page: runs over time, duration percentiles, top models by calls and by tokens, top tools, and a per-trace waterfall of every LLM call, tool call and handoff in order.

Rustrak reads Sentry's Spans Protocol v2, the batched format the real SDKs use for AI spans, verified against @sentry/node with the Vercel AI SDK. It also takes standalone OTel-style spans that have no parent transaction. When one agent hands off to another mid-run, the trace lists every agent involved, not just the first.

Rustrak AI agent monitoring

There is no server-side setup. One integration in Sentry.init is the whole change:

import * as Sentry from '@sentry/node';

Sentry.init({
  dsn: 'http://<key>@localhost:8080/<project_id>',
  integrations: [Sentry.vercelAIIntegration()],
});

And there is deliberately no spend widget. Per-model pricing goes stale faster than we could ship it, so Rustrak reports exact token counts and leaves the multiplication to you.

Performance

Transactions and spans flow through a processor pipeline onto a performance dashboard, ranked by p95. Latency is coloured against thresholds rather than left as raw numbers: green under a second, amber under three, red beyond. The row that needs attention is the one that looks wrong.

Open a transaction for its span waterfall and its measurements.

Rustrak performance view

Logs

Errors tell you what broke. Logs tell you what your app was doing when it did not. Rustrak stores structured logs as a first-class event type on the same envelope endpoint, with six severities from trace to fatal, their own filter, and per-row attributes that keep their types.

A log emitted inside an active span carries the trace_id, so it links back to the request it came from.

Rustrak structured logs view

Logging is off by default in Sentry SDKs. Opt in once, then use the logger:

Sentry.init({
  dsn: 'http://<key>@localhost:8080/<project_id>',
  enableLogs: true,
});

Sentry.logger.info('User signed up', { userId: 4172, plan: 'pro' });

Release health

Sessions are tracked with full Sentry SDK compatibility and aggregated per release, which turns "is this deploy worse than the last one" into two numbers: crash-free sessions and crash-free users.

Both are tiered rather than printed flat: green at 99% or above, amber at 95%, red below. A release at 96% is not fine and should not read as if it were.

Rustrak releases view

Alerts

Alert rules fire on three events, and each rule chooses its own destination:

Trigger When it fires
new_issue A new issue is detected for the first time
regression A resolved issue reappears
unmute A muted issue is unmuted

Destinations are Slack (incoming webhook or bot token), SMTP email, or a plain JSON webhook. Credentials belong to the instance and are configured once; routing belongs to the rule.

Rustrak alerts view

Teams, storage and retention

Projects carry three roles, Admin, Member and Viewer, with invitations, so a contractor can be given one project and nothing else.

The server also reports its own storage usage and enforces configurable retention, with manual cleanup and source-map garbage collection on demand. That matters more on a self-hosted instance than on a hosted one: nobody else is going to notice the disk filling up.

Getting around

⌘K opens a command bar over any screen. Projects and settings are two fixed sections, with the highlighted project's pages in a preview column, so Enter on a project goes to the project and its pages stay one keystroke away. Typing flattens everything into one relevance-ordered list.

On your phone

The dashboard is a Progressive Web App. Open your Rustrak instance in Safari or Chrome, add it to your home screen, and it launches full screen like a native app, with a bottom tab bar and screens built for touch instead of a shrunken desktop page. There is no app store build and nothing extra to deploy: the phone talks to the same server.

wp-mobile

From code, and from your editor

The REST API has a typed client, and the server has an MCP endpoint built in, so an assistant can triage your instance in the same session it is writing the fix. Turn it on in Settings → AI assistants (MCP) and point Claude, Cursor or any MCP client at https:///mcp with an API token: there is nothing to install. See the MCP guide.

npm install @rustrak/client   # the REST API, typed
Package Version What it is
@rustrak/client npm TypeScript client. Every method returns Result and never throws, so a call that can fail says so in its type

The OpenAPI spec is browsable in the API reference.

Telemetry

The server sends one anonymous report every six hours: version, platform, memory, and counters such as "how many ingests were rejected" or "which routes returned 500". Never IPs, names, URLs, events or messages. It is what lets a memory regression or a new panic show up across installations after a release, and it costs one atomic increment per request.

RUSTRAK_TELEMETRY=off   # or DO_NOT_TRACK=1; either one is enough

Every field is listed in the telemetry page, and GET /api/telemetry/preview shows the exact document before it leaves.

Documentation

Getting started What Rustrak is and how it fits together
Installation Self-hosting, PostgreSQL, production notes
Configuration Every environment variable
API reference Endpoints and schemas
Architecture Two-phase ingestion, grouping, storage

Questions, ideas or something to show? Join GitHub Discussions. Bugs go to Issues.

Contributors

People who have contributed code, translations or documentation to Rustrak.

Rustrak contributors

CONTRIBUTING.md covers the local setup, the test suite and the quality gate. Issues tagged good first issue are a reasonable place to start.

Sponsors

Rustrak has no paid tier and no hosted plan. Development is funded through GitHub Sponsors and Open Collective.

Sponsor Rustrak on GitHub Support Rustrak on Open Collective

License

AGPL-3.0, except @rustrak/client, which is MIT. See LICENSING.md. Copyright © 2026 Abian Suarez.

Frequently asked questions

Is rustrak free to use?

rustrak is open source under the AGPL-3.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does rustrak do?

Self-hosted, open-source Sentry alternative in Rust. Error tracking, performance, logs and AI agent traces in one small container that works with the Sentry SDK

What is rustrak written in?

rustrak is primarily written in Rust. Its source is publicly available at https://github.com/rustrak/rustrak, and it has 1,534 GitHub stars.