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

runbooks/monitoring/performance_monitor.py

@@ -417,10 +417,15 @@ if __name__ == "__main__":
     # REMOVED: Random performance simulation violates enterprise standards
     # Use real performance metrics from actual AWS operations
     # TODO: Replace with actual performance tracking from live operations
-    for i, (module, operation) in enumerate([
-        ("inventory", "collect"), ("finops", "analyze"), ("security", "assess"),
-        ("operate", "scan"), ("vpc", "analyze")
-    ]):
+    for i, (module, operation) in enumerate(
+        [
+            ("inventory", "collect"),
+            ("finops", "analyze"),
+            ("security", "assess"),
+            ("operate", "scan"),
+            ("vpc", "analyze"),
+        ]
+    ):
         # Use deterministic test data until real metrics are implemented
         exec_time = 1.5  # Consistent performance target
         success = True  # Default success until real error tracking

runbooks/operate/dynamodb_operations.py

@@ -75,7 +75,9 @@ class DynamoDBOperations(BaseOperation):
         self.dry_run = dry_run or os.getenv("DRY_RUN", "false").lower() == "true"
 
         # DynamoDB-specific environment variables from original file - NO hardcoded defaults
-        self.default_table_name = table_name or os.getenv("TABLE_NAME", "employees")  # Table name needs default for compatibility
+        self.default_table_name = table_name or os.getenv(
+            "TABLE_NAME", "employees"
+        )  # Table name needs default for compatibility
         self.max_batch_items = get_required_env_int("MAX_BATCH_ITEMS")
 
         super().__init__(self.profile, self.region, self.dry_run)

runbooks/operate/ec2_operations.py

@@ -195,9 +195,7 @@ class EC2Operations(BaseOperation):
             return self.reboot_instances(context, kwargs.get("instance_ids", []))
         elif operation_type == "get_ebs_volumes_with_low_usage":
             return self.get_ebs_volumes_with_low_usage(
-                context, 
-                kwargs.get("threshold_days", 10),
-                kwargs.get("usage_threshold", 10.0)
+                context, kwargs.get("threshold_days", 10), kwargs.get("usage_threshold", 10.0)
             )
         elif operation_type == "delete_volumes_by_id":
             return self.delete_volumes_by_id(context, kwargs.get("volume_data", []))
@@ -703,63 +701,60 @@ class EC2Operations(BaseOperation):
     ) -> List[OperationResult]:
         """
         Find EBS volumes with low usage based on CloudWatch VolumeUsage metric.
-        
+
         Migrated from unSkript notebook: AWS_Delete_EBS_Volumes_With_Low_Usage.ipynb
         Function: aws_get_ebs_volume_for_low_usage()
-        
+
         Args:
             context: Operation execution context
             threshold_days: Number of days to analyze usage
             usage_threshold: Usage percentage threshold (default: 10.0)
-            
+
         Returns:
             List of OperationResults with low usage volumes found
         """
         ec2_client = self.get_client("ec2", context.region)
         cloudwatch_client = self.get_client("cloudwatch", context.region)
-        
+
         result = self.create_operation_result(context, "get_ebs_volumes_with_low_usage", "ec2:volume", "analysis")
-        
+
         try:
             console.print(f"[blue]🔍 Analyzing EBS volume usage over {threshold_days} days...[/blue]")
-            
+
             # Get all volumes - migrated logic from unSkript notebook
             volumes_response = self.execute_aws_call(ec2_client, "describe_volumes")
             low_usage_volumes = []
-            
+
             now = datetime.utcnow()
             days_ago = now - timedelta(days=threshold_days)
-            
+
             with Progress(
                 SpinnerColumn(),
                 TextColumn("[progress.description]{task.description}"),
                 transient=True,
             ) as progress:
-                task = progress.add_task(f"Analyzing {len(volumes_response['Volumes'])} volumes...", total=len(volumes_response['Volumes']))
-                
+                task = progress.add_task(
+                    f"Analyzing {len(volumes_response['Volumes'])} volumes...", total=len(volumes_response["Volumes"])
+                )
+
                 for volume in volumes_response["Volumes"]:
                     volume_id = volume["VolumeId"]
-                    
+
                     try:
                         # Get CloudWatch metrics for volume usage - exact logic from unSkript
                         cloudwatch_response = cloudwatch_client.get_metric_statistics(
-                            Namespace='AWS/EBS',
-                            MetricName='VolumeUsage',
-                            Dimensions=[
-                                {
-                                    'Name': 'VolumeId',
-                                    'Value': volume_id
-                                }
-                            ],
+                            Namespace="AWS/EBS",
+                            MetricName="VolumeUsage",
+                            Dimensions=[{"Name": "VolumeId", "Value": volume_id}],
                             StartTime=days_ago,
                             EndTime=now,
                             Period=3600,
-                            Statistics=['Average']
+                            Statistics=["Average"],
                         )
-                        
+
                         # Analyze usage data - migrated from unSkript logic
-                        for datapoint in cloudwatch_response.get('Datapoints', []):
-                            if datapoint['Average'] < usage_threshold:
+                        for datapoint in cloudwatch_response.get("Datapoints", []):
+                            if datapoint["Average"] < usage_threshold:
                                 ebs_volume = {
                                     "volume_id": volume_id,
                                     "region": context.region,
@@ -768,32 +763,36 @@ class EC2Operations(BaseOperation):
                                     "volume_type": volume.get("VolumeType", "unknown"),
                                     "encrypted": volume.get("Encrypted", False),
                                     "create_time": str(volume["CreateTime"]),
-                                    "average_usage": datapoint['Average'],
-                                    "timestamp": str(datapoint['Timestamp'])
+                                    "average_usage": datapoint["Average"],
+                                    "timestamp": str(datapoint["Timestamp"]),
                                 }
                                 low_usage_volumes.append(ebs_volume)
-                                logger.debug(f"Low usage volume found: {volume_id} (avg usage: {datapoint['Average']:.2f}%)")
+                                logger.debug(
+                                    f"Low usage volume found: {volume_id} (avg usage: {datapoint['Average']:.2f}%)"
+                                )
                                 break
-                                
+
                     except ClientError as e:
                         # Handle individual volume metric errors gracefully
                         logger.warning(f"Could not get metrics for volume {volume_id}: {e}")
                         continue
-                    
+
                     progress.update(task, advance=1)
-            
+
             result.response_data = {
                 "low_usage_volumes": low_usage_volumes,
                 "count": len(low_usage_volumes),
                 "total_scanned": len(volumes_response["Volumes"]),
                 "threshold_days": threshold_days,
-                "usage_threshold": usage_threshold
+                "usage_threshold": usage_threshold,
             }
             result.mark_completed(OperationStatus.SUCCESS)
-            
+
             if low_usage_volumes:
-                console.print(f"[yellow]⚠️  Found {len(low_usage_volumes)} volumes with usage < {usage_threshold}%[/yellow]")
-                
+                console.print(
+                    f"[yellow]⚠️  Found {len(low_usage_volumes)} volumes with usage < {usage_threshold}%[/yellow]"
+                )
+
                 # Create Rich table for display
                 table = Table(title=f"Low Usage EBS Volumes (< {usage_threshold}%)")
                 table.add_column("Volume ID", style="cyan")
@@ -801,76 +800,80 @@ class EC2Operations(BaseOperation):
                 table.add_column("Type", style="green")
                 table.add_column("Usage %", justify="right", style="red")
                 table.add_column("State")
-                
+
                 for vol in low_usage_volumes[:10]:  # Show first 10
                     table.add_row(
                         vol["volume_id"],
                         str(vol["size"]),
                         vol["volume_type"],
                         f"{vol['average_usage']:.2f}%",
-                        vol["state"]
+                        vol["state"],
                     )
-                    
+
                 console.print(table)
-                
+
                 if len(low_usage_volumes) > 10:
                     console.print(f"[dim]... and {len(low_usage_volumes) - 10} more volumes[/dim]")
-                    
+
                 # SNS notification
-                message = f"Found {len(low_usage_volumes)} EBS volumes with usage < {usage_threshold}% in {context.region}"
+                message = (
+                    f"Found {len(low_usage_volumes)} EBS volumes with usage < {usage_threshold}% in {context.region}"
+                )
                 self.send_sns_notification("Low Usage EBS Volumes Detected", message)
             else:
                 console.print(f"[green]✅ No volumes found with usage < {usage_threshold}%[/green]")
-                
+
         except Exception as e:
             error_msg = f"Failed to analyze EBS volume usage: {e}"
             logger.error(error_msg)
             result.mark_completed(OperationStatus.FAILED, error_msg)
-            
+
         return [result]
-    
-    def delete_volumes_by_id(self, context: OperationContext, volume_data: List[Dict[str, str]]) -> List[OperationResult]:
+
+    def delete_volumes_by_id(
+        self, context: OperationContext, volume_data: List[Dict[str, str]]
+    ) -> List[OperationResult]:
         """
         Delete EBS volumes by ID with safety checks and confirmation.
-        
+
         Migrated from unSkript notebook: AWS_Delete_EBS_Volumes_With_Low_Usage.ipynb
         Function: aws_delete_volume_by_id()
-        
+
         Args:
             context: Operation execution context
             volume_data: List of dicts with 'volume_id' and 'region' keys
-            
+
         Returns:
             List of OperationResults for each volume deletion attempt
         """
         results = []
-        
+
         for vol_data in volume_data:
             volume_id = vol_data.get("volume_id")
             region = vol_data.get("region", context.region)
-            
+
             ec2_client = self.get_client("ec2", region)
             result = self.create_operation_result(context, "delete_volumes_by_id", "ec2:volume", volume_id)
-            
+
             try:
                 # Safety confirmation - enhanced from original
                 if not self.confirm_operation(context, volume_id, "delete EBS volume"):
                     result.mark_completed(OperationStatus.CANCELLED, "Operation cancelled by user")
                     results.append(result)
                     continue
-                
+
                 if context.dry_run:
                     console.print(f"[yellow]🏃 DRY-RUN: Would delete volume {volume_id} in {region}[/yellow]")
                     result.mark_completed(OperationStatus.DRY_RUN)
                 else:
                     # Execute deletion - exact logic from unSkript
                     delete_response = self.execute_aws_call(ec2_client, "delete_volume", VolumeId=volume_id)
-                    
+
                     result.response_data = delete_response
                     result.mark_completed(OperationStatus.SUCCESS)
                     console.print(f"[green]✅ Successfully deleted volume {volume_id}[/green]")
                     logger.info(f"Deleted EBS volume: {volume_id} in {region}")
-                    
+
             except ClientError as e:
                 error_msg = f"Failed to delete volume {volume_id}: {e}"
                 console.print(f"[red]❌ {error_msg}[/red]")
@@ -881,18 +884,22 @@ class EC2Operations(BaseOperation):
                 console.print(f"[red]❌ {error_msg}[/red]")
                 logger.error(error_msg)
                 result.mark_completed(OperationStatus.FAILED, error_msg)
-                
+
             results.append(result)
-        
+
         # Summary reporting
         successful_deletions = [r.resource_id for r in results if r.success]
         if successful_deletions:
-            message = f"Successfully deleted {len(successful_deletions)} EBS volumes: {', '.join(successful_deletions[:5])}"
+            message = (
+                f"Successfully deleted {len(successful_deletions)} EBS volumes: {', '.join(successful_deletions[:5])}"
+            )
             if len(successful_deletions) > 5:
                 message += f" and {len(successful_deletions) - 5} more"
             self.send_sns_notification("EBS Volumes Deleted", message)
-            console.print(f"[green]🎯 Deletion Summary: {len(successful_deletions)}/{len(results)} volumes deleted successfully[/green]")
-        
+            console.print(
+                f"[green]🎯 Deletion Summary: {len(successful_deletions)}/{len(results)} volumes deleted successfully[/green]"
+            )
+
         return results
 
     def cleanup_unused_eips(self, context: OperationContext) -> List[OperationResult]:
@@ -1387,26 +1394,25 @@ def lambda_handler_run_instances(event, context):
         logger.error(f"Lambda Handler Error: {e}")
         return {"statusCode": 500, "body": {"error": str(e)}}
 
-
-# CLI Support
+    # CLI Support
     def list_unattached_elastic_ips(self, context: OperationContext) -> List[OperationResult]:
         """
         Find all unattached Elastic IPs across regions.
-        
+
         Extracted from: AWS_Release_Unattached_Elastic_IPs.ipynb
-        
+
         Args:
             context: Operation execution context
-            
+
         Returns:
             List of OperationResults with unattached Elastic IPs
         """
         console.print("[bold cyan]Scanning for unattached Elastic IPs...[/bold cyan]")
         results = []
-        
+
         # Get all regions to check
         regions_to_check = [context.region] if context.region else self._get_all_regions()
-        
+
         for region in regions_to_check:
             result = OperationResult(
                 operation_id=f"list_unattached_eips_{region}",
@@ -1414,65 +1420,61 @@ def lambda_handler_run_instances(event, context):
                 resource_id=f"region:{region}",
                 resource_type="elastic_ip",
             )
-            
+
             try:
                 # Create EC2 client for specific region
-                ec2_client = boto3.client('ec2', region_name=region)
-                
+                ec2_client = boto3.client("ec2", region_name=region)
+
                 # Get all Elastic IPs in region
                 response = ec2_client.describe_addresses()
                 unattached_eips = []
-                
-                for eip in response.get('Addresses', []):
+
+                for eip in response.get("Addresses", []):
                     # Check if EIP is not attached (no AssociationId)
-                    if 'AssociationId' not in eip:
+                    if "AssociationId" not in eip:
                         eip_info = {
-                            'public_ip': eip.get('PublicIp'),
-                            'allocation_id': eip.get('AllocationId'),
-                            'region': region,
-                            'domain': eip.get('Domain', 'vpc'),
-                            'network_interface_id': eip.get('NetworkInterfaceId'),
-                            'private_ip': eip.get('PrivateIpAddress'),
-                            'tags': eip.get('Tags', [])
+                            "public_ip": eip.get("PublicIp"),
+                            "allocation_id": eip.get("AllocationId"),
+                            "region": region,
+                            "domain": eip.get("Domain", "vpc"),
+                            "network_interface_id": eip.get("NetworkInterfaceId"),
+                            "private_ip": eip.get("PrivateIpAddress"),
+                            "tags": eip.get("Tags", []),
                         }
                         unattached_eips.append(eip_info)
-                
+
                 if unattached_eips:
                     result.add_output("unattached_eips", unattached_eips)
                     result.add_output("count", len(unattached_eips))
                     result.add_output("monthly_cost", len(unattached_eips) * 3.60)  # $3.60/month per EIP
                     result.mark_completed(
-                        OperationStatus.SUCCESS,
-                        f"Found {len(unattached_eips)} unattached Elastic IPs in {region}"
+                        OperationStatus.SUCCESS, f"Found {len(unattached_eips)} unattached Elastic IPs in {region}"
                     )
                     console.print(f"[yellow]Found {len(unattached_eips)} unattached EIPs in {region}[/yellow]")
                 else:
-                    result.mark_completed(
-                        OperationStatus.SUCCESS,
-                        f"No unattached Elastic IPs found in {region}"
-                    )
-                    
+                    result.mark_completed(OperationStatus.SUCCESS, f"No unattached Elastic IPs found in {region}")
+
             except ClientError as e:
                 error_msg = f"Failed to list Elastic IPs in {region}: {e}"
                 logger.error(error_msg)
                 result.mark_completed(OperationStatus.FAILED, error_msg)
                 console.print(f"[red]Error scanning {region}: {e}[/red]")
-                
+
             results.append(result)
-            
+
         return results
 
     def release_elastic_ip(self, context: OperationContext, allocation_id: str, region: str) -> OperationResult:
         """
         Release (delete) an unattached Elastic IP.
-        
+
         Extracted from: AWS_Release_Unattached_Elastic_IPs.ipynb
-        
+
         Args:
             context: Operation execution context
             allocation_id: Allocation ID of the Elastic IP
             region: AWS region where the EIP exists
-            
+
         Returns:
             OperationResult with release status
         """
@@ -1482,18 +1484,15 @@ def lambda_handler_run_instances(event, context):
             resource_id=allocation_id,
             resource_type="elastic_ip",
         )
-        
+
         try:
-            ec2_client = boto3.client('ec2', region_name=region)
-            
+            ec2_client = boto3.client("ec2", region_name=region)
+
             if context.dry_run:
                 result.add_output("action", "DRY_RUN")
                 result.add_output("would_release", allocation_id)
                 result.add_output("monthly_savings", 3.60)
-                result.mark_completed(
-                    OperationStatus.SUCCESS,
-                    f"DRY RUN: Would release Elastic IP {allocation_id}"
-                )
+                result.mark_completed(OperationStatus.SUCCESS, f"DRY RUN: Would release Elastic IP {allocation_id}")
                 console.print(f"[yellow]DRY RUN: Would release EIP {allocation_id}[/yellow]")
             else:
                 # Actually release the Elastic IP
@@ -1501,27 +1500,24 @@ def lambda_handler_run_instances(event, context):
                 result.add_output("response", response)
                 result.add_output("released", True)
                 result.add_output("monthly_savings", 3.60)
-                result.mark_completed(
-                    OperationStatus.SUCCESS,
-                    f"Successfully released Elastic IP {allocation_id}"
-                )
+                result.mark_completed(OperationStatus.SUCCESS, f"Successfully released Elastic IP {allocation_id}")
                 console.print(f"[green]✅ Released Elastic IP {allocation_id}[/green]")
-                
+
         except ClientError as e:
             error_msg = f"Failed to release Elastic IP {allocation_id}: {e}"
             logger.error(error_msg)
             result.mark_completed(OperationStatus.FAILED, error_msg)
             console.print(f"[red]❌ Failed to release {allocation_id}: {e}[/red]")
-            
+
         return result
 
     def get_elastic_ip_cost_impact(self, context: OperationContext) -> OperationResult:
         """
         Calculate cost impact of unattached Elastic IPs.
-        
+
         Args:
             context: Operation execution context
-            
+
         Returns:
             OperationResult with cost analysis
         """
@@ -1531,79 +1527,86 @@ def lambda_handler_run_instances(event, context):
             resource_id=f"account:{context.account_id}",
             resource_type="cost_analysis",
         )
-        
+
         try:
             # Get all unattached EIPs
             eip_results = self.list_unattached_elastic_ips(context)
-            
+
             total_unattached = 0
             total_monthly_cost = 0.0
             regions_with_waste = []
-            
+
             for eip_result in eip_results:
                 if eip_result.status == OperationStatus.SUCCESS and eip_result.outputs:
-                    count = eip_result.outputs.get('count', 0)
+                    count = eip_result.outputs.get("count", 0)
                     if count > 0:
                         total_unattached += count
-                        monthly_cost = eip_result.outputs.get('monthly_cost', 0)
+                        monthly_cost = eip_result.outputs.get("monthly_cost", 0)
                         total_monthly_cost += monthly_cost
-                        regions_with_waste.append({
-                            'region': eip_result.resource_id.split(':')[1],
-                            'count': count,
-                            'monthly_cost': monthly_cost
-                        })
-            
+                        regions_with_waste.append(
+                            {
+                                "region": eip_result.resource_id.split(":")[1],
+                                "count": count,
+                                "monthly_cost": monthly_cost,
+                            }
+                        )
+
             # Create cost analysis summary
             cost_summary = {
-                'total_unattached_eips': total_unattached,
-                'total_monthly_cost': total_monthly_cost,
-                'total_annual_cost': total_monthly_cost * 12,
-                'regions_affected': len(regions_with_waste),
-                'regions_detail': regions_with_waste,
-                'cost_per_eip_monthly': 3.60,
-                'recommendation': 'Release unattached Elastic IPs to save costs'
+                "total_unattached_eips": total_unattached,
+                "total_monthly_cost": total_monthly_cost,
+                "total_annual_cost": total_monthly_cost * 12,
+                "regions_affected": len(regions_with_waste),
+                "regions_detail": regions_with_waste,
+                "cost_per_eip_monthly": 3.60,
+                "recommendation": "Release unattached Elastic IPs to save costs",
             }
-            
+
             result.add_output("cost_analysis", cost_summary)
             result.mark_completed(
                 OperationStatus.SUCCESS,
-                f"Cost analysis complete: ${total_monthly_cost:.2f}/month waste from {total_unattached} unattached EIPs"
+                f"Cost analysis complete: ${total_monthly_cost:.2f}/month waste from {total_unattached} unattached EIPs",
             )
-            
+
             # Display cost impact table
             if total_unattached > 0:
                 table = Table(title="Elastic IP Cost Impact Analysis")
                 table.add_column("Metric", style="cyan")
                 table.add_column("Value", style="yellow")
-                
+
                 table.add_row("Unattached EIPs", str(total_unattached))
                 table.add_row("Monthly Cost", f"${total_monthly_cost:.2f}")
                 table.add_row("Annual Cost", f"${total_monthly_cost * 12:.2f}")
                 table.add_row("Regions Affected", str(len(regions_with_waste)))
-                
+
                 console.print(table)
                 console.print(f"[bold red]💰 Potential savings: ${total_monthly_cost:.2f}/month[/bold red]")
             else:
                 console.print("[green]✅ No unattached Elastic IPs found - no waste![/green]")
-                
+
         except Exception as e:
             error_msg = f"Failed to analyze Elastic IP costs: {e}"
             logger.error(error_msg)
             result.mark_completed(OperationStatus.FAILED, error_msg)
-            
+
         return result
 
     def _get_all_regions(self) -> List[str]:
         """Get all available AWS regions for EC2."""
         try:
-            ec2_client = boto3.client('ec2', region_name='us-east-1')
+            ec2_client = boto3.client("ec2", region_name="us-east-1")
             response = ec2_client.describe_regions()
-            return [region['RegionName'] for region in response['Regions']]
+            return [region["RegionName"] for region in response["Regions"]]
         except Exception:
             # Fallback to common regions if API call fails
             return [
-                'us-east-1', 'us-west-2', 'eu-west-1', 'ap-southeast-1',
-                'us-west-1', 'eu-central-1', 'ap-southeast-2'
+                "us-east-1",
+                "us-west-2",
+                "eu-west-1",
+                "ap-southeast-1",
+                "us-west-1",
+                "eu-central-1",
+                "ap-southeast-2",
             ]
 
 
@@ -1663,3 +1666,8 @@ def main():
 
 if __name__ == "__main__":
     main()
+
+
+# Aliases for backward compatibility
+InstanceManager = EC2Operations
+SecurityGroupManager = EC2Operations