---
title: Kueue
description: >-
  Monitor the health and performance of Kueue, the Kubernetes-native job
  queueing system.
breadcrumbs: Docs > Integrations > Kueue
---

> For the complete documentation index, see [llms.txt](https://docs.datadoghq.com/llms.txt).

# Kueue
Supported OS Integration version1.0.0
{% callout %}
# Important note for users on the following Datadog sites: us2.ddog-gov.com

{% alert level="info" %}
To find out if this integration is available in your organization, see your [Datadog Integrations](https://app.datadoghq.com/integrations) page or ask your organization administrator.

To initiate an exception request to enable this integration for your organization, email [support@ddog-gov.com](mailto:support@ddog-gov.com).
{% /alert %}

{% /callout %}
  Kueue Overview (light mode)Kueue Overview (dark mode)
## Overview{% #overview %}

Kueue is a Kubernetes workload queueing system that manages and schedules workloads on your Kubernetes cluster. It prioritizes workloads and schedules them fairly and efficiently.

This integration collects metrics from the Kueue controller manager and API server to help you monitor the health and performance of your Kueue cluster. It also collects events for Workload lifecycle transitions, including admission, eviction, and completion.

## Setup{% #setup %}

### Prerequisites{% #prerequisites %}

Kueue is a cluster-level service. Configure this integration as a Cluster Agent cluster check so only one Agent instance scrapes the Kueue metrics endpoint.

### Installation{% #installation %}

The Kueue check is included in the Datadog Agent package. No additional installation is required on your server.

### Configuration{% #configuration %}

1. To collect optional ClusterQueue resource metrics, such as `kueue.cluster_queue.resource_usage.gpu`, configure Kueue with `metrics.enableClusterQueueResources: true` and restart the Kueue controller manager.
1. Provide a cluster check configuration to the Cluster Agent. For file or ConfigMap based configuration, set `cluster_check: true` in the instance:

```yaml
clusterAgent:
  confd:
    kueue.yaml: |-
      cluster_check: true
      init_config:
      instances:
      - openmetrics_endpoint: http://kueue-controller-manager-metrics-service.kueue-system.svc:8080/metrics
```

Kueue Workload lifecycle events are collected by default. The Agent running the check needs `get` and `list` permissions on the `workloads` resource in the `kueue.x-k8s.io` API group. Set `collect_workload_events: false` to disable event collection. 3. Alternatively, annotate the Kueue metrics service with Autodiscovery cluster check annotations:

```yaml
ad.datadoghq.com/endpoints.checks: |
  {
    "kueue": {
      "instances": [
        {
          "openmetrics_endpoint": "http://%%host%%:%%port%%/metrics"
        }
      ]
    }
  }
```

### Log collection{% #log-collection %}

The Kueue controller manager writes logs to its container output, which Kubernetes captures as container logs. Log collection is disabled by default in the Datadog Agent. To enable it, see Kubernetes log collection in the Datadog documentation. The node Agent running on the node that hosts the Kueue controller manager collects the logs, not the Cluster Agent that runs this cluster check.

After you enable log collection, set the Kueue log configuration as an Autodiscovery annotation on the controller manager's pod template so it persists across pod restarts. Add it under `spec.template.metadata.annotations` of the `kueue-controller-manager` deployment, or set `controllerManager.manager.podAnnotations` if you install Kueue with the Helm chart:

```yaml
ad.datadoghq.com/manager.logs: |
  [
    {
      "source": "kueue",
      "service": "<SERVICE_NAME>"
    }
  ]
```

This annotation targets the container named `manager`, which is the container name used by both the Kueue release manifests and the Helm chart. If your Kueue container uses a different name, replace `manager` with that name (`.spec.containers[i].name`).

### Validation{% #validation %}

Run the Cluster Agent's `clusterchecks` subcommand and look for `kueue` under the Checks section.

## Data Collected{% #data-collected %}

### Metrics{% #metrics %}

|  |
|  |
| **kueue.admission.attempts.count**(count)                                      | The total number of workload admission attempts. Each admission attempt might try to admit more than one workload. The 'result' label can be 'success' when at least one workload is admitted or 'inadmissible' when no workload is admitted.                                                                                 |
| **kueue.admission.wait_time.seconds.bucket**(count)                           | The time between workload creation or requeueing and admission, per 'kueue_cluster_queue'.*Shown as second*                                                                                                                                                                                                                   |
| **kueue.admission.wait_time.seconds.count**(count)                            | The time between workload creation or requeueing and admission, per 'kueue_cluster_queue'.*Shown as second*                                                                                                                                                                                                                   |
| **kueue.admission.wait_time.seconds.sum**(count)                              | The time between workload creation or requeueing and admission, per 'kueue_cluster_queue'.*Shown as second*                                                                                                                                                                                                                   |
| **kueue.admission_attempt.duration.seconds.bucket**(count)                    | The duration of an admission attempt. The 'result' label can be 'success' when at least one workload is admitted or 'inadmissible' when no workload is admitted.*Shown as second*                                                                                                                                             |
| **kueue.admission_attempt.duration.seconds.count**(count)                     | The duration of an admission attempt. The 'result' label can be 'success' when at least one workload is admitted or 'inadmissible' when no workload is admitted.*Shown as second*                                                                                                                                             |
| **kueue.admission_attempt.duration.seconds.sum**(count)                       | The duration of an admission attempt. The 'result' label can be 'success' when at least one workload is admitted or 'inadmissible' when no workload is admitted.*Shown as second*                                                                                                                                             |
| **kueue.admission_checks.wait_time.seconds.bucket**(count)                   | The time between quota reservation and admission for a workload, per 'kueue_cluster_queue'.*Shown as second*                                                                                                                                                                                                                  |
| **kueue.admission_checks.wait_time.seconds.count**(count)                    | The time between quota reservation and admission for a workload, per 'kueue_cluster_queue'.*Shown as second*                                                                                                                                                                                                                  |
| **kueue.admission_checks.wait_time.seconds.sum**(count)                      | The time between quota reservation and admission for a workload, per 'kueue_cluster_queue'.*Shown as second*                                                                                                                                                                                                                  |
| **kueue.admission_cycle.preemption_skips**(gauge)                            | The number of Workloads in the ClusterQueue that received preemption candidates but were skipped because other ClusterQueues needed the same resources in the same cycle.                                                                                                                                                     |
| **kueue.admitted.active_workloads**(gauge)                                    | The number of admitted workloads that are active, per 'kueue_cluster_queue'.                                                                                                                                                                                                                                                  |
| **kueue.admitted.workloads.count**(count)                                      | The total number of admitted workloads, per 'kueue_cluster_queue'.                                                                                                                                                                                                                                                            |
| **kueue.admitted_until_ready.wait_time.seconds.bucket**(count)              | The time between workload admission and the workload becoming ready, per 'kueue_cluster_queue'.*Shown as second*                                                                                                                                                                                                              |
| **kueue.admitted_until_ready.wait_time.seconds.count**(count)               | The time between workload admission and the workload becoming ready, per 'kueue_cluster_queue'.*Shown as second*                                                                                                                                                                                                              |
| **kueue.admitted_until_ready.wait_time.seconds.sum**(count)                 | The time between workload admission and the workload becoming ready, per 'kueue_cluster_queue'.*Shown as second*                                                                                                                                                                                                              |
| **kueue.build_info**(gauge)                                                   | Kueue build information. The value is 1 and is labeled by Git version, Git commit, build date, Go version, compiler, and platform.                                                                                                                                                                                            |
| **kueue.certwatcher.read_certificate.count**(count)                           | Kueue certwatcher read certificate metric.                                                                                                                                                                                                                                                                                    |
| **kueue.certwatcher.read_certificate_errors.count**(count)                   | Kueue certwatcher read certificate errors metric.                                                                                                                                                                                                                                                                             |
| **kueue.cluster_queue.borrowing_limit.cpu**(gauge)                           | Reports the ClusterQueue's resource borrowing limit across all flavors.                                                                                                                                                                                                                                                       |
| **kueue.cluster_queue.borrowing_limit.gpu**(gauge)                           | Reports the ClusterQueue's resource borrowing limit across all flavors.                                                                                                                                                                                                                                                       |
| **kueue.cluster_queue.borrowing_limit.memory**(gauge)                        | Reports the ClusterQueue's resource borrowing limit across all flavors.                                                                                                                                                                                                                                                       |
| **kueue.cluster_queue.borrowing_limit.other**(gauge)                         | Reports the ClusterQueue's resource borrowing limit across all flavors.                                                                                                                                                                                                                                                       |
| **kueue.cluster_queue.info**(gauge)                                           | Reports ClusterQueue hierarchy information. The metric has value 1 and can be joined using labels.                                                                                                                                                                                                                            |
| **kueue.cluster_queue.lending_limit.cpu**(gauge)                             | Reports the ClusterQueue's resource lending limit across all flavors.                                                                                                                                                                                                                                                         |
| **kueue.cluster_queue.lending_limit.gpu**(gauge)                             | Reports the ClusterQueue's resource lending limit across all flavors.                                                                                                                                                                                                                                                         |
| **kueue.cluster_queue.lending_limit.memory**(gauge)                          | Reports the ClusterQueue's resource lending limit across all flavors.                                                                                                                                                                                                                                                         |
| **kueue.cluster_queue.lending_limit.other**(gauge)                           | Reports the ClusterQueue's resource lending limit across all flavors.                                                                                                                                                                                                                                                         |
| **kueue.cluster_queue.nominal_quota.cpu**(gauge)                             | Reports the ClusterQueue's nominal resource quota across all flavors.                                                                                                                                                                                                                                                         |
| **kueue.cluster_queue.nominal_quota.gpu**(gauge)                             | Reports the ClusterQueue's nominal resource quota across all flavors.                                                                                                                                                                                                                                                         |
| **kueue.cluster_queue.nominal_quota.memory**(gauge)                          | Reports the ClusterQueue's nominal resource quota across all flavors.                                                                                                                                                                                                                                                         |
| **kueue.cluster_queue.nominal_quota.other**(gauge)                           | Reports the ClusterQueue's nominal resource quota across all flavors.                                                                                                                                                                                                                                                         |
| **kueue.cluster_queue.resource_pending.cpu**(gauge)                          | Reports the ClusterQueue's total pending resource requests. Unlike resource_reservation, pending workloads have not yet been assigned to flavors.                                                                                                                                                                             |
| **kueue.cluster_queue.resource_pending.gpu**(gauge)                          | Reports the ClusterQueue's total pending resource requests. Unlike resource_reservation, pending workloads have not yet been assigned to flavors.                                                                                                                                                                             |
| **kueue.cluster_queue.resource_pending.memory**(gauge)                       | Reports the ClusterQueue's total pending resource requests. Unlike resource_reservation, pending workloads have not yet been assigned to flavors.                                                                                                                                                                             |
| **kueue.cluster_queue.resource_pending.other**(gauge)                        | Reports the ClusterQueue's total pending resource requests. Unlike resource_reservation, pending workloads have not yet been assigned to flavors.                                                                                                                                                                             |
| **kueue.cluster_queue.resource_reservation.cpu**(gauge)                      | Reports the ClusterQueue's total resource reservation across all flavors.                                                                                                                                                                                                                                                     |
| **kueue.cluster_queue.resource_reservation.gpu**(gauge)                      | Reports the ClusterQueue's total resource reservation across all flavors.                                                                                                                                                                                                                                                     |
| **kueue.cluster_queue.resource_reservation.memory**(gauge)                   | Reports the ClusterQueue's total resource reservation across all flavors.                                                                                                                                                                                                                                                     |
| **kueue.cluster_queue.resource_reservation.other**(gauge)                    | Reports the ClusterQueue's total resource reservation across all flavors.                                                                                                                                                                                                                                                     |
| **kueue.cluster_queue.resource_usage.cpu**(gauge)                            | Reports the ClusterQueue's total resource usage across all flavors.                                                                                                                                                                                                                                                           |
| **kueue.cluster_queue.resource_usage.gpu**(gauge)                            | Reports the ClusterQueue's total resource usage across all flavors.                                                                                                                                                                                                                                                           |
| **kueue.cluster_queue.resource_usage.memory**(gauge)                         | Reports the ClusterQueue's total resource usage across all flavors.                                                                                                                                                                                                                                                           |
| **kueue.cluster_queue.resource_usage.other**(gauge)                          | Reports the ClusterQueue's total resource usage across all flavors.                                                                                                                                                                                                                                                           |
| **kueue.cluster_queue.status**(gauge)                                         | Reports the 'status' of each 'kueue_cluster_queue'. Possible values are 'pending', 'active', and 'terminating'. For a ClusterQueue, the metric reports a value of 1 for exactly one status.                                                                                                                                   |
| **kueue.cluster_queue.weighted_share**(gauge)                                | Reports the maximum ratio of usage above nominal quota to lendable resources in the cohort across all resources provided by the ClusterQueue, divided by weight. A value of 0 means that the ClusterQueue's usage is below the nominal quota. If the ClusterQueue has a weight of 0 and is borrowing, the metric returns NaN. |
| **kueue.cohort.info**(gauge)                                                   | Reports Cohort hierarchy information. The metric has value 1 and can be joined using labels.                                                                                                                                                                                                                                  |
| **kueue.cohort.weighted_share**(gauge)                                        | Reports the maximum ratio of usage above nominal quota to lendable resources in the Cohort across all resources provided by the Cohort, divided by weight. A value of 0 means that the Cohort's usage is below the nominal quota. If the Cohort has a weight of 0 and is borrowing, the metric returns NaN.                   |
| **kueue.cohort_subtree.admitted.active_workloads**(gauge)                    | The number of admitted Workloads that are active, per cohort subtree.                                                                                                                                                                                                                                                         |
| **kueue.cohort_subtree.admitted.workloads.count**(count)                      | The total number of admitted workloads, per cohort subtree.                                                                                                                                                                                                                                                                   |
| **kueue.cohort_subtree.quota.cpu**(gauge)                                     | Reports the cohort's nominal quota aggregated within the cohort subtree. Values are reported per resource and flavor.                                                                                                                                                                                                         |
| **kueue.cohort_subtree.quota.gpu**(gauge)                                     | Reports the cohort's nominal quota aggregated within the cohort subtree. Values are reported per resource and flavor.                                                                                                                                                                                                         |
| **kueue.cohort_subtree.quota.memory**(gauge)                                  | Reports the cohort's nominal quota aggregated within the cohort subtree. Values are reported per resource and flavor.                                                                                                                                                                                                         |
| **kueue.cohort_subtree.quota.other**(gauge)                                   | Reports the cohort's nominal quota aggregated within the cohort subtree. Values are reported per resource and flavor.                                                                                                                                                                                                         |
| **kueue.cohort_subtree.resource_reservations.cpu**(gauge)                    | Reports the cohort's resource reservations aggregated within the cohort subtree. Values are reported per resource and flavor.                                                                                                                                                                                                 |
| **kueue.cohort_subtree.resource_reservations.gpu**(gauge)                    | Reports the cohort's resource reservations aggregated within the cohort subtree. Values are reported per resource and flavor.                                                                                                                                                                                                 |
| **kueue.cohort_subtree.resource_reservations.memory**(gauge)                 | Reports the cohort's resource reservations aggregated within the cohort subtree. Values are reported per resource and flavor.                                                                                                                                                                                                 |
| **kueue.cohort_subtree.resource_reservations.other**(gauge)                  | Reports the cohort's resource reservations aggregated within the cohort subtree. Values are reported per resource and flavor.                                                                                                                                                                                                 |
| **kueue.controller.runtime.active_workers**(gauge)                            | Kueue controller runtime active workers metric.                                                                                                                                                                                                                                                                               |
| **kueue.controller.runtime.conversion_webhook_panics.count**(count)          | Kueue controller runtime conversion webhook panics metric.                                                                                                                                                                                                                                                                    |
| **kueue.controller.runtime.max_concurrent_reconciles**(gauge)                | Kueue controller runtime max concurrent reconciles metric.                                                                                                                                                                                                                                                                    |
| **kueue.controller.runtime.reconcile.count**(count)                            | Kueue controller runtime reconcile metric.                                                                                                                                                                                                                                                                                    |
| **kueue.controller.runtime.reconcile_errors.count**(count)                    | Kueue controller runtime reconcile errors metric.                                                                                                                                                                                                                                                                             |
| **kueue.controller.runtime.reconcile_panics.count**(count)                    | Kueue controller runtime reconcile panics metric.                                                                                                                                                                                                                                                                             |
| **kueue.controller.runtime.reconcile_time.seconds.bucket**(count)             | Kueue controller runtime reconcile time seconds metric.*Shown as second*                                                                                                                                                                                                                                                      |
| **kueue.controller.runtime.reconcile_time.seconds.count**(count)              | Kueue controller runtime reconcile time seconds metric.*Shown as second*                                                                                                                                                                                                                                                      |
| **kueue.controller.runtime.reconcile_time.seconds.sum**(count)                | Kueue controller runtime reconcile time seconds metric.*Shown as second*                                                                                                                                                                                                                                                      |
| **kueue.controller.runtime.reconcile_timeouts.count**(count)                  | Kueue controller runtime reconcile timeouts metric.                                                                                                                                                                                                                                                                           |
| **kueue.controller.runtime.terminal_reconcile_errors.count**(count)          | Kueue controller runtime terminal reconcile errors metric.                                                                                                                                                                                                                                                                    |
| **kueue.controller.runtime.webhook_latency.seconds.bucket**(count)            | Kueue controller runtime webhook latency seconds metric.*Shown as second*                                                                                                                                                                                                                                                     |
| **kueue.controller.runtime.webhook_latency.seconds.count**(count)             | Kueue controller runtime webhook latency seconds metric.*Shown as second*                                                                                                                                                                                                                                                     |
| **kueue.controller.runtime.webhook_latency.seconds.sum**(count)               | Kueue controller runtime webhook latency seconds metric.*Shown as second*                                                                                                                                                                                                                                                     |
| **kueue.controller.runtime.webhook_panics.count**(count)                      | Kueue controller runtime webhook panics metric.                                                                                                                                                                                                                                                                               |
| **kueue.controller.runtime.webhook_requests.count**(count)                    | Kueue controller runtime webhook requests metric.                                                                                                                                                                                                                                                                             |
| **kueue.controller.runtime.webhook_requests_in_flight**(gauge)              | Kueue controller runtime webhook requests in flight metric.                                                                                                                                                                                                                                                                   |
| **kueue.evicted_workloads.count**(count)                                      | The number of evicted workloads per cluster queue, tagged by reason, underlying cause, priority class, and replica role.                                                                                                                                                                                                      |
| **kueue.evicted_workloads_once.count**(count)                                | The number of unique workload evictions per cluster queue, tagged by eviction reason, underlying cause, priority class, and replica role.                                                                                                                                                                                     |
| **kueue.finished_workloads**(gauge)                                           | The number of finished workloads, per 'kueue_cluster_queue'.                                                                                                                                                                                                                                                                  |
| **kueue.finished_workloads.count**(count)                                     | The total number of finished workloads, per 'kueue_cluster_queue'.                                                                                                                                                                                                                                                            |
| **kueue.go.gc.duration.seconds.count**(count)                                  | The summary count of garbage collection cycles.*Shown as second*                                                                                                                                                                                                                                                              |
| **kueue.go.gc.duration.seconds.quantile**(gauge)                               | A summary of the pause duration of garbage collection cycles.*Shown as second*                                                                                                                                                                                                                                                |
| **kueue.go.gc.duration.seconds.sum**(count)                                    | The sum of the pause duration of garbage collection cycles.*Shown as second*                                                                                                                                                                                                                                                  |
| **kueue.go.gc.gogc.percent**(gauge)                                            | Kueue go gc gogc percent metric.*Shown as percent*                                                                                                                                                                                                                                                                            |
| **kueue.go.gc.gomemlimit.bytes**(gauge)                                        | Kueue go gc gomemlimit bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                           |
| **kueue.go.goroutines**(gauge)                                                 | Number of goroutines that currently exist.                                                                                                                                                                                                                                                                                    |
| **kueue.go.info**(gauge)                                                       | Kueue go info metric.                                                                                                                                                                                                                                                                                                         |
| **kueue.go.memstats.alloc_bytes**(gauge)                                      | Kueue go memstats alloc bytes metric.                                                                                                                                                                                                                                                                                         |
| **kueue.go.memstats.alloc_bytes.count**(count)                                | Kueue go memstats alloc bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                          |
| **kueue.go.memstats.buck_hash.sys_bytes**(gauge)                             | Kueue go memstats buck hash sys bytes metric.                                                                                                                                                                                                                                                                                 |
| **kueue.go.memstats.frees.count**(count)                                       | Kueue go memstats frees metric.                                                                                                                                                                                                                                                                                               |
| **kueue.go.memstats.gc.sys_bytes**(gauge)                                     | Kueue go memstats gc sys bytes metric.                                                                                                                                                                                                                                                                                        |
| **kueue.go.memstats.heap_alloc.bytes**(gauge)                                 | Kueue go memstats heap alloc bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                     |
| **kueue.go.memstats.heap_idle.bytes**(gauge)                                  | Kueue go memstats heap idle bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                      |
| **kueue.go.memstats.heap_inuse.bytes**(gauge)                                 | Kueue go memstats heap inuse bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                     |
| **kueue.go.memstats.heap_objects**(gauge)                                     | Kueue go memstats heap objects metric.                                                                                                                                                                                                                                                                                        |
| **kueue.go.memstats.heap_released.bytes**(gauge)                              | Kueue go memstats heap released bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                  |
| **kueue.go.memstats.heap_sys.bytes**(gauge)                                   | Kueue go memstats heap sys bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                       |
| **kueue.go.memstats.mallocs.count**(count)                                     | Kueue go memstats mallocs metric.                                                                                                                                                                                                                                                                                             |
| **kueue.go.memstats.mcache_inuse.bytes**(gauge)                               | Kueue go memstats mcache inuse bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                   |
| **kueue.go.memstats.mcache_sys.bytes**(gauge)                                 | Kueue go memstats mcache sys bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                     |
| **kueue.go.memstats.mspan_inuse.bytes**(gauge)                                | Kueue go memstats mspan inuse bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                    |
| **kueue.go.memstats.mspan_sys.bytes**(gauge)                                  | Kueue go memstats mspan sys bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                      |
| **kueue.go.memstats.next_gc.bytes**(gauge)                                    | Kueue go memstats next gc bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                        |
| **kueue.go.memstats.other_sys.bytes**(gauge)                                  | Kueue go memstats other sys bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                      |
| **kueue.go.memstats.stack_inuse.bytes**(gauge)                                | Kueue go memstats stack inuse bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                    |
| **kueue.go.memstats.stack_sys.bytes**(gauge)                                  | Kueue go memstats stack sys bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                      |
| **kueue.go.memstats.sys.bytes**(gauge)                                         | Kueue go memstats sys bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                            |
| **kueue.go.memstats.time_since_last_gc.seconds**(gauge)                     | Kueue go memstats time since last gc seconds metric.*Shown as second*                                                                                                                                                                                                                                                         |
| **kueue.go.threads**(gauge)                                                    | Kueue go threads metric.                                                                                                                                                                                                                                                                                                      |
| **kueue.leader_election.master_status**(gauge)                               | Kueue leader election master status metric.                                                                                                                                                                                                                                                                                   |
| **kueue.local_queue.admission.wait_time.seconds.bucket**(count)              | The time between workload creation or requeueing and admission, per 'kueue_local_queue'.*Shown as second*                                                                                                                                                                                                                     |
| **kueue.local_queue.admission.wait_time.seconds.count**(count)               | The time between workload creation or requeueing and admission, per 'kueue_local_queue'.*Shown as second*                                                                                                                                                                                                                     |
| **kueue.local_queue.admission.wait_time.seconds.sum**(count)                 | The time between workload creation or requeueing and admission, per 'kueue_local_queue'.*Shown as second*                                                                                                                                                                                                                     |
| **kueue.local_queue.admission_checks.wait_time.seconds.bucket**(count)      | The time between quota reservation and admission for a workload, per 'kueue_local_queue'.*Shown as second*                                                                                                                                                                                                                    |
| **kueue.local_queue.admission_checks.wait_time.seconds.count**(count)       | The time between quota reservation and admission for a workload, per 'kueue_local_queue'.*Shown as second*                                                                                                                                                                                                                    |
| **kueue.local_queue.admission_checks.wait_time.seconds.sum**(count)         | The time between quota reservation and admission for a workload, per 'kueue_local_queue'.*Shown as second*                                                                                                                                                                                                                    |
| **kueue.local_queue.admitted.active_workloads**(gauge)                       | The number of admitted Workloads that are active, per 'kueue_local_queue'.                                                                                                                                                                                                                                                    |
| **kueue.local_queue.admitted.workloads.count**(count)                         | The total number of admitted workloads, per 'kueue_local_queue'.                                                                                                                                                                                                                                                              |
| **kueue.local_queue.admitted_until_ready.wait_time.seconds.bucket**(count) | The time between workload admission and the workload becoming ready, per 'kueue_local_queue'.*Shown as second*                                                                                                                                                                                                                |
| **kueue.local_queue.admitted_until_ready.wait_time.seconds.count**(count)  | The time between workload admission and the workload becoming ready, per 'kueue_local_queue'.*Shown as second*                                                                                                                                                                                                                |
| **kueue.local_queue.admitted_until_ready.wait_time.seconds.sum**(count)    | The time between workload admission and the workload becoming ready, per 'kueue_local_queue'.*Shown as second*                                                                                                                                                                                                                |
| **kueue.local_queue.evicted_workloads.count**(count)                         | The number of evicted workloads per local queue, tagged by namespace, reason, underlying cause, priority class, and replica role.                                                                                                                                                                                             |
| **kueue.local_queue.finished_workloads**(gauge)                              | The number of finished workloads, per 'kueue_local_queue'.                                                                                                                                                                                                                                                                    |
| **kueue.local_queue.finished_workloads.count**(count)                        | The total number of finished workloads, per 'kueue_local_queue'.                                                                                                                                                                                                                                                              |
| **kueue.local_queue.pending_workloads**(gauge)                               | The number of pending workloads, per 'kueue_local_queue' and 'status'. The 'status' value can be 'active' for workloads in the admission queue or 'inadmissible' for workloads with a failed admission attempt that are not retried until cluster conditions that could make them admissible change.                          |
| **kueue.local_queue.quota_reserved.wait_time.seconds.bucket**(count)        | The time from when a workload is created or requeued until it receives a quota reservation, per 'kueue_local_queue'.*Shown as second*                                                                                                                                                                                         |
| **kueue.local_queue.quota_reserved.wait_time.seconds.count**(count)         | The time from when a workload is created or requeued until it receives a quota reservation, per 'kueue_local_queue'.*Shown as second*                                                                                                                                                                                         |
| **kueue.local_queue.quota_reserved.wait_time.seconds.sum**(count)           | The time from when a workload is created or requeued until it receives a quota reservation, per 'kueue_local_queue'.*Shown as second*                                                                                                                                                                                         |
| **kueue.local_queue.quota_reserved.workloads.count**(count)                  | The total number of quota-reserved workloads, per 'kueue_local_queue'.                                                                                                                                                                                                                                                        |
| **kueue.local_queue.ready_wait_time.seconds.bucket**(count)                 | The time between workload creation or requeueing and the workload becoming ready, per 'kueue_local_queue'.*Shown as second*                                                                                                                                                                                                   |
| **kueue.local_queue.ready_wait_time.seconds.count**(count)                  | The time between workload creation or requeueing and the workload becoming ready, per 'kueue_local_queue'.*Shown as second*                                                                                                                                                                                                   |
| **kueue.local_queue.ready_wait_time.seconds.sum**(count)                    | The time between workload creation or requeueing and the workload becoming ready, per 'kueue_local_queue'.*Shown as second*                                                                                                                                                                                                   |
| **kueue.local_queue.reserving.active_workloads**(gauge)                      | The number of Workloads that are reserving quota, per 'kueue_local_queue'.                                                                                                                                                                                                                                                    |
| **kueue.local_queue.resource_reservation.cpu**(gauge)                        | Reports the LocalQueue's total resource reservation across all flavors.                                                                                                                                                                                                                                                       |
| **kueue.local_queue.resource_reservation.gpu**(gauge)                        | Reports the LocalQueue's total resource reservation across all flavors.                                                                                                                                                                                                                                                       |
| **kueue.local_queue.resource_reservation.memory**(gauge)                     | Reports the LocalQueue's total resource reservation across all flavors.                                                                                                                                                                                                                                                       |
| **kueue.local_queue.resource_reservation.other**(gauge)                      | Reports the LocalQueue's total resource reservation across all flavors.                                                                                                                                                                                                                                                       |
| **kueue.local_queue.resource_usage.cpu**(gauge)                              | Reports the LocalQueue's total resource usage across all flavors.                                                                                                                                                                                                                                                             |
| **kueue.local_queue.resource_usage.gpu**(gauge)                              | Reports the LocalQueue's total resource usage across all flavors.                                                                                                                                                                                                                                                             |
| **kueue.local_queue.resource_usage.memory**(gauge)                           | Reports the LocalQueue's total resource usage across all flavors.                                                                                                                                                                                                                                                             |
| **kueue.local_queue.resource_usage.other**(gauge)                            | Reports the LocalQueue's total resource usage across all flavors.                                                                                                                                                                                                                                                             |
| **kueue.local_queue.status**(gauge)                                           | Reports the 'active' status of each 'kueue_local_queue'. Possible values are 'True', 'False', and 'Unknown'. For a LocalQueue, only one status has a value of 1.                                                                                                                                                              |
| **kueue.pending_workloads**(gauge)                                            | The number of pending workloads, per 'kueue_cluster_queue' and 'status'. The 'status' value can be 'active' for workloads in the admission queue or 'inadmissible' for workloads with a failed admission attempt that are not retried until cluster conditions that could make them admissible change.                        |
| **kueue.pods_ready_to_evicted_time.seconds.bucket**(count)                 | Bucket counts for the time between the workload's pods becoming ready and workload eviction, tagged by cluster queue, reason, underlying cause, and replica role.*Shown as second*                                                                                                                                            |
| **kueue.pods_ready_to_evicted_time.seconds.count**(count)                  | Count of observations for the time between the workload's pods becoming ready and workload eviction, tagged by cluster queue, reason, underlying cause, and replica role.*Shown as second*                                                                                                                                    |
| **kueue.pods_ready_to_evicted_time.seconds.sum**(count)                    | Total time between the workload's pods becoming ready and workload eviction, tagged by cluster queue, reason, underlying cause, and replica role.*Shown as second*                                                                                                                                                            |
| **kueue.preempted_workloads.count**(count)                                    | The number of preempted workloads per preempting cluster queue, tagged by preemption reason and replica role.                                                                                                                                                                                                                 |
| **kueue.process.cpu.seconds.count**(count)                                     | Kueue process cpu seconds metric.*Shown as second*                                                                                                                                                                                                                                                                            |
| **kueue.process.max_fds**(gauge)                                              | Kueue process max fds metric.                                                                                                                                                                                                                                                                                                 |
| **kueue.process.network_receive.bytes.count**(count)                          | Kueue process network receive bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                    |
| **kueue.process.network_transmit.bytes.count**(count)                         | Kueue process network transmit bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                   |
| **kueue.process.open_fds**(gauge)                                             | Kueue process open fds metric.                                                                                                                                                                                                                                                                                                |
| **kueue.process.resident_memory.bytes**(gauge)                                | Kueue process resident memory bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                    |
| **kueue.process.uptime.seconds**(gauge)                                        | Kueue process uptime seconds metric.*Shown as second*                                                                                                                                                                                                                                                                         |
| **kueue.process.virtual_memory.bytes**(gauge)                                 | Kueue process virtual memory bytes metric.*Shown as byte*                                                                                                                                                                                                                                                                     |
| **kueue.process.virtual_memory.max_bytes**(gauge)                            | Kueue process virtual memory max bytes metric.                                                                                                                                                                                                                                                                                |
| **kueue.quota_reserved.wait_time.seconds.bucket**(count)                     | The time from when a workload is created or requeued until it receives a quota reservation, per 'kueue_cluster_queue'.*Shown as second*                                                                                                                                                                                       |
| **kueue.quota_reserved.wait_time.seconds.count**(count)                      | The time from when a workload is created or requeued until it receives a quota reservation, per 'kueue_cluster_queue'.*Shown as second*                                                                                                                                                                                       |
| **kueue.quota_reserved.wait_time.seconds.sum**(count)                        | The time from when a workload is created or requeued until it receives a quota reservation, per 'kueue_cluster_queue'.*Shown as second*                                                                                                                                                                                       |
| **kueue.quota_reserved.workloads.count**(count)                               | The total number of quota-reserved workloads, per 'kueue_cluster_queue'.                                                                                                                                                                                                                                                      |
| **kueue.ready_wait_time.seconds.bucket**(count)                              | The time between workload creation or requeueing and the workload becoming ready, per 'kueue_cluster_queue'.*Shown as second*                                                                                                                                                                                                 |
| **kueue.ready_wait_time.seconds.count**(count)                               | The time between workload creation or requeueing and the workload becoming ready, per 'kueue_cluster_queue'.*Shown as second*                                                                                                                                                                                                 |
| **kueue.ready_wait_time.seconds.sum**(count)                                 | The time between workload creation or requeueing and the workload becoming ready, per 'kueue_cluster_queue'.*Shown as second*                                                                                                                                                                                                 |
| **kueue.replaced_workload_slices.count**(count)                              | The number of replaced workload slices, per 'kueue_cluster_queue'.                                                                                                                                                                                                                                                            |
| **kueue.reserving.active_workloads**(gauge)                                   | The number of Workloads that are reserving quota, per 'kueue_cluster_queue'.                                                                                                                                                                                                                                                  |
| **kueue.workload.creation_latency.seconds.bucket**(count)                     | The time between job creation and workload creation, per 'job_kind'. Entries are only recorded for objects with generation 1.*Shown as second*                                                                                                                                                                                |
| **kueue.workload.creation_latency.seconds.count**(count)                      | The time between job creation and workload creation, per 'job_kind'. Entries are only recorded for objects with generation 1.*Shown as second*                                                                                                                                                                                |
| **kueue.workload.creation_latency.seconds.sum**(count)                        | The time between job creation and workload creation, per 'job_kind'. Entries are only recorded for objects with generation 1.*Shown as second*                                                                                                                                                                                |
| **kueue.workload.eviction_latency.seconds.bucket**(count)                     | Bucket counts for the time from workload eviction until the workload returns to pending and releases quota, tagged by cluster queue, reason, and replica role.*Shown as second*                                                                                                                                               |
| **kueue.workload.eviction_latency.seconds.count**(count)                      | Count of observations for the time from workload eviction until the workload returns to pending and releases quota, tagged by cluster queue, reason, and replica role.*Shown as second*                                                                                                                                       |
| **kueue.workload.eviction_latency.seconds.sum**(count)                        | Total time from workload eviction until the workload returns to pending and releases quota, tagged by cluster queue, reason, and replica role.*Shown as second*                                                                                                                                                               |
| **kueue.workqueue.adds.count**(count)                                          | Kueue workqueue adds metric.                                                                                                                                                                                                                                                                                                  |
| **kueue.workqueue.depth**(gauge)                                               | Kueue workqueue depth metric.                                                                                                                                                                                                                                                                                                 |
| **kueue.workqueue.longest_running_processor.seconds**(gauge)                 | Kueue workqueue longest running processor seconds metric.*Shown as second*                                                                                                                                                                                                                                                    |
| **kueue.workqueue.queue_duration.seconds.bucket**(count)                      | Kueue workqueue queue duration seconds metric.*Shown as second*                                                                                                                                                                                                                                                               |
| **kueue.workqueue.queue_duration.seconds.count**(count)                       | Kueue workqueue queue duration seconds metric.*Shown as second*                                                                                                                                                                                                                                                               |
| **kueue.workqueue.queue_duration.seconds.sum**(count)                         | Kueue workqueue queue duration seconds metric.*Shown as second*                                                                                                                                                                                                                                                               |
| **kueue.workqueue.retries.count**(count)                                       | Kueue workqueue retries metric.                                                                                                                                                                                                                                                                                               |
| **kueue.workqueue.unfinished_work.seconds**(gauge)                            | Kueue workqueue unfinished work seconds metric.*Shown as second*                                                                                                                                                                                                                                                              |
| **kueue.workqueue.work_duration.seconds.bucket**(count)                       | Kueue workqueue work duration seconds metric.*Shown as second*                                                                                                                                                                                                                                                                |
| **kueue.workqueue.work_duration.seconds.count**(count)                        | Kueue workqueue work duration seconds metric.*Shown as second*                                                                                                                                                                                                                                                                |
| **kueue.workqueue.work_duration.seconds.sum**(count)                          | Kueue workqueue work duration seconds metric.*Shown as second*                                                                                                                                                                                                                                                                |

## Uninstallation{% #uninstallation %}

To disable the integration, rename the configuration file from `kueue.yaml` to `kueue.yaml.example`. Alternatively, if you are running a containerized environment, you can remove the annotation used to enable the integration.

## Support{% #support %}

Need help? Contact [Datadog Support](https://app.datadoghq.com/help).
