Skip to content
@tracewayapp

TracewayApp

🎉 Traceway 2.0 is here. More reliable traces, better OpenTelemetry compatibility, and a clearer picture of your app. Read the V2 release post →

Traceway Logo

Built on OpenTelemetry OpenTelemetry

OpenTelemetry-native observability. Open source. Self-hosted in 90 seconds.

OTel-First MIT License Self-Host Join us on Discord

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.

Traceway Issues Traceway Endpoints

👋 Join the Traceway Community on Discord →
Chat with the team, shape the roadmap, get help, and meet other folks running Traceway in production.

What's in the box

  • 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 on user.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 apply instruments 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.

AI-First

Your agent sets up Traceway, queries production telemetry, and finds the root cause:

npx skills add tracewayapp/skills --all

One command installs all four skills into Claude Code, Cursor, Codex, or any agent that reads SKILL.md:

  • /traceway-setup reads your repo and wires it up: OTel for backends, Traceway SDKs for web and mobile. Then it verifies data actually arrives.
  • /traceway installs the traceway CLI and uses it to query exceptions, logs, endpoints, and metrics, from bug report to root cause.
  • /traceway-learn is 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-write teaches 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 →

Claude Code fixing a production issue from a Traceway error, end to end

Symbolication

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

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.

Web Performance dashboard with Core Web Vitals from real browser visits

Two things make it different from RUM tools that upload everything and then sample to keep the bill down:

  1. 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.
  2. 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, which is in beta: npm install @tracewayapp/frontend@beta.

RUM guide · Best practices · Product page

Why Traceway

Enterprise (Datadog / New Relic) DIY OSS stack (Prometheus + Loki + Tempo + ...) Traceway
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

Quick Start

Self-host with Docker (recommended)

git clone https://github.com/tracewayapp/traceway
cd traceway && docker compose up -d
# ✓ dashboard at http://localhost

Point 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.

Embedded mode (inside your Go app)

Run Traceway inside your Go process. No Docker, no external databases, SQLite under the hood:

go get github.com/tracewayapp/traceway/backend/v2
import 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 Cloud (nothing to run)

Sign up for Traceway Cloud if you would rather not run it yourself. It is the same MIT code, run by us.

Supported Integrations

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.

Backend

OpenTelemetry is the integration path for every backend language. Point your OTLP exporter at Traceway and you are done.

OpenTelemetry
OpenTelemetry
Node.js
Node.js
NestJS
NestJS
Next.js
Next.js
Hono
Hono
Cloudflare Workers
Cloudflare
Symfony
Symfony
Laravel
Laravel
Django
Django

Go applications use OpenTelemetry too. Point opentelemetry-go at the same OTLP endpoint. See the OpenTelemetry guide.

Frontend

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
React
Vue
Vue
Svelte
Svelte
jQuery
jQuery
JavaScript
JavaScript

Mobile

Flutter
Flutter
Android
Android
iOS
iOS
React Native
React Native

AI

OpenRouter
OpenRouter

Screenshots

Logs: trace-linked search
Logs
Span waterfall
Spans
Metrics: application dashboard
Metrics
Exceptions: fingerprinted & ranked
Exceptions

Tech Stack

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

Project Structure

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

Build Tags

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

Running Tests

# 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 -update

Documentation

Full 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

Community

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

Join the Traceway Community on Discord

Contribute

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.

Links


MIT-licensed. Built with OpenTelemetry · ClickHouse · Go · SvelteKit.

Popular repositories Loading

  1. traceway traceway Public

    The only tool you need to know what is happening and how to fix it.

    Go 1.8k 96

  2. opentelemetry-symfony-bundle opentelemetry-symfony-bundle Public

    Pure-PHP OpenTelemetry instrumentation for Symfony: HTTP, Console, Messenger, Doctrine DBAL, Cache, Twig, Mailer, Scheduler, HttpClient, Guzzle and PSR-18, plus metrics and Monolog logs. Stable sem…

    PHP 86 8

  3. traceway-flutter traceway-flutter Public

    Full session replays for your flutter app. Efficient recording across Android, iOS and web. Compatible with Traceway.

    Dart 15 3

  4. lit lit Public

    A small library for mapping between queries and structs.

    Go 14 3

  5. traceway-otel-agent traceway-otel-agent Public

    A small, opinionated OpenTelemetry Collector distribution. One binary, sensible defaults, works with Traceway or any OTLP backend.

    Shell 6

  6. go-client go-client Public

    The go client for the Traceway

    Go 4 2

Repositories

Showing 10 of 14 repositories

People

This organization has no public members. You must be a member to see who’s a part of this organization.

Top languages

Loading…