render: merge cached before enter limiter

config/config.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"regexp"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
 
@@ -31,7 +32,9 @@ type CacheConfig struct {
 	Size                int           `toml:"size-mb" json:"size-mb" comment:"cache size"`
 	MemcachedServers    []string      `toml:"memcached-servers" json:"memcached-servers" comment:"memcached servers"`
 	DefaultTimeoutSec   int32         `toml:"default-timeout" json:"default-timeout" comment:"default cache ttl"`
+	DefaultTimeoutStr   string        `toml:"-" json:"-"`
 	ShortTimeoutSec     int32         `toml:"short-timeout" json:"short-timeout" comment:"short-time cache ttl"`
+	ShortTimeoutStr     string        `toml:"-" json:"-"`
 	FindTimeoutSec      int32         `toml:"find-timeout" json:"find-timeout" comment:"finder/tags autocompleter cache ttl"`
 	ShortDuration       time.Duration `toml:"short-duration" json:"short-duration" comment:"maximum diration, used with short_timeout"`
 	ShortUntilOffsetSec int64         `toml:"short-offset" json:"short-offset" comment:"offset beetween now and until for select short cache timeout"`
@@ -716,6 +719,9 @@ func CreateCache(cacheName string, cacheConfig *CacheConfig) (cache.BytesCache,
 	if cacheConfig.ShortUntilOffsetSec == 0 {
 		cacheConfig.ShortUntilOffsetSec = 120
 	}
+	cacheConfig.DefaultTimeoutStr = strconv.Itoa(int(cacheConfig.DefaultTimeoutSec))
+	cacheConfig.ShortTimeoutStr = strconv.Itoa(int(cacheConfig.ShortTimeoutSec))
+
 	switch cacheConfig.Type {
 	case "memcache":
 		if len(cacheConfig.MemcachedServers) == 0 {

prometheus/querier_select.go

@@ -94,7 +94,7 @@ func (q *Querier) Select(sortSeries bool, hints *storage.SelectHints, labelsMatc
 			From:          from,
 			Until:         until,
 			MaxDataPoints: maxDataPoints,
-		}: &data.Targets{List: []string{}, AM: am},
+		}: data.NewTargets([]string{}, am),
 	}
 	reply, err := multiTarget.Fetch(q.ctx, q.config, config.ContextPrometheus)
 	if err != nil {

render/data/multi_target.go

@@ -38,9 +38,9 @@ func MFRToMultiTarget(v3Request *v3pb.MultiFetchRequest) MultiTarget {
 			}
 			if _, ok := multiTarget[tf]; ok {
 				target := multiTarget[tf]
-				target.List = append(multiTarget[tf].List, m.PathExpression)
+				target.Append(m.PathExpression)
 			} else {
-				multiTarget[tf] = &Targets{List: []string{m.PathExpression}, AM: alias.New()}
+				multiTarget[tf] = NewTargetsOne(m.PathExpression, len(v3Request.Metrics), alias.New())
 			}
 		}
 	}

render/data/query_test.go

@@ -69,13 +69,10 @@ func ageToTimestamp(age int64) int64 {
 // fromAge and untilAge are relative age of timeframe
 func newCondition(fromAge, untilAge, maxDataPoints int64) *conditions {
 	tf := TimeFrame{ageToTimestamp(fromAge), ageToTimestamp(untilAge), maxDataPoints}
-	tt := Targets{
-		List:        []string{"*.name.*"},
-		AM:          newAM(),
-		pointsTable: "graphite.data",
-		rollupRules: newRules(false),
-	}
-	return &conditions{TimeFrame: &tf, Targets: &tt}
+	tt := NewTargets([]string{"*.name.*"}, newAM())
+	tt.pointsTable = "graphite.data"
+	tt.rollupRules = newRules(false)
+	return &conditions{TimeFrame: &tf, Targets: tt}
 }
 
 func extTableString(et map[string]*strings.Builder) map[string]string {

render/data/targets.go

@@ -10,10 +10,20 @@ import (
 	"github.com/lomik/graphite-clickhouse/pkg/alias"
 )
 
+type Cache struct {
+	Cached     bool
+	TS         int64 // cached timestamp
+	Timeout    int32
+	TimeoutStr string
+	Key        string // cache key
+	M          *metrics.CacheMetric
+}
+
 // Targets represents requested metrics
 type Targets struct {
 	// List contains queried metrics, e.g. [metric.{name1,name2}, metric.name[3-9]]
-	List []string
+	List  []string
+	Cache []Cache
 	// AM stores found expanded metrics
 	AM                *alias.Map
 	pointsTable       string
@@ -23,6 +33,29 @@ type Targets struct {
 	queryMetrics      *metrics.QueryMetrics
 }
 
+func NewTargets(list []string, am *alias.Map) *Targets {
+	return &Targets{
+		List:  list,
+		Cache: make([]Cache, len(list)),
+		AM:    am,
+	}
+}
+
+func NewTargetsOne(target string, capacity int, am *alias.Map) *Targets {
+	list := make([]string, 1, capacity)
+	list[0] = target
+	return &Targets{
+		List:  list,
+		Cache: make([]Cache, 1, capacity),
+		AM:    am,
+	}
+}
+
+func (tt *Targets) Append(target string) {
+	tt.List = append(tt.List, target)
+	tt.Cache = append(tt.Cache, Cache{})
+}
+
 func (tt *Targets) selectDataTable(cfg *config.Config, tf *TimeFrame, context string) error {
 	now := time.Now().Unix()
 

render/data/targets_test.go

@@ -47,7 +47,7 @@ func TestSelectDataTableTime(t *testing.T) {
 	}
 	err := cfg.ProcessDataTables()
 	assert.NoError(t, err)
-	tg := Targets{List: []string{"metric"}}
+	tg := NewTargets([]string{"metric"}, nil)
 
 	tests := []struct {
 		*TimeFrame
@@ -125,17 +125,17 @@ func TestSelectDataTableMatch(t *testing.T) {
 		err error
 	}{
 		{
-			&Targets{List: []string{"allinclucive.in.avg", "all.metrics.for.avg"}},
+			NewTargets([]string{"allinclucive.in.avg", "all.metrics.for.avg"}, nil),
 			cfg.DataTable[0],
 			nil,
 		},
 		{
-			&Targets{List: []string{"allinclucive.in.avg", "any.metrics.for.avg"}},
+			NewTargets([]string{"allinclucive.in.avg", "any.metrics.for.avg"}, nil),
 			cfg.DataTable[1],
 			nil,
 		},
 		{
-			&Targets{List: []string{"allinclucive.in.avg", "some.metrics.for.avg"}},
+			NewTargets([]string{"allinclucive.in.avg", "some.metrics.for.avg"}, nil),
 			cfg.DataTable[2],
 			nil,
 		},