Traceway: MIT-licensed observability stack you can self-host in ~90s

There's a few contenders in self-hostable otel:

- ClickStack (ex HyperDX) - SigNoz - Traceway - a few more

does someone has enough feedback on those to be able to tell which one works best?

I was looking into this just yesterday. So the Loki + … comparison is a bit off in the Open Source space. The main ones are Signoz and ClickStack in this space. Both using ClickHouse as the database. Heavy compared to something like Loki, but they are OTEL native and not log monitoring. So not in the same category.

Funny, the first thing I look for for infra projects like these is to find out if it's written in Go. At that point, my confidence level is increased.

I used Signoz + Clickstack on a vibe coded Go server project a few weeks ago. I just made codex figure out how to setup signoz + dependencies via docker compose. I even got it to pre-populate signoz with dashboards. It wasn't too bad. The whole thing runs with a few GB. I tried to cover metrics, tracing, and logging at the same time. This is not a production ready setup but you need to trade off cost vs. utility here. If it's useful enough, that could justify extra cost.

I have a background in having done a lot of stuff on the Elastic stack related to this; including setting up a big Elastic Fleet based stack for one client at some point. It might not be the cheapest, but it does provide awesome filtering and querying capabilities. However, a lot of teams that use it don't really know how to tap into that capability so it tends to be overengineered for what it does in the end. And the extra, underutilized complexity is why a lot of teams are wary of dealing with that stack.

Storing the data is the easy part but what's the point if you can't run queries against it and produce dashboards and diagnostic tools that actually help you? Prometheus/grafana or older graphite type setups tend to be compromises where you get lots of data but are then limited on the querying front or the number of metrics. The tradeoff is always between scale and querying flexibility. If you store tens/hundreds of GB of telemetry per day, you need a way to make sense of it. Clickhouse seems to be quite good at scaling and querying. It's basically a column database. I don't have direct experience with Loki.

But in the end, all that power only matters if people actually use it. And, again, in my experience teams tend not to. They tend to have a lot of unrealized aspirations around their tools and infrastructure. If it's just a dumping ground for data + a few simplistic dashboards, optimize for that. A lot of that data is actually only kept for compliance/auditing reasons. For that, querying is usually a secondary concern and it's OK if queries take a bit longer and are less powerful.

I'm partial to open observe, especially because in Ruby the OTEL stuff isn't great for metrics and logs yet.

There's a few contenders in self-hostable otel:

- ClickStack (ex HyperDX) - SigNoz - Traceway - a few more

does someone has enough feedback on those to be able to tell which one works best?

Funny, the first thing I look for for infra projects like these is to find out if it's written in Go. At that point, my confidence level is increased.

Here's something better than that:

https://github.com/plausible/analytics

Elixir.

I agree. The sentiment applies to most analytics. People who setup analytics are not the same as end users.

I'm partial to open observe, especially because in Ruby the OTEL stuff isn't great for metrics and logs yet.

I also run open observe at home, but I can't help but feel that the interface could use some... sparkle, and the mobile experience kinda sucks.

But you can't beat the excellent price and performance. Does what I need and much more

Here's something better than that:

https://github.com/plausible/analytics

Elixir.

Why is it better? On the internet it is not enough to just say something. You need to deliver some facts and / or a comparison. Please try it.

I agree. The sentiment applies to most analytics. People who setup analytics are not the same as end users.

I also run open observe at home, but I can't help but feel that the interface could use some... sparkle, and the mobile experience kinda sucks.

But you can't beat the excellent price and performance. Does what I need and much more

Why is it better? On the internet it is not enough to just say something. You need to deliver some facts and / or a comparison. Please try it.

_{Built on OpenTelemetry}

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

Website · Docs · Cloud · Discord

Traceway is an OpenTelemetry-native observability platform that combines logs, traces, metrics, session replay/RUM, exceptions, and AI tracing together. 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.}

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.
Metrics — Host, runtime, and custom metrics. Any dimension, any chart, with custom widget groups.
Exceptions — SHA-256 normalized stack traces grouped into ranked issues. Source-mapped (webpack, esbuild, Vite).
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).

Plus: configurable alerts (Slack / GitHub / email / webhook), Apdex + Impact-Score endpoint ranking, multi-tenant orgs with role-based access, and a per-endpoint slow-threshold override.

Why Traceway

	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

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.

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

import tracewaybackend "github.com/tracewayapp/traceway/backend"

func main() {
    go tracewaybackend.Run(
        tracewaybackend.WithPort(8082),
        tracewaybackend.WithDefaultUser("admin@localhost.com", "admin"),
        tracewaybackend.WithDefaultProject("My App", "go", "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.

Supported Integrations

Traceway integrates with the tools you already use. Every integration ships traces, metrics, and logs over OTLP/HTTP — no proprietary SDK required.

View the full list in the documentation. Missing a framework? Open an issue to request it.

Backend

Gin	Chi	Fiber	FastHTTP	net/http	Go Generic
Node.js	NestJS	Hono	Symfony	Cloudflare	OpenTelemetry

Frontend

Session Replay is included with every frontend integration — and with Flutter too.

Next.js

React

Vue

Svelte

jQuery

JavaScript

Mobile

Flutter

Android

React Native

AI

OpenRouter

Screenshots

Logs — trace-linked search	Span waterfall
Metrics — application dashboard	Exceptions — grouped & ranked

Tech Stack

Component	Technology
Backend	Go 1.25, Gin
Frontend	SvelteKit 2, Svelte 5, Tailwind CSS v4
Telemetry DB	ClickHouse (standalone) or SQLite (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
`docs/`	Documentation site (Nextra)
`examples/`	Working examples — embedded mode and OTel-instrumented apps (Express, NestJS, Next.js, Hono)
`website/`	Landing page

Build Tags

Tag	Purpose
(none)	SQLite storage — embedded mode, zero dependencies. This is the default.
`pgch`	ClickHouse + PostgreSQL storage — 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

# Standalone server (ClickHouse + PostgreSQL)
cd backend && go build -tags pgch ./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

# 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 -args -update ./app/controllers/otelcontrollers/

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 grouping, metrics, and alerts work
Embedded Mode — Run Traceway inside your Go app

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

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.

Hacker Times