configurable cache ttl

Author: nshntarora

api/handlers/handlers.go

@@ -27,9 +27,9 @@ func GetHandlers(cfg *config.Config) *http.ServeMux {
 
 func GetNewCacheStore(cfg *config.Config) cache.Cache {
 	if cfg.CacheBackend == "redis" {
-		cache.NewRedisCache(cfg.Redis.Host, strconv.Itoa(cfg.Redis.Port))
+		cache.NewRedisCache(cfg.Redis.Host, strconv.Itoa(cfg.Redis.Port), cfg.CacheTTL)
 	}
-	return cache.NewInMemoryCache()
+	return cache.NewInMemoryCache(cfg.CacheTTL)
 }
 
 func GetCacheOptions(cfg *config.Config, values []interface{}) *graphcache.GraphCacheOptions {

cache/inmemory_cache.go

@@ -3,32 +3,54 @@ package cache
 import (
 	"encoding/json"
 	"errors"
-	"fmt"
 	"graphql_cache/utils/file_utils"
 	"regexp"
 	"strings"
+	"sync"
+	"time"
 )
 
 type InMemoryCache struct {
-	data map[string]interface{}
+	data       map[string]interface{}
+	expiration map[string]*time.Time
+	ttl        int
+	mu         sync.Mutex
 }
 
-func NewInMemoryCache() *InMemoryCache {
-	return &InMemoryCache{
-		data: make(map[string]interface{}),
+func NewInMemoryCache(ttl int) *InMemoryCache {
+	cache := &InMemoryCache{
+		data:       make(map[string]interface{}),
+		expiration: make(map[string]*time.Time),
+		ttl:        ttl,
 	}
+	go cache.cleanup()
+	return cache
 }
 
 func (c *InMemoryCache) Key(key string) string {
 	return key
 }
 
 func (c *InMemoryCache) Set(key string, value interface{}) error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
 	c.data[c.Key(key)] = deepCopy(value)
+	if value == nil {
+		c.expiration[c.Key(key)] = nil
+	} else {
+		t := time.Now().Add(time.Duration(c.ttl) * time.Second)
+		c.expiration[c.Key(key)] = &t
+	}
 	return nil
 }
 
 func (c *InMemoryCache) Get(key string) (interface{}, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	expiration, exists := c.expiration[c.Key(key)]
+	if !exists || expiration == nil || time.Now().After(*expiration) {
+		return nil, errors.New("key not found")
+	}
 	value, exists := c.data[c.Key(key)]
 	if !exists {
 		return nil, errors.New("key not found")
@@ -37,28 +59,51 @@ func (c *InMemoryCache) Get(key string) (interface{}, error) {
 }
 
 func (c *InMemoryCache) Del(key string) error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
 	c.Set(c.Key(key), nil)
 	return nil
 }
 
 func (c *InMemoryCache) Exists(key string) (bool, error) {
-	_, exists := c.data[c.Key(key)]
-	return exists, nil
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	expiration, exists := c.expiration[c.Key(key)]
+	if !exists || expiration == nil || time.Now().After(*expiration) {
+		return false, nil
+	}
+	return true, nil
 }
 
 func (c *InMemoryCache) Map() (map[string]interface{}, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
 	copy := make(map[string]interface{})
+	now := time.Now()
 	for k, v := range c.data {
-		copy[k] = v
+		if expiration, exists := c.expiration[k]; exists && expiration != nil && now.Before(*expiration) {
+			copy[k] = v
+		}
 	}
 	return copy, nil
 }
 
 func (c *InMemoryCache) JSON() ([]byte, error) {
-	return json.Marshal(c.data)
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	copy := make(map[string]interface{})
+	now := time.Now()
+	for k, v := range c.data {
+		if expiration, exists := c.expiration[k]; exists && expiration != nil && now.Before(*expiration) {
+			copy[k] = v
+		}
+	}
+	return json.Marshal(copy)
 }
 
 func (c *InMemoryCache) Debug(identifier string) error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
 	f := file_utils.NewFile("../" + identifier + ".cache.json")
 	defer f.Close()
 	jsonContent, _ := c.JSON()
@@ -67,23 +112,40 @@ func (c *InMemoryCache) Debug(identifier string) error {
 }
 
 func (c *InMemoryCache) Flush() error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
 	c.data = make(map[string]interface{})
+	c.expiration = make(map[string]*time.Time)
 	return nil
 }
 
 func (c *InMemoryCache) DeleteByPrefix(prefix string) error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
 	var re = regexp.MustCompile(`(?m)` + strings.ReplaceAll(c.Key(prefix), "*", ".*"))
 	for k := range c.data {
-		// regex match the prefix to the key
-		// if the key is gql:* then delete all keys which start with gql
 		if re.Match([]byte(k)) {
-			fmt.Println("deleting key: ", k)
 			c.Del(k)
 		}
 	}
 	return nil
 }
 
+func (c *InMemoryCache) cleanup() {
+	for {
+		time.Sleep(time.Duration(c.ttl) * time.Second)
+		c.mu.Lock()
+		now := time.Now()
+		for key, expiration := range c.expiration {
+			if expiration != nil && now.After(*expiration) {
+				delete(c.data, key)
+				delete(c.expiration, key)
+			}
+		}
+		c.mu.Unlock()
+	}
+}
+
 func deepCopy(v interface{}) interface{} {
 	if v == nil {
 		return nil

cache/redis_cache.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"reflect"
+	"time"
 
 	"github.com/go-redis/redis/v8"
 )
@@ -13,20 +14,22 @@ var ctx = context.Background()
 // RedisCache implements the Cache interface and uses Redis as the cache store
 type RedisCache struct {
 	cache *redis.Client
+	ttl   int
 }
 
 func (c *RedisCache) Key(key string) string {
 	return key
 }
 
-func NewRedisCache(host, port string) Cache {
+func NewRedisCache(host, port string, ttl int) Cache {
 	c := redis.NewClient(&redis.Options{
 		Addr:     host + ":" + port,
 		Password: "", // no password set
 		DB:       0,  // use default DB
 	})
 	return &RedisCache{
 		cache: c,
+		ttl:   ttl,
 	}
 }
 
@@ -35,14 +38,14 @@ func (c *RedisCache) Set(key string, value interface{}) error {
 	switch valueType.Kind() {
 	case reflect.Map:
 		br, _ := json.Marshal(value)
-		c.cache.Set(ctx, c.Key(key), string(br), 0)
-		c.cache.Set(ctx, c.Key(key+"_type"), "reflect.Map", 0)
+		c.cache.Set(ctx, c.Key(key), string(br), time.Second*time.Duration(c.ttl))
+		c.cache.Set(ctx, c.Key(key+"_type"), "reflect.Map", time.Second*time.Duration(c.ttl))
 	case reflect.Slice:
 		br, _ := json.Marshal(value)
-		c.cache.Set(ctx, c.Key(key), string(br), 0)
-		c.cache.Set(ctx, c.Key(key+"_type"), "reflect.Slice", 0)
+		c.cache.Set(ctx, c.Key(key), string(br), time.Second*time.Duration(c.ttl))
+		c.cache.Set(ctx, c.Key(key+"_type"), "reflect.Slice", time.Second*time.Duration(c.ttl))
 	default:
-		c.cache.Set(ctx, c.Key(key), value, 0)
+		c.cache.Set(ctx, c.Key(key), value, time.Second*time.Duration(c.ttl))
 	}
 	return nil
 }

config.toml

@@ -16,6 +16,9 @@ port=9090
 # The returns cache hit or cache miss in the header you specify here. Default is X-Orbit-Cache
 cache_header_name="X-Orbit-Cache"
 
+# TTL of the graphql cache in seconds - default is 60 minutes
+cache_ttl=3600
+
 # If you have an authenticated API and want to separate the cache based on what the headers are, you can configure the headers here.
 # The system will scope the cache based on the unique values of the headers you provide
 # For example, if you want to scope the cache based on the Authorization header, you can set the following:

config/config.go

@@ -26,6 +26,7 @@ type Config struct {
 	Port            int            `toml:"port"`
 	CacheBackend    string         `toml:"cache_backend"`
 	CacheHeaderName string         `toml:"cache_header_name"`
+	CacheTTL        int            `toml:"cache_ttl"`
 	ScopeHeaders    []string       `toml:"scope_headers"`
 	PrimaryKeyField string         `toml:"primary_key_field"`
 	Handlers        HandlersConfig `toml:"handlers"`
@@ -85,5 +86,10 @@ func NewConfig() *Config {
 		cfg.CacheHeaderName = "x-orbit-cache"
 	}
 
+	if cfg.CacheTTL == 0 {
+		// default cache TTL is 1 hour
+		cfg.CacheTTL = 3600
+	}
+
 	return &cfg
 }

graphcache/graphcache.go

@@ -39,8 +39,8 @@ const CacheBackendInMemory CacheBackend = "in_memory"
 
 func NewGraphCache() *GraphCache {
 	return NewGraphCacheWithOptions(context.Background(), &GraphCacheOptions{
-		ObjectStore: cache.NewInMemoryCache(),
-		QueryStore:  cache.NewInMemoryCache(),
+		ObjectStore: cache.NewInMemoryCache(300),
+		QueryStore:  cache.NewInMemoryCache(300),
 	})
 }
 

graphcache/graphcache_test.go

@@ -19,8 +19,8 @@ func TestNewGraphCache(t *testing.T) {
 
 func TestNewGraphCacheWithOptions(t *testing.T) {
 	opts := &GraphCacheOptions{
-		ObjectStore: cache.NewInMemoryCache(),
-		QueryStore:  cache.NewInMemoryCache(),
+		ObjectStore: cache.NewInMemoryCache(300),
+		QueryStore:  cache.NewInMemoryCache(300),
 		Prefix:      "test::",
 		IDField:     "customID",
 	}