Skip to content

CHANGELOG.md

Latest commit

 

History

History
617 lines (584 loc) · 60.3 KB

CHANGELOG.md

File metadata and controls

617 lines (584 loc) · 60.3 KB
Raw

Changelog

This file covers the cloud-commitments-go modules (pkg/, providers/, ci_cd_sanity_tests/) only. The format is based on Keep a Changelog.

[Unreleased]

Notices

  • Azure search reservations are upfront-only (#38). search purchases and offering quotes with monthly or no-upfront are refused before any request, because the Capacity catalog does not recognise SearchService. Monthly stays allowed for cache, managedredis and synapse, whose catalog rows list it.

  • Expiry adjustment functions return an error (#450). recommendations.AdjustExistingCoverageForExpiringCommitments, ...WithCoverage and ...WithCoverageOptions now return error as their last value. An unknown service, or an EC2 size with no normalization factor in a size-flexible family, fails the call and leaves the recommendations untouched. Non-RDS expiry pools now carry the service name, and EC2 pools in size-flexible families net per family in normalized units.

  • EC2 re-drives now refuse when several RIs carry the idempotency token. If more than one active or payment-pending RI has the token (#724), the purchase is refused instead of adopting the first one: no purchase is sent and the error wraps common.ErrRefusedBeforePurchase, names the count and the masked token, and needs a human to reconcile.

  • Azure savings plan inventory fails closed for Shared plans billed to a billing account (#272). savingsplans.Client.GetExistingCommitments and GetCoveringCommitments (the one the duplicate check reads) list plans billed to /subscriptions/<client subscription>, plus billing-account-billed Single-scope plans whose applied scope names exactly the client subscription. A billing-account plan with Shared, management group or unresolvable scope cannot be attributed to one subscription, so the whole call returns an error starting "incomplete savings plan inventory for subscription ..., page N: row M: " (for example "billing-account plan is not single-subscription scoped", or a "single-scope plan ..." message when a Single scope cannot be resolved) instead of a partial list. Plans billed to a subscription are not affected by this scope check, and GetCoveringCommitments also returns the plans billed to other subscriptions that may cover this one. The duplicate check therefore sees an error, not a silently incomplete inventory, and no recommendation is purchased on top of a plan it could not see. This affects EA and MCA tenants that buy savings plans at billing-account scope with Shared applied scope. Workaround: buy Single-scope plans attributed to the subscription. A consumer that catches the error and skips Azure savings plan inventory also removes the duplicate-purchase guard for that subscription, so it can buy on top of the Shared plan it could not see; only do that where no Shared billing-account plan can cover the subscription. Tracked in #272; revisit when a tenant needs Shared attribution.

  • Azure Redis purchases must go through managedredis (ServiceMemoryDB). The Azure recommendations adapter still labels Redis recommendations ServiceCache, and the cache client now refuses every purchase (#538), so route Azure Redis purchases to the managedredis client. The refusal wraps common.ErrRefusedBeforePurchase (nothing was sent), not an upfront-approval failure, so approving and retrying does not help.

  • Removed (aws/azure/gcp service clients): the unused ValidateOffering and GetValidResourceTypes methods, and the exported test seams RPValidateAPI/SetRPValidateClient (azure savingsplans), SQLAdminService/SetSQLAdminService (gcp cloudsql), MachineTypesService/MachineTypesIterator/SetMachineTypesService (gcp computeengine), RedisCachesPager/SetRedisCachesPager (azure cache and managedredis), ServicesPager/SetSearchServicesPager (azure search). None of these were part of pkg/provider interfaces; callers that type-asserted the concrete clients must drop those calls. GetOfferingDetails is unchanged. (#11)

  • Removed (gcp cloudstorage and memorystore clients): the unused exported test seams StorageService/BucketIterator/BucketHandle/SetStorageService and RedisService/RedisIterator/CreateInstanceOperation/SetRedisService. Purchases are a no-op, so nothing read them; callers that type-asserted the concrete clients must drop those calls. The gcp module no longer requires cloud.google.com/go/storage or cloud.google.com/go/redis. (#6)

Added

  • ladder.LadderPlan.ValidateRunCaps: checks an assembled plan against the per-run caps: the summed immediate purchase USD/hr must not exceed max_hourly_commit_per_run, and purchases plus reshapes must not exceed max_actions_per_run (holds are not counted). Pure, no caller yet; the per-run execution gate in #27 is the intended caller. (#27)

  • ladder.BuildPlan: assembles a validated LadderPlan from an AllocateResult and its BuildTranches output. Each immediate tranche becomes one purchase action with the tranche's own commitment amount; an allocation with no immediate tranche becomes a hold stating when its first tranche fires. Pure, no I/O, no existing caller changes. (#27)

  • aws/recommendations: recommendations.GetRICommitmentRate derives the commitment dollars per covered on-demand dollar of a new Convertible EC2 Reserved Instance from Cost Explorer's reservation purchase recommendations: used share of the effective monthly RI cost (recurring plus upfront amortized over the term) over the covered on-demand cost, filtered by account and region, with ErrNoRICommitmentRate when no usable detail exists. (#732)

  • ladder/aws: GetCommitmentRates also returns a convertible-ri sizing rate from GetRICommitmentRate. A missing RI rate omits only that layer; any other error fails the call. Costs one extra billed Cost Explorer request (plus pages) per call. (#732)

  • ladder/aws: AWSLadder.WithBufferFraction and a stable-usage estimator: when the fraction is set, GetUsageBaseline fills StableUSDPerHour with the lowest of the low-water mark, the 10th percentile and the last 3 days, times 1 - fraction. It stays nil when the option is unset, the series has fewer than 14 days, or the 10th percentile is under half the median (#31).

  • AWS/Redshift: when the AttemptJournal also implements common.ClaimReader, the reserved-node dedupe skips nodes another purchase recorded as bought, before and after the send. A claim read error refuses before the send or leaves the outcome unknown after it; if the skip leaves one of several matches and the token has no sending or outcome_unknown record, the purchase is refused as ambiguous (#700).

  • pkg: optional common.ClaimReader (ClaimedByOthers(ctx, token, ids)), which an AttemptJournal may implement so a provider can skip commitments another purchase recorded as bought (#700).

  • pkg: common.Commitment.CostKnown reports whether Cost holds a price the provider reported. The zero value means unknown, so a Cost of 0 without CostKnown must not be read as free. Producers set it in a follow-up (#74).

  • common: AttemptJournal, AttemptRecord and an optional PurchaseOptions.AttemptJournal, a caller-backed durable record of purchase attempts per idempotency token (#107). Nothing reads it yet.

  • pkg: provider.PurchaseReconciler, an optional read-only ServiceClient interface with common.ReconcileRequest, common.ReconcileResult and common.ReconcileVerdict (ReconcileFound/ReconcileUnknown, never NotFound), so a purchase that returned ErrOutcomeUnknown can later be checked against the provider. Types only; AWS EC2 and Redshift implementations follow (#298).

  • aws: the ec2 and redshift service clients now implement provider.PurchaseReconciler: a read-only check, after a purchase returned ErrOutcomeUnknown, of whether the purchase landed. The verdict is Found or Unknown, never NotFound. It reports Found only for exactly one full attribute match inside the attempt window, and Unknown otherwise. The other AWS clients (rds, elasticache, memorydb, opensearch, savingsplans) have an idempotency token and do not implement it. The platform consumes it in a follow-up (#298).

  • ladder/aws: ladder.ObservedCommitmentRateCapability and its AWS implementation report commitment dollars per covered on-demand dollar measured on the account's existing Savings Plans and convertible RIs (account-scoped Cost Explorer utilization). Layers with no usable observation are absent.

  • azure: PartialResultError.SkipKinds() []SkipKind, index-aligned with SkipReasons(), so consumers can tell skip causes apart without matching the reason text. SkipUnpriceable is a row with no usable price, a non-USD currency, no pricer or a malformed row. SkipPriceLookupUnavailable is a price lookup that failed to complete: the failing Advisor row and every one after it. SkipSourceIncomplete is a truncated Advisor walk. The kinds survive the multi-subscription merge. A PartialResultError built with only Skipped reads as SkipUnpriceable. Existing fields and methods are unchanged (#670).

  • azure.NewPartialSubscriptionFailureWithKinds: builds a PartialSubscriptionFailureError with each skip's kind, so a consumer test can build a failure whose SkipKinds() reports a price-lookup outage or a truncated source. SkipKinds() now also reads an empty kind as SkipUnpriceable (#680).

  • common.ErrRefusedBeforePurchase: a sentinel for a purchase refused before the call sent any purchase request, detectable with errors.Is. The AWS EC2, RDS, OpenSearch, Redshift and MemoryDB approved-upfront guard refusals wrap it.

  • Azure NewPartialSubscriptionFailure constructor: builds a PartialSubscriptionFailureError, optionally with skip reasons readable through Skips(), so code outside the module can construct one, for example in tests.

  • Azure currency refusals wrap common.ErrCurrencyNotAccepted: reservation purchase, savings plan purchase and reservation exchange refusals can now be detected with errors.Is; each existing message gains a : currency not accepted suffix.

  • Typed accessors on partial recommendation results: the Azure and GCP PartialResultError types now expose SkippedCount() int and SkipReasons() []string (a copy), so callers can match one interface through errors.As instead of parsing the message text.

  • common.ErrCurrencyNotAccepted: a sentinel error for operations refused because the billing currency is missing or not the requested one, so callers can tell a refusal from an API failure with errors.Is.

  • ladder.AllocateResult.NetExistingUSDPerHour: the net existing commitment (existing minus expiring, summed over layers) that Allocate sized the gap against, set on every successful result including the hold-only exits. Callers can report it instead of recomputing a gross figure from the layer states, so a plan's existing figure reconciles with its gap. Allocate now checks the snapshot before the baseline-unavailable hold, so expiring above existing is an error there too (#83).

  • exchange.WithOfferedInstanceTypes / RunAutoExchangeParams.OfferedInstanceTypes: restrict RI reshape targets to the instance types the region offers. AnalyzeReshaping and AnalyzeReshapingWithRecs take it as a variadic ReshapeOption; an empty list keeps the previous size ladder, and a family missing from a non-empty list gets a recommendation with the reason "instance family not offered in region". Auto exchange now reports the recommendation's own reason for every skipped RI without a target (#563).

  • RecommendationParams.RIAccountScope: selects the Cost Explorer account scope (linked default, or payer) for Reserved Instance recommendations, mirroring SPAccountScope. Empty keeps the previous linked behaviour; an unknown value is rejected (#508).

  • recommendations.RederiveFamilyCoverage: recomputes the family-wide RDS ProjectedCoverage that family-NU sizing wrote, after a caller changed Count (--max-instances, count override, duplicate-RI dedupe). It shares its formula with sizing, returns a new slice and leaves non-RDS, SQL Server and unsized recs untouched (#511).

  • recommendations.AdjustExistingCoverageForExpiringCommitmentsWithCoverageOptions: the per-pool (EC2 and other non-family) expiry deduction, plus credit for replacements already bought. Coverage is a lookback average, so RIs bought inside CoverageLookbackDays are not in it yet; with R the count of active, non-expiring RIs in the same pool that started inside the lookback, the deduction is max(0, expiring - R). It can only buy less, never more. A growth purchase in the pool counts as a replacement. Size-flexible EC2 families net in normalized units (#450), so a replacement of another size in the same family is credited. CoverageLookbackDays <= 0 credits none. Additive; the existing functions are unchanged (#346).

  • recommendations.Client.GetSPCommitmentRate: commitment dollars per on-demand dollar (r) of the used part of a new Savings Plan, derived from CE purchase recommendations as (utilization/100) * EstimatedSPCost / (EstimatedSPCost + EstimatedSavingsAmount) (ratio of sums over matching details). Strict raw-detail parsing; an absent field or no matching detail is ErrNoSPCommitmentRate, never a 1:1 fallback. Nothing consumes it yet (go#349, groundwork for converting on-demand ladder sizing to commitment dollars).

  • recommendations.ApplyFamilyNUSizingRDSWithExpiryOptions: the rebuy-window RDS family sizing, plus credit for replacements already bought. Coverage is a lookback average, so RIs bought inside CoverageLookbackDays are not in it yet; with R the NU of visible active, non-expiring RIs that started inside the lookback, post-expiry covered is max(0, max(min(C, C - E + R), min(C, A - E))). It is never below the R = 0 formula, so it can only buy less, and a partial inventory still never removes more than expires. FamilyExpiryReport.ReplacementNU records R. CoverageLookbackDays <= 0 credits none. Additive; the other functions are unchanged (LeanerCloud/cloud-commitments-cli#2132, #2175).

  • common.SavingsPlanDetails.Currency: the ISO 4217 code the hourly commitment is denominated in. Additive and unused until the Azure Savings Plan client starts requiring it (#46).

  • recommendations.ApplyFamilyNUSizingRDSWithExpiry: family-NU sizing that deducts RDS RIs expiring inside the rebuy window from family coverage in normalized units (max(covered - expiring, min(covered, active - expiring)), so a partial RI inventory never removes more than expires), and reports expiring RIs it could not use (FamilyExpiryReport.Unusable). Additive; ApplyFamilyNUSizingRDS is unchanged. Consumers that pass a rebuy window will see higher RDS counts and costs for families with expiring RIs (LeanerCloud/cloud-commitments-cli#2132).

  • insurance.ContractTerms(): returns the documented Archera contract_term values that Comparison accepts and the decoder returns, as a new sorted slice on every call (#316). The order is lexicographic, not by duration. Consumers should call it instead of copying the list.

  • common.ErrOutcomeUnknown: exported sentinel for a purchase whose response was lost and whose commitment may exist (#301). Consumers can use errors.Is to tell it from a definite failure. The AWS EC2 and Redshift clients switch to it in a follow-up once the aws module pins this commit.

  • pkg/insurance: a read-only Archera insured-commitment comparison contract (#284, #285). NewClient returns a client with Comparison and Plan for Archera's documented GET /v1/org/{org_id}/commitment-plans/{plan_id}/comparison and GET /v1/org/{org_id}/commitment-plans/{plan_id} endpoints (DecodeComparison and DecodePlan parse already-fetched bodies). The origin is fixed at https://api.archera.ai, the key is sent only in the x-api-key header, and the client never follows redirects and never retries. It has no purchase or binding capability and nothing in the repo calls it yet. Contract points consumers must keep:

    • Money is *big.Rat; nil means unknown, never zero. archera_premium is already inside commitment_cost.total, so do not add it again. Monthly rates are 730-hour rates and the one-time upfront cost is a separate field; do not sum them.
    • The vendor schema has no currency or expiry field, so both stay nil (unknown). FetchedAt records retrieval time and freshness policy is the consumer's.
    • Nullable vendor identity (term, payment option, commitment type) stays nullable. Each comparison row keeps its current offer and all candidate offers.
    • A comparison is a hypothetical rollup, not a bindable quote. An insured target of 100% is a requested target subject to Archera underwriting, not a guarantee.
    • AssessProductSupport returns supported only for the two AWS rows quoted from Archera's Supported Reservable Services page (aws/AmazonEC2 and aws/savingsplan/Compute); every other product is unknown. Support is not underwriting eligibility.
    • The API key is redacted from fmt output for Config and Client, except %p (and %T on a non-pointer value), which fmt handles before redaction.
    • Verified with offline tests only; no live Archera call has been made, so response shapes come from the published schema.

Changed

  • BREAKING azure: Azure Redis recommendations now come only from managedredis and are labelled memorydb (ServiceMemoryDB), both from Consumption and from Advisor rows. The cache client's GetRecommendations returns none, so GetRecommendationsForService(ServiceCache) is empty for Azure, and consumers that stored Azure Redis plans or settings under cache must also match memorydb. Azure Redis recommendations keep CacheDetails Engine and NodeType but no longer report Shards (0, unknown) (#692).

  • azure: the cache service no longer purchases Azure Redis reservations; managedredis (ServiceMemoryDB) is the only service that buys RedisCache, so one Redis recommendation cannot be bought once through each service. cache.PurchaseCommitment now refuses before any API call with an error wrapping common.ErrRefusedBeforePurchase. Consumers that buy an Azure ServiceCache recommendation must route it to managedredis (#538).

  • Ladder run and tranche statuses now write the US spelling canceled (RunStatusCanceled, TrancheStatusCanceled). Rows holding the legacy cancelled still validate, count as terminal, and parse to the new constants through ParseRunStatus and ParseTrancheStatus. The RunStatusCancelled and TrancheStatusCancelled names remain as deprecated aliases with the new value. Consumers that compare raw stored strings or filter on cancelled in SQL must accept both spellings.

  • ListTargetOfferings now walks up to 50 pages (about 5000 offerings) instead of 10, and returns an error wrapping the new ec2.ErrTargetOfferingsTruncated (with no list) when that bound is hit, instead of silently returning a partial list.

  • GCP Cloud Storage pricing lists the SKU catalog once per client, like Cloud SQL and Memorystore.

  • Azure multi-subscription collection keeps skipped recommendations when a subscription also fails. They are returned by the new PartialSubscriptionFailureError.Skips() (a *PartialResultError, or nil) and are deliberately not in the error chain, so a partial-result check never matches a subscription failure. Fields, Unwrap and message are unchanged.

  • GCP reports the recommendations it skips. Compute Engine recommendations dropped for a non-USD amount, a malformed amount or an unrecognized term are now returned as a partial-result error (Partial() bool) alongside the recommendations that succeeded, mirroring Azure, instead of only being logged.

  • GCP: one strict commitment term parser (#15). Compute Engine now uses skumatch.TermYears like Cloud SQL, Memorystore and Cloud Storage; it accepts 1yr/1/12mo/3yr/3/36mo case-insensitively. An unrecognized term now errors in GetOfferingDetails and skips pricing in enrichRecWithPricing instead of being priced as one year.

  • aws/recommendations: the four Cost Explorer coverage and utilization page fetchers share one generic fetchWithRetry helper (rate limiter plus concurrency cap); behaviour and error messages are unchanged (#120).

  • aws/rds: the RDS purchase path uses the shared purchaseguard idempotency guard and AlreadyExists recovery, like ElastiCache. Behavior for valid purchases is unchanged (#10).

  • aws/memorydb: the MemoryDB purchase path uses the shared purchaseguard idempotency guard and AlreadyExists recovery, like ElastiCache. Behavior for valid purchases is unchanged; only the lookup-failure error wording changes to "before MemoryDB reservation purchase" (#10).

  • aws/opensearch: the OpenSearch purchase path uses the shared purchaseguard idempotency guard and AlreadyExists recovery, like ElastiCache. Behavior for valid purchases is unchanged (#10).

  • azure/cache: GetValidResourceTypes now returns an error when the Redis cache list reaches the page cap (#249) instead of logging a warning and returning a partial SKU set.

  • scripts/setup-git-secrets.sh: the database DSN detector now fires on user:password@host (the old pattern ended at @, which git-secrets' word-match scan rejected before a hostname), and also covers postgresql, mariadb, driver-suffixed schemes and empty usernames (#125).

  • provider: ProviderConfig is renamed to Config (#39). ProviderConfig stays as a type alias marked Deprecated: use Config., so existing consumers keep compiling, but consumers that run staticcheck with fatal warnings (cloud-commitments-mcp, ~86 uses, and cloud-commitments-platform, ~36 uses) fail lint with SA1019 on their next pkg bump until they migrate to provider.Config. The aws, azure and gcp provider modules and ci_cd_sanity_tests already use provider.Config.

  • httpclient: dials to the RFC 8215 local-use NAT64 prefix 64:ff9b:1::/48 are refused when any RFC 6052 layout (/48, /56, /64, /96) embeds a metadata IPv4 address; Teredo 2001::/32 stays allowed (#238).

  • CI: the security-scan job runs a pinned gitleaks CLI (v8.30.1, sha256-verified) over the checkout with .gitleaks.toml and fails on any finding (#101).

  • CI: the AWS and Azure sanity workflows now fail when their secrets are missing instead of skipping and passing; fork and Dependabot pull requests are skipped explicitly. The AWS OIDC session name is now cc-go-sanity (#2).

  • common.HoursPerMonth: exported 730-hour average month (HoursPerYear / 12) next to HoursPerYear; the remaining bare 730 and 8760 literals in the aws and gcp providers use the shared constants (#109).

  • gcp: region-lookup permission errors are now classified by type only (googleapi 403 or gRPC PermissionDenied) through the shared IsPermissionError. gRPC PermissionDenied is now skipped with a warning like a 403, and an untyped error whose text merely contains "403" and "permission" now propagates instead of being skipped (#6).

  • BREAKING gcp: stored contexts removed (#6). computeengine.NewClient no longer takes a context.Context (it was stored and never read), and computeengine.BillingService.ListSKUs now takes ctx as its first parameter, so custom implementations must add it. Provider and RecommendationsClientAdapter no longer store a context (unexported fields; no API change). Downstream call sites to update: mcp tools/gcp_computeengine_cud_safeguards_test.go:76,125, tools/search_dedupe_test.go:344, cmd/cudly-mcp/gcp_purchase_protocol_test.go:102; platform internal/purchase/gcp_history_cost_test.go:48. No cli, mcp or platform code references BillingService, ListSKUs or a gcp.Provider literal.

  • azure: managedredis and synapse reservations now get the same generated display name as the other services (redis-<region>-<sku>-<n>x-<term>-<payment>-... and synapse-...) instead of the fixed Azure Cache for Redis Reservation - <sku> / Synapse SQL Pool Reservation - <sku>. This also removes the stray space before the idempotency marker on managedredis. Idempotency lookup keys on the tag or the marker suffix, not the base name (#538).

  • BREAKING gcp: Cloud SQL and Memorystore no longer return CUD recommendations (#294). They came from the project-scoped PerformanceRecommenders, which give per-instance tuning advice, and were relabeled as 1yr CUDs with made-up or zero savings. Cloud SQL and Memorystore CUDs are spend-based, and Google recommends them only at Cloud Billing account scope (see docs/design/gcp-spend-commitments.md). GetSupportedServices now returns only ServiceCompute, the default recommendation fan-out queries only the Compute Engine commitment recommender, and an explicit Cloud SQL or Memorystore request returns an error wrapping common.ErrCommitmentPurchaseNotSupported without calling the Recommender API. SetRecommenderClient on both clients is now a deprecated no-op. Pricing (GetOfferingDetails, ValidateOffering) is unchanged.

  • BREAKING ladder.Allocate converts the on-demand-equivalent gap to commitment dollars (go#349). Tranches were bought 1:1 against an on-demand-priced gap, over-buying by 1/rate (a 30% discount bought 43% too much). AllocationInput.InFlightUSDPerHour *float64 is replaced by InFlight []InFlightTranche (commitment USD/hr plus the rate stored with each tranche, netted as commitment/rate) and a required CommitmentRates map (a partial map is fine: a layer that receives an allocation without a rate is held, never bought 1:1; a rate outside (0, 1] or non-finite is an error). Allocation.GapUSDPerHour is now commitment USD/hr, with OnDemandEquivalentUSDPerHour and Rate alongside; the per-run cap applies to commitment dollars. The base split now also counts in-flight base commitment against the stable level. BuildTranches rejects an Allocation without a rate in (0, 1] and stamps it on Tranche.CommitmentRate. The amounts are exact; the purchase boundary must round commitment DOWN. Tranches persisted before this change are in the old unit and carry no rate. Consumer: the platform's internal/server/handler_ladder.go only.

  • BREAKING ladder.TrancheResult.BuyNow removed; BuildTranches now emits a Tranche for every ramp step, including AfterDays == 0 (its FireAfter equals TrancheInput.Now). The immediate step was returned as a BuyNow action that the platform never persisted, so in-flight netting could not see it (#36). The only consumer is the platform's internal/server/handler_ladder.go; cloud-commitments-cli and cloud-commitments-mcp do not reference it. Buy-now rationale and data sources are no longer carried on the immediate step (tranches have no such fields). Tranche.AmountUSDPerHour and AllocationInput.InFlightUSDPerHour now document their unit (#349).

  • Breaking (source): insurance.Config.APIKey is now an opaque insurance.Secret (build it with insurance.NewSecret(key)) instead of a string. The key lives in a closure, so a Config held in an unexported struct field no longer prints it under any fmt verb, json, xml, yaml or slog. Config.Format is removed (%v of a Config now prints {[redacted] <org>}), and two copies of one Config are no longer reflect.DeepEqual. Config is also no longer comparable (== stops compiling and a Config map key panics as unhashable), and json.Unmarshal into a Config carrying an APIKey now errors where the old json:"-" tag ignored it (#330)

  • Breaking (source): azure.PartialResultError gained a Kinds field (#670). Downstream code that builds it with unkeyed composite literals no longer compiles; keyed literals such as PartialResultError{Skipped: ...} are unaffected and read as SkipUnpriceable.

  • Breaking (source): common.PurchaseResult gained an ExistingCommitment field. Downstream code that builds it with unkeyed composite literals no longer compiles; keyed literals are unaffected. The field is true when a provider adopted a commitment that already existed for the same idempotency token (#211)

  • Breaking (source): common.PurchaseResult gained an OfferingClass field. Downstream code that builds it with unkeyed composite literals no longer compiles; keyed literals are unaffected. On an adopted re-drive it carries the offering class AWS reports for the existing RI (the EC2 provider sets it in a follow-up change); empty otherwise (#211).

  • aws/EC2: an adopted re-drive now reports the existing RI's offering class in PurchaseResult.OfferingClass (#211).

  • GCP Compute Engine adoption now returns a nil Cost instead of a pointer to 0; a fresh purchase is unchanged (#211).

Fixed

  • Duplicate check: Azure Advisor SQL Database reservation rows now carry Engine sqlserver and the SKU as InstanceClass, like the SQL client's own recommendations. They had no details, so their dedupe key never matched a held SQL commitment and the held reservation did not reduce them. Savings Plan rows keep no details, as before, and the MemoryDB details are now attached only to reservation rows (no real Advisor row is affected) (#735).

  • Duplicate check: the Azure SQL Database dedupe key no longer includes the zone-redundancy slot, so a held reservation stamped zoneRedundant now covers a recommendation stamped none or empty, and the reverse. A vCore reservation covers standard compute either way; the slot only split one pool in two and let duplicates through when the two sides disagreed. It can only over-filter: a held vCore ZR add-on reservation now counts toward the same pool (#715).

  • Duplicate check: a recent purchase now reduces every term and payment variant of a recommendation, not only the first one in input order, for EC2 as well as every other service. Each term|payment group starts from the full held quantity and consumes it in input order, so one held unit against four variants of 2 yields 1, 1, 1, 1 (was 1, 2, 2, 2). Providers pick this up on their next pkg pin bump. Fixes #703.

  • providers/gcp: m4-ultramem-224 now matches its own M4Ultramem224 catalog rows instead of the plain M4 rates, which understated RAM cost by about 25%. The commitment SKU text (Commitment v1: M4Ultramem224 Cpu/Ram in ...) is assumed by analogy with other families and not verified against the live catalog; a wrong text fails closed with "no commitment pricing found". Other M4 ultramem shapes (m4n-* and unknown sizes) are refused with an unknown-catalog-family error. The m1, m2 and m3 ultramem shapes are unchanged. Fixes #719.

  • common: a Recommendation, and a PurchaseResult carrying one (with no Error), now decodes from JSON when details holds an object. details is decoded into the typed pointer for the recommendation's service through DecodeServiceDetailsFor; absent details leave the field unchanged and null sets it nil, as encoding/json does, and details for a service with no typed details fail with ErrUntypedServiceDetails. Before this, encoding/json could not decode an object into the ServiceDetails interface (#211).

  • CostKnown producers (#74): providers now set common.Commitment.CostKnown where the price is reported, and stop inventing inventory fields.

    • AWS ladder RI costs: CostKnown is true only when EC2 reported the price (FixedPrice plus a recurring price) and either a Duration is present or the upfront is 0.
    • AWS ladder SP costs: CostKnown is true.
    • Azure savings plans: a reported Commitment.Amount, including 0, is marked known.
    • Azure inventory: the cache and search consumption inventory no longer invent Region or State. Both are now empty, meaning unknown. Cosmos DB, SQL and Synapse moved to the Reservations API in #717.
    • Known log noise: an empty State still logs one recfilter WARNING per such commitment.

  • azure reservation purchases: compute, cosmosdb, database, managedredis, search and synapse now refuse a purchase before any API call, wrapping common.ErrRefusedBeforePurchase, when the recommendation region (empty, or not the same region as the client after lowercasing and removing spaces) does not match the client region. Previously the reservation was bought in the client region regardless of rec.Region (#704).

  • Breaking (source): managedredis.ReservationsDetailsPager and (*managedredis.Client).SetReservationsPager are removed; tests inject reservation inventory with SetInventoryFactories instead (#699).

  • azure Redis: managedredis.GetExistingCommitments now reads held reservations from the Reservations API (purchase date, quantity, location, state), so a Redis reservation bought in the last day reduces the matching recommendation instead of being invisible to the duplicate guard (#699). An incomplete live reservation row (missing SKU, location, quantity or purchase date, an unattributable scope, or an expiry falling today) now fails the lookup with an error instead of being skipped, as azure compute already does.

  • Breaking (source): cosmosdb.ReservationsDetailsPager and (*cosmosdb.Client).SetReservationsPager are removed; tests inject reservation inventory with SetInventoryFactories instead (#705).

  • azure Cosmos DB: cosmosdb.GetExistingCommitments now reads held reservations from the Reservations API (purchase date, quantity, location, state), so a Cosmos DB reservation bought in the last day reduces the matching recommendation instead of being invisible to the duplicate guard. Region is now the reservation location, not the client region. An incomplete live reservation row fails the lookup with an error instead of being skipped (#705).

  • Breaking (source): synapse.ReservationsDetailsPager and (*synapse.Client).SetReservationsPager are removed; tests inject reservation inventory with SetInventoryFactories instead (#705).

  • azure Synapse: synapse.GetExistingCommitments now reads held reservations from the Reservations API (purchase date, quantity, location, state), so a Synapse reservation bought in the last day reduces the matching recommendation instead of being invisible to the duplicate guard. Region is now the reservation location, not the client region. An incomplete live reservation row fails the lookup with an error instead of being skipped (#705).

  • Breaking (source): database.ReservationsDetailsPager and (*database.Client).SetReservationsPager are removed; tests inject reservation inventory with SetInventoryFactories instead (#705).

  • azure SQL Database: database.GetExistingCommitments now reads held reservations from the Reservations API (purchase date, quantity, location, state), so a SQL Database reservation bought in the last day reduces the matching recommendation instead of being invisible to the duplicate guard. Held reservations carry engine sqlserver and the subscription's dominant zone-redundancy setting, as recommendations do. Region is now the reservation location, not the client region. An incomplete live reservation row fails the lookup with an error instead of being skipped (#705).

  • aws RI recommendations: a fractional Cost Explorer quantity now rounds down instead of to the nearest integer, so a purchase never exceeds CE's quantity. The upfront, recurring monthly cost, monthly savings and savings percentage scale by count / quantity, so they describe the instances actually bought. Before, 2.5 became 3 with the upfront for 2.5, and the approved-upfront check refused the purchase. The on-demand baseline and break-even months are unchanged (#635).

  • AWS: purchase counts outside [1, MaxInt32] are refused before any API call in EC2, ElastiCache, MemoryDB, OpenSearch, RDS and Redshift, with ErrRefusedBeforePurchase and offeringprice.ErrPurchaseCountOutOfRange (#683).

  • azure: an error from a reservation purchase retry (attempt 2 or later) now also wraps common.ErrOutcomeUnknown. That covers a currency refusal from the retry's calculatePrice, a failed idempotency re-check, a non-retryable purchase failure, a cancelled retry wait and exhausted attempts. A retry runs only after a purchase that failed retryably and may have committed, and the re-check can miss that order, so none of these errors may read as "nothing was bought". The cause stays in the chain, so errors.Is(err, common.ErrCurrencyNotAccepted) still matches. The ErrCurrencyNotAccepted doc now says it is pre-purchase only without ErrOutcomeUnknown (#671).

  • Azure purchases check the recommendation currency. Azure reservation purchases compare the calculatePrice billing currency with the recommendation currency (empty means USD) and refuse before purchasing when it is missing or differs. Azure Savings Plan purchases refuse when the recommendation currency (empty means USD) differs from the plan commitment currency.

  • Azure reservation purchases and compute exchanges for accounts billed in a currency other than USD are now refused (recommendations are USD-only). The purchase check also runs again when a purchase is retried after a session timeout. CalculateExchange refuses, so no exchange session is returned to execute, when the net payable currency is missing or is not USD.

  • gcp: the Cloud SQL, Memorystore and Cloud Storage price extractors keep 1-year and 3-year commitment SKUs in separate slots and return the price for the requested term, so a catalog that lists both terms no longer fails as ambiguous (#254). Two SKUs of the same term at different prices still fail closed, and a recommendation term other than 1yr or 3yr (for example "2yr") now errors instead of being priced as one year.

  • ladder: a run no longer emits a buffer-layer purchase for a layer it also recommends reshaping. The buffer allocation becomes an informational Hold naming the pending reshape; the reshape and all other allocations are unchanged. A layer that also carries the base or flex role (merged Azure reservation) is not held (#30).

  • ladder: a run no longer emits a buffer-layer purchase for a layer it also recommends reshaping. The buffer allocation becomes an informational Hold naming the pending reshape; the reshape stays. Other allocations are not edited, but with the held buffer removed a binding MaxHourlyCommitPerRun can give base/flex a larger share of the cap (total spend never higher), and a freed max-actions slot can let a deferred purchase through. A layer that also carries the base role (merged Azure reservation) is not held (#30).

  • azure: recommendations from the Consumption path (compute, database, cache, cosmosdb, managedredis, synapse) and the Savings Plan benefit path now set CommitmentCurrency to USD, because their commitment amounts come from sources already required to be USD. The legacy path carries no checked commitment amounts and stays empty (#623); Advisor reservation rows are priced separately, see below.

  • azure: Advisor reservation recommendations (virtual machines, SQL databases, Redis cache) are now priced from the Retail Prices reservation rows, so they carry CommitmentCost or RecurringMonthlyCost and CommitmentCurrency USD on both payment legs. A row that cannot be priced is skipped and counted in the partial-result error. An Advisor reservation row is dropped when the Consumption path returned a reservation for the same account, service, region and term, and Advisor regions are normalized to ARM form (eastus). Duplicate Advisor reservation rows for the same account, service, region and term collapse to the cheapest priced total. Advisor Savings Plan rows stay unpriced, and CosmosDb and SqlDataWarehouse Advisor rows are still ignored because their quantity unit is unproven (#655).

  • azure: Advisor compute reservation rows for a different VM series are no longer dropped by a Consumption row or collapsed into a cheaper Advisor row for the same region and term; the series (D, E, B...) is now part of the match. A row whose series cannot be read keeps the previous per-region, per-term match on both sides, so one need never shows as two rows. Series that share several size flexibility groups (D, E, M) still merge (#674).

  • AWS/OpenSearch: the STS account-ID lookup used for post-purchase tagging caches only a successful result, so one throttled or timed-out GetCallerIdentity no longer disables tagging for the client's lifetime (#53).

  • AWS/recommendations: normalizeRegionName maps the current Europe (Ireland|Frankfurt|London|Paris|Stockholm) Cost Explorer display names to region codes, so coverage lookups keyed by region code match those recommendations (#53).

  • AWS/recommendations: normalizeRegionName also maps Asia Pacific (Malaysia|Thailand), Canada West (Calgary) and Mexico (Central) to ap-southeast-5, ap-southeast-7, ca-west-1 and mx-central-1 (#53).

  • AWS/recommendations: normalizeRegionName also maps Asia Pacific (Taipei) (ap-east-2), Asia Pacific (New Zealand) (ap-southeast-6) and the China, GovCloud, ISO and European Sovereign Cloud region descriptions from the SDK partitions file (#53). The alias table is now a package-level regionAliases map, the no-op region-code prefix branch is removed (output unchanged for every input), and the collision test covers the whole map.

  • AWS/Savings Plans: GetExistingCommitments returns an error naming the plan ID and value when a plan has an unparseable start or end date, instead of silently leaving the date zero (#53).

  • AWS/Savings Plans: GetExistingCommitments returns an error naming the plan ID when a plan has no start or end date; a zero start date was never treated as recent by the purchase dedupe, so a duplicate purchase could slip through (#53).

  • AWS/RDS: PurchaseCommitment refuses an offering whose upfront (FixedPrice x count) exceeds the approved recommendation upfront by more than 5%, or that is priced in a non-USD currency; a zero approved upfront is not checked (#53).

  • Bump Go to 1.26.10 to pick up the fix for GO-2026-6809 (crypto/x509), which govulncheck now reports against 1.26.9.

  • AWS/MemoryDB, OpenSearch, Redshift: PurchaseCommitment refuses an offering whose upfront (FixedPrice x count) exceeds the approved recommendation upfront by more than 5%, or that is priced in a non-USD currency (MemoryDB offerings carry no currency, so only the recommendation's currency is checked there), or, for MemoryDB, an upfront offering with a zero price or one bought in a China region (cn-north-1, cn-northwest-1), where the assumed USD price is wrong; a zero approved upfront is not checked. All AWS RI price guards (EC2, RDS, MemoryDB, OpenSearch, Redshift) also refuse a NaN or infinite approved upfront (#53).

  • AWS ElastiCache purchases refuse a recommendation with no engine instead of sending an empty ProductDescription filter, send the engine lowercased as ElastiCache reports it, and verify the chosen offering's node type, duration and engine before buying it (#53).

  • AWS EC2 RI purchases refuse an offering whose total upfront exceeds the recommendation's approved upfront by more than 5% (USD only; a recommendation without an upfront figure is not checked), so a repriced or differently-priced offering can no longer bypass the approved cap (#53).

  • ReshapeBuffer rejects nil payment caps instead of mapping them to math.MaxFloat64: MaxPaymentPerExchangeUSD and MaxPaymentDailyUSD are now required, so an omitted cap can no longer mean unlimited spend on the auto-exchange path (#83).

  • aws/recommendations: GetRecommendations for RI services now rejects an unrecognized term, payment option or lookback period instead of letting Cost Explorer apply its own defaults under the requested label; the deprecated silent converters are removed (#53).

  • aws/recommendations: GetRecommendations for RI services now rejects a non-empty unrecognized term, payment option or lookback period instead of letting Cost Explorer apply its own defaults under the requested label; an unset (empty) value still means the Cost Explorer default. The deprecated silent converters are removed (#53).

  • Azure savings plan recommendations use a 730 hour month (was 730.5), matching common.HoursPerMonth and the 8760 hour year; monthly recurring cost, on-demand cost and savings shift by about 0.07% (#583).

  • exchange.AnalyzeReshaping: no longer proposes a same-capacity reshape (1x m5.24xlarge to 2x m5.12xlarge); it frees no units and AWS needs an equal-or-greater exchange value, so such RIs now get no recommendation and no quote (#563).

  • common.EC2NormalizationFactor: knows the 32xlarge, 48xlarge, 56xlarge, 96xlarge and 112xlarge sizes (256 to 896), so RI exchange analysis no longer skips RIs of those sizes with "No normalization factor known" (#563).

  • exchange: RunAutoExchange now stops and returns the error when cancelling stale pending exchanges fails, instead of logging it and creating new exchanges while a stale pending one may still be approvable.

  • exchange: RunAutoExchange now rejects any mode other than auto or manual (including empty) with an error before any store or exchange call; previously every non-manual value auto-executed exchanges.

  • common: BuildReservationName no longer drops its random uniqueness suffix when a long SKU overflows the 60-char cap (it dropped it first, so long-SKU purchases got deterministic, colliding names). The timestamp and payment segments drop first, then the SKU is truncated; the suffix is always kept (#123).

  • logging: SetOutput no longer races with Logger.With and concurrent log calls: the unsynchronized mirror of the writer is gone and the destination lives only in the mutex-guarded log.Logger (#123).

  • common: DecodeServiceDetailsFor now rejects a non-empty details payload for a service with no typed details instead of silently returning nil details; MemoryDB (whose recommendations carry CacheDetails) now decodes as CacheDetails (#123).

  • common: DecodeServiceDetailsFor now rejects a non-empty details payload for a service with no typed details instead of silently returning nil details; MemoryDB (whose recommendations carry CacheDetails) and NoSQL (Azure Cosmos DB, NoSQLDetails) now decode to their typed details, so MemoryDB rows without a payload decode to a zero *CacheDetails instead of nil (#123).

  • common: DecodeServiceDetailsFor now rejects a non-empty details payload for a service with no typed details instead of silently returning nil details; MemoryDB (whose recommendations carry CacheDetails) and NoSQL (Azure Cosmos DB, NoSQLDetails) now decode to their typed details, so MemoryDB rows without a payload decode to a zero *CacheDetails instead of nil. The rejection wraps ErrUntypedServiceDetails for errors.Is (#123).

  • retry: jittered backoff is now clamped to MaxDelay after jitter is applied (upward jitter could exceed it), and the Do / PerAttemptTimeout docs now say the per-attempt context is derived from, and cancelled with, the outer context (#123).

  • aws/ec2: GetOfferingDetails always priced the convertible offering and its doc comment wrongly said the class does not change prices. Added GetOfferingDetailsForClass to price the class the purchase uses; GetOfferingDetails keeps the convertible default (#570).

  • A Multi-AZ size-flexible RDS reservation now covers Single-AZ demand in the duplicate-purchase guard (#323): it counts as twice the size units of its family, so a recent Multi-AZ db.r6g.large PostgreSQL reservation suppresses two Single-AZ db.r6g.large recommendations. Single-AZ never covers Multi-AZ, and exact-class engines such as SQL Server keep their key.

  • Size-flexible RDS reservations now cover Single-AZ and Multi-AZ demand in the duplicate-purchase guard (#323): Single-AZ and Multi-AZ share one family budget in size units, and a Multi-AZ node costs twice the units. A recent Multi-AZ db.r6g.large PostgreSQL reservation suppresses two Single-AZ db.r6g.large recommendations, and a Single-AZ db.r6g.xlarge suppresses one Multi-AZ db.r6g.large. Exact-class engines such as SQL Server keep their key.

  • The duplicate-purchase guard now treats regional Linux/Unix default-tenancy EC2 reservations as size-flexible (#323): a recent m5.xlarge reservation suppresses two m5.large recommendations in the same region, counted in normalized units. Zonal, Windows/RHEL/SUSE, dedicated, wildcard and unknown-size entries stay exact-type, as do the families AWS excludes from size flexibility (G4ad, G4dn, G5, G5g, G6, G6e, G6f, Gr6, Gr6f, hpc7a, P5, Inf1, Inf2, u7i-6tb, u7i-8tb). A partly spent reservation is never credited as a whole node.

  • Unbounded AWS pagination loops now stop at a page cap and honour cancellation (#561): the existing-commitment and valid-resource-type scans for ElastiCache, RDS, OpenSearch, Redshift and EC2 check the context before each page and fail with an error after 50 pages instead of looping forever. The Savings Plans existing-commitment scan now errors at its page cap instead of returning a partial list to the duplicate-purchase guards.

  • Duplicate guard counts an existing RDS reservation against other sizes of the same family (#323): an AWS RDS reservation now pays for recommendations of any size in the same instance family, engine, region and deployment, by normalized units, instead of matching only the exact instance class. Only MySQL, MariaDB, PostgreSQL and Aurora are size-flexible; SQL Server, Oracle (until both paths carry the license model, #342), Db2 and unknown engines still match the exact class.

  • aws/savingsplans: Savings Plans offering lookup, validation and purchase now fail with ErrUnsupportedPartition before any AWS call for cn-* (aws-cn) regions, whose plans are priced in CNY while the purchase path is USD-only; aws and aws-us-gov are unchanged (#7).

  • MemoryDB reserved-node and offering listings are page-capped and cancellable (#556): GetExistingCommitments and GetValidResourceTypes now check the context per page and fail loudly after 50 pages instead of looping on a NextToken that never ends.

  • exchange: reshape no longer treats metal as a fixed 192-unit size: it is removed from the size table, so NormalizationFactorForSize("metal") returns 0 (unknown), no recommendation targets a *.metal type, and a metal RI without a caller-supplied NormalizationFactor is reported as skipped with a reason instead of being sized as 192 units or dropped silently (#552).

  • exchange: reshape recommendations no longer propose a target with more normalized capacity than the source RI owns (3x m5.xlarge at 80% used to become 2x m5.2xlarge, 32 units against 24 owned); findBestFit now steps down to a smaller size when rounding up would exceed the owned units, and skips the RI when nothing fits (#551).

  • azure: compute PurchaseCommitment now checks the term before the payment option and returns the term error unwrapped (no failed to marshal request: prefix), like the other six services (#538).

  • azure: synapse's zero-quantity purchase error now includes the quantity (..., got 0), like the other six services (#538).

  • azure: PurchaseCommitment for cache, compute, cosmosdb, database, managedredis and search now rejects a blank resource type before any HTTP call, as synapse already did, instead of sending an empty sku.name (#538).

  • azure: The shared CUDLY_MAX_PARALLELISM slot is now held per outbound call (page fetch, pricing page, SKU or capability request) instead of across a whole per-service sweep, so a long Azure sweep no longer starves AWS and GCP calls (#8).

  • scorer: MinCount no longer applies to Savings Plans. Their Count is always 1 (the commitment is dollar-denominated), so --min-count 2 dropped every Savings Plan recommendation.

  • aws/recommendations: RDS family-NU sizing and the expiry deduction no longer pool SQL Server by instance family (its RIs are never size-flexible): those recs go to the per-size path and expiring SQL Server RIs count as Unusable. Oracle stays pooled until the license model is carried (#342).

  • aws/recommendations: FamilyExpiryReport.ExpiringNU now reports the NU actually removed from family covered NU (before minus after) instead of the expiring RIs' own NU, so it is 0 when underutilized RIs absorb the expiry (#342).

  • aws and azure/savingsplans recommendations: a Cost Explorer RI or Savings Plan detail with an explicit non-USD CurrencyCode, and an Azure benefit recommendation whose currencyCode is not USD, are skipped instead of passing non-USD OnDemandCost/EstimatedSavings through as USD. AWS reports each skip in IncompleteRecommendationsError (wraps recommendations.ErrNotUSD); Azure records it in the collection's skip log, surfacing as PartialResultError. An absent AWS CurrencyCode is unchanged (#124)

  • aws/recommendations: the Savings Plans coverage and utilization and on-demand Cost Explorer fetchers now hold the shared concurrency slot around each call, so they count toward CUDLY_MAX_PARALLELISM (#8).

  • azure: the Retail Prices $filter values built from SKU and region in the search, compute, cosmosdb and savingsplans clients are now validated with pricing.ODataString, so an injected value is rejected before any request is built (#526).

  • reporter.RenderSummary now lists filtered-reason categories in sorted order instead of random map order (#110).

  • gcp/computeengine: a Recommender cost projection with a non-zero cost and a non-USD or missing currency code is now skipped with a logged warning instead of being reported as USD EstimatedSavings.

  • azure/compute: reservation exchange targets are no longer always billed Upfront. ExchangeTarget.BillingPlan (new, optional) is sent as each target's billingPlan in the CalculateExchange body, so the session that ExecuteExchange commits carries it. Unset keeps the previous Upfront request byte for byte; anything other than Upfront or Monthly (exact spelling) is a validation error before any request (#89).

  • ladder.Allocate no longer subtracts existing commitment from a residual baseline a second time (#282). New UsageBaseline.Basis (BaselineBasisTotal, the default including the empty value, or BaselineBasisResidual). A residual baseline counts only usage existing commitments left uncovered, so Allocate sizes low_water * target% - in_flight (never above the residual) instead of low_water - existing, which held a $4/hr residual with a $6/hr Savings Plan as "target already met". A residual baseline with a target below 100% and existing commitment is held (the gap needs the covered usage the residual excludes). Expiring commitment is not added back on that basis. Unknown basis values are an error. Additive: total-basis results are unchanged. The AWS ladder baseline now declares the residual basis (its series counts only uncovered On Demand Instances usage), so a partly covered AWS account is no longer held as "target already met"; with a target below 100% and existing commitment it is held ("residual baseline cannot size a partial target") instead of being undersized by subtracting that commitment from the residual again. Part of #282.

  • azure/savingsplans: the commitment currency is no longer hardcoded to USD. SavingsPlanDetails.Currency (new, additive) is sent in the purchase and validate bodies and returned by GetOfferingDetails; empty or malformed values (anything but 3 ASCII letters; format-only, not ISO 4217 membership) fail closed (#46).

  • pkg/insurance: hardened vendor-text handling in Client errors (#286). The sanitizer now also strips format, line and paragraph separator characters (Unicode Cf, Zl, Zp) from vendor text; other invisible characters (for example U+034F, variation selectors, U+3164) are not stripped and can still split an echoed key, which is why NewClient now rejects any API key that is not printable ASCII (0x21-0x7E). Comparison and Plan decode errors go through the same strip, redact and truncate pipeline as HTTPError.Message, and a Retry-After beyond the int range is capped at 24 h instead of ignored.

  • pkg/insurance: decode errors no longer echo an uncapped vendor value (#336). A rejected enum value is shown only when it is a short identifier ([A-Za-z0-9_.-], up to 32 bytes); anything else is reported as (N bytes, not shown), so a hostile response cannot flood logs or inject text into an error that a consumer prints or returns to an LLM.

  • Units change (Azure Consumption recommendations): the cost fields were amounts over the API's lookback window but were treated as monthly figures and term totals (#267). For recommendations from the Consumption ReservationRecommendations API (compute, database, cache, cosmosdb, synapse, managedredis; the Advisor path is unchanged): OnDemandCost and EstimatedSavings are now monthly run-rates (window amount x 30.4375 / lookback days; savings is net of overage); CommitmentCost is now Count x the reservation retail price for the term (upfront variant) or 0 (monthly variant); RecurringMonthlyCost is now 0 (upfront) or Count x price / term months (monthly), never the window total. The lookback is requested explicitly (Last7Days) and read from the response. A recommendation with a missing or unknown lookback or term, a non-USD modern currency, or no resolvable reservation price is skipped with an error log instead of being returned with guessed figures. A price lookup that fails to complete (transport error, HTTP error status, cancelled or expired context) instead fails the whole service's GetRecommendations call. Consumers that cache or compare these fields (caps, payback, savings thresholds) will see different magnitudes after upgrading. In this repo, pkg/reporter/reporter.go (lines 44, 96) and pkg/common/audit.go (line 301) use CommitmentCost and will now see 0 for monthly variants; the platform's recTotalCommitment must add RecurringMonthlyCost x term months to get the true total commitment of a monthly variant. Those consumers are not changed here

  • Align pre-commit gocyclo threshold (10) with CI pipeline

  • Pin tool versions in GitHub Actions for reproducible builds

  • The local git-secrets setup script aborted on its PEM pattern and, when patched past that, made every scan fail on an invalid regex; its keyword allowlist whitelisted whole lines containing common Go/Terraform tokens. Allowlisting now lives in .gitallowed as literal entries and the PEM detector covers PKCS#8 keys (#1972)

Removed

  • BREAKING: providers/azure/services/cache no longer exports RecommendationsPager, (*Client).SetRecommendationsPager or (*Client).ReservationUnitPrice. The cache client no longer collects or prices recommendations; managedredis does. No cli, mcp or platform code references them. (#692)
  • BREAKING: common.Matches (pkg/common) is removed. It compared only Provider, Region, Service, ResourceType and engine and had no callers in this repo, the CLI, the MCP server or the platform; use pkg/recfilter for dedupe. (#123)
  • BREAKING: the pkg/errors package is removed (no importers). Removed exported symbols: NotFoundError, ValidationError, AuthenticationError, AuthorizationError, ConflictError, RateLimitError, ServiceError, their New*/Is* helpers (NewNotFoundError, NewNotFoundErrorWithMessage, IsNotFoundError, NewValidationError, IsValidationError, NewAuthenticationError, IsAuthenticationError, NewAuthorizationError, IsAuthorizationError, NewConflictError, IsConflictError, NewRateLimitError, IsRateLimitError, NewServiceError, IsServiceError) and the sentinels ErrNotFound, ErrUnauthorized, ErrForbidden, ErrInvalidInput, ErrConflict, ErrInternalError. (#123)
  • BREAKING: the pkg/config package is removed (no importers). Removed exported symbols: Load, DefaultScorerConfig, Config, AWSConfig, AzureConfig, GCPConfig and ServerConfig. The pkg module no longer depends on github.com/spf13/pflag. (#123)

Releases before the split of this repository (0.9.0 and earlier) are not listed here; they described the combined product and live in the history of cloud-commitments-cli.