GitHub Actions Cost-Diff Reporting

name: cost-diff-report

on:
  pull_request:
    types: [opened, synchronize, reopened]

permissions:
  pull-requests: write
  contents: read

jobs:
  cost-diff:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - uses: hashicorp/setup-terraform@v3

      - name: Plan and price head commit
        run: |
          terraform init -input=false
          terraform plan -out=head.tfplan -input=false
          terraform show -json head.tfplan > head_plan.json
          python price_plan.py head_plan.json head_priced.json

      - name: Plan and price base commit
        run: |
          git worktree add /tmp/base $
          cd /tmp/base && terraform init -input=false
          terraform plan -out=base.tfplan -input=false
          terraform show -json base.tfplan > "$GITHUB_WORKSPACE/base_plan.json"
          cd "$GITHUB_WORKSPACE"
          python price_plan.py base_plan.json base_priced.json

      - name: Post cost-diff comment
        env:
          GITHUB_TOKEN: $
        run: |
          python cost_diff_comment.py \
            --repo "$" \
            --pr-number "$" \
            --base-snapshot base_priced.json \
            --head-snapshot head_priced.json

#!/usr/bin/env python3
"""
Post or update a sticky GitHub PR comment showing the per-resource monthly
cost delta between a Terraform plan's base and head snapshots. Idempotent:
re-running against the same PR edits the existing comment instead of adding
a new one, keyed on a hidden HTML marker embedded in the comment body.
"""

from __future__ import annotations

import argparse
import json
import logging
import os
import sys
import time
from dataclasses import dataclass
from pathlib import Path
from typing import Optional

import requests

logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
logger = logging.getLogger("cost_diff_comment")

STICKY_MARKER = "<!-- cost-diff-report:v1 -->"
GITHUB_API = "https://api.github.com"
MAX_ROWS_IN_TABLE = 20


@dataclass
class PricedResource:
    address: str
    resource_type: str
    monthly_usd: float


@dataclass
class ResourceDelta:
    address: str
    resource_type: str
    base_usd: float
    head_usd: float

    @property
    def delta_usd(self) -> float:
        return round(self.head_usd - self.base_usd, 2)

    @property
    def status(self) -> str:
        if self.base_usd == 0.0 and self.head_usd != 0.0:
            return "added"
        if self.head_usd == 0.0 and self.base_usd != 0.0:
            return "removed"
        return "changed" if self.delta_usd != 0.0 else "unchanged"


def retry(times: int = 4, backoff: float = 2.0):
    """Retry a requests call on transient network errors or 429/5xx responses."""
    def decorator(fn):
        def wrapped(*args, **kwargs):
            delay = 1.0
            for attempt in range(1, times + 1):
                try:
                    resp = fn(*args, **kwargs)
                    if resp.status_code == 429 or resp.status_code >= 500:
                        raise requests.exceptions.HTTPError(f"transient {resp.status_code}", response=resp)
                    return resp
                except requests.exceptions.RequestException as exc:
                    if attempt == times:
                        raise
                    logger.warning("attempt %d/%d failed: %s; retrying in %.1fs", attempt, times, exc, delay)
                    time.sleep(delay)
                    delay *= backoff
        return wrapped
    return decorator


def load_snapshot(path: Path) -> dict[str, PricedResource]:
    with path.open("r", encoding="utf-8") as fh:
        rows = json.load(fh)
    resources = {r["address"]: PricedResource(r["address"], r["resource_type"], float(r["monthly_usd"])) for r in rows}
    logger.info("loaded %d priced resource(s) from %s", len(resources), path)
    return resources


def compute_deltas(base: dict[str, PricedResource], head: dict[str, PricedResource]) -> list[ResourceDelta]:
    """Union base/head addresses; a resource missing from one side prices at $0 there."""
    deltas = []
    for addr in sorted(set(base) | set(head)):
        rtype = (head.get(addr) or base.get(addr)).resource_type
        d = ResourceDelta(addr, rtype, base[addr].monthly_usd if addr in base else 0.0,
                           head[addr].monthly_usd if addr in head else 0.0)
        if d.status != "unchanged":
            deltas.append(d)
    deltas.sort(key=lambda d: -abs(d.delta_usd))
    return deltas


def render_comment(deltas: list[ResourceDelta], base_total: float, head_total: float) -> str:
    net = round(head_total - base_total, 2)
    lines = [
        STICKY_MARKER,
        "### Terraform cost-diff",
        "",
        f"**Net monthly change: {'+' if net >= 0 else ''}${net:,.2f}** "
        f"(base ${base_total:,.2f} → head ${head_total:,.2f})",
        "",
        "| Resource | Type | Status | Base $/mo | Head $/mo | Delta $/mo |",
        "|---|---|---|---|---|---|",
    ]
    for d in deltas[:MAX_ROWS_IN_TABLE]:
        sign = "+" if d.delta_usd >= 0 else ""
        lines.append(f"| `{d.address}` | {d.resource_type} | {d.status} | "
                      f"${d.base_usd:,.2f} | ${d.head_usd:,.2f} | {sign}${d.delta_usd:,.2f} |")
    if len(deltas) > MAX_ROWS_IN_TABLE:
        lines.append(f"\n_{len(deltas) - MAX_ROWS_IN_TABLE} additional changed resource(s) omitted._")
    return "\n".join(lines)


@retry()
def _list_comments_page(session: requests.Session, repo: str, pr_number: int, page: int) -> requests.Response:
    return session.get(f"{GITHUB_API}/repos/{repo}/issues/{pr_number}/comments",
                        params={"per_page": 100, "page": page}, timeout=15)


def find_sticky_comment_id(session: requests.Session, repo: str, pr_number: int) -> Optional[int]:
    """Paginate through every comment page looking for the hidden marker."""
    page = 1
    while True:
        resp = _list_comments_page(session, repo, pr_number, page)
        resp.raise_for_status()
        batch = resp.json()
        for comment in batch:
            if STICKY_MARKER in comment.get("body", ""):
                return comment["id"]
        if len(batch) < 100:
            return None
        page += 1


@retry()
def _post_comment(session: requests.Session, repo: str, pr_number: int, body: str) -> requests.Response:
    return session.post(f"{GITHUB_API}/repos/{repo}/issues/{pr_number}/comments", json={"body": body}, timeout=15)


@retry()
def _patch_comment(session: requests.Session, repo: str, comment_id: int, body: str) -> requests.Response:
    return session.patch(f"{GITHUB_API}/repos/{repo}/issues/comments/{comment_id}", json={"body": body}, timeout=15)


def upsert_comment(session: requests.Session, repo: str, pr_number: int, body: str) -> None:
    """Create the sticky comment on the first run; edit it in place on every later run."""
    existing_id = find_sticky_comment_id(session, repo, pr_number)
    if existing_id is None:
        resp = _post_comment(session, repo, pr_number, body)
        resp.raise_for_status()
        logger.info("created cost-diff comment id=%s", resp.json()["id"])
    else:
        _patch_comment(session, repo, existing_id, body).raise_for_status()
        logger.info("updated existing cost-diff comment id=%s", existing_id)


def parse_args(argv: Optional[list[str]] = None) -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Post a sticky Terraform cost-diff PR comment")
    parser.add_argument("--repo", required=True, help="owner/repo, e.g. org/infra")
    parser.add_argument("--pr-number", required=True, type=int)
    parser.add_argument("--base-snapshot", required=True, type=Path)
    parser.add_argument("--head-snapshot", required=True, type=Path)
    parser.add_argument("--token", default=None, help="defaults to $GITHUB_TOKEN")
    return parser.parse_args(argv)


def main() -> int:
    args = parse_args()
    token = args.token or os.environ.get("GITHUB_TOKEN")
    if not token:
        logger.error("no GitHub token supplied via --token or $GITHUB_TOKEN")
        return 2

    base = load_snapshot(args.base_snapshot)
    head = load_snapshot(args.head_snapshot)
    deltas = compute_deltas(base, head)
    base_total = round(sum(r.monthly_usd for r in base.values()), 2)
    head_total = round(sum(r.monthly_usd for r in head.values()), 2)
    logger.info("%d changed resource(s); net delta $%.2f", len(deltas), head_total - base_total)

    session = requests.Session()
    session.headers.update({
        "Authorization": f"Bearer {token}",
        "Accept": "application/vnd.github+json",
        "X-GitHub-Api-Version": "2022-11-28",
    })
    upsert_comment(session, args.repo, args.pr_number, render_comment(deltas, base_total, head_total))
    return 0


if __name__ == "__main__":
    sys.exit(main())