Skip to main content
The Host integration requires CXDOT Collector 1.4.0 or greater. Use the Host CXDOT Collector integration to collect operating system metrics from the machine where the CXDOT Collector runs, including CPU, memory, disk, file system, network, load, paging, processes, and uptime. The integration can also count the processes that match named checks and collect per-process metrics.

Supported telemetry types

The Host CXDOT Collector integration supports these telemetry types:

Prerequisites

The Host CXDOT Collector integration has the following prerequisites:
  • When you deploy the CXDOT Collector with the Helm chart on Linux, the chart mounts the node’s file system read-only at /hostfs and sets root_path so metrics describe the node rather than the Collector container. No extra volume mapping is required.
  • For another container-based Linux deployment, bind-mount the host root file system read-only into the container and set root_path to that mount point. For example, mount the host root at /hostfs and set root_path: /hostfs. Without this mount, the integration reports metrics for the container instead of the host.
  • When the CXDOT Collector runs directly on the host, you don’t need a file system mount.

Configure

The Host CXDOT Collector integration is enabled by default. It monitors the machine where the node Collector runs and doesn’t require target endpoints or pod labels for discovery. On Kubernetes, the node Collector runs one Host integration instance per node. For more information about Collector tiers and node placement, see architecture. Host metrics receive base deployment enrichment, such as cluster and host identity labels. They aren’t scoped to individual pods. By default, the integration collects CPU, memory, disk, file system, network, load, paging, and uptime metrics on Linux, macOS, and Windows, plus process counts on Linux and macOS. On Linux, it also collects network-interface configuration from /sys/class/net and system-wide file descriptor usage. On Windows, it also collects the CPU queue length, the file cache size, the commit limit and commit charge, and the open handle count across all processes. The network family also collects TCP statistics on Windows, split by IPv4 and IPv6. The interface configuration metrics describe the interfaces the Collector process can see. They match the node’s interfaces when the Collector runs with host networking or directly on the host. Process checks and per-process metrics run only after you configure them, so a default installation collects neither. Per-process metrics can substantially increase time series cardinality. For more information, see the Monitor processes section. Shared timing settings apply to every metric family, and root_path applies on Linux only. You can enable or disable each family, and most families also pass through additional settings. On Windows, the processes.config settings have no effect. For the complete field list, accepted values, and defaults, see the configuration reference on this page. To configure the Host CXDOT Collector integration, follow these steps:
  1. Optional: Adjust shared settings or individual metric families. For example, add the following to the values.yaml for your CXDOT Collector Helm chart:
  2. Optional: Count the processes that match named checks, and collect detailed per-process metrics for the processes you choose. For example, add the following to the values.yaml for your CXDOT Collector Helm chart:
    This example counts the processes named nginx every collection interval and collects per-process metrics for processes named postgres or haproxy. For all options, see the Monitor processes section.
  3. Optional: Disable the integration. For example, add the following to the values.yaml for your CXDOT Collector Helm chart:

Validate

To validate the Host CXDOT Collector integration, follow these steps:
  1. In the Live Telemetry Analyzer, filter for __name__=cxdot.integration.target.health and cxdot.integration.name=host. Confirm that each series reports 1 for a healthy node. Use the cxdot.integration.target and host.name attributes to identify the node and metric family.
  2. In Metrics Explorer, run the following query:
    Confirm that the query returns one time series per node. Use the host.name label to identify the node.
  3. Optional: If you configured process checks, run the following query in Metrics Explorer and confirm that it returns one series per check:
    Use the cxdot.process.check attribute to identify each check. A check that matches no process reports 0.

Troubleshooting

  • A check reports 0 for a running process: The check’s selector can’t read one of its fields, or doesn’t match the value. Check the Collector logs for an unreadable-field warning. An executable_path selector needs root or the CAP_SYS_PTRACE capability on Linux, and a pid_file must be readable by the Collector.
  • A check has no count and cxdot.integration.target.health reports 0 for cxdot.integration.check="process": The Collector can’t read the process table. Confirm that root_path points at the host’s root file system and that /proc is mounted without hidepid.

Monitor processes

The process setting has two parts. Both run only when you configure them. process.enabled defaults to true, and with no checks and no per-process selection, the integration collects nothing for it. Set process.enabled to false to turn both parts off.
  • A process check counts the processes that match a name and a set of selectors. It reports the count every interval, including 0.
  • Per-process metrics, such as process.cpu.time and process.memory.usage, describe individual processes.
Both parts run on Linux, macOS, and Windows.

Configure process checks

Each check has a unique name and at least one selector field. Add the following to the values.yaml for your CXDOT Collector Helm chart:
The check name becomes the cxdot.process.check attribute, so keep it stable when you change the selectors. By default, checks run at the integration’s collection_interval. Set checks_collection_interval to count processes more often without collecting per-process metrics more often. Each check reports one time series per host, so a shorter interval adds little cost.

Match processes

Checks, include_matches, and exclude_matches share one set of matching rules:
  • Within a field, any value can match. values: [redis-server, redis-sentinel] matches either name.
  • Across fields, every field must match. A selector with executable_name and owner matches processes that satisfy both.
  • Across list items, any item can match. A process matches include_matches when at least one item matches it.
  • A process can belong to several checks. Each check is independent, and the first match doesn’t win.
  • A field the Collector can’t read doesn’t match. For example, a process with an unreadable executable path doesn’t match an executable_path selector.
  • A process with no executable or command line, such as a Linux kernel thread, has an empty executable_path and command_line. No strict value matches an empty field.
  • match_type: strict, the default, compares the whole value. On Windows, strict comparison of executable_name, executable_path, and owner ignores case.
  • match_type: regexp uses RE2 syntax and matches anywhere in the value. Anchor the expression with ^ and $ to match the whole value. Regular expressions are case-sensitive on every operating system. Use (?i) to ignore case.
  • pid_file matches the process whose ID is on the first line of the file. A missing file, a path that isn’t a regular file, a file that doesn’t parse, or an ID with no running process matches nothing, so the check reports 0. The Collector reads the file once per interval, under root_path on a Kubernetes node.
  • include_children: true adds every descendant of every matching process, and each process counts once per check. A child whose parent has exited is no longer found through that parent.
The following table shows what each field matches: On Linux, a kernel name truncated to 15 characters is extended from the first command-line argument. On a Kubernetes node, the Collector resolves owner from the node’s /etc/passwd, so the name is the host’s.

Select per-process metrics

Per-process metrics are off until you select processes under per_process_metrics. The Collector selects:
  • every process, if all_processes is true
  • plus the processes that match include_matches
  • plus every member of every check, if include_checks is true, including descendants for a check that sets include_children
  • minus the processes that match exclude_matches
Exclusions never change check counts. Setting exclude_matches alone doesn’t select every other process. For example, add the following to the values.yaml for your CXDOT Collector Helm chart:
To collect per-process metrics for every process except a few, set all_processes: true and list the exceptions under exclude_matches. On a Kubernetes node, per-process metrics don’t carry the process.owner attribute, because the Collector container has no user list to resolve owner names from. An owner selector still matches, because the Collector resolves it from the node’s /etc/passwd.

Control the cost of selection

The Collector decides whether to select a process before it reads any of the process’s metrics. To decide, it reads only the fields the selectors use, and stops at the first field that rules a selector out. A process that isn’t selected costs only those reads, whichever fields you select on, and never causes a read error to be logged. Only all_processes makes the Collector read metrics for every process. When all_processes is true, mute_process_io_error defaults to true, because a Collector that isn’t root can’t read the I/O counters of other users’ processes. Set it to false to log those errors. mute_process_user_error defaults to true when all_processes is true, or when root_path is set to a path other than /, such as on a Kubernetes node, where the Helm chart sets it to /hostfs. The Collector reads process owners from its own user list, which has no entry for most user IDs when the Collector runs in a container. On a Kubernetes node, the owner read fails for every process. Set it to false to log those errors. all_processes also reads executable paths the Collector may not be allowed to read: other users’ processes on Linux when the Collector isn’t root, and protected processes on Windows, where reading the process name fails too. mute_process_exe_error and mute_process_name_error default to false, so set both to true to stop all_processes from logging read errors.

Move process settings to schema version 1.17

Before schema version 1.17, process.config took a different set of settings, such as include and exclude. A configuration that declares an earlier schema_version keeps working: the Collector converts these settings at startup, and the Helm chart still accepts them. To declare schema version 1.17 or later, rewrite them as shown in the following table: An earlier configuration with process.enabled: true and no include collected per-process metrics for every process. To keep collecting them, set per_process_metrics.all_processes: true. An earlier configuration also logged the read errors that the current defaults mute in some cases. For more information, see the Control the cost of selection section. If a configuration declares schema version 1.17 or later and sets an earlier setting, the Collector runs neither process checks nor per-process metrics, and logs an error that names the setting. A process.config that mixes earlier and current settings fails validation.

Permissions

The Collector reads process details with its own permissions:
  • On Linux, any user can read process names, command lines, and owners. Reading executable_path for another user’s process requires root or the CAP_SYS_PTRACE capability. The Helm chart runs the node Collector as a non-root user by default, so an executable_path selector matches only the processes that run as the same user as the Collector unless you grant the capability.
  • A /proc file system mounted with hidepid=2 hides other users’ processes, including init (PID 1), from a Collector that isn’t root. The Collector then treats the process table as unreadable: checks report no count, and cxdot.integration.target.health reports 0.
  • On Windows, protected processes deny their path and owner. Their command line reads as empty, so a command_line selector doesn’t match them, and the Collector logs no warning for it.
  • A pid_file must be readable by the Collector. A file readable only by root matches nothing for a non-root Collector.
When a selector can’t read a field, the Collector logs a warning, at most once every 10 minutes for each check or selector. It also logs a warning at startup when an executable_path selector lacks the permission to read other users’ executables.

Process check telemetry

Each check reports the system.process.check.count metric, with the cxdot.process.check attribute set to the check name. The metric carries the host attributes that every Host integration metric has, and no per-process attributes. For example, on a host that runs one Kafka broker and no mongod, the integration reports these series:
The count distinguishes a stopped process from missing data: The health series exists only when checks are configured. It reports 1 when the Collector read the process table, whatever the count is. In the rows with no value, a series doesn’t disappear at once. After the Collector stops reporting it, queries return its last value for five minutes, and then return no value. The Collector reports no count when it can’t read the process table, for example when root_path is wrong or /proc isn’t mounted. It treats a table that can’t be the host’s the same way: an empty one, or, outside Windows, one without init (PID 1), which is what the Collector reads when the host’s /proc isn’t mounted under root_path. This way, a Collector problem doesn’t look like every check failing at once. A process can belong to several checks, and include_children can pull the same process into a check that already counts it. Summing system.process.check.count across checks therefore counts overlapping processes more than once. Sum across hosts for the same check, and filter on cxdot.process.check to read one check.

Alert on a stopped process

Group monitors by host.name and cxdot.process.check. The following queries cover common cases. These queries return no result when the count has no value, which happens when the Collector or host is down, or when the Collector can’t read the process table. A condition such as < 1 doesn’t fire in those cases. To alert in those cases too, add a missing data condition to the monitor, or create a separate monitor that alerts when cxdot.integration.target.health is 0 or has no value. To alert when mongod isn’t running on a host that’s configured for it, use a liveness query:
To alert when 4 of the last 5 readings are less than 1, use the following query. The step after the colon is the checks interval, and the window is 5 times the step, so the window holds 5 readings. At the default 60 seconds that’s [5m:1m]. If you change checks_collection_interval, change both: at 15 seconds, use [75s:15s].
To alert when a worker pool shrinks, set monitor thresholds on the count. For example, the following queries match a critical threshold of 2 and a warning threshold of 4:

Configuration reference

Configure one Host integration instance with the following settings. In Helm values, place these settings under collection.cxdot.integrations.host. In a Collector configuration file, place them under cxdot.integrations.host.

Optional settings

  • enabled Type: boolean. Optional. Default: true. Whether to enable this configuration block. If true, the Collector runs the integration or capability. If false, the Collector doesn’t run it.
  • collection_interval Type: duration. Optional. Default: 60s. How often the Collector collects operating system metrics.
  • timeout Type: duration. Optional. Default: 60s. Maximum time allowed for one collection.
  • root_path Type: string. Optional. Default: empty string. Root of the host file system when the Collector runs in a container with the host root bind-mounted (for example, /hostfs). The Collector uses this path so metric collection reads the node instead of the container. Omit when the Collector runs directly on the host.
  • cpu Type: object. Optional. Settings for collecting CPU usage metrics.
  • cpu.enabled Type: boolean. Optional. Default: true. Whether to enable this configuration block. If true, the Collector runs the integration or capability. If false, the Collector doesn’t run it.
  • cpu.config Type: object. Optional. Default: {"metrics":{"system.cpu.physical.count":{"enabled":true},"system.cpu.utilization":{"enabled":true}}}. Advanced settings for CPU metrics, passed through to the Collector unchanged. The default enables this integration’s standard metric set.
  • memory Type: object. Optional. Settings for collecting memory usage metrics.
  • memory.enabled Type: boolean. Optional. Default: true. Whether to enable this configuration block. If true, the Collector runs the integration or capability. If false, the Collector doesn’t run it.
  • memory.config Type: object. Optional. Default: {"metrics":{"system.linux.memory.available":{"enabled":true},"system.memory.limit":{"enabled":true},"system.memory.linux.shared":{"enabled":true},"system.memory.utilization":{"enabled":true}}}. Advanced settings for memory metrics, passed through to the Collector unchanged. The default enables this integration’s standard metric set.
  • filesystem Type: object. Optional. Settings for collecting file system usage metrics.
  • filesystem.enabled Type: boolean. Optional. Default: true. Whether to enable this configuration block. If true, the Collector runs the integration or capability. If false, the Collector doesn’t run it.
  • filesystem.config Type: object. Optional. Default: {"include_virtual_filesystems":true,"metrics":{"system.filesystem.utilization":{"enabled":true}}}. Advanced settings for file system metrics, passed through to the Collector unchanged. The default enables this integration’s standard metric set.
  • filesystem.config.include_virtual_filesystems Type: boolean. Optional. Default: true. Include virtual and bind-mounted file systems. Containerized Collectors require this to report file systems from a bind-mounted host root.
  • filesystem.config.exclude_devices Type: object. Optional. Filter that excludes filesystems by device name. Set match_type to strict to match names exactly or regexp to match them as regular expressions. The scraper requires match_type when this filter is set.
  • filesystem.config.exclude_devices.devices Type: array of string. Optional. Device names or patterns to exclude, for example, /dev/loop0.
  • filesystem.config.exclude_fs_types Type: object. Optional. Filter that excludes filesystems by type. Set match_type to strict to match types exactly or regexp to match them as regular expressions. The scraper requires match_type when this filter is set.
  • filesystem.config.exclude_fs_types.fs_types Type: array of string. Optional. Filesystem types or patterns to exclude, for example, tmpfs or overlay.
  • filesystem.config.exclude_mount_points Type: object. Optional. Filter that excludes filesystems by mount point. Set match_type to strict to match mount points exactly or regexp to match them as regular expressions. The scraper requires match_type when this filter is set. When root_path is set, specify mount points as the host sees them, not as the container does.
  • filesystem.config.exclude_mount_points.mount_points Type: array of string. Optional. Mount points or patterns to exclude, for example, /var/lib/docker.
  • filesystem.config.include_devices Type: object. Optional. Filter that limits filesystem metrics to the listed device names. Set match_type to strict to match names exactly or regexp to match them as regular expressions. The scraper requires match_type when this filter is set.
  • filesystem.config.include_devices.devices Type: array of string. Optional. Device names or patterns to include, for example, /dev/nvme0n1p2.
  • filesystem.config.include_fs_types Type: object. Optional. Filter that limits filesystem metrics to the listed filesystem types. Set match_type to strict to match types exactly or regexp to match them as regular expressions. The scraper requires match_type when this filter is set.
  • filesystem.config.include_fs_types.fs_types Type: array of string. Optional. Filesystem types or patterns to include, for example, ext4 or xfs.
  • filesystem.config.include_mount_points Type: object. Optional. Filter that limits filesystem metrics to the listed mount points. Set match_type to strict to match mount points exactly or regexp to match them as regular expressions. The scraper requires match_type when this filter is set. When root_path is set, specify mount points as the host sees them, not as the container does.
  • filesystem.config.include_mount_points.mount_points Type: array of string. Optional. Mount points or patterns to include, for example, / or /data.
  • network Type: object. Optional. Settings for collecting network interface and connection metrics.
  • network.enabled Type: boolean. Optional. Default: true. Whether to enable this configuration block. If true, the Collector runs the integration or capability. If false, the Collector doesn’t run it.
  • network.config Type: object. Optional. Default: {"metrics":{"system.network.conntrack.count":{"enabled":true},"system.network.conntrack.max":{"enabled":true}}}. Advanced settings for network metrics, passed through to the Collector unchanged. The default enables this integration’s standard metric set.
  • disk Type: object. Optional. Settings for collecting disk I/O metrics.
  • disk.enabled Type: boolean. Optional. Default: true. Whether to enable this configuration block. If true, the Collector runs the integration or capability. If false, the Collector doesn’t run it.
  • disk.config Type: object. Optional. Default: {}. Advanced settings for disk metrics, passed through to the Collector unchanged.
  • load Type: object. Optional. Settings for collecting system load average metrics.
  • load.enabled Type: boolean. Optional. Default: true. Whether to enable this configuration block. If true, the Collector runs the integration or capability. If false, the Collector doesn’t run it.
  • load.config Type: object. Optional. Default: {}. Advanced settings for load metrics, passed through to the Collector unchanged.
  • paging Type: object. Optional. Settings for collecting paging and swap activity metrics.
  • paging.enabled Type: boolean. Optional. Default: true. Whether to enable this configuration block. If true, the Collector runs the integration or capability. If false, the Collector doesn’t run it.
  • paging.config Type: object. Optional. Default: {}. Advanced settings for paging metrics, passed through to the Collector unchanged.
  • processes Type: object. Optional. Settings for collecting process count metrics on Linux and macOS, and the processor queue length on Windows.
  • processes.enabled Type: boolean. Optional. Default: true. Whether to enable this configuration block. If true, the Collector runs the integration or capability. If false, the Collector doesn’t run it.
  • processes.config Type: object. Optional. Default: {}. Advanced settings for process count metrics, passed through to the Collector unchanged. Linux and macOS only; Windows ignores them.
  • uptime Type: object. Optional. Settings for collecting system uptime metrics.
  • uptime.enabled Type: boolean. Optional. Default: true. Whether to enable this configuration block. If true, the Collector runs the integration or capability. If false, the Collector doesn’t run it.
  • uptime.config Type: object. Optional. Default: {}. Advanced settings for uptime metrics, passed through to the Collector unchanged.
  • netclass Type: object. Optional. Settings for collecting per-interface configuration metrics from /sys/class/net.
  • netclass.enabled Type: boolean. Optional. Default: true. Whether to enable this configuration block. If true, the Collector runs the integration or capability. If false, the Collector doesn’t run it.
  • file_handles Type: object. Optional. Settings for collecting system-wide file-descriptor counts from /proc/sys/fs/file-nr on Linux, and the open handle count on Windows.
  • file_handles.enabled Type: boolean. Optional. Default: true. Whether to enable this configuration block. If true, the Collector runs the integration or capability. If false, the Collector doesn’t run it.
  • process Type: object. Optional. Settings for process checks, which count the processes that match each named check, and per-process metrics. Each runs only when configured. Both run on Linux, macOS, and Windows.
  • process.enabled Type: boolean. Optional. Default: true. Turns process checks and per-process metrics on. With no checks and no per-process selection, nothing runs. Set to false to turn both off.
  • process.config Type: object. Optional. Default: {}. Process checks and per-process metric selection.
  • process.config.per_process_metrics Type: object. Optional. Default: {}. Which processes get per-process metrics, such as process.cpu.time, and how they’re collected. No process is selected by default. Per-process metrics produce one set of time series per process. The Collector reads only the fields a selector needs to decide whether a process is selected, and collects metrics only for the processes it selects. Only all_processes makes it collect every process.
  • process.config.per_process_metrics.all_processes Type: boolean. Optional. Default: false. If true, selects every process, except those that match exclude_matches. The Collector then collects every process each interval. If false, only include_matches and include_checks select processes.
  • process.config.per_process_metrics.include_checks Type: boolean. Optional. Default: false. If true, selects every process that each check in checks counts, including descendants when the check sets include_children. If false, checks don’t select processes for per-process metrics.
  • process.config.per_process_metrics.include_matches Type: array of object. Optional. Default: []. Selects the processes that match any item.
  • process.config.per_process_metrics.include_matches[].command_line Type: object. Optional. Matches the process command line, with arguments joined by single spaces.
  • process.config.per_process_metrics.include_matches[].command_line.match_type Type: string. Optional. Default: strict. strict matches the whole value exactly. regexp matches a regular expression anywhere in the value. Anchor it with ^ and $ to match the whole value. Allowed values: strict, regexp.
  • process.config.per_process_metrics.include_matches[].command_line.values Type: array of string. Required. Minimum items: 1. Values to compare. A process matches when any value matches.
  • process.config.per_process_metrics.include_matches[].executable_name Type: object. Optional. Matches the process name, such as nginx. On Windows, the name includes the .exe extension. On Linux and macOS, a name the kernel truncates to 15 characters is extended from the first command-line argument.
  • process.config.per_process_metrics.include_matches[].executable_name.match_type Type: string. Optional. Default: strict. strict matches the whole value exactly. regexp matches a regular expression anywhere in the value. Anchor it with ^ and $ to match the whole value. Allowed values: strict, regexp.
  • process.config.per_process_metrics.include_matches[].executable_name.values Type: array of string. Required. Minimum items: 1. Values to compare. A process matches when any value matches.
  • process.config.per_process_metrics.include_matches[].executable_path Type: object. Optional. Matches the full path of the process executable. Reading the path of another user’s process on Linux requires the Collector to run as root or with the CAP_SYS_PTRACE capability.
  • process.config.per_process_metrics.include_matches[].executable_path.match_type Type: string. Optional. Default: strict. strict matches the whole value exactly. regexp matches a regular expression anywhere in the value. Anchor it with ^ and $ to match the whole value. Allowed values: strict, regexp.
  • process.config.per_process_metrics.include_matches[].executable_path.values Type: array of string. Required. Minimum items: 1. Values to compare. A process matches when any value matches.
  • process.config.per_process_metrics.include_matches[].owner Type: object. Optional. Matches the user name that owns the process. On Windows, the name has the form DOMAIN\user.
  • process.config.per_process_metrics.include_matches[].owner.match_type Type: string. Optional. Default: strict. strict matches the whole value exactly. regexp matches a regular expression anywhere in the value. Anchor it with ^ and $ to match the whole value. Allowed values: strict, regexp.
  • process.config.per_process_metrics.include_matches[].owner.values Type: array of string. Required. Minimum items: 1. Values to compare. A process matches when any value matches.
  • process.config.per_process_metrics.include_matches[].pid_file Type: string. Optional. Absolute path of a file that holds a process ID. Matches the process with the ID on the first line of the file. The Collector reads the file each interval and must have permission to read it. A missing or unreadable file, a path that isn’t a regular file, a file that doesn’t contain an ID, or an ID with no running process matches no process.
  • process.config.per_process_metrics.exclude_matches Type: array of object. Optional. Default: []. Processes that match any item never get per-process metrics. Exclusions don’t affect check counts, and setting this doesn’t select every other process.
  • process.config.per_process_metrics.exclude_matches[].command_line Type: object. Optional. Matches the process command line, with arguments joined by single spaces.
  • process.config.per_process_metrics.exclude_matches[].command_line.match_type Type: string. Optional. Default: strict. strict matches the whole value exactly. regexp matches a regular expression anywhere in the value. Anchor it with ^ and $ to match the whole value. Allowed values: strict, regexp.
  • process.config.per_process_metrics.exclude_matches[].command_line.values Type: array of string. Required. Minimum items: 1. Values to compare. A process matches when any value matches.
  • process.config.per_process_metrics.exclude_matches[].executable_name Type: object. Optional. Matches the process name, such as nginx. On Windows, the name includes the .exe extension. On Linux and macOS, a name the kernel truncates to 15 characters is extended from the first command-line argument.
  • process.config.per_process_metrics.exclude_matches[].executable_name.match_type Type: string. Optional. Default: strict. strict matches the whole value exactly. regexp matches a regular expression anywhere in the value. Anchor it with ^ and $ to match the whole value. Allowed values: strict, regexp.
  • process.config.per_process_metrics.exclude_matches[].executable_name.values Type: array of string. Required. Minimum items: 1. Values to compare. A process matches when any value matches.
  • process.config.per_process_metrics.exclude_matches[].executable_path Type: object. Optional. Matches the full path of the process executable. Reading the path of another user’s process on Linux requires the Collector to run as root or with the CAP_SYS_PTRACE capability.
  • process.config.per_process_metrics.exclude_matches[].executable_path.match_type Type: string. Optional. Default: strict. strict matches the whole value exactly. regexp matches a regular expression anywhere in the value. Anchor it with ^ and $ to match the whole value. Allowed values: strict, regexp.
  • process.config.per_process_metrics.exclude_matches[].executable_path.values Type: array of string. Required. Minimum items: 1. Values to compare. A process matches when any value matches.
  • process.config.per_process_metrics.exclude_matches[].owner Type: object. Optional. Matches the user name that owns the process. On Windows, the name has the form DOMAIN\user.
  • process.config.per_process_metrics.exclude_matches[].owner.match_type Type: string. Optional. Default: strict. strict matches the whole value exactly. regexp matches a regular expression anywhere in the value. Anchor it with ^ and $ to match the whole value. Allowed values: strict, regexp.
  • process.config.per_process_metrics.exclude_matches[].owner.values Type: array of string. Required. Minimum items: 1. Values to compare. A process matches when any value matches.
  • process.config.per_process_metrics.exclude_matches[].pid_file Type: string. Optional. Absolute path of a file that holds a process ID. Matches the process with the ID on the first line of the file. The Collector reads the file each interval and must have permission to read it. A missing or unreadable file, a path that isn’t a regular file, a file that doesn’t contain an ID, or an ID with no running process matches no process.
  • process.config.per_process_metrics.metrics Type: object. Optional. Default: {}. Turns individual per-process metrics on or off, for example process.disk.operations: {enabled: true}.
  • process.config.per_process_metrics.resource_attributes Type: object. Optional. Default: {}. Turns individual per-process resource attributes on or off. Selectors match a process whether or not its attributes are turned on.
  • process.config.per_process_metrics.mute_process_all_errors Type: boolean. Optional. Default: false. Stops logging every error the Collector encounters while reading a process.
  • process.config.per_process_metrics.mute_process_name_error Type: boolean. Optional. Default: false. Stops logging errors for process names the Collector can’t read.
  • process.config.per_process_metrics.mute_process_exe_error Type: boolean. Optional. Default: false. Stops logging errors for executable paths the Collector can’t read.
  • process.config.per_process_metrics.mute_process_cgroup_error Type: boolean. Optional. Default: false. Stops logging errors for control groups the Collector can’t read.
  • process.config.per_process_metrics.mute_process_io_error Type: boolean. Optional. Stops logging errors for I/O counters the Collector can’t read. When unset, these errors are muted if all_processes is true, and logged otherwise.
  • process.config.per_process_metrics.mute_process_user_error Type: boolean. Optional. Stops logging errors for process owners the Collector can’t read. When unset, these errors are muted if all_processes is true or root_path is set to a path other than /, as on a Kubernetes node, and logged otherwise.
  • process.config.per_process_metrics.scrape_process_delay Type: duration. Optional. Default: 0s. Skips a process until it has been running for this long.
  • process.config.checks_collection_interval Type: duration. Optional. How often the Collector counts the processes for each check. When unset, checks use collection_interval. Set a shorter interval to detect a stopped process sooner without collecting per-process metrics more often.
  • process.config.checks Type: array of object. Optional. Default: []. Named process checks. Every collection interval, the Collector reports the number of processes that match each check as system.process.check.count, including 0 when none match. A process can belong to several checks, so summing the counts across checks can count a process more than once.
  • process.config.checks[].name Type: string. Required. Minimum length: 1. Identifies the check. It becomes the cxdot.process.check attribute on the check’s count. Names must be unique.
  • process.config.checks[].include_children Type: boolean. Optional. Default: false. Also counts every descendant of each matching process.
  • process.config.checks[].command_line Type: object. Optional. Matches the process command line, with arguments joined by single spaces.
  • process.config.checks[].command_line.match_type Type: string. Optional. Default: strict. strict matches the whole value exactly. regexp matches a regular expression anywhere in the value. Anchor it with ^ and $ to match the whole value. Allowed values: strict, regexp.
  • process.config.checks[].command_line.values Type: array of string. Required. Minimum items: 1. Values to compare. A process matches when any value matches.
  • process.config.checks[].executable_name Type: object. Optional. Matches the process name, such as nginx. On Windows, the name includes the .exe extension. On Linux and macOS, a name the kernel truncates to 15 characters is extended from the first command-line argument.
  • process.config.checks[].executable_name.match_type Type: string. Optional. Default: strict. strict matches the whole value exactly. regexp matches a regular expression anywhere in the value. Anchor it with ^ and $ to match the whole value. Allowed values: strict, regexp.
  • process.config.checks[].executable_name.values Type: array of string. Required. Minimum items: 1. Values to compare. A process matches when any value matches.
  • process.config.checks[].executable_path Type: object. Optional. Matches the full path of the process executable. Reading the path of another user’s process on Linux requires the Collector to run as root or with the CAP_SYS_PTRACE capability.
  • process.config.checks[].executable_path.match_type Type: string. Optional. Default: strict. strict matches the whole value exactly. regexp matches a regular expression anywhere in the value. Anchor it with ^ and $ to match the whole value. Allowed values: strict, regexp.
  • process.config.checks[].executable_path.values Type: array of string. Required. Minimum items: 1. Values to compare. A process matches when any value matches.
  • process.config.checks[].owner Type: object. Optional. Matches the user name that owns the process. On Windows, the name has the form DOMAIN\user.
  • process.config.checks[].owner.match_type Type: string. Optional. Default: strict. strict matches the whole value exactly. regexp matches a regular expression anywhere in the value. Anchor it with ^ and $ to match the whole value. Allowed values: strict, regexp.
  • process.config.checks[].owner.values Type: array of string. Required. Minimum items: 1. Values to compare. A process matches when any value matches.
  • process.config.checks[].pid_file Type: string. Optional. Absolute path of a file that holds a process ID. Matches the process with the ID on the first line of the file. The Collector reads the file each interval and must have permission to read it. A missing or unreadable file, a path that isn’t a regular file, a file that doesn’t contain an ID, or an ID with no running process matches no process.