Function WrapWithLRUCache

cache/lru.go:42–79

WrapWithLRUCache wraps a given `Cache` c with a LRU cache. The LRU cache will always store items in both caches. However it will only fetch items from the underlying cache if the LRU cache doesn't have the item. Items fetched from the underlying cache will be stored in the LRU cache with a default T

(c Cache, name string, reg prometheus.Registerer, lruSize int, defaultTTL time.Duration, logger log.Logger)

// The LRU cache is limited in number of items using `lruSize`. This means this cache is not tailored for large items or items that have a big
// variation in size.
func WrapWithLRUCache(c Cache, name string, reg prometheus.Registerer, lruSize int, defaultTTL time.Duration, logger log.Logger) (*LRUCache, error) {
	l, err := lru.NewLRU[string, *Item](lruSize, nil)
	if err != nil {
		return nil, err
	}

	cache := &LRUCache{
		c:          c,
		logger:     logger,
		lru:        l,
		name:       name,
		defaultTTL: defaultTTL,

		requests: promauto.With(reg).NewCounter(prometheus.CounterOpts{
			Name:        "cache_memory_requests_total",
			Help:        "Total number of requests to the in-memory cache.",
			ConstLabels: map[string]string{"name": name},
		}),
		hits: promauto.With(reg).NewCounter(prometheus.CounterOpts{
			Name:        "cache_memory_hits_total",
			Help:        "Total number of requests to the in-memory cache that were a hit.",
			ConstLabels: map[string]string{"name": name},
		}),
	}

	cache.items = promauto.With(reg).NewGaugeFunc(prometheus.GaugeOpts{
		Name:        "cache_memory_items_count",
		Help:        "Total number of items currently in the in-memory cache.",
		ConstLabels: map[string]string{"name": name},
	}, func() float64 {
		cache.mtx.Lock()
		defer cache.mtx.Unlock()

		return float64(cache.lru.Len())
	})

	return cache, nil
}

func (l *LRUCache) SetAsync(key string, value []byte, ttl time.Duration) {
	l.c.SetAsync(key, value, ttl)