granny-devops 0.19.2__tar.gz → 0.19.3__tar.gz

{granny_devops-0.19.2 → granny_devops-0.19.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: granny-devops
-Version: 0.19.2
+Version: 0.19.3
 Summary: Cloud tools collection -- AWS infrastructure, CDN, and DevOps automation
 Author-email: Martin Wieser <martin.wieser@pseekoo.com>
 License: MIT License

{granny_devops-0.19.2 → granny_devops-0.19.3}/granny/analyze/costs.py

@@ -335,3 +335,92 @@ def azure_costs(subscriptions: list[str] | None = None) -> list[CostSummary]:
             )
         )
     return out
+
+
+# ---------------------------------------------------------------------------
+# Usage-billed providers
+# ---------------------------------------------------------------------------
+#
+# Bunny and Scaleway both expose real month-to-date spend, so neither needs the
+# run-rate reconstruction Hetzner requires. Neither offers a forecast endpoint,
+# so both derive one the same way: scale month-to-date by how much of the month
+# has elapsed. That is a straight-line projection, not the provider's opinion,
+# and the note on each row says so.
+
+
+def _straight_line_eom(mtd: float, today: date | None = None) -> float:
+    """Project month-to-date spend to month end, pro rata by elapsed days.
+
+    Counts today as elapsed, so the first of the month projects from one day of
+    data rather than dividing by zero.
+    """
+    start, today, end = _month_bounds(today)
+    elapsed = (today - start).days + 1
+    days_in_month = (end - start).days
+    return mtd / elapsed * days_in_month
+
+
+def bunny_costs(customer: str | None = None) -> list[CostSummary]:
+    """Month-to-date Bunny spend, from the prepaid balance drawdown.
+
+    Bunny is prepaid: ``ThisMonthCharges`` is what this month has drawn against
+    a balance already paid in. The remaining balance rides along in the note,
+    because on a prepaid account "how much is left" is the question that
+    actually causes an outage.
+    """
+    from granny.bunny.billing import BunnyBillingClient
+
+    start, _today, end = _month_bounds()
+    try:
+        client = BunnyBillingClient(customer=customer)
+        billing = client.get_billing()
+    except Exception as e:  # noqa: BLE001 - one provider must not abort a sweep
+        logger.warning("Bunny billing: %s", e)
+        return []
+
+    mtd = client.month_to_date(billing)
+    balance = client.balance(billing)
+    note = f"Prepaid; balance EUR {balance:,.2f} remaining. Forecast is straight-line."
+    return [
+        CostSummary(
+            provider="bunny",
+            account=customer or "default",
+            currency="EUR",
+            period_start=start.isoformat(),
+            period_end=end.isoformat(),
+            mtd_cost=mtd,
+            forecast_eom=_straight_line_eom(mtd),
+            note=note,
+        )
+    ]
+
+
+def scaleway_costs(organization_id: str | None = None) -> list[CostSummary]:
+    """Month-to-date Scaleway spend, net of free-tier discounts.
+
+    Scaleway reports consumption per SKU per project, so this total is real but
+    cannot be broken down per resource. The discount lines arrive negative and
+    are already included.
+    """
+    from granny.scaleway.billing import ScalewayBillingClient
+
+    start, _today, end = _month_bounds()
+    try:
+        client = ScalewayBillingClient(organization_id=organization_id)
+        mtd, currency = client.month_to_date()
+    except Exception as e:  # noqa: BLE001 - one provider must not abort a sweep
+        logger.warning("Scaleway billing: %s", e)
+        return []
+
+    return [
+        CostSummary(
+            provider="scaleway",
+            account=client.organization_id,
+            currency=currency,
+            period_start=start.isoformat(),
+            period_end=end.isoformat(),
+            mtd_cost=mtd,
+            forecast_eom=_straight_line_eom(mtd),
+            note="Per-SKU billing; no per-resource split. Forecast is straight-line.",
+        )
+    ]

granny_devops-0.19.3/granny/bunny/__init__.py

@@ -0,0 +1,7 @@
+"""Bunny account-level clients that are not tied to one product.
+
+Bunny's product clients already live under the layer they belong to:
+``granny.cdn.bunny`` for pull zones, ``granny.storage.bunny`` for storage
+zones, ``granny.dns.bunny`` for DNS. Billing spans all three, so it lives
+here rather than picking one of them arbitrarily.
+"""

granny_devops-0.19.3/granny/bunny/billing.py

@@ -0,0 +1,104 @@
+"""Bunny account billing client.
+
+Bunny is prepaid: money goes in as a balance and the month draws it down. So
+``ThisMonthCharges`` is real month-to-date spend, and ``Balance`` is the number
+that decides whether the CDN keeps serving next week.
+
+Per-product costs are only partly available. Each pull zone reports its own
+``MonthlyCharges``, but storage, DNS and per-region traffic are billed as
+account-level totals with no per-zone split. Callers that want a cost per
+storage zone cannot have one.
+"""
+
+import logging
+from typing import Any
+
+import requests
+
+from granny.credentials.secrets import get_bunny_api_key
+
+logger = logging.getLogger(__name__)
+
+API_BASE = "https://api.bunny.net"
+
+# The `/billing` payload carries ~30 MonthlyCharges* fields, nearly all zero for
+# any given account. This maps the ones worth naming onto human labels; the
+# rest are reported generically if they turn out to be non-zero, so a product
+# we have never used does not silently vanish from the breakdown.
+CHARGE_LABELS = {
+    "MonthlyChargesStorage": "Storage",
+    "MonthlyChargesDNS": "DNS",
+    "MonthlyChargesEUTraffic": "Traffic (EU)",
+    "MonthlyChargesUSTraffic": "Traffic (US)",
+    "MonthlyChargesASIATraffic": "Traffic (Asia)",
+    "MonthlyChargesSATraffic": "Traffic (South America)",
+    "MonthlyChargesAFTraffic": "Traffic (Africa)",
+    "MonthlyChargesOptimizer": "Optimizer",
+    "MonthlyChargesShield": "Shield",
+    "MonthlyChargesScripting": "Edge Scripting",
+    "MonthlyChargesLoadBalancer": "Load Balancer",
+    "MonthlyChargesMagicContainers": "Magic Containers",
+    "MonthlyChargesAiGateway": "AI Gateway",
+    "MonthlyChargesDB": "Database",
+    "MonthlyChargesExtraPullZones": "Extra pull zones",
+    "MonthlyChargesExtraStorageZones": "Extra storage zones",
+    "MonthlyChargesExtraDnsZones": "Extra DNS zones",
+    "MonthlyChargesTaxes": "Taxes",
+}
+
+# Not a charge -- it is the sum of them, and adding it to a breakdown would
+# double the total.
+_TOTAL_FIELD = "ThisMonthCharges"
+
+
+class BunnyBillingClient:
+    """Account balance and month-to-date charges."""
+
+    def __init__(self, api_key: str | None = None, customer: str | None = None) -> None:
+        api_key = api_key or get_bunny_api_key(customer)
+        if not api_key:
+            label = f"BUNNY_API_KEY_{customer.upper()}" if customer else "BUNNY_API_KEY"
+            raise ValueError(f"{label} not set (env or vault).")
+        self.session = requests.Session()
+        self.session.headers.update({"AccessKey": api_key, "Content-Type": "application/json"})
+
+    def _request(self, method: str, path: str) -> Any:
+        url = f"{API_BASE}{path}"
+        resp = getattr(self.session, method.lower())(url, timeout=30)
+        if resp.status_code >= 400:
+            raise RuntimeError(f"Bunny {method} {path}: {resp.status_code} {resp.text}")
+        if resp.status_code == 204 or not resp.text:
+            return {}
+        return resp.json()
+
+    def get_billing(self) -> dict:
+        """Raw ``/billing`` payload: balance, totals and per-product charges."""
+        return self._request("GET", "/billing")
+
+    def month_to_date(self, billing: dict | None = None) -> float:
+        billing = self.get_billing() if billing is None else billing
+        return float(billing.get(_TOTAL_FIELD) or 0.0)
+
+    def balance(self, billing: dict | None = None) -> float:
+        billing = self.get_billing() if billing is None else billing
+        return float(billing.get("Balance") or 0.0)
+
+    @staticmethod
+    def charge_breakdown(billing: dict) -> list[tuple[str, float]]:
+        """Non-zero per-product charges, largest first.
+
+        Zero-valued products are dropped rather than rendered as ``0.00``: on
+        an account with thirty charge fields and six in use, listing them all
+        buries the six that matter.
+        """
+        out: list[tuple[str, float]] = []
+        for key, value in billing.items():
+            if not key.startswith("MonthlyCharges") or not value:
+                continue
+            label = CHARGE_LABELS.get(key)
+            if label is None:
+                # An unmapped product we are apparently paying for. Better a
+                # clumsy label than a missing line.
+                label = key.removeprefix("MonthlyCharges")
+            out.append((label, float(value)))
+        return sorted(out, key=lambda pair: -pair[1])

{granny_devops-0.19.2 → granny_devops-0.19.3}/granny/cli/analyze.py

@@ -153,6 +153,11 @@ def vpcs(region: tuple[str, ...], as_json: bool) -> None:
 
 _PROVIDERS = ("aws", "gcp", "azure")
 
+# Only `costs` understands Bunny and Scaleway. `gpus` and `credits` share
+# _PROVIDERS and would offer choices they cannot answer -- neither provider
+# rents GPUs or issues the kind of credit those commands report.
+_COST_PROVIDERS = (*_PROVIDERS, "bunny", "scaleway")
+
 
 def _parse_filter(filter_str: str | None) -> set[str] | None:
     if not filter_str:
@@ -472,9 +477,9 @@ def credits(
 @analyze.command()
 @click.option(
     "--provider",
-    type=click.Choice([*_PROVIDERS, "all"]),
+    type=click.Choice([*_COST_PROVIDERS, "all"]),
     default="all",
-    help="Restrict to one cloud (default: all three)",
+    help="Restrict to one cloud (default: every cloud that reports spend)",
 )
 @click.option("--profile", "profiles", multiple=True, help="AWS profile (repeatable)")
 @click.option(
@@ -486,12 +491,16 @@ def credits(
 @click.option(
     "--subscription", "subscriptions", multiple=True, help="Azure subscription ID (repeatable)"
 )
+@click.option(
+    "--customer", default=None, help="Bunny customer profile (see `granny cdn list-customers`)"
+)
 @click.option("--json-output", "as_json", is_flag=True, help="Output as JSON")
 def costs(
     provider: str,
     profiles: tuple[str, ...],
     billing_accounts: tuple[str, ...],
     subscriptions: tuple[str, ...],
+    customer: str | None,
     as_json: bool,
 ) -> None:
     """Show month-to-date spend and end-of-month forecast per account."""
@@ -499,7 +508,7 @@ def costs(
 
     from granny.analyze import costs as co
 
-    targets = _PROVIDERS if provider == "all" else (provider,)
+    targets = _COST_PROVIDERS if provider == "all" else (provider,)
     rows: list = []
     for p in targets:
         try:
@@ -509,6 +518,10 @@ def costs(
                 rows.extend(co.gcp_costs(billing_accounts=list(billing_accounts) or None))
             elif p == "azure":
                 rows.extend(co.azure_costs(subscriptions=list(subscriptions) or None))
+            elif p == "bunny":
+                rows.extend(co.bunny_costs(customer=customer))
+            elif p == "scaleway":
+                rows.extend(co.scaleway_costs())
         except RuntimeError as e:
             click.echo(f"[{p}] skipped: {e}", err=True)