runbooks 0.9.8__py3-none-any.whl → 1.0.0__py3-none-any.whl

runbooks/finops/markdown_exporter.py

@@ -423,6 +423,447 @@ class MarkdownExporter:
         highest = max(profiles, key=lambda p: p.get("potential_savings", 0))
         return highest.get("profile_name", "Unknown")[:20]
 
+    def format_vpc_cleanup_table(self, vpc_candidates: List[Any]) -> str:
+        """
+        Format VPC cleanup candidates into 15-column markdown table.
+        
+        Args:
+            vpc_candidates: List of VPCCandidate objects from vpc.unified_scenarios
+            
+        Returns:
+            Markdown formatted table string with VPC cleanup analysis
+        """
+        if not vpc_candidates:
+            return "⚠️ No VPC candidates to format"
+        
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S UTC")
+        
+        # Build table header and separator
+        headers = [
+            "Account_ID", "VPC_ID", "VPC_Name", "CIDR_Block", "Overlapping", 
+            "Is_Default", "ENI_Count", "Tags", "Flow_Logs", "TGW/Peering", 
+            "LBs_Present", "IaC", "Timeline", "Decision", "Owners/Approvals", "Notes"
+        ]
+        
+        markdown_lines = [
+            "# VPC Cleanup Analysis Report",
+            "",
+            f"**Generated**: {timestamp}",
+            f"**Total VPC Candidates**: {len(vpc_candidates)}",
+            f"**Analysis Source**: CloudOps Runbooks VPC Module v0.9.9",
+            "",
+            "## VPC Cleanup Decision Table",
+            "",
+            "| " + " | ".join(headers) + " |",
+            "| " + " | ".join(["---" for _ in headers]) + " |"
+        ]
+        
+        # Process each VPC candidate with enhanced data extraction
+        for candidate in vpc_candidates:
+            # Extract data with safe attribute access and formatting
+            account_id = getattr(candidate, 'account_id', 'Unknown')
+            vpc_id = getattr(candidate, 'vpc_id', 'Unknown')
+            vpc_name = getattr(candidate, 'vpc_name', '') or 'Unnamed'
+            cidr_block = getattr(candidate, 'cidr_block', 'Unknown')
+            
+            # Handle overlapping logic - check CIDR conflicts
+            overlapping = self._check_cidr_overlapping(cidr_block, vpc_candidates)
+            
+            # Enhanced is_default handling
+            is_default = getattr(candidate, 'is_default', False)
+            is_default_display = "⚠️ Yes" if is_default else "No"
+            
+            # Enhanced ENI count
+            dependency_analysis = getattr(candidate, 'dependency_analysis', None)
+            eni_count = dependency_analysis.eni_count if dependency_analysis else 0
+            
+            # Enhanced tags with owner focus
+            tags_dict = getattr(candidate, 'tags', {}) or {}
+            tags_display = self._format_tags_for_owners_display(tags_dict)
+            
+            # Flow logs detection
+            flow_logs = self._detect_flow_logs(candidate)
+            
+            # TGW/Peering detection
+            tgw_peering = self._detect_tgw_peering(candidate)
+            
+            # Load balancers detection
+            lbs_present = self._detect_load_balancers(candidate)
+            
+            # IaC detection from tags
+            iac_detected = self._detect_iac_from_tags(tags_dict)
+            
+            # Timeline estimation based on VPC state
+            timeline = self._estimate_cleanup_timeline(candidate)
+            
+            # Decision based on bucket classification
+            decision = self._determine_cleanup_decision(candidate)
+            
+            # Enhanced owners/approvals extraction
+            owners_approvals = self._extract_owners_approvals(tags_dict, is_default)
+            
+            # Notes based on VPC characteristics
+            notes = self._generate_vpc_notes(candidate)
+            overlapping = "Yes" if getattr(candidate, 'overlapping', False) else "No"
+            
+            # Format boolean indicators with emoji
+            is_default = "⚠️ Yes" if getattr(candidate, 'is_default', False) else "✅ No"
+            flow_logs = "✅ Yes" if getattr(candidate, 'flow_logs_enabled', False) else "❌ No"
+            tgw_peering = "✅ Yes" if getattr(candidate, 'tgw_peering_attached', False) else "❌ No"
+            load_balancers = "✅ Yes" if getattr(candidate, 'load_balancers_present', False) else "❌ No"
+            iac_managed = "✅ Yes" if getattr(candidate, 'iac_managed', False) else "❌ No"
+            
+            # ENI Count handling
+            eni_count = getattr(candidate, 'eni_count', 0)
+            
+            # Tags formatting - prioritize important tags with enhanced display
+            tags = getattr(candidate, 'tags', {}) or {}
+            relevant_tags = []
+            if tags:
+                # Priority order for business-relevant tags
+                priority_keys = ['Name', 'Environment', 'Project', 'Owner', 'BusinessOwner', 'Team', 'CostCenter', 'Application']
+                for key in priority_keys:
+                    if key in tags and tags[key] and len(relevant_tags) < 3:  # Increased limit for better visibility
+                        relevant_tags.append(f"{key}:{tags[key]}")
+                
+                # Add other important tags if space available
+                for key, value in tags.items():
+                    if key not in priority_keys and value and len(relevant_tags) < 3:
+                        relevant_tags.append(f"{key}:{value}")
+            
+            # Enhanced display logic for tags
+            if relevant_tags:
+                tags_display = "; ".join(relevant_tags)
+                if len(tags_display) > 35:  # Slightly increased width for better readability
+                    tags_display = tags_display[:32] + "..."
+            elif tags:
+                # If tags exist but none were priority, show count
+                tags_display = f"({len(tags)} tags)"
+            else:
+                # No tags at all
+                tags_display = "No tags"
+            
+            # Timeline and Decision
+            timeline = getattr(candidate, 'cleanup_timeline', '') or getattr(candidate, 'implementation_timeline', 'Unknown')
+            
+            # Decision handling - check for different decision attribute names
+            decision_attr = getattr(candidate, 'decision', None)
+            if decision_attr:
+                if hasattr(decision_attr, 'value'):
+                    decision = decision_attr.value
+                else:
+                    decision = str(decision_attr)
+            else:
+                # Fallback decision logic based on risk/dependencies
+                decision = getattr(candidate, 'cleanup_bucket', 'Unknown')
+            
+            # Owners/Approvals - Enhanced extraction from tags if not populated
+            owners = getattr(candidate, 'owners_approvals', []) or getattr(candidate, 'stakeholders', [])
+            
+            # If no owners found via attributes, try to extract from tags directly
+            if not owners and tags:
+                owner_keys = ['Owner', 'BusinessOwner', 'TechnicalOwner', 'Team', 'Contact', 'CreatedBy', 'ManagedBy']
+                for key in owner_keys:
+                    if key in tags and tags[key]:
+                        if 'business' in key.lower() or 'manager' in tags[key].lower():
+                            owners.append(f"{tags[key]} (Business)")
+                        elif 'technical' in key.lower() or any(tech in tags[key].lower() for tech in ['ops', 'devops', 'engineering']):
+                            owners.append(f"{tags[key]} (Technical)")
+                        else:
+                            owners.append(tags[key])
+                        break  # Take first found owner to avoid clutter
+            
+            if owners:
+                owners_display = "; ".join(owners)
+                if len(owners_display) > 30:  # Increased width for better display
+                    owners_display = owners_display[:27] + "..."
+            else:
+                # Enhanced "unknown" display based on VPC characteristics
+                if getattr(candidate, 'is_default', False):
+                    owners_display = "System Default"
+                elif getattr(candidate, 'iac_detected', False):
+                    owners_display = "IaC Managed"
+                else:
+                    owners_display = "No owner tags"
+            
+            # Notes - combination of risk assessment and business impact
+            notes_parts = []
+            risk_level = getattr(candidate, 'risk_level', None)
+            if risk_level:
+                risk_val = risk_level.value if hasattr(risk_level, 'value') else str(risk_level)
+                notes_parts.append(f"Risk:{risk_val}")
+            
+            business_impact = getattr(candidate, 'business_impact', '') 
+            if business_impact:
+                notes_parts.append(business_impact[:15])  # Truncate
+            
+            notes = "; ".join(notes_parts) if notes_parts else getattr(candidate, 'notes', 'No notes')
+            if len(notes) > 30:  # Truncate for table formatting
+                notes = notes[:27] + "..."
+            
+            # Create table row - escape pipes for markdown compatibility
+            row_data = [
+                account_id, vpc_id, vpc_name, cidr_block, overlapping,
+                is_default, str(eni_count), tags_display, flow_logs, tgw_peering,
+                load_balancers, iac_managed, timeline, decision, owners_display, notes
+            ]
+            
+            # Escape pipes and format row
+            escaped_data = [str(cell).replace("|", "\\|") for cell in row_data]
+            markdown_lines.append("| " + " | ".join(escaped_data) + " |")
+        
+        # Add summary statistics
+        total_vpcs = len(vpc_candidates)
+        default_vpcs = sum(1 for c in vpc_candidates if getattr(c, 'is_default', False))
+        flow_logs_enabled = sum(1 for c in vpc_candidates if getattr(c, 'flow_logs_enabled', False))
+        iac_managed_count = sum(1 for c in vpc_candidates if getattr(c, 'iac_managed', False))
+        zero_eni_vpcs = sum(1 for c in vpc_candidates if getattr(c, 'eni_count', 1) == 0)
+        
+        markdown_lines.extend([
+            "",
+            "## Analysis Summary",
+            "",
+            f"- **Total VPCs Analyzed**: {total_vpcs}",
+            f"- **Default VPCs**: {default_vpcs} ({(default_vpcs/total_vpcs*100):.1f}%)",
+            f"- **Flow Logs Enabled**: {flow_logs_enabled} ({(flow_logs_enabled/total_vpcs*100):.1f}%)",
+            f"- **IaC Managed**: {iac_managed_count} ({(iac_managed_count/total_vpcs*100):.1f}%)",
+            f"- **Zero ENI Attachments**: {zero_eni_vpcs} ({(zero_eni_vpcs/total_vpcs*100):.1f}%)",
+            "",
+            "## Cleanup Recommendations",
+            "",
+            "1. **Priority 1**: VPCs with zero ENI attachments and no dependencies",
+            "2. **Priority 2**: Default VPCs with no active resources",
+            "3. **Priority 3**: Non-IaC managed VPCs requiring manual cleanup",
+            "4. **Review Required**: VPCs with unclear ownership or business impact",
+            "",
+            "---",
+            f"*Generated by CloudOps Runbooks VPC Module v0.9.9 at {timestamp}*"
+        ])
+        
+        return "\n".join(markdown_lines)
+
+    def export_vpc_analysis_to_file(self, vpc_candidates: List[Any], filename: str = None, output_dir: str = "./exports") -> str:
+        """
+        Export VPC analysis to markdown file with intelligent naming.
+        
+        Args:
+            vpc_candidates: List of VPC candidates from analysis
+            filename: Base filename (optional, auto-generated if not provided)
+            output_dir: Output directory path
+            
+        Returns:
+            Path to exported file
+        """
+        if not filename:
+            timestamp = datetime.now().strftime("%Y-%m-%d")
+            filename = f"vpc-cleanup-analysis-{timestamp}.md"
+        
+        # Ensure .md extension
+        if not filename.endswith('.md'):
+            filename = f"{filename}.md"
+        
+        # Create output directory
+        output_path = Path(output_dir)
+        output_path.mkdir(parents=True, exist_ok=True)
+        
+        # Generate markdown content
+        markdown_content = self.format_vpc_cleanup_table(vpc_candidates)
+        
+        # Write to file
+        filepath = output_path / filename
+        
+        print_info(f"📝 Exporting VPC analysis to: {filename}")
+        
+        try:
+            with open(filepath, "w", encoding="utf-8") as f:
+                f.write(markdown_content)
+            
+            print_success(f"✅ VPC analysis exported: {filepath}")
+            print_info(f"🔗 Ready for executive review or documentation systems")
+            return str(filepath)
+            
+        except Exception as e:
+            print_warning(f"❌ Failed to export VPC analysis: {e}")
+            return ""
+
+    def _check_cidr_overlapping(self, cidr_block: str, vpc_candidates: List[Any]) -> str:
+        """Check for CIDR block overlapping across VPCs."""
+        if not cidr_block or not vpc_candidates:
+            return "No"
+        
+        # Simple overlapping check - in enterprise scenario, this would use more sophisticated logic
+        current_cidr = cidr_block
+        for candidate in vpc_candidates:
+            other_cidr = getattr(candidate, 'cidr_block', None)
+            if other_cidr and other_cidr != current_cidr and current_cidr.startswith(other_cidr.split('/')[0].rsplit('.', 1)[0]):
+                return "Yes"
+        
+        return "No"
+
+    def _detect_flow_logs(self, candidate: Any) -> str:
+        """Detect if VPC has flow logs enabled."""
+        return "Yes" if getattr(candidate, 'flow_logs_enabled', False) else "No"
+
+    def _detect_tgw_peering(self, candidate: Any) -> str:
+        """Analyze Transit Gateway and VPC peering connections."""
+        # Check for TGW attachments and peering connections
+        tgw_attachments = getattr(candidate, 'tgw_attachments', []) or []
+        peering_connections = getattr(candidate, 'peering_connections', []) or []
+        
+        if tgw_attachments or peering_connections:
+            connection_count = len(tgw_attachments) + len(peering_connections)
+            return f"Yes ({connection_count})"
+        return "No"
+
+    def _detect_load_balancers(self, candidate: Any) -> str:
+        """Detect load balancers in the VPC."""
+        load_balancers = getattr(candidate, 'load_balancers', []) or []
+        return "Yes" if load_balancers else "No"
+
+    def _detect_iac_from_tags(self, tags_dict: dict) -> str:
+        """Detect Infrastructure as Code management from tags."""
+        iac_keys = ['aws:cloudformation:stack-name', 'terraform:module', 'cdktf:stack', 'pulumi:project']
+        for key in iac_keys:
+            if key in tags_dict and tags_dict[key]:
+                return "Yes"
+        return "No"
+
+    def _estimate_cleanup_timeline(self, candidate: Any) -> str:
+        """Estimate cleanup timeline based on complexity."""
+        # Simple heuristic based on dependencies
+        if hasattr(candidate, 'dependency_analysis') and candidate.dependency_analysis:
+            eni_count = getattr(candidate.dependency_analysis, 'eni_count', 0)
+        else:
+            eni_count = 0
+            
+        if eni_count == 0:
+            return "1-2 days"
+        elif eni_count < 5:
+            return "3-5 days" 
+        else:
+            return "1-2 weeks"
+
+    def _format_cleanup_decision(self, candidate: Any) -> str:
+        """Format cleanup decision recommendation."""
+        recommendation = getattr(candidate, 'cleanup_recommendation', 'unknown')
+        if recommendation == 'delete':
+            return "Delete"
+        elif recommendation == 'keep':
+            return "Keep"
+        elif recommendation == 'review':
+            return "Review"
+        else:
+            return "TBD"
+
+    def _format_tags_for_owners_display(self, tags_dict: dict) -> str:
+        """Format tags for display with priority on ownership information."""
+        if not tags_dict:
+            return "No tags"
+        
+        # Priority keys focusing on ownership and approvals
+        priority_keys = ['Name', 'Owner', 'BusinessOwner', 'TechnicalOwner', 'Team', 'Contact']
+        relevant_tags = []
+        
+        for key in priority_keys:
+            if key in tags_dict and tags_dict[key]:
+                relevant_tags.append(f"{key}:{tags_dict[key]}")
+                if len(relevant_tags) >= 3:  # Limit for table readability
+                    break
+        
+        return "; ".join(relevant_tags) if relevant_tags else f"({len(tags_dict)} tags)"
+
+    def _determine_cleanup_decision(self, candidate: Any) -> str:
+        """Determine cleanup decision based on VPC analysis."""
+        # Check the cleanup bucket from three-bucket strategy
+        cleanup_bucket = getattr(candidate, 'cleanup_bucket', 'unknown')
+        
+        if cleanup_bucket == 'bucket_1':
+            return "Delete"
+        elif cleanup_bucket == 'bucket_2': 
+            return "Review"
+        elif cleanup_bucket == 'bucket_3':
+            return "Keep"
+        else:
+            # Fallback logic based on other attributes
+            is_default = getattr(candidate, 'is_default', False)
+            has_eni = getattr(candidate, 'eni_count', 0) > 0
+            
+            if is_default and not has_eni:
+                return "Delete"
+            elif has_eni:
+                return "Review"
+            else:
+                return "TBD"
+
+    def _extract_owners_approvals(self, tags_dict: dict, is_default: bool) -> str:
+        """Extract owners and approval information from tags and VPC status."""
+        # Extract from tags with enhanced owner detection
+        owner_keys = ['Owner', 'BusinessOwner', 'TechnicalOwner', 'Team', 'Contact', 'CreatedBy', 'ManagedBy']
+        
+        extracted_owners = []
+        for key in owner_keys:
+            if key in tags_dict and tags_dict[key]:
+                value = tags_dict[key]
+                if 'business' in key.lower():
+                    extracted_owners.append(f"{value} (Business)")
+                elif 'technical' in key.lower():
+                    extracted_owners.append(f"{value} (Technical)")
+                elif 'team' in key.lower():
+                    extracted_owners.append(f"{value} (Team)")
+                else:
+                    extracted_owners.append(f"{value} ({key})")
+                
+                if len(extracted_owners) >= 2:  # Limit for table readability
+                    break
+        
+        if extracted_owners:
+            return "; ".join(extracted_owners)
+        
+        # Fallback based on VPC type
+        if is_default:
+            return "System Default VPC"
+        else:
+            # Check for IaC tags
+            iac_keys = ['aws:cloudformation:stack-name', 'terraform:module', 'cdktf:stack', 'pulumi:project']
+            for key in iac_keys:
+                if key in tags_dict and tags_dict[key]:
+                    return "IaC Managed"
+            return "No owner tags found"
+
+    def _generate_vpc_notes(self, candidate: Any) -> str:
+        """Generate comprehensive notes for VPC candidate."""
+        notes = []
+        
+        # Add bucket classification note
+        cleanup_bucket = getattr(candidate, 'cleanup_bucket', 'unknown')
+        if cleanup_bucket == 'bucket_1':
+            notes.append("Internal data plane - safe for cleanup")
+        elif cleanup_bucket == 'bucket_2':
+            notes.append("External interconnects - requires analysis")
+        elif cleanup_bucket == 'bucket_3':
+            notes.append("Control plane - manual review required")
+            
+        # Add ENI count if significant
+        if hasattr(candidate, 'dependency_analysis') and candidate.dependency_analysis:
+            eni_count = getattr(candidate.dependency_analysis, 'eni_count', 0)
+            if eni_count > 0:
+                notes.append(f"{eni_count} ENI attachments")
+        
+        # Add default VPC note
+        if getattr(candidate, 'is_default', False):
+            notes.append("Default VPC (CIS compliance issue)")
+            
+        # Add IaC detection
+        if getattr(candidate, 'iac_detected', False):
+            notes.append("IaC managed")
+            
+        # Add security concerns
+        risk_level = getattr(candidate, 'risk_level', 'unknown')
+        if risk_level == 'high':
+            notes.append("High security risk")
+            
+        return "; ".join(notes) if notes else "Standard VPC cleanup candidate"
+
 
 def export_finops_to_markdown(
     profile_data: Union[Dict[str, Any], List[Dict[str, Any]]],

runbooks/finops/nat_gateway_optimizer.py

@@ -49,6 +49,7 @@ 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 ..common.aws_pricing import get_service_monthly_cost, calculate_annual_cost
 from .embedded_mcp_validator import EmbeddedMCPValidator
 from ..common.profile_utils import get_profile_for_operation
 
@@ -139,14 +140,24 @@ class NATGatewayOptimizer:
             profile_name=get_profile_for_operation("operational", profile_name)
         )
         
-        # NAT Gateway pricing (per hour, as of 2024)
-        self.nat_gateway_hourly_cost = 0.045  # $0.045/hour
-        self.nat_gateway_data_processing_cost = 0.045  # $0.045/GB
+        # NAT Gateway pricing - using dynamic pricing engine
+        # Base monthly cost calculation (will be applied per region)
+        self._base_monthly_cost_us_east_1 = get_service_monthly_cost("nat_gateway", "us-east-1")
+        self.nat_gateway_data_processing_cost = 0.045  # $0.045/GB (data transfer pricing)
         
         # Enterprise thresholds for optimization recommendations
         self.low_usage_threshold_connections = 10  # Active connections per day
         self.low_usage_threshold_bytes = 1_000_000  # 1MB per day
         self.analysis_period_days = 7  # CloudWatch analysis period
+    
+    def _get_regional_monthly_cost(self, region: str) -> float:
+        """Get dynamic monthly NAT Gateway cost for specified region."""
+        try:
+            return get_service_monthly_cost("nat_gateway", region)
+        except Exception:
+            # Fallback to regional cost calculation
+            from ..common.aws_pricing import calculate_regional_cost
+            return calculate_regional_cost(self._base_monthly_cost_us_east_1, region)
         
     async def analyze_nat_gateways(self, dry_run: bool = True) -> NATGatewayOptimizerResults:
         """
@@ -413,9 +424,9 @@ class NATGatewayOptimizer:
                 metrics = usage_metrics.get(nat_gateway.nat_gateway_id)
                 route_tables = dependencies.get(nat_gateway.nat_gateway_id, [])
                 
-                # Calculate current costs
-                monthly_cost = self.nat_gateway_hourly_cost * 24 * 30  # Base hourly cost
-                annual_cost = monthly_cost * 12
+                # Calculate current costs using dynamic pricing
+                monthly_cost = self._get_regional_monthly_cost(nat_gateway.region)
+                annual_cost = calculate_annual_cost(monthly_cost)
                 
                 # Determine optimization recommendation
                 recommendation = "retain"  # Default: keep the NAT Gateway
@@ -724,9 +735,9 @@ class TransitGatewayCostAnalysis(BaseModel):
     """Transit Gateway cost analysis results"""  
     transit_gateway_id: str
     region: str
-    monthly_base_cost: float = 36.50  # $36.50/month base cost
+    monthly_base_cost: float = 0.0  # Will be calculated dynamically based on region
     attachment_count: int = 0
-    attachment_hourly_cost: float = 0.05  # $0.05/hour per attachment
+    attachment_hourly_cost: float = 0.05  # $0.05/hour per attachment (attachment pricing)
     data_processing_cost: float = 0.0
     total_monthly_cost: float = 0.0
     annual_cost: float = 0.0
@@ -737,7 +748,7 @@ class NetworkDataTransferCostAnalysis(BaseModel):
     """Network data transfer cost analysis"""
     region_pair: str  # e.g., "us-east-1 -> us-west-2"
     monthly_gb_transferred: float = 0.0
-    cost_per_gb: float = 0.02  # Varies by region pair
+    cost_per_gb: float = 0.0  # Will be calculated dynamically based on region pair
     monthly_transfer_cost: float = 0.0
     annual_transfer_cost: float = 0.0
     optimization_recommendations: List[str] = Field(default_factory=list)
@@ -763,17 +774,43 @@ class EnhancedVPCCostOptimizer:
         self.profile = profile
         self.nat_optimizer = NATGatewayOptimizer(profile=profile)
         
-        # Cost model from vpc cost_engine.py
-        self.cost_model = {
-            "nat_gateway_hourly": 0.045,
-            "nat_gateway_data_processing": 0.045,  # per GB
-            "transit_gateway_monthly": 36.50,
-            "transit_gateway_attachment_hourly": 0.05,
-            "vpc_endpoint_interface_hourly": 0.01,
-            "data_transfer_regional": 0.01,  # per GB within region
-            "data_transfer_cross_region": 0.02,  # per GB cross-region
-            "data_transfer_internet": 0.09  # per GB to internet
-        }
+        # Dynamic cost model using AWS pricing engine
+        self.cost_model = self._initialize_dynamic_cost_model()
+    
+    def _initialize_dynamic_cost_model(self) -> Dict[str, float]:
+        """Initialize dynamic cost model using AWS pricing engine."""
+        try:
+            # Get base pricing for us-east-1, then apply regional multipliers as needed
+            base_region = "us-east-1"
+            
+            return {
+                "nat_gateway_monthly": get_service_monthly_cost("nat_gateway", base_region),
+                "nat_gateway_data_processing": get_service_monthly_cost("data_transfer", base_region),
+                "transit_gateway_monthly": get_service_monthly_cost("transit_gateway", base_region),
+                "vpc_endpoint_monthly": get_service_monthly_cost("vpc_endpoint", base_region),
+                "data_transfer_regional": get_service_monthly_cost("data_transfer", base_region),
+                "data_transfer_internet": get_service_monthly_cost("data_transfer", base_region) * 4.5,  # Internet is ~4.5x higher
+            }
+        except Exception as e:
+            print_warning(f"Dynamic pricing initialization failed: {e}")
+            # Fallback to regional cost calculation
+            from ..common.aws_pricing import calculate_regional_cost
+            base_costs = {
+                "nat_gateway_hourly": 0.045,
+                "nat_gateway_data_processing": 0.045,  # per GB
+                "transit_gateway_monthly": 36.50,
+                "transit_gateway_attachment_hourly": 0.05,
+                "vpc_endpoint_interface_hourly": 0.01,
+                "data_transfer_regional": 0.01,  # per GB within region
+                "data_transfer_cross_region": 0.02,  # per GB cross-region
+                "data_transfer_internet": 0.09  # per GB to internet
+            }
+            
+            # Apply regional multipliers to fallback costs
+            return {
+                key: calculate_regional_cost(value, "us-east-1") 
+                for key, value in base_costs.items()
+            }
         
     async def analyze_comprehensive_vpc_costs(self, profile: Optional[str] = None, 
                                             regions: Optional[List[str]] = None) -> Dict[str, Any]:

runbooks/finops/optimizer.py

@@ -11,6 +11,8 @@ from typing import Any, Dict, List, Optional
 
 import boto3
 
+from ..common.rich_utils import console
+
 
 @dataclass
 class CostSavingsOpportunity:

runbooks/finops/single_dashboard.py

@@ -638,7 +638,7 @@ class SingleAccountDashboard:
                 style="dim",
             )
 
-        console.print(table)
+        rich_console.print(table)
 
         # Summary panel (using filtered services for consistent analysis)
         total_current = sum(filtered_current_services.values())
@@ -681,7 +681,7 @@ class SingleAccountDashboard:
 • Services Analyzed: {len(all_services)}{period_info}
         """
 
-        console.print(Panel(summary_text.strip(), title="📊 Analysis Summary", style="info"))
+        rich_console.print(Panel(summary_text.strip(), title="📊 Analysis Summary", style="info"))
 
     def _export_service_analysis(
         self, args: argparse.Namespace, cost_data: Dict[str, Any], service_costs: List[str], account_id: str