runbooks 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

runbooks/__init__.py

@@ -61,7 +61,7 @@ s3_ops = S3Operations()
 
 # Centralized Version Management - Single Source of Truth
 # All modules MUST import __version__ from this location
-__version__ = "1.1.1"
+__version__ = "1.1.3"
 
 # Fallback for legacy importlib.metadata usage during transition
 try:

runbooks/cfat/assessment/collectors.py

@@ -20,6 +20,7 @@ from typing import Any, Dict, List, Optional
 
 from loguru import logger
 
+from runbooks import __version__
 from runbooks.base import CloudFoundationsBase
 
 
@@ -147,7 +148,7 @@ class VPCCollector(BaseCollector):
                 "internet_gateways": internet_gateways,
                 "route_tables": route_tables,
                 "assessment_metadata": {
-                    "collector_version": "v0.7.8-vpc-enhanced",
+                    "collector_version": f"v{__version__}-vpc-enhanced",
                     "github_issue": "#96",
                     "cost_optimization_enabled": True,
                 },
@@ -165,7 +166,7 @@ class VPCCollector(BaseCollector):
                 "flow_logs": [],
                 "internet_gateways": [],
                 "route_tables": [],
-                "assessment_metadata": {"collector_version": "v0.7.8-vpc-enhanced", "error": str(e)},
+                "assessment_metadata": {"collector_version": f"v{__version__}-vpc-enhanced", "error": str(e)},
             }
 
     def _analyze_nat_optimization(self, nat_gateways: List[Dict], subnets: List[Dict]) -> int:

runbooks/cloudops/cost_optimizer.py

@@ -20,6 +20,7 @@ Source Notebooks:
 """
 
 import asyncio
+import json
 import time
 from typing import Dict, List, Optional, Any, Tuple
 import boto3
@@ -64,25 +65,31 @@ class CostOptimizer(CloudOpsBase):
     """
     
     def __init__(
-        self, 
-        profile: str = "default", 
+        self,
+        profile: str = "default",
         dry_run: bool = True,
-        execution_mode: ExecutionMode = ExecutionMode.DRY_RUN
+        execution_mode: ExecutionMode = ExecutionMode.DRY_RUN,
+        region: str = "us-east-1"
     ):
         """
         Initialize Cost Optimizer with enterprise patterns.
-        
+
         Args:
             profile: AWS profile (typically billing profile for cost data)
             dry_run: Enable safe analysis mode (default True)
             execution_mode: Execution mode for operations
+            region: AWS region for operations (default us-east-1)
         """
         super().__init__(profile, dry_run, execution_mode)
-        
-        print_header("CloudOps Cost Optimizer", "1.0.0")
+
+        # Initialize region attribute
+        self.region = region
+
+        from runbooks import __version__
+        print_header("CloudOps Cost Optimizer", __version__)
         print_info(f"Execution mode: {execution_mode.value}")
         print_info(f"Profile: {profile}")
-        
+
         if dry_run:
             print_warning("🛡️  DRY RUN MODE: No resources will be modified")
 
@@ -1201,41 +1208,44 @@ class CostOptimizer(CloudOpsBase):
         )
     
     async def optimize_workspaces(
-        self, 
+        self,
         usage_threshold_days: int = 180,
+        analysis_days: int = 30,
         dry_run: bool = True
     ) -> CostOptimizationResult:
         """
         Business Scenario: Cleanup unused WorkSpaces with zero usage in last 6 months
         JIRA Reference: FinOps-24
         Expected Savings: USD $12,518 annually
-        
+
         Args:
-            usage_threshold_days: Days of zero usage to consider for deletion
+            usage_threshold_days: Days of zero usage to consider for deletion (default: 180)
+            analysis_days: Period for usage analysis in days, configurable 30/60 (default: 30)
             dry_run: If True, only analyze without deletion
-            
+
         Returns:
             CostOptimizationResult with WorkSpaces cleanup analysis
         """
         operation_name = "WorkSpaces Cost Optimization"
-        print_header(f"🏢 {operation_name} (FinOps-24)")
+        print_header(f"🏢 {operation_name}")
         
         # Import existing workspaces analyzer
         try:
-            from runbooks.finops.workspaces_analyzer import WorkSpacesAnalyzer
-        except ImportError:
-            print_error("WorkSpaces analyzer not available - implementing basic analysis")
+            from runbooks.finops.workspaces_analyzer import WorkSpacesCostAnalyzer, analyze_workspaces
+        except ImportError as e:
+            print_error(f"WorkSpaces analyzer not available: {e}")
+            print_warning("This is likely due to missing dependencies or import issues")
             return CostOptimizationResult(
                 scenario=BusinessScenario.COST_OPTIMIZATION,
                 scenario_name=operation_name,
                 execution_timestamp=datetime.now(),
                 execution_mode=self.execution_mode,
                 success=False,
-                error_message="WorkSpaces analyzer module not found",
+                error_message=f"WorkSpaces analyzer import failed: {e}",
                 # Add required fields to prevent Pydantic validation errors
                 execution_time=0.0,
                 resources_analyzed=0,
-                resources_impacted=[],  # Must be a list, not an integer
+                resources_impacted=[],
                 business_metrics={
                     "total_monthly_savings": 0.0,
                     "overall_risk_level": "low"
@@ -1244,42 +1254,38 @@ class CostOptimizer(CloudOpsBase):
                 aws_profile_used=self.profile or "default",
                 current_monthly_spend=0.0,
                 optimized_monthly_spend=0.0,
-                savings_percentage=0.0
-            )
-        
-        with create_progress_bar() as progress:
-            task = progress.add_task("Analyzing WorkSpaces usage...", total=100)
-            
-            # Step 1: Initialize WorkSpaces analyzer
-            workspaces_analyzer = WorkSpacesAnalyzer(
-                session=self.session,
-                region=self.region
-            )
-            progress.update(task, advance=25)
-            
-            # Step 2: Analyze unused WorkSpaces
-            unused_workspaces = await workspaces_analyzer.find_unused_workspaces(
-                usage_threshold_days=usage_threshold_days
+                savings_percentage=0.0,
+                annual_savings=0.0
             )
-            progress.update(task, advance=50)
-            
-            # Step 3: Calculate cost savings
-            estimated_savings = len(unused_workspaces) * 45  # ~$45/month per WorkSpace
-            progress.update(task, advance=75)
-            
-            # Step 4: Execute cleanup if not dry_run
-            if not dry_run and unused_workspaces:
-                await self._execute_workspaces_cleanup(unused_workspaces)
-            progress.update(task, advance=100)
         
-        # Display results
-        results_table = create_table("WorkSpaces Optimization Results")
-        results_table.add_row("Unused WorkSpaces Found", str(len(unused_workspaces)))
-        results_table.add_row("Monthly Savings", format_cost(estimated_savings))
-        results_table.add_row("Annual Savings", format_cost(estimated_savings * 12))
-        results_table.add_row("Execution Mode", "Analysis Only" if dry_run else "Cleanup Executed")
-        console.print(results_table)
+        # Execute WorkSpaces analysis using proven finops function
+        analysis_results = analyze_workspaces(
+            profile=self.profile,
+            unused_days=usage_threshold_days,
+            analysis_days=analysis_days,
+            output_format="json",
+            dry_run=dry_run
+        )
+
+        # Extract analysis results
+        if analysis_results.get("status") == "success":
+            summary = analysis_results.get("summary", {})
+            estimated_monthly_savings = summary.get("unused_monthly_cost", 0.0)
+            estimated_annual_savings = summary.get("potential_annual_savings", 0.0)
+            unused_workspaces_count = summary.get("unused_workspaces", 0)
+            total_workspaces = summary.get("total_workspaces", 0)
+        else:
+            print_error(f"WorkSpaces analysis failed: {analysis_results.get('error', 'Unknown error')}")
+            estimated_monthly_savings = 0.0
+            estimated_annual_savings = 0.0
+            unused_workspaces_count = 0
+            total_workspaces = 0
         
+        # Calculate savings percentage if we have baseline cost data
+        savings_percentage = 0.0
+        if summary.get("total_monthly_cost", 0) > 0:
+            savings_percentage = (estimated_monthly_savings / summary.get("total_monthly_cost", 1)) * 100
+
         return CostOptimizationResult(
             scenario=BusinessScenario.COST_OPTIMIZATION,
             scenario_name=operation_name,
@@ -1287,30 +1293,44 @@ class CostOptimizer(CloudOpsBase):
             execution_mode=self.execution_mode,
             execution_time=15.0,
             success=True,
-            total_monthly_savings=estimated_savings,
-            annual_savings=estimated_savings * 12,
-            savings_percentage=0.0,  # Would need baseline cost to calculate
-            affected_resources=len(unused_workspaces),
+            # Core cost metrics using correct variable names
+            current_monthly_spend=summary.get("total_monthly_cost", 0.0),
+            optimized_monthly_spend=summary.get("total_monthly_cost", 0.0) - estimated_monthly_savings,
+            total_monthly_savings=estimated_monthly_savings,
+            annual_savings=estimated_annual_savings,
+            savings_percentage=savings_percentage,
+            # Resource metrics
+            affected_resources=unused_workspaces_count,
+            resources_analyzed=total_workspaces,
+            resources_impacted=[],  # Must be a list
             resource_impacts=[
                 ResourceImpact(
-                    resource_id=f"workspaces-cleanup-{len(unused_workspaces)}",
+                    resource_id=f"workspaces-optimization-{unused_workspaces_count}",
                     resource_type="AWS::WorkSpaces::Workspace",
-                    action="terminate",
-                    monthly_savings=estimated_savings,
-                    risk_level=RiskLevel.LOW
+                    resource_name=f"{unused_workspaces_count} unused WorkSpaces",
+                    region=self.session.region_name or "us-east-1",
+                    account_id=self.account_id,
+                    estimated_monthly_cost=summary.get("unused_monthly_cost", 0.0),
+                    projected_savings=estimated_monthly_savings,
+                    risk_level=RiskLevel.LOW,
+                    business_criticality="low",
+                    modification_required=not dry_run
                 )
             ],
-            # Add missing required fields
-            resources_analyzed=len(unused_workspaces),
-            resources_impacted=[],  # Must be a list
+            # Business metrics for executive reporting
             business_metrics={
-                "total_monthly_savings": estimated_savings,
-                "overall_risk_level": "low"
+                "total_monthly_savings": estimated_monthly_savings,
+                "overall_risk_level": "low",
+                "unused_workspaces_count": unused_workspaces_count,
+                "total_workspaces_analyzed": total_workspaces
             },
-            recommendations=[],
-            aws_profile_used=self.profile or "default",
-            current_monthly_spend=0.0,
-            optimized_monthly_spend=0.0
+            recommendations=[
+                f"Terminate {unused_workspaces_count} unused WorkSpaces to save ${estimated_monthly_savings:.2f}/month",
+                f"Estimated annual savings: ${estimated_annual_savings:.2f}",
+                "Verify WorkSpaces are truly unused before termination",
+                "Consider implementing usage monitoring for remaining WorkSpaces"
+            ],
+            aws_profile_used=self.profile or "default"
         )
     
     async def optimize_rds_snapshots(
@@ -1336,20 +1356,70 @@ class CostOptimizer(CloudOpsBase):
         with create_progress_bar() as progress:
             task = progress.add_task("Analyzing RDS manual snapshots...", total=100)
             
-            # Step 1: Discover manual RDS snapshots across regions
+            # Step 1: Discover manual RDS snapshots using proven AWS Config aggregator method
             all_manual_snapshots = []
-            regions = ['us-east-1', 'us-west-2', 'ap-southeast-2']  # Common regions
-            
-            for region in regions:
-                regional_client = self.session.client('rds', region_name=region)
-                try:
-                    response = regional_client.describe_db_snapshots(
-                        SnapshotType='manual',
-                        MaxRecords=100
-                    )
-                    all_manual_snapshots.extend(response.get('DBSnapshots', []))
-                except Exception as e:
-                    print_warning(f"Could not access region {region}: {e}")
+
+            try:
+                # Use AWS Config aggregator to discover all RDS snapshots across organization
+                config_client = self.session.client('config', region_name='ap-southeast-2')
+
+                # Get all RDS snapshots via AWS Config aggregator (proven method)
+                response = config_client.select_aggregate_resource_config(
+                    Expression="SELECT configuration, accountId, awsRegion WHERE resourceType = 'AWS::RDS::DBSnapshot'",
+                    ConfigurationAggregatorName='organization-aggregator',
+                    MaxResults=100  # AWS limit is 100
+                )
+
+                print_info(f"Found {len(response.get('Results', []))} RDS snapshots via AWS Config aggregator")
+
+                # Process snapshots found by Config aggregator
+                for result in response.get('Results', []):
+                    try:
+                        resource_data = json.loads(result)
+                        config_data = resource_data.get('configuration', {})
+
+                        # Handle case where configuration might be a string
+                        if isinstance(config_data, str):
+                            config_data = json.loads(config_data)
+
+                        # Filter for manual snapshots only
+                        if config_data.get('snapshotType') == 'manual':
+                            # Create snapshot object compatible with describe_db_snapshots format
+                            snapshot = {
+                                'DBSnapshotIdentifier': config_data.get('dBSnapshotIdentifier'),
+                                'SnapshotCreateTime': datetime.fromisoformat(config_data.get('snapshotCreateTime', '').replace('Z', '+00:00')) if config_data.get('snapshotCreateTime') else datetime.now(),
+                                'AllocatedStorage': config_data.get('allocatedStorage', 0),
+                                'DBInstanceIdentifier': config_data.get('dBInstanceIdentifier'),
+                                'SnapshotType': config_data.get('snapshotType'),
+                                'Status': config_data.get('status', 'available'),
+                                'Engine': config_data.get('engine'),
+                                'EngineVersion': config_data.get('engineVersion')
+                            }
+                            all_manual_snapshots.append(snapshot)
+                    except Exception as e:
+                        print_warning(f"Error processing snapshot from Config: {e}")
+
+                print_success(f"Successfully processed {len(all_manual_snapshots)} manual snapshots from Config aggregator")
+
+            except Exception as e:
+                print_warning(f"AWS Config aggregator query failed, falling back to regional discovery: {e}")
+
+                # Fallback to regional discovery if Config aggregator fails
+                regions = ['us-east-1', 'us-west-2', 'ap-southeast-2', 'eu-west-1', 'ap-southeast-1']  # Extended regions
+
+                for region in regions:
+                    regional_client = self.session.client('rds', region_name=region)
+                    try:
+                        # Get all manual snapshots in this region
+                        paginator = regional_client.get_paginator('describe_db_snapshots')
+                        page_iterator = paginator.paginate(SnapshotType='manual')
+
+                        for page in page_iterator:
+                            all_manual_snapshots.extend(page.get('DBSnapshots', []))
+
+                        print_info(f"Found {len([s for s in all_manual_snapshots if 'region' not in s])} manual snapshots in {region}")
+                    except Exception as e:
+                        print_warning(f"Could not access region {region}: {e}")
             
             progress.update(task, advance=40)
             
@@ -1363,7 +1433,86 @@ class CostOptimizer(CloudOpsBase):
             
             progress.update(task, advance=70)
             
-            # Step 3: Calculate estimated savings
+            # Step 3: Use enhanced RDS snapshot optimizer for consistent results
+            try:
+                from runbooks.finops.rds_snapshot_optimizer import EnhancedRDSSnapshotOptimizer
+
+                print_info("🔧 Using enhanced RDS snapshot optimization logic...")
+                enhanced_optimizer = EnhancedRDSSnapshotOptimizer(profile=self.profile, dry_run=dry_run)
+
+                if enhanced_optimizer.initialize_session():
+                    # Discover all snapshots (not just manual)
+                    all_snapshots = enhanced_optimizer.discover_snapshots_via_config_aggregator()
+
+                    if all_snapshots:
+                        # Run enhanced optimization analysis
+                        optimization_results = enhanced_optimizer.analyze_optimization_opportunities(
+                            all_snapshots, age_threshold=snapshot_age_threshold_days
+                        )
+
+                        # Use comprehensive scenario for realistic savings
+                        comprehensive_scenario = optimization_results['optimization_scenarios']['comprehensive']
+
+                        # Create resource impacts for comprehensive scenario
+                        resource_impacts = []
+                        for snapshot in comprehensive_scenario['snapshots']:
+                            resource_impacts.append(
+                                ResourceImpact(
+                                    resource_type="rds-snapshot",
+                                    resource_id=snapshot.get('DBSnapshotIdentifier', 'unknown'),
+                                    region=snapshot.get('Region', 'unknown'),
+                                    account_id=snapshot.get('AccountId', 'unknown'),
+                                    estimated_monthly_cost=snapshot.get('EstimatedMonthlyCost', 0.0),
+                                    projected_savings=snapshot.get('EstimatedMonthlyCost', 0.0),
+                                    risk_level=RiskLevel.MEDIUM,
+                                    modification_required=True,
+                                    resource_name=f"RDS Snapshot {snapshot.get('DBSnapshotIdentifier', 'unknown')}",
+                                    estimated_downtime=0.0
+                                )
+                            )
+
+                        progress.update(task, advance=100)
+
+                        return CostOptimizationResult(
+                            scenario=BusinessScenario.COST_OPTIMIZATION,
+                            scenario_name=operation_name,
+                            execution_timestamp=datetime.now(),
+                            execution_mode=self.execution_mode,
+                            execution_time=30.0,
+                            success=True,
+                            error_message=None,
+                            resources_analyzed=optimization_results['total_snapshots'],
+                            resources_impacted=resource_impacts,
+                            business_metrics=self.create_business_metrics(
+                                total_savings=optimization_results['potential_monthly_savings'],
+                                overall_risk=RiskLevel.MEDIUM
+                            ),
+                            recommendations=[
+                                f"Review {optimization_results['cleanup_candidates']} snapshots older than {snapshot_age_threshold_days} days",
+                                f"Potential annual savings: ${optimization_results['potential_annual_savings']:,.2f}",
+                                "Consider implementing automated retention policies",
+                                "Review backup requirements before deletion"
+                            ],
+                            # CostOptimizationResult specific fields
+                            current_monthly_spend=optimization_results.get('current_monthly_spend', 0.0),
+                            optimized_monthly_spend=optimization_results.get('current_monthly_spend', 0.0) - optimization_results['potential_monthly_savings'],
+                            savings_percentage=(optimization_results['potential_monthly_savings'] / max(optimization_results.get('current_monthly_spend', 1), 1)) * 100,
+                            annual_savings=optimization_results['potential_annual_savings'],
+                            total_monthly_savings=optimization_results['potential_monthly_savings'],
+                            affected_resources=optimization_results['cleanup_candidates'],
+                            resource_impacts=resource_impacts
+                        )
+                    else:
+                        print_warning("No snapshots discovered via enhanced optimizer")
+
+            except ImportError as e:
+                print_warning(f"Enhanced optimizer not available, using legacy logic: {e}")
+            except Exception as e:
+                print_warning(f"Enhanced optimizer failed, using legacy logic: {e}")
+
+            # Fallback to legacy calculation for compatibility
+            print_info("Using legacy optimization calculation...")
+            # Step 3: Calculate estimated savings (legacy)
             # Based on JIRA data: $5K-24K range for manual snapshots
             total_size_gb = sum(snapshot.get('AllocatedStorage', 0) for snapshot in old_snapshots)
             estimated_monthly_savings = total_size_gb * 0.05  # ~$0.05/GB-month for snapshots
@@ -1399,8 +1548,11 @@ class CostOptimizer(CloudOpsBase):
                 ResourceImpact(
                     resource_id=f"rds-snapshots-cleanup-{len(old_snapshots)}",
                     resource_type="AWS::RDS::DBSnapshot",
-                    action="delete",
-                    monthly_savings=estimated_monthly_savings,
+                    resource_name=f"RDS Manual Snapshots Cleanup ({len(old_snapshots)} snapshots)",
+                    region=self.region,
+                    account_id=self.account_id,
+                    estimated_monthly_cost=estimated_monthly_savings,
+                    projected_savings=estimated_monthly_savings,
                     risk_level=RiskLevel.MEDIUM
                 )
             ],

runbooks/cloudops/models.py

@@ -164,16 +164,22 @@ class CloudOpsExecutionResult(BaseModel):
 
 class CostOptimizationResult(CloudOpsExecutionResult):
     """Specialized result for cost optimization scenarios."""
-    
+
     # Cost-Specific Metrics
     current_monthly_spend: float = Field(description="Current monthly spend for analyzed resources")
     optimized_monthly_spend: float = Field(description="Projected monthly spend after optimization")
     savings_percentage: float = Field(ge=0, le=100, description="Savings percentage")
-    
+    annual_savings: float = Field(description="Annual savings projection for business scenarios", default=0.0)
+    total_monthly_savings: float = Field(description="Total projected monthly savings", default=0.0)
+
     # Resource Categories
     idle_resources: List[ResourceImpact] = Field(description="Identified idle resources", default=[])
     oversized_resources: List[ResourceImpact] = Field(description="Identified oversized resources", default=[])
     unattached_resources: List[ResourceImpact] = Field(description="Identified unattached resources", default=[])
+
+    # Additional fields used by cost_optimizer.py
+    affected_resources: int = Field(description="Number of resources affected by optimization", default=0)
+    resource_impacts: List[ResourceImpact] = Field(description="Detailed resource impact analysis", default=[])
     
     @field_validator('optimized_monthly_spend')
     @classmethod

runbooks/common/aws_pricing.py

@@ -771,6 +771,18 @@ class DynamicAWSPricing:
                         ]
                     }
             
+            # Handle data_transfer service with graceful fallback
+            if service_key == "data_transfer":
+                print_warning("data_transfer service not supported by AWS Pricing API - using standard rates")
+                # Return standard AWS data transfer pricing structure
+                return AWSPricingResult(
+                    service_key="data_transfer",
+                    region=region,
+                    monthly_cost=0.045,  # $0.045/GB for NAT Gateway data processing
+                    pricing_source="aws_standard_rates",
+                    last_updated=datetime.now()
+                )
+
             if service_key not in service_mapping:
                 raise ValueError(f"Service {service_key} not supported by AWS Pricing API integration")
             

runbooks/common/business_logic.py

@@ -189,7 +189,7 @@ class UniversalBusinessLogic:
         # Apply proven profile management patterns
         selected_profile = get_profile_for_operation("operational", profile)
 
-        print_header(f"{resource_type.title()} {operation.title()}", f"v1.0.0 - {self.module_name}")
+        print_header(f"{resource_type.title()} {operation.title()}", f"v1.1.2 - {self.module_name}")
         print_info(f"Using profile: {selected_profile}")
 
         # Standard operation tracking