spring-ready-python 0.1.0__py3-none-any.whl

spring_ready/actuator/info.py

@@ -0,0 +1,123 @@
+"""
+Actuator info endpoint.
+Provides application metadata like Spring Boot Actuator's /actuator/info.
+"""
+
+import os
+import sys
+import logging
+from typing import Dict, Any, Optional
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+
+class InfoEndpoint:
+    """
+    Info endpoint that provides application metadata.
+
+    Matches Spring Boot Actuator's info endpoint format:
+    - app: Application info (name, version, description)
+    - build: Build information
+    - git: Git commit info (if available)
+    - java: Runtime info (adapted for Python)
+    """
+
+    def __init__(
+            self,
+            app_name: Optional[str] = None,
+            app_version: Optional[str] = None,
+            app_description: Optional[str] = None
+    ):
+        self.app_name = app_name or os.getenv("SPRING_APPLICATION_NAME", "unknown")
+        self.app_version = app_version or os.getenv("APP_VERSION", "unknown")
+        self.app_description = app_description or os.getenv("APP_DESCRIPTION", "")
+        self.custom_info: Dict[str, Any] = {}
+
+    def add_info(self, key: str, value: Any) -> None:
+        """Add custom info field"""
+        self.custom_info[key] = value
+
+    def get_info(self) -> Dict[str, Any]:
+        """
+        Get application info.
+
+        Returns:
+            Info response matching Spring Boot Actuator format
+        """
+        info = {
+            "app": {
+                "name": self.app_name,
+                "version": self.app_version,
+            }
+        }
+
+        if self.app_description:
+            info["app"]["description"] = self.app_description
+
+        # Python runtime info (equivalent to java info in Spring)
+        info["python"] = {
+            "version": sys.version,
+            "vendor": sys.copyright.split("\n")[0] if sys.copyright else "Python Software Foundation",
+            "runtime": {
+                "name": "CPython",
+                "version": sys.version.split()[0]
+            },
+            "jvm": {  # Keep "jvm" key for compatibility with Spring Admin
+                "name": f"Python {sys.version.split()[0]}",
+                "vendor": "Python Software Foundation",
+                "version": sys.version.split()[0]
+            }
+        }
+
+        # Build info from environment (if available)
+        if any(os.getenv(k) for k in ["BUILD_NUMBER", "BUILD_TIME", "GIT_COMMIT"]):
+            info["build"] = {}
+
+            if build_number := os.getenv("BUILD_NUMBER"):
+                info["build"]["number"] = build_number
+
+            if build_time := os.getenv("BUILD_TIME"):
+                info["build"]["time"] = build_time
+
+            if git_commit := os.getenv("GIT_COMMIT"):
+                info["build"]["commit"] = git_commit
+
+        # Git info (if available)
+        if git_commit := os.getenv("GIT_COMMIT"):
+            info["git"] = {
+                "commit": {
+                    "id": git_commit,
+                    "time": os.getenv("GIT_COMMIT_TIME", "")
+                },
+                "branch": os.getenv("GIT_BRANCH", "")
+            }
+
+        # Add custom info
+        if self.custom_info:
+            info.update(self.custom_info)
+
+        return info
+
+
+def create_default_info_endpoint(
+        app_name: Optional[str] = None,
+        app_version: Optional[str] = None,
+        app_description: Optional[str] = None
+) -> InfoEndpoint:
+    """
+    Create info endpoint with default configuration.
+
+    Args:
+        app_name: Application name (default from env)
+        app_version: Application version (default from env)
+        app_description: Application description (default from env)
+
+    Returns:
+        InfoEndpoint instance
+    """
+    return InfoEndpoint(
+        app_name=app_name,
+        app_version=app_version,
+        app_description=app_description
+    )

spring_ready/actuator/logfile.py

@@ -0,0 +1,201 @@
+"""
+Actuator Logfile Endpoint.
+Provides access to application log files.
+"""
+
+import os
+import logging
+from typing import Optional
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class LogfileEndpoint:
+    """
+    Logfile endpoint for Spring Boot Actuator compatibility.
+
+    Provides access to application log files with support for:
+    - Full log file retrieval
+    - Partial retrieval with Range header support
+    """
+
+    def __init__(self, log_file_path: Optional[str] = None):
+        """
+        Args:
+            log_file_path: Path to the log file (default: None, which means no log file)
+        """
+        self.log_file_path = log_file_path
+
+        # Verify log file exists if path provided
+        if self.log_file_path and not os.path.exists(self.log_file_path):
+            logger.warning(f"Log file not found: {self.log_file_path}")
+
+    def get_logfile(self, range_header: Optional[str] = None) -> tuple[Optional[bytes], Optional[str], int]:
+        """
+        Get log file contents.
+
+        Args:
+            range_header: HTTP Range header value (e.g., "bytes=0-1023")
+
+        Returns:
+            Tuple of (content, content_range_header, status_code)
+            - content: Log file bytes or None if not available
+            - content_range_header: Content-Range header value or None
+            - status_code: HTTP status code (200, 206, or 404)
+        """
+        # If no log file configured
+        if not self.log_file_path:
+            logger.warning("No log file configured for logfile endpoint")
+            return None, None, 404
+
+        # If log file doesn't exist
+        if not os.path.exists(self.log_file_path):
+            logger.warning(f"Log file not found: {self.log_file_path}")
+            return None, None, 404
+
+        try:
+            file_size = os.path.getsize(self.log_file_path)
+
+            # Handle range request
+            if range_header:
+                # Parse range header (e.g., "bytes=0-1023")
+                if range_header.startswith("bytes="):
+                    range_spec = range_header[6:]
+                    start, end = self._parse_range(range_spec, file_size)
+
+                    if start is None or end is None:
+                        # Invalid range
+                        return None, None, 416  # Range Not Satisfiable
+
+                    # Read the specified range
+                    with open(self.log_file_path, 'rb') as f:
+                        f.seek(start)
+                        content = f.read(end - start + 1)
+
+                    # Build Content-Range header
+                    content_range = f"bytes {start}-{end}/{file_size}"
+                    return content, content_range, 206  # Partial Content
+
+            # Read entire file
+            with open(self.log_file_path, 'rb') as f:
+                content = f.read()
+
+            return content, None, 200
+
+        except Exception as e:
+            logger.error(f"Error reading log file: {e}", exc_info=True)
+            return None, None, 500
+
+    def _parse_range(self, range_spec: str, file_size: int) -> tuple[Optional[int], Optional[int]]:
+        """
+        Parse HTTP Range specification.
+
+        Args:
+            range_spec: Range specification (e.g., "0-1023" or "-1024" or "1024-")
+            file_size: Total file size
+
+        Returns:
+            Tuple of (start, end) byte positions, or (None, None) if invalid
+        """
+        try:
+            if '-' not in range_spec:
+                return None, None
+
+            parts = range_spec.split('-', 1)
+
+            # Handle "-1024" (last 1024 bytes)
+            if not parts[0]:
+                suffix_length = int(parts[1])
+                start = max(0, file_size - suffix_length)
+                end = file_size - 1
+                return start, end
+
+            # Handle "1024-" (from byte 1024 to end)
+            if not parts[1]:
+                start = int(parts[0])
+                end = file_size - 1
+                return start, end
+
+            # Handle "0-1023" (bytes 0 to 1023)
+            start = int(parts[0])
+            end = int(parts[1])
+
+            # Validate range
+            if start < 0 or end >= file_size or start > end:
+                return None, None
+
+            return start, end
+
+        except (ValueError, IndexError):
+            return None, None
+
+    def is_available(self) -> bool:
+        """Check if log file is available"""
+        return (
+            self.log_file_path is not None
+            and os.path.exists(self.log_file_path)
+        )
+
+
+def create_default_logfile_endpoint(log_file_path: Optional[str] = None) -> LogfileEndpoint:
+    """
+    Create logfile endpoint with default configuration.
+
+    Automatically detects log file from Python logging handlers if not specified.
+    Priority: explicit parameter > LOG_FILE_PATH env var > auto-detected from logging
+
+    Args:
+        log_file_path: Path to log file (default: auto-detect or from env LOG_FILE_PATH)
+
+    Returns:
+        LogfileEndpoint instance
+    """
+    # Priority 1: Explicit parameter
+    if log_file_path is not None:
+        return LogfileEndpoint(log_file_path=log_file_path)
+
+    # Priority 2: Environment variable
+    log_file_path = os.getenv("LOG_FILE_PATH")
+    if log_file_path is not None:
+        return LogfileEndpoint(log_file_path=log_file_path)
+
+    # Priority 3: Auto-detect from Python logging handlers
+    log_file_path = _auto_detect_log_file()
+
+    return LogfileEndpoint(log_file_path=log_file_path)
+
+
+def _auto_detect_log_file() -> Optional[str]:
+    """
+    Auto-detect log file path from Python logging configuration.
+
+    Scans all logging handlers for FileHandler, RotatingFileHandler,
+    TimedRotatingFileHandler and extracts the file path.
+
+    Returns:
+        Detected log file path or None if no file handler found
+    """
+    try:
+        # Check root logger first
+        for handler in logging.root.handlers:
+            if isinstance(handler, logging.FileHandler):
+                log_path = handler.baseFilename
+                logger.info(f"Auto-detected log file: {log_path}")
+                return log_path
+
+        # Check all other loggers
+        for logger_name in logging.Logger.manager.loggerDict:
+            log_instance = logging.getLogger(logger_name)
+            if hasattr(log_instance, 'handlers'):
+                for handler in log_instance.handlers:
+                    if isinstance(handler, logging.FileHandler):
+                        log_path = handler.baseFilename
+                        logger.info(f"Auto-detected log file from logger '{logger_name}': {log_path}")
+                        return log_path
+
+        logger.debug("No log file found in logging configuration")
+        return None
+    except Exception as e:
+        logger.warning(f"Failed to auto-detect log file: {e}")
+        return None

spring_ready/actuator/loggers.py

@@ -0,0 +1,184 @@
+"""
+Actuator Loggers Endpoint.
+Shows and manages logger configurations and levels.
+"""
+
+import logging
+from typing import Dict, Any, Optional, List
+
+
+# Valid log levels
+VALID_LEVELS = ["TRACE", "DEBUG", "INFO", "WARN", "ERROR", "CRITICAL", "OFF"]
+
+# Map Spring Boot levels to Python levels
+LEVEL_MAPPING = {
+    "TRACE": logging.DEBUG,  # Python doesn't have TRACE, use DEBUG
+    "DEBUG": logging.DEBUG,
+    "INFO": logging.INFO,
+    "WARN": logging.WARNING,
+    "ERROR": logging.ERROR,
+    "CRITICAL": logging.CRITICAL,
+    "OFF": logging.CRITICAL + 10,  # Effectively disable logging
+}
+
+# Reverse mapping for display
+PYTHON_TO_SPRING = {
+    logging.DEBUG: "DEBUG",
+    logging.INFO: "INFO",
+    logging.WARNING: "WARN",
+    logging.ERROR: "ERROR",
+    logging.CRITICAL: "CRITICAL",
+}
+
+
+class LoggersEndpoint:
+    """
+    Loggers endpoint for Spring Boot Actuator compatibility.
+
+    Provides:
+    - List all loggers with their levels
+    - Get individual logger configuration
+    - Set/update logger levels
+    - Clear logger levels (reset to inherited)
+    """
+
+    def __init__(self):
+        """Initialize loggers endpoint"""
+        pass
+
+    def _get_logger_level_name(self, level: Optional[int]) -> Optional[str]:
+        """
+        Convert Python log level to Spring Boot level name.
+
+        Args:
+            level: Python log level integer
+
+        Returns:
+            Spring Boot level name or None
+        """
+        if level is None:
+            return None
+        return PYTHON_TO_SPRING.get(level, "DEBUG")
+
+    def _get_logger_info(self, logger: logging.Logger) -> Dict[str, Any]:
+        """
+        Get logger information.
+
+        Args:
+            logger: Logger instance
+
+        Returns:
+            Dictionary with configuredLevel and effectiveLevel
+        """
+        # Get configured level (may be None if inherited)
+        configured_level = logger.level if logger.level != logging.NOTSET else None
+        configured_level_name = self._get_logger_level_name(configured_level)
+
+        # Get effective level (always has a value due to inheritance)
+        effective_level = logger.getEffectiveLevel()
+        effective_level_name = self._get_logger_level_name(effective_level)
+
+        return {
+            "configuredLevel": configured_level_name,
+            "effectiveLevel": effective_level_name
+        }
+
+    def get_all_loggers(self) -> Dict[str, Any]:
+        """
+        Get all loggers.
+
+        Returns:
+            Dictionary with levels list and loggers dict
+        """
+        loggers_dict = {}
+
+        # Get root logger
+        root_logger = logging.getLogger()
+        loggers_dict["ROOT"] = self._get_logger_info(root_logger)
+
+        # Get all other loggers
+        # Access the internal logger dictionary
+        logger_dict = logging.Logger.manager.loggerDict
+        for name, logger_item in sorted(logger_dict.items()):
+            # Skip PlaceHolder objects, only include actual Logger instances
+            if isinstance(logger_item, logging.Logger):
+                loggers_dict[name] = self._get_logger_info(logger_item)
+
+        return {
+            "levels": VALID_LEVELS,
+            "loggers": loggers_dict,
+            "groups": {}
+        }
+
+    def get_logger(self, name: str) -> Optional[Dict[str, Any]]:
+        """
+        Get a single logger by name.
+
+        Args:
+            name: Logger name (use "ROOT" for root logger)
+
+        Returns:
+            Logger info or None if not found
+        """
+        if name == "ROOT":
+            logger = logging.getLogger()
+        else:
+            # Check if logger exists
+            if name not in logging.Logger.manager.loggerDict:
+                return None
+            logger = logging.getLogger(name)
+
+        return self._get_logger_info(logger)
+
+    def set_logger_level(self, name: str, level: Optional[str]) -> bool:
+        """
+        Set logger level.
+
+        Args:
+            name: Logger name (use "ROOT" for root logger)
+            level: Level name (DEBUG, INFO, WARN, ERROR, etc.) or None to clear
+
+        Returns:
+            True if successful, False if logger not found or invalid level
+        """
+        # Validate level
+        if level is not None and level not in LEVEL_MAPPING:
+            return False
+
+        # Get logger
+        if name == "ROOT":
+            logger = logging.getLogger()
+        else:
+            logger = logging.getLogger(name)
+
+        # Set level
+        if level is None:
+            # Clear level (set to NOTSET to inherit from parent)
+            logger.setLevel(logging.NOTSET)
+        else:
+            python_level = LEVEL_MAPPING[level]
+            logger.setLevel(python_level)
+
+        return True
+
+    def clear_logger_level(self, name: str) -> bool:
+        """
+        Clear logger level (reset to inherited).
+
+        Args:
+            name: Logger name
+
+        Returns:
+            True if successful
+        """
+        return self.set_logger_level(name, None)
+
+
+def create_default_loggers_endpoint() -> LoggersEndpoint:
+    """
+    Create loggers endpoint.
+
+    Returns:
+        LoggersEndpoint instance
+    """
+    return LoggersEndpoint()

spring_ready/actuator/mappings.py

@@ -0,0 +1,88 @@
+"""
+Actuator Mappings Endpoint.
+Shows all registered request mappings (routes) in the application.
+"""
+
+from typing import Dict, Any, List
+from fastapi import FastAPI
+from fastapi.routing import APIRoute
+
+
+class MappingsEndpoint:
+    """
+    Mappings endpoint for Spring Boot Actuator compatibility.
+
+    Shows all registered FastAPI routes with their HTTP methods and handlers.
+    """
+
+    def __init__(self, app: FastAPI):
+        """
+        Args:
+            app: FastAPI application instance
+        """
+        self.app = app
+
+    def get_mappings(self) -> Dict[str, Any]:
+        """
+        Get all request mappings.
+
+        Returns:
+            Dictionary with contexts and dispatcher servlet mappings
+        """
+        mappings = []
+
+        # Iterate through all routes
+        for route in self.app.routes:
+            if isinstance(route, APIRoute):
+                # Get handler info
+                handler_name = route.endpoint.__name__ if hasattr(route, 'endpoint') else "unknown"
+                handler_module = route.endpoint.__module__ if hasattr(route, 'endpoint') else "unknown"
+
+                # Get methods
+                methods = list(route.methods) if hasattr(route, 'methods') else []
+
+                # Build mapping entry
+                mapping = {
+                    "handler": f"{handler_module}.{handler_name}",
+                    "predicate": f"{{{', '.join(methods)}}} {route.path}",
+                    "details": {
+                        "requestMappingConditions": {
+                            "methods": methods,
+                            "patterns": [route.path]
+                        }
+                    }
+                }
+
+                mappings.append(mapping)
+
+        return {
+            "contexts": {
+                "application": {
+                    "mappings": {
+                        "dispatcherServlet": {
+                            "details": {
+                                "requestMappingConditions": {
+                                    "patterns": []
+                                }
+                            },
+                            "dispatcherHandlers": {
+                                "webHandler": mappings
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+
+def create_default_mappings_endpoint(app: FastAPI) -> MappingsEndpoint:
+    """
+    Create mappings endpoint for a FastAPI application.
+
+    Args:
+        app: FastAPI application instance
+
+    Returns:
+        MappingsEndpoint instance
+    """
+    return MappingsEndpoint(app)