trovesuite 1.0.0__py3-none-any.whl

trovesuite/configs/logging.py

@@ -0,0 +1,261 @@
+import logging
+import logging.config
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Any
+import json
+from .settings import db_settings
+
+
+class ColoredFormatter(logging.Formatter):
+    """Custom formatter with colors for different log levels"""
+    
+    # Color codes
+    COLORS = {
+        'DEBUG': '\033[36m',     # Cyan
+        'INFO': '\033[32m',      # Green
+        'WARNING': '\033[33m',   # Yellow
+        'ERROR': '\033[31m',     # Red
+        'CRITICAL': '\033[35m',  # Magenta
+        'RESET': '\033[0m'       # Reset
+    }
+    
+    def format(self, record):
+        log_color = self.COLORS.get(record.levelname, self.COLORS['RESET'])
+        reset_color = self.COLORS['RESET']
+        
+        # Add color to level name
+        record.levelname = f"{log_color}{record.levelname}{reset_color}"
+        
+        return super().format(record)
+
+
+class JSONFormatter(logging.Formatter):
+    """Custom JSON formatter for structured logging"""
+    
+    def format(self, record):
+        log_entry = {
+            'timestamp': datetime.fromtimestamp(record.created).isoformat(),
+            'level': record.levelname,
+            'logger': record.name,
+            'message': record.getMessage(),
+            'module': record.module,
+            'function': record.funcName,
+            'line': record.lineno,
+            'thread': record.thread,
+            'process': record.process
+        }
+        
+        # Add exception info if present
+        if record.exc_info:
+            log_entry['exception'] = self.formatException(record.exc_info)
+            
+        # Add extra fields if present
+        if hasattr(record, 'extra_fields'):
+            log_entry.update(record.extra_fields)
+            
+        return json.dumps(log_entry, ensure_ascii=False)
+
+
+class LoggingConfig:
+    """Centralized logging configuration for the application"""
+    
+    def __init__(self):
+        self.settings = db_settings
+        self.log_level = self._get_log_level()
+        self.log_dir = self._setup_log_directory()
+        
+    def _get_log_level(self) -> str:
+        """Get log level from environment or settings"""
+        env_level = os.getenv("LOG_LEVEL", "INFO").upper()
+        if db_settings.DEBUG:
+            return "DEBUG"
+        return env_level
+    
+    def _setup_log_directory(self) -> Path:
+        """Create and return log directory path"""
+        log_dir = Path("logs")
+        log_dir.mkdir(exist_ok=True)
+        return log_dir
+    
+    def get_logging_config(self) -> Dict[str, Any]:
+        """Return complete logging configuration dictionary"""
+        return {
+            'version': 1,
+            'disable_existing_loggers': False,
+            'formatters': {
+                'detailed': {
+                    'format': '%(asctime)s | %(levelname)-8s | %(name)s | %(module)s.%(funcName)s:%(lineno)d | %(message)s',
+                    'datefmt': '%Y-%m-%d %H:%M:%S'
+                },
+                'colored': {
+                    '()': ColoredFormatter,
+                    'format': '%(asctime)s | %(levelname)-8s | %(name)s | %(module)s.%(funcName)s:%(lineno)d | %(message)s',
+                    'datefmt': '%Y-%m-%d %H:%M:%S'
+                },
+                'json': {
+                    '()': JSONFormatter
+                },
+                'simple': {
+                    'format': '%(levelname)-8s | %(name)s | %(message)s'
+                }
+            },
+            'handlers': {
+                'console': {
+                    'class': 'logging.StreamHandler',
+                    'level': self.log_level,
+                    'formatter': 'colored' if sys.stdout.isatty() else 'detailed',
+                    'stream': 'ext://sys.stdout'
+                },
+                'file_info': {
+                    'class': 'logging.handlers.RotatingFileHandler',
+                    'level': 'INFO',
+                    'formatter': 'detailed',
+                    'filename': str(self.log_dir / 'app.log'),
+                    'maxBytes': 10485760,  # 10MB
+                    'backupCount': 5,
+                    'encoding': 'utf8'
+                },
+                'file_error': {
+                    'class': 'logging.handlers.RotatingFileHandler',
+                    'level': 'ERROR',
+                    'formatter': 'detailed',
+                    'filename': str(self.log_dir / 'error.log'),
+                    'maxBytes': 10485760,  # 10MB
+                    'backupCount': 5,
+                    'encoding': 'utf8'
+                },
+                'file_debug': {
+                    'class': 'logging.handlers.RotatingFileHandler',
+                    'level': 'DEBUG',
+                    'formatter': 'json',
+                    'filename': str(self.log_dir / 'debug.log'),
+                    'maxBytes': 10485760,  # 10MB
+                    'backupCount': 3,
+                    'encoding': 'utf8'
+                }
+            },
+            'loggers': {
+                '': {  # Root logger
+                    'level': self.log_level,
+                    'handlers': ['console', 'file_info', 'file_error'],
+                    'propagate': False
+                },
+                'app': {
+                    'level': self.log_level,
+                    'handlers': ['console', 'file_info', 'file_error', 'file_debug'],
+                    'propagate': False
+                },
+                'uvicorn': {
+                    'level': 'INFO',
+                    'handlers': ['console', 'file_info'],
+                    'propagate': False
+                },
+                'uvicorn.access': {
+                    'level': 'INFO',
+                    'handlers': ['console', 'file_info'],
+                    'propagate': False
+                },
+                'fastapi': {
+                    'level': 'INFO',
+                    'handlers': ['console', 'file_info'],
+                    'propagate': False
+                },
+                'sqlalchemy': {
+                    'level': 'WARNING',
+                    'handlers': ['console', 'file_info'],
+                    'propagate': False
+                },
+                'psycopg2': {
+                    'level': 'WARNING',
+                    'handlers': ['console', 'file_info'],
+                    'propagate': False
+                }
+            }
+        }
+
+
+def setup_logging() -> logging.Logger:
+    """Initialize and configure logging for the application"""
+    config = LoggingConfig()
+    logging_config = config.get_logging_config()
+    
+    # Apply the configuration
+    logging.config.dictConfig(logging_config)
+    
+    # Get the main application logger
+    logger = logging.getLogger('app')
+    
+    # Log the configuration
+    logger.info(f"Logging initialized with level: {config.log_level}")
+    logger.info(f"Log directory: {config.log_dir}")
+    logger.info(f"Environment: {config.settings.ENVIRONMENT}")
+    logger.info(f"Debug mode: {config.settings.DEBUG}")
+    
+    return logger
+
+
+def get_logger(name: str = None) -> logging.Logger:
+    """Get a logger instance for the given name"""
+    if name is None:
+        return logging.getLogger('app')
+    return logging.getLogger(f'app.{name}')
+
+
+class LoggerMixin:
+    """Mixin class to add logging capabilities to any class"""
+    
+    @property
+    def logger(self) -> logging.Logger:
+        """Get logger for this class"""
+        return get_logger(self.__class__.__name__)
+
+
+def log_function_call(func):
+    """Decorator to log function calls with parameters and execution time"""
+    def wrapper(*args, **kwargs):
+        logger = get_logger(func.__module__)
+        
+        # Log function entry
+        logger.debug(f"Calling {func.__name__} with args={args}, kwargs={kwargs}")
+        
+        start_time = datetime.now()
+        try:
+            result = func(*args, **kwargs)
+            execution_time = (datetime.now() - start_time).total_seconds()
+            logger.debug(f"Function {func.__name__} completed successfully in {execution_time:.4f}s")
+            return result
+        except Exception as e:
+            execution_time = (datetime.now() - start_time).total_seconds()
+            logger.error(f"Function {func.__name__} failed after {execution_time:.4f}s: {str(e)}", exc_info=True)
+            raise
+    
+    return wrapper
+
+
+def log_async_function_call(func):
+    """Decorator to log async function calls with parameters and execution time"""
+    async def wrapper(*args, **kwargs):
+        logger = get_logger(func.__module__)
+        
+        # Log function entry
+        logger.debug(f"Calling async {func.__name__} with args={args}, kwargs={kwargs}")
+        
+        start_time = datetime.now()
+        try:
+            result = await func(*args, **kwargs)
+            execution_time = (datetime.now() - start_time).total_seconds()
+            logger.debug(f"Async function {func.__name__} completed successfully in {execution_time:.4f}s")
+            return result
+        except Exception as e:
+            execution_time = (datetime.now() - start_time).total_seconds()
+            logger.error(f"Async function {func.__name__} failed after {execution_time:.4f}s: {str(e)}", exc_info=True)
+            raise
+    
+    return wrapper
+
+
+# Initialize logging when this module is imported
+main_logger = setup_logging()

trovesuite/configs/settings.py

@@ -0,0 +1,153 @@
+import os
+import warnings
+from typing import Optional
+
+class Settings:
+    """Settings configuration for TroveSuite Auth Service"""
+
+    # =============================================================================
+    # DATABASE CONFIGURATION
+    # =============================================================================
+    DATABASE_URL: str = os.getenv(
+        "DATABASE_URL", 
+        "postgresql://username:password@localhost:5432/database_name"
+    )
+
+    # Alternative database configuration
+    DB_USER: Optional[str] = os.getenv("DB_USER")
+    DB_HOST: Optional[str] = os.getenv("DB_HOST")
+    DB_NAME: Optional[str] = os.getenv("DB_NAME")
+    DB_PORT: int = int(os.getenv("DB_PORT", "5432"))
+    DB_PASSWORD: Optional[str] = os.getenv("DB_PASSWORD")
+    ENVIRONMENT: str = os.getenv("ENVIRONMENT", "development")
+
+    # =============================================================================
+    # APPLICATION SETTINGS
+    # =============================================================================
+    APP_NAME: str = os.getenv("APP_NAME", "TroveSuite Auth Service")
+    DEBUG: bool = os.getenv("DEBUG", "False").lower() == "true"
+    
+    # =============================================================================
+    # SECURITY SETTINGS
+    # =============================================================================
+    ALGORITHM: str = os.getenv("ALGORITHM", "HS256")
+    SECRET_KEY: str = os.getenv("SECRET_KEY", "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7")
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = int(os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES", "60"))
+    
+    # =============================================================================
+    # LOGGING SETTINGS
+    # =============================================================================
+    LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
+    LOG_FORMAT: str = os.getenv("LOG_FORMAT", "detailed")  # detailed, json, simple
+    LOG_TO_FILE: bool = os.getenv("LOG_TO_FILE", "False").lower() == "false"
+    LOG_MAX_SIZE: int = int(os.getenv("LOG_MAX_SIZE", "10485760"))  # 10MB
+    LOG_BACKUP_COUNT: int = int(os.getenv("LOG_BACKUP_COUNT", "5"))
+    LOG_DIR: str = os.getenv("LOG_DIR", "logs")
+
+    # =============================================================================
+    # DATABASE TABLE NAMES
+    # =============================================================================
+    # Main schema tables
+    MAIN_TENANTS_TABLE: str = os.getenv("MAIN_TENANTS_TABLE", "tenants")
+    ROLE_PERMISSIONS_TABLE: str = os.getenv("ROLE_PERMISSIONS_TABLE", "role_permissions")
+    
+    # Tenant-specific tables (used in queries with tenant schema)
+    TENANT_LOGIN_SETTINGS_TABLE: str = os.getenv("TENANT_LOGIN_SETTINGS_TABLE", "login_settings")
+    USER_GROUPS_TABLE: str = os.getenv("USER_GROUPS_TABLE", "user_groups")
+    ASSIGN_ROLES_TABLE: str = os.getenv("ASSIGN_ROLES_TABLE", "assign_roles")
+
+    # =============================================================================
+    # AZURE CONFIGURATION (Optional - for queue functionality)
+    # =============================================================================
+    STORAGE_ACCOUNT_NAME: str = os.getenv("STORAGE_ACCOUNT_NAME", "")
+    USER_ASSIGNED_MANAGED_IDENTITY: str = os.getenv("USER_ASSIGNED_MANAGED_IDENTITY", "")
+    
+    @property
+    def database_url(self) -> str:
+        """Get the database URL, either from DATABASE_URL or constructed from individual components"""
+        if self.DATABASE_URL != "postgresql://username:password@localhost:5432/database_name":
+            return self.DATABASE_URL
+        
+        # Validate individual components
+        if not all([self.DB_USER, self.DB_HOST, self.DB_NAME, self.DB_PASSWORD]):
+            missing = []
+            if not self.DB_USER:
+                missing.append("DB_USER")
+            if not self.DB_HOST:
+                missing.append("DB_HOST")
+            if not self.DB_NAME:
+                missing.append("DB_NAME")
+            if not self.DB_PASSWORD:
+                missing.append("DB_PASSWORD")
+            
+            raise ValueError(
+                f"Database configuration incomplete. Missing environment variables: {', '.join(missing)}. "
+                f"Please set these variables or provide a complete DATABASE_URL."
+            )
+        
+        return f"postgresql://{self.DB_USER}:{self.DB_PASSWORD}@{self.DB_HOST}:{self.DB_PORT}/{self.DB_NAME}"
+    
+    def validate_configuration(self) -> None:
+        """Validate the current configuration and warn about potential issues"""
+        warnings_list = []
+        
+        # Check for default secret key
+        if self.SECRET_KEY == "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7":
+            warnings_list.append(
+                "SECRET_KEY is using the default value. This is insecure for production. "
+                "Please set a strong, unique SECRET_KEY environment variable."
+            )
+        
+        # Check for development environment in production-like settings
+        if self.ENVIRONMENT == "development" and self.DEBUG is False:
+            warnings_list.append(
+                "ENVIRONMENT is set to 'development' but DEBUG is False. "
+                "Consider setting ENVIRONMENT to 'production' for production deployments."
+            )
+        
+        # Check database configuration
+        try:
+            self.database_url
+        except ValueError as e:
+            warnings_list.append(f"Database configuration issue: {str(e)}")
+        
+        # Check for missing Azure configuration if needed
+        if self.ENVIRONMENT == "production" and not self.STORAGE_ACCOUNT_NAME:
+            warnings_list.append(
+                "STORAGE_ACCOUNT_NAME is not set. Azure queue functionality may not work properly."
+            )
+        
+        # Emit warnings
+        for warning in warnings_list:
+            warnings.warn(warning, UserWarning)
+    
+    def get_configuration_summary(self) -> dict:
+        """Get a summary of the current configuration (excluding sensitive data)"""
+        return {
+            "app_name": self.APP_NAME,
+            "environment": self.ENVIRONMENT,
+            "debug": self.DEBUG,
+            "database_host": self.DB_HOST,
+            "database_port": self.DB_PORT,
+            "database_name": self.DB_NAME,
+            "database_user": self.DB_USER,
+            "log_level": self.LOG_LEVEL,
+            "log_format": self.LOG_FORMAT,
+            "log_to_file": self.LOG_TO_FILE,
+            "algorithm": self.ALGORITHM,
+            "access_token_expire_minutes": self.ACCESS_TOKEN_EXPIRE_MINUTES,
+            "MAIN_TENANTS_TABLE": self.MAIN_TENANTS_TABLE,
+            "role_permissions_table": self.ROLE_PERMISSIONS_TABLE,
+            "TENANT_LOGIN_SETTINGS_TABLE": self.TENANT_LOGIN_SETTINGS_TABLE,
+            "user_groups_table": self.USER_GROUPS_TABLE,
+            "assign_roles_table": self.ASSIGN_ROLES_TABLE,
+        }
+
+# Global settings instance
+db_settings = Settings()
+
+# Validate configuration on import
+try:
+    db_settings.validate_configuration()
+except Exception as e:
+    warnings.warn("Configuration validation failed: %s", str(e), UserWarning)

trovesuite/entities/__init__.py

@@ -0,0 +1,11 @@
+"""
+TroveSuite Entities Module
+
+Shared entities and response models for TroveSuite services.
+"""
+
+from .sh_response import Respons
+
+__all__ = [
+    "Respons"
+]

trovesuite/entities/health.py

@@ -0,0 +1,84 @@
+from fastapi import APIRouter
+from src.entities.shared.shared_response import Respons
+from src.configs.settings import db_settings
+from src.configs.database import DatabaseManager
+from src.configs.logging import get_logger
+
+health_check_router = APIRouter(tags=["Health Path"])
+logger = get_logger("health")
+
+@health_check_router.get("/health", response_model=Respons[dict])
+async def health():
+    """Health check endpoint."""
+    try:
+        # Basic application health
+        app_health = {
+            "status": "healthy",
+            "app_name": db_settings.APP_NAME,
+            "version": db_settings.APP_VERSION,
+            "environment": db_settings.ENVIRONMENT,
+            "debug": db_settings.DEBUG
+        }
+        
+        # Database health check
+        db_health = DatabaseManager.health_check()
+        
+        # Overall health status
+        overall_status = "healthy" if db_health["status"] == "healthy" else "degraded"
+        
+        health_data = {
+            "overall_status": overall_status,
+            "application": app_health,
+            "database": db_health
+        }
+        
+        logger.info(f"Health check completed with status: {overall_status}")
+        
+        return Respons[dict](
+            details=f"Health check successful - Status: {overall_status}",
+            data=[health_data],
+            success=True,
+            status_code=200
+        )
+        
+    except Exception as e:
+        logger.error(f"Health check failed: {str(e)}")
+        return Respons[dict](
+            details="Health check failed",
+            error=str(e),
+            data=[],
+            success=False,
+            status_code=500
+        )
+
+@health_check_router.get("/health/db", response_model=Respons[dict])
+async def database_health():
+    """Database-specific health check endpoint."""
+    try:
+        db_health = DatabaseManager.health_check()
+        
+        if db_health["status"] == "healthy":
+            return Respons[dict](
+                details="Database health check successful",
+                data=[db_health],
+                success=True,
+                status_code=200
+            )
+        else:
+            return Respons[dict](
+                details="Database health check failed",
+                error=db_health.get("error", "Unknown database error"),
+                data=[db_health],
+                success=False,
+                status_code=503
+            )
+            
+    except Exception as e:
+        logger.error(f"Database health check failed: {str(e)}")
+        return Respons[dict](
+            details="Database health check failed",
+            error=str(e),
+            data=[],
+            success=False,
+            status_code=500
+        )

trovesuite/entities/sh_response.py

@@ -0,0 +1,61 @@
+from pydantic import BaseModel
+from typing import Optional, List, Any, TypeVar, Generic
+
+class PaginationMeta(BaseModel):
+    """Pagination metadata"""
+    page: int
+    size: int
+    total: int
+    has_next: bool
+
+T = TypeVar('T')
+
+class Respons(BaseModel, Generic[T]):
+    detail: Optional[str] = None
+    error: Optional[str] = None
+    data: Optional[List[T]] = None
+    status_code: int = 200
+    success: bool = True
+    pagination: Optional[PaginationMeta] = None
+
+
+class ResponseException(Exception):
+    """Custom exception that carries a response model"""
+    
+    def __init__(self, message: str, response: Respons):
+        self.message = message
+        self.response = response
+        super().__init__(self.message)
+
+
+def create_error_response(
+    error_message: str,
+    status_code: int = 500,
+    details: str = "An error occurred",
+    data: Optional[List[Any]] = None
+) -> dict:
+    """Helper function to create error response dictionary"""
+    return {
+        "detail": details,
+        "error": error_message,
+        "data": data or [],
+        "status_code": status_code,
+        "success": False
+    }
+
+
+def raise_with_response(
+    message: str,
+    status_code: int = 500,
+    details: str = "An error occurred",
+    data: Optional[List[Any]] = None
+) -> None:
+    """Helper function to raise ResponseException with error response"""
+    error_response = Respons(
+        detail=details,
+        error=message,
+        data=data or [],
+        status_code=status_code,
+        success=False
+    )
+    raise ResponseException(message, error_response)

trovesuite/utils/__init__.py

@@ -0,0 +1,11 @@
+"""
+TroveSuite Utils Module
+
+Utility functions and helpers for TroveSuite services.
+"""
+
+from .helper import Helper
+
+__all__ = [
+    "Helper"
+]

trovesuite/utils/helper.py

@@ -0,0 +1,36 @@
+import logging
+from typing import List
+from typing import TypeVar
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+class Helper:
+
+    @staticmethod
+    def map_to_dto(data: list, dto_class: T) -> List[T]:
+        """
+        Helper method to convert database results to DTO objects
+        Args:
+            data: List of database query results (dictionaries)
+            dto_class: The DTO class to instantiate
+        Returns:
+            List of DTO instances
+        """
+        if not data:
+            return []
+        
+        try:
+            result = []
+            for row in data:
+                # Convert RealDictRow to regular dict
+                if hasattr(row, 'items'):
+                    row_dict = dict(row.items())
+                else:
+                    row_dict = dict(row)
+                result.append(dto_class(**row_dict))
+            return result
+        except Exception as e:
+            logger.error(f"Error mapping data to DTO: {str(e)}")
+            raise