π Traceway 2.0 is here. More reliable traces, better OpenTelemetry compatibility, and a clearer picture of your app. Read the V2 release post β
Website Β· Docs Β· Cloud Β· Discord
Traceway is an OpenTelemetry-native observability platform. It combines logs, traces, metrics, real user monitoring (RUM) with session replay, exceptions, AI tracing, and on-call paging in one place. Point an OTLP exporter at it and you're in business. No Collector, no glue code, no per-language vendor SDK.
MIT licensed. No BSL. No "open core." Every feature is in the box. Self-host it for free, or run it on Traceway Cloud if you'd rather not babysit infra.
π Join the Traceway Community on Discord β
Chat with the team, shape the roadmap, get help, and meet other folks running Traceway in production.
- Logs: Structured, trace-linked, sub-second search. Native OTLP/HTTP ingest from any OTel SDK.
- Traces: End-to-end span waterfalls across every service. Click a log, jump to its span.
- Endpoints: Per-route latency percentiles (P50/P95/P99), throughput, and error rate, ranked by Apdex and a 5-factor impact score.
- Metrics: Host, runtime, and custom metrics. Any dimension, any chart, with custom widget groups.
- Exceptions: Stack traces are normalized, given a SHA-256 fingerprint, and grouped into ranked issues. Source-mapped (webpack, esbuild, Vite).
- Profiling (experimental): Flame graphs for CPU, heap, and goroutines with version-to-version diffing and a top-functions table. Ingests native Go pprof and OTLP profiles.
- Real User Monitoring: How fast your site is for real visitors, which release made it slower, and who was affected. Core Web Vitals from every visit, release regression alerts and frontend SLOs. More below.
- Session Replay: Watch what the user did right before the error. Available for web (any JS framework) and Flutter.
- AI Observability: LLM cost, tokens, latency, and full conversations across providers (OpenRouter and any OTel-compatible AI gateway). Calls group into conversations via
gen_ai.conversation.id, tool calls are parsed from completions and rendered in the chat view, and multi-language content flagging catches conversations containing terms you care about. Per-customer analytics (conversation length, cost per conversation) key onuser.id: set it to a stable customer identifier such as your account or tenant id, the same value across all of that user's conversations, never a session id. - On-Call & Paging: Rotation schedules with layers and overrides, escalation policies, and pages that escalate until someone acknowledges. Delivered via email, Slack, Pushover, Telegram, or SMS, with one-click acknowledge links that need no login.
- SLOs: Service level objectives over any indicator Traceway already stores: endpoint availability or latency, any span filter (a queue consumer, an outbound call), task success, monitor uptime, a metric held under a limit per time slice, or crash-free sessions for browser and mobile projects. Rolling 7, 30 or 90 day windows, an error budget, burn rates, and multi-window burn-rate alerts with recovery notices, all computed from precomputed buckets rather than raw scans.
- Fleet Overview: One organization-wide page above every project: each reporting instance with live CPU, memory, disk and network, plus issues, monitors and open pages across all projects. Kubernetes nodes group by cluster, and a single
kubectl applyinstruments a whole cluster.
Plus: background-task (job) monitoring, configurable alerts (Slack / GitHub / email / webhook / Pushover / Telegram), multi-tenant orgs with role-based access, and a per-endpoint slow-threshold override.
Your agent sets up Traceway, queries production telemetry, and finds the root cause:
npx skills add tracewayapp/skills --allOne command installs all four skills into Claude Code, Cursor, Codex, or any agent that reads SKILL.md:
/traceway-setupreads your repo and wires it up: OTel for backends, Traceway SDKs for web and mobile. Then it verifies data actually arrives./tracewayinstalls thetracewayCLI and uses it to query exceptions, logs, endpoints, and metrics, from bug report to root cause./traceway-learnis the full guide to the product: issues, endpoints, traces, logs, metrics, monitors, status pages, alerts, on-call schedules and paging, and settings. Ask it how anything in Traceway works./traceway-writeteaches an agent to make routine on-call changes safely. It does nothing until you opt in to agent write access (below).
The CLI is designed for agents first: JSON when piped, tables on a TTY, stable error identifiers and exit codes, --fields to trim responses. It's read only. Nothing hangs, nothing gets damaged.
Want the agent to act too? Agent write access is opt-in at three levels: a write credential (the separate traceway-write CLI, a tww_ token, or the /mcp/write server), an organization admin switch, and the creator's own role. Then an agent can archive issues, acknowledge pages, snooze alerts, run monitors and write post-mortems, and every write lands in an audit log. In Claude Code the traceway-write skill is its own plugin (plugins/tw-write). Learn more β
The skills are plain Markdown in skills/, MIT-licensed like the rest of Traceway, and every release publishes them to tracewayapp/skills, the small repo you install from. No lock-in. Learn more β
app.min.js:1:63 tells you nothing. Traceway resolves minified production errors back to the original file, line, and function the moment they arrive. The same engine handles stripped and obfuscated mobile crashes: iOS and Swift against the build's dSYM, Android against its R8 mapping.txt, Dart and Flutter against their obfuscation map.
The symbolicator is pure Go and built to keep up with ingest. Every debug artifact (a source map, a dSYM, an R8 mapping) compiles once into a binary .tw file and is memory-mapped from disk. Opening a compiled map takes under a microsecond, p99 lookup stays under a millisecond on a cold cache, and no map is re-parsed after a restart. The corpus is a disk budget, not a RAM budget.
The same engine ships as a standalone OpenTelemetry Collector processor, drop-in compatible with Honeycomb's source_map_symbolicator: same component type, same attribute contract, same config keys. Use it in your own pipeline, with or without Traceway behind it.
Upload source maps from CI with npx traceway-sourcemaps --directory ./dist; dSYMs and R8 mappings post to the same endpoint. Benchmarks live in benchmarks/; run them on your fork. Learn more β
Real User Monitoring (RUM) shows how your site works for the people using it: how fast pages load and react, which errors happen, and what a user did right before something broke. Add the browser SDK to a React, Vue, Svelte, jQuery or plain JavaScript app and you get:
- A Web Performance dashboard, set up when you create the project. It shows the Core Web Vitals (how long the main content takes to appear, how fast the page reacts to a click, how much the layout jumps around), split by page, release, browser, device and country.
- Release regression alerts and frontend SLOs. Get told once when a new release is slower than the one before it, and set a target such as "95% of clicks respond within 200 ms".
- Errors with their history. Every error arrives with up to 10 minutes of the clicks, requests and console output before it, and a 30 second replay of what the user saw.
- Captures and recording triggers. When one customer reports a problem, ask their browser for its recent history. Or describe a situation, such as three failed requests within a minute, and have it recorded when it happens.
- Remote settings. Change what browsers collect from the dashboard, for everyone or for one release, without shipping a build.
Two things make it different from RUM tools that upload everything and then sample to keep the bill down:
- Every visit is measured. Each browser adds up its own page timings and sends one small summary, so nobody is left out of the numbers. What is stored grows with your pages and releases, not with your visitors.
- Details stay in the browser until they are needed. The last 10 minutes of activity and the page recording are kept in a ring buffer on the device. They are uploaded when an error happens, when a trigger matches, or when you start a capture. A visit with no problems never uploads them.
The browser SDK is OpenTelemetry: it sends standard OTLP logs, traces and metrics and gets its settings over OpAMP, so a click in the browser and the backend work behind it show up as one trace. RUM needs the 2.x browser SDK: npm install @tracewayapp/frontend.
RUM guide Β· Best practices Β· Product page
| Enterprise (Datadog / New Relic) | DIY OSS stack (Prometheus + Loki + Tempo + ...) | Traceway | |
|---|---|---|---|
| Pricing | Per-event, per-host, per-seat | Free + ops time | Self-host free, fixed cloud tiers |
| Setup | Vendor SDK per language | Glue 6 tools together | docker compose up -d |
| License | Proprietary | Mixed (some BSL / open-core) | MIT, no asterisks |
| OTel | Wrapped in vendor SDK | OTel Collector required | Native OTLP/HTTP ingest |
| Replay + traces + AI | 3 separate products | Wire it yourself | One system, one trace ID |
git clone https://github.com/tracewayapp/traceway
cd traceway && docker compose up -d
# β dashboard at http://localhostPoint any OTel SDK at http://localhost/api/otel/v1/traces (or /metrics, /logs) and traces start flowing. See the self-hosting docs for production deployment, TLS, and storage configuration.
Prefer a single container with no external databases? The SQLite image is the smallest deployment. The DuckDB image keeps the same zero-dependency setup but adds a columnar telemetry store for far more dashboard headroom. Run either with docker compose -f docker-compose.sqlite.yml up -d or -f docker-compose.duckdb.yml.
Docker images are cryptographically signed with Cosign.
Run Traceway inside your Go process. No Docker, no external databases, SQLite under the hood:
go get github.com/tracewayapp/traceway/backend/v2import tracewaybackend "github.com/tracewayapp/traceway/backend/v2"
func main() {
go tracewaybackend.Run(
tracewaybackend.WithPort(8082),
tracewaybackend.WithDefaultUser("admin@localhost.com", "admin"),
tracewaybackend.WithDefaultProject("My App", "opentelemetry", "dev-token"),
)
// ... start your app, point its OTel exporter to http://localhost:8082/api/otel/v1/traces
}Open http://localhost:8082, log in, and hit your app to see traces appear. Full walkthrough in the embedded mode guide, or check the working example.
Traceway integrates with the tools you already use. Backends report over OTLP/HTTP, so any OpenTelemetry SDK works. Browser and mobile apps use the Traceway SDKs.
View the full list in the documentation. Missing a framework? Open an issue to request it.
OpenTelemetry is the integration path for every backend language. Point your OTLP exporter at Traceway and you are done.
OpenTelemetry |
Node.js |
NestJS |
Next.js |
Hono |
Cloudflare |
Symfony |
Laravel |
Django |
Go applications use OpenTelemetry too. Point opentelemetry-go at the same OTLP endpoint. See the OpenTelemetry guide.
Session Replay is included with every frontend integration, and with Flutter too.
A full-stack framework has two halves and two Traceway projects. Next.js and Remix use the React integration below for the browser, SvelteKit uses Svelte, and Nuxt uses Vue. Their server half is a separate OpenTelemetry project from the table above. See Project Structure.
React |
Vue |
Svelte |
jQuery |
JavaScript |
Flutter |
Android |
iOS |
React Native |
OpenRouter |
| Logs: trace-linked search |
Span waterfall |
| Metrics: application dashboard |
Exceptions: fingerprinted & ranked |
| Component | Technology |
|---|---|
| Backend | Go 1.26, Gin |
| Frontend | SvelteKit 2, Svelte 5, Tailwind CSS v4 |
| Telemetry DB | ClickHouse (standalone), SQLite or DuckDB (embedded) |
| Relational DB | PostgreSQL (standalone) or SQLite (embedded) |
| Ingest | OTLP/HTTP (Protobuf + JSON) for traces, metrics, logs |
| Directory | Description |
|---|---|
backend/ |
Go/Gin API server: OTLP ingest, REST API, notifications, migrations |
frontend/ |
SvelteKit 2 dashboard SPA |
cli/ |
Agent-first traceway command line for querying exceptions, logs, endpoints, and metrics |
skills/ |
Agent skills (/traceway-setup, /traceway, /traceway-learn) for Claude Code, Cursor, Codex, and any SKILL.md-compatible agent |
docs/ |
Documentation site (Nextra) |
examples/ |
Working examples: embedded mode and OTel-instrumented apps (Express, NestJS, Next.js, Hono) |
website/ |
Landing page |
Storage is selected on two axes: the telemetry store and the transactional (relational) store.
| Tag | Purpose |
|---|---|
| (none) | SQLite storage on both axes: embedded mode, zero dependencies. This is the default. |
telemetry_duckdb |
DuckDB telemetry store: embedded mode with a columnar engine. Requires CGO_ENABLED=1. |
transactional_pg telemetry_ch |
ClickHouse (telemetry) + PostgreSQL (config) for standalone server mode. |
localdist |
Embeds frontend from static/dist/ instead of static/frontend/. Used by traceway-cloud to inject billing UI. |
# Embedded mode (SQLite, default)
cd backend && go build ./cmd/traceway
# Embedded mode with DuckDB telemetry
cd backend && CGO_ENABLED=1 go build -tags telemetry_duckdb ./cmd/traceway
# Standalone server (ClickHouse + PostgreSQL)
cd backend && go build -tags "transactional_pg telemetry_ch" ./cmd/traceway# SQLite tests (default, no tags needed)
cd backend && go test -v -count=1 ./app/repositories/...
# ClickHouse + PostgreSQL tests (requires Docker)
./scripts/test-backend-pgch.sh
# DuckDB telemetry tests
cd backend && CGO_ENABLED=1 go test -tags telemetry_duckdb -v -count=1 ./app/repositories/...
# OTEL trace converter tests (no DB required)
cd backend && go test -v -count=1 ./app/controllers/otelcontrollers/
# Update OTEL golden files after intentional converter changes
cd backend && go test -v -count=1 ./app/controllers/otelcontrollers/ -args -updateFull documentation at docs.tracewayapp.com:
- Client SDKs: OpenTelemetry, Go, Node.js, Python, and more
- Self-Hosting: Docker Compose and production deployment
- Concepts: How tracing, exception fingerprinting, metrics, and alerts work
- Real User Monitoring: Page speed, sessions, replay and errors from real visitors, plus best practices for setting up a frontend app
- Embedded Mode: Run Traceway inside your Go app
- Kubernetes: Instrument a whole cluster with the manifests in
examples/kubernetes - Organization Overview: Servers, issues, monitors, and on-call pages across every project, one sidebar click apart
- SLOs: Objectives, error budgets and burn-rate alerting over endpoints, spans, tasks, monitors, metrics and crash-free sessions
Traceway is built in the open, and the Discord community is where it happens. Come say hi, whether you're kicking the tires, running it in production, or just curious. We use it to:
- π£οΈ Talk through ideas: feature requests, integration asks, roadmap input
- π Help each other out: setup, OTel wiring, deployment questions
- π Show & tell: share what you're building and how you're using Traceway
- π Catch bugs early: report issues and get fast feedback from maintainers
- π Get the inside scoop: sneak peeks at what's shipping next
Contributions are welcome. Pull requests get reviewed and merged. If you're not sure where to start or want to discuss an idea first, open an issue or drop by the community Discord and we'll talk it through.
- Website
- Documentation
- Traceway Cloud: managed hosting (same MIT code, run by us)
- Community Discord: chat with the team and other users