@pagopa/dx-savemoney 0.3.2 → 0.4.0

package/src/azure/resources/vm.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 {
@@ -27,6 +28,8 @@ import {
  * @param computeClient - Azure Compute client for VM details
  * @param timespanDays - Number of days to analyze metrics
  * @param verbose - Whether verbose logging is enabled
+ * @param cache - Run-scoped metrics cache
+ * @param pricing - Optional pricing facade for estimated monthly cost
  * @returns Analysis result with cost risk and reason
  */
 export async function analyzeVM(
@@ -37,6 +40,7 @@ export async function analyzeVM(
   thresholds: Thresholds = DEFAULT_THRESHOLDS,
   verbose = false,
   cache?: MetricsCache,
+  pricing?: PricingService,
 ): Promise<AnalysisResult> {
   verboseLogResourceStart(
     verbose,
@@ -76,21 +80,35 @@ export async function analyzeVM(
     );
 
     if (vmStatus?.code === "PowerState/deallocated") {
-      const result = {
-        costRisk,
-        reason: "VM is deallocated. ",
-        suspectedUnused: true,
-      };
+      const result = await enrichWithPricing(
+        {
+          costRisk,
+          reason: "VM is deallocated. ",
+          suspectedUnused: true,
+        },
+        resource,
+        computeClient,
+        resourceGroupName,
+        vmName,
+        pricing,
+      );
       verboseLogAnalysisResult(verbose, result);
       return result;
     }
 
     if (vmStatus?.code === "PowerState/stopped") {
-      const result = {
-        costRisk,
-        reason: "VM is stopped. ",
-        suspectedUnused: true,
-      };
+      const result = await enrichWithPricing(
+        {
+          costRisk,
+          reason: "VM is stopped. ",
+          suspectedUnused: true,
+        },
+        resource,
+        computeClient,
+        resourceGroupName,
+        vmName,
+        pricing,
+      );
       verboseLogAnalysisResult(verbose, result);
       return result;
     }
@@ -127,7 +145,67 @@ export async function analyzeVM(
     reason += `Low network traffic (${(networkIn / 1024 / 1024).toFixed(2)} MB/day avg). `;
   }
 
-  const result = { costRisk, reason, suspectedUnused: reason.length > 0 };
+  const result = await enrichWithPricing(
+    { costRisk, reason, suspectedUnused: reason.length > 0 },
+    resource,
+    computeClient,
+    resourceGroupName,
+    vmName,
+    pricing,
+  );
   verboseLogAnalysisResult(verbose, result);
   return result;
 }
+
+/**
+ * Best-effort enrichment of a VM analysis result with the estimated
+ * monthly cost recoverable by removing/right-sizing the resource.
+ *
+ * No-op when:
+ *  - the result is not flagged as suspected unused
+ *  - no pricing facade was provided
+ *  - the VM SKU or region cannot be determined
+ *  - the Retail Prices lookup returns no matching meter
+ *
+ * Any error along the way is logged at warn level and swallowed so the
+ * main analysis never fails because of a pricing problem.
+ */
+async function enrichWithPricing(
+  result: AnalysisResult,
+  resource: armResources.GenericResource,
+  computeClient: ComputeManagementClient,
+  resourceGroupName: string,
+  vmName: string,
+  pricing?: PricingService,
+): Promise<AnalysisResult> {
+  if (!pricing || !result.suspectedUnused) {
+    return result;
+  }
+  try {
+    const details = await computeClient.virtualMachines.get(
+      resourceGroupName,
+      vmName,
+    );
+    const armSkuName = details.hardwareProfile?.vmSize;
+    const armRegionName = details.location ?? resource.location;
+    if (!armSkuName || !armRegionName) {
+      return result;
+    }
+    const os = details.storageProfile?.osDisk?.osType?.toLowerCase();
+    const estimatedMonthlySavings = await pricing.resolveVm({
+      armRegionName,
+      armSkuName,
+      os: os === "windows" ? "windows" : "linux",
+    });
+    if (!estimatedMonthlySavings) {
+      return result;
+    }
+    return { ...result, estimatedMonthlySavings };
+  } catch (error) {
+    const logger = getLogger(["savemoney", "azure"]);
+    logger.warn(
+      `Failed to enrich VM ${vmName} with pricing: ${error instanceof Error ? error.message : error}`,
+    );
+    return result;
+  }
+}

package/src/azure/types.ts

@@ -27,6 +27,12 @@ export type AzureConfig = BaseConfig & {
    * If omitted, all resources are analyzed.
    */
   filterTags?: Map<string, string>;
+  /**
+   * Runtime-only pricing enrichment switch. This is intentionally not exposed
+   * in YAML config: the Retail Prices lookup uses internal defaults unless the
+   * CLI disables it for offline/debug runs.
+   */
+  pricing?: PricingConfig;
   /**
    * Which finding sources to include in the run.
    * - `"custom"`  → enables the per-resource analyzer plugins
@@ -83,3 +89,11 @@ export type AzureResourceReport = {
  * filter for Azure runs and would silently produce an empty report.
  */
 export type AzureSource = "advisor" | "custom";
+
+export type PricingConfig = {
+  /**
+   * Runtime switch used by the CLI `--no-pricing` flag. Pricing otherwise
+   * stays enabled with internal defaults for currency and cache settings.
+   */
+  enabled?: boolean;
+};

package/src/finding.ts

@@ -32,9 +32,9 @@ export type Finding = {
    */
   code: string;
   /**
-   * Estimated monthly cost that could be recovered by acting on this
-   * finding. Populated by Advisor and (in later phases) by the Retail
-   * Prices integration. Absent when the analyzer cannot estimate it.
+   * Estimated monthly saving for this specific finding. Populated by Advisor
+   * recommendations; custom Retail Prices estimates stay at resource level
+   * because they represent cost at risk, not a per-finding saving.
    */
   estimatedMonthlySavings?: Money;
   /**
@@ -128,6 +128,13 @@ export function findingsFromAnalysisResult(args: {
   if (sentences.length === 0) {
     return [];
   }
+  // We intentionally do NOT propagate any monetary estimate down to the
+  // individual findings: a per-resource cost (e.g. €29.94/mo for a VM)
+  // attached to a sentence like "No tags found" would falsely suggest
+  // "add the missing tags to save €29.94". The resource-level cost is
+  // carried instead by `AnalysisResult.estimatedMonthlySavings` and
+  // surfaced by the report layer as a per-resource header — see
+  // `azure/report.ts`.
   return sentences.map((sentence) => ({
     category: "cost" as const,
     code: code ?? "custom.unknown",

package/src/index.ts

@@ -21,14 +21,13 @@ export {
 } from "./azure/analyzers/index.js";
 
 // Export common types
-export type { AzureConfig, AzureSource } from "./azure/types.js";
+export type { AzureConfig, AzureSource, PricingConfig } from "./azure/types.js";
+export { type MetricsCache, type MonitorClientLike } from "./azure/utils.js";
 
 // Export Azure module
 import * as azureModule from "./azure/index.js";
 export const azure = azureModule;
 
-export { type MetricsCache, type MonitorClientLike } from "./azure/utils.js";
-
 // Phase 0: unified Finding model and analyzer plugin layer
 export {
   type Finding,
@@ -38,6 +37,7 @@ export {
   type Money,
   type ResourceReport,
 } from "./finding.js";
+
 export * from "./types.js";
 
 import type { AzureConfig } from "./azure/types.js";

package/src/types.ts

@@ -2,10 +2,19 @@
  * Common types shared across all cloud providers
  */
 
+import type { Money } from "./finding.js";
+
 import { ThresholdsSchema } from "./schema.js";
 
 export type AnalysisResult = {
   costRisk: CostRisk;
+  /**
+   * Estimated monthly resource cost at risk. Custom pricing-enriched
+   * analyzers populate it when a Retail Prices lookup succeeds; the report
+   * renders it once per resource instead of treating it as a per-finding
+   * saving.
+   */
+  estimatedMonthlySavings?: Money;
   reason: string;
   suspectedUnused: boolean;
 };
@@ -41,6 +50,9 @@ export function mergeResults(
 ): AnalysisResult {
   return {
     costRisk: specificResult.costRisk,
+    estimatedMonthlySavings:
+      specificResult.estimatedMonthlySavings ??
+      baseResult.estimatedMonthlySavings,
     reason: baseResult.reason + specificResult.reason,
     suspectedUnused:
       baseResult.suspectedUnused || specificResult.suspectedUnused,