---
title: KubeVirt Handler
description: Collect key metrics to monitor the health of your KubeVirt Handler Daemons.
breadcrumbs: Docs > Integrations > KubeVirt Handler
---

# KubeVirt Handler
Supported OS Integration version2.4.0
## Overview{% #overview %}

This check monitors [KubeVirt Handler](https://docs.datadoghq.com/integrations/kubevirt_handler) through the Datadog Agent.

**Minimum Agent version:** 7.59.0

## Setup{% #setup %}

Follow the instructions below to install and configure this check for an Agent running on a host. For containerized environments, see the [Autodiscovery Integration Templates](https://docs.datadoghq.com/agent/kubernetes/integrations/) for guidance on applying these instructions.

### Installation{% #installation %}

The KubeVirt Handler check is included in the [Datadog Agent](https://app.datadoghq.com/account/settings/agent/latest) package. No additional installation is needed on your server.

### Configuration{% #configuration %}

1. Edit the `kubevirt_handler.d/conf.yaml` file, in the `conf.d/` folder at the root of your Agent's configuration directory to start collecting your kubevirt_handler performance data. See the [sample kubevirt_handler.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/kubevirt_handler/datadog_checks/kubevirt_handler/data/conf.yaml.example) for all available configuration options.

1. [Restart the Agent](https://docs.datadoghq.com/agent/guide/agent-commands/#start-stop-and-restart-the-agent).

### Validation{% #validation %}

[Run the Agent's status subcommand](https://docs.datadoghq.com/agent/guide/agent-commands/#agent-status-and-information) and look for `kubevirt_handler` under the Checks section.

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

### Metrics{% #metrics %}

|  |
|  |
| **kubevirt\_handler.can\_connect**(gauge)                                   | Value of 1 if the agent can connect to the KubeVirt Handler, and 0 otherwise.                                                                                                                                                                    |
| **kubevirt\_handler.vmi.cpu\_system\_usage\_seconds.count**(count)          | Total CPU time spent in system mode.*Shown as second*                                                                                                                                                                                            |
| **kubevirt\_handler.vmi.cpu\_usage\_seconds.count**(count)                  | Total CPU time spent in all modes (sum of both vcpu and hypervisor usage).*Shown as second*                                                                                                                                                      |
| **kubevirt\_handler.vmi.cpu\_user\_usage\_seconds.count**(count)            | Total CPU time spent in user mode.*Shown as second*                                                                                                                                                                                              |
| **kubevirt\_handler.vmi.memory\_actual\_balloon\_bytes**(gauge)             | Current balloon size in bytes.*Shown as byte*                                                                                                                                                                                                    |
| **kubevirt\_handler.vmi.memory\_available\_bytes**(gauge)                   | Amount of usable memory as seen by the domain.*Shown as byte*                                                                                                                                                                                    |
| **kubevirt\_handler.vmi.memory\_domain\_bytes**(gauge)                      | The amount of memory in bytes allocated to the domain.*Shown as byte*                                                                                                                                                                            |
| **kubevirt\_handler.vmi.memory\_pgmajfault.count**(count)                   | The number of page faults when disk IO was required.*Shown as page*                                                                                                                                                                              |
| **kubevirt\_handler.vmi.memory\_pgminfault.count**(count)                   | The number of other page faults, when disk IO was not required.*Shown as page*                                                                                                                                                                   |
| **kubevirt\_handler.vmi.memory\_resident\_bytes**(gauge)                    | Resident set size of the process running the domain.*Shown as byte*                                                                                                                                                                              |
| **kubevirt\_handler.vmi.memory\_swap\_in\_traffic\_bytes**(gauge)           | The total amount of data read from swap space of the guest in bytes.*Shown as byte*                                                                                                                                                              |
| **kubevirt\_handler.vmi.memory\_swap\_out\_traffic\_bytes**(gauge)          | The total amount of memory written out to swap space of the guest in bytes.*Shown as byte*                                                                                                                                                       |
| **kubevirt\_handler.vmi.memory\_unused\_bytes**(gauge)                      | The amount of memory left completely unused by the system.*Shown as byte*                                                                                                                                                                        |
| **kubevirt\_handler.vmi.memory\_usable\_bytes**(gauge)                      | The amount of memory which can be reclaimed by balloon without pushing the guest system to swap, corresponds to 'Available' in /proc/meminfo*Shown as byte*                                                                                      |
| **kubevirt\_handler.vmi.network\_receive\_bytes.count**(count)              | Total network traffic received in bytes.*Shown as byte*                                                                                                                                                                                          |
| **kubevirt\_handler.vmi.network\_receive\_errors.count**(count)             | Total network received error packets.*Shown as packet*                                                                                                                                                                                           |
| **kubevirt\_handler.vmi.network\_receive\_packets.count**(count)            | Total network traffic received packets.*Shown as packet*                                                                                                                                                                                         |
| **kubevirt\_handler.vmi.network\_receive\_packets\_dropped.count**(count)   | The total number of rx packets dropped on vNIC interfaces.*Shown as packet*                                                                                                                                                                      |
| **kubevirt\_handler.vmi.network\_transmit\_bytes.count**(count)             | Total network traffic transmitted in bytes.*Shown as byte*                                                                                                                                                                                       |
| **kubevirt\_handler.vmi.network\_transmit\_errors.count**(count)            | Total network transmitted error packets.*Shown as packet*                                                                                                                                                                                        |
| **kubevirt\_handler.vmi.network\_transmit\_packets.count**(count)           | Total network traffic transmitted packets.*Shown as packet*                                                                                                                                                                                      |
| **kubevirt\_handler.vmi.network\_transmit\_packets\_dropped.count**(count)  | The total number of tx packets dropped on vNIC interfaces.*Shown as packet*                                                                                                                                                                      |
| **kubevirt\_handler.vmi.node\_cpu\_affinity**(gauge)                        | Number of VMI CPU affinities to node physical cores.                                                                                                                                                                                             |
| **kubevirt\_handler.vmi.storage\_flush\_requests.count**(count)             | Total storage flush requests.*Shown as request*                                                                                                                                                                                                  |
| **kubevirt\_handler.vmi.storage\_flush\_times\_seconds.count**(count)       | Total time spent on cache flushing.*Shown as second*                                                                                                                                                                                             |
| **kubevirt\_handler.vmi.storage\_iops\_read.count**(count)                  | Total number of I/O read operations.*Shown as read*                                                                                                                                                                                              |
| **kubevirt\_handler.vmi.storage\_iops\_write.count**(count)                 | Total number of I/O write operations.*Shown as write*                                                                                                                                                                                            |
| **kubevirt\_handler.vmi.storage\_read\_times\_seconds.count**(count)        | Total time spent on read operations.*Shown as second*                                                                                                                                                                                            |
| **kubevirt\_handler.vmi.storage\_read\_traffic\_bytes.count**(count)        | Total number of bytes read from storage.*Shown as byte*                                                                                                                                                                                          |
| **kubevirt\_handler.vmi.storage\_write\_times\_seconds.count**(count)       | Total time spent on write operations.*Shown as second*                                                                                                                                                                                           |
| **kubevirt\_handler.vmi.storage\_write\_traffic\_bytes.count**(count)       | Total number of written bytes.*Shown as byte*                                                                                                                                                                                                    |
| **kubevirt\_handler.vmi.vcpu\_delay\_seconds.count**(count)                 | Amount of time spent by each vcpu waiting in the queue instead of running.*Shown as second*                                                                                                                                                      |
| **kubevirt\_handler.vmi.vcpu\_seconds.count**(count)                        | Total amount of time spent in each state by each vcpu (cpu_time excluding hypervisor time). Where `id` is the vcpu identifier and `state` can be one of the following: [`OFFLINE`, `RUNNING`, `BLOCKED`].*Shown as second*                       |
| **kubevirt\_handler.vmi.vcpu\_wait\_seconds.count**(count)                  | Amount of time spent by each vcpu while waiting on I/O.*Shown as second*                                                                                                                                                                         |
| **kubevirt\_handler.workqueue.adds.count**(count)                           | Total number of adds handled by workqueue*Shown as item*                                                                                                                                                                                         |
| **kubevirt\_handler.workqueue.depth**(gauge)                                | Current depth of workqueue*Shown as item*                                                                                                                                                                                                        |
| **kubevirt\_handler.workqueue.longest\_running\_processor\_seconds**(gauge) | How many seconds has the longest running processor for workqueue been running.*Shown as second*                                                                                                                                                  |
| **kubevirt\_handler.workqueue.queue\_duration\_seconds.bucket**(count)      | How long an item stays in workqueue before being requested.*Shown as second*                                                                                                                                                                     |
| **kubevirt\_handler.workqueue.queue\_duration\_seconds.count**(count)       | How long an item stays in workqueue before being requested.*Shown as second*                                                                                                                                                                     |
| **kubevirt\_handler.workqueue.queue\_duration\_seconds.sum**(count)         | How long an item stays in workqueue before being requested.*Shown as second*                                                                                                                                                                     |
| **kubevirt\_handler.workqueue.retries.count**(count)                        | Total number of retries handled by workqueue                                                                                                                                                                                                     |
| **kubevirt\_handler.workqueue.unfinished\_work\_seconds**(gauge)            | How many seconds of work has done that is in progress and hasn't been observed by work_duration. Large values indicate stuck threads. One can deduce the number of stuck threads by observing the rate at which this increases.*Shown as second* |
| **kubevirt\_handler.workqueue.work\_duration\_seconds.bucket**(count)       | How long in seconds processing an item from workqueue takes.*Shown as second*                                                                                                                                                                    |
| **kubevirt\_handler.workqueue.work\_duration\_seconds.count**(count)        | How long in seconds processing an item from workqueue takes.*Shown as second*                                                                                                                                                                    |
| **kubevirt\_handler.workqueue.work\_duration\_seconds.sum**(count)          | How long in seconds processing an item from workqueue takes.*Shown as second*                                                                                                                                                                    |

### Events{% #events %}

The KubeVirt Handler integration does not include any events.

### Service Checks{% #service-checks %}

The KubeVirt Handler integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

Need help? Contact [Datadog support](https://docs.datadoghq.com/help/).