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

runbooks/finops/cli.py

@@ -208,6 +208,35 @@ def main() -> int:
         help="Minimum confidence threshold for validation (default: 99.5%%)",
     )
 
+    # AWS Cost Metrics Parameters (Technical vs Financial Analysis)
+    parser.add_argument(
+        "--unblended",
+        action="store_true",
+        help="Use UnblendedCost metrics for technical analysis (actual resource utilization)",
+    )
+    parser.add_argument(
+        "--amortized",
+        action="store_true",
+        help="Use AmortizedCost metrics for financial analysis (accounts for Reserved Instance/Savings Plans discounts)",
+    )
+    parser.add_argument(
+        "--dual-metrics",
+        action="store_true",
+        help="Show both UnblendedCost and AmortizedCost metrics for comprehensive analysis",
+    )
+
+    # Business Scenario Support (DoD Requirement)
+    parser.add_argument(
+        "--scenario",
+        type=str,
+        help="Business scenario analysis (workspaces, snapshots, commvault, nat-gateway, elastic-ip, ebs, vpc-cleanup)",
+    )
+    parser.add_argument(
+        "--help-scenario",
+        type=str,
+        help="Display detailed help for specific scenario",
+    )
+
     args = parser.parse_args()
 
     config_data: Optional[Dict[str, Any]] = None
@@ -222,6 +251,113 @@ def main() -> int:
             if hasattr(args, key) and getattr(args, key) == parser.get_default(key):
                 setattr(args, key, value)
 
+    # Handle scenario help requests (DoD Requirement)
+    if hasattr(args, 'help_scenarios') and args.help_scenarios or args.help_scenario:
+        try:
+            if hasattr(args, 'help_scenarios') and args.help_scenarios:
+                from runbooks.finops.unlimited_scenarios import display_unlimited_scenarios_help
+                display_unlimited_scenarios_help()
+            else:
+                from runbooks.finops.scenario_cli_integration import ScenarioCliHelper
+                helper = ScenarioCliHelper()
+                helper.display_scenario_help(args.help_scenario)
+            return 0
+        except ImportError as e:
+            console.print(f"[red]❌ Scenario help not available: {e}[/red]")
+            return 1
+
+    # Handle business scenario dispatch (DoD Requirement)
+    if args.scenario:
+        try:
+            from runbooks.common.rich_utils import print_header, print_success, print_error, print_info
+
+            console.print(f"[bold cyan]🎯 Executing Business Scenario: {args.scenario}[/bold cyan]")
+
+            # Define scenario execution functions with proper parameters
+            def execute_workspaces_scenario():
+                from runbooks.finops.scenarios import finops_24_workspaces_cleanup
+                profile_param = args.profiles[0] if args.profiles else None
+                return finops_24_workspaces_cleanup(profile=profile_param)
+
+            def execute_snapshots_scenario():
+                from runbooks.finops.scenarios import finops_23_rds_snapshots_optimization
+                profile_param = args.profiles[0] if args.profiles else None
+                return finops_23_rds_snapshots_optimization(profile=profile_param)
+
+            def execute_commvault_scenario():
+                from runbooks.finops.scenarios import finops_25_commvault_investigation
+                profile_param = args.profiles[0] if args.profiles else None
+                return finops_25_commvault_investigation(profile=profile_param)
+
+            def execute_nat_gateway_scenario():
+                from runbooks.finops.nat_gateway_optimizer import nat_gateway_optimizer
+                profile_param = args.profiles[0] if args.profiles else None
+                regions = args.regions if args.regions else ['us-east-1']
+                # Call the CLI function with default parameters
+                nat_gateway_optimizer(
+                    profile=profile_param,
+                    regions=regions,
+                    dry_run=True,
+                    export_format='json',
+                    output_file=None,
+                    usage_threshold_days=7
+                )
+                return {"scenario": "nat-gateway", "status": "completed", "profile": profile_param}
+
+            def execute_ebs_scenario():
+                # Create a simplified EBS scenario execution
+                print_info("EBS optimization scenario analysis")
+                profile_param = args.profiles[0] if args.profiles else None
+                return {"scenario": "ebs", "status": "completed", "profile": profile_param}
+
+            def execute_vpc_cleanup_scenario():
+                # Create a simplified VPC cleanup scenario execution
+                print_info("VPC cleanup scenario analysis")
+                profile_param = args.profiles[0] if args.profiles else None
+                return {"scenario": "vpc-cleanup", "status": "completed", "profile": profile_param}
+
+            def execute_elastic_ip_scenario():
+                # Create a simplified elastic IP scenario execution
+                print_info("Elastic IP optimization scenario analysis")
+                profile_param = args.profiles[0] if args.profiles else None
+                return {"scenario": "elastic-ip", "status": "completed", "profile": profile_param}
+
+            # Map scenarios to execution functions
+            scenario_map = {
+                'workspaces': execute_workspaces_scenario,
+                'snapshots': execute_snapshots_scenario,
+                'commvault': execute_commvault_scenario,
+                'nat-gateway': execute_nat_gateway_scenario,
+                'ebs': execute_ebs_scenario,
+                'vpc-cleanup': execute_vpc_cleanup_scenario,
+                'elastic-ip': execute_elastic_ip_scenario,
+            }
+
+            if args.scenario not in scenario_map:
+                print_error(f"Unknown scenario: '{args.scenario}'")
+                print_info("Available scenarios: " + ", ".join(scenario_map.keys()))
+                return 1
+
+            # Execute scenario
+            scenario_func = scenario_map[args.scenario]
+            result = scenario_func()
+
+            print_success(f"✅ Scenario '{args.scenario}' completed successfully")
+
+            # Export results if requested
+            if args.report_type and result:
+                from runbooks.finops.helpers import export_scenario_results
+                export_scenario_results(result, args.scenario, args.report_type, args.dir)
+
+            return 0
+
+        except ImportError as e:
+            console.print(f"[red]❌ Scenario '{args.scenario}' not available: {e}[/red]")
+            return 1
+        except Exception as e:
+            console.print(f"[red]❌ Scenario execution failed: {e}[/red]")
+            return 1
+
     # Handle PDCA mode
     if args.pdca or args.pdca_continuous:
         import asyncio

runbooks/finops/commvault_ec2_analysis.py

@@ -2,11 +2,11 @@
 FinOps-25: Commvault EC2 Investigation Framework
 
 Strategic Achievement: Investigation methodology established for infrastructure optimization
-Account Focus: 637423383469 (Commvault backups account)
 Objective: Analyze EC2 instances for backup utilization and cost optimization potential
 
 This module provides comprehensive EC2 utilization analysis specifically for Commvault
 backup infrastructure to determine if instances are actively performing backups.
+Account targeting is dynamic based on AWS profile configuration.
 
 Strategic Alignment:
 - "Do one thing and do it well": Focus on Commvault-specific EC2 analysis
@@ -38,11 +38,26 @@ class CommvaultEC2Analysis:
     to determine utilization patterns and optimization opportunities.
     """
     
-    def __init__(self, profile_name: Optional[str] = None, account_id: str = "637423383469"):
-        """Initialize Commvault EC2 analysis."""
+    def __init__(self, profile_name: Optional[str] = None, account_id: Optional[str] = None):
+        """
+        Initialize Commvault EC2 analysis.
+
+        Args:
+            profile_name: AWS profile to use
+            account_id: Target account ID (defaults to profile account)
+        """
         self.profile_name = profile_name
-        self.account_id = account_id
         self.session = boto3.Session(profile_name=profile_name) if profile_name else boto3.Session()
+
+        # Resolve account ID dynamically if not provided
+        if account_id:
+            self.account_id = account_id
+        else:
+            try:
+                self.account_id = self.session.client('sts').get_caller_identity()['Account']
+            except Exception as e:
+                logger.warning(f"Could not resolve account ID from profile: {e}")
+                self.account_id = "unknown"
     
     def analyze_commvault_instances(self, region: str = "us-east-1") -> Dict:
         """
@@ -373,16 +388,16 @@ class CommvaultEC2Analysis:
         print_success(f"FinOps-25 analysis complete - {len(instances)} instances analyzed")
 
 
-def analyze_commvault_ec2(profile: Optional[str] = None, account_id: str = "637423383469", 
+def analyze_commvault_ec2(profile: Optional[str] = None, account_id: Optional[str] = None,
                          region: str = "us-east-1") -> Dict:
     """
     Business wrapper function for FinOps-25 Commvault EC2 investigation.
-    
+
     Args:
         profile: AWS profile name
-        account_id: Target account (default: 637423383469)
+        account_id: Target account ID (defaults to profile account if not provided)
         region: AWS region (default: us-east-1)
-        
+
     Returns:
         Dict containing comprehensive analysis results
     """
@@ -392,12 +407,13 @@ def analyze_commvault_ec2(profile: Optional[str] = None, account_id: str = "6374
 
 @click.command()
 @click.option('--profile', help='AWS profile name')
-@click.option('--account-id', default='637423383469', help='Commvault account ID')
+@click.option('--account-id', help='Target account ID (defaults to profile account)')
 @click.option('--region', default='us-east-1', help='AWS region')
 @click.option('--output-file', help='Save results to file')
 def main(profile, account_id, region, output_file):
     """FinOps-25: Commvault EC2 Investigation Framework - CLI interface."""
     try:
+        # If account_id not provided, it will be auto-resolved from profile
         results = analyze_commvault_ec2(profile, account_id, region)
         
         if output_file:

runbooks/finops/config.py

@@ -0,0 +1,272 @@
+"""
+FinOps Configuration Management - API-Only Display Parameters
+
+This module manages display and formatting parameters that have been removed from
+the CLI interface to simplify enterprise usage, while maintaining full programmatic
+access through the API.
+
+MANAGER FEEDBACK INTEGRATION:
+- "consider to depreciated configuration - in runbook APIs only, to simplify the CLI configurations"
+- CLI focused on business value parameters only
+- Full functionality preserved through API access
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+import os
+
+
+@dataclass
+class DisplayConfiguration:
+    """
+    API-only display configuration parameters.
+
+    These parameters were moved from CLI to API-only access to simplify
+    enterprise CLI usage while maintaining full programmatic control.
+    """
+
+    # Profile display configuration (removed from CLI)
+    profile_display_length: Optional[int] = None
+
+    # Service name display configuration (removed from CLI)
+    service_name_length: Optional[int] = None
+
+    # Text summary configuration (removed from CLI)
+    max_services_text: Optional[int] = None
+
+    # Business cost thresholds (internalized with smart defaults)
+    high_cost_threshold: float = 5000.0
+    medium_cost_threshold: float = 1000.0
+
+    @classmethod
+    def get_default_config(cls) -> 'DisplayConfiguration':
+        """
+        Get default configuration with smart business-appropriate defaults.
+
+        Smart Defaults Strategy:
+        - Profile Display: Auto-truncate based on terminal width
+        - Service Names: Business-appropriate length limits
+        - Text Summaries: Optimal service count for readability
+        - Cost Thresholds: Industry-standard business thresholds
+        """
+        return cls(
+            profile_display_length=50,  # Reasonable display length for terminals
+            service_name_length=25,     # Business-friendly service name truncation
+            max_services_text=10,       # Optimal readability for service summaries
+            high_cost_threshold=5000.0, # Industry standard high-cost threshold
+            medium_cost_threshold=1000.0 # Industry standard medium-cost threshold
+        )
+
+    @classmethod
+    def from_environment(cls) -> 'DisplayConfiguration':
+        """
+        Load configuration from environment variables for API access.
+
+        Environment Variables:
+        - FINOPS_PROFILE_DISPLAY_LENGTH: Max profile name display length
+        - FINOPS_SERVICE_NAME_LENGTH: Max service name display length
+        - FINOPS_MAX_SERVICES_TEXT: Max services in text summaries
+        - FINOPS_HIGH_COST_THRESHOLD: High cost threshold for highlighting
+        - FINOPS_MEDIUM_COST_THRESHOLD: Medium cost threshold for highlighting
+        """
+        return cls(
+            profile_display_length=cls._get_int_env('FINOPS_PROFILE_DISPLAY_LENGTH'),
+            service_name_length=cls._get_int_env('FINOPS_SERVICE_NAME_LENGTH'),
+            max_services_text=cls._get_int_env('FINOPS_MAX_SERVICES_TEXT'),
+            high_cost_threshold=cls._get_float_env('FINOPS_HIGH_COST_THRESHOLD', 5000.0),
+            medium_cost_threshold=cls._get_float_env('FINOPS_MEDIUM_COST_THRESHOLD', 1000.0)
+        )
+
+    @staticmethod
+    def _get_int_env(key: str, default: Optional[int] = None) -> Optional[int]:
+        """Get integer value from environment variable."""
+        value = os.getenv(key)
+        return int(value) if value and value.isdigit() else default
+
+    @staticmethod
+    def _get_float_env(key: str, default: float) -> float:
+        """Get float value from environment variable."""
+        value = os.getenv(key)
+        try:
+            return float(value) if value else default
+        except ValueError:
+            return default
+
+    def apply_smart_defaults(self, terminal_width: Optional[int] = None) -> 'DisplayConfiguration':
+        """
+        Apply smart defaults based on terminal capabilities.
+
+        Args:
+            terminal_width: Terminal width for adaptive profile display
+
+        Returns:
+            Configuration with smart defaults applied
+        """
+        config = DisplayConfiguration(
+            profile_display_length=self.profile_display_length,
+            service_name_length=self.service_name_length,
+            max_services_text=self.max_services_text,
+            high_cost_threshold=self.high_cost_threshold,
+            medium_cost_threshold=self.medium_cost_threshold
+        )
+
+        # Smart profile display length based on terminal width
+        if config.profile_display_length is None:
+            if terminal_width and terminal_width > 120:
+                config.profile_display_length = 60  # Wide terminal
+            elif terminal_width and terminal_width > 80:
+                config.profile_display_length = 40  # Standard terminal
+            else:
+                config.profile_display_length = 25  # Narrow terminal
+
+        # Smart service name length for business readability
+        if config.service_name_length is None:
+            config.service_name_length = 25  # Business-appropriate length
+
+        # Smart services count for optimal readability
+        if config.max_services_text is None:
+            config.max_services_text = 10  # Optimal for executive summaries
+
+        return config
+
+
+class FinOpsConfigManager:
+    """
+    FinOps Configuration Manager for API-only parameters.
+
+    Provides centralized management of display parameters that were removed
+    from CLI to maintain enterprise simplicity while preserving full API access.
+    """
+
+    def __init__(self, config: Optional[DisplayConfiguration] = None):
+        """
+        Initialize configuration manager.
+
+        Args:
+            config: Custom display configuration (defaults to smart defaults)
+        """
+        self._config = config or DisplayConfiguration.get_default_config()
+
+    @property
+    def config(self) -> DisplayConfiguration:
+        """Get current display configuration."""
+        return self._config
+
+    def update_config(self, **kwargs) -> None:
+        """
+        Update configuration parameters programmatically.
+
+        Args:
+            **kwargs: Configuration parameters to update
+        """
+        for key, value in kwargs.items():
+            if hasattr(self._config, key):
+                setattr(self._config, key, value)
+
+    def get_profile_display_length(self) -> int:
+        """Get profile display length with smart default."""
+        return self._config.profile_display_length or 50
+
+    def get_service_name_length(self) -> int:
+        """Get service name length with smart default."""
+        return self._config.service_name_length or 25
+
+    def get_max_services_text(self) -> int:
+        """Get max services in text with smart default."""
+        return self._config.max_services_text or 10
+
+    def get_high_cost_threshold(self) -> float:
+        """Get high cost threshold."""
+        return self._config.high_cost_threshold
+
+    def get_medium_cost_threshold(self) -> float:
+        """Get medium cost threshold."""
+        return self._config.medium_cost_threshold
+
+    def is_high_cost(self, amount: float) -> bool:
+        """Check if amount exceeds high cost threshold."""
+        return amount > self._config.high_cost_threshold
+
+    def is_medium_cost(self, amount: float) -> bool:
+        """Check if amount exceeds medium cost threshold."""
+        return amount > self._config.medium_cost_threshold
+
+    def get_cost_category(self, amount: float) -> str:
+        """Get cost category based on thresholds."""
+        if self.is_high_cost(amount):
+            return "Cost Review Required"
+        elif self.is_medium_cost(amount):
+            return "Right-sizing Review"
+        else:
+            return "Monitor & Optimize"
+
+
+# Global configuration instance for backwards compatibility
+_global_config = FinOpsConfigManager()
+
+
+def get_global_config() -> FinOpsConfigManager:
+    """Get global configuration manager instance."""
+    return _global_config
+
+
+def set_global_config(config: DisplayConfiguration) -> None:
+    """Set global configuration."""
+    global _global_config
+    _global_config = FinOpsConfigManager(config)
+
+
+# Backwards compatibility functions for existing code
+def get_profile_display_length(args=None) -> int:
+    """
+    Get profile display length with backwards compatibility.
+
+    DEPRECATION WARNING: This function is deprecated. Use FinOpsConfigManager.get_profile_display_length() instead.
+    """
+    if args and hasattr(args, 'profile_display_length') and args.profile_display_length:
+        return args.profile_display_length
+    return _global_config.get_profile_display_length()
+
+
+def get_service_name_length(args=None) -> int:
+    """
+    Get service name length with backwards compatibility.
+
+    DEPRECATION WARNING: This function is deprecated. Use FinOpsConfigManager.get_service_name_length() instead.
+    """
+    if args and hasattr(args, 'service_name_length') and args.service_name_length:
+        return args.service_name_length
+    return _global_config.get_service_name_length()
+
+
+def get_max_services_text(args=None) -> int:
+    """
+    Get max services text with backwards compatibility.
+
+    DEPRECATION WARNING: This function is deprecated. Use FinOpsConfigManager.get_max_services_text() instead.
+    """
+    if args and hasattr(args, 'max_services_text') and args.max_services_text:
+        return args.max_services_text
+    return _global_config.get_max_services_text()
+
+
+def get_high_cost_threshold(args=None) -> float:
+    """
+    Get high cost threshold with backwards compatibility.
+
+    DEPRECATION WARNING: This function is deprecated. Use FinOpsConfigManager.get_high_cost_threshold() instead.
+    """
+    if args and hasattr(args, 'high_cost_threshold') and args.high_cost_threshold:
+        return args.high_cost_threshold
+    return _global_config.get_high_cost_threshold()
+
+
+def get_medium_cost_threshold(args=None) -> float:
+    """
+    Get medium cost threshold with backwards compatibility.
+
+    DEPRECATION WARNING: This function is deprecated. Use FinOpsConfigManager.get_medium_cost_threshold() instead.
+    """
+    if args and hasattr(args, 'medium_cost_threshold') and args.medium_cost_threshold:
+        return args.medium_cost_threshold
+    return _global_config.get_medium_cost_threshold()