created lru cache in querysharding pkg

pkg/queryfrontend/shard_query.go

@@ -19,7 +19,7 @@ import (
 )
 
 // PromQLShardingMiddleware creates a new Middleware that shards PromQL aggregations using grouping labels.
-func PromQLShardingMiddleware(queryAnalyzer *querysharding.QueryAnalyzer, numShards int, limits queryrange.Limits, merger queryrange.Merger, registerer prometheus.Registerer) queryrange.Middleware {
+func PromQLShardingMiddleware(queryAnalyzer querysharding.Analyze, numShards int, limits queryrange.Limits, merger queryrange.Merger, registerer prometheus.Registerer) queryrange.Middleware {
 	return queryrange.MiddlewareFunc(func(next queryrange.Handler) queryrange.Handler {
 		queriesTotal := promauto.With(registerer).NewCounterVec(prometheus.CounterOpts{
 			Namespace: "thanos",
@@ -45,7 +45,7 @@ type querySharder struct {
 	next   queryrange.Handler
 	limits queryrange.Limits
 
-	queryAnalyzer *querysharding.QueryAnalyzer
+	queryAnalyzer querysharding.Analyze
 	numShards     int
 	merger        queryrange.Merger
 

pkg/querysharding/analyzer.go

@@ -6,26 +6,63 @@ package querysharding
 import (
 	"fmt"
 
+	lru "github.com/hashicorp/golang-lru"
 	"github.com/prometheus/prometheus/promql/parser"
 )
 
 // QueryAnalyzer is an analyzer which determines
 // whether a PromQL Query is shardable and using which labels.
-type QueryAnalyzer struct{}
+
+type Analyze interface {
+	Analyze(string) (QueryAnalysis, error)
+}
+
+type QueryAnalyzer struct {
+}
+
+type CachedQueryAnalyzer struct {
+	analyzer *QueryAnalyzer
+	cache    *lru.Cache
+}
 
 var nonShardableFuncs = []string{
 	"label_join",
 	"label_replace",
 }
 
 // NewQueryAnalyzer creates a new QueryAnalyzer.
-func NewQueryAnalyzer() *QueryAnalyzer {
-	return &QueryAnalyzer{}
+func NewQueryAnalyzer() *CachedQueryAnalyzer {
+	cache, _ := lru.New(256)
+
+	return &CachedQueryAnalyzer{
+		analyzer: &QueryAnalyzer{},
+		cache:    cache,
+	}
+}
+
+type cachedValue struct {
+	QueryAnalysis QueryAnalysis
+	err           error
 }
 
-// Analyze analyzes a query and returns a QueryAnalysis.
+func (a *CachedQueryAnalyzer) Analyze(query string) (QueryAnalysis, error) {
+	if a.cache.Contains(query) {
+		value, _ := a.cache.Get(query)
+		return value.(cachedValue).QueryAnalysis, value.(cachedValue).err
+	}
+
+	// Analyze if needed
+	analysis, err := a.analyzer.Analyze(query)
 
-// Analyze uses the following algorithm:
+	// Adding to cache
+	_ = a.cache.Add(query, cachedValue{QueryAnalysis: analysis, err: err})
+
+	return analysis, err
+}
+
+// queryAnalyzer analyzes a query and returns a QueryAnalysis.
+
+// queryAnalyzer uses the following algorithm:
 // * if a query has subqueries, such as label_join or label_replace,
 //   or has functions which cannot be sharded, then treat the query as non shardable.
 // * if the query's root expression has grouping labels,
@@ -36,7 +73,9 @@ func NewQueryAnalyzer() *QueryAnalyzer {
 //   as shardable by those labels.
 // * otherwise, treat the query as non-shardable.
 // The le label is excluded from sharding.
+
 func (a *QueryAnalyzer) Analyze(query string) (QueryAnalysis, error) {
+
 	expr, err := parser.ParseExpr(query)
 	if err != nil {
 		return nonShardableQuery(), err

pkg/querysharding/analyzer_test.go

@@ -11,6 +11,7 @@ import (
 )
 
 func TestAnalyzeQuery(t *testing.T) {
+
 	type testCase struct {
 		name           string
 		expression     string