Tracing Black Boxes III: Solr Query Performance Tuning
by Patson Luk September 10, 2013
Solr Server provides JMX statistics that show performance details such as query speed and cache hit/miss rates in a macro level, which James talked about in a previous post. However, it might be tough to trace how a particular operation; for example: how a specific query fared in the system. This week, I’d like to introduce TraceView’s latest support for Solr Server, which provides breakdown of each operation, enabling more precise performance monitoring and troubleshooting.
How does Solr work, anyway?
Requests made to Solr Server can be roughly divided into 3 categories: queries, data indexing/update, admin operations (check server health/log, optimize server etc). Requests made to Solr server first go through the
SolrDispatchFilter that looks up the corresponding Solr Core (a running instance of index/dataset along with configurations) and handler. The retrieved SolrCore and handler are then used to process the request. For SearchHandler, it is further broken down into smaller SearchComponents (for example, querying, highlighting results, calculating statistics etc).
Take note that since version 4, Solr added distributed capabilities in Solr called SolrCloud, which enable highly available, fault tolerant cluster of Solr servers. Index/dataset is no longer hosted on a single Core/instance. Instead, it is constructed by several shards, each as a disjoint subset of the documents in the index, and each shard can be backed by multiple cores, which are replicas of each other.
For caching, Solr uses several built-in classes (LRUCache, FastLRUCache, LFUCache) for various aspects (field, filter, query result, document etc). They are implemented as in-memory caches to allow quicker operations. The configurations of caches can be found in the Query section of
Indexing and updates can be slow, and certainly compete for resources, but they can be done asynchronously. Admin operations can be slow as well, but they are typically one-time events, or not performance sensitive. Queries are typically the most important operation, as they live in the critical path for the user. TraceView monitor activities on each of the classes that correspond to these actions and their components to extract run-time information on each of the modules described. Let’s take a look at an example.
A trace follows the path of a request through the entire application. For example, a trace below shows the breakdowns of a query operation:
There’s a lot more going on that just searching the index for the given phrase!
Solr has a lot more functionality than just returning a list of documents that match a query. In particular, this query’s time is actually dominated by “highlight.process” (highlight matching phrases in the query result) and “ResponseWriter.write” (write data to the response stream). We could speed up this request by nearly 2x by just disabling the highlighter in config!
The other interesting information here is what’s not visible. This query didn’t hit a cache of any sort. Even for highly variable search terms, the cache can help with users paging through longer lists or sharing links. In this case, TraceView found several cache miss events on “documentCache” that contribute to longer load time.
Pre-warming the cache could help with this, or if this is a common term, it’s possible that it’s being evicted due to small cache size. We could verify this by checking the JMX statistics for cache eviction rates and adjusting the cache size in our config, if necessary.
Instrumentation on Solr Server does not only give an isolated view of how Solr performs, it also draws a complete picture of all the interactions with other applications/systems. For example, below is trace of a query request issued a typical Drupal search page backed by Solr service runs on a different host:
We can trace the request handling all the way through the Apache server, Drupal modules, and Solr handling all in one trace. In particular, this tracks requests even when the app and Solr are running on different machines, which allows you to track down issues where the application calls the Solr server incorrectly.
Want to get this visibility into Solr? Sign up for your free TraceView account here, and monitoring Solr is 2 easy steps:
- Install machine monitoring on the server itself:
wget https://www.tracelytics.com/install_tracelytics.sh sudo sh ./install_tracelytics.sh 05a78228-c8a9-abab-9509-7a4fabdcbcbc # your key here
- Add the TraceView agent to Solr startup:
java -javaagent:/usr/local/tracelytics-agent.jar -jar start.jar
You’ll be up and running in 5 minutes.