--- title: Kubernetes Data Collected description: >- Reference guide for metrics and events collected by the Datadog Agent from Kubernetes clusters breadcrumbs: Docs > Containers > Kubernetes > Kubernetes Data Collected --- # Kubernetes Data Collected This page lists data collected by the Datadog Agent when deployed on a Kubernetes cluster. The set of metrics collected may vary depending on the version of Kubernetes in use. **Note**: For Windows containers, see [Limited metrics for Windows deployments](https://docs.datadoghq.com/agent/troubleshooting/windows_containers/#limited-metrics-for-windows-deployments). ## Metrics{% #metrics %} ### Kubernetes{% #kubernetes %} | | | | | **kubernetes.cpu.capacity**(gauge) | The number of cores in this machine*Shown as core* | | **kubernetes.cpu.limits**(gauge) | The limit of cpu cores set*Shown as core* | | **kubernetes.cpu.requests**(gauge) | The requested cpu cores*Shown as core* | | **kubernetes.cpu.usage.total**(gauge) | The number of cores used*Shown as nanocore* | | **kubernetes.diskio.io\_service\_bytes.stats.total**(gauge) | The amount of disk space the container uses.*Shown as byte* | | **kubernetes.filesystem.usage**(gauge) | The amount of disk used. Requires Docker container runtime.*Shown as byte* | | **kubernetes.filesystem.usage\_pct**(gauge) | The percentage of disk used. Requires Docker container runtime.*Shown as fraction* | | **kubernetes.memory.capacity**(gauge) | The amount of memory (in bytes) in this machine*Shown as byte* | | **kubernetes.memory.limits**(gauge) | The limit of memory set*Shown as byte* | | **kubernetes.memory.requests**(gauge) | The requested memory*Shown as byte* | | **kubernetes.memory.usage**(gauge) | The amount of memory used*Shown as byte* | | **kubernetes.network.rx\_bytes**(gauge) | The amount of bytes per second received*Shown as byte* | | **kubernetes.network.tx\_bytes**(gauge) | The amount of bytes per second transmitted*Shown as byte* | | **kubernetes.network\_errors**(gauge) | The amount of network errors per second*Shown as error* | **Note**: For more information about `kubernetes.cpu.*` metrics, see [Discrepancies in `kubernetes.cpu.*` and `container.cpu.*` metrics](https://docs.datadoghq.com/containers/faq/cpu-usage-metrics). ### Kubelet{% #kubelet %} For more information, see the documentation for the [Kubelet](https://docs.datadoghq.com/integrations/kubelet/) integration. | | | | | **kubernetes.containers.last\_state.terminated**(gauge) | The number of containers that were previously terminated | | **kubernetes.pods.running**(gauge) | The number of running pods | | **kubernetes.pods.expired**(gauge) | The number of expired pods the check ignored | | **kubernetes.containers.running**(gauge) | The number of running containers | | **kubernetes.containers.restarts**(gauge) | The number of times the container has been restarted | | **kubernetes.containers.state.terminated**(gauge) | The number of currently terminated containers | | **kubernetes.containers.state.waiting**(gauge) | The number of currently waiting containers | | **kubernetes.cpu.load.10s.avg**(gauge) | Container cpu load average over the last 10 seconds | | **kubernetes.cpu.system.total**(gauge) | The number of cores used for system time*Shown as core* | | **kubernetes.cpu.user.total**(gauge) | The number of cores used for user time*Shown as core* | | **kubernetes.cpu.cfs.periods**(gauge) | Number of elapsed enforcement period intervals | | **kubernetes.cpu.cfs.throttled.periods**(gauge) | Number of throttled period intervals | | **kubernetes.cpu.cfs.throttled.seconds**(gauge) | Total time duration the container has been throttled | | **kubernetes.cpu.capacity**(gauge) | The number of cores in this machine (available until kubernetes v1.18)*Shown as core* | | **kubernetes.cpu.usage.total**(gauge) | The number of cores used*Shown as nanocore* | | **kubernetes.cpu.limits**(gauge) | The limit of cpu cores set*Shown as core* | | **kubernetes.cpu.requests**(gauge) | The requested cpu cores*Shown as core* | | **kubernetes.filesystem.usage**(gauge) | The amount of disk used*Shown as byte* | | **kubernetes.filesystem.usage\_pct**(gauge) | The percentage of disk used*Shown as fraction* | | **kubernetes.io.read\_bytes**(gauge) | The amount of bytes read from the disk*Shown as byte* | | **kubernetes.io.write\_bytes**(gauge) | The amount of bytes written to the disk*Shown as byte* | | **kubernetes.memory.capacity**(gauge) | The amount of memory (in bytes) in this machine (available until kubernetes v1.18)*Shown as byte* | | **kubernetes.memory.limits**(gauge) | The limit of memory set*Shown as byte* | | **kubernetes.memory.sw\_limit**(gauge) | The limit of swap space set*Shown as byte* | | **kubernetes.memory.requests**(gauge) | The requested memory*Shown as byte* | | **kubernetes.memory.usage**(gauge) | Current memory usage in bytes including all memory regardless of when it was accessed*Shown as byte* | | **kubernetes.memory.working\_set**(gauge) | Current working set in bytes - this is what the OOM killer is watching for*Shown as byte* | | **kubernetes.memory.cache**(gauge) | The amount of memory that is being used to cache data from disk (e.g. memory contents that can be associated precisely with a block on a block device)*Shown as byte* | | **kubernetes.memory.rss**(gauge) | Size of RSS in bytes*Shown as byte* | | **kubernetes.memory.swap**(gauge) | The amount of swap currently used by by processes in this cgroup*Shown as byte* | | **kubernetes.memory.usage\_pct**(gauge) | The percentage of memory used per pod (memory limit must be set)*Shown as fraction* | | **kubernetes.memory.sw\_in\_use**(gauge) | The percentage of swap space used*Shown as fraction* | | **kubernetes.network.rx\_bytes**(gauge) | The amount of bytes per second received*Shown as byte* | | **kubernetes.network.rx\_dropped**(gauge) | The amount of rx packets dropped per second*Shown as packet* | | **kubernetes.network.rx\_errors**(gauge) | The amount of rx errors per second*Shown as error* | | **kubernetes.network.tx\_bytes**(gauge) | The amount of bytes per second transmitted*Shown as byte* | | **kubernetes.network.tx\_dropped**(gauge) | The amount of tx packets dropped per second*Shown as packet* | | **kubernetes.network.tx\_errors**(gauge) | The amount of tx errors per second*Shown as error* | | **kubernetes.diskio.io\_service\_bytes.stats.total**(gauge) | The amount of disk space the container uses*Shown as byte* | | **kubernetes.apiserver.certificate.expiration.count**(gauge) | The count of remaining lifetime on the certificate used to authenticate a request*Shown as second* | | **kubernetes.apiserver.certificate.expiration.sum**(gauge) | The sum of remaining lifetime on the certificate used to authenticate a request*Shown as second* | | **kubernetes.rest.client.requests**(gauge) | The number of HTTP requests*Shown as operation* | | **kubernetes.rest.client.latency.count**(gauge) | The count of request latency in seconds broken down by verb and URL | | **kubernetes.rest.client.latency.sum**(gauge) | The sum of request latency in seconds broken down by verb and URL*Shown as second* | | **kubernetes.kubelet.pleg.discard\_events**(count) | The number of discard events in PLEG | | **kubernetes.kubelet.pleg.last\_seen**(gauge) | Timestamp in seconds when PLEG was last seen active*Shown as second* | | **kubernetes.kubelet.pleg.relist\_duration.count**(gauge) | The count of relisting pods in PLEG | | **kubernetes.kubelet.pleg.relist\_duration.sum**(gauge) | The sum of duration in seconds for relisting pods in PLEG*Shown as second* | | **kubernetes.kubelet.pleg.relist\_interval.count**(gauge) | The count of relisting pods in PLEG*Shown as second* | | **kubernetes.kubelet.pleg.relist\_interval.sum**(gauge) | The sum of interval in seconds between relisting in PLEG | | **kubernetes.kubelet.runtime.operations**(count) | The number of runtime operations*Shown as operation* | | **kubernetes.kubelet.runtime.errors**(gauge) | Cumulative number of runtime operations errors*Shown as operation* | | **kubernetes.kubelet.runtime.operations.duration.sum**(gauge) | The sum of duration of operations*Shown as operation* | | **kubernetes.kubelet.runtime.operations.duration.count**(gauge) | The count of operations | | **kubernetes.kubelet.network\_plugin.latency.sum**(gauge) | The sum of latency in microseconds of network plugin operations*Shown as microsecond* | | **kubernetes.kubelet.network\_plugin.latency.count**(gauge) | The count of network plugin operations by latency | | **kubernetes.kubelet.network\_plugin.latency.quantile**(gauge) | The quantiles of network plugin operations by latency | | **kubernetes.kubelet.volume.stats.available\_bytes**(gauge) | The number of available bytes in the volume*Shown as byte* | | **kubernetes.kubelet.volume.stats.capacity\_bytes**(gauge) | The capacity in bytes of the volume*Shown as byte* | | **kubernetes.kubelet.volume.stats.used\_bytes**(gauge) | The number of used bytes in the volume*Shown as byte* | | **kubernetes.kubelet.volume.stats.inodes**(gauge) | The maximum number of inodes in the volume*Shown as inode* | | **kubernetes.kubelet.volume.stats.inodes\_free**(gauge) | The number of free inodes in the volume*Shown as inode* | | **kubernetes.kubelet.volume.stats.inodes\_used**(gauge) | The number of used inodes in the volume*Shown as inode* | | **kubernetes.ephemeral\_storage.limits**(gauge) | Ephemeral storage limit of the container (requires kubernetes v1.8+)*Shown as byte* | | **kubernetes.ephemeral\_storage.requests**(gauge) | Ephemeral storage request of the container (requires kubernetes v1.8+)*Shown as byte* | | **kubernetes.ephemeral\_storage.usage**(gauge) | Ephemeral storage usage of the POD*Shown as byte* | | **kubernetes.kubelet.evictions**(count) | The number of pods that have been evicted from the kubelet (ALPHA in kubernetes v1.16) | | **kubernetes.kubelet.cpu.usage**(gauge) | The number of cores used by kubelet*Shown as nanocore* | | **kubernetes.kubelet.memory.usage**(gauge) | Current kubelet memory usage in bytes*Shown as byte* | | **kubernetes.kubelet.memory.rss**(gauge) | Size of kubelet RSS in bytes*Shown as byte* | | **kubernetes.runtime.cpu.usage**(gauge) | The number of cores used by the runtime*Shown as nanocore* | | **kubernetes.runtime.memory.usage**(gauge) | Current runtime memory usage in bytes*Shown as byte* | | **kubernetes.runtime.memory.rss**(gauge) | Size of runtime RSS in bytes*Shown as byte* | | **kubernetes.kubelet.container.log\_filesystem.used\_bytes**(gauge) | Bytes used by the container's logs on the filesystem (requires kubernetes 1.14+)*Shown as byte* | | **kubernetes.kubelet.pod.start.duration**(gauge) | Duration in microseconds for a single pod to go from pending to running*Shown as microsecond* | | **kubernetes.kubelet.pod.worker.duration**(gauge) | Duration in microseconds to sync a single pod. Broken down by operation type: create, update, or sync*Shown as microsecond* | | **kubernetes.kubelet.pod.worker.start.duration**(gauge) | Duration in microseconds from seeing a pod to starting a worker*Shown as microsecond* | | **kubernetes.kubelet.docker.operations**(count) | The number of docker operations*Shown as operation* | | **kubernetes.kubelet.docker.errors**(count) | The number of docker operations errors*Shown as operation* | | **kubernetes.kubelet.docker.operations.duration.sum**(gauge) | The sum of duration of docker operations*Shown as operation* | | **kubernetes.kubelet.docker.operations.duration.count**(gauge) | The count of docker operations | | **kubernetes.go\_threads**(gauge) | Number of OS threads created | | **kubernetes.go\_goroutines**(gauge) | Number of goroutines that currently exist | | **kubernetes.liveness\_probe.success.total**(gauge) | Cumulative number of successful liveness probe for a container (ALPHA in kubernetes v1.15) | | **kubernetes.liveness\_probe.failure.total**(gauge) | Cumulative number of failed liveness probe for a container (ALPHA in kubernetes v1.15) | | **kubernetes.readiness\_probe.success.total**(gauge) | Cumulative number of successful readiness probe for a container (ALPHA in kubernetes v1.15) | | **kubernetes.readiness\_probe.failure.total**(gauge) | Cumulative number of failed readiness probe for a container (ALPHA in kubernetes v1.15) | | **kubernetes.startup\_probe.success.total**(gauge) | Cumulative number of successful startup probe for a container (ALPHA in kubernetes v1.15) | | **kubernetes.startup\_probe.failure.total**(gauge) | Cumulative number of failed startup probe for a container (ALPHA in kubernetes v1.15) | | **kubernetes.node.filesystem.usage**(gauge) | The amount of disk used at node level*Shown as byte* | | **kubernetes.node.filesystem.usage\_pct**(gauge) | The percentage of disk space used at node level*Shown as fraction* | | **kubernetes.node.image.filesystem.usage**(gauge) | The amount of disk used on image filesystem (node level)*Shown as byte* | | **kubernetes.node.image.filesystem.usage\_pct**(gauge) | The percentage of disk used (node level)*Shown as fraction* | | **kubernetes.pod.terminating.duration**(gauge) | Amount of time the pod hangs in termination phase*Shown as second* | | **kubernetes.pod.resize.pending**(gauge) | Number of pods with resource resize request in pending state | ### Kubernetes state metrics core{% #kubernetes-state-metrics-core %} For more information, see the documentation for the [Kubernetes state metrics core](https://docs.datadoghq.com/integrations/kubernetes_state_core/) integration. This check requires Datadog Cluster Agent v1.12 or later. | | | | | **kubernetes\_state.apiservice.condition**(gauge) | The current condition of this apiservice. Tags:`kube_namespace` `apiservice` `condition` `status`. | | **kubernetes\_state.apiservice.count**(gauge) | The current count of apiservices. | | **kubernetes\_state.configmap.count**(gauge) | Number of ConfigMaps. Requires ConfigMaps to be added to Cluster Agent collector. Tags: `kube_namespace`. | | **kubernetes\_state.container.cpu\_limit**(gauge) | The value of CPU limit by a container. Tags:`kube_namespace` `pod_name` `kube_container_name` `node` `resource` `unit` (`env` `service` `version` from standard labels).*Shown as cpu* | | **kubernetes\_state.container.cpu\_limit.total**(gauge) | The total value of CPU limits by all containers in the cluster. Tags:`kube_namespace` `kube_container_name` `kube_`.*Shown as cpu* | | **kubernetes\_state.container.cpu\_requested**(gauge) | The value of CPU requested by a container. Tags:`kube_namespace` `pod_name` `kube_container_name` `node` `resource` `unit` (`env` `service` `version` from standard labels).*Shown as cpu* | | **kubernetes\_state.container.cpu\_requested.total**(gauge) | The total value of CPU requested by all containers in the cluster. Tags:`kube_namespace` `kube_container_name` `kube_`.*Shown as cpu* | | **kubernetes\_state.container.gpu\_limit**(gauge) | The value of GPU limit by a container. Tags:`kube_namespace` `pod_name` `kube_container_name` `node` `resource` `mig_profile` `unit` (`env` `service` `version` from standard labels). | | **kubernetes\_state.container.gpu\_limit.total**(gauge) | The total value of GPU limits by all containers in the cluster. Tags:`kube_namespace` `kube_container_name` `kube_`. | | **kubernetes\_state.container.gpu\_requested**(gauge) | The value of GPU requested by a container. Tags:`kube_namespace` `pod_name` `kube_container_name` `node` `resource` `mig_profile` `unit` (`env` `service` `version` from standard labels). | | **kubernetes\_state.container.gpu\_requested.total**(gauge) | The total value of GPU requested by all containers in the cluster. Tags:`kube_namespace` `kube_container_name` `kube_`. | | **kubernetes\_state.container.memory\_limit**(gauge) | The value of memory limit by a container. Tags:`kube_namespace` `pod_name` `kube_container_name` `node` `resource` `unit` (`env` `service` `version` from standard labels).*Shown as byte* | | **kubernetes\_state.container.memory\_limit.total**(gauge) | The total value of memory limits by all containers in the cluster. Tags:`kube_namespace` `kube_container_name` `kube_`.*Shown as byte* | | **kubernetes\_state.container.memory\_requested**(gauge) | The value of memory requested by a container. Tags:`kube_namespace` `pod_name` `kube_container_name` `node` `resource` `unit` (`env` `service` `version` from standard labels).*Shown as byte* | | **kubernetes\_state.container.memory\_requested.total**(gauge) | The total value of memory requested by all containers in the cluster. Tags:`kube_namespace` `kube_container_name` `kube_`.*Shown as byte* | | **kubernetes\_state.container.network\_bandwidth\_limit**(gauge) | The value of network bandwidth limit for a container. Tags:`kube_namespace` `pod_name` `kube_container_name` `node` `resource` `unit` (`env` `service` `version` from standard labels). | | **kubernetes\_state.container.network\_bandwidth\_requested**(gauge) | The value of network bandwidth requested by a container. Tags:`kube_namespace` `pod_name` `kube_container_name` `node` `resource` `unit` (`env` `service` `version` from standard labels). | | **kubernetes\_state.container.ready**(gauge) | Describes whether the containers readiness check succeeded. Tags:`kube_namespace` `pod_name` `kube_container_name` (`env` `service` `version` from standard labels). | | **kubernetes\_state.container.restarts**(gauge) | The number of container restarts per container. Tags:`kube_namespace` `pod_name` `kube_container_name` (`env` `service` `version` from standard labels). | | **kubernetes\_state.container.running**(gauge) | Describes whether the container is currently in running state. Tags:`kube_namespace` `pod_name` `kube_container_name` (`env` `service` `version` from standard labels). | | **kubernetes\_state.container.status\_report.count.terminated**(gauge) | Describes the reason the container is currently in terminated state. Tags:`kube_namespace` `pod_name` `kube_container_name` `reason` (`env` `service` `version` from standard labels). | | **kubernetes\_state.container.status\_report.count.waiting**(gauge) | Describes the reason the container is currently in waiting state. Tags:`kube_namespace` `pod_name` `kube_container_name` `reason` (`env` `service` `version` from standard labels). | | **kubernetes\_state.container.terminated**(gauge) | Describes whether the container is currently in terminated state. Tags:`kube_namespace` `pod_name` `kube_container_name` (`env` `service` `version` from standard labels). | | **kubernetes\_state.container.waiting**(gauge) | Describes whether the container is currently in waiting state. Tags:`kube_namespace` `pod_name` `kube_container_name` (`env` `service` `version` from standard labels). | | **kubernetes\_state.crd.condition**(gauge) | The current condition of this custom resource definition. Tags: `customresourcedefinition` `condition` `status`. | | **kubernetes\_state.crd.count**(gauge) | Number of custom resource definitions. | | **kubernetes\_state.cronjob.count**(gauge) | Number of cronjobs. Tags:`kube_namespace`. | | **kubernetes\_state.cronjob.duration\_since\_last\_schedule**(gauge) | The duration since the last time the cronjob was scheduled. Tags:`kube_cronjob` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.cronjob.duration\_since\_last\_successful**(gauge) | The duration since the last time the cronjob was successfully scheduled. Tags:`kube_cronjob` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.cronjob.spec\_suspend**(gauge) | Suspend flag tells the controller to suspend subsequent executions. Tags:`kube_namespace` `kube_cronjob` (`env` `service` `version` from standard labels). | | **kubernetes\_state.daemonset.count**(gauge) | Number of DaemonSets. Tags:`kube_namespace`. | | **kubernetes\_state.daemonset.daemons\_available**(gauge) | The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and available. Tags:`kube_daemon_set` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.daemonset.daemons\_unavailable**(gauge) | The number of nodes that should be running the daemon pod and have none of the daemon pod running and available. Tags:`kube_daemon_set` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.daemonset.desired**(gauge) | The number of nodes that should be running the daemon pod. Tags:`kube_daemon_set` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.daemonset.misscheduled**(gauge) | The number of nodes running a daemon pod but are not supposed to. Tags:`kube_daemon_set` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.daemonset.ready**(gauge) | The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and ready. Tags:`kube_daemon_set` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.daemonset.scheduled**(gauge) | The number of nodes running at least one daemon pod and are supposed to. Tags:`kube_daemon_set` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.daemonset.updated**(gauge) | The total number of nodes that are running updated daemon pod. Tags:`kube_daemon_set` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.deployment.condition**(gauge) | The current status conditions of a deployment. Tags:`kube_deployment` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.deployment.count**(gauge) | Number of deployments. Tags:`kube_namespace`. | | **kubernetes\_state.deployment.paused**(gauge) | Whether the deployment is paused and will not be processed by the deployment controller. Tags:`kube_deployment` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.deployment.replicas**(gauge) | The number of replicas per deployment. Tags:`kube_deployment` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.deployment.replicas\_available**(gauge) | The number of available replicas per deployment. Tags:`kube_deployment` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.deployment.replicas\_desired**(gauge) | Number of desired pods for a deployment. Tags:`kube_deployment` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.deployment.replicas\_ready**(gauge) | The number of ready replicas per deployment. Tags:`kube_deployment` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.deployment.replicas\_unavailable**(gauge) | The number of unavailable replicas per deployment. Tags:`kube_deployment` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.deployment.replicas\_updated**(gauge) | The number of updated replicas per deployment. Tags:`kube_deployment` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.deployment.rollingupdate.max\_surge**(gauge) | Maximum number of replicas that can be scheduled above the desired number of replicas during a rolling update of a deployment. Tags:`kube_deployment` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.deployment.rollingupdate.max\_unavailable**(gauge) | Maximum number of unavailable replicas during a rolling update of a deployment. Tags:`kube_deployment` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.deployment.rollout\_duration**(gauge) | Number of seconds since deployment rollout started. Tags:`kube_deployment` `kube_namespace` (`env` `service` `version` from standard labels).*Shown as second* | | **kubernetes\_state.endpoint.address\_available**(gauge) | Number of addresses available in endpoint. Tags:`endpoint` `kube_namespace`. | | **kubernetes\_state.endpoint.address\_not\_ready**(gauge) | Number of addresses not ready in endpoint. Tags:`endpoint` `kube_namespace`. | | **kubernetes\_state.endpoint.count**(gauge) | Number of endpoints. Tags:`kube_namespace`. | | **kubernetes\_state.hpa.condition**(gauge) | The condition of this autoscaler. Tags:`kube_namespace` `horizontalpodautoscaler` `condition` `status`. | | **kubernetes\_state.hpa.count**(gauge) | Number of horizontal pod autoscalers. Tags: `kube_namespace`. | | **kubernetes\_state.hpa.current\_replicas**(gauge) | Current number of replicas of pods managed by this autoscaler. Tags:`kube_namespace` `horizontalpodautoscaler`. | | **kubernetes\_state.hpa.desired\_replicas**(gauge) | Desired number of replicas of pods managed by this autoscaler. Tags:`kube_namespace` `horizontalpodautoscaler`. | | **kubernetes\_state.hpa.max\_replicas**(gauge) | Upper limit for the number of pods that can be set by the autoscaler; cannot be smaller than MinReplicas. Tags:`kube_namespace` `horizontalpodautoscaler`. | | **kubernetes\_state.hpa.min\_replicas**(gauge) | Lower limit for the number of pods that can be set by the autoscaler default 1. Tags:`kube_namespace` `horizontalpodautoscaler`. | | **kubernetes\_state.hpa.spec\_target\_metric**(gauge) | The metric specifications used by this autoscaler when calculating the desired replica count. Tags:`kube_namespace` `horizontalpodautoscaler` `metric_name` `metric_target_type`. | | **kubernetes\_state.hpa.status\_target\_metric**(gauge) | The current metric status used by this autoscaler when calculating the desired replica count. Tags:`kube_namespace` `horizontalpodautoscaler` `metric_name` `metric_target_type`. | | **kubernetes\_state.ingress.count**(gauge) | Number of ingresses. Tags:`kube_namespace`. | | **kubernetes\_state.ingress.path**(gauge) | Information about the ingress path. Tags:`kube_namespace` `kube_ingress_path` `kube_ingress` `kube_service` `kube_service_port` `kube_ingress_host` . | | **kubernetes\_state.initcontainer.cpu\_limit**(gauge) | Maximum number of cpus a container can request. Tags:`kube_namespace` `pod_name` `kube_container_name` (`env` `service` `version` from standard labels).*Shown as cpu* | | **kubernetes\_state.initcontainer.cpu\_requested**(gauge) | Number of cpus requested by the container. Tags:`kube_namespace` `pod_name` `kube_container_name` (`env` `service` `version` from standard labels).*Shown as cpu* | | **kubernetes\_state.initcontainer.memory\_limit**(gauge) | Maximum number of byte a container can request. Tags:`kube_namespace` `pod_name` `kube_container_name` (`env` `service` `version` from standard labels).*Shown as byte* | | **kubernetes\_state.initcontainer.memory\_requested**(gauge) | Number of bytes memory requested by the container. Tags:`kube_namespace` `pod_name` `kube_container_name` (`env` `service` `version` from standard labels).*Shown as byte* | | **kubernetes\_state.initcontainer.ready**(gauge) | Indicates when the container is ready. Tags:`kube_namespace` `pod_name` `kube_container_name` (`env` `service` `version` from standard labels). | | **kubernetes\_state.initcontainer.restarts**(gauge) | Describes whether the number of restarts for the init container. Tags:`kube_namespace` `pod_name` `kube_container_name` (`env` `service` `version` from standard labels). | | **kubernetes\_state.initcontainer.running**(gauge) | Indicates when the container is running. Tags:`kube_namespace` `pod_name` `kube_container_name` (`env` `service` `version` from standard labels). | | **kubernetes\_state.initcontainer.status\_report.count.terminated**(gauge) | Number of containers in a terminated state. Tags:`kube_namespace` `pod_name` `kube_container_name` (`env` `service` `version` from standard labels). | | **kubernetes\_state.initcontainer.status\_report.count.waiting**(gauge) | Number of containers in a waiting state. Tags:`kube_namespace` `pod_name` `kube_container_name` (`env` `service` `version` from standard labels). | | **kubernetes\_state.initcontainer.waiting**(gauge) | Describes whether the init container is currently in waiting state. Tags:`kube_namespace` `pod_name` `kube_container_name` (`env` `service` `version` from standard labels). | | **kubernetes\_state.job.completion.failed**(gauge) | The job has failed its execution. Tags:`kube_job` or `kube_cronjob` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.job.completion.succeeded**(gauge) | The job has completed its execution. Tags:`kube_job` or `kube_cronjob` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.job.count**(gauge) | Number of jobs. Tags:`kube_namespace` `kube_cronjob`. | | **kubernetes\_state.job.duration**(gauge) | Time elapsed between the start and completion time of the job or the current time if the job is still running. Tags:`kube_job` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.job.failed**(gauge) | The number of pods which reached Phase Failed. Tags:`kube_job` or `kube_cronjob` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.job.succeeded**(gauge) | The number of pods which reached Phase Succeeded. Tags:`kube_job` or `kube_cronjob` `kube_namespace` (`env` `service` `version` from standard labels). | | **kubernetes\_state.limitrange.cpu.default**(gauge) | Information about CPU limit range usage by constraint. Tags:`kube_namespace` `limitrange` `type`.*Shown as cpu* | | **kubernetes\_state.limitrange.cpu.default\_request**(gauge) | Information about CPU limit range usage by constraint. Tags:`kube_namespace` `limitrange` `type`.*Shown as cpu* | | **kubernetes\_state.limitrange.cpu.max**(gauge) | Information about CPU limit range usage by constraint. Tags:`kube_namespace` `limitrange` `type`.*Shown as cpu* | | **kubernetes\_state.limitrange.cpu.max\_limit\_request\_ratio**(gauge) | Information about CPU limit range usage by constraint. Tags:`kube_namespace` `limitrange` `type`.*Shown as cpu* | | **kubernetes\_state.limitrange.cpu.min**(gauge) | Information about CPU limit range usage by constraint. Tags:`kube_namespace` `limitrange` `type`.*Shown as cpu* | | **kubernetes\_state.limitrange.memory.default**(gauge) | Information about memory limit range usage by constraint. Tags:`kube_namespace` `limitrange` `type`.*Shown as byte* | | **kubernetes\_state.limitrange.memory.default\_request**(gauge) | Information about memory limit range usage by constraint. Tags:`kube_namespace` `limitrange` `type`.*Shown as byte* | | **kubernetes\_state.limitrange.memory.max**(gauge) | Information about memory limit range usage by constraint. Tags:`kube_namespace` `limitrange` `type`.*Shown as byte* | | **kubernetes\_state.limitrange.memory.max\_limit\_request\_ratio**(gauge) | Information about memory limit range usage by constraint. Tags:`kube_namespace` `limitrange` `type`.*Shown as byte* | | **kubernetes\_state.limitrange.memory.min**(gauge) | Information about memory limit range usage by constraint. Tags:`kube_namespace` `limitrange` `type`.*Shown as byte* | | **kubernetes\_state.namespace.count**(gauge) | Number of namespaces. Tags:`phase`. | | **kubernetes\_state.node.age**(gauge) | The time in seconds since the creation of the node. Tags:`node`.*Shown as second* | | **kubernetes\_state.node.by\_condition**(gauge) | The condition of a cluster node. Tags:`condition` `node` `status`. | | **kubernetes\_state.node.count**(gauge) | Number of nodes. Tags:`kernel_version` `os_image` `container_runtime_version` `kubelet_version`. | | **kubernetes\_state.node.cpu\_allocatable**(gauge) | The allocatable CPU of a node that is available for scheduling. Tags:`node` `resource` `unit`.*Shown as cpu* | | **kubernetes\_state.node.cpu\_allocatable.total**(gauge) | The total allocatable CPU of all nodes in the cluster that is available for scheduling.*Shown as cpu* | | **kubernetes\_state.node.cpu\_capacity**(gauge) | The CPU capacity of a node. Tags:`node` `resource` `unit`.*Shown as cpu* | | **kubernetes\_state.node.cpu\_capacity.total**(gauge) | The total CPU capacity of all nodes in the cluster.*Shown as cpu* | | **kubernetes\_state.node.ephemeral\_storage\_allocatable**(gauge) | The allocatable ephemeral-storage of a node that is available for scheduling. Tags:`node` `resource` `unit`. | | **kubernetes\_state.node.ephemeral\_storage\_capacity**(gauge) | The ephemeral-storage capacity of a node. Tags:`node` `resource` `unit`. | | **kubernetes\_state.node.gpu\_allocatable**(gauge) | The allocatable GPU of a node that is available for scheduling. Tags:`node` `resource` `mig_profile` `unit`. | | **kubernetes\_state.node.gpu\_allocatable.total**(gauge) | The total allocatable GPU of all nodes in the cluster that is available for scheduling. | | **kubernetes\_state.node.gpu\_capacity**(gauge) | The GPU capacity of a node. Tags:`node` `resource` `mig_profile` `unit`. | | **kubernetes\_state.node.gpu\_capacity.total**(gauge) | The total GPU capacity of all nodes in the cluster. | | **kubernetes\_state.node.memory\_allocatable**(gauge) | The allocatable memory of a node that is available for scheduling. Tags:`node` `resource` `unit`.*Shown as byte* | | **kubernetes\_state.node.memory\_allocatable.total**(gauge) | The total allocatable memory of all nodes in the cluster that is available for scheduling.*Shown as byte* | | **kubernetes\_state.node.memory\_capacity**(gauge) | The memory capacity of a node. Tags:`node` `resource` `unit`.*Shown as byte* | | **kubernetes\_state.node.memory\_capacity.total**(gauge) | The total memory capacity of all nodes in the cluster.*Shown as byte* | | **kubernetes\_state.node.network\_bandwidth\_allocatable**(gauge) | The allocatable network bandwidth of a node that is available for scheduling. Tags:`node` `resource` `unit`. | | **kubernetes\_state.node.network\_bandwidth\_capacity**(gauge) | The network bandwidth capacity of a node. Tags:`node` `resource` `unit`. | | **kubernetes\_state.node.pods\_allocatable**(gauge) | The allocatable memory of a node that is available for scheduling. Tags:`node` `resource` `unit`. | | **kubernetes\_state.node.pods\_capacity**(gauge) | The pods capacity of a node. Tags:`node` `resource` `unit`. | | **kubernetes\_state.node.status**(gauge) | Whether the node can schedule new pods. Tags:`node` `status`. | | **kubernetes\_state.pdb.disruptions\_allowed**(gauge) | Number of pod disruptions that are currently allowed. Tags:`kube_namespace` `poddisruptionbudget`. | | **kubernetes\_state.pdb.pods\_desired**(gauge) | Minimum desired number of healthy pods. Tags:`kube_namespace` `poddisruptionbudget`. | | **kubernetes\_state.pdb.pods\_healthy**(gauge) | Current number of healthy pods. Tags:`kube_namespace` `poddisruptionbudget`. | | **kubernetes\_state.pdb.pods\_total**(gauge) | Total number of pods counted by this disruption budget. Tags:`kube_namespace` `poddisruptionbudget`. | | **kubernetes\_state.persistentvolume.by\_phase**(gauge) | The phase indicates if a volume is available bound to a claim or released by a claim. Tags:`persistentvolume` `storageclass` `phase`. | | **kubernetes\_state.persistentvolume.capacity**(gauge) | Persistentvolume capacity in bytes. Tags:`persistentvolume` `storageclass`. | | **kubernetes\_state.persistentvolumeclaim.access\_mode**(gauge) | The access mode(s) specified by the persistent volume claim. Tags:`kube_namespace` `persistentvolumeclaim` `access_mode` `storageclass`. | | **kubernetes\_state.persistentvolumeclaim.request\_storage**(gauge) | The capacity of storage requested by the persistent volume claim. Tags:`kube_namespace` `persistentvolumeclaim` `storageclass`. | | **kubernetes\_state.persistentvolumeclaim.status**(gauge) | The phase the persistent volume claim is currently in. Tags:`kube_namespace` `persistentvolumeclaim` `phase` `storageclass`. | | **kubernetes\_state.pod.age**(gauge) | The time in seconds since the creation of the pod. Tags:`node` `kube_namespace` `pod_name` `pod_phase` (`env` `service` `version` from standard labels).*Shown as second* | | **kubernetes\_state.pod.count**(gauge) | Number of Pods. Tags:`node` `kube_namespace` `kube_`. | | **kubernetes\_state.pod.ready**(gauge) | Describes whether the pod is ready to serve requests. Tags:`node` `kube_namespace` `pod_name` `condition` (`env` `service` `version` from standard labels). | | **kubernetes\_state.pod.scheduled**(gauge) | Describes the status of the scheduling process for the pod. Tags:`node` `kube_namespace` `pod_name` `condition` (`env` `service` `version` from standard labels). | | **kubernetes\_state.pod.status\_phase**(gauge) | The pods current phase. Tags:`node` `kube_namespace` `pod_name` `pod_phase` (`env` `service` `version` from standard labels). | | **kubernetes\_state.pod.tolerations**(gauge) | Information about the pod tolerations | | **kubernetes\_state.pod.unschedulable**(gauge) | Describes the unschedulable status for the pod. Tags:`kube_namespace` `pod_name` (`env` `service` `version` from standard labels). | | **kubernetes\_state.pod.uptime**(gauge) | The time in seconds since the pod has been scheduled and acknowledged by the Kubelet. Tags:`node` `kube_namespace` `pod_name` `pod_phase` (`env` `service` `version` from standard labels). | | **kubernetes\_state.pod.volumes.persistentvolumeclaims\_readonly**(gauge) | Describes whether a persistentvolumeclaim is mounted read only. Tags:`node` `kube_namespace` `pod_name` `volume` `persistentvolumeclaim` (`env` `service` `version` from standard labels). | | **kubernetes\_state.replicaset.count**(gauge) | Number of ReplicaSets Tags:`kube_namespace` `kube_deployment`. | | **kubernetes\_state.replicaset.fully\_labeled\_replicas**(gauge) | The number of fully labeled replicas per ReplicaSet. Tags:`kube_namespace` `kube_replica_set` (`env` `service` `version` from standard labels). | | **kubernetes\_state.replicaset.replicas**(gauge) | The number of replicas per ReplicaSet. Tags:`kube_namespace` `kube_replica_set` (`env` `service` `version` from standard labels). | | **kubernetes\_state.replicaset.replicas\_desired**(gauge) | Number of desired pods for a ReplicaSet. Tags:`kube_namespace` `kube_replica_set` (`env` `service` `version` from standard labels). | | **kubernetes\_state.replicaset.replicas\_ready**(gauge) | The number of ready replicas per ReplicaSet. Tags:`kube_namespace` `kube_replica_set` (`env` `service` `version` from standard labels). | | **kubernetes\_state.replicationcontroller.fully\_labeled\_replicas**(gauge) | The number of fully labeled replicas per ReplicationController. Tags:`kube_namespace` `kube_replication_controller`. | | **kubernetes\_state.replicationcontroller.replicas**(gauge) | The number of replicas per ReplicationController. Tags:`kube_namespace` `kube_replication_controller`. | | **kubernetes\_state.replicationcontroller.replicas\_available**(gauge) | The number of available replicas per ReplicationController. Tags:`kube_namespace` `kube_replication_controller`. | | **kubernetes\_state.replicationcontroller.replicas\_desired**(gauge) | Number of desired pods for a ReplicationController. Tags:`kube_namespace` `kube_replication_controller`. | | **kubernetes\_state.replicationcontroller.replicas\_ready**(gauge) | The number of ready replicas per ReplicationController. Tags:`kube_namespace` `kube_replication_controller`. | | **kubernetes\_state.resourcequota.count\_configmaps.limit**(gauge) | Information about resource quota limits by resource. Tags:`kube_namespace` `resourcequota`. | | **kubernetes\_state.resourcequota.count\_configmaps.used**(gauge) | Information about resource quota usage by resource. Tags:`kube_namespace` `resourcequota`. | | **kubernetes\_state.resourcequota.count\_secrets.limit**(gauge) | Information about resource quota limits by resource. Tags:`kube_namespace` `resourcequota`. | | **kubernetes\_state.resourcequota.count\_secrets.used**(gauge) | Information about resource quota usage by resource. Tags:`kube_namespace` `resourcequota`. | | **kubernetes\_state.resourcequota.pods.limit**(gauge) | Information about resource quota limits by resource. Tags:`kube_namespace` `resourcequota`. | | **kubernetes\_state.resourcequota.pods.used**(gauge) | Information about resource quota usage by resource. Tags:`kube_namespace` `resourcequota`. | | **kubernetes\_state.resourcequota.requests.cpu.limit**(gauge) | Information about resource quota limits by resource. Tags:`kube_namespace` `resourcequota`. | | **kubernetes\_state.resourcequota.requests.cpu.used**(gauge) | Information about resource quota usage by resource. Tags:`kube_namespace` `resourcequota`. | | **kubernetes\_state.secret.count**(gauge) | Number of Secrets. Requires Secrets to be added to Cluster Agent collector. Tags: `kube_namespace`. | | **kubernetes\_state.secret.type**(gauge) | Type about secret. Tags:`kube_namespace` `secret` `type`. | | **kubernetes\_state.service.count**(gauge) | Number of services. Tags:`kube_namespace` `type`. | | **kubernetes\_state.service.type**(gauge) | Service types. Tags:`kube_namespace` `kube_service` `type`. | | **kubernetes\_state.statefulset.count**(gauge) | Number of StatefulSets Tags:`kube_namespace`. | | **kubernetes\_state.statefulset.replicas**(gauge) | The number of replicas per StatefulSet. Tags:`kube_namespace` `kube_stateful_set` (`env` `service` `version` from standard labels). | | **kubernetes\_state.statefulset.replicas\_current**(gauge) | The number of current replicas per StatefulSet. Tags:`kube_namespace` `kube_stateful_set` (`env` `service` `version` from standard labels). | | **kubernetes\_state.statefulset.replicas\_desired**(gauge) | Number of desired pods for a StatefulSet. Tags:`kube_namespace` `kube_stateful_set` (`env` `service` `version` from standard labels). | | **kubernetes\_state.statefulset.replicas\_ready**(gauge) | The number of ready replicas per StatefulSet. Tags:`kube_namespace` `kube_stateful_set` (`env` `service` `version` from standard labels). | | **kubernetes\_state.statefulset.replicas\_updated**(gauge) | The number of updated replicas per StatefulSet. Tags:`kube_namespace` `kube_stateful_set` (`env` `service` `version` from standard labels). | | **kubernetes\_state.vpa.count**(gauge) | Number of vertical pod autoscalers. Tags: `kube_namespace`. | | **kubernetes\_state.vpa.lower\_bound**(gauge) | Minimum resources the container can use before the VerticalPodAutoscaler updater evicts it. Tags:`kube_namespace` `verticalpodautoscaler` `kube_container_name` `resource` `target_api_version` `target_kind` `target_name` `unit`. | | **kubernetes\_state.vpa.spec\_container\_maxallowed**(gauge) | Maximum resources the VerticalPodAutoscaler can set for containers matching the name. Tags:`kube_namespace` `verticalpodautoscaler` `kube_container_name` `resource` `target_api_version` `target_kind` `target_name` `unit`. | | **kubernetes\_state.vpa.spec\_container\_minallowed**(gauge) | Minimum resources the VerticalPodAutoscaler can set for containers matching the name. Tags:`kube_namespace` `verticalpodautoscaler` `kube_container_name` `resource` `target_api_version` `target_kind` `target_name` `unit`. | | **kubernetes\_state.vpa.target**(gauge) | Target resources the VerticalPodAutoscaler recommends for the container. Tags:`kube_namespace` `verticalpodautoscaler` `kube_container_name` `resource` `target_api_version` `target_kind` `target_name` `unit`. | | **kubernetes\_state.vpa.uncapped\_target**(gauge) | Target resources the VerticalPodAutoscaler recommends for the container ignoring bounds. Tags:`kube_namespace` `verticalpodautoscaler` `kube_container_name` `resource` `target_api_version` `target_kind` `target_name` `unit`. | | **kubernetes\_state.vpa.update\_mode**(gauge) | Update mode of the VerticalPodAutoscaler. Tags:`kube_namespace` `verticalpodautoscaler` `target_api_version` `target_kind` `target_name` `update_mode`. | | **kubernetes\_state.vpa.upperbound**(gauge) | Maximum resources the container can use before the VerticalPodAutoscaler updater evicts it. Tags:`kube_namespace` `verticalpodautoscaler` `kube_container_name` `resource` `target_api_version` `target_kind` `target_name` `unit`. | **Note:** You can configure [Datadog Standard labels](https://docs.datadoghq.com/getting_started/tagging/unified_service_tagging/#configuration) on your Kubernetes objects to get the `env` `service` `version` tags. ### Kubernetes state{% #kubernetes-state %} **Note**: `kubernetes_state.*` metrics are gathered from the `kube-state-metrics` API. The `kubernetes_state` check is a legacy check. For an alternative, see [Kubernetes state metrics core](https://docs.datadoghq.com/integrations/kubernetes_state_core/). Datadog recommends that you do not enable both checks simultaneously. | | | | | **kubernetes\_state.container.ready**(gauge) | Whether the containers readiness check succeeded | | **kubernetes\_state.container.running**(gauge) | Whether the container is currently in running state | | **kubernetes\_state.container.terminated**(gauge) | Whether the container is currently in terminated state | | **kubernetes\_state.container.status\_report.count.terminated**(gauge) | Count of the containers currently reporting a in terminated state with the reason as a tag | | **kubernetes\_state.container.waiting**(gauge) | Whether the container is currently in waiting state | | **kubernetes\_state.container.status\_report.count.waiting**(gauge) | Count of the containers currently reporting a in waiting state with the reason as a tag | | **kubernetes\_state.container.gpu.request**(gauge) | The number of requested gpu devices by a container | | **kubernetes\_state.container.gpu.limit**(gauge) | The limit on gpu devices to be used by a container | | **kubernetes\_state.container.restarts**(gauge) | The number of restarts per container | | **kubernetes\_state.container.cpu\_requested**(gauge) | The number of requested cpu cores by a container*Shown as cpu* | | **kubernetes\_state.container.memory\_requested**(gauge) | The number of requested memory bytes by a container*Shown as byte* | | **kubernetes\_state.container.cpu\_limit**(gauge) | The limit on cpu cores to be used by a container*Shown as cpu* | | **kubernetes\_state.container.memory\_limit**(gauge) | The limit on memory to be used by a container*Shown as byte* | | **kubernetes\_state.daemonset.scheduled**(gauge) | The number of nodes running at least one daemon pod and that are supposed to | | **kubernetes\_state.daemonset.misscheduled**(gauge) | The number of nodes running a daemon pod but are not supposed to | | **kubernetes\_state.daemonset.desired**(gauge) | The number of nodes that should be running the daemon pod | | **kubernetes\_state.daemonset.ready**(gauge) | The number of nodes that should be running the daemon pod and have one or more running and ready | | **kubernetes\_state.daemonset.updated**(gauge) | The number of nodes that run the updated daemon pod spec | | **kubernetes\_state.deployment.count**(gauge) | The number of deployments | | **kubernetes\_state.deployment.replicas**(gauge) | The number of replicas per deployment | | **kubernetes\_state.deployment.replicas\_available**(gauge) | The number of available replicas per deployment | | **kubernetes\_state.deployment.replicas\_unavailable**(gauge) | The number of unavailable replicas per deployment | | **kubernetes\_state.deployment.replicas\_updated**(gauge) | The number of updated replicas per deployment | | **kubernetes\_state.deployment.replicas\_desired**(gauge) | The number of desired replicas per deployment | | **kubernetes\_state.deployment.paused**(gauge) | Whether a deployment is paused | | **kubernetes\_state.deployment.rollingupdate.max\_unavailable**(gauge) | Maximum number of unavailable replicas during a rolling update | | **kubernetes\_state.endpoint.address\_available**(gauge) | Number of addresses available in endpoint | | **kubernetes\_state.endpoint.address\_not\_ready**(gauge) | Number of addresses not ready in endpoint | | **kubernetes\_state.endpoint.created**(gauge) | Unix creation timestamp | | **kubernetes\_state.job.count**(gauge) | The number of jobs | | **kubernetes\_state.job.failed**(count) | Observed number of failed pods in a job | | **kubernetes\_state.job.succeeded**(count) | Observed number of succeeded pods in a job | | **kubernetes\_state.limitrange.cpu.min**(gauge) | Minimum CPU request for this type | | **kubernetes\_state.limitrange.cpu.max**(gauge) | Maximum CPU limit for this type | | **kubernetes\_state.limitrange.cpu.default**(gauge) | Default CPU limit if not specified | | **kubernetes\_state.limitrange.cpu.default\_request**(gauge) | Default CPU request if not specified | | **kubernetes\_state.limitrange.cpu.max\_limit\_request\_ratio**(gauge) | Maximum CPU limit / request ratio | | **kubernetes\_state.limitrange.memory.min**(gauge) | Minimum memory request for this type | | **kubernetes\_state.limitrange.memory.max**(gauge) | Maximum memory limit for this type | | **kubernetes\_state.limitrange.memory.default**(gauge) | Default memory limit if not specified | | **kubernetes\_state.limitrange.memory.default\_request**(gauge) | Default memory request if not specified | | **kubernetes\_state.limitrange.memory.max\_limit\_request\_ratio**(gauge) | Maximum memory limit / request ratio | | **kubernetes\_state.node.count**(count) | The number of nodes*Shown as node* | | **kubernetes\_state.node.cpu\_capacity**(gauge) | The total CPU resources of the node*Shown as cpu* | | **kubernetes\_state.node.memory\_capacity**(gauge) | The total memory resources of the node*Shown as byte* | | **kubernetes\_state.node.pods\_capacity**(gauge) | The total pod resources of the node | | **kubernetes\_state.node.gpu.cards\_allocatable**(gauge) | The GPU resources of a node that are available for scheduling | | **kubernetes\_state.node.gpu.cards\_capacity**(gauge) | The total GPU resources of the node | | **kubernetes\_state.persistentvolumeclaim.status**(gauge) | The phase the persistent volume claim is currently in | | **kubernetes\_state.persistentvolumeclaim.request\_storage**(gauge) | Storage space request for a given pvc*Shown as byte* | | **kubernetes\_state.persistentvolumes.by\_phase**(gauge) | Number of persistent volumes to sum by phase and storageclass | | **kubernetes\_state.namespace.count**(gauge) | The number of namespaces*Shown as cpu* | | **kubernetes\_state.node.cpu\_allocatable**(gauge) | The CPU resources of a node that are available for scheduling*Shown as cpu* | | **kubernetes\_state.node.memory\_allocatable**(gauge) | The memory resources of a node that are available for scheduling*Shown as byte* | | **kubernetes\_state.node.pods\_allocatable**(gauge) | The pod resources of a node that are available for scheduling | | **kubernetes\_state.node.status**(gauge) | Submitted with a value of 1 for each node and tagged either 'status:schedulable' or 'status:unschedulable'; Sum this metric by either status to get the number of nodes in that status. | | **kubernetes\_state.node.by\_condition**(gauge) | The condition of a cluster node | | **kubernetes\_state.nodes.by\_condition**(gauge) | To sum by `condition` and `status` to get number of nodes in a given condition. | | **kubernetes\_state.hpa.min\_replicas**(gauge) | Lower limit for the number of pods that can be set by the autoscaler | | **kubernetes\_state.hpa.max\_replicas**(gauge) | Upper limit for the number of pods that can be set by the autoscaler | | **kubernetes\_state.hpa.desired\_replicas**(gauge) | Desired number of replicas of pods managed by this autoscaler | | **kubernetes\_state.hpa.condition**(gauge) | Observed condition of autoscalers to sum by condition and status | | **kubernetes\_state.pdb.pods\_desired**(gauge) | Minimum desired number of healthy pods | | **kubernetes\_state.pdb.disruptions\_allowed**(gauge) | Number of pod disruptions that are currently allowed | | **kubernetes\_state.pdb.pods\_healthy**(gauge) | Current number of healthy pods | | **kubernetes\_state.pdb.pods\_total**(gauge) | Total number of pods counted by this disruption budget | | **kubernetes\_state.pod.ready**(gauge) | In association with the `condition` tag, whether the pod is ready to serve requests, e.g. `condition:true` keeps the pods that are in a ready state | | **kubernetes\_state.pod.scheduled**(gauge) | Reports the status of the scheduling process for the pod with its tags | | **kubernetes\_state.pod.unschedulable**(gauge) | Reports PODs that Kube scheduler cannot schedule on any node | | **kubernetes\_state.pod.status\_phase**(gauge) | To sum by `phase` to get number of pods in a given phase, and `namespace` to break this down by namespace | | **kubernetes\_state.replicaset.count**(gauge) | The number of replicasets | | **kubernetes\_state.replicaset.replicas**(gauge) | The number of replicas per ReplicaSet | | **kubernetes\_state.replicaset.fully\_labeled\_replicas**(gauge) | The number of fully labeled replicas per ReplicaSet | | **kubernetes\_state.replicaset.replicas\_ready**(gauge) | The number of ready replicas per ReplicaSet | | **kubernetes\_state.replicaset.replicas\_desired**(gauge) | Number of desired pods for a ReplicaSet | | **kubernetes\_state.replicationcontroller.replicas**(gauge) | The number of replicas per ReplicationController | | **kubernetes\_state.replicationcontroller.fully\_labeled\_replicas**(gauge) | The number of fully labeled replicas per ReplicationController | | **kubernetes\_state.replicationcontroller.replicas\_ready**(gauge) | The number of ready replicas per ReplicationController | | **kubernetes\_state.replicationcontroller.replicas\_desired**(gauge) | Number of desired replicas for a ReplicationController | | **kubernetes\_state.replicationcontroller.replicas\_available**(gauge) | The number of available replicas per ReplicationController | | **kubernetes\_state.resourcequota.pods.used**(gauge) | Observed number of pods used for a resource quota | | **kubernetes\_state.resourcequota.services.used**(gauge) | Observed number of services used for a resource quota | | **kubernetes\_state.resourcequota.persistentvolumeclaims.used**(gauge) | Observed number of persistent volume claims used for a resource quota | | **kubernetes\_state.resourcequota.services.nodeports.used**(gauge) | Observed number of node ports used for a resource quota | | **kubernetes\_state.resourcequota.services.loadbalancers.used**(gauge) | Observed number of loadbalancers used for a resource quota | | **kubernetes\_state.resourcequota.requests.cpu.used**(gauge) | Observed sum of CPU cores requested for a resource quota*Shown as cpu* | | **kubernetes\_state.resourcequota.requests.memory.used**(gauge) | Observed sum of memory bytes requested for a resource quota*Shown as byte* | | **kubernetes\_state.resourcequota.requests.storage.used**(gauge) | Observed sum of storage bytes requested for a resource quota*Shown as byte* | | **kubernetes\_state.resourcequota.limits.cpu.used**(gauge) | Observed sum of limits for CPU cores for a resource quota*Shown as cpu* | | **kubernetes\_state.resourcequota.limits.memory.used**(gauge) | Observed sum of limits for memory bytes for a resource quota*Shown as byte* | | **kubernetes\_state.resourcequota.pods.limit**(gauge) | Hard limit of the number of pods for a resource quota | | **kubernetes\_state.resourcequota.services.limit**(gauge) | Hard limit of the number of services for a resource quota | | **kubernetes\_state.resourcequota.persistentvolumeclaims.limit**(gauge) | Hard limit of the number of PVC for a resource quota | | **kubernetes\_state.resourcequota.services.nodeports.limit**(gauge) | Hard limit of the number of node ports for a resource quota | | **kubernetes\_state.resourcequota.services.loadbalancers.limit**(gauge) | Hard limit of the number of loadbalancers for a resource quota | | **kubernetes\_state.resourcequota.requests.cpu.limit**(gauge) | Hard limit on the total of CPU core requested for a resource quota*Shown as cpu* | | **kubernetes\_state.resourcequota.requests.memory.limit**(gauge) | Hard limit on the total of memory bytes requested for a resource quota*Shown as byte* | | **kubernetes\_state.resourcequota.requests.storage.limit**(gauge) | Hard limit on the total of storage bytes requested for a resource quota*Shown as byte* | | **kubernetes\_state.resourcequota.limits.cpu.limit**(gauge) | Hard limit on the sum of CPU core limits for a resource quota*Shown as cpu* | | **kubernetes\_state.resourcequota.limits.memory.limit**(gauge) | Hard limit on the sum of memory bytes limits for a resource quota*Shown as byte* | | **kubernetes\_state.service.count**(gauge) | Sum by namespace and type to count active services | | **kubernetes\_state.statefulset.count**(gauge) | The number of statefulsets | | **kubernetes\_state.statefulset.replicas**(gauge) | The number of replicas per statefulset | | **kubernetes\_state.statefulset.replicas\_desired**(gauge) | The number of desired replicas per statefulset | | **kubernetes\_state.statefulset.replicas\_current**(gauge) | The number of current replicas per StatefulSet | | **kubernetes\_state.statefulset.replicas\_ready**(gauge) | The number of ready replicas per StatefulSet | | **kubernetes\_state.statefulset.replicas\_updated**(gauge) | The number of updated replicas per StatefulSet | | **kubernetes\_state.telemetry.payload.size**(gauge) | The message size received from kube-state-metrics*Shown as byte* | | **kubernetes\_state.telemetry.metrics.processed.count**(count) | The number of metrics processed | | **kubernetes\_state.telemetry.metrics.input.count**(count) | The number of metrics received | | **kubernetes\_state.telemetry.metrics.blacklist.count**(count) | The number of metrics blacklisted by the check | | **kubernetes\_state.telemetry.metrics.ignored.count**(count) | The number of metrics ignored by the check | | **kubernetes\_state.telemetry.collector.metrics.count**(count) | The number of metrics by collector (kubernetes object kind) by kubernetes namespaces | | **kubernetes\_state.vpa.lower\_bound**(gauge) | The vpa lower bound recommendation | | **kubernetes\_state.vpa.target**(gauge) | The vpa target recommendation | | **kubernetes\_state.vpa.uncapped\_target**(gauge) | The vpa uncapped recommendation recommendation | | **kubernetes\_state.vpa.upperbound**(gauge) | The vpa upper bound recommendation | | **kubernetes\_state.vpa.update\_mode**(gauge) | The vpa update mode | ### Kubernetes DNS{% #kubernetes-dns %} | | | | | **kubedns.cachemiss\_count**(gauge) | Number of DNS requests resulting in a cache miss.*Shown as request* | | **kubedns.cachemiss\_count.count**(count) | Instant number of DNS requests made resulting in a cache miss.*Shown as request* | | **kubedns.error\_count**(gauge) | Number of DNS requests resulting in an error.*Shown as error* | | **kubedns.error\_count.count**(count) | Instant number of DNS requests made resulting in an error.*Shown as error* | | **kubedns.request\_count**(gauge) | Total number of DNS requests made.*Shown as request* | | **kubedns.request\_count.count**(count) | Instant number of DNS requests made.*Shown as request* | | **kubedns.request\_duration.seconds.count**(gauge) | Number of requests on which the kubedns.request_duration.seconds.sum metric is evaluated.*Shown as request* | | **kubedns.request\_duration.seconds.sum**(gauge) | Time (in seconds) each request took to resolve.*Shown as second* | | **kubedns.response\_size.bytes.count**(gauge) | Number of responses on which the kubedns.response_size.bytes.sum metric is evaluated.*Shown as response* | | **kubedns.response\_size.bytes.sum**(gauge) | Size of the returns response in bytes.*Shown as byte* | ### Kubernetes proxy{% #kubernetes-proxy %} | | | | | **kubeproxy.cpu.time**(gauge) | Total user and system CPU time spent in seconds*Shown as second* | | **kubeproxy.mem.resident**(gauge) | Resident memory size in bytes*Shown as byte* | | **kubeproxy.mem.virtual**(gauge) | Virtual memory size in bytes*Shown as byte* | | **kubeproxy.rest.client.exec\_plugin.certificate.rotation**(gauge) | Histogram of the number of seconds the last auth exec plugin client certificate lived before being rotated. If auth exec plugin client certificates are unused, histogram will contain no data.*Shown as second* | | **kubeproxy.rest.client.exec\_plugin.ttl**(gauge) | Gauge of the shortest TTL (time-to-live) of the client certificate(s) managed by the auth exec plugin. The value is in seconds until certificate expiry (negative if already expired). If auth exec plugins are unused or manage no TLS certificates, the value will be +INF. (alpha)*Shown as second* | | **kubeproxy.rest.client.request.duration**(gauge) | Request latency in seconds. Broken down by verb and URL.*Shown as second* | | **kubeproxy.rest.client.requests**(gauge) | Number of HTTP requests partitioned by status code method and host*Shown as request* | | **kubeproxy.sync\_proxy.rules.duration**(gauge) | SyncProxyRules latency in seconds (alpha)*Shown as second* | | **kubeproxy.sync\_proxy.rules.endpoint\_changes.pending**(gauge) | Pending proxy rules Endpoint changes (alpha) | | **kubeproxy.sync\_proxy.rules.endpoint\_changes.total**(gauge) | Cumulative proxy rules Endpoint changes (alpha) | | **kubeproxy.sync\_proxy.rules.iptables**(gauge) | Number of proxy iptables rules programmed (alpha) | | **kubeproxy.sync\_proxy.rules.iptables.restore\_failures**(gauge) | Cumulative proxy iptables restore failures (alpha) | | **kubeproxy.sync\_proxy.rules.last\_queued\_timestamp**(gauge) | The last time a sync of proxy rules was queued (alpha)*Shown as second* | | **kubeproxy.sync\_proxy.rules.last\_timestamp**(gauge) | The last time proxy rules were successfully synced (alpha)*Shown as second* | | **kubeproxy.sync\_proxy.rules.latency.count**(gauge) | SyncProxyRules latency count (alpha) | | **kubeproxy.sync\_proxy.rules.latency.sum**(gauge) | SyncProxyRules latency sum (alpha)*Shown as microsecond* | | **kubeproxy.sync\_proxy.rules.service\_changes.pending**(gauge) | Pending proxy rules Service changes (alpha) | | **kubeproxy.sync\_proxy.rules.service\_changes.total**(gauge) | Cumulative proxy rules Service changes (alpha) | ### Kubernetes API server{% #kubernetes-api-server %} For more information, see the documentation for the [Kubernetes API server](https://docs.datadoghq.com/integrations/kube_apiserver_metrics/) integration. | | | | | **kube\_apiserver.APIServiceRegistrationController\_depth**(gauge) | The current depth of workqueue: APIServiceRegistrationController | | **kube\_apiserver.admission\_controller\_admission\_duration\_seconds.count**(count) | The admission controller latency histogram in seconds identified by name and broken out for each operation and API resource and type (validate or admit) count | | **kube\_apiserver.admission\_controller\_admission\_duration\_seconds.sum**(gauge) | The admission controller latency histogram in seconds identified by name and broken out for each operation and API resource and type (validate or admit)*Shown as second* | | **kube\_apiserver.admission\_step\_admission\_latencies\_seconds.count**(count) | The admission sub-step latency histogram broken out for each operation and API resource and step type (validate or admit) count | | **kube\_apiserver.admission\_step\_admission\_latencies\_seconds.sum**(gauge) | The admission sub-step latency broken out for each operation and API resource and step type (validate or admit)*Shown as second* | | **kube\_apiserver.admission\_step\_admission\_latencies\_seconds\_summary.count**(count) | The admission sub-step latency summary broken out for each operation and API resource and step type (validate or admit) count | | **kube\_apiserver.admission\_step\_admission\_latencies\_seconds\_summary.quantile**(gauge) | The admission sub-step latency summary broken out for each operation and API resource and step type (validate or admit) quantile*Shown as second* | | **kube\_apiserver.admission\_step\_admission\_latencies\_seconds\_summary.sum**(gauge) | The admission sub-step latency summary broken out for each operation and API resource and step type (validate or admit)*Shown as second* | | **kube\_apiserver.admission\_webhook\_admission\_latencies\_seconds.count**(count) | The admission webhook latency identified by name and broken out for each operation and API resource and type (validate or admit) count | | **kube\_apiserver.admission\_webhook\_admission\_latencies\_seconds.sum**(gauge) | The admission webhook latency identified by name and broken out for each operation and API resource and type (validate or admit)*Shown as second* | | **kube\_apiserver.aggregator\_unavailable\_apiservice**(gauge) | Gauge of APIServices which are marked as unavailable broken down by APIService name (alpha; Kubernetes 1.14+) | | **kube\_apiserver.apiserver\_admission\_webhook\_fail\_open\_count**(gauge) | Admission webhook fail open count, identified by name and broken out for each admission type (validating or mutating). | | **kube\_apiserver.apiserver\_admission\_webhook\_fail\_open\_count.count**(count) | Admission webhook fail open count, identified by name and broken out for each admission type (validating or mutating). | | **kube\_apiserver.apiserver\_admission\_webhook\_request\_total**(gauge) | Admission webhook request total, identified by name and broken out for each admission type (alpha; Kubernetes 1.23+) | | **kube\_apiserver.apiserver\_admission\_webhook\_request\_total.count**(count) | Admission webhook request total, identified by name and broken out for each admission type (alpha; Kubernetes 1.23+) | | **kube\_apiserver.apiserver\_dropped\_requests\_total**(gauge) | The accumulated number of requests dropped with 'Try again later' response*Shown as request* | | **kube\_apiserver.apiserver\_dropped\_requests\_total.count**(count) | The monotonic count of requests dropped with 'Try again later' response*Shown as request* | | **kube\_apiserver.apiserver\_request\_count**(gauge) | The accumulated number of apiserver requests broken out for each verb API resource client and HTTP response contentType and code (deprecated in Kubernetes 1.15)*Shown as request* | | **kube\_apiserver.apiserver\_request\_count.count**(count) | The monotonic count of apiserver requests broken out for each verb API resource client and HTTP response contentType and code (deprecated in Kubernetes 1.15)*Shown as request* | | **kube\_apiserver.apiserver\_request\_terminations\_total.count**(count) | The number of requests the apiserver terminated in self-defense (Kubernetes 1.17+)*Shown as request* | | **kube\_apiserver.apiserver\_request\_total**(gauge) | The accumulated number of apiserver requests broken out for each verb API resource client and HTTP response contentType and code (Kubernetes 1.15+; replaces apiserver_request_count)*Shown as request* | | **kube\_apiserver.apiserver\_request\_total.count**(count) | The monotonic count of apiserver requests broken out for each verb API resource client and HTTP response contentType and code (Kubernetes 1.15+; replaces apiserver_request_count.count)*Shown as request* | | **kube\_apiserver.audit\_event**(gauge) | The accumulated number audit events generated and sent to the audit backend*Shown as event* | | **kube\_apiserver.audit\_event.count**(count) | The monotonic count of audit events generated and sent to the audit backend*Shown as event* | | **kube\_apiserver.authenticated\_user\_requests**(gauge) | The accumulated number of authenticated requests broken out by username*Shown as request* | | **kube\_apiserver.authenticated\_user\_requests.count**(count) | The monotonic count of authenticated requests broken out by username*Shown as request* | | **kube\_apiserver.authentication\_attempts.count**(count) | The counter of authenticated attempts (Kubernetes 1.16+)*Shown as request* | | **kube\_apiserver.authentication\_duration\_seconds.count**(count) | The authentication duration histogram broken out by result (Kubernetes 1.17+) | | **kube\_apiserver.authentication\_duration\_seconds.sum**(gauge) | The authentication duration histogram broken out by result (Kubernetes 1.17+)*Shown as second* | | **kube\_apiserver.current\_inflight\_requests**(gauge) | The maximal number of currently used inflight request limit of this apiserver per request kind in last second. | | **kube\_apiserver.envelope\_encryption\_dek\_cache\_fill\_percent**(gauge) | Percent of the cache slots currently occupied by cached DEKs. | | **kube\_apiserver.etcd.db.total\_size**(gauge) | The total size of the etcd database file physically allocated in bytes (alpha; Kubernetes 1.19+)*Shown as byte* | | **kube\_apiserver.etcd\_object\_counts**(gauge) | The number of stored objects at the time of last check split by kind (alpha; deprecated in Kubernetes 1.22)*Shown as object* | | **kube\_apiserver.etcd\_request\_duration\_seconds.count**(count) | Etcd request latencies count for each operation and object type (alpha) | | **kube\_apiserver.etcd\_request\_duration\_seconds.sum**(gauge) | Etcd request latencies for each operation and object type (alpha)*Shown as second* | | **kube\_apiserver.etcd\_request\_errors\_total**(count) | Etcd failed request counts for each operation and object type*Shown as request* | | **kube\_apiserver.etcd\_requests\_total**(count) | Etcd request counts for each operation and object type*Shown as request* | | **kube\_apiserver.flowcontrol\_current\_executing\_requests**(gauge) | Number of requests in initial (for a WATCH) or any (for a non-WATCH) execution stage in the API Priority and Fairness subsystem | | **kube\_apiserver.flowcontrol\_current\_executing\_seats**(gauge) | Number of seats (concurrency units) currently occupied by executing requests in the API Priority and Fairness subsystem | | **kube\_apiserver.flowcontrol\_current\_inqueue\_requests**(count) | Number of requests currently pending in queues of the API Priority and Fairness subsystem | | **kube\_apiserver.flowcontrol\_dispatched\_requests\_total**(count) | Number of requests executed by API Priority and Fairness subsystem | | **kube\_apiserver.flowcontrol\_nominal\_limit\_seats**(gauge) | Nominal limit on the number of execution seats available to requests in the API Priority and Fairness subsystem | | **kube\_apiserver.flowcontrol\_rejected\_requests\_total.count**(count) | Number of requests rejected by API Priority and Fairness subsystem | | **kube\_apiserver.flowcontrol\_request\_concurrency\_limit**(gauge) | Shared concurrency limit in the API Priority and Fairness subsystem | | **kube\_apiserver.flowcontrol\_request\_wait\_duration\_seconds.count**(count) | The request wait duration histogram count in the API Priority and Fairness subsystem | | **kube\_apiserver.flowcontrol\_request\_wait\_duration\_seconds.sum**(gauge) | The request wait duration histogram sum in the API Priority and Fairness subsystem*Shown as second* | | **kube\_apiserver.go\_goroutines**(gauge) | The number of goroutines that currently exist | | **kube\_apiserver.go\_threads**(gauge) | The number of OS threads created*Shown as thread* | | **kube\_apiserver.grpc\_client\_handled\_total**(count) | The total number of RPCs completed by the client regardless of success or failure*Shown as request* | | **kube\_apiserver.grpc\_client\_msg\_received\_total**(count) | The total number of gRPC stream messages received by the client*Shown as message* | | **kube\_apiserver.grpc\_client\_msg\_sent\_total**(count) | The total number of gRPC stream messages sent by the client*Shown as message* | | **kube\_apiserver.grpc\_client\_started\_total**(count) | The total number of RPCs started on the client*Shown as request* | | **kube\_apiserver.http\_requests\_total**(gauge) | The accumulated number of HTTP requests made*Shown as request* | | **kube\_apiserver.http\_requests\_total.count**(count) | The monotonic count of the number of HTTP requests made*Shown as request* | | **kube\_apiserver.kubernetes\_feature\_enabled**(gauge) | Whether a Kubernetes feature gate is enabled or not, identified by name and stage (alpha; Kubernetes 1.26+) | | **kube\_apiserver.longrunning\_gauge**(gauge) | The gauge of all active long-running apiserver requests broken out by verb, group, version, resource, scope, and component. Not all requests are tracked this way.*Shown as request* | | **kube\_apiserver.process\_cpu\_total**(count) | Total user and system CPU time spent in seconds.*Shown as second* | | **kube\_apiserver.process\_resident\_memory\_bytes**(gauge) | The resident memory size in bytes*Shown as byte* | | **kube\_apiserver.process\_virtual\_memory\_bytes**(gauge) | The virtual memory size in bytes*Shown as byte* | | **kube\_apiserver.registered\_watchers**(gauge) | The number of currently registered watchers for a given resource*Shown as object* | | **kube\_apiserver.request\_duration\_seconds.count**(count) | The response latency distribution in seconds for each verb, dry run value, group, version, resource, subresource, scope, and component count | | **kube\_apiserver.request\_duration\_seconds.sum**(gauge) | The response latency distribution in seconds for each verb, dry run value, group, version, resource, subresource, scope, and component*Shown as second* | | **kube\_apiserver.request\_latencies.count**(count) | The response latency distribution in microseconds for each verb, resource, and subresource count | | **kube\_apiserver.request\_latencies.sum**(gauge) | The response latency distribution in microseconds for each verb, resource and subresource*Shown as microsecond* | | **kube\_apiserver.requested\_deprecated\_apis**(gauge) | Gauge of deprecated APIs that have been requested, broken out by API group, version, resource, subresource, and removed_release*Shown as request* | | **kube\_apiserver.rest\_client\_request\_latency\_seconds.count**(count) | The request latency in seconds broken down by verb and URL count | | **kube\_apiserver.rest\_client\_request\_latency\_seconds.sum**(gauge) | The request latency in seconds broken down by verb and URL*Shown as second* | | **kube\_apiserver.rest\_client\_requests\_total**(gauge) | The accumulated number of HTTP requests partitioned by status code method and host*Shown as request* | | **kube\_apiserver.rest\_client\_requests\_total.count**(count) | The monotonic count of HTTP requests partitioned by status code method and host*Shown as request* | | **kube\_apiserver.slis.kubernetes\_healthcheck**(gauge) | Result of a single kubernetes apiserver healthcheck (alpha; requires k8s v1.26+) | | **kube\_apiserver.slis.kubernetes\_healthcheck\_total**(count) | The monotonic count of all kubernetes apiserver healthchecks (alpha; requires k8s v1.26+) | | **kube\_apiserver.storage\_list\_evaluated\_objects\_total**(gauge) | The number of objects tested in the course of serving a LIST request from storage (alpha; Kubernetes 1.23+)*Shown as object* | | **kube\_apiserver.storage\_list\_fetched\_objects\_total**(gauge) | The number of objects read from storage in the course of serving a LIST request (alpha; Kubernetes 1.23+)*Shown as object* | | **kube\_apiserver.storage\_list\_returned\_objects\_total**(gauge) | The number of objects returned for a LIST request from storage (alpha; Kubernetes 1.23+)*Shown as object* | | **kube\_apiserver.storage\_list\_total**(gauge) | The number of LIST requests served from storage (alpha; Kubernetes 1.23+)*Shown as object* | | **kube\_apiserver.storage\_objects**(gauge) | The number of stored objects at the time of last check split by kind (Kubernetes 1.21+; replaces etcd_object_counts)*Shown as object* | | **kube\_apiserver.watch\_events\_sizes.count**(count) | The watch event size distribution (Kubernetes 1.16+) | | **kube\_apiserver.watch\_events\_sizes.sum**(gauge) | The watch event size distribution (Kubernetes 1.16+)*Shown as byte* | ### Kubernetes controller manager{% #kubernetes-controller-manager %} For more information, see the documentation for the [Kubernetes controller manager](https://docs.datadoghq.com/integrations/kube_controller_manager/) integration. | | | | | **kube\_controller\_manager.goroutines**(gauge) | Number of goroutines that currently exist | | **kube\_controller\_manager.job\_controller.terminated\_pods\_tracking\_finalizer**(count) | Used to monitor whether the job controller is removing Pod finalizers from terminated Pods after accounting them in Job status | | **kube\_controller\_manager.leader\_election.lease\_duration**(gauge) | Duration of the leadership lease | | **kube\_controller\_manager.leader\_election.transitions**(count) | Number of leadership transitions observed | | **kube\_controller\_manager.max\_fds**(gauge) | Maximum allowed open file descriptors | | **kube\_controller\_manager.nodes.count**(gauge) | Number of registered nodes, per zone | | **kube\_controller\_manager.nodes.evictions**(count) | Count of node eviction events, per zone | | **kube\_controller\_manager.nodes.unhealthy**(gauge) | Number of unhealthy nodes, per zone | | **kube\_controller\_manager.open\_fds**(gauge) | Number of open file descriptors | | **kube\_controller\_manager.queue.adds**(count) | Elements added, by queue | | **kube\_controller\_manager.queue.depth**(gauge) | Current depth, by queue | | **kube\_controller\_manager.queue.latency.count**(gauge) | Processing latency count, by queue (deprecated in kubernetes v1.14) | | **kube\_controller\_manager.queue.latency.quantile**(gauge) | Processing latency quantiles, by queue (deprecated in kubernetes v1.14)*Shown as microsecond* | | **kube\_controller\_manager.queue.latency.sum**(gauge) | Processing latency sum, by queue (deprecated in kubernetes v1.14)*Shown as microsecond* | | **kube\_controller\_manager.queue.process\_duration.count**(gauge) | How long processing an item from workqueue takes, by queue | | **kube\_controller\_manager.queue.process\_duration.sum**(gauge) | Total workqueue processing time, by queue*Shown as second* | | **kube\_controller\_manager.queue.queue\_duration.count**(gauge) | How long item stays in a queue before being requested, by queue | | **kube\_controller\_manager.queue.queue\_duration.sum**(gauge) | Total time of items stays in a queue before being requested, by queue*Shown as second* | | **kube\_controller\_manager.queue.retries**(count) | Retries handled, by queue | | **kube\_controller\_manager.queue.work\_duration.count**(gauge) | Work duration, by queue (deprecated in kubernetes v1.14) | | **kube\_controller\_manager.queue.work\_duration.quantile**(gauge) | Work duration quantiles, by queue (deprecated in kubernetes v1.14)*Shown as microsecond* | | **kube\_controller\_manager.queue.work\_duration.sum**(gauge) | Work duration sum, by queue (deprecated in kubernetes v1.14)*Shown as microsecond* | | **kube\_controller\_manager.queue.work\_longest\_duration**(gauge) | How many seconds has the longest running processor been running, by queue*Shown as second* | | **kube\_controller\_manager.queue.work\_unfinished\_duration**(gauge) | How many seconds of work has done that is in progress and hasn't been observed by process_duration, by queue*Shown as second* | | **kube\_controller\_manager.rate\_limiter.use**(gauge) | Usage of the rate limiter, by limiter | | **kube\_controller\_manager.slis.kubernetes\_healthcheck**(gauge) | Result of a single controller manager healthcheck (alpha; requires k8s v1.26+) | | **kube\_controller\_manager.slis.kubernetes\_healthcheck\_total**(count) | Cumulative results of all controller manager healthchecks (alpha; requires k8s v1.26+) | | **kube\_controller\_manager.threads**(gauge) | Number of OS threads created | ### Kubernetes metrics server{% #kubernetes-metrics-server %} For more information, see the documentation for the [Kubernetes metrics server](https://docs.datadoghq.com/integrations/kube_metrics_server) integration. | | | | | **kube\_metrics\_server.authenticated\_user.requests**(count) | Counter of authenticated requests broken out by username | | **kube\_metrics\_server.go.gc\_duration\_seconds.count**(gauge) | Number of the GC invocation | | **kube\_metrics\_server.go.gc\_duration\_seconds.quantile**(gauge) | GC invocation durations quantiles | | **kube\_metrics\_server.go.gc\_duration\_seconds.sum**(gauge) | GC invocation durations sum | | **kube\_metrics\_server.go.goroutines**(gauge) | Number of goroutines that currently exist | | **kube\_metrics\_server.kubelet\_summary\_request\_duration.count**(gauge) | Number of Kubelet summary request | | **kube\_metrics\_server.kubelet\_summary\_request\_duration.sum**(gauge) | The Kubelet summary request latencies sum | | **kube\_metrics\_server.kubelet\_summary\_scrapes\_total**(count) | Total number of attempted Summary API scrapes done by Metrics Server | | **kube\_metrics\_server.manager\_tick\_duration.count**(gauge) | The total time spent collecting and storing metrics | | **kube\_metrics\_server.manager\_tick\_duration.sum**(gauge) | The total time spent collecting and storing metrics | | **kube\_metrics\_server.process.max\_fds**(gauge) | Maximum number of open file descriptors | | **kube\_metrics\_server.process.open\_fds**(gauge) | Number of open file descriptors | | **kube\_metrics\_server.scraper\_duration.count**(gauge) | Time spent scraping sources | | **kube\_metrics\_server.scraper\_duration.sum**(gauge) | Time spent scraping sources | | **kube\_metrics\_server.scraper\_last\_time**(gauge) | Last time metrics-server performed a scrape since unix epoch | ### Kubernetes scheduler{% #kubernetes-scheduler %} For more information, see the documentation for the [Kubernetes scheduler](https://docs.datadoghq.com/integrations/kube_scheduler) integration. | | | | | **kube\_scheduler.binding\_duration.count**(gauge) | Number of latency in seconds | | **kube\_scheduler.binding\_duration.sum**(gauge) | Total binding latency in seconds | | **kube\_scheduler.cache.lookups**(count) | Number of equivalence cache lookups, by whether or not a cache entry was found | | **kube\_scheduler.client.http.requests**(count) | Number of HTTP requests, partitioned by status code, method, and host | | **kube\_scheduler.client.http.requests\_duration.count**(gauge) | Number of client requests. Broken down by verb and URL | | **kube\_scheduler.client.http.requests\_duration.sum**(gauge) | Total latency. Broken down by verb and URL | | **kube\_scheduler.gc\_duration\_seconds.count**(gauge) | Number of the GC invocation | | **kube\_scheduler.gc\_duration\_seconds.quantile**(gauge) | GC invocation durations quantiles | | **kube\_scheduler.gc\_duration\_seconds.sum**(gauge) | GC invocation durations sum | | **kube\_scheduler.goroutine\_by\_scheduling\_operation**(gauge) | Number of running goroutines split by the work they do such as binding (alpha; requires k8s v1.26+) | | **kube\_scheduler.goroutines**(gauge) | Number of goroutines that currently exist | | **kube\_scheduler.max\_fds**(gauge) | Maximum allowed open file descriptors | | **kube\_scheduler.open\_fds**(gauge) | Number of open file descriptors | | **kube\_scheduler.pending\_pods**(gauge) | Number of pending pods, by the queue type (requires k8s v1.15+) | | **kube\_scheduler.pod\_preemption.attempts**(count) | Number of preemption attempts in the cluster till now | | **kube\_scheduler.pod\_preemption.victims.count**(gauge) | Number of selected pods during the latest preemption round | | **kube\_scheduler.pod\_preemption.victims.sum**(gauge) | Total selected pods during the latest preemption round | | **kube\_scheduler.queue.incoming\_pods**(count) | Number of pods added to scheduling queues by event and queue type (requires k8s v1.17+) | | **kube\_scheduler.schedule\_attempts**(gauge) | Number of attempts to schedule pods, by the result. 'unschedulable' means a pod could not be scheduled, while 'error' means an internal scheduler problem. | | **kube\_scheduler.scheduling.algorithm.predicate\_duration.count**(gauge) | Number of scheduling algorithm predicate evaluation | | **kube\_scheduler.scheduling.algorithm.predicate\_duration.sum**(gauge) | Total scheduling algorithm predicate evaluation duration | | **kube\_scheduler.scheduling.algorithm.preemption\_duration.count**(gauge) | Number of scheduling algorithm preemption evaluation | | **kube\_scheduler.scheduling.algorithm.preemption\_duration.sum**(gauge) | Total scheduling algorithm preemption evaluation duration | | **kube\_scheduler.scheduling.algorithm.priority\_duration.count**(gauge) | Number of scheduling algorithm priority evaluation | | **kube\_scheduler.scheduling.algorithm.priority\_duration.sum**(gauge) | Total scheduling algorithm priority evaluation duration | | **kube\_scheduler.scheduling.algorithm\_duration.count**(gauge) | Number of scheduling algorithm latency | | **kube\_scheduler.scheduling.algorithm\_duration.sum**(gauge) | Total scheduling algorithm latency | | **kube\_scheduler.scheduling.attempt\_duration.count**(gauge) | Scheduling attempt latency in seconds (scheduling algorithm + binding) (requires k8s v1.23+) | | **kube\_scheduler.scheduling.attempt\_duration.sum**(gauge) | Total scheduling attempt latency in seconds (scheduling algorithm + binding) (requires k8s v1.23+) | | **kube\_scheduler.scheduling.e2e\_scheduling\_duration.count**(gauge) | Number of E2e scheduling latency (scheduling algorithm + binding) | | **kube\_scheduler.scheduling.e2e\_scheduling\_duration.sum**(gauge) | Total E2e scheduling latency (scheduling algorithm + binding) | | **kube\_scheduler.scheduling.pod.scheduling\_attempts.count**(gauge) | Number of attempts to successfully schedule a pod (requires k8s v1.23+) | | **kube\_scheduler.scheduling.pod.scheduling\_attempts.sum**(gauge) | Total number of attempts to successfully schedule a pod (requires k8s v1.23+) | | **kube\_scheduler.scheduling.pod.scheduling\_duration.count**(gauge) | E2e latency for a pod being scheduled which may include multiple scheduling attempts (requires k8s v1.23+) | | **kube\_scheduler.scheduling.pod.scheduling\_duration.sum**(gauge) | Total e2e latency for a pod being scheduled which may include multiple scheduling attempts (requires k8s v1.23+) | | **kube\_scheduler.scheduling.scheduling\_duration.count**(gauge) | Number of scheduling split by sub-parts of the scheduling operation | | **kube\_scheduler.scheduling.scheduling\_duration.quantile**(gauge) | Scheduling latency quantiles split by sub-parts of the scheduling operation | | **kube\_scheduler.scheduling.scheduling\_duration.sum**(gauge) | Total scheduling latency split by sub-parts of the scheduling operation | | **kube\_scheduler.slis.kubernetes\_healthcheck**(gauge) | Result of a single scheduler healthcheck (alpha; requires k8s v1.26+) | | **kube\_scheduler.slis.kubernetes\_healthcheck\_total**(count) | Cumulative results of all scheduler healthchecks (alpha; requires k8s v1.26+) | | **kube\_scheduler.threads**(gauge) | Number of OS threads created | | **kube\_scheduler.volume\_scheduling\_duration.count**(gauge) | Number of Volume scheduling | | **kube\_scheduler.volume\_scheduling\_duration.sum**(gauge) | Total Volume scheduling stage latency | ## Events{% #events %} - Backoff - Conflict - Delete - DeletingAllPods - Didn't have enough resource - Error - Failed - FailedCreate - FailedDelete - FailedMount - FailedSync - Failedvalidation - FreeDiskSpaceFailed - HostPortConflict - InsufficientFreeCPU - InsufficientFreeMemory - InvalidDiskCapacity - Killing - KubeletsetupFailed - NodeNotReady - NodeoutofDisk - OutofDisk - Rebooted - TerminatedAllPods - Unable - Unhealthy ## Service checks{% #service-checks %} ### Kubelet{% #kubelet-1 %} For more information, see the documentation for the [Kubelet](https://docs.datadoghq.com/integrations/kubelet/) integration. **kubernetes.kubelet.check.ping** Returns `CRITICAL` if the Kubelet doesn't respond to Ping. OK, otherwise *Statuses: ok, critical* **kubernetes.kubelet.check.docker** Returns `CRITICAL` if the Docker service doesn't run on the Kubelet. OK, otherwise *Statuses: ok, critical* **kubernetes.kubelet.check.syncloop** Returns `CRITICAL` if the syncloop health check is down. OK, otherwise *Statuses: ok, critical* **kubernetes.kubelet.check** Returns `CRITICAL` if the overall Kubelet health check is down. OK, otherwise *Statuses: ok, critical* ### Kubernetes controller manager{% #kubernetes-controller-manager-1 %} For more information, see the documentation for the [Kubernetes controller manager](https://docs.datadoghq.com/integrations/kube_controller_manager/) integration. **kube\_controller\_manager.prometheus.health** Returns `CRITICAL` if the check cannot access the metrics endpoint. *Statuses: ok, critical* **kube\_controller\_manager.leader\_election.status** Returns `CRITICAL` if no replica is currently set as leader. *Statuses: ok, critical* **kube\_controller\_manager.up** Returns `CRITICAL` if Kube Controller Manager is not healthy. *Statuses: ok, critical* ### Kubernetes metrics server{% #kubernetes-metrics-server-1 %} For more information, see the documentation for the [Kubernetes metrics server](https://docs.datadoghq.com/integrations/kube_metrics_server) integration. **kube\_metrics\_server.prometheus.health** Returns `CRITICAL` if the check cannot access the metrics endpoint. *Statuses: ok, critical* **kube\_metrics\_server.up** Returns `CRITICAL` if Kubernetes Metrics Server is not healthy. *Statuses: ok, critical* ### Kubernetes scheduler{% #kubernetes-scheduler-1 %} For more information, see the documentation for the [Kubernetes scheduler](https://docs.datadoghq.com/integrations/kube_scheduler) integration. **kube\_scheduler.prometheus.health** Returns `CRITICAL` if the check cannot access the metrics endpoint. *Statuses: ok, critical* **kube\_scheduler.leader\_election.status** Returns `CRITICAL` if no replica is currently set as leader. *Statuses: ok, critical* **kube\_scheduler.up** Returns `CRITICAL` if Kube Scheduler is not healthy. *Statuses: ok, critical* ### Kubernetes state metrics core{% #kubernetes-state-metrics-core-1 %} For more information, see the documentation for the [Kubernetes state metrics core](https://docs.datadoghq.com/integrations/kubernetes_state_core/) integration. {% dl %} {% dt %} `kubernetes_state.cronjob.complete` {% /dt %} {% dd %} Whether the last job of the cronjob is failed or not. Tags:`kube_cronjob` `kube_namespace` (`env` `service` `version` from standard labels). {% /dd %} {% dt %} `kubernetes_state.cronjob.on_schedule_check` {% /dt %} {% dd %} Alert if the cronjob's next schedule is in the past. Tags:`kube_cronjob` `kube_namespace` (`env` `service` `version` from standard labels). {% /dd %} {% dt %} `kubernetes_state.job.complete` {% /dt %} {% dd %} Whether the job is failed or not. Tags:`kube_job` or `kube_cronjob` `kube_namespace` (`env` `service` `version` from standard labels). {% /dd %} {% dt %} `kubernetes_state.node.ready` {% /dt %} {% dd %} Whether the node is ready. Tags:`node` `condition` `status`. {% /dd %} {% dt %} `kubernetes_state.node.out_of_disk` {% /dt %} {% dd %} Whether the node is out of disk. Tags:`node` `condition` `status`. {% /dd %} {% dt %} `kubernetes_state.node.disk_pressure` {% /dt %} {% dd %} Whether the node is under disk pressure. Tags:`node` `condition` `status`. {% /dd %} {% dt %} `kubernetes_state.node.network_unavailable` {% /dt %} {% dd %} Whether the node network is unavailable. Tags:`node` `condition` `status`. {% /dd %} {% dt %} `kubernetes_state.node.memory_pressure` {% /dt %} {% dd %} Whether the node network is under memory pressure. Tags:`node` `condition` `status`. {% /dd %} {% /dl %} ## Further Reading{% #further-reading %} - [Collect your application logs](https://docs.datadoghq.com/agent/kubernetes/log/) - [Collect your application traces](https://docs.datadoghq.com/agent/kubernetes/apm/) - [Collect your Prometheus metrics](https://docs.datadoghq.com/agent/kubernetes/prometheus/) - [Collect automatically your applications metrics and logs](https://docs.datadoghq.com/agent/kubernetes/integrations/) - [Limit data collection to a subset of containers only](https://docs.datadoghq.com/agent/guide/autodiscovery-management/) - [Assign tags to all data emitted by a container](https://docs.datadoghq.com/agent/kubernetes/tag/)