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

spring_ready/__init__.py

@@ -0,0 +1,30 @@
+"""
+Spring-Ready Python
+A lightweight library to make Python apps Spring Boot ecosystem compatible.
+
+Provides:
+- Eureka service registration
+- Config Server integration with discovery
+- Actuator endpoints (health, info, prometheus)
+- FastAPI integration
+
+Usage:
+    from spring_ready import SpringReadyApp
+
+    app = SpringReadyApp()
+"""
+
+from .core import SpringReadyApp
+from .exceptions import (
+    SpringReadyException,
+    EurekaRegistrationError,
+    ConfigServerError,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "SpringReadyApp",
+    "SpringReadyException",
+    "EurekaRegistrationError",
+    "ConfigServerError",
+]

spring_ready/actuator/__init__.py

@@ -0,0 +1,68 @@
+"""Spring Boot Actuator-compatible endpoints"""
+
+from .health import HealthEndpoint, HealthIndicator, HealthStatus, create_default_health_endpoint
+from .info import InfoEndpoint, create_default_info_endpoint
+from .prometheus import PrometheusEndpoint, create_default_prometheus_endpoint
+from .discovery import ActuatorDiscoveryEndpoint, create_default_discovery_endpoint
+from .metrics import MetricsEndpoint, create_default_metrics_endpoint
+from .env import EnvEndpoint, create_default_env_endpoint
+from .loggers import LoggersEndpoint, create_default_loggers_endpoint
+from .mappings import MappingsEndpoint, create_default_mappings_endpoint
+from .threaddump import ThreadDumpEndpoint, create_default_threaddump_endpoint
+from .httptrace import (
+    HttpTraceEndpoint,
+    HttpExchangesEndpoint,
+    create_default_httptrace_endpoint,
+    create_default_httpexchanges_endpoint
+)
+from .logfile import LogfileEndpoint, create_default_logfile_endpoint
+from .refresh import RefreshEndpoint, create_default_refresh_endpoint
+from .beans import BeansEndpoint, create_default_beans_endpoint
+from .configprops import ConfigPropsEndpoint, create_default_configprops_endpoint
+from .scheduledtasks import ScheduledTasksEndpoint, create_default_scheduledtasks_endpoint
+from .heapdump import HeapdumpEndpoint, create_default_heapdump_endpoint
+from .caches import CachesEndpoint, create_default_caches_endpoint
+from .auditevents import AuditEventsEndpoint, create_default_auditevents_endpoint
+
+__all__ = [
+    "HealthEndpoint",
+    "HealthIndicator",
+    "HealthStatus",
+    "create_default_health_endpoint",
+    "InfoEndpoint",
+    "create_default_info_endpoint",
+    "PrometheusEndpoint",
+    "create_default_prometheus_endpoint",
+    "ActuatorDiscoveryEndpoint",
+    "create_default_discovery_endpoint",
+    "MetricsEndpoint",
+    "create_default_metrics_endpoint",
+    "EnvEndpoint",
+    "create_default_env_endpoint",
+    "LoggersEndpoint",
+    "create_default_loggers_endpoint",
+    "MappingsEndpoint",
+    "create_default_mappings_endpoint",
+    "ThreadDumpEndpoint",
+    "create_default_threaddump_endpoint",
+    "HttpTraceEndpoint",
+    "HttpExchangesEndpoint",
+    "create_default_httptrace_endpoint",
+    "create_default_httpexchanges_endpoint",
+    "LogfileEndpoint",
+    "create_default_logfile_endpoint",
+    "RefreshEndpoint",
+    "create_default_refresh_endpoint",
+    "BeansEndpoint",
+    "create_default_beans_endpoint",
+    "ConfigPropsEndpoint",
+    "create_default_configprops_endpoint",
+    "ScheduledTasksEndpoint",
+    "create_default_scheduledtasks_endpoint",
+    "HeapdumpEndpoint",
+    "create_default_heapdump_endpoint",
+    "CachesEndpoint",
+    "create_default_caches_endpoint",
+    "AuditEventsEndpoint",
+    "create_default_auditevents_endpoint",
+]

spring_ready/actuator/auditevents.py

@@ -0,0 +1,114 @@
+"""
+Actuator AuditEvents Endpoint.
+Provides information about security-related audit events.
+"""
+
+import time
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass, field
+from collections import deque
+
+
+@dataclass
+class AuditEvent:
+    """Single audit event"""
+    timestamp: str
+    principal: str
+    type: str
+    data: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "timestamp": self.timestamp,
+            "principal": self.principal,
+            "type": self.type,
+            "data": self.data
+        }
+
+
+class AuditEventsEndpoint:
+    """
+    AuditEvents endpoint for Spring Boot Actuator compatibility.
+
+    Tracks security-related events like authentication, authorization, etc.
+    Stores events in memory with configurable max size.
+    """
+
+    def __init__(self, max_events: int = 1000):
+        """
+        Args:
+            max_events: Maximum number of events to keep in memory
+        """
+        self.max_events = max_events
+        self.events: deque = deque(maxlen=max_events)
+
+    def add_event(
+        self,
+        principal: str,
+        event_type: str,
+        data: Optional[Dict[str, Any]] = None
+    ) -> None:
+        """
+        Add an audit event.
+
+        Args:
+            principal: Principal (user/system) that triggered the event
+            event_type: Event type (e.g., "AUTHENTICATION_SUCCESS", "AUTHORIZATION_FAILURE")
+            data: Additional event data
+        """
+        timestamp = time.strftime("%Y-%m-%dT%H:%M:%S.000Z", time.gmtime())
+
+        event = AuditEvent(
+            timestamp=timestamp,
+            principal=principal,
+            type=event_type,
+            data=data or {}
+        )
+
+        self.events.append(event)
+
+    def get_events(
+        self,
+        principal: Optional[str] = None,
+        after: Optional[str] = None,
+        event_type: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Get audit events with optional filtering.
+
+        Args:
+            principal: Filter by principal name
+            after: Filter events after this timestamp
+            event_type: Filter by event type
+
+        Returns:
+            Dictionary with filtered audit events
+        """
+        filtered_events = list(self.events)
+
+        # Apply filters
+        if principal:
+            filtered_events = [e for e in filtered_events if e.principal == principal]
+
+        if after:
+            filtered_events = [e for e in filtered_events if e.timestamp > after]
+
+        if event_type:
+            filtered_events = [e for e in filtered_events if e.type == event_type]
+
+        return {
+            "events": [event.to_dict() for event in filtered_events]
+        }
+
+
+def create_default_auditevents_endpoint(max_events: int = 1000) -> AuditEventsEndpoint:
+    """
+    Create auditevents endpoint with default configuration.
+
+    Args:
+        max_events: Maximum number of events to keep
+
+    Returns:
+        AuditEventsEndpoint instance
+    """
+    return AuditEventsEndpoint(max_events=max_events)

spring_ready/actuator/beans.py

@@ -0,0 +1,141 @@
+"""
+Actuator Beans Endpoint.
+Shows information about application beans/components.
+"""
+
+import sys
+from typing import Dict, Any, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from fastapi import FastAPI
+
+
+class BeansEndpoint:
+    """
+    Beans endpoint for Spring Boot Actuator compatibility.
+
+    Shows information about application components, similar to Spring's bean registry.
+    In Python/FastAPI context, this includes:
+    - Registered routes
+    - Middleware components
+    - Dependency injection components
+    """
+
+    def __init__(self, app: Optional['FastAPI'] = None):
+        """
+        Args:
+            app: FastAPI application instance
+        """
+        self.app = app
+
+    def get_beans(self) -> Dict[str, Any]:
+        """
+        Get all beans/components.
+
+        Returns:
+            Dictionary with application contexts and bean definitions
+        """
+        beans = {}
+
+        if self.app:
+            # Add FastAPI app itself
+            beans["fastapi_app"] = {
+                "type": "fastapi.applications.FastAPI",
+                "scope": "singleton",
+                "attributes": {
+                    "title": self.app.title,
+                    "version": self.app.version,
+                    "openapi_url": self.app.openapi_url,
+                }
+            }
+
+            # Add middleware
+            middleware_beans = self._get_middleware_beans()
+            beans.update(middleware_beans)
+
+            # Add routes as beans
+            route_beans = self._get_route_beans()
+            beans.update(route_beans)
+
+        # Add Python system components
+        system_beans = self._get_system_beans()
+        beans.update(system_beans)
+
+        return {
+            "contexts": {
+                "application": {
+                    "beans": beans,
+                    "parentId": None
+                }
+            }
+        }
+
+    def _get_middleware_beans(self) -> Dict[str, Any]:
+        """Get middleware components as beans"""
+        middleware_beans = {}
+
+        if not self.app or not hasattr(self.app, 'user_middleware'):
+            return middleware_beans
+
+        for idx, middleware in enumerate(self.app.user_middleware):
+            middleware_cls = middleware.cls if hasattr(middleware, 'cls') else middleware
+            bean_name = f"middleware_{idx}_{middleware_cls.__name__}"
+
+            middleware_beans[bean_name] = {
+                "type": f"{middleware_cls.__module__}.{middleware_cls.__name__}",
+                "scope": "singleton",
+                "attributes": {}
+            }
+
+        return middleware_beans
+
+    def _get_route_beans(self) -> Dict[str, Any]:
+        """Get routes as beans"""
+        route_beans = {}
+
+        if not self.app:
+            return route_beans
+
+        for route in self.app.routes:
+            if hasattr(route, 'endpoint') and hasattr(route, 'path'):
+                endpoint_name = route.endpoint.__name__ if hasattr(route.endpoint, '__name__') else str(route.endpoint)
+                bean_name = f"route_{endpoint_name}_{route.path.replace('/', '_').replace('{', '').replace('}', '')}"
+
+                route_beans[bean_name] = {
+                    "type": "fastapi.routing.APIRoute",
+                    "scope": "singleton",
+                    "attributes": {
+                        "path": route.path,
+                        "methods": list(route.methods) if hasattr(route, 'methods') else [],
+                        "name": route.name if hasattr(route, 'name') else None
+                    }
+                }
+
+        return route_beans
+
+    def _get_system_beans(self) -> Dict[str, Any]:
+        """Get Python system components"""
+        return {
+            "python_interpreter": {
+                "type": "system.python.interpreter",
+                "scope": "singleton",
+                "attributes": {
+                    "version": sys.version.split()[0],
+                    "executable": sys.executable,
+                    "platform": sys.platform
+                }
+            }
+        }
+
+
+def create_default_beans_endpoint(app: Optional['FastAPI'] = None) -> BeansEndpoint:
+    """
+    Create beans endpoint with default configuration.
+
+    Args:
+        app: FastAPI application instance
+
+    Returns:
+        BeansEndpoint instance
+    """
+    return BeansEndpoint(app=app)

spring_ready/actuator/caches.py

@@ -0,0 +1,111 @@
+"""
+Actuator Caches Endpoint.
+Provides access to application caches.
+"""
+
+from typing import Dict, Any, Optional, List
+
+
+class CachesEndpoint:
+    """
+    Caches endpoint for Spring Boot Actuator compatibility.
+
+    Provides access to application caches.
+    Currently returns empty structure as no cache manager is configured by default.
+    Can be extended to integrate with Redis, Memcached, or in-memory caches.
+    """
+
+    def __init__(self):
+        """Initialize caches endpoint"""
+        self.cache_managers: Dict[str, Dict[str, Any]] = {}
+
+    def get_caches(self) -> Dict[str, Any]:
+        """
+        Get all caches.
+
+        Returns:
+            Dictionary with cache managers and caches
+        """
+        caches = {}
+
+        for manager_name, manager_info in self.cache_managers.items():
+            for cache_name in manager_info.get("caches", []):
+                caches[cache_name] = {
+                    "target": f"{manager_name}::{cache_name}",
+                    "cacheManager": manager_name
+                }
+
+        return {
+            "cacheManagers": self.cache_managers,
+            "caches": caches
+        }
+
+    def get_cache(self, cache_name: str, cache_manager: Optional[str] = None) -> Optional[Dict[str, Any]]:
+        """
+        Get a specific cache.
+
+        Args:
+            cache_name: Cache name
+            cache_manager: Optional cache manager name
+
+        Returns:
+            Cache details or None if not found
+        """
+        for manager_name, manager_info in self.cache_managers.items():
+            if cache_manager and manager_name != cache_manager:
+                continue
+
+            if cache_name in manager_info.get("caches", []):
+                return {
+                    "target": f"{manager_name}::{cache_name}",
+                    "name": cache_name,
+                    "cacheManager": manager_name
+                }
+
+        return None
+
+    def evict_cache(self, cache_name: str, cache_manager: Optional[str] = None) -> bool:
+        """
+        Evict a specific cache.
+
+        Args:
+            cache_name: Cache name
+            cache_manager: Optional cache manager name
+
+        Returns:
+            True if cache was evicted, False otherwise
+        """
+        # Placeholder - actual eviction would depend on cache implementation
+        return self.get_cache(cache_name, cache_manager) is not None
+
+    def evict_all_caches(self) -> bool:
+        """
+        Evict all caches.
+
+        Returns:
+            True if successful
+        """
+        # Placeholder - actual eviction would depend on cache implementation
+        return True
+
+    def add_cache_manager(self, name: str, caches: List[str]) -> None:
+        """
+        Register a cache manager.
+
+        Args:
+            name: Cache manager name
+            caches: List of cache names
+        """
+        self.cache_managers[name] = {
+            "caches": caches
+        }
+
+
+def create_default_caches_endpoint() -> CachesEndpoint:
+    """
+    Create caches endpoint with default configuration.
+
+    Returns:
+        CachesEndpoint instance
+    """
+    return CachesEndpoint()

spring_ready/actuator/configprops.py

@@ -0,0 +1,109 @@
+"""
+Actuator ConfigProps Endpoint.
+Shows configuration properties grouped by prefix.
+"""
+
+import os
+from typing import Dict, Any
+
+
+class ConfigPropsEndpoint:
+    """
+    ConfigProps endpoint for Spring Boot Actuator compatibility.
+
+    Shows configuration properties similar to Spring Boot's @ConfigurationProperties.
+    Groups environment variables and settings by common prefixes.
+    """
+
+    def get_config_props(self) -> Dict[str, Any]:
+        """
+        Get all configuration properties grouped by prefix.
+
+        Returns:
+            Dictionary with configuration property beans
+        """
+        # Group environment variables by common prefixes
+        grouped_props = self._group_by_prefix(dict(os.environ))
+
+        beans = {}
+        for prefix, props in grouped_props.items():
+            bean_name = f"{prefix}_properties"
+            beans[bean_name] = {
+                "prefix": prefix,
+                "properties": props
+            }
+
+        return {
+            "contexts": {
+                "application": {
+                    "beans": beans
+                }
+            }
+        }
+
+    def get_config_props_by_prefix(self, prefix: str) -> Dict[str, Any]:
+        """
+        Get configuration properties filtered by prefix.
+
+        Args:
+            prefix: Prefix to filter by
+
+        Returns:
+            Dictionary with matching configuration properties
+        """
+        matching_props = {}
+
+        for key, value in os.environ.items():
+            if key.startswith(prefix.upper()) or key.lower().startswith(prefix.lower()):
+                matching_props[key] = value
+
+        if not matching_props:
+            return {}
+
+        bean_name = f"{prefix}_properties"
+        return {
+            "contexts": {
+                "application": {
+                    "beans": {
+                        bean_name: {
+                            "prefix": prefix,
+                            "properties": matching_props
+                        }
+                    }
+                }
+            }
+        }
+
+    def _group_by_prefix(self, env_vars: Dict[str, str]) -> Dict[str, Dict[str, str]]:
+        """
+        Group environment variables by common prefixes.
+
+        Args:
+            env_vars: Environment variables dictionary
+
+        Returns:
+            Dictionary grouped by prefix
+        """
+        grouped = {}
+
+        for key, value in env_vars.items():
+            # Extract prefix (first part before _)
+            parts = key.split('_', 1)
+            prefix = parts[0] if parts else key
+
+            if prefix not in grouped:
+                grouped[prefix] = {}
+
+            grouped[prefix][key] = value
+
+        return grouped
+
+
+def create_default_configprops_endpoint() -> ConfigPropsEndpoint:
+    """
+    Create configprops endpoint with default configuration.
+
+    Returns:
+        ConfigPropsEndpoint instance
+    """
+    return ConfigPropsEndpoint()