runbooks 1.1.1__py3-none-any.whl → 1.1.2__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.2"
 
 # 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

@@ -1201,19 +1201,21 @@ 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
         """
@@ -1222,20 +1224,21 @@ class CostOptimizer(CloudOpsBase):
         
         # 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 +1247,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 +1286,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(
@@ -1399,8 +1412,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")