runbooks 1.1.4__py3-none-any.whl → 1.1.6__py3-none-any.whl

runbooks/enterprise/__init__.py

@@ -59,7 +59,7 @@ __all__ = [
     "configure_enterprise_logging",
     # Security
     "get_enhanced_logger",
-    "assess_vpc_security_posture", 
+    "assess_vpc_security_posture",
     "validate_compliance_requirements",
     "evaluate_security_baseline",
     "classify_security_risk",

runbooks/enterprise/logging.py

@@ -17,36 +17,37 @@ from typing import Any, Dict, List, Optional, Union, Literal
 
 try:
     from loguru import logger as loguru_logger
+
     _HAS_LOGURU = True
 except ImportError:
     # Create a mock loguru-like object for compatibility
     import logging
-    
+
     class MockLoguru:
         def __init__(self):
             self.logger = logging.getLogger(__name__)
-            
+
         def remove(self, *args, **kwargs):
             pass  # No-op for standard logging
-            
+
         def add(self, *args, **kwargs):
             pass  # No-op for standard logging
-            
+
         def bind(self, **kwargs):
             return self  # Return self for chaining
-            
+
         def info(self, message, *args, **kwargs):
             self.logger.info(message, *args)
-            
+
         def warning(self, message, *args, **kwargs):
             self.logger.warning(message, *args)
-            
+
         def error(self, message, *args, **kwargs):
             self.logger.error(message, *args)
-            
+
         def debug(self, message, *args, **kwargs):
             self.logger.debug(message, *args)
-    
+
     loguru_logger = MockLoguru()
     _HAS_LOGURU = False
 
@@ -58,6 +59,7 @@ try:
     from rich.panel import Panel
     from rich.text import Text
     from rich import box
+
     _HAS_RICH = True
 except ImportError:
     _HAS_RICH = False
@@ -72,7 +74,7 @@ class EnterpriseRichLogger:
     def __init__(
         self,
         name: str = "runbooks",
-        level: str = "INFO", 
+        level: str = "INFO",
         log_dir: Optional[Path] = None,
         enable_console: bool = True,
         enable_file: bool = True,
@@ -100,17 +102,17 @@ class EnterpriseRichLogger:
         self.log_dir = log_dir or Path.home() / ".runbooks" / "logs"
         self.correlation_id = correlation_id or self._generate_correlation_id()
         self.json_output = json_output
-        
+
         # Initialize Rich console for beautiful output
         self.console = rich_console or (Console() if _HAS_RICH else None)
-        
+
         # User-type specific styling
         self.level_styles = {
             "DEBUG": {"style": "dim white", "icon": "🔧", "label": "TECH"},
             "INFO": {"style": "cyan", "icon": "ℹ️", "label": "INFO"},
             "WARNING": {"style": "yellow bold", "icon": "⚠️", "label": "BIZ"},
             "ERROR": {"style": "red bold", "icon": "❌", "label": "ALL"},
-            "CRITICAL": {"style": "red bold reverse", "icon": "🚨", "label": "ALL"}
+            "CRITICAL": {"style": "red bold reverse", "icon": "🚨", "label": "ALL"},
         }
 
         # Ensure log directory exists
@@ -222,18 +224,20 @@ class EnterpriseRichLogger:
         """Determine if message should be logged based on current log level."""
         level_hierarchy = {"DEBUG": 0, "INFO": 1, "WARNING": 2, "ERROR": 3, "CRITICAL": 4}
         return level_hierarchy.get(level, 0) >= level_hierarchy.get(self.level, 1)
-    
-    def _rich_log(self, level: str, message: str, details: Optional[Dict[str, Any]] = None, progress: Optional[Progress] = None) -> None:
+
+    def _rich_log(
+        self, level: str, message: str, details: Optional[Dict[str, Any]] = None, progress: Optional[Progress] = None
+    ) -> None:
         """Enhanced logging with Rich CLI formatting and user-type specific content."""
         if not self._should_log(level):
             return
-            
+
         # Get level-specific styling
         level_config = self.level_styles.get(level, self.level_styles["INFO"])
         icon = level_config["icon"]
         style = level_config["style"]
         label = level_config["label"]
-        
+
         # Handle JSON output for programmatic use
         if self.json_output:
             log_entry = {
@@ -241,35 +245,39 @@ class EnterpriseRichLogger:
                 "level": level,
                 "correlation_id": self.correlation_id,
                 "message": message,
-                "details": details or {}
+                "details": details or {},
             }
             if self.console:
                 self.console.print_json(data=log_entry)
             else:
                 print(json.dumps(log_entry))
             return
-            
+
         # Rich console output with user-type specific formatting
         if self.console and _HAS_RICH:
             timestamp = datetime.now().strftime("%H:%M:%S")
-            
+
             # User-type specific message formatting
             if level == "DEBUG":
                 # Tech users - Full details with timing and API info
                 self.console.print(f"[dim]{timestamp}[/] {icon} [bold]{label}[/] {message}")
                 if details and "aws_api" in details and details["aws_api"]:
                     api_details = details["aws_api"]
-                    self.console.print(f"    └─ [dim]API: {api_details.get('service', 'unknown')} / {api_details.get('operation', 'unknown')}[/]")
+                    self.console.print(
+                        f"    └─ [dim]API: {api_details.get('service', 'unknown')} / {api_details.get('operation', 'unknown')}[/]"
+                    )
                     if details.get("request_id"):
                         self.console.print(f"    └─ [dim]Request ID: {details['request_id']}[/]")
                 if details.get("duration"):
-                    duration_color = "green" if details["duration"] < 1.0 else "yellow" if details["duration"] < 5.0 else "red"
+                    duration_color = (
+                        "green" if details["duration"] < 1.0 else "yellow" if details["duration"] < 5.0 else "red"
+                    )
                     self.console.print(f"    └─ [dim]Duration: [{duration_color}]{details['duration']:.3f}s[/dim][/]")
                 if details.get("memory_usage"):
                     memory_mb = details["memory_usage"] / 1024 / 1024
                     memory_color = "green" if memory_mb < 50 else "yellow" if memory_mb < 200 else "red"
                     self.console.print(f"    └─ [dim]Memory: [{memory_color}]{memory_mb:.1f}MB[/dim][/]")
-                    
+
             elif level == "INFO":
                 # Standard users - Clean status with progress bars
                 if progress:
@@ -282,27 +290,37 @@ class EnterpriseRichLogger:
                         status_color = "green" if details["operation_status"] == "completed" else "yellow"
                         info_text += f" [{status_color}][{details['operation_status']}][/]"
                     self.console.print(info_text)
-                    
+
             elif level == "WARNING":
                 # Business users - Recommendations and alerts
                 self.console.print(f"{icon} [bold]{label}[/] [{style}]{message}[/]")
                 if details.get("recommendation"):
                     self.console.print(f"    💡 [bright_cyan]Recommendation:[/] {details['recommendation']}")
                 if details.get("cost_impact"):
-                    impact_color = "red" if details["cost_impact"] > 1000 else "yellow" if details["cost_impact"] > 100 else "green"
+                    impact_color = (
+                        "red"
+                        if details["cost_impact"] > 1000
+                        else "yellow"
+                        if details["cost_impact"] > 100
+                        else "green"
+                    )
                     self.console.print(f"    💰 [{impact_color}]Cost Impact:[/] ${details['cost_impact']:,.2f}/month")
                 if details.get("savings_opportunity"):
-                    self.console.print(f"    💎 [bright_green]Savings Opportunity:[/] ${details['savings_opportunity']:,.2f}/month")
+                    self.console.print(
+                        f"    💎 [bright_green]Savings Opportunity:[/] ${details['savings_opportunity']:,.2f}/month"
+                    )
                 if details.get("business_impact"):
                     self.console.print(f"    📊 [bright_blue]Business Impact:[/] {details['business_impact']}")
-                    
+
             elif level in ["ERROR", "CRITICAL"]:
                 # All users - Clear errors with solutions
                 self.console.print(f"{icon} [bold]{label}[/] [{style}]{message}[/]")
                 if details.get("solution"):
                     self.console.print(f"    🔧 [bright_blue]Solution:[/] {details['solution']}")
                 if details.get("suggested_command"):
-                    self.console.print(f"    ⚡ [bright_yellow]Try this command:[/] [cyan]{details['suggested_command']}[/]")
+                    self.console.print(
+                        f"    ⚡ [bright_yellow]Try this command:[/] [cyan]{details['suggested_command']}[/]"
+                    )
                 if details.get("aws_error"):
                     self.console.print(f"    📋 [dim]AWS Error:[/] {details['aws_error']}")
                 if details.get("troubleshooting_steps"):
@@ -312,56 +330,79 @@ class EnterpriseRichLogger:
         else:
             # Fallback to standard logging
             print(f"[{level}] {message}")
-        
+
         # Always log to file systems
         if _HAS_LOGURU:
             loguru_logger.bind(correlation_id=self.correlation_id, **(details or {})).info(f"[{level}] {message}")
         else:
             logging.getLogger(self.name).info(f"[{level}] {message}")
 
-    def debug_tech(self, message: str, aws_api: Optional[Dict[str, str]] = None, duration: Optional[float] = None, 
-                   memory_usage: Optional[int] = None, request_id: Optional[str] = None, **kwargs) -> None:
+    def debug_tech(
+        self,
+        message: str,
+        aws_api: Optional[Dict[str, str]] = None,
+        duration: Optional[float] = None,
+        memory_usage: Optional[int] = None,
+        request_id: Optional[str] = None,
+        **kwargs,
+    ) -> None:
         """Log debug message for tech users (SRE/DevOps) with full API details."""
         details = {
-            "aws_api": aws_api or {}, 
-            "duration": duration, 
+            "aws_api": aws_api or {},
+            "duration": duration,
             "memory_usage": memory_usage,
             "request_id": request_id,
-            **kwargs
+            **kwargs,
         }
         self._rich_log("DEBUG", message, details)
 
-    def info_standard(self, message: str, progress: Optional[Progress] = None, resource_count: Optional[int] = None, 
-                     operation_status: Optional[str] = None, **kwargs) -> None:
+    def info_standard(
+        self,
+        message: str,
+        progress: Optional[Progress] = None,
+        resource_count: Optional[int] = None,
+        operation_status: Optional[str] = None,
+        **kwargs,
+    ) -> None:
         """Log info message for standard users with progress indicators."""
-        details = {
-            "resource_count": resource_count,
-            "operation_status": operation_status,
-            **kwargs
-        }
+        details = {"resource_count": resource_count, "operation_status": operation_status, **kwargs}
         self._rich_log("INFO", message, details, progress)
 
-    def warning_business(self, message: str, recommendation: Optional[str] = None, cost_impact: Optional[float] = None, 
-                        savings_opportunity: Optional[float] = None, business_impact: Optional[str] = None, **kwargs) -> None:
+    def warning_business(
+        self,
+        message: str,
+        recommendation: Optional[str] = None,
+        cost_impact: Optional[float] = None,
+        savings_opportunity: Optional[float] = None,
+        business_impact: Optional[str] = None,
+        **kwargs,
+    ) -> None:
         """Log warning message for business users with recommendations and cost impact."""
         details = {
-            "recommendation": recommendation, 
+            "recommendation": recommendation,
             "cost_impact": cost_impact,
             "savings_opportunity": savings_opportunity,
             "business_impact": business_impact,
-            **kwargs
+            **kwargs,
         }
         self._rich_log("WARNING", message, details)
 
-    def error_all(self, message: str, solution: Optional[str] = None, aws_error: Optional[str] = None, 
-                 suggested_command: Optional[str] = None, troubleshooting_steps: Optional[List[str]] = None, **kwargs) -> None:
+    def error_all(
+        self,
+        message: str,
+        solution: Optional[str] = None,
+        aws_error: Optional[str] = None,
+        suggested_command: Optional[str] = None,
+        troubleshooting_steps: Optional[List[str]] = None,
+        **kwargs,
+    ) -> None:
         """Log error message for all users with clear solutions."""
         details = {
-            "solution": solution, 
+            "solution": solution,
             "aws_error": aws_error,
             "suggested_command": suggested_command,
             "troubleshooting_steps": troubleshooting_steps or [],
-            **kwargs
+            **kwargs,
         }
         self._rich_log("ERROR", message, details)
 
@@ -387,80 +428,87 @@ class EnterpriseRichLogger:
         self._rich_log("CRITICAL", message, kwargs)
 
     # Convenience methods for common operations
-    def log_aws_operation(self, operation: str, service: str, duration: Optional[float] = None, 
-                         success: bool = True, resource_count: Optional[int] = None, **kwargs) -> None:
+    def log_aws_operation(
+        self,
+        operation: str,
+        service: str,
+        duration: Optional[float] = None,
+        success: bool = True,
+        resource_count: Optional[int] = None,
+        **kwargs,
+    ) -> None:
         """Log AWS operation with appropriate level based on success and duration."""
         if not success:
             self.error_all(
                 f"AWS {service} {operation} failed",
                 solution=f"Check AWS permissions for {service}:{operation}",
                 aws_error=kwargs.get("error"),
-                suggested_command=f"aws {service} {operation.replace('_', '-')} --help"
+                suggested_command=f"aws {service} {operation.replace('_', '-')} --help",
             )
         elif self.level == "DEBUG":
             self.debug_tech(
                 f"AWS {service} {operation} completed",
                 aws_api={"service": service, "operation": operation},
                 duration=duration,
-                **kwargs
+                **kwargs,
             )
         else:
             status = "completed" if success else "failed"
             self.info_standard(
                 f"{service.upper()} {operation.replace('_', ' ')} {status}",
                 resource_count=resource_count,
-                operation_status=status
+                operation_status=status,
             )
 
-    def log_cost_analysis(self, operation: str, cost_impact: Optional[float] = None, 
-                         savings_opportunity: Optional[float] = None, recommendation: Optional[str] = None) -> None:
+    def log_cost_analysis(
+        self,
+        operation: str,
+        cost_impact: Optional[float] = None,
+        savings_opportunity: Optional[float] = None,
+        recommendation: Optional[str] = None,
+    ) -> None:
         """Log cost analysis with business-focused messaging."""
         if cost_impact and cost_impact > 100:  # Significant cost impact
             self.warning_business(
                 f"Cost analysis: {operation}",
                 cost_impact=cost_impact,
                 savings_opportunity=savings_opportunity,
-                recommendation=recommendation or f"Review {operation} for optimization opportunities"
+                recommendation=recommendation or f"Review {operation} for optimization opportunities",
             )
         else:
             self.info_standard(f"Cost analysis completed: {operation}")
 
-    def log_performance_metric(self, operation: str, duration: float, threshold: float = 5.0, 
-                              memory_usage: Optional[int] = None) -> None:
+    def log_performance_metric(
+        self, operation: str, duration: float, threshold: float = 5.0, memory_usage: Optional[int] = None
+    ) -> None:
         """Log performance metrics with appropriate warnings."""
         if duration > threshold:
             self.warning_business(
                 f"Performance alert: {operation} took {duration:.2f}s",
                 recommendation=f"Consider optimizing {operation} - target: <{threshold}s",
-                business_impact="May affect user experience during peak hours"
+                business_impact="May affect user experience during peak hours",
             )
         elif self.level == "DEBUG":
-            self.debug_tech(
-                f"Performance: {operation}",
-                duration=duration,
-                memory_usage=memory_usage
-            )
+            self.debug_tech(f"Performance: {operation}", duration=duration, memory_usage=memory_usage)
         else:
             self.info_standard(f"{operation} completed", operation_status="completed")
 
-    def log_security_finding(self, finding: str, severity: str = "medium", 
-                           remediation_steps: Optional[List[str]] = None) -> None:
+    def log_security_finding(
+        self, finding: str, severity: str = "medium", remediation_steps: Optional[List[str]] = None
+    ) -> None:
         """Log security finding with appropriate level and remediation."""
         if severity.lower() in ["high", "critical"]:
             self.error_all(
                 f"Security finding: {finding}",
                 solution=f"Immediate action required for {severity} severity finding",
-                troubleshooting_steps=remediation_steps or [
-                    "Review security policies",
-                    "Apply security patches",
-                    "Contact security team if needed"
-                ]
+                troubleshooting_steps=remediation_steps
+                or ["Review security policies", "Apply security patches", "Contact security team if needed"],
             )
         elif severity.lower() == "medium":
             self.warning_business(
                 f"Security alert: {finding}",
                 recommendation="Schedule remediation within next maintenance window",
-                business_impact="Potential security risk if not addressed"
+                business_impact="Potential security risk if not addressed",
             )
         else:
             self.info_standard(f"Security scan: {finding} ({severity} severity)")
@@ -469,13 +517,14 @@ class EnterpriseRichLogger:
     def operation_context(self, operation_name: str, **context_details):
         """Context manager for logging operation start/end with performance tracking."""
         import time
+
         start_time = time.time()
-        
+
         if self.level == "DEBUG":
             self.debug_tech(f"Starting {operation_name}", **context_details)
         else:
             self.info_standard(f"Starting {operation_name}")
-        
+
         success = True
         try:
             yield self
@@ -484,23 +533,16 @@ class EnterpriseRichLogger:
             self.error_all(
                 f"Operation failed: {operation_name}",
                 solution="Check logs above for detailed error information",
-                aws_error=str(e)
+                aws_error=str(e),
             )
             raise
         finally:
             duration = time.time() - start_time
             if success:
                 if self.level == "DEBUG":
-                    self.debug_tech(
-                        f"Completed {operation_name}",
-                        duration=duration,
-                        **context_details
-                    )
+                    self.debug_tech(f"Completed {operation_name}", duration=duration, **context_details)
                 else:
-                    self.info_standard(
-                        f"Completed {operation_name}",
-                        operation_status="completed"
-                    )
+                    self.info_standard(f"Completed {operation_name}", operation_status="completed")
             else:
                 self.error_all(f"Failed {operation_name} after {duration:.2f}s")
 
@@ -668,6 +710,7 @@ def configure_enterprise_logging(
         json_output=json_output,
     )
 
+
 # Backward compatibility alias
 EnterpriseLogger = EnterpriseRichLogger
 
@@ -761,44 +804,41 @@ def get_logger() -> EnterpriseRichLogger:
 def get_context_logger(level: str = "INFO", json_output: bool = False) -> EnterpriseRichLogger:
     """
     Get context-aware enterprise logger with Rich CLI integration.
-    
+
     This is the recommended way to get a logger instance with proper
     Rich CLI integration and user-type specific formatting.
-    
+
     Args:
         level: Log level (DEBUG, INFO, WARNING, ERROR)
         json_output: Enable structured JSON output
-        
+
     Returns:
         Configured enterprise logger with Rich CLI support
     """
     try:
         from runbooks.common.rich_utils import get_context_aware_console
+
         rich_console = get_context_aware_console()
     except ImportError:
         rich_console = Console() if _HAS_RICH else None
-        
-    return configure_enterprise_logging(
-        level=level,
-        rich_console=rich_console,
-        json_output=json_output
-    )
+
+    return configure_enterprise_logging(level=level, rich_console=rich_console, json_output=json_output)
 
 
 def get_module_logger(module_name: str, level: str = "INFO", json_output: bool = False) -> EnterpriseRichLogger:
     """
     Get a module-specific enhanced logger with automatic correlation ID and module identification.
-    
+
     This is the recommended method for modules to get their logger instance.
-    
+
     Args:
         module_name: Name of the module (e.g., 'finops', 'inventory', 'security')
         level: Log level (DEBUG, INFO, WARNING, ERROR)
         json_output: Enable structured JSON output
-        
+
     Returns:
         Configured enterprise logger with module-specific identification
-        
+
     Example:
         >>> from runbooks.enterprise.logging import get_module_logger
         >>> logger = get_module_logger("finops", level="INFO")
@@ -807,23 +847,21 @@ def get_module_logger(module_name: str, level: str = "INFO", json_output: bool =
     """
     try:
         from runbooks.common.rich_utils import get_context_aware_console
+
         rich_console = get_context_aware_console()
     except ImportError:
         rich_console = Console() if _HAS_RICH else None
-        
+
     logger = EnterpriseRichLogger(
-        name=f"runbooks.{module_name}",
-        level=level,
-        rich_console=rich_console,
-        json_output=json_output
+        name=f"runbooks.{module_name}", level=level, rich_console=rich_console, json_output=json_output
     )
-    
+
     # Add module-specific initialization message
     if level == "DEBUG":
         logger.debug_tech(
             f"Module logger initialized for {module_name}",
             aws_api={"service": "logging", "operation": "module_init"},
-            duration=0.001
+            duration=0.001,
         )
-    
+
     return logger