@pagopa/dx-savemoney 0.3.3 → 0.5.0

package/src/azure/analyzer.ts

@@ -32,11 +32,7 @@ import { getLogger } from "@logtape/logtape";
 import pLimit from "p-limit";
 
 import type { Finding } from "../finding.js";
-import type {
-  AzureConfig,
-  AzureDetailedResourceReport,
-  AzureSource,
-} from "./types.js";
+import type { AzureConfig, AzureDetailedResourceReport } from "./types.js";
 
 import { findingsFromAnalysisResult } from "../finding.js";
 import {
@@ -54,10 +50,10 @@ import {
   createDefaultSubscriptionAnalyzers,
   type SubscriptionAnalyzer,
 } from "./analyzers/index.js";
+import { PricingClient, PricingService } from "./pricing/index.js";
 import { matchesTags, type MetricsCache } from "./utils.js";
 
 const DEFAULT_CONCURRENCY = 8;
-const DEFAULT_SOURCES: AzureSource[] = ["advisor", "custom"];
 
 const RISK_ORDER: Record<CostRisk, number> = { high: 0, low: 2, medium: 1 };
 
@@ -85,9 +81,8 @@ export async function analyzeAzureResources(
   const credential = new DefaultAzureCredential();
   const allReports: AzureDetailedResourceReport[] = [];
 
-  const sources = config.sources ?? DEFAULT_SOURCES;
-  const customEnabled = sources.includes("custom");
-  const advisorEnabled = sources.includes("advisor");
+  const customEnabled = config.sources.includes("custom");
+  const advisorEnabled = config.sources.includes("advisor");
 
   const analyzers = createDefaultAnalyzers();
   const subscriptionAnalyzers = advisorEnabled
@@ -95,6 +90,10 @@ export async function analyzeAzureResources(
     : [];
   const thresholds: Thresholds = config.thresholds ?? DEFAULT_THRESHOLDS;
 
+  // Build a single PricingService for the whole run when enabled, so the
+  // disk cache and in-memory memo are shared across subscriptions.
+  const pricing = buildPricingService(config);
+
   // Normalise concurrency the same way p-limit does to keep maxInFlight
   // consistent. A raw value of 0/NaN would produce maxInFlight = 0/NaN and
   // either deadlock or silently disable backpressure.
@@ -140,6 +139,7 @@ export async function analyzeAzureResources(
         limit,
         logger,
         maxInFlight,
+        pricing,
         reports: allReports,
         reportsById,
         runCache,
@@ -214,6 +214,7 @@ export async function analyzeResource(
   timespanDays: number,
   thresholds: Thresholds,
   verbose = false,
+  pricing?: PricingService,
 ): Promise<AnalysisResult> {
   let result: AnalysisResult = {
     costRisk: "low",
@@ -231,6 +232,7 @@ export async function analyzeResource(
     clients,
     metricsCache,
     preferredLocation,
+    pricing,
     resource,
     thresholds,
     timespanDays,
@@ -262,6 +264,50 @@ export async function analyzeResource(
   return { ...result, reason: result.reason.trim() };
 }
 
+/**
+ * Inserts a `Finding` into the right report entry, creating a stub
+ * resource entry on the fly when the finding refers to a resource that
+ * the per-resource pass did not analyze.
+ */
+export function mergeFinding(
+  finding: Finding,
+  reports: AzureDetailedResourceReport[],
+  reportsById: Map<string, AzureDetailedResourceReport>,
+): void {
+  const idKey = finding.resourceId.toLowerCase();
+  const existing = reportsById.get(idKey);
+  if (existing) {
+    existing.findings = [...(existing.findings ?? []), finding];
+    const added = analysisFromFinding(finding);
+    // Use max costRisk (not last-wins) and join reasons with a space so we
+    // don't produce "Sentence one.Sentence two." when the existing reason is
+    // already trimmed (i.e. has no trailing separator space).
+    existing.analysis = {
+      costRisk:
+        RISK_ORDER[existing.analysis.costRisk] <= RISK_ORDER[added.costRisk]
+          ? existing.analysis.costRisk
+          : added.costRisk,
+      estimatedMonthlySavings: existing.analysis.estimatedMonthlySavings,
+      reason:
+        existing.analysis.reason && added.reason
+          ? `${existing.analysis.reason.trimEnd()} ${added.reason.trimStart()}`
+          : existing.analysis.reason || added.reason,
+      suspectedUnused:
+        existing.analysis.suspectedUnused || added.suspectedUnused,
+    };
+    return;
+  }
+
+  const stub = buildResourceStub(finding.resourceId);
+  const report: AzureDetailedResourceReport = {
+    analysis: analysisFromFinding(finding),
+    findings: [finding],
+    resource: stub,
+  };
+  reports.push(report);
+  reportsById.set(idKey, report);
+}
+
 export function shouldIncludeAdvisorFindingForTags(
   finding: Finding,
   taggedResourceIds: ReadonlySet<string>,
@@ -295,6 +341,18 @@ function analysisFromFinding(finding: Finding): AnalysisResult {
   };
 }
 
+/**
+ * Builds the shared `PricingService` for the run when pricing enrichment
+ * is enabled. Returns `undefined` when the CLI disables pricing via
+ * `--no-pricing`; otherwise the client/cache use internal defaults.
+ */
+function buildPricingService(config: AzureConfig): PricingService | undefined {
+  if (config.pricing?.enabled === false) {
+    return undefined;
+  }
+  return new PricingService(new PricingClient());
+}
+
 /**
  * Builds a minimal `GenericResource` from a resource ID. Used when a
  * subscription-level analyzer surfaces a resource the per-resource pass
@@ -383,49 +441,6 @@ function isSubscriptionScopedReport(r: AzureDetailedResourceReport): boolean {
   return r.resource.type === "Microsoft.Subscription";
 }
 
-/**
- * Inserts a `Finding` into the right report entry, creating a stub
- * resource entry on the fly when the finding refers to a resource that
- * the per-resource pass did not analyze.
- */
-function mergeFinding(
-  finding: Finding,
-  reports: AzureDetailedResourceReport[],
-  reportsById: Map<string, AzureDetailedResourceReport>,
-): void {
-  const idKey = finding.resourceId.toLowerCase();
-  const existing = reportsById.get(idKey);
-  if (existing) {
-    existing.findings = [...(existing.findings ?? []), finding];
-    const added = analysisFromFinding(finding);
-    // Use max costRisk (not last-wins) and join reasons with a space so we
-    // don't produce "Sentence one.Sentence two." when the existing reason is
-    // already trimmed (i.e. has no trailing separator space).
-    existing.analysis = {
-      costRisk:
-        RISK_ORDER[existing.analysis.costRisk] <= RISK_ORDER[added.costRisk]
-          ? existing.analysis.costRisk
-          : added.costRisk,
-      reason:
-        existing.analysis.reason && added.reason
-          ? `${existing.analysis.reason.trimEnd()} ${added.reason.trimStart()}`
-          : existing.analysis.reason || added.reason,
-      suspectedUnused:
-        existing.analysis.suspectedUnused || added.suspectedUnused,
-    };
-    return;
-  }
-
-  const stub = buildResourceStub(finding.resourceId);
-  const report: AzureDetailedResourceReport = {
-    analysis: analysisFromFinding(finding),
-    findings: [finding],
-    resource: stub,
-  };
-  reports.push(report);
-  reportsById.set(idKey, report);
-}
-
 function normalizeResourceId(resourceId: string | undefined): string {
   return (resourceId ?? "").trim().toLowerCase();
 }
@@ -443,6 +458,7 @@ async function runPerResourceAnalysis(args: {
   limit: ReturnType<typeof pLimit>;
   logger: ReturnType<typeof getLogger>;
   maxInFlight: number;
+  pricing?: PricingService;
   reports: AzureDetailedResourceReport[];
   reportsById: Map<string, AzureDetailedResourceReport>;
   runCache: MetricsCache;
@@ -458,6 +474,7 @@ async function runPerResourceAnalysis(args: {
     limit,
     logger,
     maxInFlight,
+    pricing,
     reports,
     reportsById,
     runCache,
@@ -500,6 +517,7 @@ async function runPerResourceAnalysis(args: {
         config.timespanDays,
         thresholds,
         config.verbose || false,
+        pricing,
       );
 
       if (analysis.suspectedUnused) {

package/src/azure/analyzers/registry.ts

@@ -57,8 +57,8 @@ export function createDefaultAnalyzers(): Analyzer[] {
       supports: (r) => r.type?.toLowerCase() === "microsoft.app/containerapps",
     },
     {
-      analyze: ({ clients, resource, verbose }) =>
-        analyzeDisk(resource, clients.compute, verbose),
+      analyze: ({ clients, pricing, resource, verbose }) =>
+        analyzeDisk(resource, clients.compute, verbose, pricing),
       id: "azure.disk",
       supports: (r) => r.type?.toLowerCase() === "microsoft.compute/disks",
     },
@@ -66,6 +66,7 @@ export function createDefaultAnalyzers(): Analyzer[] {
       analyze: ({
         clients,
         metricsCache,
+        pricing,
         resource,
         thresholds,
         timespanDays,
@@ -79,6 +80,7 @@ export function createDefaultAnalyzers(): Analyzer[] {
           thresholds,
           verbose,
           metricsCache,
+          pricing,
         ),
       id: "azure.vm",
       supports: (r) =>
@@ -102,6 +104,7 @@ export function createDefaultAnalyzers(): Analyzer[] {
       analyze: ({
         clients,
         metricsCache,
+        pricing,
         resource,
         thresholds,
         timespanDays,
@@ -115,6 +118,7 @@ export function createDefaultAnalyzers(): Analyzer[] {
           thresholds,
           verbose,
           metricsCache,
+          pricing,
         ),
       id: "azure.public-ip",
       supports: (r) =>
@@ -145,6 +149,7 @@ export function createDefaultAnalyzers(): Analyzer[] {
       analyze: ({
         clients,
         metricsCache,
+        pricing,
         resource,
         thresholds,
         timespanDays,
@@ -158,6 +163,7 @@ export function createDefaultAnalyzers(): Analyzer[] {
           thresholds,
           verbose,
           metricsCache,
+          pricing,
         ),
       id: "azure.app-service-plan",
       supports: (r) => r.type?.toLowerCase() === "microsoft.web/serverfarms",

package/src/azure/analyzers/types.ts

@@ -20,6 +20,7 @@ import type { NetworkManagementClient } from "@azure/arm-network";
 import type * as armResources from "@azure/arm-resources";
 
 import type { AnalysisResult, Thresholds } from "../../types.js";
+import type { PricingService } from "../pricing/pricing-service.js";
 import type { MetricsCache } from "../utils.js";
 
 /**
@@ -46,6 +47,11 @@ export type AnalyzerContext = {
    */
   metricsCache: MetricsCache;
   preferredLocation: string;
+  /**
+   * Optional pricing facade used to enrich findings with an estimated
+   * monthly cost. Absent when pricing is disabled via config / CLI.
+   */
+  pricing?: PricingService;
   resource: armResources.GenericResource;
   thresholds: Thresholds;
   timespanDays: number;

package/src/azure/config.ts

@@ -71,11 +71,7 @@ export async function loadAzureConfig(
     ? process.env.ARM_SUBSCRIPTION_ID.split(",")
     : (await prompt("Enter Subscription IDs (comma-separated): ")).split(",");
 
-  return {
-    preferredLocation: "italynorth",
-    subscriptionIds,
-    timespanDays: 30,
-  };
+  return ConfigSchema.parse({ azure: { subscriptionIds } }).azure;
 }
 
 /**

package/src/azure/pricing/__tests__/cache.test.ts

@@ -0,0 +1,67 @@
+/**
+ * Tests for the disk-backed pricing cache.
+ *
+ * Each test uses a freshly-created temp directory so they do not leak
+ * state into the developer's real pricing cache.
+ */
+
+import { writeFile } from "node:fs/promises";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { DiskCache } from "../cache.js";
+import { makeTestCacheDir, removeTestCacheDir } from "../test-cache-dir.js";
+
+describe("DiskCache", () => {
+  let dir: string;
+  beforeEach(async () => {
+    dir = await makeTestCacheDir("cache");
+  });
+  afterEach(async () => {
+    await removeTestCacheDir(dir);
+  });
+
+  it("returns undefined on a miss", async () => {
+    const cache = new DiskCache({ dir });
+    await expect(cache.get("nope")).resolves.toBeUndefined();
+  });
+
+  it("returns the value written under the same key", async () => {
+    const cache = new DiskCache({ dir });
+    await cache.set("hello", { hits: 42 });
+    await expect(cache.get("hello")).resolves.toEqual({ hits: 42 });
+  });
+
+  it("treats different keys as independent entries", async () => {
+    const cache = new DiskCache({ dir });
+    await cache.set("a", 1);
+    await cache.set("b", 2);
+    await expect(cache.get("a")).resolves.toBe(1);
+    await expect(cache.get("b")).resolves.toBe(2);
+  });
+
+  it("returns undefined once the entry is older than ttlMs", async () => {
+    const cache = new DiskCache({ dir, ttlMs: 1 });
+    await cache.set("stale", { v: 1 });
+    // Wait long enough to outlast the 1 ms TTL.
+    await new Promise((resolve) => setTimeout(resolve, 25));
+    await expect(cache.get("stale")).resolves.toBeUndefined();
+  });
+
+  it("returns undefined when the cache file contains invalid JSON", async () => {
+    const cache = new DiskCache({ dir });
+    const path = cache.pathFor("broken");
+    await writeFile(path, "{not json", "utf8");
+    await expect(cache.get("broken")).resolves.toBeUndefined();
+  });
+
+  it("derives different paths for different keys", () => {
+    const cache = new DiskCache({ dir });
+    expect(cache.pathFor("a")).not.toBe(cache.pathFor("b"));
+  });
+
+  it("refuses to remove directories outside the test cache parent", async () => {
+    await expect(removeTestCacheDir(process.cwd())).rejects.toThrow(
+      /non-test cache directory/,
+    );
+  });
+});

package/src/azure/pricing/__tests__/client.test.ts

@@ -0,0 +1,212 @@
+/**
+ * Tests for the Azure Retail Prices HTTP client.
+ *
+ * The client is exercised against an in-process fake `fetch` so the suite
+ * never reaches the real `prices.azure.com` endpoint. A temp directory is
+ * used as cache so each test starts from a cold state.
+ */
+
+import { readFile } from "node:fs/promises";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { FetchLike } from "../client.js";
+
+import { DiskCache } from "../cache.js";
+import { PricingClient } from "../client.js";
+import { makeTestCacheDir, removeTestCacheDir } from "../test-cache-dir.js";
+
+const FIXTURE_PATH = new URL(
+  "./fixtures/vm-b2s-westeurope.json",
+  import.meta.url,
+);
+
+async function loadFixture(): Promise<unknown> {
+  const raw = await readFile(FIXTURE_PATH, "utf8");
+  return JSON.parse(raw);
+}
+
+function makeOkFetch(body: unknown): FetchLike {
+  return vi.fn(async () => ({
+    json: async () => body,
+    ok: true,
+    status: 200,
+    statusText: "OK",
+  }));
+}
+
+describe("PricingClient.query", () => {
+  let dir: string;
+  beforeEach(async () => {
+    dir = await makeTestCacheDir("client");
+  });
+  afterEach(async () => {
+    await removeTestCacheDir(dir);
+  });
+
+  it("returns the items from a single page response", async () => {
+    const body = await loadFixture();
+    const fetchImpl = makeOkFetch(body);
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: fetchImpl,
+    });
+
+    const items = await client.query("serviceName eq 'Virtual Machines'");
+
+    expect(items).toHaveLength(2);
+    expect(items[0].armSkuName).toBe("Standard_B2s");
+    expect(items[0].unitPrice).toBe(0.057);
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
+
+  it("includes the filter, currency, and api-version in the request URL", async () => {
+    const body = await loadFixture();
+    const fetchImpl = makeOkFetch(body);
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      currencyCode: "EUR",
+      fetch: fetchImpl,
+    });
+
+    await client.query("serviceName eq 'Virtual Machines'");
+
+    const url = (fetchImpl as ReturnType<typeof vi.fn>).mock
+      .calls[0][0] as string;
+    expect(url).toContain("prices.azure.com/api/retail/prices");
+    expect(url).toContain("currencyCode=EUR");
+    expect(url).toContain("api-version=");
+    // URLSearchParams encodes spaces as `+` (form-urlencoded), so we
+    // convert them back before decoding the filter expression.
+    const decoded = decodeURIComponent(url.replace(/\+/g, " "));
+    expect(decoded).toContain("$filter=serviceName eq 'Virtual Machines'");
+  });
+
+  it("follows NextPageLink across multiple pages", async () => {
+    const page1 = {
+      Count: 1,
+      Items: [
+        {
+          currencyCode: "EUR",
+          retailPrice: 1,
+          type: "Consumption",
+          unitOfMeasure: "1 Hour",
+          unitPrice: 1,
+        },
+      ],
+      NextPageLink: "https://prices.azure.com/api/retail/prices?next=2",
+    };
+    const page2 = {
+      Count: 1,
+      Items: [
+        {
+          currencyCode: "EUR",
+          retailPrice: 2,
+          type: "Consumption",
+          unitOfMeasure: "1 Hour",
+          unitPrice: 2,
+        },
+      ],
+      NextPageLink: null,
+    };
+    const fetchImpl = vi
+      .fn<FetchLike>()
+      .mockResolvedValueOnce({
+        json: async () => page1,
+        ok: true,
+        status: 200,
+        statusText: "OK",
+      })
+      .mockResolvedValueOnce({
+        json: async () => page2,
+        ok: true,
+        status: 200,
+        statusText: "OK",
+      });
+
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: fetchImpl,
+    });
+    const items = await client.query("anything");
+
+    expect(items.map((i) => i.unitPrice)).toEqual([1, 2]);
+    expect(fetchImpl).toHaveBeenCalledTimes(2);
+  });
+
+  it("serves a cached response without hitting the network on the second call", async () => {
+    const body = await loadFixture();
+    const fetchImpl = makeOkFetch(body);
+    const cache = new DiskCache({ dir });
+    const client = new PricingClient({ cache, fetch: fetchImpl });
+
+    const first = await client.query("filter-a");
+    const second = await client.query("filter-a");
+
+    expect(first).toEqual(second);
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
+
+  it("keeps cache entries scoped by currency", async () => {
+    const body = await loadFixture();
+    const fetchImpl = makeOkFetch(body);
+    const cache = new DiskCache({ dir });
+    const eur = new PricingClient({
+      cache,
+      currencyCode: "EUR",
+      fetch: fetchImpl,
+    });
+    const usd = new PricingClient({
+      cache,
+      currencyCode: "USD",
+      fetch: fetchImpl,
+    });
+
+    await eur.query("same-filter");
+    await usd.query("same-filter");
+
+    // Two distinct cache keys → two API round-trips, no cross-contamination.
+    expect(fetchImpl).toHaveBeenCalledTimes(2);
+  });
+
+  it("throws a descriptive error on a non-2xx response", async () => {
+    const fetchImpl: FetchLike = vi.fn(async () => ({
+      json: async () => ({}),
+      ok: false,
+      status: 503,
+      statusText: "Service Unavailable",
+    }));
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: fetchImpl,
+    });
+
+    await expect(client.query("x")).rejects.toThrow(/503/);
+  });
+
+  it("throws when the response body fails schema validation", async () => {
+    const fetchImpl = makeOkFetch({ wrong: "shape" });
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: fetchImpl,
+    });
+
+    await expect(client.query("x")).rejects.toThrow();
+  });
+
+  it("throws a descriptive error when the response body is not JSON", async () => {
+    const fetchImpl: FetchLike = vi.fn(async () => ({
+      json: async () => {
+        throw new SyntaxError("Unexpected token");
+      },
+      ok: true,
+      status: 200,
+      statusText: "OK",
+    }));
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: fetchImpl,
+    });
+
+    await expect(client.query("x")).rejects.toThrow(/invalid JSON/);
+  });
+});

package/src/azure/pricing/__tests__/fixtures/vm-b2s-westeurope.json

@@ -0,0 +1,51 @@
+{
+  "BillingCurrency": "EUR",
+  "Count": 2,
+  "Items": [
+    {
+      "currencyCode": "EUR",
+      "tierMinimumUnits": 0,
+      "retailPrice": 0.057,
+      "unitPrice": 0.057,
+      "armRegionName": "westeurope",
+      "location": "EU West",
+      "effectiveStartDate": "2024-01-01T00:00:00Z",
+      "meterId": "00000000-0000-0000-0000-000000000001",
+      "meterName": "B2s",
+      "productId": "DZH318Z0BPVW",
+      "skuId": "DZH318Z0BPVW/0001",
+      "productName": "Virtual Machines BS Series",
+      "skuName": "B2s",
+      "serviceName": "Virtual Machines",
+      "serviceId": "DZH318Z0BPVW",
+      "serviceFamily": "Compute",
+      "unitOfMeasure": "1 Hour",
+      "type": "Consumption",
+      "isPrimaryMeterRegion": true,
+      "armSkuName": "Standard_B2s"
+    },
+    {
+      "currencyCode": "EUR",
+      "tierMinimumUnits": 0,
+      "retailPrice": 0.0285,
+      "unitPrice": 0.0285,
+      "armRegionName": "westeurope",
+      "location": "EU West",
+      "effectiveStartDate": "2024-01-01T00:00:00Z",
+      "meterId": "00000000-0000-0000-0000-000000000002",
+      "meterName": "B2s Low Priority",
+      "productId": "DZH318Z0BPVW",
+      "skuId": "DZH318Z0BPVW/0002",
+      "productName": "Virtual Machines BS Series",
+      "skuName": "B2s Spot",
+      "serviceName": "Virtual Machines",
+      "serviceId": "DZH318Z0BPVW",
+      "serviceFamily": "Compute",
+      "unitOfMeasure": "1 Hour",
+      "type": "Consumption",
+      "isPrimaryMeterRegion": true,
+      "armSkuName": "Standard_B2s"
+    }
+  ],
+  "NextPageLink": null
+}