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

runbooks/inventory/core/collector.py

@@ -1,23 +1,31 @@
 """
-Enhanced Inventory collector for AWS resources with 4-Profile Architecture.
-
-This module provides the main inventory collection orchestration,
-leveraging existing inventory scripts and extending them with
-cloud foundations best practices.
-
-ENHANCED v0.8.0: 4-Profile AWS SSO Architecture & Performance Benchmarking
-- Proven FinOps success patterns: 61 accounts, $474,406 validated
-- Performance targets: <45s for inventory discovery operations
-- Comprehensive error handling with profile fallbacks
-- Enterprise-grade reliability and monitoring
-- Phase 4: MCP Integration Framework & Cross-Module Data Flow
+Enhanced Inventory Collector - AWS Resource Discovery with Enterprise Profile Management.
+
+Strategic Alignment:
+- "Do one thing and do it well" - Focused inventory collection with proven patterns
+- "Move Fast, But Not So Fast We Crash" - Performance with enterprise reliability
+
+Core Capabilities:
+- Single profile architecture: --profile override pattern for all operations
+- Multi-account discovery leveraging existing enterprise infrastructure
+- Performance targets: <45s inventory operations across 60+ accounts
+- MCP integration for real-time AWS API validation and accuracy
+- Rich CLI output following enterprise UX standards
+
+Business Value:
+- Enables systematic AWS resource governance across enterprise landing zones
+- Provides foundation for cost optimization and security compliance initiatives
+- Supports terraform IaC validation and configuration drift detection
 """
 
 import asyncio
+import json
+import os
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional, Set
 
+import boto3
 from loguru import logger
 
 from runbooks.base import CloudFoundationsBase, ProgressTracker
@@ -34,12 +42,13 @@ try:
     ENHANCED_PROFILES_AVAILABLE = True
 except ImportError:
     ENHANCED_PROFILES_AVAILABLE = False
-    # Fallback profile definitions
+    # Fallback profile definitions with universal environment support
+    import os
     ENTERPRISE_PROFILES = {
-        "BILLING_PROFILE": "ams-admin-Billing-ReadOnlyAccess-909135376185",
-        "MANAGEMENT_PROFILE": "ams-admin-ReadOnlyAccess-909135376185",
-        "CENTRALISED_OPS_PROFILE": "ams-centralised-ops-ReadOnlyAccess-335083429030",
-        "SINGLE_ACCOUNT_PROFILE": "ams-shared-services-non-prod-ReadOnlyAccess-499201730520",
+        "BILLING_PROFILE": os.getenv("BILLING_PROFILE", "default-billing-profile"),
+        "MANAGEMENT_PROFILE": os.getenv("MANAGEMENT_PROFILE", "default-management-profile"),
+        "CENTRALISED_OPS_PROFILE": os.getenv("CENTRALISED_OPS_PROFILE", "default-ops-profile"),
+        "SINGLE_ACCOUNT_PROFILE": os.getenv("SINGLE_AWS_PROFILE", "default-single-profile"),
     }
 
 
@@ -87,8 +96,8 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         self.benchmarks = []
         self.current_benchmark = None
 
-        # Enhanced profile management
-        self.available_profiles = self._initialize_profile_architecture()
+        # Simplified profile management: single profile for all operations
+        self.active_profile = self._initialize_profile_architecture()
 
         # Resource collectors
         self._resource_collectors = self._initialize_collectors()
@@ -97,9 +106,20 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         self.mcp_integrator = EnterpriseMCPIntegrator(profile)
         self.cross_module_integrator = EnterpriseCrossModuleIntegrator(profile)
         self.enable_mcp_validation = True
+        
+        # Initialize inventory-specific MCP validator
+        self.inventory_mcp_validator = None
+        try:
+            from ..mcp_inventory_validator import create_inventory_mcp_validator
+            # Use profiles that would work for inventory operations
+            validator_profiles = [self.active_profile]
+            self.inventory_mcp_validator = create_inventory_mcp_validator(validator_profiles)
+            print_info("Inventory MCP validator initialized for real-time validation")
+        except Exception as e:
+            print_warning(f"Inventory MCP validator initialization failed: {str(e)[:50]}...")
 
         print_info("Enhanced inventory collector with MCP integration initialized")
-        logger.info(f"Enhanced inventory collector initialized with {len(self.available_profiles)} profiles")
+        logger.info(f"Enhanced inventory collector initialized with active profile: {self.active_profile}")
 
     def run(self, **kwargs) -> Dict[str, Any]:
         """
@@ -116,17 +136,42 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
             resource_types=resource_types, account_ids=account_ids, include_costs=include_costs
         )
 
-    def _initialize_profile_architecture(self) -> Dict[str, str]:
-        """Initialize 4-profile AWS SSO architecture"""
-        if self.use_enterprise_profiles and ENHANCED_PROFILES_AVAILABLE:
-            profiles = ENTERPRISE_PROFILES.copy()
-            logger.info("Using proven enterprise 4-profile AWS SSO architecture")
+    def _initialize_profile_architecture(self) -> str:
+        """
+        Initialize profile management following --profile or --all patterns.
+        
+        Strategic Alignment: "Do one thing and do it well"
+        - Single profile override pattern: --profile takes precedence
+        - Universal AWS environment compatibility: works with ANY profile configuration
+        - Graceful fallback system for discovery across different AWS setups
+        
+        Returns:
+            str: The active profile to use for all operations
+        """
+        # PRIMARY: User --profile parameter takes absolute precedence (Universal Compatibility)
+        if self.profile:
+            print_info(f"✅ Universal AWS Compatibility: Using user-specified profile '{self.profile}'")
+            logger.info("Profile override via --profile parameter - universal environment support")
+            return self.profile
+        
+        # SECONDARY: Environment variable fallback with intelligent prioritization
+        # Priority order: Management > Billing > Operations > Default (Organizations discovery preference)
+        env_profile = (
+            os.getenv("MANAGEMENT_PROFILE") or 
+            os.getenv("BILLING_PROFILE") or 
+            os.getenv("CENTRALISED_OPS_PROFILE") or
+            os.getenv("SINGLE_AWS_PROFILE") or
+            "default"
+        )
+        
+        if env_profile != "default":
+            print_info(f"✅ Universal AWS Compatibility: Using environment profile '{env_profile}'")
+            logger.info(f"Environment variable profile selected: {env_profile}")
         else:
-            # Fallback to single profile or provided profile
-            profiles = {"PRIMARY_PROFILE": self.profile or "default"}
-            logger.info(f"Using single profile architecture: {profiles['PRIMARY_PROFILE']}")
-
-        return profiles
+            print_info("✅ Universal AWS Compatibility: Using 'default' profile - works with any AWS CLI configuration")
+            logger.info("Using default profile - universal compatibility mode")
+        
+        return env_profile
 
     def _initialize_collectors(self) -> Dict[str, str]:
         """Initialize available resource collectors."""
@@ -140,19 +185,68 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
             "vpc": "VPCCollector",
             "cloudformation": "CloudFormationCollector",
             "costs": "CostCollector",
+            "organizations": "ManagementResourceCollector",
         }
 
         logger.debug(f"Initialized {len(collectors)} resource collectors")
         return collectors
+    
+    def _extract_resource_counts(self, resource_data: Dict[str, Any]) -> Dict[str, int]:
+        """
+        Extract resource counts from collected inventory data for MCP validation.
+        
+        Args:
+            resource_data: Raw resource data from inventory collection
+            
+        Returns:
+            Dictionary mapping resource types to counts
+        """
+        resource_counts = {}
+        
+        try:
+            # Handle various data structures from inventory collection
+            if isinstance(resource_data, dict):
+                for resource_type, resources in resource_data.items():
+                    if isinstance(resources, list):
+                        resource_counts[resource_type] = len(resources)
+                    elif isinstance(resources, dict):
+                        # Handle nested structures (e.g., by region)
+                        total_count = 0
+                        for region_data in resources.values():
+                            if isinstance(region_data, list):
+                                total_count += len(region_data)
+                            elif isinstance(region_data, dict) and 'resources' in region_data:
+                                total_count += len(region_data['resources'])
+                        resource_counts[resource_type] = total_count
+                    elif isinstance(resources, int):
+                        resource_counts[resource_type] = resources
+                        
+            logger.debug(f"Extracted resource counts for validation: {resource_counts}")
+            return resource_counts
+            
+        except Exception as e:
+            logger.warning(f"Failed to extract resource counts for MCP validation: {e}")
+            return {}
 
     def get_all_resource_types(self) -> List[str]:
         """Get list of all available resource types."""
         return list(self._resource_collectors.keys())
 
     def get_organization_accounts(self) -> List[str]:
-        """Get list of accounts in AWS Organization."""
+        """
+        Get list of accounts in AWS Organization with universal compatibility.
+        
+        Strategic Alignment: "Do one thing and do it well" 
+        - Universal AWS environment compatibility: works with ANY Organizations setup
+        - Intelligent fallback system: Organizations → standalone account detection
+        - Graceful handling of different permission scenarios
+        """
         try:
-            organizations_client = self.get_client("organizations")
+            # Use active profile for Organizations operations (Universal Compatibility)
+            management_session = create_management_session(profile=self.active_profile)
+            organizations_client = management_session.client("organizations")
+            
+            print_info(f"🔍 Universal Discovery: Attempting Organizations API with profile '{self.active_profile}'...")
             response = self._make_aws_call(organizations_client.list_accounts)
 
             accounts = []
@@ -160,12 +254,31 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                 if account["Status"] == "ACTIVE":
                     accounts.append(account["Id"])
 
-            logger.info(f"Found {len(accounts)} active accounts in organization")
-            return accounts
+            if accounts:
+                print_success(f"✅ Organizations Discovery: Found {len(accounts)} active accounts in organization")
+                logger.info(f"Organizations discovery successful: {len(accounts)} accounts with profile {self.active_profile}")
+                return accounts
+            else:
+                print_warning("⚠️ Organizations Discovery: No active accounts found in organization")
+                return [self.get_account_id()]
 
         except Exception as e:
-            logger.warning(f"Could not list organization accounts: {e}")
-            # Fallback to current account
+            # Enhanced error messages for different AWS environment scenarios
+            error_message = str(e).lower()
+            
+            if "accessdenied" in error_message or "unauthorized" in error_message:
+                print_warning(f"⚠️ Universal Compatibility: Profile '{self.active_profile}' lacks Organizations permissions")
+                print_info("💡 Single Account Mode: Continuing with current account (universal compatibility)")
+            elif "organizationsnotinuse" in error_message:
+                print_info(f"ℹ️ Standalone Account: Profile '{self.active_profile}' not in an AWS Organization")
+                print_info("💡 Single Account Mode: Continuing with current account")
+            else:
+                print_warning(f"⚠️ Organizations Discovery Failed: {e}")
+                print_info("💡 Fallback Mode: Continuing with current account for universal compatibility")
+            
+            logger.warning(f"Organization discovery failed, graceful fallback: {e}")
+            
+            # Universal fallback: always return current account for single-account operations
             return [self.get_account_id()]
 
     def get_current_account_id(self) -> str:
@@ -210,13 +323,13 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                 "collector_profile": self.profile,
                 "collector_region": self.region,
                 "enterprise_profiles_used": self.use_enterprise_profiles,
-                "available_profiles": len(self.available_profiles),
+                "active_profile": self.active_profile,
                 "performance_target": self.performance_target_seconds,
             },
             "resources": {},
             "summary": {},
             "errors": [],
-            "profile_info": self.available_profiles,
+            "profile_info": {"active_profile": self.active_profile},
         }
 
         try:
@@ -228,22 +341,55 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
             results["resources"] = resource_data
             results["summary"] = self._generate_summary(resource_data)
 
-            # Phase 4: MCP Validation Integration
-            if self.enable_mcp_validation:
+            # Phase 4: Enhanced Inventory MCP Validation Integration
+            if self.enable_mcp_validation and self.inventory_mcp_validator:
                 try:
-                    print_info("Validating inventory results with MCP integration")
-                    validation_result = asyncio.run(self.mcp_integrator.validate_inventory_operations(results))
-
-                    results["mcp_validation"] = validation_result.to_dict()
-
-                    if validation_result.success:
-                        print_success(f"MCP validation passed: {validation_result.accuracy_score}% accuracy")
+                    print_info("Validating inventory results with specialized inventory MCP validator")
+                    
+                    # Extract resource counts for validation
+                    # Build validation data structure that matches what the validator expects
+                    resource_counts = self._extract_resource_counts(resource_data)
+                    
+                    # Add resource counts to results for the validator to find
+                    results["resource_counts"] = resource_counts
+                    
+                    validation_data = {
+                        "resource_counts": resource_counts,
+                        "regions": results["metadata"].get("regions_scanned", []),
+                        self.active_profile: {
+                            "resource_counts": resource_counts,
+                            "regions": results["metadata"].get("regions_scanned", [])
+                        }
+                    }
+                    
+                    # Run inventory-specific MCP validation
+                    inventory_validation = self.inventory_mcp_validator.validate_inventory_data(validation_data)
+                    
+                    results["inventory_mcp_validation"] = inventory_validation
+                    
+                    overall_accuracy = inventory_validation.get("total_accuracy", 0)
+                    if inventory_validation.get("passed_validation", False):
+                        print_success(f"✅ Inventory MCP validation PASSED: {overall_accuracy:.1f}% accuracy achieved")
                     else:
-                        print_warning("MCP validation encountered issues - results may need review")
+                        print_warning(f"⚠️ Inventory MCP validation: {overall_accuracy:.1f}% accuracy (≥99.5% required)")
+                    
+                    # Also try the generic MCP integrator as backup
+                    try:
+                        validation_result = asyncio.run(self.mcp_integrator.validate_inventory_operations(results))
+                        results["mcp_validation"] = validation_result.to_dict()
+                    except Exception:
+                        pass  # Skip generic validation if it fails
 
                 except Exception as e:
-                    print_warning(f"MCP validation failed: {str(e)[:50]}... - continuing without validation")
-                    results["mcp_validation"] = {"error": str(e), "validation_skipped": True}
+                    print_warning(f"Inventory MCP validation failed: {str(e)[:50]}... - continuing without validation")
+                    results["inventory_mcp_validation"] = {"error": str(e), "validation_skipped": True}
+                    
+                    # Fallback to generic MCP integration
+                    try:
+                        validation_result = asyncio.run(self.mcp_integrator.validate_inventory_operations(results))
+                        results["mcp_validation"] = validation_result.to_dict()
+                    except Exception as fallback_e:
+                        results["mcp_validation"] = {"error": str(fallback_e), "validation_skipped": True}
 
             # Complete performance benchmark
             end_time = datetime.now()
@@ -292,6 +438,946 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
             results["errors"].append(error_msg)
             return results
 
+    def _collect_parallel(
+        self, resource_types: List[str], account_ids: List[str], include_costs: bool
+    ) -> Dict[str, Any]:
+        """
+        Collect inventory in parallel with enhanced performance monitoring.
+        
+        Follows the same pattern as legacy implementation but with enterprise
+        performance monitoring and error handling.
+        """
+        results = {}
+        total_tasks = len(resource_types) * len(account_ids)
+        progress = ProgressTracker(total_tasks, "Collecting inventory")
+
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            # Submit collection tasks
+            future_to_params = {}
+
+            for resource_type in resource_types:
+                for account_id in account_ids:
+                    future = executor.submit(
+                        self._collect_resource_for_account, resource_type, account_id, include_costs
+                    )
+                    future_to_params[future] = (resource_type, account_id)
+
+            # Collect results
+            for future in as_completed(future_to_params):
+                resource_type, account_id = future_to_params[future]
+                try:
+                    resource_data = future.result()
+
+                    if resource_type not in results:
+                        results[resource_type] = {}
+
+                    results[resource_type][account_id] = resource_data
+                    progress.update(status=f"Completed {resource_type} for {account_id}")
+
+                except Exception as e:
+                    logger.error(f"Failed to collect {resource_type} for account {account_id}: {e}")
+                    progress.update(status=f"Failed {resource_type} for {account_id}")
+
+        progress.complete()
+        return results
+
+    def _collect_sequential(
+        self, resource_types: List[str], account_ids: List[str], include_costs: bool
+    ) -> Dict[str, Any]:
+        """
+        Collect inventory sequentially with enhanced error handling.
+        
+        Follows the same pattern as legacy implementation but with enhanced
+        error handling and progress tracking.
+        """
+        results = {}
+        total_tasks = len(resource_types) * len(account_ids)
+        progress = ProgressTracker(total_tasks, "Collecting inventory")
+
+        for resource_type in resource_types:
+            results[resource_type] = {}
+
+            for account_id in account_ids:
+                try:
+                    resource_data = self._collect_resource_for_account(resource_type, account_id, include_costs)
+                    results[resource_type][account_id] = resource_data
+                    progress.update(status=f"Completed {resource_type} for {account_id}")
+
+                except Exception as e:
+                    logger.error(f"Failed to collect {resource_type} for account {account_id}: {e}")
+                    results[resource_type][account_id] = {"error": str(e)}
+                    progress.update(status=f"Failed {resource_type} for {account_id}")
+
+        progress.complete()
+        return results
+
+    def _collect_resource_for_account(self, resource_type: str, account_id: str, include_costs: bool) -> Dict[str, Any]:
+        """
+        Collect specific resource type for an account using REAL AWS API calls.
+        
+        This method makes actual AWS API calls to discover resources, following
+        the proven patterns from the existing inventory modules.
+        """
+        try:
+            # Use active profile for AWS API calls
+            session = boto3.Session(profile_name=self.active_profile)
+            
+            print_info(f"Collecting {resource_type} resources from account {account_id} using profile {self.active_profile}")
+            
+            if resource_type == "ec2":
+                return self._collect_ec2_instances(session, account_id)
+            elif resource_type == "rds":
+                return self._collect_rds_instances(session, account_id)
+            elif resource_type == "s3":
+                return self._collect_s3_buckets(session, account_id)
+            elif resource_type == "lambda":
+                return self._collect_lambda_functions(session, account_id)
+            elif resource_type == "iam":
+                return self._collect_iam_resources(session, account_id)
+            elif resource_type == "vpc":
+                return self._collect_vpc_resources(session, account_id)
+            elif resource_type == "cloudformation":
+                return self._collect_cloudformation_stacks(session, account_id)
+            elif resource_type == "organizations":
+                return self._collect_organizations_data(session, account_id)
+            elif resource_type == "costs" and include_costs:
+                return self._collect_cost_data(session, account_id)
+            else:
+                print_warning(f"Resource type '{resource_type}' not supported yet")
+                return {
+                    "resources": [],
+                    "count": 0, 
+                    "resource_type": resource_type,
+                    "account_id": account_id,
+                    "collection_timestamp": datetime.now().isoformat(),
+                    "warning": f"Resource type {resource_type} not implemented yet"
+                }
+                
+        except Exception as e:
+            error_msg = f"Failed to collect {resource_type} for account {account_id}: {e}"
+            logger.error(error_msg)
+            print_error(error_msg)
+            return {
+                "error": str(e),
+                "resource_type": resource_type,
+                "account_id": account_id,
+                "collection_timestamp": datetime.now().isoformat(),
+            }
+
+    def _collect_ec2_instances(self, session: boto3.Session, account_id: str) -> Dict[str, Any]:
+        """Collect EC2 instances using real AWS API calls."""
+        try:
+            region = self.region or session.region_name or "us-east-1"
+            ec2_client = session.client("ec2", region_name=region)
+            
+            print_info(f"Calling EC2 describe_instances API for account {account_id} in region {region}")
+            
+            # Make real AWS API call with pagination support
+            instances = []
+            paginator = ec2_client.get_paginator('describe_instances')
+            
+            for page in paginator.paginate():
+                for reservation in page.get("Reservations", []):
+                    for instance in reservation.get("Instances", []):
+                        # Extract instance data
+                        instance_data = {
+                            "instance_id": instance["InstanceId"],
+                            "instance_type": instance["InstanceType"],
+                            "state": instance["State"]["Name"],
+                            "region": region,
+                            "account_id": account_id,
+                            "launch_time": instance.get("LaunchTime", "").isoformat() if instance.get("LaunchTime") else "",
+                            "availability_zone": instance.get("Placement", {}).get("AvailabilityZone", ""),
+                            "vpc_id": instance.get("VpcId", ""),
+                            "subnet_id": instance.get("SubnetId", ""),
+                            "private_ip_address": instance.get("PrivateIpAddress", ""),
+                            "public_ip_address": instance.get("PublicIpAddress", ""),
+                            "public_dns_name": instance.get("PublicDnsName", ""),
+                        }
+                        
+                        # Extract tags
+                        tags = {}
+                        name = "No Name Tag"
+                        for tag in instance.get("Tags", []):
+                            tags[tag["Key"]] = tag["Value"]
+                            if tag["Key"] == "Name":
+                                name = tag["Value"]
+                        
+                        instance_data["tags"] = tags
+                        instance_data["name"] = name
+                        
+                        # Extract security groups
+                        instance_data["security_groups"] = [
+                            {"group_id": sg["GroupId"], "group_name": sg["GroupName"]} 
+                            for sg in instance.get("SecurityGroups", [])
+                        ]
+                        
+                        instances.append(instance_data)
+            
+            print_success(f"Found {len(instances)} EC2 instances in account {account_id}")
+            
+            return {
+                "instances": instances,
+                "count": len(instances),
+                "collection_timestamp": datetime.now().isoformat(),
+                "region": region,
+                "account_id": account_id,
+            }
+            
+        except Exception as e:
+            print_error(f"Failed to collect EC2 instances: {e}")
+            raise
+
+    def _collect_rds_instances(self, session: boto3.Session, account_id: str) -> Dict[str, Any]:
+        """Collect RDS instances using real AWS API calls."""
+        try:
+            region = self.region or session.region_name or "us-east-1"
+            rds_client = session.client("rds", region_name=region)
+            
+            print_info(f"Calling RDS describe_db_instances API for account {account_id} in region {region}")
+            
+            # Make real AWS API call with pagination support
+            instances = []
+            paginator = rds_client.get_paginator('describe_db_instances')
+            
+            for page in paginator.paginate():
+                for db_instance in page.get("DBInstances", []):
+                    instance_data = {
+                        "db_instance_identifier": db_instance["DBInstanceIdentifier"],
+                        "engine": db_instance["Engine"],
+                        "engine_version": db_instance["EngineVersion"],
+                        "instance_class": db_instance["DBInstanceClass"],
+                        "status": db_instance["DBInstanceStatus"],
+                        "account_id": account_id,
+                        "region": region,
+                        "multi_az": db_instance.get("MultiAZ", False),
+                        "storage_type": db_instance.get("StorageType", ""),
+                        "allocated_storage": db_instance.get("AllocatedStorage", 0),
+                        "endpoint": db_instance.get("Endpoint", {}).get("Address", "") if db_instance.get("Endpoint") else "",
+                        "port": db_instance.get("Endpoint", {}).get("Port", 0) if db_instance.get("Endpoint") else 0,
+                        "vpc_id": db_instance.get("DBSubnetGroup", {}).get("VpcId", "") if db_instance.get("DBSubnetGroup") else "",
+                    }
+                    
+                    instances.append(instance_data)
+            
+            print_success(f"Found {len(instances)} RDS instances in account {account_id}")
+            
+            return {
+                "instances": instances,
+                "count": len(instances),
+                "collection_timestamp": datetime.now().isoformat(),
+                "region": region,
+                "account_id": account_id,
+            }
+            
+        except Exception as e:
+            print_error(f"Failed to collect RDS instances: {e}")
+            raise
+
+    def _collect_s3_buckets(self, session: boto3.Session, account_id: str) -> Dict[str, Any]:
+        """Collect S3 buckets using real AWS API calls."""
+        try:
+            s3_client = session.client("s3")
+            
+            print_info(f"Calling S3 list_buckets API for account {account_id}")
+            
+            # Make real AWS API call - S3 buckets are global
+            response = s3_client.list_buckets()
+            buckets = []
+            
+            for bucket in response.get("Buckets", []):
+                bucket_data = {
+                    "name": bucket["Name"],
+                    "creation_date": bucket["CreationDate"].isoformat(),
+                    "account_id": account_id,
+                }
+                
+                # Try to get bucket location (region)
+                try:
+                    location_response = s3_client.get_bucket_location(Bucket=bucket["Name"])
+                    bucket_region = location_response.get("LocationConstraint")
+                    if bucket_region is None:
+                        bucket_region = "us-east-1"  # Default for US Standard
+                    bucket_data["region"] = bucket_region
+                except Exception as e:
+                    logger.warning(f"Could not get location for bucket {bucket['Name']}: {e}")
+                    bucket_data["region"] = "unknown"
+                
+                # Try to get bucket versioning
+                try:
+                    versioning_response = s3_client.get_bucket_versioning(Bucket=bucket["Name"])
+                    bucket_data["versioning"] = versioning_response.get("Status", "Suspended")
+                except Exception as e:
+                    logger.warning(f"Could not get versioning for bucket {bucket['Name']}: {e}")
+                    bucket_data["versioning"] = "unknown"
+                
+                buckets.append(bucket_data)
+            
+            print_success(f"Found {len(buckets)} S3 buckets in account {account_id}")
+            
+            return {
+                "buckets": buckets,
+                "count": len(buckets),
+                "collection_timestamp": datetime.now().isoformat(),
+                "account_id": account_id,
+            }
+            
+        except Exception as e:
+            print_error(f"Failed to collect S3 buckets: {e}")
+            raise
+
+    def _collect_lambda_functions(self, session: boto3.Session, account_id: str) -> Dict[str, Any]:
+        """Collect Lambda functions using real AWS API calls."""
+        try:
+            region = self.region or session.region_name or "us-east-1"
+            lambda_client = session.client("lambda", region_name=region)
+            
+            print_info(f"Calling Lambda list_functions API for account {account_id} in region {region}")
+            
+            # Make real AWS API call with pagination support
+            functions = []
+            paginator = lambda_client.get_paginator('list_functions')
+            
+            for page in paginator.paginate():
+                for function in page.get("Functions", []):
+                    function_data = {
+                        "function_name": function["FunctionName"],
+                        "runtime": function.get("Runtime", ""),
+                        "handler": function.get("Handler", ""),
+                        "code_size": function.get("CodeSize", 0),
+                        "description": function.get("Description", ""),
+                        "timeout": function.get("Timeout", 0),
+                        "memory_size": function.get("MemorySize", 0),
+                        "last_modified": function.get("LastModified", ""),
+                        "role": function.get("Role", ""),
+                        "account_id": account_id,
+                        "region": region,
+                    }
+                    
+                    functions.append(function_data)
+            
+            print_success(f"Found {len(functions)} Lambda functions in account {account_id}")
+            
+            return {
+                "functions": functions,
+                "count": len(functions),
+                "collection_timestamp": datetime.now().isoformat(),
+                "region": region,
+                "account_id": account_id,
+            }
+            
+        except Exception as e:
+            print_error(f"Failed to collect Lambda functions: {e}")
+            raise
+
+    def _collect_iam_resources(self, session: boto3.Session, account_id: str) -> Dict[str, Any]:
+        """Collect IAM resources using real AWS API calls."""
+        try:
+            iam_client = session.client("iam")
+            
+            print_info(f"Calling IAM APIs for account {account_id}")
+            
+            resources = {"users": [], "roles": [], "policies": [], "groups": []}
+            
+            # Collect users
+            paginator = iam_client.get_paginator('list_users')
+            for page in paginator.paginate():
+                for user in page.get("Users", []):
+                    user_data = {
+                        "user_name": user["UserName"],
+                        "user_id": user["UserId"],
+                        "arn": user["Arn"],
+                        "create_date": user["CreateDate"].isoformat(),
+                        "path": user["Path"],
+                        "account_id": account_id,
+                    }
+                    resources["users"].append(user_data)
+            
+            # Collect roles
+            paginator = iam_client.get_paginator('list_roles')
+            for page in paginator.paginate():
+                for role in page.get("Roles", []):
+                    role_data = {
+                        "role_name": role["RoleName"],
+                        "role_id": role["RoleId"],
+                        "arn": role["Arn"],
+                        "create_date": role["CreateDate"].isoformat(),
+                        "path": role["Path"],
+                        "account_id": account_id,
+                    }
+                    resources["roles"].append(role_data)
+            
+            total_count = len(resources["users"]) + len(resources["roles"])
+            print_success(f"Found {total_count} IAM resources in account {account_id}")
+            
+            return {
+                "resources": resources,
+                "count": total_count,
+                "collection_timestamp": datetime.now().isoformat(),
+                "account_id": account_id,
+            }
+            
+        except Exception as e:
+            print_error(f"Failed to collect IAM resources: {e}")
+            raise
+
+    def _collect_vpc_resources(self, session: boto3.Session, account_id: str) -> Dict[str, Any]:
+        """Collect VPC resources using real AWS API calls."""
+        try:
+            region = self.region or session.region_name or "us-east-1"
+            ec2_client = session.client("ec2", region_name=region)
+            
+            print_info(f"Calling EC2 VPC APIs for account {account_id} in region {region}")
+            
+            vpcs = []
+            paginator = ec2_client.get_paginator('describe_vpcs')
+            
+            for page in paginator.paginate():
+                for vpc in page.get("Vpcs", []):
+                    vpc_data = {
+                        "vpc_id": vpc["VpcId"],
+                        "cidr_block": vpc["CidrBlock"],
+                        "state": vpc["State"],
+                        "is_default": vpc.get("IsDefault", False),
+                        "instance_tenancy": vpc.get("InstanceTenancy", ""),
+                        "account_id": account_id,
+                        "region": region,
+                    }
+                    
+                    # Extract tags
+                    tags = {}
+                    name = "No Name Tag"
+                    for tag in vpc.get("Tags", []):
+                        tags[tag["Key"]] = tag["Value"]
+                        if tag["Key"] == "Name":
+                            name = tag["Value"]
+                    
+                    vpc_data["tags"] = tags
+                    vpc_data["name"] = name
+                    
+                    vpcs.append(vpc_data)
+            
+            print_success(f"Found {len(vpcs)} VPCs in account {account_id}")
+            
+            return {
+                "vpcs": vpcs,
+                "count": len(vpcs),
+                "collection_timestamp": datetime.now().isoformat(),
+                "region": region,
+                "account_id": account_id,
+            }
+            
+        except Exception as e:
+            print_error(f"Failed to collect VPC resources: {e}")
+            raise
+
+    def _collect_cloudformation_stacks(self, session: boto3.Session, account_id: str) -> Dict[str, Any]:
+        """Collect CloudFormation stacks using real AWS API calls."""
+        try:
+            region = self.region or session.region_name or "us-east-1"
+            cf_client = session.client("cloudformation", region_name=region)
+            
+            print_info(f"Calling CloudFormation describe_stacks API for account {account_id} in region {region}")
+            
+            stacks = []
+            paginator = cf_client.get_paginator('describe_stacks')
+            
+            for page in paginator.paginate():
+                for stack in page.get("Stacks", []):
+                    stack_data = {
+                        "stack_name": stack["StackName"],
+                        "stack_id": stack["StackId"],
+                        "stack_status": stack["StackStatus"],
+                        "creation_time": stack["CreationTime"].isoformat(),
+                        "description": stack.get("Description", ""),
+                        "account_id": account_id,
+                        "region": region,
+                    }
+                    
+                    if "LastUpdatedTime" in stack:
+                        stack_data["last_updated_time"] = stack["LastUpdatedTime"].isoformat()
+                    
+                    stacks.append(stack_data)
+            
+            print_success(f"Found {len(stacks)} CloudFormation stacks in account {account_id}")
+            
+            return {
+                "stacks": stacks,
+                "count": len(stacks),
+                "collection_timestamp": datetime.now().isoformat(),
+                "region": region,
+                "account_id": account_id,
+            }
+            
+        except Exception as e:
+            print_error(f"Failed to collect CloudFormation stacks: {e}")
+            raise
+
+    def _collect_cost_data(self, session: boto3.Session, account_id: str) -> Dict[str, Any]:
+        """Collect cost data using real AWS Cost Explorer API calls."""
+        try:
+            # Note: Cost Explorer requires specific billing permissions
+            print_warning("Cost data collection requires AWS Cost Explorer permissions")
+            print_info(f"Attempting to collect cost data for account {account_id}")
+            
+            # For now, return placeholder - would need billing profile for actual cost data
+            return {
+                "monthly_costs": {
+                    "note": "Cost data collection requires proper billing permissions and profile",
+                    "suggestion": "Use BILLING_PROFILE environment variable or --profile with billing access"
+                },
+                "account_id": account_id,
+                "collection_timestamp": datetime.now().isoformat(),
+            }
+            
+        except Exception as e:
+            print_error(f"Failed to collect cost data: {e}")
+            raise
+
+    def _collect_organizations_data(self, session: boto3.Session, account_id: str) -> Dict[str, Any]:
+        """Collect AWS Organizations data using existing organizations discovery module."""
+        try:
+            print_info(f"Collecting Organizations data for account {account_id}")
+            
+            # Use the session's profile name for organizations discovery
+            profile_name = session.profile_name or self.active_profile
+            
+            org_client = session.client('organizations', region_name='us-east-1')  # Organizations is always us-east-1
+            
+            # Collect organization structure and accounts
+            organizations_data = {
+                "organization_info": {},
+                "accounts": [],
+                "organizational_units": [],
+                "resource_type": "organizations",
+                "account_id": account_id,
+                "collection_timestamp": datetime.now().isoformat()
+            }
+            
+            try:
+                # Get organization details
+                org_response = org_client.describe_organization()
+                organizations_data["organization_info"] = org_response.get("Organization", {})
+                
+                # Get all accounts in the organization
+                paginator = org_client.get_paginator('list_accounts')
+                accounts = []
+                for page in paginator.paginate():
+                    accounts.extend(page.get('Accounts', []))
+                
+                organizations_data["accounts"] = accounts
+                organizations_data["count"] = len(accounts)
+                
+                # Get organizational units
+                try:
+                    roots_response = org_client.list_roots()
+                    for root in roots_response.get('Roots', []):
+                        ou_paginator = org_client.get_paginator('list_organizational_units_for_parent')
+                        for ou_page in ou_paginator.paginate(ParentId=root['Id']):
+                            organizations_data["organizational_units"].extend(ou_page.get('OrganizationalUnits', []))
+                except Exception as ou_e:
+                    print_warning(f"Could not collect organizational units: {ou_e}")
+                    organizations_data["organizational_units"] = []
+                
+                print_success(f"Successfully collected {len(accounts)} accounts from organization")
+                
+            except Exception as org_e:
+                print_warning(f"Organization data collection limited: {org_e}")
+                # Try to collect at least basic account info if not in an organization
+                try:
+                    sts_client = session.client('sts')
+                    caller_identity = sts_client.get_caller_identity()
+                    organizations_data["accounts"] = [{
+                        "Id": caller_identity.get("Account"),
+                        "Name": f"Account-{caller_identity.get('Account')}",
+                        "Status": "ACTIVE",
+                        "JoinedMethod": "STANDALONE"
+                    }]
+                    organizations_data["count"] = 1
+                    print_info("Collected standalone account information")
+                except Exception as sts_e:
+                    print_error(f"Could not collect account information: {sts_e}")
+                    organizations_data["count"] = 0
+            
+            return organizations_data
+            
+        except Exception as e:
+            print_error(f"Failed to collect organizations data: {e}")
+            raise
+
+    def _generate_summary(self, resource_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Generate comprehensive summary statistics from collected data.
+        
+        Enhanced implementation with better error handling and metrics.
+        """
+        summary = {
+            "total_resources": 0,
+            "resources_by_type": {},
+            "resources_by_account": {},
+            "collection_status": "completed",
+            "errors": [],
+            "collection_summary": {
+                "successful_collections": 0,
+                "failed_collections": 0,
+                "accounts_processed": set(),
+                "resource_types_processed": set(),
+            }
+        }
+
+        for resource_type, accounts_data in resource_data.items():
+            type_count = 0
+            summary["collection_summary"]["resource_types_processed"].add(resource_type)
+
+            for account_id, account_data in accounts_data.items():
+                summary["collection_summary"]["accounts_processed"].add(account_id)
+                
+                if "error" in account_data:
+                    summary["errors"].append(f"{resource_type}/{account_id}: {account_data['error']}")
+                    summary["collection_summary"]["failed_collections"] += 1
+                    continue
+
+                summary["collection_summary"]["successful_collections"] += 1
+
+                # Count resources based on type
+                account_count = account_data.get("count", 0)
+                if account_count == 0:
+                    # Try to calculate from actual resource lists
+                    if resource_type == "ec2":
+                        account_count = len(account_data.get("instances", []))
+                    elif resource_type == "rds":
+                        account_count = len(account_data.get("instances", []))
+                    elif resource_type == "s3":
+                        account_count = len(account_data.get("buckets", []))
+                    elif resource_type == "lambda":
+                        account_count = len(account_data.get("functions", []))
+                    else:
+                        account_count = len(account_data.get("resources", []))
+
+                type_count += account_count
+
+                if account_id not in summary["resources_by_account"]:
+                    summary["resources_by_account"][account_id] = 0
+                summary["resources_by_account"][account_id] += account_count
+
+            summary["resources_by_type"][resource_type] = type_count
+            summary["total_resources"] += type_count
+
+        # Convert sets to lists for JSON serialization
+        summary["collection_summary"]["accounts_processed"] = list(summary["collection_summary"]["accounts_processed"])
+        summary["collection_summary"]["resource_types_processed"] = list(summary["collection_summary"]["resource_types_processed"])
+        
+        # Update collection status based on errors
+        if summary["errors"]:
+            if summary["collection_summary"]["successful_collections"] == 0:
+                summary["collection_status"] = "failed"
+            else:
+                summary["collection_status"] = "completed_with_errors"
+
+        return summary
+    
+    def export_inventory_results(
+        self, 
+        results: Dict[str, Any], 
+        export_format: str = "json",
+        output_file: Optional[str] = None
+    ) -> str:
+        """
+        Export inventory results to multiple formats following proven finops patterns.
+        
+        Args:
+            results: Inventory results dictionary
+            export_format: Export format (json, csv, markdown, pdf, yaml)
+            output_file: Optional output file path
+        
+        Returns:
+            Export file path or formatted string content
+        """
+        import json
+        import csv
+        from datetime import datetime
+        from pathlib import Path
+        
+        # Determine output file path
+        if not output_file:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            output_file = f"/Volumes/Working/1xOps/CloudOps-Runbooks/tmp/inventory_export_{timestamp}.{export_format}"
+        
+        # Ensure tmp directory exists
+        Path(output_file).parent.mkdir(parents=True, exist_ok=True)
+        
+        try:
+            if export_format.lower() == "json":
+                return self._export_json(results, output_file)
+            elif export_format.lower() == "csv":
+                return self._export_csv(results, output_file)
+            elif export_format.lower() == "markdown":
+                return self._export_markdown(results, output_file)
+            elif export_format.lower() == "yaml":
+                return self._export_yaml(results, output_file)
+            elif export_format.lower() == "pdf":
+                return self._export_pdf(results, output_file)
+            else:
+                raise ValueError(f"Unsupported export format: {export_format}")
+                
+        except Exception as e:
+            error_msg = f"Export failed for format {export_format}: {e}"
+            print_error(error_msg)
+            logger.error(error_msg)
+            raise
+    
+    def _export_json(self, results: Dict[str, Any], output_file: str) -> str:
+        """Export results to JSON format."""
+        with open(output_file, 'w') as f:
+            json.dump(results, f, indent=2, default=str)
+        
+        print_success(f"Inventory exported to JSON: {output_file}")
+        return output_file
+    
+    def _export_csv(self, results: Dict[str, Any], output_file: str) -> str:
+        """Export results to CSV format with real AWS data structure."""
+        import csv
+        
+        with open(output_file, 'w', newline='') as f:
+            writer = csv.writer(f)
+            
+            # Write header
+            writer.writerow(["Account", "Region", "Resource Type", "Resource ID", "Name", "Status", "Additional Info"])
+            
+            # Write data rows from real AWS resource structure
+            resource_data = results.get("resources", {})
+            
+            for resource_type, accounts_data in resource_data.items():
+                for account_id, account_data in accounts_data.items():
+                    if "error" in account_data:
+                        # Handle error cases
+                        writer.writerow([
+                            account_id,
+                            account_data.get("region", "unknown"),
+                            resource_type,
+                            "",
+                            "",
+                            "ERROR",
+                            account_data.get("error", "")
+                        ])
+                        continue
+                    
+                    account_region = account_data.get("region", "unknown")
+                    
+                    # Handle different resource types with their specific data structures
+                    if resource_type == "ec2" and "instances" in account_data:
+                        for instance in account_data["instances"]:
+                            writer.writerow([
+                                account_id,
+                                instance.get("region", account_region),
+                                "ec2-instance",
+                                instance.get("instance_id", ""),
+                                instance.get("name", "No Name Tag"),
+                                instance.get("state", ""),
+                                f"Type: {instance.get('instance_type', '')}, AZ: {instance.get('availability_zone', '')}"
+                            ])
+                    
+                    elif resource_type == "rds" and "instances" in account_data:
+                        for instance in account_data["instances"]:
+                            writer.writerow([
+                                account_id,
+                                instance.get("region", account_region),
+                                "rds-instance",
+                                instance.get("db_instance_identifier", ""),
+                                instance.get("db_instance_identifier", ""),
+                                instance.get("status", ""),
+                                f"Engine: {instance.get('engine', '')}, Class: {instance.get('instance_class', '')}"
+                            ])
+                    
+                    elif resource_type == "s3" and "buckets" in account_data:
+                        for bucket in account_data["buckets"]:
+                            writer.writerow([
+                                account_id,
+                                bucket.get("region", account_region),
+                                "s3-bucket",
+                                bucket.get("name", ""),
+                                bucket.get("name", ""),
+                                "",
+                                f"Created: {bucket.get('creation_date', '')}"
+                            ])
+                    
+                    elif resource_type == "lambda" and "functions" in account_data:
+                        for function in account_data["functions"]:
+                            writer.writerow([
+                                account_id,
+                                function.get("region", account_region),
+                                "lambda-function",
+                                function.get("function_name", ""),
+                                function.get("function_name", ""),
+                                "",
+                                f"Runtime: {function.get('runtime', '')}, Memory: {function.get('memory_size', '')}MB"
+                            ])
+                    
+                    elif resource_type == "iam" and "resources" in account_data:
+                        iam_resources = account_data["resources"]
+                        for user in iam_resources.get("users", []):
+                            writer.writerow([
+                                account_id,
+                                "global",
+                                "iam-user",
+                                user.get("user_name", ""),
+                                user.get("user_name", ""),
+                                "",
+                                f"ARN: {user.get('arn', '')}"
+                            ])
+                        for role in iam_resources.get("roles", []):
+                            writer.writerow([
+                                account_id,
+                                "global",
+                                "iam-role",
+                                role.get("role_name", ""),
+                                role.get("role_name", ""),
+                                "",
+                                f"ARN: {role.get('arn', '')}"
+                            ])
+                    
+                    elif resource_type == "vpc" and "vpcs" in account_data:
+                        for vpc in account_data["vpcs"]:
+                            writer.writerow([
+                                account_id,
+                                vpc.get("region", account_region),
+                                "vpc",
+                                vpc.get("vpc_id", ""),
+                                vpc.get("name", "No Name Tag"),
+                                vpc.get("state", ""),
+                                f"CIDR: {vpc.get('cidr_block', '')}, Default: {vpc.get('is_default', False)}"
+                            ])
+                    
+                    elif resource_type == "cloudformation" and "stacks" in account_data:
+                        for stack in account_data["stacks"]:
+                            writer.writerow([
+                                account_id,
+                                stack.get("region", account_region),
+                                "cloudformation-stack",
+                                stack.get("stack_name", ""),
+                                stack.get("stack_name", ""),
+                                stack.get("stack_status", ""),
+                                f"Created: {stack.get('creation_time', '')}"
+                            ])
+                    
+                    # Handle cases where no specific resources were found but collection was successful
+                    elif account_data.get("count", 0) == 0:
+                        writer.writerow([
+                            account_id,
+                            account_region,
+                            resource_type,
+                            "",
+                            "",
+                            "NO_RESOURCES",
+                            f"No {resource_type} resources found"
+                        ])
+        
+        print_success(f"Inventory exported to CSV: {output_file}")
+        return output_file
+    
+    def _export_markdown(self, results: Dict[str, Any], output_file: str) -> str:
+        """Export results to Markdown format with tables."""
+        content = []
+        content.append("# AWS Inventory Report")
+        content.append(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        content.append("")
+        
+        # Summary section
+        total_resources = sum(
+            len(resources)
+            for account_data in results.get("accounts", {}).values()
+            for region_data in account_data.get("regions", {}).values()
+            for resources in region_data.get("resources", {}).values()
+        )
+        
+        content.append("## Summary")
+        content.append(f"- Total Accounts: {len(results.get('accounts', {}))}")
+        content.append(f"- Total Resources: {total_resources}")
+        content.append("")
+        
+        # Detailed inventory
+        content.append("## Detailed Inventory")
+        content.append("")
+        content.append("| Account | Region | Resource Type | Resource ID | Name | Status |")
+        content.append("|---------|--------|---------------|-------------|------|--------|")
+        
+        for account_id, account_data in results.get("accounts", {}).items():
+            for region, region_data in account_data.get("regions", {}).items():
+                for resource_type, resources in region_data.get("resources", {}).items():
+                    for resource in resources:
+                        content.append(f"| {account_id} | {region} | {resource_type} | {resource.get('id', '')} | {resource.get('name', '')} | {resource.get('state', '')} |")
+        
+        with open(output_file, 'w') as f:
+            f.write('\n'.join(content))
+        
+        print_success(f"Inventory exported to Markdown: {output_file}")
+        return output_file
+    
+    def _export_yaml(self, results: Dict[str, Any], output_file: str) -> str:
+        """Export results to YAML format."""
+        try:
+            import yaml
+        except ImportError:
+            print_error("PyYAML not available. Install with: pip install pyyaml")
+            raise
+        
+        with open(output_file, 'w') as f:
+            yaml.dump(results, f, default_flow_style=False, sort_keys=False)
+        
+        print_success(f"Inventory exported to YAML: {output_file}")
+        return output_file
+    
+    def _export_pdf(self, results: Dict[str, Any], output_file: str) -> str:
+        """Export results to executive PDF report."""
+        try:
+            from reportlab.lib.pagesizes import letter, A4
+            from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+            from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+            from reportlab.lib.units import inch
+            from reportlab.lib import colors
+        except ImportError:
+            # Graceful fallback to markdown if reportlab not available
+            print_warning("ReportLab not available, exporting to markdown instead")
+            return self._export_markdown(results, output_file.replace('.pdf', '.md'))
+        
+        doc = SimpleDocTemplate(output_file, pagesize=A4)
+        styles = getSampleStyleSheet()
+        story = []
+        
+        # Title
+        title_style = ParagraphStyle(
+            'CustomTitle',
+            parent=styles['Heading1'],
+            fontSize=24,
+            spaceAfter=30,
+            textColor=colors.darkblue
+        )
+        story.append(Paragraph("AWS Inventory Report", title_style))
+        story.append(Spacer(1, 20))
+        
+        # Executive Summary
+        story.append(Paragraph("Executive Summary", styles['Heading2']))
+        
+        total_resources = sum(
+            len(resources)
+            for account_data in results.get("accounts", {}).values()
+            for region_data in account_data.get("regions", {}).values()
+            for resources in region_data.get("resources", {}).values()
+        )
+        
+        summary_text = f"""
+        This report provides a comprehensive inventory of AWS resources across {len(results.get('accounts', {}))} accounts.
+        A total of {total_resources} resources were discovered and catalogued.
+        """
+        story.append(Paragraph(summary_text, styles['Normal']))
+        story.append(Spacer(1, 20))
+        
+        # Build the PDF
+        doc.build(story)
+        
+        print_success(f"Inventory exported to PDF: {output_file}")
+        return output_file
+
 
 # Legacy compatibility class - maintain backward compatibility
 class InventoryCollector(EnhancedInventoryCollector):
@@ -390,54 +1476,51 @@ class InventoryCollector(EnhancedInventoryCollector):
         this would delegate to specific resource collectors.
         """
         # Mock implementation - replace with actual collectors
-        import random
         import time
 
-        # Simulate collection time
-        time.sleep(random.uniform(0.1, 0.5))
+        # Deterministic collection timing
+        time.sleep(0.2)  # Fixed 200ms delay for testing
 
-        # Generate mock data based on resource type
-        if resource_type == "ec2":
-            return {
-                "instances": [
-                    {
-                        "instance_id": f"i-{random.randint(100000000000, 999999999999):012x}",
-                        "instance_type": random.choice(["t3.micro", "t3.small", "m5.large"]),
-                        "state": random.choice(["running", "stopped"]),
-                        "region": self.region or "us-east-1",
-                        "account_id": account_id,
-                        "tags": {"Environment": random.choice(["dev", "staging", "prod"])},
-                    }
-                    for _ in range(random.randint(0, 5))
-                ],
-                "count": random.randint(0, 5),
-            }
-        elif resource_type == "rds":
-            return {
-                "instances": [
-                    {
-                        "db_instance_identifier": f"db-{random.randint(1000, 9999)}",
-                        "engine": random.choice(["mysql", "postgres", "aurora"]),
-                        "instance_class": random.choice(["db.t3.micro", "db.t3.small"]),
-                        "status": "available",
-                        "account_id": account_id,
-                    }
-                    for _ in range(random.randint(0, 3))
-                ],
-                "count": random.randint(0, 3),
-            }
-        elif resource_type == "s3":
+        # REMOVED: Mock data generation violates enterprise standards
+        # Use real AWS API calls with proper authentication and error handling
+        try:
+            if resource_type == "ec2":
+                # TODO: Implement real EC2 API call
+                # ec2_client = self.session.client('ec2', region_name=self.region)
+                # response = ec2_client.describe_instances()
+                return {
+                    "instances": [],  # Replace with real EC2 API response processing
+                    "count": 0,
+                    "account_id": account_id,
+                    "region": self.region or "us-east-1"
+                }
+            elif resource_type == "rds":
+                # TODO: Implement real RDS API call
+                # rds_client = self.session.client('rds', region_name=self.region)
+                # response = rds_client.describe_db_instances()
+                return {
+                    "instances": [],  # Replace with real RDS API response processing
+                    "count": 0,
+                    "account_id": account_id,
+                    "region": self.region or "us-east-1"
+                }
+            elif resource_type == "s3":
+                # TODO: Implement real S3 API call
+                # s3_client = self.session.client('s3')
+                # response = s3_client.list_buckets()
+                return {
+                    "buckets": [],  # Replace with real S3 API response processing
+                    "count": 0,
+                    "account_id": account_id,
+                    "region": self.region or "us-east-1"
+                }
+        except Exception as e:
+            # Proper error handling for AWS API failures
             return {
-                "buckets": [
-                    {
-                        "name": f"bucket-{account_id}-{random.randint(1000, 9999)}",
-                        "creation_date": datetime.now().isoformat(),
-                        "region": self.region or "us-east-1",
-                        "account_id": account_id,
-                    }
-                    for _ in range(random.randint(1, 10))
-                ],
-                "count": random.randint(1, 10),
+                "error": str(e),
+                "resource_type": resource_type,
+                "account_id": account_id,
+                "count": 0
             }
         else:
             return {"resources": [], "count": 0, "resource_type": resource_type, "account_id": account_id}