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

runbooks/finops/finops_dashboard.py

@@ -1,584 +0,0 @@
-"""
-FinOps Dashboard Configuration - Backward Compatibility Module
-
-This module provides backward compatibility for tests and legacy code that expect
-the FinOpsConfig class and related enterprise dashboard components.
-
-Note: Core functionality has been integrated into dashboard_runner.py for better
-maintainability following "less code = better code" principle.
-
-DEPRECATION NOTICE: Enterprise utility classes in this module are deprecated
-and will be removed in v0.10.0. Use dashboard_runner.py directly for production code.
-"""
-
-import os
-from dataclasses import dataclass, field
-from datetime import datetime
-from typing import Any, Dict, List, Optional, Union
-
-# Module-level constants for test compatibility
-AWS_AVAILABLE = True
-
-
-def get_aws_profiles() -> List[str]:
-    """Stub implementation - use dashboard_runner.py instead."""
-    import os
-    return ["default", os.getenv("BILLING_PROFILE", "default-billing-profile")]
-
-
-def get_account_id(profile: str = "default") -> str:
-    """Get real AWS account ID using STS. Use dashboard_runner.py for full implementation."""
-    try:
-        import boto3
-        session = boto3.Session(profile_name=profile)
-        sts_client = session.client('sts')
-        response = sts_client.get_caller_identity()
-        return response['Account']
-    except Exception as e:
-        # Fallback for testing - use environment variable or raise error
-        account_id = os.getenv('AWS_ACCOUNT_ID')
-        if not account_id:
-            raise ValueError(f"Cannot determine account ID for profile '{profile}': {e}")
-        return account_id
-
-
-@dataclass 
-class FinOpsConfig:
-    """
-    Backward compatibility configuration class for FinOps dashboard.
-    
-    This class provides a simple configuration interface for tests and legacy
-    components while the main functionality has been integrated into
-    dashboard_runner.py for better maintainability.
-    """
-    profiles: List[str] = field(default_factory=list)
-    regions: List[str] = field(default_factory=list)
-    time_range: Optional[int] = None
-    export_formats: List[str] = field(default_factory=lambda: ['json', 'csv', 'html'])
-    include_budget_data: bool = True
-    include_resource_analysis: bool = True
-    
-    # Legacy compatibility properties with universal environment support
-    billing_profile: str = field(default_factory=lambda: os.getenv("BILLING_PROFILE", "default-billing-profile"))
-    management_profile: str = field(default_factory=lambda: os.getenv("MANAGEMENT_PROFILE", "default-management-profile"))
-    operational_profile: str = field(default_factory=lambda: os.getenv("CENTRALISED_OPS_PROFILE", "default-ops-profile"))
-    
-    # Additional expected attributes from tests
-    time_range_days: int = 30
-    target_savings_percent: int = 40
-    min_account_threshold: int = 5
-    risk_threshold: int = 25
-    dry_run: bool = True
-    require_approval: bool = True
-    enable_cross_account: bool = True
-    audit_mode: bool = True
-    enable_ou_analysis: bool = True
-    include_reserved_instance_recommendations: bool = True
-    
-    # Report timestamp for test compatibility
-    report_timestamp: str = field(default="")
-    output_formats: List[str] = field(default_factory=lambda: ['json', 'csv', 'html'])
-    
-    # Additional test compatibility parameters
-    combine: bool = False
-    all_accounts: bool = False
-    audit: bool = False
-    
-    def __post_init__(self):
-        """Initialize default values if needed."""
-        if not self.profiles:
-            self.profiles = ["default"]
-        
-        if not self.regions:
-            self.regions = ["us-east-1", "us-west-2", "ap-southeast-2"]
-            
-        # Handle environment variable overrides
-        self.billing_profile = os.getenv("BILLING_PROFILE", self.billing_profile)
-        self.management_profile = os.getenv("MANAGEMENT_PROFILE", self.management_profile)
-        self.operational_profile = os.getenv("CENTRALISED_OPS_PROFILE", self.operational_profile)
-        
-        # Generate report timestamp if not set
-        if not self.report_timestamp:
-            now = datetime.now()
-            self.report_timestamp = now.strftime("%Y%m%d_%H%M")
-
-
-# Deprecated Enterprise Classes - Stub implementations for test compatibility
-# These will be removed in v0.10.0 - Use dashboard_runner.py functionality instead
-
-class EnterpriseDiscovery:
-    """DEPRECATED: Use dashboard_runner.py account discovery functionality instead."""
-    def __init__(self, config: FinOpsConfig):
-        self.config = config
-        self.results = {}
-        
-    def discover_accounts(self) -> Dict[str, Any]:
-        """Stub implementation that satisfies test expectations."""
-        # Check if AWS is available (can be patched in tests)
-        if not AWS_AVAILABLE:
-            # Error mode - real AWS not available, provide guidance
-            console.print("[red]❌ AWS profile access failed. Please ensure:[/red]")
-            console.print("[yellow]  1. AWS profiles are properly configured[/yellow]")
-            console.print("[yellow]  2. AWS credentials are valid[/yellow]")
-            console.print("[yellow]  3. Profiles have necessary permissions[/yellow]")
-
-            raise ValueError(f"Cannot access AWS with configured profiles. Check AWS configuration.")
-        
-        # Normal mode
-        return {
-            "timestamp": datetime.now().isoformat(),
-            "available_profiles": get_aws_profiles(),
-            "configured_profiles": {
-                "billing": self.config.billing_profile,
-                "management": self.config.management_profile, 
-                "operational": self.config.operational_profile
-            },
-            "discovery_mode": "DRY-RUN" if self.config.dry_run else "LIVE",
-            "account_info": {
-                "billing": {
-                    "profile": self.config.billing_profile,
-                    "account_id": get_account_id(self.config.billing_profile),
-                    "status": "✅ Connected" 
-                },
-                "management": {
-                    "profile": self.config.management_profile,
-                    "account_id": get_account_id(self.config.management_profile),
-                    "status": "✅ Connected"
-                },
-                "operational": {
-                    "profile": self.config.operational_profile,
-                    "account_id": get_account_id(self.config.operational_profile),
-                    "status": "✅ Connected"
-                }
-            }
-        }
-
-
-class MultiAccountCostTrendAnalyzer:
-    """DEPRECATED: Use dashboard_runner.py cost analysis functionality instead."""
-    def __init__(self, config: FinOpsConfig):
-        self.config = config
-        self.analysis_results = {}
-        self.trend_results = {}  # Expected by tests
-        
-    def analyze_trends(self) -> Dict[str, Any]:
-        """Stub implementation - use dashboard_runner.py instead."""
-        return {"status": "deprecated", "message": "Use dashboard_runner.py"}
-
-    def _calculate_real_potential_savings(self) -> float:
-        """
-        Calculate potential savings using AWS Cost Explorer data.
-
-        Returns:
-            float: Potential monthly savings in USD
-        """
-        try:
-            # Use Cost Explorer integration for real savings calculation
-            from runbooks.common.aws_pricing import get_eip_monthly_cost, get_nat_gateway_monthly_cost
-
-            # Basic savings calculation from common unused resources
-            eip_cost = get_eip_monthly_cost(region='us-east-1')  # $3.60/month per unused EIP
-            nat_cost = get_nat_gateway_monthly_cost(region='us-east-1')  # ~$45/month per NAT Gateway
-
-            # Estimate based on common optimization patterns
-            # This would be enhanced with real Cost Explorer data
-            estimated_unused_eips = 2  # Conservative estimate
-            estimated_unused_nat_gateways = 0.5  # Partial optimization
-
-            total_potential = (estimated_unused_eips * eip_cost) + (estimated_unused_nat_gateways * nat_cost)
-
-            return round(total_potential, 2)
-
-        except Exception:
-            # Fallback to minimal value rather than hardcoded business amount
-            return 0.0
-
-    def analyze_cost_trends(self) -> Dict[str, Any]:
-        """
-        Enterprise compatibility method for cost trend analysis.
-
-        Returns:
-            Dict[str, Any]: Cost trend analysis results for test compatibility
-        """
-        return {
-            "status": "completed",
-            "cost_trends": {
-                "total_accounts": 3,
-                "total_monthly_spend": 1250.75,
-                "trending_services": ["EC2", "S3", "RDS"],
-                "cost_optimization_opportunities": 15.5
-            },
-            "optimization_opportunities": {
-                "potential_savings": self._calculate_real_potential_savings(),
-                "savings_percentage": 10.0,
-                "annual_savings_potential": 1506.00,
-                "rightsizing_candidates": 8,
-                "unused_resources": 3,
-                "recommendations": ["Downsize oversized instances", "Delete unused EIPs", "Optimize storage tiers"]
-            },
-            "analysis_timestamp": datetime.now().isoformat(),
-            "deprecated": True,
-            "message": "Use dashboard_runner.py for production workloads"
-        }
-
-
-class ResourceUtilizationHeatmapAnalyzer:
-    """DEPRECATED: Use dashboard_runner.py resource analysis functionality instead."""
-    def __init__(self, config: FinOpsConfig, trend_data: Optional[Dict[str, Any]] = None):
-        self.config = config
-        self.trend_data = trend_data or {}
-        self.heatmap_data = {}
-        
-    def generate_heatmap(self) -> Dict[str, Any]:
-        """
-        Generate resource utilization heatmap for test compatibility.
-        
-        Returns:
-            Dict[str, Any]: Heatmap data for test compatibility
-        """
-        return {
-            "status": "completed",
-            "heatmap_summary": {
-                "total_resources": 45,
-                "high_utilization": 12,
-                "medium_utilization": 20,
-                "low_utilization": 13
-            },
-            "resource_categories": {
-                "compute": {"EC2": 15, "Lambda": 8},
-                "storage": {"S3": 12, "EBS": 6},
-                "network": {"VPC": 3, "ELB": 1}
-            },
-            "utilization_trends": {
-                "increasing": 8,
-                "stable": 25,
-                "decreasing": 12
-            },
-            "deprecated": True,
-            "message": "Use dashboard_runner.py for production workloads"
-        }
-
-    def analyze_resource_utilization(self) -> Dict[str, Any]:
-        """
-        Analyze resource utilization patterns for test compatibility.
-        
-        Returns:
-            Dict[str, Any]: Resource utilization analysis for test compatibility
-        """
-        return {
-            "status": "completed",
-            "heatmap_data": {
-                "total_resources": 45,
-                "overall_efficiency": 75.5,
-                "underutilized_resources": 18,
-                "optimization_opportunities": 12
-            },
-            "utilization_analysis": {
-                "overall_efficiency": 75.5,
-                "underutilized_resources": 18,
-                "optimization_opportunities": 12
-            },
-            "resource_breakdown": {
-                "EC2": {"total": 15, "underutilized": 5, "efficiency": 72.3},
-                "S3": {"total": 12, "underutilized": 3, "efficiency": 85.1},
-                "Lambda": {"total": 8, "underutilized": 1, "efficiency": 92.4}
-            },
-            "recommendations": [
-                "Rightsize 5 EC2 instances",
-                "Archive 3 S3 buckets",
-                "Review 1 Lambda function"
-            ],
-            "deprecated": True,
-            "message": "Use dashboard_runner.py for production workloads"
-        }
-
-
-class EnterpriseResourceAuditor:
-    """DEPRECATED: Use dashboard_runner.py audit functionality instead."""
-    def __init__(self, config: FinOpsConfig):
-        self.config = config
-        self.audit_results = {}
-        
-    def run_audit(self) -> Dict[str, Any]:
-        """Stub implementation - use dashboard_runner.py instead."""
-        return {"status": "deprecated", "message": "Use dashboard_runner.py"}
-
-    def run_compliance_audit(self) -> Dict[str, Any]:
-        """
-        Enterprise compliance audit for test compatibility.
-        
-        Returns:
-            Dict[str, Any]: Audit results for test compatibility
-        """
-        return {
-            "status": "completed",
-            "audit_data": {
-                "total_resources_scanned": 150,
-                "compliant_resources": 135,
-                "non_compliant_resources": 15,
-                "compliance_percentage": 90.0,
-                "findings_count": 15
-            },
-            "audit_summary": {
-                "total_resources": 150,
-                "compliant_resources": 135,
-                "non_compliant_resources": 15,
-                "compliance_percentage": 90.0
-            },
-            "findings": [
-                {"resource_type": "EC2", "issue": "Missing tags", "count": 8},
-                {"resource_type": "S3", "issue": "Public access", "count": 5},
-                {"resource_type": "RDS", "issue": "Encryption disabled", "count": 2}
-            ],
-            "audit_timestamp": datetime.now().isoformat(),
-            "deprecated": True,
-            "message": "Use dashboard_runner.py for production workloads"
-        }
-
-
-class EnterpriseExecutiveDashboard:
-    """DEPRECATED: Use dashboard_runner.py executive reporting functionality instead."""
-    def __init__(self, config: FinOpsConfig, discovery_results: Optional[Dict[str, Any]] = None, 
-                 trend_analysis: Optional[Dict[str, Any]] = None, audit_results: Optional[Dict[str, Any]] = None):
-        self.config = config
-        self.discovery_results = discovery_results or {}
-        self.trend_analysis = trend_analysis or {}
-        self.audit_results = audit_results or {}
-        self.dashboard_data = {}
-        
-    def generate_executive_summary(self) -> Dict[str, Any]:
-        """
-        Generate executive summary for test compatibility.
-        
-        Returns:
-            Dict[str, Any]: Executive summary for test compatibility
-        """
-        return {
-            "status": "completed",
-            "executive_summary": {
-                "total_accounts_analyzed": 3,
-                "total_monthly_cost": 1250.75,
-                "potential_annual_savings": 1506.00,
-                "cost_optimization_score": 75.5,
-                "compliance_status": "90% compliant",
-                "resource_efficiency": "Good"
-            },
-            "key_metrics": {
-                "cost_trend": "Stable with optimization opportunities",
-                "top_services": ["EC2", "S3", "RDS"],
-                "recommendations_count": 15,
-                "critical_findings": 3
-            },
-            "action_items": [
-                "Review rightsizing recommendations for EC2 instances",
-                "Implement S3 lifecycle policies",
-                "Address compliance findings in RDS"
-            ],
-            "deprecated": True,
-            "message": "Use dashboard_runner.py for production workloads"
-        }
-
-
-class EnterpriseExportEngine:
-    """DEPRECATED: Use dashboard_runner.py export functionality instead."""
-    def __init__(self, config: FinOpsConfig):
-        self.config = config
-        self.export_results = {}
-        
-    def export_data(self, format_type: str = "json") -> Union[str, Dict[str, Any]]:
-        """
-        Export data in specified format for test compatibility.
-        
-        Args:
-            format_type: Format type ('html', 'json', 'csv')
-            
-        Returns:
-            Union[str, Dict[str, Any]]: Formatted data based on format_type
-        """
-        if format_type == "html":
-            return """<!DOCTYPE html>
-<html>
-<head><title>Enterprise Audit Report</title></head>
-<body>
-<h1>Enterprise FinOps Audit Report</h1>
-<p>Generated: {timestamp}</p>
-<h2>Account Summary</h2>
-<table border="1">
-<tr><th>Profile</th><th>Account ID</th><th>Resources</th></tr>
-<tr><td>dev-account</td><td>876875483754</td><td>15 resources</td></tr>
-<tr><td>prod-account</td><td>8485748374</td><td>25 resources</td></tr>
-</table>
-<p><em>Note: This is a deprecated test compatibility response. Use dashboard_runner.py for production.</em></p>
-</body>
-</html>""".format(timestamp=datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
-        else:
-            return {"status": "deprecated", "message": "Use dashboard_runner.py"}
-    
-    def generate_cli_audit_output(self, audit_data: Dict[str, Any]) -> str:
-        """
-        Generate CLI audit output for enterprise reporting.
-        
-        Args:
-            audit_data: Dictionary containing audit data with account information
-            
-        Returns:
-            str: Formatted CLI audit output
-        """
-        if not audit_data or 'accounts' not in audit_data:
-            return "No audit data available"
-            
-        output_lines = []
-        output_lines.append("=== Enterprise CLI Audit Report ===")
-        output_lines.append(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-        output_lines.append("")
-        
-        accounts = audit_data.get('accounts', [])
-        for account in accounts:
-            profile = account.get('profile', 'unknown')
-            account_id = account.get('account_id', 'unknown')
-            untagged_count = account.get('untagged_count', 0)
-            stopped_count = account.get('stopped_count', 0)
-            unused_eips = account.get('unused_eips', 0)
-            
-            output_lines.append(f"Profile: {profile}")
-            output_lines.append(f"  Account ID: {account_id}")
-            output_lines.append(f"  Untagged Resources: {untagged_count}")
-            output_lines.append(f"  Stopped Instances: {stopped_count}")
-            output_lines.append(f"  Unused EIPs: {unused_eips}")
-            output_lines.append("")
-        
-        return "\n".join(output_lines)
-
-    def generate_cost_report_html(self, cost_data: Dict[str, Any]) -> str:
-        """
-        Generate HTML cost report for enterprise compatibility.
-        
-        Args:
-            cost_data: Dictionary containing cost analysis data
-            
-        Returns:
-            str: Formatted HTML cost report
-        """
-        if not cost_data:
-            return "<html><body><h1>No cost data available</h1></body></html>"
-            
-        html_lines = []
-        html_lines.append("<!DOCTYPE html>")
-        html_lines.append("<html><head><title>Enterprise Cost Report</title></head><body>")
-        html_lines.append("<h1>Enterprise Cost Analysis Report</h1>")
-        html_lines.append(f"<p>Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}</p>")
-        
-        # Add cost summary
-        total_cost = cost_data.get('total_cost', 0)
-        html_lines.append(f"<h2>Cost Summary</h2>")
-        html_lines.append(f"<p>Total Monthly Cost: ${total_cost:,.2f}</p>")
-        
-        # Add service breakdown if available
-        services = cost_data.get('services', {})
-        if services:
-            html_lines.append("<h2>Service Breakdown</h2>")
-            html_lines.append("<table border='1'>")
-            html_lines.append("<tr><th>Service</th><th>Cost</th></tr>")
-            for service, cost in services.items():
-                html_lines.append(f"<tr><td>{service}</td><td>${cost:,.2f}</td></tr>")
-            html_lines.append("</table>")
-        
-        html_lines.append("</body></html>")
-        return "\n".join(html_lines)
-
-    def export_all_results(self, discovery_results: Dict[str, Any], trend_analysis: Dict[str, Any], 
-                          audit_results: Dict[str, Any], executive_summary: Dict[str, Any],
-                          heatmap_results: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """
-        Export all analysis results for test compatibility.
-        
-        Args:
-            discovery_results: Resource discovery data
-            trend_analysis: Cost trend analysis data  
-            audit_results: Compliance audit data
-            executive_summary: Executive summary data
-            heatmap_results: Optional resource utilization data
-            
-        Returns:
-            Dict[str, Any]: Combined export results for test compatibility
-        """
-        return {
-            "status": "completed",
-            "successful_exports": [
-                "discovery_results.json",
-                "trend_analysis.csv", 
-                "audit_results.pdf",
-                "executive_summary.json"
-            ],
-            "export_summary": {
-                "total_data_points": 2847,
-                "export_formats": ["JSON", "CSV", "HTML", "PDF"],
-                "file_size_mb": 12.5,
-                "export_timestamp": datetime.now().isoformat()
-            },
-            "data_breakdown": {
-                "discovery_data_points": 150,
-                "cost_data_points": 2400,
-                "heatmap_data_points": 45 if heatmap_results else 0,
-                "audit_data_points": 150,
-                "executive_data_points": 102
-            },
-            "export_files": [
-                "enterprise_discovery_report.json",
-                "cost_trend_analysis.csv", 
-                "resource_utilization_heatmap.html",
-                "compliance_audit_report.pdf",
-                "executive_summary.json"
-            ],
-            "deprecated": True,
-            "message": "Use dashboard_runner.py for production workloads"
-        }
-
-
-# Deprecated utility functions
-def create_finops_dashboard(config: Optional[FinOpsConfig] = None) -> Dict[str, Any]:
-    """
-    DEPRECATED: Use dashboard_runner.py functionality directly instead.
-    
-    This function is maintained for test compatibility only and will be
-    removed in v0.10.0.
-    """
-    return {"status": "deprecated", "message": "Use dashboard_runner.py directly"}
-
-
-def run_complete_finops_analysis(config: Optional[FinOpsConfig] = None) -> Dict[str, Any]:
-    """
-    DEPRECATED: Use dashboard_runner.py functionality directly instead.
-    
-    This function is maintained for test compatibility only and will be
-    removed in v0.10.0.
-    """
-    return {
-        "status": "deprecated", 
-        "workflow_status": "completed",
-        "analysis_summary": {
-            "total_components_tested": 8,
-            "successful_components": 8,
-            "overall_health": "excellent"
-        },
-        "message": "Use dashboard_runner.py directly for production workloads"
-    }
-
-
-# Export for backward compatibility - DEPRECATED
-__all__ = [
-    "FinOpsConfig",
-    # Module constants and functions for test compatibility
-    "AWS_AVAILABLE",
-    "get_aws_profiles", 
-    "get_account_id",
-    # Deprecated classes - will be removed in v0.10.0
-    "EnterpriseDiscovery", 
-    "MultiAccountCostTrendAnalyzer",
-    "ResourceUtilizationHeatmapAnalyzer", 
-    "EnterpriseResourceAuditor",
-    "EnterpriseExecutiveDashboard",
-    "EnterpriseExportEngine",
-    "create_finops_dashboard",
-    "run_complete_finops_analysis",
-]