2354 lines
52 KiB
Plaintext
2354 lines
52 KiB
Plaintext
[[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.
|
|
|
|
`indexing_pressure`::
|
|
Statistics about the node's indexing load and related rejections.
|
|
|
|
`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.
|
|
=======
|
|
|
|
[[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).
|
|
|
|
`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)
|
|
Current number of inbound TCP connections used for internal communication between nodes.
|
|
|
|
`total_outbound_connections`::
|
|
(integer)
|
|
The cumulative number of outbound transport connections that this node has
|
|
opened since it started. Each transport connection may comprise multiple TCP
|
|
connections but is only counted once in this statistic. Transport connections
|
|
are typically <<long-lived-connections,long-lived>> so this statistic should
|
|
remain constant in a stable cluster.
|
|
|
|
`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-indexing-pressure]]
|
|
`indexing_pressure`::
|
|
(object)
|
|
Contains <<index-modules-indexing-pressure,indexing pressure>> statistics for the node.
|
|
+
|
|
.Properties of `indexing_pressure`
|
|
[%collapsible%open]
|
|
======
|
|
`memory`::
|
|
(object)
|
|
Contains statistics for memory consumption from indexing load.
|
|
+
|
|
.Properties of `<memory>`
|
|
[%collapsible%open]
|
|
=======
|
|
`current`::
|
|
(object)
|
|
Contains statistics for current indexing load.
|
|
+
|
|
.Properties of `<current>`
|
|
[%collapsible%open]
|
|
========
|
|
`combined_coordinating_and_primary`::
|
|
(<<byte-units,byte value>>)
|
|
Memory consumed by indexing requests in the coordinating or primary stage. This
|
|
value is not the sum of coordinating and primary as a node can reuse the
|
|
coordinating memory if the primary stage is executed locally.
|
|
|
|
`combined_coordinating_and_primary_in_bytes`::
|
|
(integer)
|
|
Memory consumed, in bytes, by indexing requests in the coordinating or primary
|
|
stage. This value is not the sum of coordinating and primary as a node can
|
|
reuse the coordinating memory if the primary stage is executed locally.
|
|
|
|
`coordinating`::
|
|
(<<byte-units,byte value>>)
|
|
Memory consumed by indexing requests in the coordinating stage.
|
|
|
|
`coordinating_in_bytes`::
|
|
(integer)
|
|
Memory consumed, in bytes, by indexing requests in the coordinating stage.
|
|
|
|
`primary`::
|
|
(<<byte-units,byte value>>)
|
|
Memory consumed by indexing requests in the primary stage.
|
|
|
|
`primary_in_bytes`::
|
|
(integer)
|
|
Memory consumed, in bytes, by indexing requests in the primary stage.
|
|
|
|
`replica`::
|
|
(<<byte-units,byte value>>)
|
|
Memory consumed by indexing requests in the replica stage.
|
|
|
|
`replica_in_bytes`::
|
|
(integer)
|
|
Memory consumed, in bytes, by indexing requests in the replica stage.
|
|
|
|
`all`::
|
|
(<<byte-units,byte value>>)
|
|
Memory consumed by indexing requests in the coordinating, primary, or replica stage.
|
|
|
|
`all_in_bytes`::
|
|
(integer)
|
|
Memory consumed, in bytes, by indexing requests in the coordinating, primary,
|
|
or replica stage.
|
|
========
|
|
`total`::
|
|
(object)
|
|
Contains statistics for the cumulative indexing load since the node started.
|
|
+
|
|
.Properties of `<total>`
|
|
[%collapsible%open]
|
|
========
|
|
`combined_coordinating_and_primary`::
|
|
(<<byte-units,byte value>>)
|
|
Memory consumed by indexing requests in the coordinating or primary stage. This
|
|
value is not the sum of coordinating and primary as a node can reuse the
|
|
coordinating memory if the primary stage is executed locally.
|
|
|
|
`combined_coordinating_and_primary_in_bytes`::
|
|
(integer)
|
|
Memory consumed, in bytes, by indexing requests in the coordinating or primary
|
|
stage. This value is not the sum of coordinating and primary as a node can
|
|
reuse the coordinating memory if the primary stage is executed locally.
|
|
|
|
`coordinating`::
|
|
(<<byte-units,byte value>>)
|
|
Memory consumed by indexing requests in the coordinating stage.
|
|
|
|
`coordinating_in_bytes`::
|
|
(integer)
|
|
Memory consumed, in bytes, by indexing requests in the coordinating stage.
|
|
|
|
`primary`::
|
|
(<<byte-units,byte value>>)
|
|
Memory consumed by indexing requests in the primary stage.
|
|
|
|
`primary_in_bytes`::
|
|
(integer)
|
|
Memory consumed, in bytes, by indexing requests in the primary stage.
|
|
|
|
`replica`::
|
|
(<<byte-units,byte value>>)
|
|
Memory consumed by indexing requests in the replica stage.
|
|
|
|
`replica_in_bytes`::
|
|
(integer)
|
|
Memory consumed, in bytes, by indexing requests in the replica stage.
|
|
|
|
`all`::
|
|
(<<byte-units,byte value>>)
|
|
Memory consumed by indexing requests in the coordinating, primary, or replica stage.
|
|
|
|
`all_in_bytes`::
|
|
(integer)
|
|
Memory consumed, in bytes, by indexing requests in the coordinating, primary,
|
|
or replica stage.
|
|
|
|
`coordinating_rejections`::
|
|
(integer)
|
|
Number of indexing requests rejected in the coordinating stage.
|
|
|
|
`primary_rejections`::
|
|
(integer)
|
|
Number of indexing requests rejected in the primary stage.
|
|
|
|
`replica_rejections`::
|
|
(integer)
|
|
Number of indexing requests rejected in the replica stage.
|
|
========
|
|
=======
|
|
======
|
|
|
|
[[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
|
|
--------------------------------------------------
|