Datadog

A hosted monitoring platform: an agent on every host ships metrics, logs and traces to Datadog’s SaaS, which bills per host, per GB and per metric.

What it is: Observability
Used for: Metrics,Logs,Distributed tracing,Error tracking,Synthetic monitoring,Alerting
Type: Commercial product
Made by: Datadog, Inc.
License: Proprietary (the Datadog Agent is Apache 2.0)
Facts checked: 5 October 2026

What it is

The Datadog Agent is an open-source program, written in Go, that runs on every host, or as one pod per node in Kubernetes. It runs checks against the machine and the software on it through more than 1,000 integrations, accepts custom metrics over DogStatsD on UDP port 8125, takes traces from Datadog’s tracing libraries on TCP port 8126 and OpenTelemetry data over OTLP on 4317 and 4318, and tails log files. It sends everything over HTTPS on port 443 to the Datadog site (region) your account lives in. Storage, dashboards, search, monitors and alerting all live in Datadog’s proprietary backend, so the Agent is the only part you run.

Each product has its own meter. Infrastructure Monitoring is billed per host per month ($15 Pro, $23 Enterprise, billed annually), with hosts counted every hour and billed at the high-water mark of the lowest 99% of those hours. APM adds $31 per host. Logs are billed twice: $0.10 per GB ingested, then $1.70 per million events indexed for 15-day search. Custom metrics are counted per unique combination of metric name and tag values, and each host includes only 100 (Pro) or 200 (Enterprise). RUM, security, on-call and other products are priced separately, so the bill depends on how many hosts, tags, log lines and products you use, not only on the plan.

Why teams pick it

Metrics, traces and logs in one product, joined by shared tags, so you can go from a latency graph to the traces and log lines behind it
More than 1,000 integrations with out-of-the-box dashboards for common databases, web servers and cloud services
Nothing to operate besides the Agent: Datadog runs storage and keeps full-resolution metrics for 15 months on paid plans
Speaks OpenTelemetry: OTLP into the Agent, its own DDOT Collector, or direct OTLP intake, so instrumentation stays vendor-neutral
Logs can be ingested, live-tailed and archived to your own S3 bucket without indexing them, so you pay to search only what you choose

Watch out for

Many meters at once: hosts, GB ingested, million indexed log events, indexed spans and custom metrics. A tag with many values multiplies custom metrics, and every metric scraped from a Prometheus endpoint counts as custom
Extra indexed custom metrics are billed at a price set in your contract, not on the public price list, and installing the Agent inside each container makes each container a billable host
Proprietary SaaS with no self-hosted option. OpenTelemetry keeps instrumentation portable, but dashboards, monitors and saved queries don’t move to another tool
The free tier stops at 5 hosts and keeps metrics for only one day
OTLP log ingestion is off by default “to avoid unexpected billing”: a sign of how fast log volume turns into cost

Alternatives

What all observability have in common →

Amazon CloudWatchAWSAWS’s built-in monitoring service: metrics from every AWS service, logs, alarms and dashboards, and now traces, OpenTelemetry and PromQL, billed per metric, per GB and per alarm.

Better StackCommercialUptime checks, on-call paging and status pages, plus logs, traces, metrics and errors in a ClickHouse-based store, sold as one SaaS billed per responder and per GB.

ClickStackOpen sourceClickHouse’s open-source observability stack: an OpenTelemetry collector, ClickHouse for storage and the HyperDX UI for search, dashboards and alerts on logs, traces, metrics and session replays.

GrafanaOpen sourceDashboards and alerts over data that stays where it is: Prometheus, SQL databases, cloud monitoring and more.

OpenTelemetryOpen sourceThe vendor-neutral standard for producing and shipping traces, metrics and logs, with SDKs for most languages and a Collector to route the data.

How it fits with other technologies

What Datadog uses

What uses Datadog

/etc/datadog-agent/datadog.yaml: logs, APM and an OTLP receiver · yaml

api_key: <DD_API_KEY>
site: datadoghq.eu              # the region your account lives in
tags:
  - env:prod
  - team:payments

logs_enabled: true              # then add conf.d/<app>.d/conf.yaml with the file paths

apm_config:
  enabled: true                 # trace receiver on localhost:8126

otlp_config:
  receiver:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318
  logs:
    enabled: true               # off by default: logs are billed per GB

# sudo systemctl restart datadog-agent
# custom metric: echo -n "checkout.completed:1|c|#plan:pro" | nc -4u -w1 localhost 8125

What you pay for#

List prices from datadoghq.com, checked 5 October 2026. Each product has its own unit, and most teams pay for several at once.

Product	Unit	Billed annually	On demand
Infrastructure Pro	Per host, per month	$15	$18
Infrastructure Enterprise	Per host, per month	$23	$27
APM (with Infrastructure)	Per host, per month; 150 GB of spans per host included	$31	$48
Log ingestion	Per GB ingested (uncompressed)	$0.10	$0.10
Log indexing, 15-day retention	Per million log events	$1.70	$2.55
Custom metrics	Per unique metric name and tag values	100 per host included (200 on Enterprise); extra indexed ones at your contract price	Same
On-Call	Per seat, per month	$20	$29

Hosts and custom metrics are metered hourly; the month’s bill uses the highest count after dropping the top 1% of hours.
Free plan: up to 5 hosts with 1-day metric retention.

What each covers#

Datadog, Better Stack and Sentry overlap but start from different places. An open-source stack covers the same ground with several tools you run yourself.

Signal	Datadog	Better Stack	Sentry	Open-source stack
Metrics	Infrastructure Monitoring, per host plus custom metrics	Yes, billed per GB retained	Yes, billed per GB	Prometheus
Logs	Per GB ingested, then per million events indexed	Per GB ingested and per GB-month retained	Yes, 5 GB included, then per GB	Grafana Loki, or ClickHouse
Traces	APM, per host	Yes, OpenTelemetry and eBPF	Yes, billed per span	Jaeger, fed by OpenTelemetry
Errors	Error Tracking	Yes, accepts Sentry SDKs	Its core product	Self-hosted Sentry (source-available, not OSI open source)
Uptime checks	Synthetic API and browser tests	Yes, its first product	HTTP uptime monitors	Prometheus blackbox exporter
On-call and status pages	On-Call and Status Pages products	Both built in	No; alerts go out to PagerDuty, Slack and others	Alertmanager routes alerts; paging and status pages need other tools

See it in a real stack

No architecture uses Datadog yet. Drop it into the playground and wire it up yourself.Open playground →

Where it came from2010–2019

Olivier Pomel and Alexis Lê-Quôc worked together at Wireless Generation, a New York education software company, Pomel as VP of Technology and Lê-Quôc running operations. Developers and operations teams, the company later argued, had worked apart with separate goals, priorities and tools. The two founded Datadog in New York in June 2010 with the goal, as the company later put it, of “breaking down silos between Dev and Ops”.

The first product, in 2012, was infrastructure monitoring built for cloud servers that come and go. APM followed in 2017, and in 2018 log management completed what Datadog called the “three pillars of observability”: metrics, traces and logs in one place. The 2018 log product split ingestion from indexing, so customers could collect and archive every log but pay to index only some. Datadog went public on the Nasdaq in September 2019 at $27 a share, under the ticker DDOG.

Since then the platform has grown into dozens of separately priced products, from real user monitoring and security to on-call and status pages, all fed by the same Agent and the same tags.

Why it’s built this way

One agent per host, many integrations: Cloud servers appear and disappear constantly. A single agent that discovers what runs on the host and reports it, rather than per-application setup, keeps monitoring up with that churn.
Tags on everything: Metrics, traces and logs carry the same tags (host, service, env), which is what lets the product line them up side by side. It is also why each new tag value creates new billable custom metrics.
Ingest everything, index selectively: Indexing every log was too expensive, so teams dropped logs before sending them and lost them in incidents. Logging without Limits (2018) archives all logs cheaply and indexes only the ones you pick.

Timeline

2010
Pomel and Lê-Quôc found Datadog in New York in June
2012
First product: infrastructure monitoring
2017
APM launches
2018
Agent 6 rewritten in Go; log management with Logging without Limits
2019
IPO on the Nasdaq in September at $27 a share

Sources29 · facts checked 5 October 2026

Improve this page on GitHub