-

internal/cache/cache.go

@@ -153,8 +153,18 @@ type CacheManager struct {
 func NewCacheManager(config config.ConfigProvider, logger *zap.Logger) *CacheManager {
 	var provider CacheProvider
 	
-	// For now, we'll use memory cache. In production, this could be Redis
-	provider = NewMemoryCache(config, logger)
+	// Use Redis if configured, otherwise fall back to memory cache
+	if config.GetBool("REDIS_ENABLED") {
+		redisProvider, err := NewRedisCache(config, logger)
+		if err != nil {
+			logger.Warn("Failed to initialize Redis cache, falling back to memory cache", zap.Error(err))
+			provider = NewMemoryCache(config, logger)
+		} else {
+			provider = redisProvider
+		}
+	} else {
+		provider = NewMemoryCache(config, logger)
+	}
 	
 	return &CacheManager{
 		provider: provider,

internal/cache/redis.go

@@ -0,0 +1,191 @@
+package cache
+
+import (
+	"context"
+	"time"
+
+	"github.com/redis/go-redis/v9"
+	"go.uber.org/zap"
+
+	"github.com/kms/api-key-service/internal/config"
+	"github.com/kms/api-key-service/internal/errors"
+)
+
+// RedisCache implements CacheProvider using Redis
+type RedisCache struct {
+	client *redis.Client
+	config config.ConfigProvider
+	logger *zap.Logger
+}
+
+// NewRedisCache creates a new Redis cache provider
+func NewRedisCache(config config.ConfigProvider, logger *zap.Logger) (CacheProvider, error) {
+	// Redis configuration
+	redisAddr := config.GetString("REDIS_ADDR")
+	if redisAddr == "" {
+		redisAddr = "localhost:6379"
+	}
+
+	redisPassword := config.GetString("REDIS_PASSWORD")
+	redisDB := config.GetInt("REDIS_DB")
+
+	// Create Redis client
+	client := redis.NewClient(&redis.Options{
+		Addr:         redisAddr,
+		Password:     redisPassword,
+		DB:           redisDB,
+		PoolSize:     config.GetInt("REDIS_POOL_SIZE"),
+		MinIdleConns: config.GetInt("REDIS_MIN_IDLE_CONNS"),
+		MaxRetries:   config.GetInt("REDIS_MAX_RETRIES"),
+		DialTimeout:  config.GetDuration("REDIS_DIAL_TIMEOUT"),
+		ReadTimeout:  config.GetDuration("REDIS_READ_TIMEOUT"),
+		WriteTimeout: config.GetDuration("REDIS_WRITE_TIMEOUT"),
+	})
+
+	// Test connection
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	if err := client.Ping(ctx).Err(); err != nil {
+		logger.Error("Failed to connect to Redis", zap.Error(err))
+		return nil, errors.NewInternalError("Failed to connect to Redis").WithInternal(err)
+	}
+
+	logger.Info("Connected to Redis successfully", zap.String("addr", redisAddr))
+
+	return &RedisCache{
+		client: client,
+		config: config,
+		logger: logger,
+	}, nil
+}
+
+// Get retrieves a value from Redis cache
+func (r *RedisCache) Get(ctx context.Context, key string) ([]byte, error) {
+	r.logger.Debug("Getting value from Redis cache", zap.String("key", key))
+
+	result, err := r.client.Get(ctx, key).Result()
+	if err != nil {
+		if err == redis.Nil {
+			return nil, errors.NewNotFoundError("cache key")
+		}
+		r.logger.Error("Failed to get value from Redis", zap.Error(err))
+		return nil, errors.NewInternalError("Failed to get cached value").WithInternal(err)
+	}
+
+	return []byte(result), nil
+}
+
+// Set stores a value in Redis cache with TTL
+func (r *RedisCache) Set(ctx context.Context, key string, value []byte, ttl time.Duration) error {
+	r.logger.Debug("Setting value in Redis cache", 
+		zap.String("key", key), 
+		zap.Duration("ttl", ttl))
+
+	err := r.client.Set(ctx, key, value, ttl).Err()
+	if err != nil {
+		r.logger.Error("Failed to set value in Redis", zap.Error(err))
+		return errors.NewInternalError("Failed to cache value").WithInternal(err)
+	}
+
+	return nil
+}
+
+// Delete removes a value from Redis cache
+func (r *RedisCache) Delete(ctx context.Context, key string) error {
+	r.logger.Debug("Deleting value from Redis cache", zap.String("key", key))
+
+	err := r.client.Del(ctx, key).Err()
+	if err != nil {
+		r.logger.Error("Failed to delete value from Redis", zap.Error(err))
+		return errors.NewInternalError("Failed to delete cached value").WithInternal(err)
+	}
+
+	return nil
+}
+
+// Exists checks if a key exists in Redis cache
+func (r *RedisCache) Exists(ctx context.Context, key string) (bool, error) {
+	count, err := r.client.Exists(ctx, key).Result()
+	if err != nil {
+		r.logger.Error("Failed to check key existence in Redis", zap.Error(err))
+		return false, errors.NewInternalError("Failed to check cache key existence").WithInternal(err)
+	}
+
+	return count > 0, nil
+}
+
+// Clear removes all values from Redis cache (use with caution)
+func (r *RedisCache) Clear(ctx context.Context) error {
+	r.logger.Warn("Clearing Redis cache - this will remove ALL cached data")
+
+	err := r.client.FlushDB(ctx).Err()
+	if err != nil {
+		r.logger.Error("Failed to clear Redis cache", zap.Error(err))
+		return errors.NewInternalError("Failed to clear cache").WithInternal(err)
+	}
+
+	return nil
+}
+
+// Close closes the Redis connection
+func (r *RedisCache) Close() error {
+	r.logger.Info("Closing Redis connection")
+	return r.client.Close()
+}
+
+// SetNX sets a key only if it doesn't exist (Redis-specific operation)
+func (r *RedisCache) SetNX(ctx context.Context, key string, value []byte, ttl time.Duration) (bool, error) {
+	r.logger.Debug("Setting value in Redis cache with NX", 
+		zap.String("key", key), 
+		zap.Duration("ttl", ttl))
+
+	result, err := r.client.SetNX(ctx, key, value, ttl).Result()
+	if err != nil {
+		r.logger.Error("Failed to set NX value in Redis", zap.Error(err))
+		return false, errors.NewInternalError("Failed to cache value with NX").WithInternal(err)
+	}
+
+	return result, nil
+}
+
+// Expire sets TTL for an existing key
+func (r *RedisCache) Expire(ctx context.Context, key string, ttl time.Duration) error {
+	r.logger.Debug("Setting TTL for Redis key", 
+		zap.String("key", key), 
+		zap.Duration("ttl", ttl))
+
+	result, err := r.client.Expire(ctx, key, ttl).Result()
+	if err != nil {
+		r.logger.Error("Failed to set TTL in Redis", zap.Error(err))
+		return errors.NewInternalError("Failed to set key TTL").WithInternal(err)
+	}
+
+	if !result {
+		return errors.NewNotFoundError("cache key")
+	}
+
+	return nil
+}
+
+// TTL returns the remaining time to live for a key
+func (r *RedisCache) TTL(ctx context.Context, key string) (time.Duration, error) {
+	ttl, err := r.client.TTL(ctx, key).Result()
+	if err != nil {
+		r.logger.Error("Failed to get TTL from Redis", zap.Error(err))
+		return 0, errors.NewInternalError("Failed to get key TTL").WithInternal(err)
+	}
+
+	return ttl, nil
+}
+
+// Keys returns all keys matching a pattern
+func (r *RedisCache) Keys(ctx context.Context, pattern string) ([]string, error) {
+	keys, err := r.client.Keys(ctx, pattern).Result()
+	if err != nil {
+		r.logger.Error("Failed to get keys from Redis", zap.Error(err))
+		return nil, errors.NewInternalError("Failed to get cache keys").WithInternal(err)
+	}
+
+	return keys, nil
+}