feat(gcp): add Cloud DNS catalog pricing (RC3-023c, #78) (#93)

* feat(gcp): add Cloud DNS catalog pricing (RC3-023c, #78)

Adds GCP Cloud DNS pricing (managed zone monthly fee, DNS query volume)
sourced from the live Cloud Billing Catalog (service FA26-5236-B8B5):
$0.20/$0.10/$0.03 per zone-month across the 1-25/26-10,000/10,001+
tiers, and $0.40/$0.20 per million queries below/above 1B queries per
month. Both SKUs are global (region-invariant). Public, private,
forwarding, and peering zone types share a single rate ladder per the
live pricing page, so zone_type is validated but does not affect rate
selection. Routing-policy queries, health checks, DNS Armor, DNSSEC,
and Response Policies have no catalog SKU under this service and are
out of scope for this pass.

* fix(gcp): address code-review findings for Cloud DNS pricing (#78)

Fix a wire-format bug where DNS zone/query tier breakdowns reported
counts under a GB-specific "gbs" JSON field (renamed to "quantity",
shared with External IP egress breakdowns which were already
GB-denominated); wire DNS zone_count/queries_per_month through to
monthly_estimate in get_price the same way storage specs already are;
extract a shared SKU tieredRates unwrap helper used by KMS/BigQuery/AI
and DNS pricing; extract shared fallback-resolution, price-builder,
and tiered-estimate helpers to remove duplication between the zone and
query pricing paths; relax zone_type from a hard-rejecting enum to an
informational field since it never affects price; add a defensive
GLOBAL-scope filter and duplicate-match warning when matching Cloud
DNS SKUs by description; and consolidate five duplicated DecisionMatrix
catalog-hint entries into one.

Author: x7even

opencloudcosts-go/internal/models/models.go

@@ -59,6 +59,7 @@ const (
 	PricingDomainObservability     PricingDomain = "observability"
 	PricingDomainInterRegionEgress PricingDomain = "inter_region_egress"
 	PricingDomainSecurity          PricingDomain = "security"
+	PricingDomainDNS               PricingDomain = "dns"
 )
 
 // PriceUnit describes the unit of a price.
@@ -77,6 +78,7 @@ const (
 	PriceUnitPerUnit            PriceUnit = "per_unit"
 	PriceUnitPerKeyVersionMonth PriceUnit = "per_key_version_month"
 	PriceUnitPerOperation       PriceUnit = "per_operation"
+	PriceUnitPerZoneMonth       PriceUnit = "per_zone_month"
 )
 
 // PricingSpec is the marker interface for all pricing specification variants.
@@ -667,6 +669,67 @@ func (s *KMSPricingSpec) UnmarshalJSON(data []byte) error {
 	return json.Unmarshal(data, (*alias)(s))
 }
 
+// DNSPricingSpec prices GCP Cloud DNS managed zones and DNS queries
+// (domain=dns, service=cloud_dns).
+//
+// Cloud DNS bills along two independent, region-invariant dimensions:
+//   - a per-zone-month charge, volume-discounted by the total managed-zone
+//     count (zones 1-25, 26-10,000, 10,001+); and
+//   - a per-query charge for standard DNS resolution (port 53) queries,
+//     volume-discounted above 1,000,000,000 queries/month.
+//
+// zone_type does NOT change price: public, private, forwarding, and (by
+// inference) peering zones all resolve to the single shared ManagedZone tier
+// ladder (verified live against the GCP Cloud Billing Catalog API, issue
+// #78). ZoneType is retained as a validated, informational field only —
+// mirroring the role KeyType plays in KMSPricingSpec — not because it
+// selects a different rate.
+//
+// "Routing policy queries" ($0.70/$0.35 per million) are a real, documented
+// GCP charge but have no catalog SKU under this service ID; they are out of
+// scope for this spec.
+//
+// Pricing is region-invariant (scope="global" on every returned
+// NormalizedPrice); Region is accepted but ignored by the GCP provider.
+type DNSPricingSpec struct {
+	BasePricingSpec
+	// ZoneType is informational only — every zone type shares the single
+	// ManagedZone tier ladder, so this field never changes price.
+	// "public" (default) | "private" | "forwarding" | "peering".
+	ZoneType string `json:"zone_type,omitempty"`
+	// ZoneCount is the optional total managed-zone count (across all zone
+	// types) for a monthly cost estimate.
+	ZoneCount *float64 `json:"zone_count,omitempty"`
+	// QueriesPerMonth is the optional monthly DNS query volume (port 53) for
+	// a monthly cost estimate.
+	QueriesPerMonth *float64 `json:"queries_per_month,omitempty"`
+}
+
+var _ PricingSpec = (*DNSPricingSpec)(nil)
+
+// CacheKey implements PricingSpec.
+func (s *DNSPricingSpec) CacheKey() string {
+	zoneCount := ""
+	if s.ZoneCount != nil {
+		zoneCount = fmt.Sprintf("%v", *s.ZoneCount)
+	}
+	queries := ""
+	if s.QueriesPerMonth != nil {
+		queries = fmt.Sprintf("%v", *s.QueriesPerMonth)
+	}
+	return fmt.Sprintf("%s:%s:%s:%s", s.baseCacheKey(), s.ZoneType, zoneCount, queries)
+}
+
+// UnmarshalJSON pre-populates defaults then decodes.
+func (s *DNSPricingSpec) UnmarshalJSON(data []byte) error {
+	*s = DNSPricingSpec{
+		BasePricingSpec: defaultBase(),
+		ZoneType:        "public",
+	}
+	type alias DNSPricingSpec
+	return json.Unmarshal(data, (*alias)(s))
+}
+
 // NormalizePaymentOption returns the canonical SP payment option string or an
 // error for unknown values. The SP JSON uses these exact case-sensitive strings.
 func NormalizePaymentOption(s string) (string, error) {
@@ -697,7 +760,7 @@ type domainPeek struct {
 // Pydantic's discriminated-union behaviour on the PricingSpec type in models.py.
 //
 // Supported domains: compute, storage, database, container, ai, serverless,
-// analytics, network, observability, inter_region_egress, security.
+// analytics, network, observability, inter_region_egress, security, dns.
 func UnmarshalPricingSpec(data []byte) (PricingSpec, error) {
 	var peek domainPeek
 	if err := json.Unmarshal(data, &peek); err != nil {
@@ -782,6 +845,13 @@ func UnmarshalPricingSpec(data []byte) (PricingSpec, error) {
 		}
 		return &s, nil
 
+	case PricingDomainDNS:
+		var s DNSPricingSpec
+		if err := json.Unmarshal(data, &s); err != nil {
+			return nil, fmt.Errorf("models: DNSPricingSpec: %w", err)
+		}
+		return &s, nil
+
 	default:
 		return nil, fmt.Errorf("models: unknown pricing domain %q", peek.Domain)
 	}

opencloudcosts-go/internal/models/models_test.go

@@ -857,6 +857,61 @@ func TestUnmarshal_KMSFieldsAndDispatch(t *testing.T) {
 	}
 }
 
+func TestUnmarshal_DNSDefaults(t *testing.T) {
+	data := []byte(`{"domain":"dns","provider":"gcp","service":"cloud_dns","region":"us-central1"}`)
+	got, err := UnmarshalPricingSpec(data)
+	if err != nil {
+		t.Fatalf("UnmarshalPricingSpec: %v", err)
+	}
+	d, ok := got.(*DNSPricingSpec)
+	if !ok {
+		t.Fatalf("expected *DNSPricingSpec, got %T", got)
+	}
+	if d.ZoneType != "public" {
+		t.Errorf("ZoneType default: got %q, want %q", d.ZoneType, "public")
+	}
+	if d.ZoneCount != nil {
+		t.Errorf("ZoneCount default: got %v, want nil", d.ZoneCount)
+	}
+	if d.QueriesPerMonth != nil {
+		t.Errorf("QueriesPerMonth default: got %v, want nil", d.QueriesPerMonth)
+	}
+}
+
+func TestUnmarshal_DNSFieldsAndDispatch(t *testing.T) {
+	// Exercises the real MCP entry path (JSON -> UnmarshalPricingSpec ->
+	// DNSPricingSpec.UnmarshalJSON) with explicit non-default fields, so a
+	// discriminator or default-seeding regression here would be caught
+	// rather than only in tests that construct DNSPricingSpec directly.
+	data := []byte(`{"provider":"gcp","domain":"dns","service":"cloud_dns","zone_type":"private","zone_count":10,"queries_per_month":5000000}`)
+	got, err := UnmarshalPricingSpec(data)
+	if err != nil {
+		t.Fatalf("UnmarshalPricingSpec: %v", err)
+	}
+	d, ok := got.(*DNSPricingSpec)
+	if !ok {
+		t.Fatalf("expected *DNSPricingSpec, got %T", got)
+	}
+	if d.Provider != CloudProviderGCP {
+		t.Errorf("Provider: got %q, want %q", d.Provider, CloudProviderGCP)
+	}
+	if d.Domain != PricingDomainDNS {
+		t.Errorf("Domain: got %q, want %q", d.Domain, PricingDomainDNS)
+	}
+	if d.Service != "cloud_dns" {
+		t.Errorf("Service: got %q, want %q", d.Service, "cloud_dns")
+	}
+	if d.ZoneType != "private" {
+		t.Errorf("ZoneType: got %q, want %q", d.ZoneType, "private")
+	}
+	if d.ZoneCount == nil || *d.ZoneCount != 10 {
+		t.Errorf("ZoneCount: got %v, want 10", d.ZoneCount)
+	}
+	if d.QueriesPerMonth == nil || *d.QueriesPerMonth != 5000000 {
+		t.Errorf("QueriesPerMonth: got %v, want 5000000", d.QueriesPerMonth)
+	}
+}
+
 func TestUnmarshal_ContainerDefaults(t *testing.T) {
 	data := []byte(`{"domain":"container","provider":"aws","region":"us-east-1"}`)
 	got, err := UnmarshalPricingSpec(data)
@@ -1365,6 +1420,72 @@ func TestCacheKey_EgressPricingSpec(t *testing.T) {
 	}
 }
 
+// TestCacheKey_DNSPricingSpec verifies zone_type is embedded in the cache key
+// (differentiating an informational-but-attribute-tagged request), and that
+// ZoneCount/QueriesPerMonth — being optional *float64 fields that directly
+// change the computed monthly_cost — are also embedded, mirroring the
+// nil-safe pointer-field convention used by StoragePricingSpec.CacheKey.
+// Omitting these from the cache key would let two requests that differ only
+// in zone_count or queries_per_month collide on the same key despite pricing
+// to different monthly costs.
+func TestCacheKey_DNSPricingSpec(t *testing.T) {
+	zoneCount := 10.0
+	queries := 5_000_000.0
+
+	tests := []struct {
+		name string
+		spec DNSPricingSpec
+		want string
+	}{
+		{
+			name: "zone_type only, no quantities",
+			spec: DNSPricingSpec{
+				BasePricingSpec: BasePricingSpec{
+					Provider: CloudProviderGCP,
+					Domain:   PricingDomainDNS,
+					Service:  "cloud_dns",
+					Term:     PricingTermOnDemand,
+				},
+				ZoneType: "public",
+			},
+			want: "gcp:dns:cloud_dns::on_demand:public::",
+		},
+		{
+			name: "zone_count and queries_per_month set",
+			spec: DNSPricingSpec{
+				BasePricingSpec: BasePricingSpec{
+					Provider: CloudProviderGCP,
+					Domain:   PricingDomainDNS,
+					Service:  "cloud_dns",
+					Term:     PricingTermOnDemand,
+				},
+				ZoneType:        "private",
+				ZoneCount:       &zoneCount,
+				QueriesPerMonth: &queries,
+			},
+			want: "gcp:dns:cloud_dns::on_demand:private:10:5e+06",
+		},
+	}
+
+	for _, tc := range tests {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			got := tc.spec.CacheKey()
+			if got != tc.want {
+				t.Errorf("CacheKey() = %q, want %q", got, tc.want)
+			}
+		})
+	}
+
+	// Different zone_count values must not collide on the same cache key.
+	other := 20.0
+	a := DNSPricingSpec{ZoneType: "public", ZoneCount: &zoneCount}
+	b := DNSPricingSpec{ZoneType: "public", ZoneCount: &other}
+	if a.CacheKey() == b.CacheKey() {
+		t.Errorf("CacheKey() collided for different zone_count values: %q", a.CacheKey())
+	}
+}
+
 // --------------------------------------------------------------------------
 // UnmarshalPricingSpec error cases.
 // --------------------------------------------------------------------------

opencloudcosts-go/internal/providers/gcp/gcp.go

@@ -15,6 +15,7 @@ import (
 	"io"
 	"log/slog"
 	"net/http"
+	"sort"
 	"strings"
 	"time"
 
@@ -375,40 +376,64 @@ func skuMatchesRegion(regions []any, region string) bool {
 	return false
 }
 
-// skuPrice extracts the first-tier unit price (startUsageAmount == 0) from a raw
-// GCP SKU map[string]any returned by the Billing Catalog API.
-func skuPrice(sku map[string]any) float64 {
+// tierRate is one parsed (startUsageAmount, unitPrice) pair from a raw GCP
+// SKU's pricingInfo[0].pricingExpression.tieredRates.
+type tierRate struct {
+	start float64
+	price float64
+}
+
+// skuTierList parses every tiered unit price out of a raw GCP SKU
+// (map[string]any as returned by the Billing Catalog API), sorted ascending
+// by startUsageAmount (ties keep their original relative order). It is the
+// single shared JSON-unwrap step behind skuPrice (below — first zero-start
+// tier), skuPaidPrice (gcp_ai.go — first tier with startUsageAmount > 0), and
+// skuAllTierRates (gcp_dns.go — every tier, for SKUs with more than two
+// tiers); previously each reimplemented this same
+// pricingInfo->pricingExpression->tieredRates unwrap independently.
+func skuTierList(sku map[string]any) []tierRate {
 	pi, _ := sku["pricingInfo"].([]any)
 	if len(pi) == 0 {
-		return 0
+		return nil
 	}
 	pe, _ := pi[0].(map[string]any)
 	if pe == nil {
-		return 0
+		return nil
 	}
 	expr, _ := pe["pricingExpression"].(map[string]any)
 	if expr == nil {
-		return 0
+		return nil
 	}
 	tiers, _ := expr["tieredRates"].([]any)
+
+	out := make([]tierRate, 0, len(tiers))
 	for _, t := range tiers {
 		tier, _ := t.(map[string]any)
 		if tier == nil {
 			continue
 		}
-		start, _ := tier["startUsageAmount"].(float64)
-		if start != 0 {
-			continue
-		}
 		up, _ := tier["unitPrice"].(map[string]any)
 		if up == nil {
 			continue
 		}
+		start, _ := tier["startUsageAmount"].(float64)
 		units, _ := up["units"].(string)
 		nanos, _ := up["nanos"].(float64)
-		price := gcpMoney(units, int(nanos))
-		if price > 0 {
-			return price
+		out = append(out, tierRate{start: start, price: gcpMoney(units, int(nanos))})
+	}
+	sort.SliceStable(out, func(i, j int) bool { return out[i].start < out[j].start })
+	return out
+}
+
+// skuPrice extracts the first-tier unit price (startUsageAmount == 0) from a raw
+// GCP SKU map[string]any returned by the Billing Catalog API.
+func skuPrice(sku map[string]any) float64 {
+	for _, t := range skuTierList(sku) {
+		if t.start != 0 {
+			continue
+		}
+		if t.price > 0 {
+			return t.price
 		}
 	}
 	return 0

opencloudcosts-go/internal/providers/gcp/gcp_ai.go

@@ -396,35 +396,10 @@ func (p *Provider) buildBigQueryIndex(ctx context.Context, region string) (bigqu
 // skuPaidPrice extracts the first paid-tier unit price (startUsageAmount > 0) from a SKU.
 // Used for BigQuery SKUs that have a free-quota tier at startUsageAmount == 0.
 func skuPaidPrice(sku map[string]any) float64 {
-	pi, _ := sku["pricingInfo"].([]any)
-	if len(pi) == 0 {
-		return 0
-	}
-	pe, _ := pi[0].(map[string]any)
-	if pe == nil {
-		return 0
-	}
-	expr, _ := pe["pricingExpression"].(map[string]any)
-	if expr == nil {
-		return 0
-	}
-	tiers, _ := expr["tieredRates"].([]any)
-	for _, t := range tiers {
-		tier, _ := t.(map[string]any)
-		if tier == nil {
-			continue
-		}
-		start, _ := tier["startUsageAmount"].(float64)
-		if start <= 0 {
-			continue
-		}
-		up, _ := tier["unitPrice"].(map[string]any)
-		if up == nil {
-			continue
+	for _, t := range skuTierList(sku) {
+		if t.start > 0 {
+			return t.price
 		}
-		units, _ := up["units"].(string)
-		nanos, _ := up["nanos"].(float64)
-		return gcpMoney(units, int(nanos))
 	}
 	return 0
 }