GitHub - yassi/dj-cache-panel: A universal cache inspector for Django.

Django Cache Panel

A universal cache inspector for Django.

Docs

https://yassi.github.io/dj-cache-panel/

Features

Browse Cache Instances: View all configured cache backends from your CACHES setting
Abilities Matrix: See at a glance which operations each cache supports (Query, Get, Delete, Flush)
Key Search: Search and browse cache keys with wildcard patterns (for supported backends)
Value Preview: View cache values directly in search results
Pagination: Navigate through large sets of keys efficiently
Admin Integration: Seamlessly integrates with Django's admin interface
Secure: Only accessible to staff users
Backend Agnostic: Works with any Django cache backend (with varying feature support)

Project Structure

dj-cache-panel/
├── dj_cache_panel/          # Main package
│   ├── templates/           # Django templates
│   ├── cache_panels.py      # Backend specific panels
│   ├── views.py             # Django views
│   └── urls.py              # URL patterns
├── example_project/         # Example Django project
├── tests/                   # Test suite
├── images/                  # Screenshots for README
└── requirements.txt         # Development dependencies

Requirements

Python 3.9+
Django 4.2+

Screenshots

Django Admin Integration

Seamlessly integrated into your Django admin interface. A new section for dj-cache-panel will appear in the same places where your models appear.

NOTE: This application does not actually introduce any model or migrations.

Caches Overview

Get a list of all your caches as well as the allowed capabilities for each cache

Key Search

Key Edits/Adds

Installation

1. Install the Package

pip install dj-cache-panel

2. Add to Django Settings

Add dj_cache_panel to your INSTALLED_APPS:

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'dj_cache_panel',  # Add this line
    # ... your other apps
]

3. Configure Cache Instances

Django cache panel will use the CACHES setting normally defined in django projects

Additionally, you can also define some extra settings for extending or changing behavior of the existing cache panels.

Note: these are advanced settings; the vast majority of django projects will not need to define any of these

DJ_CACHE_PANEL_SETTINGS = {
    # Optional: completely replace the default backend-to-panel mapping
    # "BACKEND_PANEL_MAP": {}
    #
    # Optional: extend or override specific backend-to-panel mappings
    # Panel classes can be specified as:
    #   - Simple class name (e.g., "RedisCachePanel") - for built-in panels
    #   - Full module path (e.g., "myapp.panels.CustomCachePanel") - for custom panels
    "BACKEND_PANEL_EXTENSIONS": {
        # Example: Map a custom backend to a custom panel class
        # "myapp.backends.CustomCache": "myapp.panels.CustomCachePanel",
        # Example: Override a built-in backend mapping
        # "django.core.cache.backends.redis.RedisCache": "myapp.panels.MyRedisCachePanel",
    },
    # Optional: per-cache settings overrides
    # Typically used to lock down a cache instance to only certain abilities
    "CACHES": {
        "redis": {
            "abilities": {  # Optional: override the abilities for this cache instance
                # "query": True,
                # "get_key": True,
                # "delete_key": True,
                # "edit_key": True,
                # "add_key": True,
                # "flush_cache": True,
            },
        }
    },
}

4. Include URLs

Add the Cache Panel URLs to your main urls.py:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/dj-cache-panel/', include('dj_cache_panel.urls')),  # Add this line
    path('admin/', admin.site.urls),
]

5. Run Migrations and Create Superuser

python manage.py migrate
python manage.py createsuperuser  # If you don't have an admin user

6. Access the Panel

Start your Django development server:
```
python manage.py runserver
```
Navigate to the Django admin at http://127.0.0.1:8000/admin/
Look for the "DJ_CACHE_PANEL" section in the admin interface
Click "Manage Cache keys and values" to start browsing your cache instances

License

This project is licensed under the MIT License. See the LICENSE file for details.

Development Setup

If you want to contribute to this project or set it up for local development:

Prerequisites

Python 3.9 or higher
Redis server running locally
Git
Autoconf
Docker

It is reccommended that you use docker since it will automate much of dev env setup

1. Clone the Repository

git clone https://github.com/yassi/dj-cache-panel.git
cd dj-cache-panel

2a. Set up dev environment using virtualenv

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

pip install -e . # install dj-cache-panel package locally
pip intall -r requirements.txt  # install all dev requirements

# Alternatively
make install # this will also do the above in one single command

2b. Set up dev environment using docker

make docker_up  # bring up all services (redis, memached) and dev environment container
make docker_shell  # open up a shell in the docker conatiner

3. Set Up Example Project

The repository includes an example Django project for development and testing

cd example_project
python manage.py migrate
python manage.py createsuperuser

4. Populate Test Data (Optional)

An optional CLI tool for populating cache keys automatically is included in the example django project in this code base.

python manage.py populate_redis

This command will populate your cache instance with sample data for testing.

6. Run the Development Server

python manage.py runserver

Visit http://127.0.0.1:8000/admin/ to access the Django admin with Cache Panel.

7. Running Tests

The project includes a comprehensive test suite. You can run them by using make or by invoking pytest directly:

# build and install all dev dependencies and run all tests inside of docker container
make test_docker

# Test without the docker on your host machine.
# note that testing always requires a redis and memcached service to be up.
# these are mostly easily brought up using docker
make test_local