Link Search Menu Expand Document Documentation Menu
文档

节点统计

1.0 版引入

节点统计 API 返回有关您的集群的统计信息。

端点

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>

路径参数

下表列出了可用的路径参数。所有路径参数均为可选。

参数 类型 描述
nodeId 字符串 用于筛选结果的 nodeId 逗号分隔列表。支持节点过滤器。默认为 _all。
度量 字符串 响应中包含的度量组的逗号分隔列表。例如，jvm,fs。请参阅以下所有索引度量列表。默认为所有度量。
index_metric 字符串 响应中包含的索引度量组的逗号分隔列表。例如，docs,store。请参阅以下所有索引度量列表。默认为所有索引度量。

下表列出了所有可用的度量组。

度量 描述
索引 索引统计信息，例如文档的大小、文档计数以及搜索、索引和删除时间。
操作系统 关于宿主操作系统的统计信息，包括负载、内存和交换。
进程 关于进程的统计信息，包括其内存消耗、打开文件描述符和 CPU 使用情况。
JVM 关于 JVM 的统计信息，包括内存池、缓冲区池和垃圾回收，以及已加载类的数量。
thread_pool 关于节点的每个线程池的统计信息。
文件系统 文件系统统计信息，例如读/写统计信息、数据路径和可用磁盘空间。
transport 集群内部通信中发送/接收的传输层统计信息。
http 关于 HTTP 层的统计信息。
breaker 关于字段数据断路器的统计信息。
script（脚本） 关于脚本的统计信息，例如编译和缓存逐出。
discovery 关于集群状态的统计信息。
摄取 关于摄取管道的统计信息。
adaptive_selection 关于自适应副本选择的统计信息，它使用分片分配感知选择合格节点。
script_cache 关于脚本缓存的统计信息。
indexing_pressure 关于节点索引压力的统计信息。
shard_indexing_pressure 关于分片索引压力的统计信息。
search_backpressure 与搜索反压相关的统计信息。
cluster_manager_throttling 与集群管理器节点上受限任务相关的统计信息。
weighted_routing 与加权轮询请求相关的统计信息。
resource_usage_stats 节点级别的资源使用统计信息，例如 CPU 和 JVM 内存。
admission_control 关于准入控制的统计信息。
caches 关于缓存的统计信息。

要筛选 indices 度量返回的信息，可以使用特定的 index_metric 值。这些值只能在以下查询类型中使用：

GET _nodes/stats/
GET _nodes/stats/_all
GET _nodes/stats/indices

支持以下索引指标：

  • docs
  • 存储
  • indexing
  • 获取
  • search
  • merge
  • refresh
  • flush
  • warmer
  • 查询缓存
  • fielddata
  • completion
  • 段
  • 事务日志
  • request_cache

例如，以下查询请求 docs 和 search 的统计信息：

GET _nodes/stats/indices/docs,search

您还可以在 caches 度量中使用特定的 index_metric 值来指定哪些缓存将返回统计信息。支持以下索引度量：

  • request_cache

例如，以下查询请求 request_cache 的统计信息：

GET _nodes/stats/caches/request_cache

查询参数

下表列出了可用的查询参数。所有查询参数都是可选的。

参数 类型 描述
completion_fields 字符串 要包含在完成统计信息中的字段。支持逗号分隔列表和通配符表达式。
fielddata_fields 字符串 要包含在字段数据统计信息中的字段。支持逗号分隔列表和通配符表达式。
fields 字符串 要包含的字段。支持逗号分隔列表和通配符表达式。
groups 字符串 包含在搜索统计信息中的搜索组的逗号分隔列表。
level 字符串 指定 indices 度量的统计信息是按集群、索引还是分片级别聚合。有效值为 indices、node 和 shard。当用于 caches 度量时，有效值为 indices、shard 和 tier。如果未使用分层溢出缓存，则 tier 值将被忽略。
timeout 时间 设置节点响应的时间限制。默认为 30s。
include_segment_file_sizes 布尔型 如果请求段统计信息，此字段指定返回每个 Lucene 索引文件的聚合磁盘使用情况。默认为 false。

请求示例

GET _nodes/stats/

示例响应

选择箭头以查看示例响应。

响应 
{
  "_nodes" : {
    "total" : 1,
    "successful" : 1,
    "failed" : 0
  },
  "cluster_name" : "docker-cluster",
  "nodes" : {
    "F-ByTQzVQ3GQeYzQJArJGQ" : {
      "timestamp" : 1664484195257,
      "name" : "opensearch",
      "transport_address" : "127.0.0.1:9300",
      "host" : "127.0.0.1",
      "ip" : "127.0.0.1:9300",
      "roles" : [
        "cluster_manager",
        "data",
        "ingest",
        "remote_cluster_client"
      ],
      "attributes" : {
        "shard_indexing_pressure_enabled" : "true"
      },
      "indices" : {
        "docs" : {
          "count" : 13160,
          "deleted" : 12
        },
        "store" : {
          "size_in_bytes" : 6263461,
          "reserved_in_bytes" : 0
        },
        "indexing" : {
          "index_total" : 0,
          "index_time_in_millis" : 0,
          "index_current" : 0,
          "index_failed" : 0,
          "delete_total" : 204,
          "delete_time_in_millis" : 427,
          "delete_current" : 0,
          "noop_update_total" : 0,
          "is_throttled" : false,
          "throttle_time_in_millis" : 0
        },
        "get" : {
          "total" : 4,
          "time_in_millis" : 18,
          "exists_total" : 4,
          "exists_time_in_millis" : 18,
          "missing_total" : 0,
          "missing_time_in_millis" : 0,
          "current" : 0
        },
        "search" : {
          "open_contexts": 4,
          "query_total": 194,
          "query_time_in_millis": 467,
          "query_current": 0,
          "fetch_total": 194,
          "fetch_time_in_millis": 143,
          "fetch_current": 0,
          "scroll_total": 0,
          "scroll_time_in_millis": 0,
          "scroll_current": 0,
          "point_in_time_total": 0,
          "point_in_time_time_in_millis": 0,
          "point_in_time_current": 0,
          "suggest_total": 0,
          "suggest_time_in_millis": 0,
          "suggest_current": 0,
          "search_idle_reactivate_count_total": 0,
          "request" : {
            "dfs_pre_query" : {
              "time_in_millis" : 0,
              "current" : 0,
              "total" : 0
            },
            "query" : {
              "time_in_millis" : 200,
              "current" : 2,
              "total" : 12
            },
            "fetch" : {
              "time_in_millis" : 37,
              "current" : 3,
              "total" : 4
            },
            "dfs_query" : {
              "time_in_millis" : 0,
              "current" : 0,
              "total" : 0
            },
            "expand" : {
              "time_in_millis" : 9,
              "current" : 1,
              "total" : 0
            },
            "can_match" : {
              "time_in_millis" : 0,
              "current" : 0,
              "total" : 0
            }
          }
        },
        "merges" : {
          "current" : 0,
          "current_docs" : 0,
          "current_size_in_bytes" : 0,
          "total" : 1,
          "total_time_in_millis" : 5,
          "total_docs" : 12,
          "total_size_in_bytes" : 3967,
          "total_stopped_time_in_millis" : 0,
          "total_throttled_time_in_millis" : 0,
          "total_auto_throttle_in_bytes" : 251658240
        },
        "refresh" : {
          "total" : 74,
          "total_time_in_millis" : 201,
          "external_total" : 57,
          "external_total_time_in_millis" : 314,
          "listeners" : 0
        },
        "flush" : {
          "total" : 28,
          "periodic" : 28,
          "total_time_in_millis" : 1261
        },
        "warmer" : {
          "current" : 0,
          "total" : 45,
          "total_time_in_millis" : 99
        },
        "query_cache" : {
          "memory_size_in_bytes" : 0,
          "total_count" : 0,
          "hit_count" : 0,
          "miss_count" : 0,
          "cache_size" : 0,
          "cache_count" : 0,
          "evictions" : 0
        },
        "fielddata" : {
          "memory_size_in_bytes" : 356,
          "evictions" : 0
        },
        "completion" : {
          "size_in_bytes" : 0,
          "fields" : { }
        },
        "segments" : {
          "count" : 17,
          "memory_in_bytes" : 0,
          "terms_memory_in_bytes" : 0,
          "stored_fields_memory_in_bytes" : 0,
          "term_vectors_memory_in_bytes" : 0,
          "norms_memory_in_bytes" : 0,
          "points_memory_in_bytes" : 0,
          "doc_values_memory_in_bytes" : 0,
          "index_writer_memory_in_bytes" : 0,
          "version_map_memory_in_bytes" : 0,
          "fixed_bit_set_memory_in_bytes" : 288,
          "max_unsafe_auto_id_timestamp" : -1,
          "remote_store" : {
            "upload" : {
              "total_upload_size" : {
                "started_bytes" : 152419,
                "succeeded_bytes" : 152419,
                "failed_bytes" : 0
              },
              "refresh_size_lag" : {
                "total_bytes" : 0,
                "max_bytes" : 0
              },
              "max_refresh_time_lag_in_millis" : 0,
              "total_time_spent_in_millis" : 516,
              "pressure" : {
                "total_rejections" : 0
              }
            },
            "download" : {
              "total_download_size" : {
                "started_bytes" : 0,
                "succeeded_bytes" : 0,
                "failed_bytes" : 0
              },
              "total_time_spent_in_millis" : 0
            }
          },
          "file_sizes" : { }
        },
        "translog" : {
          "operations" : 12,
          "size_in_bytes" : 1452,
          "uncommitted_operations" : 12,
          "uncommitted_size_in_bytes" : 1452,
          "earliest_last_modified_age" : 164160,
          "remote_store" : {
            "upload" : {
              "total_uploads" : {
                "started" : 57,
                "failed" : 0,
                "succeeded" : 57
              },
              "total_upload_size" : {
                "started_bytes" : 16830,
                "failed_bytes" : 0,
                "succeeded_bytes" : 16830
              }
            }
          }
        },
        "request_cache" : {
          "memory_size_in_bytes" : 1649,
          "evictions" : 0,
          "hit_count" : 0,
          "miss_count" : 18
        },
        "recovery" : {
          "current_as_source" : 0,
          "current_as_target" : 0,
          "throttle_time_in_millis" : 0
        }
      },
      "os" : {
        "timestamp" : 1664484195263,
        "cpu" : {
          "percent" : 0,
          "load_average" : {
            "1m" : 0.0,
            "5m" : 0.0,
            "15m" : 0.0
          }
        },
        "mem" : {
          "total_in_bytes" : 13137076224,
          "free_in_bytes" : 9265442816,
          "used_in_bytes" : 3871633408,
          "free_percent" : 71,
          "used_percent" : 29
        },
        "swap" : {
          "total_in_bytes" : 4294967296,
          "free_in_bytes" : 4294967296,
          "used_in_bytes" : 0
        },
        "cgroup" : {
          "cpuacct" : {
            "control_group" : "/",
            "usage_nanos" : 338710071600
          },
          "cpu" : {
            "control_group" : "/",
            "cfs_period_micros" : 100000,
            "cfs_quota_micros" : -1,
            "stat" : {
              "number_of_elapsed_periods" : 0,
              "number_of_times_throttled" : 0,
              "time_throttled_nanos" : 0
            }
          },
          "memory" : {
            "control_group" : "/",
            "limit_in_bytes" : "9223372036854771712",
            "usage_in_bytes" : "1432346624"
          }
        }
      },
      "process" : {
        "timestamp" : 1664484195263,
        "open_file_descriptors" : 556,
        "max_file_descriptors" : 65536,
        "cpu" : {
          "percent" : 0,
          "total_in_millis" : 170870
        },
        "mem" : {
          "total_virtual_in_bytes" : 6563344384
        }
      },
      "jvm" : {
        "timestamp" : 1664484195264,
        "uptime_in_millis" : 21232111,
        "mem" : {
          "heap_used_in_bytes" : 308650480,
          "heap_used_percent" : 57,
          "heap_committed_in_bytes" : 536870912,
          "heap_max_in_bytes" : 536870912,
          "non_heap_used_in_bytes" : 147657128,
          "non_heap_committed_in_bytes" : 152502272,
          "pools" : {
            "young" : {
              "used_in_bytes" : 223346688,
              "max_in_bytes" : 0,
              "peak_used_in_bytes" : 318767104,
              "peak_max_in_bytes" : 0,
              "last_gc_stats" : {
                "used_in_bytes" : 0,
                "max_in_bytes" : 0,
                "usage_percent" : -1
              }
            },
            "old" : {
              "used_in_bytes" : 67068928,
              "max_in_bytes" : 536870912,
              "peak_used_in_bytes" : 67068928,
              "peak_max_in_bytes" : 536870912,
              "last_gc_stats" : {
                "used_in_bytes" : 34655744,
                "max_in_bytes" : 536870912,
                "usage_percent" : 6
              }
            },
            "survivor" : {
              "used_in_bytes" : 18234864,
              "max_in_bytes" : 0,
              "peak_used_in_bytes" : 32721280,
              "peak_max_in_bytes" : 0,
              "last_gc_stats" : {
                "used_in_bytes" : 18234864,
                "max_in_bytes" : 0,
                "usage_percent" : -1
              }
            }
          }
        },
        "threads" : {
          "count" : 80,
          "peak_count" : 80
        },
        "gc" : {
          "collectors" : {
            "young" : {
              "collection_count" : 18,
              "collection_time_in_millis" : 199
            },
            "old" : {
              "collection_count" : 0,
              "collection_time_in_millis" : 0
            }
          }
        },
        "buffer_pools" : {
          "mapped" : {
            "count" : 23,
            "used_in_bytes" : 6232113,
            "total_capacity_in_bytes" : 6232113
          },
          "direct" : {
            "count" : 63,
            "used_in_bytes" : 9050069,
            "total_capacity_in_bytes" : 9050068
          },
          "mapped - 'non-volatile memory'" : {
            "count" : 0,
            "used_in_bytes" : 0,
            "total_capacity_in_bytes" : 0
          }
        },
        "classes" : {
          "current_loaded_count" : 20693,
          "total_loaded_count" : 20693,
          "total_unloaded_count" : 0
        }
      },
      "thread_pool" : {
        "OPENSEARCH_ML_TASK_THREAD_POOL" : {
          "threads" : 0,
          "queue" : 0,
          "active" : 0,
          "rejected" : 0,
          "largest" : 0,
          "completed" : 0
        },
        "ad-batch-task-threadpool" : {
          "threads" : 0,
          "queue" : 0,
          "active" : 0,
          "rejected" : 0,
          "largest" : 0,
          "completed" : 0
        },
        ...
      },
      "fs" : {
        "timestamp" : 1664484195264,
        "total" : {
          "total_in_bytes" : 269490393088,
          "free_in_bytes" : 261251477504,
          "available_in_bytes" : 247490805760
        },
        "data" : [
          {
            "path" : "/usr/share/opensearch/data/nodes/0",
            "mount" : "/ (overlay)",
            "type" : "overlay",
            "total_in_bytes" : 269490393088,
            "free_in_bytes" : 261251477504,
            "available_in_bytes" : 247490805760
          }
        ],
        "io_stats" : { }
      },
      "transport" : {
        "server_open" : 0,
        "total_outbound_connections" : 0,
        "rx_count" : 0,
        "rx_size_in_bytes" : 0,
        "tx_count" : 0,
        "tx_size_in_bytes" : 0
      },
      "http" : {
        "current_open" : 5,
        "total_opened" : 1108
      },
      "breakers" : {
        "request" : {
          "limit_size_in_bytes" : 322122547,
          "limit_size" : "307.1mb",
          "estimated_size_in_bytes" : 0,
          "estimated_size" : "0b",
          "overhead" : 1.0,
          "tripped" : 0
        },
        "fielddata" : {
          "limit_size_in_bytes" : 214748364,
          "limit_size" : "204.7mb",
          "estimated_size_in_bytes" : 356,
          "estimated_size" : "356b",
          "overhead" : 1.03,
          "tripped" : 0
        },
        "in_flight_requests" : {
          "limit_size_in_bytes" : 536870912,
          "limit_size" : "512mb",
          "estimated_size_in_bytes" : 0,
          "estimated_size" : "0b",
          "overhead" : 2.0,
          "tripped" : 0
        },
        "parent" : {
          "limit_size_in_bytes" : 510027366,
          "limit_size" : "486.3mb",
          "estimated_size_in_bytes" : 308650480,
          "estimated_size" : "294.3mb",
          "overhead" : 1.0,
          "tripped" : 0
        }
      },
      "script" : {
        "compilations" : 0,
        "cache_evictions" : 0,
        "compilation_limit_triggered" : 0
      },
      "discovery" : {
        "cluster_state_queue" : {
          "total" : 0,
          "pending" : 0,
          "committed" : 0
        },
        "published_cluster_states" : {
          "full_states" : 2,
          "incompatible_diffs" : 0,
          "compatible_diffs" : 10
        },
        "cluster_state_stats" : {
          "overall" : {
            "update_count" : 9,
            "total_time_in_millis" : 807,
            "failed_count" : 0
          },
          "remote_upload" : {
            "success_count" : 9,
            "failed_count" : 0,
            "total_time_in_millis" : 116,
            "cleanup_attempt_failed_count" : 0
          }
        }
      },
      "ingest" : {
        "total" : {
          "count" : 0,
          "time_in_millis" : 0,
          "current" : 0,
          "failed" : 0
        },
        "pipelines" : { }
      },
      "search_pipeline" : {
        "total_request" : {
          "count" : 5,
          "time_in_millis" : 158,
          "current" : 0,
          "failed" : 0
        },
        "total_response" : {
          "count" : 2,
          "time_in_millis" : 1,
          "current" : 0,
          "failed" : 0
        },
        "pipelines" : {
          "public_info" : {
            "request" : {
              "count" : 3,
              "time_in_millis" : 71,
              "current" : 0,
              "failed" : 0
            },
            "response" : {
              "count" : 0,
              "time_in_millis" : 0,
              "current" : 0,
              "failed" : 0
            },
            "request_processors" : [
              {
                "filter_query:abc" : {
                  "type" : "filter_query",
                  "stats" : {
                    "count" : 1,
                    "time_in_millis" : 0,
                    "current" : 0,
                    "failed" : 0
                  }
                }
              },
            ]
              ...
            "response_processors" : [
              {
                "rename_field" : {
                  "type" : "rename_field",
                  "stats" : {
                    "count" : 2,
                    "time_in_millis" : 1,
                    "current" : 0,
                    "failed" : 0
                  }
                }
              }
            ]
          },
          ...
        }
      },
      "adaptive_selection" : {
        "F-ByTQzVQ3GQeYzQJArJGQ" : {
          "outgoing_searches" : 0,
          "avg_queue_size" : 0,
          "avg_service_time_ns" : 501024,
          "avg_response_time_ns" : 794105,
          "rank" : "0.8"
        }
      },
      "script_cache" : {
        "sum" : {
          "compilations" : 0,
          "cache_evictions" : 0,
          "compilation_limit_triggered" : 0
        },
        "contexts" : [
          {
            "context" : "aggregation_selector",
            "compilations" : 0,
            "cache_evictions" : 0,
            "compilation_limit_triggered" : 0
          },
          {
            "context" : "aggs",
            "compilations" : 0,
            "cache_evictions" : 0,
            "compilation_limit_triggered" : 0
          },
          ...
        ]
      },
      "indexing_pressure" : {
        "memory" : {
          "current" : {
            "combined_coordinating_and_primary_in_bytes" : 0,
            "coordinating_in_bytes" : 0,
            "primary_in_bytes" : 0,
            "replica_in_bytes" : 0,
            "all_in_bytes" : 0
          },
          "total" : {
            "combined_coordinating_and_primary_in_bytes" : 40256,
            "coordinating_in_bytes" : 40256,
            "primary_in_bytes" : 45016,
            "replica_in_bytes" : 0,
            "all_in_bytes" : 40256,
            "coordinating_rejections" : 0,
            "primary_rejections" : 0,
            "replica_rejections" : 0
          },
          "limit_in_bytes" : 53687091
        }
      },
      "shard_indexing_pressure" : {
        "stats" : { },
        "total_rejections_breakup_shadow_mode" : {
          "node_limits" : 0,
          "no_successful_request_limits" : 0,
          "throughput_degradation_limits" : 0
        },
        "enabled" : false,
        "enforced" : false
      },
      "resource_usage_stats": {
        "nxLWtMdXQmWA-ZBVWU8nwA": {
          "timestamp": 1698401391000,
          "cpu_utilization_percent": "0.1",
          "memory_utilization_percent": "3.9",
          "io_usage_stats": {
            "max_io_utilization_percent": "99.6"
          }
        }
      },
      "admission_control": {
        "global_cpu_usage": {
          "transport": {
            "rejection_count": {
              "search": 3,
              "indexing": 1
            }
          }
        },
        "global_io_usage": {
          "transport": {
            "rejection_count": {
              "search": 3,
              "indexing": 1
            }
          }
        }
      },
      "caches" : {
        "request_cache" : {
          "size_in_bytes" : 1649,
          "evictions" : 0,
          "hit_count" : 0,
          "miss_count" : 18,
          "item_count" : 18,
          "store_name" : "opensearch_onheap"
        }
      }
    }
  }
}

响应正文字段

下表列出了所有响应字段。

字段 数据类型 描述
_nodes 对象 返回的节点统计信息。
_nodes.total 整数 此请求的总节点数。
_nodes.successful 整数 请求成功的节点数。
_nodes.failed 整数 请求失败的节点数。如果存在请求失败的节点，则包含失败消息。
集群名称 字符串 集群的名称。
节点 对象 此请求中包含的节点的统计信息。

节点

nodes 对象包含请求返回的所有节点及其 ID。每个节点都有以下属性。

字段 数据类型 描述
时间戳 整数 收集节点统计信息的时间，以自 epoch 以来的毫秒为单位。
名称 字符串 节点的名称。
transport_address IP 地址 集群中节点用于内部通信的传输层的主机和端口。
host IP 地址 节点的网络主机。
ip IP 地址 节点的 IP 地址和端口。
roles 数组 节点的角色（例如，cluster_manager、data 或 ingest）。
attributes 对象 节点的属性（例如，shard_indexing_pressure_enabled）。
索引 对象 节点上具有分片的每个索引的索引统计信息。
操作系统 对象 节点的操作系统统计信息。
进程 对象 节点的进程统计信息。
JVM 对象 节点的 JVM 统计信息。
thread_pool 对象 关于节点的每个线程池的统计信息。
文件系统 对象 节点的存储文件系统统计信息。
transport 对象 节点的传输统计信息。
http 对象 节点的 HTTP 统计信息。
http.current_open 整数 节点当前打开的 HTTP 连接数。
http.total_opened 整数 节点自启动以来打开的 HTTP 连接总数。
breakers 对象 节点的断路器统计信息。
script（脚本） 对象 节点的脚本统计信息。
script_cache 对象 节点的脚本缓存统计信息。
discovery 对象 节点的节点发现统计信息。
摄取 对象 节点的摄取统计信息。
search_pipeline 对象 与搜索管道相关的统计信息。
adaptive_selection 对象 关于节点自适应选择的统计信息。
indexing_pressure 对象 与节点索引压力相关的统计信息。
shard_indexing_pressure 对象 与分片级别索引压力相关的统计信息。
search_backpressure 对象 与搜索反压相关的统计信息。
cluster_manager_throttling 对象 与集群管理器节点上受限任务相关的统计信息。
weighted_routing 对象 与加权轮询请求相关的统计信息。
resource_usage_stats 对象 与节点资源使用情况相关的统计信息。
admission_control 对象 与节点准入控制相关的统计信息。
caches 对象 与节点缓存相关的统计信息。

索引

indices 对象包含此节点上具有分片的每个索引的索引统计信息。每个索引都具有以下属性。

字段 字段类型 描述
docs 对象 节点上所有主分片的文档统计信息。
docs.count 整数 Lucene 报告的文档数量。不包括已删除的文档和尚未分配给段的最近索引的文档。嵌套文档单独计数。
docs.deleted 整数 Lucene 报告的已删除文档数量。不包括尚未影响段的最新删除操作。
存储 对象 关于节点上分片大小的统计信息。
store.size_in_bytes 整数 节点上所有分片的总大小。
store.reserved_in_bytes 整数 由于恢复快照和对等恢复等活动，分片存储将增长到的预测字节数。
indexing 对象 关于节点索引操作的统计信息。
indexing.index_total 整数 节点上的索引操作总数。
indexing.index_time_in_millis 整数 所有索引操作的总时间，以毫秒为单位。
indexing.index_current 整数 当前正在运行的索引操作数。
indexing.index_failed 整数 失败的索引操作数。
indexing.delete_total 整数 删除总数。
indexing.delete_time_in_millis 整数 所有删除操作的总时间，以毫秒为单位。
indexing.delete_current 整数 当前正在运行的删除操作数。
indexing.noop_update_total 整数 空操作的总数。
indexing.is_throttled 布尔型 指定是否有任何操作被限制。
indexing.throttle_time_in_millis 整数 限制操作的总时间，以毫秒为单位。
获取 对象 关于节点获取操作的统计信息。
get.total 整数 获取操作总数。
get.time_in_millis 整数 所有获取操作的总时间，以毫秒为单位。
get.exists_total 整数 成功获取操作的总数。
get.exists_time_in_millis 整数 所有成功获取操作的总时间，以毫秒为单位。
get.missing_total 整数 失败获取操作的数量。
get.missing_time_in_millis 整数 所有失败获取操作的总时间，以毫秒为单位。
get.current 整数 当前正在运行的获取操作数。
search 对象 关于节点搜索操作的统计信息。
search.concurrent_avg_slice_count 整数 所有搜索请求的平均切片计数。计算方法是总切片数除以并发搜索请求的总数。
search.concurrent_query_total 整数 使用并发段搜索的查询操作总数。
search.concurrent_query_time_in_millis 整数 使用并发段搜索的所有查询操作所花费的总时间，以毫秒为单位。
search.concurrent_query_current 整数 当前正在运行的使用并发段搜索的查询操作数。
search.open_contexts 整数 开放搜索上下文的数量。
search.query_total 整数 分片查询操作的总数。
search.query_time_in_millis 整数 所有分片查询操作的总时间，以毫秒为单位。
search.query_current 整数 当前正在运行的分片查询操作数。
search.fetch_total 整数 分片获取操作的总数。
search.fetch_time_in_millis 整数 所有分片获取操作的总时间，以毫秒为单位。
search.fetch_current 整数 当前正在运行的分片获取操作数。
search.scroll_total 整数 分片滚动操作的总数。
search.scroll_time_in_millis 整数 所有分片滚动操作的总时间，以毫秒为单位。
search.scroll_current 整数 当前正在运行的分片滚动操作数。
search.point_in_time_total 整数 自节点上次重启以来已创建（已完成和活动）的分片时间点 (PIT) 上下文总数。
search.point_in_time_time_in_millis 整数 自节点上次重启以来，分片 PIT 上下文保持打开状态的时间量，以毫秒为单位。
search.point_in_time_current 整数 当前打开的分片 PIT 上下文数。
search.suggest_total 整数 分片建议操作的总数。
search.suggest_time_in_millis 整数 所有分片建议操作的总时间，以毫秒为单位。
search.suggest_current 整数 当前正在运行的分片建议操作数。
search.search_idle_reactivate_count_total 整数 所有分片从空闲状态激活的总次数。
search.request 对象 关于节点协调器搜索操作的统计信息。
search.request.took.time_in_millis 整数 所有搜索请求所花费的总时间，以毫秒为单位。
search.request.took.current 整数 当前正在运行的搜索请求数。
search.request.took.total 整数 已完成的搜索请求总数。
search.request.dfs_pre_query.time_in_millis 整数 所有协调器深度优先搜索 (DFS) 预查询操作的总时间，以毫秒为单位。
search.request.dfs_pre_query.current 整数 当前正在运行的协调器 DFS 预查询操作数。
search.request.dfs_pre_query.total 整数 已完成的协调器 DFS 预查询操作总数。
search.request.query.time_in_millis 整数 所有协调器查询操作的总时间，以毫秒为单位。
search.request.query.current 整数 当前正在运行的协调器查询操作数。
search.request.query.total 整数 已完成的协调器查询操作总数。
search.request.fetch.time_in_millis 整数 所有协调器获取操作的总时间，以毫秒为单位。
search.request.fetch.current 整数 当前正在运行的协调器获取操作数。
search.request.fetch.total 整数 已完成的协调器获取操作总数。
search.request.dfs_query.time_in_millis 整数 所有协调器 DFS 预查询操作的总时间，以毫秒为单位。
search.request.dfs_query.current 整数 当前正在运行的协调器 DFS 预查询操作数。
search.request.dfs_query.total 整数 已完成的协调器 DFS 预查询操作总数。
search.request.expand.time_in_millis 整数 所有协调器扩展操作的总时间，以毫秒为单位。
search.request.expand.current 整数 当前正在运行的协调器扩展操作数。
search.request.expand.total 整数 已完成的协调器扩展操作总数。
search.request.can_match.time_in_millis 整数 所有协调器匹配操作的总时间，以毫秒为单位。
search.request.can_match.current 整数 当前正在运行的协调器匹配操作数。
search.request.can_match.total 整数 已完成的协调器匹配操作总数。
merges 对象 关于节点合并操作的统计信息。
merges.current 整数 当前正在运行的合并操作数。
merges.current_docs 整数 当前正在运行的文档合并数。
merges.current_size_in_bytes 整数 用于执行当前合并操作的内存大小，以字节为单位。
merges.total 整数 合并操作的总数。
merges.total_time_in_millis 整数 合并总时间，以毫秒为单位。
merges.total_docs 整数 已合并的文档总数。
merges.total_size_in_bytes 整数 所有已合并文档的总大小，以字节为单位。
merges.total_stopped_time_in_millis 整数 停止合并操作所花费的总时间，以毫秒为单位。
merges.total_throttled_time_in_millis 整数 限制合并操作所花费的总时间，以毫秒为单位。
merges.total_auto_throttle_in_bytes 整数 自动限制合并操作的总大小，以字节为单位。
refresh 对象 关于节点刷新操作的统计信息。
refresh.total 整数 刷新操作的总数。
refresh.total_time_in_millis 整数 所有刷新操作的总时间，以毫秒为单位。
refresh.external_total 整数 外部刷新操作的总数。
refresh.external_total_time_in_millis 整数 所有外部刷新操作的总时间，以毫秒为单位。
refresh.listeners 整数 刷新侦听器数量。
flush 对象 关于节点刷新操作的统计信息。
flush.total 整数 刷新操作的总数。
flush.periodic 整数 定期刷新操作的总数。
flush.total_time_in_millis 整数 所有刷新操作的总时间，以毫秒为单位。
warmer 对象 关于节点索引预热操作的统计信息。
warmer.current 整数 当前索引预热操作的数量。
warmer.total 整数 索引预热操作的总数。
warmer.total_time_in_millis 整数 所有索引预热操作的总时间，以毫秒为单位。
查询缓存 关于节点查询缓存操作的统计信息。  
query_cache.memory_size_in_bytes 整数 节点中所有分片用于查询缓存的内存量，以字节为单位。
query_cache.total_count 整数 查询缓存中的命中和未命中总数。
query_cache.hit_count 整数 查询缓存中的总命中数。
query_cache.miss_count 整数 查询缓存中的总未命中数。
query_cache.cache_size 整数 查询缓存中当前查询的数量。
query_cache.cache_count 整数 已添加到查询缓存中的查询总数，包括已逐出的查询。
query_cache.evictions 整数 查询缓存中的逐出次数。
fielddata 对象 关于节点中所有分片的字段数据缓存的统计信息。
fielddata.memory_size_in_bytes 整数 节点中所有分片用于字段数据缓存的内存总量，以字节为单位。
fielddata.evictions 整数 字段数据缓存中的逐出次数。
fielddata.fields 对象 包含所有字段数据字段。
completion 对象 关于节点中所有分片完成情况的统计信息。
completion.size_in_bytes 整数 节点中所有分片用于完成操作的内存总量，以字节为单位。
completion.fields 对象 包含完成字段。
段 对象 关于节点中所有分段的统计信息。
segments.count 整数 段的总数。
segments.memory_in_bytes 整数 内存总量，以字节为单位。
segments.terms_memory_in_bytes 整数 用于词项的内存总量，以字节为单位。
segments.stored_fields_memory_in_bytes 整数 用于存储字段的内存总量，以字节为单位。
segments.term_vectors_memory_in_bytes 整数 用于词向量的内存总量，以字节为单位。
segments.norms_memory_in_bytes 整数 用于归一化因子的内存总量，以字节为单位。
segments.points_memory_in_bytes 整数 用于点的内存总量，以字节为单位。
segments.doc_values_memory_in_bytes 整数 用于文档值的内存总量，以字节为单位。
segments.index_writer_memory_in_bytes 整数 所有索引写入器使用的内存总量，以字节为单位。
segments.version_map_memory_in_bytes 整数 所有版本映射使用的内存总量，以字节为单位。
segments.fixed_bit_set_memory_in_bytes 整数 固定位集使用的内存总量，以字节为单位。固定位集用于嵌套对象和连接字段。
segments.max_unsafe_auto_id_timestamp 整数 最近退役的索引请求的时间戳，自纪元以来的毫秒数。
segments.segment_replication 对象 当节点上启用段复制时，所有主分片的段复制统计信息。
segments.segment_replication.max_bytes_behind 长整型 (long) 落后主副本的最大字节数。
segments.segment_replication.total_bytes_behind 长整型 (long) 落后主副本的总字节数。
segments.segment_replication.max_replication_lag 长整型 (long) 副本追上其主副本所需的最大时间量，以毫秒为单位。
segments.remote_store 对象 关于远程段存储操作的统计信息。
segments.remote_store.upload 对象 与上传到远程段存储相关的统计信息。
segments.remote_store.upload.total_upload_size 对象 上传到远程段存储的数据量，以字节为单位。
segments.remote_store.upload.total_upload_size.started_bytes 整数 上传开始后要上传到远程段存储的字节数。
segments.remote_store.upload.total_upload_size.succeeded_bytes 整数 成功上传到远程段存储的字节数。
segments.remote_store.upload.total_upload_size.failed_bytes 整数 上传到远程段存储失败的字节数。
segments.remote_store.upload.refresh_size_lag 对象 上传期间远程段存储和本地存储之间的滞后量。
segments.remote_store.upload.refresh_size_lag.total_bytes 整数 上传刷新期间远程段存储和本地存储之间滞后的总字节数。
segments.remote_store.upload.refresh_size_lag.max_bytes 整数 上传刷新期间远程段存储和本地存储之间最大滞后量，以字节为单位。
segments.remote_store.upload.max_refresh_time_lag_in_millis 整数 远程刷新落后于本地刷新的最大持续时间，以毫秒为单位。
segments.remote_store.upload.total_time_spent_in_millis 整数 上传到远程段存储所花费的总时间，以毫秒为单位。
segments.remote_store.upload.pressure 对象 与段存储上传反压相关的统计信息。
segments.remote_store.upload.pressure.total_rejections 整数 由于段存储上传反压而被拒绝的请求总数。
segments.remote_store.download 对象 与下载到远程段存储相关的统计信息。
segments.remote_store.download.total_download_size 对象 从远程段存储下载的数据总量。
segments.remote_store.download.total_download_size.started_bytes 整数 下载开始后从远程段存储下载的字节数。
segments.remote_store.download.total_download_size.succeeded_bytes 整数 成功从远程段存储下载的字节数。
segments.remote_store.download.total_download_size.failed_bytes 整数 从远程段存储下载失败的字节数。
segments.remote_store.download.total_time_spent_in_millis 整数 从远程段存储下载所花费的总持续时间，以毫秒为单位。
segments.file_sizes 整数 关于段文件大小的统计信息。
事务日志 对象 关于节点事务日志操作的统计信息。
translog.operations 整数 事务日志操作数。
translog.size_in_bytes 整数 事务日志的大小，以字节为单位。
translog.uncommitted_operations 整数 未提交的事务日志操作数。
translog.uncommitted_size_in_bytes 整数 未提交的事务日志操作的大小，以字节为单位。
translog.earliest_last_modified_age 整数 事务日志的最早上次修改时间。
translog.remote_store 对象 与远程事务日志存储操作相关的统计信息。
translog.remote_store.upload 对象 与上传到远程事务日志存储相关的统计信息。
translog.remote_store.upload.total_uploads 对象 同步到远程事务日志存储的次数。
translog.remote_store.upload.total_uploads.started 整数 已开始上传同步到远程事务日志存储的次数。
translog.remote_store.upload.total_uploads.failed 整数 上传同步到远程事务日志存储失败的次数。
translog.remote_store.upload.total_uploads.succeeded 整数 上传同步到远程事务日志存储成功的次数。
translog.remote_store.upload.total_upload_size 对象 上传到远程事务日志存储的数据总量。
translog.remote_store.upload.total_upload_size.started_bytes 整数 上传开始后正在积极上传到远程事务日志存储的字节数。
translog.remote_store.upload.total_upload_size.failed_bytes 整数 上传到远程事务日志存储失败的字节数。
translog.remote_store.upload.total_upload_size.succeeded_bytes 整数 成功上传到远程事务日志存储的字节数。
request_cache 对象 关于节点请求缓存的统计信息。
request_cache.memory_size_in_bytes 整数 请求缓存使用的内存大小，以字节为单位。
request_cache.evictions 整数 请求缓存逐出次数。
request_cache.hit_count 整数 请求缓存命中数。
request_cache.miss_count 整数 请求缓存未命中数。
recovery 对象 关于节点恢复操作的统计信息。
recovery.current_as_source 整数 已使用索引分片作为源的恢复操作数。
recovery.current_as_target 整数 已使用索引分片作为目标的恢复操作数。
recovery.throttle_time_in_millis 整数 由于限制导致的恢复操作延迟，以毫秒为单位。

操作系统

os 对象包含节点的操作系统统计信息，并具有以下属性。

字段 字段类型 描述
时间戳 整数 操作系统统计信息的上次刷新时间，自纪元以来的毫秒数。
cpu 对象 关于节点 CPU 使用情况的统计信息。
cpu.percent 整数 系统最近的 CPU 使用情况。
cpu.load_average 对象 关于系统平均负载的统计信息。
cpu.load_average.1m 浮点型 系统在一分钟时间段内的平均负载。
cpu.load_average.5m 浮点型 系统在五分钟时间段内的平均负载。
cpu.load_average.15m 浮点型 系统在 15 分钟时间段内的平均负载。
mem 对象 关于节点内存使用情况的统计信息。
mem.total_in_bytes 整数 物理内存总量，以字节为单位。
mem.free_in_bytes 整数 空闲物理内存总量，以字节为单位。
mem.used_in_bytes 整数 已使用物理内存总量，以字节为单位。
mem.free_percent 整数 空闲内存的百分比。
mem.used_percent 整数 已使用内存的百分比。
swap 对象 关于节点交换空间的统计信息。
swap.total_in_bytes 整数 交换空间总量，以字节为单位。
swap.free_in_bytes 整数 空闲交换空间总量，以字节为单位。
swap.used_in_bytes 整数 已使用交换空间总量，以字节为单位。
cgroup 对象 包含节点的 cgroup 统计信息。仅在 Linux 上返回。
cgroup.cpuacct 对象 关于节点 cpuacct 控制组的统计信息。
cgroup.cpu 对象 关于节点 CPU 控制组的统计信息。
cgroup.memory 对象 关于节点内存控制组的统计信息。

进程

process 对象包含节点的进程统计信息，并具有以下属性。

字段 字段类型 描述
时间戳 整数 进程统计信息的上次刷新时间，自纪元以来的毫秒数。
open_file_descriptors 整数 与当前进程关联的已打开文件描述符数。
max_file_descriptors 整数 系统的最大文件描述符数。
cpu 对象 关于节点 CPU 的统计信息。
cpu.percent 整数 进程的 CPU 使用率百分比。
cpu.total_in_millis 整数 JVM 运行所在进程使用的总 CPU 时间，以毫秒为单位。
mem 对象 关于节点内存的统计信息。
mem.total_virtual_in_bytes 整数 当前正在运行的进程保证可用的虚拟内存总量，以字节为单位。

JVM

jvm 对象包含节点 JVM 的统计信息，并具有以下属性。

字段 字段类型 描述
时间戳 整数 JVM 统计信息的上次刷新时间，自纪元以来的毫秒数。
uptime_in_millis 整数 JVM 运行时间，以毫秒为单位。
mem 对象 节点 JVM 内存使用情况的统计信息。
mem.heap_used_in_bytes 整数 当前正在使用的内存量，以字节为单位。
mem.heap_used_percent 整数 堆当前使用的内存百分比。
mem.heap_committed_in_bytes 整数 堆可用于使用的内存量，以字节为单位。
mem.heap_max_in_bytes 整数 堆可用于使用的最大内存量，以字节为单位。
mem.non_heap_used_in_bytes 整数 当前使用的非堆内存量，以字节为单位。
mem.non_heap_committed_in_bytes 整数 可用于使用的非堆内存最大量，以字节为单位。
mem.pools 对象 关于节点堆内存使用情况的统计信息。
mem.pools.young 对象 关于节点年轻代堆内存使用情况的统计信息。包含已使用的内存量、可用内存最大量和峰值已使用的内存量。
mem.pools.old 对象 关于节点老年代堆内存使用情况的统计信息。包含已使用的内存量、可用内存最大量和峰值已使用的内存量。
mem.pools.survivor 对象 关于节点幸存区内存使用情况的统计信息。包含已使用的内存量、可用内存最大量和峰值已使用的内存量。
threads 对象 关于节点 JVM 线程使用情况的统计信息。
threads.count 整数 JVM 中当前活动的线程数。
threads.peak_count 整数 JVM 中的最大线程数。
gc.collectors 对象 关于节点 JVM 垃圾收集器的统计信息。
gc.collectors.young 整数 关于收集年轻代对象的 JVM 垃圾收集器的统计信息。
gc.collectors.young.collection_count 整数 收集年轻代对象的垃圾收集器数量。
gc.collectors.young.collection_time_in_millis 整数 年轻代对象垃圾收集所花费的总时间，以毫秒为单位。
gc.collectors.old 整数 关于收集老年代对象的 JVM 垃圾收集器的统计信息。
gc.collectors.old.collection_count 整数 收集老年代对象的垃圾收集器数量。
gc.collectors.old.collection_time_in_millis 整数 老年代对象垃圾收集所花费的总时间，以毫秒为单位。
buffer_pools 对象 关于节点 JVM 缓冲区池的统计信息。
buffer_pools.mapped 对象 关于节点映射的 JVM 缓冲区池的统计信息。
buffer_pools.mapped.count 整数 映射缓冲区池的数量。
buffer_pools.mapped.used_in_bytes 整数 映射缓冲区池使用的内存量，以字节为单位。
buffer_pools.mapped.total_capacity_in_bytes 整数 映射缓冲区池的总容量，以字节为单位。
buffer_pools.direct 对象 关于节点直接 JVM 缓冲区池的统计信息。
buffer_pools.direct.count 整数 直接缓冲区池的数量。
buffer_pools.direct.used_in_bytes 整数 直接缓冲区池使用的内存量，以字节为单位。
buffer_pools.direct.total_capacity_in_bytes 整数 直接缓冲区池的总容量，以字节为单位。
classes 对象 关于节点 JVM 加载的类的统计信息。
classes.current_loaded_count 整数 JVM 当前加载的类数量。
classes.total_loaded_count 整数 自 JVM 启动以来 JVM 加载的类总数。
classes.total_unloaded_count 整数 自 JVM 启动以来 JVM 卸载的类总数。

thread_pool

thread_pool 对象包含所有线程池的列表。每个线程池都是一个嵌套对象，由其 ID 指定，并包含以下属性。

字段 字段类型 描述
threads 整数 池中的线程数。
queue 整数 队列中的线程数。
active 整数 池中活动线程的数量。
rejected 整数 已拒绝的任务数量。
largest 整数 池中线程的峰值数量。
completed 整数 已完成的任务数量。
total_wait_time_in_nanos 整数 任务在线程池队列中等待的总时间。目前，只有 search、search_throttled 和 index_searcher 线程池支持此指标。

文件系统

fs 对象表示节点文件存储的统计信息。它具有以下属性。

字段 字段类型 描述
时间戳 整数 文件存储统计信息的上次刷新时间，自纪元以来的毫秒数。
total 对象 节点所有文件存储的统计信息。
total.total_in_bytes 整数 所有文件存储的总内存大小，以字节为单位。
total.free_in_bytes 整数 所有文件存储中未分配的磁盘空间总量，以字节为单位。
total.available_in_bytes 整数 JVM 在所有文件存储上可用的总磁盘空间。表示 OpenSearch 可以使用的实际内存量，以字节为单位。
data 数组 所有文件存储的列表。每个文件存储都具有以下属性。
data.path 字符串 文件存储的路径。
data.mount 字符串 文件存储的挂载点。
data.type 字符串 文件存储的类型（例如，叠加）。
data.total_in_bytes 整数 文件存储的总大小，以字节为单位。
data.free_in_bytes 整数 文件存储中未分配的磁盘空间总量，以字节为单位。
data.available_in_bytes 整数 JVM 可用于文件存储的磁盘空间总量，以字节为单位。
io_stats 对象 节点的 I/O 统计信息（仅限 Linux）。包括设备、读写操作和 I/O 操作时间。

transport

transport 对象具有以下属性。

字段 字段类型 描述
server_open 整数 OpenSearch 节点用于内部通信的开放入站 TCP 连接数。
total_outbound_connections 整数 自节点启动以来，节点已打开的出站传输连接总数。
rx_count 整数 节点在内部通信期间接收的 RX（接收）数据包总数。
rx_size_in_bytes 整数 节点在内部通信期间接收的 RX 数据包总大小，以字节为单位。
tx_count 整数 节点在内部通信期间发送的 TX（传输）数据包总数。
tx_size_in_bytes 整数 节点在内部通信期间发送的 TX（传输）数据包总大小，以字节为单位。

breakers

breakers 对象包含节点断路器的统计信息。每个断路器都是一个按名称列出的嵌套对象，并包含以下属性。

字段 字段类型 描述
limit_size_in_bytes 整数 断路器的内存限制，以字节为单位。
limit_size 字节值 断路器的内存限制，以人类可读的格式表示（例如，307.1mb）。
estimated_size_in_bytes 整数 操作的估计内存使用量，以字节为单位。
estimated_size 字节值 操作的估计内存使用量，以人类可读的格式表示（例如，356b）。
overhead 浮点型 所有估计值用于计算最终估计值的乘数因子。
tripped 整数 为防止内存不足错误而激活断路器的总次数。

script 和 script_cache

script 和 script_cache 对象具有以下属性。

字段 字段类型 描述
script（脚本） 对象 节点的脚本统计信息。
script.compilations 整数 节点脚本编译的总数。
script.cache_evictions 整数 脚本缓存清除旧数据的总次数。
script.compilation_limit_triggered 整数 脚本编译被断路器限制的总次数。
script_cache 对象 节点的脚本缓存统计信息。
script_cache.sum.compilations 整数 节点缓存中脚本编译的总数。
script_cache.sum.cache_evictions 整数 脚本缓存清除旧数据的总次数。
script_cache.sum.compilation_limit_triggered 整数 缓存中脚本编译被断路器限制的总次数。
script_cache.contexts 对象数组 脚本缓存的上下文列表。每个上下文包含其名称、编译次数、缓存逐出次数以及脚本被断路器限制的次数。

discovery

discovery 对象包含节点发现统计信息，并具有以下属性。

字段 字段类型 描述
cluster_state_queue 对象 节点的集群状态队列统计信息。
cluster_state_queue.total 整数 队列中集群状态的总数。
cluster_state_queue.pending 整数 队列中待处理集群状态的数量。
cluster_state_queue.committed 整数 队列中已提交集群状态的数量。
published_cluster_states 对象 节点已发布集群状态的统计信息。
published_cluster_states.full_states 整数 已发布集群状态的数量。
published_cluster_states.incompatible_diffs 整数 已发布集群状态之间不兼容差异的数量。
published_cluster_states.compatible_diffs 整数 已发布集群状态之间兼容差异的数量。
cluster_state_stats 对象 活动领导者发布的集群状态更新统计信息。
cluster_state_stats.overall 对象 总体集群状态更新统计信息。
cluster_state_stats.overall.update_count 整数 成功集群状态更新的总数。
cluster_state_stats.overall.total_time_in_millis 整数 所有集群状态更新所花费的总时间，以毫秒为单位。
cluster_state_stats.overall.failed_count 整数 失败集群状态更新的总数。
cluster_state_stats.remote_upload 对象 与远程上传相关的集群状态更新统计信息。
cluster_state_stats.remote_upload.success_count 整数 成功上传到远程存储的集群状态更新总数。
cluster_state_stats.remote_upload.failed_count 整数 上传到远程存储失败的集群状态更新总数。
cluster_state_stats.remote_upload.total_time_in_millis 整数 上传到远程存储的所有集群状态更新所花费的总时间，以毫秒为单位。
cluster_state_stats.remote_upload.cleanup_attempt_failed_count 整数 尝试从远程存储清理旧集群状态时遇到的失败总数。

摄取

ingest 对象包含摄入统计信息，并具有以下属性。

字段 字段类型 描述
total 整数 节点生命周期内的摄入统计信息。
total.count 整数 节点摄入的文档总数。
total.time_in_millis 整数 预处理摄入文档的总时间，以毫秒为单位。
total.current 整数 节点当前正在摄入的文档总数。
total.failed 整数 节点失败摄入的总数。
pipelines 对象 节点的摄入管道统计信息。每个管道都是一个由其 ID 指定的嵌套对象，并具有以下属性。
pipelines.id.count 整数 摄入管道预处理的文档数量。
pipelines.id.time_in_millis 整数 摄入管道中预处理文档的总时间，以毫秒为单位。
pipelines.id.failed 整数 摄入管道失败摄入的总数。
pipelines.id.processors 对象数组 摄入处理器统计信息。包括当前转换的文档数量、已转换文档总数、失败转换数以及转换文档所花费的时间。

search_pipeline

search_pipeline 对象包含与搜索管道相关的统计信息，并具有以下属性。

字段 字段类型 描述
total_request 对象 与所有搜索请求处理器相关的累积统计信息。
total_request.count 整数 搜索请求处理器执行的总数。
total_request.time_in_millis 整数 所有搜索请求处理器执行的总时间，以毫秒为单位。
total_request.current 整数 当前正在进行的搜索请求处理器执行的总数。
total_request.failed 整数 失败搜索请求处理器执行的总数。
total_response 对象 与所有搜索响应处理器相关的累积统计信息。
total_response.count 整数 搜索响应处理器执行的总数。
total_response.time_in_millis 整数 所有搜索响应处理器执行的总时间，以毫秒为单位。
total_response.current 整数 当前正在进行的搜索响应处理器执行的总数。
total_response.failed 整数 失败搜索响应处理器执行的总数。
pipelines 对象 搜索管道统计信息。每个管道都是一个由其 ID 指定的嵌套对象，具有以下行中列出的属性。如果处理器具有 tag，则处理器的统计信息在名称为 <processor_type>:<tag>（例如，filter_query:abc）的对象中提供。所有没有 tag 的相同类型处理器的统计信息将被聚合并在名称为 <processor-type>（例如，filter_query）的对象中提供。
pipelines.id.request.count 整数 搜索管道执行的搜索请求处理器执行次数。
pipelines.id.request.time_in_millis 整数 搜索管道中搜索请求处理器执行的总时间，以毫秒为单位。
pipelines.id.request.current 整数 搜索管道当前正在进行的搜索请求处理器执行次数。
pipelines.id.request.failed 整数 搜索管道失败搜索请求处理器执行次数。
pipelines.id.request_processors 对象数组 搜索请求处理器统计信息。包括执行总数、执行总时间、当前正在进行的执行总数以及失败执行次数。
pipelines.id.response.count 整数 搜索管道执行的搜索响应处理器执行次数。
pipelines.id.response.time_in_millis 整数 搜索管道中搜索响应处理器执行的总时间，以毫秒为单位。
pipelines.id.response.current 整数 搜索管道当前正在进行的搜索响应处理器执行次数。
pipelines.id.response.failed 整数 搜索管道失败搜索响应处理器执行次数。
pipelines.id.response_processors 对象数组 搜索响应处理器统计信息。包括执行总数、执行总时间、当前正在进行的执行总数以及失败执行次数。

adaptive_selection

adaptive_selection 对象包含自适应选择统计信息。每个条目都由节点 ID 指定，并具有以下属性。

字段 字段类型 描述
outgoing_searches 整数 节点的出站搜索请求数量。
avg_queue_size 整数 节点搜索请求的滚动平均队列大小（指数加权）。
avg_service_time_ns 整数 搜索请求的滚动平均服务时间，以纳秒为单位（指数加权）。
avg_response_time_ns 整数 搜索请求的滚动平均响应时间，以纳秒为单位（指数加权）。
rank 字符串 用于路由请求时选择分片的节点排名。

indexing_pressure

indexing_pressure 对象包含索引压力统计信息，并具有以下属性。

字段 字段类型 描述
memory 对象 与索引负载内存消耗相关的统计信息。
memory.current 对象 与当前索引负载内存消耗相关的统计信息。
memory.current.combined_coordinating_and_primary_in_bytes 整数 协调或主阶段中索引请求使用的总内存，以字节为单位。如果主阶段在本地运行，节点可以重用协调内存，因此总内存不一定等于协调和主阶段内存使用量的总和。
memory.current.coordinating_in_bytes 整数 协调阶段中索引请求消耗的总内存，以字节为单位。
memory.current.primary_in_bytes 整数 主阶段中索引请求消耗的总内存，以字节为单位。
memory.current.replica_in_bytes 整数 副本阶段中索引请求消耗的总内存，以字节为单位。
memory.current.all_in_bytes 整数 协调、主或副本阶段中索引请求消耗的总内存。

shard_indexing_pressure

shard_indexing_pressure 对象包含分片索引压力统计信息，并具有以下属性。

字段 字段类型 描述
stats 对象 关于分片索引压力的统计信息。
total_rejections_breakup_shadow_mode 对象 如果在影子模式下运行，total_rejections_breakup_shadow_mode 对象包含节点中所有分片请求拒绝标准的统计信息。
total_rejections_breakup_shadow_mode.node_limits 整数 由于节点内存限制导致的拒绝总数。当所有分片达到分配给节点的内存限制（例如，堆大小的 10%）时，该分片无法在节点上接收更多流量，并且索引请求将被拒绝。
total_rejections_breakup_shadow_mode.no_successful_request_limits 整数 当节点占用水平超出其软限制且分片有多个未完成请求正在等待执行时，拒绝的总数。在这种情况下，在系统恢复之前，额外的索引请求将被拒绝。
total_rejections_breakup_shadow_mode.throughput_degradation_limits 整数 当节点占用水平超出其软限制且分片级别的请求周转时间持续恶化时，拒绝的总数。在这种情况下，在系统恢复之前，额外的索引请求将被拒绝。
enabled 布尔型 指定是否为节点启用分片索引压力功能。
enforced 布尔型 如果为 true，则分片索引压力以强制模式运行（存在拒绝）。如果为 false，则分片索引压力以影子模式运行（没有拒绝，但会记录统计信息，可以在 total_rejections_breakup_shadow_mode 对象中检索）。仅当启用分片索引压力时适用。

cluster_manager_throttling

cluster_manager_throttling 对象包含集群管理器节点上受限制任务的统计信息。它仅针对当前选为集群管理器的节点填充。

字段 字段类型 描述
stats 对象 集群管理器节点上受限制任务的统计信息。
stats.total_throttled_tasks 长整型 受限制任务的总数。
stats.throttled_tasks_per_task_type 对象 按单个任务类型划分的统计信息，指定为键值对。键是单个任务类型，其值表示受限制的请求数量。

weighted_routing

weighted_routing 对象包含加权轮询请求的统计信息。具体来说，它包含此节点在“区域外”时服务请求的次数计数器。

字段 字段类型 描述
stats 对象 关于加权路由的统计信息。
fail_open_count 整数 当节点的路由权重设置为零时，此节点上的分片服务请求的次数。

resource_usage_stats

resource_usage_stats 对象包含资源使用统计信息。每个条目都由节点 ID 指定，并具有以下属性。

字段 字段类型 描述
时间戳 整数 资源使用统计信息的上次刷新时间，自纪元以来的毫秒数。
cpu_utilization_percent 浮点型 在 node.resource.tracker.global_cpu_usage.window_duration 设置中配置的时间段内，任何 OpenSearch 进程的平均 CPU 使用率统计信息。
memory_utilization_percent 浮点型 在 node.resource.tracker.global_jvmmp.window_duration 设置中配置的时间段内，节点 JVM 内存使用统计信息。
max_io_utilization_percent 浮点型 （仅限 Linux）在 node.resource.tracker.global_io_usage.window_duration 设置中配置的时间段内，任何 OpenSearch 进程的平均 IO 使用率统计信息。

admission_control

admission_control 对象包含基于资源消耗的搜索和索引请求的拒绝计数，并具有以下属性。

字段 字段类型 描述
admission_control.global_cpu_usage.transport.rejection_count.search 整数 当节点 CPU 使用限制达到时，传输层中的搜索拒绝总数。在这种情况下，在系统恢复之前，额外的搜索请求将被拒绝。CPU 使用限制在 admission_control.search.cpu_usage.limit 设置中配置。
admission_control.global_cpu_usage.transport.rejection_count.indexing 整数 当节点 CPU 使用限制达到时，传输层中的索引拒绝总数。在系统恢复之前，任何额外的索引请求都将被拒绝。CPU 使用限制在 admission_control.indexing.cpu_usage.limit 设置中配置。
admission_control.global_io_usage.transport.rejection_count.search 整数 当节点 IO 使用限制达到时，传输层中的搜索拒绝总数。在系统恢复之前，任何额外的搜索请求都将被拒绝。CPU 使用限制在 admission_control.search.io_usage.limit 设置中配置（仅限 Linux）。
admission_control.global_io_usage.transport.rejection_count.indexing 整数 当节点 IO 使用限制达到时，传输层中的索引拒绝总数。在系统恢复之前，任何额外的索引请求都将被拒绝。IO 使用限制在 admission_control.indexing.io_usage.limit 设置中配置（仅限 Linux）。

caches

因为此 API 支持实验性的分层缓存功能，所以本节中的响应可能会发生变化。如果未启用分层缓存功能标志，则 API 将返回所有值为 0。

caches 对象包含缓存统计信息，例如 request_cache 统计信息。无论查询参数 level 的值如何，始终返回每个子指标中的总值。

字段 字段类型 描述
request_cache 对象 请求缓存的统计信息。
request_cache.size_in_bytes 整数 请求缓存的总大小，以字节为单位。
request_cache.evictions 整数 请求缓存的逐出总数。
request_cache.hit_count 整数 请求缓存的总命中数。
request_cache.miss_count 整数 请求缓存的总未命中数。
request_cache.item_count 整数 请求缓存中的项目总数。
request_cache.store_name 字符串 请求缓存使用的存储类型名称。有关更多信息，请参阅分层缓存。

如果 level 查询参数设置为其有效值之一：indices、shard 或 tier，则 caches.request_cache 中将存在其他字段，这些字段按这些级别对值进行分类。例如，如果 level=indices,tier，则正在使用分层缓存，并且节点具有名为 index0 和 index1 的索引，则 caches 对象将包含每个级别值组合的相同五个指标，如下表所示。

字段 字段类型 描述
request_cache.indices.index0.tier.on_heap 对象 包含堆层上 index0 的五个指标。
request_cache.indices.index0.tier.disk 对象 包含磁盘层上 index0 的五个指标。
request_cache.indices.index1.tier.on_heap 对象 包含堆层上 index1 的五个指标。
request_cache.indices.index1.tier.disk 对象 包含磁盘层上 index1 的五个指标。

所需权限

如果您使用安全插件，请确保您具有适当的权限：cluster:monitor/nodes/stats。

剩余 350 字符

有问题？。

想做贡献？或。