Upload folder using huggingface_hub

__init__.py

@@ -1,96 +1,47 @@
 """
-Monitoring Module
+Logging Module
 
-Continuous AI Governance Infrastructure for AegisLM.
-
-Provides:
-- Streaming evaluation pipeline for real-time monitoring
-- Drift detection with statistical analysis
-- Alert generation and management
-- Dashboard data API
-
-Architecture:
-    Live Prompt Stream
-           ↓
-    Streaming Evaluator
-           ↓
-    Defender + Judge
-           ↓
-    Rolling Metrics Store
-           ↓
-    Drift Detection
-           ↓
-    Alerting Engine
-           ↓
-    Dashboard (Monitoring Tab)
+Structured logging framework for AegisLM.
 """
 
-from .alerting import (
-    AlertManager,
-    AlertSeverity,
-    AlertSummary,
-    AlertType,
-    get_alert_manager,
-)
-from .drift_detection import (
-    DriftDetector,
-    DriftDetectionResult,
-    MetricWindow,
-    get_drift_detector,
+from backend.logging.logger import (
+    StructuredLogger,
+    get_logger,
+    default_logger,
 )
-from .pipeline import (
-    MonitoringPipeline,
-    MonitoringConfig,
-    MonitoringDashboardData,
-    get_monitoring_pipeline,
-)
-from .schemas import (
-    Alert,
-    AlertSeverity,
-    AlertSummary,
-    AlertType,
-    DriftDetectionResult,
-    MonitoringConfig,
-    MonitoringDashboardData,
-    MonitoringRequest,
-    MonitoringResponse,
-    RollingMetrics,
-)
-from .streaming_evaluator import (
-    StreamingEvaluator,
-    get_streaming_evaluator,
+from backend.logging.schema import (
+    LogLevel,
+    Component,
+    BaseLogSchema,
+    EvaluationLogSchema,
+    MetricsLogSchema,
+    ErrorLogSchema,
+    LifecycleLogSchema,
+    OrchestratorLogSchema,
+    ModelExecutorLogSchema,
+    ScoringLogSchema,
+    APILogSchema,
+    AggregatedMetricsSchema,
+    RunSummarySchema,
 )
 
 __all__ = [
-    # Pipeline
-    "MonitoringPipeline",
-    "MonitoringConfig",
-    "MonitoringDashboardData",
-    "get_monitoring_pipeline",
-    
-    # Streaming Evaluator
-    "StreamingEvaluator",
-    "get_streaming_evaluator",
-    
-    # Drift Detection
-    "DriftDetector",
-    "DriftDetectionResult",
-    "MetricWindow",
-    "get_drift_detector",
-    
-    # Alerting
-    "AlertManager",
-    "Alert",
-    "AlertType",
-    "AlertSeverity",
-    "AlertSummary",
-    "get_alert_manager",
-    
-    # Schemas
-    "MonitoringRequest",
-    "MonitoringResponse",
-    "RollingMetrics",
+    # Logger
+    "StructuredLogger",
+    "get_logger",
+    "default_logger",
+    # Schema
+    "LogLevel",
+    "Component",
+    "BaseLogSchema",
+    "EvaluationLogSchema",
+    "MetricsLogSchema",
+    "ErrorLogSchema",
+    "LifecycleLogSchema",
+    "OrchestratorLogSchema",
+    "ModelExecutorLogSchema",
+    "ScoringLogSchema",
+    "APILogSchema",
+    "AggregatedMetricsSchema",
+    "RunSummarySchema",
 ]
-
-# Version
-__version__ = "0.1.0"

audit.py

@@ -0,0 +1,450 @@
+"""
+Audit Logging Service
+
+Provides audit logging functionality for security and compliance.
+Immutable entries - append only, no updates allowed.
+"""
+
+import uuid
+from datetime import datetime
+from typing import Any, Dict, Optional
+from enum import Enum
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.db.models import AuditLog, User, Tenant
+from backend.db.session import get_db_session
+
+
+class AuditAction(str, Enum):
+    """Standard audit action types."""
+    # Job actions
+    JOB_CREATED = "JOB_CREATED"
+    JOB_STARTED = "JOB_STARTED"
+    JOB_COMPLETED = "JOB_COMPLETED"
+    JOB_FAILED = "JOB_FAILED"
+    JOB_CANCELLED = "JOB_CANCELLED"
+    JOB_DELETED = "JOB_DELETED"
+    
+    # User actions
+    USER_CREATED = "USER_CREATED"
+    USER_UPDATED = "USER_UPDATED"
+    USER_DELETED = "USER_DELETED"
+    USER_LOGIN = "USER_LOGIN"
+    USER_LOGOUT = "USER_LOGOUT"
+    ROLE_CHANGED = "ROLE_CHANGED"
+    
+    # API Key actions
+    API_KEY_CREATED = "API_KEY_CREATED"
+    API_KEY_DELETED = "API_KEY_DELETED"
+    API_KEY_ROTATED = "API_KEY_ROTATED"
+    
+    # Release actions
+    RELEASE_APPROVED = "RELEASE_APPROVED"
+    RELEASE_REJECTED = "RELEASE_REJECTED"
+    RELEASE_BLOCKED = "RELEASE_BLOCKED"
+    
+    # Report actions
+    REPORT_CREATED = "REPORT_CREATED"
+    REPORT_EXPORTED = "REPORT_EXPORTED"
+    REPORT_DELETED = "REPORT_DELETED"
+    
+    # Monitoring actions
+    ALERT_CREATED = "ALERT_CREATED"
+    ALERT_RESOLVED = "ALERT_RESOLVED"
+    BASELINE_UPDATED = "BASELINE_UPDATED"
+    
+    # Tenant actions
+    TENANT_CREATED = "TENANT_CREATED"
+    TENANT_UPDATED = "TENANT_UPDATED"
+    TENANT_DEACTIVATED = "TENANT_DEACTIVATED"
+    
+    # Model/Dataset actions
+    MODEL_REGISTERED = "MODEL_REGISTERED"
+    DATASET_REGISTERED = "DATASET_REGISTERED"
+
+
+class ResourceType(str, Enum):
+    """Resource types for audit logging."""
+    JOB = "job"
+    USER = "user"
+    API_KEY = "api_key"
+    RELEASE = "release"
+    REPORT = "report"
+    ALERT = "alert"
+    TENANT = "tenant"
+    MODEL = "model"
+    DATASET = "dataset"
+
+
+class AuditLogger:
+    """
+    Audit logging service for tracking user actions.
+    
+    All entries are immutable - append only, no updates allowed.
+    """
+    
+    def __init__(self, db_session: AsyncSession):
+        self.db = db_session
+    
+    async def log(
+        self,
+        tenant_id: uuid.UUID,
+        user_id: uuid.UUID,
+        action: AuditAction,
+        resource_type: ResourceType,
+        resource_id: Optional[uuid.UUID] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        request_id: Optional[str] = None,
+        ip_address: Optional[str] = None,
+        status: str = "success",
+        error_message: Optional[str] = None,
+    ) -> AuditLog:
+        """
+        Create an audit log entry.
+        
+        Args:
+            tenant_id: Tenant ID
+            user_id: User who performed the action
+            action: Action performed
+            resource_type: Type of resource affected
+            resource_id: ID of the affected resource
+            metadata: Additional action metadata
+            request_id: Request ID for tracing
+            ip_address: Client IP address
+            status: Action status (success, failure, pending)
+            error_message: Error message if action failed
+            
+        Returns:
+            Created AuditLog entry
+        """
+        audit_log = AuditLog(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            action=action.value,
+            resource_type=resource_type.value,
+            resource_id=resource_id,
+            metadata=metadata,
+            request_id=request_id,
+            ip_address=ip_address,
+            status=status,
+            error_message=error_message,
+            timestamp=datetime.utcnow(),
+        )
+        
+        self.db.add(audit_log)
+        await self.db.commit()
+        await self.db.refresh(audit_log)
+        
+        return audit_log
+    
+    async def log_job_created(
+        self,
+        tenant_id: uuid.UUID,
+        user_id: uuid.UUID,
+        job_id: uuid.UUID,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ) -> AuditLog:
+        """Log job creation."""
+        return await self.log(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            action=AuditAction.JOB_CREATED,
+            resource_type=ResourceType.JOB,
+            resource_id=job_id,
+            metadata=metadata,
+            **kwargs,
+        )
+    
+    async def log_job_completed(
+        self,
+        tenant_id: uuid.UUID,
+        user_id: uuid.UUID,
+        job_id: uuid.UUID,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ) -> AuditLog:
+        """Log job completion."""
+        return await self.log(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            action=AuditAction.JOB_COMPLETED,
+            resource_type=ResourceType.JOB,
+            resource_id=job_id,
+            metadata=metadata,
+            **kwargs,
+        )
+    
+    async def log_job_failed(
+        self,
+        tenant_id: uuid.UUID,
+        user_id: uuid.UUID,
+        job_id: uuid.UUID,
+        error_message: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ) -> AuditLog:
+        """Log job failure."""
+        return await self.log(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            action=AuditAction.JOB_FAILED,
+            resource_type=ResourceType.JOB,
+            resource_id=job_id,
+            metadata=metadata,
+            status="failure",
+            error_message=error_message,
+            **kwargs,
+        )
+    
+    async def log_api_key_created(
+        self,
+        tenant_id: uuid.UUID,
+        user_id: uuid.UUID,
+        api_key_id: uuid.UUID,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ) -> AuditLog:
+        """Log API key creation."""
+        return await self.log(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            action=AuditAction.API_KEY_CREATED,
+            resource_type=ResourceType.API_KEY,
+            resource_id=api_key_id,
+            metadata=metadata,
+            **kwargs,
+        )
+    
+    async def log_release_approved(
+        self,
+        tenant_id: uuid.UUID,
+        user_id: uuid.UUID,
+        release_id: uuid.UUID,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ) -> AuditLog:
+        """Log release approval."""
+        return await self.log(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            action=AuditAction.RELEASE_APPROVED,
+            resource_type=ResourceType.RELEASE,
+            resource_id=release_id,
+            metadata=metadata,
+            **kwargs,
+        )
+    
+    async def log_user_login(
+        self,
+        tenant_id: uuid.UUID,
+        user_id: uuid.UUID,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ) -> AuditLog:
+        """Log user login."""
+        return await self.log(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            action=AuditAction.USER_LOGIN,
+            resource_type=ResourceType.USER,
+            resource_id=user_id,
+            metadata=metadata,
+            **kwargs,
+        )
+    
+    async def log_role_changed(
+        self,
+        tenant_id: uuid.UUID,
+        user_id: uuid.UUID,
+        target_user_id: uuid.UUID,
+        old_role: str,
+        new_role: str,
+        **kwargs,
+    ) -> AuditLog:
+        """Log role change."""
+        return await self.log(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            action=AuditAction.ROLE_CHANGED,
+            resource_type=ResourceType.USER,
+            resource_id=target_user_id,
+            metadata={"old_role": old_role, "new_role": new_role},
+            **kwargs,
+        )
+    
+    async def log_report_exported(
+        self,
+        tenant_id: uuid.UUID,
+        user_id: uuid.UUID,
+        report_id: uuid.UUID,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ) -> AuditLog:
+        """Log report export."""
+        return await self.log(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            action=AuditAction.REPORT_EXPORTED,
+            resource_type=ResourceType.REPORT,
+            resource_id=report_id,
+            metadata=metadata,
+            **kwargs,
+        )
+    
+    async def get_tenant_audit_logs(
+        self,
+        tenant_id: uuid.UUID,
+        limit: int = 100,
+        offset: int = 0,
+        action: Optional[AuditAction] = None,
+        user_id: Optional[uuid.UUID] = None,
+        resource_type: Optional[ResourceType] = None,
+    ) -> list[AuditLog]:
+        """
+        Get audit logs for a tenant.
+        
+        Args:
+            tenant_id: Tenant ID
+            limit: Maximum number of entries to return
+            offset: Number of entries to skip
+            action: Filter by action type
+            user_id: Filter by user
+            resource_type: Filter by resource type
+            
+        Returns:
+            List of audit log entries
+        """
+        query = select(AuditLog).where(
+            AuditLog.tenant_id == tenant_id
+        )
+        
+        if action:
+            query = query.where(AuditLog.action == action.value)
+        
+        if user_id:
+            query = query.where(AuditLog.user_id == user_id)
+        
+        if resource_type:
+            query = query.where(AuditLog.resource_type == resource_type.value)
+        
+        query = (
+            query
+            .order_by(AuditLog.timestamp.desc())
+            .limit(limit)
+            .offset(offset)
+        )
+        
+        result = await self.db.execute(query)
+        return list(result.scalars().all())
+
+
+async def create_audit_log(
+    tenant_id: uuid.UUID,
+    user_id: uuid.UUID,
+    action: AuditAction,
+    resource_type: ResourceType,
+    resource_id: Optional[uuid.UUID] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    request_id: Optional[str] = None,
+    ip_address: Optional[str] = None,
+    status: str = "success",
+    error_message: Optional[str] = None,
+) -> AuditLog:
+    """
+    Convenience function to create an audit log entry.
+    
+    Creates a new database session for the operation.
+    """
+    async with get_db_session() as session:
+        logger = AuditLogger(session)
+        return await logger.log(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            action=action,
+            resource_type=resource_type,
+            resource_id=resource_id,
+            metadata=metadata,
+            request_id=request_id,
+            ip_address=ip_address,
+            status=status,
+            error_message=error_message,
+        )
+
+
+# =============================================================================
+# Audit context manager for automatic logging
+# =============================================================================
+
+class AuditContext:
+    """
+    Context manager for automatic audit logging.
+    
+    Usage:
+        async with AuditContext(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            action=AuditAction.JOB_CREATED,
+            resource_type=ResourceType.JOB,
+            resource_id=job_id,
+        ) as audit:
+            # Do work
+            await process_job(job_id)
+            # Success automatically logged on exit
+    """
+    
+    def __init__(
+        self,
+        tenant_id: uuid.UUID,
+        user_id: uuid.UUID,
+        action: AuditAction,
+        resource_type: ResourceType,
+        resource_id: Optional[uuid.UUID] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        request_id: Optional[str] = None,
+        ip_address: Optional[str] = None,
+    ):
+        self.tenant_id = tenant_id
+        self.user_id = user_id
+        self.action = action
+        self.resource_type = resource_type
+        self.resource_id = resource_id
+        self.metadata = metadata or {}
+        self.request_id = request_id
+        self.ip_address = ip_address
+        self.status = "success"
+        self.error_message = None
+        self._audit_log: Optional[AuditLog] = None
+    
+    async def __aenter__(self) -> "AuditContext":
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is not None:
+            self.status = "failure"
+            self.error_message = str(exc_val) if exc_val else "Unknown error"
+        
+        # Log the action
+        async with get_db_session() as session:
+            logger = AuditLogger(session)
+            self._audit_log = await logger.log(
+                tenant_id=self.tenant_id,
+                user_id=self.user_id,
+                action=self.action,
+                resource_type=self.resource_type,
+                resource_id=self.resource_id,
+                metadata=self.metadata,
+                request_id=self.request_id,
+                ip_address=self.ip_address,
+                status=self.status,
+                error_message=self.error_message,
+            )
+        
+        return False  # Don't suppress exceptions
+    
+    @property
+    def audit_log(self) -> Optional[AuditLog]:
+        """Get the created audit log entry."""
+        return self._audit_log

audit_hash_chain.py

@@ -0,0 +1,202 @@
+"""
+Audit Hash Chain for AegisLM
+
+Provides hash chain functionality for tamper-evident audit logging.
+Each audit entry contains a hash that includes the previous entry's hash,
+creating a chain that can be verified for integrity.
+"""
+
+import hashlib
+import uuid
+from datetime import datetime
+from typing import Any, Dict, List, Tuple
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.db.models import AuditLog
+from backend.db.session import get_db_session
+
+
+class AuditHashChain:
+    """
+    Manages the audit log hash chain for tamper detection.
+    
+    Each audit entry contains a hash that includes the previous entry's hash,
+    creating a chain that can be verified for integrity.
+    """
+    
+    GENESIS_HASH = "0" * 64  # 64-character hex string (SHA256)
+    
+    @staticmethod
+    def compute_entry_hash(
+        previous_hash: str,
+        tenant_id: uuid.UUID,
+        user_id: uuid.UUID,
+        action: str,
+        resource_type: str,
+        resource_id: uuid.UUID | None,
+        timestamp: datetime,
+        status: str,
+    ) -> str:
+        """
+        Compute SHA256 hash for an audit entry.
+        
+        Args:
+            previous_hash: Hash of the previous entry
+            tenant_id: Tenant ID
+            user_id: User who performed the action
+            action: Action performed
+            resource_type: Type of resource
+            resource_id: ID of the resource
+            timestamp: When the action occurred
+            status: Action status
+            
+        Returns:
+            SHA256 hash as hex string
+        """
+        # Create deterministic string representation
+        entry_data = "|".join([
+            previous_hash,
+            str(tenant_id),
+            str(user_id),
+            action,
+            resource_type,
+            str(resource_id) if resource_id else "",
+            timestamp.isoformat(),
+            status,
+        ])
+        
+        return hashlib.sha256(entry_data.encode()).hexdigest()
+    
+    @staticmethod
+    def compute_hash_from_log(log: AuditLog, previous_hash: str) -> str:
+        """
+        Compute hash from an AuditLog object.
+        
+        Args:
+            log: AuditLog object
+            previous_hash: Hash of previous entry
+            
+        Returns:
+            SHA256 hash as hex string
+        """
+        return AuditHashChain.compute_entry_hash(
+            previous_hash=previous_hash,
+            tenant_id=log.tenant_id,
+            user_id=log.user_id,
+            action=log.action,
+            resource_type=log.resource_type,
+            resource_id=log.resource_id,
+            timestamp=log.timestamp,
+            status=log.status,
+        )
+    
+    @classmethod
+    async def verify_chain(
+        cls,
+        db: AsyncSession,
+        tenant_id: uuid.UUID,
+    ) -> Tuple[bool, List[Dict[str, Any]]]:
+        """
+        Verify the integrity of the audit log hash chain for a tenant.
+        
+        Args:
+            db: Database session
+            tenant_id: Tenant ID
+            
+        Returns:
+            Tuple of (is_valid, list of issues)
+        """
+        # Get all audit logs for tenant, ordered by timestamp
+        query = (
+            select(AuditLog)
+            .where(AuditLog.tenant_id == tenant_id)
+            .order_by(AuditLog.timestamp.asc())
+        )
+        result = await db.execute(query)
+        logs = list(result.scalars().all())
+        
+        issues = []
+        previous_hash = cls.GENESIS_HASH
+        
+        for i, log in enumerate(logs):
+            # Check if stored hash matches computed hash
+            stored_hash = getattr(log, 'entry_hash', None)
+            if stored_hash is None:
+                issues.append({
+                    "index": i,
+                    "log_id": str(log.id),
+                    "issue": "No hash stored",
+                })
+                continue
+            
+            computed_hash = cls.compute_hash_from_log(log, previous_hash)
+            
+            if stored_hash != computed_hash:
+                issues.append({
+                    "index": i,
+                    "log_id": str(log.id),
+                    "issue": "Hash mismatch",
+                    "expected": computed_hash,
+                    "actual": stored_hash,
+                })
+            
+            # Move to next
+            previous_hash = stored_hash
+        
+        return len(issues) == 0, issues
+    
+    @classmethod
+    async def get_chain_status(
+        cls,
+        db: AsyncSession,
+        tenant_id: uuid.UUID,
+    ) -> Dict[str, Any]:
+        """
+        Get the status of the audit hash chain.
+        
+        Args:
+            db: Database session
+            tenant_id: Tenant ID
+            
+        Returns:
+            Dictionary with chain status
+        """
+        # Get count of logs
+        query = select(AuditLog).where(AuditLog.tenant_id == tenant_id)
+        result = await db.execute(query)
+        logs = list(result.scalars().all())
+        
+        if not logs:
+            return {
+                "total_entries": 0,
+                "chain_valid": True,
+                "issues": [],
+            }
+        
+        # Verify chain
+        is_valid, issues = await cls.verify_chain(db, tenant_id)
+        
+        return {
+            "total_entries": len(logs),
+            "chain_valid": is_valid,
+            "issues": issues,
+            "first_entry_timestamp": logs[0].timestamp.isoformat() if logs else None,
+            "last_entry_timestamp": logs[-1].timestamp.isoformat() if logs else None,
+        }
+
+
+# Convenience functions
+async def verify_audit_chain(tenant_id: uuid.UUID) -> Dict[str, Any]:
+    """
+    Verify the audit chain for a tenant.
+    
+    Args:
+        tenant_id: Tenant ID
+        
+    Returns:
+        Dictionary with verification results
+    """
+    async with get_db_session() as session:
+        return await AuditHashChain.get_chain_status(session, tenant_id)

logger.py

@@ -0,0 +1,225 @@
+"""
+Structured Logging Framework
+
+Provides JSON-formatted structured logging for the AegisLM backend.
+"""
+
+import json
+import logging
+import sys
+import traceback
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, Dict, Optional
+from uuid import UUID
+
+from backend.core.config import settings
+
+
+class LogLevel(str, Enum):
+    """Log level enumeration."""
+
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+class StructuredLogger:
+    """
+    Structured JSON logger for AegisLM.
+    
+    All logs are emitted as JSON with a consistent schema.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        run_id: Optional[UUID] = None,
+        component: Optional[str] = None,
+    ):
+        self.logger = logging.getLogger(name)
+        self.run_id = run_id
+        self.component = component or name
+        
+        # Configure logger if not already configured
+        if not self.logger.handlers:
+            self._configure_logger()
+
+    def _configure_logger(self) -> None:
+        """Configure the logger with JSON formatter."""
+        # Set level from settings
+        level = getattr(logging, settings.log_level.upper(), logging.INFO)
+        self.logger.setLevel(level)
+        
+        # Create handler
+        handler = logging.StreamHandler(sys.stdout)
+        handler.setLevel(level)
+        
+        # Use JSON formatter
+        formatter = JSONFormatter()
+        handler.setFormatter(formatter)
+        
+        self.logger.addHandler(handler)
+        self.logger.propagate = False
+
+    def _build_log_entry(
+        self,
+        level: str,
+        message: str,
+        extra_metadata: Optional[Dict[str, Any]] = None,
+        exception: Optional[Exception] = None,
+    ) -> Dict[str, Any]:
+        """Build structured log entry."""
+        log_entry = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "level": level,
+            "run_id": str(self.run_id) if self.run_id else None,
+            "component": self.component,
+            "message": message,
+        }
+        
+        # Add metadata
+        if extra_metadata:
+            log_entry["metadata"] = extra_metadata
+        
+        # Add exception info if provided
+        if exception:
+            log_entry["exception"] = {
+                "type": type(exception).__name__,
+                "message": str(exception),
+                "traceback": traceback.format_exc(),
+            }
+        
+        return log_entry
+
+    def log(
+        self,
+        level: str,
+        message: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        exception: Optional[Exception] = None,
+    ) -> None:
+        """Emit a log entry."""
+        log_entry = self._build_log_entry(level, message, metadata, exception)
+        
+        # Use standard logging
+        log_method = getattr(self.logger, level.lower(), self.logger.info)
+        log_method(json.dumps(log_entry))
+
+    def debug(self, message: str, metadata: Optional[Dict[str, Any]] = None) -> None:
+        """Log debug message."""
+        self.log(LogLevel.DEBUG.value, message, metadata)
+
+    def info(self, message: str, metadata: Optional[Dict[str, Any]] = None) -> None:
+        """Log info message."""
+        self.log(LogLevel.INFO.value, message, metadata)
+
+    def warning(self, message: str, metadata: Optional[Dict[str, Any]] = None) -> None:
+        """Log warning message."""
+        self.log(LogLevel.WARNING.value, message, metadata)
+
+    def error(
+        self,
+        message: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        exception: Optional[Exception] = None,
+    ) -> None:
+        """Log error message."""
+        self.log(LogLevel.ERROR.value, message, metadata, exception)
+
+    def critical(
+        self,
+        message: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        exception: Optional[Exception] = None,
+    ) -> None:
+        """Log critical message."""
+        self.log(LogLevel.CRITICAL.value, message, metadata, exception)
+
+    def set_run_id(self, run_id: UUID) -> None:
+        """Set the current run ID for all subsequent logs."""
+        self.run_id = run_id
+
+    def bind(self, **kwargs) -> "StructuredLogger":
+        """
+        Create a new logger with additional bound context.
+        
+        Returns a new logger instance with merged metadata.
+        """
+        new_logger = StructuredLogger(
+            name=self.logger.name,
+            run_id=self.run_id,
+            component=self.component,
+        )
+        return new_logger
+
+
+class JSONFormatter(logging.Formatter):
+    """JSON formatter for structured logging."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Format log record as JSON."""
+        try:
+            # Try to parse the message as JSON
+            log_data = json.loads(record.getMessage())
+        except (json.JSONDecodeError, ValueError):
+            # If not JSON, use as-is
+            log_data = {"message": record.getMessage()}
+
+        # Add standard fields
+        log_entry = {
+            "timestamp": datetime.fromtimestamp(
+                record.created, tz=timezone.utc
+            ).isoformat(),
+            "level": record.levelname,
+            "logger": record.name,
+            **log_data,
+        }
+
+        # Add extra fields from record
+        if hasattr(record, "run_id") and record.run_id:
+            log_entry["run_id"] = record.run_id
+
+        if hasattr(record, "component") and record.component:
+            log_entry["component"] = record.component
+
+        if hasattr(record, "metadata") and record.metadata:
+            log_entry["metadata"] = record.metadata
+
+        # Add exception info
+        if record.exc_info:
+            log_entry["exception"] = {
+                "type": record.exc_info[0].__name__ if record.exc_info[0] else None,
+                "message": str(record.exc_info[1]) if record.exc_info[1] else None,
+            }
+
+        return json.dumps(log_entry)
+
+
+# =============================================================================
+# Logger factory functions
+# =============================================================================
+
+def get_logger(
+    name: str,
+    run_id: Optional[UUID] = None,
+    component: Optional[str] = None,
+) -> StructuredLogger:
+    """
+    Get a structured logger instance.
+    
+    Args:
+        name: Logger name (typically __name__)
+        run_id: Optional run ID for correlation
+        component: Optional component name
+        
+    Returns:
+        StructuredLogger instance
+    """
+    return StructuredLogger(name, run_id, component)
+
+
+# Default logger
+default_logger = get_logger("aegislm")

schema.py

@@ -0,0 +1,324 @@
+"""
+Logging Schema Definitions
+
+Defines Pydantic models for structured log entries.
+"""
+
+from datetime import datetime
+from enum import Enum
+from typing import Any, Dict, List, Optional
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+
+class LogLevel(str, Enum):
+    """Log level enumeration."""
+
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+class Component(str, Enum):
+    """System components for logging."""
+
+    ORCHESTRATOR = "orchestrator"
+    MODEL_EXECUTOR = "model_executor"
+    ATTACKER = "attacker"
+    DEFENDER = "defender"
+    JUDGE = "judge"
+    SCORING = "scoring"
+    API = "api"
+    DATABASE = "database"
+    AGENT = "agent"
+
+
+class BaseLogSchema(BaseModel):
+    """Base schema for all log entries."""
+
+    timestamp: datetime = Field(
+        default_factory=datetime.utcnow,
+        description="ISO 8601 timestamp of the log entry"
+    )
+    level: LogLevel = Field(
+        description="Log level"
+    )
+    run_id: Optional[UUID] = Field(
+        default=None,
+        description="Evaluation run ID for correlation"
+    )
+    component: Component = Field(
+        description="Component that generated the log"
+    )
+    message: str = Field(
+        description="Log message"
+    )
+    metadata: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Additional structured metadata"
+    )
+
+
+class EvaluationLogSchema(BaseLogSchema):
+    """Schema for evaluation-related logs."""
+
+    sample_id: Optional[str] = Field(
+        default=None,
+        description="Sample ID being processed"
+    )
+    attack_type: Optional[str] = Field(
+        default=None,
+        description="Type of attack applied"
+    )
+    model_name: Optional[str] = Field(
+        default=None,
+        description="Model being evaluated"
+    )
+
+
+class MetricsLogSchema(BaseLogSchema):
+    """Schema for metrics and observability logs."""
+
+    latency_ms: Optional[float] = Field(
+        default=None,
+        description="Processing latency in milliseconds"
+    )
+    tokens_generated: Optional[int] = Field(
+        default=None,
+        description="Number of tokens generated"
+    )
+    attack_chain_depth: Optional[int] = Field(
+        default=None,
+        description="Depth of attack chain"
+    )
+    throughput_samples_per_sec: Optional[float] = Field(
+        default=None,
+        description="Processing throughput"
+    )
+    memory_usage_mb: Optional[float] = Field(
+        default=None,
+        description="Memory usage in MB"
+    )
+
+
+class ErrorLogSchema(BaseLogSchema):
+    """Schema for error logs."""
+
+    error_type: str = Field(
+        description="Type of error"
+    )
+    error_message: str = Field(
+        description="Error message"
+    )
+    stack_trace: Optional[str] = Field(
+        default=None,
+        description="Stack trace if available"
+    )
+    recoverable: bool = Field(
+        default=True,
+        description="Whether the error is recoverable"
+    )
+
+
+class LifecycleLogSchema(BaseLogSchema):
+    """Schema for lifecycle event logs."""
+
+    event: str = Field(
+        description="Lifecycle event name"
+    )
+    previous_state: Optional[str] = Field(
+        default=None,
+        description="Previous state"
+    )
+    new_state: str = Field(
+        description="New state"
+    )
+
+
+# =============================================================================
+# Log entry schemas for specific components
+# =============================================================================
+
+class OrchestratorLogSchema(EvaluationLogSchema):
+    """Schema for orchestrator logs."""
+
+    total_samples: Optional[int] = Field(
+        default=None,
+        description="Total samples to process"
+    )
+    processed_samples: Optional[int] = Field(
+        default=None,
+        description="Samples processed so far"
+    )
+    failed_samples: Optional[int] = Field(
+        default=None,
+        description="Number of failed samples"
+    )
+
+
+class ModelExecutorLogSchema(EvaluationLogSchema):
+    """Schema for model executor logs."""
+
+    model_name: str = Field(
+        description="Model name"
+    )
+    model_version: str = Field(
+        description="Model version"
+    )
+    generation_time_ms: float = Field(
+        description="Time taken for generation"
+    )
+    input_tokens: int = Field(
+        description="Number of input tokens"
+    )
+    output_tokens: int = Field(
+        description="Number of output tokens"
+    )
+    device: str = Field(
+        description="Device used for inference"
+    )
+
+
+class ScoringLogSchema(BaseLogSchema):
+    """Schema for scoring logs."""
+
+    hallucination_score: Optional[float] = Field(
+        default=None,
+        description="Hallucination score [0, 1]"
+    )
+    toxicity_score: Optional[float] = Field(
+        default=None,
+        description="Toxicity score [0, 1]"
+    )
+    bias_score: Optional[float] = Field(
+        default=None,
+        description="Bias score [0, 1]"
+    )
+    confidence_score: Optional[float] = Field(
+        default=None,
+        description="Confidence score [0, 1]"
+    )
+    composite_score: Optional[float] = Field(
+        default=None,
+        description="Composite robustness score"
+    )
+
+
+class APILogSchema(BaseLogSchema):
+    """Schema for API request/response logs."""
+
+    method: str = Field(
+        description="HTTP method"
+    )
+    path: str = Field(
+        description="Request path"
+    )
+    status_code: Optional[int] = Field(
+        default=None,
+        description="Response status code"
+    )
+    request_id: Optional[str] = Field(
+        default=None,
+        description="Request ID for tracing"
+    )
+    user_agent: Optional[str] = Field(
+        default=None,
+        description="User agent string"
+    )
+    response_time_ms: Optional[float] = Field(
+        default=None,
+        description="Response time in milliseconds"
+    )
+
+
+# =============================================================================
+# Log aggregation schemas
+# =============================================================================
+
+class AggregatedMetricsSchema(BaseModel):
+    """Schema for aggregated evaluation metrics."""
+
+    run_id: UUID = Field(
+        description="Evaluation run ID"
+    )
+    total_samples: int = Field(
+        description="Total number of samples"
+    )
+    successful_samples: int = Field(
+        description="Number of successfully processed samples"
+    )
+    failed_samples: int = Field(
+        description="Number of failed samples"
+    )
+    
+    # Aggregate scores
+    mean_hallucination: Optional[float] = Field(
+        default=None,
+        description="Mean hallucination score"
+    )
+    mean_toxicity: Optional[float] = Field(
+        default=None,
+        description="Mean toxicity score"
+    )
+    mean_bias: Optional[float] = Field(
+        default=None,
+        description="Mean bias score"
+    )
+    mean_confidence: Optional[float] = Field(
+        default=None,
+        description="Mean confidence score"
+    )
+    mean_robustness: Optional[float] = Field(
+        default=None,
+        description="Mean robustness score"
+    )
+    composite_score: Optional[float] = Field(
+        default=None,
+        description="Final composite score"
+    )
+    
+    # Timing metrics
+    total_processing_time_ms: float = Field(
+        description="Total processing time in milliseconds"
+    )
+    mean_sample_time_ms: float = Field(
+        description="Mean time per sample in milliseconds"
+    )
+    throughput_samples_per_sec: float = Field(
+        description="Processing throughput"
+    )
+    
+    # Error summary
+    error_types: Dict[str, int] = Field(
+        default_factory=dict,
+        description="Count of each error type"
+    )
+
+
+class RunSummarySchema(BaseModel):
+    """Schema for evaluation run summary."""
+
+    run_id: UUID = Field(
+        description="Evaluation run ID"
+    )
+    model_name: str = Field(
+        description="Model name"
+    )
+    dataset_version: str = Field(
+        description="Dataset version"
+    )
+    status: str = Field(
+        description="Run status"
+    )
+    metrics: AggregatedMetricsSchema = Field(
+        description="Aggregated metrics"
+    )
+    artifacts_path: str = Field(
+        description="Path to run artifacts"
+    )
+    completed_at: datetime = Field(
+        description="Completion timestamp"
+    )

system_metrics.py

@@ -0,0 +1,262 @@
+"""
+System Metrics Monitoring Module
+
+Provides system metrics logging for performance monitoring:
+- RAM usage
+- GPU usage
+- Active tasks
+- DB connections
+
+Logs periodically to track system health and performance.
+"""
+
+import asyncio
+import psutil
+import time
+from datetime import datetime
+from typing import Dict, Optional
+
+from backend.logging.logger import get_logger
+
+
+logger = get_logger("system_metrics", component="monitoring")
+
+
+class SystemMetrics:
+    """
+    System metrics collector for monitoring resource usage.
+    
+    Tracks:
+    - RAM usage
+    - GPU memory usage
+    - Active tasks
+    - DB connections
+    """
+    
+    def __init__(self, interval: int = 30):
+        """
+        Initialize system metrics collector.
+        
+        Args:
+            interval: Logging interval in seconds
+        """
+        self.interval = interval
+        self._running = False
+        self._task: Optional[asyncio.Task] = None
+        self._last_metrics: Dict = {}
+    
+    async def start(self) -> None:
+        """Start periodic metrics collection."""
+        if self._running:
+            return
+        
+        self._running = True
+        self._task = asyncio.create_task(self._collect_loop())
+        logger.info("System metrics collection started", interval=self.interval)
+    
+    async def stop(self) -> None:
+        """Stop periodic metrics collection."""
+        self._running = False
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+        logger.info("System metrics collection stopped")
+    
+    async def _collect_loop(self) -> None:
+        """Main collection loop."""
+        while self._running:
+            try:
+                metrics = await self.collect_metrics()
+                self._last_metrics = metrics
+                self._log_metrics(metrics)
+            except Exception as e:
+                logger.error(
+                    "Failed to collect metrics",
+                    error=str(e),
+                    exception=e
+                )
+            
+            await asyncio.sleep(self.interval)
+    
+    async def collect_metrics(self) -> Dict:
+        """
+        Collect current system metrics.
+        
+        Returns:
+            Dictionary with current metrics
+        """
+        # CPU metrics
+        cpu_percent = psutil.cpu_percent(interval=0.1)
+        cpu_count = psutil.cpu_count()
+        
+        # Memory metrics
+        memory = psutil.virtual_memory()
+        
+        # Disk metrics
+        disk = psutil.disk_usage('/')
+        
+        metrics = {
+            "timestamp": datetime.utcnow().isoformat(),
+            "cpu": {
+                "percent": cpu_percent,
+                "count": cpu_count,
+            },
+            "memory": {
+                "total_mb": memory.total / (1024 * 1024),
+                "available_mb": memory.available / (1024 * 1024),
+                "used_mb": memory.used / (1024 * 1024),
+                "percent": memory.percent,
+            },
+            "disk": {
+                "total_gb": disk.total / (1024 * 1024 * 1024),
+                "used_gb": disk.used / (1024 * 1024 * 1024),
+                "free_gb": disk.free / (1024 * 1024 * 1024),
+                "percent": disk.percent,
+            },
+        }
+        
+        # GPU metrics (if available)
+        try:
+            import torch
+            if torch.cuda.is_available():
+                gpu_metrics = {
+                    "available": True,
+                    "device_count": torch.cuda.device_count(),
+                    "current_device": torch.cuda.current_device(),
+                    "memory_allocated_mb": torch.cuda.memory_allocated() / (1024 * 1024),
+                    "memory_reserved_mb": torch.cuda.memory_reserved() / (1024 * 1024),
+                    "max_memory_allocated_mb": torch.cuda.max_memory_allocated() / (1024 * 1024),
+                }
+                
+                # Get memory for each device
+                device_memory = []
+                for i in range(torch.cuda.device_count()):
+                    device_memory.append({
+                        "device": i,
+                        "allocated_mb": torch.cuda.memory_allocated(i) / (1024 * 1024),
+                        "reserved_mb": torch.cuda.memory_reserved(i) / (1024 * 1024),
+                    })
+                gpu_metrics["devices"] = device_memory
+                
+                metrics["gpu"] = gpu_metrics
+            else:
+                metrics["gpu"] = {"available": False}
+        except ImportError:
+            metrics["gpu"] = {"available": False, "error": "PyTorch not available"}
+        
+        # Active tasks (if running in async context)
+        try:
+            loop = asyncio.get_event_loop()
+            tasks = [t for t in asyncio.all_tasks(loop) if not t.done()]
+            metrics["async"] = {
+                "active_tasks": len(tasks),
+            }
+        except RuntimeError:
+            metrics["async"] = {"active_tasks": 0}
+        
+        return metrics
+    
+    def _log_metrics(self, metrics: Dict) -> None:
+        """Log metrics to structured logger."""
+        # Log at info level for regular metrics
+        logger.info(
+            "System metrics snapshot",
+            memory_mb=metrics["memory"]["used_mb"],
+            memory_percent=metrics["memory"]["percent"],
+            cpu_percent=metrics["cpu"]["percent"],
+            active_tasks=metrics["async"]["active_tasks"],
+            metadata=metrics,
+        )
+        
+        # Log warnings for high usage
+        if metrics["memory"]["percent"] > 90:
+            logger.warning(
+                "High memory usage detected",
+                memory_percent=metrics["memory"]["percent"],
+            )
+        
+        if metrics["cpu"]["percent"] > 90:
+            logger.warning(
+                "High CPU usage detected",
+                cpu_percent=metrics["cpu"]["percent"],
+            )
+        
+        # Check GPU if available
+        if metrics.get("gpu", {}).get("available"):
+            gpu = metrics["gpu"]
+            if gpu.get("memory_allocated_mb", 0) > 0:
+                # Log GPU memory if being used
+                logger.info(
+                    "GPU memory usage",
+                    gpu_memory_mb=gpu["memory_allocated_mb"],
+                    gpu_memory_reserved_mb=gpu["memory_reserved_mb"],
+                )
+    
+    def get_current_metrics(self) -> Dict:
+        """
+        Get the last collected metrics.
+        
+        Returns:
+            Last metrics dictionary or empty dict if not collected yet
+        """
+        return self._last_metrics
+
+
+# Global metrics collector instance
+_metrics_collector: Optional[SystemMetrics] = None
+
+
+def get_metrics_collector(interval: int = 30) -> SystemMetrics:
+    """
+    Get the global metrics collector instance.
+    
+    Args:
+        interval: Collection interval in seconds
+    
+    Returns:
+        SystemMetrics instance
+    """
+    global _metrics_collector
+    if _metrics_collector is None:
+        _metrics_collector = SystemMetrics(interval=interval)
+    return _metrics_collector
+
+
+async def start_metrics_collection(interval: int = 30) -> None:
+    """
+    Start system metrics collection.
+    
+    Args:
+        interval: Collection interval in seconds
+    """
+    collector = get_metrics_collector(interval)
+    await collector.start()
+
+
+async def stop_metrics_collection() -> None:
+    """Stop system metrics collection."""
+    collector = get_metrics_collector()
+    await collector.stop()
+
+
+def get_current_metrics() -> Dict:
+    """
+    Get current system metrics.
+    
+    Returns:
+        Current metrics dictionary
+    """
+    collector = get_metrics_collector()
+    return collector.get_current_metrics()
+
+
+__all__ = [
+    "SystemMetrics",
+    "get_metrics_collector",
+    "start_metrics_collection",
+    "stop_metrics_collection",
+    "get_current_metrics",
+]