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

runbooks/common/enhanced_exception_handler.py

@@ -326,7 +326,7 @@ class EnterpriseExceptionHandler:
         # Defensive check for None values
         if execution_time is None or performance_target is None or performance_target == 0:
             return None
-            
+
         performance_ratio = execution_time / performance_target
 
         # Only create error if performance significantly exceeded (>150% of target)
@@ -974,11 +974,21 @@ class EnterpriseExceptionHandler:
     def _initialize_profile_recommendations(self) -> Dict[str, List[str]]:
         """Initialize profile recommendations for different operations with universal support."""
         import os
+
         # Environment variable-driven profile recommendations
         return {
-            "inventory": [os.getenv("MANAGEMENT_PROFILE", "management-profile"), os.getenv("CENTRALISED_OPS_PROFILE", "ops-profile")],
-            "operate": [os.getenv("CENTRALISED_OPS_PROFILE", "ops-profile"), os.getenv("MANAGEMENT_PROFILE", "management-profile")],
-            "finops": [os.getenv("BILLING_PROFILE", "billing-profile"), os.getenv("MANAGEMENT_PROFILE", "management-profile")],
+            "inventory": [
+                os.getenv("MANAGEMENT_PROFILE", "management-profile"),
+                os.getenv("CENTRALISED_OPS_PROFILE", "ops-profile"),
+            ],
+            "operate": [
+                os.getenv("CENTRALISED_OPS_PROFILE", "ops-profile"),
+                os.getenv("MANAGEMENT_PROFILE", "management-profile"),
+            ],
+            "finops": [
+                os.getenv("BILLING_PROFILE", "billing-profile"),
+                os.getenv("MANAGEMENT_PROFILE", "management-profile"),
+            ],
             "security": [os.getenv("MANAGEMENT_PROFILE", "management-profile")],
             "cfat": [os.getenv("MANAGEMENT_PROFILE", "management-profile")],
         }
@@ -994,6 +1004,7 @@ class EnterpriseExceptionHandler:
         if service == "ce" and error_code == "AccessDenied":
             # Cost Explorer requires special billing permissions
             import os
+
             base_analysis["recommended_profiles"] = [os.getenv("BILLING_PROFILE", "billing-profile")]
 
         return base_analysis

runbooks/common/enhanced_logging_example.py

@@ -15,158 +15,144 @@ from runbooks.enterprise.logging import get_context_logger, EnterpriseRichLogger
 
 class EnhancedLoggingExample:
     """Demonstrates enhanced logging integration patterns for different user types."""
-    
+
     def __init__(self, log_level: str = "INFO", json_output: bool = False):
         """
         Initialize with enhanced logger.
-        
+
         Args:
             log_level: Logging level (DEBUG, INFO, WARNING, ERROR)
             json_output: Enable structured JSON output
         """
         self.logger = get_context_logger(level=log_level, json_output=json_output)
         self.log_level = log_level.upper()
-    
+
     def demonstrate_debug_logging(self):
         """Demonstrate DEBUG level logging for tech users (SRE/DevOps)."""
         print("\n=== DEBUG Level Logging (Tech Users) ===")
-        
+
         # AWS API tracing example
         start_time = time.time()
-        
+
         # Simulate AWS API call
         time.sleep(0.1)
         duration = time.time() - start_time
-        
+
         self.logger.debug_tech(
             "EC2 instances discovered in region us-east-1",
-            aws_api={
-                "service": "ec2",
-                "operation": "describe_instances",
-                "region": "us-east-1"
-            },
+            aws_api={"service": "ec2", "operation": "describe_instances", "region": "us-east-1"},
             duration=duration,
             request_id="12345-abcde-67890",
-            resource_count=42
+            resource_count=42,
         )
-        
+
         # Performance metrics
         self.logger.debug_tech(
             "Cost analysis query executed",
-            aws_api={
-                "service": "ce",
-                "operation": "get_cost_and_usage"
-            },
+            aws_api={"service": "ce", "operation": "get_cost_and_usage"},
             duration=2.435,
             data_points=1500,
-            cache_hit=False
+            cache_hit=False,
         )
-    
+
     def demonstrate_info_logging(self):
         """Demonstrate INFO level logging for standard users."""
         print("\n=== INFO Level Logging (Standard Users) ===")
-        
+
         # Standard operation status
         self.logger.info_standard("Starting cost analysis for account 123456789012")
-        
+
         # Progress indication
         self.logger.info_standard("Processing 15 AWS services across 3 regions")
-        
+
         # Completion status
         self.logger.info_standard(
-            "Cost analysis completed successfully",
-            execution_time="12.3s",
-            resources_analyzed=245
+            "Cost analysis completed successfully", execution_time="12.3s", resources_analyzed=245
         )
-    
+
     def demonstrate_warning_logging(self):
         """Demonstrate WARNING level logging for business users."""
         print("\n=== WARNING Level Logging (Business Users) ===")
-        
+
         # Cost alerts with recommendations
         self.logger.warning_business(
             "High storage costs detected in S3",
             recommendation="Consider implementing lifecycle policies for objects older than 90 days",
             cost_impact=2847.50,
-            affected_buckets=12
+            affected_buckets=12,
         )
-        
+
         # Resource optimization alerts
         self.logger.warning_business(
             "Underutilized EC2 instances found",
             recommendation="Review instance sizing for potential rightsizing opportunities",
             cost_impact=1250.00,
-            instance_count=8
+            instance_count=8,
         )
-        
+
         # Budget threshold warnings
         self.logger.warning_business(
             "Monthly budget threshold exceeded",
             recommendation="Review cost allocation and consider implementing cost controls",
             cost_impact=450.75,
-            budget_utilization="105%"
+            budget_utilization="105%",
         )
-    
+
     def demonstrate_error_logging(self):
         """Demonstrate ERROR level logging for all users."""
         print("\n=== ERROR Level Logging (All Users) ===")
-        
+
         # AWS authentication errors
         self.logger.error_all(
             "Unable to access Cost Explorer API",
             solution="Run 'aws sso login' to refresh your authentication tokens",
             aws_error="ExpiredToken: Token has expired",
-            profile="billing-profile"
+            profile="billing-profile",
         )
-        
+
         # Configuration errors
         self.logger.error_all(
             "Invalid AWS profile configuration",
             solution="Check your ~/.aws/config file or contact your AWS administrator",
-            aws_error="ProfileNotFound: The config profile (invalid-profile) could not be found"
+            aws_error="ProfileNotFound: The config profile (invalid-profile) could not be found",
         )
-        
+
         # Service access errors
         self.logger.error_all(
             "Insufficient permissions for Organizations API",
             solution="Request 'organizations:ListAccounts' permission or use a different profile",
-            aws_error="AccessDenied: User is not authorized to perform organizations:ListAccounts"
+            aws_error="AccessDenied: User is not authorized to perform organizations:ListAccounts",
         )
-    
+
     def demonstrate_structured_logging(self):
         """Demonstrate structured JSON logging for programmatic use."""
         print("\n=== Structured JSON Logging (Programmatic Use) ===")
-        
+
         # Create JSON logger
         json_logger = get_context_logger(level=self.log_level, json_output=True)
-        
+
         # JSON structured logs
         json_logger.info_standard(
             "Cost analysis completed",
             total_cost=15432.75,
             account_count=5,
-            service_breakdown={
-                "EC2": 8750.25,
-                "S3": 3200.50,
-                "RDS": 2482.00,
-                "Lambda": 1000.00
-            }
+            service_breakdown={"EC2": 8750.25, "S3": 3200.50, "RDS": 2482.00, "Lambda": 1000.00},
         )
-        
+
         json_logger.warning_business(
             "Budget variance detected",
             recommendation="Implement cost controls",
             cost_impact=2500.00,
-            variance_percentage=15.2
+            variance_percentage=15.2,
         )
-    
+
     def demonstrate_contextual_logging(self):
         """Demonstrate context-aware logging based on execution environment."""
         print("\n=== Context-Aware Logging ===")
-        
+
         # Logging adapts to CLI vs Jupyter vs CI/CD environments
         self.logger.info_standard("Environment-aware logging initialized")
-        
+
         # Performance logging with context
         with self.logger_performance_context("cost_analysis_operation") as perf:
             # Simulate work
@@ -181,27 +167,27 @@ def demo_user_type_scenarios():
     """
     print("Enhanced Multi-Level Logging System Demo")
     print("=" * 50)
-    
+
     # Tech users (DEBUG level)
     print("\n🔧 TECH USER SCENARIO (--log-level DEBUG)")
     tech_demo = EnhancedLoggingExample(log_level="DEBUG")
     tech_demo.demonstrate_debug_logging()
-    
-    # Standard users (INFO level) 
+
+    # Standard users (INFO level)
     print("\n👥 STANDARD USER SCENARIO (--log-level INFO)")
     standard_demo = EnhancedLoggingExample(log_level="INFO")
     standard_demo.demonstrate_info_logging()
-    
+
     # Business users (WARNING level)
     print("\n💼 BUSINESS USER SCENARIO (--log-level WARNING)")
     business_demo = EnhancedLoggingExample(log_level="WARNING")
     business_demo.demonstrate_warning_logging()
-    
+
     # Error scenarios (ERROR level)
     print("\n🚨 ERROR SCENARIOS (--log-level ERROR)")
     error_demo = EnhancedLoggingExample(log_level="ERROR")
     error_demo.demonstrate_error_logging()
-    
+
     # JSON output for automation
     print("\n📄 STRUCTURED JSON OUTPUT (--json-output)")
     json_demo = EnhancedLoggingExample(log_level="INFO", json_output=True)
@@ -211,21 +197,21 @@ def demo_user_type_scenarios():
 # Performance context manager for demonstration
 class MockPerformanceContext:
     """Mock performance context for demonstration."""
-    
+
     def __init__(self, operation_name: str):
         self.operation_name = operation_name
         self.metrics = {}
         self.start_time = time.time()
-    
+
     def __enter__(self):
         return self
-    
+
     def __exit__(self, exc_type, exc_val, exc_tb):
         duration = time.time() - self.start_time
         print(f"Performance: {self.operation_name} completed in {duration:.3f}s")
         if self.metrics:
             print(f"Metrics: {self.metrics}")
-    
+
     def add_metric(self, key: str, value: Any):
         self.metrics[key] = value
 
@@ -236,4 +222,4 @@ EnhancedLoggingExample.logger_performance_context = lambda self, name: MockPerfo
 
 if __name__ == "__main__":
     """Run the enhanced logging demonstration."""
-    demo_user_type_scenarios()
+    demo_user_type_scenarios()

runbooks/common/enhanced_logging_integration_example.py

@@ -12,14 +12,14 @@ multi-level logging architecture for user-type specific content.
 runbooks finops --log-level DEBUG --profile my-profile
 ```
 
-### Standard Users (INFO level - default)  
+### Standard Users (INFO level - default)
 ```bash
 runbooks finops --profile my-profile
 ```
 
 ### Business Users (WARNING level)
 ```bash
-runbooks finops --log-level WARNING --profile my-profile  
+runbooks finops --log-level WARNING --profile my-profile
 ```
 
 ### Error Focus (ERROR level)
@@ -47,7 +47,7 @@ class EnhancedLoggingIntegrationExample:
     def __init__(self, module_name: str = "example", log_level: str = "INFO", json_output: bool = False):
         """
         Initialize with enhanced logging.
-        
+
         Args:
             module_name: Name of the module
             log_level: Logging level (DEBUG, INFO, WARNING, ERROR)
@@ -63,21 +63,39 @@ class EnhancedLoggingIntegrationExample:
 
         # Simulate AWS operations with different outcomes
         operations = [
-            {"service": "cost-explorer", "operation": "get_cost_and_usage", "duration": 0.8, "success": True, "resource_count": 25},
-            {"service": "ec2", "operation": "describe_instances", "duration": 1.2, "success": True, "resource_count": 10},
+            {
+                "service": "cost-explorer",
+                "operation": "get_cost_and_usage",
+                "duration": 0.8,
+                "success": True,
+                "resource_count": 25,
+            },
+            {
+                "service": "ec2",
+                "operation": "describe_instances",
+                "duration": 1.2,
+                "success": True,
+                "resource_count": 10,
+            },
             {"service": "s3", "operation": "list_buckets", "duration": 0.3, "success": True, "resource_count": 5},
-            {"service": "iam", "operation": "get_account_summary", "duration": 15.2, "success": False, "error": "AccessDenied: Insufficient permissions"}
+            {
+                "service": "iam",
+                "operation": "get_account_summary",
+                "duration": 15.2,
+                "success": False,
+                "error": "AccessDenied: Insufficient permissions",
+            },
         ]
 
         for op in operations:
             self.logger.log_aws_operation(
                 operation=op["operation"],
-                service=op["service"], 
+                service=op["service"],
                 duration=op["duration"],
                 success=op["success"],
                 resource_count=op.get("resource_count"),
                 error=op.get("error"),
-                request_id=f"req-{int(time.time())}-{hash(op['service']) % 10000}"
+                request_id=f"req-{int(time.time())}-{hash(op['service']) % 10000}",
             )
             time.sleep(0.1)  # Brief pause for demonstration
 
@@ -88,23 +106,23 @@ class EnhancedLoggingIntegrationExample:
 
         cost_scenarios = [
             {
-                "operation": "monthly_ec2_spend_analysis", 
-                "cost_impact": 2500.0, 
+                "operation": "monthly_ec2_spend_analysis",
+                "cost_impact": 2500.0,
                 "savings_opportunity": 750.0,
-                "recommendation": "Consider Reserved Instances for consistent workloads"
+                "recommendation": "Consider Reserved Instances for consistent workloads",
             },
             {
                 "operation": "s3_storage_optimization",
                 "cost_impact": 150.0,
-                "savings_opportunity": 45.0, 
-                "recommendation": "Implement lifecycle policies for infrequent access data"
+                "savings_opportunity": 45.0,
+                "recommendation": "Implement lifecycle policies for infrequent access data",
             },
             {
                 "operation": "unused_eip_analysis",
                 "cost_impact": 50.0,
                 "savings_opportunity": 50.0,
-                "recommendation": "Release 10 unused Elastic IPs immediately"
-            }
+                "recommendation": "Release 10 unused Elastic IPs immediately",
+            },
         ]
 
         for scenario in cost_scenarios:
@@ -117,9 +135,19 @@ class EnhancedLoggingIntegrationExample:
         print("=" * 60)
 
         performance_scenarios = [
-            {"operation": "inventory_collection", "duration": 2.1, "threshold": 5.0, "memory_usage": 52428800},  # Fast operation
-            {"operation": "large_cost_analysis", "duration": 8.5, "threshold": 5.0, "memory_usage": 104857600},  # Slow operation
-            {"operation": "security_scan", "duration": 0.8, "threshold": 2.0, "memory_usage": 26214400}  # Quick scan
+            {
+                "operation": "inventory_collection",
+                "duration": 2.1,
+                "threshold": 5.0,
+                "memory_usage": 52428800,
+            },  # Fast operation
+            {
+                "operation": "large_cost_analysis",
+                "duration": 8.5,
+                "threshold": 5.0,
+                "memory_usage": 104857600,
+            },  # Slow operation
+            {"operation": "security_scan", "duration": 0.8, "threshold": 2.0, "memory_usage": 26214400},  # Quick scan
         ]
 
         for scenario in performance_scenarios:
@@ -137,9 +165,9 @@ class EnhancedLoggingIntegrationExample:
                 "severity": "high",
                 "remediation_steps": [
                     "Review bucket policy for public access",
-                    "Remove public read permissions if not required", 
-                    "Enable bucket logging for audit trail"
-                ]
+                    "Remove public read permissions if not required",
+                    "Enable bucket logging for audit trail",
+                ],
             },
             {
                 "finding": "IAM user without MFA enabled",
@@ -147,14 +175,14 @@ class EnhancedLoggingIntegrationExample:
                 "remediation_steps": [
                     "Enable MFA for the affected user",
                     "Review IAM policies for excessive permissions",
-                    "Consider using IAM roles instead of users"
-                ]
+                    "Consider using IAM roles instead of users",
+                ],
             },
             {
                 "finding": "Security group with overly permissive rules",
                 "severity": "low",
-                "remediation_steps": ["Review and tighten security group rules"]
-            }
+                "remediation_steps": ["Review and tighten security group rules"],
+            },
         ]
 
         for finding in security_findings:
@@ -185,16 +213,16 @@ class EnhancedLoggingIntegrationExample:
         """Demonstrate JSON output for programmatic use."""
         print(f"\n📋 JSON OUTPUT EXAMPLE ({self.log_level} level)")
         print("=" * 60)
-        
+
         # Create a JSON logger
         json_logger = get_module_logger("example_json", level=self.log_level, json_output=True)
-        
+
         json_logger.info_standard("JSON output demonstration", resource_count=42, operation_status="completed")
         json_logger.log_cost_analysis(
             "json_cost_analysis",
             cost_impact=1200.0,
             savings_opportunity=360.0,
-            recommendation="Optimize resource allocation for cost efficiency"
+            recommendation="Optimize resource allocation for cost efficiency",
         )
 
     def run_all_demonstrations(self):
@@ -209,8 +237,8 @@ class EnhancedLoggingIntegrationExample:
         self.demonstrate_performance_logging()
         self.demonstrate_security_logging()
         self.demonstrate_operation_context()
-        
-        if not hasattr(self.logger, 'json_output') or not self.logger.json_output:
+
+        if not hasattr(self.logger, "json_output") or not self.logger.json_output:
             self.demonstrate_json_output()
 
     def _get_user_type_description(self) -> str:
@@ -218,8 +246,8 @@ class EnhancedLoggingIntegrationExample:
         descriptions = {
             "DEBUG": "Tech Users (SRE/DevOps) - Full technical details, API traces, performance metrics",
             "INFO": "Standard Users - Clean operation status, progress indicators, business-friendly output",
-            "WARNING": "Business Users - Cost insights, recommendations, optimization opportunities", 
-            "ERROR": "All Users - Clear error messages with solutions and troubleshooting steps"
+            "WARNING": "Business Users - Cost insights, recommendations, optimization opportunities",
+            "ERROR": "All Users - Clear error messages with solutions and troubleshooting steps",
         }
         return descriptions.get(self.log_level, "Unknown user type")
 
@@ -230,28 +258,28 @@ def main():
     print("=" * 80)
     print("This demonstration shows how logging adapts content based on user type:")
     print("• DEBUG Level: Technical users (SRE/DevOps)")
-    print("• INFO Level: Standard users (default)")  
+    print("• INFO Level: Standard users (default)")
     print("• WARNING Level: Business users")
     print("• ERROR Level: All users (minimal output)")
     print("=" * 80)
 
     # Test all log levels
     log_levels = ["DEBUG", "INFO", "WARNING", "ERROR"]
-    
+
     for level in log_levels:
         demo = EnhancedLoggingIntegrationExample("enhanced_logging_demo", level)
         demo.run_all_demonstrations()
-        
+
         if level != "ERROR":  # Add separator except for last level
             print(f"\n{'=' * 80}\n")
 
     print("\n✅ DEMONSTRATION COMPLETE")
     print("\nTo use enhanced logging in your module:")
-    print("1. from runbooks.enterprise.logging import get_module_logger")  
+    print("1. from runbooks.enterprise.logging import get_module_logger")
     print("2. logger = get_module_logger('your_module_name')")
     print("3. Use logger.info_standard(), logger.debug_tech(), logger.warning_business(), etc.")
     print("4. Use logger.log_aws_operation(), logger.log_cost_analysis() for convenience")
 
 
 if __name__ == "__main__":
-    main()
+    main()

runbooks/common/env_utils.py

@@ -12,13 +12,13 @@ from typing import Union
 def get_required_env(var_name: str) -> str:
     """
     Get required string environment variable - NO hardcoded defaults.
-    
+
     Args:
         var_name: Environment variable name
-        
+
     Returns:
         Environment variable value
-        
+
     Raises:
         ValueError: If environment variable is not set
     """
@@ -31,13 +31,13 @@ def get_required_env(var_name: str) -> str:
 def get_required_env_int(var_name: str) -> int:
     """
     Get required integer environment variable - NO hardcoded defaults.
-    
+
     Args:
         var_name: Environment variable name
-        
+
     Returns:
         Environment variable value as integer
-        
+
     Raises:
         ValueError: If environment variable is not set or not a valid integer
     """
@@ -51,13 +51,13 @@ def get_required_env_int(var_name: str) -> int:
 def get_required_env_float(var_name: str) -> float:
     """
     Get required float environment variable - NO hardcoded defaults.
-    
+
     Args:
         var_name: Environment variable name
-        
+
     Returns:
         Environment variable value as float
-        
+
     Raises:
         ValueError: If environment variable is not set or not a valid float
     """
@@ -71,20 +71,20 @@ def get_required_env_float(var_name: str) -> float:
 def get_required_env_bool(var_name: str) -> bool:
     """
     Get required boolean environment variable - NO hardcoded defaults.
-    
+
     Args:
         var_name: Environment variable name
-        
+
     Returns:
         Environment variable value as boolean
-        
+
     Raises:
         ValueError: If environment variable is not set
     """
     value = get_required_env(var_name).lower()
-    if value in ('true', '1', 'yes', 'on'):
+    if value in ("true", "1", "yes", "on"):
         return True
-    elif value in ('false', '0', 'no', 'off'):
+    elif value in ("false", "0", "no", "off"):
         return False
     else:
         raise ValueError(f"Environment variable {var_name} must be a valid boolean (true/false), got: {value}")
@@ -92,5 +92,5 @@ def get_required_env_bool(var_name: str) -> bool:
 
 # Legacy compatibility function names for existing code
 _get_required_env_float = get_required_env_float
-_get_required_env_int = get_required_env_int 
-_get_required_env = get_required_env
+_get_required_env_int = get_required_env_int
+_get_required_env = get_required_env