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

runbooks/cloudops/cost_optimizer.py

@@ -31,6 +31,8 @@ from runbooks.common.rich_utils import (
     console, print_header, print_success, print_error, print_warning, print_info,
     create_table, create_progress_bar, format_cost, create_panel
 )
+from runbooks.common.aws_pricing import get_service_monthly_cost, calculate_annual_cost, calculate_regional_cost
+from runbooks.common.env_utils import get_required_env_float
 from .base import CloudOpsBase
 from .models import (
     CostOptimizationResult, BusinessScenario, ExecutionMode, RiskLevel,
@@ -84,6 +86,7 @@ class CostOptimizer(CloudOpsBase):
         if dry_run:
             print_warning("🛡️  DRY RUN MODE: No resources will be modified")
     
+    
     async def discover_infrastructure(
         self,
         regions: Optional[List[str]] = None,
@@ -180,9 +183,9 @@ class CostOptimizer(CloudOpsBase):
                     for instance in reservation['Instances']:
                         if instance['State']['Name'] in ['running', 'stopped']:
                             total_instances += 1
-                            # Rough cost estimation
+                            # Dynamic cost estimation
                             instance_type = instance.get('InstanceType', 't3.micro')
-                            estimated_cost += self._estimate_ec2_cost(instance_type)
+                            estimated_cost += self._estimate_ec2_cost(instance_type, region)
                             
             except Exception as e:
                 print_warning(f"EC2 discovery failed in {region}: {str(e)}")
@@ -208,7 +211,7 @@ class CostOptimizer(CloudOpsBase):
                     total_volumes += 1
                     volume_size = volume.get('Size', 0)
                     volume_type = volume.get('VolumeType', 'gp2')
-                    estimated_cost += self._estimate_ebs_cost(volume_size, volume_type)
+                    estimated_cost += self._estimate_ebs_cost(volume_size, volume_type, region)
                     
             except Exception as e:
                 print_warning(f"EBS discovery failed in {region}: {str(e)}")
@@ -227,8 +230,8 @@ class CostOptimizer(CloudOpsBase):
             response = s3.list_buckets()
             
             bucket_count = len(response['Buckets'])
-            # S3 cost estimation is complex, using placeholder
-            estimated_cost = bucket_count * 10.0  # Rough estimate
+            # S3 cost estimation - using standard storage baseline per bucket
+            estimated_cost = bucket_count * get_service_monthly_cost("s3_standard", "us-east-1")
             
             return {
                 'service': 'S3',
@@ -254,7 +257,7 @@ class CostOptimizer(CloudOpsBase):
                 for instance in response['DBInstances']:
                     total_instances += 1
                     instance_class = instance.get('DBInstanceClass', 'db.t3.micro')
-                    estimated_cost += self._estimate_rds_cost(instance_class)
+                    estimated_cost += self._estimate_rds_cost(instance_class, region)
                     
             except Exception as e:
                 print_warning(f"RDS discovery failed in {region}: {str(e)}")
@@ -279,13 +282,13 @@ class CostOptimizer(CloudOpsBase):
                 nat_response = ec2.describe_nat_gateways()
                 nat_count = len(nat_response['NatGateways'])
                 total_resources += nat_count
-                estimated_cost += nat_count * 45.0  # $45/month per NAT gateway
+                estimated_cost += nat_count * get_service_monthly_cost("nat_gateway", region)
                 
                 # Elastic IPs
                 eip_response = ec2.describe_addresses()
                 eip_count = len(eip_response['Addresses'])
                 total_resources += eip_count
-                estimated_cost += eip_count * 3.6  # $3.60/month per unused EIP
+                estimated_cost += eip_count * get_service_monthly_cost("elastic_ip", region)
                 
             except Exception as e:
                 print_warning(f"VPC discovery failed in {region}: {str(e)}")
@@ -297,30 +300,84 @@ class CostOptimizer(CloudOpsBase):
             'optimization_opportunities': ['unused_nat_gateways', 'unused_eips', 'load_balancer_optimization']
         }
     
-    def _estimate_ec2_cost(self, instance_type: str) -> float:
-        """Rough EC2 cost estimation per month."""
-        cost_map = {
-            't3.nano': 3.8, 't3.micro': 7.6, 't3.small': 15.2,
-            't3.medium': 30.4, 't3.large': 60.8, 't3.xlarge': 121.6,
-            'm5.large': 70.1, 'm5.xlarge': 140.2, 'm5.2xlarge': 280.3,
-            'c5.large': 62.1, 'c5.xlarge': 124.2, 'c5.2xlarge': 248.4
-        }
-        return cost_map.get(instance_type, 50.0)  # Default estimate
+    def _estimate_ec2_cost(self, instance_type: str, region: str = "us-east-1") -> float:
+        """EC2 cost estimation using dynamic pricing with fallback."""
+        try:
+            # Map instance types to AWS pricing service keys
+            # For simplicity, using a base cost multiplier approach
+            base_cost = get_service_monthly_cost("ec2_instance", region)
+            
+            # Instance type multipliers based on AWS pricing patterns
+            type_multipliers = {
+                't3.nano': 0.1, 't3.micro': 0.2, 't3.small': 0.4,
+                't3.medium': 0.8, 't3.large': 1.6, 't3.xlarge': 3.2,
+                'm5.large': 1.8, 'm5.xlarge': 3.6, 'm5.2xlarge': 7.2,
+                'c5.large': 1.6, 'c5.xlarge': 3.2, 'c5.2xlarge': 6.4
+            }
+            
+            multiplier = type_multipliers.get(instance_type, 1.0)
+            return base_cost * multiplier
+            
+        except Exception:
+            # Fallback to regional cost calculation if service key not available
+            base_costs = {
+                't3.nano': 3.8, 't3.micro': 7.6, 't3.small': 15.2,
+                't3.medium': 30.4, 't3.large': 60.8, 't3.xlarge': 121.6,
+                'm5.large': 70.1, 'm5.xlarge': 140.2, 'm5.2xlarge': 280.3,
+                'c5.large': 62.1, 'c5.xlarge': 124.2, 'c5.2xlarge': 248.4
+            }
+            base_cost = base_costs.get(instance_type, 50.0)
+            return calculate_regional_cost(base_cost, region)
     
-    def _estimate_ebs_cost(self, size_gb: int, volume_type: str) -> float:
-        """Rough EBS cost estimation per month."""
-        cost_per_gb = {
-            'gp2': 0.10, 'gp3': 0.08, 'io1': 0.125, 'io2': 0.125, 'sc1': 0.025, 'st1': 0.045
-        }
-        return size_gb * cost_per_gb.get(volume_type, 0.10)
+    def _estimate_ebs_cost(self, size_gb: int, volume_type: str, region: str = "us-east-1") -> float:
+        """EBS cost estimation using dynamic pricing."""
+        try:
+            # Map volume types to service keys in our pricing engine
+            volume_service_map = {
+                'gp2': 'ebs_gp2',
+                'gp3': 'ebs_gp3', 
+                'io1': 'ebs_io1',
+                'io2': 'ebs_io2',
+                'sc1': 'ebs_sc1',
+                'st1': 'ebs_st1'
+            }
+            
+            service_key = volume_service_map.get(volume_type, 'ebs_gp2')  # Default to gp2
+            cost_per_gb = get_service_monthly_cost(service_key, region)
+            return size_gb * cost_per_gb
+            
+        except Exception:
+            # Fallback to regional cost calculation
+            cost_per_gb_base = {
+                'gp2': 0.10, 'gp3': 0.08, 'io1': 0.125, 'io2': 0.125, 'sc1': 0.025, 'st1': 0.045
+            }
+            base_cost_per_gb = cost_per_gb_base.get(volume_type, 0.10)
+            regional_cost_per_gb = calculate_regional_cost(base_cost_per_gb, region)
+            return size_gb * regional_cost_per_gb
     
-    def _estimate_rds_cost(self, instance_class: str) -> float:
-        """Rough RDS cost estimation per month."""
-        cost_map = {
-            'db.t3.micro': 14.6, 'db.t3.small': 29.2, 'db.t3.medium': 58.4,
-            'db.m5.large': 140.2, 'db.m5.xlarge': 280.3, 'db.m5.2xlarge': 560.6
-        }
-        return cost_map.get(instance_class, 100.0)  # Default estimate
+    def _estimate_rds_cost(self, instance_class: str, region: str = "us-east-1") -> float:
+        """RDS cost estimation using dynamic pricing with fallback."""
+        try:
+            # Use RDS snapshot pricing as a baseline, then apply instance multipliers
+            base_cost = get_service_monthly_cost("rds_snapshot", region)
+            
+            # Instance class multipliers based on AWS RDS pricing patterns
+            class_multipliers = {
+                'db.t3.micro': 1.0, 'db.t3.small': 2.0, 'db.t3.medium': 4.0,
+                'db.m5.large': 9.6, 'db.m5.xlarge': 19.2, 'db.m5.2xlarge': 38.4
+            }
+            
+            multiplier = class_multipliers.get(instance_class, 6.8)  # Reasonable default multiplier
+            return base_cost * multiplier
+            
+        except Exception:
+            # Fallback to regional cost calculation
+            base_costs = {
+                'db.t3.micro': 14.6, 'db.t3.small': 29.2, 'db.t3.medium': 58.4,
+                'db.m5.large': 140.2, 'db.m5.xlarge': 280.3, 'db.m5.2xlarge': 560.6
+            }
+            base_cost = base_costs.get(instance_class, 100.0)
+            return calculate_regional_cost(base_cost, region)
     
     async def analyze_ec2_rightsizing(self) -> Dict[str, Any]:
         """Analyze EC2 instances for rightsizing opportunities."""
@@ -563,8 +620,8 @@ class CostOptimizer(CloudOpsBase):
                 )
                 
                 if is_unused:
-                    # Estimate cost (approximately $45/month base cost)
-                    estimated_cost = 45.0  # Base NAT Gateway cost
+                    # Estimate cost using dynamic pricing
+                    estimated_cost = get_service_monthly_cost("nat_gateway", region)
                     
                     # Add data processing costs if available
                     # (This would require more detailed Cost Explorer integration)
@@ -680,7 +737,7 @@ class CostOptimizer(CloudOpsBase):
         regions: Optional[List[str]] = None,
         cpu_threshold: float = 5.0,
         duration_hours: int = 168,  # 7 days
-        cost_threshold: float = 10.0
+        cost_threshold: float = None
     ) -> CostOptimizationResult:
         """
         Business Scenario: Stop idle EC2 instances
@@ -706,8 +763,13 @@ class CostOptimizer(CloudOpsBase):
         # Implementation follows similar pattern to NAT Gateway optimization
         # This would integrate the logic from AWS_Stop_Idle_EC2_Instances.ipynb
         
+        # Set dynamic cost threshold if not provided - NO hardcoded defaults
+        if cost_threshold is None:
+            cost_threshold = get_required_env_float('EC2_COST_THRESHOLD')
+        
         print_info(f"Analyzing EC2 instances with <{cpu_threshold}% CPU utilization")
         print_info(f"Analysis period: {duration_hours} hours")
+        print_info(f"Minimum cost threshold: ${cost_threshold}/month")
         
         # Placeholder for detailed implementation
         # In production, this would:

runbooks/common/__init__.py

@@ -1,23 +1,33 @@
 """
-CloudOps Runbooks Common Framework - Enterprise Foundation
+CloudOps Runbooks Common Framework - Universal Foundation
 
-This module provides the foundational enterprise framework components
-extracted from proven FinOps success patterns achieving 99.9996% accuracy,
-280% ROI, and $630K annual value creation.
+This module provides the foundational universal framework components
+that work with ANY AWS setup without hardcoded assumptions.
 
 Components:
 - rich_utils: Beautiful CLI formatting with CloudOps theme
-- profile_utils: Three-tier AWS profile management system
+- profile_utils: Universal AWS profile management (User → AWS_PROFILE → default)
+- date_utils: Dynamic date generation utilities (No hardcoded dates)
 - performance_monitor: Enterprise-grade performance benchmarking
 - context_logger: Context-aware logging for CLI and Jupyter
 - mcp_integration: Phase 4 MCP Integration Framework (NEW)
 - cross_module_integration: Phase 4 Cross-Module Data Flow (NEW)
 - enterprise_audit_integration: Phase 4 Enterprise Audit Framework (NEW)
 
-Version: 0.8.0 - Phase 4 Multi-Module Integration Complete
+Version: 1.0.0 - Universal Compatibility Update
 """
 
 # Rich CLI utilities (CloudOps theme, console, formatting)
+# Dynamic date utilities (No hardcoded dates)
+from .date_utils import (
+    get_aws_cli_example_period,
+    get_collection_timestamp,
+    get_current_month_period,
+    get_current_year,
+    get_previous_month_period,
+    get_test_date_period,
+)
+
 # Phase 4: Cross-Module Integration (Data Flow Architecture)
 from .cross_module_integration import (
     DataFlowContext,
@@ -51,12 +61,12 @@ from .performance_monitor import (
     get_performance_benchmark,
 )
 
-# Profile management utilities (Three-tier enterprise system)
+# Profile management utilities (Universal AWS profile system)
 from .profile_utils import (
     create_cost_session,
     create_management_session,
     create_operational_session,
-    get_enterprise_profile_mapping,
+    get_current_profile_info,
     get_profile_for_operation,
     resolve_profile_for_operation_silent,
     validate_profile_access,
@@ -120,13 +130,20 @@ __all__ = [
     "print_markdown",
     "confirm_action",
     "create_columns",
+    # Dynamic date utilities
+    "get_current_year",
+    "get_current_month_period",
+    "get_previous_month_period",
+    "get_test_date_period",
+    "get_aws_cli_example_period",
+    "get_collection_timestamp",
     # Profile management utilities
     "get_profile_for_operation",
     "resolve_profile_for_operation_silent",
     "create_cost_session",
     "create_management_session",
     "create_operational_session",
-    "get_enterprise_profile_mapping",
+    "get_current_profile_info",
     "validate_profile_access",
     # Performance monitoring framework
     "PerformanceMetrics",