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

runbooks/finops/helpers.py

@@ -286,9 +286,17 @@ def export_audit_report_to_pdf(
             untagged_display = ""
             if row.get("untagged_count", 0) > 0:
                 # Format like reference: "EC2: us-east-1: i-1234567890"
-                untagged_display = f"EC2:\nus-east-1:\ni-{row.get('account_id', '1234567890')[:10]}"
+                account_id = row.get('account_id', 'unknown')
+                if account_id and account_id != 'unknown':
+                    untagged_display = f"EC2:\nus-east-1:\ni-{account_id[:10]}"
+                else:
+                    untagged_display = f"EC2:\nus-east-1:\ni-unavailable"
                 if row.get("untagged_count", 0) > 1:
-                    untagged_display += f"\n\nRDS:\nus-west-2:\ndb-{row.get('account_id', '9876543210')[:10]}"
+                    account_id = row.get('account_id', 'unknown')
+                    if account_id and account_id != 'unknown':
+                        untagged_display += f"\n\nRDS:\nus-west-2:\ndb-{account_id[:10]}"
+                    else:
+                        untagged_display += f"\n\nRDS:\nus-west-2:\ndb-unavailable"
 
             # Format stopped instances like reference
             stopped_display = ""
@@ -1282,3 +1290,108 @@ def generate_pdca_improvement_report(
     except Exception as e:
         console.print(f"[bold red]Error generating PDCA improvement report: {str(e)}[/]")
         return None
+
+
+def export_scenario_results(results: Dict[str, Any], scenario_name: str,
+                           report_types: List[str], output_dir: Optional[str] = None) -> bool:
+    """
+    Export business scenario results in specified formats.
+
+    Args:
+        results: Scenario analysis results dictionary
+        scenario_name: Name of the business scenario
+        report_types: List of export formats ('json', 'csv', 'pdf', 'markdown')
+        output_dir: Output directory (defaults to current directory)
+
+    Returns:
+        True if all exports succeeded
+    """
+    try:
+        from runbooks.common.rich_utils import print_success, print_error, print_info
+
+        output_dir = output_dir or "."
+        base_filename = f"finops-scenario-{scenario_name}-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
+
+        success_count = 0
+        total_exports = len(report_types)
+
+        for report_type in report_types:
+            try:
+                if report_type == 'json':
+                    output_path = os.path.join(output_dir, f"{base_filename}.json")
+                    with open(output_path, 'w', encoding='utf-8') as f:
+                        json.dump(results, f, indent=2, default=str)
+                    print_info(f"📄 JSON export: {output_path}")
+
+                elif report_type == 'csv':
+                    output_path = os.path.join(output_dir, f"{base_filename}.csv")
+                    # Extract key metrics for CSV export
+                    if 'business_impact' in results:
+                        business_data = results['business_impact']
+                        with open(output_path, 'w', newline='', encoding='utf-8') as f:
+                            writer = csv.DictWriter(f, fieldnames=business_data.keys())
+                            writer.writeheader()
+                            writer.writerow(business_data)
+                    print_info(f"📊 CSV export: {output_path}")
+
+                elif report_type == 'pdf':
+                    output_path = os.path.join(output_dir, f"{base_filename}.pdf")
+                    # Create basic PDF with scenario results
+                    doc = SimpleDocTemplate(output_path, pagesize=letter)
+                    story = []
+
+                    # Title
+                    title = Paragraph(f"FinOps Business Scenario: {scenario_name.title()}",
+                                    styles['Heading1'])
+                    story.append(title)
+                    story.append(Spacer(1, 12))
+
+                    # Add results summary
+                    if 'business_impact' in results:
+                        business_data = results['business_impact']
+                        for key, value in business_data.items():
+                            text = Paragraph(f"<b>{key.replace('_', ' ').title()}:</b> {value}",
+                                           styles['Normal'])
+                            story.append(text)
+
+                    doc.build(story)
+                    print_info(f"📋 PDF export: {output_path}")
+
+                elif report_type == 'markdown':
+                    output_path = os.path.join(output_dir, f"{base_filename}.md")
+                    with open(output_path, 'w', encoding='utf-8') as f:
+                        f.write(f"# FinOps Business Scenario: {scenario_name.title()}\n\n")
+                        f.write(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+
+                        # Add business impact section
+                        if 'business_impact' in results:
+                            f.write("## Business Impact\n\n")
+                            business_data = results['business_impact']
+                            for key, value in business_data.items():
+                                f.write(f"- **{key.replace('_', ' ').title()}**: {value}\n")
+                            f.write("\n")
+
+                        # Add technical details section
+                        if 'technical_details' in results:
+                            f.write("## Technical Details\n\n")
+                            tech_data = results['technical_details']
+                            for key, value in tech_data.items():
+                                f.write(f"- **{key.replace('_', ' ').title()}**: {value}\n")
+
+                    print_info(f"📝 Markdown export: {output_path}")
+
+                success_count += 1
+
+            except Exception as e:
+                print_error(f"Failed to export {report_type}: {e}")
+
+        if success_count == total_exports:
+            print_success(f"✅ All {success_count} export formats completed successfully")
+            return True
+        else:
+            print_info(f"⚠️ {success_count}/{total_exports} exports completed")
+            return False
+
+    except Exception as e:
+        print_error(f"Export failed: {e}")
+        return False

runbooks/finops/multi_dashboard.py

@@ -552,8 +552,9 @@ class MultiAccountDashboard:
             # SRE FIX: Extract account ID from Organizations API profile format
             if "@" in profile:
                 base_profile, target_account_id = profile.split("@", 1)
-                # Configurable display format - no hardcoded truncation
-                max_profile_display_length = getattr(args, "max_profile_display_length", 50)
+                # Configurable display format - using centralized config
+                from runbooks.finops.config import get_profile_display_length
+                max_profile_display_length = get_profile_display_length(args)
                 if len(base_profile) > max_profile_display_length:
                     display_profile = f"{base_profile[:max_profile_display_length]}...@{target_account_id}"
                 else:
@@ -1413,9 +1414,10 @@ class MultiAccountDashboard:
                         .replace("✅", "OK")
                     )
 
-                # Optimization recommendation based on configurable thresholds
-                high_cost_threshold = getattr(args, "high_cost_threshold", 5000)
-                medium_cost_threshold = getattr(args, "medium_cost_threshold", 1000)
+                # Optimization recommendation based on centralized config
+                from runbooks.finops.config import get_high_cost_threshold, get_medium_cost_threshold
+                high_cost_threshold = get_high_cost_threshold(args)
+                medium_cost_threshold = get_medium_cost_threshold(args)
 
                 if current > high_cost_threshold:
                     optimization = "Cost Review Required"

runbooks/finops/optimizer.py

@@ -511,9 +511,87 @@ class CostOptimizer:
         return size_gb * rate
 
     def _get_cpu_utilization(self, cloudwatch, instance_id: str, days: int = 30) -> float:
-        """Get average CPU utilization for instance."""
-        # Mock implementation - in production would query CloudWatch
-        return 3.5  # Mock low utilization
+        """Get average CPU utilization for instance from CloudWatch."""
+        try:
+            from datetime import datetime, timedelta
+
+            end_time = datetime.utcnow()
+            start_time = end_time - timedelta(days=days)
+
+            response = cloudwatch.get_metric_statistics(
+                Namespace='AWS/EC2',
+                MetricName='CPUUtilization',
+                Dimensions=[{'Name': 'InstanceId', 'Value': instance_id}],
+                StartTime=start_time,
+                EndTime=end_time,
+                Period=3600,  # 1 hour
+                Statistics=['Average']
+            )
+
+            if response['Datapoints']:
+                cpu_avg = sum(dp['Average'] for dp in response['Datapoints']) / len(response['Datapoints'])
+                return cpu_avg
+            else:
+                console.print(f"[yellow]⚠️ No CPU metrics found for {instance_id}[/yellow]")
+                return 0.0
+
+        except Exception as e:
+            console.print(f"[red]❌ Error getting CPU metrics for {instance_id}: {e}[/red]")
+            return 0.0
+
+    def _get_memory_utilization(self, cloudwatch, instance_id: str, days: int = 30) -> float:
+        """Get average memory utilization for instance from CloudWatch."""
+        try:
+            from datetime import datetime, timedelta
+
+            end_time = datetime.utcnow()
+            start_time = end_time - timedelta(days=days)
+
+            response = cloudwatch.get_metric_statistics(
+                Namespace='CWAgent',
+                MetricName='mem_used_percent',
+                Dimensions=[{'Name': 'InstanceId', 'Value': instance_id}],
+                StartTime=start_time,
+                EndTime=end_time,
+                Period=3600,
+                Statistics=['Average']
+            )
+
+            if response['Datapoints']:
+                memory_avg = sum(dp['Average'] for dp in response['Datapoints']) / len(response['Datapoints'])
+                return memory_avg
+            else:
+                return 0.0  # No memory metrics available
+
+        except Exception:
+            return 0.0  # Memory metrics might not be available
+
+    def _get_network_utilization(self, cloudwatch, instance_id: str, days: int = 30) -> float:
+        """Get average network utilization for instance from CloudWatch."""
+        try:
+            from datetime import datetime, timedelta
+
+            end_time = datetime.utcnow()
+            start_time = end_time - timedelta(days=days)
+
+            response = cloudwatch.get_metric_statistics(
+                Namespace='AWS/EC2',
+                MetricName='NetworkIn',
+                Dimensions=[{'Name': 'InstanceId', 'Value': instance_id}],
+                StartTime=start_time,
+                EndTime=end_time,
+                Period=3600,
+                Statistics=['Average']
+            )
+
+            if response['Datapoints']:
+                network_avg = sum(dp['Average'] for dp in response['Datapoints']) / len(response['Datapoints'])
+                return network_avg / 1024 / 1024  # Convert to MB
+            else:
+                return 0.0
+
+        except Exception:
+            return 0.0
 
     def _get_running_instances(self, ec2_client):
         """Get all running EC2 instances."""
@@ -524,9 +602,22 @@ class CostOptimizer:
         return instances
 
     def _analyze_instance_utilization(self, cloudwatch, instance_id: str) -> Dict[str, float]:
-        """Analyze instance utilization metrics."""
-        # Mock implementation
-        return {"cpu_avg": 15.0, "memory_avg": 25.0, "network_avg": 5.0}
+        """Analyze instance utilization metrics from CloudWatch."""
+        try:
+            cpu_avg = self._get_cpu_utilization(cloudwatch, instance_id)
+
+            # Get additional metrics if available
+            memory_avg = self._get_memory_utilization(cloudwatch, instance_id)
+            network_avg = self._get_network_utilization(cloudwatch, instance_id)
+
+            return {
+                "cpu_avg": cpu_avg,
+                "memory_avg": memory_avg,
+                "network_avg": network_avg
+            }
+        except Exception as e:
+            console.print(f"[red]❌ Error analyzing utilization for {instance_id}: {e}[/red]")
+            return {"cpu_avg": 0.0, "memory_avg": 0.0, "network_avg": 0.0}
 
     def _suggest_smaller_instance(self, current_type: str) -> Optional[str]:
         """Suggest a smaller instance type."""

runbooks/finops/scenario_cli_integration.py

@@ -0,0 +1,247 @@
+"""
+FinOps Scenario CLI Integration - Phase 1 Priority 2
+
+This module provides CLI integration for the Business Scenario Matrix with intelligent
+parameter defaults and scenario-specific help generation.
+
+Strategic Achievement: Manager requires business scenario intelligence with smart
+parameter recommendations per business case type.
+"""
+
+import click
+from typing import Dict, List, Optional, Any
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from .business_case_config import (
+    get_business_case_config,
+    get_business_scenario_matrix,
+    BusinessScenarioMatrix,
+    ScenarioParameter
+)
+from ..common.rich_utils import print_header, print_info, print_success, print_warning
+
+
+class ScenarioCliHelper:
+    """
+    CLI integration helper for business scenario intelligence.
+
+    Provides intelligent parameter recommendations and scenario-specific help.
+    """
+
+    def __init__(self):
+        """Initialize CLI helper with scenario matrix."""
+        self.console = Console()
+        self.business_config = get_business_case_config()
+        self.scenario_matrix = get_business_scenario_matrix()
+
+    def display_scenario_help(self, scenario_key: Optional[str] = None) -> None:
+        """Display scenario-specific help with parameter recommendations."""
+        print_header("FinOps Business Scenarios", "Parameter Intelligence")
+
+        if scenario_key:
+            self._display_single_scenario_help(scenario_key)
+        else:
+            self._display_all_scenarios_help()
+
+    def _display_single_scenario_help(self, scenario_key: str) -> None:
+        """Display detailed help for a single scenario."""
+        scenario_config = self.business_config.get_scenario(scenario_key)
+        if not scenario_config:
+            print_warning(f"Unknown scenario: {scenario_key}")
+            return
+
+        # Display scenario overview
+        self.console.print(f"\n[bold cyan]Scenario: {scenario_config.display_name}[/bold cyan]")
+        self.console.print(f"[dim]Business Case: {scenario_config.business_description}[/dim]")
+        self.console.print(f"[dim]Technical Focus: {scenario_config.technical_focus}[/dim]")
+        self.console.print(f"[dim]Savings Target: {scenario_config.savings_range_display}[/dim]")
+        self.console.print(f"[dim]Risk Level: {scenario_config.risk_level}[/dim]")
+
+        # Display parameter recommendations
+        recommendations = self.scenario_matrix.get_parameter_recommendations(scenario_key)
+        if recommendations:
+            self.console.print(f"\n[bold green]🎯 Intelligent Parameter Recommendations[/bold green]")
+
+            for param_key, param in recommendations.items():
+                self._display_parameter_recommendation(param)
+
+            # Display optimal command
+            optimal_command = self._generate_optimal_command(scenario_key, recommendations)
+            self.console.print(f"\n[bold yellow]💡 Optimal Command Example:[/bold yellow]")
+            self.console.print(f"[dim]runbooks finops --scenario {scenario_key} {optimal_command}[/dim]")
+        else:
+            print_info("Using standard parameters for this scenario")
+
+    def _display_all_scenarios_help(self) -> None:
+        """Display overview of all scenarios with parameter summaries."""
+        # Create scenarios overview table
+        table = Table(
+            title="🎯 Business Scenarios with Intelligent Parameter Defaults",
+            show_header=True,
+            header_style="bold cyan"
+        )
+
+        table.add_column("Scenario", style="bold white", width=15)
+        table.add_column("Business Case", style="cyan", width=25)
+        table.add_column("Savings Target", style="green", width=15)
+        table.add_column("Optimal Parameters", style="yellow", width=35)
+        table.add_column("Tier", style="magenta", width=8)
+
+        # Get scenario summaries
+        scenario_summaries = self.scenario_matrix.get_all_scenario_summaries()
+
+        # Tier classification for display
+        tier_mapping = {
+            'workspaces': 'Tier 1',
+            'nat-gateway': 'Tier 1',
+            'rds-snapshots': 'Tier 1',
+            'ebs-optimization': 'Tier 2',
+            'vpc-cleanup': 'Tier 2',
+            'elastic-ip': 'Tier 2',
+            'backup-investigation': 'Tier 3'
+        }
+
+        for scenario_key, scenario in self.business_config.get_all_scenarios().items():
+            parameter_summary = scenario_summaries.get(scenario_key, "Standard")
+            tier = tier_mapping.get(scenario_key, "Standard")
+
+            table.add_row(
+                scenario_key,
+                scenario.display_name,
+                scenario.savings_range_display,
+                parameter_summary,
+                tier
+            )
+
+        self.console.print(table)
+
+        # Display usage instructions
+        usage_panel = Panel(
+            """[bold]Usage Examples:[/bold]
+
+[cyan]Tier 1 High-Value Scenarios:[/cyan]
+• runbooks finops --scenario workspaces --time-range 90 --pdf
+• runbooks finops --scenario nat-gateway --time-range 30 --json --amortized
+• runbooks finops --scenario rds-snapshots --time-range 90 --csv --dual-metrics
+
+[cyan]Tier 2 Strategic Scenarios:[/cyan]
+• runbooks finops --scenario ebs-optimization --time-range 180 --pdf --dual-metrics
+• runbooks finops --scenario vpc-cleanup --time-range 30 --csv --unblended
+• runbooks finops --scenario elastic-ip --time-range 7 --json --unblended
+
+[cyan]Get Scenario-Specific Help:[/cyan]
+• runbooks finops --scenario workspaces --help-scenario
+• runbooks finops --help-scenarios  # All scenarios overview
+            """,
+            title="📚 Scenario Usage Guide",
+            style="cyan"
+        )
+        self.console.print(usage_panel)
+
+    def _display_parameter_recommendation(self, param: ScenarioParameter) -> None:
+        """Display a single parameter recommendation."""
+        # Format parameter display
+        if isinstance(param.optimal_value, bool) and param.optimal_value:
+            param_display = f"[bold]{param.name}[/bold]"
+        else:
+            param_display = f"[bold]{param.name} {param.optimal_value}[/bold]"
+
+        self.console.print(f"  {param_display}")
+        self.console.print(f"    [dim]→ {param.business_justification}[/dim]")
+
+        if param.alternative_values:
+            alternatives = ', '.join(str(v) for v in param.alternative_values)
+            self.console.print(f"    [dim]Alternatives: {alternatives}[/dim]")
+        self.console.print()
+
+    def _generate_optimal_command(self, scenario_key: str, recommendations: Dict[str, ScenarioParameter]) -> str:
+        """Generate optimal command example from recommendations."""
+        command_parts = []
+
+        for param_key, param in recommendations.items():
+            if isinstance(param.optimal_value, bool) and param.optimal_value:
+                command_parts.append(param.name)
+            else:
+                command_parts.append(f"{param.name} {param.optimal_value}")
+
+        return " ".join(command_parts)
+
+    def validate_scenario_parameters(self, scenario_key: str, provided_params: Dict[str, Any]) -> None:
+        """Validate and provide suggestions for scenario parameters."""
+        suggestions = self.scenario_matrix.validate_parameters_for_scenario(scenario_key, provided_params)
+
+        if suggestions:
+            self.console.print(f"\n[bold yellow]💡 Parameter Optimization Suggestions for '{scenario_key}':[/bold yellow]")
+            for param_type, suggestion in suggestions.items():
+                self.console.print(f"  [yellow]→[/yellow] {suggestion}")
+            self.console.print()
+
+    def get_scenario_cli_choices(self) -> List[str]:
+        """Get list of valid scenario choices for Click options."""
+        return self.business_config.get_scenario_choices()
+
+    def get_enhanced_scenario_help_text(self) -> str:
+        """Get enhanced help text including parameter intelligence."""
+        base_help = self.business_config.get_scenario_help_text()
+        return f"{base_help}\n\nUse --scenario [scenario-name] for specific optimization analysis."
+
+
+def display_scenario_matrix_help(scenario_key: Optional[str] = None) -> None:
+    """
+    Display business scenario matrix help with parameter intelligence.
+
+    Args:
+        scenario_key: Specific scenario to show help for, or None for all scenarios
+    """
+    helper = ScenarioCliHelper()
+    helper.display_scenario_help(scenario_key)
+
+
+def validate_and_suggest_parameters(scenario_key: str, cli_params: Dict[str, Any]) -> None:
+    """
+    Validate CLI parameters against scenario recommendations and provide suggestions.
+
+    Args:
+        scenario_key: The business scenario being executed
+        cli_params: Dictionary of provided CLI parameters
+    """
+    helper = ScenarioCliHelper()
+    helper.validate_scenario_parameters(scenario_key, cli_params)
+
+
+def get_scenario_parameter_defaults(scenario_key: str) -> Dict[str, Any]:
+    """
+    Get parameter defaults for a specific scenario.
+
+    Args:
+        scenario_key: The business scenario key
+
+    Returns:
+        Dictionary of parameter defaults that can be applied to CLI arguments
+    """
+    matrix = get_business_scenario_matrix()
+    recommendations = matrix.get_parameter_recommendations(scenario_key)
+
+    defaults = {}
+
+    for param_key, param in recommendations.items():
+        if param.name == '--time-range':
+            defaults['time_range'] = param.optimal_value
+        elif param.name == '--unblended':
+            defaults['unblended'] = True
+        elif param.name == '--amortized':
+            defaults['amortized'] = True
+        elif param.name == '--dual-metrics':
+            defaults['dual_metrics'] = True
+        elif param.name == '--pdf':
+            defaults['pdf'] = True
+        elif param.name == '--csv':
+            defaults['csv'] = True
+        elif param.name == '--json':
+            defaults['json'] = True
+        elif param.name == '--markdown':
+            defaults['export_markdown'] = True
+
+    return defaults

runbooks/finops/scenarios.py

@@ -50,6 +50,17 @@ from .business_cases import BusinessCaseAnalyzer, BusinessCaseFormatter
 logger = logging.getLogger(__name__)
 
 
+def _get_account_from_profile(profile: Optional[str] = None) -> str:
+    """Get account ID from AWS profile with dynamic resolution."""
+    try:
+        import boto3
+        session = boto3.Session(profile_name=profile)
+        return session.client('sts').get_caller_identity()['Account']
+    except Exception as e:
+        logger.warning(f"Could not resolve account ID from profile {profile}: {e}")
+        return "unknown"
+
+
 # ============================================================================
 # CLEAN API FUNCTIONS FOR NOTEBOOK CONSUMPTION
 # ============================================================================
@@ -400,7 +411,7 @@ def finops_25_commvault_investigation(profile: Optional[str] = None, account: Op
                 'monthly_cost': technical_findings.get('total_monthly_cost', 0),
                 'optimization_candidates': technical_findings.get('optimization_candidates', 0),
                 'investigation_required': technical_findings.get('investigation_required', 0),
-                'target_account': raw_analysis.get('target_account', account or '637423383469')
+                'target_account': raw_analysis.get('target_account', account or _get_account_from_profile(profile))
             },
             'implementation': {
                 'timeline': raw_analysis.get('deployment_timeline', '3-4 weeks investigation + systematic implementation'),