runbooks 0.7.6__py3-none-any.whl → 0.7.7__py3-none-any.whl

runbooks/finops/dashboard_runner.py

@@ -1,17 +1,21 @@
 import argparse
+import os
 from collections import defaultdict
 from typing import Any, Dict, List, Optional, Tuple
 
 import boto3
 from rich import box
 from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn, TimeElapsedColumn
 from rich.progress import track
 from rich.status import Status
 from rich.table import Column, Table
 
 from runbooks.finops.aws_client import (
+    ec2_summary,
     get_accessible_regions,
     get_account_id,
+    get_aws_profiles,
     get_budgets,
     get_stopped_instances,
     get_untagged_resources,
@@ -23,6 +27,10 @@ from runbooks.finops.cost_processor import (
     export_to_json,
     get_cost_data,
     get_trend,
+    change_in_total_cost,
+    format_budget_info,
+    format_ec2_summary,
+    process_service_costs,
 )
 from runbooks.finops.helpers import (
     clean_rich_tags,
@@ -31,6 +39,7 @@ from runbooks.finops.helpers import (
     export_audit_report_to_pdf,
     export_cost_dashboard_to_pdf,
     export_trend_data_to_json,
+    generate_pdca_improvement_report,
 )
 from runbooks.finops.profile_processor import (
     process_combined_profiles,
@@ -42,6 +51,153 @@ from runbooks.finops.visualisations import create_trend_bars
 console = Console()
 
 
+def _get_profile_for_operation(operation_type: str, default_profile: str) -> str:
+    """
+    Get the appropriate AWS profile based on operation type.
+    
+    Args:
+        operation_type: Type of operation ('billing', 'management', 'operational')
+        default_profile: Default profile to fall back to
+        
+    Returns:
+        str: Profile name to use for the operation
+    """
+    profile_map = {
+        'billing': os.getenv('BILLING_PROFILE'),
+        'management': os.getenv('MANAGEMENT_PROFILE'),  
+        'operational': os.getenv('CENTRALISED_OPS_PROFILE')
+    }
+    
+    profile = profile_map.get(operation_type)
+    if profile:
+        # Verify profile exists
+        available_profiles = boto3.Session().available_profiles
+        if profile in available_profiles:
+            console.log(f"[dim cyan]Using {operation_type} profile: {profile}[/]")
+            return profile
+        else:
+            console.log(f"[yellow]Warning: {operation_type.title()} profile '{profile}' not found in AWS config. Using default: {default_profile}[/]")
+    
+    return default_profile
+
+
+def _create_cost_session(profile: str) -> boto3.Session:
+    """
+    Create a boto3 session specifically for cost operations.
+    Uses BILLING_PROFILE if available, falls back to provided profile.
+    
+    Args:
+        profile: Default profile to use
+        
+    Returns:
+        boto3.Session: Session configured for cost operations
+    """
+    cost_profile = _get_profile_for_operation('billing', profile)
+    return boto3.Session(profile_name=cost_profile)
+
+
+def _create_management_session(profile: str) -> boto3.Session:
+    """
+    Create a boto3 session specifically for management operations.
+    Uses MANAGEMENT_PROFILE if available, falls back to provided profile.
+    
+    Args:
+        profile: Default profile to use
+        
+    Returns:
+        boto3.Session: Session configured for management operations  
+    """
+    mgmt_profile = _get_profile_for_operation('management', profile)
+    return boto3.Session(profile_name=mgmt_profile)
+
+
+def _create_operational_session(profile: str) -> boto3.Session:
+    """
+    Create a boto3 session specifically for operational tasks.
+    Uses CENTRALISED_OPS_PROFILE if available, falls back to provided profile.
+    
+    Args:
+        profile: Default profile to use
+        
+    Returns:
+        boto3.Session: Session configured for operational tasks
+    """
+    ops_profile = _get_profile_for_operation('operational', profile)
+    return boto3.Session(profile_name=ops_profile)
+
+
+def _calculate_risk_score(untagged, stopped, unused_vols, unused_eips, budget_data):
+    """Calculate risk score based on audit findings for PDCA tracking."""
+    score = 0
+    
+    # Untagged resources (high risk for compliance)
+    untagged_count = sum(len(ids) for region_map in untagged.values() for ids in region_map.values())
+    score += untagged_count * 2  # High weight for untagged
+    
+    # Stopped instances (medium risk for cost)
+    stopped_count = sum(len(ids) for ids in stopped.values())
+    score += stopped_count * 1
+    
+    # Unused volumes (medium risk for cost)
+    volume_count = sum(len(ids) for ids in unused_vols.values())
+    score += volume_count * 1
+    
+    # Unused EIPs (high risk for cost)
+    eip_count = sum(len(ids) for ids in unused_eips.values())
+    score += eip_count * 3  # High cost impact
+    
+    # Budget overruns (critical risk)
+    overruns = len([b for b in budget_data if b["actual"] > b["limit"]])
+    score += overruns * 5  # Critical weight
+    
+    return score
+
+
+def _format_risk_score(score):
+    """Format risk score with visual indicators."""
+    if score == 0:
+        return "[bright_green]🟢 LOW\n(0)[/]"
+    elif score <= 10:
+        return f"[yellow]🟡 MEDIUM\n({score})[/]"
+    elif score <= 25:
+        return f"[orange1]🟠 HIGH\n({score})[/]"
+    else:
+        return f"[bright_red]🔴 CRITICAL\n({score})[/]"
+
+
+def _display_pdca_summary(pdca_metrics):
+    """Display PDCA improvement summary with actionable insights."""
+    if not pdca_metrics:
+        return
+        
+    total_risk = sum(m["risk_score"] for m in pdca_metrics)
+    avg_risk = total_risk / len(pdca_metrics)
+    
+    high_risk_accounts = [m for m in pdca_metrics if m["risk_score"] > 25]
+    total_untagged = sum(m["untagged_count"] for m in pdca_metrics)
+    total_unused_eips = sum(m["unused_eips_count"] for m in pdca_metrics)
+    
+    summary_table = Table(
+        title="🎯 PDCA Continuous Improvement Metrics",
+        box=box.SIMPLE,
+        style="cyan"
+    )
+    summary_table.add_column("Metric", style="bold")
+    summary_table.add_column("Value", justify="right")
+    summary_table.add_column("Action Required", style="yellow")
+    
+    summary_table.add_row("Average Risk Score", f"{avg_risk:.1f}", 
+                         "✅ Good" if avg_risk < 10 else "⚠️ Review Required")
+    summary_table.add_row("High-Risk Accounts", str(len(high_risk_accounts)),
+                         "🔴 Immediate Action" if high_risk_accounts else "✅ Good")
+    summary_table.add_row("Total Untagged Resources", str(total_untagged),
+                         "📋 Tag Management" if total_untagged > 50 else "✅ Good")
+    summary_table.add_row("Total Unused EIPs", str(total_unused_eips),
+                         "💰 Cost Optimization" if total_unused_eips > 5 else "✅ Good")
+    
+    console.print(summary_table)
+
+
 def _initialize_profiles(
     args: argparse.Namespace,
 ) -> Tuple[List[str], Optional[List[str]], Optional[int]]:
@@ -74,102 +230,173 @@ def _initialize_profiles(
 
 
 def _run_audit_report(profiles_to_use: List[str], args: argparse.Namespace) -> None:
-    """Generate and export an audit report."""
-    console.print("[bold bright_cyan]Preparing your audit report...[/]")
+    """Generate and export an audit report with PDCA continuous improvement."""
+    console.print("[bold bright_cyan]🔍 PLAN: Preparing comprehensive audit report...[/]")
+    
+    # Display multi-profile configuration
+    billing_profile = os.getenv('BILLING_PROFILE')
+    mgmt_profile = os.getenv('MANAGEMENT_PROFILE') 
+    ops_profile = os.getenv('CENTRALISED_OPS_PROFILE')
+    
+    if any([billing_profile, mgmt_profile, ops_profile]):
+        console.print("[dim cyan]Multi-profile configuration detected:[/]")
+        if billing_profile:
+            console.print(f"[dim cyan]  • Billing operations: {billing_profile}[/]")
+        if mgmt_profile:
+            console.print(f"[dim cyan]  • Management operations: {mgmt_profile}[/]")
+        if ops_profile:
+            console.print(f"[dim cyan]  • Operational tasks: {ops_profile}[/]")
+        console.print()
+    
+    # Enhanced table with better visual hierarchy
     table = Table(
-        Column("Profile", justify="center"),
-        Column("Account ID", justify="center"),
-        Column("Untagged Resources"),
-        Column("Stopped EC2 Instances"),
-        Column("Unused Volumes"),
-        Column("Unused EIPs"),
-        Column("Budget Alerts"),
-        title="AWS FinOps Audit Report",
+        Column("Profile", justify="center", style="bold magenta"),
+        Column("Account ID", justify="center", style="dim"),
+        Column("Untagged Resources", style="yellow"),
+        Column("Stopped EC2 Instances", style="red"),
+        Column("Unused Volumes", style="orange1"),
+        Column("Unused EIPs", style="cyan"),
+        Column("Budget Alerts", style="bright_red"),
+        Column("Risk Score", justify="center", style="bold"),
+        title="🎯 AWS FinOps Audit Report - PDCA Enhanced",
         show_lines=True,
-        box=box.ASCII_DOUBLE_HEAD,
+        box=box.ROUNDED,
         style="bright_cyan",
+        caption="🚀 PDCA Cycle: Plan → Do → Check → Act",
     )
 
     audit_data = []
     raw_audit_data = []
+    pdca_metrics = []  # New: Track PDCA improvement metrics
     nl = "\n"
     comma_nl = ",\n"
 
-    for profile in profiles_to_use:
-        session = boto3.Session(profile_name=profile)
-        account_id = get_account_id(session) or "Unknown"
-        regions = args.regions or get_accessible_regions(session)
+    console.print("[bold green]⚙️ DO: Collecting audit data across profiles...[/]")
+    
+    # Create progress tracker for enhanced user experience (v2.2.3 reference)
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        TimeElapsedColumn(),
+        console=console,
+        transient=True
+    ) as progress:
+        task = progress.add_task("Collecting audit data", total=len(profiles_to_use))
+        
+        for profile in profiles_to_use:
+            progress.update(task, description=f"Processing profile: {profile}")
+            
+            # Use operational session for resource discovery
+            ops_session = _create_operational_session(profile)
+            # Use management session for account and governance operations
+            mgmt_session = _create_management_session(profile)
+            # Use billing session for cost and budget operations
+            billing_session = _create_cost_session(profile)
+            
+            account_id = get_account_id(mgmt_session) or "Unknown"
+            regions = args.regions or get_accessible_regions(ops_session)
 
-        try:
-            untagged = get_untagged_resources(session, regions)
-            anomalies = []
-            for service, region_map in untagged.items():
-                if region_map:
-                    service_block = f"[bright_yellow]{service}[/]:\n"
-                    for region, ids in region_map.items():
-                        if ids:
-                            ids_block = "\n".join(f"[orange1]{res_id}[/]" for res_id in ids)
-                            service_block += f"\n{region}:\n{ids_block}\n"
-                    anomalies.append(service_block)
-            if not any(region_map for region_map in untagged.values()):
-                anomalies = ["None"]
-        except Exception as e:
-            anomalies = [f"Error: {str(e)}"]
-
-        stopped = get_stopped_instances(session, regions)
-        stopped_list = [f"{r}:\n[gold1]{nl.join(ids)}[/]" for r, ids in stopped.items()] or ["None"]
-
-        unused_vols = get_unused_volumes(session, regions)
-        vols_list = [f"{r}:\n[dark_orange]{nl.join(ids)}[/]" for r, ids in unused_vols.items()] or ["None"]
-
-        unused_eips = get_unused_eips(session, regions)
-        eips_list = [f"{r}:\n{comma_nl.join(ids)}" for r, ids in unused_eips.items()] or ["None"]
-
-        budget_data = get_budgets(session)
-        alerts = []
-        for b in budget_data:
-            if b["actual"] > b["limit"]:
-                alerts.append(f"[red1]{b['name']}[/]: ${b['actual']:.2f} > ${b['limit']:.2f}")
-        if not alerts:
-            alerts = ["No budgets exceeded"]
-
-        audit_data.append(
-            {
+            try:
+                # Use operational session for resource discovery
+                untagged = get_untagged_resources(ops_session, regions)
+                anomalies = []
+                for service, region_map in untagged.items():
+                    if region_map:
+                        service_block = f"[bright_yellow]{service}[/]:\n"
+                        for region, ids in region_map.items():
+                            if ids:
+                                ids_block = "\n".join(f"[orange1]{res_id}[/]" for res_id in ids)
+                                service_block += f"\n{region}:\n{ids_block}\n"
+                        anomalies.append(service_block)
+                if not any(region_map for region_map in untagged.values()):
+                    anomalies = ["None"]
+            except Exception as e:
+                anomalies = [f"Error: {str(e)}"]
+
+            # Use operational session for EC2 and resource operations
+            stopped = get_stopped_instances(ops_session, regions)
+            stopped_list = [f"{r}:\n[gold1]{nl.join(ids)}[/]" for r, ids in stopped.items()] or ["None"]
+
+            unused_vols = get_unused_volumes(ops_session, regions)
+            vols_list = [f"{r}:\n[dark_orange]{nl.join(ids)}[/]" for r, ids in unused_vols.items()] or ["None"]
+
+            unused_eips = get_unused_eips(ops_session, regions)
+            eips_list = [f"{r}:\n{comma_nl.join(ids)}" for r, ids in unused_eips.items()] or ["None"]
+
+            # Use billing session for budget data
+            budget_data = get_budgets(billing_session)
+            alerts = []
+            for b in budget_data:
+                if b["actual"] > b["limit"]:
+                    alerts.append(f"[red1]{b['name']}[/]: ${b['actual']:.2f} > ${b['limit']:.2f}")
+            if not alerts:
+                alerts = ["✅ No budgets exceeded"]
+
+            # Calculate risk score for PDCA improvement tracking
+            risk_score = _calculate_risk_score(untagged, stopped, unused_vols, unused_eips, budget_data)
+            risk_display = _format_risk_score(risk_score)
+            
+            # Track PDCA metrics
+            pdca_metrics.append({
                 "profile": profile,
                 "account_id": account_id,
-                "untagged_resources": clean_rich_tags("\n".join(anomalies)),
-                "stopped_instances": clean_rich_tags("\n".join(stopped_list)),
-                "unused_volumes": clean_rich_tags("\n".join(vols_list)),
-                "unused_eips": clean_rich_tags("\n".join(eips_list)),
-                "budget_alerts": clean_rich_tags("\n".join(alerts)),
-            }
-        )
+                "risk_score": risk_score,
+                "untagged_count": sum(len(ids) for region_map in untagged.values() for ids in region_map.values()),
+                "stopped_count": sum(len(ids) for ids in stopped.values()),
+                "unused_volumes_count": sum(len(ids) for ids in unused_vols.values()),
+                "unused_eips_count": sum(len(ids) for ids in unused_eips.values()),
+                "budget_overruns": len([b for b in budget_data if b["actual"] > b["limit"]])
+            })
+
+            audit_data.append(
+                {
+                    "profile": profile,
+                    "account_id": account_id,
+                    "untagged_resources": clean_rich_tags("\n".join(anomalies)),
+                    "stopped_instances": clean_rich_tags("\n".join(stopped_list)),
+                    "unused_volumes": clean_rich_tags("\n".join(vols_list)),
+                    "unused_eips": clean_rich_tags("\n".join(eips_list)),
+                    "budget_alerts": clean_rich_tags("\n".join(alerts)),
+                    "risk_score": risk_score,
+                }
+            )
 
-        # Data for JSON which includes raw audit data
-        raw_audit_data.append(
-            {
-                "profile": profile,
-                "account_id": account_id,
-                "untagged_resources": untagged,
-                "stopped_instances": stopped,
-                "unused_volumes": unused_vols,
-                "unused_eips": unused_eips,
-                "budget_alerts": budget_data,
-            }
-        )
+            # Data for JSON which includes raw audit data
+            raw_audit_data.append(
+                {
+                    "profile": profile,
+                    "account_id": account_id,
+                    "untagged_resources": untagged,
+                    "stopped_instances": stopped,
+                    "unused_volumes": unused_vols,
+                    "unused_eips": unused_eips,
+                    "budget_alerts": budget_data,
+                }
+            )
 
-        table.add_row(
-            f"[dark_magenta]{profile}[/]",
-            account_id,
-            "\n".join(anomalies),
-            "\n".join(stopped_list),
-            "\n".join(vols_list),
-            "\n".join(eips_list),
-            "\n".join(alerts),
-        )
+            table.add_row(
+                f"[dark_magenta]{profile}[/]",
+                account_id,
+                "\n".join(anomalies),
+                "\n".join(stopped_list),
+                "\n".join(vols_list),
+                "\n".join(eips_list),
+                "\n".join(alerts),
+                risk_display,
+            )
+            
+            progress.advance(task)
     console.print(table)
-    console.print("[bold bright_cyan]Note: The dashboard only lists untagged EC2, RDS, Lambda, ELBv2.\n[/]")
-
+    
+    # CHECK phase: Display PDCA improvement metrics
+    console.print("\n[bold yellow]📊 CHECK: PDCA Improvement Analysis[/]")
+    _display_pdca_summary(pdca_metrics)
+    
+    console.print("[bold bright_cyan]📝 Note: Dashboard scans EC2, RDS, Lambda, ELBv2 resources across all accessible regions.\n[/]")
+
+    # ACT phase: Export reports with PDCA enhancements
     if args.report_name:  # Ensure report_name is provided for any export
         if args.report_type:
             for report_type in args.report_type:
@@ -184,59 +411,97 @@ def _run_audit_report(profiles_to_use: List[str], args: argparse.Namespace) -> N
                 elif report_type == "pdf":
                     pdf_path = export_audit_report_to_pdf(audit_data, args.report_name, args.dir)
                     if pdf_path:
-                        console.print(f"[bright_green]Successfully exported to PDF format: {pdf_path}[/]")
+                        console.print(f"[bright_green]✅ Successfully exported to PDF format: {pdf_path}[/]")
+        
+        # Generate PDCA improvement report
+        console.print("\n[bold cyan]🎯 ACT: Generating PDCA improvement recommendations...[/]")
+        pdca_path = generate_pdca_improvement_report(pdca_metrics, args.report_name, args.dir)
+        if pdca_path:
+            console.print(f"[bright_green]🚀 PDCA improvement report saved: {pdca_path}[/]")
 
 
 def _run_trend_analysis(profiles_to_use: List[str], args: argparse.Namespace) -> None:
-    """Analyze and display cost trends."""
+    """Analyze and display cost trends with multi-profile support."""
     console.print("[bold bright_cyan]Analysing cost trends...[/]")
+    
+    # Display billing profile information
+    billing_profile = os.getenv('BILLING_PROFILE')
+    if billing_profile:
+        console.print(f"[dim cyan]Using billing profile for cost data: {billing_profile}[/]")
+    
     raw_trend_data = []
-    if args.combine:
-        account_profiles = defaultdict(list)
-        for profile in profiles_to_use:
-            try:
-                session = boto3.Session(profile_name=profile)
-                account_id = get_account_id(session)
-                if account_id:
-                    account_profiles[account_id].append(profile)
-            except Exception as e:
-                console.print(f"[red]Error checking account ID for profile {profile}: {str(e)}[/]")
+    
+    # Enhanced progress tracking for trend analysis
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        TimeElapsedColumn(),
+        console=console,
+        transient=True
+    ) as progress:
+            if args.combine:
+                account_profiles = defaultdict(list)
+                task1 = progress.add_task("Grouping profiles by account", total=len(profiles_to_use))
+                
+                for profile in profiles_to_use:
+                    try:
+                        # Use management session to get account ID
+                        session = _create_management_session(profile)
+                        account_id = get_account_id(session)
+                        if account_id:
+                            account_profiles[account_id].append(profile)
+                    except Exception as e:
+                        console.print(f"[red]Error checking account ID for profile {profile}: {str(e)}[/]")
+                    progress.advance(task1)
+
+                task2 = progress.add_task("Fetching cost trends", total=len(account_profiles))
+                for account_id, profiles in account_profiles.items():
+                    progress.update(task2, description=f"Fetching trends for account: {account_id}")
+                    try:
+                        primary_profile = profiles[0]
+                        # Use billing session for cost trend data
+                        cost_session = _create_cost_session(primary_profile)
+                        cost_data = get_trend(cost_session, args.tag)
+                        trend_data = cost_data.get("monthly_costs")
+
+                        if not trend_data:
+                            console.print(f"[yellow]No trend data available for account {account_id}[/]")
+                            continue
+
+                        profile_list = ", ".join(profiles)
+                        console.print(f"\n[bright_yellow]Account: {account_id} (Profiles: {profile_list})[/]")
+                        raw_trend_data.append(cost_data)
+                        create_trend_bars(trend_data)
+                    except Exception as e:
+                        console.print(f"[red]Error getting trend for account {account_id}: {str(e)}[/]")
+                    progress.advance(task2)
 
-        for account_id, profiles in account_profiles.items():
-            try:
-                primary_profile = profiles[0]
-                session = boto3.Session(profile_name=primary_profile)
-                cost_data = get_trend(session, args.tag)
-                trend_data = cost_data.get("monthly_costs")
-
-                if not trend_data:
-                    console.print(f"[yellow]No trend data available for account {account_id}[/]")
-                    continue
-
-                profile_list = ", ".join(profiles)
-                console.print(f"\n[bright_yellow]Account: {account_id} (Profiles: {profile_list})[/]")
-                raw_trend_data.append(cost_data)
-                create_trend_bars(trend_data)
-            except Exception as e:
-                console.print(f"[red]Error getting trend for account {account_id}: {str(e)}[/]")
-
-    else:
-        for profile in profiles_to_use:
-            try:
-                session = boto3.Session(profile_name=profile)
-                cost_data = get_trend(session, args.tag)
-                trend_data = cost_data.get("monthly_costs")
-                account_id = cost_data.get("account_id", "Unknown")
-
-                if not trend_data:
-                    console.print(f"[yellow]No trend data available for profile {profile}[/]")
-                    continue
-
-                console.print(f"\n[bright_yellow]Account: {account_id} (Profile: {profile})[/]")
-                raw_trend_data.append(cost_data)
-                create_trend_bars(trend_data)
-            except Exception as e:
-                console.print(f"[red]Error getting trend for profile {profile}: {str(e)}[/]")
+            else:
+                task3 = progress.add_task("Fetching individual trends", total=len(profiles_to_use))
+                for profile in profiles_to_use:
+                    progress.update(task3, description=f"Processing profile: {profile}")
+                    try:
+                        # Use billing session for cost data
+                        cost_session = _create_cost_session(profile)
+                        # Use management session for account ID
+                        mgmt_session = _create_management_session(profile)
+                        
+                        cost_data = get_trend(cost_session, args.tag)
+                        trend_data = cost_data.get("monthly_costs")
+                        account_id = get_account_id(mgmt_session) or cost_data.get("account_id", "Unknown")
+
+                        if not trend_data:
+                            console.print(f"[yellow]No trend data available for profile {profile}[/]")
+                            continue
+
+                        console.print(f"\n[bright_yellow]Account: {account_id} (Profile: {profile})[/]")
+                        raw_trend_data.append(cost_data)
+                        create_trend_bars(trend_data)
+                    except Exception as e:
+                        console.print(f"[red]Error getting trend for profile {profile}: {str(e)}[/]")
+                    progress.advance(task3)
 
     if raw_trend_data and args.report_name and args.report_type:
         if "json" in args.report_type:
@@ -246,10 +511,11 @@ def _run_trend_analysis(profiles_to_use: List[str], args: argparse.Namespace) ->
 
 
 def _get_display_table_period_info(profiles_to_use: List[str], time_range: Optional[int]) -> Tuple[str, str, str, str]:
-    """Get period information for the display table."""
+    """Get period information for the display table using appropriate billing profile."""
     if profiles_to_use:
         try:
-            sample_session = boto3.Session(profile_name=profiles_to_use[0])
+            # Use billing session for cost data period information
+            sample_session = _create_cost_session(profiles_to_use[0])
             sample_cost_data = get_cost_data(sample_session, time_range)
             previous_period_name = sample_cost_data.get("previous_period_name", "Last Month Due")
             current_period_name = sample_cost_data.get("current_period_name", "Current Month Cost")
@@ -342,42 +608,219 @@ def _generate_dashboard_data(
     args: argparse.Namespace,
     table: Table,
 ) -> List[ProfileData]:
-    """Fetch, process, and prepare the main dashboard data."""
+    """Fetch, process, and prepare the main dashboard data with multi-profile support."""
     export_data: List[ProfileData] = []
-    if args.combine:
-        account_profiles = defaultdict(list)
-        for profile in profiles_to_use:
-            try:
-                session = boto3.Session(profile_name=profile)
-                current_account_id = get_account_id(session)  # Renamed to avoid conflict
-                if current_account_id:
-                    account_profiles[current_account_id].append(profile)
-                else:
-                    console.log(f"[yellow]Could not determine account ID for profile {profile}[/]")
-            except Exception as e:
-                console.log(f"[bold red]Error checking account ID for profile {profile}: {str(e)}[/]")
-
-        for account_id_key, profiles_list in track(  # Renamed loop variables
-            account_profiles.items(), description="[bright_cyan]Fetching cost data..."
-        ):
-            # account_id_key here is known to be a string because it's a key from account_profiles
-            # where None keys were filtered out when populating it.
-            if len(profiles_list) > 1:
-                profile_data = process_combined_profiles(
-                    account_id_key, profiles_list, user_regions, time_range, args.tag
-                )
+    
+    # Enhanced progress tracking with v2.2.3 style progress bar
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(complete_style="bright_green", finished_style="bright_green"),
+        TaskProgressColumn(),
+        TimeElapsedColumn(),
+        console=console,
+        transient=False  # Keep progress visible
+    ) as progress:
+        
+            if args.combine:
+                account_profiles = defaultdict(list)
+                grouping_task = progress.add_task("Grouping profiles by account", total=len(profiles_to_use))
+                
+                for profile in profiles_to_use:
+                    progress.update(grouping_task, description=f"Checking account for profile: {profile}")
+                    try:
+                        # Use management session for account identification
+                        mgmt_session = _create_management_session(profile)
+                        current_account_id = get_account_id(mgmt_session)
+                        if current_account_id:
+                            account_profiles[current_account_id].append(profile)
+                        else:
+                            console.log(f"[yellow]Could not determine account ID for profile {profile}[/]")
+                    except Exception as e:
+                        console.log(f"[bold red]Error checking account ID for profile {profile}: {str(e)}[/]")
+                    progress.advance(grouping_task)
+
+                # Process combined profiles with enhanced progress tracking
+                processing_task = progress.add_task("Processing account data", total=len(account_profiles))
+                for account_id_key, profiles_list in account_profiles.items():
+                    progress.update(processing_task, description=f"Processing account: {account_id_key}")
+                    
+                    if len(profiles_list) > 1:
+                        profile_data = _process_combined_profiles_enhanced(
+                            account_id_key, profiles_list, user_regions, time_range, args.tag
+                        )
+                    else:
+                        profile_data = _process_single_profile_enhanced(profiles_list[0], user_regions, time_range, args.tag)
+                    export_data.append(profile_data)
+                    add_profile_to_table(table, profile_data)
+                    progress.advance(processing_task)
+                    
             else:
-                profile_data = process_single_profile(profiles_list[0], user_regions, time_range, args.tag)
-            export_data.append(profile_data)
-            add_profile_to_table(table, profile_data)
-    else:
-        for profile in track(profiles_to_use, description="[bright_cyan]Fetching cost data..."):
-            profile_data = process_single_profile(profile, user_regions, time_range, args.tag)
-            export_data.append(profile_data)
-            add_profile_to_table(table, profile_data)
+                # Process individual profiles with enhanced progress tracking
+                individual_task = progress.add_task("Processing individual profiles", total=len(profiles_to_use))
+                for profile in profiles_to_use:
+                    progress.update(individual_task, description=f"Processing profile: {profile}")
+                    profile_data = _process_single_profile_enhanced(profile, user_regions, time_range, args.tag)
+                    export_data.append(profile_data)
+                    add_profile_to_table(table, profile_data)
+                    progress.advance(individual_task)
+                    
     return export_data
 
 
+def _process_single_profile_enhanced(
+    profile: str,
+    user_regions: Optional[List[str]] = None,
+    time_range: Optional[int] = None,
+    tag: Optional[List[str]] = None,
+) -> ProfileData:
+    """
+    Enhanced single profile processing with multi-profile session support.
+    Uses appropriate sessions for different operations: billing, management, operational.
+    """
+    try:
+        # Use billing session for cost data
+        cost_session = _create_cost_session(profile)
+        cost_data = get_cost_data(cost_session, time_range, tag)
+        
+        # Use operational session for EC2 and resource operations
+        ops_session = _create_operational_session(profile)
+        
+        if user_regions:
+            profile_regions = user_regions
+        else:
+            profile_regions = get_accessible_regions(ops_session)
+
+        ec2_data = ec2_summary(ops_session, profile_regions)
+        service_costs, service_cost_data = process_service_costs(cost_data)
+        budget_info = format_budget_info(cost_data["budgets"])
+        account_id = cost_data.get("account_id", "Unknown") or "Unknown"
+        ec2_summary_text = format_ec2_summary(ec2_data)
+        percent_change_in_total_cost = change_in_total_cost(cost_data["current_month"], cost_data["last_month"])
+
+        return {
+            "profile": profile,
+            "account_id": account_id,
+            "last_month": cost_data["last_month"],
+            "current_month": cost_data["current_month"],
+            "service_costs": service_cost_data,
+            "service_costs_formatted": service_costs,
+            "budget_info": budget_info,
+            "ec2_summary": ec2_data,
+            "ec2_summary_formatted": ec2_summary_text,
+            "success": True,
+            "error": None,
+            "current_period_name": cost_data["current_period_name"],
+            "previous_period_name": cost_data["previous_period_name"],
+            "percent_change_in_total_cost": percent_change_in_total_cost,
+        }
+
+    except Exception as e:
+        console.log(f"[red]Error processing profile {profile}: {str(e)}[/]")
+        return {
+            "profile": profile,
+            "account_id": "Error",
+            "last_month": 0,
+            "current_month": 0,
+            "service_costs": [],
+            "service_costs_formatted": [f"Failed to process profile: {str(e)}"],
+            "budget_info": ["N/A"],
+            "ec2_summary": {"N/A": 0},
+            "ec2_summary_formatted": ["Error"],
+            "success": False,
+            "error": str(e),
+            "current_period_name": "Current month",
+            "previous_period_name": "Last month",
+            "percent_change_in_total_cost": None,
+        }
+
+
+def _process_combined_profiles_enhanced(
+    account_id: str,
+    profiles: List[str],
+    user_regions: Optional[List[str]] = None,
+    time_range: Optional[int] = None,
+    tag: Optional[List[str]] = None,
+) -> ProfileData:
+    """
+    Enhanced combined profile processing with multi-profile session support.
+    Aggregates data from multiple profiles in the same AWS account.
+    """
+    try:
+        primary_profile = profiles[0]
+        
+        # Use billing session for cost data aggregation
+        primary_cost_session = _create_cost_session(primary_profile)
+        # Use operational session for resource data
+        primary_ops_session = _create_operational_session(primary_profile)
+        
+        # Get cost data using billing session
+        account_cost_data = get_cost_data(primary_cost_session, time_range, tag)
+        
+        if user_regions:
+            profile_regions = user_regions
+        else:
+            profile_regions = get_accessible_regions(primary_ops_session)
+
+        # Aggregate EC2 data from all profiles using operational sessions
+        combined_ec2_data = defaultdict(int)
+        for profile in profiles:
+            try:
+                profile_ops_session = _create_operational_session(profile)
+                profile_ec2_data = ec2_summary(profile_ops_session, profile_regions)
+                for instance_type, count in profile_ec2_data.items():
+                    combined_ec2_data[instance_type] += count
+            except Exception as e:
+                console.log(f"[yellow]Warning: Could not get EC2 data for profile {profile}: {str(e)}[/]")
+
+        service_costs, service_cost_data = process_service_costs(account_cost_data)
+        budget_info = format_budget_info(account_cost_data["budgets"])
+        ec2_summary_text = format_ec2_summary(dict(combined_ec2_data))
+        percent_change_in_total_cost = change_in_total_cost(
+            account_cost_data["current_month"], account_cost_data["last_month"]
+        )
+        
+        profile_list = ", ".join(profiles)
+        console.log(f"[dim cyan]Combined {len(profiles)} profiles for account {account_id}: {profile_list}[/]")
+
+        return {
+            "profile": f"Combined ({profile_list})",
+            "account_id": account_id,
+            "last_month": account_cost_data["last_month"],
+            "current_month": account_cost_data["current_month"],
+            "service_costs": service_cost_data,
+            "service_costs_formatted": service_costs,
+            "budget_info": budget_info,
+            "ec2_summary": dict(combined_ec2_data),
+            "ec2_summary_formatted": ec2_summary_text,
+            "success": True,
+            "error": None,
+            "current_period_name": account_cost_data["current_period_name"],
+            "previous_period_name": account_cost_data["previous_period_name"],
+            "percent_change_in_total_cost": percent_change_in_total_cost,
+        }
+
+    except Exception as e:
+        console.log(f"[red]Error processing combined profiles for account {account_id}: {str(e)}[/]")
+        profile_list = ", ".join(profiles)
+        return {
+            "profile": f"Combined ({profile_list})",
+            "account_id": account_id,
+            "last_month": 0,
+            "current_month": 0,
+            "service_costs": [],
+            "service_costs_formatted": [f"Failed to process combined profiles: {str(e)}"],
+            "budget_info": ["N/A"],
+            "ec2_summary": {"N/A": 0},
+            "ec2_summary_formatted": ["Error"],
+            "success": False,
+            "error": str(e),
+            "current_period_name": "Current month",
+            "previous_period_name": "Last month",
+            "percent_change_in_total_cost": None,
+        }
+
+
 def _export_dashboard_reports(
     export_data: List[ProfileData],
     args: argparse.Namespace,
@@ -414,9 +857,37 @@ def _export_dashboard_reports(
 
 
 def run_dashboard(args: argparse.Namespace) -> int:
-    """Main function to run the AWS FinOps dashboard."""
+    """Main function to run the AWS FinOps dashboard with multi-profile support."""
     with Status("[bright_cyan]Initialising...", spinner="aesthetic", speed=0.4):
         profiles_to_use, user_regions, time_range = _initialize_profiles(args)
+        
+    # Display multi-profile configuration at startup
+    billing_profile = os.getenv('BILLING_PROFILE')
+    mgmt_profile = os.getenv('MANAGEMENT_PROFILE')
+    ops_profile = os.getenv('CENTRALISED_OPS_PROFILE')
+    
+    if any([billing_profile, mgmt_profile, ops_profile]):
+        console.print("\n[bold bright_cyan]🔧 Multi-Profile Configuration Detected[/]")
+        config_table = Table(
+            title="Profile Configuration",
+            show_header=True,
+            header_style="bold cyan",
+            box=box.SIMPLE,
+            style="dim"
+        )
+        config_table.add_column("Operation Type", style="bold")
+        config_table.add_column("Profile", style="bright_cyan")
+        config_table.add_column("Purpose", style="dim")
+        
+        if billing_profile:
+            config_table.add_row("💰 Billing", billing_profile, "Cost Explorer & Budget API access")
+        if mgmt_profile:
+            config_table.add_row("🏛️ Management", mgmt_profile, "Account ID & Organizations operations")
+        if ops_profile:
+            config_table.add_row("⚙️ Operational", ops_profile, "EC2, S3, and resource discovery")
+            
+        console.print(config_table)
+        console.print("[dim]Fallback: Using profile-specific sessions when env vars not set[/]\n")
 
     if args.audit:
         _run_audit_report(profiles_to_use, args)