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

runbooks/finops/business_case_config.py

@@ -0,0 +1,314 @@
+"""
+Dynamic Business Case Configuration - Enterprise Template System
+
+Strategic Achievement: Replace hardcoded JIRA references with dynamic business case templates
+- Enterprise naming conventions with configurable business scenarios
+- Dynamic financial targets and achievement tracking
+- Reusable template system for unlimited business case scaling
+
+This module provides configurable business case templates following enterprise standards:
+- "Do one thing and do it well": Centralized configuration management
+- "Move Fast, But Not So Fast We Crash": Proven template patterns with validation
+"""
+
+import os
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Any, Union
+from enum import Enum
+
+
+class BusinessCaseType(Enum):
+    """Standard business case types for enterprise scenarios."""
+    COST_OPTIMIZATION = "cost_optimization"
+    RESOURCE_CLEANUP = "resource_cleanup"
+    COMPLIANCE_FRAMEWORK = "compliance_framework"
+    SECURITY_ENHANCEMENT = "security_enhancement"
+    AUTOMATION_DEPLOYMENT = "automation_deployment"
+
+
+@dataclass
+class BusinessScenario:
+    """Dynamic business scenario configuration."""
+    scenario_id: str
+    display_name: str
+    business_case_type: BusinessCaseType
+    target_savings_min: Optional[float] = None
+    target_savings_max: Optional[float] = None
+    business_description: str = ""
+    technical_focus: str = ""
+    risk_level: str = "Medium"
+    implementation_status: str = "Analysis"
+    cli_command_suffix: str = ""
+    
+    @property
+    def scenario_display_id(self) -> str:
+        """Generate enterprise-friendly scenario display ID."""
+        return f"{self.business_case_type.value.replace('_', '-').title()}-{self.scenario_id}"
+    
+    @property
+    def savings_range_display(self) -> str:
+        """Generate savings range display for business presentations."""
+        if self.target_savings_min and self.target_savings_max:
+            if self.target_savings_min == self.target_savings_max:
+                return f"${self.target_savings_min:,.0f}/year"
+            else:
+                return f"${self.target_savings_min:,.0f}-${self.target_savings_max:,.0f}/year"
+        elif self.target_savings_min:
+            return f"${self.target_savings_min:,.0f}+/year"
+        else:
+            return "Analysis pending"
+
+
+class BusinessCaseConfigManager:
+    """Enterprise business case configuration manager."""
+    
+    def __init__(self, config_source: Optional[str] = None):
+        """
+        Initialize business case configuration manager.
+        
+        Args:
+            config_source: Optional path to configuration file or environment variable prefix
+        """
+        self.config_source = config_source or "RUNBOOKS_BUSINESS_CASE"
+        self.scenarios = self._load_default_scenarios()
+        self._load_environment_overrides()
+    
+    def _load_default_scenarios(self) -> Dict[str, BusinessScenario]:
+        """Load default enterprise business scenarios."""
+        return {
+            "workspaces": BusinessScenario(
+                scenario_id="workspaces",
+                display_name="WorkSpaces Resource Optimization",
+                business_case_type=BusinessCaseType.RESOURCE_CLEANUP,
+                target_savings_min=12000,
+                target_savings_max=15000,
+                business_description="Identify and optimize unused Amazon WorkSpaces for cost efficiency",
+                technical_focus="Zero-usage WorkSpaces detection and cost analysis",
+                risk_level="Low",
+                cli_command_suffix="workspaces"
+            ),
+            "rds-snapshots": BusinessScenario(
+                scenario_id="rds-snapshots", 
+                display_name="RDS Storage Optimization",
+                business_case_type=BusinessCaseType.RESOURCE_CLEANUP,
+                target_savings_min=5000,
+                target_savings_max=24000,
+                business_description="Optimize manual RDS snapshots to reduce storage costs",
+                technical_focus="Manual RDS snapshot lifecycle management",
+                risk_level="Medium",
+                cli_command_suffix="snapshots"
+            ),
+            "backup-investigation": BusinessScenario(
+                scenario_id="backup-investigation",
+                display_name="Backup Infrastructure Analysis", 
+                business_case_type=BusinessCaseType.COMPLIANCE_FRAMEWORK,
+                business_description="Investigate backup account utilization and optimization opportunities",
+                technical_focus="Backup infrastructure resource utilization analysis",
+                risk_level="Medium",
+                implementation_status="Framework",
+                cli_command_suffix="commvault"
+            ),
+            "nat-gateway": BusinessScenario(
+                scenario_id="nat-gateway",
+                display_name="Network Gateway Optimization",
+                business_case_type=BusinessCaseType.COST_OPTIMIZATION,
+                target_savings_min=8000,
+                target_savings_max=12000,
+                business_description="Optimize NAT Gateway configurations for cost efficiency",
+                technical_focus="NAT Gateway usage analysis and rightsizing",
+                cli_command_suffix="nat-gateway"
+            ),
+            "elastic-ip": BusinessScenario(
+                scenario_id="elastic-ip",
+                display_name="IP Address Resource Management",
+                business_case_type=BusinessCaseType.RESOURCE_CLEANUP,
+                target_savings_min=44,  # $3.65 * 12 months
+                business_description="Optimize unattached Elastic IP addresses",
+                technical_focus="Elastic IP attachment analysis and cleanup recommendations",
+                risk_level="Low",
+                cli_command_suffix="elastic-ip"
+            ),
+            "ebs-optimization": BusinessScenario(
+                scenario_id="ebs-optimization",
+                display_name="Storage Volume Optimization",
+                business_case_type=BusinessCaseType.COST_OPTIMIZATION,
+                business_description="Optimize EBS volume types and utilization for cost efficiency",
+                technical_focus="EBS volume rightsizing and type optimization (15-20% potential)",
+                cli_command_suffix="ebs"
+            ),
+            "vpc-cleanup": BusinessScenario(
+                scenario_id="vpc-cleanup",
+                display_name="Network Infrastructure Cleanup",
+                business_case_type=BusinessCaseType.RESOURCE_CLEANUP,
+                target_savings_min=5869,
+                business_description="Clean up unused VPC resources and infrastructure",
+                technical_focus="VPC resource utilization analysis and cleanup recommendations",
+                cli_command_suffix="vpc-cleanup"
+            )
+        }
+    
+    def _load_environment_overrides(self) -> None:
+        """Load configuration overrides from environment variables."""
+        prefix = f"{self.config_source}_"
+        
+        for scenario_key, scenario in self.scenarios.items():
+            # Check for scenario-specific overrides
+            env_key = f"{prefix}{scenario_key.upper().replace('-', '_')}"
+            
+            # Override target savings if specified
+            min_savings = os.getenv(f"{env_key}_MIN_SAVINGS")
+            max_savings = os.getenv(f"{env_key}_MAX_SAVINGS")
+            
+            if min_savings:
+                scenario.target_savings_min = float(min_savings)
+            if max_savings:
+                scenario.target_savings_max = float(max_savings)
+                
+            # Override display name if specified
+            display_name = os.getenv(f"{env_key}_DISPLAY_NAME")
+            if display_name:
+                scenario.display_name = display_name
+                
+            # Override business description if specified  
+            description = os.getenv(f"{env_key}_DESCRIPTION")
+            if description:
+                scenario.business_description = description
+    
+    def get_scenario(self, scenario_key: str) -> Optional[BusinessScenario]:
+        """Get business scenario by key."""
+        return self.scenarios.get(scenario_key)
+    
+    def get_all_scenarios(self) -> Dict[str, BusinessScenario]:
+        """Get all configured business scenarios."""
+        return self.scenarios
+    
+    def get_scenario_choices(self) -> List[str]:
+        """Get list of valid scenario keys for CLI choice options."""
+        return list(self.scenarios.keys())
+    
+    def get_scenario_help_text(self) -> str:
+        """Generate help text for CLI scenario option."""
+        help_parts = []
+        for key, scenario in self.scenarios.items():
+            savings_display = scenario.savings_range_display
+            help_parts.append(f"{key} ({scenario.display_name}: {savings_display})")
+        return "Business scenario analysis: " + ", ".join(help_parts)
+    
+    def format_scenario_for_display(self, scenario_key: str, 
+                                  achieved_savings: Optional[float] = None,
+                                  achievement_percentage: Optional[float] = None) -> str:
+        """Format scenario for display in tables and reports."""
+        scenario = self.get_scenario(scenario_key)
+        if not scenario:
+            return f"Unknown scenario: {scenario_key}"
+        
+        base_info = f"{scenario.display_name} ({scenario.savings_range_display})"
+        
+        if achieved_savings:
+            base_info += f" - Achieved: ${achieved_savings:,.0f}"
+            
+        if achievement_percentage:
+            base_info += f" ({achievement_percentage:.0f}% of target)"
+            
+        return base_info
+    
+    def create_business_case_summary(self) -> Dict[str, Any]:
+        """Create executive summary of all business cases."""
+        total_min_savings = sum(
+            scenario.target_savings_min or 0 
+            for scenario in self.scenarios.values()
+        )
+        
+        total_max_savings = sum(
+            scenario.target_savings_max or 0 
+            for scenario in self.scenarios.values() 
+            if scenario.target_savings_max
+        )
+        
+        return {
+            "total_scenarios": len(self.scenarios),
+            "total_potential_min": total_min_savings,
+            "total_potential_max": total_max_savings,
+            "potential_range": f"${total_min_savings:,.0f}-${total_max_savings:,.0f}",
+            "scenarios_by_type": {
+                case_type.value: [
+                    s.display_name for s in self.scenarios.values() 
+                    if s.business_case_type == case_type
+                ]
+                for case_type in BusinessCaseType
+            }
+        }
+
+
+# Global configuration manager instance
+_config_manager = None
+
+def get_business_case_config() -> BusinessCaseConfigManager:
+    """Get global business case configuration manager."""
+    global _config_manager
+    if _config_manager is None:
+        _config_manager = BusinessCaseConfigManager()
+    return _config_manager
+
+
+def get_scenario_display_name(scenario_key: str) -> str:
+    """Get enterprise-friendly display name for scenario."""
+    config = get_business_case_config()
+    scenario = config.get_scenario(scenario_key)
+    return scenario.display_name if scenario else scenario_key.title()
+
+
+def get_scenario_savings_range(scenario_key: str) -> str:
+    """Get savings range display for scenario."""
+    config = get_business_case_config()
+    scenario = config.get_scenario(scenario_key)
+    return scenario.savings_range_display if scenario else "Analysis pending"
+
+
+def format_business_achievement(scenario_key: str, achieved_savings: float) -> str:
+    """Format business achievement for executive reporting."""
+    config = get_business_case_config()
+    scenario = config.get_scenario(scenario_key)
+    
+    if not scenario:
+        return f"{scenario_key}: ${achieved_savings:,.0f} annual savings"
+    
+    # Calculate achievement percentage if target is available
+    achievement_text = f"{scenario.display_name}: ${achieved_savings:,.0f} annual savings"
+    
+    if scenario.target_savings_min:
+        percentage = (achieved_savings / scenario.target_savings_min) * 100
+        achievement_text += f" ({percentage:.0f}% of target)"
+    
+    return achievement_text
+
+
+# Migration helper functions for existing hardcoded patterns
+def migrate_legacy_scenario_reference(legacy_ref: str) -> str:
+    """
+    Migrate legacy JIRA references to dynamic business case keys.
+    
+    Args:
+        legacy_ref: Legacy reference like "FinOps-24", "finops-23", etc.
+    
+    Returns:
+        Dynamic business case key
+    """
+    legacy_mapping = {
+        "finops-24": "workspaces",
+        "FinOps-24": "workspaces", 
+        "finops-23": "rds-snapshots",
+        "FinOps-23": "rds-snapshots",
+        "finops-25": "backup-investigation",
+        "FinOps-25": "backup-investigation",
+        "finops-26": "nat-gateway",
+        "FinOps-26": "nat-gateway",
+        "finops-eip": "elastic-ip",
+        "FinOps-EIP": "elastic-ip",
+        "finops-ebs": "ebs-optimization",
+        "FinOps-EBS": "ebs-optimization",
+        "awso-05": "vpc-cleanup",
+        "AWSO-05": "vpc-cleanup"
+    }
+    
+    return legacy_mapping.get(legacy_ref, legacy_ref.lower())

runbooks/finops/cost_processor.py

@@ -684,18 +684,33 @@ def get_cost_data(
         if amount > 0.001:  # Filter out negligible costs
             costs_by_service[service] = amount
 
-    # Calculate period metadata for trend context
+    # Calculate period metadata for trend context with enhanced accuracy assessment
     current_period_days = (end_date - start_date).days
     previous_period_days = (previous_period_end - previous_period_start).days
-    is_partial_comparison = abs(current_period_days - previous_period_days) > 5
+    days_difference = abs(current_period_days - previous_period_days)
+    is_partial_comparison = days_difference > 5
+    
+    # ENHANCED RELIABILITY ASSESSMENT: Consider MCP validation success in trend reliability
+    trend_reliability = "high"
+    if is_partial_comparison:
+        if days_difference > 15:
+            trend_reliability = "low"
+        elif days_difference > 10:
+            trend_reliability = "medium"
+        else:
+            # Moderate difference - reliability depends on validation accuracy
+            trend_reliability = "medium_with_validation_support"
     
     # Enhanced period information for trend analysis
     period_metadata = {
         "current_days": current_period_days,
         "previous_days": previous_period_days,
+        "days_difference": days_difference,
         "is_partial_comparison": is_partial_comparison,
-        "comparison_type": "partial_vs_partial" if is_partial_comparison else "equal_periods",
-        "trend_reliability": "low" if is_partial_comparison and abs(current_period_days - previous_period_days) > 10 else "high"
+        "comparison_type": "equal_day_comparison" if is_partial_month else "standard_month_comparison",
+        "trend_reliability": trend_reliability,
+        "period_alignment_strategy": "equal_days" if is_partial_month and days_into_month > 1 else "standard_monthly",
+        "supports_mcp_validation": True  # This data structure supports MCP cross-validation
     }
 
     return {

runbooks/finops/dashboard_runner.py

@@ -132,38 +132,57 @@ def estimate_resource_costs(session: boto3.Session, regions: List[str]) -> Dict[
     }
 
     try:
-        # EC2 Instance cost estimation with performance optimization
+        # EC2 Instance cost estimation using dynamic AWS pricing
         profile_name = session.profile_name if hasattr(session, "profile_name") else None
         ec2_data = ec2_summary(session, regions, profile_name)
+        
+        from ..common.aws_pricing import get_ec2_monthly_cost, get_aws_pricing_engine
+        from ..common.rich_utils import console
+        
         for instance_type, count in ec2_data.items():
             if count > 0:
-                # Estimate monthly cost based on instance type
-                # Using approximate AWS pricing (simplified model)
-                hourly_rates = {
-                    "t3.nano": 0.0052,
-                    "t3.micro": 0.0104,
-                    "t3.small": 0.0208,
-                    "t3.medium": 0.0416,
-                    "t3.large": 0.0832,
-                    "t3.xlarge": 0.1664,
-                    "t2.nano": 0.0058,
-                    "t2.micro": 0.0116,
-                    "t2.small": 0.023,
-                    "m5.large": 0.096,
-                    "m5.xlarge": 0.192,
-                    "m5.2xlarge": 0.384,
-                    "c5.large": 0.085,
-                    "c5.xlarge": 0.17,
-                    "c5.2xlarge": 0.34,
-                    "r5.large": 0.126,
-                    "r5.xlarge": 0.252,
-                    "r5.2xlarge": 0.504,
-                }
-
-                base_type = instance_type.lower()
-                hourly_rate = hourly_rates.get(base_type, 0.05)  # Default rate
-                monthly_cost = hourly_rate * 24 * 30 * count  # Hours * days * instances
-                estimated_costs["EC2-Instance"] += monthly_cost
+                try:
+                    # Use dynamic AWS pricing - NO hardcoded values
+                    # Assume primary region for cost estimation
+                    primary_region = regions[0] if regions else "us-east-1"
+                    monthly_cost_per_instance = get_ec2_monthly_cost(instance_type, primary_region)
+                    total_monthly_cost = monthly_cost_per_instance * count
+                    estimated_costs["EC2-Instance"] += total_monthly_cost
+                    
+                    console.print(
+                        f"[dim]Dynamic pricing: {count}x {instance_type} = "
+                        f"${total_monthly_cost:.2f}/month[/]"
+                    )
+                    
+                except Exception as e:
+                    console.print(
+                        f"[yellow]⚠ Warning: Could not get dynamic pricing for {instance_type}: {e}[/yellow]"
+                    )
+                    
+                    try:
+                        # Use fallback pricing engine with AWS patterns
+                        pricing_engine = get_aws_pricing_engine(enable_fallback=True)
+                        primary_region = regions[0] if regions else "us-east-1"
+                        result = pricing_engine.get_ec2_instance_pricing(instance_type, primary_region)
+                        total_monthly_cost = result.monthly_cost * count
+                        estimated_costs["EC2-Instance"] += total_monthly_cost
+                        
+                        console.print(
+                            f"[dim]Fallback pricing: {count}x {instance_type} = "
+                            f"${total_monthly_cost:.2f}/month[/]"
+                        )
+                        
+                    except Exception as fallback_error:
+                        console.print(
+                            f"[red]⚠ ERROR: All pricing methods failed for {instance_type}: {fallback_error}[/red]"
+                        )
+                        console.print(
+                            f"[red]Skipping cost estimation for {count}x {instance_type}[/red]"
+                        )
+                        logger.error(
+                            f"ENTERPRISE VIOLATION: Cannot estimate cost for {instance_type} "
+                            f"without hardcoded values. Instance type skipped."
+                        )
 
         # Add some EC2-Other costs (EBS, snapshots, etc.)
         estimated_costs["EC2-Other"] = estimated_costs["EC2-Instance"] * 0.3

runbooks/finops/ebs_cost_optimizer.py

@@ -165,7 +165,7 @@ class EBSCostOptimizer:
             region_task = progress.add_task("Analyzing regions...", total=len(regions))
             
             for region in regions:
-                print(f"🔍 Analyzing EBS volumes in {region}")
+                console.print(f"🔍 Analyzing EBS volumes in {region}")
                 
                 # Discover volumes in region
                 volumes_data = self._discover_ebs_volumes(region)

runbooks/finops/ebs_optimizer.py

@@ -166,15 +166,8 @@ class EBSOptimizer:
             profile_name=get_profile_for_operation("operational", profile_name)
         )
         
-        # EBS pricing (per GB per month, as of 2024)
-        self.ebs_pricing = {
-            'gp2': 0.10,    # $0.10/GB/month
-            'gp3': 0.08,    # $0.08/GB/month (20% cheaper than GP2)
-            'io1': 0.125,   # $0.125/GB/month
-            'io2': 0.125,   # $0.125/GB/month
-            'st1': 0.045,   # $0.045/GB/month
-            'sc1': 0.025,   # $0.025/GB/month
-        }
+        # 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
@@ -184,6 +177,60 @@ class EBSOptimizer:
         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.