Observability invoices have a habit of catching engineering leaders off guard, even on teams that watch their cloud compute spend closely. Telemetry pricing simply scales along different axes than virtual machines do. As an illustrative example, take a reserved Linux container node costing $70 a month on AWS. Leave default agent settings untouched, and it is not unheard of for combined host licensing, APM fees, custom metric series, and indexed log events to cost more than the instance itself.

Maybe the question isn't which APM vendor posts the lowest unit price on its rate card, but rather why routine health checks and unbounded metric tags are reaching paid vendor ingest at all? Keeping telemetry spend proportional starts with separating threshold monitoring from high-cardinality debugging, matching the vendor's billing model to how your workloads run, and filtering noise at the collector before you pay to store it.

Monitoring vs. Observability in Daily Operations

On-call engineers rely on monitoring and observability for two distinct jobs. Paying high-cardinality prices for both is where budgets usually get away from a team.

Threshold monitoring checks failure conditions you already know to expect: synthetic HTTP probes failing from two regions, database disk usage crossing 85%, PostgreSQL replication lag rising past 10 seconds, or dead-letter queues growing. Those checks only need low-cardinality counters to wake up the right responder.

Distributed observability comes in when an unfamiliar regression shows up—correlating traces, SQL spans, and structured logs by tenant_id, release_sha, or shard to see why checkout p95 latency jumped after a Tuesday afternoon deploy. That diagnostic depth is well worth keeping on errors, slow outliers, and a representative baseline sample. Indexing 100% of healthy probe traffic does nothing to make that investigation faster.

Comparing Major APM Pricing Dimensions

Published vendor rate cards shift periodically, so always verify current pricing and committed-use terms (as of late 2026) before planning a migration. Even so, each major platform anchors its bill on a different part of your architecture:

Platform Primary Billing Dimensions Strongest Fit Common Cost Driver to Watch
Datadog Per-host (Infra and APM), custom metric cardinality, log ingest, indexed log retention, and ingested spans Teams wanting tightly correlated AWS, container, database, and RUM views out of the box High-water-mark hourly host peaks during autoscaling, unbounded tag cardinality on custom metrics, and indexing verbose info logs
New Relic Ingested data per GB plus per-user seat tiers (Core vs. Full Platform users) Small engineering teams running many small hosts or serverless functions with modest GB volume Full-Platform per-seat fees when broad engineering rosters require trace and dashboard access
Grafana Cloud Active Prometheus metric series, Loki log GB, and Tempo trace GB OpenTelemetry- and Prometheus-native stacks wanting open standards without running storage backends Label explosions (such as putting user IDs or request paths into Prometheus metric labels) multiplying active series
Sentry Error events, performance transaction spans, and session replay quotas Application teams prioritizing stack-trace grouping, release regression tracking, and frontend/backend error triage Uncapped client-side exception loops or 1.0 trace sampling on high-throughput API routes
OpenTelemetry + ClickHouse (Self-Hosted or Managed) Underlying compute, NVMe/object storage, and internal engineering upkeep High-volume workloads where commercial per-GB and per-host markups exceed internal operating effort Operating schema lifecycle, upgrades, and query tuning internally unless paired with managed operations

Cutting Datadog and APM Overages Before Switching Vendors

Ripping out an observability tool takes months of dashboard, alert, and runbook rework. Before going down that road, check what happens when you tighten up four common sources of telemetry waste—changes that usually fit inside a single sprint.

Audit Custom Metric Tag Cardinality

Under time-series billing models, every unique combination of tag values on a custom metric becomes its own billable series. Attach user_id, order_id, pod_uid, or unnormalized URL paths to a counter or histogram, and one metric can fan out into tens of thousands of active series before lunch. High-cardinality identifiers belong in trace attributes and structured log fields, not metric tags. Restrict metric tags to bounded dimensions like service, env, region, and status_class, and use Metrics Without Limits or collector drop rules to strip accidental high-cardinality labels right away.

Separate Archive Log Storage From Live Indexing

Compliance rules and post-incident forensics often call for 90 to 365 days of raw log retention, while engineers troubleshooting an active issue mostly search the last 3 to 7 days. Do all of those months need to sit in a paid live index? Rarely. Route full log streams into an S3 archive bucket where you can query them on demand via Athena or rehydration, and drop load-balancer 200 OK access logs, Kubernetes probes (/healthz, /readyz), and debug chatter from live paid indexes.

Watch Autoscaling Host High-Water Marks

Per-host contracts often calculate monthly overages from your 99th-percentile hourly host count. If a batch pipeline spins up forty short-lived worker nodes for two hours every afternoon, those brief peaks can trigger steep on-demand host charges compared with running a steadier worker pool or moving bursty jobs onto Fargate or serverless billing. Check how your contract counts concurrent hosts before tuning autoscaling rules.

Put an OpenTelemetry Collector Gate Ahead of Vendor Ingest

Running your own OpenTelemetry Collector tier keeps application instrumentation vendor-neutral while letting you apply tail-based sampling before data leaves your VPC. You can drop health-check spans outright, retain every errored or slow trace for debugging, and sample ordinary fast requests at a modest baseline:

# Illustrative OpenTelemetry Collector pipeline: drop health probes & tail-sample traces
processors:
  filter/drop_probes:
    error_mode: ignore
    traces:
      span:
        - 'attributes["http.route"] == "/healthz"'
        - 'attributes["http.route"] == "/readyz"'

  tail_sampling:
    decision_wait: 10s
    num_traces: 50000
    policies:
      - name: keep-server-errors
        type: status_code
        status_code: { status_codes: [ERROR] }
      - name: keep-slow-traces
        type: latency
        latency: { threshold_ms: 1200 }
      - name: sample-healthy-baseline
        type: probabilistic
        probabilistic: { sampling_percentage: 5.0 }

  batch:
    send_batch_size: 2048
    timeout: 5s

One operational detail matters with tail sampling in production: every span sharing a trace ID has to land on the same collector instance within decision_wait. Multi-replica collector tiers therefore need trace-ID-aware load balancing upstream, along with memory limits sized for peak in-flight spans. And of course, compute aggregate request rate, error rate, and latency histograms (RED metrics) from spans before tail sampling drops healthy traces—otherwise your SLO and error-budget numbers will skew toward failures.

If your stack also logs LLM prompts and token counts, pair these collector rules with our guide on LLM observability and cost optimization. Turning on compressed OTLP export and routing traffic through VPC endpoints where supported also keeps observability agents from inflating your NAT Gateway data transfer bill.