Uptrace

Open-source APM, honestly reviewed. No marketing fluff, just what you get when you self-host your observability stack.

TL;DR

• What it is: Open-source (AGPL-3.0) APM platform — traces, metrics, and logs in a single UI, built on OpenTelemetry and ClickHouse [README][5].
• Who it’s for: Engineering teams paying $2,000–$40,000/mo for Datadog or New Relic who want the same three signals (traces, metrics, logs) without the per-seat fees, usage-spike anxiety, or vendor lock-in [website].
• Cost savings: Datadog runs $42,468/mo for a 150-engineer team with 225 APM hosts. Uptrace Cloud quotes $2,039 for the same workload — a 95% reduction. Self-hosted on your own VPS brings it close to infrastructure cost only [website].
• Key strength: OpenTelemetry-native means zero vendor lock-in at the instrumentation layer. Your SDK code works against any OTel backend — switching away from Uptrace doesn’t require re-instrumentation [README][4].
• Key weakness: 4,135 GitHub stars is modest compared to SigNoz (26K+) in the same open-source APM category [5]. The AGPL-3.0 license adds constraints if you’re embedding it in a commercial product. Adoption and community size lag behind more established alternatives.

---

What is Uptrace

Uptrace is an open-source APM (Application Performance Monitoring) platform that handles all three observability signals — distributed traces, metrics, and logs — in a single interface. The underlying storage engine is ClickHouse, which is what lets the project credibly claim it can process billions of spans on a single server with on-disk compression that squeezes a 1KB span down to roughly 40 bytes [README].

The core pitch is straightforward: take the three things you’re currently paying Datadog or New Relic for, and run them on your own infrastructure for a fraction of the cost. The company leans hard on the number “90%” in its marketing (“Cut Your Observability Bill by 90%”), which is aggressive but not fabricated — the actual pricing comparison on the homepage shows $2,039 vs $42,468 for the same large team workload [website].

What makes Uptrace technically coherent rather than just “cheaper Datadog” is its commitment to OpenTelemetry as the only supported ingestion protocol. You don’t install a proprietary agent. You instrument your code with the OpenTelemetry SDK — an open standard managed by CNCF — and point it at Uptrace. That means if Uptrace ever disappoints you, your instrumentation code works against SigNoz, Jaeger, Grafana Tempo, or any other OTel-compatible backend without changes [README][4].

The project has been running since 2021, claims 1,000+ active installations, and maintains 99.9% uptime on its managed cloud. The GitHub repository sits at 4,135 stars — respectable but notably behind SigNoz (26,569 stars) in the same category [5][website].

---

Why people choose it over Datadog, New Relic, and Grafana

The third-party review coverage for Uptrace is thin compared to more prominent open-source tools — most of what exists is comparison pages and directory listings rather than first-hand migration stories. That’s itself a signal about where it sits in the market: not a household name, but a technically solid choice for teams who’ve done the research.

Versus Datadog and New Relic. This is the central argument. Both are fully closed-source SaaS platforms with per-host, per-seat, and per-GB pricing that compounds in painful ways at scale. The SaaSHub comparison [1] notes Uptrace’s positioning explicitly against these: open-source core, self-hostable, freemium cloud tier starting at $30/month vs enterprise pricing that can run into five figures monthly. The Uptrace website’s pricing comparison is the clearest statement of the value proposition: same 150-engineer team, same workloads — Uptrace Cloud at $2,039/mo vs New Relic at $24,635 vs Datadog at $42,468 [website]. Even if you haircut those numbers by half for methodology differences, the order-of-magnitude gap is real.

Versus Grafana + Prometheus. This is a more nuanced comparison. The Grafana stack (Prometheus for metrics, Loki for logs, Tempo for traces, Grafana for visualization) is the incumbent self-hosted observability answer. It’s extremely powerful and has massive community adoption. The trade-off: the Grafana stack requires you to operate four separate services and stitch them together yourself. Uptrace is a single deployment that handles all three signals with pre-built correlation between them. The SaaSHub comparison [1] lists Grafana as the natural comparison product — Grafana is a visualization layer that doesn’t store data, while Uptrace is a full-stack system. The SaaSHub comparison notes Grafana’s “steep learning curve” and “complex setup for alerting” as its main weaknesses, which maps to exactly the pain Uptrace is trying to solve with its 50+ pre-built dashboards and unified query interface [1].

Versus SigNoz. SigNoz is the most direct competitor in the open-source OTel APM space — also built on ClickHouse, also targeting Datadog refugees, also self-hostable. It has 26K+ GitHub stars versus Uptrace’s 4,135 [5]. SigNoz has larger community adoption and more third-party coverage. The honest read: if community size and ecosystem breadth matter, SigNoz is ahead. If you want a slightly more mature managed cloud offering with EU data residency and a team focused on commercial deployments, Uptrace competes [website][5].

On data sovereignty. For teams where compliance or data geography matters, Uptrace’s managed cloud runs on servers in Germany and Finland. The website explicitly states: “Your telemetry data never leaves the European Union. Full GDPR compliance by design” [website]. This is a legitimate differentiator against US-based SaaS APM vendors for EU-based engineering teams.

On OpenTelemetry lock-in avoidance. Multiple sources implicitly flag this: every Datadog agent, every New Relic agent, every proprietary APM SDK is a migration tax that grows with your codebase. OTel-first means you pay that migration cost once when you instrument your services, and then you can switch backends freely. Uptrace’s bet is that teams will choose self-hosted OTel backends over proprietary SaaS once they understand the compounding cost [README][4].

---

Features

From the README and documentation:

Observability core:

• Single UI for traces, metrics, and logs — correlated across all three [README]
• 50+ pre-built dashboards that auto-provision once metrics start arriving [README]
• Service graph with dependency mapping and bottleneck visualization [README][website]
• RED metrics out of the box: request rate, error rate, latency [website]
• Latency percentiles: p50, p90, p99, and max [website]
• Chart annotations for correlating deployments with performance changes [README]
• Faceted filters across spans and logs [README]

Query languages:

• SQL-like language for aggregating spans [README]
• PromQL-like language for aggregating metrics [README]
• Intuitive query builder in the UI [README]

Ingestion:

• OpenTelemetry (primary protocol) [README]
• Prometheus remote write [README]
• Vector, FluentBit for log ingestion [README]
• CloudWatch (for AWS-native telemetry) [README]
• Grafana Tempo and Prometheus compatibility — you can point an existing Grafana instance at Uptrace as a datasource [README]
• 10,000+ spans/second processing on a single CPU core [README]
• On-disk compression: ~40 bytes per 1KB span [README]

Alerting and notifications:

• Alert rules on spans, logs, and metrics [README]
• Notification channels: Email, Slack, Webhook, AlertManager [README]

Access and security:

• Single Sign-On via OpenID Connect: Keycloak, Google Cloud, Cloudflare [README]
• User and project management via YAML config [README]
• SSO is included in the open-source build — not gated behind a commercial license, unlike some competitors [README]

Storage:

• ClickHouse for time-series observability data [README][4]
• PostgreSQL for metadata: metric names, alerts, user data [README][4]
• Redis for caching [4]

---

Pricing: SaaS vs self-hosted math

Uptrace Cloud:

• Free trial: 1TB storage, 100,000 active timeseries, no credit card required [website]
• Paid: pricing listed as starting around $30/month on SaaSHub [1]; the website describes per-GB ingest and per-timeseries pricing with volume discounts, a monthly cap guarantee, and no per-seat fees [website]
• Specific tier prices weren’t captured in the scrape — check https://uptrace.dev/pricing for current numbers

Self-hosted (community edition):

• Software: $0 (AGPL-3.0) [README]
• Infrastructure: $20–60/month for a VPS capable of running Uptrace + ClickHouse + PostgreSQL + Redis under moderate load (minimum 4GB RAM, 2 CPUs) [4]
• Your time: 1–3 hours initial setup with Docker Compose

Datadog for comparison (from Uptrace’s own pricing page):

• Large team (150 engineers, 225 APM hosts, 10TB logs): $42,468/mo
• Midsize team: scales proportionally with host count and log volume
• Per-host APM pricing: ~$31/host/month for APM Pro

New Relic for comparison:

• Same large team scenario: $24,635/mo [website]
• Per-seat model with compute pricing added on top

Concrete math for a midsize team: Say you’re a 20-engineer startup with 15 APM hosts, pushing 50GB of logs per month and 20,000 active metrics. On Datadog that’s approximately $500–$800/month before log ingestion spikes. On New Relic, similar. On Uptrace Cloud at per-GB pricing, you’re looking at a fraction of that — likely $50–200/month depending on exact volumes. Self-hosted on a Hetzner dedicated server ($40–60/month), it runs on your infrastructure indefinitely [website][1].

The AGPL-3.0 license note: unlike MIT, AGPL requires that if you run a modified version of Uptrace as a network service, you must publish those modifications. For most self-hosters this is irrelevant. For a company thinking about building a commercial observability product on top of Uptrace, it’s a real constraint — you’d need a commercial license agreement [README].

---

Deployment reality check

The Docker deployment path is well-documented and works off a git clone and a docker compose up [4]. The Docker Compose stack includes six services: Uptrace itself, ClickHouse, PostgreSQL, Redis, an OpenTelemetry Collector, and an optional MailHog for email testing. That’s heavier than a single-binary deployment but not unusual for the category.

What you actually need:

• A Linux VPS with 2+ CPU cores and 4GB+ RAM minimum; more realistically 8GB+ RAM once you’re ingesting production-scale telemetry [4]
• 10GB+ disk space at minimum; real production deployments will want 100GB+ depending on retention policy
• Docker and Docker Compose
• A domain and reverse proxy (nginx or Caddy) for HTTPS
• An SMTP provider if you want email alerts

Default setup after install:

• Web UI at http://localhost:14318
• Default credentials: admin@uptrace.local / admin — change immediately [4]

What can go sideways:

• ClickHouse is a powerful but operationally non-trivial database. Under high span volume it will need tuning (memory limits, merge tree settings). This isn’t a beginner database to run in production [4].
• The minimum spec of 4GB RAM is optimistic for production. Real deployments with meaningful span volume should budget 8–16GB.
• AGPL-3.0 means any network-exposed modifications must be open-sourced — understand this before embedding Uptrace in a commercial product [README].
• Community size is smaller than SigNoz or the Grafana stack, so self-help resources (Stack Overflow threads, community blog posts) are thinner. Support channels are Telegram and Slack [README].
• The Kubernetes and Ansible deployment paths exist but are less beginner-friendly than Docker Compose [website][4].

Realistic time estimates:

• Technical user following the Docker guide: 30–60 minutes to a working instance
• First production-scale data flowing in: 2–4 hours including OTel SDK instrumentation of one service
• Non-technical founder: this tool is not aimed at you; you’ll need an engineer or a managed deployment service

---

Pros and Cons

Pros

• Genuinely unified observability. Traces, metrics, and logs in one interface with correlation between them — not three separate tools bolted together [README][website].
• OpenTelemetry-native means zero instrumentation lock-in. Your code works against any OTel backend. Migrating away from Uptrace doesn’t require re-instrumenting your services [README][4].
• ClickHouse compression is exceptional. 40 bytes per 1KB span means storage costs that are structurally lower than Elasticsearch-based alternatives. Billions of spans on a single server is a real claim, not marketing [README].
• SSO included in the open-source edition. Keycloak, Google, and Cloudflare OIDC work in the community build — this is gated behind paid tiers in most competitors [README].
• 50+ pre-built dashboards auto-provisioned. You don’t start from a blank screen [README].
• No per-seat pricing on the cloud tier. Unlimited users included — a genuine differentiator from Datadog and New Relic where per-seat costs compound with team size [website].
• EU data residency on managed cloud. Servers in Germany and Finland, GDPR-compliant by design [website].
• Monthly cap guarantee on cloud pricing. No surprise invoices from a traffic spike [website].

Cons

• AGPL-3.0, not MIT. You can self-host freely, but modifications deployed as network services must be open-sourced. Not a problem for internal deployments; a real constraint for commercial embedding [README].
• Small community relative to alternatives. 4,135 stars vs SigNoz’s 26,569 means fewer community tutorials, fewer third-party integrations, fewer Stack Overflow answers [5].
• ClickHouse operational overhead. Running ClickHouse well in production requires database tuning knowledge most dev teams don’t have. The Grafana stack’s use of object storage (S3/GCS) is operationally simpler at scale [4].
• Thin third-party review coverage. Most review sites have directory listings, not first-hand accounts. This makes it harder to find honest post-mortems from real production deployments [1][2].
• Minimum viable VPS is heavier than advertised. 4GB RAM is a floor, not a comfortable operating point once real production telemetry arrives [4].
• Pricing page details not fully public. The specific per-GB and per-timeseries numbers weren’t captured in available sources — you have to request a quote or navigate the live pricing page to model costs precisely.
• Alertmanager integration, not a native alerting UI. The alerting works, but heavy alerting users familiar with PagerDuty-style routing will find it less polished than commercial alternatives [README].

---

Who should use this / who shouldn’t

Use Uptrace if:

• Your Datadog or New Relic bill has crossed $1,000/month and you have an engineer who can spend a day deploying and instrumenting.
• You want OpenTelemetry instrumentation with a clear self-hosted backend that doesn’t lock your SDK code to a vendor.
• You’re in the EU and need GDPR-compliant telemetry storage without hand-rolling your own infrastructure.
• You’re comfortable with Docker Compose deployments and have some familiarity with ClickHouse or are willing to learn it.
• Your team is already writing OTel-instrumented code and just needs a backend.

Skip it (consider SigNoz instead) if:

• Community size and third-party ecosystem breadth matter to you — SigNoz has 6× the GitHub stars and significantly more first-hand production coverage [5].
• You want a more active open-source community for questions, plugins, and troubleshooting.

Skip it (consider Grafana stack instead) if:

• You have an existing Prometheus metrics setup and want to add tracing and logging around it without replacing anything.
• You need object storage (S3/GCS) as the backing store rather than a local ClickHouse disk — this is operationally simpler at large scale.
• You want the broadest possible ecosystem of dashboards, plugins, and integrations.

Skip it (stay on Datadog) if:

• You need 24/7 commercial support with SLA guarantees.
• Your compliance framework requires SOC 2 Type II vendor certification and you can’t self-certify a self-hosted setup.
• You have no engineer available for initial deployment and ongoing maintenance.

Skip it (use Uptrace Cloud instead of self-hosting) if:

• You want the cost savings but not the operational burden of running ClickHouse and PostgreSQL in production.

---

Alternatives worth considering

• SigNoz — the closest open-source competitor. Also OTel-native, also ClickHouse-backed. 26,569 stars vs Uptrace’s 4,135. More community adoption, more third-party tooling, Apache 2.0 license [5]. The natural first comparison.
• Grafana + Prometheus + Loki + Tempo — the incumbent self-hosted stack. More operationally complex (four services instead of one), but massive ecosystem and community. Use this if you already have Prometheus and want to grow around it [1].
• Coroot — newer entrant with 7,568 stars and a compelling zero-instrumentation story using eBPF. Worth evaluating if you want observability without touching application code [5].
• Datadog — the commercial benchmark. Easiest onboarding, best enterprise support, most integrations. The bill is the reason you’re looking at alternatives.
• New Relic — per-seat pricing has gotten more competitive recently with a free tier. Still closed-source SaaS, still expensive at scale.
• OpenTelemetry Collector + Jaeger — if you only need distributed tracing and no metrics or logs, Jaeger is a simpler self-hosted option with stronger community history.

For an engineering team escaping Datadog, the realistic shortlist is Uptrace vs SigNoz. Both are OTel-native and ClickHouse-backed. Pick SigNoz if community size and ecosystem breadth matter. Pick Uptrace if the cloud tier’s EU data residency and managed offering align better with your team’s needs.

---

Bottom line

Uptrace makes a technically coherent case: OpenTelemetry instrumentation is a one-time cost that buys you backend portability, ClickHouse compression makes high-volume telemetry economically viable at small scale, and the unified traces-metrics-logs interface eliminates the operational pain of running three separate tools. The pricing comparison against Datadog and New Relic isn’t marketing fiction — the structural cost difference is real and large. The honest caveats are equally real: the community is small relative to SigNoz, ClickHouse has an operational learning curve, and AGPL-3.0 constrains commercial use. For an engineering team with a $1,000+/month Datadog bill and a developer who can spend a day on deployment, the math is straightforward. For a non-technical founder looking to self-host without engineering support, this is not the right tool — look at the Uptrace Cloud managed tier instead, or factor in a one-time deployment engagement from a studio like upready.dev.

---

Sources

1. SaaSHub — Grafana VS Uptrace comparison (features, pricing, category metadata). https://www.saashub.com/compare-grafana-vs-uptrace
2. SaaSHub — Tiktokvoice-net’s Favourites (Uptrace listing, pricing context). https://www.saashub.com/u/Tiktokvoice-net
3. Uptrace — 10 Best Zabbix Alternatives for Infrastructure Monitoring in 2025 (Uptrace-authored comparison, infrastructure monitoring context). https://uptrace.dev/comparisons/zabbix-alternatives
4. Uptrace — Deploying Uptrace with Docker (official deployment guide, system requirements, architecture). https://uptrace.dev/get/hosted/docker
5. OpenAlternative.co — Open Source Projects tagged “Distributed Tracing” (category landscape, star counts, competitor comparison). https://openalternative.co/tags/distributed-tracing

Primary sources:

• GitHub repository and README: https://github.com/uptrace/uptrace (4,135 stars, AGPL-3.0 license)
• Official website: https://uptrace.dev
• Pricing page: https://uptrace.dev/pricing
• Cloud demo (no login required): https://app.uptrace.dev/play