cost-model/modules/pricing/public/azure/azurepricingsource.go

package azure

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strings"
	"time"

	"github.com/opencost/opencost/core/pkg/cloud"
	"github.com/opencost/opencost/core/pkg/log"
	"github.com/opencost/opencost/core/pkg/pricing"
	"github.com/opencost/opencost/core/pkg/unit"
	"github.com/opencost/opencost/modules/pricing/public/httpclient"
)

const (
	azurePricingBaseURL = "https://prices.azure.com/api/retail/prices"
	azureVMFilter       = "serviceName eq 'Virtual Machines' and priceType eq 'Consumption'"
	azureDiskFilter     = "serviceName eq 'Storage' and priceType eq 'Consumption'"
)

// AzurePricingSourceConfig holds configuration for AzurePricingSource.
type AzurePricingSourceConfig struct {
	CurrencyCode string
}

var azureHTTPClient = httpclient.NewClient(120 * time.Second)

// AzurePricingSource implements the PricingSource interface using the
// Azure Retail Prices API (no auth required).
type AzurePricingSource struct {
	config AzurePricingSourceConfig
}

func NewAzurePricingSource(cfg AzurePricingSourceConfig) *AzurePricingSource {
	return &AzurePricingSource{config: cfg}
}

func (a *AzurePricingSource) GetPricing() (*pricing.PricingSet, error) {
	log.Infof("PricingSource (Azure): starting pricing download")
	start := time.Now()

	ps := &pricing.PricingSet{
		NodePricing:             []*pricing.NodePricing{},
		PersistentVolumePricing: []*pricing.PersistentVolumePricing{},
	}

	// Fetch VM pricing
	url := a.buildVMURL()
	pageCount := 0
	seenNodes := make(map[nodeKey]struct{})

	for url != "" {
		resp, err := azureHTTPClient.Get(url)
		if err != nil {
			return nil, fmt.Errorf("PricingSource (Azure): GET %s: %w", url, err)
		}

		if resp.StatusCode != http.StatusOK {
			body, _ := io.ReadAll(resp.Body)
			closeErr := resp.Body.Close()
			if closeErr != nil {
				log.Warnf("failed to close response body: %v", closeErr)
			}
			return nil, fmt.Errorf("PricingSource (Azure): unexpected status %d on VM page %d: %s", resp.StatusCode, pageCount, string(body))
		}

		next, err := a.parseVMPage(resp.Body, ps, seenNodes)
		closeErr := resp.Body.Close()
		if closeErr != nil {
			log.Warnf("failed to close response body: %v", closeErr)
		}
		if err != nil {
			return nil, fmt.Errorf("PricingSource (Azure): parsing VM page %d: %w", pageCount, err)
		}

		pageCount++
		url = next
		log.Debugf("PricingSource (Azure): fetched VM page %d, next: %s", pageCount, url)
	}

	log.Infof("PricingSource (Azure): fetched %d VM pricing entries across %d pages", len(ps.NodePricing), pageCount)

	// Fetch disk pricing
	url = a.buildDiskURL()
	diskPageCount := 0

	for url != "" {
		resp, err := azureHTTPClient.Get(url)
		if err != nil {
			return nil, fmt.Errorf("PricingSource (Azure): GET %s: %w", url, err)
		}

		if resp.StatusCode != http.StatusOK {
			body, _ := io.ReadAll(resp.Body)
			closeErr := resp.Body.Close()
			if closeErr != nil {
				log.Warnf("failed to close response body: %v", closeErr)
			}
			return nil, fmt.Errorf("PricingSource (Azure): unexpected status %d on disk page %d: %s", resp.StatusCode, diskPageCount, string(body))
		}

		next, err := a.parseDiskPage(resp.Body, ps)
		closeErr := resp.Body.Close()
		if closeErr != nil {
			log.Warnf("failed to close response body: %v", closeErr)
		}
		if err != nil {
			return nil, fmt.Errorf("PricingSource (Azure): parsing disk page %d: %w", diskPageCount, err)
		}

		diskPageCount++
		url = next
		log.Debugf("PricingSource (Azure): fetched disk page %d, next: %s", diskPageCount, url)
	}

	log.Infof("PricingSource (Azure): completed in %s — %d node pricing, %d volume pricing",
		time.Since(start).Round(time.Second), len(ps.NodePricing), len(ps.PersistentVolumePricing))

	return ps, nil
}

func (a *AzurePricingSource) buildVMURL() string {
	u := azurePricingBaseURL + "?$filter=" + url.QueryEscape(azureVMFilter)
	if a.config.CurrencyCode != "" {
		u += "&currencyCode=" + url.QueryEscape(a.config.CurrencyCode)
	}
	return u
}

func (a *AzurePricingSource) buildDiskURL() string {
	u := azurePricingBaseURL + "?$filter=" + url.QueryEscape(azureDiskFilter)
	if a.config.CurrencyCode != "" {
		u += "&currencyCode=" + url.QueryEscape(a.config.CurrencyCode)
	}
	return u
}

func (a *AzurePricingSource) parseVMPage(body io.Reader, ps *pricing.PricingSet, seen map[nodeKey]struct{}) (nextURL string, err error) {
	data, err := io.ReadAll(body)
	if err != nil {
		return "", fmt.Errorf("reading response body: %w", err)
	}

	var page AzurePricing
	if err := json.Unmarshal(data, &page); err != nil {
		return "", fmt.Errorf("unmarshalling response: %w", err)
	}

	for _, item := range page.Items {
		if !a.includeItem(item) {
			continue
		}

		provisioning := pricing.ProvisioningOnDemand
		if isSpotItem(item) {
			provisioning = pricing.ProvisioningSpot
		}

		nk := nodeKey{Region: item.ArmRegionName, InstanceType: item.ArmSkuName, Provisioning: provisioning}
		if _, ok := seen[nk]; ok {
			continue
		}
		seen[nk] = struct{}{}

		nodePricing := &pricing.NodePricing{
			Properties: pricing.NodePricingProperties{
				Provider:     cloud.ProviderAzure,
				Region:       item.ArmRegionName,
				InstanceType: item.ArmSkuName,
				Provisioning: provisioning,
			},
			Prices: pricing.Prices{
				pricing.ResourceNode: pricing.Price{
					Unit:  unit.Hour,
					Price: float64(item.RetailPrice),
				},
			},
		}

		ps.NodePricing = append(ps.NodePricing, nodePricing)
	}

	return page.NextPageLink, nil
}

func (a *AzurePricingSource) parseDiskPage(body io.Reader, ps *pricing.PricingSet) (nextURL string, err error) {
	data, err := io.ReadAll(body)
	if err != nil {
		return "", fmt.Errorf("reading response body: %w", err)
	}

	var page AzurePricing
	if err := json.Unmarshal(data, &page); err != nil {
		return "", fmt.Errorf("unmarshalling response: %w", err)
	}

	for _, item := range page.Items {
		if !a.includeDiskItem(item) {
			continue
		}

		volumeType := mapAzureDiskType(item.SkuName)
		if volumeType == pricing.VolumeTypeNil {
			continue
		}

		// Azure disk pricing is per GB-month, convert to per GB-hour
		hourlyPrice := float64(item.RetailPrice) / 730.0

		volumePricing := &pricing.PersistentVolumePricing{
			Properties: pricing.PersistentVolumePricingProperties{
				Provider:   cloud.ProviderAzure,
				Region:     item.ArmRegionName,
				VolumeType: volumeType,
			},
			Prices: pricing.Prices{
				pricing.ResourceStorage: pricing.Price{
					Unit:  unit.GiBHour,
					Price: hourlyPrice,
				},
			},
		}

		ps.PersistentVolumePricing = append(ps.PersistentVolumePricing, volumePricing)
	}

	return page.NextPageLink, nil
}

// includeItem mirrors the filtering logic in the existing Azure provider for VMs.
func (a *AzurePricingSource) includeItem(item AzurePricingAttributes) bool {
	if item.ArmSkuName == "" || item.ArmRegionName == "" {
		return false
	}
	productLower := strings.ToLower(item.ProductName)
	if strings.Contains(productLower, "windows") {
		return false
	}
	if strings.Contains(productLower, "cloud services") || strings.Contains(productLower, "cloudservices") {
		return false
	}

	// The Azure API appends an exact suffix to SkuName for non-on-demand rows.
	// We want on-demand and Spot Linux pricing, so only reject Low Priority
	// (a deprecated pricing model with no corresponding ProvisioningType).
	skuLower := strings.ToLower(item.SkuName)
	return !strings.HasSuffix(skuLower, " low priority")
}

// isSpotItem returns true if the pricing item represents Spot VM pricing.
// The Azure Retail Prices API denotes Spot rows with a " Spot" suffix on SkuName.
func isSpotItem(item AzurePricingAttributes) bool {
	return strings.HasSuffix(strings.ToLower(item.SkuName), " spot")
}

// includeDiskItem filters disk items to include only managed disks.
func (a *AzurePricingSource) includeDiskItem(item AzurePricingAttributes) bool {
	if item.ArmRegionName == "" {
		return false
	}
	productLower := strings.ToLower(item.ProductName)
	// Exclude unmanaged disks explicitly (weird case where "Unmanaged disk" still has managed "managed disk" :\)
	if strings.Contains(productLower, "unmanaged") {
		return false
	}
	// Only include managed disks
	return strings.Contains(productLower, "managed disk")
}

// AzurePricing represents the response from Azure Retail Prices API
type AzurePricing struct {
	BillingCurrency    string                   `json:"BillingCurrency"`
	CustomerEntityId   string                   `json:"CustomerEntityId"`
	CustomerEntityType string                   `json:"CustomerEntityType"`
	Items              []AzurePricingAttributes `json:"Items"`
	NextPageLink       string                   `json:"NextPageLink"`
	Count              int                      `json:"Count"`
}

// AzurePricingAttributes represents a single pricing item from Azure Retail Prices API
type AzurePricingAttributes struct {
	CurrencyCode         string     `json:"currencyCode"`
	TierMinimumUnits     float32    `json:"tierMinimumUnits"`
	RetailPrice          float32    `json:"retailPrice"`
	UnitPrice            float32    `json:"unitPrice"`
	ArmRegionName        string     `json:"armRegionName"`
	Location             string     `json:"location"`
	EffectiveStartDate   *time.Time `json:"effectiveStartDate"`
	EffectiveEndDate     *time.Time `json:"effectiveEndDate"`
	MeterId              string     `json:"meterId"`
	MeterName            string     `json:"meterName"`
	ProductId            string     `json:"productId"`
	SkuId                string     `json:"skuId"`
	ProductName          string     `json:"productName"`
	SkuName              string     `json:"skuName"`
	ServiceName          string     `json:"serviceName"`
	ServiceId            string     `json:"serviceId"`
	ServiceFamily        string     `json:"serviceFamily"`
	UnitOfMeasure        string     `json:"unitOfMeasure"`
	Type                 string     `json:"type"`
	IsPrimaryMeterRegion bool       `json:"isPrimaryMeterRegion"`
	ArmSkuName           string     `json:"armSkuName"`
}