Containers
sysdig_container_count
| |
|---|
| Prometheus ID | sysdig_container_count |
| Legacy ID | container.count |
| Metric Type | gauge |
| Unit | number |
| Description | The count of the number of containers. |
| Additional Notes | This metric is perfect for dashboards and alerts. In particular, you can create alerts that notify you when you have too many (or too few) containers of a certain type in a certain group or node - try segmenting by container.image, .id or .name. See also: host.count. |
sysdig_container_cpu_cgroup_used_percent
| |
|---|
| Prometheus ID | sysdig_container_cpu_cgroup_used_percent |
| Legacy ID | cpu.cgroup.used.percent |
| Metric Type | gauge |
| Unit | percent |
| Description | The percentage of a container’s cgroup limit that is actually used. This is the minimum usage for the underlying cgroup limits: cpuset.limit and quota.limit. |
| Additional Notes | |
sysdig_container_cpu_cores_cgroup_limit
| |
|---|
| Prometheus ID | sysdig_container_cpu_cores_cgroup_limit |
| Legacy ID | cpu.cores.cgroup.limit |
| Metric Type | gauge |
| Unit | number |
| Description | The number of CPU cores assigned to a container. This is the minimum of the cgroup limits: cpuset.limit and quota.limit. |
| Additional Notes | |
sysdig_container_cpu_cores_quota_limit
| |
|---|
| Prometheus ID | sysdig_container_cpu_cores_quota_limit |
| Legacy ID | cpu.cores.quota.limit |
| Metric Type | gauge |
| Unit | number |
| Description | The number of CPU cores assigned to a container. Technically, the container’s cgroup quota and period. This is a way of creating a CPU limit for a container. |
| Additional Notes | |
sysdig_container_cpu_cores_used
| |
|---|
| Prometheus ID | sysdig_container_cpu_cores_used |
| Legacy ID | cpu.cores.used |
| Metric Type | gauge |
| Unit | number |
| Description | The CPU core usage of each container is obtained from cgroups, and is equal to the number of cores used by the container. For example, if a container uses two of an available four cores, the value of sysdig_container_cpu_cores_used will be two. |
| Additional Notes | |
sysdig_container_cpu_cores_used_percent
| |
|---|
| Prometheus ID | sysdig_container_cpu_cores_used_percent |
| Legacy ID | cpu.cores.used.percent |
| Metric Type | gauge |
| Unit | percent |
| Description | The CPU core usage percent for each container is obtained from cgroups, and is equal to the number of cores multiplied by 100. For example, if a container uses three cores, the value of sysdig_container_cpu_cores_used_percent would be 300%. |
| Additional Notes | |
sysdig_container_cpu_quota_used_percent
| |
|---|
| Prometheus ID | sysdig_container_cpu_quota_used_percent |
| Legacy ID | cpu.quota.used.percent |
| Metric Type | gauge |
| Unit | percent |
| Description | The percentage of a container’s CPU Quota that is actually used. CPU Quotas are a common way of creating a CPU limit for a container. CPU Quotas are based on a percentage of time - a container can only spend its quota of time on CPU cycles across a given time period (default period is 100ms). Note that, unlike CPU Shares, CPU Quota is a hard limit to the amount of CPU the container can use - so this metric, CPU Quota %, should not exceed 100%. |
| Additional Notes | |
sysdig_container_cpu_shares_count
| |
|---|
| Prometheus ID | sysdig_container_cpu_shares_count |
| Legacy ID | cpu.shares.count |
| Metric Type | gauge |
| Unit | number |
| Description | The number of CPU shares assigned to a container (technically, the container’s cgroup) - this is a common way of creating a CPU limit for a container. CPU Shares represent a relative weight used by the kernel to distribute CPU cycles across different containers. The default value for a container is 1024. Each container receives its own allocation of CPU cycles, according to the ratio of it’s share count vs to the total number of shares claimed by all containers. For example, if you have three containers, each with 1024 shares, then each will recieve 1/3 of the CPU cycles. Note that this is not a hard limit: a container can consume more than its allocation, if the CPU has cycles that aren’t being consumed by the container they were originally allocated to. |
| Additional Notes | |
sysdig_container_cpu_shares_used_percent
| |
|---|
| Prometheus ID | sysdig_container_cpu_shares_used_percent |
| Legacy ID | cpu.shares.used.percent |
| Metric Type | gauge |
| Unit | percent |
| Description | The percentage of a container’s allocated CPU shares that are actually used. CPU Shares are a common way of creating a CPU limit for a container. CPU Shares represent a relative weight used by the kernel to distribute CPU cycles across different containers. The default value for a container is 1024. Each container receives its own allocation of CPU cycles, according to the ratio of it’s share count vs to the total number of shares claimed by all containers. For example, if you have three containers, each with 1024 shares, then each will recieve 1/3 of the CPU cycles. Note that this is not a hard limit: a container can consume more than its allocation, if the CPU has cycles that aren’t being consumed by the container they were originally allocated to - so this metric, CPU Shares %, can actually exceed 100%. |
| Additional Notes | |
sysdig_container_cpu_used_percent
| |
|---|
| Prometheus ID | sysdig_container_cpu_used_percent |
| Legacy ID | cpu.used.percent |
| Metric Type | gauge |
| Unit | percent |
| Description | The CPU usage for each container is obtained from cgroups, and normalized by dividing by the number of cores to determine an overall percentage. For example, if the environment contains six cores on a host, and the container or processes are assigned two cores, Sysdig will report CPU usage of 2/6 * 100% = 33.33%. This metric is calculated differently for hosts and processes. |
| Additional Notes | |
sysdig_container_fd_used_percent
| |
|---|
| Prometheus ID | sysdig_container_fd_used_percent |
| Legacy ID | fd.used.percent |
| Metric Type | gauge |
| Unit | percent |
| Description | The percentage of used file descriptors out of the maximum available. |
| Additional Notes | Usually, when a process reaches its FD limit it will stop operating properly and possibly crash. As a consequence, this is a metric you want to monitor carefully, or even better use for alerts. |
sysdig_container_file_error_open_count
| |
|---|
| Prometheus ID | sysdig_container_file_error_open_count |
| Legacy ID | file.error.open.count |
| Metric Type | counter |
| Unit | number |
| Description | The number of errors in opening files. |
| Additional Notes | By default, this metric shows the total value for the selected scope. For instance, if you apply it to a group of machines, you will see the total value for the whole group. However, you can easily segment the metric to see it by host, process, container, and so on. Just use ‘Segment by’ in the UI. |
sysdig_container_file_error_total_count
| |
|---|
| Prometheus ID | sysdig_container_file_error_total_count |
| Legacy ID | file.error.total.count |
| Metric Type | counter |
| Unit | number |
| Description | The number of error caused by file access. |
| Additional Notes | By default, this metric shows the total value for the selected scope. For instance, if you apply it to a group of machines, you will see the total value for the whole group. However, you can easily segment the metric to see it by host, process, container, and so on. Just use ‘Segment by’ in the UI. |
sysdig_container_file_in_bytes
| |
|---|
| Prometheus ID | sysdig_container_file_in_bytes |
| Legacy ID | file.bytes.in |
| Metric Type | counter |
| Unit | data |
| Description | The amount of bytes read from file. |
| Additional Notes | By default, this metric shows the total value for the selected scope. For instance, if you apply it to a group of machines, you will see the total value for the whole group. However, you can easily segment the metric to see it by host, process, container, and so on. Just use ‘Segment by’ in the UI. |
sysdig_container_file_in_iops
| |
|---|
| Prometheus ID | sysdig_container_file_in_iops |
| Legacy ID | file.iops.in |
| Metric Type | counter |
| Unit | number |
| Description | The number of file read operations per second. |
| Additional Notes | This is calculated by measuring the actual number of read and write requests made by a process. Therefore, it can differ from what other tools show, which is usually based on interpolating this value from the number of bytes read and written to the file system. |
sysdig_container_file_in_time
| |
|---|
| Prometheus ID | sysdig_container_file_in_time |
| Legacy ID | file.time.in |
| Metric Type | counter |
| Unit | time |
| Description | The time spent in file reading. |
| Additional Notes | By default, this metric shows the total value for the selected scope. For instance, if you apply it to a group of machines, you will see the total value for the whole group. However, you can easily segment the metric to see it by host, process, container, and so on. Just use ‘Segment by’ in the UI. |
sysdig_container_file_open_count
| |
|---|
| Prometheus ID | sysdig_container_file_open_count |
| Legacy ID | file.open.count |
| Metric Type | counter |
| Unit | number |
| Description | The number of time the file has been opened. |
| Additional Notes | |
sysdig_container_file_out_bytes
| |
|---|
| Prometheus ID | sysdig_container_file_out_bytes |
| Legacy ID | file.bytes.out |
| Metric Type | counter |
| Unit | data |
| Description | The number of of bytes written to file. |
| Additional Notes | By default, this metric shows the total value for the selected scope. For instance, if you apply it to a group of machines, you will see the total value for the whole group. However, you can easily segment the metric to see it by host, process, container, and so on. Just use ‘Segment by’ in the UI. |
sysdig_container_file_out_iops
| |
|---|
| Prometheus ID | sysdig_container_file_out_iops |
| Legacy ID | file.iops.out |
| Metric Type | counter |
| Unit | number |
| Description | The Number of file write operations per second. |
| Additional Notes | This is calculated by measuring the actual number of read and write requests made by a process. Therefore, it can differ from what other tools show, which is usually based on interpolating this value from the number of bytes read and written to the file system. |
sysdig_container_file_out_time
| |
|---|
| Prometheus ID | sysdig_container_file_out_time |
| Legacy ID | file.time.out |
| Metric Type | counter |
| Unit | time |
| Description | The time spent in file writing. |
| Additional Notes | By default, this metric shows the total value for the selected scope. For instance, if you apply it to a group of machines, you will see the total value for the whole group. However, you can easily segment the metric to see it by host, process, container, and so on. Just use ‘Segment by’ in the UI. |
sysdig_container_file_total_bytes
| |
|---|
| Prometheus ID | sysdig_container_file_total_bytes |
| Legacy ID | file.bytes.total |
| Metric Type | counter |
| Unit | data |
| Description | The number of bytes read from and written to file. |
| Additional Notes | By default, this metric shows the total value for the selected scope. For instance, if you apply it to a group of machines, you will see the total value for the whole group. However, you can easily segment the metric to see it by host, process, container, and so on. Just use ‘Segment by’ in the UI. |
sysdig_container_file_total_iops
| |
|---|
| Prometheus ID | sysdig_container_file_total_iops |
| Legacy ID | file.iops.total |
| Metric Type | counter |
| Unit | number |
| Description | The number of read and write file operations per second. |
| Additional Notes | This is calculated by measuring the actual number of read and write requests made by a process. Therefore, it can differ from what other tools show, which is usually based on interpolating this value from the number of bytes read and written to the file system. |
sysdig_container_file_total_time
| |
|---|
| Prometheus ID | sysdig_container_file_total_time |
| Legacy ID | file.time.total |
| Metric Type | counter |
| Unit | time |
| Description | The time spent in file I/O. |
| Additional Notes | By default, this metric shows the total value for the selected scope. For instance, if you apply it to a group of machines, you will see the total value for the whole group. However, you can easily segment the metric to see it by host, process, container, and so on. Just use ‘Segment by’ in the UI. |
sysdig_container_fs_free_bytes
| |
|---|
| Prometheus ID | sysdig_container_fs_free_bytes |
| Legacy ID | fs.bytes.free |
| Metric Type | gauge |
| Unit | data |
| Description | The available space in the filesystem. |
| Additional Notes | Container Filesystem metrics report data on filesystems mounted to containers. These are the most useful metrics for stateful containers which have dedicated file storage mounted. Use these metrics with appropriate scoping. Care should be taken when aggregating filesystem metrics to ensure that there is no “double counting” of filesystems that are mounted to multiple containers. Additionally, the metrics from overlay type file systems are generally not reported, so these metrics typically will not show the actual space consumed by a container. |
sysdig_container_fs_free_percent
| |
|---|
| Prometheus ID | sysdig_container_fs_free_percent |
| Legacy ID | fs.free.percent |
| Metric Type | gauge |
| Unit | percent |
| Description | The percentage of free space in the filesystem. |
| Additional Notes | Container Filesystem metrics report data on filesystems mounted to containers. These are the most useful metrics for stateful containers which have dedicated file storage mounted. Use these metrics with appropriate scoping. Care should be taken when aggregating filesystem metrics to ensure that there is no “double counting” of filesystems that are mounted to multiple containers. Additionally, the metrics from overlay type file systems are generally not reported, so these metrics typically will not show the actual space consumed by a container. |
sysdig_container_fs_inodes_total_count
| |
|---|
| Prometheus ID | sysdig_container_fs_inodes_total_count |
| Legacy ID | fs.inodes.total.count |
| Metric Type | gauge |
| Unit | number |
| Description | The total number of inodes in the filesystem. |
| Additional Notes | Container Filesystem metrics report data on filesystems mounted to containers. These are the most useful metrics for stateful containers which have dedicated file storage mounted. Use these metrics with appropriate scoping. Care should be taken when aggregating filesystem metrics to ensure that there is no “double counting” of filesystems that are mounted to multiple containers. Additionally, the metrics from overlay type file systems are generally not reported, so these metrics typically will not show the actual space consumed by a container. |
sysdig_container_fs_inodes_used_count
| |
|---|
| Prometheus ID | sysdig_container_fs_inodes_used_count |
| Legacy ID | fs.inodes.used.count |
| Metric Type | gauge |
| Unit | number |
| Description | The number of inodes used in the filesystem. |
| Additional Notes | Container Filesystem metrics report data on filesystems mounted to containers. These are the most useful metrics for stateful containers which have dedicated file storage mounted. Use these metrics with appropriate scoping. Care should be taken when aggregating filesystem metrics to ensure that there is no “double counting” of filesystems that are mounted to multiple containers. Additionally, the metrics from overlay type file systems are generally not reported, so these metrics typically will not show the actual space consumed by a container. |
sysdig_container_fs_inodes_used_percent
| |
|---|
| Prometheus ID | sysdig_container_fs_inodes_used_percent |
| Legacy ID | fs.inodes.used.percent |
| Metric Type | gauge |
| Unit | percent |
| Description | The percentage of inodes usage in the filesystem. |
| Additional Notes | Container Filesystem metrics report data on filesystems mounted to containers. These are the most useful metrics for stateful containers which have dedicated file storage mounted. Use these metrics with appropriate scoping. Care should be taken when aggregating filesystem metrics to ensure that there is no “double counting” of filesystems that are mounted to multiple containers. Additionally, the metrics from overlay type file systems are generally not reported, so these metrics typically will not show the actual space consumed by a container. |
sysdig_container_fs_largest_used_percent
| |
|---|
| Prometheus ID | sysdig_container_fs_largest_used_percent |
| Legacy ID | fs.largest.used.percent |
| Metric Type | gauge |
| Unit | percent |
| Description | The percentage of the largest filesystem in use. |
| Additional Notes | Container Filesystem metrics report data on filesystems mounted to containers. These are the most useful metrics for stateful containers which have dedicated file storage mounted. Use these metrics with appropriate scoping. Care should be taken when aggregating filesystem metrics to ensure that there is no “double counting” of filesystems that are mounted to multiple containers. Additionally, the metrics from overlay type file systems are generally not reported, so these metrics typically will not show the actual space consumed by a container. |
sysdig_container_fs_root_used_percent
| |
|---|
| Prometheus ID | sysdig_container_fs_root_used_percent |
| Legacy ID | fs.root.used.percent |
| Metric Type | gauge |
| Unit | percent |
| Description | The percentage of the root filesystem in use in the container. |
| Additional Notes | Container Filesystem metrics report data on filesystems mounted to containers. These are the most useful metrics for stateful containers which have dedicated file storage mounted. Use these metrics with appropriate scoping. Care should be taken when aggregating filesystem metrics to ensure that there is no “double counting” of filesystems that are mounted to multiple containers. Additionally, the metrics from overlay type file systems are generally not reported, so these metrics typically will not show the actual space consumed by a container. |
sysdig_container_fs_total_bytes
| |
|---|
| Prometheus ID | sysdig_container_fs_total_bytes |
| Legacy ID | fs.bytes.total |
| Metric Type | gauge |
| Unit | data |
| Description | The size of container filesystem. |
| Additional Notes | Container Filesystem metrics report data on filesystems mounted to containers. These are the most useful metrics for stateful containers which have dedicated file storage mounted. Use these metrics with appropriate scoping. Care should be taken when aggregating filesystem metrics to ensure that there is no “double counting” of filesystems that are mounted to multiple containers. Additionally, the metrics from overlay type file systems are generally not reported, so these metrics typically will not show the actual space consumed by a container. |
sysdig_container_fs_used_bytes
| |
|---|
| Prometheus ID | sysdig_container_fs_used_bytes |
| Legacy ID | fs.bytes.used |
| Metric Type | gauge |
| Unit | data |
| Description | The used space in the container filesystem. |
| Additional Notes | Container Filesystem metrics report data on filesystems mounted to containers. These are the most useful metrics for stateful containers which have dedicated file storage mounted. Use these metrics with appropriate scoping. Care should be taken when aggregating filesystem metrics to ensure that there is no “double counting” of filesystems that are mounted to multiple containers. Additionally, the metrics from overlay type file systems are generally not reported, so these metrics typically will not show the actual space consumed by a container. |
sysdig_container_fs_used_percent
| |
|---|
| Prometheus ID | sysdig_container_fs_used_percent |
| Legacy ID | fs.used.percent |
| Metric Type | gauge |
| Unit | percent |
| Description | The percentage of the sum of all filesystems in use in the container. |
| Additional Notes | Container Filesystem metrics report data on filesystems mounted to containers. These are the most useful metrics for stateful containers which have dedicated file storage mounted. Use these metrics with appropriate scoping. Care should be taken when aggregating filesystem metrics to ensure that there is no “double counting” of filesystems that are mounted to multiple containers. Additionally, the metrics from overlay type file systems are generally not reported, so these metrics typically will not show the actual space consumed by a container. |
sysdig_container_info
| |
|---|
| Prometheus ID | sysdig_container_info |
| Legacy ID | info |
| Metric Type | gauge |
| Unit | number |
| Description | The info metrics will always have the value of 1. |
| Additional Notes | |
sysdig_container_memory_limit_bytes
| |
|---|
| Prometheus ID | sysdig_container_memory_limit_bytes |
| Legacy ID | memory.limit.bytes |
| Metric Type | gauge |
| Unit | data |
| Description | The memory limit in bytes assigned to a container. |
| Additional Notes | |
sysdig_container_memory_limit_used_percent
| |
|---|
| Prometheus ID | sysdig_container_memory_limit_used_percent |
| Legacy ID | memory.limit.used.percent |
| Metric Type | gauge |
| Unit | percent |
| Description | The percentage of memory limit used by a container. |
| Additional Notes | |
sysdig_container_memory_used_bytes
| |
|---|
| Prometheus ID | sysdig_container_memory_used_bytes |
| Legacy ID | memory.bytes.used |
| Metric Type | gauge |
| Unit | data |
| Description | The amount of physical memory currently in use. |
| Additional Notes | By default, this metric shows the average value for the selected scope. For instance, if you apply it to a group of machines, you will see the average value for the whole group. However, the metric can also be segmented by using ‘Segment by’ in the UI. |
sysdig_container_memory_used_percent
| |
|---|
| Prometheus ID | sysdig_container_memory_used_percent |
| Legacy ID | memory.used.percent |
| Metric Type | gauge |
| Unit | percent |
| Description | The percentage of physical memory in use. |
| Additional Notes | By default, this metric shows the average value for the selected scope. For instance, if you apply it to a group of machines, you will see the average value for the whole group. However, you can easily segment the metric to see it by host, process, container, and so on. Just use ‘Segment by’ in the UI. |
sysdig_container_memory_virtual_bytes
| |
|---|
| Prometheus ID | sysdig_container_memory_virtual_bytes |
| Legacy ID | memory.bytes.virtual |
| Metric Type | gauge |
| Unit | data |
| Description | The virtual memory size of the process, in bytes. This value is obtained from Sysdig events. |
| Additional Notes | |
sysdig_container_net_connection_in_count
| |
|---|
| Prometheus ID | sysdig_container_net_connection_in_count |
| Legacy ID | net.connection.count.in |
| Metric Type | counter |
| Unit | number |
| Description | The number of currently established client (inbound) connections. |
| Additional Notes | This metric is especially useful when segmented by protocol, port or process. |
sysdig_container_net_connection_out_count
| |
|---|
| Prometheus ID | sysdig_container_net_connection_out_count |
| Legacy ID | net.connection.count.out |
| Metric Type | counter |
| Unit | number |
| Description | The number of currently established server (outbound) connections. |
| Additional Notes | This metric is especially useful when segmented by protocol, port or process. |
sysdig_container_net_connection_total_count
| |
|---|
| Prometheus ID | sysdig_container_net_connection_total_count |
| Legacy ID | net.connection.count.total |
| Metric Type | counter |
| Unit | number |
| Description | The number of currently established connections. This value may exceed the sum of the inbound and outbound metrics since it represents client and server inter-host connections as well as internal only connections. |
| Additional Notes | This metric is especially useful when segmented by protocol, port or process. |
sysdig_container_net_error_count
| |
|---|
| Prometheus ID | sysdig_container_net_error_count |
| Legacy ID | net.error.count |
| Metric Type | counter |
| Unit | number |
| Description | The number of errors on network-related system calls performed by containers. This includes syscalls acting on ipv4 and ipv6 socket file descriptors, such as recv and send. It also includes socket family syscalls, such as accept, connect and bind. |
| Additional Notes | By default, this metric shows the total value for the selected scope. For example, if the scope is defined as a group of machines, the metric value will be the total value for the whole group. Select Segment By in the UI to see the metric by host, process, container, and so on. |
sysdig_container_net_http_error_count
| |
|---|
| Prometheus ID | sysdig_container_net_http_error_count |
| Legacy ID | net.http.error.count |
| Metric Type | counter |
| Unit | number |
| Description | The number of failed HTTP requests as counted from 4xx/5xx status codes. |
| Additional Notes | |
sysdig_container_net_http_request_count
| |
|---|
| Prometheus ID | sysdig_container_net_http_request_count |
| Legacy ID | net.http.request.count |
| Metric Type | counter |
| Unit | number |
| Description | The count of HTTP requests. |
| Additional Notes | |
sysdig_container_net_http_request_time
| |
|---|
| Prometheus ID | sysdig_container_net_http_request_time |
| Legacy ID | net.http.request.time |
| Metric Type | counter |
| Unit | time |
| Description | The average time taken for HTTP requests. |
| Additional Notes | |
sysdig_container_net_http_statuscode_error_count
| |
|---|
| Prometheus ID | sysdig_container_net_http_statuscode_error_count |
| Legacy ID | net.http.statuscode.error.count |
| Metric Type | counter |
| Unit | number |
| Description | The number of HTTP error codes returned. |
| Additional Notes | |
sysdig_container_net_http_statuscode_request_count
| |
|---|
| Prometheus ID | sysdig_container_net_http_statuscode_request_count |
| Legacy ID | net.http.statuscode.request.count |
| Metric Type | counter |
| Unit | number |
| Description | The number of HTTP status codes requests. |
| Additional Notes | |
sysdig_container_net_http_url_error_count
| |
|---|
| Prometheus ID | sysdig_container_net_http_url_error_count |
| Legacy ID | net.http.url.error.count |
| Metric Type | counter |
| Unit | number |
| Description | |
| Additional Notes | |
sysdig_container_net_http_url_request_count
| |
|---|
| Prometheus ID | sysdig_container_net_http_url_request_count |
| Legacy ID | net.http.url.request.count |
| Metric Type | counter |
| Unit | number |
| Description | The number of HTTP URLs requests. |
| Additional Notes | |
sysdig_container_net_http_url_request_time
| |
|---|
| Prometheus ID | sysdig_container_net_http_url_request_time |
| Legacy ID | net.http.url.request.time |
| Metric Type | counter |
| Unit | time |
| Description | The time taken for requesting HTTP URLs. |
| Additional Notes | |
sysdig_container_net_in_bytes
| |
|---|
| Prometheus ID | sysdig_container_net_in_bytes |
| Legacy ID | net.bytes.in |
| Metric Type | counter |
| Unit | data |
| Description | The number of inbound network bytes. |
| Additional Notes | By default, this metric shows the total value for the selected scope. For instance, if you apply it to a group of machines, you will see the total value for the whole group. However, you can easily segment the metric to see it by host, process, container, and so on. Just use ‘Segment by’ in the UI. |
sysdig_container_net_mongodb_error_count
| |
|---|
| Prometheus ID | sysdig_container_net_mongodb_error_count |
| Legacy ID | net.mongodb.error.count |
| Metric Type | counter |
| Unit | number |
| Description | The number of Failed MongoDB requests. |
| Additional Notes | |
sysdig_container_net_mongodb_request_count
| |
|---|
| Prometheus ID | sysdig_container_net_mongodb_request_count |
| Legacy ID | net.mongodb.request.count |
| Metric Type | counter |
| Unit | number |
| Description | The total number of MongoDB requests. |
| Additional Notes | |
sysdig_container_net_out_bytes
| |
|---|
| Prometheus ID | sysdig_container_net_out_bytes |
| Legacy ID | net.bytes.out |
| Metric Type | counter |
| Unit | data |
| Description | The number of outbound network bytes. |
| Additional Notes | By default, this metric shows the total value for the selected scope. For instance, if you apply it to a group of machines, you will see the total value for the whole group. However, you can easily segment the metric to see it by host, process, container, and so on. Just use ‘Segment by’ in the UI. |
sysdig_container_net_request_count
| |
|---|
| Prometheus ID | sysdig_container_net_request_count |
| Legacy ID | net.request.count |
| Metric Type | counter |
| Unit | number |
| Description | The total number of network requests. Note, this value may exceed the sum of inbound and outbound requests, because this count includes requests over internal connections. |
| Additional Notes | |
sysdig_container_net_request_in_count
| |
|---|
| Prometheus ID | sysdig_container_net_request_in_count |
| Legacy ID | net.request.count.in |
| Metric Type | counter |
| Unit | number |
| Description | The number of inbound network requests. |
| Additional Notes | |
sysdig_container_net_request_in_time
| |
|---|
| Prometheus ID | sysdig_container_net_request_in_time |
| Legacy ID | net.request.time.in |
| Metric Type | counter |
| Unit | time |
| Description | The average time to serve an inbound request. |
| Additional Notes | |
sysdig_container_net_request_out_count
| |
|---|
| Prometheus ID | sysdig_container_net_request_out_count |
| Legacy ID | net.request.count.out |
| Metric Type | counter |
| Unit | number |
| Description | The number of outbound network requests. |
| Additional Notes | |
sysdig_container_net_request_out_time
| |
|---|
| Prometheus ID | sysdig_container_net_request_out_time |
| Legacy ID | net.request.time.out |
| Metric Type | counter |
| Unit | time |
| Description | The average time spent waiting for an outbound request. |
| Additional Notes | |
sysdig_container_net_request_time
| |
|---|
| Prometheus ID | sysdig_container_net_request_time |
| Legacy ID | net.request.time |
| Metric Type | counter |
| Unit | time |
| Description | The average time to serve a network request. |
| Additional Notes | |
sysdig_container_net_server_connection_in_count
| |
|---|
| Prometheus ID | sysdig_container_net_server_connection_in_count |
| Legacy ID | net.server.connection.count.in |
| Metric Type | counter |
| Unit | number |
| Description | |
| Additional Notes | |
sysdig_container_net_server_in_bytes
| |
|---|
| Prometheus ID | sysdig_container_net_server_in_bytes |
| Legacy ID | net.server.bytes.in |
| Metric Type | counter |
| Unit | data |
| Description | |
| Additional Notes | |
sysdig_container_net_server_out_bytes
| |
|---|
| Prometheus ID | sysdig_container_net_server_out_bytes |
| Legacy ID | net.server.bytes.out |
| Metric Type | counter |
| Unit | data |
| Description | |
| Additional Notes | |
sysdig_container_net_server_total_bytes
| |
|---|
| Prometheus ID | sysdig_container_net_server_total_bytes |
| Legacy ID | net.server.bytes.total |
| Metric Type | counter |
| Unit | data |
| Description | |
| Additional Notes | |
sysdig_container_net_sql_error_count
| |
|---|
| Prometheus ID | sysdig_container_net_sql_error_count |
| Legacy ID | net.sql.error.count |
| Metric Type | counter |
| Unit | number |
| Description | The number of failed SQL requests. |
| Additional Notes | |
sysdig_container_net_sql_query_error_count
| |
|---|
| Prometheus ID | sysdig_container_net_sql_query_error_count |
| Legacy ID | net.sql.query.error.count |
| Metric Type | counter |
| Unit | number |
| Description | |
| Additional Notes | |
sysdig_container_net_sql_query_request_count
| |
|---|
| Prometheus ID | sysdig_container_net_sql_query_request_count |
| Legacy ID | net.sql.query.request.count |
| Metric Type | counter |
| Unit | number |
| Description | |
| Additional Notes | |
sysdig_container_net_sql_query_request_time
| |
|---|
| Prometheus ID | sysdig_container_net_sql_query_request_time |
| Legacy ID | net.sql.query.request.time |
| Metric Type | counter |
| Unit | time |
| Description | |
| Additional Notes | |
sysdig_container_net_sql_querytype_error_count
| |
|---|
| Prometheus ID | sysdig_container_net_sql_querytype_error_count |
| Legacy ID | net.sql.querytype.error.count |
| Metric Type | counter |
| Unit | number |
| Description | |
| Additional Notes | |
sysdig_container_net_sql_querytype_request_count
| |
|---|
| Prometheus ID | sysdig_container_net_sql_querytype_request_count |
| Legacy ID | net.sql.querytype.request.count |
| Metric Type | counter |
| Unit | number |
| Description | |
| Additional Notes | |
sysdig_container_net_sql_querytype_request_time
| |
|---|
| Prometheus ID | sysdig_container_net_sql_querytype_request_time |
| Legacy ID | net.sql.querytype.request.time |
| Metric Type | counter |
| Unit | time |
| Description | |
| Additional Notes | |
sysdig_container_net_sql_request_count
| |
|---|
| Prometheus ID | sysdig_container_net_sql_request_count |
| Legacy ID | net.sql.request.count |
| Metric Type | counter |
| Unit | number |
| Description | The number of SQL requests. |
| Additional Notes | |
sysdig_container_net_sql_request_time
| |
|---|
| Prometheus ID | sysdig_container_net_sql_request_time |
| Legacy ID | net.sql.request.time |
| Metric Type | counter |
| Unit | time |
| Description | The average time to complete an SQL request. |
| Additional Notes | |
sysdig_container_net_sql_table_error_count
| |
|---|
| Prometheus ID | sysdig_container_net_sql_table_error_count |
| Legacy ID | net.sql.table.error.count |
| Metric Type | counter |
| Unit | number |
| Description | The total number of SQL errors returned. |
| Additional Notes | |
sysdig_container_net_sql_table_request_count
| |
|---|
| Prometheus ID | sysdig_container_net_sql_table_request_count |
| Legacy ID | net.sql.table.request.count |
| Metric Type | counter |
| Unit | number |
| Description | The total number of SQL table requests. |
| Additional Notes | |
sysdig_container_net_sql_table_request_time
| |
|---|
| Prometheus ID | sysdig_container_net_sql_table_request_time |
| Legacy ID | net.sql.table.request.time |
| Metric Type | counter |
| Unit | time |
| Description | The average time to serve an SQL table request. |
| Additional Notes | |
sysdig_container_net_tcp_queue_len
| |
|---|
| Prometheus ID | sysdig_container_net_tcp_queue_len |
| Legacy ID | net.tcp.queue.len |
| Metric Type | counter |
| Unit | number |
| Description | The length of the TCP request queue. |
| Additional Notes | |
sysdig_container_net_total_bytes
| |
|---|
| Prometheus ID | sysdig_container_net_total_bytes |
| Legacy ID | net.bytes.total |
| Metric Type | counter |
| Unit | data |
| Description | The total number of network bytes, including inbound and outbound connections. |
| Additional Notes | By default, this metric shows the total value for the selected scope. For instance, if you apply it to a group of machines, you will see the total value for the whole group. However, you can easily segment the metric to see it by host, process, container, and so on. Just use ‘Segment by’ in the UI. |
sysdig_container_proc_count
| |
|---|
| Prometheus ID | sysdig_container_proc_count |
| Legacy ID | proc.count |
| Metric Type | counter |
| Unit | number |
| Description | The number of processes on host or container. |
| Additional Notes | |
sysdig_container_swap_limit_bytes
| |
|---|
| Prometheus ID | sysdig_container_swap_limit_bytes |
| Legacy ID | swap.limit.bytes |
| Metric Type | gauge |
| Unit | data |
| Description | The swap limit in bytes assigned to a container. |
| Additional Notes | |
sysdig_container_swap_limit_used_percent
| |
|---|
| Prometheus ID | sysdig_container_swap_limit_used_percent |
| Legacy ID | swap.limit.used.percent |
| Metric Type | gauge |
| Unit | percent |
| Description | The percentage of swap limit used by the container. |
| Additional Notes | |
sysdig_container_syscall_count
| |
|---|
| Prometheus ID | sysdig_container_syscall_count |
| Legacy ID | syscall.count |
| Metric Type | gauge |
| Unit | number |
| Description | The total number of syscalls seen. |
| Additional Notes | Syscalls are resource intensive. This metric tracks how many have been made by a given process or container |
sysdig_container_syscall_error_count
| |
|---|
| Prometheus ID | sysdig_container_syscall_error_count |
| Legacy ID | host.error.count |
| Metric Type | counter |
| Unit | number |
| Description | The number of system call errors. |
| Additional Notes | By default, this metric shows the total value for the selected scope. For instance, if you apply it to a group of machines, you will see the total value for the whole group. However, you can easily segment the metric to see it by host, process, container, and so on. Just use ‘Segment by’ in the UI. |
sysdig_container_thread_count
| |
|---|
| Prometheus ID | sysdig_container_thread_count |
| Legacy ID | thread.count |
| Metric Type | counter |
| Unit | number |
| Description | The number of threads running in a container. |
| Additional Notes | |
sysdig_container_timeseries_count_appcheck
| |
|---|
| Prometheus ID | sysdig_container_timeseries_count_appcheck |
| Legacy ID | metricCount.appCheck |
| Metric Type | gauge |
| Unit | number |
| Description | The number of appcheck custom metrics. |
| Additional Notes | |
sysdig_container_timeseries_count_jmx
| |
|---|
| Prometheus ID | sysdig_container_timeseries_count_jmx |
| Legacy ID | metricCount.jmx |
| Metric Type | gauge |
| Unit | number |
| Description | The number of JMX custom metrics. |
| Additional Notes | |
sysdig_container_timeseries_count_prometheus
| |
|---|
| Prometheus ID | sysdig_container_timeseries_count_prometheus |
| Legacy ID | metricCount.prometheus |
| Metric Type | gauge |
| Unit | number |
| Description | The number of Prometheus custom metrics. |
| Additional Notes | |
sysdig_container_timeseries_count_statsd
| |
|---|
| Prometheus ID | sysdig_container_timeseries_count_statsd |
| Legacy ID | metricCount.statsd |
| Metric Type | gauge |
| Unit | number |
| Description | The number of StatsD custom metrics. |
| Additional Notes | |
sysdig_container_up
| |
|---|
| Prometheus ID | sysdig_container_up |
| Legacy ID | uptime |
| Metric Type | gauge |
| Unit | number |
| Description | The percentage of time the selected entity was down during the visualized time sample. |
| Additional Notes | The metric reflects the state of the container. |