perf: add cache in db layer

pkg/api/utils.go

@@ -117,11 +117,11 @@ func getCallerIP(c *gin.Context) string {
 	// TODO - Need to check if this is the correct way without getting spoofing
 	if runtimeEnv := utils.LoadDotEnv("RUNTIME_ENV"); runtimeEnv == "aws" {
 		callerIp := c.Request.Header.Get("X-Original-Forwarded-For")
-		log.Info().Msgf("Got caller IP from X-Original-Forwarded-For header: %s", callerIp)
+		log.Trace().Msgf("Got caller IP from X-Original-Forwarded-For header: %s", callerIp)
 		return callerIp
 	}
 	callerIp := c.ClientIP()
-	log.Info().Msgf("Got caller IP from ClientIP: %s", callerIp)
+	log.Trace().Msgf("Got caller IP from ClientIP: %s", callerIp)
 	return callerIp
 }
 

pkg/cache/cache.go

@@ -3,6 +3,7 @@ package cache
 import (
 	"context"
 	"crypto/tls"
+	"encoding/json"
 	"fmt"
 	"os"
 	"sync"
@@ -25,6 +26,12 @@ type Cache struct {
 	Redis redis.Client
 }
 
+// CacheableData interface for any data that can be cached
+type CacheableData interface {
+	GetCacheKey() string
+	GetExpiration() time.Duration
+}
+
 var (
 	instance *Cache
 	once     sync.Once
@@ -109,3 +116,29 @@ func (c *Cache) Shutdown() {
 	c.Redis.Close()
 	log.Info().Msg("Successfully closed Redis connection")
 }
+
+// GetCache attempts to retrieve and unmarshal data from cache
+func (c *Cache) GetCache(data CacheableData, value interface{}) error {
+	cachedData, err := c.Get(data.GetCacheKey())
+	if err != nil || cachedData == "" {
+		return fmt.Errorf("cache miss for key: %s", data.GetCacheKey())
+	}
+
+	log.Info().Msgf("Cache hit for key: %s", data.GetCacheKey())
+	return json.Unmarshal([]byte(cachedData), value)
+}
+
+// SetCache marshals and stores data in cache
+func (c *Cache) SetCache(data CacheableData, value interface{}) error {
+	dataJSON, err := json.Marshal(value)
+	if err != nil {
+		return fmt.Errorf("failed to marshal data: %w", err)
+	}
+
+	if err := c.SetWithExpire(data.GetCacheKey(), dataJSON, data.GetExpiration()); err != nil {
+		return fmt.Errorf("failed to set cache: %w", err)
+	}
+
+	log.Info().Msgf("Successfully set cache for key: %s", data.GetCacheKey())
+	return nil
+}

pkg/orm/dojo_worker.go

@@ -2,14 +2,58 @@ package orm
 
 import (
 	"context"
-	"dojo-api/db"
 	"errors"
 	"fmt"
 	"strconv"
+	"time"
+
+	"dojo-api/db"
+
+	"dojo-api/pkg/cache"
 
 	"github.com/rs/zerolog/log"
 )
 
+type DojoWorkerCacheKey string
+
+const (
+	WorkerByWalletCacheKey DojoWorkerCacheKey = "worker_by_wallet" // Short key for worker by wallet
+	WorkerCountCacheKey    DojoWorkerCacheKey = "worker_count"     // Short key for worker count
+)
+
+type DojoWorkerCache struct {
+	key           DojoWorkerCacheKey
+	walletAddress string
+}
+
+func NewDojoWorkerCache(key DojoWorkerCacheKey) *DojoWorkerCache {
+	return &DojoWorkerCache{
+		key: key,
+	}
+}
+
+func (dc *DojoWorkerCache) GetCacheKey() string {
+	switch dc.key {
+	case WorkerByWalletCacheKey:
+		return fmt.Sprintf("%s:%s", dc.key, dc.walletAddress)
+	case WorkerCountCacheKey:
+		return string(dc.key)
+	default:
+		return fmt.Sprintf("dw:%s", dc.walletAddress)
+	}
+}
+
+func (dc *DojoWorkerCache) GetExpiration() time.Duration {
+	switch dc.key {
+	case WorkerByWalletCacheKey:
+		return 5 * time.Minute
+	case WorkerCountCacheKey:
+		return 1 * time.Minute
+	default:
+		return 3 * time.Minute
+	}
+}
+
 type DojoWorkerORM struct {
 	dbClient      *db.PrismaClient
 	clientWrapper *PrismaClientWrapper
@@ -33,6 +77,18 @@ func (s *DojoWorkerORM) CreateDojoWorker(walletAddress string, chainId string) (
 }
 
 func (s *DojoWorkerORM) GetDojoWorkerByWalletAddress(walletAddress string) (*db.DojoWorkerModel, error) {
+	workerCache := NewDojoWorkerCache(WorkerByWalletCacheKey)
+	workerCache.walletAddress = walletAddress
+
+	var worker *db.DojoWorkerModel
+	cache := cache.GetCacheInstance()
+
+	// Try to get from cache first
+	if err := cache.GetCache(workerCache, &worker); err == nil {
+		return worker, nil
+	}
+
+	// Cache miss, fetch from database
 	s.clientWrapper.BeforeQuery()
 	defer s.clientWrapper.AfterQuery()
 
@@ -47,10 +103,26 @@ func (s *DojoWorkerORM) GetDojoWorkerByWalletAddress(walletAddress string) (*db.
 		}
 		return nil, err
 	}
+
+	// Store in cache
+	if err := cache.SetCache(workerCache, worker); err != nil {
+		log.Warn().Err(err).Msg("Failed to set worker cache")
+	}
+
 	return worker, nil
 }
 
 func (s *DojoWorkerORM) GetDojoWorkers() (int, error) {
+	workerCache := NewDojoWorkerCache(WorkerCountCacheKey)
+	var count int
+	cache := cache.GetCacheInstance()
+
+	// Try to get from cache first
+	if err := cache.GetCache(workerCache, &count); err == nil {
+		return count, nil
+	}
+
+	// Cache miss, fetch from database
 	s.clientWrapper.BeforeQuery()
 	defer s.clientWrapper.AfterQuery()
 
@@ -70,10 +142,15 @@ func (s *DojoWorkerORM) GetDojoWorkers() (int, error) {
 	}
 
 	workerCountStr := string(result[0].Count)
-	workerCountInt, err := strconv.Atoi(workerCountStr)
+	count, err = strconv.Atoi(workerCountStr)
 	if err != nil {
 		return 0, err
 	}
 
-	return workerCountInt, nil
+	// Store in cache
+	if err := cache.SetCache(workerCache, count); err != nil {
+		log.Warn().Err(err).Msg("Failed to set worker count cache")
+	}
+
+	return count, nil
 }

pkg/orm/subscriptionKey.go

@@ -2,8 +2,12 @@ package orm
 
 import (
 	"context"
-	"dojo-api/db"
 	"errors"
+	"fmt"
+	"time"
+
+	"dojo-api/db"
+	"dojo-api/pkg/cache"
 
 	"github.com/rs/zerolog/log"
 )
@@ -13,14 +17,56 @@ type SubscriptionKeyORM struct {
 	clientWrapper *PrismaClientWrapper
 }
 
+type SubscriptionKeyCacheKey string
+
+const (
+	SubKeysByHotkeyCacheKey SubscriptionKeyCacheKey = "sk_by_hotkey"
+	SubKeyByKeyCacheKey     SubscriptionKeyCacheKey = "sk_by_key"
+)
+
+type SubscriptionKeyCache struct {
+	key    SubscriptionKeyCacheKey
+	hotkey string
+	subKey string
+}
+
+func NewSubscriptionKeyCache(key SubscriptionKeyCacheKey) *SubscriptionKeyCache {
+	return &SubscriptionKeyCache{
+		key: key,
+	}
+}
+
+func (sc *SubscriptionKeyCache) GetCacheKey() string {
+	switch sc.key {
+	case SubKeysByHotkeyCacheKey:
+		return fmt.Sprintf("%s:%s", sc.key, sc.hotkey)
+	case SubKeyByKeyCacheKey:
+		return fmt.Sprintf("%s:%s", sc.key, sc.subKey)
+	default:
+		return fmt.Sprintf("sk:%s", sc.subKey)
+	}
+}
+
+func (sc *SubscriptionKeyCache) GetExpiration() time.Duration {
+	return 5 * time.Minute
+}
+
 func NewSubscriptionKeyORM() *SubscriptionKeyORM {
 	clientWrapper := GetPrismaClient()
 	return &SubscriptionKeyORM{dbClient: clientWrapper.Client, clientWrapper: clientWrapper}
 }
 
 func (a *SubscriptionKeyORM) GetSubscriptionKeysByMinerHotkey(hotkey string) ([]db.SubscriptionKeyModel, error) {
-	a.clientWrapper.BeforeQuery()
-	defer a.clientWrapper.AfterQuery()
+	subCache := NewSubscriptionKeyCache(SubKeysByHotkeyCacheKey)
+	subCache.hotkey = hotkey
+
+	var subKeys []db.SubscriptionKeyModel
+	cache := cache.GetCacheInstance()
+
+	// Try to get from cache first
+	if err := cache.GetCache(subCache, &subKeys); err == nil {
+		return subKeys, nil
+	}
 
 	ctx := context.Background()
 
@@ -41,6 +87,11 @@ func (a *SubscriptionKeyORM) GetSubscriptionKeysByMinerHotkey(hotkey string) ([]
 		return nil, err
 	}
 
+	// Cache the result
+	if err := cache.SetCache(subCache, apiKeys); err != nil {
+		log.Error().Err(err).Msgf("Error caching subscription keys")
+	}
+
 	return apiKeys, nil
 }
 
@@ -88,6 +139,16 @@ func (a *SubscriptionKeyORM) DisableSubscriptionKeyByHotkey(hotkey string, subsc
 }
 
 func (a *SubscriptionKeyORM) GetSubscriptionByKey(subScriptionKey string) (*db.SubscriptionKeyModel, error) {
+	subCache := NewSubscriptionKeyCache(SubKeyByKeyCacheKey)
+	subCache.subKey = subScriptionKey
+
+	var foundSubscriptionKey *db.SubscriptionKeyModel
+	cache := cache.GetCacheInstance()
+
+	// Try to get from cache first
+	if err := cache.GetCache(subCache, &foundSubscriptionKey); err == nil {
+		return foundSubscriptionKey, nil
+	}
 	a.clientWrapper.BeforeQuery()
 	defer a.clientWrapper.AfterQuery()
 
@@ -107,5 +168,10 @@ func (a *SubscriptionKeyORM) GetSubscriptionByKey(subScriptionKey string) (*db.S
 		return nil, err
 	}
 
+	// Cache the result
+	if err := cache.SetCache(subCache, foundSubscriptionKey); err != nil {
+		log.Error().Err(err).Msgf("Error caching subscription key")
+	}
+
 	return foundSubscriptionKey, nil
 }