fix: update fastcache metrics with go routine (#206)

* chore: update metric with go routine

* chore: update metric with go routine

* fix: missing for loop

* chore: fix comment

store/cache/cache.go

@@ -2,6 +2,7 @@ package cache
 
 import (
 	"sync"
+	"time"
 
 	"github.com/VictoriaMetrics/fastcache"
 	"github.com/line/lbm-sdk/v2/store/cachekv"
@@ -63,13 +64,29 @@ func NewCommitKVStoreCacheManager(cacheSize int, provider MetricsProvider) *Comm
 		// This function was called because it intended to use the inter block cache, creating a cache of minimal size.
 		cacheSize = DefaultCommitKVStoreCacheSize
 	}
-	return &CommitKVStoreCacheManager{
+	cm := &CommitKVStoreCacheManager{
 		cache:       fastcache.New(cacheSize),
 		caches:      make(map[string]types.CommitKVStore),
 		metrics:     provider(),
 		prefixMap:   make(map[string][]byte),
 		prefixOrder: 0,
 	}
+	startCacheMetricUpdator(cm.cache, cm.metrics)
+	return cm
+}
+
+func startCacheMetricUpdator(cache *fastcache.Cache, metrics *Metrics) {
+	// Execution time of `fastcache.UpdateStats()` can increase linearly as cache entries grows
+	// So we update the metrics with a separate go route.
+	go func() {
+		for {
+			stats := fastcache.Stats{}
+			cache.UpdateStats(&stats)
+			metrics.InterBlockCacheEntries.Set(float64(stats.EntriesCount))
+			metrics.InterBlockCacheBytes.Set(float64(stats.BytesSize))
+			time.Sleep(1 * time.Minute)
+		}
+	}()
 }
 
 // GetStoreCache returns a Cache from the CommitStoreCacheManager for a given
@@ -135,10 +152,6 @@ func (ckv *CommitKVStoreCache) Get(key []byte) []byte {
 	ckv.metrics.InterBlockCacheMisses.Add(1)
 	value := ckv.CommitKVStore.Get(key)
 	ckv.cache.Set(prefixedKey, value)
-	stats := fastcache.Stats{}
-	ckv.cache.UpdateStats(&stats)
-	ckv.metrics.InterBlockCacheEntries.Set(float64(stats.EntriesCount))
-	ckv.metrics.InterBlockCacheBytes.Set(float64(stats.BytesSize))
 	return value
 }
 

store/iavl/store.go

@@ -35,7 +35,6 @@ var (
 	_ types.StoreWithInitialVersion = (*Store)(nil)
 
 	_ types.CacheManager = (*CacheManagerSingleton)(nil)
-	_ types.CacheManager = (*CacheManagerOwnCache)(nil)
 )
 
 // Store Implements types.KVStore and CommitKVStore.
@@ -55,24 +54,28 @@ func (cms *CacheManagerSingleton) GetCache() *fastcache.Cache {
 }
 
 func NewCacheManagerSingleton(cacheSize int, provider MetricsProvider) types.CacheManager {
-	return &CacheManagerSingleton{
+	cm := &CacheManagerSingleton{
 		cache:   fastcache.New(cacheSize),
 		metrics: provider(),
 	}
-}
-
-type CacheManagerOwnCache struct {
-	cacheSize int
-}
-
-func (cmo *CacheManagerOwnCache) GetCache() *fastcache.Cache {
-	return fastcache.New(cmo.cacheSize)
-}
-
-func NewCacheManagerOwnCache(cacheSize int) types.CacheManager {
-	return &CacheManagerOwnCache{
-		cacheSize: cacheSize,
-	}
+	startCacheMetricUpdator(cm.cache, cm.metrics)
+	return cm
+}
+
+func startCacheMetricUpdator(cache *fastcache.Cache, metrics *Metrics) {
+	// Execution time of `fastcache.UpdateStats()` can increase linearly as cache entries grows
+	// So we update the metrics with a separate go route.
+	go func() {
+		for {
+			stats := fastcache.Stats{}
+			cache.UpdateStats(&stats)
+			metrics.IAVLCacheHits.Set(float64(stats.GetCalls - stats.Misses))
+			metrics.IAVLCacheMisses.Set(float64(stats.Misses))
+			metrics.IAVLCacheEntries.Set(float64(stats.EntriesCount))
+			metrics.IAVLCacheBytes.Set(float64(stats.BytesSize))
+			time.Sleep(1 * time.Minute)
+		}
+	}()
 }
 
 type CacheManagerNoCache struct{}
@@ -230,14 +233,6 @@ func (st *Store) Set(key, value []byte) {
 func (st *Store) Get(key []byte) []byte {
 	defer telemetry.MeasureSince(time.Now(), "store", "iavl", "get")
 	_, value := st.tree.Get(key)
-	if st.cache != nil {
-		stats := fastcache.Stats{}
-		st.cache.UpdateStats(&stats)
-		st.metrics.IAVLCacheHits.Set(float64(stats.GetCalls - stats.Misses))
-		st.metrics.IAVLCacheMisses.Set(float64(stats.Misses))
-		st.metrics.IAVLCacheEntries.Set(float64(stats.EntriesCount))
-		st.metrics.IAVLCacheBytes.Set(float64(stats.BytesSize))
-	}
 	return value
 }