@pagopa/dx-savemoney 0.1.5 → 0.2.0

package/src/azure/resources/__tests__/storage.test.ts

@@ -0,0 +1,185 @@
+/**
+ * Tests for analyzeStorageAccount() — verifies that custom thresholds
+ * actually change the analysis outcome.
+ *
+ * Key scenario:
+ *   - Metric: 30 avg transactions/day
+ *   - Default threshold: 10  → 30 >= 10 → NOT flagged
+ *   - Custom threshold:  50  → 30 <  50 → IS  flagged   ✓ proves the feature works
+ */
+
+import type { MonitorClient } from "@azure/arm-monitor";
+import type { GenericResource } from "@azure/arm-resources";
+
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { Thresholds } from "../../../types.js";
+
+import { DEFAULT_THRESHOLDS } from "../../../types.js";
+
+// Mock the utils module so we control getMetric without real Azure calls
+vi.mock("../../utils.js", () => ({
+  getMetric: vi.fn(),
+  verboseLog: vi.fn(),
+  verboseLogAnalysisResult: vi.fn(),
+  verboseLogResourceStart: vi.fn(),
+}));
+
+// Import after vi.mock so the module resolves the mock
+import { getMetric } from "../../utils.js";
+import { analyzeStorageAccount } from "../storage.js";
+
+// ── helpers ────────────────────────────────────────────────────────────────
+
+// Minimal stub: analyzeStorageAccount only needs monitorClient to be passed
+// through to getMetric, which is fully mocked. We provide only the shape that
+// TypeScript requires without unsafe type assertions.
+const FAKE_CLIENT = {
+  metrics: { list: vi.fn() },
+} as unknown as MonitorClient;
+
+const FAKE_RESOURCE: GenericResource = {
+  id: "/subscriptions/sub1/resourceGroups/rg1/providers/Microsoft.Storage/storageAccounts/st1",
+  name: "st1",
+  type: "Microsoft.Storage/storageAccounts",
+};
+
+const mockGetMetric = vi.mocked(getMetric);
+
+// ── tests ──────────────────────────────────────────────────────────────────
+
+describe("analyzeStorageAccount — threshold sensitivity", () => {
+  beforeEach(() => {
+    mockGetMetric.mockReset();
+  });
+
+  describe("with DEFAULT threshold (transactionsPerDay = 10)", () => {
+    it("does NOT flag a resource with 30 transactions/day (30 ≥ 10)", async () => {
+      mockGetMetric.mockResolvedValue(30);
+
+      const result = await analyzeStorageAccount(
+        FAKE_RESOURCE,
+        FAKE_CLIENT,
+        30,
+        DEFAULT_THRESHOLDS,
+      );
+
+      expect(result.suspectedUnused).toBe(false);
+    });
+
+    it("flags a resource with 5 transactions/day (5 < 10)", async () => {
+      mockGetMetric.mockResolvedValue(5);
+
+      const result = await analyzeStorageAccount(
+        FAKE_RESOURCE,
+        FAKE_CLIENT,
+        30,
+        DEFAULT_THRESHOLDS,
+      );
+
+      expect(result.suspectedUnused).toBe(true);
+    });
+
+    it("does not flag when metric is exactly at the threshold (10)", async () => {
+      mockGetMetric.mockResolvedValue(10);
+
+      const result = await analyzeStorageAccount(
+        FAKE_RESOURCE,
+        FAKE_CLIENT,
+        30,
+        DEFAULT_THRESHOLDS,
+      );
+
+      // 10 < 10 is false → not flagged
+      expect(result.suspectedUnused).toBe(false);
+    });
+  });
+
+  describe("with CUSTOM threshold (transactionsPerDay = 50)", () => {
+    const customThresholds: Thresholds = {
+      ...DEFAULT_THRESHOLDS,
+      storage: { transactionsPerDay: 50 },
+    };
+
+    it("DOES flag a resource with 30 transactions/day (30 < 50) — proves override works", async () => {
+      mockGetMetric.mockResolvedValue(30);
+
+      const result = await analyzeStorageAccount(
+        FAKE_RESOURCE,
+        FAKE_CLIENT,
+        30,
+        customThresholds,
+      );
+
+      expect(result.suspectedUnused).toBe(true);
+    });
+
+    it("does NOT flag a resource with 60 transactions/day (60 ≥ 50)", async () => {
+      mockGetMetric.mockResolvedValue(60);
+
+      const result = await analyzeStorageAccount(
+        FAKE_RESOURCE,
+        FAKE_CLIENT,
+        30,
+        customThresholds,
+      );
+
+      expect(result.suspectedUnused).toBe(false);
+    });
+
+    it("flags at threshold boundary (49 < 50)", async () => {
+      mockGetMetric.mockResolvedValue(49);
+
+      const result = await analyzeStorageAccount(
+        FAKE_RESOURCE,
+        FAKE_CLIENT,
+        30,
+        customThresholds,
+      );
+
+      expect(result.suspectedUnused).toBe(true);
+    });
+  });
+
+  describe("edge cases", () => {
+    it("returns suspectedUnused: false when metric is null (data unavailable)", async () => {
+      mockGetMetric.mockResolvedValue(null);
+
+      const result = await analyzeStorageAccount(
+        FAKE_RESOURCE,
+        FAKE_CLIENT,
+        30,
+        DEFAULT_THRESHOLDS,
+      );
+
+      expect(result.suspectedUnused).toBe(false);
+    });
+
+    it("returns suspectedUnused: false when resource id is missing", async () => {
+      const resourceWithoutId = { ...FAKE_RESOURCE, id: undefined };
+
+      const result = await analyzeStorageAccount(
+        resourceWithoutId,
+        FAKE_CLIENT,
+        30,
+        DEFAULT_THRESHOLDS,
+      );
+
+      expect(result.suspectedUnused).toBe(false);
+      expect(mockGetMetric).not.toHaveBeenCalled();
+    });
+
+    it("applies default thresholds when the parameter is omitted", async () => {
+      // 5 < DEFAULT 10 → flagged even without explicit thresholds argument
+      mockGetMetric.mockResolvedValue(5);
+
+      const result = await analyzeStorageAccount(
+        FAKE_RESOURCE,
+        FAKE_CLIENT,
+        30,
+      );
+
+      expect(result.suspectedUnused).toBe(true);
+    });
+  });
+});

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

@@ -8,8 +8,9 @@ import type { MonitorClient } from "@azure/arm-monitor";
 import * as armResources from "@azure/arm-resources";
 import { getLogger } from "@logtape/logtape";
 
-import type { AnalysisResult } from "../../types.js";
+import type { AnalysisResult, Thresholds } from "../../types.js";
 
+import { DEFAULT_THRESHOLDS } from "../../types.js";
 import {
   getMetric,
   verboseLog,
@@ -31,6 +32,7 @@ export async function analyzeAppServicePlan(
   webSiteClient: WebSiteManagementClient,
   monitorClient: MonitorClient,
   timespanDays: number,
+  thresholds: Thresholds = DEFAULT_THRESHOLDS,
   verbose = false,
 ): Promise<AnalysisResult> {
   verboseLogResourceStart(
@@ -87,19 +89,25 @@ export async function analyzeAppServicePlan(
       timespanDays,
     );
 
-    if (cpuPercentage !== null && cpuPercentage < 5) {
+    if (
+      cpuPercentage !== null &&
+      cpuPercentage < thresholds.appService.cpuPercent
+    ) {
       reason += `Very low CPU usage (${cpuPercentage.toFixed(2)}%). `;
     }
 
-    if (memoryPercentage !== null && memoryPercentage < 10) {
+    if (
+      memoryPercentage !== null &&
+      memoryPercentage < thresholds.appService.memoryPercent
+    ) {
       reason += `Very low memory usage (${memoryPercentage.toFixed(2)}%). `;
     }
 
     // Check if it's an oversized plan (Premium tier with low usage)
     if (
       planDetails.sku?.tier?.includes("Premium") &&
-      cpuPercentage &&
-      cpuPercentage < 10
+      cpuPercentage !== null &&
+      cpuPercentage < thresholds.appService.premiumCpuPercent
     ) {
       reason += "Premium tier with low resource utilization. ";
     }

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

@@ -8,8 +8,9 @@ import type { MonitorClient } from "@azure/arm-monitor";
 import * as armResources from "@azure/arm-resources";
 import { getLogger } from "@logtape/logtape";
 
-import type { AnalysisResult } from "../../types.js";
+import type { AnalysisResult, Thresholds } from "../../types.js";
 
+import { DEFAULT_THRESHOLDS } from "../../types.js";
 import {
   getMetric,
   verboseLog,
@@ -32,6 +33,7 @@ export async function analyzeContainerApp(
   containerAppsClient: ContainerAppsAPIClient,
   monitorClient: MonitorClient,
   timespanDays: number,
+  thresholds: Thresholds = DEFAULT_THRESHOLDS,
   verbose = false,
 ): Promise<AnalysisResult> {
   verboseLogResourceStart(
@@ -79,6 +81,7 @@ export async function analyzeContainerApp(
       resource,
       monitorClient,
       timespanDays,
+      thresholds,
       reason,
       verbose,
     );
@@ -86,6 +89,7 @@ export async function analyzeContainerApp(
       resource,
       monitorClient,
       timespanDays,
+      thresholds,
       reason,
       verbose,
     );
@@ -110,6 +114,7 @@ async function checkNetworkMetrics(
   resource: armResources.GenericResource,
   monitorClient: MonitorClient,
   timespanDays: number,
+  thresholds: Thresholds,
   reason: string,
   verbose: boolean,
 ): Promise<string> {
@@ -149,7 +154,7 @@ async function checkNetworkMetrics(
   if (
     networkIn !== null &&
     networkOut !== null &&
-    networkIn + networkOut < 34000
+    networkIn + networkOut < thresholds.containerApp.networkBytes
   ) {
     newReason += `Very low network traffic (${((networkIn + networkOut) / 1048576).toFixed(2)} MB/day avg). `;
   }
@@ -164,6 +169,7 @@ async function checkResourceMetrics(
   resource: armResources.GenericResource,
   monitorClient: MonitorClient,
   timespanDays: number,
+  thresholds: Thresholds,
   reason: string,
   verbose: boolean,
 ): Promise<string> {
@@ -200,11 +206,14 @@ async function checkResourceMetrics(
     `Memory Usage: ${memoryUsage !== null ? `${(memoryUsage / 1048576).toFixed(2)} MB` : "N/A"}`,
   );
 
-  if (cpuUsage !== null && cpuUsage < 1000000) {
+  if (cpuUsage !== null && cpuUsage < thresholds.containerApp.cpuNanoCores) {
     newReason += `Very low CPU usage (${(cpuUsage / 1000000000).toFixed(4)} cores). `;
   }
 
-  if (memoryUsage !== null && memoryUsage < 10485760) {
+  if (
+    memoryUsage !== null &&
+    memoryUsage < thresholds.containerApp.memoryBytes
+  ) {
     newReason += `Very low memory usage (${(memoryUsage / 1048576).toFixed(2)} MB). `;
   }
 

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

@@ -8,8 +8,9 @@ import type { NetworkManagementClient } from "@azure/arm-network";
 import * as armResources from "@azure/arm-resources";
 import { getLogger } from "@logtape/logtape";
 
-import type { AnalysisResult } from "../../types.js";
+import type { AnalysisResult, Thresholds } from "../../types.js";
 
+import { DEFAULT_THRESHOLDS } from "../../types.js";
 import {
   getMetric,
   verboseLog,
@@ -31,6 +32,7 @@ export async function analyzePublicIp(
   networkClient: NetworkManagementClient,
   monitorClient: MonitorClient,
   timespanDays: number,
+  thresholds: Thresholds = DEFAULT_THRESHOLDS,
   verbose = false,
 ): Promise<AnalysisResult> {
   verboseLogResourceStart(
@@ -87,8 +89,7 @@ export async function analyzePublicIp(
       timespanDays,
     );
 
-    if (bytesInDDoS !== null && bytesInDDoS < 340000) {
-      // Less than ~340KB average per day
+    if (bytesInDDoS !== null && bytesInDDoS < thresholds.publicIp.bytesInDDoS) {
       reason += `Very low network traffic (${(bytesInDDoS / 1024 / 1024).toFixed(2)} MB/day avg). `;
     }
   } catch (error) {

package/src/azure/resources/static-web-app.ts

@@ -7,8 +7,9 @@ import type { MonitorClient } from "@azure/arm-monitor";
 import * as armResources from "@azure/arm-resources";
 import { getLogger } from "@logtape/logtape";
 
-import type { AnalysisResult } from "../../types.js";
+import type { AnalysisResult, Thresholds } from "../../types.js";
 
+import { DEFAULT_THRESHOLDS } from "../../types.js";
 import {
   getMetric,
   verboseLog,
@@ -29,6 +30,7 @@ export async function analyzeStaticSite(
   resource: armResources.GenericResource,
   monitorClient: MonitorClient,
   timespanDays: number,
+  thresholds: Thresholds = DEFAULT_THRESHOLDS,
   verbose = false,
 ): Promise<AnalysisResult> {
   verboseLogResourceStart(
@@ -84,13 +86,11 @@ export async function analyzeStaticSite(
     if (siteHits === null && bytesSent === null) {
       reason += `No traffic data available in ${timespanDays} days. `;
     } else {
-      if (siteHits !== null && siteHits < 100) {
-        // Less than 100 requests total in the timespan (< ~3.3 requests/day)
+      if (siteHits !== null && siteHits < thresholds.staticSite.siteHits) {
         reason += `Very low site traffic (${siteHits.toFixed(0)} requests in ${timespanDays} days). `;
       }
 
-      if (bytesSent !== null && bytesSent < 1048576) {
-        // Less than 1MB total in the timespan (< ~34KB/day)
+      if (bytesSent !== null && bytesSent < thresholds.staticSite.bytesSent) {
         reason += `Very low data transfer (${(bytesSent / 1024 / 1024).toFixed(2)} MB in ${timespanDays} days). `;
       }
     }

package/src/azure/resources/storage.ts

@@ -6,8 +6,9 @@ import type { MonitorClient } from "@azure/arm-monitor";
 
 import * as armResources from "@azure/arm-resources";
 
-import type { AnalysisResult } from "../../types.js";
+import type { AnalysisResult, Thresholds } from "../../types.js";
 
+import { DEFAULT_THRESHOLDS } from "../../types.js";
 import {
   getMetric,
   verboseLog,
@@ -27,6 +28,7 @@ export async function analyzeStorageAccount(
   resource: armResources.GenericResource,
   monitorClient: MonitorClient,
   timespanDays: number,
+  thresholds: Thresholds = DEFAULT_THRESHOLDS,
   verbose = false,
 ): Promise<AnalysisResult> {
   verboseLogResourceStart(
@@ -51,8 +53,10 @@ export async function analyzeStorageAccount(
     "Average",
     timespanDays,
   );
-  if (transactions !== null && transactions < 10) {
-    // Less than 10 transactions per day on average
+  if (
+    transactions !== null &&
+    transactions < thresholds.storage.transactionsPerDay
+  ) {
     const result = {
       costRisk,
       reason: `Very low transaction count (${transactions.toFixed(2)} avg/day). `,

package/src/azure/resources/vm.ts

@@ -8,8 +8,9 @@ import type { MonitorClient } from "@azure/arm-monitor";
 import * as armResources from "@azure/arm-resources";
 import { getLogger } from "@logtape/logtape";
 
-import type { AnalysisResult } from "../../types.js";
+import type { AnalysisResult, Thresholds } from "../../types.js";
 
+import { DEFAULT_THRESHOLDS } from "../../types.js";
 import {
   getMetric,
   verboseLog,
@@ -32,6 +33,7 @@ export async function analyzeVM(
   monitorClient: MonitorClient,
   computeClient: ComputeManagementClient,
   timespanDays: number,
+  thresholds: Thresholds = DEFAULT_THRESHOLDS,
   verbose = false,
 ): Promise<AnalysisResult> {
   verboseLogResourceStart(
@@ -114,12 +116,10 @@ export async function analyzeVM(
     timespanDays,
   );
 
-  if (cpuUsage !== null && cpuUsage < 1) {
-    // Less than 1% average CPU
+  if (cpuUsage !== null && cpuUsage < thresholds.vm.cpuPercent) {
     reason += `Low CPU usage (avg ${cpuUsage.toFixed(2)}%). `;
   }
-  if (networkIn !== null && networkIn < 1024 * 1024 * 3) {
-    // Less than 3MB average per day
+  if (networkIn !== null && networkIn < thresholds.vm.networkInBytesPerDay) {
     reason += `Low network traffic (${(networkIn / 1024 / 1024).toFixed(2)} MB/day avg). `;
   }
 

package/src/azure/types.ts

@@ -4,14 +4,27 @@
 
 import type * as armResources from "@azure/arm-resources";
 
-import type { AnalysisResult, BaseConfig, CostRisk } from "../types.js";
+import type {
+  AnalysisResult,
+  BaseConfig,
+  CostRisk,
+  Thresholds,
+} from "../types.js";
 
 /**
  * Azure configuration extending base config
  */
 export type AzureConfig = BaseConfig & {
+  /**
+   * Only analyze resources that match ALL the given tag key-value pairs.
+   * If omitted, all resources are analyzed.
+   */
+  filterTags?: Map<string, string>;
   subscriptionIds: string[];
-  tenantId: string;
+  /**
+   * Analysis thresholds. Defaults from DEFAULT_THRESHOLDS are used when not provided.
+   */
+  thresholds?: Thresholds;
   verbose?: boolean;
 };
 

package/src/azure/utils.ts

@@ -3,6 +3,7 @@
  */
 
 import type { MonitorClient } from "@azure/arm-monitor";
+import type * as armResources from "@azure/arm-resources";
 
 import { getLogger } from "@logtape/logtape";
 
@@ -158,6 +159,26 @@ export async function getMetric(
   }
 }
 
+/**
+ * Returns true if the resource matches ALL specified tag key-value pairs.
+ * If filterTags is empty or undefined, always returns true (no filtering).
+ *
+ * @param resource - The Azure resource to check
+ * @param filterTags - Map of required tag key→value pairs
+ */
+export function matchesTags(
+  resource: armResources.GenericResource,
+  filterTags: Map<string, string> | undefined,
+): boolean {
+  if (!filterTags || filterTags.size === 0) {
+    return true;
+  }
+  const resourceTags = resource.tags ?? {};
+  return [...filterTags.entries()].every(
+    ([key, value]) => resourceTags[key] === value,
+  );
+}
+
 /**
  * Logs a verbose message, optionally with an object.
  *

package/src/index.ts

@@ -15,85 +15,35 @@
 
 // Export common types
 export type { AzureConfig } from "./azure/types.js";
-export * from "./types.js";
 
 // Export Azure module
 import * as azureModule from "./azure/index.js";
 export const azure = azureModule;
 
-import { getLogger } from "@logtape/logtape";
-// Utility imports for loadConfig and prompt functions
-import * as fs from "fs";
-import * as readline from "readline";
+export * from "./types.js";
 
 import type { AzureConfig } from "./azure/types.js";
 
-/**
- * Loads configuration from file, environment variables, or interactive prompts.
- *
- * @param configPath - Optional path to JSON configuration file
- * @returns Configuration object with subscription IDs and settings
- */
-export async function loadConfig(configPath?: string): Promise<AzureConfig> {
-  const logger = getLogger(["savemoney", "config"]);
-
-  if (configPath && fs.existsSync(configPath)) {
-    try {
-      const configContent = fs.readFileSync(configPath, "utf-8");
-      const config = JSON.parse(configContent);
-
-      // Validate required fields
-      if (!config.tenantId || !config.subscriptionIds) {
-        throw new Error(
-          "Config file must contain 'tenantId' and 'subscriptionIds'",
-        );
-      }
-
-      return {
-        ...config,
-        preferredLocation: config.preferredLocation || "italynorth",
-        timespanDays: config.timespanDays || 30,
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to load config file: ${error instanceof Error ? error.message : error}`,
-      );
-    }
-  }
-
-  logger.info(
-    "Configuration file not found. Checking environment variables...",
-  );
-
-  const tenantId =
-    process.env.ARM_TENANT_ID || (await prompt("Enter Tenant ID: "));
-  const subscriptionIds = process.env.ARM_SUBSCRIPTION_ID
-    ? process.env.ARM_SUBSCRIPTION_ID.split(",")
-    : (await prompt("Enter Subscription IDs (comma-separated): ")).split(",");
-
-  return {
-    preferredLocation: "italynorth",
-    subscriptionIds,
-    tenantId,
-    timespanDays: 30,
-  };
-}
+import { loadAzureConfig } from "./azure/config.js";
 
 /**
- * Prompts user for input via stdin.
+ * Loads configuration from a YAML file, environment variables, or interactive prompts.
+ *
+ * The YAML file should have an `azure` top-level key:
+ * ```yaml
+ * azure:
+ *   subscriptionIds:
+ *     - xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+ *   preferredLocation: italynorth
+ *   timespanDays: 30
+ *   thresholds:
+ *     vm:
+ *       cpuPercent: 5
+ * ```
  *
- * @param question - The question to display to the user
- * @returns User's input as a string
+ * @param configPath - Optional path to a YAML configuration file
+ * @returns Configuration object with subscription IDs, settings and thresholds
  */
-export async function prompt(question: string): Promise<string> {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-  return new Promise((resolve) =>
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer);
-    }),
-  );
+export async function loadConfig(configPath?: string): Promise<AzureConfig> {
+  return loadAzureConfig(configPath);
 }