elasticsearch/docs/reference/cluster/nodes-stats.asciidoc

[[cluster-nodes-stats]]
=== Nodes stats API
++++
<titleabbrev>Nodes stats</titleabbrev>
++++

Returns cluster nodes statistics.

[[cluster-nodes-stats-api-request]]
==== {api-request-title}

`GET /_nodes/stats` +

`GET /_nodes/<node_id>/stats` +

`GET/_nodes/stats/<metric>` +

`GET/_nodes/<node_id>/stats/<metric>` +

`GET /_nodes/stats/<metric>/<index_metric>` +

`GET /_nodes/<node_id>/stats/<metric>/<index_metric>`


[[cluster-nodes-stats-api-desc]]
==== {api-description-title}

You can use the cluster nodes stats API to retrieve statistics for nodes in a cluster.


All the nodes selective options are explained <<cluster-nodes,here>>.

By default, all stats are returned. You can limit the returned information by
using metrics.

[[cluster-nodes-stats-api-path-params]]
==== {api-path-parms-title}


`<metric>`::
    (Optional, string) Limits the information returned to the specific metrics.
    A comma-separated list of the following options:
+
--
  `adaptive_selection`::
      Statistics about <<search-adaptive-replica,adaptive replica selection>>.

  `breaker`::
      Statistics about the field data circuit breaker.

  `discovery`::
      Statistics about the discovery.

  `fs`::
      File system information, data path, free disk space, read/write
      stats.

  `http`::
      HTTP connection information.

  `indices`::
      Indices stats about size, document count, indexing and deletion times,
      search times, field cache size, merges and flushes.

  `ingest`::
      Statistics about ingest preprocessing.

  `jvm`::
      JVM stats, memory pool information, garbage collection, buffer
      pools, number of loaded/unloaded classes.

  `os`::
      Operating system stats, load average, mem, swap.

  `process`::
      Process statistics, memory consumption, cpu usage, open
      file descriptors.

  `thread_pool`::
      Statistics about each thread pool, including current size, queue and
      rejected tasks.

  `transport`::
      Transport statistics about sent and received bytes in cluster
      communication.
--

`<index_metric>`::
    (Optional, string) Limit the information returned for `indices` metric to
    the specific index metrics. It can be used only if `indices` (or `all`)
    metric is specified. Supported metrics are:
+
--
    * `completion`
    * `docs`
    * `fielddata`
    * `flush`
    * `get`
    * `indexing`
    * `merge`
    * `query_cache`
    * `recovery`
    * `refresh`
    * `request_cache`
    * `search`
    * `segments`
    * `store`
    * `translog`
    * `warmer`
--

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=node-id]


[[cluster-nodes-stats-api-query-params]]
==== {api-query-parms-title}

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=completion-fields]

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=fielddata-fields]

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=fields]

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=groups]

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=level]

`types`::
    (Optional, string) A comma-separated list of document types for the
    `indexing` index metric.

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=timeoutparms]

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=include-segment-file-sizes]

[role="child_attributes"]
[[cluster-nodes-stats-api-response-body]]
==== {api-response-body-title}

`_nodes`::
(object)
Contains statistics about the number of nodes selected by the request.
+
.Properties of `_nodes`
[%collapsible%open]
====
`total`::
(integer)
Total number of nodes selected by the request.

`successful`::
(integer)
Number of nodes that responded successfully to the request.

`failed`::
(integer)
Number of nodes that rejected the request or failed to respond. If this value
is not `0`, a reason for the rejection or failure is included in the response.
====

`cluster_name`::
(string)
Name of the cluster. Based on the <<cluster.name>> setting.

`nodes`::
(object)
Contains statistics for the nodes selected by the request.
+
.Properties of `nodes`
[%collapsible%open]
====
`<node_id>`::
(object)
Contains statistics for the node.
+
.Properties of `<node_id>`
[%collapsible%open]
=====
`timestamp`::
(integer)
Time the node stats were collected for this response. Recorded in milliseconds
since the https://en.wikipedia.org/wiki/Unix_time[Unix Epoch].

`name`::
(string)
Human-readable identifier for the node. Based on the <<node.name>> setting.

`transport_address`::
(string)
Host and port for the <<modules-transport,transport layer>>, used for internal
communication between nodes in a cluster.

`host`::
(string)
Network host for the node, based on the <<network.host>> setting.

`ip`::
(string)
IP address and port for the node.

`roles`::
(array of strings)
Roles assigned to the node. See <<modules-node>>.

`attributes`::
(object)
Contains a list of attributes for the node.

[[cluster-nodes-stats-api-response-body-indices]]
`indices`::
(object)
Contains statistics about indices with shards assigned to the node.
+
.Properties of `indices`
[%collapsible%open]
======
`docs`::
(object)
Contains statistics about documents across all primary shards assigned to the
node.
+
.Properties of `docs`
[%collapsible%open]
=======
`count`::
(integer)
include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=docs-count]

`deleted`::
(integer)
include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=docs-deleted]
=======

`store`::
(object)
Contains statistics about the size of shards assigned to the node.
+
.Properties of `store`
[%collapsible%open]
=======
`size`::
(<<byte-units,byte value>>)
Total size of all shards assigned to the node.

`size_in_bytes`::
(integer)
Total size, in bytes, of all shards assigned to the node.

`reserved`::
(<<byte-units,byte value>>)
A prediction of how much larger the shard stores on this node will eventually
grow due to ongoing peer recoveries, restoring snapshots, and similar
activities. A value of `-1b` indicates that this is not available.

`reserved_in_bytes`::
(integer)
A prediction, in bytes, of how much larger the shard stores on this node will
eventually grow due to ongoing peer recoveries, restoring snapshots, and
similar activities. A value of `-1` indicates that this is not available.
=======

`indexing`::
(object)
Contains statistics about indexing operations for the node.
+
.Properties of `indexing`
[%collapsible%open]
=======
`index_total`::
(integer)
Total number of indexing operations.

`index_time`::
(<<time-units,time value>>)
Total time spent performing indexing operations.

`index_time_in_millis`::
(integer)
Total time in milliseconds
spent performing indexing operations.

`index_current`::
(integer)
Number of indexing operations currently running.

`index_failed`::
(integer)
Number of failed indexing operations.

`delete_total`::
(integer)
Total number of deletion operations.

`delete_time`::
(<<time-units,time value>>)
Time spent performing deletion operations.

`delete_time_in_millis`::
(integer)
Time in milliseconds
spent performing deletion operations.

`delete_current`::
(integer)
Number of deletion operations currently running.

`noop_update_total`::
(integer)
Total number of noop operations.

`is_throttled`::
(boolean)
Number of times
operations were throttled.

`throttle_time`::
(<<time-units,time value>>)
Total time spent throttling operations.

`throttle_time_in_millis`::
(integer)
Total time in milliseconds
spent throttling operations.
=======

`get`::
(object)
Contains statistics about get operations for the node.
+
.Properties of `get`
[%collapsible%open]
=======
`total`::
(integer)
Total number of get operations.

`getTime`::
(<<time-units,time value>>)
Time spent performing get operations.

`time_in_millis`::
(integer)
Time in milliseconds
spent performing get operations.

`exists_total`::
(integer)
Total number of successful get operations.

`exists_time`::
(<<time-units,time value>>)
Time spent performing successful get operations.

`exists_time_in_millis`::
(integer)
Time in milliseconds
spent performing successful get operations.

`missing_total`::
(integer)
Total number of failed get operations.

`missing_time`::
(<<time-units,time value>>)
Time spent performing failed get operations.

`missing_time_in_millis`::
(integer)
Time in milliseconds
spent performing failed get operations.

`current`::
(integer)
Number of get operations currently running.
=======

`search`::
(object)
Contains statistics about search operations for the node.
+
.Properties of `search`
[%collapsible%open]
=======
`open_contexts`::
(integer)
Number of open search contexts.

`query_total`::
(integer)
Total number of query operations.

`query_time`::
(<<time-units,time value>>)
Time spent performing query operations.

`query_time_in_millis`::
(integer)
Time in milliseconds
spent performing query operations.

`query_current`::
(integer)
Number of query operations currently running.

`fetch_total`::
(integer)
Total number of fetch operations.

`fetch_time`::
(<<time-units,time value>>)
Time spent performing fetch operations.

`fetch_time_in_millis`::
(integer)
Time in milliseconds
spent performing fetch operations.

`fetch_current`::
(integer)
Number of fetch operations currently running.

`scroll_total`::
(integer)
Total number of scroll operations.

`scroll_time`::
(<<time-units,time value>>)
Time spent performing scroll operations.

`scroll_time_in_millis`::
(integer)
Time in milliseconds
spent performing scroll operations.

`scroll_current`::
(integer)
Number of scroll operations currently running.

`suggest_total`::
(integer)
Total number of suggest operations.

`suggest_time`::
(<<time-units,time value>>)
Time spent performing suggest operations.

`suggest_time_in_millis`::
(integer)
Time in milliseconds
spent performing suggest operations.

`suggest_current`::
(integer)
Number of suggest operations currently running.
=======

`merges`::
(object)
Contains statistics about merge operations for the node.
+
.Properties of `merges`
[%collapsible%open]
=======
`current`::
(integer)
Number of merge operations currently running.

`current_docs`::
(integer)
Number of document merges currently running.

`current_size`::
(<<byte-units,byte value>>)
Memory used performing current document merges.

`current_size_in_bytes`::
(integer)
Memory, in bytes, used performing current document merges.

`total`::
(integer)
Total number of merge operations.

`total_time`::
(<<time-units,time value>>)
Total time spent performing merge operations.

`total_time_in_millis`::
(integer)
Total time in milliseconds
spent performing merge operations.

`total_docs`::
(integer)
Total number of merged documents.

`total_size`::
(<<byte-units,byte value>>)
Total size of document merges.

`total_size_in_bytes`::
(integer)
Total size of document merges in bytes.

`total_stopped_time`::
(<<time-units,time value>>)
Total time spent stopping merge operations.

`total_stopped_time_in_millis`::
(integer)
Total time in milliseconds
spent stopping merge operations.

`total_throttled_time`::
(<<time-units,time value>>)
Total time spent throttling merge operations.

`total_throttled_time_in_millis`::
(integer)
Total time in milliseconds
spent throttling merge operations.

`total_auto_throttle`::
(<<byte-units,byte value>>)
Size of automatically throttled merge operations.

`total_auto_throttle_in_bytes`::
(integer)
Size, in bytes, of automatically throttled merge operations.
=======

`refresh`::
(object)
Contains statistics about refresh operations for the node.
+
.Properties of `refresh`
[%collapsible%open]
=======
`total`::
(integer)
Total number of refresh operations.

`total_time`::
(<<time-units,time value>>)
Total time spent performing refresh operations.

`total_time_in_millis`::
(integer)
Total time in milliseconds
spent performing refresh operations.

`external_total`::
(integer)
Total number of external refresh operations.

`external_total_time`::
(<<time-units,time value>>)
Total time spent performing external operations.

`external_total_time_in_millis`::
(integer)
Total time in milliseconds
spent performing external operations.

`listeners`::
(integer)
Number of refresh listeners.
=======

`flush`::
(object)
Contains statistics about flush operations for the node.
+
.Properties of `flush`
[%collapsible%open]
=======
`total`::
(integer)
Number of flush operations.

`periodic`::
(integer)
Number of flush periodic operations.

`total_time`::
(<<time-units,time value>>)
Total time spent performing flush operations.

`total_time_in_millis`::
(integer)
Total time in milliseconds
spent performing flush operations.
=======

`warmer`::
(object)
Contains statistics about index warming operations for the node.
+
.Properties of `warmer`
[%collapsible%open]
=======
`current`::
(integer)
Number of active index warmers.

`total`::
(integer)
Total number of index warmers.

`total_time`::
(<<time-units,time value>>)
Total time spent performing index warming operations.

`total_time_in_millis`::
(integer)
Total time in milliseconds
spent performing index warming operations.
=======

`query_cache`::
(object)
Contains statistics about the query cache across all shards assigned to the
node.
+
.Properties of `query_cache`
[%collapsible%open]
=======
`memory_size`::
(<<byte-units,byte value>>)
Total amount of memory used for the query cache across all shards assigned to
the node.

`memory_size_in_bytes`::
(integer)
Total amount of memory, in bytes, used for the query cache across all shards
assigned to the node.

`total_count`::
(integer)
Total count of hits, misses, and cached queries
in the query cache.

`hit_count`::
(integer)
Number of query cache hits.

`miss_count`::
(integer)
Number of query cache misses.

`cache_size`::
(integer)
Size, in bytes, of the query cache.

`cache_count`::
(integer)
Count of queries
in the query cache.

`evictions`::
(integer)
Number of query cache evictions.
=======

`fielddata`::
(object)
Contains statistics about the field data cache across all shards
assigned to the node.
+
.Properties of `fielddata`
[%collapsible%open]
=======
`memory_size`::
(<<byte-units,byte value>>)
Total amount of memory used for the field data cache across all shards
assigned to the node.

`memory_size_in_bytes`::
(integer)
Total amount of memory, in bytes, used for the field data cache across all
shards assigned to the node.

`evictions`::
(integer)
Number of fielddata evictions.
=======

`completion`::
(object)
Contains statistics about completions across all shards assigned to the node.
+
.Properties of `completion`
[%collapsible%open]
=======
`size`::
(<<byte-units,byte value>>)
Total amount of memory used for completion across all shards assigned to
the node.

`size_in_bytes`::
(integer)
Total amount of memory, in bytes, used for completion across all shards assigned
to the node.
=======

`segments`::
(object)
Contains statistics about segments across all shards assigned to the node.
+
.Properties of `segments`
[%collapsible%open]
=======
`count`::
(integer)
Number of segments.

`memory`::
(<<byte-units,byte value>>)
Total amount of memory used for segments across all shards assigned to the
node.

`memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for segments across all shards assigned
to the node.

`terms_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for terms across all shards assigned to the node.

`terms_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for terms across all shards assigned to
the node.

`stored_fields_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for stored fields across all shards assigned to
the node.

`stored_fields_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for stored fields across all shards
assigned to the node.

`term_vectors_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for term vectors across all shards assigned to
the node.

`term_vectors_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for term vectors across all shards
assigned to the node.

`norms_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for normalization factors across all shards assigned
to the node.

`norms_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for normalization factors across all
shards assigned to the node.

`points_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for points across all shards assigned to the node.

`points_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for points across all shards assigned to
the node.

`doc_values_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for doc values across all shards assigned to
the node.

`doc_values_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for doc values across all shards assigned
to the node.

`index_writer_memory`::
(<<byte-units,byte value>>)
Total amount of memory used by all index writers across all shards assigned to
the node.

`index_writer_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used by all index writers across all shards
assigned to the node.

`version_map_memory`::
(<<byte-units,byte value>>)
Total amount of memory used by all version maps across all shards assigned to
the node.

`version_map_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used by all version maps across all shards
assigned to the node.

`fixed_bit_set`::
(<<byte-units,byte value>>)
Total amount of memory used by fixed bit sets across all shards assigned to
the node.
+
Fixed bit sets are used for nested object field types and
type filters for <<parent-join,join>> fields.

`fixed_bit_set_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used by fixed bit sets across all shards
assigned to the node.
+
Fixed bit sets are used for nested object field types and
type filters for <<parent-join,join>> fields.

`max_unsafe_auto_id_timestamp`::
(integer)
Time of the most recently retried indexing request. Recorded in milliseconds
since the https://en.wikipedia.org/wiki/Unix_time[Unix Epoch].

`file_sizes`::
(object)
Contains statistics about the size of the segment file.
+
.Properties of `file_sizes`
[%collapsible%open]
========
`size`::
(<<byte-units,byte value>>)
Size of the segment file.

`size_in_bytes`::
(integer)
Size, in bytes,
of the segment file.

`description`::
(string)
Description of the segment file.
========
=======

`translog`::
(object)
Contains statistics about transaction log operations for the node.
+
.Properties of `translog`
[%collapsible%open]
=======
`operations`::
(integer)
Number of transaction log operations.

`size`::
(<<byte-units,byte value>>)
Size of the transaction log.

`size_in_bytes`::
(integer)
Size, in bytes, of the transaction log.

`uncommitted_operations`::
(integer)
Number of uncommitted transaction log operations.

`uncommitted_size`::
(<<byte-units,byte value>>)
Size of uncommitted transaction log operations.

`uncommitted_size_in_bytes`::
(integer)
Size, in bytes, of uncommitted transaction log operations.

`earliest_last_modified_age`::
(integer)
Earliest last modified age
for the transaction log.
=======

`request_cache`::
(object)
Contains statistics about the request cache across all shards assigned to the
node.
+
.Properties of `request_cache`
[%collapsible%open]
=======
`memory_size`::
(<<byte-units,byte value>>)
Memory used by the request cache.

`memory_size_in_bytes`::
(integer)
Memory, in bytes, used by the request cache.

`evictions`::
(integer)
Number of request cache operations.

`hit_count`::
(integer)
Number of request cache hits.

`miss_count`::
(integer)
Number of request cache misses.
=======

`recovery`::
(object)
Contains statistics about recovery operations for the node.
+
.Properties of `recovery`
[%collapsible%open]
=======
`current_as_source`::
(integer)
Number of recoveries
that used an index shard as a source.

`current_as_target`::
(integer)
Number of recoveries
that used an index shard as a target.

`throttle_time`::
(<<time-units,time value>>)
Time by which recovery operations were delayed due to throttling.

`throttle_time_in_millis`::
(integer)
Time in milliseconds
recovery operations were delayed due to throttling.
=======
======

[[cluster-nodes-stats-api-response-body-os]]
`os`::
(object)
Contains statistics about the operating system for the node.
+
.Properties of `os`
[%collapsible%open]
======
`timestamp`::
(integer)
Last time the operating system statistics were refreshed. Recorded in
milliseconds since the https://en.wikipedia.org/wiki/Unix_time[Unix Epoch].

`cpu`::
(object)
Contains statistics about CPU usage for the node.
+
.Properties of `cpu`
[%collapsible%open]
=======
`percent`::
(integer)
Recent CPU usage for the whole system, or `-1` if not supported.

`load_average`::
(object)
Contains statistics about load averages on the system.
+
.Properties of `load_average`
[%collapsible%open]
========
`1m`::
(float)
One-minute load average on the system (field is not present if one-minute load
average is not available).

`5m`::
(float)
Five-minute load average on the system (field is not present if five-minute load
average is not available).

`15m`::
(float)
Fifteen-minute load average on the system (field is not present if
fifteen-minute load average is not available).
========
=======

`mem`::
(object)
Contains statistics about memory usage for the node.
+
.Properties of `mem`
[%collapsible%open]
=======
`total`::
(<<byte-units,byte value>>)
Total amount of physical memory.

`total_in_bytes`::
(integer)
Total amount of physical memory in bytes.

`free`::
(<<byte-units,byte value>>)
Amount of free physical memory.

`free_in_bytes`::
(integer)
Amount of free physical memory in bytes.

`used`::
(<<byte-units,byte value>>)
Amount of used physical memory.

`used_in_bytes`::
(integer)
Amount of used physical memory in bytes.

`free_percent`::
(integer)
Percentage of free memory.

`used_percent`::
(integer)
Percentage of used memory.
=======

`swap`::
(object)
Contains statistics about swap space for the node.
+
.Properties of `swap`
[%collapsible%open]
=======
`total`::
(<<byte-units,byte value>>)
Total amount of swap space.

`total_in_bytes`::
(integer)
Total amount of swap space in bytes.

`free`::
(<<byte-units,byte value>>)
Amount of free swap space.

`free_in_bytes`::
(integer)
Amount of free swap space in bytes.

`used`::
(<<byte-units,byte value>>)
Amount of used swap space.

`used_in_bytes`::
(integer)
Amount of used swap space in bytes.
=======

`cgroup` (Linux only)::
(object)
Contains cgroup statistics for the node.
+
NOTE: For the cgroup stats to be visible, cgroups must be compiled into the
kernel, the `cpu` and `cpuacct` cgroup subsystems must be configured and stats
must be readable from `/sys/fs/cgroup/cpu` and `/sys/fs/cgroup/cpuacct`.
+
.Properties of `cgroup`
[%collapsible%open]
=======

`cpuacct` (Linux only)::
(object)
Contains statistics about `cpuacct` control group for the node.
+
.Properties of `cpuacct`
[%collapsible%open]
========
`control_group` (Linux only)::
(string)
The `cpuacct` control group to which the {es} process belongs.

`usage_nanos` (Linux only)::
(integer)
The total CPU time (in nanoseconds) consumed by all tasks in the same cgroup
as the {es} process.
========

`cpu` (Linux only)::
(object)
Contains statistics about `cpu` control group for the node.
+
.Properties of `cpu`
[%collapsible%open]
========
`control_group` (Linux only)::
(string)
The `cpu` control group to which the {es} process belongs.

`cfs_period_micros` (Linux only)::
(integer)
The period of time (in microseconds) for how regularly all tasks in the same
cgroup as the {es} process should have their access to CPU resources
reallocated.

`cfs_quota_micros` (Linux only)::
(integer)
The total amount of time (in microseconds) for which all tasks in
the same cgroup as the {es} process can run during one period
`cfs_period_micros`.

`stat` (Linux only)::
(object)
Contains CPU statistics for the node.
+
.Properties of `stat`
[%collapsible%open]
=========
`number_of_elapsed_periods` (Linux only)::
(integer)
The number of reporting periods (as specified by
`cfs_period_micros`) that have elapsed.

`number_of_times_throttled` (Linux only)::
(integer)
The number of times all tasks in the same cgroup as the {es} process have
been throttled.

`time_throttled_nanos` (Linux only)::
(integer)
The total amount of time (in nanoseconds) for which all tasks in the same
cgroup as the {es} process have been throttled.
=========
========

`memory` (Linux only)::
(object)
Contains statistics about the `memory` control group for the node.
+
.Properties of `memory`
[%collapsible%open]
========
`control_group` (Linux only)::
(string)
The `memory` control group to which the {es} process belongs.

`limit_in_bytes` (Linux only)::
(string)
The maximum amount of user memory (including file cache) allowed for all
tasks in the same cgroup as the {es} process. This value can be too big to
store in a `long`, so is returned as a string so that the value returned can
exactly match what the underlying operating system interface returns. Any
value that is too large to parse into a `long` almost certainly means no
limit has been set for the cgroup.

`usage_in_bytes` (Linux only)::
(string)
The total current memory usage by processes in the cgroup (in bytes) by all
tasks in the same cgroup as the {es} process. This value is stored as a
string for consistency with `limit_in_bytes`.
========
=======
======

[[cluster-nodes-stats-api-response-body-process]]
`process`::
(object)
Contains process statistics for the node.
+
.Properties of `process`
[%collapsible%open]
======
`timestamp`::
(integer)
Last time the statistics were refreshed. Recorded in milliseconds
since the https://en.wikipedia.org/wiki/Unix_time[Unix Epoch].

`open_file_descriptors`::
(integer)
Number of opened file descriptors associated with the current  or
`-1` if not supported.

`max_file_descriptors`::
(integer)
Maximum number of file descriptors allowed on the system, or `-1` if not
supported.

`cpu`::
(object)
Contains CPU statistics for the node.
+
.Properties of `cpu`
[%collapsible%open]
=======
`percent`::
(integer)
CPU usage in percent, or `-1` if not known at the time the stats are
computed.

`total`::
(<<time-units,time value>>)
CPU time used by the process on which the Java virtual machine is running.

`total_in_millis`::
(integer)
CPU time (in milliseconds) used by the process on which the Java virtual
machine is running, or `-1` if not supported.
=======

`mem`::
(object)
Contains virtual memory statistics for the node.
+
.Properties of `mem`
[%collapsible%open]
=======
`total_virtual`::
(<<byte-units,byte value>>)
Size of virtual memory that is guaranteed to be available to the
running process.

`total_virtual_in_bytes`::
(integer)
Size in bytes of virtual memory that is guaranteed to be available to the
running process.
=======
======

[[cluster-nodes-stats-api-response-body-jvm]]
`jvm`::
(object)
Contains Java Virtual Machine (JVM) statistics for the node.
+
.Properties of `jvm`
[%collapsible%open]
======
`timestamp`::
(integer)
Last time JVM statistics were refreshed.

`uptime`::
(<<time-units,time value>>)
JVM uptime.

`uptime_in_millis`::
(integer)
JVM uptime in milliseconds.

`mem`::
(object)
Contains JVM memory usage statistics for the node.
+
.Properties of `mem`
[%collapsible%open]
=======
`heap_used`::
(<<byte-units,byte value>>)
Memory currently in use by the heap.

`heap_used_in_bytes`::
(integer)
Memory, in bytes, currently in use by the heap.

`heap_used_percent`::
(integer)
Percentage of memory currently in use by the heap.

`heap_committed`::
(<<byte-units,byte value>>)
Amount of memory available for use by the heap.

`heap_committed_in_bytes`::
(integer)
Amount of memory, in bytes, available for use by the heap.

`heap_max`::
(<<byte-units,byte value>>)
Maximum amount of memory available for use by the heap.

`heap_max_in_bytes`::
(integer)
Maximum amount of memory, in bytes, available for use by the heap.

`non_heap_used`::
(<<byte-units,byte value>>)
Non-heap memory used.

`non_heap_used_in_bytes`::
(integer)
Non-heap memory used, in bytes.

`non_heap_committed`::
(<<byte-units,byte value>>)
Amount of non-heap memory available.

`non_heap_committed_in_bytes`::
(integer)
Amount of non-heap memory available, in bytes.

`pools`::
(object)
Contains statistics about heap memory usage for the node.
+
.Properties of `pools`
[%collapsible%open]
========

`young`::
(object)
Contains statistics about memory usage by the young generation heap for the
node.
+
.Properties of `young`
[%collapsible%open]
=========
`used`::
(<<byte-units,byte value>>)
Memory used by the young generation heap.

`used_in_bytes`::
(integer)
Memory, in bytes, used by the young generation heap.

`max`::
(<<byte-units,byte value>>)
Maximum amount of memory available for use by the young generation heap.

`max_in_bytes`::
(integer)
Maximum amount of memory, in bytes, available for use by the young generation
heap.

`peak_used`::
(<<byte-units,byte value>>)
Largest amount of memory historically used by the young generation heap.

`peak_used_in_bytes`::
(integer)
Largest amount of memory, in bytes, historically used by the young generation
heap.

`peak_max`::
(<<byte-units,byte value>>)
Largest amount of memory historically used by the young generation heap.

`peak_max_in_bytes`::
(integer)
Largest amount of memory, in bytes, historically used by the young generation
heap.
=========

`survivor`::
(object)
Contains statistics about memory usage by the survivor space for the node.
+
.Properties of `survivor`
[%collapsible%open]
=========
`used`::
(<<byte-units,byte value>>)
Memory used by the survivor space.

`used_in_bytes`::
(integer)
Memory, in bytes, used by the survivor space.

`max`::
(<<byte-units,byte value>>)
Maximum amount of memory available for use by the survivor space.

`max_in_bytes`::
(integer)
Maximum amount of memory, in bytes, available for use by the survivor space.

`peak_used`::
(<<byte-units,byte value>>)
Largest amount of memory historically used by the survivor space.

`peak_used_in_bytes`::
(integer)
Largest amount of memory, in bytes, historically used by the survivor space.

`peak_max`::
(<<byte-units,byte value>>)
Largest amount of memory historically used by the survivor space.

`peak_max_in_bytes`::
(integer)
Largest amount of memory, in bytes, historically used by the survivor space.
=========

`old`::
(object)
Contains statistics about memory usage by the old generation heap for the node.
+
.Properties of `old`
[%collapsible%open]
=========
`used`::
(<<byte-units,byte value>>)
Memory used by the old generation heap.

`used_in_bytes`::
(integer)
Memory, in bytes, used by the old generation heap.

`max`::
(<<byte-units,byte value>>)
Maximum amount of memory available for use by the old generation heap.

`max_in_bytes`::
(integer)
Maximum amount of memory, in bytes, available for use by the old generation
heap.

`peak_used`::
(<<byte-units,byte value>>)
Largest amount of memory historically used by the old generation heap.

`peak_used_in_bytes`::
(integer)
Largest amount of memory, in bytes, historically used by the old generation
heap.

`peak_max`::
(<<byte-units,byte value>>)
Highest memory limit historically available for use by the old generation heap.

`peak_max_in_bytes`::
(integer)
Highest memory limit, in bytes, historically available for use by the old
generation heap.
=========
========
=======

`threads`::
(object)
Contains statistics about JVM thread usage for the node.
+
.Properties of `threads`
[%collapsible%open]
=======
`count`::
(integer)
Number of active threads in use by JVM.

`peak_count`::
(integer)
Highest number of threads used by JVM.
=======

`gc`::
(object)
Contains statistics about JVM garbage collectors for the node.
+
.Properties of `gc`
[%collapsible%open]
=======
`collectors`::
(object)
Contains statistics about JVM garbage collectors for the node.
+
.Properties of `collectors`
[%collapsible%open]
========
`young`::
(object)
Contains statistics about JVM garbage collectors that collect young generation
objects for the node.
+
.Properties of `young`
[%collapsible%open]
=========
`collection_count`::
(integer)
Number of JVM garbage collectors that collect young generation objects.

`collection_time`::
(<<time-units,time value>>)
Total time spent by JVM collecting young generation objects.

`collection_time_in_millis`::
(integer)
Total time in milliseconds spent by JVM collecting young generation objects.
=========

`old`::
(object)
Contains statistics about JVM garbage collectors that collect old generation
objects for the node.
+
.Properties of `old`
[%collapsible%open]
=========
`collection_count`::
(integer)
Number of JVM garbage collectors that collect old generation objects.

`collection_time`::
(<<time-units,time value>>)
Total time spent by JVM collecting old generation objects.

`collection_time_in_millis`::
(integer)
Total time in milliseconds spent by JVM collecting old generation objects.
=========
========
=======

`buffer_pools`::
(object)
Contains statistics about JVM buffer pools for the node.
+
.Properties of `buffer_pools`
[%collapsible%open]
=======
`mapped`::
(object)
Contains statistics about mapped JVM buffer pools for the node.
+
.Properties of `mapped`
[%collapsible%open]
========
`count`::
(integer)
Number of mapped buffer pools.

`used`::
(<<byte-units,byte value>>)
Size of mapped buffer pools.

`used_in_bytes`::
(integer)
Size, in bytes, of mapped buffer pools.

`total_capacity`::
(<<byte-units,byte value>>)
Total capacity of mapped buffer pools.

`total_capacity_in_bytes`::
(integer)
Total capacity, in bytes, of mapped buffer pools.
========

`direct`::
(object)
Contains statistics about direct JVM buffer pools for the node.
+
.Properties of `direct`
[%collapsible%open]
========
`count`::
(integer)
Number of direct buffer pools.

`used`::
(<<byte-units,byte value>>)
Size of direct buffer pools.

`used_in_bytes`::
(integer)
Size, in bytes, of direct buffer pools.

`total_capacity`::
(<<byte-units,byte value>>)
Total capacity of direct buffer pools.

`total_capacity_in_bytes`::
(integer)
Total capacity, in bytes, of direct buffer pools.
========
=======

`classes`::
(object)
Contains statistics about classes loaded by JVM for the node.
+
.Properties of `classes`
[%collapsible%open]
=======
`current_loaded_count`::
(integer)
Number of classes currently loaded by JVM.

`total_loaded_count`::
(integer)
Total number of classes loaded since the JVM started.

`total_unloaded_count`::
(integer)
Total number of classes unloaded since the JVM started.
=======
======

[[cluster-nodes-stats-api-response-body-threadpool]]
`thread_pool`::
(object)
Contains thread pool statistics for the node
+
.Properties of `thread_pool`
[%collapsible%open]
======
`<thread_pool_name>`::
(object)
Contains statistics about the thread pool for the node.
+
.Properties of `<thread_pool_name>`
[%collapsible%open]
=======
`threads`::
(integer)
Number of threads in the thread pool.

`queue`::
(integer)
Number of tasks in queue for the thread pool.

`active`::
(integer)
Number of active threads in the thread pool.

`rejected`::
(integer)
Number of tasks rejected by the thread pool executor.

`largest`::
(integer)
Highest number of active threads in the thread pool.

`completed`::
(integer)
Number of tasks completed by the thread pool executor.
=======
======

[[cluster-nodes-stats-api-response-body-fs]]
`fs`::
(object)
Contains file store statistics for the node.
+
.Properties of `fs`
[%collapsible%open]
======
`timestamp`::
(integer)
Last time the file stores statistics were refreshed. Recorded in
milliseconds since the https://en.wikipedia.org/wiki/Unix_time[Unix Epoch].

`total`::
(object)
Contains statistics for all file stores of the node.
+
.Properties of `total`
[%collapsible%open]
=======
`total`::
(<<byte-units,byte value>>)
Total size of all file stores.

`total_in_bytes`::
(integer)
Total size (in bytes) of all file stores.

`free`::
(<<byte-units,byte value>>)
Total unallocated disk space in all file stores.

`free_in_bytes`::
(integer)
Total number of unallocated bytes in all file stores.

`available`::
(<<byte-units,byte value>>)
Total disk space available to this Java virtual machine on all file
stores. Depending on OS or process level restrictions, this might appear
less than `free`. This is the actual amount of free disk
space the {es} node can utilise.

`available_in_bytes`::
(integer)
Total number of bytes available to this Java virtual machine on all file
stores. Depending on OS or process level restrictions, this might appear
less than `free_in_bytes`. This is the actual amount of free disk
space the {es} node can utilise.
=======

`least_usage_estimate`::
(object)
Contains statistics for the file store with the least estimated usage. See
<<cluster-nodes-stats-fs-data,`fs.data`>> for a list of child parameters.


`most_usage_estimate`::
(object)
Contains statistics for the file store with the most estimated usage. See
<<cluster-nodes-stats-fs-data,`fs.data`>> for a list of child parameters.

[[cluster-nodes-stats-fs-data]]
`data`::
(array of objects)
List of all file stores.
+
.Properties of `data`
[%collapsible%open]
=======
`path`::
(string)
Path to the file store.

`mount`::
(string)
Mount point of the file store (ex: /dev/sda2).
+
NOTE: This parameter is not provided for the `least_usage_estimate` or
`most_usage_estimate` file stores.

`type`::
(string)
Type of the file store (ex: ext4).

`total`::
(<<byte-units,byte value>>)
Total size of the file store.

`total_in_bytes`::
(integer)
Total size (in bytes) of the file store.

`free`::
(<<byte-units,byte value>>)
Total amount of unallocated disk space in the file store.

`free_in_bytes`::
(integer)
Total number of unallocated bytes in the file store.

`available`::
(<<byte-units,byte value>>)
Total amount of disk space available to this Java virtual machine on this file
store.

`available_in_bytes`::
(integer)
Total number of bytes available to this Java virtual machine on this file
store.
=======

`io_stats` (Linux only)::
(objects)
Contains I/O statistics for the node.
+
.Properties of `io_stats`
[%collapsible%open]
=======
`devices` (Linux only)::
(array)
Array of disk metrics for each device that is backing an {es} data path.
These disk metrics are probed periodically and averages between the last
probe and the current probe are computed.
+
.Properties of `devices`
[%collapsible%open]
========
`device_name` (Linux only)::
(string)
The Linux device name.

`operations` (Linux only)::
(integer)
The total number of read and write operations for the device completed since
starting {es}.

`read_operations` (Linux only)::
(integer)
The total number of read operations for the device completed since starting
{es}.

`write_operations` (Linux only)::
(integer)
The total number of write operations for the device completed since starting
{es}.

`read_kilobytes` (Linux only)::
(integer)
The total number of kilobytes read for the device since starting {es}.

`write_kilobytes` (Linux only)::
(integer)
The total number of kilobytes written for the device since starting {es}.
========

`operations` (Linux only)::
    (integer)
    The total number of read and write operations across all devices used by
    {es} completed since starting {es}.

`read_operations` (Linux only)::
    (integer)
    The total number of read operations for across all devices used by {es}
    completed since starting {es}.

`write_operations` (Linux only)::
    (integer)
    The total number of write operations across all devices used by {es}
    completed since starting {es}.

`read_kilobytes` (Linux only)::
    (integer)
    The total number of kilobytes read across all devices used by {es} since
    starting {es}.

`write_kilobytes` (Linux only)::
    (integer)
    The total number of kilobytes written across all devices used by {es} since
    starting {es}.
=======
======

[[cluster-nodes-stats-api-response-body-transport]]
`transport`::
(object)
Contains transport statistics for the node.
+
.Properties of `transport`
[%collapsible%open]
======
`server_open`::
(integer)
Number of open TCP connections used for internal communication between nodes.

`rx_count`::
(integer)
Total number of RX (receive) packets received by the node during internal
cluster communication.

`rx_size`::
(<<byte-units,byte value>>)
Size of RX packets received by the node during internal cluster communication.

`rx_size_in_bytes`::
(integer)
Size, in bytes, of RX packets received by the node during internal cluster
communication.

`tx_count`::
(integer)
Total number of TX (transmit) packets sent by the node during internal cluster
communication.

`tx_size`::
(<<byte-units,byte value>>)
Size of TX packets sent by the node during internal cluster communication.

`tx_size_in_bytes`::
(integer)
Size, in bytes, of TX packets sent by the node during internal cluster
communication.
======

[[cluster-nodes-stats-api-response-body-http]]
`http`::
(object)
Contains http statistics for the node.
+
.Properties of `http`
[%collapsible%open]
======
`current_open`::
(integer)
Current number of open HTTP connections for the node.

`total_opened`::
(integer)
Total number of HTTP connections opened for the node.
======

[[cluster-nodes-stats-api-response-body-breakers]]
`beakers`::
(object)
Contains circuit breaker statistics for the node.
+
.Properties of `breakers`
[%collapsible%open]
======
`<circuit_breaker_name>`::
(object)
Contains statistics for the circuit breaker.
+
.Properties of `<circuit_breaker_name>`
[%collapsible%open]
=======
`limit_size_in_bytes`::
(integer)
Memory limit, in bytes, for the circuit breaker.

`limit_size`::
(<<byte-units,byte value>>)
Memory limit for the circuit breaker.

`estimated_size_in_bytes`::
(integer)
Estimated memory used, in bytes, for the operation.

`estimated_size`::
(<<byte-units,byte value>>)
Estimated memory used for the operation.

`overhead`::
(float)
A constant that all estimates for the circuit breaker are multiplied with to
calculate a final estimate.

`tripped`::
(integer)
Total number of times the circuit breaker has been triggered and prevented an
out of memory error.
=======
======

[[cluster-nodes-stats-api-response-body-script]]
`script`::
(object)
Contains script statistics for the node.
+
.Properties of `script`
[%collapsible%open]
======
`compilations`::
(integer)
Total number of inline script compilations performed by the node.

`cache_evictions`::
(integer)
Total number of times the script cache has evicted old data.

`compilation_limit_triggered`::
(integer)
Total number of times the <<script-compilation-circuit-breaker,script
compilation>> circuit breaker has limited inline script compilations.
======

[[cluster-nodes-stats-api-response-body-discovery]]
`discovery`::
(object)
Contains node discovery statistics for the node.
+
.Properties of `discovery`
[%collapsible%open]
======
`cluster_state_queue`::
(object)
Contains statistics for the cluster state queue of the node.
+
.Properties of `cluster_state_queue`
[%collapsible%open]
=======
`total`::
(integer)
Total number of cluster states in queue.

`pending`::
(integer)
Number of pending cluster states in queue.

`committed`::
(integer)
Number of committed cluster states in queue.
=======

`published_cluster_states`::
(object)
Contains statistics for the published cluster states of the node.
+
.Properties of `published_cluster_states`
[%collapsible%open]
=======
`full_states`::
(integer)
Number of published cluster states.

`incompatible_diffs`::
(integer)
Number of incompatible differences between published cluster states.

`compatible_diffs`::
(integer)
Number of compatible differences between published cluster states.
=======
======

[[cluster-nodes-stats-api-response-body-ingest]]
`ingest`::
(object)
Contains ingest statistics for the node.
+
.Properties of `ingest`
[%collapsible%open]
======
`total`::
(object)
Contains statistics about ingest operations for the node.
+
.Properties of `total`
[%collapsible%open]
=======
`count`::
(integer)
Total number of documents ingested during the lifetime of this node.

`time`::
(<<time-units,time value>>)
Total time spent preprocessing ingest documents during the lifetime of this
node.

`time_in_millis`::
(integer)
Total time, in milliseconds, spent preprocessing ingest documents during the
lifetime of this node.

`current`::
(integer)
Total number of documents currently being ingested.

`failed`::
(integer)
Total number of failed ingest operations during the lifetime of this node.
=======

`pipelines`::
(object)
Contains statistics about ingest pipelines for the node.
+
.Properties of `pipelines`
[%collapsible%open]
=======
`<pipeline_id>`::
(object)
Contains statistics about the ingest pipeline.
+
.Properties of `<pipeline_id>`
[%collapsible%open]
========
`count`::
(integer)
Number of documents preprocessed by the ingest pipeline.

`time`::
(<<time-units,time value>>)
Total time spent preprocessing documents in the ingest pipeline.

`time_in_millis`::
(integer)
Total time, in milliseconds, spent preprocessing documents in the ingest
pipeline.

`failed`::
(integer)
Total number of failed operations for the ingest pipeline.

`processors`::
(array of objects)
Contains statistics for the ingest processors for the ingest pipeline.
+
.Properties of `processors`
[%collapsible%open]
=========
`<processor>`::
(object)
Contains statistics for the ingest processor.
+
.Properties of `<processor>`
[%collapsible%open]
==========
`count`::
(integer)
Number of documents transformed by the processor.

`time`::
(<<time-units,time value>>)
Time spent by the processor transforming documents.

`time_in_millis`::
(integer)
Time, in milliseconds, spent by the processor transforming documents.

`current`::
(integer)
Number of documents currently being transformed by the processor.

`failed`::
(integer)
Number of failed operations for the processor.
==========
=========
========
=======
======

[[cluster-nodes-stats-api-response-body-adaptive-selection]]
`adaptive_selection`::
(object)
Contains adaptive selection statistics for the node.
+
.Properties of `adaptive_selection`
[%collapsible%open]
======
`outgoing_searches`::
(integer)
The number of outstanding search requests from the node these stats are for
to the keyed node.

`avg_queue_size`::
(integer)
The exponentially weighted moving average queue size of search requests on
the keyed node.

`avg_service_time`::
(<<time-units,time value>>)
The exponentially weighted moving average service time of search requests on
the keyed node.

`avg_service_time_ns`::
(integer)
The exponentially weighted moving average service time, in nanoseconds, of
search requests on the keyed node.

`avg_response_time`::
(<<time-units,time value>>)
The exponentially weighted moving average response time of search requests
on the keyed node.

`avg_response_time_ns`::
(integer)
The exponentially weighted moving average response time, in nanoseconds, of
search requests on the keyed node.

`rank`::
(string)
The rank of this node; used for shard selection when routing search
requests.
======
=====
====

[[cluster-nodes-stats-api-example]]
==== {api-examples-title}

[source,console]
--------------------------------------------------
# return just indices
GET /_nodes/stats/indices

# return just os and process
GET /_nodes/stats/os,process

# return just process for node with IP address 10.0.0.1
GET /_nodes/10.0.0.1/stats/process
--------------------------------------------------

All stats can be explicitly requested via `/_nodes/stats/_all` or
`/_nodes/stats?metric=_all`.

You can get information about indices stats on `node`, `indices`, or `shards`
level.

[source,console]
--------------------------------------------------
# Fielddata summarized by node
GET /_nodes/stats/indices/fielddata?fields=field1,field2

# Fielddata summarized by node and index
GET /_nodes/stats/indices/fielddata?level=indices&fields=field1,field2

# Fielddata summarized by node, index, and shard
GET /_nodes/stats/indices/fielddata?level=shards&fields=field1,field2

# You can use wildcards for field names
GET /_nodes/stats/indices/fielddata?fields=field*
--------------------------------------------------

You can get statistics about search groups for searches executed
on this node.

[source,console]
--------------------------------------------------
# All groups with all stats
GET /_nodes/stats?groups=_all

# Some groups from just the indices stats
GET /_nodes/stats/indices?groups=foo,bar
--------------------------------------------------

[[cluster-nodes-stats-ingest-ex]]
===== Retrieve ingest statistics only

To return only ingest-related node statistics, set the `<metric>` path
parameter to `ingest` and use the
<<common-options-response-filtering,`filter_path`>> query parameter.

[source,console]
--------------------------------------------------
GET /_nodes/stats/ingest?filter_path=nodes.*.ingest
--------------------------------------------------

You can use the `metric` and `filter_path` query parameters to get the same
response.

[source,console]
--------------------------------------------------
GET /_nodes/stats?metric=ingest&filter_path=nodes.*.ingest
--------------------------------------------------

To further refine the response, change the `filter_path` value.
For example, the following request only returns ingest pipeline statistics.

[source,console]
--------------------------------------------------
GET /_nodes/stats?metric=ingest&filter_path=nodes.*.ingest.pipelines
--------------------------------------------------