""" Views for monitoring and managing permission cache performance """ from django.shortcuts import render, redirect from django.contrib.admin.views.decorators import staff_member_required from django.contrib import messages from django.http import JsonResponse from django.utils import timezone from django.views.decorators.http import require_http_methods from django.views.decorators.csrf import csrf_exempt from users.permission_cache_service import permission_cache from users.models import CustomUser from users.decorators import require_permission import json import logging logger = logging.getLogger(__name__) @staff_member_required @require_permission('admin', 'system_monitoring') def cache_performance_dashboard(request): """ Display cache performance dashboard with statistics and controls """ try: # Get cache statistics cache_stats = permission_cache.get_cache_statistics() # Get recent cache activity (if available) recent_activity = _get_recent_cache_activity() # Get system recommendations recommendations = _get_cache_recommendations(cache_stats) context = { 'cache_stats': cache_stats, 'recent_activity': recent_activity, 'recommendations': recommendations, 'page_title': 'Permission Cache Performance', 'last_updated': timezone.now() } return render(request, 'users/cache_performance_dashboard.html', context) except Exception as e: logger.error(f"Error loading cache performance dashboard: {e}") messages.error(request, f"Error loading cache dashboard: {str(e)}") return redirect('admin:index') @staff_member_required @require_permission('admin', 'cache_management') @require_http_methods(["POST"]) def warm_cache_action(request): """ Warm cache for selected users or roles """ try: action_type = request.POST.get('action_type') if action_type == 'critical_users': limit = int(request.POST.get('limit', 50)) results = permission_cache.warm_critical_users_cache(limit) messages.success( request, f"Cache warmed for {results['successful_users']}/{results['total_users']} critical users" ) elif action_type == 'specific_users': user_ids = request.POST.getlist('user_ids') if not user_ids: messages.error(request, "No users selected for cache warming") return redirect('cache_performance_dashboard') total_successful = 0 total_failed = 0 for user_id in user_ids: try: results = permission_cache.warm_user_cache(user_id) if not results.get('errors'): total_successful += 1 else: total_failed += 1 except Exception as e: total_failed += 1 logger.error(f"Error warming cache for user {user_id}: {e}") messages.success( request, f"Cache warming completed: {total_successful} successful, {total_failed} failed" ) elif action_type == 'role_users': role = request.POST.get('role') limit = int(request.POST.get('limit', 20)) if not role: messages.error(request, "No role selected for cache warming") return redirect('cache_performance_dashboard') # Get users with this role users = CustomUser.objects.filter(role=role, is_active=True)[:limit] total_successful = 0 total_failed = 0 for user in users: try: results = permission_cache.warm_user_cache(str(user.id)) if not results.get('errors'): total_successful += 1 else: total_failed += 1 except Exception as e: total_failed += 1 logger.error(f"Error warming cache for user {user.id}: {e}") messages.success( request, f"Cache warmed for {total_successful}/{len(users)} users with role '{role}'" ) else: messages.error(request, "Invalid cache warming action") return redirect('cache_performance_dashboard') except Exception as e: logger.error(f"Error in cache warming action: {e}") messages.error(request, f"Error warming cache: {str(e)}") return redirect('cache_performance_dashboard') @staff_member_required @require_permission('admin', 'cache_management') @require_http_methods(["POST"]) def invalidate_cache_action(request): """ Invalidate cache for selected users or roles """ try: action_type = request.POST.get('action_type') if action_type == 'specific_user': user_id = request.POST.get('user_id') page_name = request.POST.get('page_name') # Optional if not user_id: messages.error(request, "No user selected for cache invalidation") return redirect('cache_performance_dashboard') invalidated_count = permission_cache.invalidate_user_cache(user_id, page_name) if page_name: messages.success( request, f"Invalidated {invalidated_count} cache keys for user {user_id}, page {page_name}" ) else: messages.success( request, f"Invalidated {invalidated_count} cache keys for user {user_id} (all pages)" ) elif action_type == 'role_cache': role = request.POST.get('role') if not role: messages.error(request, "No role selected for cache invalidation") return redirect('cache_performance_dashboard') invalidated_count = permission_cache.invalidate_role_cache(role) messages.success( request, f"Invalidated {invalidated_count} cache keys for role '{role}'" ) else: messages.error(request, "Invalid cache invalidation action") return redirect('cache_performance_dashboard') except Exception as e: logger.error(f"Error in cache invalidation action: {e}") messages.error(request, f"Error invalidating cache: {str(e)}") return redirect('cache_performance_dashboard') @staff_member_required @require_http_methods(["GET"]) def cache_statistics_api(request): """ API endpoint for real-time cache statistics """ try: stats = permission_cache.get_cache_statistics() # Add additional runtime statistics stats['timestamp'] = timezone.now().isoformat() stats['server_time'] = timezone.now().strftime('%Y-%m-%d %H:%M:%S') return JsonResponse(stats) except Exception as e: logger.error(f"Error getting cache statistics: {e}") return JsonResponse({ 'error': str(e), 'timestamp': timezone.now().isoformat() }, status=500) @staff_member_required @require_http_methods(["GET"]) def user_cache_status_api(request): """ API endpoint to check cache status for specific users """ try: user_ids = request.GET.getlist('user_ids') page_name = request.GET.get('page_name', 'loans') if not user_ids: return JsonResponse({'error': 'No user IDs provided'}, status=400) cache_status = {} for user_id in user_ids: try: # Check if user has cached permissions cached_permissions = permission_cache.get_user_page_permissions(user_id, page_name) cached_actions = permission_cache.get_user_available_actions(user_id, page_name) cache_status[user_id] = { 'has_permissions_cache': cached_permissions is not None, 'has_actions_cache': cached_actions is not None, 'permissions_count': len(cached_permissions) if cached_permissions else 0, 'actions_count': len(cached_actions) if cached_actions else 0 } except Exception as e: cache_status[user_id] = { 'error': str(e), 'has_permissions_cache': False, 'has_actions_cache': False } return JsonResponse({ 'cache_status': cache_status, 'page_name': page_name, 'timestamp': timezone.now().isoformat() }) except Exception as e: logger.error(f"Error checking user cache status: {e}") return JsonResponse({ 'error': str(e), 'timestamp': timezone.now().isoformat() }, status=500) def _get_recent_cache_activity(): """ Get recent cache activity information """ try: # This would typically come from cache logs or monitoring # For now, return placeholder data return { 'recent_hits': 0, 'recent_misses': 0, 'recent_invalidations': 0, 'top_cached_pages': ['loans', 'clients', 'reports'], 'most_active_users': [] } except Exception as e: logger.error(f"Error getting recent cache activity: {e}") return {} def _get_cache_recommendations(cache_stats): """ Generate cache optimization recommendations based on statistics """ recommendations = [] try: hit_rate = cache_stats.get('hit_rate_percentage', 0) total_requests = cache_stats.get('total_hits', 0) + cache_stats.get('total_misses', 0) # Hit rate recommendations if hit_rate < 70: recommendations.append({ 'type': 'warning', 'title': 'Low Cache Hit Rate', 'message': f'Current hit rate is {hit_rate:.1f}%. Consider warming cache for active users.', 'action': 'warm_critical_users' }) elif hit_rate > 90: recommendations.append({ 'type': 'success', 'title': 'Excellent Cache Performance', 'message': f'Cache hit rate is {hit_rate:.1f}%. Performance is optimal.', 'action': None }) # Request volume recommendations if total_requests > 10000: recommendations.append({ 'type': 'info', 'title': 'High Cache Usage', 'message': f'{total_requests} total cache requests. Consider monitoring Redis memory usage.', 'action': 'monitor_memory' }) # Backend recommendations cache_backend = cache_stats.get('cache_backend', 'Unknown') if cache_backend != 'Redis': recommendations.append({ 'type': 'warning', 'title': 'Cache Backend Optimization', 'message': f'Currently using {cache_backend}. Redis is recommended for better performance.', 'action': 'upgrade_backend' }) # Redis-specific recommendations redis_stats = cache_stats.get('redis_stats', {}) if redis_stats: used_memory = redis_stats.get('used_memory', 'N/A') if used_memory != 'N/A' and 'MB' in used_memory: try: memory_mb = float(used_memory.replace('MB', '')) if memory_mb > 100: recommendations.append({ 'type': 'info', 'title': 'Redis Memory Usage', 'message': f'Redis is using {used_memory}. Monitor for memory optimization opportunities.', 'action': 'optimize_memory' }) except: pass return recommendations except Exception as e: logger.error(f"Error generating cache recommendations: {e}") return [{ 'type': 'error', 'title': 'Recommendation Error', 'message': f'Could not generate recommendations: {str(e)}', 'action': None }]