Datadog vs SigNoz vs Grafana vs OpenObserve 2026
Observability Costs Broke Everyone's Budget
Modern observability should be table stakes. In practice, Datadog bills for hosts, custom metrics, log ingestion, and APM traces independently — and the combined invoice for a mid-sized engineering team frequently lands in the $50K–$200K/year range. This has driven a wave of migration toward open-source and self-hosted alternatives that implement the same OpenTelemetry standards at a fraction of the cost.
By 2026, the choice isn't just Datadog vs everything else. It's a spectrum: Datadog (managed, premium, fully integrated), Grafana (the composable open-source stack you assemble), SigNoz (opinionated open-source with a great out-of-the-box experience), and OpenObserve (the newcomer optimizing specifically for storage cost).
TL;DR
Datadog is the all-in-one observability platform for teams that prioritize ease of setup, deep integrations, and can absorb the cost. Grafana Stack (Loki + Tempo + Mimir + Prometheus) is the composable open-source alternative — powerful, free, but requires infrastructure management. SigNoz is the best self-hosted option with a Datadog-like UI that runs on ClickHouse and supports OpenTelemetry natively. OpenObserve is purpose-built for storage efficiency — claims 140x cheaper log storage than Elasticsearch, prioritizes ingest cost over feature depth.
Key Takeaways
- Datadog: $15/host/month (Pro); $0.10/GB + $1.70/M events logs; APM $31/host/month; LLM Observability $120/day (auto-activates!); no free tier; ~29K customers
- Grafana: Free OSS (AGPL); Cloud free tier (10K series, 50GB logs, 50GB traces, 14-day); Pro $19/month; ~67.5K GitHub stars
- SigNoz: Free open-source (ClickHouse-backed, Apache 2.0); SigNoz Cloud Teams at $49/month + usage; ~25K GitHub stars (crossed Dec 2025)
- OpenObserve: Free open-source (Apache 2.0); Cloud free tier eliminated June 2025 — now PAYG at $0.30/GB; ~15K GitHub stars; claims 140x lower storage cost than Elasticsearch
- OpenTelemetry: All four support OTLP ingestion natively — switching between them is primarily a deployment change
- Cost at 100GB/day logs: Datadog ~$9,000/month; Grafana Cloud ~$1,500/month; SigNoz self-hosted ~$150/month infra
Pricing Comparison
| Plan | Datadog | Grafana Cloud | SigNoz Cloud | OpenObserve Cloud |
|---|---|---|---|---|
| Free tier | ❌ (trial only) | ✅ 10K series, 50GB logs, 50GB traces | ✅ (startup: $19/mo) | ❌ Eliminated June 2025 (14-day trial only) |
| Log ingestion | $0.10/GB + $1.70/M indexed | $0.50/GB | $0.30/GB | $0.30/GB |
| APM traces | $31/host/mo or $2.55/M spans | $0.50/GB traces | $0.30/GB traces | $0.30/GB |
| Metrics | $0.05/custom metric/mo | $8/1K active series | $0.10/M samples | Included in PAYG |
| Infrastructure | $15/host/month Pro | N/A (BYOI) | N/A | N/A |
| Self-hosted | ❌ (agent only) | ✅ Free (OSS) | ✅ Free (OSS) | ✅ Free (OSS) |
Datadog Pricing Detail
Datadog charges separately for every signal type — a key criticism:
- Infrastructure: $15/host/month (Pro) or $23/host/month (Enterprise); on-demand $0.10/host/hour
- Log Management: $0.10/GB ingested + $1.70/million events indexed (15-day retention); archived at $0.05/GB; Flex Logs (cold storage) $0.025/GB
- APM: $31/host/month (includes 150 GB trace ingestion) or $2.55/million spans (on-demand); Continuous Profiler $4/host/month add-on
- LLM Observability: $120/day — activates automatically when AI spans detected; a frequent surprise billing issue
- Synthetics: $5/1K API test runs; $12/1K browser test runs
- RUM: $1.50/1K sessions
- Custom Metrics: $0.05/metric/month (first 100 included per host)
At 10 hosts + 50GB/day logs + APM: roughly $3,500–$5,000/month. Datadog's annual contracts typically include volume discounts of 20–30%.
Grafana Cloud Pricing Detail
Grafana Cloud uses a usage-based model with a generous free tier:
- Free tier: 10K active metric series, 50GB logs, 50GB traces, 3 users, 14-day retention; genuinely useful for small teams
- Pro: $19/month platform fee + same included usage as Free, with per-unit overages ($0.50/GB logs, $8/1K active series, $0.50/GB traces)
- Advanced: $25,000/year minimum commitment
- Enterprise (self-hosted): Custom; estimated $40,000–$100,000/year
- Self-hosted OSS: Grafana + Loki + Mimir + Tempo + Pyroscope = $0; you pay only for infrastructure
The self-hosted Grafana stack (LGTM: Loki, Grafana, Tempo, Mimir) is free and runs on any Kubernetes cluster. Infrastructure cost for 10GB/day logs at commodity cloud rates: ~$100–$200/month.
SigNoz Pricing Detail
SigNoz is Apache 2.0 open source, backed by ClickHouse:
- Community (self-hosted): Free, Apache 2.0, unlimited; includes SSO + API Keys (added May 2025 — previously Cloud-only)
- Teams Cloud: $49/month base + $0.30/GB logs + $0.30/GB traces + $0.10/million metric samples
- Startup Program: $19/month (50% off, eligibility required)
- Enterprise: From $4,000/month; dedicated cloud or BYOC (Bring Your Own Cloud) options; RBAC, dedicated support, SLAs
ClickHouse's columnar compression makes SigNoz storage ~3–5x more efficient than Elasticsearch-based stacks. The self-hosted version is fully featured — the cloud offering adds managed infrastructure.
OpenObserve Pricing Detail
OpenObserve (formerly ZincObserve) is written in Rust, optimized for storage compression:
- Open source: Free, Apache 2.0, self-hosted; uses S3/GCS/MinIO as the storage backend — single binary deploy
- Cloud: Free tier eliminated June 2, 2025. Now pay-as-you-go: $0.30/GB for log/metric/trace ingestion + per-query and pipeline charges; 14-day free trial for new accounts
- Enterprise: AWS Marketplace listing; custom pricing for large deployments
The Rust-native, Parquet-on-S3 architecture is OpenObserve's primary differentiator. A single node handles up to 2.6 TB/day ingest; an HA cluster scales to petabyte-level storage at S3 commodity pricing ($0.023/GB) rather than premium observability platform markups. The company claims 140x lower storage costs vs. Elasticsearch due to columnar Parquet compression.
Architecture and Data Ingestion
Datadog: The Integrated Agent
Datadog's Agent is the central collection component — a single process that collects metrics, logs, and traces:
# datadog.yaml
api_key: <DATADOG_API_KEY>
logs_enabled: true
apm_enabled: true
# Auto-discovery for Kubernetes
listeners:
- name: kubelet
# Custom log collection
logs:
- type: file
path: /var/log/app/*.log
service: my-app
source: nodejs
Datadog's 700+ integrations auto-configure collection from common services (MySQL, Redis, Nginx, etc.). The tradeoff is that everything routes through Datadog's SaaS — no self-hosted option.
OpenTelemetry: The Common Standard
All four platforms support OTLP (OpenTelemetry Protocol) natively in 2026. This means switching between them primarily involves changing the endpoint URL:
# OpenTelemetry Collector config — switch observability backends by changing exporter
exporters:
# Datadog
datadog:
api:
key: ${DD_API_KEY}
site: datadoghq.com
# SigNoz / OpenObserve / Grafana Tempo — OTLP
otlp:
endpoint: https://ingest.signoz.io:443
headers:
signoz-ingestion-key: ${SIGNOZ_KEY}
# Grafana Loki for logs
loki:
endpoint: http://loki:3100/loki/api/v1/push
# Application instrumentation — same code regardless of backend
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
provider = TracerProvider()
exporter = OTLPSpanExporter(
endpoint="http://otel-collector:4317" # change endpoint per platform
)
provider.add_span_processor(BatchSpanProcessor(exporter))
trace.set_tracer_provider(provider)
tracer = trace.get_tracer(__name__)
with tracer.start_as_current_span("process_order") as span:
span.set_attribute("order.id", order_id)
span.set_attribute("order.amount", amount)
result = process(order_id)
SigNoz: ClickHouse-Backed
SigNoz stores all signals in ClickHouse, a columnar OLAP database:
# Self-hosted install via Docker Compose
git clone https://github.com/SigNoz/signoz
cd signoz/deploy
docker compose up -d
# Kubernetes via Helm
helm repo add signoz https://charts.signoz.io
helm install my-release signoz/signoz
# Send traces via OTLP (same as any OTel-compatible backend)
OTEL_EXPORTER_OTLP_ENDPOINT=http://signoz-otel-collector:4317 \
OTEL_SERVICE_NAME=my-service \
node app.js
ClickHouse enables fast aggregation queries across billions of spans — critical for p99 latency analysis across large trace volumes.
Grafana Stack: Composable
# docker-compose for local LGTM stack
services:
grafana:
image: grafana/grafana:latest
ports: ["3000:3000"]
loki:
image: grafana/loki:latest
# Logs backend
tempo:
image: grafana/tempo:latest
# Traces backend
prometheus:
image: prom/prometheus:latest
# Metrics backend (or use Grafana Mimir for scale)
# Python logging → Loki via promtail or OpenTelemetry
import logging
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
# Correlate logs, traces, metrics using trace_id
# Grafana's Explore view links them automatically
Feature Comparison
| Feature | Datadog | Grafana | SigNoz | OpenObserve |
|---|---|---|---|---|
| APM / Distributed Tracing | ✅ | ✅ (Tempo) | ✅ | ✅ |
| Log Management | ✅ | ✅ (Loki) | ✅ | ✅ |
| Metrics | ✅ | ✅ (Prometheus/Mimir) | ✅ | ✅ |
| Continuous Profiling | ✅ | ✅ (Pyroscope) | ✅ (limited) | ❌ |
| RUM / Synthetic Monitoring | ✅ | ✅ (k6) | ❌ | ❌ |
| Alerting | ✅ | ✅ | ✅ | ✅ |
| Dashboards | ✅ | ✅ (best in class) | ✅ | ✅ |
| OpenTelemetry native | ✅ | ✅ | ✅ | ✅ |
| Self-hostable | ❌ | ✅ | ✅ | ✅ |
| AI-assisted debugging | ✅ (Bits AI) | ✅ (Grafana AI) | ❌ | ❌ |
Logs, Traces, and Metrics Correlation
The killer feature of a unified observability platform is correlating signals — clicking on a log line and jumping to the trace, or seeing a metrics spike and drilling into the underlying spans.
Datadog executes this best out-of-the-box: log-to-trace correlation is automatic when using Datadog agents; APM trace IDs are injected into logs automatically.
SigNoz correlates logs and traces via trace_id and span_id fields — if your OTLP instrumentation sets these (which auto-instrumentation does), the UI provides direct links between signals.
Grafana uses Derived Fields (for logs) and exemplars (for metrics) to link signals. Setup requires manual configuration but the result is equivalent.
OpenObserve has basic correlation via trace ID but lacks the polished cross-signal navigation of the other three.
Alerting and On-Call
Alerting is where observability becomes operational. Each platform has a different model:
Datadog has the most polished alerting with composite monitors (alert when metric A + metric B + log query C all trigger simultaneously), anomaly detection (ML-based baseline deviation), and forecast monitors. Integration with PagerDuty, OpsGenie, and Slack is native and well-tested. The UI for alert management is excellent. Cost: monitors are generally included but APM anomaly detection and forecast monitors require APM plans.
Grafana uses a unified alerting system across all data sources. You can alert on Prometheus metrics, Loki log queries, and Tempo trace data from the same UI. Alert rules use the same PromQL/LogQL/TraceQL you write for dashboards. Grafana OnCall (open source) handles scheduling and escalations. The tradeoff: setup is more manual than Datadog.
SigNoz supports alerting on metrics, logs, and traces from its UI. Alert rules are configured in the same interface used for querying. Integrations with PagerDuty, OpsGenie, and Slack are available. Still less polished than Datadog's alerting, but sufficient for most production needs.
OpenObserve has basic alerting — scheduled queries that trigger webhooks. It handles the core case (metric threshold, log pattern) but lacks anomaly detection or composite alert logic. For teams primarily using OpenObserve for log storage, external alerting via Grafana (connected to OpenObserve via the Prometheus-compatible endpoint) is a common pattern.
Estimated Monthly Cost at Different Scales
Real-world observability costs depend on the combination of metrics, logs, and trace volume. Here's a comparison at three scales:
Small team: 5 hosts, 10GB/day logs, 1M traces/day (~300GB logs/mo, ~1GB traces/mo)
| Platform | Estimated Monthly Cost |
|---|---|
| Datadog (Pro) | ~$800–$1,200 |
| Grafana Cloud Pro | ~$200–$400 (within free tier for some signals) |
| SigNoz Cloud Teams | $49 base + $0.30 × 300GB = ~$140/month |
| SigNoz self-hosted | ~$50–$100 infra |
| OpenObserve Cloud | $0.30 × 300GB = ~$90/month (no free tier) |
Mid-scale: 20 hosts, 100GB/day logs, 10M traces/day (~3TB logs/mo, ~15GB traces/mo)
| Platform | Estimated Monthly Cost |
|---|---|
| Datadog (Pro) | ~$4,000–$7,000 |
| Grafana Cloud Pro | ~$1,500–$2,500 |
| SigNoz Cloud Teams | $49 + $0.30 × 3,000GB = ~$950/month |
| SigNoz self-hosted | ~$200–$400 infra |
| OpenObserve Cloud | $0.30 × 3,000GB = ~$900/month |
Large scale: 100 hosts, 500GB/day logs, 100M traces/day (~15TB logs/mo)
| Platform | Estimated Monthly Cost |
|---|---|
| Datadog (Pro, with discounts) | ~$30,000–$60,000 |
| Grafana self-hosted | ~$2,000–$5,000 infra |
| SigNoz self-hosted | ~$1,500–$3,000 infra |
| OpenObserve self-hosted | ~$500–$1,500 infra (S3 at $0.023/GB) |
The self-hosted cost estimates include ClickHouse/PostgreSQL infrastructure, compute, and storage at commodity cloud prices. Datadog's enterprise contracts typically include 20–30% volume discounts but the base rate remains the most expensive by a significant margin.
When to Choose Each
Choose Datadog if:
- You need the fastest time-to-value with minimal configuration
- Your team uses Datadog's security (CSPM, SIEM), CI visibility, or synthetic monitoring features
- You have an enterprise budget and prefer managed infrastructure
- You need 1,000+ pre-built integrations with auto-discovery
- ⚠️ LLM billing warning: If your services emit AI/LLM spans, Datadog's LLM Observability activates automatically at $120/day. Disable it explicitly if you don't need it.
Choose Grafana Stack if:
- You want full control over data residency and infrastructure
- Your team already uses Prometheus and wants to add logs/traces
- You want to avoid vendor lock-in (all components are open source)
- Budget is a primary constraint and you have DevOps capacity to maintain the stack
Choose SigNoz if:
- You want a self-hosted Datadog-like experience with minimal ops overhead
- You're migrating from Datadog and want to maintain workflow familiarity
- ClickHouse's query performance for trace/log analytics matters
- You want OpenTelemetry-native from day one without Datadog agent dependency
Choose OpenObserve if:
- Log storage cost is the primary concern — the Parquet/S3 backend has the lowest self-hosted storage cost of the four
- You're building on S3 or GCS and want commodity storage prices ($0.023/GB vs proprietary markup)
- You want a single-binary self-hosted deploy without ClickHouse or a 5-service LGTM stack
- You need RUM + session replay bundled (added in 2025 — missing from SigNoz)
- Note: OpenObserve Cloud eliminated its free tier June 2025 — $0.30/GB PAYG only (14-day trial for new accounts)
Track Datadog, SigNoz, Grafana, and OpenObserve API uptime and usage on APIScout.
Related: LangSmith vs Langfuse vs Braintrust: LLM Observability 2026 · LLM API Pricing 2026