Upload 4 files

config-provider.py

@@ -0,0 +1,582 @@
+"""
+Thread-Safe Configuration Provider for Flare Platform
+"""
+import threading
+import os
+import json
+import commentjson
+from typing import Optional, Dict, Any, List
+from datetime import datetime
+from pathlib import Path
+import tempfile
+import shutil
+
+from config_models import (
+    ServiceConfig, GlobalConfig, ProjectConfig, VersionConfig, 
+    IntentConfig, APIConfig, ActivityLogEntry
+)
+from logger import log_info, log_error, log_warning, log_debug, LogTimer
+from exceptions import (
+    RaceConditionError, ConfigurationError, ResourceNotFoundError,
+    DuplicateResourceError, ValidationError
+)
+from encryption_utils import encrypt, decrypt
+
+class ConfigProvider:
+    """Thread-safe singleton configuration provider"""
+    
+    _instance: Optional[ServiceConfig] = None
+    _lock = threading.RLock()  # Reentrant lock for nested calls
+    _file_lock = threading.Lock()  # Separate lock for file operations
+    _CONFIG_PATH = Path(__file__).parent / "service_config.jsonc"
+    
+    @classmethod
+    def get(cls) -> ServiceConfig:
+        """Get cached configuration - thread-safe"""
+        if cls._instance is None:
+            with cls._lock:
+                # Double-checked locking pattern
+                if cls._instance is None:
+                    with LogTimer("config_load"):
+                        cls._instance = cls._load()
+                        cls._instance.build_index()
+                        log_info("Configuration loaded successfully")
+        return cls._instance
+    
+    @classmethod
+    def reload(cls) -> ServiceConfig:
+        """Force reload configuration from file"""
+        with cls._lock:
+            log_info("Reloading configuration...")
+            cls._instance = None
+            return cls.get()
+    
+    @classmethod
+    def _load(cls) -> ServiceConfig:
+        """Load configuration from file"""
+        try:
+            if not cls._CONFIG_PATH.exists():
+                raise ConfigurationError(
+                    f"Config file not found: {cls._CONFIG_PATH}",
+                    config_key="service_config.jsonc"
+                )
+            
+            with open(cls._CONFIG_PATH, 'r', encoding='utf-8') as f:
+                config_data = commentjson.load(f)
+            
+            # Ensure required fields
+            if 'config' not in config_data:
+                config_data['config'] = {}
+            
+            # Parse API configs (handle JSON strings)
+            if 'apis' in config_data:
+                cls._parse_api_configs(config_data['apis'])
+            
+            # Validate and create model
+            cfg = ServiceConfig.model_validate(config_data)
+            
+            log_debug(
+                "Configuration loaded",
+                projects=len(cfg.projects),
+                apis=len(cfg.apis),
+                users=len(cfg.global_config.users)
+            )
+            
+            return cfg
+            
+        except Exception as e:
+            log_error(f"Error loading config", error=str(e), path=str(cls._CONFIG_PATH))
+            raise ConfigurationError(f"Failed to load configuration: {e}")
+    
+    @classmethod
+    def _parse_api_configs(cls, apis: List[Dict[str, Any]]) -> None:
+        """Parse JSON string fields in API configs"""
+        for api in apis:
+            # Parse headers
+            if 'headers' in api and isinstance(api['headers'], str):
+                try:
+                    api['headers'] = json.loads(api['headers'])
+                except json.JSONDecodeError:
+                    api['headers'] = {}
+            
+            # Parse body_template
+            if 'body_template' in api and isinstance(api['body_template'], str):
+                try:
+                    api['body_template'] = json.loads(api['body_template'])
+                except json.JSONDecodeError:
+                    api['body_template'] = {}
+            
+            # Parse auth configs
+            if 'auth' in api and api['auth']:
+                cls._parse_auth_config(api['auth'])
+    
+    @classmethod
+    def _parse_auth_config(cls, auth: Dict[str, Any]) -> None:
+        """Parse auth configuration"""
+        # Parse token_request_body
+        if 'token_request_body' in auth and isinstance(auth['token_request_body'], str):
+            try:
+                auth['token_request_body'] = json.loads(auth['token_request_body'])
+            except json.JSONDecodeError:
+                auth['token_request_body'] = {}
+        
+        # Parse token_refresh_body
+        if 'token_refresh_body' in auth and isinstance(auth['token_refresh_body'], str):
+            try:
+                auth['token_refresh_body'] = json.loads(auth['token_refresh_body'])
+            except json.JSONDecodeError:
+                auth['token_refresh_body'] = {}
+    
+    @classmethod
+    def save(cls, config: ServiceConfig, username: str) -> None:
+        """Thread-safe configuration save with optimistic locking"""
+        with cls._file_lock:
+            try:
+                # Load current config for race condition check
+                current_config = cls._load()
+                
+                # Check for race condition
+                if config.last_update_date and current_config.last_update_date:
+                    if config.last_update_date != current_config.last_update_date:
+                        raise RaceConditionError(
+                            "Configuration was modified by another user",
+                            current_user=username,
+                            last_update_user=current_config.last_update_user,
+                            last_update_date=current_config.last_update_date,
+                            entity_type="configuration"
+                        )
+                
+                # Update metadata
+                config.last_update_date = datetime.utcnow().isoformat()
+                config.last_update_user = username
+                
+                # Convert to JSON
+                data = config.to_jsonc_dict()
+                json_str = json.dumps(data, ensure_ascii=False, indent=2)
+                
+                # Atomic write using temp file
+                with tempfile.NamedTemporaryFile(
+                    mode='w',
+                    encoding='utf-8',
+                    dir=cls._CONFIG_PATH.parent,
+                    delete=False
+                ) as tmp_file:
+                    tmp_file.write(json_str)
+                    temp_path = Path(tmp_file.name)
+                
+                # Atomic rename
+                temp_path.replace(cls._CONFIG_PATH)
+                
+                # Update cache
+                with cls._lock:
+                    cls._instance = config
+                    cls._instance.build_index()
+                
+                log_info(
+                    "Configuration saved",
+                    user=username,
+                    size=len(json_str)
+                )
+                
+            except Exception as e:
+                log_error("Failed to save configuration", error=str(e), user=username)
+                raise
+    
+    # ===================== Environment Methods =====================
+    
+    @classmethod
+    def update_environment(cls, update_data: dict, username: str) -> None:
+        """Update environment configuration"""
+        with cls._lock:
+            config = cls.get()
+            
+            # Update providers
+            if 'llm_provider' in update_data:
+                config.global_config.llm_provider = update_data['llm_provider']
+            
+            if 'tts_provider' in update_data:
+                config.global_config.tts_provider = update_data['tts_provider']
+            
+            if 'stt_provider' in update_data:
+                config.global_config.stt_provider = update_data['stt_provider']
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "UPDATE_ENVIRONMENT",
+                "environment", None, None,
+                f"Updated providers"
+            )
+            
+            # Save
+            cls.save(config, username)
+    
+    # ===================== Project Methods =====================
+    
+    @classmethod
+    def get_project(cls, project_id: int) -> Optional[ProjectConfig]:
+        """Get project by ID"""
+        config = cls.get()
+        return next((p for p in config.projects if p.id == project_id), None)
+    
+    @classmethod
+    def create_project(cls, project_data: dict, username: str) -> ProjectConfig:
+        """Create new project with thread safety"""
+        with cls._lock:
+            config = cls.get()
+            
+            # Check for duplicate name
+            if any(p.name == project_data['name'] for p in config.projects):
+                raise DuplicateResourceError("project", project_data['name'])
+            
+            # Create project
+            project = ProjectConfig(
+                id=config.project_id_counter,
+                created_date=datetime.utcnow().isoformat(),
+                created_by=username,
+                **project_data
+            )
+            
+            # Update config
+            config.projects.append(project)
+            config.project_id_counter += 1
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "CREATE_PROJECT",
+                "project", project.id, project.name
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "Project created",
+                project_id=project.id,
+                name=project.name,
+                user=username
+            )
+            
+            return project
+    
+    @classmethod
+    def update_project(cls, project_id: int, update_data: dict, username: str) -> ProjectConfig:
+        """Update project with optimistic locking"""
+        with cls._lock:
+            config = cls.get()
+            project = cls.get_project(project_id)
+            
+            if not project:
+                raise ResourceNotFoundError("project", project_id)
+            
+            # Check race condition
+            if 'last_update_date' in update_data:
+                if project.last_update_date != update_data['last_update_date']:
+                    raise RaceConditionError(
+                        f"Project '{project.name}' was modified by another user",
+                        current_user=username,
+                        last_update_user=project.last_update_user,
+                        last_update_date=project.last_update_date,
+                        entity_type="project",
+                        entity_id=project_id
+                    )
+            
+            # Update fields
+            for key, value in update_data.items():
+                if hasattr(project, key) and key not in ['id', 'created_date', 'created_by']:
+                    setattr(project, key, value)
+            
+            project.last_update_date = datetime.utcnow().isoformat()
+            project.last_update_user = username
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "UPDATE_PROJECT",
+                "project", project.id, project.name
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "Project updated",
+                project_id=project.id,
+                user=username
+            )
+            
+            return project
+    
+    @classmethod
+    def delete_project(cls, project_id: int, username: str) -> None:
+        """Soft delete project"""
+        with cls._lock:
+            config = cls.get()
+            project = cls.get_project(project_id)
+            
+            if not project:
+                raise ResourceNotFoundError("project", project_id)
+            
+            project.deleted = True
+            project.last_update_date = datetime.utcnow().isoformat()
+            project.last_update_user = username
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "DELETE_PROJECT",
+                "project", project.id, project.name
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "Project deleted",
+                project_id=project.id,
+                user=username
+            )
+    
+    # ===================== Version Methods =====================
+    
+    @classmethod
+    def create_version(cls, project_id: int, version_data: dict, username: str) -> VersionConfig:
+        """Create new version"""
+        with cls._lock:
+            config = cls.get()
+            project = cls.get_project(project_id)
+            
+            if not project:
+                raise ResourceNotFoundError("project", project_id)
+            
+            # Create version
+            version = VersionConfig(
+                id=project.version_id_counter,
+                no=project.version_id_counter,
+                created_date=datetime.utcnow().isoformat(),
+                created_by=username,
+                **version_data
+            )
+            
+            # Update project
+            project.versions.append(version)
+            project.version_id_counter += 1
+            project.last_update_date = datetime.utcnow().isoformat()
+            project.last_update_user = username
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "CREATE_VERSION",
+                "version", version.id, f"{project.name} v{version.no}",
+                f"Project: {project.name}"
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "Version created",
+                project_id=project.id,
+                version_id=version.id,
+                user=username
+            )
+            
+            return version
+    
+    @classmethod
+    def publish_version(cls, project_id: int, version_id: int, username: str) -> VersionConfig:
+        """Publish a version"""
+        with cls._lock:
+            config = cls.get()
+            project = cls.get_project(project_id)
+            
+            if not project:
+                raise ResourceNotFoundError("project", project_id)
+            
+            version = next((v for v in project.versions if v.id == version_id), None)
+            if not version:
+                raise ResourceNotFoundError("version", version_id)
+            
+            # Unpublish other versions
+            for v in project.versions:
+                if v.published and v.id != version_id:
+                    v.published = False
+            
+            # Publish this version
+            version.published = True
+            version.publish_date = datetime.utcnow().isoformat()
+            version.published_by = username
+            
+            # Update project
+            project.last_update_date = datetime.utcnow().isoformat()
+            project.last_update_user = username
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "PUBLISH_VERSION",
+                "version", version.id, f"{project.name} v{version.no}",
+                f"Published version {version.no}"
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "Version published",
+                project_id=project.id,
+                version_id=version.id,
+                user=username
+            )
+            
+            return version
+    
+    # ===================== API Methods =====================
+    
+    @classmethod
+    def create_api(cls, api_data: dict, username: str) -> APIConfig:
+        """Create new API"""
+        with cls._lock:
+            config = cls.get()
+            
+            # Check for duplicate name
+            if any(a.name == api_data['name'] for a in config.apis):
+                raise DuplicateResourceError("api", api_data['name'])
+            
+            # Create API
+            api = APIConfig(
+                created_date=datetime.utcnow().isoformat(),
+                created_by=username,
+                **api_data
+            )
+            
+            # Add to config
+            config.apis.append(api)
+            
+            # Rebuild index
+            config.build_index()
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "CREATE_API",
+                "api", api.name, api.name
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "API created",
+                api_name=api.name,
+                user=username
+            )
+            
+            return api
+    
+    @classmethod
+    def update_api(cls, api_name: str, update_data: dict, username: str) -> APIConfig:
+        """Update API configuration"""
+        with cls._lock:
+            config = cls.get()
+            api = config.get_api(api_name)
+            
+            if not api:
+                raise ResourceNotFoundError("api", api_name)
+            
+            # Check race condition
+            if 'last_update_date' in update_data:
+                if api.last_update_date != update_data['last_update_date']:
+                    raise RaceConditionError(
+                        f"API '{api_name}' was modified by another user",
+                        current_user=username,
+                        last_update_user=api.last_update_user,
+                        last_update_date=api.last_update_date,
+                        entity_type="api",
+                        entity_id=api_name
+                    )
+            
+            # Update fields
+            for key, value in update_data.items():
+                if hasattr(api, key) and key not in ['name', 'created_date', 'created_by']:
+                    setattr(api, key, value)
+            
+            api.last_update_date = datetime.utcnow().isoformat()
+            api.last_update_user = username
+            
+            # Rebuild index
+            config.build_index()
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "UPDATE_API",
+                "api", api.name, api.name
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "API updated",
+                api_name=api.name,
+                user=username
+            )
+            
+            return api
+    
+    @classmethod
+    def delete_api(cls, api_name: str, username: str) -> None:
+        """Soft delete API"""
+        with cls._lock:
+            config = cls.get()
+            api = config.get_api(api_name)
+            
+            if not api:
+                raise ResourceNotFoundError("api", api_name)
+            
+            api.deleted = True
+            api.last_update_date = datetime.utcnow().isoformat()
+            api.last_update_user = username
+            
+            # Rebuild index
+            config.build_index()
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "DELETE_API",
+                "api", api.name, api.name
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "API deleted",
+                api_name=api.name,
+                user=username
+            )
+    
+    # ===================== Helper Methods =====================
+    
+    @classmethod
+    def _add_activity(
+        cls,
+        config: ServiceConfig,
+        username: str,
+        action: str,
+        entity_type: str,
+        entity_id: Any,
+        entity_name: Optional[str] = None,
+        details: Optional[str] = None
+    ) -> None:
+        """Add activity log entry"""
+        activity = ActivityLogEntry(
+            timestamp=datetime.utcnow().isoformat(),
+            username=username,
+            action=action,
+            entity_type=entity_type,
+            entity_id=str(entity_id) if entity_id else None,
+            entity_name=entity_name,
+            details=details
+        )
+        
+        config.activity_log.append(activity)
+        
+        # Keep only last 1000 entries
+        if len(config.activity_log) > 1000:
+            config.activity_log = config.activity_log[-1000:]

exceptions.py

@@ -0,0 +1,176 @@
+"""
+Custom Exception Classes for Flare Platform
+"""
+from typing import Optional, Dict, Any
+from datetime import datetime
+
+class FlareException(Exception):
+    """Base exception for all Flare errors"""
+    def __init__(self, message: str, details: Optional[Dict[str, Any]] = None):
+        super().__init__(message)
+        self.message = message
+        self.details = details or {}
+        self.timestamp = datetime.utcnow().isoformat()
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert exception to dictionary for API responses"""
+        return {
+            "error": self.__class__.__name__,
+            "message": self.message,
+            "details": self.details,
+            "timestamp": self.timestamp
+        }
+
+class RaceConditionError(FlareException):
+    """Raised when a race condition is detected during concurrent updates"""
+    def __init__(
+        self, 
+        message: str, 
+        current_user: Optional[str] = None,
+        last_update_user: Optional[str] = None,
+        last_update_date: Optional[str] = None,
+        entity_type: Optional[str] = None,
+        entity_id: Optional[Any] = None
+    ):
+        details = {
+            "current_user": current_user,
+            "last_update_user": last_update_user,
+            "last_update_date": last_update_date,
+            "entity_type": entity_type,
+            "entity_id": entity_id,
+            "action": "Please reload the data and try again"
+        }
+        super().__init__(message, details)
+        self.current_user = current_user
+        self.last_update_user = last_update_user
+        self.last_update_date = last_update_date
+
+class ConfigurationError(FlareException):
+    """Raised when there's a configuration issue"""
+    def __init__(self, message: str, config_key: Optional[str] = None):
+        details = {"config_key": config_key} if config_key else {}
+        super().__init__(message, details)
+
+class ValidationError(FlareException):
+    """Raised when validation fails"""
+    def __init__(self, message: str, field: Optional[str] = None, value: Any = None):
+        details = {}
+        if field:
+            details["field"] = field
+        if value is not None:
+            details["value"] = str(value)
+        super().__init__(message, details)
+
+class AuthenticationError(FlareException):
+    """Raised when authentication fails"""
+    def __init__(self, message: str = "Authentication failed"):
+        super().__init__(message)
+
+class AuthorizationError(FlareException):
+    """Raised when authorization fails"""
+    def __init__(self, message: str = "Insufficient permissions", required_permission: Optional[str] = None):
+        details = {"required_permission": required_permission} if required_permission else {}
+        super().__init__(message, details)
+
+class SessionError(FlareException):
+    """Raised when there's a session-related error"""
+    def __init__(self, message: str, session_id: Optional[str] = None):
+        details = {"session_id": session_id} if session_id else {}
+        super().__init__(message, details)
+
+class ProviderError(FlareException):
+    """Raised when a provider (LLM, TTS, STT) fails"""
+    def __init__(self, message: str, provider_type: str, provider_name: str, original_error: Optional[str] = None):
+        details = {
+            "provider_type": provider_type,
+            "provider_name": provider_name,
+            "original_error": original_error
+        }
+        super().__init__(message, details)
+
+class APICallError(FlareException):
+    """Raised when an external API call fails"""
+    def __init__(
+        self, 
+        message: str, 
+        api_name: str, 
+        status_code: Optional[int] = None,
+        response_body: Optional[str] = None
+    ):
+        details = {
+            "api_name": api_name,
+            "status_code": status_code,
+            "response_body": response_body
+        }
+        super().__init__(message, details)
+
+class WebSocketError(FlareException):
+    """Raised when WebSocket operations fail"""
+    def __init__(self, message: str, session_id: Optional[str] = None, state: Optional[str] = None):
+        details = {
+            "session_id": session_id,
+            "state": state
+        }
+        super().__init__(message, details)
+
+class ResourceNotFoundError(FlareException):
+    """Raised when a requested resource is not found"""
+    def __init__(self, resource_type: str, resource_id: Any):
+        message = f"{resource_type} not found: {resource_id}"
+        details = {
+            "resource_type": resource_type,
+            "resource_id": str(resource_id)
+        }
+        super().__init__(message, details)
+
+class DuplicateResourceError(FlareException):
+    """Raised when attempting to create a duplicate resource"""
+    def __init__(self, resource_type: str, identifier: str):
+        message = f"{resource_type} already exists: {identifier}"
+        details = {
+            "resource_type": resource_type,
+            "identifier": identifier
+        }
+        super().__init__(message, details)
+
+# Error response formatters
+def format_error_response(error: Exception, request_id: Optional[str] = None) -> Dict[str, Any]:
+    """Format any exception into a standardized error response"""
+    if isinstance(error, FlareException):
+        response = error.to_dict()
+    else:
+        # Generic error
+        response = {
+            "error": error.__class__.__name__,
+            "message": str(error),
+            "details": {},
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    
+    if request_id:
+        response["request_id"] = request_id
+    
+    return response
+
+def get_http_status_code(error: Exception) -> int:
+    """Get appropriate HTTP status code for an exception"""
+    status_map = {
+        ValidationError: 422,
+        AuthenticationError: 401,
+        AuthorizationError: 403,
+        ResourceNotFoundError: 404,
+        DuplicateResourceError: 409,
+        RaceConditionError: 409,
+        ConfigurationError: 500,
+        ProviderError: 503,
+        APICallError: 502,
+        WebSocketError: 500,
+        SessionError: 400
+    }
+    
+    for error_class, status_code in status_map.items():
+        if isinstance(error, error_class):
+            return status_code
+    
+    # Default to 500 for unknown errors
+    return 500

logger.py

@@ -0,0 +1,186 @@
+"""
+Centralized Logging System for Flare Platform
+"""
+import sys
+import logging
+import json
+import os
+import threading
+from datetime import datetime
+from enum import Enum
+from typing import Optional, Dict, Any
+from pathlib import Path
+
+class LogLevel(Enum):
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+class FlareLogger:
+    _instance = None
+    _lock = threading.Lock()
+    
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self):
+        if self._initialized:
+            return
+            
+        self._initialized = True
+        
+        # Log level from environment
+        self.log_level = LogLevel[os.getenv('LOG_LEVEL', 'INFO')]
+        
+        # Configure Python logging
+        self.logger = logging.getLogger('flare')
+        self.logger.setLevel(self.log_level.value)
+        
+        # Remove default handlers
+        self.logger.handlers = []
+        
+        # Console handler with custom format
+        console_handler = logging.StreamHandler(sys.stdout)
+        console_handler.setFormatter(self._get_formatter())
+        self.logger.addHandler(console_handler)
+        
+        # File handler for production
+        if os.getenv('LOG_TO_FILE', 'false').lower() == 'true':
+            log_dir = Path('logs')
+            log_dir.mkdir(exist_ok=True)
+            file_handler = logging.FileHandler(
+                log_dir / f"flare_{datetime.now().strftime('%Y%m%d')}.log"
+            )
+            file_handler.setFormatter(self._get_formatter())
+            self.logger.addHandler(file_handler)
+        
+        # Future: Add ElasticSearch handler here
+        # if os.getenv('ELASTICSEARCH_URL'):
+        #     from elasticsearch_handler import ElasticsearchHandler
+        #     es_handler = ElasticsearchHandler(
+        #         hosts=[os.getenv('ELASTICSEARCH_URL')],
+        #         index='flare-logs'
+        #     )
+        #     self.logger.addHandler(es_handler)
+    
+    def _get_formatter(self):
+        return logging.Formatter(
+            '[%(asctime)s.%(msecs)03d] [%(levelname)s] [%(name)s] %(message)s',
+            datefmt='%H:%M:%S'
+        )
+    
+    def log(self, level: LogLevel, message: str, **kwargs):
+        """Central logging method with structured data"""
+        # Add context data
+        extra_data = {
+            'timestamp': datetime.utcnow().isoformat(),
+            'service': 'flare',
+            'thread_id': threading.get_ident(),
+            **kwargs
+        }
+        
+        # Log with structured data
+        log_message = message
+        if kwargs:
+            # Format kwargs for readability
+            kwargs_str = json.dumps(kwargs, ensure_ascii=False, default=str)
+            log_message = f"{message} | {kwargs_str}"
+        
+        getattr(self.logger, level.value.lower())(log_message, extra={'data': extra_data})
+        
+        # Always flush for real-time debugging
+        sys.stdout.flush()
+    
+    def debug(self, message: str, **kwargs):
+        """Log debug message"""
+        self.log(LogLevel.DEBUG, message, **kwargs)
+    
+    def info(self, message: str, **kwargs):
+        """Log info message"""
+        self.log(LogLevel.INFO, message, **kwargs)
+    
+    def warning(self, message: str, **kwargs):
+        """Log warning message"""
+        self.log(LogLevel.WARNING, message, **kwargs)
+    
+    def error(self, message: str, **kwargs):
+        """Log error message"""
+        self.log(LogLevel.ERROR, message, **kwargs)
+    
+    def critical(self, message: str, **kwargs):
+        """Log critical message"""
+        self.log(LogLevel.CRITICAL, message, **kwargs)
+    
+    def set_level(self, level: str):
+        """Dynamically change log level"""
+        try:
+            self.log_level = LogLevel[level.upper()]
+            self.logger.setLevel(self.log_level.value)
+            self.info(f"Log level changed to {level}")
+        except KeyError:
+            self.warning(f"Invalid log level: {level}")
+
+# Global logger instance
+logger = FlareLogger()
+
+# Convenience functions
+def log_debug(message: str, **kwargs):
+    """Log debug message"""
+    logger.debug(message, **kwargs)
+
+def log_info(message: str, **kwargs):
+    """Log info message"""
+    logger.info(message, **kwargs)
+
+def log_warning(message: str, **kwargs):
+    """Log warning message"""
+    logger.warning(message, **kwargs)
+
+def log_error(message: str, **kwargs):
+    """Log error message"""
+    logger.error(message, **kwargs)
+
+def log_critical(message: str, **kwargs):
+    """Log critical message"""
+    logger.critical(message, **kwargs)
+
+# Backward compatibility
+def log(message: str, level: str = "INFO", **kwargs):
+    """Legacy log function for compatibility"""
+    getattr(logger, level.lower())(message, **kwargs)
+
+# Performance logging helpers
+class LogTimer:
+    """Context manager for timing operations"""
+    def __init__(self, operation_name: str, **extra_kwargs):
+        self.operation_name = operation_name
+        self.extra_kwargs = extra_kwargs
+        self.start_time = None
+    
+    def __enter__(self):
+        self.start_time = datetime.now()
+        log_debug(f"Starting {self.operation_name}", **self.extra_kwargs)
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        duration_ms = (datetime.now() - self.start_time).total_seconds() * 1000
+        if exc_type:
+            log_error(
+                f"{self.operation_name} failed after {duration_ms:.2f}ms",
+                error=str(exc_val),
+                duration_ms=duration_ms,
+                **self.extra_kwargs
+            )
+        else:
+            log_info(
+                f"{self.operation_name} completed in {duration_ms:.2f}ms",
+                duration_ms=duration_ms,
+                **self.extra_kwargs
+            )

session.py

@@ -1,169 +1,313 @@
 """
-Flare – Session Management
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-• thread-safe SessionStore
-• state-machine alanları
+Optimized Session Management for Flare Platform
 """
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+import json
+import secrets
+import hashlib
+import time
 
-from __future__ import annotations
-import threading, uuid, time
-from datetime import datetime, timedelta
-from typing import Dict, List
-from utils import log
+from config_models import VersionConfig, IntentConfig
+from logger import log_debug, log_info
 
+@dataclass
 class Session:
-    """Single chat session."""
-
-    def __init__(self, project_name: str, version_config=None):
-        self.session_id: str = str(uuid.uuid4())
-        self.project_name: str = project_name
-        self.version_number: int = version_config.id if version_config else None
-        self.version_config = version_config  # Version config'i sakla
+    """Optimized session for future Redis storage"""
+    
+    # Core identifiers
+    session_id: str
+    project_name: str
+    version_number: int
+    
+    # State management - string for better debugging
+    state: str = "idle"  # idle | collect_params | call_api | humanize
+    
+    # Minimal stored data
+    current_intent: Optional[str] = None
+    variables: Dict[str, str] = field(default_factory=dict)
+    project_id: Optional[int] = None
+    version_id: Optional[int] = None
+    
+    # Chat history - limited to recent messages
+    chat_history: List[Dict[str, str]] = field(default_factory=list)
+    
+    # Metadata
+    created_at: str = field(default_factory=lambda: datetime.utcnow().isoformat())
+    last_activity: str = field(default_factory=lambda: datetime.utcnow().isoformat())
+    
+    # Parameter collection state
+    awaiting_parameters: List[str] = field(default_factory=list)
+    asked_parameters: Dict[str, int] = field(default_factory=dict)
+    unanswered_parameters: List[str] = field(default_factory=list)
+    parameter_ask_rounds: int = 0
+    
+    # Real-time support
+    is_realtime_session: bool = False
+    
+    # Transient data (not serialized to Redis)
+    _version_config: Optional[VersionConfig] = field(default=None, init=False, repr=False)
+    _intent_config: Optional[IntentConfig] = field(default=None, init=False, repr=False)
+    _auth_tokens: Dict[str, Dict] = field(default_factory=dict, init=False, repr=False)
+    
+    # Constants
+    MAX_CHAT_HISTORY: int = field(default=20, init=False, repr=False)
+    
+    def add_message(self, role: str, content: str) -> None:
+        """Add message to chat history with size limit"""
+        message = {
+            "role": role,
+            "content": content,
+            "timestamp": datetime.utcnow().isoformat()
+        }
         
-        # flow state
-        self.state: str = "idle"                   # idle | await_param | call_api | humanize
-        self.last_intent: str | None = None
-        self.awaiting_parameters: List[str] = []
-        self.missing_ask_count: int = 0
-
-        # data
-        self.variables: Dict[str, str] = {}
-        self.auth_tokens: Dict[str, Dict] = {}     # api_name -> {token, expiry}
-
-        # history
-        self.chat_history: List[Dict[str, str]] = []
-
-        # smart parameter collection tracking
-        self.asked_parameters: Dict[str, int] = {}  # parametre_adı -> kaç_kez_soruldu
-        self.unanswered_parameters: List[str] = []  # sorulduğu halde cevaplanmayan parametreler
-        self.parameter_ask_rounds: int = 0          # toplam kaç tur soru soruldu
-
-        self.created_at: datetime = datetime.now()
-        self.last_activity: datetime = datetime.now()
-
-        # Real-time conversation tracking
-        self.is_realtime_session: bool = False
-        self.active_websocket = None
-        self.current_audio_buffer = []
-        self.last_audio_timestamp: Optional[datetime] = None
-
-    def mark_as_realtime(self):
-        """Mark session as real-time (WebSocket-based)"""
-        self.is_realtime_session = True
-        self.last_audio_timestamp = datetime.now()
+        self.chat_history.append(message)
         
-    def update_audio_timestamp(self):
-        """Update last audio activity timestamp"""
-        self.last_audio_timestamp = datetime.now()
-        self.update_activity()
+        # Keep only recent messages
+        if len(self.chat_history) > self.MAX_CHAT_HISTORY:
+            self.chat_history = self.chat_history[-self.MAX_CHAT_HISTORY:]
         
-    def get_version_config(self):
-        """Get stored version config"""
-        return self.version_config
+        # Update activity
+        self.last_activity = datetime.utcnow().isoformat()
         
-    def update_activity(self):
-        """Update last activity timestamp"""
-        self.last_activity = datetime.now()
+        log_debug(
+            f"Message added to session",
+            session_id=self.session_id,
+            role=role,
+            history_size=len(self.chat_history)
+        )
+    
+    def add_turn(self, role: str, content: str) -> None:
+        """Alias for add_message for compatibility"""
+        self.add_message(role, content)
+    
+    def set_version_config(self, config: VersionConfig) -> None:
+        """Set transient version config"""
+        self._version_config = config
+        self.version_id = config.id if config else None
+    
+    def get_version_config(self) -> Optional[VersionConfig]:
+        """Get transient version config"""
+        return self._version_config
+    
+    def set_intent_config(self, config: IntentConfig) -> None:
+        """Set current intent config"""
+        self._intent_config = config
+        self.current_intent = config.name if config else None
+    
+    def get_intent_config(self) -> Optional[IntentConfig]:
+        """Get current intent config"""
+        return self._intent_config
+    
+    def reset_flow(self) -> None:
+        """Reset conversation flow to idle"""
+        self.state = "idle"
+        self.current_intent = None
+        self._intent_config = None
+        self.awaiting_parameters = []
+        self.asked_parameters = {}
+        self.unanswered_parameters = []
+        self.parameter_ask_rounds = 0
+        
+        log_debug(
+            f"Session flow reset",
+            session_id=self.session_id
+        )
+    
+    def to_redis(self) -> str:
+        """Serialize for Redis storage"""
+        data = {
+            'session_id': self.session_id,
+            'project_name': self.project_name,
+            'version_number': self.version_number,
+            'state': self.state,
+            'current_intent': self.current_intent,
+            'variables': self.variables,
+            'project_id': self.project_id,
+            'version_id': self.version_id,
+            'chat_history': self.chat_history[-self.MAX_CHAT_HISTORY:],
+            'created_at': self.created_at,
+            'last_activity': self.last_activity,
+            'awaiting_parameters': self.awaiting_parameters,
+            'asked_parameters': self.asked_parameters,
+            'unanswered_parameters': self.unanswered_parameters,
+            'parameter_ask_rounds': self.parameter_ask_rounds,
+            'is_realtime_session': self.is_realtime_session
+        }
+        return json.dumps(data, ensure_ascii=False)
+    
+    @classmethod
+    def from_redis(cls, data: str) -> 'Session':
+        """Deserialize from Redis"""
+        obj = json.loads(data)
+        return cls(**obj)
+    
+    def get_state_info(self) -> dict:
+        """Get debug info about current state"""
+        return {
+            'state': self.state,
+            'intent': self.current_intent,
+            'variables': list(self.variables.keys()),
+            'history_length': len(self.chat_history),
+            'awaiting_params': self.awaiting_parameters,
+            'last_activity': self.last_activity
+        }
+    
+    def get_auth_token(self, api_name: str) -> Optional[Dict]:
+        """Get cached auth token for API"""
+        return self._auth_tokens.get(api_name)
+    
+    def set_auth_token(self, api_name: str, token_data: Dict) -> None:
+        """Cache auth token for API"""
+        self._auth_tokens[api_name] = token_data
+    
+    def is_expired(self, timeout_minutes: int = 30) -> bool:
+        """Check if session is expired"""
+        last_activity_time = datetime.fromisoformat(self.last_activity.replace('Z', '+00:00'))
+        current_time = datetime.utcnow()
+        elapsed_minutes = (current_time - last_activity_time).total_seconds() / 60
+        return elapsed_minutes > timeout_minutes
 
-    # -------- helper ----------
-    def add_turn(self, role: str, content: str):
-        self.chat_history.append({"role": role, "content": content})
-        self.update_activity()  # Activity güncellemesi eklendi
-        if len(self.chat_history) > 20:
-            self.chat_history.pop(0)
 
-    # -------- reset flow ------
-    def reset_flow(self):
-        self.state = "idle"
-        self.last_intent = None
-        self.awaiting_parameters.clear()
-        self.missing_ask_count = 0
-        # Smart collection tracking'i reset etme, 
-        # çünkü aynı session'da başka intent için kullanılabilir
+def generate_secure_session_id() -> str:
+    """Generate cryptographically secure session ID"""
+    # Use secrets for secure random generation
+    random_bytes = secrets.token_bytes(32)
+    
+    # Add timestamp for uniqueness
+    timestamp = str(int(time.time() * 1000000))
+    
+    # Combine and hash
+    combined = random_bytes + timestamp.encode()
+    session_id = hashlib.sha256(combined).hexdigest()
+    
+    return f"session_{session_id[:32]}"
 
-    # -------- smart parameter collection methods ------
-    def record_parameter_question(self, param_names: List[str]):
-        """Sorulan parametreleri kaydet"""
-        self.parameter_ask_rounds += 1
-        log(f"📝 Recording parameter question round {self.parameter_ask_rounds} for: {param_names}")
-        
-        for param in param_names:
-            self.asked_parameters[param] = self.asked_parameters.get(param, 0) + 1
-            log(f"   - {param} asked {self.asked_parameters[param]} time(s)")
-    
-    def mark_parameters_unanswered(self, param_names: List[str]):
-        """Cevaplanmayan parametreleri işaretle"""
-        for param in param_names:
-            if param not in self.unanswered_parameters:
-                self.unanswered_parameters.append(param)
-                log(f"❓ Parameter marked as unanswered: {param}")
-    
-    def mark_parameter_answered(self, param_name: str):
-        """Parametre cevaplandığında işareti kaldır"""
-        if param_name in self.unanswered_parameters:
-            self.unanswered_parameters.remove(param_name)
-            log(f"✅ Parameter marked as answered: {param_name}")
-    
-    def get_parameter_ask_count(self, param_name: str) -> int:
-        """Bir parametrenin kaç kez sorulduğunu döndür"""
-        return self.asked_parameters.get(param_name, 0)
-    
-    def reset_parameter_tracking(self):
-        """Parametre takibini sıfırla (yeni intent için)"""
-        self.asked_parameters.clear()
-        self.unanswered_parameters.clear()
-        self.parameter_ask_rounds = 0
-        log("🔄 Parameter tracking reset for new intent")
 
 class SessionStore:
-    """Thread-safe global store."""
-
+    """In-memory session store (to be replaced with Redis)"""
+    
     def __init__(self):
-        self._lock = threading.Lock()
         self._sessions: Dict[str, Session] = {}
-
-    def create_session(self, project_name: str, version_config=None) -> Session:
+        self._lock = threading.Lock()
+        
+    def create_session(
+        self,
+        project_name: str,
+        version_number: int,
+        is_realtime: bool = False
+    ) -> Session:
+        """Create new session"""
+        session_id = generate_secure_session_id()
+        
+        session = Session(
+            session_id=session_id,
+            project_name=project_name,
+            version_number=version_number,
+            is_realtime_session=is_realtime
+        )
+        
         with self._lock:
-            s = Session(project_name, version_config)
-            self._sessions[s.session_id] = s
-            log(f"🆕 Session created {s.session_id} with project {project_name} version {s.version_number}")
-            return s
-
-    def get_session(self, sid: str) -> Session | None:
+            self._sessions[session_id] = session
+        
+        log_info(
+            "Session created",
+            session_id=session_id,
+            project=project_name,
+            version=version_number,
+            is_realtime=is_realtime
+        )
+        
+        return session
+    
+    def get_session(self, session_id: str) -> Optional[Session]:
+        """Get session by ID"""
         with self._lock:
-            return self._sessions.get(sid)
-
-    def __contains__(self, sid: str) -> bool:
-        return self.get_session(sid) is not None
-
-    def cleanup_expired_sessions(self, timeout_minutes: int = 30):
-        """Remove expired sessions"""
+            session = self._sessions.get(session_id)
+            
+        if session and session.is_expired():
+            log_info(f"Session expired", session_id=session_id)
+            self.delete_session(session_id)
+            return None
+            
+        return session
+    
+    def update_session(self, session: Session) -> None:
+        """Update session in store"""
+        session.last_activity = datetime.utcnow().isoformat()
+        
+        with self._lock:
+            self._sessions[session.session_id] = session
+    
+    def delete_session(self, session_id: str) -> None:
+        """Delete session"""
         with self._lock:
-            now = datetime.now()
-            expired = []
-            for sid, session in self._sessions.items():
-                if (now - session.last_activity).total_seconds() > timeout_minutes * 60:
-                    expired.append(sid)
+            if session_id in self._sessions:
+                del self._sessions[session_id]
+                log_info(f"Session deleted", session_id=session_id)
+    
+    def cleanup_expired_sessions(self, timeout_minutes: int = 30) -> int:
+        """Clean up expired sessions"""
+        expired_count = 0
+        
+        with self._lock:
+            expired_ids = [
+                sid for sid, session in self._sessions.items()
+                if session.is_expired(timeout_minutes)
+            ]
             
-            for sid in expired:
-                del self._sessions[sid]
-                log(f"🗑️ Expired session removed: {sid[:8]}...")
+            for session_id in expired_ids:
+                del self._sessions[session_id]
+                expired_count += 1
+        
+        if expired_count > 0:
+            log_info(
+                f"Cleaned up expired sessions",
+                count=expired_count
+            )
+        
+        return expired_count
+    
+    def get_active_session_count(self) -> int:
+        """Get count of active sessions"""
+        with self._lock:
+            return len(self._sessions)
+    
+    def get_session_stats(self) -> Dict[str, Any]:
+        """Get session statistics"""
+        with self._lock:
+            realtime_count = sum(
+                1 for s in self._sessions.values() 
+                if s.is_realtime_session
+            )
             
-            if expired:
-                log(f"📊 Active sessions: {len(self._sessions)}")
+            return {
+                'total_sessions': len(self._sessions),
+                'realtime_sessions': realtime_count,
+                'regular_sessions': len(self._sessions) - realtime_count
+            }
+
 
+# Global session store instance
+import threading
 session_store = SessionStore()
 
-# Cleanup thread başlat
-def start_session_cleanup():
-    def cleanup_loop():
+# Session cleanup task
+def start_session_cleanup(interval_minutes: int = 5, timeout_minutes: int = 30):
+    """Start background task to clean up expired sessions"""
+    import asyncio
+    
+    async def cleanup_task():
         while True:
             try:
-                session_store.cleanup_expired_sessions()
+                expired = session_store.cleanup_expired_sessions(timeout_minutes)
+                if expired > 0:
+                    log_info(f"Session cleanup completed", expired=expired)
             except Exception as e:
-                log(f"❌ Session cleanup error: {e}")
-            time.sleep(300)  # 5 dakikada bir
+                log_error(f"Session cleanup error", error=str(e))
+            
+            await asyncio.sleep(interval_minutes * 60)
     
-    thread = threading.Thread(target=cleanup_loop, daemon=True)
-    thread.start()
-    log("🧹 Session cleanup thread started")
+    # Run in background
+    asyncio.create_task(cleanup_task())