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

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__)
 
@@ -62,12 +63,13 @@ def _set_global_organizations_cache(data):
     accounts_count = len(data.get('accounts', {}).get('discovered_accounts', [])) if data else 0
     console.print(f"[green]✅ Global Organizations cache: {accounts_count} accounts (TTL: {_GLOBAL_ORGS_CACHE['ttl_minutes']}min)[/green]")
 
-# Enterprise 4-Profile AWS SSO Architecture (Proven FinOps Success Pattern)
+# Universal AWS Environment Profile Support (Compatible with ANY AWS Setup)
+import os
 ENTERPRISE_PROFILES = {
-    "BILLING_PROFILE": "ams-admin-Billing-ReadOnlyAccess-909135376185",  # Cost Explorer access
-    "MANAGEMENT_PROFILE": "ams-admin-ReadOnlyAccess-909135376185",  # Organizations access
-    "CENTRALISED_OPS_PROFILE": "ams-centralised-ops-ReadOnlyAccess-335083429030",  # Operations access
-    "SINGLE_ACCOUNT_PROFILE": "ams-shared-services-non-prod-ReadOnlyAccess-499201730520",  # Single account ops
+    "BILLING_PROFILE": os.getenv("BILLING_PROFILE", "default"),  # Universal compatibility
+    "MANAGEMENT_PROFILE": os.getenv("MANAGEMENT_PROFILE", "default"),  # Works with any profile
+    "CENTRALISED_OPS_PROFILE": os.getenv("CENTRALISED_OPS_PROFILE", "default"),  # Universal operations
+    "SINGLE_ACCOUNT_PROFILE": os.getenv("SINGLE_AWS_PROFILE", "default"),  # Universal single account
 }
 
 
@@ -407,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",
@@ -419,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()
@@ -471,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)
 
@@ -587,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
@@ -1290,10 +1375,10 @@ async def run_enhanced_organizations_discovery(
     return org_results
 
 
-# Legacy compatibility function
+# Legacy compatibility function with universal defaults
 async def run_organizations_discovery(
-    management_profile: str = "ams-admin-ReadOnlyAccess-909135376185",
-    billing_profile: str = "ams-admin-Billing-ReadOnlyAccess-909135376185",
+    management_profile: str = None,
+    billing_profile: str = None,
 ) -> Dict:
     """
     Legacy compatibility function - redirects to enhanced discovery
@@ -1303,6 +1388,10 @@ async def run_organizations_discovery(
     """
     console.print("[yellow]ℹ️  Using enhanced discovery engine for improved reliability and performance[/yellow]")
 
+    # Apply universal environment defaults
+    management_profile = management_profile or os.getenv("MANAGEMENT_PROFILE", "default-management-profile")
+    billing_profile = billing_profile or os.getenv("BILLING_PROFILE", "default-billing-profile")
+
     return await run_enhanced_organizations_discovery(
         management_profile=management_profile,
         billing_profile=billing_profile,

runbooks/inventory/unified_validation_engine.py

@@ -564,21 +564,8 @@ class UnifiedValidationEngine:
         total_weighted_accuracy = 0.0
         total_weight = 0.0
         
-        # Resource weighting for enterprise accuracy calculation
-        resource_weights = {
-            "ec2": 3.0,      # High weight - critical compute resources
-            "vpc": 2.5,      # High weight - foundational networking  
-            "s3": 2.0,       # Medium-high weight - core storage
-            "rds": 2.0,      # Medium-high weight - critical databases
-            "iam": 2.0,      # Medium-high weight - security foundation
-            "lambda": 1.5,   # Medium weight - serverless compute
-            "elbv2": 1.5,    # Medium weight - load balancing
-            "cloudformation": 1.0,  # Medium weight - infrastructure management
-            "route53": 1.0,  # Medium weight - DNS services
-            "sns": 0.8,      # Lower weight - messaging
-            "eni": 0.8,      # Lower weight - network interfaces
-            "ebs": 0.8,      # Lower weight - block storage
-        }
+        # Dynamic resource weighting based on actual discovery for universal compatibility
+        resource_weights = self._calculate_dynamic_resource_weights(resource_counts)
         
         for resource_type in self.supported_resources.keys():
             runbooks_count = resource_counts["runbooks"].get(resource_type, 0)