runbooks 1.1.4__py3-none-any.whl → 1.1.5__py3-none-any.whl

runbooks/vpc/cost_engine.py

@@ -21,22 +21,23 @@ logger = logging.getLogger(__name__)
 @dataclass
 class CostAnalysisCache:
     """Cache for cost analysis results to improve performance."""
+
     cost_data: Dict[str, Any] = field(default_factory=dict)
     last_updated: Dict[str, float] = field(default_factory=dict)
     cache_ttl: int = 300  # 5 minutes
-    
+
     def is_valid(self, cache_key: str) -> bool:
         """Check if cached data is still valid."""
         if cache_key not in self.last_updated:
             return False
         return time.time() - self.last_updated[cache_key] < self.cache_ttl
-    
+
     def get_cached_data(self, cache_key: str) -> Optional[Any]:
         """Get cached data if valid."""
         if self.is_valid(cache_key):
             return self.cost_data.get(cache_key)
         return None
-    
+
     def cache_data(self, cache_key: str, data: Any):
         """Cache data."""
         self.cost_data[cache_key] = data
@@ -46,13 +47,14 @@ class CostAnalysisCache:
 @dataclass
 class ParallelCostMetrics:
     """Metrics for parallel cost analysis operations."""
+
     total_operations: int = 0
     parallel_operations: int = 0
     cache_hits: int = 0
     api_calls: int = 0
     total_time: float = 0.0
     average_operation_time: float = 0.0
-    
+
     def get_cache_hit_ratio(self) -> float:
         """Calculate cache hit ratio."""
         total = self.cache_hits + self.api_calls
@@ -62,7 +64,7 @@ class ParallelCostMetrics:
 class NetworkingCostEngine:
     """
     Enhanced core engine for networking cost calculations and analysis with parallel processing
-    
+
     Performance Features:
     - Parallel cost calculations with ThreadPoolExecutor
     - Intelligent TTL-based caching (5 minutes)
@@ -71,8 +73,14 @@ class NetworkingCostEngine:
     - Real-time performance metrics
     """
 
-    def __init__(self, session: Optional[boto3.Session] = None, config: Optional[VPCNetworkingConfig] = None,
-                 enable_parallel: bool = True, max_workers: int = 10, enable_caching: bool = True):
+    def __init__(
+        self,
+        session: Optional[boto3.Session] = None,
+        config: Optional[VPCNetworkingConfig] = None,
+        enable_parallel: bool = True,
+        max_workers: int = 10,
+        enable_caching: bool = True,
+    ):
         """
         Initialize the enhanced cost engine with performance optimizations
 
@@ -86,17 +94,17 @@ class NetworkingCostEngine:
         self.session = session or boto3.Session()
         self.config = config or load_config()
         self.cost_model = self.config.cost_model
-        
+
         # Performance optimization settings
         self.enable_parallel = enable_parallel
         self.max_workers = max_workers
         self.enable_caching = enable_caching
-        
+
         # Initialize performance components
         self.cost_cache = CostAnalysisCache() if enable_caching else None
         self.performance_metrics = ParallelCostMetrics()
         self.executor = ThreadPoolExecutor(max_workers=max_workers) if enable_parallel else None
-        
+
         # Lazy-loaded clients with connection pooling
         self._cost_explorer_client = None
         self._cloudwatch_client = None
@@ -414,45 +422,45 @@ class NetworkingCostEngine:
         return savings_analysis
 
     # Enhanced Performance Methods for <30s Execution Target
-    
+
     def analyze_vpc_costs_parallel(
-        self, 
-        vpc_ids: List[str], 
+        self,
+        vpc_ids: List[str],
         include_historical: bool = True,
         include_projections: bool = True,
-        days_analysis: int = 30
+        days_analysis: int = 30,
     ) -> Dict[str, Any]:
         """
         Analyze VPC costs in parallel for enhanced performance.
-        
+
         Performance Targets:
         - <30s total execution for up to 50 VPCs
         - ≥99.5% accuracy through intelligent caching
         - 60%+ parallel efficiency over sequential processing
-        
+
         Args:
             vpc_ids: List of VPC IDs to analyze
             include_historical: Include historical cost analysis
             include_projections: Include cost projections
             days_analysis: Number of days to analyze
-            
+
         Returns:
             Comprehensive cost analysis results
         """
         start_time = time.time()
-        
+
         if not self.enable_parallel or len(vpc_ids) <= 2:
             # Sequential processing for small sets or if parallel disabled
             return self._analyze_vpc_costs_sequential(vpc_ids, include_historical, include_projections, days_analysis)
-        
+
         # Prepare parallel cost analysis tasks
         analysis_futures = []
         cost_results = {}
-        
+
         # Split VPCs into batches for optimal parallel processing
         batch_size = max(1, len(vpc_ids) // self.max_workers)
-        vpc_batches = [vpc_ids[i:i + batch_size] for i in range(0, len(vpc_ids), batch_size)]
-        
+        vpc_batches = [vpc_ids[i : i + batch_size] for i in range(0, len(vpc_ids), batch_size)]
+
         try:
             # Submit parallel cost analysis tasks
             for batch_idx, vpc_batch in enumerate(vpc_batches):
@@ -462,14 +470,14 @@ class NetworkingCostEngine:
                     include_historical,
                     include_projections,
                     days_analysis,
-                    f"batch_{batch_idx}"
+                    f"batch_{batch_idx}",
                 )
                 analysis_futures.append(future)
                 self.performance_metrics.parallel_operations += 1
-            
+
             # Collect parallel results with timeout protection
             timeout_seconds = 25  # Leave 5s buffer for processing
-            
+
             for future in as_completed(analysis_futures, timeout=timeout_seconds):
                 try:
                     batch_results = future.result(timeout=5)
@@ -477,20 +485,20 @@ class NetworkingCostEngine:
                 except Exception as e:
                     logger.warning(f"Parallel cost analysis batch failed: {e}")
                     # Continue with other batches
-                    
+
             # Aggregate results from all parallel operations
             aggregated_results = self._aggregate_parallel_cost_results(cost_results)
-            
+
             # Update performance metrics
             total_time = time.time() - start_time
             self.performance_metrics.total_time = total_time
             self.performance_metrics.total_operations = len(vpc_ids)
             self.performance_metrics.average_operation_time = total_time / max(len(vpc_ids), 1)
-            
+
             logger.info(f"Parallel VPC cost analysis completed: {len(vpc_ids)} VPCs in {total_time:.2f}s")
-            
+
             return aggregated_results
-            
+
         except Exception as e:
             logger.error(f"Parallel cost analysis failed: {e}")
             # Fallback to sequential processing
@@ -503,67 +511,59 @@ class NetworkingCostEngine:
         include_historical: bool,
         include_projections: bool,
         days_analysis: int,
-        batch_id: str
+        batch_id: str,
     ) -> Dict[str, Any]:
         """
         Analyze costs for a batch of VPCs with caching optimization.
-        
+
         Args:
             vpc_batch: Batch of VPC IDs to analyze
             include_historical: Include historical analysis
             include_projections: Include cost projections
             days_analysis: Days to analyze
             batch_id: Batch identifier for tracking
-            
+
         Returns:
             Cost analysis results for the batch
         """
         batch_results = {}
-        
+
         for vpc_id in vpc_batch:
             try:
                 # Check cache first for performance optimization
                 cache_key = f"vpc_cost_{vpc_id}_{days_analysis}_{include_historical}_{include_projections}"
-                
+
                 if self.cost_cache:
                     cached_result = self.cost_cache.get_cached_data(cache_key)
                     if cached_result:
                         batch_results[vpc_id] = cached_result
                         self.performance_metrics.cache_hits += 1
                         continue
-                
+
                 # Perform fresh analysis
                 vpc_cost_analysis = self._analyze_single_vpc_costs(
                     vpc_id, include_historical, include_projections, days_analysis
                 )
-                
+
                 # Cache the result
                 if self.cost_cache:
                     self.cost_cache.cache_data(cache_key, vpc_cost_analysis)
-                
+
                 batch_results[vpc_id] = vpc_cost_analysis
                 self.performance_metrics.api_calls += 1
-                
+
             except Exception as e:
                 logger.warning(f"Cost analysis failed for VPC {vpc_id} in batch {batch_id}: {e}")
-                batch_results[vpc_id] = {
-                    "error": str(e),
-                    "vpc_id": vpc_id,
-                    "analysis_failed": True
-                }
-        
+                batch_results[vpc_id] = {"error": str(e), "vpc_id": vpc_id, "analysis_failed": True}
+
         return batch_results
 
     def _analyze_single_vpc_costs(
-        self,
-        vpc_id: str,
-        include_historical: bool,
-        include_projections: bool,
-        days_analysis: int
+        self, vpc_id: str, include_historical: bool, include_projections: bool, days_analysis: int
     ) -> Dict[str, Any]:
         """
         Analyze costs for a single VPC with comprehensive metrics.
-        
+
         Returns:
             Detailed cost analysis for single VPC
         """
@@ -574,82 +574,80 @@ class NetworkingCostEngine:
             "total_cost": 0.0,
             "cost_breakdown": {},
             "optimization_opportunities": [],
-            "performance_metrics": {}
+            "performance_metrics": {},
         }
-        
+
         try:
             # NAT Gateway costs
             nat_gateways = self._get_vpc_nat_gateways(vpc_id)
             nat_gateway_costs = 0.0
-            
+
             for nat_gateway_id in nat_gateways:
                 nat_cost = self.calculate_nat_gateway_cost(nat_gateway_id, days_analysis)
                 nat_gateway_costs += nat_cost.get("total_cost", 0.0)
-            
+
             vpc_cost_data["cost_breakdown"]["nat_gateways"] = nat_gateway_costs
-            
+
             # VPC Endpoints costs
             vpc_endpoints = self._get_vpc_endpoints(vpc_id)
             endpoint_costs = 0.0
-            
+
             for endpoint in vpc_endpoints:
                 endpoint_cost = self.calculate_vpc_endpoint_cost(
                     endpoint.get("VpcEndpointType", "Gateway"),
                     endpoint.get("availability_zones", 1),
-                    0  # Data processing would need additional analysis
+                    0,  # Data processing would need additional analysis
                 )
                 endpoint_costs += endpoint_cost.get("total_monthly_cost", 0.0)
-            
+
             vpc_cost_data["cost_breakdown"]["vpc_endpoints"] = endpoint_costs
-            
+
             # Elastic IPs costs
             elastic_ips = self._get_vpc_elastic_ips(vpc_id)
             eip_costs = 0.0
-            
+
             for eip in elastic_ips:
                 # Estimate idle hours (simplified)
-                eip_cost = self.calculate_elastic_ip_cost(idle_hours=24*days_analysis*0.1)  # 10% idle assumption
+                eip_cost = self.calculate_elastic_ip_cost(idle_hours=24 * days_analysis * 0.1)  # 10% idle assumption
                 eip_costs += eip_cost.get("total_cost", 0.0)
-            
+
             vpc_cost_data["cost_breakdown"]["elastic_ips"] = eip_costs
-            
+
             # Data transfer estimates (simplified)
             data_transfer_cost = self.calculate_data_transfer_cost(
                 inter_az_gb=100,  # Estimated
                 inter_region_gb=50,  # Estimated
-                internet_out_gb=200  # Estimated
+                internet_out_gb=200,  # Estimated
             )
             vpc_cost_data["cost_breakdown"]["data_transfer"] = data_transfer_cost.get("total_cost", 0.0)
-            
+
             # Calculate total cost
             vpc_cost_data["total_cost"] = sum(vpc_cost_data["cost_breakdown"].values())
-            
+
             # Historical analysis if requested
             if include_historical:
                 vpc_cost_data["historical_analysis"] = self._get_historical_vpc_costs(vpc_id, days_analysis)
-            
+
             # Cost projections if requested
             if include_projections:
                 vpc_cost_data["cost_projections"] = self._calculate_vpc_cost_projections(vpc_cost_data, days_analysis)
-            
+
             # Optimization opportunities
             vpc_cost_data["optimization_opportunities"] = self._identify_vpc_optimization_opportunities(vpc_cost_data)
-            
+
         except Exception as e:
             vpc_cost_data["error"] = str(e)
             vpc_cost_data["analysis_failed"] = True
             logger.error(f"Single VPC cost analysis failed for {vpc_id}: {e}")
-        
+
         return vpc_cost_data
 
     def _get_vpc_nat_gateways(self, vpc_id: str) -> List[str]:
         """Get NAT Gateway IDs for a VPC."""
         try:
-            ec2 = self.session.client('ec2')
-            response = ec2.describe_nat_gateways(
-                Filters=[{'Name': 'vpc-id', 'Values': [vpc_id]}]
-            )
-            return [nat['NatGatewayId'] for nat in response.get('NatGateways', [])]
+            ec2 = self.session.client("ec2")
+            response = ec2.describe_nat_gateways(Filters=[{"Name": "vpc-id", "Values": [vpc_id]}])
+            return [nat["NatGatewayId"] for nat in response.get("NatGateways", [])]
         except Exception as e:
             logger.warning(f"Failed to get NAT Gateways for VPC {vpc_id}: {e}")
             return []
@@ -657,11 +655,9 @@ class NetworkingCostEngine:
     def _get_vpc_endpoints(self, vpc_id: str) -> List[Dict[str, Any]]:
         """Get VPC Endpoints for a VPC."""
         try:
-            ec2 = self.session.client('ec2')
-            response = ec2.describe_vpc_endpoints(
-                Filters=[{'Name': 'vpc-id', 'Values': [vpc_id]}]
-            )
-            return response.get('VpcEndpoints', [])
+            ec2 = self.session.client("ec2")
+            response = ec2.describe_vpc_endpoints(Filters=[{"Name": "vpc-id", "Values": [vpc_id]}])
+            return response.get("VpcEndpoints", [])
         except Exception as e:
             logger.warning(f"Failed to get VPC Endpoints for VPC {vpc_id}: {e}")
             return []
@@ -669,47 +665,41 @@ class NetworkingCostEngine:
     def _get_vpc_elastic_ips(self, vpc_id: str) -> List[Dict[str, Any]]:
         """Get Elastic IPs associated with a VPC."""
         try:
-            ec2 = self.session.client('ec2')
+            ec2 = self.session.client("ec2")
             # Get instances in VPC first
-            instances = ec2.describe_instances(
-                Filters=[{'Name': 'vpc-id', 'Values': [vpc_id]}]
-            )
-            
+            instances = ec2.describe_instances(Filters=[{"Name": "vpc-id", "Values": [vpc_id]}])
+
             instance_ids = []
-            for reservation in instances.get('Reservations', []):
-                for instance in reservation.get('Instances', []):
-                    instance_ids.append(instance['InstanceId'])
-            
+            for reservation in instances.get("Reservations", []):
+                for instance in reservation.get("Instances", []):
+                    instance_ids.append(instance["InstanceId"])
+
             # Get EIPs associated with these instances
             addresses = ec2.describe_addresses()
             vpc_eips = []
-            
-            for address in addresses.get('Addresses', []):
-                if address.get('InstanceId') in instance_ids:
+
+            for address in addresses.get("Addresses", []):
+                if address.get("InstanceId") in instance_ids:
                     vpc_eips.append(address)
-            
+
             return vpc_eips
-            
+
         except Exception as e:
             logger.warning(f"Failed to get Elastic IPs for VPC {vpc_id}: {e}")
             return []
 
     def _analyze_vpc_costs_sequential(
-        self, 
-        vpc_ids: List[str],
-        include_historical: bool,
-        include_projections: bool,
-        days_analysis: int
+        self, vpc_ids: List[str], include_historical: bool, include_projections: bool, days_analysis: int
     ) -> Dict[str, Any]:
         """Sequential fallback cost analysis."""
         results = {}
-        
+
         for vpc_id in vpc_ids:
             results[vpc_id] = self._analyze_single_vpc_costs(
                 vpc_id, include_historical, include_projections, days_analysis
             )
             self.performance_metrics.total_operations += 1
-            
+
         return {
             "vpc_costs": results,
             "analysis_method": "sequential",
@@ -717,8 +707,8 @@ class NetworkingCostEngine:
             "performance_metrics": {
                 "total_time": self.performance_metrics.total_time,
                 "average_operation_time": self.performance_metrics.average_operation_time,
-                "cache_hit_ratio": self.performance_metrics.get_cache_hit_ratio()
-            }
+                "cache_hit_ratio": self.performance_metrics.get_cache_hit_ratio(),
+            },
         }
 
     def _aggregate_parallel_cost_results(self, cost_results: Dict[str, Any]) -> Dict[str, Any]:
@@ -727,20 +717,20 @@ class NetworkingCostEngine:
         total_vpcs = len(cost_results)
         failed_analyses = 0
         cost_breakdown_summary = {}
-        
+
         for vpc_id, vpc_data in cost_results.items():
             if vpc_data.get("analysis_failed"):
                 failed_analyses += 1
                 continue
-                
+
             total_cost += vpc_data.get("total_cost", 0.0)
-            
+
             # Aggregate cost breakdowns
             for cost_type, cost_value in vpc_data.get("cost_breakdown", {}).items():
                 if cost_type not in cost_breakdown_summary:
                     cost_breakdown_summary[cost_type] = 0.0
                 cost_breakdown_summary[cost_type] += cost_value
-        
+
         return {
             "vpc_costs": cost_results,
             "summary": {
@@ -749,7 +739,7 @@ class NetworkingCostEngine:
                 "successful_analyses": total_vpcs - failed_analyses,
                 "failed_analyses": failed_analyses,
                 "success_rate": (total_vpcs - failed_analyses) / max(total_vpcs, 1) * 100,
-                "cost_breakdown_summary": cost_breakdown_summary
+                "cost_breakdown_summary": cost_breakdown_summary,
             },
             "analysis_method": "parallel",
             "performance_metrics": {
@@ -758,29 +748,29 @@ class NetworkingCostEngine:
                 "api_calls": self.performance_metrics.api_calls,
                 "cache_hit_ratio": self.performance_metrics.get_cache_hit_ratio(),
                 "total_time": self.performance_metrics.total_time,
-                "average_operation_time": self.performance_metrics.average_operation_time
-            }
+                "average_operation_time": self.performance_metrics.average_operation_time,
+            },
         }
 
     def _get_historical_vpc_costs(self, vpc_id: str, days: int) -> Dict[str, Any]:
         """Get historical cost data for VPC (simplified implementation)."""
         # This would integrate with Cost Explorer for actual historical data
         # For now, return estimated historical trends
-        
+
         return {
             "historical_period_days": days,
             "cost_trend": "stable",  # Could be "increasing", "decreasing", "stable"
             "average_daily_cost": 0.0,  # Would be calculated from actual data
             "peak_daily_cost": 0.0,
             "lowest_daily_cost": 0.0,
-            "trend_analysis": "Stable cost pattern with minor fluctuations"
+            "trend_analysis": "Stable cost pattern with minor fluctuations",
         }
 
     def _calculate_vpc_cost_projections(self, vpc_cost_data: Dict[str, Any], days_analyzed: int) -> Dict[str, Any]:
         """Calculate cost projections based on current analysis."""
         current_total = vpc_cost_data.get("total_cost", 0.0)
         daily_average = current_total / max(days_analyzed, 1)
-        
+
         return {
             "daily_projection": daily_average,
             "weekly_projection": daily_average * 7,
@@ -788,47 +778,53 @@ class NetworkingCostEngine:
             "quarterly_projection": daily_average * 90,
             "annual_projection": daily_average * 365,
             "projection_confidence": "medium",  # Would be based on historical variance
-            "projection_basis": f"Based on {days_analyzed} days analysis"
+            "projection_basis": f"Based on {days_analyzed} days analysis",
         }
 
     def _identify_vpc_optimization_opportunities(self, vpc_cost_data: Dict[str, Any]) -> List[Dict[str, Any]]:
         """Identify cost optimization opportunities for VPC."""
         opportunities = []
         cost_breakdown = vpc_cost_data.get("cost_breakdown", {})
-        
+
         # NAT Gateway optimization
         nat_cost = cost_breakdown.get("nat_gateways", 0.0)
         if nat_cost > 100:  # Monthly threshold
-            opportunities.append({
-                "type": "nat_gateway_optimization",
-                "description": "Consider VPC Endpoints or NAT Instances for high NAT Gateway costs",
-                "potential_savings": nat_cost * 0.3,  # 30% potential savings
-                "implementation_effort": "medium",
-                "risk_level": "low"
-            })
-        
+            opportunities.append(
+                {
+                    "type": "nat_gateway_optimization",
+                    "description": "Consider VPC Endpoints or NAT Instances for high NAT Gateway costs",
+                    "potential_savings": nat_cost * 0.3,  # 30% potential savings
+                    "implementation_effort": "medium",
+                    "risk_level": "low",
+                }
+            )
+
         # VPC Endpoint optimization
         endpoint_cost = cost_breakdown.get("vpc_endpoints", 0.0)
         if endpoint_cost > 50:
-            opportunities.append({
-                "type": "vpc_endpoint_optimization",
-                "description": "Review VPC Endpoint usage and consider Gateway endpoints where possible",
-                "potential_savings": endpoint_cost * 0.2,  # 20% potential savings
-                "implementation_effort": "low",
-                "risk_level": "low"
-            })
-        
+            opportunities.append(
+                {
+                    "type": "vpc_endpoint_optimization",
+                    "description": "Review VPC Endpoint usage and consider Gateway endpoints where possible",
+                    "potential_savings": endpoint_cost * 0.2,  # 20% potential savings
+                    "implementation_effort": "low",
+                    "risk_level": "low",
+                }
+            )
+
         # Elastic IP optimization
         eip_cost = cost_breakdown.get("elastic_ips", 0.0)
         if eip_cost > 20:
-            opportunities.append({
-                "type": "elastic_ip_optimization",
-                "description": "Review idle Elastic IPs and consider release or attachment",
-                "potential_savings": eip_cost * 0.8,  # High savings potential for idle EIPs
-                "implementation_effort": "low",
-                "risk_level": "medium"
-            })
-        
+            opportunities.append(
+                {
+                    "type": "elastic_ip_optimization",
+                    "description": "Review idle Elastic IPs and consider release or attachment",
+                    "potential_savings": eip_cost * 0.8,  # High savings potential for idle EIPs
+                    "implementation_effort": "low",
+                    "risk_level": "medium",
+                }
+            )
+
         return opportunities
 
     def get_cost_engine_performance_metrics(self) -> Dict[str, Any]:
@@ -839,7 +835,7 @@ class NetworkingCostEngine:
                 "parallel_processing_enabled": self.enable_parallel,
                 "max_workers": self.max_workers,
                 "caching_enabled": self.enable_caching,
-                "cache_ttl_seconds": self.cost_cache.cache_ttl if self.cost_cache else 0
+                "cache_ttl_seconds": self.cost_cache.cache_ttl if self.cost_cache else 0,
             },
             "operation_metrics": {
                 "total_operations": self.performance_metrics.total_operations,
@@ -848,23 +844,290 @@ class NetworkingCostEngine:
                 "api_calls": self.performance_metrics.api_calls,
                 "cache_hit_ratio": self.performance_metrics.get_cache_hit_ratio(),
                 "total_time": self.performance_metrics.total_time,
-                "average_operation_time": self.performance_metrics.average_operation_time
+                "average_operation_time": self.performance_metrics.average_operation_time,
             },
             "cache_health": {
                 "cache_size": len(self.cost_cache.cost_data) if self.cost_cache else 0,
-                "valid_entries": sum(
-                    1 for key in self.cost_cache.cost_data.keys() 
-                    if self.cost_cache.is_valid(key)
-                ) if self.cost_cache else 0,
-                "cache_efficiency": "healthy" if self.performance_metrics.get_cache_hit_ratio() > 0.2 else "low"
+                "valid_entries": sum(1 for key in self.cost_cache.cost_data.keys() if self.cost_cache.is_valid(key))
+                if self.cost_cache
+                else 0,
+                "cache_efficiency": "healthy" if self.performance_metrics.get_cache_hit_ratio() > 0.2 else "low",
             },
             "thread_pool_health": {
                 "executor_available": self.executor is not None,
                 "max_workers": self.max_workers if self.executor else 0,
-                "parallel_efficiency": min(100, (self.performance_metrics.parallel_operations / max(self.max_workers, 1)) * 100) if self.enable_parallel else 0
+                "parallel_efficiency": min(
+                    100, (self.performance_metrics.parallel_operations / max(self.max_workers, 1)) * 100
+                )
+                if self.enable_parallel
+                else 0,
+            },
+        }
+
+    def analyze_networking_costs(
+        self,
+        vpc_ids: Optional[List[str]] = None,
+        include_recommendations: bool = True,
+        target_savings_percentage: float = 0.30,
+    ) -> Dict[str, Any]:
+        """
+        Comprehensive networking cost analysis for AWS-25 VPC cleanup requirements.
+
+        Args:
+            vpc_ids: List of VPC IDs to analyze (if None, analyzes all accessible VPCs)
+            include_recommendations: Include optimization recommendations
+            target_savings_percentage: Target savings percentage for recommendations
+
+        Returns:
+            Comprehensive networking cost analysis with optimization opportunities
+        """
+        start_time = time.time()
+
+        try:
+            # If no VPC IDs provided, return empty analysis with recommendations
+            if not vpc_ids:
+                logger.info("No VPCs provided for analysis - generating default cost framework")
+                return self._generate_default_networking_analysis(target_savings_percentage)
+
+            # Analyze costs for provided VPCs
+            vpc_cost_analysis = self.analyze_vpc_costs_parallel(
+                vpc_ids=vpc_ids, include_historical=True, include_projections=True, days_analysis=30
+            )
+
+            # Extract cost summary
+            total_monthly_cost = 0.0
+            cost_breakdown = {}
+
+            if "summary" in vpc_cost_analysis:
+                summary = vpc_cost_analysis["summary"]
+                total_monthly_cost = summary.get("total_cost", 0.0)
+                cost_breakdown = summary.get("cost_breakdown_summary", {})
+
+            # Generate optimization scenarios
+            optimization_scenarios = self._generate_optimization_scenarios(
+                total_monthly_cost, target_savings_percentage
+            )
+
+            # Calculate savings estimates
+            savings_analysis = self.estimate_optimization_savings(
+                current_costs=cost_breakdown or {"networking": total_monthly_cost},
+                optimization_scenarios=optimization_scenarios,
+            )
+
+            analysis_time = time.time() - start_time
+
+            networking_analysis = {
+                "analysis_timestamp": datetime.now().isoformat(),
+                "analysis_duration_seconds": analysis_time,
+                "vpc_analysis": vpc_cost_analysis,
+                "total_monthly_cost": total_monthly_cost,
+                "annual_cost_projection": total_monthly_cost * 12,
+                "cost_breakdown": cost_breakdown,
+                "optimization_scenarios": optimization_scenarios,
+                "savings_analysis": savings_analysis,
+                "target_savings_percentage": target_savings_percentage,
+                "performance_metrics": self.get_cost_engine_performance_metrics(),
+            }
+
+            if include_recommendations:
+                networking_analysis["recommendations"] = self._generate_networking_recommendations(
+                    networking_analysis, target_savings_percentage
+                )
+
+            logger.info(f"Networking cost analysis completed in {analysis_time:.2f}s")
+            return networking_analysis
+
+        except Exception as e:
+            logger.error(f"Networking cost analysis failed: {e}")
+            return {
+                "error": str(e),
+                "analysis_timestamp": datetime.now().isoformat(),
+                "analysis_failed": True,
+                "fallback_analysis": self._generate_default_networking_analysis(target_savings_percentage),
             }
+
+    def _generate_default_networking_analysis(self, target_savings_percentage: float) -> Dict[str, Any]:
+        """Generate default networking analysis when no VPCs are found."""
+        return {
+            "analysis_timestamp": datetime.now().isoformat(),
+            "total_monthly_cost": 0.0,
+            "annual_cost_projection": 0.0,
+            "cost_breakdown": {"nat_gateways": 0.0, "vpc_endpoints": 0.0, "elastic_ips": 0.0, "data_transfer": 0.0},
+            "vpc_count": 0,
+            "target_savings_percentage": target_savings_percentage,
+            "optimization_opportunities": [
+                {
+                    "type": "infrastructure_assessment",
+                    "description": "No VPCs found for analysis - review VPC discovery and permissions",
+                    "potential_savings": 0.0,
+                    "implementation_effort": "low",
+                    "risk_level": "low",
+                }
+            ],
+            "recommendations": [
+                "Verify AWS profile permissions for VPC discovery",
+                "Check regional VPC distribution",
+                "Review multi-account VPC architecture",
+            ],
         }
 
+    def _generate_optimization_scenarios(
+        self, current_monthly_cost: float, target_percentage: float
+    ) -> List[Dict[str, Any]]:
+        """Generate optimization scenarios for networking costs."""
+        base_target = current_monthly_cost * target_percentage
+
+        return [
+            {
+                "name": "Conservative Optimization",
+                "description": "Low-risk optimizations with immediate implementation",
+                "reductions": {
+                    "nat_gateways": 15,  # NAT Gateway → VPC Endpoints
+                    "elastic_ips": 50,  # Release idle EIPs
+                    "data_transfer": 10,  # Optimize data transfer patterns
+                },
+                "risk_level": "low",
+                "effort": "low",
+                "timeline_days": 7,
+            },
+            {
+                "name": "Moderate Optimization",
+                "description": "Medium-risk optimizations with architectural changes",
+                "reductions": {
+                    "nat_gateways": 30,  # Consolidated NAT Gateways
+                    "vpc_endpoints": 20,  # Interface → Gateway endpoints
+                    "elastic_ips": 80,  # Comprehensive EIP audit
+                    "data_transfer": 25,  # Regional optimization
+                },
+                "risk_level": "medium",
+                "effort": "medium",
+                "timeline_days": 21,
+            },
+            {
+                "name": "Aggressive Optimization",
+                "description": "High-impact optimizations requiring significant changes",
+                "reductions": {
+                    "nat_gateways": 50,  # Major architectural refactoring
+                    "vpc_endpoints": 40,  # Complete endpoint strategy review
+                    "elastic_ips": 90,  # Full EIP elimination where possible
+                    "data_transfer": 40,  # Cross-AZ and inter-region optimization
+                },
+                "risk_level": "high",
+                "effort": "high",
+                "timeline_days": 60,
+            },
+        ]
+
+    def _generate_networking_recommendations(
+        self, analysis: Dict[str, Any], target_percentage: float
+    ) -> List[Dict[str, Any]]:
+        """Generate actionable networking cost optimization recommendations."""
+        recommendations = []
+
+        total_cost = analysis.get("total_monthly_cost", 0.0)
+        cost_breakdown = analysis.get("cost_breakdown", {})
+
+        # NAT Gateway recommendations
+        nat_cost = cost_breakdown.get("nat_gateways", 0.0)
+        if nat_cost > 50:  # Monthly threshold
+            recommendations.append(
+                {
+                    "type": "nat_gateway_optimization",
+                    "priority": "high",
+                    "title": "NAT Gateway Cost Optimization",
+                    "description": f"NAT Gateways costing ${nat_cost:.2f}/month - consider VPC Endpoints",
+                    "potential_monthly_savings": nat_cost * 0.3,
+                    "implementation_steps": [
+                        "Identify services using NAT Gateway for AWS API access",
+                        "Implement VPC Endpoints for S3, DynamoDB, and other AWS services",
+                        "Consolidate NAT Gateways across availability zones where possible",
+                        "Monitor data transfer patterns for optimization opportunities",
+                    ],
+                    "risk_assessment": "Low risk with proper testing and staged rollout",
+                }
+            )
+
+        # VPC Endpoint recommendations
+        endpoint_cost = cost_breakdown.get("vpc_endpoints", 0.0)
+        if endpoint_cost > 30:
+            recommendations.append(
+                {
+                    "type": "vpc_endpoint_optimization",
+                    "priority": "medium",
+                    "title": "VPC Endpoint Optimization",
+                    "description": f"VPC Endpoints costing ${endpoint_cost:.2f}/month - review usage patterns",
+                    "potential_monthly_savings": endpoint_cost * 0.2,
+                    "implementation_steps": [
+                        "Audit VPC Endpoint usage patterns",
+                        "Convert Interface endpoints to Gateway endpoints where supported",
+                        "Remove unused VPC Endpoints",
+                        "Consolidate endpoints across multiple VPCs",
+                    ],
+                    "risk_assessment": "Low risk - no service disruption expected",
+                }
+            )
+
+        # Elastic IP recommendations
+        eip_cost = cost_breakdown.get("elastic_ips", 0.0)
+        if eip_cost > 10:
+            recommendations.append(
+                {
+                    "type": "elastic_ip_optimization",
+                    "priority": "high",
+                    "title": "Elastic IP Cost Reduction",
+                    "description": f"Elastic IPs costing ${eip_cost:.2f}/month - high savings potential",
+                    "potential_monthly_savings": eip_cost * 0.8,
+                    "implementation_steps": [
+                        "Identify idle/unattached Elastic IPs",
+                        "Review EIP requirements for each application",
+                        "Implement Application Load Balancer for public endpoints where appropriate",
+                        "Release unused Elastic IPs immediately",
+                    ],
+                    "risk_assessment": "Medium risk - verify connectivity requirements before release",
+                }
+            )
+
+        # Data transfer recommendations
+        transfer_cost = cost_breakdown.get("data_transfer", 0.0)
+        if transfer_cost > 25:
+            recommendations.append(
+                {
+                    "type": "data_transfer_optimization",
+                    "priority": "medium",
+                    "title": "Data Transfer Cost Optimization",
+                    "description": f"Data transfer costing ${transfer_cost:.2f}/month - optimize patterns",
+                    "potential_monthly_savings": transfer_cost * 0.25,
+                    "implementation_steps": [
+                        "Analyze inter-AZ data transfer patterns",
+                        "Optimize application architecture for regional efficiency",
+                        "Implement CloudFront for frequently accessed content",
+                        "Review cross-region replication requirements",
+                    ],
+                    "risk_assessment": "Low risk with proper testing of application performance",
+                }
+            )
+
+        # Add overall assessment
+        if total_cost == 0:
+            recommendations.append(
+                {
+                    "type": "infrastructure_discovery",
+                    "priority": "high",
+                    "title": "Infrastructure Discovery Required",
+                    "description": "No networking costs detected - verify VPC discovery and analysis scope",
+                    "potential_monthly_savings": 0.0,
+                    "implementation_steps": [
+                        "Verify AWS profile permissions for VPC and networking resource access",
+                        "Check multi-region VPC distribution",
+                        "Review organizational unit and account structure",
+                        "Validate Cost Explorer API access for historical data",
+                    ],
+                    "risk_assessment": "No risk - discovery and validation activities only",
+                }
+            )
+
+        return recommendations
+
     def __del__(self):
         """Cleanup resources when cost engine is destroyed."""
         if self.executor: