16 Best Open Source Alternatives to Datadog

Updated July 2026

Datadog earned its place by pulling everything into one pane - metrics, traces, logs, and alerts correlated well enough that an on-call engineer can find the cause at 3 a.m. The breadth is real. So is the bill. Datadog charges by host, by ingested gigabyte, by custom metric, so the more thoroughly you instrument - exactly what good observability asks of you - the faster the invoice climbs, and the telemetry that explains your own infrastructure lives in Datadog's.

The open source alternatives below keep that telemetry on infrastructure you run. Metrics, distributed traces, and logs land in stores you own, retained on your terms rather than a billing tier's, and instrumenting one more service costs storage instead of a per-host line item. You get the correlated view across your stack without a meter that punishes you for measuring more.

Netdata logo

1.Netdata

79.2kGPL-3.0C Self-host
Netdata screenshot

Netdata trades sampling intervals for resolution: it charts system and application metrics at one-second granularity, so a spike that a one-minute tool would average away shows up immediately. Install it and dashboards populate themselves with little configuration, which is how it stays useful for lean teams as much as large fleets.

  • Per-second metrics and visualizations
  • Collects from systems, containers, apps, logs, APIs, and synthetic checks
  • ML models per metric for anomaly detection
  • Built-in alerts with email, Slack, Telegram, PagerDuty, Discord, and Teams
Grafana logo

2.Grafana

74.4kAGPL-3.0TypeScript Self-host
Grafana screenshot

Grafana is an open-source platform for monitoring and observability. It lets you query, visualize, alert on, and understand metrics no matter where they are stored, and it is built to create, explore, and share dashboards with a team.

  • Client-side visualizations for metrics and logs
  • Dynamic dashboards with template variables
  • Ad-hoc query exploration and side-by-side comparisons
  • Log exploration with preserved label filters
SigNoz logo

3.SigNoz

27.3kOtherTypeScript Self-host
SigNoz screenshot

SigNoz is an open source observability platform for monitoring applications, services, and infrastructure. It brings logs, metrics, and traces into one place so you can spot issues, troubleshoot downtime, and debug with richer context, positioned as an open source alternative to Datadog and New Relic.

  • Application performance monitoring with p99 latency, error rate, Apdex, and ops per second
  • Centralized logs with filters, query builder, and log charts
  • Distributed tracing with flamegraphs and Gantt charts
  • Metrics dashboards with pie, time-series, and bar chart panels
Apache SkyWalking logo

4.Apache SkyWalking

24.8kApache-2.0Java Self-host
Apache SkyWalking screenshot

Apache SkyWalking is an open source APM system for microservices, cloud-native, and container-based architectures. It collects monitoring, tracing, and diagnostic data from distributed systems and brings service topology, service-centric observability, and dashboards together in one place.

  • Distributed tracing with service topology analysis
  • Metrics, logs, profiling, and alarms
  • Agents for Java, .NET Core, PHP, NodeJS, Go, Python, and more
  • eBPF-based monitoring and profiling with Rover
Jaeger logo

5.Jaeger

22.9kApache-2.0Go Self-host
Jaeger screenshot

Jaeger is a distributed tracing system for monitoring and troubleshooting requests as they flow through complex distributed systems. By following a single request across every service it touches, teams can pinpoint latency, errors, and unexpected behavior in development or production.

  • Distributed tracing across complex service workflows
  • Ingests OpenTelemetry trace data over HTTP or gRPC
  • Pluggable storage backends for traces
  • Web UI for exploring traces and service dependencies
Vector logo

6.Vector

22kMPL-2.0Rust Self-host
Vector screenshot

Vector is an open-source observability data pipeline for collecting, transforming, and routing logs and metrics. It runs end-to-end as an agent or aggregator, so teams can consolidate telemetry flow and send data to current or future vendors. The focus is control over observability data, including cost reduction, enrichment, and data security placement.

  • Collect, transform, and route logs and metrics
  • Deploy as an agent or aggregator
  • Sources include Docker logs, files, HTTP, journald, Kafka, and sockets
  • Transforms include dedupe, filter, remap, Lua, and log-to-metric
OpenObserve logo

7.OpenObserve

19.3kAGPL-3.0TypeScript Self-host
OpenObserve screenshot

OpenObserve is a cloud-native observability tool for logs, metrics, traces, analytics, and real user monitoring. It is built for teams that want a single place to search, query, and alert on telemetry without the cost and complexity of separate tools.

  • Parquet columnar storage with S3-native design
  • Full-text log search, SQL queries, filters, and dashboards
  • Distributed tracing with OpenTelemetry
  • Metrics dashboards with SQL or PromQL
Pinpoint logo

8.Pinpoint

13.8kApache-2.0Java Self-host
Pinpoint screenshot

Pinpoint is an application performance management tool for large-scale distributed systems, inspired by Google Dapper. It traces transactions end to end across services so you can see how components connect and quickly find problem areas and bottlenecks in complex applications.

  • ServerMap for distributed system topology
  • Real-time active thread chart
  • Request-response scatter chart
  • CallStack for code-level transaction visibility
Fluentd logo

9.Fluentd

13.6kApache-2.0Ruby Self-host
Fluentd screenshot

Fluentd sits between your data sources and your backend systems as a single unified logging layer, so applications no longer need to know where their logs end up. It collects events from many sources and writes them to files, RDBMS, NoSQL, IaaS, SaaS, Hadoop, and other destinations.

  • Unified logging layer decouples sources from backends
  • 500+ plugins for inputs and outputs
  • Writes to files, RDBMS, NoSQL, IaaS, SaaS, and Hadoop
  • Structured JSON events with fluent.conf routing
Quickwit logo

10.Quickwit

11.3kApache-2.0Rust Self-host
Quickwit screenshot

Quickwit is a cloud-native search engine for observability data, focused on logs and distributed traces, with metrics support on the roadmap. It is an open-source alternative to Datadog, Elasticsearch, Loki, and Tempo for teams that need full-text search and analytics over large event data.

  • Full-text search and aggregation queries
  • Elasticsearch/OpenSearch-compatible ingest and search APIs
  • OTEL-native logs and traces with Jaeger-native tracing
  • Schemaless or strict schema indexing with schemaless analytics
HyperDX logo

11.HyperDX

9.6kMITTypeScript Self-host
HyperDX screenshot

HyperDX is an open source observability platform for finding production issues in logs, metrics, traces, errors, and session replays. It runs on top of a ClickHouse cluster and is built to make search and visualization faster across production telemetry.

  • Correlate logs, metrics, session replays, traces, and errors
  • Schema-agnostic search on an existing ClickHouse schema
  • Alerts, dashboards, event deltas, and live tailing
  • OpenTelemetry support with an included collector
Falco logo

12.Falco

9kApache-2.0C++ Self-host
Falco screenshot

Falco is a cloud native runtime security tool for Linux. It detects and alerts on abnormal behavior and potential security threats in real time, acting as a kernel monitoring and detection agent that observes events such as syscalls.

  • Kernel-level event monitoring based on syscalls
  • Custom rules engine for host and container behavior
  • Container runtime and Kubernetes metadata enrichment
  • Off-host event analysis in SIEM or data lake systems
Fluent Bit logo

13.Fluent Bit

7.9kApache-2.0C Self-host
Fluent Bit screenshot

Fluent Bit is a lightweight telemetry agent for collecting, processing, and forwarding logs, metrics, and traces from any source to any destination. It is built for Linux, Windows, macOS, BSD, and embedded environments, and is designed to use minimal CPU and memory.

  • 70+ built-in plugins for inputs, filters, and outputs
  • SQL stream processing for analytics and transformations
  • Built-in TLS and SSL support with async I/O
  • Internal metrics exposed over HTTP and Prometheus
Coroot logo

14.Coroot

7.8kApache-2.0Go Self-host
Coroot screenshot

Coroot is an open source observability and APM tool that brings metrics, logs, traces, and profiles together in one place. It cuts down manual investigation by turning that telemetry into actionable insights, including automated root cause analysis and SLO-based alerting.

  • Automatic collection of metrics, logs, traces, and profiles via eBPF
  • eBPF instrumentation with zero code changes
  • Service map, predefined inspections, and SLO-based alerting
  • Distributed tracing and continuous profiling
Uptrace logo

15.Uptrace

4.2kAGPL-3.0Go Self-host
Uptrace screenshot

Uptrace is an open source APM for monitoring applications and troubleshooting issues with OpenTelemetry traces, metrics, and logs. It is built for teams that want a single place to follow application behavior across telemetry data.

  • Single UI for traces, metrics, and logs
  • 50+ pre-built dashboards
  • Alerting with Email, Slack, WebHook, and AlertManager
  • SQL-like span queries and Promql-like metric queries
Elastic APM logo

16.Elastic APM

1.3kOtherGo Self-host
Elastic APM screenshot

Elastic APM Server is the application performance monitoring component of Elastic Observability. It receives data from Elastic APM agents instrumented in your applications and turns it into Elasticsearch documents, so performance data lands in the same store as your logs and metrics for hybrid-cloud applications.

  • Ingests data from Elastic APM agents
  • Stores APM data as Elasticsearch documents
  • End-to-end distributed tracing with metrics and logs in context
  • Accepts OpenTelemetry data

Switching from Datadog to open source

Datadog is hard to replace because it is not just a metrics tool. It combines host and container monitoring, logs, traces, dashboards, alerting, service maps, synthetics, incident workflows, and a large integration catalog behind one data model. The first choice is whether you want one open source platform that covers most of that surface or a composed stack with separate systems for metrics, logs, and traces. A composed stack gives you sharper control over retention and cost, but it also makes correlation, permissions, upgrades, and on-call ownership your problem.

Expect gaps around polish, hosted operations, and cross-signal workflows. Datadog's value is often in the glue - tag conventions, saved views, monitor evaluation, alert routing, APM navigation, and integration defaults that teams stop thinking about. Open source replacements can be excellent at the core telemetry paths, but you should expect more setup work for role-based access, audit trails, multi-tenant isolation, long-term storage, mobile review, and executive-friendly dashboards. Also budget time to retrain engineers on query languages and to rebuild runbooks tied to Datadog screens.

Migration usually works best as a dual-write period, not a flag day. Start by inventorying Datadog monitors, dashboards, metric names, tag keys, log pipelines, trace instrumentation, and SLOs. Move collection toward open protocols or vendor-neutral agents where possible, then send the same telemetry to both systems until alert behavior matches. Dashboards and monitors can often be exported as JSON through Datadog APIs or infrastructure-as-code state, but the queries need translation. Historical logs and metrics depend on retention, archives, and API limits, so treat old data as reference, not something that will fully rehydrate cleanly.

Related alternatives

Frequently asked questions

What is the hardest part of replacing Datadog?+

The hardest part is usually not collecting telemetry. It is recreating the operating model built around Datadog: tag standards, monitor ownership, dashboard conventions, alert routes, service views, and incident habits. If teams use Datadog as the shared source of truth during outages, plan the replacement around workflows first and storage engines second.

Will an open source replacement cost less than Datadog?+

It can, but only if you manage ingestion, retention, storage, and operations deliberately. Datadog pricing is tied to usage dimensions such as hosts, logs, traces, and features. Open source shifts much of that cost into infrastructure, engineering time, upgrades, backups, and on-call ownership. The biggest savings usually come from controlling high-volume logs and trace sampling.

Do we have to self-host everything after leaving Datadog?+

No. Some teams run the full stack themselves, while others use managed hosting around open source components. The tradeoff is control versus operational load. Self-hosting gives you direct control over retention, data location, and tuning. Managed options reduce upgrade and reliability work, but you still need to understand data formats, limits, and export paths before committing.

How much historical Datadog data can we migrate?+

Do not assume you can bulk-move all historical telemetry in a useful form. Datadog APIs and archives can help with some logs, events, dashboards, monitors, and recent queryable data, but retention windows, aggregation, rate limits, and data shape matter. Most migrations keep Datadog history read-only for a while and focus effort on clean collection going forward.

What happens to Datadog dashboards and monitors?+

Dashboards and monitors are usually portable as definitions, not as finished replacements. You can export many of them through APIs or existing infrastructure-as-code workflows, then translate queries, functions, template variables, thresholds, and notification rules. Expect cleanup. Datadog-specific formulas, composite monitors, tag filters, and alert recovery behavior often need manual review before they are trusted in production.

Is an open source observability stack suitable for regulated environments?+

Yes, but the burden moves to your team. You need clear answers for data residency, encryption, access control, audit logging, retention, backups, and deletion. Datadog centralizes many of those controls inside a managed service. With open source, you must design and prove them yourself, especially if logs or traces contain customer identifiers, secrets, or regulated business data.

How should we replace the Datadog Agent and existing instrumentation?+

Start by separating host collection from application instrumentation. For hosts and containers, test a vendor-neutral collection path that can emit the metrics, logs, and metadata your replacement expects. For applications, prefer open instrumentation standards where possible so traces and metrics are not tied to one backend. Keep the Datadog Agent during dual-write if it reduces cutover risk.

Will APM traces look the same after the switch?+

Not exactly. Trace ingestion may be straightforward, but the experience around service maps, dependency views, error grouping, sampling controls, and flame graph navigation will differ. Datadog also encourages certain naming and tagging conventions. Before switching, validate trace propagation across your main services, check whether spans retain useful attributes, and confirm that high-cardinality data will not overwhelm the new backend.

How do logs change when moving off Datadog?+

Logs are where cost and migration surprises often show up. Datadog log pipelines, parsing rules, indexes, facets, exclusion filters, and archives may have accumulated over years. Rebuild those intentionally instead of forwarding everything. Decide which logs need search, which need cheap retention, which fields must be parsed, and which sensitive values should be dropped before storage.

What should we test before cutting over alerts from Datadog?+

Run Datadog and the replacement in parallel for enough time to cover normal traffic, deploys, batch jobs, and at least one real incident or game day. Compare alert timing, missing data behavior, recovery notifications, grouping, deduplication, and escalation paths. A monitor that looks equivalent on paper can still page too late, page too often, or miss partial failures.

What if the open source project we choose gets abandoned?+

Reduce that risk by choosing portable data formats and keeping collection decoupled from storage and dashboards. Avoid writing application code directly against one backend's private assumptions when a standard telemetry path would work. Keep configuration in version control, document retention and backup procedures, and test exports periodically. If the backend changes later, you want a pipeline migration, not a full reinstrumentation project.