Excise old series cache

This was used before we sharded the inserter on a metric-basis, and is
no longer useful.

Author: JLockerman

cmd/timescale-prometheus/main.go

@@ -211,22 +211,6 @@ func main() {
 		return float64(client.MetricNamesCacheCapacity())
 	})
 
-	cachedSeriesSets := prometheus.NewCounterFunc(prometheus.CounterOpts{
-		Namespace: promNamespace,
-		Name:      "series_set_cache_elements_stored",
-		Help:      "Total number of labels to series-set id mappings cached.",
-	}, func() float64 {
-		return float64(client.NumCachedSeries())
-	})
-
-	seriesSetCacheCap := prometheus.NewGaugeFunc(prometheus.GaugeOpts{
-		Namespace: promNamespace,
-		Name:      "series_set_cache_capacity",
-		Help:      "Maximum number of elements in the series-set cache.",
-	}, func() float64 {
-		return float64(client.SeriesCacheCapacity())
-	})
-
 	cachedLabels := prometheus.NewCounterFunc(prometheus.CounterOpts{
 		Namespace: promNamespace,
 		Name:      "label_cache_elements_stored",
@@ -245,8 +229,6 @@ func main() {
 
 	prometheus.MustRegister(cachedMetricNames)
 	prometheus.MustRegister(metricNamesCacheCap)
-	prometheus.MustRegister(cachedSeriesSets)
-	prometheus.MustRegister(seriesSetCacheCap)
 	prometheus.MustRegister(cachedLabels)
 	prometheus.MustRegister(labelsCacheCap)
 
@@ -264,7 +246,6 @@ func main() {
 		FailedQueries:       failedQueries,
 		ReceivedQueries:     receivedQueries,
 		CachedMetricNames:   cachedMetricNames,
-		CachedSeriesSets:    cachedSeriesSets,
 		CachedLabels:        cachedLabels,
 	}
 	writeHandler := timeHandler(httpRequestDuration, "write", api.Write(client, elector, &promMetrics))

pkg/api/metrics.go

@@ -19,6 +19,5 @@ type Metrics struct {
 	FailedQueries       prometheus.Counter
 	QueryBatchDuration  prometheus.Histogram
 	CachedMetricNames   prometheus.CounterFunc
-	CachedSeriesSets    prometheus.CounterFunc
 	CachedLabels        prometheus.CounterFunc
 }

pkg/pgclient/client.go

@@ -48,7 +48,6 @@ func ParseFlags(cfg *Config) *Config {
 	flag.IntVar(&cfg.ReportInterval, "tput-report", 0, "interval in seconds at which throughput should be reported")
 	flag.Uint64Var(&cfg.LabelsCacheSize, "labels-cache-size", 10000, "maximum number of labels to cache")
 	flag.Uint64Var(&cfg.MetricsCacheSize, "metrics-cache-size", pgmodel.DefaultMetricCacheSize, "maximum number of metric names to cache")
-	flag.Uint64Var(&cfg.SeriesCacheSize, "series-cache-size", pgmodel.DefaultSeriesCacheSize, "maximum number of series-sets to cache")
 	return cfg
 }
 
@@ -130,14 +129,6 @@ func (c *Client) Read(req *prompb.ReadRequest) (*prompb.ReadResponse, error) {
 	return c.reader.Read(req)
 }
 
-func (c *Client) NumCachedSeries() int {
-	return c.ingestor.NumCachedSeries()
-}
-
-func (c *Client) SeriesCacheCapacity() int {
-	return c.ingestor.SeriesCacheCapacity()
-}
-
 func (c *Client) NumCachedMetricNames() int {
 	return c.metricCache.NumElements()
 }

pkg/pgmodel/cache.go

@@ -13,41 +13,13 @@ import (
 
 const (
 	DefaultMetricCacheSize = 10000
-	DefaultSeriesCacheSize = 100000
 )
 
 var (
 	// ErrEntryNotFound is returned when entry is not found.
 	ErrEntryNotFound = fmt.Errorf("entry not found")
 )
 
-type seriesCache struct {
-	series *clockcache.Cache
-}
-
-var _ SeriesCache = (*seriesCache)(nil)
-
-func (b *seriesCache) GetSeries(lset Labels) (SeriesID, error) {
-	result, ok := b.series.Get(lset.String())
-	if !ok {
-		return 0, ErrEntryNotFound
-	}
-	return result.(SeriesID), nil
-}
-
-func (b *seriesCache) SetSeries(lset Labels, id SeriesID) error {
-	b.series.Insert(lset.String(), id)
-	return nil
-}
-
-func (b *seriesCache) NumElements() int {
-	return b.series.Len()
-}
-
-func (b *seriesCache) Capacity() int {
-	return b.series.Cap()
-}
-
 // MetricNameCache stores and retrieves metric table names in a in-memory cache.
 type MetricNameCache struct {
 	Metrics *clockcache.Cache

pkg/pgmodel/cache_test.go

@@ -12,84 +12,6 @@ import (
 	"github.com/timescale/timescale-prometheus/pkg/clockcache"
 )
 
-func TestCache(t *testing.T) {
-	cache := seriesCache{
-		series: clockcache.WithMax(100),
-	}
-
-	label := labels.Labels{
-		labels.Label{
-			Name:  "name1",
-			Value: "val1",
-		},
-	}
-
-	l, err := LabelsFromSlice(label)
-	if err != nil {
-		t.Errorf("invalid labels %+v: %v", l, err)
-	}
-	if _, err := cache.GetSeries(*l); err == nil {
-		t.Errorf("found cache for a series that was not stored")
-	}
-
-	testLabels := []labels.Labels{
-		{
-			labels.Label{
-				Name:  "name1",
-				Value: "val1",
-			},
-		},
-		{
-			labels.Label{
-				Name:  "name1",
-				Value: "val2",
-			},
-		},
-		{
-			labels.Label{
-				Name:  "name2",
-				Value: "val2",
-			},
-		},
-		{
-			labels.Label{
-				Name:  "name1",
-				Value: "val1",
-			},
-			labels.Label{
-				Name:  "name2",
-				Value: "val2",
-			},
-		},
-	}
-
-	for i, series := range testLabels {
-		ls, err := LabelsFromSlice(series)
-		if err != nil {
-			t.Errorf("invalid series %+v, %v", ls, err)
-		}
-		if err := cache.SetSeries(*ls, SeriesID(i)); err != nil {
-			t.Errorf("got unexpected error while storing series: %d", i)
-
-		}
-	}
-
-	for i, series := range testLabels {
-		var res SeriesID
-		ls, err := LabelsFromSlice(series)
-		if err != nil {
-			t.Errorf("invalid series %+v, %v", ls, err)
-		}
-		if res, err = cache.GetSeries(*ls); err != nil {
-			t.Errorf("got unexpected error while getting series: %v", series)
-		}
-		if res != SeriesID(i) {
-			t.Errorf("wrong id returned: got %v expected %v", res, i)
-		}
-	}
-
-}
-
 func TestBigLables(t *testing.T) {
 	builder := strings.Builder{}
 	builder.Grow(int(^uint16(0)) + 1) // one greater than uint16 max

pkg/pgmodel/ingestor.go

@@ -50,8 +50,7 @@ type samplesInfo struct {
 
 // DBIngestor ingest the TimeSeries data into Timescale database.
 type DBIngestor struct {
-	cache SeriesCache
-	db    inserter
+	db inserter
 }
 
 // Ingest transforms and ingests the timeseries data into Timescale database.
@@ -107,14 +106,6 @@ func (i *DBIngestor) parseData(tts []prompb.TimeSeries, req *prompb.WriteRequest
 	return dataSamples, rows, nil
 }
 
-func (i *DBIngestor) NumCachedSeries() int {
-	return i.cache.NumElements()
-}
-
-func (i *DBIngestor) SeriesCacheCapacity() int {
-	return i.cache.Capacity()
-}
-
 // Close closes the ingestor
 func (i *DBIngestor) Close() {
 	i.db.Close()

pkg/pgmodel/ingestor_test.go

@@ -248,20 +248,14 @@ func TestDBIngestorIngest(t *testing.T) {
 
 	for _, c := range testCases {
 		t.Run(c.name, func(t *testing.T) {
-			cache := &mockCache{
-				seriesCache:  make(map[string]SeriesID),
-				setSeriesErr: c.setSeriesErr,
-				getSeriesErr: c.getSeriesErr,
-			}
 			inserter := mockInserter{
 				insertSeriesErr: c.insertSeriesErr,
 				insertDataErr:   c.insertDataErr,
 				insertedSeries:  make(map[string]SeriesID),
 			}
 
 			i := DBIngestor{
-				cache: cache,
-				db:    &inserter,
+				db: &inserter,
 			}
 
 			count, err := i.Ingest(c.metrics, NewWriteRequest())

pkg/pgmodel/pgx.go

@@ -206,12 +206,7 @@ func NewPgxIngestorWithMetricCache(c *pgxpool.Pool, cache MetricCache, cfg *Cfg)
 		return nil, err
 	}
 
-	bc := &seriesCache{clockcache.WithMax(cfg.SeriesCacheSize)}
-
-	return &DBIngestor{
-		db:    pi,
-		cache: bc,
-	}, nil
+	return &DBIngestor{db: pi}, nil
 }
 
 // NewPgxIngestor returns a new Ingestor that write to PostgreSQL using PGX