12 Kubernetes Observability Tools for Better Insights

Twelve open source Kubernetes observability tools for metrics, logs, traces and alerts: what each does, current versions and how to combine them.

Dec 24, 2025 - 13:02
Nov 10, 2026 - 20:10
 0  53
12 Kubernetes Observability Tools for Better Insights

A practical Kubernetes observability stack needs tools for four jobs: collecting metrics (Prometheus, kube-state-metrics, metrics-server), shipping and storing logs (Fluent Bit, Loki), tracing requests (OpenTelemetry, Jaeger, Tempo) and alerting and visualising (Alertmanager, Grafana). Thanos adds long-term metrics storage and Pixie adds eBPF-based visibility without code changes.

Kubernetes moves workloads around constantly. Pods are rescheduled, nodes are replaced and IP addresses change, so the questions "what is slow" and "why did it fail" need data from several layers at once. This list covers twelve open source tools that teams commonly combine for that purpose, what each one does, where it fits and what to watch for. Version numbers come from each project's release pages in November 2026. For the general tool comparison outside Kubernetes, start with our pillar post on observability tools for DevOps monitoring.

Key takeaways

  • No single tool covers metrics, logs and traces well. Most production stacks combine four to six of the tools below.
  • Prometheus with kube-state-metrics and Grafana is the most common starting point for cluster metrics.
  • OpenTelemetry is the vendor-neutral way to instrument applications. It supports traces, metrics, logs and baggage as signals.
  • Loki and Tempo store logs and traces in object storage, which keeps retention costs down.
  • Choose tools by the questions your on-call engineers need to answer, then add storage and retention to match.

The twelve tools at a glance

#ToolSignalMain job in Kubernetes
1PrometheusMetricsScrapes and stores time series, evaluates alert rules
2kube-state-metricsMetricsTurns Kubernetes object state into metrics
3metrics-serverMetricsFeeds the resource Metrics API for autoscaling and kubectl top
4AlertmanagerAlertsGroups, routes and silences Prometheus alerts
5GrafanaVisualisationDashboards and exploration across data sources
6ThanosMetricsLong-term storage and global queries for Prometheus
7Fluent BitLogsLightweight log collection from every node
8Grafana LokiLogsLog storage indexed by labels
9OpenTelemetryTraces, metrics, logsStandard instrumentation and the Collector pipeline
10JaegerTracesDistributed tracing backend and UI
11Grafana TempoTracesTrace storage on object storage with TraceQL
12PixieAuto-telemetryeBPF-based visibility without code changes

Metrics

1. Prometheus

Prometheus is the default metrics system for Kubernetes and a graduated CNCF project. It discovers targets through the Kubernetes API, scrapes their /metrics endpoints on a schedule, stores the samples locally and evaluates recording and alerting rules written in PromQL. The latest release on the Prometheus download page is 3.16.0, and the long-term support line is 3.13.

Most teams install it through the kube-prometheus-stack Helm chart or the Prometheus Operator, which manage scrape configuration through ServiceMonitor and PodMonitor custom resources. Watch label cardinality: a label holding user IDs or request paths can multiply series counts and memory use. Our Prometheus and Grafana guide walks through a full setup.

apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: orders-api
  labels:
    release: kube-prometheus-stack
spec:
  selector:
    matchLabels:
      app: orders-api
  endpoints:
  - port: http-metrics
    interval: 30s

2. kube-state-metrics

kube-state-metrics listens to the Kubernetes API server and generates metrics about objects: Deployments with unavailable replicas, pods stuck in Pending, jobs that failed, PersistentVolumeClaims that are not bound. It does not measure CPU or memory use. It serves plain-text metrics on port 8080 at /metrics, with its own telemetry on 8081. The current release is v2.20.0. Many of the most useful Kubernetes alerts, such as a Deployment that has not reached its desired replica count, depend on it.

3. metrics-server

metrics-server collects CPU and memory usage from each kubelet and serves the latest values through the Metrics API. The Horizontal Pod Autoscaler and kubectl top rely on it. It keeps only current values in memory, so it is not a monitoring system; treat it as plumbing for autoscaling and use Prometheus for history.

4. Alertmanager

Prometheus decides when an alert fires; Alertmanager decides who hears about it. It groups related alerts, removes duplicates, routes by labels to email, chat or paging tools, and supports silences during maintenance. The latest release is 0.35.0. Good routing, such as sending namespace-owned alerts to the owning team, does more for on-call quality than adding more alert rules. Our list of cloud monitoring alerts to configure gives starting rules.

5. Grafana

Grafana is the dashboard layer for most open source stacks. It queries Prometheus, Loki, Tempo, Jaeger and many other data sources, so an engineer can move from a latency graph to the matching logs and traces in one place. Keep dashboards in Git as JSON or provision them through code so they survive cluster rebuilds.

6. Thanos

A single Prometheus server keeps data on local disk for a limited time and only sees its own cluster. Thanos, an incubating CNCF project, adds a sidecar that uploads Prometheus data blocks to object storage and a query layer that reads across many Prometheus servers. It suits organisations that run several clusters and need months of metrics history. Cortex and Mimir solve a similar problem with a different architecture.

Logs

7. Fluent Bit

Fluent Bit runs as a DaemonSet on every node, reads container log files, adds Kubernetes metadata such as namespace, pod name and labels, and forwards records to a backend. It is part of the Fluentd project family, which is a graduated CNCF project, and is designed to use little memory and CPU. Use its filters to drop noisy debug logs before they reach storage.

8. Grafana Loki

Loki stores logs cheaply by indexing only labels, not the full text, and keeping log content compressed in object storage. You query with LogQL, which uses the same label selectors as PromQL, so switching from a metric to its logs is natural. The latest stable release is v3.7.10, with v4.0 in release candidates. Keep labels low in cardinality; putting request IDs in labels causes the same problems as in Prometheus. For log locations that are easy to miss, see hidden Kubernetes logs you should check.

Traces

9. OpenTelemetry

OpenTelemetry provides APIs, SDKs and a Collector for producing and shipping telemetry in a vendor-neutral format. Its documentation lists traces, metrics, logs and baggage as supported signals; profiles are still in development. In Kubernetes, the OpenTelemetry Operator can inject auto-instrumentation into pods for several languages, and the Collector can run as a DaemonSet or Deployment to receive, process and export data to any backend. Instrumenting with OpenTelemetry means you can change backends later without touching application code.

receivers:
  otlp:
    protocols:
      grpc:
      http:
processors:
  batch:
exporters:
  otlp:
    endpoint: tempo.observability.svc:4317
    tls:
      insecure: true
service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlp]

10. Jaeger

Jaeger is a graduated CNCF tracing project with its own UI for searching traces and viewing service dependency graphs. Jaeger v2, released in November 2024, is built on the OpenTelemetry Collector framework, so it accepts OpenTelemetry data natively. The documentation lists 2.23 as the latest version. Teams on Jaeger v1 should follow the project's migration guide.

11. Grafana Tempo

Tempo is a tracing backend that needs only object storage, which makes high trace volumes affordable. It accepts Jaeger, Zipkin and OpenTelemetry protocols and offers TraceQL, a query language modelled on PromQL and LogQL, for finding spans by attributes such as duration or status. It can also generate metrics from spans. Pair it with Grafana to jump from a slow request in a dashboard to the exact trace.

Zero-instrumentation visibility

12. Pixie

Pixie is a CNCF sandbox project that uses eBPF probes to collect metrics, events, traces and logs from Kubernetes workloads without changes to application code. It can show HTTP, database and DNS traffic between services shortly after installation, which helps during incidents in services nobody has instrumented yet. Because it runs privileged probes on nodes, review its security requirements with your platform team before installing it in production.

Putting a stack together

There is no single correct combination, but three common shapes cover most teams:

Team situationSuggested stack
One cluster, small team, just startingkube-prometheus-stack (Prometheus, Alertmanager, Grafana, kube-state-metrics), metrics-server, Fluent Bit to Loki
Several clusters, need historyAdd Thanos or a similar long-term store, central Grafana, OpenTelemetry Collector per cluster
Microservices with latency problemsAdd OpenTelemetry instrumentation with Tempo or Jaeger, and use Pixie for services not yet instrumented

Questions to answer before installing anything

  • What do on-call engineers need to know in the first five minutes of an incident?
  • How long must metrics, logs and traces be kept, and for what reason?
  • Who owns dashboards and alert rules for each namespace?
  • Will you run the storage yourselves or use a managed service?
  • How will you control cardinality and log volume as the cluster grows?

A rollout order that works

Installing everything at once tends to produce dashboards nobody reads. A staged order keeps each step useful. Start with Prometheus, kube-state-metrics, Alertmanager and Grafana, and write five or six alerts for symptoms users would notice. Add Fluent Bit and Loki next, so the engineer who receives an alert can read the matching logs. Instrument the two or three busiest services with OpenTelemetry and send traces to Tempo or Jaeger. Only then add long-term storage with Thanos, once you know how much history people actually query.

Common mistakes

  • Alerting on causes instead of symptoms. Page on user-facing error rates and latency; send CPU warnings to a dashboard.
  • No resource limits on the monitoring stack. Prometheus and log collectors can starve workloads during a spike. Give them requests, limits and their own node pool if needed.
  • Unbounded labels. High-cardinality labels are the most common cause of Prometheus and Loki memory problems.
  • Separate tools with no links. Add trace IDs to log lines and use Grafana data links so engineers can move between signals.
  • Monitoring that dies with the cluster. Keep at least alerting and a basic health check outside the cluster being monitored.

Our post on observability metrics for cloud-native systems lists which signals to collect first, and observability vs traditional monitoring explains why the three signals need to work together.

Learning path

Prometheus and Grafana are the base of most Kubernetes observability work and appear in many SRE and DevOps interviews. Our Prometheus and Grafana training covers PromQL, exporters, alerting and dashboards on real clusters, in Kharadi, Pune and live online across India.

Frequently asked questions

What is the best Kubernetes observability tool?

No one tool covers everything. Most teams start with Prometheus, kube-state-metrics, Alertmanager and Grafana for metrics, then add Fluent Bit with Loki for logs and OpenTelemetry with Tempo or Jaeger for traces.

What is the difference between kube-state-metrics and metrics-server?

metrics-server reports current CPU and memory use for autoscaling and kubectl top. kube-state-metrics reports the state of Kubernetes objects, such as replica counts and pod phases, for Prometheus to scrape.

Do I need OpenTelemetry if I already use Prometheus?

For metrics alone, Prometheus may be enough. OpenTelemetry becomes valuable when you add tracing or want vendor-neutral instrumentation that can send data to different backends.

Is Jaeger or Tempo better for tracing?

Both accept OpenTelemetry data. Jaeger has its own UI and is a graduated CNCF project. Tempo stores traces only in object storage and integrates closely with Grafana. Pick based on your existing stack and storage costs.

How do I keep observability costs under control?

Limit label cardinality, drop noisy logs at the collector, sample traces, set retention per signal and store long-term data in object storage through tools like Thanos, Loki and Tempo.

What is Pixie used for?

Pixie gives instant visibility into service traffic using eBPF, without changing application code. It is useful for troubleshooting services that are not instrumented yet.

References

What's Your Reaction?

Like Like 0
Dislike Dislike 0
Love Love 0
Funny Funny 0
Angry Angry 0
Sad Sad 0
Wow Wow 0
Mridul I am a passionate technology enthusiast with a strong focus on DevOps, Cloud Computing, and Cybersecurity. Through my blogs at DevOps Training Institute, I aim to simplify complex concepts and share practical insights for learners and professionals. My goal is to empower readers with knowledge, hands-on tips, and industry best practices to stay ahead in the ever-evolving world of DevOps.