runbooks 0.7.7__py3-none-any.whl → 0.9.0__py3-none-any.whl

runbooks/operate/dynamodb_operations.py

@@ -20,9 +20,13 @@ from typing import Any, Dict, List, Optional, Union
 import boto3
 from botocore.exceptions import BotoCoreError, ClientError
 from loguru import logger
+from rich.console import Console
 
 from runbooks.operate.base import BaseOperation, OperationContext, OperationResult, OperationStatus
 
+# Initialize Rich console for enhanced CLI output
+console = Console()
+
 
 class DynamoDBOperations(BaseOperation):
     """
@@ -746,8 +750,8 @@ def main():
     import sys
 
     if len(sys.argv) < 2:
-        print("Usage: python dynamodb_operations.py <operation> [args...]")
-        print("Operations: put, delete, batch-write, create-table, backup-table")
+        console.print("[yellow]Usage: python dynamodb_operations.py <operation> [args...][/yellow]")
+        console.print("[blue]Operations: put, delete, batch-write, create-table, backup-table[/blue]")
         sys.exit(1)
 
     operation = sys.argv[1]
@@ -794,14 +798,14 @@ def main():
         else:
             raise ValueError(f"Unknown operation: {operation}")
 
-        # Print results
+        # Print results with Rich formatting
         for result in results:
             if result.success:
-                print(f"✅ {result.operation_type} completed successfully")
+                console.print(f"[green]✅ {result.operation_type} completed successfully[/green]")
                 if result.response_data:
-                    print(f"   Data: {json.dumps(result.response_data, default=str, indent=2)}")
+                    console.print(f"[blue]   Data: {json.dumps(result.response_data, default=str, indent=2)}[/blue]")
             else:
-                print(f"❌ {result.operation_type} failed: {result.error_message}")
+                console.print(f"[red]❌ {result.operation_type} failed: {result.error_message}[/red]")
 
     except Exception as e:
         logger.error(f"Error during operation: {e}")

runbooks/operate/ec2_operations.py

@@ -21,14 +21,18 @@ Version: 2.0.0 - Enterprise Enhancement
 import base64
 import json
 import os
-from datetime import datetime
+from datetime import datetime, timedelta
 from typing import Any, Dict, List, Optional, Union
 
 import boto3
 from botocore.exceptions import BotoCoreError, ClientError
 from loguru import logger
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+from rich.table import Table
 
-from runbooks.operate.base import BaseOperation, OperationContext, OperationResult, OperationStatus
+from runbooks.operate.base import BaseOperation, OperationContext, OperationResult, OperationStatus, console
 
 
 class EC2Operations(BaseOperation):
@@ -52,6 +56,9 @@ class EC2Operations(BaseOperation):
         "cleanup_unused_volumes",
         "cleanup_unused_eips",
         "reboot_instances",
+        "analyze_rightsizing",
+        "optimize_instance_types",
+        "generate_cost_recommendations",
     }
     requires_confirmation = True
 
@@ -96,7 +103,7 @@ class EC2Operations(BaseOperation):
         """
         if not arn.startswith("arn:aws:sns:"):
             raise ValueError(f"Invalid SNS Topic ARN: {arn}")
-        logger.info(f"✅ Valid SNS ARN: {arn}")
+        console.print(f"[green]✅ Valid SNS ARN: {arn}[/green]")
 
     def validate_regions(self, source_region: str, dest_region: str) -> None:
         """
@@ -116,7 +123,7 @@ class EC2Operations(BaseOperation):
             raise ValueError(f"Invalid source region: {source_region}")
         if dest_region not in valid_regions:
             raise ValueError(f"Invalid destination region: {dest_region}")
-        logger.info(f"Validated AWS regions: {source_region} -> {dest_region}")
+        console.print(f"[blue]🌍 Validated AWS regions: {source_region} -> {dest_region}[/blue]")
 
     def send_sns_notification(self, subject: str, message: str) -> None:
         """
@@ -193,17 +200,23 @@ class EC2Operations(BaseOperation):
 
             try:
                 if context.dry_run:
-                    logger.info(f"[DRY-RUN] Would start instance {instance_id}")
+                    console.print(
+                        Panel(
+                            f"[yellow]Would start instance {instance_id}[/yellow]",
+                            title="🏃 DRY-RUN MODE",
+                            border_style="yellow",
+                        )
+                    )
                     result.mark_completed(OperationStatus.DRY_RUN)
                 else:
                     response = self.execute_aws_call(ec2_client, "start_instances", InstanceIds=[instance_id])
                     result.response_data = response
                     result.mark_completed(OperationStatus.SUCCESS)
-                    logger.info(f"Successfully started instance {instance_id}")
+                    console.print(f"[green]✅ Successfully started instance {instance_id}[/green]")
 
             except ClientError as e:
                 error_msg = f"Failed to start instance {instance_id}: {e}"
-                logger.error(error_msg)
+                console.print(f"[red]❌ {error_msg}[/red]")
                 result.mark_completed(OperationStatus.FAILED, error_msg)
 
             results.append(result)
@@ -772,6 +785,303 @@ class EC2Operations(BaseOperation):
 
         return results
 
+    def analyze_rightsizing(self, context: OperationContext, days: int = 14) -> OperationResult:
+        """
+        Analyze EC2 instances for rightsizing opportunities using CloudWatch metrics.
+
+        Args:
+            context: Operation execution context
+            days: Number of days to analyze (default: 14)
+
+        Returns:
+            OperationResult with rightsizing recommendations
+        """
+        result = OperationResult(
+            operation_id=f"analyze_rightsizing_{context.account_id}",
+            operation_name="analyze_rightsizing",
+            resource_id=f"account:{context.account_id}",
+            resource_type="account",
+        )
+
+        try:
+            # Get all running instances
+            response = self.client.describe_instances(Filters=[{"Name": "instance-state-name", "Values": ["running"]}])
+
+            rightsizing_recommendations = []
+            cloudwatch = boto3.client("cloudwatch", region_name=context.region)
+
+            for reservation in response["Reservations"]:
+                for instance in reservation["Instances"]:
+                    instance_id = instance["InstanceId"]
+                    current_type = instance["InstanceType"]
+
+                    # Get CPU utilization metrics
+                    cpu_metrics = cloudwatch.get_metric_statistics(
+                        Namespace="AWS/EC2",
+                        MetricName="CPUUtilization",
+                        Dimensions=[{"Name": "InstanceId", "Value": instance_id}],
+                        StartTime=datetime.utcnow() - timedelta(days=days),
+                        EndTime=datetime.utcnow(),
+                        Period=3600,
+                        Statistics=["Average", "Maximum"],
+                    )
+
+                    if cpu_metrics["Datapoints"]:
+                        avg_cpu = sum(dp["Average"] for dp in cpu_metrics["Datapoints"]) / len(
+                            cpu_metrics["Datapoints"]
+                        )
+                        max_cpu = max(dp["Maximum"] for dp in cpu_metrics["Datapoints"])
+
+                        recommendation = self._generate_rightsizing_recommendation(
+                            instance_id, current_type, avg_cpu, max_cpu
+                        )
+
+                        if recommendation:
+                            rightsizing_recommendations.append(recommendation)
+
+            result.add_output("rightsizing_recommendations", rightsizing_recommendations)
+            result.add_output("total_instances_analyzed", sum(len(r["Instances"]) for r in response["Reservations"]))
+            result.add_output("optimization_opportunities", len(rightsizing_recommendations))
+
+            result.mark_completed(
+                OperationStatus.SUCCESS, f"Analyzed {len(rightsizing_recommendations)} rightsizing opportunities"
+            )
+
+        except Exception as e:
+            error_msg = f"Failed to analyze rightsizing opportunities: {e}"
+            logger.error(error_msg)
+            result.mark_completed(OperationStatus.FAILED, error_msg)
+
+        return result
+
+    def optimize_instance_types(self, context: OperationContext, recommendations: List[Dict]) -> List[OperationResult]:
+        """
+        Apply instance type optimizations based on rightsizing recommendations.
+
+        Args:
+            context: Operation execution context
+            recommendations: List of rightsizing recommendations
+
+        Returns:
+            List of OperationResults for each optimization
+        """
+        results = []
+
+        for rec in recommendations:
+            result = OperationResult(
+                operation_id=f"optimize_{rec['instance_id']}",
+                operation_name="optimize_instance_types",
+                resource_id=rec["instance_id"],
+                resource_type="ec2_instance",
+            )
+
+            try:
+                instance_id = rec["instance_id"]
+                new_instance_type = rec["recommended_type"]
+
+                if context.dry_run:
+                    result.add_output("action", "DRY_RUN")
+                    result.add_output("would_change_type", f"{rec['current_type']} -> {new_instance_type}")
+                    result.add_output("estimated_monthly_savings", rec.get("estimated_savings", 0))
+                    result.mark_completed(
+                        OperationStatus.SUCCESS, f"DRY RUN: Would optimize {instance_id} to {new_instance_type}"
+                    )
+                else:
+                    # Stop instance first
+                    self.client.stop_instances(InstanceIds=[instance_id])
+
+                    # Wait for instance to stop
+                    waiter = self.client.get_waiter("instance_stopped")
+                    waiter.wait(InstanceIds=[instance_id])
+
+                    # Modify instance type
+                    self.client.modify_instance_attribute(
+                        InstanceId=instance_id, InstanceType={"Value": new_instance_type}
+                    )
+
+                    # Start instance
+                    self.client.start_instances(InstanceIds=[instance_id])
+
+                    result.add_output("action", "OPTIMIZED")
+                    result.add_output("previous_type", rec["current_type"])
+                    result.add_output("new_type", new_instance_type)
+                    result.add_output("estimated_monthly_savings", rec.get("estimated_savings", 0))
+
+                    result.mark_completed(
+                        OperationStatus.SUCCESS, f"Successfully optimized {instance_id} to {new_instance_type}"
+                    )
+
+            except Exception as e:
+                error_msg = f"Failed to optimize instance {rec['instance_id']}: {e}"
+                logger.error(error_msg)
+                result.mark_completed(OperationStatus.FAILED, error_msg)
+
+            results.append(result)
+
+        return results
+
+    def generate_cost_recommendations(
+        self, context: OperationContext, target_savings_pct: float = 30.0
+    ) -> OperationResult:
+        """
+        Generate comprehensive cost optimization recommendations for EC2 resources.
+
+        Args:
+            context: Operation execution context
+            target_savings_pct: Target savings percentage (default: 30%)
+
+        Returns:
+            OperationResult with cost recommendations
+        """
+        result = OperationResult(
+            operation_id=f"cost_recommendations_{context.account_id}",
+            operation_name="generate_cost_recommendations",
+            resource_id=f"account:{context.account_id}",
+            resource_type="account",
+        )
+
+        try:
+            recommendations = []
+            total_monthly_spend = 0
+            potential_savings = 0
+
+            # Analyze rightsizing opportunities
+            rightsizing_result = self.analyze_rightsizing(context)
+            if rightsizing_result.status == OperationStatus.SUCCESS:
+                rightsizing_recs = rightsizing_result.outputs.get("rightsizing_recommendations", [])
+                for rec in rightsizing_recs:
+                    recommendations.append(
+                        {
+                            "type": "rightsizing",
+                            "resource_id": rec["instance_id"],
+                            "current_cost": rec.get("current_monthly_cost", 0),
+                            "optimized_cost": rec.get("optimized_monthly_cost", 0),
+                            "monthly_savings": rec.get("estimated_savings", 0),
+                            "recommendation": f"Rightsize {rec['current_type']} to {rec['recommended_type']}",
+                            "risk_level": "low",
+                            "implementation_effort": "medium",
+                        }
+                    )
+                    total_monthly_spend += rec.get("current_monthly_cost", 0)
+                    potential_savings += rec.get("estimated_savings", 0)
+
+            # Analyze unused resources
+            unused_volumes = self.cleanup_unused_volumes(context)
+            if hasattr(unused_volumes, "outputs") and unused_volumes.outputs.get("unused_volumes"):
+                for volume in unused_volumes.outputs["unused_volumes"]:
+                    volume_cost = volume.get("monthly_cost", 50)  # Estimate $50/month per unused volume
+                    recommendations.append(
+                        {
+                            "type": "resource_cleanup",
+                            "resource_id": volume["VolumeId"],
+                            "current_cost": volume_cost,
+                            "optimized_cost": 0,
+                            "monthly_savings": volume_cost,
+                            "recommendation": f"Delete unused EBS volume {volume['VolumeId']}",
+                            "risk_level": "low",
+                            "implementation_effort": "low",
+                        }
+                    )
+                    total_monthly_spend += volume_cost
+                    potential_savings += volume_cost
+
+            # Calculate overall metrics
+            if total_monthly_spend > 0:
+                savings_percentage = (potential_savings / total_monthly_spend) * 100
+                meets_target = savings_percentage >= target_savings_pct
+            else:
+                savings_percentage = 0
+                meets_target = False
+
+            result.add_output("recommendations", recommendations)
+            result.add_output("total_recommendations", len(recommendations))
+            result.add_output("current_monthly_spend", total_monthly_spend)
+            result.add_output("potential_monthly_savings", potential_savings)
+            result.add_output("potential_annual_savings", potential_savings * 12)
+            result.add_output("savings_percentage", savings_percentage)
+            result.add_output("meets_target", meets_target)
+            result.add_output("target_savings_pct", target_savings_pct)
+
+            result.mark_completed(
+                OperationStatus.SUCCESS,
+                f"Generated {len(recommendations)} cost optimization recommendations with {savings_percentage:.1f}% potential savings",
+            )
+
+        except Exception as e:
+            error_msg = f"Failed to generate cost recommendations: {e}"
+            logger.error(error_msg)
+            result.mark_completed(OperationStatus.FAILED, error_msg)
+
+        return result
+
+    def _generate_rightsizing_recommendation(
+        self, instance_id: str, current_type: str, avg_cpu: float, max_cpu: float
+    ) -> Optional[Dict]:
+        """Generate rightsizing recommendation based on CPU metrics."""
+        # Instance type cost mapping (simplified for demonstration)
+        type_costs = {
+            "t3.nano": 4,
+            "t3.micro": 8,
+            "t3.small": 17,
+            "t3.medium": 34,
+            "t3.large": 67,
+            "t3.xlarge": 134,
+            "t3.2xlarge": 268,
+            "m5.large": 78,
+            "m5.xlarge": 156,
+            "m5.2xlarge": 312,
+            "m5.4xlarge": 624,
+            "c5.large": 73,
+            "c5.xlarge": 146,
+            "c5.2xlarge": 292,
+            "c5.4xlarge": 584,
+        }
+
+        current_monthly_cost = type_costs.get(current_type, 100)
+
+        # Rightsizing logic based on CPU utilization
+        if avg_cpu < 10 and max_cpu < 25:
+            # Significantly underutilized - downsize by 2 levels
+            if "xlarge" in current_type:
+                recommended_type = current_type.replace("xlarge", "large")
+            elif "large" in current_type:
+                recommended_type = current_type.replace("large", "medium")
+            elif "medium" in current_type:
+                recommended_type = current_type.replace("medium", "small")
+            else:
+                return None  # Already smallest size
+
+        elif avg_cpu < 20 and max_cpu < 50:
+            # Underutilized - downsize by 1 level
+            if "2xlarge" in current_type:
+                recommended_type = current_type.replace("2xlarge", "xlarge")
+            elif "xlarge" in current_type:
+                recommended_type = current_type.replace("xlarge", "large")
+            elif "large" in current_type:
+                recommended_type = current_type.replace("large", "medium")
+            else:
+                return None  # Already optimal or too small
+        else:
+            return None  # No optimization needed
+
+        optimized_monthly_cost = type_costs.get(recommended_type, current_monthly_cost * 0.7)
+        estimated_savings = current_monthly_cost - optimized_monthly_cost
+
+        if estimated_savings > 5:  # Only recommend if savings > $5/month
+            return {
+                "instance_id": instance_id,
+                "current_type": current_type,
+                "recommended_type": recommended_type,
+                "avg_cpu_utilization": avg_cpu,
+                "max_cpu_utilization": max_cpu,
+                "current_monthly_cost": current_monthly_cost,
+                "optimized_monthly_cost": optimized_monthly_cost,
+                "estimated_savings": estimated_savings,
+                "confidence": "high" if avg_cpu < 15 else "medium",
+            }
+
+        return None
+
 
 # Lambda handlers to append to ec2_operations.py
 
@@ -873,8 +1183,8 @@ def main():
     import sys
 
     if len(sys.argv) < 2:
-        print("Usage: python ec2_operations.py <operation>")
-        print("Operations: terminate, run, cleanup-volumes, cleanup-eips")
+        console.print("[yellow]Usage: python ec2_operations.py <operation>[/yellow]")
+        console.print("[blue]Operations: terminate, run, cleanup-volumes, cleanup-eips[/blue]")
         sys.exit(1)
 
     operation = sys.argv[1]
@@ -913,9 +1223,9 @@ def main():
 
         for result in results:
             if result.success:
-                print(f"✅ {result.operation_type} completed successfully")
+                console.print(f"[green]✅ {result.operation_type} completed successfully[/green]")
             else:
-                print(f"❌ {result.operation_type} failed: {result.error_message}")
+                console.print(f"[red]❌ {result.operation_type} failed: {result.error_message}[/red]")
 
     except Exception as e:
         logger.error(f"Error during operation: {e}")