aws-cost-calculator-cli 1.6.2__py3-none-any.whl → 2.4.0__py3-none-any.whl

cost_calculator/cur.py

@@ -0,0 +1,244 @@
+"""
+CUR (Cost and Usage Report) queries via Athena for resource-level analysis.
+"""
+import time
+from datetime import datetime, timedelta
+
+
+# Service name to CUR product code mapping
+SERVICE_TO_PRODUCT_CODE = {
+    'EC2 - Other': 'AmazonEC2',
+    'Amazon Elastic Compute Cloud - Compute': 'AmazonEC2',
+    'Amazon Relational Database Service': 'AmazonRDS',
+    'Amazon Simple Storage Service': 'AmazonS3',
+    'Load Balancing': 'AWSELB',
+    'Elastic Load Balancing': 'AWSELB',
+    'Amazon DynamoDB': 'AmazonDynamoDB',
+    'AWS Lambda': 'AWSLambda',
+    'Amazon CloudFront': 'AmazonCloudFront',
+    'Amazon ElastiCache': 'AmazonElastiCache',
+    'Amazon Elastic MapReduce': 'ElasticMapReduce',
+    'Amazon Kinesis': 'AmazonKinesis',
+    'Amazon Redshift': 'AmazonRedshift',
+    'Amazon Simple Notification Service': 'AmazonSNS',
+    'Amazon Simple Queue Service': 'AmazonSQS',
+}
+
+
+def map_service_to_product_code(service_name):
+    """Map service name to CUR product code"""
+    # Direct mapping
+    if service_name in SERVICE_TO_PRODUCT_CODE:
+        return SERVICE_TO_PRODUCT_CODE[service_name]
+    
+    # Fuzzy matching
+    service_lower = service_name.lower()
+    for key, code in SERVICE_TO_PRODUCT_CODE.items():
+        if key.lower() in service_lower or service_lower in key.lower():
+            return code
+    
+    # Fallback: try to extract from service name
+    # "Amazon Relational Database Service" -> "AmazonRDS"
+    return service_name.replace(' ', '').replace('-', '')
+
+
+def get_cur_config():
+    """Load CUR configuration from config file or environment variables"""
+    import os
+    from pathlib import Path
+    import json
+    
+    # Try config file first
+    config_file = Path.home() / '.config' / 'cost-calculator' / 'cur_config.json'
+    if config_file.exists():
+        with open(config_file) as f:
+            return json.load(f)
+    
+    # Fall back to environment variables
+    return {
+        'database': os.environ.get('CUR_DATABASE', 'cur_database'),
+        'table': os.environ.get('CUR_TABLE', 'cur_table'),
+        's3_output': os.environ.get('CUR_S3_OUTPUT', 's3://your-athena-results-bucket/')
+    }
+
+
+def query_cur_resources(athena_client, accounts, service, account_filter, weeks, 
+                       cur_database=None,
+                       cur_table=None,
+                       s3_output=None):
+    """
+    Query CUR via Athena for resource-level cost details.
+    
+    Args:
+        athena_client: boto3 Athena client
+        accounts: list of account IDs
+        service: service name to filter by
+        account_filter: specific account ID or None for all accounts
+        weeks: number of weeks to analyze
+        cur_database: Athena database name
+        cur_table: CUR table name
+        s3_output: S3 location for query results
+    
+    Returns:
+        list of dicts with resource details
+    """
+    # Load CUR configuration
+    cur_config = get_cur_config()
+    if cur_database is None:
+        cur_database = cur_config['database']
+    if cur_table is None:
+        cur_table = cur_config['table']
+    if s3_output is None:
+        s3_output = cur_config['s3_output']
+    
+    # Calculate date range
+    end_date = datetime.now() - timedelta(days=2)
+    start_date = end_date - timedelta(weeks=weeks)
+    
+    # Map service to product code
+    product_code = map_service_to_product_code(service)
+    
+    # Build account filter
+    if account_filter:
+        account_clause = f"AND line_item_usage_account_id = '{account_filter}'"
+    else:
+        account_list = "','".join(accounts)
+        account_clause = f"AND line_item_usage_account_id IN ('{account_list}')"
+    
+    # Build query - use generic columns that work for all services
+    query = f"""
+    SELECT 
+        line_item_usage_account_id as account_id,
+        line_item_resource_id as resource_id,
+        line_item_usage_type as usage_type,
+        product_region as region,
+        SUM(line_item_unblended_cost) as total_cost,
+        SUM(line_item_usage_amount) as total_usage
+    FROM {cur_database}.{cur_table}
+    WHERE line_item_product_code = '{product_code}'
+      {account_clause}
+      AND line_item_resource_id != ''
+      AND line_item_line_item_type IN ('Usage', 'Fee')
+      AND line_item_usage_start_date >= DATE '{start_date.strftime('%Y-%m-%d')}'
+      AND line_item_usage_start_date < DATE '{end_date.strftime('%Y-%m-%d')}'
+    GROUP BY 1, 2, 3, 4
+    ORDER BY total_cost DESC
+    LIMIT 50
+    """
+    
+    # Execute Athena query
+    try:
+        response = athena_client.start_query_execution(
+            QueryString=query,
+            QueryExecutionContext={'Database': cur_database},
+            ResultConfiguration={'OutputLocation': s3_output}
+        )
+        
+        query_execution_id = response['QueryExecutionId']
+        
+        # Wait for query to complete (max 60 seconds)
+        max_wait = 60
+        wait_interval = 2
+        elapsed = 0
+        
+        while elapsed < max_wait:
+            status_response = athena_client.get_query_execution(
+                QueryExecutionId=query_execution_id
+            )
+            state = status_response['QueryExecution']['Status']['State']
+            
+            if state == 'SUCCEEDED':
+                break
+            elif state in ['FAILED', 'CANCELLED']:
+                reason = status_response['QueryExecution']['Status'].get(
+                    'StateChangeReason', 'Unknown error'
+                )
+                raise Exception(f"Athena query {state}: {reason}")
+            
+            time.sleep(wait_interval)
+            elapsed += wait_interval
+        
+        if elapsed >= max_wait:
+            raise Exception("Athena query timeout after 60 seconds")
+        
+        # Get results
+        results_response = athena_client.get_query_results(
+            QueryExecutionId=query_execution_id,
+            MaxResults=100
+        )
+        
+        # Parse results
+        resources = []
+        rows = results_response['ResultSet']['Rows']
+        
+        # Skip header row
+        for row in rows[1:]:
+            data = row['Data']
+            resources.append({
+                'account_id': data[0].get('VarCharValue', ''),
+                'resource_id': data[1].get('VarCharValue', ''),
+                'usage_type': data[2].get('VarCharValue', ''),
+                'region': data[3].get('VarCharValue', ''),
+                'total_cost': float(data[4].get('VarCharValue', 0)),
+                'total_usage': float(data[5].get('VarCharValue', 0))
+            })
+        
+        return {
+            'resources': resources,
+            'service': service,
+            'product_code': product_code,
+            'account_filter': account_filter,
+            'period': {
+                'start': start_date.strftime('%Y-%m-%d'),
+                'end': end_date.strftime('%Y-%m-%d'),
+                'weeks': weeks
+            }
+        }
+        
+    except Exception as e:
+        raise Exception(f"CUR query failed: {str(e)}")
+
+
+def format_resource_output(result):
+    """Format resource query results for display"""
+    resources = result['resources']
+    service = result['service']
+    account_filter = result.get('account_filter')
+    period = result['period']
+    
+    output = []
+    output.append(f"\n📊 Resource Breakdown: {service}")
+    
+    if account_filter:
+        output.append(f"Account: {account_filter} | Period: {period['start']} to {period['end']} ({period['weeks']} weeks)")
+    else:
+        output.append(f"All Accounts | Period: {period['start']} to {period['end']} ({period['weeks']} weeks)")
+    
+    output.append("")
+    
+    if not resources:
+        output.append("No resources found with costs in this period.")
+        return '\n'.join(output)
+    
+    # Format as table
+    output.append(f"Top {len(resources)} Resources by Cost:")
+    output.append("┌─────────────────────────────┬──────────────────────────────┬────────────┬─────────┐")
+    output.append("│ Resource ID                 │ Usage Type                   │ Region     │ Cost    │")
+    output.append("├─────────────────────────────┼──────────────────────────────┼────────────┼─────────┤")
+    
+    for resource in resources:
+        resource_id = resource['resource_id'][:27] + '...' if len(resource['resource_id']) > 27 else resource['resource_id']
+        usage_type = resource['usage_type'][:28] + '..' if len(resource['usage_type']) > 28 else resource['usage_type']
+        region = resource['region'][:10] if resource['region'] else 'N/A'
+        cost = resource['total_cost']
+        
+        output.append(
+            f"│ {resource_id:<27} │ {usage_type:<28} │ {region:<10} │ ${cost:>6.2f} │"
+        )
+    
+    output.append("└─────────────────────────────┴──────────────────────────────┴────────────┴─────────┘")
+    output.append("")
+    output.append("💡 Tip: Use AWS CLI to investigate specific resources:")
+    output.append(f"  aws ec2 describe-instances --instance-ids <resource-id>")
+    
+    return '\n'.join(output)

cost_calculator/dimensions.py

@@ -0,0 +1,141 @@
+"""
+Dimension mapping between CLI, Cost Explorer, and Athena CUR.
+
+This module provides utilities for translating dimension names across different backends.
+"""
+
+# Dimension mapping: CLI dimension -> (CE dimension, Athena column)
+DIMENSION_MAP = {
+    'service': ('SERVICE', 'line_item_product_code'),
+    'account': ('LINKED_ACCOUNT', 'line_item_usage_account_id'),
+    'region': ('REGION', 'product_region'),
+    'usage_type': ('USAGE_TYPE', 'line_item_usage_type'),
+    'resource': (None, 'line_item_resource_id'),  # Athena only
+    'instance_type': ('INSTANCE_TYPE', 'product_instance_type'),
+    'operation': ('OPERATION', 'line_item_operation'),
+    'availability_zone': ('AVAILABILITY_ZONE', 'product_availability_zone'),
+}
+
+
+def get_ce_dimension(cli_dimension):
+    """
+    Get Cost Explorer dimension key for a CLI dimension.
+    
+    Args:
+        cli_dimension: CLI dimension name (e.g., 'service', 'account')
+    
+    Returns:
+        str: Cost Explorer dimension key (e.g., 'SERVICE', 'LINKED_ACCOUNT')
+        None: If dimension is not available in Cost Explorer
+    
+    Raises:
+        ValueError: If dimension is unknown
+    """
+    if cli_dimension not in DIMENSION_MAP:
+        raise ValueError(f"Unknown dimension: {cli_dimension}")
+    
+    ce_dim, _ = DIMENSION_MAP[cli_dimension]
+    return ce_dim
+
+
+def get_athena_column(cli_dimension):
+    """
+    Get Athena CUR column name for a CLI dimension.
+    
+    Args:
+        cli_dimension: CLI dimension name (e.g., 'service', 'account')
+    
+    Returns:
+        str: Athena column name (e.g., 'line_item_product_code', 'line_item_usage_account_id')
+    
+    Raises:
+        ValueError: If dimension is unknown
+    """
+    if cli_dimension not in DIMENSION_MAP:
+        raise ValueError(f"Unknown dimension: {cli_dimension}")
+    
+    _, athena_col = DIMENSION_MAP[cli_dimension]
+    return athena_col
+
+
+def is_athena_only(cli_dimension):
+    """
+    Check if a dimension is only available in Athena (not in Cost Explorer).
+    
+    Args:
+        cli_dimension: CLI dimension name
+    
+    Returns:
+        bool: True if dimension requires Athena, False otherwise
+    """
+    if cli_dimension not in DIMENSION_MAP:
+        raise ValueError(f"Unknown dimension: {cli_dimension}")
+    
+    ce_dim, _ = DIMENSION_MAP[cli_dimension]
+    return ce_dim is None
+
+
+def get_available_dimensions(backend='auto'):
+    """
+    Get list of available dimensions for a given backend.
+    
+    Args:
+        backend: 'auto', 'ce', or 'athena'
+    
+    Returns:
+        list: List of available dimension names
+    """
+    if backend == 'athena':
+        # All dimensions available in Athena
+        return list(DIMENSION_MAP.keys())
+    elif backend == 'ce':
+        # Only dimensions with CE mapping
+        return [dim for dim, (ce_dim, _) in DIMENSION_MAP.items() if ce_dim is not None]
+    else:  # auto
+        # All dimensions (backend will be auto-selected)
+        return list(DIMENSION_MAP.keys())
+
+
+def validate_dimension_backend(dimension, backend):
+    """
+    Validate that a dimension is available for the specified backend.
+    
+    Args:
+        dimension: CLI dimension name
+        backend: 'auto', 'ce', or 'athena'
+    
+    Returns:
+        tuple: (is_valid, error_message)
+    
+    Examples:
+        >>> validate_dimension_backend('resource', 'ce')
+        (False, "Dimension 'resource' requires Athena backend (not available in Cost Explorer)")
+        
+        >>> validate_dimension_backend('service', 'ce')
+        (True, None)
+    """
+    if dimension not in DIMENSION_MAP:
+        return False, f"Unknown dimension: {dimension}"
+    
+    if backend == 'ce' and is_athena_only(dimension):
+        return False, f"Dimension '{dimension}' requires Athena backend (not available in Cost Explorer)"
+    
+    return True, None
+
+
+# Human-readable dimension descriptions
+DIMENSION_DESCRIPTIONS = {
+    'service': 'AWS Service (e.g., EC2, S3, RDS)',
+    'account': 'AWS Account ID',
+    'region': 'AWS Region (e.g., us-east-1, eu-west-1)',
+    'usage_type': 'Usage Type (e.g., BoxUsage:t3.micro)',
+    'resource': 'Resource ID/ARN (Athena only)',
+    'instance_type': 'Instance Type (e.g., t3.micro, m5.large)',
+    'operation': 'Operation (e.g., RunInstances, CreateBucket)',
+    'availability_zone': 'Availability Zone (e.g., us-east-1a)',
+}
+
+
+def get_dimension_description(dimension):
+    """Get human-readable description for a dimension."""
+    return DIMENSION_DESCRIPTIONS.get(dimension, dimension)

cost_calculator/executor.py

@@ -3,6 +3,7 @@ Executor that routes to either API or local execution.
 """
 import boto3
 import click
+from pathlib import Path
 from cost_calculator.api_client import is_api_configured, call_lambda_api
 
 
@@ -22,6 +23,13 @@ def get_credentials_dict(config):
         try:
             session = boto3.Session(profile_name=config['aws_profile'])
             credentials = session.get_credentials()
+            
+            if credentials is None:
+                raise Exception(
+                    f"Could not get credentials for profile '{config['aws_profile']}'.\n"
+                    f"Run: aws sso login --profile {config['aws_profile']}"
+                )
+            
             frozen_creds = credentials.get_frozen_credentials()
             
             return {
@@ -29,9 +37,44 @@ def get_credentials_dict(config):
                 'secret_key': frozen_creds.secret_key,
                 'session_token': frozen_creds.token
             }
-        except Exception:
-            # If profile not found, return None (API will handle)
-            return None
+        except Exception as e:
+            # Show the actual error instead of silently returning None
+            error_msg = str(e)
+            
+            # If it's an SSO token error, provide better guidance
+            if 'SSO Token' in error_msg or 'sso' in error_msg.lower():
+                # Try to detect if using sso_session format
+                import subprocess
+                try:
+                    result = subprocess.run(
+                        ['grep', '-A', '3', f'profile {config["aws_profile"]}', 
+                         str(Path.home() / '.aws' / 'config')],
+                        capture_output=True,
+                        text=True,
+                        timeout=2
+                    )
+                    if 'sso_session' in result.stdout:
+                        # Extract session name
+                        for line in result.stdout.split('\n'):
+                            if 'sso_session' in line:
+                                session_name = line.split('=')[1].strip()
+                                raise Exception(
+                                    f"Failed to get AWS credentials for profile '{config['aws_profile']}'.\n"
+                                    f"Error: {error_msg}\n\n"
+                                    f"Your profile uses SSO session '{session_name}'.\n"
+                                    f"Try: aws sso login --sso-session {session_name}\n"
+                                    f"(Requires AWS CLI v2.9.0+)\n\n"
+                                    f"Or: aws sso login --profile {config['aws_profile']}\n"
+                                    f"(If using older AWS CLI)"
+                                )
+                except:
+                    pass
+            
+            raise Exception(
+                f"Failed to get AWS credentials for profile '{config['aws_profile']}'.\n"
+                f"Error: {error_msg}\n"
+                f"Try: aws sso login --profile {config['aws_profile']}"
+            )
     else:
         # Use static credentials
         creds = config.get('credentials', {})
@@ -49,39 +92,29 @@ def get_credentials_dict(config):
 
 def execute_trends(config, weeks):
     """
-    Execute trends analysis via API or locally.
+    Execute trends analysis via API.
+    
+    Args:
+        config: Profile configuration
+        weeks: Number of weeks to analyze
     
     Returns:
         dict: trends data
     """
-    accounts = config['accounts']
+    profile_name = config.get('profile_name', config.get('name'))
     
-    if is_api_configured():
-        # Use API
-        click.echo("Using Lambda API...")
-        credentials = get_credentials_dict(config)
-        return call_lambda_api('trends', credentials, accounts, weeks=weeks)
-    else:
-        # Use local execution
-        click.echo("Using local execution...")
-        from cost_calculator.trends import analyze_trends
-        
-        # Initialize boto3 client
-        if 'aws_profile' in config:
-            session = boto3.Session(profile_name=config['aws_profile'])
-        else:
-            creds = config['credentials']
-            session_kwargs = {
-                'aws_access_key_id': creds['aws_access_key_id'],
-                'aws_secret_access_key': creds['aws_secret_access_key'],
-                'region_name': creds.get('region', 'us-east-1')
-            }
-            if 'aws_session_token' in creds:
-                session_kwargs['aws_session_token'] = creds['aws_session_token']
-            session = boto3.Session(**session_kwargs)
-        
-        ce_client = session.client('ce', region_name='us-east-1')
-        return analyze_trends(ce_client, accounts, weeks)
+    if not is_api_configured():
+        raise Exception(
+            "API not configured. Set COST_API_SECRET environment variable.\n"
+            "Local execution is disabled. Use the Lambda API."
+        )
+    
+    # Use API only
+    click.echo("Using Lambda API...")
+    credentials = get_credentials_dict(config)
+    if not credentials:
+        raise Exception("Failed to get AWS credentials. Check your AWS SSO session.")
+    return call_lambda_api('trends', credentials, profile=profile_name, weeks=weeks)
 
 
 def execute_monthly(config, months):
@@ -91,83 +124,70 @@ def execute_monthly(config, months):
     Returns:
         dict: monthly data
     """
-    accounts = config['accounts']
+    profile_name = config.get('profile_name', config.get('name'))
     
-    if is_api_configured():
-        # Use API
-        click.echo("Using Lambda API...")
-        credentials = get_credentials_dict(config)
-        return call_lambda_api('monthly', credentials, accounts, months=months)
-    else:
-        # Use local execution
-        click.echo("Using local execution...")
-        from cost_calculator.monthly import analyze_monthly_trends
-        
-        # Initialize boto3 client
-        if 'aws_profile' in config:
-            session = boto3.Session(profile_name=config['aws_profile'])
-        else:
-            creds = config['credentials']
-            session_kwargs = {
-                'aws_access_key_id': creds['aws_access_key_id'],
-                'aws_secret_access_key': creds['aws_secret_access_key'],
-                'region_name': creds.get('region', 'us-east-1')
-            }
-            if 'aws_session_token' in creds:
-                session_kwargs['aws_session_token'] = creds['aws_session_token']
-            session = boto3.Session(**session_kwargs)
-        
-        ce_client = session.client('ce', region_name='us-east-1')
-        return analyze_monthly_trends(ce_client, accounts, months)
+    if not is_api_configured():
+        raise Exception(
+            "API not configured. Set COST_API_SECRET environment variable.\n"
+            "Local execution is disabled. Use the Lambda API."
+        )
+    
+    # Use API only
+    click.echo("Using Lambda API...")
+    credentials = get_credentials_dict(config)
+    if not credentials:
+        raise Exception("Failed to get AWS credentials. Check your AWS SSO session.")
+    return call_lambda_api('monthly', credentials, profile=profile_name, months=months)
 
 
-def execute_drill(config, weeks, service_filter=None, account_filter=None, usage_type_filter=None):
+def execute_drill(config, weeks, service_filter=None, account_filter=None, usage_type_filter=None, resources=False, dimension=None, backend='auto'):
     """
-    Execute drill-down analysis via API or locally.
+    Execute drill-down analysis via API.
+    
+    Args:
+        config: Profile configuration
+        weeks: Number of weeks to analyze
+        service_filter: Optional service name filter
+        account_filter: Optional account ID filter
+        usage_type_filter: Optional usage type filter
+        resources: If True, query CUR for resource-level details
+        dimension: Dimension to analyze by (service, account, region, usage_type, resource, etc.)
+        backend: Backend to use ('auto', 'ce', 'athena')
     
     Returns:
-        dict: drill data
+        dict: drill data or resource data
     """
-    accounts = config['accounts']
+    profile_name = config.get('profile_name', config.get('name'))
     
-    if is_api_configured():
-        # Use API
-        click.echo("Using Lambda API...")
-        credentials = get_credentials_dict(config)
-        kwargs = {'weeks': weeks}
-        if service_filter:
-            kwargs['service'] = service_filter
-        if account_filter:
-            kwargs['account'] = account_filter
-        if usage_type_filter:
-            kwargs['usage_type'] = usage_type_filter
-        return call_lambda_api('drill', credentials, accounts, **kwargs)
-    else:
-        # Use local execution
-        click.echo("Using local execution...")
-        from cost_calculator.drill import analyze_drill_down
-        
-        # Initialize boto3 client
-        if 'aws_profile' in config:
-            session = boto3.Session(profile_name=config['aws_profile'])
-        else:
-            creds = config['credentials']
-            session_kwargs = {
-                'aws_access_key_id': creds['aws_access_key_id'],
-                'aws_secret_access_key': creds['aws_secret_access_key'],
-                'region_name': creds.get('region', 'us-east-1')
-            }
-            if 'aws_session_token' in creds:
-                session_kwargs['aws_session_token'] = creds['aws_session_token']
-            session = boto3.Session(**session_kwargs)
-        
-        ce_client = session.client('ce', region_name='us-east-1')
-        return analyze_drill_down(
-            ce_client, accounts, weeks,
-            service_filter=service_filter,
-            account_filter=account_filter,
-            usage_type_filter=usage_type_filter
+    if not is_api_configured():
+        raise Exception(
+            "API not configured. Set COST_API_SECRET environment variable.\n"
+            "Local execution is disabled. Use the Lambda API."
         )
+    
+    # Use API only
+    click.echo("Using Lambda API...")
+    credentials = get_credentials_dict(config)
+    if not credentials:
+        raise Exception("Failed to get AWS credentials. Check your AWS SSO session.")
+    
+    kwargs = {'weeks': weeks}
+    if service_filter:
+        kwargs['service'] = service_filter
+    if account_filter:
+        kwargs['account'] = account_filter
+    if usage_type_filter:
+        kwargs['usage_type'] = usage_type_filter
+    if dimension:
+        kwargs['dimension'] = dimension
+    if backend and backend != 'auto':
+        kwargs['backend'] = backend
+    if resources:
+        if not service_filter and not dimension:
+            raise click.ClickException("--service or --dimension is required when using --resources flag")
+        kwargs['resources'] = True
+    
+    return call_lambda_api('drill', credentials, profile=profile_name, **kwargs)
 
 
 def execute_analyze(config, weeks, analysis_type, pattern=None, min_cost=None):
@@ -217,8 +237,11 @@ def execute_profile_operation(operation, profile_name=None, accounts=None, descr
     
     api_secret = os.environ.get('COST_API_SECRET', '')
     
-    # Use profiles endpoint (hardcoded URL)
-    url = 'https://64g7jq7sjygec2zmll5lsghrpi0txrzo.lambda-url.us-east-1.on.aws/'
+    # Use profiles endpoint (can be overridden via environment variable)
+    url = os.environ.get(
+        'COST_CALCULATOR_PROFILES_URL',
+        'https://64g7jq7sjygec2zmll5lsghrpi0txrzo.lambda-url.us-east-1.on.aws/'
+    )
     
     payload = {'operation': operation}
     if profile_name: