project initialization

backend/monitoring/views.py

@@ -0,0 +1,481 @@
+"""
+Django views for monitoring and metrics endpoints.
+"""
+
+import json
+from datetime import datetime, timedelta
+from typing import Dict, Any, Optional
+from django.http import JsonResponse, HttpResponse
+from django.views.generic import TemplateView
+from django.contrib.auth.mixins import LoginRequiredMixin
+from django.db import connection
+from django.utils import timezone
+from django.conf import settings
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+from prometheus_client import generate_latest, REGISTRY, CONTENT_TYPE_LATEST
+from prometheus_client.parser import text_string_to_metric_families
+
+from .middleware import MetricsView
+from .exporters import metrics_collector
+from .alerts import alert_manager, Alert, AlertSeverity, AlertCategory
+
+class MetricsView(APIView):
+    """View for Prometheus metrics endpoint."""
+
+    def get(self, request):
+        """Get Prometheus metrics."""
+        try:
+            # Collect current metrics
+            metrics_collector.collect_once()
+
+            # Generate Prometheus format
+            metrics_data = generate_latest(REGISTRY)
+            return HttpResponse(
+                metrics_data,
+                content_type=CONTENT_TYPE_LATEST
+            )
+        except Exception as e:
+            return JsonResponse(
+                {'error': f'Failed to generate metrics: {str(e)}'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+class HealthCheckView(APIView):
+    """Health check endpoint."""
+
+    def get(self, request):
+        """Comprehensive health check."""
+        try:
+            health_status = {
+                'status': 'healthy',
+                'timestamp': timezone.now().isoformat(),
+                'version': getattr(settings, 'VERSION', '1.0.0'),
+                'environment': getattr(settings, 'ENVIRONMENT', 'development'),
+                'checks': {}
+            }
+
+            # Database health
+            try:
+                with connection.cursor() as cursor:
+                    cursor.execute("SELECT 1")
+                    cursor.fetchone()
+                health_status['checks']['database'] = {
+                    'status': 'healthy',
+                    'response_time': self._measure_response_time(self._check_database)
+                }
+            except Exception as e:
+                health_status['checks']['database'] = {
+                    'status': 'unhealthy',
+                    'error': str(e)
+                }
+                health_status['status'] = 'degraded'
+
+            # Cache health
+            try:
+                from django.core.cache import cache
+                cache.set('health_check', 'test', 1)
+                cache.get('health_check')
+                health_status['checks']['cache'] = {
+                    'status': 'healthy',
+                    'response_time': self._measure_response_time(self._check_cache)
+                }
+            except Exception as e:
+                health_status['checks']['cache'] = {
+                    'status': 'unhealthy',
+                    'error': str(e)
+                }
+                health_status['status'] = 'degraded'
+
+            # Storage health
+            try:
+                storage_health = self._check_storage()
+                health_status['checks']['storage'] = storage_health
+                if storage_health['status'] != 'healthy':
+                    health_status['status'] = 'degraded'
+            except Exception as e:
+                health_status['checks']['storage'] = {
+                    'status': 'unhealthy',
+                    'error': str(e)
+                }
+                health_status['status'] = 'degraded'
+
+            # External services health
+            external_services = self._check_external_services()
+            health_status['checks']['external_services'] = external_services
+            if any(service['status'] != 'healthy' for service in external_services.values()):
+                health_status['status'] = 'degraded'
+
+            # Malaysian services health
+            malaysian_services = self._check_malaysian_services()
+            health_status['checks']['malaysian_services'] = malaysian_services
+            if any(service['status'] != 'healthy' for service in malaysian_services.values()):
+                health_status['status'] = 'degraded'
+
+            # Determine HTTP status code
+            if health_status['status'] == 'healthy':
+                http_status = status.HTTP_200_OK
+            elif health_status['status'] == 'degraded':
+                http_status = status.HTTP_503_SERVICE_UNAVAILABLE
+            else:
+                http_status = status.HTTP_500_INTERNAL_SERVER_ERROR
+
+            return Response(health_status, status=http_status)
+
+        except Exception as e:
+            return Response(
+                {'status': 'unhealthy', 'error': str(e)},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def _measure_response_time(self, func) -> float:
+        """Measure response time of a function."""
+        import time
+        start_time = time.time()
+        func()
+        return time.time() - start_time
+
+    def _check_database(self):
+        """Check database connectivity."""
+        with connection.cursor() as cursor:
+            cursor.execute("SELECT 1")
+            cursor.fetchone()
+
+    def _check_cache(self):
+        """Check cache functionality."""
+        from django.core.cache import cache
+        cache.set('health_check', 'test', 1)
+        result = cache.get('health_check')
+        if result != 'test':
+            raise Exception("Cache functionality failed")
+
+    def _check_storage(self) -> Dict[str, Any]:
+        """Check storage availability."""
+        try:
+            import os
+            # Check media directory
+            media_path = getattr(settings, 'MEDIA_ROOT', '/media')
+            if not os.path.exists(media_path):
+                return {'status': 'unhealthy', 'error': 'Media directory not found'}
+
+            # Check write permissions
+            test_file = os.path.join(media_path, 'health_check_test.tmp')
+            try:
+                with open(test_file, 'w') as f:
+                    f.write('test')
+                os.remove(test_file)
+            except Exception as e:
+                return {'status': 'unhealthy', 'error': f'Write permission error: {str(e)}'}
+
+            # Check disk space
+            disk_usage = os.statvfs(media_path)
+            free_space_percent = (disk_usage.f_bavail * disk_usage.f_frsize) / (disk_usage.f_blocks * disk_usage.f_frsize) * 100
+
+            if free_space_percent < 10:
+                return {
+                    'status': 'degraded',
+                    'error': f'Low disk space: {free_space_percent:.1f}% free'
+                }
+
+            return {'status': 'healthy', 'free_space_percent': free_space_percent}
+
+        except Exception as e:
+            return {'status': 'unhealthy', 'error': str(e)}
+
+    def _check_external_services(self) -> Dict[str, Dict[str, Any]]:
+        """Check external services health."""
+        services = {}
+
+        # Check email service
+        try:
+            from django.core.mail import get_connection
+            connection = get_connection()
+            connection.open()
+            connection.close()
+            services['email'] = {'status': 'healthy'}
+        except Exception as e:
+            services['email'] = {'status': 'unhealthy', 'error': str(e)}
+
+        # Check Redis (if configured)
+        try:
+            import redis
+            redis_client = redis.from_url(settings.REDIS_URL)
+            redis_client.ping()
+            services['redis'] = {'status': 'healthy'}
+        except Exception as e:
+            services['redis'] = {'status': 'unhealthy', 'error': str(e)}
+
+        # Check external APIs (if configured)
+        external_apis = getattr(settings, 'EXTERNAL_APIS', {})
+        for api_name, api_config in external_apis.items():
+            try:
+                import requests
+                response = requests.get(
+                    api_config['health_url'],
+                    timeout=api_config.get('timeout', 5)
+                )
+                if response.status_code == 200:
+                    services[api_name] = {'status': 'healthy'}
+                else:
+                    services[api_name] = {
+                        'status': 'unhealthy',
+                        'error': f'HTTP {response.status_code}'
+                    }
+            except Exception as e:
+                services[api_name] = {'status': 'unhealthy', 'error': str(e)}
+
+        return services
+
+    def _check_malaysian_services(self) -> Dict[str, Dict[str, Any]]:
+        """Check Malaysian-specific services."""
+        services = {}
+
+        # Check Malaysian postcode service
+        try:
+            from core.services.malaysian_services import MalaysianPostcodeService
+            postcode_service = MalaysianPostcodeService()
+            result = postcode_service.lookup_postcode('50000')
+            services['postcode_service'] = {
+                'status': 'healthy' if result else 'degraded'
+            }
+        except Exception as e:
+            services['postcode_service'] = {'status': 'unhealthy', 'error': str(e)}
+
+        # Check SST calculation service
+        try:
+            from core.services.malaysian_services import SSTCalculationService
+            sst_service = SSTCalculationService()
+            result = sst_service.calculate_sst(100, 'standard', 'Johor')
+            services['sst_service'] = {
+                'status': 'healthy' if result is not None else 'degraded'
+            }
+        except Exception as e:
+            services['sst_service'] = {'status': 'unhealthy', 'error': str(e)}
+
+        # Check IC validation service
+        try:
+            from core.services.malaysian_services import ICValidationService
+            ic_service = ICValidationService()
+            result = ic_service.validate_ic('1234567890')
+            services['ic_validation_service'] = {
+                'status': 'healthy' if result is not None else 'degraded'
+            }
+        except Exception as e:
+            services['ic_validation_service'] = {'status': 'unhealthy', 'error': str(e)}
+
+        return services
+
+class AlertsView(APIView):
+    """Alerts management endpoint."""
+
+    def get(self, request):
+        """Get alerts."""
+        try:
+            # Check for new alerts
+            alert_manager.check_rules()
+
+            # Get query parameters
+            severity = request.query_params.get('severity')
+            category = request.query_params.get('category')
+            status = request.query_params.get('status', 'active')
+            hours = int(request.query_params.get('hours', 24))
+
+            # Get alerts
+            if status == 'active':
+                alerts = alert_manager.get_active_alerts(severity=severity, category=category)
+            else:
+                alerts = alert_manager.get_alert_history(hours=hours)
+                if severity:
+                    alerts = [a for a in alerts if a.severity == severity]
+                if category:
+                    alerts = [a for a in alerts if a.category == category]
+
+            # Convert to response format
+            response_data = {
+                'alerts': [alert.to_dict() for alert in alerts],
+                'summary': self._get_alerts_summary(alerts),
+                'timestamp': timezone.now().isoformat()
+            }
+
+            return Response(response_data)
+
+        except Exception as e:
+            return Response(
+                {'error': f'Failed to get alerts: {str(e)}'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def post(self, request):
+        """Create manual alert."""
+        try:
+            data = request.data
+
+            alert = Alert(
+                title=data['title'],
+                description=data['description'],
+                severity=data.get('severity', AlertSeverity.INFO),
+                category=data.get('category', AlertCategory.SYSTEM),
+                metadata=data.get('metadata', {})
+            )
+
+            alert_manager.trigger_alert(alert)
+
+            return Response(
+                {'message': 'Alert created successfully', 'alert_id': alert.id},
+                status=status.HTTP_201_CREATED
+            )
+
+        except Exception as e:
+            return Response(
+                {'error': f'Failed to create alert: {str(e)}'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def _get_alerts_summary(self, alerts) -> Dict[str, Any]:
+        """Get alerts summary statistics."""
+        summary = {
+            'total': len(alerts),
+            'by_severity': {},
+            'by_category': {},
+            'by_status': {}
+        }
+
+        for alert in alerts:
+            # Count by severity
+            summary['by_severity'][alert.severity] = summary['by_severity'].get(alert.severity, 0) + 1
+
+            # Count by category
+            summary['by_category'][alert.category] = summary['by_category'].get(alert.category, 0) + 1
+
+            # Count by status
+            status = alert.get_status()
+            summary['by_status'][status] = summary['by_status'].get(status, 0) + 1
+
+        return summary
+
+class AlertActionView(APIView):
+    """Alert management actions."""
+
+    def post(self, request, alert_id: str, action: str):
+        """Perform alert actions."""
+        try:
+            if action == 'acknowledge':
+                user = request.user.username if request.user.is_authenticated else 'api_user'
+                alert_manager.acknowledge_alert(alert_id, user)
+                return Response({'message': f'Alert {alert_id} acknowledged'})
+
+            elif action == 'resolve':
+                user = request.user.username if request.user.is_authenticated else 'api_user'
+                alert_manager.resolve_alert(alert_id, user)
+                return Response({'message': f'Alert {alert_id} resolved'})
+
+            else:
+                return Response(
+                    {'error': f'Unknown action: {action}'},
+                    status=status.HTTP_400_BAD_REQUEST
+                )
+
+        except Exception as e:
+            return Response(
+                {'error': f'Failed to perform action {action} on alert {alert_id}: {str(e)}'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+class MonitoringDashboardView(LoginRequiredMixin, TemplateView):
+    """Monitoring dashboard template view."""
+
+    template_name = 'monitoring/dashboard.html'
+
+    def get_context_data(self, **kwargs):
+        """Get dashboard context data."""
+        context = super().get_context_data(**kwargs)
+
+        # Get current alerts
+        context['active_alerts'] = alert_manager.get_active_alerts()
+        context['alert_summary'] = self._get_alerts_summary(context['active_alerts'])
+
+        # Get system metrics
+        context['system_metrics'] = self._get_system_metrics()
+
+        # Get business metrics
+        context['business_metrics'] = self._get_business_metrics()
+
+        # Malaysian-specific metrics
+        context['malaysian_metrics'] = self._get_malaysian_metrics()
+
+        return context
+
+    def _get_alerts_summary(self, alerts) -> Dict[str, Any]:
+        """Get alerts summary."""
+        summary = {
+            'total': len(alerts),
+            'critical': len([a for a in alerts if a.severity == AlertSeverity.CRITICAL]),
+            'error': len([a for a in alerts if a.severity == AlertSeverity.ERROR]),
+            'warning': len([a for a in alerts if a.severity == AlertSeverity.WARNING]),
+            'info': len([a for a in alerts if a.severity == AlertSeverity.INFO]),
+        }
+        return summary
+
+    def _get_system_metrics(self) -> Dict[str, Any]:
+        """Get system metrics."""
+        try:
+            import psutil
+
+            return {
+                'cpu_usage': psutil.cpu_percent(interval=1),
+                'memory_usage': psutil.virtual_memory().percent,
+                'disk_usage': psutil.disk_usage('/').percent,
+                'load_average': psutil.getloadavg()[0],
+                'uptime': datetime.now() - datetime.fromtimestamp(psutil.boot_time()),
+            }
+        except Exception:
+            return {}
+
+    def _get_business_metrics(self) -> Dict[str, Any]:
+        """Get business metrics."""
+        try:
+            from django.contrib.auth import get_user_model
+            from core.models import Transaction
+
+            User = get_user_model()
+
+            # Active users
+            active_users = User.objects.filter(
+                is_active=True,
+                last_login__gte=timezone.now() - timedelta(minutes=30)
+            ).count()
+
+            # Today's transactions
+            today_transactions = Transaction.objects.filter(
+                created_at__date=timezone.now().date(),
+                status='completed'
+            ).count()
+
+            return {
+                'active_users': active_users,
+                'today_transactions': today_transactions,
+            }
+        except Exception:
+            return {}
+
+    def _get_malaysian_metrics(self) -> Dict[str, Any]:
+        """Get Malaysian-specific metrics."""
+        try:
+            from core.models import MalaysianICValidation, SSTCalculation
+
+            return {
+                'ic_validations_today': MalaysianICValidation.objects.filter(
+                    created_at__date=timezone.now().date()
+                ).count(),
+                'sst_calculations_today': SSTCalculation.objects.filter(
+                    created_at__date=timezone.now().date()
+                ).count(),
+            }
+        except Exception:
+            return {}
+
+class MetricsDashboardView(LoginRequiredMixin, TemplateView):
+    """Metrics dashboard template view."""
+
+    template_name = 'monitoring/metrics_dashboard.html'