---
title: Docker Data Collected
description: >-
  Reference guide for metrics and events collected by the Datadog Agent from
  Docker containers
breadcrumbs: >-
  Docs > Containers > Docker Agent for Docker, containerd, and Podman > Docker
  Data Collected
---

# Docker Data Collected

## Docker integration{% #docker-integration %}

### Metrics{% #metrics %}

Metrics collected by the Agent when deployed in a Docker container:

|  |
|  |
| **docker.container.open\_fds**(gauge)                 | The number of open file descriptors*Shown as file*                                                                                                                    |
| **docker.container.size\_rootfs**(gauge)              | Total size of all the files in the container*Shown as byte*                                                                                                           |
| **docker.container.size\_rootfs.95percentile**(gauge) | 95th percentile of docker.container.size_rootfs*Shown as byte*                                                                                                        |
| **docker.container.size\_rootfs.avg**(gauge)          | Average value of docker.container.size_rootfs*Shown as byte*                                                                                                          |
| **docker.container.size\_rootfs.count**(rate)         | The rate that the value of docker.container.size_rw was sampled*Shown as sample*                                                                                      |
| **docker.container.size\_rootfs.max**(gauge)          | Max value of docker.container.size_rootfs*Shown as byte*                                                                                                              |
| **docker.container.size\_rootfs.median**(gauge)       | Median value of docker.container.size_rootfs*Shown as byte*                                                                                                           |
| **docker.container.size\_rw**(gauge)                  | Total size of all the files in the container which have been created or changed by processes running in the container*Shown as byte*                                  |
| **docker.container.size\_rw.95percentile**(gauge)     | 95th percentile of docker.container.size_rw*Shown as byte*                                                                                                            |
| **docker.container.size\_rw.avg**(gauge)              | Average value of docker.container.size_rw*Shown as byte*                                                                                                              |
| **docker.container.size\_rw.count**(rate)             | The rate that the value of docker.container.size_rw was sampled*Shown as sample*                                                                                      |
| **docker.container.size\_rw.max**(gauge)              | Max value of docker.container.size_rw*Shown as byte*                                                                                                                  |
| **docker.container.size\_rw.median**(gauge)           | Median value of docker.container.size_rw*Shown as byte*                                                                                                               |
| **docker.containers.running**(gauge)                  | The number of containers running on this host tagged by image                                                                                                         |
| **docker.containers.running.total**(gauge)            | The total number of containers running on this host                                                                                                                   |
| **docker.containers.stopped**(gauge)                  | The number of containers stopped on this host tagged by image                                                                                                         |
| **docker.containers.stopped.total**(gauge)            | The total number of containers stopped on this host                                                                                                                   |
| **docker.cpu.limit**(gauge)                           | Limit on CPU available to the container, expressed as percentage of a core*Shown as percent*                                                                          |
| **docker.cpu.shares**(gauge)                          | Shares of CPU usage allocated to the container                                                                                                                        |
| **docker.cpu.system**(gauge)                          | The percent of time the CPU is executing system calls on behalf of processes of this container, unnormalized*Shown as percent*                                        |
| **docker.cpu.system.95percentile**(gauge)             | 95th percentile of docker.cpu.system [deprecated in agent 6.0]*Shown as percent*                                                                                      |
| **docker.cpu.system.avg**(gauge)                      | Average value of docker.cpu.system [deprecated in agent 6.0]*Shown as percent*                                                                                        |
| **docker.cpu.system.count**(rate)                     | The rate that the value of docker.cpu.system was sampled [deprecated in agent 6.0]*Shown as sample*                                                                   |
| **docker.cpu.system.max**(gauge)                      | Max value of docker.cpu.system*Shown as percent*                                                                                                                      |
| **docker.cpu.system.median**(gauge)                   | Median value of docker.cpu.system [deprecated in agent 6.0]*Shown as percent*                                                                                         |
| **docker.cpu.throttled**(gauge)                       | Number of times the cgroup has been throttled                                                                                                                         |
| **docker.cpu.usage**(gauge)                           | The percent of CPU time obtained by this container*Shown as percent*                                                                                                  |
| **docker.cpu.user**(gauge)                            | The percent of time the CPU is under direct control of processes of this container, unnormalized*Shown as percent*                                                    |
| **docker.cpu.user.95percentile**(gauge)               | 95th percentile of docker.cpu.user [deprecated in agent 6.0]*Shown as percent*                                                                                        |
| **docker.cpu.user.avg**(gauge)                        | Average value of docker.cpu.user [deprecated in agent 6.0]*Shown as percent*                                                                                          |
| **docker.cpu.user.count**(rate)                       | The rate that the value of docker.cpu.user was sampled [deprecated in agent 6.0]*Shown as sample*                                                                     |
| **docker.cpu.user.max**(gauge)                        | Max value of docker.cpu.user [deprecated in agent 6.0]*Shown as percent*                                                                                              |
| **docker.cpu.user.median**(gauge)                     | Median value of docker.cpu.user [deprecated in agent 6.0]*Shown as percent*                                                                                           |
| **docker.data.free**(gauge)                           | Storage pool disk space free*Shown as byte*                                                                                                                           |
| **docker.data.percent**(gauge)                        | The percent of storage pool used*Shown as percent*                                                                                                                    |
| **docker.data.total**(gauge)                          | Storage pool disk space total*Shown as byte*                                                                                                                          |
| **docker.data.used**(gauge)                           | Storage pool disk space used*Shown as byte*                                                                                                                           |
| **docker.image.size**(gauge)                          | Size of all layers of the image on disk*Shown as byte*                                                                                                                |
| **docker.image.virtual\_size**(gauge)                 | Size of all layers of the image on disk*Shown as byte*                                                                                                                |
| **docker.images.available**(gauge)                    | The number of top-level images                                                                                                                                        |
| **docker.images.intermediate**(gauge)                 | The number of intermediate images, which are intermediate layers that make up other images                                                                            |
| **docker.io.read\_bytes**(gauge)                      | Bytes read per second from disk by the processes of the container*Shown as byte*                                                                                      |
| **docker.io.read\_bytes.95percentile**(gauge)         | 95th percentile of docker.io.read_bytes [deprecated in agent 6.0]*Shown as byte*                                                                                      |
| **docker.io.read\_bytes.avg**(gauge)                  | Average value of docker.io.read_bytes [deprecated in agent 6.0]*Shown as byte*                                                                                        |
| **docker.io.read\_bytes.count**(rate)                 | The rate that the value of docker.io.read_bytes was sampled [deprecated in agent 6.0]*Shown as sample*                                                                |
| **docker.io.read\_bytes.max**(gauge)                  | Max value of docker.container.io.read_bytes [deprecated in agent 6.0]*Shown as byte*                                                                                  |
| **docker.io.read\_bytes.median**(gauge)               | Median value of docker.container.io.read_bytes [deprecated in agent 6.0]*Shown as byte*                                                                               |
| **docker.io.write\_bytes**(gauge)                     | Bytes written per second to disk by the processes of the container*Shown as byte*                                                                                     |
| **docker.io.write\_bytes.95percentile**(gauge)        | 95th percentile of docker.io.write_bytes [deprecated in agent 6.0]*Shown as byte*                                                                                     |
| **docker.io.write\_bytes.avg**(gauge)                 | Average value of docker.io.write_bytes [deprecated in agent 6.0]*Shown as byte*                                                                                       |
| **docker.io.write\_bytes.count**(rate)                | The rate that the value of docker.io.write_bytes was sampled [deprecated in agent 6.0]*Shown as sample*                                                               |
| **docker.io.write\_bytes.max**(gauge)                 | Max value of docker.container.io.write_bytes [deprecated in agent 6.0]*Shown as byte*                                                                                 |
| **docker.io.write\_bytes.median**(gauge)              | Median value of docker.container.io.write_bytes [deprecated in agent 6.0]*Shown as byte*                                                                              |
| **docker.kmem.usage**(gauge)                          | The amount of kernel memory that belongs to the container's processes.*Shown as byte*                                                                                 |
| **docker.mem.cache**(gauge)                           | The amount of memory that is being used to cache data from disk (e.g. memory contents that can be associated precisely with a block on a block device)*Shown as byte* |
| **docker.mem.cache.95percentile**(gauge)              | 95th percentile value of docker.mem.cache [deprecated in agent 6.0]*Shown as byte*                                                                                    |
| **docker.mem.cache.avg**(gauge)                       | Average value of docker.mem.cache [deprecated in agent 6.0]*Shown as byte*                                                                                            |
| **docker.mem.cache.count**(rate)                      | The rate that the value of docker.mem.cache was sampled [deprecated in agent 6.0]*Shown as sample*                                                                    |
| **docker.mem.cache.max**(gauge)                       | Max value of docker.mem.cache [deprecated in agent 6.0]*Shown as byte*                                                                                                |
| **docker.mem.cache.median**(gauge)                    | Median value of docker.mem.cache [deprecated in agent 6.0]*Shown as byte*                                                                                             |
| **docker.mem.in\_use**(gauge)                         | The fraction of used memory to available memory, IF THE LIMIT IS SET*Shown as fraction*                                                                               |
| **docker.mem.in\_use.95percentile**(gauge)            | 95th percentile of docker.mem.in_use [deprecated in agent 6.0]*Shown as fraction*                                                                                     |
| **docker.mem.in\_use.avg**(gauge)                     | Average value of docker.mem.in_use [deprecated in agent 6.0]*Shown as fraction*                                                                                       |
| **docker.mem.in\_use.count**(rate)                    | The rate that the value of docker.mem.in_use was sampled [deprecated in agent 6.0]*Shown as sample*                                                                   |
| **docker.mem.in\_use.max**(gauge)                     | Max value of docker.container.mem.in_use [deprecated in agent 6.0]*Shown as fraction*                                                                                 |
| **docker.mem.in\_use.median**(gauge)                  | Median value of docker.container.mem.in_use [deprecated in agent 6.0]*Shown as fraction*                                                                              |
| **docker.mem.limit**(gauge)                           | The memory limit for the container, if set*Shown as byte*                                                                                                             |
| **docker.mem.limit.95percentile**(gauge)              | 95th percentile of docker.mem.limit. Ordinarily this value will not change [deprecated in agent 6.0]*Shown as byte*                                                   |
| **docker.mem.limit.avg**(gauge)                       | Average value of docker.mem.limit. Ordinarily this value will not change [deprecated in agent 6.0]*Shown as byte*                                                     |
| **docker.mem.limit.count**(rate)                      | The rate that the value of docker.mem.limit was sampled [deprecated in agent 6.0]*Shown as sample*                                                                    |
| **docker.mem.limit.max**(gauge)                       | Max value of docker.mem.limit. Ordinarily this value will not change [deprecated in agent 6.0]*Shown as byte*                                                         |
| **docker.mem.limit.median**(gauge)                    | Median value of docker.mem.limit. Ordinarily this value will not change [deprecated in agent 6.0]*Shown as byte*                                                      |
| **docker.mem.rss**(gauge)                             | The amount of non-cache memory that belongs to the container's processes. Used for stacks, heaps, etc.*Shown as byte*                                                 |
| **docker.mem.rss.95percentile**(gauge)                | 95th percentile value of docker.mem.rss [deprecated in agent 6.0]*Shown as byte*                                                                                      |
| **docker.mem.rss.avg**(gauge)                         | Average value of docker.mem.rss [deprecated in agent 6.0]*Shown as byte*                                                                                              |
| **docker.mem.rss.count**(rate)                        | The rate that the value of docker.mem.rss was sampled [deprecated in agent 6.0]*Shown as sample*                                                                      |
| **docker.mem.rss.max**(gauge)                         | Max value of docker.mem.rss [deprecated in agent 6.0]*Shown as byte*                                                                                                  |
| **docker.mem.rss.median**(gauge)                      | Median value of docker.mem.rss [deprecated in agent 6.0]*Shown as byte*                                                                                               |
| **docker.mem.soft\_limit**(gauge)                     | The memory reservation limit for the container, if set*Shown as byte*                                                                                                 |
| **docker.mem.soft\_limit.95percentile**(gauge)        | 95th percentile of docker.mem.soft_limit. Ordinarily this value will not change*Shown as byte*                                                                        |
| **docker.mem.soft\_limit.avg**(gauge)                 | Average value of docker.mem.soft_limit. Ordinarily this value will not change*Shown as byte*                                                                          |
| **docker.mem.soft\_limit.count**(rate)                | The rate that the value of docker.mem.soft_limit was sampled*Shown as sample*                                                                                         |
| **docker.mem.soft\_limit.max**(gauge)                 | Max value of docker.mem.soft_limit. Ordinarily this value will not change*Shown as byte*                                                                              |
| **docker.mem.soft\_limit.median**(gauge)              | Median value of docker.mem.soft_limit. Ordinarily this value will not change*Shown as byte*                                                                           |
| **docker.mem.sw\_in\_use**(gauge)                     | The fraction of used swap + memory to available swap + memory, if the limit is set*Shown as fraction*                                                                 |
| **docker.mem.sw\_in\_use.95percentile**(gauge)        | 95th percentile of docker.mem.sw_in_use [deprecated in agent 6.0]*Shown as fraction*                                                                                  |
| **docker.mem.sw\_in\_use.avg**(gauge)                 | Average value of docker.mem.sw_in_use [deprecated in agent 6.0]*Shown as fraction*                                                                                    |
| **docker.mem.sw\_in\_use.count**(rate)                | The rate that the value of docker.mem.sw_in_use was sampled [deprecated in agent 6.0]*Shown as sample*                                                                |
| **docker.mem.sw\_in\_use.max**(gauge)                 | Max value of docker.container.mem.sw_in_use [deprecated in agent 6.0]*Shown as fraction*                                                                              |
| **docker.mem.sw\_in\_use.median**(gauge)              | Median value of docker.container.mem.sw_in_use [deprecated in agent 6.0]*Shown as fraction*                                                                           |
| **docker.mem.sw\_limit**(gauge)                       | The swap + memory limit for the container, if set*Shown as byte*                                                                                                      |
| **docker.mem.sw\_limit.95percentile**(gauge)          | 95th percentile of docker.mem.sw_limit. Ordinarily this value will not change [deprecated in agent 6.0]*Shown as byte*                                                |
| **docker.mem.sw\_limit.avg**(gauge)                   | Average value of docker.mem.sw_limit. Ordinarily this value will not change [deprecated in agent 6.0]*Shown as byte*                                                  |
| **docker.mem.sw\_limit.count**(rate)                  | The rate that the value of docker.mem.sw_limit was sampled [deprecated in agent 6.0]*Shown as sample*                                                                 |
| **docker.mem.sw\_limit.max**(gauge)                   | Max value of docker.mem.sw_limit. Ordinarily this value will not change [deprecated in agent 6.0]*Shown as byte*                                                      |
| **docker.mem.sw\_limit.median**(gauge)                | Median value of docker.mem.sw_limit. Ordinarily this value will not change [deprecated in agent 6.0]*Shown as byte*                                                   |
| **docker.mem.swap**(gauge)                            | The amount of swap currently used by the container*Shown as byte*                                                                                                     |
| **docker.mem.swap.95percentile**(gauge)               | 95th percentile value of docker.mem.swap [deprecated in agent 6.0]*Shown as byte*                                                                                     |
| **docker.mem.swap.avg**(gauge)                        | Average value of docker.mem.swap [deprecated in agent 6.0]*Shown as byte*                                                                                             |
| **docker.mem.swap.count**(rate)                       | The rate that the value of docker.mem.swap was sampled [deprecated in agent 6.0]*Shown as sample*                                                                     |
| **docker.mem.swap.max**(gauge)                        | Max value of docker.mem.swap [deprecated in agent 6.0]*Shown as byte*                                                                                                 |
| **docker.mem.swap.median**(gauge)                     | Median value of docker.mem.swap [deprecated in agent 6.0]*Shown as byte*                                                                                              |
| **docker.metadata.free**(gauge)                       | Storage pool metadata space free*Shown as byte*                                                                                                                       |
| **docker.metadata.percent**(gauge)                    | The percent of storage pool metadata used*Shown as percent*                                                                                                           |
| **docker.metadata.total**(gauge)                      | Storage pool metadata space total*Shown as byte*                                                                                                                      |
| **docker.metadata.used**(gauge)                       | Storage pool metadata space used*Shown as byte*                                                                                                                       |
| **docker.net.bytes\_rcvd**(gauge)                     | Bytes received per second from the network*Shown as byte*                                                                                                             |
| **docker.net.bytes\_rcvd.95percentile**(gauge)        | 95th percentile of docker.net.bytes_rcvd [deprecated in agent 6.0]*Shown as byte*                                                                                     |
| **docker.net.bytes\_rcvd.avg**(gauge)                 | Average value of docker.net.bytes_rcvd [deprecated in agent 6.0]*Shown as byte*                                                                                       |
| **docker.net.bytes\_rcvd.count**(rate)                | The rate that the value of docker.net.bytes_rcvd was sampled [deprecated in agent 6.0]*Shown as sample*                                                               |
| **docker.net.bytes\_rcvd.max**(gauge)                 | Max value of docker.container.net.bytes_rcvd [deprecated in agent 6.0]*Shown as byte*                                                                                 |
| **docker.net.bytes\_rcvd.median**(gauge)              | Median value of docker.container.net.bytes_rcvd [deprecated in agent 6.0]*Shown as byte*                                                                              |
| **docker.net.bytes\_sent**(gauge)                     | Bytes sent per second to the network*Shown as byte*                                                                                                                   |
| **docker.net.bytes\_sent\_bytes.95percentile**(gauge) | 95th percentile of docker.net.bytes_sent_bytes [deprecated in agent 6.0]*Shown as byte*                                                                               |
| **docker.net.bytes\_sent\_bytes.avg**(gauge)          | Average value of docker.net.bytes_sent_bytes [deprecated in agent 6.0]*Shown as byte*                                                                                 |
| **docker.net.bytes\_sent\_bytes.count**(rate)         | The rate that the value of docker.net.bytes_sent_bytes was sampled [deprecated in agent 6.0]*Shown as sample*                                                         |
| **docker.net.bytes\_sent\_bytes.max**(gauge)          | Max value of docker.container.net.bytes_sent_bytes [deprecated in agent 6.0]*Shown as byte*                                                                           |
| **docker.net.bytes\_sent\_bytes.median**(gauge)       | Median value of docker.container.net.bytes_sent_bytes [deprecated in agent 6.0]*Shown as byte*                                                                        |
| **docker.thread.count**(gauge)                        | Current thread count for the container*Shown as thread*                                                                                                               |
| **docker.thread.limit**(gauge)                        | Thread count limit for the container, if set*Shown as thread*                                                                                                         |
| **docker.uptime**(gauge)                              | Time since the container was started*Shown as second*                                                                                                                 |

### Events{% #events %}

The Docker Agent produces the following events:

- Delete Image
- Die
- Error
- Fail
- Kill
- Out of memory (oom)
- Pause
- Restart container
- Restart Daemon
- Update

To collect additional Docker events, reach out to [Datadog support](https://www.datadoghq.com/support/).

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

**docker.service\_up**

Returns `CRITICAL` if the Agent is unable to collect the list of containers from the Docker daemon. Returns `OK` otherwise.

*Statuses: ok, critical*

**docker.container\_health**

Returns `CRITICAL` if a container is unhealthy. Returns `OK` otherwise or `UNKNOWN` if the health is unknown. **Note**: Only available for Agent v6 and below.

*Statuses: ok, critical, unknown*

**docker.exit**

Returns `CRITICAL` if a container exited with a non-zero exit code. Returns `OK` otherwise.

*Statuses: ok, critical*

**Note**: To use `docker.exit`, add `collect_exit_codes: true` in your [Docker YAML file](https://github.com/DataDog/integrations-core/blob/7.39.0/docker_daemon/datadog_checks/docker_daemon/data/conf.yaml.example#L151-L154) and restart the Agent.

**Note**: To use `docker.exit`, add `collect_exit_codes: true` in your Docker `conf.yaml` file and restart the Agent.

## Container integration{% #container-integration %}

### Metrics{% #metrics-1 %}

|  |
|  |
| **container.cpu.limit**(gauge)                  | The maximum CPU time available to the container*Shown as nanocore*                                                                               |
| **container.cpu.system**(gauge)                 | The container system CPU usage*Shown as nanocore*                                                                                                |
| **container.cpu.throttled**(gauge)              | The total cpu throttled time*Shown as nanosecond*                                                                                                |
| **container.cpu.throttled.periods**(gauge)      | The number of periods during which the container was throttled                                                                                   |
| **container.cpu.usage**(gauge)                  | The container total CPU Usage*Shown as nanocore*                                                                                                 |
| **container.cpu.user**(gauge)                   | The container userspace CPU usage*Shown as nanocore*                                                                                             |
| **container.io.read**(gauge)                    | The number of bytes read from disks by this container*Shown as byte*                                                                             |
| **container.io.read.operations**(gauge)         | The number of read operations done by this container                                                                                             |
| **container.io.write**(gauge)                   | The number of bytes written to disks by this container*Shown as byte*                                                                            |
| **container.io.write.operations**(gauge)        | The number of write operations done by this container                                                                                            |
| **container.memory.active\_anon**(gauge)        | The container active anonymous memory (requires extended_memory_metrics flag in the check config)*Shown as byte*                                 |
| **container.memory.active\_file**(gauge)        | The container active file-backed memory (requires extended_memory_metrics flag in the check config)*Shown as byte*                               |
| **container.memory.cache**(gauge)               | The container cache usage*Shown as byte*                                                                                                         |
| **container.memory.commit**(gauge)              | The container commit memory usage*Shown as byte*                                                                                                 |
| **container.memory.commit.peak**(gauge)         | The container peak commit memory usage*Shown as byte*                                                                                            |
| **container.memory.file\_dirty**(gauge)         | The container memory that are waiting to get written back to the disk (requires extended_memory_metrics flag in the check config)*Shown as byte* |
| **container.memory.file\_mapped**(gauge)        | The container mapped file memory (requires extended_memory_metrics flag in the check config)*Shown as byte*                                      |
| **container.memory.file\_writeback**(gauge)     | The container memory that is queued for syncing to disk (requires extended_memory_metrics flag in the check config)*Shown as byte*               |
| **container.memory.inactive\_anon**(gauge)      | The container inactive anonymous memory (requires extended_memory_metrics flag in the check config)*Shown as byte*                               |
| **container.memory.inactive\_file**(gauge)      | The container inactive file-backed memory (requires extended_memory_metrics flag in the check config)*Shown as byte*                             |
| **container.memory.kernel**(gauge)              | The container kernel memory usage*Shown as byte*                                                                                                 |
| **container.memory.limit**(gauge)               | The container memory limit*Shown as byte*                                                                                                        |
| **container.memory.major\_page\_faults**(count) | Number of major page faults incurred                                                                                                             |
| **container.memory.oom\_events**(gauge)         | The number of OOM events triggered by the container                                                                                              |
| **container.memory.page\_faults**(count)        | Total number of page faults incurred                                                                                                             |
| **container.memory.page\_tables**(gauge)        | The container memory allocated for page tables (requires extended_memory_metrics flag in the check config)*Shown as byte*                        |
| **container.memory.refault\_anon**(count)       | The number of refaults of previously evicted anonymous pages (requires extended_memory_metrics flag in the check config)*Shown as byte*          |
| **container.memory.refault\_file**(count)       | The number of refaults of previously evicted file pages (requires extended_memory_metrics flag in the check config)*Shown as byte*               |
| **container.memory.rss**(gauge)                 | The container RSS usage*Shown as byte*                                                                                                           |
| **container.memory.shmem**(gauge)               | The container swap-backed memory such as tmpfs (requires extended_memory_metrics flag in the check config), shm segments…*Shown as byte*         |
| **container.memory.soft\_limit**(gauge)         | The container memory soft limit*Shown as byte*                                                                                                   |
| **container.memory.swap**(gauge)                | The container swap usage*Shown as byte*                                                                                                          |
| **container.memory.unevictable**(gauge)         | The container memory that can't be reclaimed (requires extended_memory_metrics flag in the check config)*Shown as byte*                          |
| **container.memory.usage**(gauge)               | The container total memory usage*Shown as byte*                                                                                                  |
| **container.memory.usage.peak**(gauge)          | The maximum memory usage recorded since the container started*Shown as byte*                                                                     |
| **container.memory.working\_set**(gauge)        | The container working set usage*Shown as byte*                                                                                                   |
| **container.net.rcvd**(gauge)                   | The number of network bytes received (per interface)*Shown as byte*                                                                              |
| **container.net.rcvd.packets**(gauge)           | The number of network packets received (per interface)                                                                                           |
| **container.net.sent**(gauge)                   | The number of network bytes sent (per interface)*Shown as byte*                                                                                  |
| **container.net.sent.packets**(gauge)           | The number of network packets sent (per interface)                                                                                               |
| **container.pid.open\_files**(gauge)            | The number of open file descriptors (Linux only)                                                                                                 |
| **container.pid.thread\_count**(gauge)          | The number of threads running inside this container                                                                                              |
| **container.pid.thread\_limit**(gauge)          | The maximum number of threads for this container                                                                                                 |
| **container.restarts**(gauge)                   | The number of container restarted                                                                                                                |
| **container.uptime**(gauge)                     | The container uptime*Shown as second*                                                                                                            |

If you need extended container memory metrics `extended_memory_metrics` has to be set to `true`. It will enable following metrics: active_anon, inactive_anon, active_file, inactive_file, unevictable, shmem, file_mapped, file_dirty, file_writeback, page_tables, refault_anon, refault_file

## Containerd integration{% #containerd-integration %}

### Metrics{% #metrics-2 %}

Containerd collects metrics about the resource usage of your containers.

CPU, memory, block I/O, or huge page table metrics are collected out of the box. Additionally, you can also collect some disk metrics.

|  |
|  |
| **containerd.cpu.system**(gauge)              | The total CPU time*Shown as nanosecond*                        |
| **containerd.cpu.throttled.periods**(gauge)   | The total CPU throttled time (Linux only)*Shown as nanosecond* |
| **containerd.cpu.total**(gauge)               | The total CPU time*Shown as nanosecond*                        |
| **containerd.cpu.user**(gauge)                | The total user CPU time*Shown as nanosecond*                   |
| **containerd.image.pull**(count)              | The number of image pull requests*Shown as byte*               |
| **containerd.image.size**(gauge)              | The size of the container image*Shown as byte*                 |
| **containerd.mem.cache**(gauge)               | The cache amount used (Linux only)*Shown as byte*              |
| **containerd.mem.commit**(gauge)              | The committed memory (Windows only)*Shown as byte*             |
| **containerd.mem.commit\_peak**(gauge)        | The peak committed memory (Windows only)*Shown as byte*        |
| **containerd.mem.current.failcnt**(gauge)     | The usage failcnt (Linux only)                                 |
| **containerd.mem.current.limit**(gauge)       | The memory limit (Linux only)*Shown as byte*                   |
| **containerd.mem.current.usage**(gauge)       | The memory usage (Linux only)*Shown as byte*                   |
| **containerd.mem.kernel.usage**(gauge)        | The kernel usage (Linux only)*Shown as byte*                   |
| **containerd.mem.kernel\_tcp.failcnt**(gauge) | The kerneltcp failcnt (Linux only)                             |
| **containerd.mem.kernel\_tcp.limit**(gauge)   | The kerneltcp limit (Linux only)*Shown as byte*                |
| **containerd.mem.kernel\_tcp.max**(gauge)     | The kerneltcp maximum usage (Linux only)*Shown as byte*        |
| **containerd.mem.kernel\_tcp.usage**(gauge)   | The kerneltcp usage (Linux only)*Shown as byte*                |
| **containerd.mem.rss**(gauge)                 | The rss amount used (Linux only)*Shown as byte*                |
| **containerd.mem.swap.usage**(gauge)          | The swap usage (Linux only)*Shown as byte*                     |
| **containerd.mem.working\_set**(gauge)        | The container working set usage*Shown as byte*                 |
| **containerd.proc.open\_fds**(gauge)          | The number of open file descriptors*Shown as file*             |
| **containerd.storage.read**(rate)             | Read bytes (Windows only)*Shown as byte*                       |
| **containerd.storage.write**(rate)            | Write bytes (Windows only)*Shown as byte*                      |
| **containerd.uptime**(gauge)                  | Time since the container was started*Shown as second*          |

This integration works on Linux and Windows, but some metrics are OS dependent. Look at `metadata.csv` for the list of OS dependent metrics.

### Events{% #events-1 %}

The containerd check can collect events. Use `filters` to select the relevant events. See the sample [`containerd.d/conf.yaml`](https://github.com/DataDog/datadog-agent/blob/master/cmd/agent/dist/conf.d/containerd.d/conf.yaml.default) for more details.

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

**containerd.health**

Returns `CRITICAL` if the Agent check is unable to connect to the monitored containerd socket. Returns `OK` otherwise.

*Statuses: ok, critical*
