Briefly, this error occurs when Elasticsearch is unable to retrieve frozen cache information from a discovery node. This could be due to network issues, node unavailability, or misconfiguration. To resolve this, you can check the network connectivity between nodes, ensure the discovery node is up and running, and verify the configuration settings. If the issue persists, consider restarting the Elasticsearch cluster or increasing the timeout settings.
This guide will help you check for common problems that cause the log ” –> failed fetching frozen cache info from [” + discoveryNode + “] ” to appear. To understand the issues related to this log, read the explanation below about the following Elasticsearch concepts: plugin, discovery, cache, node.
Overview
The process known as discovery occurs when an Elasticsearch node starts, restarts or loses contact with the master node for any reason. In those cases, the node needs to contact other nodes in the cluster to find any existing master node or initiate the election of a new master node.
How it works
Upon startup, each node looks for other nodes, firstly by contacting the IP addresses of eligible master nodes held in the previous cluster state. If they are not available, it will look for nodes based upon the seed host provider mechanisms available.
Seed host providers may be defined in 3 ways: list based, file based or plugin based. All of these methods provide a list of IP addresses or hostnames which the node should contact in order to obtain a list of master eligible nodes. The node will contact all of these addresses in turn, until either an active master is found, or failing that, until sufficient nodes can be found to elect a new master node.
Examples
The simplest form is to define a list of seed host providers in elasticsearch.yml:
discovery.seed_hosts: - 192.168.1.10:9300 - 192.168.1.11 - seeds.mydomain.com
An alternative way is to refer to a file using the following setting:
discovery.seed_providers: file
The file MUST be placed in the following filepath: $ES_PATH_CONF/unicast_hosts.txt
10.10.10.5 10.10.10.6:9305 10.10.10.5:10005 # an IPv6 address [2001:0db8:85a3:0000:0000:8a2e:0370:7334]:9301
Note that the use of a port is optional. If not used, then the default port range of 9300-9400 will be used.
If you use AWS or GCS then you can install and use a plugin to obtain a list of seed hosts from an API. A plugin also exists for Azure but is deprecated since version 5.
AWS plugin
A typical configuration could be as follows:
discovery.seed_providers: ec2 discovery.ec2.tag.role: master discovery.ec2.tag.environment: dev discovery.ec2.endpoint: ec2.us-east-1.amazonaws.com cloud.node.auto_attributes: true cluster.routing.allocation.awareness.attributes: aws_availability_zone
The above configuration would look for all nodes with a tag called “environment” set to “dev” and a tag called “role” set to “master”, in the AWS zone us-east-1. The last two lines set up cluster routing allocation awareness based upon aws availability zones. (Not necessary, but nice to have).
GCE plugin
A typical configuration could be as follows:
discovery.seed_providers: gce cloud.gce.project_id: <your-google-project-id> cloud.gce.zone: <your-zone> discovery.gce.tags: <my-tag-name>
The above configuration would look for all virtual machines inside your project, zone and with a tag set to the tag name you provide.
Notes and good things to know
Cluster formation depends on correct setup of the network.host settings in elasticsearch.yml. Make sure that the nodes can reach each other across the network using their IP addresses / hostname, and are not getting blocked due to firewall settings on the ports required.
Overview
Elasticsearch uses three types of caches to improve the efficiency of operation.
- Node request cache
- Shard data cache
- Field data cache
How they work
Node request cache maintains the results of queries used in a filter context. The results are evicted on a least recently used basis.
Shard data cache maintains the results of frequently used queries where size=0, particularly the results of aggregations. This cache is particularly relevant for logging use cases where data is not updated on old indices, and regular aggregations can be kept in cache to be reused.
The field data cache is used for sorting and aggregations. To keep these operations quick Elasticsearch loads these values into memory.
Examples
Elasticsearch usually manages cache behind the scenes, without the need for any specific settings. However, it is possible to monitor and limit the amount of memory being used on each node for a given cache type by putting the following in elasticsearch.yml :
indices.queries.cache.size: 10% indices.fielddata.cache.size: 30%
Note, the above values are in fact the defaults, and there is no need to set them specifically. The default values are good for most use cases, and should rarely be modified.
You can monitor the use of caches on each node like this:
GET /_nodes/stats/indices/fielddata GET /_nodes/stats/indices/query_cache GET /_nodes/stats/indices/request_cache
Notes and good things to know
Construct your queries with reusable filters. There are certain parts of your query which are good candidates to be reused across a large number of queries, and you should design your queries with this in mind. Anything thing that does not need to be scored should go in the filter section of a bool query. For example, time ranges, language selectors, or clauses that exclude inactive documents are all likely to be excluded in a large number of queries, and should be included in filter parts of the query so that they can be cached and reused.
In particular, take care with time filters. “now-15m” cannot be reused, because “now” will continually change as the time window moves on. On the other hand “now-15/m” will round to the nearest minute, and can be re-used (via cache) for 60 seconds before rolling over to the next minute.
For example when a user enters the search term “brexit”, we may want to also filter on language and time period to return relevant articles. The query below leaves only the query term “brexit” in the “must” part of the query, because this is the only part which should affect the relevance score. The time filter and language filter can be reused time and time again for new queries for different searches.
POST results/_search
{
"query": {
"bool": {
"must": [
{
"match": {
"message": {
"query": "brexit"
}
}
}
],
"filter": [
{
"range": {
"@timestamp": {
"gte": "now-10d/d"
}
}
},
{
"term": {
"lang.keyword": {
"value": "en",
"boost": 1
}
}
}
]
}
}
}Limit the use of field data. Be careful about using fielddata=true in your mapping where the number of terms will result in a high cardinality. If you must use fielddata=true, you can also reduce the requirement of fielddata cache by limiting the requirements for fielddata for a given index using a field data frequency filter.
POST results/_search
{
"query": {
"bool": {
"must": [
{
"match": {
"message": {
"query": "brexit"
}
}
}
],
"filter": [
{
"range": {
"@timestamp": {
"gte": "now-10d/d"
}
}
},
{
"term": {
"lang.keyword": {
"value": "en",
"boost": 1
}
}
}
]
}
}
}Log Context
Log “–> failed fetching frozen cache info from [” + discoveryNode + “]” classname is FrozenCacheInfoService.java.
We extracted the following from Elasticsearch source code for those seeking an in-depth context :
);
}
@Override
public void onFailure(Exception e) {
logger.debug(() -> "--> failed fetching frozen cache info from [" + discoveryNode + "]"; e);
// Failed even to execute the nodes info action; just give up
updateEntry(NodeState.FAILED);
}
private void retryOrRecordFailure(Exception e) {
