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

runbooks/common/patterns.py

@@ -81,17 +81,17 @@ class DRYPatternManager:
             return
 
         # Common import patterns
-        cls._patterns['click'] = click
-        cls._patterns['console'] = cls.get_console()
+        cls._patterns["click"] = click
+        cls._patterns["console"] = cls.get_console()
 
         # Error handling patterns
-        cls._patterns['error_handlers'] = cls._create_error_handlers()
+        cls._patterns["error_handlers"] = cls._create_error_handlers()
 
         # Click group patterns
-        cls._patterns['click_group'] = cls._create_click_group_pattern()
+        cls._patterns["click_group"] = cls._create_click_group_pattern()
 
         # Common CLI decorators reference
-        cls._patterns['common_decorators'] = cls._get_common_decorators()
+        cls._patterns["common_decorators"] = cls._get_common_decorators()
 
         cls._loaded = True
 
@@ -119,9 +119,9 @@ class DRYPatternManager:
                 console.print(f"[dim]{details}[/dim]")
 
         return {
-            'module_not_available': module_not_available_error,
-            'operation_failed': operation_failed_error,
-            'success': success_message
+            "module_not_available": module_not_available_error,
+            "operation_failed": operation_failed_error,
+            "success": success_message,
         }
 
     @classmethod
@@ -131,6 +131,7 @@ class DRYPatternManager:
 
         Eliminates 6 instances of identical @click.group patterns.
         """
+
         def create_group(name: str, help_text: str, invoke_without_command: bool = True):
             """Create standardized Click group with common options."""
 
@@ -153,15 +154,12 @@ class DRYPatternManager:
     def _get_common_decorators(cls):
         """Reference to common decorators - avoid importing in every module."""
         try:
-            from runbooks.common.decorators import (
-                common_aws_options,
-                common_output_options,
-                common_filter_options
-            )
+            from runbooks.common.decorators import common_aws_options, common_output_options, common_filter_options
+
             return {
-                'aws_options': common_aws_options,
-                'output_options': common_output_options,
-                'filter_options': common_filter_options
+                "aws_options": common_aws_options,
+                "output_options": common_output_options,
+                "filter_options": common_filter_options,
             }
         except ImportError:
             # Graceful degradation if decorators not available
@@ -176,17 +174,17 @@ def get_console() -> Console:
 
 def get_error_handlers() -> Dict[str, Callable]:
     """Get standardized error handlers."""
-    return DRYPatternManager.get_pattern('error_handlers')
+    return DRYPatternManager.get_pattern("error_handlers")
 
 
 def get_click_group_creator() -> Callable:
     """Get standardized Click group creator."""
-    return DRYPatternManager.get_pattern('click_group')
+    return DRYPatternManager.get_pattern("click_group")
 
 
 def get_common_decorators() -> Dict[str, Any]:
     """Get common CLI decorators."""
-    return DRYPatternManager.get_pattern('common_decorators')
+    return DRYPatternManager.get_pattern("common_decorators")
 
 
 # Pattern registry status for monitoring
@@ -198,9 +196,9 @@ def get_pattern_registry_status() -> Dict[str, Any]:
         Dictionary containing registry status, loaded patterns, and memory efficiency metrics
     """
     return {
-        'loaded': DRYPatternManager._loaded,
-        'pattern_count': len(DRYPatternManager._patterns),
-        'available_patterns': list(DRYPatternManager._patterns.keys()),
-        'console_shared': DRYPatternManager._console is not None,
-        'memory_efficiency': 'Single instance sharing active'
-    }
+        "loaded": DRYPatternManager._loaded,
+        "pattern_count": len(DRYPatternManager._patterns),
+        "available_patterns": list(DRYPatternManager._patterns.keys()),
+        "console_shared": DRYPatternManager._console is not None,
+        "memory_efficiency": "Single instance sharing active",
+    }

runbooks/common/performance_monitoring.py

@@ -25,14 +25,21 @@ from datetime import datetime
 import json
 
 from runbooks.common.rich_utils import (
-    console, print_success, print_warning, print_info, print_error,
-    create_table, create_progress_bar, STATUS_INDICATORS
+    console,
+    print_success,
+    print_warning,
+    print_info,
+    print_error,
+    create_table,
+    create_progress_bar,
+    STATUS_INDICATORS,
 )
 
 
 @dataclass
 class PerformanceMetrics:
     """Enterprise performance metrics tracking."""
+
     operation_name: str
     module_name: str
     start_time: float
@@ -68,21 +75,22 @@ class PerformanceMetrics:
             "api_calls": self.api_calls_count,
             "success": self.success,
             "business_value": self.business_value,
-            "resources_processed": self.resources_processed
+            "resources_processed": self.resources_processed,
         }
 
 
 @dataclass
 class ModulePerformanceTargets:
     """Module-specific performance targets for enterprise operations."""
-    finops: int = 15        # FinOps cost analysis operations
-    inventory: int = 45     # Multi-account discovery operations
-    operate: int = 15       # Resource operations with safety validation
-    security: int = 45      # Comprehensive security assessments
-    cfat: int = 60          # Cloud foundations assessments
-    vpc: int = 30           # Network analysis with cost integration
-    remediation: int = 15   # Automated security remediation
-    sre: int = 30           # Site reliability engineering operations
+
+    finops: int = 15  # FinOps cost analysis operations
+    inventory: int = 45  # Multi-account discovery operations
+    operate: int = 15  # Resource operations with safety validation
+    security: int = 45  # Comprehensive security assessments
+    cfat: int = 60  # Cloud foundations assessments
+    vpc: int = 30  # Network analysis with cost integration
+    remediation: int = 15  # Automated security remediation
+    sre: int = 30  # Site reliability engineering operations
 
     def get_target(self, module_name: str) -> int:
         """Get performance target for module."""
@@ -107,10 +115,12 @@ def reset_api_counter():
     _api_call_counter = 0
 
 
-def monitor_performance(module_name: str = "runbooks",
-                       operation_name: Optional[str] = None,
-                       target_seconds: Optional[int] = None,
-                       track_memory: bool = True):
+def monitor_performance(
+    module_name: str = "runbooks",
+    operation_name: Optional[str] = None,
+    target_seconds: Optional[int] = None,
+    track_memory: bool = True,
+):
     """
     Decorator for comprehensive performance monitoring.
 
@@ -128,6 +138,7 @@ def monitor_performance(module_name: str = "runbooks",
         def analyze_costs(**kwargs):
             # Your operation code here
     """
+
     def decorator(f: Callable) -> Callable:
         @wraps(f)
         def wrapper(*args, **kwargs):
@@ -143,7 +154,7 @@ def monitor_performance(module_name: str = "runbooks",
                 module_name=module_name,
                 start_time=time.time(),
                 end_time=0.0,
-                target_seconds=target
+                target_seconds=target,
             )
 
             # Start memory tracking if enabled
@@ -166,8 +177,8 @@ def monitor_performance(module_name: str = "runbooks",
 
                 # Extract business metrics if available
                 if isinstance(result, dict):
-                    metrics.business_value = result.get('annual_savings', 0.0)
-                    metrics.resources_processed = result.get('resources_count', 0)
+                    metrics.business_value = result.get("annual_savings", 0.0)
+                    metrics.resources_processed = result.get("resources_count", 0)
 
                 # Capture performance data
                 metrics.api_calls_count = _api_call_counter
@@ -205,6 +216,7 @@ def monitor_performance(module_name: str = "runbooks",
                 raise
 
         return wrapper
+
     return decorator
 
 
@@ -221,8 +233,7 @@ def _provide_performance_feedback(metrics: PerformanceMetrics):
     if execution_time <= target:
         # Performance target met
         print_success(
-            f"⚡ Performance: {execution_time:.1f}s "
-            f"(target: <{target}s) - {metrics.efficiency_score:.1f}% efficient"
+            f"⚡ Performance: {execution_time:.1f}s (target: <{target}s) - {metrics.efficiency_score:.1f}% efficient"
         )
 
         # Celebrate exceptional performance
@@ -232,8 +243,7 @@ def _provide_performance_feedback(metrics: PerformanceMetrics):
     else:
         # Performance target exceeded
         print_warning(
-            f"⚠️ Performance: {execution_time:.1f}s "
-            f"(exceeded {target}s target by {execution_time - target:.1f}s)"
+            f"⚠️ Performance: {execution_time:.1f}s (exceeded {target}s target by {execution_time - target:.1f}s)"
         )
 
         # Provide optimization recommendations
@@ -269,16 +279,10 @@ def _provide_optimization_recommendations(metrics: PerformanceMetrics):
     module_recommendations = {
         "finops": [
             "Use more specific date ranges to reduce Cost Explorer data",
-            "Consider account filtering for large organizations"
+            "Consider account filtering for large organizations",
         ],
-        "inventory": [
-            "Use service-specific discovery instead of full scan",
-            "Implement parallel account processing"
-        ],
-        "security": [
-            "Focus on high-priority security checks first",
-            "Use incremental scanning for large environments"
-        ]
+        "inventory": ["Use service-specific discovery instead of full scan", "Implement parallel account processing"],
+        "security": ["Focus on high-priority security checks first", "Use incremental scanning for large environments"],
     }
 
     if metrics.module_name in module_recommendations:
@@ -286,8 +290,7 @@ def _provide_optimization_recommendations(metrics: PerformanceMetrics):
             print_info(f"  • {rec}")
 
 
-def benchmark_operation(module_name: str, operation_name: str,
-                       target_calls: int = 10):
+def benchmark_operation(module_name: str, operation_name: str, target_calls: int = 10):
     """
     Decorator for benchmarking operation performance over multiple runs.
 
@@ -301,6 +304,7 @@ def benchmark_operation(module_name: str, operation_name: str,
         def analyze_costs(**kwargs):
             # Your operation code here
     """
+
     def decorator(f: Callable) -> Callable:
         @wraps(f)
         def wrapper(*args, **kwargs):
@@ -313,8 +317,7 @@ def benchmark_operation(module_name: str, operation_name: str,
 
                 # Execute with monitoring
                 monitored_func = monitor_performance(
-                    module_name=module_name,
-                    operation_name=f"{operation_name}_benchmark_{run+1}"
+                    module_name=module_name, operation_name=f"{operation_name}_benchmark_{run + 1}"
                 )(f)
 
                 result = monitored_func(*args, **kwargs)
@@ -329,6 +332,7 @@ def benchmark_operation(module_name: str, operation_name: str,
             return result
 
         return wrapper
+
     return decorator
 
 
@@ -360,28 +364,30 @@ def _analyze_benchmark_results(results: List[PerformanceMetrics], operation_name
         columns=[
             {"name": "Metric", "style": "cyan"},
             {"name": "Value", "style": "green"},
-            {"name": "Assessment", "style": "yellow"}
-        ]
+            {"name": "Assessment", "style": "yellow"},
+        ],
     )
 
     target = results[0].target_seconds
 
-    table.add_row("Average Time", f"{avg_time:.2f}s",
-                  "✅ Good" if avg_time <= target else "⚠️ Needs optimization")
-    table.add_row("Best Time", f"{min_time:.2f}s",
-                  "🏆 Excellent" if min_time <= target * 0.5 else "✅ Good")
-    table.add_row("Worst Time", f"{max_time:.2f}s",
-                  "⚠️ Investigate" if max_time > target * 1.5 else "✅ Acceptable")
-    table.add_row("Success Rate", f"{len(execution_times)}/{len(results)}",
-                  "✅ Perfect" if len(execution_times) == len(results) else "⚠️ Some failures")
-    table.add_row("Consistency", f"±{(max_time - min_time):.2f}s",
-                  "✅ Consistent" if (max_time - min_time) <= target * 0.2 else "⚠️ Variable")
+    table.add_row("Average Time", f"{avg_time:.2f}s", "✅ Good" if avg_time <= target else "⚠️ Needs optimization")
+    table.add_row("Best Time", f"{min_time:.2f}s", "🏆 Excellent" if min_time <= target * 0.5 else "✅ Good")
+    table.add_row("Worst Time", f"{max_time:.2f}s", "⚠️ Investigate" if max_time > target * 1.5 else "✅ Acceptable")
+    table.add_row(
+        "Success Rate",
+        f"{len(execution_times)}/{len(results)}",
+        "✅ Perfect" if len(execution_times) == len(results) else "⚠️ Some failures",
+    )
+    table.add_row(
+        "Consistency",
+        f"±{(max_time - min_time):.2f}s",
+        "✅ Consistent" if (max_time - min_time) <= target * 0.2 else "⚠️ Variable",
+    )
 
     console.print(table)
 
 
-def get_performance_report(module_name: Optional[str] = None,
-                          last_n_operations: int = 10) -> Dict[str, Any]:
+def get_performance_report(module_name: Optional[str] = None, last_n_operations: int = 10) -> Dict[str, Any]:
     """
     Generate performance report for operations.
 
@@ -395,8 +401,7 @@ def get_performance_report(module_name: Optional[str] = None,
     # Filter operations
     filtered_operations = _performance_history
     if module_name:
-        filtered_operations = [op for op in filtered_operations
-                             if op.module_name == module_name]
+        filtered_operations = [op for op in filtered_operations if op.module_name == module_name]
 
     # Get recent operations
     recent_operations = filtered_operations[-last_n_operations:]
@@ -418,10 +423,10 @@ def get_performance_report(module_name: Optional[str] = None,
             "failed_operations": len(failed_ops),
             "success_rate_percent": (len(successful_ops) / len(recent_operations)) * 100,
             "average_execution_time": round(avg_time, 2),
-            "average_efficiency_score": round(avg_efficiency, 1)
+            "average_efficiency_score": round(avg_efficiency, 1),
         },
         "operations": [op.to_dict() for op in recent_operations],
-        "recommendations": _generate_performance_recommendations(recent_operations)
+        "recommendations": _generate_performance_recommendations(recent_operations),
     }
 
     return report
@@ -435,17 +440,12 @@ def _generate_performance_recommendations(operations: List[PerformanceMetrics])
         return recommendations
 
     # Analyze patterns
-    slow_operations = [op for op in operations
-                      if op.success and op.performance_ratio > 1.5]
-    high_memory_operations = [op for op in operations
-                             if op.memory_peak_mb > 150]
-    high_api_operations = [op for op in operations
-                          if op.api_calls_count > 50]
+    slow_operations = [op for op in operations if op.success and op.performance_ratio > 1.5]
+    high_memory_operations = [op for op in operations if op.memory_peak_mb > 150]
+    high_api_operations = [op for op in operations if op.api_calls_count > 50]
 
     if slow_operations:
-        recommendations.append(
-            f"⚠️ {len(slow_operations)} operations exceeded target by >50% - consider optimization"
-        )
+        recommendations.append(f"⚠️ {len(slow_operations)} operations exceeded target by >50% - consider optimization")
 
     if high_memory_operations:
         recommendations.append(
@@ -453,16 +453,12 @@ def _generate_performance_recommendations(operations: List[PerformanceMetrics])
         )
 
     if high_api_operations:
-        recommendations.append(
-            f"🔄 {len(high_api_operations)} operations made >50 API calls - consider caching"
-        )
+        recommendations.append(f"🔄 {len(high_api_operations)} operations made >50 API calls - consider caching")
 
     # Success rate recommendations
     failed_ops = [op for op in operations if not op.success]
     if len(failed_ops) > len(operations) * 0.1:  # >10% failure rate
-        recommendations.append(
-            "❌ High failure rate detected - review error handling and retry logic"
-        )
+        recommendations.append("❌ High failure rate detected - review error handling and retry logic")
 
     return recommendations
 
@@ -487,7 +483,7 @@ def export_performance_data(output_path: str = "performance_report.json") -> boo
     try:
         report = get_performance_report()
 
-        with open(output_path, 'w') as f:
+        with open(output_path, "w") as f:
             json.dump(report, f, indent=2)
 
         print_success(f"Performance data exported to {output_path}")
@@ -508,5 +504,5 @@ __all__ = [
     "reset_api_counter",
     "get_performance_report",
     "clear_performance_history",
-    "export_performance_data"
-]
+    "export_performance_data",
+]