Multi-Cloud Reserved Instance Coverage Report

#!/usr/bin/env python3
"""
Reserved Instance Coverage Report
Analyzes RI/Savings Plan coverage and generates purchase recommendations
"""

import argparse
import json
from datetime import datetime, timedelta
from azure.identity import DefaultAzureCredential
from azure.mgmt.consumption import ConsumptionManagementClient
from azure.mgmt.reservations import AzureReservationAPI
from azure.mgmt.costmanagement import CostManagementClient
import pandas as pd
from tabulate import tabulate

class RICoverageAnalyzer:
    def __init__(self, credential, subscription_id=None, billing_account_id=None):
        self.credential = credential
        self.subscription_id = subscription_id
        self.billing_account_id = billing_account_id

        if subscription_id:
            self.consumption_client = ConsumptionManagementClient(
                credential, subscription_id
            )
            self.cost_client = CostManagementClient(credential)

        self.reservation_client = AzureReservationAPI(credential)

    def get_reservation_summaries(self, grain='daily', days=30):
        """Get reservation utilization summaries"""
        end_date = datetime.utcnow()
        start_date = end_date - timedelta(days=days)

        scope = f"/subscriptions/{self.subscription_id}"

        try:
            summaries = list(
                self.consumption_client.reservations_summaries.list(
                    scope=scope,
                    grain=grain,
                    start_date=start_date.strftime('%Y-%m-%d'),
                    end_date=end_date.strftime('%Y-%m-%d')
                )
            )
            return summaries
        except Exception as e:
            print(f"Note: Could not fetch reservation summaries: {e}")
            return []

    def get_reservation_recommendations(self, scope_type='Single', look_back='Last30Days'):
        """Get RI purchase recommendations from Azure"""
        scope = f"/subscriptions/{self.subscription_id}"

        try:
            recommendations = list(
                self.consumption_client.reservation_recommendations.list(
                    scope=scope,
                    filter=f"properties/scope eq '{scope_type}' and properties/lookBackPeriod eq '{look_back}'"
                )
            )
            return recommendations
        except Exception as e:
            print(f"Note: Could not fetch recommendations: {e}")
            return []

    def get_cost_by_pricing_model(self, days=30):
        """Analyze costs by pricing model (On-Demand vs Reserved)"""
        end_date = datetime.utcnow()
        start_date = end_date - timedelta(days=days)

        scope = f"/subscriptions/{self.subscription_id}"

        query = {
            "type": "ActualCost",
            "timeframe": "Custom",
            "timePeriod": {
                "from": start_date.strftime('%Y-%m-%dT00:00:00Z'),
                "to": end_date.strftime('%Y-%m-%dT23:59:59Z')
            },
            "dataset": {
                "granularity": "None",
                "aggregation": {
                    "totalCost": {
                        "name": "Cost",
                        "function": "Sum"
                    }
                },
                "grouping": [
                    {
                        "type": "Dimension",
                        "name": "PricingModel"
                    },
                    {
                        "type": "Dimension",
                        "name": "ServiceName"
                    }
                ]
            }
        }

        try:
            result = self.cost_client.query.usage(scope=scope, parameters=query)
            return self._parse_cost_query_result(result)
        except Exception as e:
            print(f"Error querying costs: {e}")
            return None

    def _parse_cost_query_result(self, result):
        """Parse the cost query result into a DataFrame"""
        if not result.rows:
            return pd.DataFrame()

        columns = [col.name for col in result.columns]
        df = pd.DataFrame(result.rows, columns=columns)

        # Convert cost to float
        if 'Cost' in df.columns:
            df['Cost'] = pd.to_numeric(df['Cost'], errors='coerce')

        return df

    def calculate_coverage_metrics(self, cost_data):
        """Calculate RI coverage metrics from cost data"""
        if cost_data is None or cost_data.empty:
            return None

        # Group by pricing model
        pricing_summary = cost_data.groupby('PricingModel')['Cost'].sum()

        total_cost = pricing_summary.sum()
        on_demand = pricing_summary.get('OnDemand', 0) + pricing_summary.get('On Demand', 0)
        reserved = pricing_summary.get('Reservation', 0) + pricing_summary.get('Reserved', 0)
        savings_plan = pricing_summary.get('SavingsPlan', 0) + pricing_summary.get('Savings Plan', 0)
        spot = pricing_summary.get('Spot', 0)

        covered = reserved + savings_plan
        coverable = on_demand + covered  # Excludes spot

        coverage_pct = (covered / coverable * 100) if coverable > 0 else 0

        return {
            'total_cost': total_cost,
            'on_demand_cost': on_demand,
            'reserved_cost': reserved,
            'savings_plan_cost': savings_plan,
            'spot_cost': spot,
            'coverage_percentage': coverage_pct,
            'potential_savings_low': on_demand * 0.30,  # 30% conservative
            'potential_savings_high': on_demand * 0.55,  # 55% aggressive (3yr)
        }

    def get_utilization_details(self):
        """Get detailed utilization of existing reservations"""
        try:
            reservations = list(
                self.reservation_client.reservation_order.list()
            )

            utilization_data = []
            for order in reservations:
                order_id = order.name

                # Get reservations in this order
                try:
                    items = list(
                        self.reservation_client.reservation.list(
                            reservation_order_id=order_id
                        )
                    )

                    for item in items:
                        utilization_data.append({
                            'order_id': order_id,
                            'reservation_id': item.name,
                            'display_name': getattr(item, 'display_name', 'N/A'),
                            'sku': getattr(item.sku, 'name', 'N/A') if item.sku else 'N/A',
                            'quantity': getattr(item, 'quantity', 0),
                            'term': getattr(item.properties, 'term', 'N/A') if hasattr(item, 'properties') else 'N/A',
                            'provisioning_state': getattr(item, 'provisioning_state', 'N/A'),
                        })
                except Exception as e:
                    print(f"Could not get details for order {order_id}: {e}")

            return utilization_data
        except Exception as e:
            print(f"Error fetching reservations: {e}")
            return []

    def format_recommendations(self, recommendations):
        """Format recommendations for display"""
        if not recommendations:
            return []

        formatted = []
        for rec in recommendations:
            props = rec.properties if hasattr(rec, 'properties') else rec

            formatted.append({
                'sku': getattr(props, 'sku_name', 'N/A') if hasattr(props, 'sku_name') else getattr(props, 'recommended_resource_type', 'N/A'),
                'location': getattr(props, 'location', 'N/A'),
                'recommended_quantity': getattr(props, 'recommended_quantity', 0),
                'term': getattr(props, 'term', 'N/A'),
                'cost_with_no_ri': getattr(props, 'cost_with_no_reserved_instances', 0),
                'net_savings': getattr(props, 'net_savings', 0),
                'first_usage_date': str(getattr(props, 'first_usage_date', 'N/A')),
            })

        return formatted

    def generate_report(self, days=30):
        """Generate comprehensive RI coverage report"""
        print("=" * 70)
        print("RESERVED INSTANCE COVERAGE REPORT")
        print(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        print(f"Analysis Period: Last {days} days")
        print("=" * 70)

        # 1. Cost Analysis by Pricing Model
        print("\n📊 COST ANALYSIS BY PRICING MODEL")
        print("-" * 50)

        cost_data = self.get_cost_by_pricing_model(days=days)
        metrics = self.calculate_coverage_metrics(cost_data)

        if metrics:
            print("Total Compute Cost:      $%s" % format(metrics['total_cost'], ',.2f'))
            print("On-Demand Cost:          $%s" % format(metrics['on_demand_cost'], ',.2f'))
            print("Reserved Cost:           $%s" % format(metrics['reserved_cost'], ',.2f'))
            print("Savings Plan Cost:       $%s" % format(metrics['savings_plan_cost'], ',.2f'))
            print("Spot Cost:               $%s" % format(metrics['spot_cost'], ',.2f'))
            print("\n🎯 COVERAGE: %.1f%%" % metrics['coverage_percentage'])
            print("\n💰 POTENTIAL ANNUAL SAVINGS:")
            print("   Conservative (1yr RI): $%s" % format(metrics['potential_savings_low'] * 12, ',.2f'))
            print("   Aggressive (3yr RI):   $%s" % format(metrics['potential_savings_high'] * 12, ',.2f'))
        else:
            print("Could not retrieve cost data. Check permissions.")

        # 2. Existing Reservation Utilization
        print("\n📈 EXISTING RESERVATION INVENTORY")
        print("-" * 50)

        utilization = self.get_utilization_details()
        if utilization:
            df = pd.DataFrame(utilization)
            print(tabulate(df, headers='keys', tablefmt='grid', showindex=False))
        else:
            print("No existing reservations found or could not retrieve data.")

        # 3. Purchase Recommendations
        print("\n🛒 PURCHASE RECOMMENDATIONS")
        print("-" * 50)

        recommendations = self.get_reservation_recommendations()
        formatted_recs = self.format_recommendations(recommendations)

        if formatted_recs:
            df = pd.DataFrame(formatted_recs)
            print(tabulate(df, headers='keys', tablefmt='grid', showindex=False))

            total_potential_savings = sum(r.get('net_savings', 0) for r in formatted_recs)
            print("\nTotal Recommended Savings: $%s/year" % format(total_potential_savings, ',.2f'))
        else:
            print("No recommendations available. This could mean:")
            print("  - You already have optimal coverage")
            print("  - Usage is too variable for commitments")
            print("  - Insufficient data (need 30+ days of usage)")

        # 4. Action Items
        print("\n✅ RECOMMENDED ACTIONS")
        print("-" * 50)

        if metrics and metrics['coverage_percentage'] < 70:
            print("⚠️  Coverage is %.1f%% - target is 70-80%%" % metrics['coverage_percentage'])
            print("   → Review purchase recommendations above")
            print("   → Start with 1-year terms for new workloads")
            print("   → Consider 3-year terms for stable, long-running VMs")
        elif metrics and metrics['coverage_percentage'] < 50:
            print("🚨 Coverage is critically low at %.1f%%" % metrics['coverage_percentage'])
            print("   → Immediate action required")
            print("   → Prioritize largest on-demand spenders")
        else:
            print("✅ Coverage looks healthy. Review quarterly to maintain.")

        print("\n" + "=" * 70)

        return dict(
            metrics=metrics,
            utilization=utilization,
            recommendations=formatted_recs
        )


def main():
    parser = argparse.ArgumentParser(
        description='Analyze Reserved Instance coverage and get recommendations'
    )
    parser.add_argument(
        '--subscription', '-s',
        help='Azure Subscription ID',
        required=True
    )
    parser.add_argument(
        '--billing-account', '-b',
        help='Azure Billing Account ID (for multi-subscription analysis)',
        default=None
    )
    parser.add_argument(
        '--days', '-d',
        type=int,
        default=30,
        help='Number of days to analyze (default: 30)'
    )
    parser.add_argument(
        '--output', '-o',
        help='Output file path for JSON report',
        default=None
    )

    args = parser.parse_args()

    print("🔐 Authenticating with Azure...")
    credential = DefaultAzureCredential()

    analyzer = RICoverageAnalyzer(
        credential=credential,
        subscription_id=args.subscription,
        billing_account_id=args.billing_account
    )

    report = analyzer.generate_report(days=args.days)

    if args.output:
        # Convert to JSON-serializable format
        output_data = dict(
            generated_at=datetime.now().isoformat(),
            subscription_id=args.subscription,
            analysis_days=args.days,
            metrics=report['metrics'],
            recommendations=report['recommendations']
        )

        with open(args.output, 'w') as f:
            json.dump(output_data, f, indent=2, default=str)

        print("\n📄 Report saved to: " + args.output)


if __name__ == "__main__":
    main()