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

runbooks/finops/finops_scenarios.py

@@ -1,18 +1,18 @@
 """
-FinOps Business Scenarios - Manager Priority Cost Optimization Framework
+FinOps Business Scenarios - Dynamic Business Case Framework
 
-Strategic Achievement: $132,720+ annual savings (380-757% above targets)
-- FinOps-24: WorkSpaces cleanup ($13,020 annual, 104% of target)
-- FinOps-23: RDS snapshots optimization ($119,700 annual, 498% of target) 
-- FinOps-25: Commvault EC2 investigation framework (methodology established)
+Strategic Achievement: Enterprise business case management with configurable scenarios
+- Dynamic scenario configuration with environment variable overrides  
+- Business-focused naming conventions replacing hardcoded JIRA references
+- Scalable template system for unlimited business case expansion
 
 This module provides business-oriented wrapper functions for executive presentations
 calling proven technical implementations from src/runbooks/remediation/ modules.
 
 Strategic Alignment:
-- "Do one thing and do it well": Business wrappers focusing on executive insights
-- "Move Fast, But Not So Fast We Crash": Proven technical implementations underneath
-- Enterprise FAANG SDLC: Evidence-based cost optimization with audit trails
+- "Do one thing and do it well": Dynamic configuration management with enterprise templates
+- "Move Fast, But Not So Fast We Crash": Proven technical implementations with configurable business cases
+- Enterprise FAANG SDLC: Evidence-based cost optimization with reusable template framework
 """
 
 import asyncio
@@ -30,6 +30,10 @@ from ..common.rich_utils import (
 )
 from ..remediation import workspaces_list, rds_snapshot_list
 from . import commvault_ec2_analysis
+from .business_case_config import (
+    get_business_case_config, get_scenario_display_name, get_scenario_savings_range,
+    format_business_achievement, migrate_legacy_scenario_reference
+)
 
 logger = logging.getLogger(__name__)
 
@@ -55,9 +59,9 @@ def create_business_scenarios_validated(profile_name: Optional[str] = None) -> D
         commvault_data = scenarios_analyzer._get_real_commvault_data()
         
         scenarios = {
-            'FinOps-24_WorkSpaces': workspaces_data,
-            'FinOps-23_RDS_Snapshots': rds_data,
-            'FinOps-25_Commvault': commvault_data,
+            'workspaces': workspaces_data,
+            'rds_snapshots': rds_data, 
+            'backup_investigation': commvault_data,
             'metadata': {
                 'generated_at': datetime.now().isoformat(),
                 'data_source': 'Real AWS APIs via runbooks',
@@ -70,29 +74,32 @@ def create_business_scenarios_validated(profile_name: Optional[str] = None) -> D
         
     except Exception as e:
         logger.error(f"Error creating validated scenarios: {e}")
-        # Return fallback business scenarios with manager's validated achievements
+        # Return fallback business scenarios using dynamic configuration
+        config = get_business_case_config()
+        workspaces_scenario = config.get_scenario('workspaces')
+        rds_scenario = config.get_scenario('rds-snapshots')
+        backup_scenario = config.get_scenario('backup-investigation')
+        
         return {
-            'FinOps-24_WorkSpaces': {
-                'title': 'WorkSpaces Cleanup - Zero Usage Detection',
-                'validated_savings': 13020,
-                'achievement_rate': 104,
-                'risk_level': 'Low'
+            'workspaces': {
+                'title': workspaces_scenario.display_name if workspaces_scenario else 'WorkSpaces Resource Optimization',
+                'savings_range': workspaces_scenario.savings_range_display if workspaces_scenario else '$12K-15K/year',
+                'risk_level': workspaces_scenario.risk_level if workspaces_scenario else 'Low'
             },
-            'FinOps-23_RDS_Snapshots': {
-                'title': 'RDS Manual Snapshots Cleanup',
-                'validated_savings': 119700,
-                'achievement_rate': 498,
-                'risk_level': 'Medium'
+            'rds_snapshots': {
+                'title': rds_scenario.display_name if rds_scenario else 'RDS Storage Optimization',
+                'savings_range': rds_scenario.savings_range_display if rds_scenario else '$5K-24K/year',
+                'risk_level': rds_scenario.risk_level if rds_scenario else 'Medium'
             },
-            'FinOps-25_Commvault': {
-                'title': 'Commvault Account Investigation',
+            'backup_investigation': {
+                'title': backup_scenario.display_name if backup_scenario else 'Backup Infrastructure Analysis',
                 'framework_status': 'Investigation Ready',
-                'risk_level': 'Medium'
+                'risk_level': backup_scenario.risk_level if backup_scenario else 'Medium'
             },
             'metadata': {
                 'generated_at': datetime.now().isoformat(),
-                'data_source': 'Manager scenarios fallback - $132,720+ validated',
-                'validation_method': 'Business case validation',
+                'data_source': 'Dynamic business case configuration',
+                'validation_method': 'Template-based business scenarios',
                 'version': '0.9.5'
             }
         }

runbooks/finops/notebook_utils.py

@@ -591,6 +591,6 @@ if __name__ == '__main__':
             config=config,
             optimization_focus=OptimizationCategory.COST_OPTIMIZATION
         )
-        print(f"Dashboard created with {len(result.export_files)} export files")
+        console.print(f"Dashboard created with {len(result.export_files)} export files")
     
     asyncio.run(test_dashboard())

runbooks/finops/schemas.py

@@ -26,7 +26,7 @@ from typing import Dict, List, Optional, Union, Any, Literal
 from enum import Enum
 import re
 
-from pydantic import BaseModel, Field, validator, root_validator, ConfigDict
+from pydantic import BaseModel, Field, field_validator, model_validator, ConfigDict
 from pydantic.types import UUID4, PositiveFloat, NonNegativeFloat
 
 
@@ -106,7 +106,8 @@ class CostBreakdown(BaseSchema):
     percentage_of_total: float = Field(..., ge=0, le=100)
     resource_count: int = Field(..., ge=0)
     
-    @validator('service_name')
+    @field_validator('service_name')
+    @classmethod
     def validate_service_name(cls, v):
         """Validate AWS service names."""
         # Common AWS service patterns
@@ -130,14 +131,15 @@ class CostBreakdown(BaseSchema):
         
         return v.strip()
     
-    @validator('annual_cost')
-    def validate_annual_cost_consistency(cls, v, values):
+    @field_validator('annual_cost')
+    @classmethod
+    def validate_annual_cost_consistency(cls, v, info):
         """Ensure annual cost is approximately 12x monthly cost."""
-        if 'monthly_cost' in values:
-            expected_annual = values['monthly_cost'] * 12
+        if 'monthly_cost' in info.data:
+            expected_annual = info.data['monthly_cost'] * 12
             # Allow 1% tolerance for rounding differences
             if abs(v - expected_annual) > (expected_annual * 0.01):
-                raise ValueError(f'Annual cost {v} should be approximately 12x monthly cost {values["monthly_cost"]}')
+                raise ValueError(f'Annual cost {v} should be approximately 12x monthly cost {info.data["monthly_cost"]}')
         return v
 
 
@@ -169,7 +171,8 @@ class OptimizationScenario(BaseSchema):
     validation_timestamp: Optional[datetime] = Field(None)
     mcp_variance_percent: Optional[float] = Field(None, ge=0, le=100)
     
-    @validator('scenario_name')
+    @field_validator('scenario_name')
+    @classmethod
     def validate_scenario_name(cls, v):
         """Validate scenario naming conventions."""
         # Ensure professional naming
@@ -177,27 +180,30 @@ class OptimizationScenario(BaseSchema):
             raise ValueError('Scenario name must start with capital letter and contain only letters, numbers, spaces, hyphens, and parentheses')
         return v.strip()
     
-    @validator('annual_savings')
-    def validate_annual_savings_consistency(cls, v, values):
+    @field_validator('annual_savings')
+    @classmethod
+    def validate_annual_savings_consistency(cls, v, info):
         """Ensure annual savings consistency with monthly savings."""
-        if 'monthly_savings' in values:
-            expected_annual = values['monthly_savings'] * 12
+        if 'monthly_savings' in info.data:
+            expected_annual = info.data['monthly_savings'] * 12
             if abs(v - expected_annual) > (expected_annual * 0.01):  # 1% tolerance
-                raise ValueError(f'Annual savings {v} should be approximately 12x monthly savings {values["monthly_savings"]}')
+                raise ValueError(f'Annual savings {v} should be approximately 12x monthly savings {info.data["monthly_savings"]}')
         return v
     
-    @validator('payback_period_months')
-    def calculate_payback_period(cls, v, values):
+    @field_validator('payback_period_months')
+    @classmethod
+    def calculate_payback_period(cls, v, info):
         """Calculate payback period if not provided."""
-        if v is None and 'implementation_cost' in values and 'monthly_savings' in values:
-            impl_cost = values['implementation_cost']
-            monthly_savings = values['monthly_savings']
+        if v is None and 'implementation_cost' in info.data and 'monthly_savings' in info.data:
+            impl_cost = info.data['implementation_cost']
+            monthly_savings = info.data['monthly_savings']
             if monthly_savings > 0:
                 calculated_payback = impl_cost / monthly_savings
                 return round(calculated_payback, 1)
         return v
     
-    @validator('affected_services')
+    @field_validator('affected_services')
+    @classmethod
     def validate_aws_services(cls, v):
         """Validate AWS service names in affected services."""
         common_services = {
@@ -215,7 +221,8 @@ class OptimizationScenario(BaseSchema):
         
         return v
     
-    @validator('affected_accounts')
+    @field_validator('affected_accounts')
+    @classmethod
     def validate_account_ids(cls, v):
         """Validate AWS account ID format."""
         account_pattern = r'^\d{12}$|^[\w\-\.]{1,50}$'  # 12-digit ID or account name
@@ -270,47 +277,50 @@ class CostOptimizationResult(BaseSchema):
         default=[ExportFormat.JSON, ExportFormat.CSV, ExportFormat.PDF]
     )
     
-    @validator('total_potential_annual_savings')
-    def validate_annual_consistency(cls, v, values):
+    @field_validator('total_potential_annual_savings')
+    @classmethod
+    def validate_annual_consistency(cls, v, info):
         """Validate annual savings consistency."""
-        if 'total_potential_monthly_savings' in values:
-            expected = values['total_potential_monthly_savings'] * 12
+        if 'total_potential_monthly_savings' in info.data:
+            expected = info.data['total_potential_monthly_savings'] * 12
             if abs(v - expected) > (expected * 0.01):
                 raise ValueError('Annual savings must be approximately 12x monthly savings')
         return v
     
-    @validator('savings_percentage')
-    def calculate_savings_percentage(cls, v, values):
+    @field_validator('savings_percentage')
+    @classmethod
+    def calculate_savings_percentage(cls, v, info):
         """Validate or calculate savings percentage."""
-        if 'current_monthly_spend' in values and 'total_potential_monthly_savings' in values:
-            current_spend = values['current_monthly_spend']
+        if 'current_monthly_spend' in info.data and 'total_potential_monthly_savings' in info.data:
+            current_spend = info.data['current_monthly_spend']
             if current_spend > 0:
-                calculated = (values['total_potential_monthly_savings'] / current_spend) * 100
+                calculated = (info.data['total_potential_monthly_savings'] / current_spend) * 100
                 if abs(v - calculated) > 0.1:  # 0.1% tolerance
                     raise ValueError(f'Savings percentage {v}% inconsistent with calculated {calculated:.1f}%')
         return v
     
-    @validator('total_scenarios')
-    def validate_scenario_count(cls, v, values):
+    @field_validator('total_scenarios')
+    @classmethod
+    def validate_scenario_count(cls, v, info):
         """Ensure scenario count matches actual scenarios."""
-        if 'optimization_scenarios' in values:
-            actual_count = len(values['optimization_scenarios'])
+        if 'optimization_scenarios' in info.data:
+            actual_count = len(info.data['optimization_scenarios'])
             if v != actual_count:
                 raise ValueError(f'Total scenarios {v} does not match actual scenarios count {actual_count}')
         return v
     
-    @root_validator
-    def validate_complexity_distribution(cls, values):
+    @model_validator(mode='after')
+    def validate_complexity_distribution(self):
         """Validate complexity scenario counts."""
-        scenarios = values.get('optimization_scenarios', [])
+        scenarios = self.optimization_scenarios or []
         if scenarios:
             low_count = sum(1 for s in scenarios if s.complexity == ComplexityLevel.LOW)
             medium_count = sum(1 for s in scenarios if s.complexity == ComplexityLevel.MEDIUM)
             high_count = sum(1 for s in scenarios if s.complexity == ComplexityLevel.HIGH)
             
-            expected_low = values.get('low_complexity_scenarios', 0)
-            expected_medium = values.get('medium_complexity_scenarios', 0)
-            expected_high = values.get('high_complexity_scenarios', 0)
+            expected_low = self.low_complexity_scenarios or 0
+            expected_medium = self.medium_complexity_scenarios or 0
+            expected_high = self.high_complexity_scenarios or 0
             
             if (low_count != expected_low or 
                 medium_count != expected_medium or 
@@ -320,7 +330,7 @@ class CostOptimizationResult(BaseSchema):
                     f'actual L:{low_count} M:{medium_count} H:{high_count}'
                 )
         
-        return values
+        return self
 
 
 # Business Interface Schemas
@@ -350,7 +360,8 @@ class ExecutiveSummary(BaseSchema):
     data_validation_status: ValidationStatus = Field(...)
     last_validated: datetime = Field(...)
     
-    @validator('roi_percentage')
+    @field_validator('roi_percentage')
+    @classmethod
     def validate_reasonable_roi(cls, v):
         """Ensure ROI is reasonable for executive presentation."""
         if v > 1000:  # 1000% ROI
@@ -377,12 +388,13 @@ class MCPValidationResult(BaseSchema):
     mcp_source: str = Field(..., min_length=1)
     response_time_seconds: Optional[PositiveFloat] = Field(None, le=300)  # 5 minute timeout
     
-    @validator('variance_percent')
-    def calculate_variance_percent(cls, v, values):
+    @field_validator('variance_percent')
+    @classmethod
+    def calculate_variance_percent(cls, v, info):
         """Calculate and validate variance percentage."""
-        if 'notebook_value' in values and 'mcp_value' in values:
-            notebook_val = values['notebook_value']
-            mcp_val = values['mcp_value']
+        if 'notebook_value' in info.data and 'mcp_value' in info.data:
+            notebook_val = info.data['notebook_value']
+            mcp_val = info.data['mcp_value']
             
             if notebook_val > 0:
                 calculated = abs((notebook_val - mcp_val) / notebook_val) * 100
@@ -441,22 +453,24 @@ class ComprehensiveTestSuite(BaseSchema):
     meets_production_criteria: bool = Field(...)
     quality_score: float = Field(..., ge=0, le=100)
     
-    @validator('passed_tests')
-    def validate_test_counts(cls, v, values):
+    @field_validator('passed_tests')
+    @classmethod
+    def validate_test_counts(cls, v, info):
         """Ensure test counts are consistent."""
-        if 'failed_tests' in values and 'skipped_tests' in values and 'total_tests' in values:
-            calculated_total = v + values['failed_tests'] + values['skipped_tests']
-            if calculated_total != values['total_tests']:
-                raise ValueError(f'Test counts inconsistent: {calculated_total} ≠ {values["total_tests"]}')
+        if 'failed_tests' in info.data and 'skipped_tests' in info.data and 'total_tests' in info.data:
+            calculated_total = v + info.data['failed_tests'] + info.data['skipped_tests']
+            if calculated_total != info.data['total_tests']:
+                raise ValueError(f'Test counts inconsistent: {calculated_total} ≠ {info.data["total_tests"]}')
         return v
     
-    @validator('pass_rate_percent')
-    def calculate_pass_rate(cls, v, values):
+    @field_validator('pass_rate_percent')
+    @classmethod
+    def calculate_pass_rate(cls, v, info):
         """Calculate and validate pass rate."""
-        if 'passed_tests' in values and 'total_tests' in values:
-            total = values['total_tests']
+        if 'passed_tests' in info.data and 'total_tests' in info.data:
+            total = info.data['total_tests']
             if total > 0:
-                calculated = (values['passed_tests'] / total) * 100
+                calculated = (info.data['passed_tests'] / total) * 100
                 if abs(v - calculated) > 0.01:
                     raise ValueError(f'Pass rate {v}% inconsistent with calculated {calculated:.2f}%')
         return v
@@ -480,7 +494,8 @@ class ExportMetadata(BaseSchema):
     export_validated: bool = Field(...)
     validation_errors: List[str] = Field(default_factory=list)
     
-    @validator('file_path')
+    @field_validator('file_path')
+    @classmethod
     def validate_file_path(cls, v):
         """Validate file path format."""
         # Basic path validation

runbooks/finops/single_dashboard.py

@@ -346,18 +346,34 @@ class SingleAccountDashboard:
             # Integrate quarterly data into trend data structure
             corrected_trend_data["quarterly_costs_by_service"] = quarterly_costs
             
-            # Log the trend analysis context for transparency
+            # Enhanced trend analysis context with MCP validation awareness
             if "period_metadata" in corrected_trend_data:
                 metadata = corrected_trend_data["period_metadata"]
                 current_days = metadata.get("current_days", 0)
                 previous_days = metadata.get("previous_days", 0)
+                days_difference = metadata.get("days_difference", abs(current_days - previous_days))
                 reliability = metadata.get("trend_reliability", "unknown")
+                alignment_strategy = metadata.get("period_alignment_strategy", "standard")
                 
+                # ENHANCED LOGIC: Reduce warnings when using intelligent period alignment
                 if metadata.get("is_partial_comparison", False):
-                    print_warning(f"Partial period comparison detected: {current_days} vs {previous_days} days")
-                    print_info(f"Trend reliability: {reliability}")
+                    if alignment_strategy == "equal_days":
+                        # Equal-day comparison reduces the severity of partial period concerns
+                        print_info(f"🔄 Enhanced period alignment: {current_days} vs {previous_days} days (equal-day strategy)")
+                        if reliability in ["high", "medium_with_validation_support"]:
+                            print_success(f"✅ Trend reliability: {reliability} (enhanced alignment)")
+                        else:
+                            print_info(f"Trend reliability: {reliability}")
+                    else:
+                        # Standard partial period warning for traditional comparisons
+                        print_warning(f"⚠️ Partial period comparison: {current_days} vs {previous_days} days")
+                        print_info(f"Trend reliability: {reliability}")
+                        
+                    # Add context for very small differences
+                    if days_difference <= 5:
+                        print_info(f"💡 Small period difference ({days_difference} days) - trends should be reliable")
                 else:
-                    print_success(f"Equal period comparison: {current_days} vs {previous_days} days")
+                    print_success(f"✅ Equal period comparison: {current_days} vs {previous_days} days")
             
             return corrected_trend_data
             

runbooks/finops/vpc_cleanup_exporter.py

@@ -16,6 +16,7 @@ from datetime import datetime
 from typing import Any, Dict, List
 
 from .markdown_exporter import MarkdownExporter
+from runbooks.common.rich_utils import console
 
 
 def _format_tags_for_display(tags_dict: Dict[str, str]) -> str:
@@ -76,7 +77,7 @@ def export_vpc_cleanup_results(vpc_result: Any, export_formats: List[str], outpu
             )
             results['markdown'] = markdown_filename
         except Exception as e:
-            print(f"Warning: Markdown export failed: {e}")
+            console.print(f"[yellow]Warning: Markdown export failed: {e}[/yellow]")
             results['markdown'] = None
     
     # Real implementations for other formats

runbooks/inventory/models/account.py

@@ -10,7 +10,7 @@ from datetime import datetime
 from enum import Enum
 from typing import Dict, List, Optional, Set
 
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field, field_validator
 
 
 class AccountStatus(str, Enum):
@@ -100,14 +100,16 @@ class AWSAccount(BaseModel):
         extra = "forbid"
         json_encoders = {datetime: lambda v: v.isoformat(), set: lambda v: list(v)}
 
-    @validator("account_id")
+    @field_validator("account_id")
+    @classmethod
     def validate_account_id(cls, v):
         """Validate account ID format."""
         if not v.isdigit() or len(v) != 12:
             raise ValueError("Account ID must be exactly 12 digits")
         return v
 
-    @validator("available_regions")
+    @field_validator("available_regions")
+    @classmethod
     def validate_regions(cls, v):
         """Validate region format."""
         valid_region_pattern = r"^[a-z]{2,3}-[a-z]+-\d+$"

runbooks/inventory/models/inventory.py

@@ -10,7 +10,7 @@ from datetime import datetime, timedelta
 from enum import Enum
 from typing import Any, Dict, List, Optional, Set
 
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field, field_validator
 
 from runbooks.inventory.models.account import AWSAccount
 from runbooks.inventory.models.resource import AWSResource

runbooks/inventory/models/resource.py

@@ -10,7 +10,7 @@ from datetime import datetime
 from enum import Enum
 from typing import Any, Dict, List, Optional, Union
 
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field, field_validator
 
 
 class ResourceState(str, Enum):
@@ -178,14 +178,16 @@ class AWSResource(BaseModel):
         use_enum_values = True
         json_encoders = {datetime: lambda v: v.isoformat() if v else None}
 
-    @validator("resource_arn")
+    @field_validator("resource_arn")
+    @classmethod
     def validate_arn_format(cls, v):
         """Validate ARN format if provided."""
         if v and not v.startswith("arn:aws:"):
             raise ValueError('ARN must start with "arn:aws:"')
         return v
 
-    @validator("account_id")
+    @field_validator("account_id")
+    @classmethod
     def validate_account_id(cls, v):
         """Validate account ID format."""
         if not v.isdigit() or len(v) != 12:

runbooks/inventory/organizations_discovery.py

@@ -34,6 +34,7 @@ from rich.table import Table
 console = Console()
 
 from ..utils.logger import configure_logger
+from ..common.performance_optimization_engine import get_optimization_engine
 
 logger = configure_logger(__name__)
 
@@ -408,11 +409,25 @@ class EnhancedOrganizationsDiscovery:
         Discover complete organization structure with performance benchmarking
 
         Enhanced with:
-        - Performance benchmark tracking (<45s target)
+        - Performance benchmark tracking (<30s target optimized from 52.3s)
         - Rich console progress monitoring
         - Comprehensive error recovery
         - Multi-profile fallback support
+        - Performance optimization engine integration
         """
+        # Get performance optimization engine
+        optimization_engine = get_optimization_engine(
+            max_workers=self.max_workers,
+            cache_ttl_minutes=30,
+            memory_limit_mb=2048
+        )
+        
+        # Use optimized discovery with performance monitoring
+        with optimization_engine.optimize_operation("organization_structure_discovery", self.performance_target_seconds):
+            return await self._discover_organization_structure_optimized(optimization_engine)
+
+    async def _discover_organization_structure_optimized(self, optimization_engine) -> Dict:
+        """Optimized organization structure discovery implementation"""
         # Start performance benchmark
         self.current_benchmark = PerformanceBenchmark(
             operation_name="organization_structure_discovery",
@@ -420,7 +435,7 @@ class EnhancedOrganizationsDiscovery:
             target_seconds=self.performance_target_seconds,
         )
 
-        logger.info("🏢 Starting enhanced organization structure discovery with performance tracking")
+        logger.info("🏢 Starting optimized organization structure discovery with SRE automation patterns")
         
         # Check global cache first to prevent duplicate calls
         cached_result = _get_global_organizations_cache()
@@ -472,9 +487,9 @@ class EnhancedOrganizationsDiscovery:
                 ) as progress:
                     discovery_task = progress.add_task("Discovering organization structure...", total=5)
 
-                    # Discover accounts
-                    progress.update(discovery_task, description="Discovering accounts...")
-                    accounts_result = await self._discover_accounts()
+                    # Discover accounts using optimization engine
+                    progress.update(discovery_task, description="Discovering accounts (optimized)...")
+                    accounts_result = await self._discover_accounts_optimized(optimization_engine)
                     self.current_benchmark.accounts_processed = accounts_result.get("total_accounts", 0)
                     progress.advance(discovery_task)
 
@@ -588,6 +603,75 @@ class EnhancedOrganizationsDiscovery:
                     "performance_benchmark": performance_benchmark_dict,
                 }
 
+    async def _discover_accounts_optimized(self, optimization_engine) -> Dict:
+        """
+        Optimized account discovery using performance optimization engine
+        
+        Addresses: Organization Discovery Performance (52.3s -> <30s target)
+        Features:
+        - Intelligent caching with TTL management
+        - Parallel account processing with batch optimization
+        - Connection pooling for Organizations API
+        - Memory-efficient processing
+        """
+        logger.info("📊 Discovering organization accounts with SRE optimization patterns")
+        
+        # Use optimization engine for discovery
+        optimized_discover_accounts = optimization_engine.optimize_organization_discovery(
+            management_profile=self.management_profile,
+            use_parallel_processing=True,
+            batch_size=20
+        )
+        
+        # Execute optimized discovery
+        try:
+            result = optimized_discover_accounts()
+            
+            # Convert to expected format
+            accounts_data = result.get('accounts', [])
+            
+            # Create AWSAccount objects for compatibility
+            for account_data in accounts_data:
+                account = AWSAccount(
+                    account_id=account_data["Id"],
+                    name=account_data["Name"], 
+                    email=account_data["Email"],
+                    status=account_data["Status"],
+                    joined_method=account_data["JoinedMethod"],
+                    joined_timestamp=account_data.get("JoinedTimestamp"),
+                    tags=account_data.get("Tags", {})
+                )
+                self.accounts_cache[account.account_id] = account
+            
+            # Update metrics
+            self.discovery_metrics["accounts_discovered"] = len(accounts_data)
+            
+            # Enhanced account categorization
+            active_accounts = [a for a in accounts_data if a.get("Status") == "ACTIVE"]
+            suspended_accounts = [a for a in accounts_data if a.get("Status") == "SUSPENDED"] 
+            closed_accounts = [a for a in accounts_data if a.get("Status") == "CLOSED"]
+            
+            optimization_info = result.get('optimizations_applied', [])
+            logger.info(f"✅ Optimized discovery: {len(accounts_data)} accounts ({len(active_accounts)} active)")
+            logger.info(f"🚀 Optimizations applied: {', '.join(optimization_info)}")
+            
+            return {
+                "total_accounts": len(accounts_data),
+                "active_accounts": len(active_accounts),
+                "suspended_accounts": len(suspended_accounts),
+                "closed_accounts": len(closed_accounts),
+                "accounts": [asdict(account) for account_id, account in self.accounts_cache.items()],
+                "discovery_method": "optimized_organizations_api",
+                "profile_used": "management",
+                "optimizations_applied": optimization_info,
+            }
+            
+        except Exception as e:
+            logger.error(f"Optimized account discovery failed: {e}")
+            # Fallback to original method
+            logger.info("Falling back to original discovery method...")
+            return await self._discover_accounts()
+
     async def _discover_accounts(self) -> Dict:
         """
         Discover all accounts in the organization using 4-profile architecture