runbooks 1.1.4__py3-none-any.whl → 1.1.5__py3-none-any.whl

runbooks/finops/cost_processor.py

@@ -28,6 +28,7 @@ NON_ANALYTICAL_SERVICES = ["Tax"]  # Services excluded from Top N analysis per u
 _filter_cache: Dict[str, tuple] = {}
 _filter_session_id: Optional[str] = None
 
+
 def _get_filter_session_id() -> str:
     """Generate filter session ID for cache scoping"""
     global _filter_session_id
@@ -79,7 +80,9 @@ def filter_analytical_services(
 
         # Only log if not already logged in this session
         if cache_key not in _filter_cache:
-            console.log(f"[dim yellow]🔍 Filtered {filtered_count} non-analytical services: {', '.join(excluded_names)}[/]")
+            console.log(
+                f"[dim yellow]🔍 Filtered {filtered_count} non-analytical services: {', '.join(excluded_names)}[/]"
+            )
             _filter_cache[cache_key] = (filtered_count, excluded_names)
 
     return filtered_services
@@ -87,29 +90,30 @@ def filter_analytical_services(
 
 class DualMetricCostProcessor:
     """Enhanced processor for UnblendedCost (technical) and AmortizedCost (financial) reporting."""
-    
-    def __init__(self, session: Session, profile_name: Optional[str] = None):
+
+    def __init__(self, session: Session, profile_name: Optional[str] = None, analysis_mode: str = "comprehensive"):
         """Initialize dual-metric cost processor.
-        
+
         Args:
             session: AWS boto3 session
             profile_name: AWS profile name for error handling
+            analysis_mode: Analysis mode - "technical" (UnblendedCost), "financial" (AmortizedCost), or "comprehensive" (both)
         """
         self.session = session
         self.profile_name = profile_name or "default"
+        self.analysis_mode = analysis_mode
         self.ce = session.client("ce")
-        
-    def collect_dual_metrics(self, 
-                           account_id: Optional[str] = None,
-                           start_date: str = None,
-                           end_date: str = None) -> DualMetricResult:
+
+    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
         """
@@ -117,39 +121,47 @@ class DualMetricCostProcessor:
         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)[/]")
+            # Inform user about the metric collection based on analysis mode
+            if self.analysis_mode == "technical":
+                console.log("[bright_blue]🔧 Collecting UnblendedCost data (Technical Analysis)[/]")
+            elif self.analysis_mode == "financial":
+                console.log("[bright_green]📊 Collecting AmortizedCost data (Financial Analysis)[/]")
+            else:
+                console.log(
+                    "[bright_cyan]💰 Collecting both UnblendedCost and AmortizedCost data (Dual-Metrics Analysis)[/]"
+                )
+
+            # Technical Analysis (UnblendedCost) - always collect for comparison
             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 {})
+                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)[/]")
+
+            # Financial Reporting (AmortizedCost) - always collect for comparison
             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 {})
+                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]
@@ -158,12 +170,12 @@ class DualMetricCostProcessor:
                         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]
@@ -172,17 +184,19 @@ class DualMetricCostProcessor:
                         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}[/]")
-            
+
+            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,
@@ -193,14 +207,14 @@ class DualMetricCostProcessor:
                 period_start=start_date,
                 period_end=end_date,
                 service_breakdown_unblended=service_breakdown_unblended,
-                service_breakdown_amortized=service_breakdown_amortized
+                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={},
@@ -212,37 +226,34 @@ class DualMetricCostProcessor:
                 period_start=start_date,
                 period_end=end_date,
                 service_breakdown_unblended=[],
-                service_breakdown_amortized=[]
+                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
+    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) 
+
+    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
@@ -253,25 +264,25 @@ def get_equal_period_cost_data(
             # 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={
@@ -282,41 +293,46 @@ def get_equal_period_cost_data(
                 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
-            })
-            
+
+            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
-            })
-    
+            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"
+        "profile": session.profile_name or profile_name or "default",
     }
 
 
@@ -568,37 +584,41 @@ def get_cost_data(
         # 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
-        
+
         # 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]   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[/]")
-                
+
+                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)
@@ -608,7 +628,14 @@ def get_cost_data(
             previous_period_end = start_date - timedelta(days=1)
             previous_period_start = previous_period_end.replace(day=1)
 
-    account_id = get_account_id(session)
+    # Get account ID with enhanced error handling for AWS-2 accuracy validation
+    try:
+        account_id = get_account_id(session)
+        if not account_id:
+            account_id = "unknown"
+    except Exception as account_error:
+        console.print(f"[yellow]Warning: Could not retrieve account ID: {account_error}[/yellow]")
+        account_id = "unknown"
 
     try:
         this_period = ce.get_cost_and_usage(
@@ -707,7 +734,7 @@ def get_cost_data(
     previous_period_days = (previous_period_end - previous_period_start).days
     days_difference = abs(current_period_days - previous_period_days)
     is_partial_comparison = days_difference > 5
-    
+
     # ENHANCED RELIABILITY ASSESSMENT: Consider MCP validation success in trend reliability
     trend_reliability = "high"
     if is_partial_comparison:
@@ -718,17 +745,24 @@ def get_cost_data(
         else:
             # Moderate difference - reliability depends on validation accuracy
             trend_reliability = "medium_with_validation_support"
-    
+
     # Enhanced period information for trend analysis
+    # Calculate is_partial_month for metadata (AWS-2 accuracy enhancement)
+    today = date.today()
+    days_into_month = today.day
+    is_partial_month = days_into_month <= 5  # First 5 days are considered "partial"
+
     period_metadata = {
         "current_days": current_period_days,
         "previous_days": previous_period_days,
         "days_difference": days_difference,
         "is_partial_comparison": is_partial_comparison,
-        "comparison_type": "equal_day_comparison" if is_partial_month else "standard_month_comparison",
+        "comparison_type": "equal_day_comparison" if is_partial_comparison else "standard_month_comparison",
         "trend_reliability": trend_reliability,
-        "period_alignment_strategy": "equal_days" if is_partial_month and days_into_month > 1 else "standard_monthly",
-        "supports_mcp_validation": True  # This data structure supports MCP cross-validation
+        "period_alignment_strategy": "equal_days"
+        if is_partial_comparison and days_into_month > 1
+        else "standard_monthly",
+        "supports_mcp_validation": True,  # This data structure supports MCP cross-validation
     }
 
     return {
@@ -757,48 +791,48 @@ def get_quarterly_cost_data(
 ) -> 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
+                "Start": quarterly_start_date.isoformat(),
+                "End": (quarterly_end_date + timedelta(days=1)).isoformat(),  # Exclusive end
             },
             Granularity="MONTHLY",
             Metrics=["UnblendedCost"],
@@ -810,22 +844,22 @@ def get_quarterly_cost_data(
         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
 
@@ -856,15 +890,15 @@ def process_service_costs(
 
 
 def format_budget_info(budgets: List[BudgetInfo]) -> List[str]:
-    """Format budget information for display with enhanced error handling."""
+    """Format budget information for display with enhanced error handling and concise icons."""
     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']:
+            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("")
@@ -872,13 +906,39 @@ def format_budget_info(budgets: List[BudgetInfo]) -> List[str]:
                 budget_info.append("Add budgets:ViewBudget")
                 budget_info.append("policy to profile")
                 return budget_info
-    
-    # Normal budget formatting
+
+    # Enhanced budget formatting with concise icons and status
     for budget in budgets:
-        budget_info.append(f"{budget['name']} limit: ${budget['limit']}")
-        budget_info.append(f"{budget['name']} actual: ${budget['actual']:.2f}")
-        if budget["forecast"] is not None:
-            budget_info.append(f"{budget['name']} forecast: ${budget['forecast']:.2f}")
+        # Calculate budget utilization for status determination
+        utilization = (budget["actual"] / budget["limit"]) * 100 if budget["limit"] > 0 else 0
+
+        # Determine status icon and color based on utilization
+        if utilization >= 100:
+            status_icon = "🚨"  # Over budget - critical
+            status_color = "bright_red"
+        elif utilization >= 85:
+            status_icon = "⚠️"  # Near limit - warning
+            status_color = "orange1"
+        elif utilization >= 70:
+            status_icon = "🟡"  # Moderate usage - caution
+            status_color = "yellow"
+        else:
+            status_icon = "✅"  # Under budget - good
+            status_color = "green"
+
+        # Format budget name (shortened for display)
+        display_name = budget["name"].replace(" Budget", "").replace("Budget", "").strip()
+        if len(display_name) > 15:
+            display_name = display_name[:12] + "..."
+
+        # Concise budget display with icons
+        budget_info.append(f"{status_icon} [{status_color}]{display_name}[/]")
+        budget_info.append(f"💰 ${budget['actual']:.0f}/${budget['limit']:.0f} ({utilization:.0f}%)")
+
+        # Add forecast only if significantly different from actual
+        if budget["forecast"] is not None and abs(budget["forecast"] - budget["actual"]) > (budget["actual"] * 0.1):
+            trend_icon = "📈" if budget["forecast"] > budget["actual"] else "📉"
+            budget_info.append(f"{trend_icon} Est: ${budget['forecast']:.0f}")
 
     if not budget_info:
         budget_info.append("ℹ️  No budgets configured")
@@ -893,7 +953,7 @@ def calculate_quarterly_enhanced_trend(
     previous: float,
     quarterly: float,
     current_days: Optional[int] = None,
-    previous_days: Optional[int] = None
+    previous_days: Optional[int] = None,
 ) -> str:
     """
     Calculate trend with quarterly financial intelligence for strategic decision making.
@@ -963,11 +1023,11 @@ def calculate_quarterly_enhanced_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
     """
@@ -982,22 +1042,22 @@ def format_cost_with_precision(amount: float, context: str = "dashboard") -> str
         return f"${amount:,.2f}"
 
 
-def calculate_trend_with_context(current: float, previous: float, 
-                               current_days: Optional[int] = None, 
-                               previous_days: Optional[int] = None) -> str:
+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 
+
+    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
     """
@@ -1006,28 +1066,71 @@ def calculate_trend_with_context(current: float, previous: float,
             return "No change (both periods $0)"
         else:
             return "New spend (no historical data)"
-    
-    # Detect partial period issues
+
+    # Detect partial period issues and apply smart normalization
     partial_period_issue = False
+    normalized_change_percent = None
+    normalization_applied = 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
+
+            # Apply smart normalization for partial month comparisons
+            if current_days < previous_days:
+                # Current month is partial, previous is full - normalize previous month
+                normalization_factor = current_days / previous_days
+                adjusted_previous = previous * normalization_factor
+                if adjusted_previous > 0:
+                    normalized_change_percent = ((current - adjusted_previous) / adjusted_previous) * 100
+                    normalization_applied = True
+                    from ..common.rich_utils import console
+
+                    console.log(
+                        f"[dim yellow]📊 Trend normalization: partial current ({current_days} days) vs full previous ({previous_days} days)[/]"
+                    )
+                    console.log(
+                        f"[dim yellow]   Adjusted comparison: ${current:.2f} vs ${adjusted_previous:.2f} (factor: {normalization_factor:.2f})[/]"
+                    )
+
+            elif current_days > previous_days:
+                # Previous month is partial, current is full - normalize current month
+                normalization_factor = previous_days / current_days
+                adjusted_current = current * normalization_factor
+                if previous > 0:
+                    normalized_change_percent = ((adjusted_current - previous) / previous) * 100
+                    normalization_applied = True
+                    from ..common.rich_utils import console
+
+                    console.log(
+                        f"[dim yellow]📊 Trend normalization: full current ({current_days} days) vs partial previous ({previous_days} days)[/]"
+                    )
+                    console.log(
+                        f"[dim yellow]   Adjusted comparison: ${adjusted_current:.2f} vs ${previous:.2f} (factor: {normalization_factor:.2f})[/]"
+                    )
+
+    # Use normalized change if available, otherwise calculate basic percentage change
+    if normalization_applied and normalized_change_percent is not None:
+        change_percent = normalized_change_percent
+        # Add indicator that normalization was applied
+        normalization_indicator = " 📏"
+    else:
+        change_percent = ((current - previous) / previous) * 100
+        normalization_indicator = ""
 
     # FIXED: Show meaningful percentage trends instead of generic messages
     if abs(change_percent) < 0.01:  # Less than 0.01%
         if current == previous:
-            return "→ 0.0%"  # Show actual zero change percentage
+            return f"→ 0.0%{normalization_indicator}"  # Show actual zero change percentage
         elif abs(current - previous) < 0.01:  # Very small absolute difference
-            return "→ <0.1%"  # Show near-zero change with percentage
+            return f"→ <0.1%{normalization_indicator}"  # Show near-zero change with percentage
         else:
             # Show actual small change with precise percentage
-            return f"{'↑' if change_percent > 0 else '↓'} {abs(change_percent):.2f}%"
+            return f"{'↑' if change_percent > 0 else '↓'} {abs(change_percent):.2f}%{normalization_indicator}"
 
     # Handle partial period comparisons with clean display
-    if partial_period_issue:
+    if partial_period_issue and not normalization_applied:
+        # Only show warnings if normalization wasn't applied (fallback case)
         if abs(change_percent) > 50:
             return "⚠️ Trend not reliable (partial data)"
         else:
@@ -1037,48 +1140,48 @@ def calculate_trend_with_context(current: float, previous: float,
     # Standard trend analysis for equal periods
     if abs(change_percent) > 90:
         if change_percent > 0:
-            return f"↑ {change_percent:.1f}% (significant increase - verify)"
+            return f"↑ {change_percent:.1f}% (significant increase - verify){normalization_indicator}"
         else:
-            return f"↓ {abs(change_percent):.1f}% (significant decrease - verify)"
+            return f"↓ {abs(change_percent):.1f}% (significant decrease - verify){normalization_indicator}"
     elif abs(change_percent) < 1:
-        return "→ Stable (< 1% change)"
+        return f"→ Stable (< 1% change){normalization_indicator}"
     else:
         if change_percent > 0:
-            return f"↑ {change_percent:.1f}%"
+            return f"↑ {change_percent:.1f}%{normalization_indicator}"
         else:
-            return f"↓ {abs(change_percent):.1f}%"
+            return f"↓ {abs(change_percent):.1f}%{normalization_indicator}"
 
 
 def format_ec2_summary(ec2_data: EC2Summary) -> List[str]:
     """Format EC2 instance summary with enhanced visual hierarchy."""
     ec2_summary_text: List[str] = []
-    
+
     # 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}
+        "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])
+        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]"
@@ -1130,25 +1233,29 @@ def export_to_csv(
                 previous_period_header,
                 current_period_header,
             ]
-            
+
             # 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)",
-                ])
+                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",
-            ])
-            
+
+            fieldnames.extend(
+                [
+                    "Budget Status",
+                    "EC2 Instances",
+                ]
+            )
+
             writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
             writer.writeheader()
             for row in data:
@@ -1196,7 +1303,7 @@ def export_to_csv(
                         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
@@ -1205,32 +1312,35 @@ def export_to_csv(
                         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,
-                        })
+                            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",
-                    })
-                    
+                    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}[/]")
@@ -1238,7 +1348,7 @@ def export_to_csv(
                     writer.writerow(
                         {
                             "CLI Profile": "Error",
-                            "AWS Account ID": "Error", 
+                            "AWS Account ID": "Error",
                             previous_period_header: "Error",
                             current_period_header: "Error",
                             "Cost By Service": f"Row processing error: {e}",
@@ -1253,7 +1363,9 @@ def export_to_csv(
         return None
 
 
-def export_to_json(data: List[ProfileData], filename: str, output_dir: Optional[str] = None, include_dual_metrics: bool = False) -> 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")
@@ -1271,47 +1383,53 @@ def export_to_json(data: List[ProfileData], filename: str, output_dir: Optional[
             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"
+                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",
+                            },
                         },
-                        "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"
+                        "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",
+                            },
                         },
-                        "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(export_data, jsonfile, indent=4)