Caching Strategy

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
        'LOCATION': os.getenv('REDIS_URL', 'redis://localhost:6379/1'),
        'OPTIONS': {
            'CLIENT_CLASS': 'django_redis.client.DefaultClient',
        },
        'KEY_PREFIX': 'fkapi',
        'TIMEOUT': 3600,  # Default: 1 hour
    }
}

from core.cache_utils import generate_cache_key

# Basic usage
cache_key = generate_cache_key("club_kits", club_id)
# Result: "club_kits_1"

# With multiple parameters
cache_key = generate_cache_key("club_kits", club_id, "season", season_id)
# Result: "club_kits_1_season_2"

# With keyword arguments
cache_key = generate_cache_key("kits", club=1, season=2, page=1)
# Result: "kits_club=1_page=1_season=2" (sorted)

def generate_cache_key(prefix: str, *args: Any, **kwargs: Any) -> str:
    parts = [prefix]
    parts.extend(str(arg) for arg in args)
    
    if kwargs:
        sorted_kwargs = sorted(kwargs.items())
        parts.extend(f"{k}={v}" for k, v in sorted_kwargs)
    
    key_string = "_".join(parts)
    
    if len(key_string) > 200:
        key_hash = hashlib.md5(key_string.encode()).hexdigest()
        return f"{prefix}_{key_hash}"
    
    return key_string

from django.db.models.signals import post_save, post_delete

def setup_cache_invalidation():
    """Set up signal handlers for automatic cache invalidation."""
    
    def invalidate_on_save(sender, instance, **kwargs):
        invalidation_fn = _MODEL_INVALIDATORS.get(type(instance))
        if invalidation_fn is not None:
            invalidation_fn(instance.id)
        if type(instance) is Kit:
            _invalidate_kit_related(instance)
    
    def invalidate_on_delete(sender, instance, **kwargs):
        invalidation_fn = _MODEL_INVALIDATORS.get(type(instance))
        if invalidation_fn is not None:
            invalidation_fn(instance.id)
    
    for model in (Club, Season, Kit, Brand, Competition):
        post_save.connect(invalidate_on_save, sender=model)
        post_delete.connect(invalidate_on_delete, sender=model)

from core.cache_utils import invalidate_club_cache

invalidate_club_cache(club_id=1)

from core.cache_utils import invalidate_season_cache

invalidate_season_cache(season_id=1)

from core.cache_utils import invalidate_kit_cache

invalidate_kit_cache(kit_id=1)

from core.cache_utils import invalidate_brand_cache

invalidate_brand_cache(brand_id=1)

from core.cache_utils import invalidate_competition_cache

invalidate_competition_cache(competition_id=1)

from core.cache_utils import invalidate_search_cache

invalidate_search_cache()

from core.cache_utils import invalidate_user_collection_cache

invalidate_user_collection_cache(userid=148184)

def _invalidate_patterns(patterns: list[str]) -> None:
    """Invalidate cache entries matching the given patterns."""
    try:
        from django_redis import get_redis_connection
        
        redis_client = get_redis_connection("default")
        for pattern in patterns:
            try:
                keys = redis_client.keys(f"fkapi:{pattern}")
                if keys:
                    redis_client.delete(*keys)
                    logger.info(f"Invalidated {len(keys)} cache keys matching pattern: {pattern}")
            except Exception as pattern_error:
                logger.debug(f"Pattern invalidation not supported for pattern {pattern}: {str(pattern_error)}")
    except ImportError:
        logger.debug("django-redis not available, skipping pattern-based invalidation")
    except Exception as e:
        logger.debug(f"Cache pattern invalidation not supported: {str(e)}")

Usage: manage.py warm_cache [options]

Options:
  --clubs N       Cache seasons for top N clubs (default: 50)
  --kits N        Cache N recent kits (default: 100)
  --seasons       Cache seasons for top clubs
  --search        Cache popular search queries

python manage.py warm_cache --seasons --clubs 100

python manage.py warm_cache --kits 200

python manage.py warm_cache --seasons --search

# settings.py
from celery.schedules import crontab

CELERY_BEAT_SCHEDULE = {
    'scrape_daily': {
        'task': 'core.tasks.scrape_daily',
        'schedule': crontab(hour=0, minute=0),
    },
    'warm_cache': {
        'task': 'core.tasks.warm_cache_task',
        'schedule': crontab(hour=2, minute=0),  # 2 AM daily
    },
}

# Example: Kit detail endpoint
Kit.objects.select_related(
    "team", "season", "brand", "type", "primary_color"
).prefetch_related(
    "competition", "secondary_color"
)

# Redis CLI
redis-cli
> INFO stats

# Look for:
# keyspace_hits - Number of cache hits
# keyspace_misses - Number of cache misses

hit_rate = keyspace_hits / (keyspace_hits + keyspace_misses)

# Set max memory (e.g., 512MB)
maxmemory 512mb

# Eviction policy - remove least recently used keys
maxmemory-policy allkeys-lru

# Sample size for LRU algorithm
maxmemory-samples 5

redis-cli INFO memory

┌─────────────┐
│   Request   │
└──────┬──────┘
       │
       ▼
┌─────────────────────┐
│  Generate Cache Key │
└──────┬──────────────┘
       │
       ▼
┌─────────────────────┐      Yes    ┌──────────────┐
│  Check Redis Cache  ├─────────────►│ Return Data  │
└──────┬──────────────┘              └──────────────┘
       │ No
       ▼
┌─────────────────────┐
│   Query Database    │
└──────┬──────────────┘
       │
       ▼
┌─────────────────────┐
│  Store in Cache     │
│  (with TTL)         │
└──────┬──────────────┘
       │
       ▼
┌─────────────────────┐
│   Return Data       │
└─────────────────────┘

redis-cli ping
# Expected output: PONG

python manage.py shell

>>> from django.core.cache import cache
>>> cache.set('test', 'value', 60)
>>> cache.get('test')
'value'

pip list | grep django-redis

echo $REDIS_URL
# Should output: redis://localhost:6379/1

python manage.py shell

>>> from core.cache_utils import setup_cache_invalidation
>>> setup_cache_invalidation()

# Add logging to cache_utils.py
import logging
logger = logging.getLogger(__name__)

def invalidate_on_save(sender, instance, **kwargs):
    logger.info(f"Invalidating cache for {type(instance).__name__} {instance.id}")
    # ...

from core.cache_utils import invalidate_search_cache
invalidate_search_cache()

# settings.py
CACHE_TIMEOUT_MEDIUM = 1800  # 30 minutes
# Reduce if data changes frequently

redis-cli INFO memory | grep used_memory_human

redis-cli KEYS "fkapi:*" | wc -l

# settings.py
CACHE_TIMEOUT_MEDIUM = 900  # 15 minutes instead of 30

# redis.conf
maxmemory 512mb
maxmemory-policy allkeys-lru

redis-cli --scan --pattern "fkapi:search_*" | xargs redis-cli DEL

# Good
from core.cache_utils import generate_cache_key
cache_key = generate_cache_key("kits", club=1, season=2)

# Bad
cache_key = f"kits_club_{club}_season_{season}"  # Inconsistent ordering

# After deployment
python manage.py warm_cache --seasons --kits 100

# tests/test_cache.py
from django.test import TestCase
from django.core.cache import cache
from core.models import Kit
from core.cache_utils import generate_cache_key

class CacheInvalidationTestCase(TestCase):
    def test_kit_save_invalidates_cache(self):
        kit = Kit.objects.first()
        cache_key = generate_cache_key("kit_json", kit.id)
        
        # Cache the kit
        cache.set(cache_key, {"test": "data"}, 3600)
        self.assertIsNotNone(cache.get(cache_key))
        
        # Save the kit (should trigger invalidation)
        kit.name = "Updated Name"
        kit.save()
        
        # Cache should be invalidated
        self.assertIsNone(cache.get(cache_key))