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

runbooks/common/date_utils.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""
+Dynamic Date Utilities for CloudOps Runbooks Platform
+
+Replaces hardcoded 2024 dates with dynamic date generation following manager's
+"No hardcoded values" requirement. Supports current month/year calculations
+for all test data and AWS API time period generation.
+
+Strategic Alignment: "Do one thing and do it well" - Focused date utility
+KISS Principle: Simple, reusable date functions for all modules
+"""
+
+from datetime import datetime, timedelta
+from typing import Dict, Tuple
+
+
+def get_current_year() -> int:
+    """Get current year dynamically."""
+    return datetime.now().year
+
+
+def get_current_month_period() -> Dict[str, str]:
+    """
+    Generate current month's start and end dates for AWS API calls.
+    
+    Returns:
+        Dict with 'Start' and 'End' keys in YYYY-MM-DD format
+    """
+    now = datetime.now()
+    start_date = now.replace(day=1).strftime('%Y-%m-%d')
+    
+    # Get last day of current month
+    if now.month == 12:
+        next_month = now.replace(year=now.year + 1, month=1, day=1)
+    else:
+        next_month = now.replace(month=now.month + 1, day=1)
+    
+    end_date = (next_month - timedelta(days=1)).strftime('%Y-%m-%d')
+    
+    return {
+        'Start': start_date,
+        'End': end_date
+    }
+
+
+def get_previous_month_period() -> Dict[str, str]:
+    """
+    Generate previous month's start and end dates for AWS API calls.
+    
+    Returns:
+        Dict with 'Start' and 'End' keys in YYYY-MM-DD format
+    """
+    now = datetime.now()
+    
+    # Get first day of previous month
+    if now.month == 1:
+        prev_month = now.replace(year=now.year - 1, month=12, day=1)
+    else:
+        prev_month = now.replace(month=now.month - 1, day=1)
+    
+    start_date = prev_month.strftime('%Y-%m-%d')
+    
+    # Get last day of previous month  
+    end_date = (now.replace(day=1) - timedelta(days=1)).strftime('%Y-%m-%d')
+    
+    return {
+        'Start': start_date,
+        'End': end_date
+    }
+
+
+def get_test_date_period(days_back: int = 30) -> Dict[str, str]:
+    """
+    Generate test date periods for consistent test data.
+    
+    Args:
+        days_back: Number of days back from today for start date
+        
+    Returns:
+        Dict with 'Start' and 'End' keys in YYYY-MM-DD format
+    """
+    end_date = datetime.now().strftime('%Y-%m-%d')
+    start_date = (datetime.now() - timedelta(days=days_back)).strftime('%Y-%m-%d')
+    
+    return {
+        'Start': start_date,
+        'End': end_date
+    }
+
+
+def get_aws_cli_example_period() -> Tuple[str, str]:
+    """
+    Generate example date period for AWS CLI documentation.
+    Uses yesterday and today to ensure valid time range.
+    
+    Returns:
+        Tuple of (start_date, end_date) in YYYY-MM-DD format
+    """
+    today = datetime.now()
+    yesterday = today - timedelta(days=1)
+    
+    return (
+        yesterday.strftime('%Y-%m-%d'),
+        today.strftime('%Y-%m-%d')
+    )
+
+
+def get_collection_timestamp() -> str:
+    """
+    Generate collection timestamp for test data.
+    
+    Returns:
+        ISO format timestamp string
+    """
+    return datetime.now().isoformat()

runbooks/common/enhanced_exception_handler.py

@@ -323,6 +323,10 @@ class EnterpriseExceptionHandler:
         Returns:
             Enhanced error if performance target significantly exceeded, None otherwise
         """
+        # Defensive check for None values
+        if execution_time is None or performance_target is None or performance_target == 0:
+            return None
+            
         performance_ratio = execution_time / performance_target
 
         # Only create error if performance significantly exceeded (>150% of target)
@@ -968,13 +972,15 @@ class EnterpriseExceptionHandler:
         }
 
     def _initialize_profile_recommendations(self) -> Dict[str, List[str]]:
-        """Initialize profile recommendations for different operations."""
+        """Initialize profile recommendations for different operations with universal support."""
+        import os
+        # Environment variable-driven profile recommendations
         return {
-            "inventory": ["ams-admin-ReadOnlyAccess-909135376185", "ams-centralised-ops-ReadOnlyAccess-335083429030"],
-            "operate": ["ams-centralised-ops-ReadOnlyAccess-335083429030", "ams-admin-ReadOnlyAccess-909135376185"],
-            "finops": ["ams-admin-Billing-ReadOnlyAccess-909135376185", "ams-admin-ReadOnlyAccess-909135376185"],
-            "security": ["ams-admin-ReadOnlyAccess-909135376185"],
-            "cfat": ["ams-admin-ReadOnlyAccess-909135376185"],
+            "inventory": [os.getenv("MANAGEMENT_PROFILE", "management-profile"), os.getenv("CENTRALISED_OPS_PROFILE", "ops-profile")],
+            "operate": [os.getenv("CENTRALISED_OPS_PROFILE", "ops-profile"), os.getenv("MANAGEMENT_PROFILE", "management-profile")],
+            "finops": [os.getenv("BILLING_PROFILE", "billing-profile"), os.getenv("MANAGEMENT_PROFILE", "management-profile")],
+            "security": [os.getenv("MANAGEMENT_PROFILE", "management-profile")],
+            "cfat": [os.getenv("MANAGEMENT_PROFILE", "management-profile")],
         }
 
     def _analyze_aws_error(self, error: ClientError, error_code: str, service: str, operation: str) -> Dict[str, Any]:
@@ -987,7 +993,8 @@ class EnterpriseExceptionHandler:
         # Service-specific adjustments
         if service == "ce" and error_code == "AccessDenied":
             # Cost Explorer requires special billing permissions
-            base_analysis["recommended_profiles"] = ["ams-admin-Billing-ReadOnlyAccess-909135376185"]
+            import os
+            base_analysis["recommended_profiles"] = [os.getenv("BILLING_PROFILE", "billing-profile")]
 
         return base_analysis
 

runbooks/common/env_utils.py

@@ -0,0 +1,96 @@
+"""
+Environment Variable Utilities - Enterprise Hardcoded Value Elimination
+
+This module provides enterprise-compliant environment variable utilities
+that enforce zero hardcoded defaults policy across the entire codebase.
+"""
+
+import os
+from typing import Union
+
+
+def get_required_env(var_name: str) -> str:
+    """
+    Get required string environment variable - NO hardcoded defaults.
+    
+    Args:
+        var_name: Environment variable name
+        
+    Returns:
+        Environment variable value
+        
+    Raises:
+        ValueError: If environment variable is not set
+    """
+    value = os.getenv(var_name)
+    if value is None:
+        raise ValueError(f"Environment variable {var_name} required - no hardcoded defaults allowed")
+    return value
+
+
+def get_required_env_int(var_name: str) -> int:
+    """
+    Get required integer environment variable - NO hardcoded defaults.
+    
+    Args:
+        var_name: Environment variable name
+        
+    Returns:
+        Environment variable value as integer
+        
+    Raises:
+        ValueError: If environment variable is not set or not a valid integer
+    """
+    value = get_required_env(var_name)
+    try:
+        return int(value)
+    except ValueError as e:
+        raise ValueError(f"Environment variable {var_name} must be a valid integer, got: {value}") from e
+
+
+def get_required_env_float(var_name: str) -> float:
+    """
+    Get required float environment variable - NO hardcoded defaults.
+    
+    Args:
+        var_name: Environment variable name
+        
+    Returns:
+        Environment variable value as float
+        
+    Raises:
+        ValueError: If environment variable is not set or not a valid float
+    """
+    value = get_required_env(var_name)
+    try:
+        return float(value)
+    except ValueError as e:
+        raise ValueError(f"Environment variable {var_name} must be a valid float, got: {value}") from e
+
+
+def get_required_env_bool(var_name: str) -> bool:
+    """
+    Get required boolean environment variable - NO hardcoded defaults.
+    
+    Args:
+        var_name: Environment variable name
+        
+    Returns:
+        Environment variable value as boolean
+        
+    Raises:
+        ValueError: If environment variable is not set
+    """
+    value = get_required_env(var_name).lower()
+    if value in ('true', '1', 'yes', 'on'):
+        return True
+    elif value in ('false', '0', 'no', 'off'):
+        return False
+    else:
+        raise ValueError(f"Environment variable {var_name} must be a valid boolean (true/false), got: {value}")
+
+
+# Legacy compatibility function names for existing code
+_get_required_env_float = get_required_env_float
+_get_required_env_int = get_required_env_int 
+_get_required_env = get_required_env

runbooks/common/mcp_cost_explorer_integration.py

@@ -79,10 +79,11 @@ class MCPCostExplorerIntegration:
             performance_target_seconds: Performance target for operations
         """
         
-        # Profile configuration with intelligent defaults
-        self.billing_profile = billing_profile or "ams-admin-Billing-ReadOnlyAccess-909135376185"
-        self.management_profile = management_profile or "ams-admin-ReadOnlyAccess-909135376185"
-        self.single_account_profile = single_account_profile or "ams-shared-services-non-prod-ReadOnlyAccess-499201730520"
+        # Profile configuration with universal environment support  
+        from runbooks.common.profile_utils import get_profile_for_operation
+        self.billing_profile = billing_profile or get_profile_for_operation("billing", None)
+        self.management_profile = management_profile or get_profile_for_operation("management", None)
+        self.single_account_profile = single_account_profile or get_profile_for_operation("single_account", None)
         
         # Validation configuration
         self.tolerance_percent = tolerance_percent

runbooks/common/mcp_integration.py

@@ -150,6 +150,11 @@ class EnterpriseMCPIntegrator:
         self.validation_threshold = 99.5  # Enterprise accuracy requirement
         self.tolerance_percent = 5.0  # ±5% tolerance for validation
 
+        # Organizations API caching to prevent duplicate calls
+        self._organizations_cache = {}
+        self._organizations_cache_timestamp = None
+        self._cache_ttl_minutes = 30  # 30-minute TTL for Organizations data
+
         # Initialize enterprise profile architecture
         self._initialize_enterprise_profiles()
 
@@ -176,6 +181,27 @@ class EnterpriseMCPIntegrator:
             except Exception as e:
                 print_error(f"Failed to initialize {profile_type} profile: {str(e)}")
 
+    def _is_organizations_cache_valid(self) -> bool:
+        """Check if Organizations cache is still valid."""
+        if not self._organizations_cache_timestamp:
+            return False
+        
+        cache_age_minutes = (datetime.now() - self._organizations_cache_timestamp).total_seconds() / 60
+        return cache_age_minutes < self._cache_ttl_minutes
+
+    def get_cached_organization_accounts(self) -> Optional[List[Dict[str, Any]]]:
+        """Get cached Organizations data if valid."""
+        if self._is_organizations_cache_valid() and 'accounts' in self._organizations_cache:
+            print_info("Using cached Organizations data (performance optimization)")
+            return self._organizations_cache['accounts']
+        return None
+
+    def cache_organization_accounts(self, accounts: List[Dict[str, Any]]) -> None:
+        """Cache Organizations data for performance optimization."""
+        self._organizations_cache = {'accounts': accounts}
+        self._organizations_cache_timestamp = datetime.now()
+        print_success(f"Cached Organizations data: {len(accounts)} accounts (TTL: {self._cache_ttl_minutes}min)")
+
     async def validate_inventory_operations(self, inventory_data: Dict[str, Any]) -> MCPValidationResult:
         """
         Validate inventory operations using MCP integration.
@@ -496,11 +522,32 @@ class EnterpriseMCPIntegrator:
     async def _validate_resource_counts(self, inventory_data: Dict, progress, task) -> None:
         """Validate resource counts across services."""
         try:
-            resources = inventory_data.get("resources", [])
+            # Enhanced: Handle both dict and string inputs for robust data structure handling
+            if isinstance(inventory_data, str):
+                # Handle case where inventory_data is a JSON string
+                try:
+                    inventory_data = json.loads(inventory_data)
+                except json.JSONDecodeError:
+                    print_warning(f"Invalid JSON string in inventory data")
+                    return
+            
+            resources = inventory_data.get("resources", []) if isinstance(inventory_data, dict) else []
+            
+            # Enhanced: Ensure resources is always a list
+            if not isinstance(resources, list):
+                resources = []
+                
             service_counts = {}
 
             for resource in resources:
-                service = resource.get("service", "unknown")
+                # Enhanced: Handle both dict and string resource entries
+                if isinstance(resource, dict):
+                    service = resource.get("service", "unknown")
+                elif isinstance(resource, str):
+                    service = "unknown"
+                else:
+                    service = "unknown"
+                    
                 service_counts[service] = service_counts.get(service, 0) + 1
 
             progress.update(task, advance=40, description=f"Validated {len(resources)} resources...")