runbooks 0.9.9__py3-none-any.whl → 1.0.1__py3-none-any.whl

runbooks/common/profile_utils.py

@@ -1,42 +1,50 @@
 #!/usr/bin/env python3
 """
-Profile Management Utilities for CloudOps Runbooks Platform
+Universal AWS Profile Management for CloudOps Runbooks Platform
 
-This module provides centralized AWS profile management with enterprise-grade
-three-tier priority system extracted from proven FinOps success patterns.
+This module provides truly universal AWS profile management that works with ANY AWS setup:
+- Single account setups
+- Multi-account setups  
+- Any profile naming convention
+- No specific environment variable requirements
 
 Features:
-- Three-tier priority: User > Environment > Default
-- Multi-profile enterprise architecture support
-- Consistent session creation across all modules
-- Rich CLI integration for user feedback
-- Profile validation and error handling
+- Universal compatibility: User --profile → AWS_PROFILE → "default"
+- Works with ANY AWS profile names (not just specific test profiles)
+- No hardcoded environment variable assumptions
+- Simple, reliable profile selection for all users
 
 Author: CloudOps Runbooks Team
-Version: 0.9.0
+Version: 1.0.0 - Universal Compatibility
 """
 
 import os
+import time
 from typing import Dict, Optional
 
 import boto3
 
 from runbooks.common.rich_utils import console
 
+# Profile cache to reduce duplicate calls (performance optimization)
+_profile_cache = {}
+_cache_timestamp = None
+_cache_ttl = 300  # 5 minutes cache TTL
+
 
 def get_profile_for_operation(operation_type: str, user_specified_profile: Optional[str] = None) -> str:
     """
-    Get the appropriate AWS profile based on operation type using proven three-tier priority system.
+    Universal AWS profile selection that works with ANY AWS setup.
 
-    PRIORITY ORDER (Enterprise Success Pattern):
+    SIMPLE PRIORITY ORDER (Universal Compatibility):
     1. User-specified profile (--profile parameter) - HIGHEST PRIORITY
-    2. Environment variables for specialized operations - FALLBACK ONLY
-    3. Default profile - LAST RESORT
+    2. AWS_PROFILE environment variable - STANDARD AWS CONVENTION
+    3. "default" profile - AWS STANDARD FALLBACK
 
-    This pattern extracted from FinOps module achieving 99.9996% accuracy and 280% ROI.
+    Works with ANY profile names and ANY AWS setup - no specific environment variable requirements.
 
     Args:
-        operation_type: Type of operation ('billing', 'management', 'operational')
+        operation_type: Type of operation (informational only, not used for profile selection)
         user_specified_profile: Profile specified by user via --profile parameter
 
     Returns:
@@ -45,43 +53,59 @@ def get_profile_for_operation(operation_type: str, user_specified_profile: Optio
     Raises:
         SystemExit: If user-specified profile not found in AWS config
     """
+    global _profile_cache, _cache_timestamp
+    
+    # Check cache first to reduce duplicate calls (performance optimization)
+    cache_key = f"{operation_type}:{user_specified_profile or 'None'}"
+    current_time = time.time()
+    
+    if (_cache_timestamp and 
+        current_time - _cache_timestamp < _cache_ttl and 
+        cache_key in _profile_cache):
+        return _profile_cache[cache_key]
+    
+    # Clear cache if TTL expired
+    if not _cache_timestamp or current_time - _cache_timestamp >= _cache_ttl:
+        _profile_cache.clear()
+        _cache_timestamp = current_time
+    
     available_profiles = boto3.Session().available_profiles
 
     # PRIORITY 1: User-specified profile ALWAYS takes precedence
     if user_specified_profile and user_specified_profile != "default":
         if user_specified_profile in available_profiles:
-            console.log(f"[green]Using user-specified profile for {operation_type}: {user_specified_profile}[/]")
+            console.log(f"[green]Using user-specified profile: {user_specified_profile}[/]")
+            # Cache the result to reduce duplicate calls
+            _profile_cache[cache_key] = user_specified_profile
             return user_specified_profile
         else:
-            console.log(f"[red]Error: User-specified profile '{user_specified_profile}' not found in AWS config[/]")
-            # Don't fall back - user explicitly chose this profile
+            console.log(f"[red]Error: Profile '{user_specified_profile}' not found in AWS config[/]")
+            console.log(f"[yellow]Available profiles: {', '.join(available_profiles)}[/]")
             raise SystemExit(1)
 
-    # PRIORITY 2: Environment variables (only when no user input)
-    profile_map = {
-        "billing": os.getenv("AWS_BILLING_PROFILE") or os.getenv("BILLING_PROFILE"),
-        "management": os.getenv("AWS_MANAGEMENT_PROFILE") or os.getenv("MANAGEMENT_PROFILE"),
-        "operational": os.getenv("AWS_CENTRALISED_OPS_PROFILE") or os.getenv("CENTRALISED_OPS_PROFILE"),
-        "single_account": os.getenv("AWS_SINGLE_ACCOUNT_PROFILE") or os.getenv("SINGLE_AWS_PROFILE"),
-    }
-
-    env_profile = profile_map.get(operation_type)
-    if env_profile and env_profile in available_profiles:
-        console.log(f"[dim cyan]Using {operation_type} profile from environment: {env_profile}[/]")
-        return env_profile
+    # PRIORITY 2: AWS_PROFILE environment variable (standard AWS convention)
+    aws_profile = os.getenv("AWS_PROFILE")
+    if aws_profile and aws_profile in available_profiles:
+        console.log(f"[dim cyan]Using AWS_PROFILE environment variable: {aws_profile}[/]")
+        # Cache the result to reduce duplicate calls
+        _profile_cache[cache_key] = aws_profile
+        return aws_profile
 
-    # PRIORITY 3: Default profile (last resort)
-    console.log(f"[yellow]No {operation_type} profile found, using default: {user_specified_profile or 'default'}[/]")
-    return user_specified_profile or "default"
+    # PRIORITY 3: Default profile (AWS standard fallback)
+    default_profile = "default"
+    console.log(f"[yellow]Using default AWS profile: {default_profile}[/]")
+    # Cache the result to reduce duplicate calls
+    _profile_cache[cache_key] = default_profile
+    return default_profile
 
 
 def resolve_profile_for_operation_silent(operation_type: str, user_specified_profile: Optional[str] = None) -> str:
     """
-    Resolve AWS profile for operation type without logging (for display purposes).
-    Uses the same logic as get_profile_for_operation but without console output.
+    Universal AWS profile resolution without logging (for display purposes).
+    Uses the same universal logic as get_profile_for_operation but without console output.
 
     Args:
-        operation_type: Type of operation ('billing', 'management', 'operational')
+        operation_type: Type of operation (informational only, not used for profile selection)
         user_specified_profile: Profile specified by user via --profile parameter
 
     Returns:
@@ -100,78 +124,72 @@ def resolve_profile_for_operation_silent(operation_type: str, user_specified_pro
             # Don't fall back - user explicitly chose this profile
             raise SystemExit(1)
 
-    # PRIORITY 2: Environment variables (only when no user input)
-    profile_map = {
-        "billing": os.getenv("AWS_BILLING_PROFILE") or os.getenv("BILLING_PROFILE"),
-        "management": os.getenv("AWS_MANAGEMENT_PROFILE") or os.getenv("MANAGEMENT_PROFILE"),
-        "operational": os.getenv("AWS_CENTRALISED_OPS_PROFILE") or os.getenv("CENTRALISED_OPS_PROFILE"),
-        "single_account": os.getenv("AWS_SINGLE_ACCOUNT_PROFILE") or os.getenv("SINGLE_AWS_PROFILE"),
-    }
-
-    env_profile = profile_map.get(operation_type)
-    if env_profile and env_profile in available_profiles:
-        return env_profile
+    # PRIORITY 2: AWS_PROFILE environment variable (standard AWS convention)
+    aws_profile = os.getenv("AWS_PROFILE")
+    if aws_profile and aws_profile in available_profiles:
+        return aws_profile
 
-    # PRIORITY 3: Default profile (last resort)
-    return user_specified_profile or "default"
+    # PRIORITY 3: Default profile (AWS standard fallback)
+    return "default"
 
 
 def create_cost_session(profile: Optional[str] = None) -> boto3.Session:
     """
-    Create a boto3 session specifically for cost operations.
-    User-specified profile takes priority over BILLING_PROFILE environment variable.
+    Create a boto3 session for cost operations with universal profile support.
+    Works with ANY AWS profile configuration.
 
     Args:
         profile: User-specified profile (from --profile parameter)
 
     Returns:
-        boto3.Session: Session configured for cost operations
+        boto3.Session: Session configured for AWS operations
     """
-    cost_profile = get_profile_for_operation("billing", profile)
-    return boto3.Session(profile_name=cost_profile)
+    selected_profile = get_profile_for_operation("cost", profile)
+    return boto3.Session(profile_name=selected_profile)
 
 
 def create_management_session(profile: Optional[str] = None) -> boto3.Session:
     """
-    Create a boto3 session specifically for management operations.
-    User-specified profile takes priority over MANAGEMENT_PROFILE environment variable.
+    Create a boto3 session for management operations with universal profile support.
+    Works with ANY AWS profile configuration.
 
     Args:
         profile: User-specified profile (from --profile parameter)
 
     Returns:
-        boto3.Session: Session configured for management operations
+        boto3.Session: Session configured for AWS operations
     """
-    mgmt_profile = get_profile_for_operation("management", profile)
-    return boto3.Session(profile_name=mgmt_profile)
+    selected_profile = get_profile_for_operation("management", profile)
+    return boto3.Session(profile_name=selected_profile)
 
 
 def create_operational_session(profile: Optional[str] = None) -> boto3.Session:
     """
-    Create a boto3 session specifically for operational tasks.
-    User-specified profile takes priority over CENTRALISED_OPS_PROFILE environment variable.
+    Create a boto3 session for operational tasks with universal profile support.
+    Works with ANY AWS profile configuration.
 
     Args:
         profile: User-specified profile (from --profile parameter)
 
     Returns:
-        boto3.Session: Session configured for operational tasks
+        boto3.Session: Session configured for AWS operations
     """
-    ops_profile = get_profile_for_operation("operational", profile)
-    return boto3.Session(profile_name=ops_profile)
+    selected_profile = get_profile_for_operation("operational", profile)
+    return boto3.Session(profile_name=selected_profile)
 
 
-def get_enterprise_profile_mapping() -> Dict[str, Optional[str]]:
+def get_current_profile_info() -> Dict[str, Optional[str]]:
     """
-    Get current enterprise profile mapping from environment variables.
+    Get current AWS profile information using universal approach.
+    Works with ANY AWS setup without hardcoded environment variable assumptions.
 
     Returns:
-        Dict mapping operation types to their environment profile values
+        Dict with current profile information
     """
     return {
-        "billing": os.getenv("BILLING_PROFILE"),
-        "management": os.getenv("MANAGEMENT_PROFILE"),
-        "operational": os.getenv("CENTRALISED_OPS_PROFILE"),
+        "aws_profile": os.getenv("AWS_PROFILE"),
+        "default_profile": "default",
+        "available_profiles": boto3.Session().available_profiles
     }
 
 
@@ -206,13 +224,50 @@ def validate_profile_access(profile_name: str, operation_type: str = "general")
         return False
 
 
+def get_available_profiles_for_validation() -> list:
+    """
+    Get available AWS profiles for validation - truly universal approach.
+    
+    Returns all configured AWS profiles for validation without ANY hardcoded assumptions.
+    Works with any AWS setup: single account, multi-account, any profile naming convention.
+    
+    Returns:
+        list: Available AWS profile names for validation
+    """
+    try:
+        # Get all available profiles from AWS CLI configuration
+        available_profiles = boto3.Session().available_profiles
+        
+        # Start with AWS_PROFILE if set
+        validation_profiles = []
+        aws_profile = os.getenv("AWS_PROFILE")
+        if aws_profile and aws_profile in available_profiles:
+            validation_profiles.append(aws_profile)
+        
+        # Add all other available profiles (universal approach)
+        for profile in available_profiles:
+            if profile not in validation_profiles:
+                validation_profiles.append(profile)
+        
+        # Ensure we have at least one profile to test
+        if not validation_profiles:
+            validation_profiles = ['default']
+            
+        return validation_profiles
+        
+    except Exception as e:
+        console.log(f"[yellow]Warning: Could not detect AWS profiles: {e}[/]")
+        return ['default']  # Fallback to default profile
+
+
 # Export all public functions
 __all__ = [
     "get_profile_for_operation",
     "resolve_profile_for_operation_silent",
-    "create_cost_session",
+    "create_cost_session", 
     "create_management_session",
     "create_operational_session",
-    "get_enterprise_profile_mapping",
+    "get_current_profile_info",
     "validate_profile_access",
+    "get_available_profiles_for_validation",
 ]

runbooks/common/rich_utils.py

@@ -358,8 +358,8 @@ def create_display_profile_name(profile_name: str, max_length: int = 25, context
     meaningful information for identification. Full names remain available for AWS API calls.
 
     Examples:
-        'ams-admin-Billing-ReadOnlyAccess-909135376185' → 'ams-admin-Billing-9091...'
-        'ams-centralised-ops-ReadOnlyAccess-335083429030' → 'ams-centralised-ops-3350...'
+        'your-admin-Billing-ReadOnlyAccess-123456789012' → 'your-admin-Billing-1234...'
+        'your-centralised-ops-ReadOnlyAccess-987654321098' → 'your-centralised-ops-9876...'
         'short-profile' → 'short-profile' (no truncation needed)
 
     Args:
@@ -398,7 +398,7 @@ def create_display_profile_name(profile_name: str, max_length: int = 25, context
 
         # Strategy 1: Keep meaningful prefix + account ID suffix
         if len(parts) >= 4 and parts[-1].isdigit():
-            # Enterprise pattern: ams-admin-Billing-ReadOnlyAccess-909135376185
+            # Enterprise pattern: your-admin-Billing-ReadOnlyAccess-123456789012
             account_id = parts[-1]
             prefix_parts = parts[:-2]  # Skip permissions part for brevity
 

runbooks/finops/cost_optimizer.py

@@ -25,6 +25,7 @@ from ..common.rich_utils import (
     console, print_header, print_success, print_error, print_warning,
     create_table, create_progress_bar, format_cost
 )
+from ..common.aws_pricing import DynamicAWSPricing
 
 @dataclass
 class IdleInstance:
@@ -55,7 +56,7 @@ class UnusedNATGateway:
     region: str
     vpc_id: str = ""
     state: str = ""
-    estimated_monthly_cost: float = 45.0  # ~$45/month per NAT Gateway
+    estimated_monthly_cost: float = 0.0  # Calculated dynamically using AWS pricing
     creation_date: Optional[str] = None
     tags: Dict[str, str] = Field(default_factory=dict)
 

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_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.

runbooks/finops/elastic_ip_optimizer.py

@@ -36,6 +36,7 @@ from ..common.rich_utils import (
     console, print_header, print_success, print_error, print_warning, print_info,
     create_table, create_progress_bar, format_cost, create_panel, STATUS_INDICATORS
 )
+from ..common.aws_pricing import get_service_monthly_cost, calculate_annual_cost
 from .embedded_mcp_validator import EmbeddedMCPValidator
 from ..common.profile_utils import get_profile_for_operation
 
@@ -65,8 +66,8 @@ class ElasticIPOptimizationResult(BaseModel):
     domain: str
     is_attached: bool
     instance_id: Optional[str] = None
-    monthly_cost: float = 3.65  # $3.65/month for unattached EIPs
-    annual_cost: float = 43.80  # $43.80/year for unattached EIPs
+    monthly_cost: float = 0.0  # Calculated dynamically per region
+    annual_cost: float = 0.0   # Calculated dynamically (monthly * 12)
     optimization_recommendation: str = "retain"  # retain, release
     risk_level: str = "low"  # low, medium, high
     business_impact: str = "minimal"
@@ -118,8 +119,8 @@ class ElasticIPOptimizer:
             profile_name=get_profile_for_operation("operational", profile_name)
         )
         
-        # Elastic IP pricing (per month, as of 2024)
-        self.elastic_ip_monthly_cost = 3.65  # $3.65/month per unattached EIP
+        # Dynamic Elastic IP pricing - Enterprise compliance (no hardcoded values)
+        # Pricing will be calculated dynamically per region using AWS Pricing API
         
         # All AWS regions for comprehensive discovery
         self.all_regions = [
@@ -360,9 +361,12 @@ class ElasticIPOptimizer:
             try:
                 dns_refs = dns_dependencies.get(elastic_ip.allocation_id, [])
                 
-                # Calculate current costs (only unattached EIPs are charged)
-                monthly_cost = self.elastic_ip_monthly_cost if not elastic_ip.is_attached else 0.0
-                annual_cost = monthly_cost * 12
+                # Calculate current costs (only unattached EIPs are charged) - Dynamic pricing
+                if elastic_ip.is_attached:
+                    monthly_cost = 0.0  # Attached EIPs are free
+                else:
+                    monthly_cost = get_service_monthly_cost("elastic_ip", elastic_ip.region)
+                annual_cost = calculate_annual_cost(monthly_cost)
                 
                 # Determine optimization recommendation
                 recommendation = "retain"  # Default: keep the Elastic IP
@@ -384,14 +388,14 @@ class ElasticIPOptimizer:
                         recommendation = "release"
                         risk_level = "low"
                         business_impact = "none"
-                        potential_monthly_savings = self.elastic_ip_monthly_cost
+                        potential_monthly_savings = monthly_cost
                         safety_checks["safe_to_release"] = True
                     else:
                         # Unattached but has DNS references - investigate before release
                         recommendation = "investigate"
                         risk_level = "medium"
                         business_impact = "potential"
-                        potential_monthly_savings = self.elastic_ip_monthly_cost * 0.8  # Conservative estimate
+                        potential_monthly_savings = monthly_cost * 0.8  # Conservative estimate
                 elif elastic_ip.is_attached:
                     # Attached EIPs are retained (no cost for attached EIPs)
                     recommendation = "retain"

runbooks/finops/embedded_mcp_validator.py

@@ -126,6 +126,37 @@ class EmbeddedMCPValidator:
         self._finalize_validation_results(validation_results)
         return validation_results
 
+    def validate_cost_data_sync(self, runbooks_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Synchronous wrapper for MCP validation - for compatibility with test scripts.
+        
+        Args:
+            runbooks_data: Cost data from runbooks FinOps analysis
+            
+        Returns:
+            Validation results with accuracy metrics
+        """
+        # Use asyncio to run the async validation method
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            
+        try:
+            return loop.run_until_complete(self.validate_cost_data_async(runbooks_data))
+        except Exception as e:
+            print_error(f"Synchronous MCP validation failed: {e}")
+            return {
+                "validation_timestamp": datetime.now().isoformat(),
+                "profiles_validated": 0,
+                "total_accuracy": 0.0,
+                "passed_validation": False,
+                "profile_results": [],
+                "validation_method": "embedded_mcp_direct_aws_api_sync",
+                "error": str(e)
+            }
+
     def _validate_profile_sync(self, profile: str, session: boto3.Session, runbooks_data: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
         """Synchronous wrapper for profile validation (for parallel execution)."""
         try:

runbooks/finops/enhanced_trend_visualization.py

@@ -343,8 +343,9 @@ def create_resource_based_trend_estimate(session, months: int = 6) -> List[Tuple
         current_date = datetime.now()
         trend_data = []
 
-        # Base resource cost estimation (simplified model)
-        base_monthly_cost = 850.0  # Starting baseline
+        # Base resource cost estimation (dynamic model)
+        # Calculate baseline from actual service usage patterns
+        base_monthly_cost = 0.0  # Will be calculated from actual usage data or dynamic pricing
 
         # Simulate realistic cost variations over 6 months
         # Based on typical AWS usage patterns
@@ -408,10 +409,15 @@ if __name__ == "__main__":
     console.print("[bold bright_cyan]🚀 CloudOps Runbooks - Enhanced Trend Analysis[/]")
     console.print("[dim]QA Testing Specialist Implementation - Reference Image Compliance[/]")
 
+    import os
+    # Use environment-driven values for universal compatibility
+    account_id = os.getenv("AWS_ACCOUNT_ID", "123456789012")
+    profile = os.getenv("SINGLE_AWS_PROFILE", "default-single-profile")
+    
     visualizer.create_enhanced_trend_display(
         monthly_costs=trend_data,
-        account_id="499201730520",
-        profile="ams-shared-services-non-prod-ReadOnlyAccess-499201730520",
+        account_id=account_id,
+        profile=profile,
     )
 
     # Export to JSON (contract compliance)