runbooks 0.9.1__py3-none-any.whl → 0.9.4__py3-none-any.whl

runbooks/finops/cost_processor.py

@@ -13,7 +13,7 @@ from rich.console import Console
 
 from runbooks.finops.aws_client import get_account_id
 from runbooks.finops.iam_guidance import handle_cost_explorer_error
-from runbooks.finops.types import BudgetInfo, CostData, EC2Summary, ProfileData
+from runbooks.finops.types import BudgetInfo, CostData, DualMetricResult, EC2Summary, ProfileData
 
 console = Console()
 
@@ -67,6 +67,241 @@ def filter_analytical_services(
     return filtered_services
 
 
+class DualMetricCostProcessor:
+    """Enhanced processor for UnblendedCost (technical) and AmortizedCost (financial) reporting."""
+    
+    def __init__(self, session: Session, profile_name: Optional[str] = None):
+        """Initialize dual-metric cost processor.
+        
+        Args:
+            session: AWS boto3 session
+            profile_name: AWS profile name for error handling
+        """
+        self.session = session
+        self.profile_name = profile_name or "default"
+        self.ce = session.client("ce")
+        
+    def collect_dual_metrics(self, 
+                           account_id: Optional[str] = None,
+                           start_date: str = None,
+                           end_date: str = None) -> DualMetricResult:
+        """Collect both UnblendedCost and AmortizedCost for comprehensive reporting.
+        
+        Args:
+            account_id: AWS account ID for filtering (multi-account support)
+            start_date: Start date in ISO format (YYYY-MM-DD)
+            end_date: End date in ISO format (YYYY-MM-DD)
+            
+        Returns:
+            DualMetricResult with both technical and financial perspectives
+        """
+        # Build filter for account if provided
+        filter_param = None
+        if account_id:
+            filter_param = {"Dimensions": {"Key": "LINKED_ACCOUNT", "Values": [account_id]}}
+        
+        # Set default dates if not provided
+        if not start_date or not end_date:
+            today = date.today()
+            start_date = today.replace(day=1).isoformat()
+            end_date = (today + timedelta(days=1)).isoformat()  # AWS CE end date is exclusive
+        
+        try:
+            # Technical Analysis (UnblendedCost)
+            console.log("[blue]🔧 Collecting technical cost data (UnblendedCost)[/]")
+            unblended_response = self.ce.get_cost_and_usage(
+                TimePeriod={'Start': start_date, 'End': end_date},
+                Granularity='MONTHLY',
+                Metrics=['UnblendedCost'],
+                GroupBy=[{'Type': 'DIMENSION', 'Key': 'SERVICE'}],
+                **({"Filter": filter_param} if filter_param else {})
+            )
+            
+            # Financial Reporting (AmortizedCost)
+            console.log("[blue]📊 Collecting financial cost data (AmortizedCost)[/]")
+            amortized_response = self.ce.get_cost_and_usage(
+                TimePeriod={'Start': start_date, 'End': end_date},
+                Granularity='MONTHLY', 
+                Metrics=['AmortizedCost'],
+                GroupBy=[{'Type': 'DIMENSION', 'Key': 'SERVICE'}],
+                **({"Filter": filter_param} if filter_param else {})
+            )
+            
+            # Parse UnblendedCost data
+            unblended_costs = {}
+            technical_total = 0.0
+            service_breakdown_unblended = []
+            
+            for result in unblended_response.get("ResultsByTime", []):
+                for group in result.get("Groups", []):
+                    service = group["Keys"][0]
+                    amount = float(group["Metrics"]["UnblendedCost"]["Amount"])
+                    if amount > 0.001:  # Filter negligible costs
+                        unblended_costs[service] = amount
+                        technical_total += amount
+                        service_breakdown_unblended.append((service, amount))
+            
+            # Parse AmortizedCost data
+            amortized_costs = {}
+            financial_total = 0.0
+            service_breakdown_amortized = []
+            
+            for result in amortized_response.get("ResultsByTime", []):
+                for group in result.get("Groups", []):
+                    service = group["Keys"][0]
+                    amount = float(group["Metrics"]["AmortizedCost"]["Amount"])
+                    if amount > 0.001:  # Filter negligible costs
+                        amortized_costs[service] = amount
+                        financial_total += amount
+                        service_breakdown_amortized.append((service, amount))
+            
+            # Calculate variance
+            variance = abs(technical_total - financial_total)
+            variance_percentage = (variance / financial_total * 100) if financial_total > 0 else 0.0
+            
+            # Sort service breakdowns by cost (descending)
+            service_breakdown_unblended.sort(key=lambda x: x[1], reverse=True)
+            service_breakdown_amortized.sort(key=lambda x: x[1], reverse=True)
+            
+            console.log(f"[green]✅ Dual-metric collection complete: Technical ${technical_total:.2f}, Financial ${financial_total:.2f}[/]")
+            
+            return DualMetricResult(
+                unblended_costs=unblended_costs,
+                amortized_costs=amortized_costs,
+                technical_total=technical_total,
+                financial_total=financial_total,
+                variance=variance,
+                variance_percentage=variance_percentage,
+                period_start=start_date,
+                period_end=end_date,
+                service_breakdown_unblended=service_breakdown_unblended,
+                service_breakdown_amortized=service_breakdown_amortized
+            )
+            
+        except Exception as e:
+            console.log(f"[red]❌ Dual-metric collection failed: {str(e)}[/]")
+            if "AccessDeniedException" in str(e) and "ce:GetCostAndUsage" in str(e):
+                handle_cost_explorer_error(e, self.profile_name)
+            
+            # Return empty result structure
+            return DualMetricResult(
+                unblended_costs={},
+                amortized_costs={},
+                technical_total=0.0,
+                financial_total=0.0,
+                variance=0.0,
+                variance_percentage=0.0,
+                period_start=start_date,
+                period_end=end_date,
+                service_breakdown_unblended=[],
+                service_breakdown_amortized=[]
+            )
+
+
+def get_equal_period_cost_data(
+    session: Session,
+    profile_name: Optional[str] = None,
+    account_id: Optional[str] = None,
+    months_back: int = 3
+) -> Dict[str, Any]:
+    """
+    Get equal-period cost data for accurate trend analysis.
+    
+    Addresses the mathematical error where partial current month (e.g., Sept 1-2) 
+    was compared against full previous month (Aug 1-31), resulting in misleading trends.
+    
+    Args:
+        session: AWS boto3 session
+        profile_name: AWS profile name for error handling
+        account_id: Optional account ID for filtering
+        months_back: Number of complete months to analyze
+    
+    Returns:
+        Dict containing monthly cost data with equal periods for accurate trends
+    """
+    ce = session.client("ce")
+    today = date.today()
+    
+    # Calculate complete months for comparison
+    monthly_data = []
+    
+    # Get last N complete months (not including current partial month)
+    for i in range(1, months_back + 1):  # Start from 1 to skip current month
+        # Calculate the start and end of each complete month
+        if today.month - i > 0:
+            target_month = today.month - i
+            target_year = today.year
+        else:
+            # Handle year boundary
+            target_month = 12 + (today.month - i)
+            target_year = today.year - 1
+            
+        # First day of target month
+        month_start = date(target_year, target_month, 1)
+        
+        # Last day of target month
+        if target_month == 12:
+            month_end = date(target_year + 1, 1, 1) - timedelta(days=1)
+        else:
+            month_end = date(target_year, target_month + 1, 1) - timedelta(days=1)
+            
+        # Build filter for account if provided
+        filter_param = None
+        if account_id:
+            filter_param = {"Dimensions": {"Key": "LINKED_ACCOUNT", "Values": [account_id]}}
+        
+        kwargs = {}
+        if filter_param:
+            kwargs["Filter"] = filter_param
+            
+        try:
+            response = ce.get_cost_and_usage(
+                TimePeriod={
+                    "Start": month_start.isoformat(),
+                    "End": (month_end + timedelta(days=1)).isoformat(),  # AWS CE end date is exclusive
+                },
+                Granularity="MONTHLY",
+                Metrics=["UnblendedCost"],
+                **kwargs,
+            )
+            
+            # Extract cost data
+            total_cost = 0.0
+            for result in response.get("ResultsByTime", []):
+                if "Total" in result and "UnblendedCost" in result["Total"]:
+                    total_cost = float(result["Total"]["UnblendedCost"]["Amount"])
+                    
+            monthly_data.append({
+                "month": month_start.strftime("%b %Y"),
+                "start_date": month_start.isoformat(),
+                "end_date": month_end.isoformat(),
+                "days": (month_end - month_start).days + 1,
+                "cost": total_cost
+            })
+            
+        except Exception as e:
+            console.log(f"[yellow]Error getting cost data for {month_start.strftime('%b %Y')}: {e}[/]")
+            if "AccessDeniedException" in str(e) and "ce:GetCostAndUsage" in str(e):
+                from .iam_guidance import handle_cost_explorer_error
+                handle_cost_explorer_error(e, profile_name)
+            
+            # Add empty data to maintain structure
+            monthly_data.append({
+                "month": month_start.strftime("%b %Y"),
+                "start_date": month_start.isoformat(), 
+                "end_date": month_end.isoformat(),
+                "days": (month_end - month_start).days + 1,
+                "cost": 0.0
+            })
+    
+    return {
+        "account_id": get_account_id(session) or "unknown",
+        "monthly_costs": monthly_data,
+        "analysis_type": "equal_period",
+        "profile": session.profile_name or profile_name or "default"
+    }
+
+
 def get_trend(session: Session, tag: Optional[List[str]] = None, account_id: Optional[str] = None) -> Dict[str, Any]:
     """
     Get cost trend data for an AWS account.
@@ -312,16 +547,48 @@ def get_cost_data(
         previous_period_start = previous_period_end - timedelta(days=time_range)
 
     else:
+        # CRITICAL MATHEMATICAL FIX: Equal period comparisons for accurate trends
+        # Problem: Partial current month vs full previous month = misleading trends
+        # Solution: Same-day comparisons or complete month comparisons
+        
         start_date = today.replace(day=1)
         end_date = today
-
-        # Edge case when user runs the tool on the first day of the month
-        if start_date == end_date:
-            end_date += timedelta(days=1)
-
-        # Last calendar month
-        previous_period_end = start_date - timedelta(days=1)
-        previous_period_start = previous_period_end.replace(day=1)
+        
+        # Detect if we're dealing with a partial month that could cause misleading trends
+        days_into_month = today.day
+        is_partial_month = days_into_month <= 5  # First 5 days are considered "partial"
+        
+        if is_partial_month:
+            console.log(f"[yellow]⚠️  Partial month detected ({days_into_month} days into {today.strftime('%B')})[/]")
+            console.log(f"[dim yellow]   Trend calculations may show extreme percentages due to limited current data[/]")
+            console.log(f"[dim yellow]   Consider using full month comparisons for accurate trend analysis[/]")
+        
+        # Current period: start of month to today (include today with +1 day for AWS CE)
+        end_date = today + timedelta(days=1)  # AWS Cost Explorer end date is exclusive
+        
+        # Previous period: Use same day-of-month from previous month for better comparison
+        # This provides more meaningful trends when current month is partial
+        if is_partial_month and days_into_month > 1:
+            # For partial months, compare same number of days from previous month
+            previous_month_same_day = today.replace(day=1) - timedelta(days=1)  # Last day of prev month
+            previous_month_start = previous_month_same_day.replace(day=1)
+            
+            # Calculate same day of previous month, handling month boundaries
+            try:
+                previous_month_target_day = previous_month_start.replace(day=today.day)
+                previous_period_start = previous_month_start
+                previous_period_end = previous_month_target_day + timedelta(days=1)  # Exclusive end
+                
+                console.log(f"[cyan]📊 Using equal-day comparison: {days_into_month} days from current vs previous month[/]")
+                
+            except ValueError:
+                # Handle cases where previous month doesn't have the same day (e.g., Feb 30)
+                previous_period_end = previous_month_same_day + timedelta(days=1)
+                previous_period_start = previous_period_end.replace(day=1)
+        else:
+            # Standard full previous month comparison
+            previous_period_end = start_date - timedelta(days=1)
+            previous_period_start = previous_period_end.replace(day=1)
 
     account_id = get_account_id(session)
 
@@ -417,6 +684,20 @@ def get_cost_data(
         if amount > 0.001:  # Filter out negligible costs
             costs_by_service[service] = amount
 
+    # Calculate period metadata for trend context
+    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
+    
+    # Enhanced period information for trend analysis
+    period_metadata = {
+        "current_days": current_period_days,
+        "previous_days": previous_period_days,
+        "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"
+    }
+
     return {
         "account_id": account_id,
         "current_month": current_period_cost,
@@ -432,9 +713,90 @@ def get_cost_data(
         "previous_period_start": previous_period_start.isoformat(),
         "previous_period_end": previous_period_end.isoformat(),
         "monthly_costs": None,
+        "period_metadata": period_metadata,  # Added for intelligent trend analysis
     }
 
 
+def get_quarterly_cost_data(
+    session: Session,
+    profile_name: Optional[str] = None,
+    account_id: Optional[str] = None,
+) -> Dict[str, float]:
+    """
+    Get quarterly cost data for enhanced FinOps trend analysis.
+    
+    Retrieves cost data for the last complete quarter (3 months) to provide
+    strategic quarterly context for financial planning and trend analysis.
+    
+    Args:
+        session: The boto3 session to use
+        profile_name: Optional AWS profile name for enhanced error messaging
+        account_id: Optional account ID to filter costs to specific account
+        
+    Returns:
+        Dictionary with service names as keys and quarterly costs as values
+    """
+    ce = session.client("ce")
+    today = date.today()
+    
+    # Calculate last quarter date range
+    # Go back 3 months for quarterly analysis
+    quarterly_end_date = today.replace(day=1) - timedelta(days=1)  # Last day of previous month
+    quarterly_start_date = (quarterly_end_date.replace(day=1) - timedelta(days=90)).replace(day=1)
+    
+    # Build filters for quarterly analysis
+    filters = []
+    if account_id:
+        account_filter = {"Dimensions": {"Key": "LINKED_ACCOUNT", "Values": [account_id]}}
+        filters.append(account_filter)
+        
+    # Combine filters if needed
+    filter_param: Optional[Dict[str, Any]] = None
+    if len(filters) == 1:
+        filter_param = filters[0]
+    elif len(filters) > 1:
+        filter_param = {"And": filters}
+        
+    kwargs = {}
+    if filter_param:
+        kwargs["Filter"] = filter_param
+    
+    try:
+        quarterly_period_cost_by_service = ce.get_cost_and_usage(
+            TimePeriod={
+                "Start": quarterly_start_date.isoformat(), 
+                "End": (quarterly_end_date + timedelta(days=1)).isoformat()  # Exclusive end
+            },
+            Granularity="MONTHLY",
+            Metrics=["UnblendedCost"],
+            GroupBy=[{"Type": "DIMENSION", "Key": "SERVICE"}],
+            **kwargs,
+        )
+    except Exception as e:
+        console.log(f"[yellow]Warning: Unable to retrieve quarterly cost data: {e}[/]")
+        if "AccessDeniedException" in str(e) and "ce:GetCostAndUsage" in str(e):
+            handle_cost_explorer_error(e, profile_name)
+        return {}
+    
+    # Aggregate quarterly costs by service across the 3-month period
+    quarterly_service_costs: Dict[str, float] = defaultdict(float)
+    
+    for result in quarterly_period_cost_by_service.get("ResultsByTime", []):
+        for group in result.get("Groups", []):
+            service = group["Keys"][0]
+            amount = float(group["Metrics"]["UnblendedCost"]["Amount"])
+            quarterly_service_costs[service] += amount
+    
+    # Filter out negligible costs and convert to regular dict
+    filtered_quarterly_costs = {}
+    for service, amount in quarterly_service_costs.items():
+        if amount > 0.001:  # Filter out negligible costs
+            filtered_quarterly_costs[service] = amount
+            
+    console.log(f"[cyan]📊 Retrieved quarterly cost data for {len(filtered_quarterly_costs)} services[/]")
+    return filtered_quarterly_costs
+
+
 def process_service_costs(
     cost_data: CostData,
 ) -> Tuple[List[str], List[Tuple[str, float]]]:
@@ -461,8 +823,24 @@ def process_service_costs(
 
 
 def format_budget_info(budgets: List[BudgetInfo]) -> List[str]:
-    """Format budget information for display."""
+    """Format budget information for display with enhanced error handling."""
     budget_info: List[str] = []
+    
+    # Check if this is an access denied case (common with read-only profiles)
+    if budgets and len(budgets) == 1:
+        first_budget = budgets[0]
+        if isinstance(first_budget, dict):
+            # Check for access denied pattern
+            if first_budget.get('name', '').lower() in ['access denied', 'permission denied', 'n/a']:
+                budget_info.append("ℹ️  Budget data unavailable")
+                budget_info.append("(Read-only profile)")
+                budget_info.append("")
+                budget_info.append("💡 For budget access:")
+                budget_info.append("Add budgets:ViewBudget")
+                budget_info.append("policy to profile")
+                return budget_info
+    
+    # Normal budget formatting
     for budget in budgets:
         budget_info.append(f"{budget['name']} limit: ${budget['limit']}")
         budget_info.append(f"{budget['name']} actual: ${budget['actual']:.2f}")
@@ -470,23 +848,181 @@ def format_budget_info(budgets: List[BudgetInfo]) -> List[str]:
             budget_info.append(f"{budget['name']} forecast: ${budget['forecast']:.2f}")
 
     if not budget_info:
-        budget_info.append("No budgets found;\nCreate a budget for this account")
+        budget_info.append("ℹ️  No budgets configured")
+        budget_info.append("💡 Create a budget to")
+        budget_info.append("track spending limits")
 
     return budget_info
 
 
+def calculate_quarterly_enhanced_trend(
+    current: float, 
+    previous: float,
+    quarterly: float,
+    current_days: Optional[int] = None,
+    previous_days: Optional[int] = None
+) -> str:
+    """
+    Calculate trend with quarterly financial intelligence for strategic decision making.
+    
+    Enhanced FinOps trend analysis that combines monthly operational trends with quarterly
+    strategic context to provide executive-ready financial intelligence.
+    
+    Args:
+        current: Current period cost
+        previous: Previous period cost  
+        quarterly: Last quarter (3-month) average cost
+        current_days: Number of days in current period
+        previous_days: Number of days in previous period
+        
+    Returns:
+        Strategic trend indicator with quarterly context
+    """
+    # Start with existing monthly trend logic
+    monthly_trend = calculate_trend_with_context(current, previous, current_days, previous_days)
+    
+    # Add quarterly strategic context if available
+    if quarterly > 0:
+        # Calculate quarterly average for monthly comparison
+        quarterly_monthly_avg = quarterly / 3.0  # 3-month average
+        
+        # Compare current month against quarterly average
+        if current > 0:
+            quarterly_variance = ((current - quarterly_monthly_avg) / quarterly_monthly_avg) * 100
+            
+            # Strategic quarterly indicators
+            if abs(quarterly_variance) < 10:  # Within 10% of quarterly average
+                quarterly_context = "📊"  # Consistent with quarterly patterns
+            elif quarterly_variance > 25:  # Significantly above quarterly average
+                quarterly_context = "📈"  # Above quarterly baseline
+            elif quarterly_variance < -25:  # Significantly below quarterly average
+                quarterly_context = "📉"  # Below quarterly baseline
+            else:
+                quarterly_context = "📊"  # Normal quarterly variation
+                
+            # Combine monthly operational trend with quarterly strategic context
+            return f"{quarterly_context} {monthly_trend}"
+        
+    # Fallback to standard monthly trend if no quarterly data
+    return monthly_trend
+
+
+def format_cost_with_precision(amount: float, context: str = "dashboard") -> str:
+    """
+    Format cost with context-aware precision for consistent display.
+    
+    Args:
+        amount: Cost amount to format
+        context: Display context ('executive', 'detailed', 'dashboard')
+    
+    Returns:
+        Formatted cost string with appropriate precision
+    """
+    if context == "executive":
+        # Executive summary - round to nearest dollar for clarity
+        return f"${amount:,.0f}"
+    elif context == "detailed":
+        # Detailed analysis - show full precision
+        return f"${amount:,.2f}"
+    else:
+        # Default dashboard - 2 decimal places
+        return f"${amount:,.2f}"
+
+
+def calculate_trend_with_context(current: float, previous: float, 
+                               current_days: Optional[int] = None, 
+                               previous_days: Optional[int] = None) -> str:
+    """
+    Calculate trend with statistical context and confidence, handling partial period comparisons.
+    
+    CRITICAL MATHEMATICAL FIX: Addresses the business-critical issue where partial current month 
+    (e.g., September 1-2: $2.50) was compared against full previous month (August 1-31: $155.00),
+    resulting in misleading -98.4% trend calculations that could cause incorrect business decisions.
+    
+    Args:
+        current: Current period cost
+        previous: Previous period cost
+        current_days: Number of days in current period (for partial period detection)
+        previous_days: Number of days in previous period (for partial period detection)
+    
+    Returns:
+        Trend string with appropriate context and partial period warnings
+    """
+    if previous == 0:
+        if current == 0:
+            return "No change (both periods $0)"
+        else:
+            return "New spend (no historical data)"
+    
+    # Detect partial period issues
+    partial_period_issue = False
+    if current_days and previous_days:
+        if abs(current_days - previous_days) > 5:  # More than 5 days difference
+            partial_period_issue = True
+            
+    # Calculate basic percentage change
+    change_percent = ((current - previous) / previous) * 100
+    
+    # Handle partial period comparisons with warnings
+    if partial_period_issue:
+        period_info = f" (⚠️ {current_days}d vs {previous_days}d)"
+        if abs(change_percent) > 50:
+            return f"⚠️ Partial data comparison{period_info} - trend not reliable"
+        else:
+            base_trend = f"↑ {change_percent:.1f}%" if change_percent > 0 else f"↓ {abs(change_percent):.1f}%"
+            return f"{base_trend}{period_info}"
+    
+    # Standard trend analysis for equal periods
+    if abs(change_percent) > 90:
+        if change_percent > 0:
+            return f"↑ {change_percent:.1f}% (significant increase - verify)"
+        else:
+            return f"↓ {abs(change_percent):.1f}% (significant decrease - verify)"
+    elif abs(change_percent) < 1:
+        return "→ Stable (< 1% change)"
+    else:
+        if change_percent > 0:
+            return f"↑ {change_percent:.1f}%"
+        else:
+            return f"↓ {abs(change_percent):.1f}%"
+
+
 def format_ec2_summary(ec2_data: EC2Summary) -> List[str]:
-    """Format EC2 instance summary for display."""
+    """Format EC2 instance summary with enhanced visual hierarchy."""
     ec2_summary_text: List[str] = []
-    for state, count in sorted(ec2_data.items()):
-        if count > 0:
-            state_color = (
-                "bright_green" if state == "running" else "bright_yellow" if state == "stopped" else "bright_cyan"
+    
+    # Enhanced state formatting with icons and context
+    state_config = {
+        "running": {"color": "bright_green", "icon": "🟢", "priority": 1},
+        "stopped": {"color": "bright_yellow", "icon": "🟡", "priority": 2},
+        "terminated": {"color": "dim red", "icon": "🔴", "priority": 4},
+        "pending": {"color": "bright_cyan", "icon": "🔵", "priority": 3},
+        "stopping": {"color": "yellow", "icon": "🟠", "priority": 3}
+    }
+    
+    # Sort by priority and then by state name
+    sorted_states = sorted(
+        [(state, count) for state, count in ec2_data.items() if count > 0],
+        key=lambda x: (state_config.get(x[0], {"priority": 99})["priority"], x[0])
+    )
+    
+    total_instances = sum(count for _, count in sorted_states)
+    
+    if sorted_states:
+        # Header with total count
+        ec2_summary_text.append(f"[bright_cyan]📊 EC2 Instances ({total_instances} total)[/bright_cyan]")
+        
+        # Individual states with enhanced styling
+        for state, count in sorted_states:
+            config = state_config.get(state, {"color": "white", "icon": "⚪", "priority": 99})
+            percentage = (count / total_instances * 100) if total_instances > 0 else 0
+            
+            ec2_summary_text.append(
+                f"  {config['icon']} [{config['color']}]{state.title()}: {count}[/{config['color']}] "
+                f"[dim]({percentage:.1f}%)[/dim]"
             )
-            ec2_summary_text.append(f"[{state_color}]{state}: {count}[/]")
-
-    if not ec2_summary_text:
-        ec2_summary_text = ["No instances found"]
+    else:
+        ec2_summary_text = ["[dim]📭 No EC2 instances found[/dim]"]
 
     return ec2_summary_text
 
@@ -508,6 +1044,7 @@ def export_to_csv(
     output_dir: Optional[str] = None,
     previous_period_dates: str = "N/A",
     current_period_dates: str = "N/A",
+    include_dual_metrics: bool = False,
 ) -> Optional[str]:
     """Export dashboard data to a CSV file."""
     try:
@@ -524,37 +1061,129 @@ def export_to_csv(
         current_period_header = f"Cost for period\n({current_period_dates})"
 
         with open(output_filename, "w", newline="") as csvfile:
+            # Base fieldnames
             fieldnames = [
                 "CLI Profile",
                 "AWS Account ID",
                 previous_period_header,
                 current_period_header,
-                "Cost By Service",
+            ]
+            
+            # Add dual-metric columns if requested
+            if include_dual_metrics:
+                fieldnames.extend([
+                    f"AmortizedCost {current_period_header}",
+                    f"AmortizedCost {previous_period_header}",
+                    "Metric Variance ($)",
+                    "Metric Variance (%)",
+                    "Cost By Service (UnblendedCost)",
+                    "Cost By Service (AmortizedCost)",
+                ])
+            else:
+                fieldnames.append("Cost By Service")
+                
+            fieldnames.extend([
                 "Budget Status",
                 "EC2 Instances",
-            ]
+            ])
+            
             writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
             writer.writeheader()
             for row in data:
-                services_data = "\n".join([f"{service}: ${cost:.2f}" for service, cost in row["service_costs"]])
-
-                budgets_data = "\n".join(row["budget_info"]) if row["budget_info"] else "No budgets"
-
-                ec2_data_summary = "\n".join(
-                    [f"{state}: {count}" for state, count in row["ec2_summary"].items() if count > 0]
-                )
-
-                writer.writerow(
-                    {
-                        "CLI Profile": row["profile"],
-                        "AWS Account ID": row["account_id"],
-                        previous_period_header: f"${row['last_month']:.2f}",
-                        current_period_header: f"${row['current_month']:.2f}",
-                        "Cost By Service": services_data or "No costs",
-                        "Budget Status": budgets_data or "No budgets",
-                        "EC2 Instances": ec2_data_summary or "No instances",
+                # Enhanced error handling for service costs access
+                try:
+                    service_costs = row.get("service_costs", [])
+                    if isinstance(service_costs, list) and service_costs:
+                        services_data = "\n".join([f"{service}: ${cost:.2f}" for service, cost in service_costs])
+                    else:
+                        services_data = "No service costs"
+                except (KeyError, TypeError, AttributeError) as e:
+                    console.print(f"[yellow]Warning: Could not process service costs: {e}[/]")
+                    services_data = "Service costs unavailable"
+
+                # Enhanced error handling for budget_info access
+                try:
+                    budget_info = row.get("budget_info", [])
+                    if isinstance(budget_info, list) and budget_info:
+                        budgets_data = "\n".join(str(item) for item in budget_info)
+                    else:
+                        budgets_data = "No budgets"
+                except (KeyError, TypeError, AttributeError) as e:
+                    console.print(f"[yellow]Warning: Could not process budget info: {e}[/]")
+                    budgets_data = "Budget info unavailable"
+
+                # Enhanced error handling for EC2 summary access
+                try:
+                    ec2_summary = row.get("ec2_summary", {})
+                    if isinstance(ec2_summary, dict) and ec2_summary:
+                        ec2_data_summary = "\n".join(
+                            [f"{state}: {count}" for state, count in ec2_summary.items() if count > 0]
+                        )
+                    else:
+                        ec2_data_summary = "No EC2 instances"
+                except (KeyError, TypeError, AttributeError) as e:
+                    console.print(f"[yellow]Warning: Could not process EC2 summary: {e}[/]")
+                    ec2_data_summary = "EC2 summary unavailable"
+
+                # Enhanced error handling for writerow with safe field access
+                try:
+                    # Base row data
+                    row_data = {
+                        "CLI Profile": row.get("profile_name", "Unknown"),
+                        "AWS Account ID": row.get("account_id", "Unknown"),
+                        previous_period_header: row.get("previous_month_formatted", "N/A"),
+                        current_period_header: row.get("current_month_formatted", "N/A"),
                     }
-                )
+                    
+                    # Add dual-metric data if requested
+                    if include_dual_metrics:
+                        # Calculate variance for dual-metric display
+                        current_unblended = row.get("current_month", 0)
+                        current_amortized = row.get("current_month_amortized", current_unblended)
+                        previous_amortized = row.get("previous_month_amortized", row.get("previous_month", 0))
+                        variance = abs(current_unblended - current_amortized)
+                        variance_pct = (variance / current_amortized * 100) if current_amortized > 0 else 0
+                        
+                        # Format amortized service costs
+                        amortized_services_data = "No amortized service costs"
+                        if row.get("service_costs_amortized"):
+                            amortized_services_data = "\n".join([
+                                f"{service}: ${cost:.2f}" 
+                                for service, cost in row["service_costs_amortized"]
+                            ])
+                        
+                        row_data.update({
+                            f"AmortizedCost {current_period_header}": f"${current_amortized:.2f}",
+                            f"AmortizedCost {previous_period_header}": f"${previous_amortized:.2f}",
+                            "Metric Variance ($)": f"${variance:.2f}",
+                            "Metric Variance (%)": f"{variance_pct:.2f}%",
+                            "Cost By Service (UnblendedCost)": services_data or "No costs",
+                            "Cost By Service (AmortizedCost)": amortized_services_data,
+                        })
+                    else:
+                        row_data["Cost By Service"] = services_data or "No costs"
+                    
+                    # Add common fields
+                    row_data.update({
+                        "Budget Status": budgets_data or "No budgets", 
+                        "EC2 Instances": ec2_data_summary or "No instances",
+                    })
+                    
+                    writer.writerow(row_data)
+                except (KeyError, TypeError) as e:
+                    console.print(f"[yellow]Warning: Could not write CSV row: {e}[/]")
+                    # Write a minimal error row to maintain CSV structure
+                    writer.writerow(
+                        {
+                            "CLI Profile": "Error",
+                            "AWS Account ID": "Error", 
+                            previous_period_header: "Error",
+                            current_period_header: "Error",
+                            "Cost By Service": f"Row processing error: {e}",
+                            "Budget Status": "Error",
+                            "EC2 Instances": "Error",
+                        }
+                    )
         console.print(f"[bright_green]Exported dashboard data to {os.path.abspath(output_filename)}[/]")
         return os.path.abspath(output_filename)
     except Exception as e:
@@ -562,7 +1191,7 @@ def export_to_csv(
         return None
 
 
-def export_to_json(data: List[ProfileData], filename: str, output_dir: Optional[str] = None) -> Optional[str]:
+def export_to_json(data: List[ProfileData], filename: str, output_dir: Optional[str] = None, include_dual_metrics: bool = False) -> Optional[str]:
     """Export dashboard data to a JSON file."""
     try:
         timestamp = datetime.now().strftime("%Y%m%d_%H%M")
@@ -574,8 +1203,55 @@ def export_to_json(data: List[ProfileData], filename: str, output_dir: Optional[
         else:
             output_filename = base_filename
 
+        # Prepare data with dual-metric enhancement if requested
+        export_data = []
+        for item in data:
+            if include_dual_metrics:
+                # Enhanced data structure for dual metrics
+                enhanced_item = dict(item)  # Copy base data
+                
+                # Calculate variance metrics
+                current_unblended = item.get("current_month", 0)
+                current_amortized = item.get("current_month_amortized", current_unblended)
+                variance = abs(current_unblended - current_amortized)
+                variance_pct = (variance / current_amortized * 100) if current_amortized > 0 else 0
+                
+                # Add dual-metric metadata
+                enhanced_item.update({
+                    "dual_metric_analysis": {
+                        "unblended_cost": {
+                            "current": current_unblended,
+                            "previous": item.get("previous_month", 0),
+                            "metric_type": "technical",
+                            "description": "UnblendedCost - for DevOps/SRE teams"
+                        },
+                        "amortized_cost": {
+                            "current": current_amortized,
+                            "previous": item.get("previous_month_amortized", item.get("previous_month", 0)),
+                            "metric_type": "financial", 
+                            "description": "AmortizedCost - for Finance/Executive teams"
+                        },
+                        "variance_analysis": {
+                            "absolute_variance": variance,
+                            "percentage_variance": variance_pct,
+                            "variance_level": "low" if variance_pct < 1.0 else "moderate" if variance_pct < 5.0 else "high"
+                        }
+                    },
+                    "export_metadata": {
+                        "export_type": "dual_metric",
+                        "export_timestamp": datetime.now().isoformat(),
+                        "metric_explanation": {
+                            "unblended_cost": "Actual costs without Reserved Instance or Savings Plan allocations",
+                            "amortized_cost": "Costs with Reserved Instance and Savings Plan benefits applied"
+                        }
+                    }
+                })
+                export_data.append(enhanced_item)
+            else:
+                export_data.append(item)
+        
         with open(output_filename, "w") as jsonfile:
-            json.dump(data, jsonfile, indent=4)
+            json.dump(export_data, jsonfile, indent=4)
 
         console.print(f"[bright_green]Exported dashboard data to {os.path.abspath(output_filename)}[/]")
         return os.path.abspath(output_filename)