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

runbooks/finops/ebs_optimizer.py

@@ -1,973 +0,0 @@
-#!/usr/bin/env python3
-"""
-EBS Volume Cost Optimization Platform - Enterprise FinOps Storage Analysis Platform
-Strategic Business Focus: EBS storage cost optimization for Manager, Financial, and CTO stakeholders
-
-Strategic Achievement: Final component of $132,720+ annual savings methodology (380-757% ROI achievement)
-Business Impact: $1.5M-$9.3M annual savings potential across enterprise accounts
-Technical Foundation: Enterprise-grade EBS analysis combining 3 optimization strategies
-
-This module provides comprehensive EBS volume cost optimization analysis following proven FinOps patterns:
-- GP2→GP3 conversion analysis (15-20% cost reduction opportunity)
-- Low usage volume detection via CloudWatch metrics
-- Orphaned volume cleanup (unattached volumes from stopped instances)
-- Combined cost savings calculation across all optimization vectors
-- Safety analysis with instance dependency mapping
-
-Strategic Alignment:
-- "Do one thing and do it well": EBS volume cost optimization specialization
-- "Move Fast, But Not So Fast We Crash": Safety-first analysis approach
-- Enterprise FAANG SDLC: Evidence-based optimization with audit trails
-- Universal $132K Cost Optimization Methodology: Manager scenarios prioritized over generic patterns
-"""
-
-import asyncio
-import logging
-import time
-from datetime import datetime, timedelta
-from typing import Any, Dict, List, Optional, Tuple
-
-import boto3
-import click
-from botocore.exceptions import ClientError, NoCredentialsError
-from pydantic import BaseModel, Field
-
-from ..common.rich_utils import (
-    console, print_header, print_success, print_error, print_warning, print_info,
-    create_table, create_progress_bar, format_cost, create_panel, STATUS_INDICATORS
-)
-from .embedded_mcp_validator import EmbeddedMCPValidator
-from ..common.profile_utils import get_profile_for_operation
-
-logger = logging.getLogger(__name__)
-
-
-class EBSVolumeDetails(BaseModel):
-    """EBS Volume details from EC2 API."""
-    volume_id: str
-    region: str
-    size: int  # Size in GB
-    volume_type: str  # gp2, gp3, io1, io2, st1, sc1
-    state: str  # available, in-use, creating, deleting
-    availability_zone: str
-    create_time: datetime
-    attached_instance_id: Optional[str] = None
-    attachment_state: Optional[str] = None  # attaching, attached, detaching, detached
-    device: Optional[str] = None
-    encrypted: bool = False
-    iops: Optional[int] = None
-    throughput: Optional[int] = None
-    tags: Dict[str, str] = Field(default_factory=dict)
-    snapshot_id: Optional[str] = None
-
-
-class EBSUsageMetrics(BaseModel):
-    """EBS Volume usage metrics from CloudWatch."""
-    volume_id: str
-    region: str
-    read_ops: float = 0.0
-    write_ops: float = 0.0
-    read_bytes: float = 0.0
-    write_bytes: float = 0.0
-    total_read_time: float = 0.0
-    total_write_time: float = 0.0
-    idle_time: float = 0.0
-    queue_length: float = 0.0
-    analysis_period_days: int = 7
-    is_low_usage: bool = False
-    usage_score: float = 0.0  # 0-100 usage score
-
-
-class EBSOptimizationResult(BaseModel):
-    """EBS Volume optimization analysis results."""
-    volume_id: str
-    region: str
-    availability_zone: str
-    current_type: str
-    current_size: int
-    current_state: str
-    attached_instance_id: Optional[str] = None
-    instance_state: Optional[str] = None
-    usage_metrics: Optional[EBSUsageMetrics] = None
-    
-    # GP2→GP3 conversion analysis
-    gp3_conversion_eligible: bool = False
-    gp3_monthly_savings: float = 0.0
-    gp3_annual_savings: float = 0.0
-    
-    # Low usage analysis
-    low_usage_detected: bool = False
-    low_usage_monthly_cost: float = 0.0
-    low_usage_annual_cost: float = 0.0
-    
-    # Orphaned volume analysis
-    is_orphaned: bool = False
-    orphaned_monthly_cost: float = 0.0
-    orphaned_annual_cost: float = 0.0
-    
-    # Combined optimization
-    optimization_recommendation: str = "retain"  # retain, gp3_convert, investigate_usage, cleanup_orphaned
-    risk_level: str = "low"  # low, medium, high
-    business_impact: str = "minimal"
-    total_monthly_savings: float = 0.0
-    total_annual_savings: float = 0.0
-    monthly_cost: float = 0.0
-    annual_cost: float = 0.0
-
-
-class EBSOptimizerResults(BaseModel):
-    """Complete EBS optimization analysis results."""
-    total_volumes: int = 0
-    gp2_volumes: int = 0
-    gp3_eligible_volumes: int = 0
-    low_usage_volumes: int = 0
-    orphaned_volumes: int = 0
-    analyzed_regions: List[str] = Field(default_factory=list)
-    optimization_results: List[EBSOptimizationResult] = Field(default_factory=list)
-    
-    # Cost breakdown
-    total_monthly_cost: float = 0.0
-    total_annual_cost: float = 0.0
-    gp3_potential_monthly_savings: float = 0.0
-    gp3_potential_annual_savings: float = 0.0
-    low_usage_potential_monthly_savings: float = 0.0
-    low_usage_potential_annual_savings: float = 0.0
-    orphaned_potential_monthly_savings: float = 0.0
-    orphaned_potential_annual_savings: float = 0.0
-    total_potential_monthly_savings: float = 0.0
-    total_potential_annual_savings: float = 0.0
-    
-    execution_time_seconds: float = 0.0
-    mcp_validation_accuracy: float = 0.0
-    analysis_timestamp: datetime = Field(default_factory=datetime.now)
-
-
-class EBSOptimizer:
-    """
-    EBS Volume Cost Optimization Platform - Enterprise FinOps Storage Engine
-    
-    Following $132,720+ methodology with proven FinOps patterns targeting $1.5M-$9.3M annual savings:
-    - Multi-region discovery and analysis across enterprise accounts
-    - GP2→GP3 conversion analysis for 15-20% cost reduction
-    - CloudWatch metrics integration for usage validation
-    - Orphaned volume detection and cleanup analysis
-    - Combined cost calculation with MCP validation (≥99.5% accuracy)
-    - Evidence generation for Manager/Financial/CTO executive reporting
-    - Business-focused naming for executive presentation readiness
-    """
-    
-    def __init__(self, profile_name: Optional[str] = None, regions: Optional[List[str]] = None):
-        """Initialize EBS optimizer with enterprise profile support."""
-        self.profile_name = profile_name
-        self.regions = regions or ['us-east-1', 'us-west-2', 'eu-west-1']
-        
-        # Initialize AWS session with profile priority system
-        self.session = boto3.Session(
-            profile_name=get_profile_for_operation("operational", profile_name)
-        )
-        
-        # EBS pricing using dynamic AWS pricing engine for universal compatibility
-        self.ebs_pricing = self._initialize_dynamic_ebs_pricing()
-        
-        # GP3 conversion savings percentage
-        self.gp3_savings_percentage = 0.20  # 20% savings GP2→GP3
-        
-        # Low usage thresholds for CloudWatch analysis
-        self.low_usage_threshold_ops = 10     # Read/Write operations per day
-        self.low_usage_threshold_bytes = 1_000_000  # 1MB per day
-        self.analysis_period_days = 7
-        
-    def _initialize_dynamic_ebs_pricing(self) -> Dict[str, float]:
-        """Initialize dynamic EBS pricing using AWS pricing engine for universal compatibility."""
-        try:
-            from ..common.aws_pricing import get_service_monthly_cost
-            
-            # Get dynamic pricing for common EBS volume types in us-east-1 (base region)
-            base_region = "us-east-1"
-            
-            return {
-                'gp2': get_service_monthly_cost("ebs_gp2", base_region, self.profile_name),
-                'gp3': get_service_monthly_cost("ebs_gp3", base_region, self.profile_name),
-                'io1': get_service_monthly_cost("ebs_io1", base_region, self.profile_name),
-                'io2': get_service_monthly_cost("ebs_io2", base_region, self.profile_name),
-                'st1': get_service_monthly_cost("ebs_st1", base_region, self.profile_name),
-                'sc1': get_service_monthly_cost("ebs_sc1", base_region, self.profile_name),
-            }
-        except Exception as e:
-            print_warning(f"Dynamic EBS pricing initialization failed: {e}")
-            print_warning("Attempting AWS Pricing API fallback with universal profile support")
-            
-            try:
-                from ..common.aws_pricing import get_aws_pricing_engine
-                
-                # Use AWS Pricing API with profile support for universal compatibility
-                pricing_engine = get_aws_pricing_engine(profile=self.profile_name, enable_fallback=True)
-                
-                # Get actual AWS pricing instead of hardcoded values
-                gp2_pricing = pricing_engine.get_ebs_pricing("gp2", "us-east-1")
-                gp3_pricing = pricing_engine.get_ebs_pricing("gp3", "us-east-1")
-                io1_pricing = pricing_engine.get_ebs_pricing("io1", "us-east-1")
-                io2_pricing = pricing_engine.get_ebs_pricing("io2", "us-east-1")
-                st1_pricing = pricing_engine.get_ebs_pricing("st1", "us-east-1")
-                sc1_pricing = pricing_engine.get_ebs_pricing("sc1", "us-east-1")
-                
-                return {
-                    'gp2': gp2_pricing.monthly_cost_per_gb,
-                    'gp3': gp3_pricing.monthly_cost_per_gb,
-                    'io1': io1_pricing.monthly_cost_per_gb,
-                    'io2': io2_pricing.monthly_cost_per_gb,
-                    'st1': st1_pricing.monthly_cost_per_gb,
-                    'sc1': sc1_pricing.monthly_cost_per_gb,
-                }
-                
-            except Exception as pricing_error:
-                print_error(f"ENTERPRISE COMPLIANCE VIOLATION: Cannot determine EBS pricing without AWS API access: {pricing_error}")
-                print_warning("Universal compatibility requires dynamic pricing - hardcoded values not permitted")
-                
-                # Return error state instead of hardcoded values to maintain enterprise compliance
-                raise RuntimeError(
-                    "Universal compatibility mode requires dynamic AWS pricing API access. "
-                    "Please ensure your AWS profile has pricing:GetProducts permissions or configure "
-                    "appropriate billing/management profile access."
-                )
-        
-    async def analyze_ebs_volumes(self, dry_run: bool = True) -> EBSOptimizerResults:
-        """
-        Comprehensive EBS volume cost optimization analysis.
-        
-        Args:
-            dry_run: Safety mode - READ-ONLY analysis only
-            
-        Returns:
-            Complete analysis results with optimization recommendations
-        """
-        print_header("EBS Volume Cost Optimization Platform", "Enterprise FinOps Storage Analysis v1.0")
-        
-        if not dry_run:
-            print_warning("⚠️ Dry-run disabled - This optimizer is READ-ONLY analysis only")
-            print_info("All EBS operations require manual execution after review")
-        
-        analysis_start_time = time.time()
-        
-        try:
-            with create_progress_bar() as progress:
-                # Step 1: Multi-region EBS volume discovery
-                discovery_task = progress.add_task("Discovering EBS volumes...", total=len(self.regions))
-                volumes = await self._discover_ebs_volumes_multi_region(progress, discovery_task)
-                
-                if not volumes:
-                    print_warning("No EBS volumes found in specified regions")
-                    return EBSOptimizerResults(
-                        analyzed_regions=self.regions,
-                        analysis_timestamp=datetime.now(),
-                        execution_time_seconds=time.time() - analysis_start_time
-                    )
-                
-                # Step 2: Usage metrics analysis via CloudWatch
-                metrics_task = progress.add_task("Analyzing usage metrics...", total=len(volumes))
-                usage_metrics = await self._analyze_usage_metrics(volumes, progress, metrics_task)
-                
-                # Step 3: Instance attachment validation
-                attachment_task = progress.add_task("Validating instance attachments...", total=len(volumes))
-                validated_volumes = await self._validate_instance_attachments(volumes, progress, attachment_task)
-                
-                # Step 4: Comprehensive optimization analysis
-                optimization_task = progress.add_task("Calculating optimization potential...", total=len(volumes))
-                optimization_results = await self._calculate_optimization_recommendations(
-                    validated_volumes, usage_metrics, progress, optimization_task
-                )
-                
-                # Step 5: MCP validation
-                validation_task = progress.add_task("MCP validation...", total=1)
-                mcp_accuracy = await self._validate_with_mcp(optimization_results, progress, validation_task)
-                
-            # Compile comprehensive results with cost breakdowns
-            results = self._compile_results(volumes, optimization_results, mcp_accuracy, analysis_start_time)
-            
-            # Display executive summary
-            self._display_executive_summary(results)
-            
-            return results
-            
-        except Exception as e:
-            print_error(f"EBS optimization analysis failed: {e}")
-            logger.error(f"EBS analysis error: {e}", exc_info=True)
-            raise
-    
-    async def _discover_ebs_volumes_multi_region(self, progress, task_id) -> List[EBSVolumeDetails]:
-        """Discover EBS volumes across multiple regions."""
-        volumes = []
-        
-        for region in self.regions:
-            try:
-                ec2_client = self.session.client('ec2', region_name=region)
-                
-                # Get all EBS volumes in region
-                paginator = ec2_client.get_paginator('describe_volumes')
-                page_iterator = paginator.paginate()
-                
-                for page in page_iterator:
-                    for volume in page.get('Volumes', []):
-                        # Extract tags
-                        tags = {tag['Key']: tag['Value'] for tag in volume.get('Tags', [])}
-                        
-                        # Get attachment details
-                        attachments = volume.get('Attachments', [])
-                        attached_instance_id = None
-                        attachment_state = None
-                        device = None
-                        
-                        if attachments:
-                            attachment = attachments[0]  # Take first attachment
-                            attached_instance_id = attachment.get('InstanceId')
-                            attachment_state = attachment.get('State')
-                            device = attachment.get('Device')
-                        
-                        volumes.append(EBSVolumeDetails(
-                            volume_id=volume['VolumeId'],
-                            region=region,
-                            size=volume['Size'],
-                            volume_type=volume['VolumeType'],
-                            state=volume['State'],
-                            availability_zone=volume['AvailabilityZone'],
-                            create_time=volume['CreateTime'],
-                            attached_instance_id=attached_instance_id,
-                            attachment_state=attachment_state,
-                            device=device,
-                            encrypted=volume.get('Encrypted', False),
-                            iops=volume.get('Iops'),
-                            throughput=volume.get('Throughput'),
-                            tags=tags,
-                            snapshot_id=volume.get('SnapshotId')
-                        ))
-                        
-                print_info(f"Region {region}: {len([v for v in volumes if v.region == region])} EBS volumes discovered")
-                
-            except ClientError as e:
-                print_warning(f"Region {region}: Access denied or region unavailable - {e.response['Error']['Code']}")
-            except Exception as e:
-                print_error(f"Region {region}: Discovery error - {str(e)}")
-                
-            progress.advance(task_id)
-        
-        return volumes
-    
-    async def _analyze_usage_metrics(self, volumes: List[EBSVolumeDetails], progress, task_id) -> Dict[str, EBSUsageMetrics]:
-        """Analyze EBS volume usage metrics via CloudWatch."""
-        usage_metrics = {}
-        end_time = datetime.utcnow()
-        start_time = end_time - timedelta(days=self.analysis_period_days)
-        
-        for volume in volumes:
-            try:
-                cloudwatch = self.session.client('cloudwatch', region_name=volume.region)
-                
-                # Get volume usage metrics
-                read_ops = await self._get_cloudwatch_metric(
-                    cloudwatch, volume.volume_id, 'VolumeReadOps', start_time, end_time
-                )
-                
-                write_ops = await self._get_cloudwatch_metric(
-                    cloudwatch, volume.volume_id, 'VolumeWriteOps', start_time, end_time
-                )
-                
-                read_bytes = await self._get_cloudwatch_metric(
-                    cloudwatch, volume.volume_id, 'VolumeReadBytes', start_time, end_time
-                )
-                
-                write_bytes = await self._get_cloudwatch_metric(
-                    cloudwatch, volume.volume_id, 'VolumeWriteBytes', start_time, end_time
-                )
-                
-                total_read_time = await self._get_cloudwatch_metric(
-                    cloudwatch, volume.volume_id, 'VolumeTotalReadTime', start_time, end_time
-                )
-                
-                total_write_time = await self._get_cloudwatch_metric(
-                    cloudwatch, volume.volume_id, 'VolumeTotalWriteTime', start_time, end_time
-                )
-                
-                # Calculate usage score and low usage detection
-                total_ops = read_ops + write_ops
-                total_bytes = read_bytes + write_bytes
-                
-                # Usage score calculation (0-100)
-                usage_score = min(100, (total_ops / (self.low_usage_threshold_ops * self.analysis_period_days)) * 100)
-                
-                # Low usage detection
-                is_low_usage = (
-                    total_ops < (self.low_usage_threshold_ops * self.analysis_period_days) and
-                    total_bytes < (self.low_usage_threshold_bytes * self.analysis_period_days)
-                )
-                
-                usage_metrics[volume.volume_id] = EBSUsageMetrics(
-                    volume_id=volume.volume_id,
-                    region=volume.region,
-                    read_ops=read_ops,
-                    write_ops=write_ops,
-                    read_bytes=read_bytes,
-                    write_bytes=write_bytes,
-                    total_read_time=total_read_time,
-                    total_write_time=total_write_time,
-                    analysis_period_days=self.analysis_period_days,
-                    is_low_usage=is_low_usage,
-                    usage_score=usage_score
-                )
-                
-            except Exception as e:
-                print_warning(f"Metrics unavailable for {volume.volume_id}: {str(e)}")
-                # Create default metrics for volumes without CloudWatch access
-                usage_metrics[volume.volume_id] = EBSUsageMetrics(
-                    volume_id=volume.volume_id,
-                    region=volume.region,
-                    analysis_period_days=self.analysis_period_days,
-                    is_low_usage=False,  # Conservative assumption without metrics
-                    usage_score=50.0   # Neutral score
-                )
-                
-            progress.advance(task_id)
-        
-        return usage_metrics
-    
-    async def _get_cloudwatch_metric(self, cloudwatch, volume_id: str, metric_name: str, 
-                                   start_time: datetime, end_time: datetime) -> float:
-        """Get CloudWatch metric data for EBS volume."""
-        try:
-            response = cloudwatch.get_metric_statistics(
-                Namespace='AWS/EBS',
-                MetricName=metric_name,
-                Dimensions=[
-                    {
-                        'Name': 'VolumeId',
-                        'Value': volume_id
-                    }
-                ],
-                StartTime=start_time,
-                EndTime=end_time,
-                Period=86400,  # Daily data points
-                Statistics=['Sum']
-            )
-            
-            # Sum all data points over the analysis period
-            total = sum(datapoint['Sum'] for datapoint in response.get('Datapoints', []))
-            return total
-            
-        except Exception as e:
-            logger.warning(f"CloudWatch metric {metric_name} unavailable for {volume_id}: {e}")
-            return 0.0
-    
-    async def _validate_instance_attachments(self, volumes: List[EBSVolumeDetails], progress, task_id) -> List[EBSVolumeDetails]:
-        """Validate EBS volume attachments and instance states."""
-        validated_volumes = []
-        
-        for volume in volumes:
-            try:
-                # For attached volumes, verify instance exists and get its state
-                if volume.attached_instance_id:
-                    ec2_client = self.session.client('ec2', region_name=volume.region)
-                    
-                    try:
-                        response = ec2_client.describe_instances(InstanceIds=[volume.attached_instance_id])
-                        
-                        if response.get('Reservations'):
-                            instance = response['Reservations'][0]['Instances'][0]
-                            instance_state = instance['State']['Name']
-                            
-                            # Update volume with instance state information
-                            volume_copy = volume.copy()
-                            # Add instance_state as a field that can be accessed later
-                            volume_copy.__dict__['instance_state'] = instance_state
-                            validated_volumes.append(volume_copy)
-                        else:
-                            # Instance not found - volume is effectively orphaned
-                            volume_copy = volume.copy()
-                            volume_copy.__dict__['instance_state'] = 'terminated'
-                            validated_volumes.append(volume_copy)
-                            
-                    except ClientError:
-                        # Instance not found or not accessible - consider orphaned
-                        volume_copy = volume.copy()
-                        volume_copy.__dict__['instance_state'] = 'not_found'
-                        validated_volumes.append(volume_copy)
-                else:
-                    # Unattached volume - keep as is
-                    validated_volumes.append(volume)
-                    
-            except Exception as e:
-                print_warning(f"Attachment validation failed for {volume.volume_id}: {str(e)}")
-                validated_volumes.append(volume)  # Add with original data
-                
-            progress.advance(task_id)
-        
-        return validated_volumes
-    
-    async def _calculate_optimization_recommendations(self, 
-                                                    volumes: List[EBSVolumeDetails],
-                                                    usage_metrics: Dict[str, EBSUsageMetrics],
-                                                    progress, task_id) -> List[EBSOptimizationResult]:
-        """Calculate comprehensive optimization recommendations and potential savings."""
-        optimization_results = []
-        
-        for volume in volumes:
-            try:
-                metrics = usage_metrics.get(volume.volume_id)
-                instance_state = getattr(volume, 'instance_state', None)
-                
-                # Calculate current monthly cost using dynamic pricing (enterprise compliance)
-                volume_pricing = self.ebs_pricing.get(volume.volume_type)
-                if volume_pricing is None:
-                    # Dynamic fallback for unknown volume types - no hardcoded values
-                    try:
-                        from ..common.aws_pricing import get_aws_pricing_engine
-                        pricing_engine = get_aws_pricing_engine(profile=self.profile_name, enable_fallback=True)
-                        volume_pricing_result = pricing_engine.get_ebs_pricing(volume.volume_type, "us-east-1")
-                        volume_pricing = volume_pricing_result.monthly_cost_per_gb
-                        print_info(f"Dynamic pricing resolved for {volume.volume_type}: ${volume_pricing:.4f}/GB/month")
-                    except Exception as e:
-                        print_error(f"ENTERPRISE COMPLIANCE VIOLATION: Cannot determine pricing for {volume.volume_type}: {e}")
-                        print_warning("Universal compatibility requires dynamic pricing - hardcoded values not permitted")
-                        raise RuntimeError(
-                            f"Universal compatibility mode requires dynamic AWS pricing for volume type '{volume.volume_type}'. "
-                            f"Please ensure your AWS profile has pricing:GetProducts permissions."
-                        )
-
-                monthly_cost = volume.size * volume_pricing
-                annual_cost = monthly_cost * 12
-                
-                # Initialize optimization analysis
-                gp3_conversion_eligible = False
-                gp3_monthly_savings = 0.0
-                low_usage_detected = False
-                low_usage_monthly_cost = 0.0
-                is_orphaned = False
-                orphaned_monthly_cost = 0.0
-                
-                recommendation = "retain"  # Default
-                risk_level = "low"
-                business_impact = "minimal"
-                
-                # 1. GP2→GP3 conversion analysis
-                if volume.volume_type == 'gp2':
-                    gp3_conversion_eligible = True
-                    gp3_monthly_savings = monthly_cost * self.gp3_savings_percentage
-                    
-                    if not metrics or not metrics.is_low_usage:
-                        recommendation = "gp3_convert"
-                        business_impact = "cost_savings"
-                
-                # 2. Low usage detection
-                if metrics and metrics.is_low_usage:
-                    low_usage_detected = True
-                    low_usage_monthly_cost = monthly_cost
-                    
-                    if volume.state == 'available' or (instance_state in ['stopped', 'terminated']):
-                        recommendation = "investigate_usage"
-                        risk_level = "medium"
-                        business_impact = "potential_cleanup"
-                
-                # 3. Orphaned volume detection
-                if (volume.state == 'available' or 
-                    (volume.attached_instance_id and instance_state in ['stopped', 'terminated', 'not_found'])):
-                    is_orphaned = True
-                    orphaned_monthly_cost = monthly_cost
-                    
-                    if instance_state in ['terminated', 'not_found']:
-                        recommendation = "cleanup_orphaned"
-                        risk_level = "low"
-                        business_impact = "safe_cleanup"
-                    elif instance_state == 'stopped':
-                        recommendation = "investigate_usage"
-                        risk_level = "medium"
-                        business_impact = "potential_cleanup"
-                
-                # Calculate total potential savings (non-overlapping)
-                total_monthly_savings = 0.0
-                
-                if recommendation == "cleanup_orphaned":
-                    total_monthly_savings = orphaned_monthly_cost
-                elif recommendation == "investigate_usage":
-                    total_monthly_savings = low_usage_monthly_cost * 0.7  # Conservative estimate
-                elif recommendation == "gp3_convert":
-                    total_monthly_savings = gp3_monthly_savings
-                
-                optimization_results.append(EBSOptimizationResult(
-                    volume_id=volume.volume_id,
-                    region=volume.region,
-                    availability_zone=volume.availability_zone,
-                    current_type=volume.volume_type,
-                    current_size=volume.size,
-                    current_state=volume.state,
-                    attached_instance_id=volume.attached_instance_id,
-                    instance_state=instance_state,
-                    usage_metrics=metrics,
-                    gp3_conversion_eligible=gp3_conversion_eligible,
-                    gp3_monthly_savings=gp3_monthly_savings,
-                    gp3_annual_savings=gp3_monthly_savings * 12,
-                    low_usage_detected=low_usage_detected,
-                    low_usage_monthly_cost=low_usage_monthly_cost,
-                    low_usage_annual_cost=low_usage_monthly_cost * 12,
-                    is_orphaned=is_orphaned,
-                    orphaned_monthly_cost=orphaned_monthly_cost,
-                    orphaned_annual_cost=orphaned_monthly_cost * 12,
-                    optimization_recommendation=recommendation,
-                    risk_level=risk_level,
-                    business_impact=business_impact,
-                    total_monthly_savings=total_monthly_savings,
-                    total_annual_savings=total_monthly_savings * 12,
-                    monthly_cost=monthly_cost,
-                    annual_cost=annual_cost
-                ))
-                
-            except Exception as e:
-                print_error(f"Optimization calculation failed for {volume.volume_id}: {str(e)}")
-                
-            progress.advance(task_id)
-        
-        return optimization_results
-    
-    async def _validate_with_mcp(self, optimization_results: List[EBSOptimizationResult], 
-                               progress, task_id) -> float:
-        """Validate optimization results with embedded MCP validator."""
-        try:
-            # Prepare validation data in FinOps format
-            validation_data = {
-                'total_annual_cost': sum(result.annual_cost for result in optimization_results),
-                'potential_annual_savings': sum(result.total_annual_savings for result in optimization_results),
-                'volumes_analyzed': len(optimization_results),
-                'regions_analyzed': list(set(result.region for result in optimization_results)),
-                'analysis_timestamp': datetime.now().isoformat()
-            }
-            
-            # Initialize MCP validator if profile is available
-            if self.profile_name:
-                mcp_validator = EmbeddedMCPValidator([self.profile_name])
-                validation_results = await mcp_validator.validate_cost_data_async(validation_data)
-                accuracy = validation_results.get('total_accuracy', 0.0)
-                
-                if accuracy >= 99.5:
-                    print_success(f"MCP Validation: {accuracy:.1f}% accuracy achieved (target: ≥99.5%)")
-                else:
-                    print_warning(f"MCP Validation: {accuracy:.1f}% accuracy (target: ≥99.5%)")
-                    
-                progress.advance(task_id)
-                return accuracy
-            else:
-                print_info("MCP validation skipped - no profile specified")
-                progress.advance(task_id)
-                return 0.0
-                
-        except Exception as e:
-            print_warning(f"MCP validation failed: {str(e)}")
-            progress.advance(task_id)
-            return 0.0
-    
-    def _compile_results(self, volumes: List[EBSVolumeDetails], 
-                        optimization_results: List[EBSOptimizationResult],
-                        mcp_accuracy: float, analysis_start_time: float) -> EBSOptimizerResults:
-        """Compile comprehensive EBS optimization results."""
-        
-        # Count volumes by type and optimization opportunity
-        gp2_volumes = len([v for v in volumes if v.volume_type == 'gp2'])
-        gp3_eligible_volumes = len([r for r in optimization_results if r.gp3_conversion_eligible])
-        low_usage_volumes = len([r for r in optimization_results if r.low_usage_detected])
-        orphaned_volumes = len([r for r in optimization_results if r.is_orphaned])
-        
-        # Calculate cost breakdowns
-        total_monthly_cost = sum(result.monthly_cost for result in optimization_results)
-        total_annual_cost = total_monthly_cost * 12
-        
-        gp3_potential_monthly_savings = sum(result.gp3_monthly_savings for result in optimization_results)
-        low_usage_potential_monthly_savings = sum(result.low_usage_monthly_cost for result in optimization_results)
-        orphaned_potential_monthly_savings = sum(result.orphaned_monthly_cost for result in optimization_results)
-        total_potential_monthly_savings = sum(result.total_monthly_savings for result in optimization_results)
-        
-        return EBSOptimizerResults(
-            total_volumes=len(volumes),
-            gp2_volumes=gp2_volumes,
-            gp3_eligible_volumes=gp3_eligible_volumes,
-            low_usage_volumes=low_usage_volumes,
-            orphaned_volumes=orphaned_volumes,
-            analyzed_regions=self.regions,
-            optimization_results=optimization_results,
-            total_monthly_cost=total_monthly_cost,
-            total_annual_cost=total_annual_cost,
-            gp3_potential_monthly_savings=gp3_potential_monthly_savings,
-            gp3_potential_annual_savings=gp3_potential_monthly_savings * 12,
-            low_usage_potential_monthly_savings=low_usage_potential_monthly_savings,
-            low_usage_potential_annual_savings=low_usage_potential_monthly_savings * 12,
-            orphaned_potential_monthly_savings=orphaned_potential_monthly_savings,
-            orphaned_potential_annual_savings=orphaned_potential_monthly_savings * 12,
-            total_potential_monthly_savings=total_potential_monthly_savings,
-            total_potential_annual_savings=total_potential_monthly_savings * 12,
-            execution_time_seconds=time.time() - analysis_start_time,
-            mcp_validation_accuracy=mcp_accuracy,
-            analysis_timestamp=datetime.now()
-        )
-    
-    def _display_executive_summary(self, results: EBSOptimizerResults) -> None:
-        """Display executive summary with Rich CLI formatting."""
-        
-        # Executive Summary Panel
-        summary_content = f"""
-💰 Total Annual Cost: {format_cost(results.total_annual_cost)}
-📊 Potential Savings: {format_cost(results.total_potential_annual_savings)}
-🎯 EBS Volumes Analyzed: {results.total_volumes}
-💾 GP2 Volumes: {results.gp2_volumes} ({results.gp3_eligible_volumes} GP3 eligible)
-📉 Low Usage: {results.low_usage_volumes} volumes
-🔓 Orphaned: {results.orphaned_volumes} volumes
-🌍 Regions: {', '.join(results.analyzed_regions)}
-⚡ Analysis Time: {results.execution_time_seconds:.2f}s
-✅ MCP Accuracy: {results.mcp_validation_accuracy:.1f}%
-        """
-        
-        console.print(create_panel(
-            summary_content.strip(),
-            title="🏆 EBS Volume Optimization Summary",
-            border_style="green"
-        ))
-        
-        # Optimization Breakdown Panel
-        breakdown_content = f"""
-🔄 GP2→GP3 Conversion: {format_cost(results.gp3_potential_annual_savings)} potential savings
-📉 Low Usage Cleanup: {format_cost(results.low_usage_potential_annual_savings)} potential savings  
-🧹 Orphaned Cleanup: {format_cost(results.orphaned_potential_annual_savings)} potential savings
-📈 Total Optimization: {format_cost(results.total_potential_annual_savings)} annual savings potential
-        """
-        
-        console.print(create_panel(
-            breakdown_content.strip(),
-            title="📊 Optimization Strategy Breakdown",
-            border_style="blue"
-        ))
-        
-        # Detailed Results Table
-        table = create_table(
-            title="EBS Volume Optimization Recommendations"
-        )
-        
-        table.add_column("Volume ID", style="cyan", no_wrap=True)
-        table.add_column("Region", style="dim")
-        table.add_column("Type", justify="center")
-        table.add_column("Size (GB)", justify="right")
-        table.add_column("Current Cost", justify="right", style="red")
-        table.add_column("Potential Savings", justify="right", style="green")
-        table.add_column("Recommendation", justify="center")
-        table.add_column("Risk", justify="center")
-        
-        # Sort by potential savings (descending)
-        sorted_results = sorted(
-            results.optimization_results, 
-            key=lambda x: x.total_annual_savings, 
-            reverse=True
-        )
-        
-        # Show top 20 results to avoid overwhelming output
-        display_results = sorted_results[:20]
-        
-        for result in display_results:
-            # Status indicators for recommendations
-            rec_color = {
-                "cleanup_orphaned": "red",
-                "investigate_usage": "yellow",
-                "gp3_convert": "blue", 
-                "retain": "green"
-            }.get(result.optimization_recommendation, "white")
-            
-            risk_indicator = {
-                "low": "🟢",
-                "medium": "🟡", 
-                "high": "🔴"
-            }.get(result.risk_level, "⚪")
-            
-            table.add_row(
-                result.volume_id[-8:],  # Show last 8 chars
-                result.region,
-                result.current_type,
-                str(result.current_size),
-                format_cost(result.annual_cost),
-                format_cost(result.total_annual_savings) if result.total_annual_savings > 0 else "-",
-                f"[{rec_color}]{result.optimization_recommendation.replace('_', ' ').title()}[/]",
-                f"{risk_indicator} {result.risk_level.title()}"
-            )
-        
-        if len(sorted_results) > 20:
-            table.add_row(
-                "...", "...", "...", "...", "...", "...", 
-                f"[dim]+{len(sorted_results) - 20} more volumes[/]", "..."
-            )
-        
-        console.print(table)
-        
-        # Recommendations Summary by Strategy
-        if results.optimization_results:
-            recommendations_summary = {}
-            for result in results.optimization_results:
-                rec = result.optimization_recommendation
-                if rec not in recommendations_summary:
-                    recommendations_summary[rec] = {"count": 0, "savings": 0.0}
-                recommendations_summary[rec]["count"] += 1
-                recommendations_summary[rec]["savings"] += result.total_annual_savings
-            
-            rec_content = []
-            strategy_names = {
-                "cleanup_orphaned": "Orphaned Volume Cleanup",
-                "investigate_usage": "Low Usage Investigation",
-                "gp3_convert": "GP2→GP3 Conversion",
-                "retain": "Retain (Optimized)"
-            }
-            
-            for rec, data in recommendations_summary.items():
-                strategy_name = strategy_names.get(rec, rec.replace('_', ' ').title())
-                rec_content.append(f"• {strategy_name}: {data['count']} volumes ({format_cost(data['savings'])} potential savings)")
-            
-            console.print(create_panel(
-                "\n".join(rec_content),
-                title="📋 Optimization Strategy Summary",
-                border_style="magenta"
-            ))
-    
-    def export_results(self, results: EBSOptimizerResults, 
-                      output_file: Optional[str] = None, 
-                      export_format: str = "json") -> str:
-        """
-        Export optimization results to various formats.
-        
-        Args:
-            results: Optimization analysis results
-            output_file: Output file path (optional)
-            export_format: Export format (json, csv, markdown)
-            
-        Returns:
-            Path to exported file
-        """
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        
-        if not output_file:
-            output_file = f"ebs_optimization_{timestamp}.{export_format}"
-        
-        try:
-            if export_format.lower() == "json":
-                import json
-                with open(output_file, 'w') as f:
-                    json.dump(results.dict(), f, indent=2, default=str)
-                    
-            elif export_format.lower() == "csv":
-                import csv
-                with open(output_file, 'w', newline='') as f:
-                    writer = csv.writer(f)
-                    writer.writerow([
-                        'Volume ID', 'Region', 'Type', 'Size (GB)', 'State', 'Instance ID',
-                        'Instance State', 'Monthly Cost', 'Annual Cost', 
-                        'GP3 Eligible', 'GP3 Savings', 'Low Usage', 'Orphaned',
-                        'Recommendation', 'Risk Level', 'Total Potential Savings'
-                    ])
-                    for result in results.optimization_results:
-                        writer.writerow([
-                            result.volume_id, result.region, result.current_type, 
-                            result.current_size, result.current_state,
-                            result.attached_instance_id or '', result.instance_state or '',
-                            f"${result.monthly_cost:.2f}", f"${result.annual_cost:.2f}",
-                            result.gp3_conversion_eligible, f"${result.gp3_annual_savings:.2f}",
-                            result.low_usage_detected, result.is_orphaned,
-                            result.optimization_recommendation, result.risk_level,
-                            f"${result.total_annual_savings:.2f}"
-                        ])
-                        
-            elif export_format.lower() == "markdown":
-                with open(output_file, 'w') as f:
-                    f.write(f"# EBS Volume Cost Optimization Report\n\n")
-                    f.write(f"**Analysis Date**: {results.analysis_timestamp}\n")
-                    f.write(f"**Total Volumes**: {results.total_volumes}\n")
-                    f.write(f"**GP2 Volumes**: {results.gp2_volumes}\n")
-                    f.write(f"**GP3 Eligible**: {results.gp3_eligible_volumes}\n")
-                    f.write(f"**Low Usage**: {results.low_usage_volumes}\n")
-                    f.write(f"**Orphaned**: {results.orphaned_volumes}\n")
-                    f.write(f"**Total Annual Cost**: ${results.total_annual_cost:.2f}\n")
-                    f.write(f"**Potential Annual Savings**: ${results.total_potential_annual_savings:.2f}\n\n")
-                    f.write(f"## Optimization Breakdown\n\n")
-                    f.write(f"- **GP2→GP3 Conversion**: ${results.gp3_potential_annual_savings:.2f}\n")
-                    f.write(f"- **Low Usage Cleanup**: ${results.low_usage_potential_annual_savings:.2f}\n")
-                    f.write(f"- **Orphaned Cleanup**: ${results.orphaned_potential_annual_savings:.2f}\n\n")
-                    f.write(f"## Volume Recommendations\n\n")
-                    f.write(f"| Volume | Region | Type | Size | Recommendation | Potential Savings |\n")
-                    f.write(f"|--------|--------|------|------|----------------|-------------------|\n")
-                    for result in results.optimization_results[:50]:  # Limit to 50 for readability
-                        f.write(f"| {result.volume_id} | {result.region} | {result.current_type} | ")
-                        f.write(f"{result.current_size}GB | {result.optimization_recommendation} | ")
-                        f.write(f"${result.total_annual_savings:.2f} |\n")
-            
-            print_success(f"Results exported to: {output_file}")
-            return output_file
-            
-        except Exception as e:
-            print_error(f"Export failed: {str(e)}")
-            raise
-
-
-# CLI Integration for enterprise runbooks commands
-@click.command()
-@click.option('--profile', help='AWS profile name (3-tier priority: User > Environment > Default)')
-@click.option('--regions', multiple=True, help='AWS regions to analyze (space-separated)')
-@click.option('--dry-run/--no-dry-run', default=True, help='Execute in dry-run mode (READ-ONLY analysis)')
-@click.option('--export-format', type=click.Choice(['json', 'csv', 'markdown']), 
-              default='json', help='Export format for results')
-@click.option('--output-file', help='Output file path for results export')
-@click.option('--usage-threshold-days', type=int, default=7, 
-              help='CloudWatch analysis period in days')
-def ebs_optimizer(profile, regions, dry_run, export_format, output_file, usage_threshold_days):
-    """
-    EBS Volume Optimizer - Enterprise Multi-Region Storage Analysis
-    
-    Comprehensive EBS cost optimization combining 3 strategies:
-    • GP2→GP3 conversion (15-20% storage cost reduction)
-    • Low usage volume detection and cleanup recommendations
-    • Orphaned volume identification from stopped/terminated instances
-    
-    Part of $132,720+ annual savings methodology completing Tier 1 High-Value engine.
-    
-    SAFETY: READ-ONLY analysis only - no resource modifications.
-    
-    Examples:
-        runbooks finops ebs --optimize
-        runbooks finops ebs --profile my-profile --regions us-east-1 us-west-2
-        runbooks finops ebs --export-format csv --output-file ebs_analysis.csv
-    """
-    try:
-        # Initialize optimizer
-        optimizer = EBSOptimizer(
-            profile_name=profile,
-            regions=list(regions) if regions else None
-        )
-        
-        # Execute comprehensive analysis
-        results = asyncio.run(optimizer.analyze_ebs_volumes(dry_run=dry_run))
-        
-        # Export results if requested
-        if output_file or export_format != 'json':
-            optimizer.export_results(results, output_file, export_format)
-            
-        # Display final success message
-        if results.total_potential_annual_savings > 0:
-            savings_breakdown = []
-            if results.gp3_potential_annual_savings > 0:
-                savings_breakdown.append(f"GP2→GP3: {format_cost(results.gp3_potential_annual_savings)}")
-            if results.low_usage_potential_annual_savings > 0:
-                savings_breakdown.append(f"Usage: {format_cost(results.low_usage_potential_annual_savings)}")
-            if results.orphaned_potential_annual_savings > 0:
-                savings_breakdown.append(f"Orphaned: {format_cost(results.orphaned_potential_annual_savings)}")
-                
-            print_success(f"Analysis complete: {format_cost(results.total_potential_annual_savings)} potential annual savings")
-            print_info(f"Optimization strategies: {' | '.join(savings_breakdown)}")
-        else:
-            print_info("Analysis complete: All EBS volumes are optimally configured")
-            
-    except KeyboardInterrupt:
-        print_warning("Analysis interrupted by user")
-        raise click.Abort()
-    except Exception as e:
-        print_error(f"EBS optimization analysis failed: {str(e)}")
-        raise click.Abort()
-
-
-if __name__ == '__main__':
-    ebs_optimizer()