@pagopa/dx-savemoney 0.3.2 → 0.4.0

package/src/azure/report.ts

@@ -38,7 +38,19 @@ const RISK_COLOR = {
 } as const;
 
 type Summary = {
+  /**
+   * Per-resource cost (i.e. the monthly bill the resource is currently
+   * generating) summed across resources flagged as suspected unused by
+   * custom analyzers. Represents the UPPER BOUND of what could be saved
+   * by removing the resource, NOT the saving of any individual finding.
+   */
+  costAtRiskByCurrency: Map<string, number>;
   counts: { high: number; low: number; medium: number };
+  /**
+   * Sum of Advisor's per-finding `extendedProperties.savingsAmount`
+   * values. These are authoritative point estimates from Azure ("apply
+   * this recommendation and save €X"), so they aggregate cleanly.
+   */
   savingsByCurrency: Map<string, number>;
   sourceCounts: Record<string, number>;
 };
@@ -111,6 +123,7 @@ export async function generateReport(
  */
 function computeSummary(report: AzureDetailedResourceReport[]): Summary {
   const summary: Summary = {
+    costAtRiskByCurrency: new Map(),
     counts: { high: 0, low: 0, medium: 0 },
     savingsByCurrency: new Map(),
     sourceCounts: {},
@@ -131,7 +144,7 @@ function computeSummary(report: AzureDetailedResourceReport[]): Summary {
       summary.counts[line.severity]++;
       summary.sourceCounts[line.source] =
         (summary.sourceCounts[line.source] ?? 0) + 1;
-      if (line.savings) {
+      if (line.source === "advisor" && line.savings) {
         summary.savingsByCurrency.set(
           line.savings.currency,
           (summary.savingsByCurrency.get(line.savings.currency) ?? 0) +
@@ -139,6 +152,16 @@ function computeSummary(report: AzureDetailedResourceReport[]): Summary {
         );
       }
     }
+    // Per-resource cost: counted ONCE per resource (not per finding) so
+    // that a resource with N findings doesn't inflate the total by Nx.
+    const costAtRisk = entry.analysis.estimatedMonthlySavings;
+    if (costAtRisk) {
+      summary.costAtRiskByCurrency.set(
+        costAtRisk.currency,
+        (summary.costAtRiskByCurrency.get(costAtRisk.currency) ?? 0) +
+          costAtRisk.amount,
+      );
+    }
   }
   return summary;
 }
@@ -162,48 +185,79 @@ function formatAmount(amount: number, currency: string): string {
 }
 
 /**
- * Renders an estimated monthly savings value as the short "(€ 12.50/mo)"
- * label that ships next to each lint line. Returns an empty string when
- * the analyzer didn't provide an estimate.
+ * Renders an Advisor per-finding monthly saving as the short
+ * "(saving: € 12.50/mo)" label that ships next to each lint line.
+ * Returns an empty string when the finding doesn't carry an estimate.
+ *
+ * Only Advisor populates this today: Microsoft attaches an authoritative
+ * per-recommendation saving to each recommendation, so it aggregates
+ * cleanly. Custom analyzers do NOT propagate the resource's monthly
+ * bill down to each finding — see the per-resource "cost at risk"
+ * header rendered by `generateLintReport` instead.
  */
-function formatSavings(savings: Money | undefined): string {
+function formatPerFindingSavings(savings?: Money): string {
   if (!savings) return "";
-  return `(${formatAmount(savings.amount, savings.currency)}/mo)`;
+  return `(saving: ${formatAmount(savings.amount, savings.currency)}/mo)`;
 }
 
 /**
  * Renders a linter-style report to stdout, grouping findings by resource.
  *
  * When `Finding[]` is attached to a report (Phase 1+), each finding is
- * rendered with its `source` badge (e.g. `[advisor]`) and the estimated
- * monthly savings, when known. For older payloads without `findings` we
- * fall back to splitting `analysis.reason` like before so the format stays
- * backward compatible.
+ * rendered with its `source` badge (e.g. `[advisor]`) and its own
+ * estimated monthly saving (when populated by Advisor). For older
+ * payloads without `findings` we fall back to splitting `analysis.reason`
+ * like before so the format stays backward compatible.
+ *
+ * When a custom analyzer populated `analysis.estimatedMonthlySavings`,
+ * the value is printed ONCE per resource as a header annotation labelled
+ * "cost at risk" — it represents the monthly bill of the resource (an
+ * upper bound on what could be recovered by removing it), NOT the saving
+ * of any individual finding sentence.
  *
  * Example output:
  *
- *   /subscriptions/.../virtualMachines/my-vm
- *     ✖ HIGH    [advisor] Right-size your VM. (€ 12.50/mo)
+ *   /subscriptions/.../virtualMachines/my-vm  (cost at risk: € 29.94/mo)
  *     ✖ HIGH    [custom]  No tags found.
+ *     ✖ HIGH    [custom]  VM is deallocated.
+ *
+ *   /subscriptions/.../virtualMachines/other-vm
+ *     ✖ HIGH    [advisor] Right-size your VM. (saving: € 12.50/mo)
  *
  *   Summary: 3 issues found  (2 high, 0 medium, 1 low)
- *   Estimated monthly savings: € 12.50
+ *   Estimated monthly cost at risk (custom): € 29.94
+ *   Estimated monthly savings (advisor):     € 12.50
  */
 function generateLintReport(report: AzureDetailedResourceReport[]): void {
-  const summary = {
+  const summary: Summary = {
+    costAtRiskByCurrency: new Map(),
     counts: { high: 0, low: 0, medium: 0 },
-    savingsByCurrency: new Map<string, number>(),
-    sourceCounts: {} as Record<string, number>,
+    savingsByCurrency: new Map(),
+    sourceCounts: {},
   };
 
   for (const entry of report) {
     const resourceId =
       entry.resource.id ?? `unknown/${entry.resource.name ?? "unknown"}`;
-    console.log(`${BOLD}${resourceId}${RESET}`);
+    const costAtRisk = entry.analysis.estimatedMonthlySavings;
+    const header = costAtRisk
+      ? `${BOLD}${resourceId}${RESET}  ${GREEN}(cost at risk: ${formatAmount(costAtRisk.amount, costAtRisk.currency)}/mo)${RESET}`
+      : `${BOLD}${resourceId}${RESET}`;
+    console.log(header);
+    if (costAtRisk) {
+      summary.costAtRiskByCurrency.set(
+        costAtRisk.currency,
+        (summary.costAtRiskByCurrency.get(costAtRisk.currency) ?? 0) +
+          costAtRisk.amount,
+      );
+    }
 
     const lines = entry.findings?.length
       ? entry.findings.map((f) => ({
-          extra: formatSavings(f.estimatedMonthlySavings),
+          extra:
+            f.source === "advisor"
+              ? formatPerFindingSavings(f.estimatedMonthlySavings)
+              : "",
           severity: f.severity,
           source: f.source,
           text: f.reason,
@@ -231,7 +285,7 @@ function generateLintReport(report: AzureDetailedResourceReport[]): void {
 
     if (entry.findings) {
       for (const f of entry.findings) {
-        if (f.estimatedMonthlySavings) {
+        if (f.source === "advisor" && f.estimatedMonthlySavings) {
           const { amount, currency } = f.estimatedMonthlySavings;
           summary.savingsByCurrency.set(
             currency,
@@ -259,7 +313,8 @@ function generateLintReport(report: AzureDetailedResourceReport[]): void {
  * out of scope for this tool.
  */
 function printSummary(summary: Summary): void {
-  const { counts, savingsByCurrency, sourceCounts } = summary;
+  const { costAtRiskByCurrency, counts, savingsByCurrency, sourceCounts } =
+    summary;
   const total = counts.high + counts.medium + counts.low;
   const summaryLine =
     `${BOLD}Summary:${RESET} ${total} issue${total !== 1 ? "s" : ""} found` +
@@ -276,13 +331,23 @@ function printSummary(summary: Summary): void {
     console.log(`${BOLD}Sources:${RESET} ${sourceBreakdown}`);
   }
 
+  if (costAtRiskByCurrency.size > 0) {
+    const parts = [...costAtRiskByCurrency.entries()].map(
+      ([currency, amount]) =>
+        `${GREEN}${formatAmount(amount, currency)}${RESET}`,
+    );
+    console.log(
+      `${BOLD}Estimated monthly cost at risk (custom):${RESET} ${parts.join(", ")}`,
+    );
+  }
+
   if (savingsByCurrency.size > 0) {
     const parts = [...savingsByCurrency.entries()].map(
       ([currency, amount]) =>
         `${GREEN}${formatAmount(amount, currency)}${RESET}`,
     );
     console.log(
-      `${BOLD}Estimated monthly savings:${RESET} ${parts.join(", ")}`,
+      `${BOLD}Estimated monthly savings (advisor):${RESET} ${parts.join(", ")}`,
     );
   }
 }

package/src/azure/resources/__tests__/app-service.test.ts

@@ -0,0 +1,165 @@
+/**
+ * Tests for analyzeAppServicePlan() pricing enrichment.
+ */
+
+import type { GenericResource } from "@azure/arm-resources";
+
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { MonitorClientLike } from "../../utils.js";
+import type { AppServicePlanClientLike } from "../app-service.js";
+
+import { DEFAULT_THRESHOLDS } from "../../../types.js";
+
+vi.mock("../../utils.js", () => ({
+  getMetric: vi.fn(),
+  verboseLog: vi.fn(),
+  verboseLogAnalysisResult: vi.fn(),
+  verboseLogResourceStart: vi.fn(),
+}));
+
+import { getMetric } from "../../utils.js";
+import { analyzeAppServicePlan } from "../app-service.js";
+
+const RESOURCE: GenericResource = {
+  id: "/subscriptions/sub1/resourceGroups/rg1/providers/Microsoft.Web/serverfarms/plan1",
+  location: "westeurope",
+  name: "plan1",
+  type: "Microsoft.Web/serverfarms",
+};
+
+const mockGetMetric = vi.mocked(getMetric);
+
+function makeMonitorClient() {
+  return {
+    metrics: { list: vi.fn() },
+  } satisfies MonitorClientLike;
+}
+
+function makePricingService() {
+  return {
+    resolveAppServicePlan: vi.fn().mockResolvedValue({
+      amount: 121.72,
+      currency: "EUR",
+    }),
+  };
+}
+
+function makeWebSiteClient(planDetails: {
+  numberOfSites?: number;
+  reserved?: boolean;
+  sku?: {
+    capacity?: number;
+    name?: string;
+    tier?: string;
+  };
+}) {
+  const client = {
+    appServicePlans: {
+      get: vi.fn().mockResolvedValue({
+        location: "westeurope",
+        ...planDetails,
+      }),
+    },
+  } satisfies AppServicePlanClientLike;
+  return client;
+}
+
+describe("analyzeAppServicePlan", () => {
+  beforeEach(() => {
+    mockGetMetric.mockReset();
+    mockGetMetric.mockResolvedValue(50);
+  });
+
+  it("enriches suspected unused plans with App Service Plan pricing", async () => {
+    const pricing = makePricingService();
+
+    const result = await analyzeAppServicePlan(
+      RESOURCE,
+      makeWebSiteClient({
+        numberOfSites: 0,
+        reserved: true,
+        sku: {
+          capacity: 2,
+          name: "S1",
+          tier: "Standard",
+        },
+      }),
+      makeMonitorClient(),
+      30,
+      DEFAULT_THRESHOLDS,
+      false,
+      undefined,
+      pricing,
+    );
+
+    expect(result.estimatedMonthlySavings).toEqual({
+      amount: 121.72,
+      currency: "EUR",
+    });
+    expect(pricing.resolveAppServicePlan).toHaveBeenCalledWith({
+      armRegionName: "westeurope",
+      os: "linux",
+      skuName: "S1",
+      workerCount: 2,
+    });
+  });
+
+  it("does not price Premium underutilization as full removable cost", async () => {
+    mockGetMetric.mockResolvedValue(1);
+    const pricing = makePricingService();
+
+    const result = await analyzeAppServicePlan(
+      RESOURCE,
+      makeWebSiteClient({
+        numberOfSites: 2,
+        reserved: false,
+        sku: {
+          capacity: 3,
+          name: "P1v3",
+          tier: "PremiumV3",
+        },
+      }),
+      makeMonitorClient(),
+      30,
+      DEFAULT_THRESHOLDS,
+      false,
+      undefined,
+      pricing,
+    );
+
+    expect(result.suspectedUnused).toBe(true);
+    expect(result.reason).toContain(
+      "Premium tier with low resource utilization",
+    );
+    expect(result.estimatedMonthlySavings).toBeUndefined();
+    expect(pricing.resolveAppServicePlan).not.toHaveBeenCalled();
+  });
+
+  it("does not treat missing site count as an empty plan", async () => {
+    mockGetMetric.mockResolvedValue(50);
+    const pricing = makePricingService();
+
+    const result = await analyzeAppServicePlan(
+      RESOURCE,
+      makeWebSiteClient({
+        reserved: true,
+        sku: {
+          capacity: 2,
+          name: "S1",
+          tier: "Standard",
+        },
+      }),
+      makeMonitorClient(),
+      30,
+      DEFAULT_THRESHOLDS,
+      false,
+      undefined,
+      pricing,
+    );
+
+    expect(result.suspectedUnused).toBe(false);
+    expect(result.estimatedMonthlySavings).toBeUndefined();
+    expect(pricing.resolveAppServicePlan).not.toHaveBeenCalled();
+  });
+});

package/src/azure/resources/app-service.ts

@@ -3,22 +3,29 @@
  */
 
 import type { WebSiteManagementClient } from "@azure/arm-appservice";
-import type { MonitorClient } from "@azure/arm-monitor";
 
 import * as armResources from "@azure/arm-resources";
 import { getLogger } from "@logtape/logtape";
 
 import type { AnalysisResult, Thresholds } from "../../types.js";
+import type { PricingService } from "../pricing/pricing-service.js";
 
 import { DEFAULT_THRESHOLDS } from "../../types.js";
 import {
   getMetric,
   type MetricsCache,
+  type MonitorClientLike,
   verboseLog,
   verboseLogAnalysisResult,
   verboseLogResourceStart,
 } from "../utils.js";
 
+export type AppServicePlanClientLike = {
+  appServicePlans: Pick<WebSiteManagementClient["appServicePlans"], "get">;
+};
+
+type AppServicePlanPricing = Pick<PricingService, "resolveAppServicePlan">;
+
 /**
  * Analyzes an Azure App Service Plan for potential cost optimization.
  *
@@ -30,12 +37,13 @@ import {
  */
 export async function analyzeAppServicePlan(
   resource: armResources.GenericResource,
-  webSiteClient: WebSiteManagementClient,
-  monitorClient: MonitorClient,
+  webSiteClient: AppServicePlanClientLike,
+  monitorClient: MonitorClientLike,
   timespanDays: number,
   thresholds: Thresholds = DEFAULT_THRESHOLDS,
   verbose = false,
   cache?: MetricsCache,
+  pricing?: AppServicePlanPricing,
 ): Promise<AnalysisResult> {
   verboseLogResourceStart(
     verbose,
@@ -69,8 +77,10 @@ export async function analyzeAppServicePlan(
 
     verboseLog(verbose, "App Service Plan API details:", planDetails);
 
+    const hasNoApps = planDetails.numberOfSites === 0;
+
     // Check if the plan has no apps
-    if (!planDetails.numberOfSites || planDetails.numberOfSites === 0) {
+    if (hasNoApps) {
       reason += "App Service Plan has no apps deployed. ";
     }
 
@@ -115,6 +125,17 @@ export async function analyzeAppServicePlan(
     ) {
       reason += "Premium tier with low resource utilization. ";
     }
+
+    const suspectedUnused = reason.length > 0;
+    const result = await enrichWithPricing(
+      { costRisk, reason: reason.trim(), suspectedUnused },
+      planDetails,
+      resource,
+      hasNoApps,
+      pricing,
+    );
+    verboseLogAnalysisResult(verbose, result);
+    return result;
   } catch (error) {
     const logger = getLogger(["savemoney", "azure"]);
     logger.warn(
@@ -128,3 +149,43 @@ export async function analyzeAppServicePlan(
   verboseLogAnalysisResult(verbose, result);
   return result;
 }
+
+async function enrichWithPricing(
+  result: AnalysisResult,
+  planDetails: Awaited<
+    ReturnType<AppServicePlanClientLike["appServicePlans"]["get"]>
+  >,
+  resource: armResources.GenericResource,
+  hasNoApps: boolean,
+  pricing?: AppServicePlanPricing,
+): Promise<AnalysisResult> {
+  // Underutilized plans need right-sizing analysis, not a full removable
+  // cost-at-risk.
+  if (!pricing || !result.suspectedUnused || !hasNoApps) {
+    return result;
+  }
+
+  try {
+    const skuName = planDetails.sku?.name;
+    const armRegionName = planDetails.location ?? resource.location;
+    if (!skuName || !armRegionName) {
+      return result;
+    }
+
+    const estimatedMonthlySavings = await pricing.resolveAppServicePlan({
+      armRegionName,
+      os: planDetails.reserved === true ? "linux" : "windows",
+      skuName,
+      workerCount: planDetails.sku?.capacity ?? planDetails.numberOfWorkers,
+    });
+    return estimatedMonthlySavings
+      ? { ...result, estimatedMonthlySavings }
+      : result;
+  } catch (error) {
+    const logger = getLogger(["savemoney", "azure"]);
+    logger.warn(
+      `Failed to enrich App Service Plan ${resource.name ?? "unknown"} with pricing: ${error instanceof Error ? error.message : error}`,
+    );
+    return result;
+  }
+}

package/src/azure/resources/disk.ts

@@ -2,13 +2,17 @@
  * Azure Managed Disk analysis
  */
 
-import type { ComputeManagementClient } from "@azure/arm-compute";
+import type { ComputeManagementClient, Disk } from "@azure/arm-compute";
 
 import * as armResources from "@azure/arm-resources";
 import { getLogger } from "@logtape/logtape";
 
+import type { Money } from "../../finding.js";
 import type { AnalysisResult } from "../../types.js";
+import type { PricingService } from "../pricing/pricing-service.js";
+import type { DiskSku } from "../pricing/resolvers/index.js";
 
+import { DiskSkuSchema } from "../pricing/resolvers/index.js";
 import {
   verboseLog,
   verboseLogAnalysisResult,
@@ -21,12 +25,14 @@ import {
  * @param resource - The Azure resource object
  * @param computeClient - Azure Compute client for disk details
  * @param verbose - Whether verbose logging is enabled
+ * @param pricing - Optional pricing service for monetary enrichment
  * @returns Analysis result with cost risk and reason
  */
 export async function analyzeDisk(
   resource: armResources.GenericResource,
   computeClient: ComputeManagementClient,
   verbose = false,
+  pricing?: PricingService,
 ): Promise<AnalysisResult> {
   verboseLogResourceStart(
     verbose,
@@ -64,13 +70,14 @@ export async function analyzeDisk(
       diskDetails.diskState?.toLowerCase() === "unattached" ||
       !diskDetails.managedBy
     ) {
-      const result = {
+      const result: AnalysisResult = {
         costRisk,
         reason: "Disk is unattached. ",
         suspectedUnused: true,
       };
-      verboseLogAnalysisResult(verbose, result);
-      return result;
+      const enriched = await enrichWithPricing(result, diskDetails, pricing);
+      verboseLogAnalysisResult(verbose, enriched);
+      return enriched;
     }
   } catch (error) {
     const logger = getLogger(["savemoney", "azure"]);
@@ -86,3 +93,38 @@ export async function analyzeDisk(
   verboseLogAnalysisResult(verbose, result);
   return result;
 }
+
+/**
+ * Best-effort: looks up the monthly price for the disk's `(sku, size,
+ * region)` triple and attaches it as `estimatedMonthlySavings`. Any
+ * failure (unsupported SKU, missing fields, resolver error) leaves the
+ * original result unchanged.
+ */
+async function enrichWithPricing(
+  result: AnalysisResult,
+  diskDetails: Disk,
+  pricing: PricingService | undefined,
+): Promise<AnalysisResult> {
+  if (!pricing) return result;
+
+  const sku = toSupportedSku(diskDetails.sku?.name);
+  const diskSizeGiB = diskDetails.diskSizeGB;
+  const armRegionName = diskDetails.location;
+  if (!sku || !diskSizeGiB || !armRegionName) return result;
+
+  const money: Money | undefined = await pricing.resolveDisk({
+    armRegionName,
+    diskSizeGiB,
+    sku,
+  });
+  return money ? { ...result, estimatedMonthlySavings: money } : result;
+}
+
+/**
+ * Narrows the SDK's `sku.name` string to the resolver-supported subset
+ * (excludes `UltraSSD_LRS` and any future tiers we don't price yet).
+ */
+function toSupportedSku(name: string | undefined): DiskSku | undefined {
+  const parsed = DiskSkuSchema.safeParse(name);
+  return parsed.success ? parsed.data : undefined;
+}

package/src/azure/resources/public-ip.ts

@@ -9,6 +9,7 @@ import * as armResources from "@azure/arm-resources";
 import { getLogger } from "@logtape/logtape";
 
 import type { AnalysisResult, Thresholds } from "../../types.js";
+import type { PricingService } from "../pricing/pricing-service.js";
 
 import { DEFAULT_THRESHOLDS } from "../../types.js";
 import {
@@ -26,6 +27,7 @@ import {
  * @param networkClient - Azure Network client for Public IP details
  * @param monitorClient - Azure Monitor client for metrics
  * @param timespanDays - Number of days to analyze metrics
+ * @param pricing - Optional pricing facade for estimated monthly cost
  * @returns Analysis result with cost risk and reason
  */
 export async function analyzePublicIp(
@@ -36,6 +38,7 @@ export async function analyzePublicIp(
   thresholds: Thresholds = DEFAULT_THRESHOLDS,
   verbose = false,
   cache?: MetricsCache,
+  pricing?: PricingService,
 ): Promise<AnalysisResult> {
   verboseLogResourceStart(
     verbose,
@@ -60,9 +63,15 @@ export async function analyzePublicIp(
   const resourceGroupName = resourceParts[4];
   const publicIpName = resourceParts[8];
 
+  // Capture details outside the try so the pricing enrichment below can
+  // reuse them without an extra API round-trip.
+  let publicIpDetails:
+    | Awaited<ReturnType<typeof networkClient.publicIPAddresses.get>>
+    | undefined;
+
   try {
     // Get detailed Public IP information
-    const publicIpDetails = await networkClient.publicIPAddresses.get(
+    publicIpDetails = await networkClient.publicIPAddresses.get(
       resourceGroupName,
       publicIpName,
     );
@@ -104,7 +113,57 @@ export async function analyzePublicIp(
   }
 
   const suspectedUnused = reason.length > 0;
-  const result = { costRisk, reason: reason.trim(), suspectedUnused };
+  const baseResult = { costRisk, reason: reason.trim(), suspectedUnused };
+  const result = await enrichWithPricing(
+    baseResult,
+    resource,
+    publicIpDetails,
+    pricing,
+  );
   verboseLogAnalysisResult(verbose, result);
   return result;
 }
+
+/**
+ * Best-effort enrichment of a Public IP analysis result with the
+ * estimated monthly cost recoverable by removing the resource.
+ */
+async function enrichWithPricing(
+  result: AnalysisResult,
+  resource: armResources.GenericResource,
+  publicIpDetails:
+    | Awaited<ReturnType<NetworkManagementClient["publicIPAddresses"]["get"]>>
+    | undefined,
+  pricing?: PricingService,
+): Promise<AnalysisResult> {
+  if (!pricing || !result.suspectedUnused || !publicIpDetails) {
+    return result;
+  }
+  try {
+    const skuName = publicIpDetails.sku?.name?.toLowerCase();
+    const allocation = publicIpDetails.publicIPAllocationMethod?.toLowerCase();
+    const armRegionName = publicIpDetails.location ?? resource.location;
+    if (
+      !armRegionName ||
+      (skuName !== "basic" && skuName !== "standard") ||
+      (allocation !== "static" && allocation !== "dynamic")
+    ) {
+      return result;
+    }
+    const estimatedMonthlySavings = await pricing.resolvePublicIp({
+      allocation,
+      armRegionName,
+      sku: skuName,
+    });
+    if (!estimatedMonthlySavings) {
+      return result;
+    }
+    return { ...result, estimatedMonthlySavings };
+  } catch (error) {
+    const logger = getLogger(["savemoney", "azure"]);
+    logger.warn(
+      `Failed to enrich Public IP with pricing: ${error instanceof Error ? error.message : error}`,
+    );
+    return result;
+  }
+}