Fix leaky bytes allocation for cache.

Makefile

@@ -11,7 +11,7 @@ help:  ## display this help
 
 .PHONY: run
 run: build ## run application
-	@LOG_LEVEL=debug BLOCK_SCHEMA_INTROSPECTION=false JWT_ROLE_RATE_LIMIT=false JWT_ROLE_CLAIM_PATH="Hasura.x-hasura-default-role" JWT_USER_CLAIM_PATH="Hasura.x-hasura-user-id" HOST_GRAPHQL=https://hasura8.lan/ ./graphql-proxy
+	@LOG_LEVEL=debug BLOCK_SCHEMA_INTROSPECTION=false CACHE_TTL=10 JWT_ROLE_RATE_LIMIT=false JWT_ROLE_CLAIM_PATH="Hasura.x-hasura-default-role" JWT_USER_CLAIM_PATH="Hasura.x-hasura-user-id" HOST_GRAPHQL=https://hasura8.lan/ ./graphql-proxy
 
 .PHONY: build
 build: ## build the binary

cache.go

@@ -14,15 +14,13 @@ func calculateHash(c *fiber.Ctx) string {
 }
 
 func enableCache() {
-	cfg.Cache.CacheClient = libpack_cache.New(time.Duration(cfg.Cache.CacheTTL) * time.Second * 2)
+	cfg.Cache.CacheClient = libpack_cache.New(time.Duration(cfg.Cache.CacheTTL) * time.Second * 100)
 }
 
 func cacheLookup(hash string) []byte {
-	if cfg.Cache.CacheClient != nil {
-		obj, found := cfg.Cache.CacheClient.Get(hash)
-		if found {
-			return obj
-		}
+	obj, found := cfg.Cache.CacheClient.Get(hash)
+	if found {
+		return obj
 	}
 	return nil
 }

cache/cache.go

@@ -12,16 +12,21 @@ type CacheEntry struct {
 
 type Cache struct {
 	sync.RWMutex
-	entries   map[string]CacheEntry
+	entries   sync.Map
 	globalTTL time.Duration
+	bytePool  sync.Pool
 }
 
 func New(globalTTL time.Duration) *Cache {
 	cache := &Cache{
-		entries:   make(map[string]CacheEntry),
 		globalTTL: globalTTL,
 	}
 
+	// Initialize the byte pool.
+	cache.bytePool.New = func() interface{} {
+		return make([]byte, 0)
+	}
+
 	// Start the cache cleanup.
 	go cache.cleanupRoutine(globalTTL)
 	return cache
@@ -39,54 +44,69 @@ func (c *Cache) cleanupRoutine(globalTTL time.Duration) {
 func (c *Cache) Set(key string, value []byte, ttl time.Duration) {
 	c.Lock()
 	defer c.Unlock()
+	expiresAt := time.Now().Add(ttl)
 
-	now := time.Now()
-	expiresAt := now.Add(ttl)
-	if expiresAt.After(now.Add(c.globalTTL)) {
-		expiresAt = now.Add(c.globalTTL)
+	// Get a byte slice from the pool and ensure it's properly sized.
+	b := c.bytePool.Get().([]byte)
+	if cap(b) < len(value) {
+		b = make([]byte, len(value))
+	} else {
+		b = b[:len(value)]
 	}
 
-	c.entries[key] = CacheEntry{
-		Value:     value,
+	copy(b, value)
+
+	entry := CacheEntry{
+		Value:     b,
 		ExpiresAt: expiresAt,
 	}
+	c.entries.Store(key, entry)
 }
 
 func (c *Cache) Get(key string) ([]byte, bool) {
 	c.RLock()
 	defer c.RUnlock()
 
-	entry, ok := c.entries[key]
-	if !ok || entry.ExpiresAt.Before(time.Now()) {
+	entry, ok := c.entries.Load(key)
+	if !ok || entry.(CacheEntry).ExpiresAt.Before(time.Now()) {
 		return nil, false
 	}
 
-	return entry.Value, true
+	// Copy the value from the byte slice.
+	value := make([]byte, len(entry.(CacheEntry).Value))
+	copy(value, entry.(CacheEntry).Value)
+	return value, true
 }
 
 func (c *Cache) Delete(key string) {
 	c.Lock()
 	defer c.Unlock()
 
-	delete(c.entries, key)
+	entry, ok := c.entries.Load(key)
+	if !ok {
+		return
+	}
+
+	// Return the byte slice to the pool.
+	c.bytePool.Put(entry.(CacheEntry).Value)
+
+	// Delete the entry from the cache.
+	c.entries.Delete(key)
 }
 
 func (c *Cache) CleanExpiredEntries() {
 	now := time.Now()
-	toDelete := make([]string, 0)
-
-	c.RLock()
-	for key, entry := range c.entries {
+	c.entries.Range(func(key, value interface{}) bool {
+		entry := value.(CacheEntry)
 		if entry.ExpiresAt.Before(now) {
-			toDelete = append(toDelete, key)
-		}
-	}
-	c.RUnlock()
+			// Return the byte slice to the pool.
+			c.bytePool.Put(entry.Value)
 
-	// Separate the deletion to its own critical section to reduce lock contention.
-	c.Lock()
-	for _, key := range toDelete {
-		delete(c.entries, key)
-	}
-	c.Unlock()
+			// Delete the entry from the cache.
+			c.entries.Delete(key)
+		}
+
+		// Return true to continue iterating over the map.
+		return true
+	})
 }

cache_test.go

@@ -27,7 +27,7 @@ func (suite *Tests) Test_cacheLookup() {
 		{
 			name: "test_existent",
 			args: args{
-				hash: "00000000000000000000000000000000000001",
+				hash: "00000000000000000000000000000000001337",
 			},
 			want: []byte("it's fine."),
 			addCache: struct {
@@ -40,7 +40,7 @@ func (suite *Tests) Test_cacheLookup() {
 	for _, tt := range tests {
 		suite.T().Run(tt.name, func(t *testing.T) {
 			if tt.addCache.data != nil {
-				cfg.Cache.CacheClient.Set(tt.args.hash, tt.addCache.data, time.Duration(1)*time.Second)
+				cfg.Cache.CacheClient.Set(tt.args.hash, tt.addCache.data, time.Duration(90*time.Second))
 			}
 			got := cacheLookup(tt.args.hash)
 			assert.Equal(tt.want, got, "Unexpected cache lookup result")