The template to monitor Elasticsearch by Zabbix that work without any external scripts. It works with both standalone and cluster instances. The metrics are collected in one pass remotely using an HTTP agent. They are getting values from REST API _cluster/health, _cluster/stats, _nodes/stats requests. You can set {$ELASTICSEARCH.USERNAME} and {$ELASTICSEARCH.PASSWORD} macros in the template for using on the host level. If you use an atypical location ES API, don’t forget to change the macros {$ELASTICSEARCH.SCHEME},{$ELASTICSEARCH.PORT}. Parsed manually from https://git.zabbix.com/projects/ZBX/repos/zabbix/browse/templates/app/elasticsearch_http from zabbix version 5.0 to 4.2 and add triggers
This is fork of official Zabbix template Elasticsearch Cluster by HTTP (Zabbix 5.0)
Features:
Tested on Zabbix 4.2 and Elasticsearch 7.4.2
R N
| Name | Description | Default | Type |
|---|---|---|---|
| {$ELASTICSEARCH.FETCH_LATENCY.MAX.WARN} |
-
 | 100 |
Text macro |
| {$ELASTICSEARCH.FLUSH_LATENCY.MAX.WARN} |
-
 | 100 |
Text macro |
| {$ELASTICSEARCH.HEAP_USED.MAX.CRIT} |
-
 | 95 |
Text macro |
| {$ELASTICSEARCH.HEAP_USED.MAX.WARN} |
-
 | 85 |
Text macro |
| {$ELASTICSEARCH.INDEXING_LATENCY.MAX.WARN} |
-
 | 100 |
Text macro |
| {$ELASTICSEARCH.MAX_SHARDS_PER_NODE} |
-
 | 1000 |
Text macro |
| {$ELASTICSEARCH.PASSWORD} |
-
 | `` | Text macro |
| {$ELASTICSEARCH.PORT} |
-
 | 9200 |
Text macro |
| {$ELASTICSEARCH.QUERY_LATENCY.MAX.WARN} |
-
 | 100 |
Text macro |
| {$ELASTICSEARCH.RESPONSE_TIME.MAX.WARN} |
-
 | 10s |
Text macro |
| {$ELASTICSEARCH.SCHEME} |
-
 | http |
Text macro |
| {$ELASTICSEARCH.USERNAME} |
-
 | `` | Text macro |
There are no template links in this template.
| Name | Description | Type | Key and additional info |
|---|---|---|---|
| Cluster nodes discovery |
Discovery ES cluster nodes.
 | HTTP agent |
es.nodes.discovery
Update: 1h
 |
| Name | Description | Type | Key and additional info |
|---|---|---|---|
| ES: Total size of all file stores |
The total size in bytes of all file stores across all selected nodes.
 | Dependent item |
es.nodes.fs.total_in_bytes
Update: 0
 |
| ES: Delayed unassigned shards |
The number of shards whose allocation has been delayed by the timeout settings.
 | Dependent item |
es.cluster.delayed_unassigned_shards
Update: 0
 |
| ES: Total available size to JVM in all file stores |
The total number of bytes available to JVM in the file stores across all selected nodes. Depending on OS or process-level restrictions, this number may be less than nodes.fs.free_in_byes. This is the actual amount of free disk space the selected Elasticsearch nodes can use.
 | Dependent item |
es.nodes.fs.available_in_bytes
Update: 0
 |
| ES: Number of initializing shards |
The number of shards that are under initialization.
 | Dependent item |
es.cluster.initializing_shards
Update: 0
 |
| ES: Get cluster version |
Returns the cluster version
 | HTTP agent |
es.cluster.get_version
Update: 1h
 |
| ES: Get nodes stats |
Returns cluster nodes statistics.
 | HTTP agent |
es.nodes.get_stats
Update: 1m
 |
| ES: Nodes with the master role |
The number of selected nodes with the master role.
 | Dependent item |
es.nodes.count.master
Update: 0
 |
| ES: Number of relocating shards |
The number of shards that are under relocation.
 | Dependent item |
es.cluster.relocating_shards
Update: 0
 |
| ES: Service status |
Checks if the service is running and accepting TCP connections.
 | Simple check |
net.tcp.service[”{$ELASTICSEARCH.SCHEME}”,”{HOST.CONN}”,”{$ELASTICSEARCH.PORT}”]
Update: 1m
 |
| ES: Number of non-deleted documents |
The total number of non-deleted documents across all primary shards assigned to the selected nodes. This number is based on the documents in Lucene segments and may include the documents from nested fields.
 | Dependent item |
es.indices.docs.count
Update: 0
 |
| ES: Cluster uptime |
Uptime duration in seconds since JVM has last started.
 | Dependent item |
es.nodes.jvm.max_uptime[{#ES.NODE}]
Update: 0
 |
| ES: Get cluster health |
Returns the health status of a cluster.
 | HTTP agent |
es.cluster.get_health
Update: 1m
 |
| ES: Task max waiting in queue |
The time expressed in seconds since the earliest initiated task is waiting for being performed.
 | Dependent item |
es.cluster.task_max_waiting_in_queue
Update: 0
 |
| ES: Number of pending tasks |
The number of cluster-level changes that have not yet been executed.
 | Dependent item |
es.cluster.number_of_pending_tasks
Update: 0
 |
| ES: Cluster health status |
Health status of the cluster, based on the state of its primary and replica shards. Statuses are: green All shards are assigned. yellow All primary shards are assigned, but one or more replica shards are unassigned. If a node in the cluster fails, some data could be unavailable until that node is repaired. red One or more primary shards are unassigned, so some data is unavailable. This can occur briefly during cluster startup as primary shards are assigned.
 | Dependent item |
es.cluster.status
Update: 0
 |
| ES: Total shards |
Total number of shards
 | Dependent item |
es.shards.total
Update: 0
 |
| ES: Service response time |
Checks performance of the TCP service.
 | Simple check |
net.tcp.service.perf[”{$ELASTICSEARCH.SCHEME}”,”{HOST.CONN}”,”{$ELASTICSEARCH.PORT}”]
Update: 1m
 |
| ES: Indices with shards assigned to nodes |
The total number of indices with shards assigned to the selected nodes.
 | Dependent item |
es.indices.count
Update: 0
 |
| ES: Nodes with the data role |
The number of selected nodes with the data role.
 | Dependent item |
es.nodes.count.data
Update: 0
 |
| ES: Number of data nodes |
The number of nodes that are dedicated to data nodes.
 | Dependent item |
es.cluster.number_of_data_nodes
Update: 0
 |
| ES: Get cluster stats |
Returns cluster statistics.
 | HTTP agent |
es.cluster.get_stats
Update: 1m
 |
| ES: Number of nodes |
The number of nodes within the cluster.
 | Dependent item |
es.cluster.number_of_nodes
Update: 0
 |
| ES: Inactive shards percentage |
The ratio of inactive shards in the cluster expressed as a percentage.
 | Dependent item |
es.cluster.inactive_shards_percent_as_number
Update: 0
 |
| ES: Nodes with the ingest role |
The number of selected nodes with the ingest role.
 | Dependent item |
es.nodes.count.ingest
Update: 0
 |
| ES: Number of unassigned shards |
The number of shards that are not allocated.
 | Dependent item |
es.cluster.unassigned_shards
Update: 0
 |
| ES {#ES.NODE}: Flush latency |
The average flush latency calculated from the available flush.total and flush.total_time_in_millis metrics.
 | Calculated |
es.node.indices.flush.latency[{#ES.NODE}]
Update: 1m

LLD
 |
| ES {#ES.NODE}: Fetch latency |
The average fetch latency calculated by sampling the total number of fetches and the total elapsed time at regular intervals.
 | Calculated |
es.node.indices.search.fetch_latency[{#ES.NODE}]
Update: 1m

LLD
 |
| ES {#ES.NODE}: Indexing latency |
The average indexing latency calculated from the available index_total and index_time_in_millis metrics.
 | Calculated |
es.node.indices.indexing.index_latency[{#ES.NODE}]
Update: 1m

LLD
 |
| ES {#ES.NODE}: Query latency |
The average query latency calculated by sampling the total number of queries and the total elapsed time at regular intervals.
 | Calculated |
es.node.indices.search.query_latency[{#ES.NODE}]
Update: 1m

LLD
 |
| ES {#ES.NODE}: Total available size |
The 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 fs.total.free_in_bytes. This is the actual amount of free disk space the Elasticsearch node can utilize.
 | Dependent item |
es.node.fs.total.available_in_bytes[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Refresh thread pool active threads |
The number of active threads in the refresh thread pool.
 | Dependent item |
es.node.thread_pool.refresh.active[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total time spent performing query |
Time in milliseconds spent performing query operations.
 | Dependent item |
es.node.indices.search.query_time_in_millis[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total number of query |
The total number of query operations.
 | Dependent item |
es.node.indices.search.query_total[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Amount of JVM heap committed |
The amount of memory, in bytes, available for use by the heap.
 | Dependent item |
es.node.jvm.mem.heap_committed_in_bytes[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Maximum JVM memory available for use |
The maximum amount of memory, in bytes, available for use by the heap.
 | Dependent item |
es.node.jvm.mem.heap_max_in_bytes[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Amount of JVM heap currently in use |
The memory, in bytes, currently in use by the heap.
 | Dependent item |
es.node.jvm.mem.heap_used_in_bytes[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Percent of JVM heap currently in use |
The percentage of memory currently in use by the heap.
 | Dependent item |
es.node.jvm.mem.heap_used_percent[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Node uptime |
JVM uptime in seconds.
 | Dependent item |
es.node.jvm.uptime[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Refresh thread pool tasks in queue |
The number of tasks in queue for the refresh thread pool.
 | Dependent item |
es.node.thread_pool.refresh.queue[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Refresh thread pool executor tasks completed |
The number of tasks completed by the refresh thread pool executor.
 | Dependent item |
es.node.thread_pool.refresh.completed.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Refresh thread pool executor tasks rejected |
The number of tasks rejected by the refresh thread pool executor.
 | Dependent item |
es.node.thread_pool.refresh.rejected.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Search thread pool active threads |
The number of active threads in the search thread pool.
 | Dependent item |
es.node.thread_pool.search.active[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Search thread pool executor tasks completed |
The number of tasks completed by the search thread pool executor.
 | Dependent item |
es.node.thread_pool.search.completed.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Search thread pool tasks in queue |
The number of tasks in queue for the search thread pool.
 | Dependent item |
es.node.thread_pool.search.queue[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Search thread pool executor tasks rejected |
The number of tasks rejected by the search thread pool executor.
 | Dependent item |
es.node.thread_pool.search.rejected.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Write thread pool active threads |
The number of active threads in the write thread pool.
 | Dependent item |
es.node.thread_pool.write.active[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Write thread pool executor tasks completed |
The number of tasks completed by the write thread pool executor.
 | Dependent item |
es.node.thread_pool.write.completed.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Write thread pool tasks in queue |
The number of tasks in queue for the write thread pool.
 | Dependent item |
es.node.thread_pool.write.queue[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent performing query |
Time in seconds spent performing query operations for the last measuring span.
 | Dependent item |
es.node.indices.search.query_time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Rate of queries |
The number of query operations per second.
 | Dependent item |
es.node.indices.search.query.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Current query operations |
The number of query operations currently running.
 | Dependent item |
es.node.indices.search.query_current[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent throttling operations |
Time in seconds spent throttling operations for the last measuring span.
 | Dependent item |
es.node.indices.indexing.throttle_time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Number of open HTTP connections |
The number of currently open HTTP connections for the node.
 | Dependent item |
es.node.http.current_open[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Rate of HTTP connections opened |
The number of HTTP connections opened for the node per second.
 | Dependent item |
es.node.http.opened.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total number of index flushes to disk |
The total number of flush operations.
 | Dependent item |
es.node.indices.flush.total[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total time spent on flushing indices to disk |
Total time in milliseconds spent performing flush operations.
 | Dependent item |
es.node.indices.flush.total_time_in_millis[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Current indexing operations |
The number of indexing operations currently running.
 | Dependent item |
es.node.indices.indexing.index_current[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total time spent performing indexing |
Total time in milliseconds spent performing indexing operations.
 | Dependent item |
es.node.indices.indexing.index_time_in_millis[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total number of indexing |
The total number of indexing operations.
 | Dependent item |
es.node.indices.indexing.index_total[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent throttling merge operations |
Time in seconds spent throttling merge operations for the last measuring span.
 | Dependent item |
es.node.indices.merges.total_throttled_time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total size |
Total size (in bytes) of all file stores.
 | Dependent item |
es.node.fs.total.total_in_bytes[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent throttling recovery operations |
Time in seconds spent throttling recovery operations for the last measuring span.
 | Dependent item |
es.node.indices.recovery.throttle_time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Rate of index refreshes |
The number of refresh operations per second.
 | Dependent item |
es.node.indices.refresh.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent performing refresh |
Time in seconds spent performing refresh operations for the last measuring span.
 | Dependent item |
es.node.indices.refresh.time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Rate of fetch |
The number of fetch operations per second.
 | Dependent item |
es.node.indices.search.fetch.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Current fetch operations |
The number of fetch operations currently running.
 | Dependent item |
es.node.indices.search.fetch_current[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent performing fetch |
Time in seconds spent performing fetch operations for the last measuring span.
 | Dependent item |
es.node.indices.search.fetch_time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total time spent performing fetch |
Time in milliseconds spent performing fetch operations.
 | Dependent item |
es.node.indices.search.fetch_time_in_millis[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total number of fetch |
The total number of fetch operations.
 | Dependent item |
es.node.indices.search.fetch_total[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Write thread pool executor tasks rejected |
The number of tasks rejected by the write thread pool executor.
 | Dependent item |
es.node.thread_pool.write.rejected.rate[{#ES.NODE}]
Update: 0

LLD
 |
| Name | Description | Expression | Priority |
|---|---|---|---|
| ES {#ES.NODE}: Fetch latency is too high (over {$ELASTICSEARCH.FETCH_LATENCY.MAX.WARN}ms for 5m) |
The fetch phase should typically take much less time than the query phase. If you notice this metric consistently increasing, this could indicate a problem with slow disks, enriching of documents (highlighting the relevant text in search results, etc.), or requesting too many results.
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.indices.search.fetch_latency[{#ES.NODE}].min(5m)}>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Flush latency is too high (over {$ELASTICSEARCH.FLUSH_LATENCY.MAX.WARN}ms for 5m) |
If you see this metric increasing steadily, it may indicate a problem with slow disks; this problem may escalate and eventually prevent you from being able to add new information to your index.
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.indices.flush.latency[{#ES.NODE}].min(5m)}>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Indexing latency is too high (over {$ELASTICSEARCH.INDEXING_LATENCY.MAX.WARN}ms for 5m) |
If the latency is increasing, it may indicate that you are indexing too many documents at the same time (Elasticsearch’s documentation recommends starting with a bulk indexing size of 5 to 15 megabytes and increasing slowly from there).
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.indices.indexing.index_latency[{#ES.NODE}].min(5m)}>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Node {#ES.NODE} has been restarted (uptime < 10m) |
Uptime is less than 10 minutes
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.jvm.uptime[{#ES.NODE}].last()}<10m

Recovery expression:
 | information |
| ES {#ES.NODE}: Percent of JVM heap in use is critical (over {$ELASTICSEARCH.HEAP_USED.MAX.CRIT}% for 1h) |
This indicates that the rate of garbage collection isn’t keeping up with the rate of garbage creation. To address this problem, you can either increase your heap size (as long as it remains below the recommended guidelines stated above), or scale out the cluster by adding more nodes.
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.jvm.mem.heap_used_percent[{#ES.NODE}].min(1h)}>95

Recovery expression:
 | high |
| ES {#ES.NODE}: Percent of JVM heap in use is high (over {$ELASTICSEARCH.HEAP_USED.MAX.WARN}% for 1h) |
This indicates that the rate of garbage collection isn’t keeping up with the rate of garbage creation. To address this problem, you can either increase your heap size (as long as it remains below the recommended guidelines stated above), or scale out the cluster by adding more nodes.
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.jvm.mem.heap_used_percent[{#ES.NODE}].min(1h)}>85

Recovery expression:
 | warning |
| ES {#ES.NODE}: Query latency is too high (over {$ELASTICSEARCH.QUERY_LATENCY.MAX.WARN}ms for 5m) |
If latency exceeds a threshold, look for potential resource bottlenecks, or investigate whether you need to optimize your queries.
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.indices.search.query_latency[{#ES.NODE}].min(5m)}>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Refresh thread pool executor has the rejected tasks (for 5m) |
The number of tasks rejected by the refresh thread pool executor is over 0 for 5m.
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.thread_pool.refresh.rejected.rate[{#ES.NODE}].min(5m)}>0

Recovery expression:
 | warning |
| ES {#ES.NODE}: Search thread pool executor has the rejected tasks (for 5m) |
The number of tasks rejected by the search thread pool executor is over 0 for 5m.
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.thread_pool.search.rejected.rate[{#ES.NODE}].min(5m)}>0

Recovery expression:
 | warning |
| ES {#ES.NODE}: Write thread pool executor has the rejected tasks (for 5m) |
The number of tasks rejected by the write thread pool executor is over 0 for 5m.
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.thread_pool.write.rejected.rate[{#ES.NODE}].min(5m)}>0

Recovery expression:
 | warning |
| ES {#ES.NODE}: Fetch latency is too high (over {$ELASTICSEARCH.FETCH_LATENCY.MAX.WARN}ms for 5m) (LLD) |
The fetch phase should typically take much less time than the query phase. If you notice this metric consistently increasing, this could indicate a problem with slow disks, enriching of documents (highlighting the relevant text in search results, etc.), or requesting too many results.
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.indices.search.fetch_latency[{#ES.NODE}].min(5m)}>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Flush latency is too high (over {$ELASTICSEARCH.FLUSH_LATENCY.MAX.WARN}ms for 5m) (LLD) |
If you see this metric increasing steadily, it may indicate a problem with slow disks; this problem may escalate and eventually prevent you from being able to add new information to your index.
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.indices.flush.latency[{#ES.NODE}].min(5m)}>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Indexing latency is too high (over {$ELASTICSEARCH.INDEXING_LATENCY.MAX.WARN}ms for 5m) (LLD) |
If the latency is increasing, it may indicate that you are indexing too many documents at the same time (Elasticsearch’s documentation recommends starting with a bulk indexing size of 5 to 15 megabytes and increasing slowly from there).
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.indices.indexing.index_latency[{#ES.NODE}].min(5m)}>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Node {#ES.NODE} has been restarted (uptime < 10m) (LLD) |
Uptime is less than 10 minutes
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.jvm.uptime[{#ES.NODE}].last()}<10m

Recovery expression:
 | information |
| ES {#ES.NODE}: Percent of JVM heap in use is critical (over {$ELASTICSEARCH.HEAP_USED.MAX.CRIT}% for 1h) (LLD) |
This indicates that the rate of garbage collection isn’t keeping up with the rate of garbage creation. To address this problem, you can either increase your heap size (as long as it remains below the recommended guidelines stated above), or scale out the cluster by adding more nodes.
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.jvm.mem.heap_used_percent[{#ES.NODE}].min(1h)}>95

Recovery expression:
 | high |
| ES {#ES.NODE}: Percent of JVM heap in use is high (over {$ELASTICSEARCH.HEAP_USED.MAX.WARN}% for 1h) (LLD) |
This indicates that the rate of garbage collection isn’t keeping up with the rate of garbage creation. To address this problem, you can either increase your heap size (as long as it remains below the recommended guidelines stated above), or scale out the cluster by adding more nodes.
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.jvm.mem.heap_used_percent[{#ES.NODE}].min(1h)}>85

Recovery expression:
 | warning |
| ES {#ES.NODE}: Query latency is too high (over {$ELASTICSEARCH.QUERY_LATENCY.MAX.WARN}ms for 5m) (LLD) |
If latency exceeds a threshold, look for potential resource bottlenecks, or investigate whether you need to optimize your queries.
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.indices.search.query_latency[{#ES.NODE}].min(5m)}>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Refresh thread pool executor has the rejected tasks (for 5m) (LLD) |
The number of tasks rejected by the refresh thread pool executor is over 0 for 5m.
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.thread_pool.refresh.rejected.rate[{#ES.NODE}].min(5m)}>0

Recovery expression:
 | warning |
| ES {#ES.NODE}: Search thread pool executor has the rejected tasks (for 5m) (LLD) |
The number of tasks rejected by the search thread pool executor is over 0 for 5m.
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.thread_pool.search.rejected.rate[{#ES.NODE}].min(5m)}>0

Recovery expression:
 | warning |
| ES {#ES.NODE}: Write thread pool executor has the rejected tasks (for 5m) (LLD) |
The number of tasks rejected by the write thread pool executor is over 0 for 5m.
 |
Expression: {Elasticsearch Cluster by HTTP zbx 4.2:es.node.thread_pool.write.rejected.rate[{#ES.NODE}].min(5m)}>0

Recovery expression:
 | warning |
The template to monitor Elasticsearch by Zabbix that work without any external scripts. It works with both standalone and cluster instances. The metrics are collected in one pass remotely using an HTTP agent. They are getting values from REST API _cluster/health, _cluster/stats, _nodes/stats requests. You can set {$ELASTICSEARCH.USERNAME} and {$ELASTICSEARCH.PASSWORD} macros in the template for using on the host level. If you use an atypical location ES API, don’t forget to change the macros {$ELASTICSEARCH.SCHEME},{$ELASTICSEARCH.PORT}. Parsed manually from https://git.zabbix.com/projects/ZBX/repos/zabbix/browse/templates/app/elasticsearch_http from zabbix version 5.0 to 4.2 and add triggers
This is fork of official Zabbix template Elasticsearch Cluster by HTTP (Zabbix 5.0)
Features:
Tested on Zabbix 4.2 and Elasticsearch 7.4.2
R N
| Name | Description | Default | Type |
|---|---|---|---|
| {$ELASTICSEARCH.FETCH_LATENCY.MAX.WARN} |
-
 | 100 |
Text macro |
| {$ELASTICSEARCH.FLUSH_LATENCY.MAX.WARN} |
-
 | 100 |
Text macro |
| {$ELASTICSEARCH.HEAP_USED.MAX.CRIT} |
-
 | 95 |
Text macro |
| {$ELASTICSEARCH.HEAP_USED.MAX.WARN} |
-
 | 85 |
Text macro |
| {$ELASTICSEARCH.INDEXING_LATENCY.MAX.WARN} |
-
 | 100 |
Text macro |
| {$ELASTICSEARCH.MAX_SHARDS_PER_NODE} |
-
 | 1000 |
Text macro |
| {$ELASTICSEARCH.PASSWORD} |
-
 | `` | Text macro |
| {$ELASTICSEARCH.PORT} |
-
 | 9200 |
Text macro |
| {$ELASTICSEARCH.QUERY_LATENCY.MAX.WARN} |
-
 | 100 |
Text macro |
| {$ELASTICSEARCH.RESPONSE_TIME.MAX.WARN} |
-
 | 10s |
Text macro |
| {$ELASTICSEARCH.SCHEME} |
-
 | http |
Text macro |
| {$ELASTICSEARCH.USERNAME} |
-
 | `` | Text macro |
There are no template links in this template.
| Name | Description | Type | Key and additional info |
|---|---|---|---|
| Cluster nodes discovery |
Discovery ES cluster nodes.
 | HTTP agent |
es.nodes.discovery
Update: 1h
 |
| Name | Description | Type | Key and additional info |
|---|---|---|---|
| ES: Task max waiting in queue |
The time expressed in seconds since the earliest initiated task is waiting for being performed.
 | Dependent item |
es.cluster.task_max_waiting_in_queue
Update: 0
 |
| ES: Number of relocating shards |
The number of shards that are under relocation.
 | Dependent item |
es.cluster.relocating_shards
Update: 0
 |
| ES: Indices with shards assigned to nodes |
The total number of indices with shards assigned to the selected nodes.
 | Dependent item |
es.indices.count
Update: 0
 |
| ES: Number of pending tasks |
The number of cluster-level changes that have not yet been executed.
 | Dependent item |
es.cluster.number_of_pending_tasks
Update: 0
 |
| ES: Number of unassigned shards |
The number of shards that are not allocated.
 | Dependent item |
es.cluster.unassigned_shards
Update: 0
 |
| ES: Cluster uptime |
Uptime duration in seconds since JVM has last started.
 | Dependent item |
es.nodes.jvm.max_uptime[{#ES.NODE}]
Update: 0
 |
| ES: Total available size to JVM in all file stores |
The total number of bytes available to JVM in the file stores across all selected nodes. Depending on OS or process-level restrictions, this number may be less than nodes.fs.free_in_byes. This is the actual amount of free disk space the selected Elasticsearch nodes can use.
 | Dependent item |
es.nodes.fs.available_in_bytes
Update: 0
 |
| ES: Number of data nodes |
The number of nodes that are dedicated to data nodes.
 | Dependent item |
es.cluster.number_of_data_nodes
Update: 0
 |
| ES: Get cluster health |
Returns the health status of a cluster.
 | HTTP agent |
es.cluster.get_health
Update: 1m
 |
| ES: Total shards |
Total number of shards
 | Dependent item |
es.shards.total
Update: 0
 |
| ES: Number of nodes |
The number of nodes within the cluster.
 | Dependent item |
es.cluster.number_of_nodes
Update: 0
 |
| ES: Delayed unassigned shards |
The number of shards whose allocation has been delayed by the timeout settings.
 | Dependent item |
es.cluster.delayed_unassigned_shards
Update: 0
 |
| ES: Cluster health status |
Health status of the cluster, based on the state of its primary and replica shards. Statuses are: green All shards are assigned. yellow All primary shards are assigned, but one or more replica shards are unassigned. If a node in the cluster fails, some data could be unavailable until that node is repaired. red One or more primary shards are unassigned, so some data is unavailable. This can occur briefly during cluster startup as primary shards are assigned.
 | Dependent item |
es.cluster.status
Update: 0
 |
| ES: Nodes with the ingest role |
The number of selected nodes with the ingest role.
 | Dependent item |
es.nodes.count.ingest
Update: 0
 |
| ES: Total size of all file stores |
The total size in bytes of all file stores across all selected nodes.
 | Dependent item |
es.nodes.fs.total_in_bytes
Update: 0
 |
| ES: Inactive shards percentage |
The ratio of inactive shards in the cluster expressed as a percentage.
 | Dependent item |
es.cluster.inactive_shards_percent_as_number
Update: 0
 |
| ES: Get cluster stats |
Returns cluster statistics.
 | HTTP agent |
es.cluster.get_stats
Update: 1m
 |
| ES: Get cluster version |
Returns the cluster version
 | HTTP agent |
es.cluster.get_version
Update: 1h
 |
| ES: Number of initializing shards |
The number of shards that are under initialization.
 | Dependent item |
es.cluster.initializing_shards
Update: 0
 |
| ES: Nodes with the master role |
The number of selected nodes with the master role.
 | Dependent item |
es.nodes.count.master
Update: 0
 |
| ES: Service response time |
Checks performance of the TCP service.
 | Simple check |
net.tcp.service.perf[”{$ELASTICSEARCH.SCHEME}”,”{HOST.CONN}”,”{$ELASTICSEARCH.PORT}”]
Update: 1m
 |
| ES: Number of non-deleted documents |
The total number of non-deleted documents across all primary shards assigned to the selected nodes. This number is based on the documents in Lucene segments and may include the documents from nested fields.
 | Dependent item |
es.indices.docs.count
Update: 0
 |
| ES: Nodes with the data role |
The number of selected nodes with the data role.
 | Dependent item |
es.nodes.count.data
Update: 0
 |
| ES: Service status |
Checks if the service is running and accepting TCP connections.
 | Simple check |
net.tcp.service[”{$ELASTICSEARCH.SCHEME}”,”{HOST.CONN}”,”{$ELASTICSEARCH.PORT}”]
Update: 1m
 |
| ES: Get nodes stats |
Returns cluster nodes statistics.
 | HTTP agent |
es.nodes.get_stats
Update: 1m
 |
| ES {#ES.NODE}: Flush latency |
The average flush latency calculated from the available flush.total and flush.total_time_in_millis metrics.
 | Calculated |
es.node.indices.flush.latency[{#ES.NODE}]
Update: 1m

LLD
 |
| ES {#ES.NODE}: Fetch latency |
The average fetch latency calculated by sampling the total number of fetches and the total elapsed time at regular intervals.
 | Calculated |
es.node.indices.search.fetch_latency[{#ES.NODE}]
Update: 1m

LLD
 |
| ES {#ES.NODE}: Indexing latency |
The average indexing latency calculated from the available index_total and index_time_in_millis metrics.
 | Calculated |
es.node.indices.indexing.index_latency[{#ES.NODE}]
Update: 1m

LLD
 |
| ES {#ES.NODE}: Query latency |
The average query latency calculated by sampling the total number of queries and the total elapsed time at regular intervals.
 | Calculated |
es.node.indices.search.query_latency[{#ES.NODE}]
Update: 1m

LLD
 |
| ES {#ES.NODE}: Total available size |
The 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 fs.total.free_in_bytes. This is the actual amount of free disk space the Elasticsearch node can utilize.
 | Dependent item |
es.node.fs.total.available_in_bytes[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Refresh thread pool active threads |
The number of active threads in the refresh thread pool.
 | Dependent item |
es.node.thread_pool.refresh.active[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total time spent performing query |
Time in milliseconds spent performing query operations.
 | Dependent item |
es.node.indices.search.query_time_in_millis[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total number of query |
The total number of query operations.
 | Dependent item |
es.node.indices.search.query_total[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Amount of JVM heap committed |
The amount of memory, in bytes, available for use by the heap.
 | Dependent item |
es.node.jvm.mem.heap_committed_in_bytes[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Maximum JVM memory available for use |
The maximum amount of memory, in bytes, available for use by the heap.
 | Dependent item |
es.node.jvm.mem.heap_max_in_bytes[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Amount of JVM heap currently in use |
The memory, in bytes, currently in use by the heap.
 | Dependent item |
es.node.jvm.mem.heap_used_in_bytes[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Percent of JVM heap currently in use |
The percentage of memory currently in use by the heap.
 | Dependent item |
es.node.jvm.mem.heap_used_percent[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Node uptime |
JVM uptime in seconds.
 | Dependent item |
es.node.jvm.uptime[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Refresh thread pool tasks in queue |
The number of tasks in queue for the refresh thread pool.
 | Dependent item |
es.node.thread_pool.refresh.queue[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Refresh thread pool executor tasks completed |
The number of tasks completed by the refresh thread pool executor.
 | Dependent item |
es.node.thread_pool.refresh.completed.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Refresh thread pool executor tasks rejected |
The number of tasks rejected by the refresh thread pool executor.
 | Dependent item |
es.node.thread_pool.refresh.rejected.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Search thread pool active threads |
The number of active threads in the search thread pool.
 | Dependent item |
es.node.thread_pool.search.active[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Search thread pool executor tasks completed |
The number of tasks completed by the search thread pool executor.
 | Dependent item |
es.node.thread_pool.search.completed.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Search thread pool tasks in queue |
The number of tasks in queue for the search thread pool.
 | Dependent item |
es.node.thread_pool.search.queue[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Search thread pool executor tasks rejected |
The number of tasks rejected by the search thread pool executor.
 | Dependent item |
es.node.thread_pool.search.rejected.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Write thread pool active threads |
The number of active threads in the write thread pool.
 | Dependent item |
es.node.thread_pool.write.active[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Write thread pool executor tasks completed |
The number of tasks completed by the write thread pool executor.
 | Dependent item |
es.node.thread_pool.write.completed.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Write thread pool tasks in queue |
The number of tasks in queue for the write thread pool.
 | Dependent item |
es.node.thread_pool.write.queue[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent performing query |
Time in seconds spent performing query operations for the last measuring span.
 | Dependent item |
es.node.indices.search.query_time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Rate of queries |
The number of query operations per second.
 | Dependent item |
es.node.indices.search.query.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Current query operations |
The number of query operations currently running.
 | Dependent item |
es.node.indices.search.query_current[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent throttling operations |
Time in seconds spent throttling operations for the last measuring span.
 | Dependent item |
es.node.indices.indexing.throttle_time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Number of open HTTP connections |
The number of currently open HTTP connections for the node.
 | Dependent item |
es.node.http.current_open[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Rate of HTTP connections opened |
The number of HTTP connections opened for the node per second.
 | Dependent item |
es.node.http.opened.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total number of index flushes to disk |
The total number of flush operations.
 | Dependent item |
es.node.indices.flush.total[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total time spent on flushing indices to disk |
Total time in milliseconds spent performing flush operations.
 | Dependent item |
es.node.indices.flush.total_time_in_millis[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Current indexing operations |
The number of indexing operations currently running.
 | Dependent item |
es.node.indices.indexing.index_current[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total time spent performing indexing |
Total time in milliseconds spent performing indexing operations.
 | Dependent item |
es.node.indices.indexing.index_time_in_millis[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total number of indexing |
The total number of indexing operations.
 | Dependent item |
es.node.indices.indexing.index_total[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent throttling merge operations |
Time in seconds spent throttling merge operations for the last measuring span.
 | Dependent item |
es.node.indices.merges.total_throttled_time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total size |
Total size (in bytes) of all file stores.
 | Dependent item |
es.node.fs.total.total_in_bytes[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent throttling recovery operations |
Time in seconds spent throttling recovery operations for the last measuring span.
 | Dependent item |
es.node.indices.recovery.throttle_time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Rate of index refreshes |
The number of refresh operations per second.
 | Dependent item |
es.node.indices.refresh.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent performing refresh |
Time in seconds spent performing refresh operations for the last measuring span.
 | Dependent item |
es.node.indices.refresh.time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Rate of fetch |
The number of fetch operations per second.
 | Dependent item |
es.node.indices.search.fetch.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Current fetch operations |
The number of fetch operations currently running.
 | Dependent item |
es.node.indices.search.fetch_current[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent performing fetch |
Time in seconds spent performing fetch operations for the last measuring span.
 | Dependent item |
es.node.indices.search.fetch_time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total time spent performing fetch |
Time in milliseconds spent performing fetch operations.
 | Dependent item |
es.node.indices.search.fetch_time_in_millis[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total number of fetch |
The total number of fetch operations.
 | Dependent item |
es.node.indices.search.fetch_total[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Write thread pool executor tasks rejected |
The number of tasks rejected by the write thread pool executor.
 | Dependent item |
es.node.thread_pool.write.rejected.rate[{#ES.NODE}]
Update: 0

LLD
 |
| Name | Description | Expression | Priority |
|---|---|---|---|
| ES {#ES.NODE}: Fetch latency is too high (over {$ELASTICSEARCH.FETCH_LATENCY.MAX.WARN}ms for 5m) |
The fetch phase should typically take much less time than the query phase. If you notice this metric consistently increasing, this could indicate a problem with slow disks, enriching of documents (highlighting the relevant text in search results, etc.), or requesting too many results.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.indices.search.fetch_latency[{#ES.NODE}],5m)>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Flush latency is too high (over {$ELASTICSEARCH.FLUSH_LATENCY.MAX.WARN}ms for 5m) |
If you see this metric increasing steadily, it may indicate a problem with slow disks; this problem may escalate and eventually prevent you from being able to add new information to your index.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.indices.flush.latency[{#ES.NODE}],5m)>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Indexing latency is too high (over {$ELASTICSEARCH.INDEXING_LATENCY.MAX.WARN}ms for 5m) |
If the latency is increasing, it may indicate that you are indexing too many documents at the same time (Elasticsearch’s documentation recommends starting with a bulk indexing size of 5 to 15 megabytes and increasing slowly from there).
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.indices.indexing.index_latency[{#ES.NODE}],5m)>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Node {#ES.NODE} has been restarted (uptime < 10m) |
Uptime is less than 10 minutes
 |
Expression: last(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.jvm.uptime[{#ES.NODE}])<10m

Recovery expression:
 | information |
| ES {#ES.NODE}: Percent of JVM heap in use is critical (over {$ELASTICSEARCH.HEAP_USED.MAX.CRIT}% for 1h) |
This indicates that the rate of garbage collection isn’t keeping up with the rate of garbage creation. To address this problem, you can either increase your heap size (as long as it remains below the recommended guidelines stated above), or scale out the cluster by adding more nodes.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.jvm.mem.heap_used_percent[{#ES.NODE}],1h)>95

Recovery expression:
 | high |
| ES {#ES.NODE}: Percent of JVM heap in use is high (over {$ELASTICSEARCH.HEAP_USED.MAX.WARN}% for 1h) |
This indicates that the rate of garbage collection isn’t keeping up with the rate of garbage creation. To address this problem, you can either increase your heap size (as long as it remains below the recommended guidelines stated above), or scale out the cluster by adding more nodes.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.jvm.mem.heap_used_percent[{#ES.NODE}],1h)>85

Recovery expression:
 | warning |
| ES {#ES.NODE}: Query latency is too high (over {$ELASTICSEARCH.QUERY_LATENCY.MAX.WARN}ms for 5m) |
If latency exceeds a threshold, look for potential resource bottlenecks, or investigate whether you need to optimize your queries.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.indices.search.query_latency[{#ES.NODE}],5m)>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Refresh thread pool executor has the rejected tasks (for 5m) |
The number of tasks rejected by the refresh thread pool executor is over 0 for 5m.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.thread_pool.refresh.rejected.rate[{#ES.NODE}],5m)>0

Recovery expression:
 | warning |
| ES {#ES.NODE}: Search thread pool executor has the rejected tasks (for 5m) |
The number of tasks rejected by the search thread pool executor is over 0 for 5m.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.thread_pool.search.rejected.rate[{#ES.NODE}],5m)>0

Recovery expression:
 | warning |
| ES {#ES.NODE}: Write thread pool executor has the rejected tasks (for 5m) |
The number of tasks rejected by the write thread pool executor is over 0 for 5m.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.thread_pool.write.rejected.rate[{#ES.NODE}],5m)>0

Recovery expression:
 | warning |
| ES {#ES.NODE}: Fetch latency is too high (over {$ELASTICSEARCH.FETCH_LATENCY.MAX.WARN}ms for 5m) (LLD) |
The fetch phase should typically take much less time than the query phase. If you notice this metric consistently increasing, this could indicate a problem with slow disks, enriching of documents (highlighting the relevant text in search results, etc.), or requesting too many results.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.indices.search.fetch_latency[{#ES.NODE}],5m)>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Flush latency is too high (over {$ELASTICSEARCH.FLUSH_LATENCY.MAX.WARN}ms for 5m) (LLD) |
If you see this metric increasing steadily, it may indicate a problem with slow disks; this problem may escalate and eventually prevent you from being able to add new information to your index.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.indices.flush.latency[{#ES.NODE}],5m)>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Indexing latency is too high (over {$ELASTICSEARCH.INDEXING_LATENCY.MAX.WARN}ms for 5m) (LLD) |
If the latency is increasing, it may indicate that you are indexing too many documents at the same time (Elasticsearch’s documentation recommends starting with a bulk indexing size of 5 to 15 megabytes and increasing slowly from there).
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.indices.indexing.index_latency[{#ES.NODE}],5m)>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Node {#ES.NODE} has been restarted (uptime < 10m) (LLD) |
Uptime is less than 10 minutes
 |
Expression: last(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.jvm.uptime[{#ES.NODE}])<10m

Recovery expression:
 | information |
| ES {#ES.NODE}: Percent of JVM heap in use is critical (over {$ELASTICSEARCH.HEAP_USED.MAX.CRIT}% for 1h) (LLD) |
This indicates that the rate of garbage collection isn’t keeping up with the rate of garbage creation. To address this problem, you can either increase your heap size (as long as it remains below the recommended guidelines stated above), or scale out the cluster by adding more nodes.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.jvm.mem.heap_used_percent[{#ES.NODE}],1h)>95

Recovery expression:
 | high |
| ES {#ES.NODE}: Percent of JVM heap in use is high (over {$ELASTICSEARCH.HEAP_USED.MAX.WARN}% for 1h) (LLD) |
This indicates that the rate of garbage collection isn’t keeping up with the rate of garbage creation. To address this problem, you can either increase your heap size (as long as it remains below the recommended guidelines stated above), or scale out the cluster by adding more nodes.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.jvm.mem.heap_used_percent[{#ES.NODE}],1h)>85

Recovery expression:
 | warning |
| ES {#ES.NODE}: Query latency is too high (over {$ELASTICSEARCH.QUERY_LATENCY.MAX.WARN}ms for 5m) (LLD) |
If latency exceeds a threshold, look for potential resource bottlenecks, or investigate whether you need to optimize your queries.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.indices.search.query_latency[{#ES.NODE}],5m)>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Refresh thread pool executor has the rejected tasks (for 5m) (LLD) |
The number of tasks rejected by the refresh thread pool executor is over 0 for 5m.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.thread_pool.refresh.rejected.rate[{#ES.NODE}],5m)>0

Recovery expression:
 | warning |
| ES {#ES.NODE}: Search thread pool executor has the rejected tasks (for 5m) (LLD) |
The number of tasks rejected by the search thread pool executor is over 0 for 5m.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.thread_pool.search.rejected.rate[{#ES.NODE}],5m)>0

Recovery expression:
 | warning |
| ES {#ES.NODE}: Write thread pool executor has the rejected tasks (for 5m) (LLD) |
The number of tasks rejected by the write thread pool executor is over 0 for 5m.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.thread_pool.write.rejected.rate[{#ES.NODE}],5m)>0

Recovery expression:
 | warning |
The template to monitor Elasticsearch by Zabbix that work without any external scripts. It works with both standalone and cluster instances. The metrics are collected in one pass remotely using an HTTP agent. They are getting values from REST API _cluster/health, _cluster/stats, _nodes/stats requests. You can set {$ELASTICSEARCH.USERNAME} and {$ELASTICSEARCH.PASSWORD} macros in the template for using on the host level. If you use an atypical location ES API, don’t forget to change the macros {$ELASTICSEARCH.SCHEME},{$ELASTICSEARCH.PORT}. Parsed manually from https://git.zabbix.com/projects/ZBX/repos/zabbix/browse/templates/app/elasticsearch_http from zabbix version 5.0 to 4.2 and add triggers
This is fork of official Zabbix template Elasticsearch Cluster by HTTP (Zabbix 5.0)
Features:
Tested on Zabbix 4.2 and Elasticsearch 7.4.2
R N
| Name | Description | Default | Type |
|---|---|---|---|
| {$ELASTICSEARCH.FETCH_LATENCY.MAX.WARN} |
-
 | 100 |
Text macro |
| {$ELASTICSEARCH.FLUSH_LATENCY.MAX.WARN} |
-
 | 100 |
Text macro |
| {$ELASTICSEARCH.HEAP_USED.MAX.CRIT} |
-
 | 95 |
Text macro |
| {$ELASTICSEARCH.HEAP_USED.MAX.WARN} |
-
 | 85 |
Text macro |
| {$ELASTICSEARCH.INDEXING_LATENCY.MAX.WARN} |
-
 | 100 |
Text macro |
| {$ELASTICSEARCH.MAX_SHARDS_PER_NODE} |
-
 | 1000 |
Text macro |
| {$ELASTICSEARCH.PASSWORD} |
-
 | `` | Text macro |
| {$ELASTICSEARCH.PORT} |
-
 | 9200 |
Text macro |
| {$ELASTICSEARCH.QUERY_LATENCY.MAX.WARN} |
-
 | 100 |
Text macro |
| {$ELASTICSEARCH.RESPONSE_TIME.MAX.WARN} |
-
 | 10s |
Text macro |
| {$ELASTICSEARCH.SCHEME} |
-
 | http |
Text macro |
| {$ELASTICSEARCH.USERNAME} |
-
 | `` | Text macro |
There are no template links in this template.
| Name | Description | Type | Key and additional info |
|---|---|---|---|
| Cluster nodes discovery |
Discovery ES cluster nodes.
 | HTTP agent |
es.nodes.discovery
Update: 1h
 |
| Name | Description | Type | Key and additional info |
|---|---|---|---|
| ES: Task max waiting in queue |
The time expressed in seconds since the earliest initiated task is waiting for being performed.
 | Dependent item |
es.cluster.task_max_waiting_in_queue
Update: 0
 |
| ES: Number of relocating shards |
The number of shards that are under relocation.
 | Dependent item |
es.cluster.relocating_shards
Update: 0
 |
| ES: Indices with shards assigned to nodes |
The total number of indices with shards assigned to the selected nodes.
 | Dependent item |
es.indices.count
Update: 0
 |
| ES: Number of pending tasks |
The number of cluster-level changes that have not yet been executed.
 | Dependent item |
es.cluster.number_of_pending_tasks
Update: 0
 |
| ES: Number of unassigned shards |
The number of shards that are not allocated.
 | Dependent item |
es.cluster.unassigned_shards
Update: 0
 |
| ES: Cluster uptime |
Uptime duration in seconds since JVM has last started.
 | Dependent item |
es.nodes.jvm.max_uptime[{#ES.NODE}]
Update: 0
 |
| ES: Total available size to JVM in all file stores |
The total number of bytes available to JVM in the file stores across all selected nodes. Depending on OS or process-level restrictions, this number may be less than nodes.fs.free_in_byes. This is the actual amount of free disk space the selected Elasticsearch nodes can use.
 | Dependent item |
es.nodes.fs.available_in_bytes
Update: 0
 |
| ES: Number of data nodes |
The number of nodes that are dedicated to data nodes.
 | Dependent item |
es.cluster.number_of_data_nodes
Update: 0
 |
| ES: Get cluster health |
Returns the health status of a cluster.
 | HTTP agent |
es.cluster.get_health
Update: 1m
 |
| ES: Total shards |
Total number of shards
 | Dependent item |
es.shards.total
Update: 0
 |
| ES: Number of nodes |
The number of nodes within the cluster.
 | Dependent item |
es.cluster.number_of_nodes
Update: 0
 |
| ES: Delayed unassigned shards |
The number of shards whose allocation has been delayed by the timeout settings.
 | Dependent item |
es.cluster.delayed_unassigned_shards
Update: 0
 |
| ES: Cluster health status |
Health status of the cluster, based on the state of its primary and replica shards. Statuses are: green All shards are assigned. yellow All primary shards are assigned, but one or more replica shards are unassigned. If a node in the cluster fails, some data could be unavailable until that node is repaired. red One or more primary shards are unassigned, so some data is unavailable. This can occur briefly during cluster startup as primary shards are assigned.
 | Dependent item |
es.cluster.status
Update: 0
 |
| ES: Nodes with the ingest role |
The number of selected nodes with the ingest role.
 | Dependent item |
es.nodes.count.ingest
Update: 0
 |
| ES: Total size of all file stores |
The total size in bytes of all file stores across all selected nodes.
 | Dependent item |
es.nodes.fs.total_in_bytes
Update: 0
 |
| ES: Inactive shards percentage |
The ratio of inactive shards in the cluster expressed as a percentage.
 | Dependent item |
es.cluster.inactive_shards_percent_as_number
Update: 0
 |
| ES: Get cluster stats |
Returns cluster statistics.
 | HTTP agent |
es.cluster.get_stats
Update: 1m
 |
| ES: Get cluster version |
Returns the cluster version
 | HTTP agent |
es.cluster.get_version
Update: 1h
 |
| ES: Number of initializing shards |
The number of shards that are under initialization.
 | Dependent item |
es.cluster.initializing_shards
Update: 0
 |
| ES: Nodes with the master role |
The number of selected nodes with the master role.
 | Dependent item |
es.nodes.count.master
Update: 0
 |
| ES: Service response time |
Checks performance of the TCP service.
 | Simple check |
net.tcp.service.perf[”{$ELASTICSEARCH.SCHEME}”,”{HOST.CONN}”,”{$ELASTICSEARCH.PORT}”]
Update: 1m
 |
| ES: Number of non-deleted documents |
The total number of non-deleted documents across all primary shards assigned to the selected nodes. This number is based on the documents in Lucene segments and may include the documents from nested fields.
 | Dependent item |
es.indices.docs.count
Update: 0
 |
| ES: Nodes with the data role |
The number of selected nodes with the data role.
 | Dependent item |
es.nodes.count.data
Update: 0
 |
| ES: Service status |
Checks if the service is running and accepting TCP connections.
 | Simple check |
net.tcp.service[”{$ELASTICSEARCH.SCHEME}”,”{HOST.CONN}”,”{$ELASTICSEARCH.PORT}”]
Update: 1m
 |
| ES: Get nodes stats |
Returns cluster nodes statistics.
 | HTTP agent |
es.nodes.get_stats
Update: 1m
 |
| ES {#ES.NODE}: Flush latency |
The average flush latency calculated from the available flush.total and flush.total_time_in_millis metrics.
 | Calculated |
es.node.indices.flush.latency[{#ES.NODE}]
Update: 1m

LLD
 |
| ES {#ES.NODE}: Fetch latency |
The average fetch latency calculated by sampling the total number of fetches and the total elapsed time at regular intervals.
 | Calculated |
es.node.indices.search.fetch_latency[{#ES.NODE}]
Update: 1m

LLD
 |
| ES {#ES.NODE}: Indexing latency |
The average indexing latency calculated from the available index_total and index_time_in_millis metrics.
 | Calculated |
es.node.indices.indexing.index_latency[{#ES.NODE}]
Update: 1m

LLD
 |
| ES {#ES.NODE}: Query latency |
The average query latency calculated by sampling the total number of queries and the total elapsed time at regular intervals.
 | Calculated |
es.node.indices.search.query_latency[{#ES.NODE}]
Update: 1m

LLD
 |
| ES {#ES.NODE}: Total available size |
The 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 fs.total.free_in_bytes. This is the actual amount of free disk space the Elasticsearch node can utilize.
 | Dependent item |
es.node.fs.total.available_in_bytes[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Refresh thread pool active threads |
The number of active threads in the refresh thread pool.
 | Dependent item |
es.node.thread_pool.refresh.active[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total time spent performing query |
Time in milliseconds spent performing query operations.
 | Dependent item |
es.node.indices.search.query_time_in_millis[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total number of query |
The total number of query operations.
 | Dependent item |
es.node.indices.search.query_total[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Amount of JVM heap committed |
The amount of memory, in bytes, available for use by the heap.
 | Dependent item |
es.node.jvm.mem.heap_committed_in_bytes[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Maximum JVM memory available for use |
The maximum amount of memory, in bytes, available for use by the heap.
 | Dependent item |
es.node.jvm.mem.heap_max_in_bytes[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Amount of JVM heap currently in use |
The memory, in bytes, currently in use by the heap.
 | Dependent item |
es.node.jvm.mem.heap_used_in_bytes[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Percent of JVM heap currently in use |
The percentage of memory currently in use by the heap.
 | Dependent item |
es.node.jvm.mem.heap_used_percent[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Node uptime |
JVM uptime in seconds.
 | Dependent item |
es.node.jvm.uptime[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Refresh thread pool tasks in queue |
The number of tasks in queue for the refresh thread pool.
 | Dependent item |
es.node.thread_pool.refresh.queue[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Refresh thread pool executor tasks completed |
The number of tasks completed by the refresh thread pool executor.
 | Dependent item |
es.node.thread_pool.refresh.completed.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Refresh thread pool executor tasks rejected |
The number of tasks rejected by the refresh thread pool executor.
 | Dependent item |
es.node.thread_pool.refresh.rejected.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Search thread pool active threads |
The number of active threads in the search thread pool.
 | Dependent item |
es.node.thread_pool.search.active[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Search thread pool executor tasks completed |
The number of tasks completed by the search thread pool executor.
 | Dependent item |
es.node.thread_pool.search.completed.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Search thread pool tasks in queue |
The number of tasks in queue for the search thread pool.
 | Dependent item |
es.node.thread_pool.search.queue[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Search thread pool executor tasks rejected |
The number of tasks rejected by the search thread pool executor.
 | Dependent item |
es.node.thread_pool.search.rejected.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Write thread pool active threads |
The number of active threads in the write thread pool.
 | Dependent item |
es.node.thread_pool.write.active[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Write thread pool executor tasks completed |
The number of tasks completed by the write thread pool executor.
 | Dependent item |
es.node.thread_pool.write.completed.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Write thread pool tasks in queue |
The number of tasks in queue for the write thread pool.
 | Dependent item |
es.node.thread_pool.write.queue[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent performing query |
Time in seconds spent performing query operations for the last measuring span.
 | Dependent item |
es.node.indices.search.query_time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Rate of queries |
The number of query operations per second.
 | Dependent item |
es.node.indices.search.query.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Current query operations |
The number of query operations currently running.
 | Dependent item |
es.node.indices.search.query_current[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent throttling operations |
Time in seconds spent throttling operations for the last measuring span.
 | Dependent item |
es.node.indices.indexing.throttle_time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Number of open HTTP connections |
The number of currently open HTTP connections for the node.
 | Dependent item |
es.node.http.current_open[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Rate of HTTP connections opened |
The number of HTTP connections opened for the node per second.
 | Dependent item |
es.node.http.opened.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total number of index flushes to disk |
The total number of flush operations.
 | Dependent item |
es.node.indices.flush.total[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total time spent on flushing indices to disk |
Total time in milliseconds spent performing flush operations.
 | Dependent item |
es.node.indices.flush.total_time_in_millis[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Current indexing operations |
The number of indexing operations currently running.
 | Dependent item |
es.node.indices.indexing.index_current[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total time spent performing indexing |
Total time in milliseconds spent performing indexing operations.
 | Dependent item |
es.node.indices.indexing.index_time_in_millis[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total number of indexing |
The total number of indexing operations.
 | Dependent item |
es.node.indices.indexing.index_total[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent throttling merge operations |
Time in seconds spent throttling merge operations for the last measuring span.
 | Dependent item |
es.node.indices.merges.total_throttled_time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total size |
Total size (in bytes) of all file stores.
 | Dependent item |
es.node.fs.total.total_in_bytes[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent throttling recovery operations |
Time in seconds spent throttling recovery operations for the last measuring span.
 | Dependent item |
es.node.indices.recovery.throttle_time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Rate of index refreshes |
The number of refresh operations per second.
 | Dependent item |
es.node.indices.refresh.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent performing refresh |
Time in seconds spent performing refresh operations for the last measuring span.
 | Dependent item |
es.node.indices.refresh.time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Rate of fetch |
The number of fetch operations per second.
 | Dependent item |
es.node.indices.search.fetch.rate[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Current fetch operations |
The number of fetch operations currently running.
 | Dependent item |
es.node.indices.search.fetch_current[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Time spent performing fetch |
Time in seconds spent performing fetch operations for the last measuring span.
 | Dependent item |
es.node.indices.search.fetch_time[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total time spent performing fetch |
Time in milliseconds spent performing fetch operations.
 | Dependent item |
es.node.indices.search.fetch_time_in_millis[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Total number of fetch |
The total number of fetch operations.
 | Dependent item |
es.node.indices.search.fetch_total[{#ES.NODE}]
Update: 0

LLD
 |
| ES {#ES.NODE}: Write thread pool executor tasks rejected |
The number of tasks rejected by the write thread pool executor.
 | Dependent item |
es.node.thread_pool.write.rejected.rate[{#ES.NODE}]
Update: 0

LLD
 |
| Name | Description | Expression | Priority |
|---|---|---|---|
| ES {#ES.NODE}: Fetch latency is too high (over {$ELASTICSEARCH.FETCH_LATENCY.MAX.WARN}ms for 5m) |
The fetch phase should typically take much less time than the query phase. If you notice this metric consistently increasing, this could indicate a problem with slow disks, enriching of documents (highlighting the relevant text in search results, etc.), or requesting too many results.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.indices.search.fetch_latency[{#ES.NODE}],5m)>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Flush latency is too high (over {$ELASTICSEARCH.FLUSH_LATENCY.MAX.WARN}ms for 5m) |
If you see this metric increasing steadily, it may indicate a problem with slow disks; this problem may escalate and eventually prevent you from being able to add new information to your index.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.indices.flush.latency[{#ES.NODE}],5m)>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Indexing latency is too high (over {$ELASTICSEARCH.INDEXING_LATENCY.MAX.WARN}ms for 5m) |
If the latency is increasing, it may indicate that you are indexing too many documents at the same time (Elasticsearch’s documentation recommends starting with a bulk indexing size of 5 to 15 megabytes and increasing slowly from there).
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.indices.indexing.index_latency[{#ES.NODE}],5m)>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Node {#ES.NODE} has been restarted (uptime < 10m) |
Uptime is less than 10 minutes
 |
Expression: last(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.jvm.uptime[{#ES.NODE}])<10m

Recovery expression:
 | information |
| ES {#ES.NODE}: Percent of JVM heap in use is critical (over {$ELASTICSEARCH.HEAP_USED.MAX.CRIT}% for 1h) |
This indicates that the rate of garbage collection isn’t keeping up with the rate of garbage creation. To address this problem, you can either increase your heap size (as long as it remains below the recommended guidelines stated above), or scale out the cluster by adding more nodes.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.jvm.mem.heap_used_percent[{#ES.NODE}],1h)>95

Recovery expression:
 | high |
| ES {#ES.NODE}: Percent of JVM heap in use is high (over {$ELASTICSEARCH.HEAP_USED.MAX.WARN}% for 1h) |
This indicates that the rate of garbage collection isn’t keeping up with the rate of garbage creation. To address this problem, you can either increase your heap size (as long as it remains below the recommended guidelines stated above), or scale out the cluster by adding more nodes.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.jvm.mem.heap_used_percent[{#ES.NODE}],1h)>85

Recovery expression:
 | warning |
| ES {#ES.NODE}: Query latency is too high (over {$ELASTICSEARCH.QUERY_LATENCY.MAX.WARN}ms for 5m) |
If latency exceeds a threshold, look for potential resource bottlenecks, or investigate whether you need to optimize your queries.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.indices.search.query_latency[{#ES.NODE}],5m)>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Refresh thread pool executor has the rejected tasks (for 5m) |
The number of tasks rejected by the refresh thread pool executor is over 0 for 5m.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.thread_pool.refresh.rejected.rate[{#ES.NODE}],5m)>0

Recovery expression:
 | warning |
| ES {#ES.NODE}: Search thread pool executor has the rejected tasks (for 5m) |
The number of tasks rejected by the search thread pool executor is over 0 for 5m.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.thread_pool.search.rejected.rate[{#ES.NODE}],5m)>0

Recovery expression:
 | warning |
| ES {#ES.NODE}: Write thread pool executor has the rejected tasks (for 5m) |
The number of tasks rejected by the write thread pool executor is over 0 for 5m.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.thread_pool.write.rejected.rate[{#ES.NODE}],5m)>0

Recovery expression:
 | warning |
| ES {#ES.NODE}: Fetch latency is too high (over {$ELASTICSEARCH.FETCH_LATENCY.MAX.WARN}ms for 5m) (LLD) |
The fetch phase should typically take much less time than the query phase. If you notice this metric consistently increasing, this could indicate a problem with slow disks, enriching of documents (highlighting the relevant text in search results, etc.), or requesting too many results.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.indices.search.fetch_latency[{#ES.NODE}],5m)>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Flush latency is too high (over {$ELASTICSEARCH.FLUSH_LATENCY.MAX.WARN}ms for 5m) (LLD) |
If you see this metric increasing steadily, it may indicate a problem with slow disks; this problem may escalate and eventually prevent you from being able to add new information to your index.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.indices.flush.latency[{#ES.NODE}],5m)>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Indexing latency is too high (over {$ELASTICSEARCH.INDEXING_LATENCY.MAX.WARN}ms for 5m) (LLD) |
If the latency is increasing, it may indicate that you are indexing too many documents at the same time (Elasticsearch’s documentation recommends starting with a bulk indexing size of 5 to 15 megabytes and increasing slowly from there).
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.indices.indexing.index_latency[{#ES.NODE}],5m)>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Node {#ES.NODE} has been restarted (uptime < 10m) (LLD) |
Uptime is less than 10 minutes
 |
Expression: last(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.jvm.uptime[{#ES.NODE}])<10m

Recovery expression:
 | information |
| ES {#ES.NODE}: Percent of JVM heap in use is critical (over {$ELASTICSEARCH.HEAP_USED.MAX.CRIT}% for 1h) (LLD) |
This indicates that the rate of garbage collection isn’t keeping up with the rate of garbage creation. To address this problem, you can either increase your heap size (as long as it remains below the recommended guidelines stated above), or scale out the cluster by adding more nodes.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.jvm.mem.heap_used_percent[{#ES.NODE}],1h)>95

Recovery expression:
 | high |
| ES {#ES.NODE}: Percent of JVM heap in use is high (over {$ELASTICSEARCH.HEAP_USED.MAX.WARN}% for 1h) (LLD) |
This indicates that the rate of garbage collection isn’t keeping up with the rate of garbage creation. To address this problem, you can either increase your heap size (as long as it remains below the recommended guidelines stated above), or scale out the cluster by adding more nodes.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.jvm.mem.heap_used_percent[{#ES.NODE}],1h)>85

Recovery expression:
 | warning |
| ES {#ES.NODE}: Query latency is too high (over {$ELASTICSEARCH.QUERY_LATENCY.MAX.WARN}ms for 5m) (LLD) |
If latency exceeds a threshold, look for potential resource bottlenecks, or investigate whether you need to optimize your queries.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.indices.search.query_latency[{#ES.NODE}],5m)>100

Recovery expression:
 | warning |
| ES {#ES.NODE}: Refresh thread pool executor has the rejected tasks (for 5m) (LLD) |
The number of tasks rejected by the refresh thread pool executor is over 0 for 5m.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.thread_pool.refresh.rejected.rate[{#ES.NODE}],5m)>0

Recovery expression:
 | warning |
| ES {#ES.NODE}: Search thread pool executor has the rejected tasks (for 5m) (LLD) |
The number of tasks rejected by the search thread pool executor is over 0 for 5m.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.thread_pool.search.rejected.rate[{#ES.NODE}],5m)>0

Recovery expression:
 | warning |
| ES {#ES.NODE}: Write thread pool executor has the rejected tasks (for 5m) (LLD) |
The number of tasks rejected by the write thread pool executor is over 0 for 5m.
 |
Expression: min(/Elasticsearch Cluster by HTTP zbx 4.2/es.node.thread_pool.write.rejected.rate[{#ES.NODE}],5m)>0

Recovery expression:
 | warning |


D&D 5e Ability Score Roller
Use pre-defined starting values
Use the following values for your ability scores (in any order):
15, 14, 13, 12, 10, 8
Roll for ability scores
Roll 4d6 (drop lowest)
Point Buy System
| STR | 8 (-1) | Point Buy Cost = 0 |
| DEX | 8 (-1) | Point Buy Cost = 0 |
| CON | 8 (-1) | Point Buy Cost = 0 |
| INT | 8 (-1) | Point Buy Cost = 0 |
| WIS | 8 (-1) | Point Buy Cost = 0 |
| CHA | 8 (-1) | Point Buy Cost = 0 |
Points remaining = 27


{{ result }}
This page uses the MediaWiki API to check if Dick Cheney is still breathing
This page has its own API
Also check out www.deadyet.xyz


_Autumn_in_New_York_ (PG-13) **
With such odious films as _Battlefield_Earth_ and _Coyote_Ugly_ meriting advance screenings for critics, speculation could not help but reach a fevered pitch when MGM opted not to screen _Autumn_in_New_York_. Could this romantic drama featuring two established stars (Richard Gere and Winona Ryder) and a very capable director (Joan Chen) be a big-name bellyflop? Or is it the gem whose plot "secrets" needed to be protected, as according to the studio's official reason? The answer, however, is not nearly as intriguing as either of those extremes. The genteel and benign _Autumn_ is hardly the disaster cynics have dreaded, but this love story is also hardly the all-stops-out tearjerker it strives to be.
The latter fact stems from a fundamental conflict between the sensibilities of the screenwriter and director. Chen's auspicious debut film, the stunning _Xiu_Xiu:_The_Sent-Down_Girl_, was an intrinsically powerful story that packed an intensified emotional wallop through its subtlety--which is not exactly the best match for the shameless button-pusher that is Allison Burnett's script. Will Keane (Gere) is a restaurateur with a well-known reputation for womanizing. When the nubile young Charlotte Fielding (Winona Ryder) catches his eye and expresses interest in return, Will doesn't see any reason why this affair will be any different until his many others--that is, until she confesses her terminal illness. It seems like an ideal arrangement, the ladykiller who loves 'em and leaves 'em hooking up with a woman who has no long-term prospects nor expectations. But, of course, Cupid will not be denied.
Chen is able to give _Autumn_ some of the lyrical understatement that she lent to _Xiu_Xiu_. The tasteful love scenes do have a romantic air; the images (captured by cinematographer Changwei Gu) are lush and inviting, as is Gabriel Yared's score; and the big emotional moments are not histrionic. But this is, as written, a broadly formula exercise in manipulation, and for it to achieve its desired weepy effect, there needs to be a more forceful hand at work. The material simply isn't strong nor convincing enough on its own to wring tears by itself--and how could it, given some of the awkward dialogue ("I can smell the moonlight! When did I learn to do that?" rhetorically inquires Charlotte before the first big kiss).
At least the script is brave enough to address the vast age difference between Gere and Ryder, making for some of the film's more amusing repartée. Together, the pair neither smolder nor fizzle; there is a compatibility, but not one overwhelming enough to make Will's inevitable changes completely believable. Individually, though, they fare better: Gere can do the cocksure bit in his sleep, and Ryder displays her natural incandescence (though it ultimately contradicts her character's condition--she maintains a healthy glow even as things gradually become more dire).
Perhaps MGM's no-screening decision on _Autumn_in_New_York_ was simply a way to get it more publicity than it otherwise would have. After all, it is still the season of larger, louder films, and something this quiet--and unexceptionally so--would barely register with anyone.
Michael Dequina<EMAIL_ADDRESS>|<EMAIL_ADDRESS>|<EMAIL_ADDRESS>Mr. Brown's Movie Site: http://www.moviereportsite.com CinemaReview Magazine: http://www.CinemaReview.com on ICQ: #25289934 | on AOL Instant Messenger: MrBrown23
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


The model
The name of the solver to use for the computation ('seidel', 'jacobi', 'gmres', 'cgls'). Default is 'seidel' (if solverName is unknown).
The tolerence of the solver (usually 1e-9)
The maximum nulber of iterations (usually 200)
Generated using TypeDoc
This class is still a work in progress and does not work yet!
Create a special solver that can be reused any time if the remote, the boundary values of the surface discontinuities, the young modulus or the density are changed.
It avoids to build the system matrix each time the geometry and the boundary conditions of the surface discontinuities as well as the young modulus and the density don't change. Also, discontinuities cannot be added or removed from the model, otherwise, the system have to be rebuilt (and therefore, this class is useless).
This class is meant to be used for superposition, for example, for teaching purpose, or for investgating new ideas.
Usage
const solver = arch.ModelSolver(model, 1e-9, 200)
remote.setFunction( (x,y,z) => [1, 0, 0, 0, 0, 0] ) solver.run() model.postprocess(true, false, true, "U", "E", "S") const U1 = grid.getAttribute('vector3', 'U', false)
remote.setFunction( (x,y,z) => [0, 1, 0, 0, 0, 0] ) solver.run() model.postprocess(true, false, true, "U", "E", "S") const U2 = grid.getAttribute('vector3', 'U', false)
// ... etc


Log in with your provided username.
The first time you log in, you may choose any password. This becomes your permanent password for any subsequent logins.
You may change this password at any time from your account settings.


Returns an attribute set of all attributes.
Returns an attribute set of all callable (non-writable) attributes.
Clears the modified attribute state. Typically used after calling an update/save endpoint to signify that the instance is in sync with the upstream datasource.
Sets multiple attribute values using the provided data
. The incoming data is parsed into an
attribute set using [[Entity.parseData()
]], before being sanitized, normalized and validated.
Returns an attribute set of all attributes that have been configured as hidden
.
Returns an attribute set of all attributes that have been configured as immutable
.
Returns an attribute set of the attributes provided in names
.
Returns an attribute set of all attributes that have been modified since instantiation or the
last call to [[Entity.clearModified()
]].
Returns an attribute set of all attributes that have not been configured as immutable
.
Normalizes a value
using the configured normalizer
function for the attribute name
. If
the attribute does not have a normalizer function configured then that value is returned as-is.
The function will have this
scoped to the Entity
instance.
Returns the value of the attribute provided in name
.
Sanitizes a value
using the configured sanitizer
function for the attribute name
. The
function will have this
scoped to the Entity
instance.
Sets the value
for the attribute name
. Values can only be set for mutable, writable
attributes. The value will be sanitized, normalized and validated.
Returns the data to expose when stringifying the instance to JSON.
Stringifies the instance to JSON.
Validates a value
using the configured validator
function for the attribute name
. If
the attribute does not have a validator function configured then that value is assumed valid.
The function will have this
scoped to the Entity
instance.
Returns an attribute set of all attributes that have not been configured as hidden
.
Returns an attribute set an all writable (non-callable) attributes.
Generated using TypeDoc
Creates a new
Entity
instance. TheattrConfigSet
defines the attributes available on theEntity
instance. Values defined inattrConfigSet
are trusted and therefore not sanitized, normalized nor validated. Data provided viadata
must be compatible with the data expected by [[Entity.fill()
]] but, unlike [[Entity.fill()
]], may also include values for immutable attributes.


Pokémon is a series of video games developed by Game
Freak and published by Nintendo and The Pokémon Company
as part
of the Pokémon media franchise. Created by Satoshi Tajiri
with assistance from Ken Sugimori,the first games released in 1996
in
Japan for the Game Boy, and the main series of role-playing
video games (RPGs), also referred as the "core series" by their
developers
Water is one of the three basic elemental
types
along with Fire and Grass, which constitute
the
three starter Pokémon. This creates a simple
triangle to
explain the type concept easily to new
players. Water is the
most common type with
over 100 Pokémon, which are based on a
wide
variety of fish and other sea-dwelling creatures.
Fire is one of the three basic elemental
types
along with Water and Grass, which constitute
the
three starter Pokémon. This creates a simple
triangle to explain the type concept easily to new
players. Fire types are notoriously rare in the
early
stages of the games so choosing the Fire
variation starter is often a plus.
Grass is one of the three basic elemental
types
along with Fire and Water, which constitute
the
three starter Pokémon. This creates a simple
triangle to explain the type concept easily to new
players.Grass is one of the weakest types
statistically, with 5
defensive weaknesses and 7
types that are resistant to Grass moves.
The AR game's potential for weight loss was a
big part of that discussion. In
the process of
getting out their doors and visiting parks, players
found they
were losing weight almost in spite of
themselves. A Reddit Pokémon Go fan
won acclaim for
reporting that he'd lost 65 pounds between July and
December.
Pokémon GO is one of the most successful
mobile games of all time, breaking
records
like fastest to earn $100 million and most-downloaded
in its first month
of release. To date, it has grossed
almost $2 billion in revenue and been
downloaded 800
million times. Although no longer the global phenomenon
it
was in 2016, the game remains incredibly popular.
"Greninja is the final evolution of Pokémon
X and Y water-type starter Froakie. It has
the ability to
take on an appearance resembling
its trainer. Pokedex says: Greninja creates
throwing stars out
of compressed water. When it
spins them and throws them at high speed, these stars can split
metal in two."
"Lucario is a bipedal, wolf-like Pokémon with
blue, cream, and black fur. It is considered to be
prideful
and loyal to its trainer. Pokedex says: By catching the aura
emanating from others,
Lucario can read their thoughts and movements."
"Mimikyu caused quite a stir for its peculiar
looks and sad backstory when it was originally
announced
for Pokémon Sun and Moon in 2016. Mimikyu is described as
a Pokémon who felt so
lonely that it decided to wear a rag
in order to look like Pikachu, everyone’s favorite Pokémon.
Pokedex says: Its actual appearance is unknown. A scholar who
saw what was
under its rag was overwhelmed by terror and died from the shock."
"Charizard is an orange draconic Pokémon
who has a fiery temper. It is the final evolution of
Charmander, one of the starter Pokémon for the original
game. Pokedex says: Charizard flies
around the sky in search
of powerful opponents. It breathes fire of such great heat
that it melts
anything. However, it never turns its fiery
breath on any opponent weaker than itself. "
Pokémon battles appear in most forms of Pokémon media, being the central gameplay aspect of the core series games, as well as being a constant focus of the anime.
Pokémon Go's Types are exactly the same as those in the main Pokémon games, but the effect of those type matchups is slightly different: in brief, things like effective or resisted attacks have slightly different multipliers to the main Pokémon games - although a December 2018 update brought them slightly closer in line.
| Type | Strong Against | Weak Against | Resistant To |
|---|---|---|---|
| Normal | None | Rock, Ghost, Steel | Ghost |
| Fighting | Normal, Rock, Steel, Ice, Dark | Flying, Poison, Psychic, Bug, Ghost, Fairy | Rock, Bug, Dark |
| Flying | Fighting, Bug, Grass | Rock, Steel, Electric | Fighting, Ground, Bug, Grass |
| Poison | Grass, Fairy | Poison, Ground, Rock, Ghost, Steel | Fighting, Poison, Grass, Fairy |
| Ground | Poison, Rock, Steel, Fire, Electric | Flying, Bug, Grass | Poison, Rock, Electric |
Pokémon Go in 2020 continues to add new features,
such the arrival of the Go Battle
League, Remote Raids
and the trade evolution feature. There are also planned
changes to PokéCoins on the way. Meanwhile, coming soon is the Johto Throwback
quest.
"Ash Ketchum, known as Satoshi in Japan, is a
fictional character in the Pokémon franchise
owned
by Nintendo. He is the protagonist of the Pokémon
anime and certain manga series as well as
on various
merchandise related to the franchise. In Japanese,
the character is voiced by
Rika Matsumoto, and Hana Takeda.
"Lance is a recurring character
in Pokémon. He is a user of Dragon-types being
the final Elite Four
member in Red, Blue and their
remakes. In Pokémon Gold, Silver, Crystal and their
remakes, he is
the Champion.Lance has appeared in
the Pokémon series games from Generation I-III.
He first
appeared in the original Red and Blue games,
being the final member of the Elite Four, and again
in
Generation III's Red and Blue remakes, FireRed
and LeafGreen. Lance in the Generation II games
differed from the previous though, as he was Pokémon Champion by this time. "
"Cynthia is a powerful Pokémon trainer
and the Champion of the Sinnoh region where Professor
Carolina, Cynthia's grandmother, runs the Pokémon
Research Lab in Celestic Town. She enjoys
visiting
the Solaceon Town Ruins. Later, in Pokémon: DP Galactic
Battles, she helps fight Team
Galactic as well. In the
anime, she has a villa in east Unova but in the Pokémon
Black and White
games, she borrows Caitlin's villa (from the Elite Four). "
"Ookido Yukinari Hakaseamuel Oak is most
notable for his vast research facility, where he cares
for and studies hundreds of Pokémon, including those owned
by, but not currently traveling with,
Trainers from Pallet
Town. He has confidence in his grandson, Gary Oak, but more
often joins
Ash's mother and friends in cheering on Ash in his competitions. "
(1996–1999)
The original Pokémon games are Japanese role-playing video games (RPGs) with an element of strategy, and were created by Satoshi Tajiri for the Game Boy. The Pokémon series began with the release of Pocket Monsters Red and Green for the Game Boy in Japan. When these games proved popular, an enhanced Blue version was released sometime after, and the Blue version was reprogrammed as Pokémon Red and Blue for international release. The original Green version was not released outside Japan
(1999–2002)
The second generation of Pokemon video games began in 1999 with the Japanese release of Pokemon Gold and Silver for the Game Boy Color, with Australia and North America getting the game in October 2000 and European release date of April 2001. Like the previous generation, an enhanced version, tiled Pokemon Crystal, was later released.
(2002–2006)
Pokémon entered its third generation with the 2002 release of Pokémon Ruby and Sapphire for Game Boy Advance and continued with the Game Boy Advance remakes of Pokémon Red and Green, Pokémon FireRed and LeafGreen (Red and Green representing the original Japanese first generation games; territories outside Japan instead saw releases of Red and Blue). An enhanced remake of Pokémon Ruby and Sapphire titled Pokémon Emerald followed after.
(2006–2010)
In 2006, Japan began the fourth generation of the franchise with the release of Pokémon Diamond and Pearl for Nintendo DS. The games were released in North America on April 22, 2007 and in Australia on June 21, 2007. The game was released in the UK and Europe on July 27, 2007. Other main series games in the fourth generation include Pokémon Platinum, a director's cut version of Diamond and Pearl in the same vein as Pokémon Yellow, Crystal, and Emerald.It was released for the Nintendo DS in Japan on September 13, 2008, in North America on March 22, 2009, and in Australia and Europe on May 14, 2009 and May 22, 2009
Pokémon Sleep is an upcoming mobile
game for
Android and iOS, as part of the
Pokémon series.
Publisher: The Pokémon Company
Take a Pokémon™ journey to the Kanto
region
with your energetic partner,
Pikachu!
Publishers: Nintendo, The Pokémon
Company
Pokémon Go is a 2016 augmented
reality mobile game developed.
Developer: Niantic
"Junichi Masuda is a Japanese video game composer,
director, designer, producer, singer, and programmer
best known for his work in the Pokémon franchise.
He
is a member of the Game Freak board of directors,
and
has been employed at the company since 1989 when
he founded it along Satoshi Tajiri and Ken Sugimori "
"Shigeki Morimoto is a game designer and
programmer
currently working at Game Freak.
He has been involved
in nearly every main series
Pokémon game, since Pokémon
Red and Blue
Versions where he was a programmer, and the
creator of the battle system and the Pokémon
"Mew". "
"Ken Sugimori is a Japanese video game
designer,
illustrator, manga artist, and
director. He is most
famous as the character
designer and art director for
the Pokémon
franchise. Sugimori is also credited with
the
art direction for other titles, including
Pulseman "
Pokémon is short for the original Japanese title of Pocket Monsters. Created by. Satoshi Tajiri.


|
package main
import (
"flag"
"log"
"math/rand"
"os"
"strconv"
"time"
"github.com/bxcodec/faker/v3"
"github.com/xitongsys/parquet-go/parquet"
"github.com/xitongsys/parquet-go/writer"
)
|
Report represents one record stored in Parquet file
|
type Report struct {
ID int64 `parquet:"name=id, type=INT64"`
Key string `parquet:"name=key, type=UTF8, encoding=PLAIN_DICTIONARY"`
ClusterID string `parquet:"name=cluster_id, type=UTF8, encoding=PLAIN"`
Path string `parquet:"name=path, type=UTF8, encoding=PLAIN"`
ExternalOrganization string `parquet:"name=external_organization, type=UTF8, encoding=PLAIN"`
Report string `parquet:"name=report, type=UTF8, encoding=PLAIN"`
}
func generateColor ( ) string {
var colors [ ] string = [ ] string {
"black" ,
"blue" ,
"red" ,
"magenta" ,
"green" ,
"cyan" ,
"yellow" ,
"white" ,
}
return colors [ rand . Int ( ) % len ( colors ) ]
}
func writeRecords ( pw * writer . ParquetWriter , n int ) {
|
create report structure to be stored in Parquet file
|
record := Report { }
for i := 0 ; i < n ; i ++ {
clusterID := faker . UUIDHyphenated ( )
record . ID = int64 ( i )
record . Key = clusterID [ 0 : 1 ]
record . ClusterID = clusterID
record . Path = faker . Name ( )
record . ExternalOrganization = strconv . Itoa ( int ( rand . Int31n ( 1000 ) ) )
report := ""
for j := 0 ; j < 500 ; j ++ {
report += faker . Paragraph ( )
}
record . Report = report
|
write the record structure into Parquet file
|
err := pw . Write ( record )
if err != nil {
log . Println ( "Write into Parquet error" , err )
}
}
}
|
closeFile function tries to close the Parquet file
|
func closeFile ( file * os . File ) {
err := file . Close ( )
|
check for any error during close operation
|
if err != nil {
log . Fatal ( "Can't close the Parquet file" )
}
}
|
stopWrite function stop writing into Parquet file
|
func stopWrite ( pw * writer . ParquetWriter ) {
err := pw . WriteStop ( )
|
most write errors are caught at this time
|
if err != nil {
log . Println ( "WriteStop error" , err )
}
}
func createAndWriteIntoParquetFile ( filename string , records int , compression parquet . CompressionCodec ) {
t1 := time . Now ( )
w , err := os . Create ( filename )
if err != nil {
log . Println ( "Can't create local file" , err )
return
}
defer closeFile ( w )
|
initialize Parquet file writer
|
pw , err := writer . NewParquetWriterFromWriter ( w , new ( Report ) , 1 )
if err != nil {
log . Println ( "Can't create parquet writer" , err )
return
}
pw . RowGroupSize = 128 * 1024 * 1024
pw . CompressionType = compression
defer stopWrite ( pw )
writeRecords ( pw , records )
log . Println ( "Write Finished" )
|
compute and print duration
|
t2 := time . Now ( )
since := time . Since ( t1 )
log . Println ( "Start time: " , t1 )
log . Println ( "End time: " , t2 )
log . Println ( "Duration: " , since )
}
func main ( ) {
const defaultNumberOfRecords = 1000
|
filled via command line argument
|
var numberOfRecrods int
|
find and parse all command line arguments
|
flag . IntVar ( & numberOfRecrods , "n" , defaultNumberOfRecords , "number of records to be written into Parquet file" )
flag . Parse ( )
createAndWriteIntoParquetFile ( "records_compression_none.parquet" , numberOfRecrods , parquet . CompressionCodec_UNCOMPRESSED )
createAndWriteIntoParquetFile ( "records_compression_snappy.parquet" , numberOfRecrods , parquet . CompressionCodec_SNAPPY )
createAndWriteIntoParquetFile ( "records_compression_gzip.parquet" , numberOfRecrods , parquet . CompressionCodec_GZIP )
}
|


Hello there!
I'm Radu and I do various things on the internet. As you've guessed, this is my website.
I write about different things on my blog and more tehnical stuff on Technica.
Also, you can check out my book notes section.
Since this website is still in its infancy, I take every suggestion kindly, so please DM me on Twitter if you've got any ideas.


LEVEL CHALLENGE 1
Looking for some low level action while levelling up your character? The Level Challenge 1 rewards you for beating a specific uberlevel at a low character level.
Killing a Boss
This challenge requires you to 'kill' a boss. This means that you need to be
physically present at the battle and near the boss when it dies before
you can use the cube recipe that grants you the reward.
If you succeed in killing the target monster, you get a whirling red overlay that looks like three rotating bolts:
You now have 30 seconds to perform the cube recipe.
Warning: This does not work if the monster is killed by reflected damage, due to a Diablo II engine limitation. Please use different means of killing the target.
HOW TO DO THE LEVEL CHALLENGE 1
MAXIMUM LEVEL 50-70 DEPENDING ON ELEMENT
Go to the Tran Athulua uberlevel on Hatred difficulty, defeat the Pirate at the entrance to get the Sunstone of the Elements.
Find and defeat any of the three Priestesses. Each will drop her Sunstone. Cube it immediately while you have the red swirls on you. This will upgrade your Sunstone of the Elements, if your level is low enough.
You have 30 seconds to cube the Sunstone with the Sunstone of the Elements after killing the Priestess, so keep your cube empty! This will add bonuses to it.
See THIS PAGE for more information about Tran Athulua.
Level Challenge 1: Beginning
Get the Sunstone of the Elements by defeating the Pirate at the entrance, on Hatred difficulty.
You can add the power of each upgraded Sunstone to the Sunstone of the Elements for a great bonus.
Level Challenge 1A: Fire
(Max Level 70)
Kill Philios, Priestess of Hefaetrus. On Hatred difficulty she will drop a Sunstone of Fire.
If you are level 70 or below, cube it with the Sunstone of the Elements while the red whirls are on your character to invest power into it.
Requires: level 70 or below
This upgrade recipe adds the following bonuses:
-10% to Enemy Fire Resistance
+10 Defense
All Resists +20%
Level Challenge 1B: Ice
(Max Level 60)
Kill Skovos, Priestess of Karcheus. On Hatred difficulty she will drop a Sunstone of Ice.
If you are level 60 or below, cube it with the Sunstone of the Elements the red whirls are on your character to invest power into it.
Requires: level 60 or below
This upgrade recipe adds the following bonuses:
+2 to All Skills
-10% to Enemy Cold Resistance
+10 Defense
Level Challenge 1C: Thunder
(Max Level 50)
Kill Lycander, Priestess of Zerae. On Hatred difficulty she will drop a Sunstone of Thunder.
If you are level 50 or below, cube it with the Sunstone of the Elements while the red whirls are on your character to invest power into it.
Requires: level 50 or below
This upgrade recipe adds the following bonuses:
20% Increased Overall Speed
-10% to Enemy Lightning Resistance
15% Bonus to all Attributes
+10 Defense
Btw. You gain no experience on Hatred difficulty in Tran Athulua itself. Keep trying until you succeed!
Btw. Although all three Priestesses give you the same looking red whirls, you need to kill the right Priestess to cube the right charm.