isa-model 0.3.91__py3-none-any.whl → 0.4.3__py3-none-any.whl

isa_model/serving/api/error_handlers.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Improved Error Handling for ISA Model API
+Provides consistent error responses and better user experience
+"""
+
+import logging
+import traceback
+from typing import Dict, Any, Optional, Union
+from enum import Enum
+from fastapi import HTTPException, status
+from fastapi.responses import JSONResponse
+
+logger = logging.getLogger(__name__)
+
+class ErrorCode(str, Enum):
+    """Standard error codes for ISA Model API"""
+    
+    # Input/Request errors (4xx)
+    INVALID_INPUT = "INVALID_INPUT"
+    MISSING_PARAMETER = "MISSING_PARAMETER"
+    INVALID_MODEL = "INVALID_MODEL"
+    INVALID_PROVIDER = "INVALID_PROVIDER"
+    INVALID_SERVICE_TYPE = "INVALID_SERVICE_TYPE"
+    INVALID_TASK = "INVALID_TASK"
+    UNSUPPORTED_FORMAT = "UNSUPPORTED_FORMAT"
+    FILE_TOO_LARGE = "FILE_TOO_LARGE"
+    RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED"
+    AUTHENTICATION_FAILED = "AUTHENTICATION_FAILED"
+    AUTHORIZATION_FAILED = "AUTHORIZATION_FAILED"
+    
+    # Service errors (5xx)
+    SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE"
+    MODEL_LOAD_FAILED = "MODEL_LOAD_FAILED"
+    INFERENCE_FAILED = "INFERENCE_FAILED"
+    EXTERNAL_API_ERROR = "EXTERNAL_API_ERROR"
+    DATABASE_ERROR = "DATABASE_ERROR"
+    TIMEOUT_ERROR = "TIMEOUT_ERROR"
+    INTERNAL_ERROR = "INTERNAL_ERROR"
+    
+    # Configuration errors
+    CONFIG_ERROR = "CONFIG_ERROR"
+    API_KEY_MISSING = "API_KEY_MISSING"
+    API_KEY_INVALID = "API_KEY_INVALID"
+
+class ISAModelError(Exception):
+    """Base exception for ISA Model errors"""
+    
+    def __init__(
+        self,
+        message: str,
+        error_code: ErrorCode,
+        status_code: int = 500,
+        details: Optional[Dict[str, Any]] = None,
+        user_message: Optional[str] = None
+    ):
+        self.message = message
+        self.error_code = error_code
+        self.status_code = status_code
+        self.details = details or {}
+        self.user_message = user_message or self._generate_user_message()
+        super().__init__(self.message)
+    
+    def _generate_user_message(self) -> str:
+        """Generate user-friendly error message"""
+        user_messages = {
+            ErrorCode.INVALID_INPUT: "请检查您的输入数据格式是否正确。",
+            ErrorCode.MISSING_PARAMETER: "请提供必需的参数。",
+            ErrorCode.INVALID_MODEL: "指定的模型不存在或不可用，请选择其他模型。",
+            ErrorCode.INVALID_PROVIDER: "指定的提供商不支持，请选择其他提供商。",
+            ErrorCode.INVALID_SERVICE_TYPE: "不支持的服务类型，请选择text、vision、audio、image或embedding。",
+            ErrorCode.INVALID_TASK: "不支持的任务类型，请查看API文档了解支持的任务。",
+            ErrorCode.UNSUPPORTED_FORMAT: "不支持的文件格式，请使用支持的格式。",
+            ErrorCode.FILE_TOO_LARGE: "文件太大，请压缩后重试。",
+            ErrorCode.RATE_LIMIT_EXCEEDED: "请求过于频繁，请稍后再试。",
+            ErrorCode.AUTHENTICATION_FAILED: "身份验证失败，请检查您的凭据。",
+            ErrorCode.AUTHORIZATION_FAILED: "您没有权限执行此操作。",
+            ErrorCode.SERVICE_UNAVAILABLE: "服务暂时不可用，请稍后再试。",
+            ErrorCode.MODEL_LOAD_FAILED: "模型加载失败，请稍后再试或选择其他模型。",
+            ErrorCode.INFERENCE_FAILED: "推理过程出现错误，请重试。",
+            ErrorCode.EXTERNAL_API_ERROR: "外部服务出现问题，请稍后再试。",
+            ErrorCode.DATABASE_ERROR: "数据库连接问题，请稍后再试。",
+            ErrorCode.TIMEOUT_ERROR: "请求超时，请稍后再试。",
+            ErrorCode.INTERNAL_ERROR: "内部服务器错误，请联系技术支持。",
+            ErrorCode.CONFIG_ERROR: "配置错误，请联系管理员。",
+            ErrorCode.API_KEY_MISSING: "缺少API密钥，请在配置中提供。",
+            ErrorCode.API_KEY_INVALID: "API密钥无效，请检查配置。"
+        }
+        
+        return user_messages.get(self.error_code, "出现了未知错误，请稍后再试。")
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert error to dictionary for API response"""
+        return {
+            "error_code": self.error_code.value,
+            "message": self.message,
+            "user_message": self.user_message,
+            "status_code": self.status_code,
+            "details": self.details
+        }
+
+def create_error_response(
+    error: Union[Exception, ISAModelError, str],
+    status_code: Optional[int] = None,
+    error_code: Optional[ErrorCode] = None,
+    details: Optional[Dict[str, Any]] = None,
+    include_traceback: bool = False
+) -> Dict[str, Any]:
+    """Create standardized error response"""
+    
+    if isinstance(error, ISAModelError):
+        response = {
+            "success": False,
+            "error": error.message,
+            "error_code": error.error_code.value,
+            "user_message": error.user_message,
+            "details": error.details,
+            "metadata": {
+                "error_type": "ISAModelError",
+                "status_code": error.status_code
+            }
+        }
+    elif isinstance(error, Exception):
+        # Convert generic exception to ISAModelError
+        error_message = str(error)
+        final_error_code = error_code or ErrorCode.INTERNAL_ERROR
+        final_status_code = status_code or 500
+        
+        isa_error = ISAModelError(
+            message=error_message,
+            error_code=final_error_code,
+            status_code=final_status_code,
+            details=details
+        )
+        
+        response = {
+            "success": False,
+            "error": isa_error.message,
+            "error_code": isa_error.error_code.value,
+            "user_message": isa_error.user_message,
+            "details": isa_error.details,
+            "metadata": {
+                "error_type": type(error).__name__,
+                "status_code": isa_error.status_code
+            }
+        }
+        
+        if include_traceback:
+            response["metadata"]["traceback"] = traceback.format_exc()
+            
+    else:
+        # String error
+        final_error_code = error_code or ErrorCode.INTERNAL_ERROR
+        final_status_code = status_code or 500
+        
+        isa_error = ISAModelError(
+            message=str(error),
+            error_code=final_error_code,
+            status_code=final_status_code,
+            details=details or {}
+        )
+        
+        response = {
+            "success": False,
+            "error": isa_error.message,
+            "error_code": isa_error.error_code.value,
+            "user_message": isa_error.user_message,
+            "details": isa_error.details,
+            "metadata": {
+                "error_type": "StringError",
+                "status_code": isa_error.status_code
+            }
+        }
+    
+    return response
+
+def handle_validation_error(exc: Exception) -> Dict[str, Any]:
+    """Handle Pydantic validation errors"""
+    details = {}
+    
+    if hasattr(exc, 'errors'):
+        # Pydantic validation error
+        validation_errors = []
+        for error in exc.errors():
+            field = " -> ".join(str(loc) for loc in error.get('loc', []))
+            message = error.get('msg', '')
+            validation_errors.append({
+                "field": field,
+                "message": message,
+                "type": error.get('type', '')
+            })
+        details["validation_errors"] = validation_errors
+    
+    return create_error_response(
+        error="请求数据格式不正确",
+        status_code=400,
+        error_code=ErrorCode.INVALID_INPUT,
+        details=details
+    )
+
+def handle_service_error(
+    service_name: str,
+    error: Exception,
+    fallback_available: bool = False
+) -> Dict[str, Any]:
+    """Handle service-specific errors with context"""
+    
+    details = {
+        "service": service_name,
+        "fallback_available": fallback_available
+    }
+    
+    # Determine error code based on service and error type
+    if "connection" in str(error).lower():
+        error_code = ErrorCode.EXTERNAL_API_ERROR
+        if fallback_available:
+            user_message = f"{service_name}服务暂时不可用，已切换到备用服务。"
+        else:
+            user_message = f"{service_name}服务连接失败，请稍后再试。"
+    elif "timeout" in str(error).lower():
+        error_code = ErrorCode.TIMEOUT_ERROR
+        user_message = f"{service_name}服务响应超时，请稍后再试。"
+    elif "authentication" in str(error).lower() or "api key" in str(error).lower():
+        error_code = ErrorCode.API_KEY_INVALID
+        user_message = f"{service_name}服务认证失败，请检查API密钥配置。"
+    elif "rate limit" in str(error).lower():
+        error_code = ErrorCode.RATE_LIMIT_EXCEEDED
+        user_message = f"{service_name}服务请求频率过高，请稍后再试。"
+    else:
+        error_code = ErrorCode.SERVICE_UNAVAILABLE
+        if fallback_available:
+            user_message = f"{service_name}服务出现问题，已切换到备用服务。"
+        else:
+            user_message = f"{service_name}服务暂时不可用，请稍后再试。"
+    
+    return create_error_response(
+        error=str(error),
+        status_code=503 if not fallback_available else 200,
+        error_code=error_code,
+        details=details
+    )
+
+def create_http_exception(
+    message: str,
+    status_code: int = 500,
+    error_code: Optional[ErrorCode] = None,
+    details: Optional[Dict[str, Any]] = None
+) -> HTTPException:
+    """Create HTTPException with standardized error format"""
+    
+    error_response = create_error_response(
+        error=message,
+        status_code=status_code,
+        error_code=error_code,
+        details=details
+    )
+    
+    return HTTPException(
+        status_code=status_code,
+        detail=error_response
+    )
+
+# Convenience functions for common errors
+def invalid_input_error(message: str, details: Optional[Dict] = None) -> HTTPException:
+    return create_http_exception(message, 400, ErrorCode.INVALID_INPUT, details)
+
+def model_not_found_error(model_name: str) -> HTTPException:
+    return create_http_exception(
+        f"模型 '{model_name}' 不存在或不可用",
+        404,
+        ErrorCode.INVALID_MODEL,
+        {"model": model_name, "suggestion": "请查看 /api/v1/models 获取可用模型列表"}
+    )
+
+def service_unavailable_error(service_name: str, fallback: bool = False) -> HTTPException:
+    status_code = 200 if fallback else 503
+    return create_http_exception(
+        f"{service_name}服务{'已切换到备用模式' if fallback else '暂时不可用'}",
+        status_code,
+        ErrorCode.SERVICE_UNAVAILABLE,
+        {"service": service_name, "fallback_mode": fallback}
+    )

isa_model/serving/api/fastapi_server.py

@@ -4,17 +4,113 @@ FastAPI Server for ISA Model Serving
 Main FastAPI application that serves model inference endpoints
 """
 
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, Request, HTTPException, Depends
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.middleware.trustedhost import TrustedHostMiddleware
 from fastapi.responses import JSONResponse
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from fastapi.staticfiles import StaticFiles
 import time
 import logging
-from typing import Dict, Any
+import os
+from typing import Dict, Any, Optional
 
-from .routes import ui_analysis, vision, llm, health, unified
+from .routes import health, unified, deployments, logs, analytics, settings, inference_monitoring, webhooks, tenants  # config, training, annotation, and evaluations temporarily disabled
 from .middleware.request_logger import RequestLoggerMiddleware
+from .middleware.security import setup_security_middleware, check_redis_health
+from .middleware.tenant_context import TenantContextMiddleware
+from .startup import run_startup_initialization
+from ...core.logging import api_logger, setup_logger
 
-logger = logging.getLogger(__name__)
+logger = api_logger  # Use Loki-configured logger instead of standard logging
+
+def configure_logging():
+    """Configure logging based on environment variables
+
+    Note: Loki integration is handled automatically by isa_model.core.logging.setup_logger
+    This function only sets log levels for existing loggers.
+    """
+    log_level = os.getenv('LOG_LEVEL', 'INFO').upper()
+    verbose_logging = os.getenv('VERBOSE_LOGGING', 'false').lower() == 'true'
+
+    # Set log level
+    level = getattr(logging, log_level, logging.INFO)
+
+    # Note: Don't call logging.basicConfig() here as it conflicts with Loki handlers
+    # The Loki logger (api_logger) is already configured with proper handlers
+    
+    # Set uvicorn logger level to match
+    uvicorn_logger = logging.getLogger("uvicorn")
+    uvicorn_logger.setLevel(level)
+    
+    # Set app logger level
+    app_logger = logging.getLogger("isa_model")
+    app_logger.setLevel(level)
+    
+    # Suppress verbose third-party library logs
+    # HTTP libraries - only show WARNING and above
+    logging.getLogger("httpcore").setLevel(logging.WARNING)
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("httpcore.http11").setLevel(logging.WARNING)
+    logging.getLogger("httpcore.connection").setLevel(logging.WARNING)
+    
+    # Database and ORM libraries
+    logging.getLogger("supabase").setLevel(logging.WARNING)
+    logging.getLogger("postgrest").setLevel(logging.WARNING)
+    
+    # AI/ML libraries
+    logging.getLogger("openai").setLevel(logging.WARNING)
+    logging.getLogger("anthropic").setLevel(logging.WARNING)
+    logging.getLogger("google").setLevel(logging.WARNING)
+    logging.getLogger("google.cloud").setLevel(logging.WARNING)
+    logging.getLogger("google.generativeai").setLevel(logging.WARNING)
+    
+    # Other verbose libraries
+    logging.getLogger("urllib3").setLevel(logging.WARNING)
+    logging.getLogger("requests").setLevel(logging.WARNING)
+    logging.getLogger("aiohttp").setLevel(logging.WARNING)
+    
+    # Reduce startup debug logs
+    if not verbose_logging:
+        # Reduce startup initialization debug logs
+        startup_logger = logging.getLogger("isa_model.serving.api.startup")
+        startup_logger.setLevel(logging.WARNING)
+        
+        # Reduce model registry debug logs
+        model_logger = logging.getLogger("isa_model.core.models.model_repo")
+        model_logger.setLevel(logging.WARNING)
+        
+        # Reduce intelligent selector debug logs
+        selector_logger = logging.getLogger("isa_model.core.services.intelligent_model_selector")
+        selector_logger.setLevel(logging.WARNING)
+        
+        # Training module removed - logger configuration no longer needed
+        
+        # Reduce knowledge base logs
+        kb_logger = logging.getLogger("isa_model.core.knowledge_base")
+        kb_logger.setLevel(logging.WARNING)
+        
+        # Reduce database migration logs
+        migration_logger = logging.getLogger("isa_model.core.database.migrations")
+        migration_logger.setLevel(logging.WARNING)
+        
+        # Reduce AI factory logs
+        ai_factory_logger = logging.getLogger("isa_model.inference.ai_factory")
+        ai_factory_logger.setLevel(logging.WARNING)
+        
+        # Reduce embedding service logs
+        embed_logger = logging.getLogger("isa_model.inference.services.embedding")
+        embed_logger.setLevel(logging.WARNING)
+        
+        # Reduce config manager logs
+        config_logger = logging.getLogger("isa_model.core.config")
+        config_logger.setLevel(logging.WARNING)
+        
+        # Reduce core integration logs
+        core_logger = logging.getLogger("isa_model.core")
+        core_logger.setLevel(logging.WARNING)
+    
+    logger.info(f"Logging configured - Level: {log_level}, Verbose: {verbose_logging}")
 
 def create_app(config: Dict[str, Any] = None) -> FastAPI:
     """
@@ -26,6 +122,9 @@ def create_app(config: Dict[str, Any] = None) -> FastAPI:
     Returns:
         Configured FastAPI application
     """
+    # Configure logging first
+    configure_logging()
+    
     app = FastAPI(
         title="ISA Model Serving API",
         description="High-performance model inference API",
@@ -34,14 +133,12 @@ def create_app(config: Dict[str, Any] = None) -> FastAPI:
         redoc_url="/redoc"
     )
     
-    # Configure CORS
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=["*"],  # Configure appropriately for production
-        allow_credentials=True,
-        allow_methods=["*"],
-        allow_headers=["*"],
-    )
+    # Setup comprehensive security middleware
+    # This includes CORS, rate limiting, security headers, request validation
+    setup_security_middleware(app)
+    
+    # Add tenant context middleware (before request logger)
+    app.add_middleware(TenantContextMiddleware)
     
     # Add custom middleware
     app.add_middleware(RequestLoggerMiddleware)
@@ -64,10 +161,52 @@ def create_app(config: Dict[str, Any] = None) -> FastAPI:
     # MAIN UNIFIED API - Single endpoint for all AI services
     app.include_router(unified.router, prefix="/api/v1", tags=["unified-api"])
     
-    # Legacy specific endpoints (kept for backward compatibility)
-    app.include_router(ui_analysis.router, prefix="/ui-analysis", tags=["ui-analysis"])
-    app.include_router(vision.router, prefix="/vision", tags=["vision"])
-    app.include_router(llm.router, prefix="/llm", tags=["llm"])
+    # DEPLOYMENTS API - Model deployment management
+    app.include_router(deployments.router, prefix="/api/v1/deployments", tags=["deployments"])
+    
+    # LOGS API - Log management and streaming
+    app.include_router(logs.router, prefix="/api/v1/logs", tags=["logs"])
+    
+    # ANALYTICS API - Usage analytics and reporting
+    app.include_router(analytics.router, prefix="/api/v1/analytics", tags=["analytics"])
+    
+    # SETTINGS API - Configuration and API key management
+    app.include_router(settings.router, prefix="/api/v1/settings", tags=["settings"])
+    
+    # EVALUATIONS API - Temporarily disabled for staging optimization
+    # app.include_router(evaluations.router, prefix="/api/v1/evaluations", tags=["evaluations"])
+    
+    # INFERENCE MONITORING API - InfluxDB-based inference monitoring and analytics
+    app.include_router(inference_monitoring.router, prefix="/api/v1/monitoring", tags=["monitoring"])
+    
+    # TRAINING API - Disabled for staging optimization
+    # app.include_router(training.router, prefix="/api/v1/training", tags=["training"])
+    
+    # WEBHOOKS API - Webhook management and notifications
+    app.include_router(webhooks.router, prefix="/api/v1/webhooks", tags=["webhooks"])
+    
+    # TENANTS API - Multi-tenancy and organization management
+    app.include_router(tenants.router, prefix="/api/v1/tenants", tags=["tenants"])
+    
+    # ANNOTATION API - Temporarily disabled for staging optimization
+    # app.include_router(annotation.router, prefix="/api/v1/annotations", tags=["annotations"])
+    
+    # CONFIG API - Configuration management
+    # app.include_router(config.router, prefix="/api/v1/config", tags=["config"])  # Temporarily disabled
+    
+    # Mount static files
+    static_path = os.path.join(os.path.dirname(__file__), "../static")
+    if os.path.exists(static_path):
+        app.mount("/static", StaticFiles(directory=static_path), name="static")
+        
+        # Serve management dashboard at /admin
+        @app.get("/admin")
+        async def admin_dashboard():
+            from fastapi.responses import FileResponse
+            index_path = os.path.join(static_path, "index.html")
+            if os.path.exists(index_path):
+                return FileResponse(index_path)
+            return {"error": "Management dashboard not found"}
     
     # Root endpoint
     @app.get("/")
@@ -76,9 +215,59 @@ def create_app(config: Dict[str, Any] = None) -> FastAPI:
             "service": "isa-model-serving",
             "version": "1.0.0",
             "status": "running",
-            "timestamp": time.time()
+            "timestamp": time.time(),
+            "admin_url": "/admin"
         }
     
+    # Add startup event handler
+    @app.on_event("startup")
+    async def startup_event():
+        logger.info("🚀 Starting application startup initialization...")
+        try:
+            await run_startup_initialization()
+            logger.info("✅ Application startup completed successfully")
+        except Exception as e:
+            logger.error(f"❌ Application startup failed: {e}")
+            logger.error("⚠️ Server will continue but may have reduced functionality")
+            # Store startup failure state for health checks
+            app.state.startup_failed = True
+            app.state.startup_error = str(e)
+            # Continue running to allow debugging and partial functionality
+    
+    # Add shutdown event handler
+    @app.on_event("shutdown")
+    async def shutdown_event():
+        logger.info("🧹 Starting application shutdown cleanup...")
+        try:
+            # Close database connections
+            try:
+                from .dependencies.database import close_database_pool
+                await close_database_pool()
+                logger.info("✅ Database connections closed")
+            except Exception as e:
+                logger.error(f"❌ Error closing database connections: {e}")
+            
+            # Clean up AI factory and services
+            try:
+                from ...inference.ai_factory import AIFactory
+                factory = AIFactory.get_instance()
+                await factory.cleanup()
+                logger.info("✅ AI Factory cleaned up")
+            except Exception as e:
+                logger.error(f"❌ Error cleaning up AI Factory: {e}")
+            
+            # Clean up startup initializer resources
+            try:
+                from .startup import startup_initializer
+                await startup_initializer.cleanup()
+                logger.info("✅ Startup resources cleaned up")
+            except Exception as e:
+                logger.error(f"❌ Error cleaning up startup resources: {e}")
+            
+            logger.info("✅ Application shutdown completed successfully")
+        except Exception as e:
+            logger.error(f"❌ Error during application shutdown: {e}")
+    
     return app
 
 # Create default app instance
@@ -86,4 +275,37 @@ app = create_app()
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    import os
+    import signal
+    
+    port = int(os.getenv("PORT", 8082))
+    
+    # Configure uvicorn for graceful shutdown
+    config = uvicorn.Config(
+        app,
+        host="0.0.0.0",
+        port=port,
+        log_level=os.getenv("LOG_LEVEL", "info").lower(),
+        access_log=True,
+        loop="asyncio",
+        # Graceful shutdown configuration
+        timeout_keep_alive=30,  # Keep connections alive for 30 seconds
+        timeout_graceful_shutdown=30,  # 30 second graceful shutdown timeout
+    )
+    
+    server = uvicorn.Server(config)
+    
+    # Setup signal handlers for graceful shutdown
+    def signal_handler(signum, frame):
+        logger.info(f"Received signal {signum}, initiating graceful shutdown...")
+        server.should_exit = True
+    
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+    
+    try:
+        server.run()
+    except KeyboardInterrupt:
+        logger.info("Keyboard interrupt received, shutting down...")
+    finally:
+        logger.info("Server shutdown complete")