class FastestServerLB[F[_]] extends LoadBalancer with AsyncSolrClientAware[F] with FastestServerLBJmxSupport[F]
LB strategy that selects the fastest server based on the latest average response time. It's aimed to handle a multi datacenter setup where some server regularly need longer to response. It shall also detect short (subsecond) pauses of a server e.g. due to garbage collection or s.th. else.
The latest average response time is determined in the following order (the first found measure is used): - currently still running requests (if they're lasting longer than previous, already completed requests) - average response time of the current or the last second - average response time of the last ten seconds - total average resonse time
The response time is measured using the given testQuery. A dedicated test query is used, because queries can have very different performance characteristics, so that it might even be hard for an application to classify this. With the testQuery you have control what is used to measure response time.
For "normal" / "fast" servers (default: with a resonse time <= the average of all servers, you can override
determineFastServers
) test queries are run whenever a request comes in, but between test queries at least
the minDelay has to be passed.
This way servers are not hammered with requests when nobody else is using your search, but if there's
high traffic this load balancer get high resolution of monitoring data to detect short pauses as well.
For "slow" servers (default: response time > average) tests are run using the specified maxDelay.
Directly after creation of this LoadBalancer / AsnycSolrClient multiple test queries are run (according
to the specified initialTestRuns
, by default 10) to have initial stats.
- Alphabetic
- By Inheritance
- FastestServerLB
- FastestServerLBJmxSupport
- FastestServerLBMBean
- AsyncSolrClientAware
- LoadBalancer
- RequestInterceptor
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
-
new
FastestServerLB(solrServers: SolrServers, collectionAndTestQuery: (SolrServer) ⇒ (String, SolrQuery), minDelay: Duration = 100 millis, maxDelay: Duration = 10 seconds, initialTestRuns: Int = 10, filterFastServers: (Long) ⇒ ((SolrServer, Long)) ⇒ Boolean = ..., mapPredictedResponseTime: (Long) ⇒ Long = identity, clock: Clock = Clock.systemDefault)(implicit futureFactory: FutureFactory[F])
- solrServers
solr servers to load balance, those are regularly tested.
- collectionAndTestQuery
a function that returns the collection name and a testQuery for the given server. The collection is used to partition server when classifying "fast"/"slow" servers, because for different collections response times will be different. It's somehow similar with the testQuery: it might be different per server, e.g. some server might only provide a /suggest handler while others provide /select (which can be specified via the "qt" query param in the test query).
- minDelay
the minimum delay between the response of a test and the start of the next test (to limit test frequency)
- maxDelay
the delay between tests for slow servers (or all servers if there are no real requests)
- initialTestRuns
on start each active server is tested the given number of times to gather initial stats and determine fast/slow servers.
- filterFastServers
a function to filter fast / preferred servers. The function takes the calculated average duration of all servers of a collection, and returns a function for a SolrServer->Duration tuple that returns true/false to indicate if a server should be considered "fast". The default value for filterFastServers uses
duration <= average * 1.1 + 5
(use 1.1 as multiplier to accepted some deviation, for smaller values like 1 or 2 millis also add some fix value to allow normal deviation).- mapPredictedResponseTime
a function that's applied to the predicted response time. This can e.g. be used to quantize the time so that minor differences are ignored.
- clock
the clock to get the current time from. The tests using the maxDelay are run using a scheduled executor, therefore this interval uses the system clock
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
averagesPer10Seconds(collection: String): TabularData
- Definition Classes
- FastestServerLBJmxSupport → FastestServerLBMBean
-
def
averagesPerSecond(collection: String): TabularData
- Definition Classes
- FastestServerLBJmxSupport → FastestServerLBMBean
-
def
averagesTotalAverage(collection: String): CompositeData
- Definition Classes
- FastestServerLBJmxSupport → FastestServerLBMBean
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
- val collectionAndTestQuery: (SolrServer) ⇒ (String, SolrQuery)
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
fastServers(collection: String): CompositeData
- Definition Classes
- FastestServerLBJmxSupport → FastestServerLBMBean
-
var
fastServersByCollection: Map[String, Set[SolrServer]]
- Attributes
- protected
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
-
def
init(): Unit
- Attributes
- protected
-
def
initJmx(): Unit
- Definition Classes
- FastestServerLBJmxSupport
-
def
initialPredictedResponseTime: Long
- Attributes
- protected
-
def
interceptQuery(f: (SolrServer, SolrQuery) ⇒ Future[QueryResponse])(solrServer: SolrServer, q: SolrQuery): Future[QueryResponse]
Intercept user queries to trigger test queries based on the current request rate.
Intercept user queries to trigger test queries based on the current request rate.
- f
the function to intercept
- solrServer
the SolrServer that's used to run the query
- q
the query to send to solr.
- returns
the query response.
- Definition Classes
- FastestServerLB → LoadBalancer → RequestInterceptor
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- val mapPredictedResponseTime: (Long) ⇒ Long
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
-
def
onBeforeFastServersChanged(collection: String, fastServers: Set[SolrServer], durationByServer: Map[SolrServer, Long], average: Long): Unit
- Attributes
- protected
-
def
predictDurations(collection: String): CompositeData
- Definition Classes
- FastestServerLBJmxSupport → FastestServerLBMBean
-
def
quantizePredictedDurations(collection: String): CompositeData
- Definition Classes
- FastestServerLBJmxSupport → FastestServerLBMBean
-
def
scheduleTests(): Unit
- Attributes
- protected
-
def
scheduleUpdateStats(): Unit
- Attributes
- protected
-
val
serverTestTimestamp: Map[SolrServer, Millisecond]
- Attributes
- protected[io.ino.solrs]
-
def
setAsyncSolrClient(client: AsyncSolrClient[F]): Unit
On creation of AsyncSolrClient this method is invoked with the created instance if the concrete component is "supported", right now this are SolrServers and LoadBalancer.
On creation of AsyncSolrClient this method is invoked with the created instance if the concrete component is "supported", right now this are SolrServers and LoadBalancer. Subclasses can override this method to get access to the solr client.
- Definition Classes
- FastestServerLB → AsyncSolrClientAware
-
def
shutdown(): Unit
- Definition Classes
- FastestServerLB → LoadBalancer
-
def
shutdownJmx(): Unit
- Definition Classes
- FastestServerLBJmxSupport
-
def
solrServer(q: SolrQuery, preferred: Option[SolrServer] = None): Option[SolrServer]
Determines the solr server to use for a new request.
Determines the solr server to use for a new request.
- Definition Classes
- FastestServerLB → LoadBalancer
-
val
solrServers: SolrServers
- Definition Classes
- FastestServerLB → LoadBalancer
-
def
stats(server: SolrServer): PerformanceStats
- Attributes
- protected
-
val
statsByServer: TrieMap[SolrServer, PerformanceStats]
- Attributes
- protected[io.ino.solrs]
-
def
subscribeToServerChanges(): Unit
- Attributes
- protected
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
updateFastServers(): Unit
Determines the servers that are tested more frequently.
Determines the servers that are tested more frequently.
- Attributes
- protected
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )