Kubernetes monitoring tools: an honest roundup

The ten, and what each is for

Under each name is a screenshot of that vendor's own interface, so you can get a feel for what your team would be working in day to day. These are general product views rather than the Kubernetes-specific screens described below, and vendors redesign often enough that it is worth checking the current interface before you decide.

Prometheus

Prometheus is a CNCF-graduated metrics toolkit and the foundation most Kubernetes monitoring stacks are still built on. It discovers pods, services and nodes through the Kubernetes API rather than static configuration, scrapes them on an interval so a failed scrape stays visible instead of vanishing, and lets you query with the same concepts you use to organize workloads.

Its scope is metrics rather than full observability, with logs and traces outside the core project. That is a reasonable division of labor rather than a shortcoming, and it is why Prometheus so often sits underneath something else.

Key features

• Kubernetes service discovery: Queries the Kubernetes API to find pods, services and nodes as they are created or removed, keeping scrape targets current without static configuration.

• Pull-based scraping: Fetches metrics from each target on an interval, so a failed scrape stays visible rather than silently disappearing.

• PromQL: A label-based query language for aggregating and filtering metrics across pods, services and namespaces.

• kube-state-metrics integration: Exposes Kubernetes object state, including deployment replica counts, pod status and resource requests.

• Alertmanager: Handles alert routing, grouping and deduplication separately from Prometheus, which makes noisy or repeated alerts easier to manage.

Pricing and rating

No license cost, since it is free open-source software. Running it in production means paying for the servers, storage and scaling it needs.

G2 rating: 4.5 out of 5, from around 61 reviews.

Tsuga

We deploy observability clusters inside your own cloud account, so Kubernetes logs, metrics and traces stay alongside the workloads they describe. We manage deployment, upgrades and autoscaling remotely while storage and compute stay on your cloud bill, which means telemetry growth becomes part of infrastructure you already own rather than a separate bill that rises with every host and pod.

Cardinality quality reports surface high-cardinality tags and unused metrics, inline filtering and transformation happen at the edge before storage, and SLOs can be defined and tracked per workload. Pricing is one flat rate per gigabyte ingested with retention included and no per-host tax.

Key features

• In-cluster BYOC deployment: Runs observability infrastructure inside your own cloud account on AWS, Google Cloud or Azure, using infrastructure-as-code, so pod and node telemetry stays within the same cloud boundary as the workloads.

• Cardinality quality reports: Detects high-cardinality tags and unused metrics, so teams can cut Kubernetes telemetry without losing useful context.

• Inline WASM filter transformation: Filters and transforms telemetry at the edge before storage, reducing the pod-level logs and metrics that would otherwise need downstream indexing.

• SLI and SLO definition: Lets teams set service-level objectives for Kubernetes workloads and track performance against them rather than against raw metrics.

• Forward-deployed engineer: A named engineer who helps tune retention, pipelines and access as the cluster's telemetry needs change.

Pricing

A flat rate per gigabyte ingested. Retention is included, fields are unlimited and there is no per-host tax, so the bill tracks telemetry volume rather than plan tiers or added columns. It runs inside your own cloud account, which removes the infrastructure markup.

Grafana Cloud

Grafana Cloud packages Loki, Grafana, Tempo and Mimir as a managed backend, so teams collect Prometheus-based metrics, logs and traces without operating the storage layer. Its Kubernetes app organizes telemetry around clusters, nodes, pods and containers, and a curated Helm chart installs the collectors with sensible defaults.

It also detects workloads beyond the standard Deployments and StatefulSets, including Argo Rollouts and bare pods, and brings cluster events into the same object views as the metrics. For a team already invested in the Grafana ecosystem, the continuity is the main argument.

Key features

• Kubernetes Monitoring app: Views organized around clusters, nodes, pods and containers, so issues are investigated inside the Kubernetes structure rather than beside it.

• Curated Helm chart deployment: Installs Node Exporter and Grafana Alloy with collection preconfigured, which removes most of the manual setup.

• Non-standard workload detection: Picks up workloads beyond Deployments and StatefulSets, including Argo Rollouts, Strimzi PodSets and bare pods.

• Cost and resource views: Shows utilization and spend by cluster, which is usually how over-provisioned workloads get found.

• Logs and events correlation: Brings logs and Kubernetes events into the same object views as metrics, reducing tool switching during an investigation.

Pricing and rating

Free to start, then Pro at $19 per month plus usage. Kubernetes Monitoring bills per host hour ($7.20) and per container hour ($0.50), with metrics, logs and traces priced separately. Enterprise plans start at a $25,000 annual commitment.

G2 rating: 4.5 out of 5, from around 190 reviews.

Datadog

Datadog runs an agent as a DaemonSet with a cluster agent talking to the API server, which together collect metrics, logs, traces and container state without per-service configuration. Its Kubernetes Explorer moves you from a namespace-level problem to a specific pod without changing screens, and autodiscovery applies monitoring templates to containerized services as they start.

The breadth is genuinely unmatched, and so is the configuration-free onboarding. What comes with it is a bill assembled from several meters at once, which is why cost management tends to become its own engineering discipline.

Key features

• Autodiscovery: Detects containerized services as they start and applies the matching monitoring template automatically.

• Kubernetes Explorer: Resource-level views of pods, deployments and namespaces, with cluster maps, failed pod detail and the related logs in reach.

• Cluster Agent: Queries the Kubernetes API on behalf of the node agents, which cuts direct API traffic and centralizes cluster metadata.

• Kubernetes tag mapping: Converts pod and node labels and annotations into Datadog tags, making Kubernetes metadata available for filtering and grouping.

• Orchestrator-level tagging: Adds pod and container context to metrics, which is what isolates an issue in a dense or fast-changing cluster.

Pricing and rating

Free for up to 5 hosts, then per host. Infrastructure starts at $15 and APM adds $31 on top. Cluster autoscaling pushes the host count, and the bill, higher during traffic spikes.

G2 rating: 4.4 out of 5, from around 726 reviews.

Dynatrace

Dynatrace uses a single agent to discover pods, services and dependencies without deployment changes, then feeds that into a live topology model of how services connect. Its AI correlates anomalies across nodes, pods, containers and applications to propose a root cause rather than a list of symptoms, and groups alerts from one underlying issue into a single notification.

For a large enterprise estate where dependency mapping is the hard part, that automation is the reason to look at it. The trade is that the topology model works best when the whole estate is instrumented its way.

Key features

• OneAgent auto-instrumentation: Discovers pods, services and dependencies after deployment, so new workloads are monitored without config or code changes.

• Smartscape topology mapping: Builds a real-time map of service relationships, showing how an issue in one workload reaches the services that depend on it.

• Davis AI root cause analysis: Correlates anomalies across infrastructure and application layers to name a likely cause instead of listing symptoms.

• Problem-based alert grouping: Collapses alerts from one underlying issue into a single notification, which cuts the repetition of a multi-service incident.

• Workload and resource views: Shows replica counts, resource limits and utilization by workload, making the configuration problems behind instability easier to spot.

Pricing and rating

Kubernetes Platform Monitoring is $1.40 per pod per month on its own, and included at no extra charge for hosts running Full-Stack Monitoring at $58 per 8 GiB host per month. Both draw down an annual platform commitment.

G2 rating: 4.5 out of 5, from around 1,366 reviews.

New Relic

New Relic pairs a standard Kubernetes integration covering nodes, namespaces, deployments and pods with eBPF-based telemetry that captures traces, HTTP calls and service maps without language-specific instrumentation. An engineer can move from a pod restart to the slow query behind it without assembling the picture across tools.

It ships predefined alerts for the failures every cluster meets, CrashLoopBackOff and OOMKilled among them. That is a small thing, and it saves the kind of setup time nobody budgets for.

Key features

• Auto-telemetry with Pixie: eBPF capture of traces, HTTP calls and service maps across workloads, with no language-specific instrumentation and no code changes.

• Kubernetes cluster explorer: The cluster from control plane through nodes and pods, with Kubernetes data collected separately from Pixie's application telemetry.

• APM auto-attach: Links application performance data to Kubernetes deployments without extensive manual setup.

• Live debugging with flame graphs: Identifies slow code and resource-heavy operations from Pixie's continuous collection.

• CrashLoopBackOff and OOMKilled detection: Predefined alerts for the common Kubernetes failures, so nobody writes those rules from scratch.

Pricing and rating

Billed on data ingested plus user seats, so going from 50 to 500 pods does not multiply the bill on its own. The free tier covers 100 GB a month, and beyond that data runs $0.40 or $0.60 per GB plus per-user fees.

G2 rating: 4.4 out of 5, from around 586 reviews.

Sysdig

Sysdig offers managed Prometheus with PromQL and Grafana-compatible dashboards, collecting on a ten second interval by default and adding Kubernetes context such as events, process activity and network metrics. Its advisor surfaces the common cluster problems with remediation steps and the relevant logs attached.

The distinctive part is that monitoring and runtime security share one collection layer. A performance question and a security question can then be investigated without maintaining two pipelines, which is a real saving for teams that own both.

Key features

• Advisor: Surfaces the common cluster problems, CrashLoopBackOffs, pod evictions and resource limit trouble among them, with remediation steps and the relevant logs.

• Cost Advisor: Breaks Kubernetes cost down by cluster, namespace and workload, and flags idle or overprovisioned compute.

• Managed Prometheus service: Handles Prometheus storage and scaling, which removes the operational work of running it at cluster scale.

• Falco-based runtime security: Watches kernel-level system calls against defined rules to catch unusual container behavior, using the same agent that collects the monitoring data.

• Dashboard library: Ready-made dashboards for workload and pod health, resource availability and capacity planning across clusters.

Pricing and rating

Priced per host, with custom metrics billed separately by time series. Estimates run $40 to $120 per host per month depending on product mix and cluster cardinality.

G2 rating: 4.7 out of 5, from around 156 reviews.

Elastic Observability

Elastic collects through its own OpenTelemetry distribution deployed as a DaemonSet, gathering node, pod, container and application telemetry alongside logs and traces. Its columnar time series storage is built for label growth, which is the specific problem ephemeral pods create, and it accepts Prometheus remote write so existing scrape configuration keeps working.

If your constraint is cardinality and you are standardizing on OpenTelemetry, that storage architecture is the argument. It also puts security data in the same place, which some teams want and others deliberately keep apart.

Key features

• EDOT Kubernetes collectors: Deploys OpenTelemetry collectors through the kube-stack Helm chart, collecting Kubernetes state data without a separate exporter.

• Time Series Data Stream architecture: Stores high-cardinality metrics in a columnar, on-disk format, which keeps memory pressure down as pod and namespace labels churn.

• Native Prometheus remote write: Accepts existing Prometheus metrics directly, so scrape configuration survives the move to Elastic storage and querying.

• Automatic downsampling: Cuts the storage historical metrics need while keeping higher resolution for recent investigations.

• Kubernetes Security Posture Management: Flags configuration problems in cluster and workload manifests before they reach production.

Pricing and rating

Priced on ingest and retention. Serverless plans run from $0.07 to $0.023 per GB ingested, plus $0.017 to $0.019 per GB retained each month. Clusters producing more logs and metrics cost proportionally more, regardless of node count.

G2 rating: 4.3 out of 5, from around 104 reviews.

Splunk Observability Cloud

Splunk collects through an OpenTelemetry Collector and presents clusters as a navigable map of nodes, pods and containers with health visible at each level. Data appears within seconds of the collector connecting, and its detectors cover common Kubernetes anomalies without anyone writing rules first.

Teams who think visually tend to get on with it quickly. Moving from a cluster view down to a single pod without first building the dashboard to do it is the part people remember.

Key features

• Kubernetes Navigator: A hierarchy-based map of nodes, pods and containers, with statuses such as Node Ready, Memory Pressure and Pod Phase visible at a glance.

• AutoDetect: Creates detectors for common Kubernetes anomalies automatically, giving baseline monitoring without configuring rules from scratch.

• Kubernetes entities view: Table, dashboard and heatmap views, with filters across each for exploring cluster data.

• OpenTelemetry Collector-based ingestion: Populates the Kubernetes views from OTel Collector metrics, which keeps collection on an open standard.

• Related content links: Connects AutoDetect alerts to runbooks and APM traces, adding context at the moment an engineer needs it.

Pricing and rating

A free edition, then per host. Infrastructure starts at $15 per host per month, App & Infra at $60 and End-to-End at $75, all billed annually. Kubernetes nodes count as hosts, so autoscaling raises the host count and the bill.

G2 rating: 4.3 out of 5, from around 55 reviews.

SigNoz

SigNoz was built around OpenTelemetry from the start, so clusters send metrics, logs and traces through the standard Collector rather than a proprietary agent. Everything lands in one backend, which makes moving from a pod restart to the relevant traces and logs a single investigation rather than three.

It also exposes cluster context, pod status and node metrics to coding agents through an MCP server. For teams who investigate from a terminal and increasingly from an agent, that is a genuinely forward-looking piece of design.

Key features

• OTel Collector via Helm: Deploys collector components with the k8s-infra chart, a DaemonSet for node and pod data and a Deployment for cluster metrics and events.

• Pod-level cluster monitoring: Tracks CPU, memory, disk and network for individual pods and nodes, with dashboards for pod health and resource saturation.

• Kubernetes events monitoring: Collects cluster state-change events through the collector, which is what tells you what preceded a pod failure.

• Unified logs, metrics and traces: Keeps the three signals in one backend, simplifying correlation between application behavior, infrastructure and log evidence.

• MCP server for coding agents: Exposes cluster context, pod status, node metrics and traces to agents such as Claude Code, so an investigation can run from a terminal workflow.

Pricing

SigNoz Cloud starts at $49 per month with no host or user fees. Logs and traces are $0.30 per GB ingested and metrics $0.10 per million samples, and unlimited hosts are monitored on any plan.

How to choose

A few things matter more than the length of a feature list. Each of the four below has decided more evaluations than any capability comparison we have watched.

Cardinality handling

Pod, node, namespace and container labels create time series in the millions, and how a platform absorbs that decides whether it becomes a cost problem, a performance problem or neither. Ask what happens to the bill and to query latency as label growth continues, because the answer is rarely in the feature list.

Correlation across signals

Metrics, logs and traces should be easy to read together. During an incident, switching tools to connect a latency spike with the log line behind it is exactly the friction you are paying to remove, and a shared metadata model is what removes it.

Deployment model

SaaS, BYOC and self-managed carry different consequences for data residency, control and operational overhead. This is the choice that is hardest to reverse later, so it is worth settling against your compliance requirements rather than your feature preferences.

How the tool charges

Per host and per container pricing makes autoscaling expensive, since a cluster growing from twenty to eighty nodes takes the monitoring bill with it. Look for a model that scales with something you control rather than with something Kubernetes does automatically.