quantum-framework 0.18.0__py3-none-any.whl

quantum_admin/backend/job_service.py

@@ -0,0 +1,347 @@
+"""
+Job Management Service for Quantum Admin
+Provides admin interface for managing Quantum jobs, schedules, and queues
+"""
+import os
+import sys
+import logging
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+from dataclasses import asdict
+
+logger = logging.getLogger(__name__)
+
+# quantum is an installed package now (FRAMEWORK_PLAN Fase 1.1). This used to
+# push <repo>/src onto sys.path and import `runtime.job_executor` — the
+# pre-packaging layout. src/ became quantum/, so the import failed, the
+# except swallowed it into a warning, HAS_JOB_EXECUTOR went False, and the
+# admin's whole Jobs subsystem quietly reported zero jobs forever. The repo
+# root is still added so the admin works from a checkout without installing.
+QUANTUM_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+if QUANTUM_ROOT not in sys.path:
+    sys.path.insert(0, QUANTUM_ROOT)
+
+try:
+    from quantum.runtime.job_executor import (
+        JobExecutor, JobQueueService, ScheduleService, ThreadService
+    )
+    HAS_JOB_EXECUTOR = True
+except ImportError as e:
+    logger.warning(f"JobExecutor not available: {e}")
+    HAS_JOB_EXECUTOR = False
+    JobExecutor = None
+
+
+class JobAdminService:
+    """
+    Admin service for managing Quantum jobs.
+
+    Provides:
+    - Job queue management
+    - Schedule management
+    - Thread monitoring
+    - Queue statistics
+    """
+
+    def __init__(self, job_db_path: str = "quantum_jobs.db"):
+        """
+        Initialize job admin service.
+
+        Args:
+            job_db_path: Path to job queue database
+        """
+        self._executor: Optional[JobExecutor] = None
+        self._job_db_path = job_db_path
+
+    @property
+    def executor(self) -> Optional[JobExecutor]:
+        """Get or create job executor instance."""
+        if not HAS_JOB_EXECUTOR:
+            return None
+
+        if self._executor is None:
+            self._executor = JobExecutor(job_db_path=self._job_db_path)
+        return self._executor
+
+    def is_available(self) -> bool:
+        """Check if job system is available."""
+        return HAS_JOB_EXECUTOR
+
+    # =========================================================================
+    # Jobs (Queued)
+    # =========================================================================
+
+    def list_jobs(
+        self,
+        queue: Optional[str] = None,
+        status: Optional[str] = None,
+        limit: int = 100
+    ) -> List[Dict]:
+        """
+        List all queued jobs.
+
+        Args:
+            queue: Filter by queue name
+            status: Filter by status (pending, running, completed, failed)
+            limit: Maximum jobs to return
+
+        Returns:
+            List of job dicts
+        """
+        if not self.executor:
+            return []
+
+        jobs = self.executor.job_queue.list_jobs(queue=queue, status=status, limit=limit)
+        return [self._job_to_dict(job) for job in jobs]
+
+    def get_job(self, job_id: int) -> Optional[Dict]:
+        """Get job details by ID."""
+        if not self.executor:
+            return None
+
+        job = self.executor.job_queue.get_job(job_id)
+        return self._job_to_dict(job) if job else None
+
+    def cancel_job(self, job_id: int) -> bool:
+        """Cancel a pending job."""
+        if not self.executor:
+            return False
+        return self.executor.job_queue.cancel_job(job_id)
+
+    def retry_job(self, job_id: int) -> bool:
+        """Retry a failed job."""
+        if not self.executor:
+            return False
+        return self.executor.job_queue.retry_job(job_id)
+
+    def dispatch_job(
+        self,
+        name: str,
+        queue: str = 'default',
+        params: Optional[Dict] = None,
+        delay: Optional[str] = None,
+        priority: int = 0
+    ) -> Optional[int]:
+        """
+        Dispatch a new job.
+
+        Args:
+            name: Job name
+            queue: Queue name
+            params: Job parameters
+            delay: Delay before execution
+            priority: Job priority (0-10)
+
+        Returns:
+            Job ID or None
+        """
+        if not self.executor:
+            return None
+
+        return self.executor.job_queue.dispatch(
+            name=name,
+            queue=queue,
+            params=params,
+            delay=delay,
+            priority=priority
+        )
+
+    def _job_to_dict(self, job) -> Dict:
+        """Convert JobInfo to dict."""
+        if not job:
+            return {}
+        return {
+            'id': job.id,
+            'name': job.name,
+            'queue': job.queue,
+            'params': job.params,
+            'status': job.status,
+            'attempts': job.attempts,
+            'max_attempts': job.max_attempts,
+            'scheduled_at': job.scheduled_at.isoformat() if job.scheduled_at else None,
+            'started_at': job.started_at.isoformat() if job.started_at else None,
+            'completed_at': job.completed_at.isoformat() if job.completed_at else None,
+            'error': job.error,
+            'created_at': job.created_at.isoformat() if job.created_at else None
+        }
+
+    # =========================================================================
+    # Schedules
+    # =========================================================================
+
+    def list_schedules(self) -> List[Dict]:
+        """List all scheduled tasks."""
+        if not self.executor:
+            return []
+
+        schedules = self.executor.schedule.list_schedules()
+        return [self._schedule_to_dict(s) for s in schedules]
+
+    def get_schedule(self, name: str) -> Optional[Dict]:
+        """Get schedule details by name."""
+        if not self.executor:
+            return None
+
+        schedule = self.executor.schedule.get_schedule(name)
+        return self._schedule_to_dict(schedule) if schedule else None
+
+    def pause_schedule(self, name: str) -> bool:
+        """Pause a scheduled task."""
+        if not self.executor:
+            return False
+        return self.executor.schedule.pause_schedule(name)
+
+    def resume_schedule(self, name: str) -> bool:
+        """Resume a paused schedule."""
+        if not self.executor:
+            return False
+        return self.executor.schedule.resume_schedule(name)
+
+    def run_schedule_now(self, name: str) -> bool:
+        """Trigger immediate execution of a schedule."""
+        if not self.executor:
+            return False
+        return self.executor.schedule.run_now(name)
+
+    def remove_schedule(self, name: str) -> bool:
+        """Remove a scheduled task."""
+        if not self.executor:
+            return False
+        return self.executor.schedule.remove_schedule(name)
+
+    def _schedule_to_dict(self, schedule) -> Dict:
+        """Convert ScheduleInfo to dict."""
+        if not schedule:
+            return {}
+        return {
+            'name': schedule.name,
+            'trigger_type': schedule.trigger_type,
+            'trigger_info': schedule.trigger_info,
+            'next_run': schedule.next_run.isoformat() if schedule.next_run else None,
+            'enabled': schedule.enabled,
+            'run_count': schedule.run_count,
+            'last_run': schedule.last_run.isoformat() if schedule.last_run else None,
+            'last_error': schedule.last_error
+        }
+
+    # =========================================================================
+    # Threads
+    # =========================================================================
+
+    def list_threads(self, status: Optional[str] = None) -> List[Dict]:
+        """List all threads."""
+        if not self.executor:
+            return []
+
+        threads = self.executor.thread.list_threads(status=status)
+        return [self._thread_to_dict(t) for t in threads]
+
+    def get_thread(self, name: str) -> Optional[Dict]:
+        """Get thread details by name."""
+        if not self.executor:
+            return None
+
+        thread = self.executor.thread.get_thread(name)
+        return self._thread_to_dict(thread) if thread else None
+
+    def terminate_thread(self, name: str) -> bool:
+        """Request thread termination."""
+        if not self.executor:
+            return False
+        return self.executor.thread.terminate_thread(name)
+
+    def _thread_to_dict(self, thread) -> Dict:
+        """Convert ThreadInfo to dict."""
+        if not thread:
+            return {}
+        return {
+            'name': thread.name,
+            'priority': thread.priority,
+            'started_at': thread.started_at.isoformat() if thread.started_at else None,
+            'status': thread.status,
+            'timeout': thread.timeout,
+            'error': thread.error
+        }
+
+    # =========================================================================
+    # Queues
+    # =========================================================================
+
+    def list_queues(self) -> List[Dict]:
+        """List all queues with stats."""
+        if not self.executor:
+            return [{'name': 'default', 'pending': 0, 'running': 0, 'completed': 0, 'failed': 0}]
+        return self.executor.list_queues()
+
+    def get_queue_stats(self, queue: str = 'default') -> Dict:
+        """Get queue statistics."""
+        if not self.executor:
+            return {'pending': 0, 'running': 0, 'completed': 0, 'failed': 0}
+        return self.executor.job_queue.get_queue_stats(queue)
+
+    def purge_queue(self, queue: str, status: Optional[str] = None) -> int:
+        """Purge jobs from a queue."""
+        if not self.executor:
+            return 0
+        return self.executor.job_queue.purge_queue(queue, status=status)
+
+    # =========================================================================
+    # Overview
+    # =========================================================================
+
+    def get_overview(self) -> Dict:
+        """
+        Get job system overview.
+
+        Returns:
+            Dict with counts and status
+        """
+        if not self.executor:
+            return {
+                'available': False,
+                'message': 'Job executor not available'
+            }
+
+        # Get queue stats
+        queue_stats = self.get_queue_stats()
+
+        # Get schedule count
+        schedules = self.list_schedules()
+        active_schedules = len([s for s in schedules if s.get('enabled')])
+
+        # Get thread count
+        threads = self.list_threads()
+        running_threads = len([t for t in threads if t.get('status') == 'running'])
+
+        return {
+            'available': True,
+            'jobs': {
+                'pending': queue_stats.get('pending', 0),
+                'running': queue_stats.get('running', 0),
+                'completed': queue_stats.get('completed', 0),
+                'failed': queue_stats.get('failed', 0),
+                'total': sum(queue_stats.values())
+            },
+            'schedules': {
+                'total': len(schedules),
+                'active': active_schedules,
+                'paused': len(schedules) - active_schedules
+            },
+            'threads': {
+                'total': len(threads),
+                'running': running_threads
+            },
+            'queues': self.list_queues()
+        }
+
+
+# Singleton instance
+_job_service: Optional[JobAdminService] = None
+
+
+def get_job_service() -> JobAdminService:
+    """Get job service singleton."""
+    global _job_service
+    if _job_service is None:
+        _job_service = JobAdminService()
+    return _job_service

quantum_admin/backend/log_service.py

@@ -0,0 +1,331 @@
+"""
+Log Service for Quantum Admin
+Unified logging for application, database, and access logs
+"""
+import json
+import logging
+import asyncio
+from typing import Optional, List, Dict, Any
+from datetime import datetime, timedelta
+from sqlalchemy.orm import Session
+from sqlalchemy import desc, or_
+
+logger = logging.getLogger(__name__)
+
+try:
+    from .models import ApplicationLog, Project, Environment
+except ImportError:
+    from models import ApplicationLog, Project, Environment
+
+
+class LogLevel:
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+class LogSource:
+    APP = "app"          # Application logs (stdout/stderr)
+    DB = "database"      # Database query logs
+    ACCESS = "access"    # HTTP access logs
+    API = "api"          # External API calls
+    SECURITY = "security"  # Security events (auth, permissions)
+    DEPLOY = "deploy"    # Deployment logs
+    SYSTEM = "system"    # System/infrastructure logs
+
+    @classmethod
+    def all_sources(cls):
+        return [cls.APP, cls.DB, cls.ACCESS, cls.API, cls.SECURITY, cls.DEPLOY, cls.SYSTEM]
+
+
+def create_log(
+    db: Session,
+    project_id: int,
+    level: str,
+    source: str,
+    message: str,
+    environment_id: int = None,
+    component_name: str = None,
+    function_name: str = None,
+    line_number: int = None,
+    request_id: str = None,
+    request_method: str = None,
+    request_path: str = None,
+    response_status: int = None,
+    response_time_ms: int = None,
+    extra_data: Dict = None
+) -> ApplicationLog:
+    """
+    Create a log entry.
+
+    Args:
+        db: Database session
+        project_id: Project this log belongs to
+        level: Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        source: Log source (app, db, access, deploy, system)
+        message: Log message
+        environment_id: Optional environment ID
+        component_name: Optional component name
+        function_name: Optional function name
+        line_number: Optional line number
+        request_id: Optional request ID for tracing
+        request_method: Optional HTTP method
+        request_path: Optional request path
+        response_status: Optional HTTP status code
+        response_time_ms: Optional response time in milliseconds
+        extra_data: Optional additional data as dictionary
+
+    Returns:
+        The created ApplicationLog object
+    """
+    log_entry = ApplicationLog(
+        project_id=project_id,
+        environment_id=environment_id,
+        timestamp=datetime.utcnow(),
+        level=level,
+        source=source,
+        message=message,
+        component_name=component_name,
+        function_name=function_name,
+        line_number=line_number,
+        request_id=request_id,
+        request_method=request_method,
+        request_path=request_path,
+        response_status=response_status,
+        response_time_ms=response_time_ms,
+        extra_data=json.dumps(extra_data) if extra_data else None
+    )
+
+    db.add(log_entry)
+    db.commit()
+    db.refresh(log_entry)
+
+    return log_entry
+
+
+def get_logs(
+    db: Session,
+    project_id: int,
+    source: str = None,
+    level: str = None,
+    environment_id: int = None,
+    search: str = None,
+    since: datetime = None,
+    until: datetime = None,
+    limit: int = 100,
+    offset: int = 0
+) -> List[ApplicationLog]:
+    """
+    Query logs with optional filters.
+
+    Args:
+        db: Database session
+        project_id: Filter by project
+        source: Filter by source (app, db, access, deploy, system)
+        level: Filter by log level
+        environment_id: Filter by environment
+        search: Search in message
+        since: Filter entries after this time
+        until: Filter entries before this time
+        limit: Maximum number of entries to return
+        offset: Number of entries to skip
+
+    Returns:
+        List of ApplicationLog objects
+    """
+    query = db.query(ApplicationLog).filter(ApplicationLog.project_id == project_id)
+
+    if source and source != 'all':
+        query = query.filter(ApplicationLog.source == source)
+    if level:
+        query = query.filter(ApplicationLog.level == level)
+    if environment_id:
+        query = query.filter(ApplicationLog.environment_id == environment_id)
+    if search:
+        query = query.filter(ApplicationLog.message.ilike(f'%{search}%'))
+    if since:
+        query = query.filter(ApplicationLog.timestamp >= since)
+    if until:
+        query = query.filter(ApplicationLog.timestamp <= until)
+
+    return query.order_by(desc(ApplicationLog.timestamp)).offset(offset).limit(limit).all()
+
+
+def get_log_stats(
+    db: Session,
+    project_id: int,
+    hours: int = 24
+) -> Dict:
+    """
+    Get log statistics for a project.
+    """
+    from sqlalchemy import func
+
+    since = datetime.utcnow() - timedelta(hours=hours)
+    query = db.query(ApplicationLog).filter(
+        ApplicationLog.project_id == project_id,
+        ApplicationLog.timestamp >= since
+    )
+
+    total = query.count()
+
+    # Count by level
+    level_counts = {}
+    for level in [LogLevel.DEBUG, LogLevel.INFO, LogLevel.WARNING, LogLevel.ERROR, LogLevel.CRITICAL]:
+        count = query.filter(ApplicationLog.level == level).count()
+        level_counts[level.lower()] = count
+
+    # Count by source
+    source_counts = {}
+    for source in LogSource.all_sources():
+        count = query.filter(ApplicationLog.source == source).count()
+        source_counts[source] = count
+
+    # Error rate
+    error_count = level_counts.get('error', 0) + level_counts.get('critical', 0)
+    error_rate = (error_count / total * 100) if total > 0 else 0
+
+    return {
+        "total": total,
+        "period_hours": hours,
+        "by_level": level_counts,
+        "by_source": source_counts,
+        "error_rate": round(error_rate, 2)
+    }
+
+
+def format_log_for_display(log: ApplicationLog) -> Dict:
+    """Format a log entry for display."""
+    return {
+        "id": log.id,
+        "timestamp": log.timestamp.strftime('%H:%M:%S') if log.timestamp else '',
+        "timestamp_full": log.timestamp.isoformat() if log.timestamp else '',
+        "level": log.level,
+        "source": log.source,
+        "message": log.message[:200] if log.message else '',
+        "full_message": log.message,
+        "component": log.component_name,
+        "function": log.function_name,
+        "request": f"{log.request_method} {log.request_path}" if log.request_method else None,
+        "status": log.response_status,
+        "duration": f"{log.response_time_ms}ms" if log.response_time_ms else None
+    }
+
+
+class LogService:
+    """Service class for log operations"""
+
+    def __init__(self, db: Session):
+        self.db = db
+
+    def log(
+        self,
+        project_id: int,
+        level: str,
+        source: str,
+        message: str,
+        **kwargs
+    ) -> ApplicationLog:
+        """Create a log entry"""
+        return create_log(
+            self.db,
+            project_id=project_id,
+            level=level,
+            source=source,
+            message=message,
+            **kwargs
+        )
+
+    def info(self, project_id: int, source: str, message: str, **kwargs) -> ApplicationLog:
+        return self.log(project_id, LogLevel.INFO, source, message, **kwargs)
+
+    def warning(self, project_id: int, source: str, message: str, **kwargs) -> ApplicationLog:
+        return self.log(project_id, LogLevel.WARNING, source, message, **kwargs)
+
+    def error(self, project_id: int, source: str, message: str, **kwargs) -> ApplicationLog:
+        return self.log(project_id, LogLevel.ERROR, source, message, **kwargs)
+
+    def debug(self, project_id: int, source: str, message: str, **kwargs) -> ApplicationLog:
+        return self.log(project_id, LogLevel.DEBUG, source, message, **kwargs)
+
+    def access_log(
+        self,
+        project_id: int,
+        method: str,
+        path: str,
+        status: int,
+        duration_ms: int,
+        **kwargs
+    ) -> ApplicationLog:
+        """Create an access log entry"""
+        message = f"{method} {path} {status} {duration_ms}ms"
+        return self.log(
+            project_id,
+            LogLevel.INFO if status < 400 else LogLevel.WARNING if status < 500 else LogLevel.ERROR,
+            LogSource.ACCESS,
+            message,
+            request_method=method,
+            request_path=path,
+            response_status=status,
+            response_time_ms=duration_ms,
+            **kwargs
+        )
+
+    def query_log(
+        self,
+        project_id: int,
+        query: str,
+        duration_ms: int,
+        **kwargs
+    ) -> ApplicationLog:
+        """Create a database query log entry"""
+        message = f"Query executed in {duration_ms}ms: {query[:100]}..."
+        return self.log(
+            project_id,
+            LogLevel.DEBUG,
+            LogSource.DB,
+            message,
+            response_time_ms=duration_ms,
+            **kwargs
+        )
+
+    def get_logs(
+        self,
+        project_id: int,
+        source: str = None,
+        level: str = None,
+        environment_id: int = None,
+        search: str = None,
+        since: datetime = None,
+        until: datetime = None,
+        limit: int = 100,
+        offset: int = 0
+    ) -> List[ApplicationLog]:
+        """Query logs"""
+        return get_logs(
+            self.db,
+            project_id=project_id,
+            source=source,
+            level=level,
+            environment_id=environment_id,
+            search=search,
+            since=since,
+            until=until,
+            limit=limit,
+            offset=offset
+        )
+
+    def get_stats(self, project_id: int, hours: int = 24) -> Dict:
+        """Get log statistics"""
+        return get_log_stats(self.db, project_id=project_id, hours=hours)
+
+    def format_logs(self, logs: List[ApplicationLog]) -> List[Dict]:
+        """Format logs for display"""
+        return [format_log_for_display(log) for log in logs]
+
+
+def get_log_service(db: Session) -> LogService:
+    """Get log service instance"""
+    return LogService(db)