Free tools Windows power users keep installed
One-click scans. No signup required.
Kubernetes observability means collecting and making useful sense of metrics, logs, and traces from the cluster and the applications running on it. OpenTelemetry can standardize how telemetry is generated, collected, processed, and exported, but it is not the database or dashboard where you store and inspect that data. A practical design pairs suitable instrumentation and collection with destinations that fit your retention, governance, and operating requirements.
What Kubernetes observability covers
Kubernetes describes observability as collecting and analyzing metrics, logs, and traces to understand a cluster’s internal state, performance, and health. Taken together, these signals can help connect a symptom—such as a slow request—to the workload, node, or component involved.
As an Amazon Associate I earn from qualifying purchases.
“Cluster observability” does not mean that one agent automatically captures everything. Decide which sources are in scope: control-plane and node components, Kubernetes object state, application output, distributed requests, and, where required, system or audit records. Each may need different collection permissions, retention, and access controls.
How the three telemetry pipelines differ
| Signal | What it helps answer | Typical Kubernetes collection path | Common destination examples |
|---|---|---|---|
| Metrics | How much, how often, and whether a value is changing over time | Scrape Prometheus-format endpoints, including component and kubelet endpoints; add Kubernetes object-status context where useful | Prometheus, Cortex, Mimir, or Thanos |
| Logs | What a process reported at a particular time | Read container output written to stdout and stderr, commonly with a node-level agent; define separately whether system and audit records are included | Fluent Bit, Fluentd, Loki, Elasticsearch, or OpenSearch |
| Traces | How a request moved between services and where time was spent | Instrument applications or supported components, then export spans using OTLP or another compatible route | Tempo, Jaeger, Zipkin, or a Collector pipeline that forwards to a trace backend |
These are examples, not interchangeable products or complete end-to-end stacks. Confirm that the destination supports the signals, protocols, context, and query patterns you actually need.
#1 Best Overall
Metrics: scrape endpoints and add Kubernetes context
The API server, scheduler, controller manager, kubelet, and kube-proxy expose Prometheus-format metrics at /metrics endpoints. A common pipeline scrapes selected endpoints periodically and writes samples to time-series storage, from which dashboards, alerts, or automation can consume them.
The kubelet also exposes cAdvisor, resource, and probe metric endpoints. Kube-state-metrics can add information about Kubernetes objects and their status, complementing measurements such as CPU or memory use. For longer-term or broader multi-cluster querying, Kubernetes documentation names Thanos and Cortex as complementary systems; they do not remove the need to plan collection and storage.
Logs: container output is only part of the picture
The container runtime captures application stdout and stderr, and Kubernetes makes container logs available through kubectl logs. For centralized collection, a node-level logging agent commonly reads log files and forwards records to a central store. Kubernetes lists Fluent Bit and Fluentd among agent examples, and Loki, Elasticsearch, and OpenSearch among destination examples.
Specify whether the pipeline also collects system-component output or audit records. Those sources have different operational and security implications from application logs; access should be limited appropriately, and retention should match the purpose of collection.
Rank #3
Traces: follow requests across services
Distributed traces represent request flow and timing across services and components. Kubernetes documentation describes system-component spans exported over OTLP with gRPC exporters, either through a Collector or directly to a configured backend. A Collector can process spans—for example, by sampling or redacting data—before forwarding them.
The Kubernetes observability documentation specifically mentions OTLP span export for Kubernetes 1.37. Treat that as release-specific guidance, not a guarantee for every cluster version: check the documentation and configuration for the Kubernetes release you operate before enabling it.
Rank #4
What OpenTelemetry does—and does not do
OpenTelemetry is a vendor-neutral framework for instrumenting, generating, collecting, and exporting telemetry such as traces, metrics, and logs. Its components help create and move telemetry; they do not, by themselves, provide a storage backend or dashboard product.
The OpenTelemetry Collector is an optional but useful pipeline point: it can receive telemetry, process it, and export it to one or more destinations. That separation can make it easier to change routing or destinations without coupling application instrumentation to one backend, provided the destination supports the emitted formats and features. It also adds configuration and infrastructure to operate. Direct export can be appropriate in some cases, including the documented Kubernetes system-trace path, when its processing and routing needs are modest.
Kubernetes-aware Collector components
Depending on the Collector distribution and version, useful component examples include:
- OTLP receiver: accepts application telemetry already emitted using OTLP.
- Kubernetes Attributes Processor: enriches telemetry with Kubernetes metadata.
- Kubeletstats Receiver: collects node, pod, and container metrics.
- Filelog Receiver: reads Kubernetes or application log files.
- Kubernetes Cluster Receiver and Kubernetes Objects Receiver: collect cluster-level and object-related information.
- Prometheus Receiver and Host Metrics Receiver: collect Prometheus-formatted metrics and host metrics, respectively.
Component availability and configuration can differ among Collector distributions and releases. Check the documentation for the exact distribution you deploy instead of copying a configuration solely because a component appears in a general component list.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Choose an instrumentation approach
| Approach | Best fit | Trade-offs to assess |
|---|---|---|
| Language SDKs and code instrumentation | Teams that can change application code and need explicit control over spans, metrics, and logs | Requires application work; language support and feature coverage vary |
| OpenTelemetry Operator and auto-instrumentation | Teams that want Kubernetes-managed Collector deployment and supported workload injection | Can reduce code changes, but introduces cluster-level configuration and operational responsibilities |
| eBPF-based instrumentation | Suitable Linux environments where a no-code-change option fits the service and protocol coverage | Grafana’s Beyla documentation specifies Linux kernel 5.8 or higher with BTF enabled; validate workload coverage and behavior for your services |
These methods are not necessarily mutually exclusive. A platform team might use SDKs where application teams need deliberate spans and use another method for suitable workloads. Do not assume automatic instrumentation captures the same context or application-specific meaning as purposeful code instrumentation.
Choose a backend by requirements, not by a universal ranking
Kubernetes documentation names multiple tools across metrics, logs, and traces; the examples above are categories, not proof that any one option is a complete observability stack. Self-managed systems and hosted services are both legitimate approaches. Compare candidates against the work your team must perform and the data it must handle.
- Signal and protocol coverage: Does the destination ingest the metrics, logs, and traces you require, in the formats your pipeline emits? If profiles are in scope, verify that separately.
- Kubernetes context: Can cluster, namespace, workload, pod, and node metadata be attached consistently and used in queries?
- Retention and scale: How much history is needed, and how will storage and multi-cluster querying grow?
- Operational ownership: Who handles upgrades, storage, access control, alerting, and incident response? A hosted service shifts some operating work but does not remove responsibility for configuration or data governance.
- Data governance: What gets collected, sampled, redacted, retained, and—if a hosted provider is used—sent outside your environment?
- Total cost: Compare ingestion, retention, query, and operational costs using your workload and expected usage. There is no substantiated universal price or performance winner.
OpenTelemetry documentation reported support from more than 90 observability vendors in documentation last modified August 29, 2025. That is a dated documentation figure, not an independently audited count for 2026 or a guarantee that every vendor supports every signal or feature.
Quick Recap
Roll out observability in deliberate stages
- Choose an initial service and its questions. Start with a critical workload and define what operators need to detect or investigate. Select the signals that answer those questions rather than collecting every available source by default.
- Map sources, permissions, and overhead. Identify required endpoints, log files, instrumentation, and Kubernetes metadata. Check access rights and estimate resource use for agents, receivers, and processing.
- Select the instrumentation and collection route. Decide whether applications use SDKs, Operator-managed injection, eBPF where its prerequisites and coverage fit, or a combination. Decide whether telemetry goes directly to a destination or through a Collector.
- Attach and verify context. Confirm that records can be associated with the relevant cluster, namespace, workload, pod, or node, and that trace context propagates across the services you expect to correlate.
- Set policy before expanding collection. Configure retention, access, sampling, and redaction to meet operational and data-governance needs. Build the dashboards and alerts tied to the initial questions.
- Test failure and change behavior. Check what happens when a destination is unavailable, a Collector or agent restarts, or a workload is upgraded. Verify that configuration remains compatible with your Kubernetes, Collector distribution, and backend versions before expanding rollout.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
