cdk-cost-analyzer 0.1.11 → 0.1.13

package/.cdk-cost-analyzer-cache/metadata.json

@@ -2,35 +2,35 @@
   "entries": {
     "AmazonS3:US East (N. Virginia):storageClass:General Purpose|volumeType:Standard": {
       "price": 0.023,
-      "timestamp": 1769022317313
+      "timestamp": 1769681855367
     },
     "AmazonDynamoDB:US East (N. Virginia):group:DDB-ReadUnits|groupDescription:OnDemand ReadRequestUnits": {
       "price": 0.023,
-      "timestamp": 1769022317321
+      "timestamp": 1769681855373
     },
     "AmazonDynamoDB:US East (N. Virginia):group:DDB-WriteUnits|groupDescription:OnDemand WriteRequestUnits": {
       "price": 0.023,
-      "timestamp": 1769022317321
+      "timestamp": 1769681855374
     },
     "AmazonEC2:US East (N. Virginia):capacitystatus:Used|instanceType:t3.micro|operatingSystem:Linux|preInstalledSw:NA|tenancy:Shared": {
       "price": 0.023,
-      "timestamp": 1769022317333
+      "timestamp": 1769681855389
     },
     "AWSLambda:US East (N. Virginia):group:AWS-Lambda-Requests": {
       "price": 0.023,
-      "timestamp": 1769022317342
+      "timestamp": 1769681855394
     },
     "AWSLambda:US East (N. Virginia):group:AWS-Lambda-Duration": {
       "price": 0.023,
-      "timestamp": 1769022317343
+      "timestamp": 1769681855394
     },
     "AmazonS3:EU (Frankfurt):storageClass:General Purpose|volumeType:Standard": {
       "price": 0.023,
-      "timestamp": 1769022329590
+      "timestamp": 1769681867552
     },
     "AmazonS3:invalid-region-123:storageClass:General Purpose|volumeType:Standard": {
       "price": 0.023,
-      "timestamp": 1769022329639
+      "timestamp": 1769681867598
     }
   }
 }

package/dist/pricing/calculators/ECSCalculator.d.ts

@@ -5,4 +5,5 @@ export declare class ECSCalculator implements ResourceCostCalculator {
     calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
     private calculateFargateCost;
     private calculateEC2Cost;
+    private getRegionPrefix;
 }

package/dist/pricing/calculators/ECSCalculator.js

@@ -29,20 +29,31 @@ class ECSCalculator {
             // Default assumptions for Fargate task
             const assumedVCpu = 0.25; // 0.25 vCPU
             const assumedMemoryGB = 0.5; // 0.5 GB
+            const regionPrefix = this.getRegionPrefix(region);
+            if (!regionPrefix) {
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: [
+                        `Region prefix not found for ${region}`,
+                        'Unable to query Fargate pricing',
+                    ],
+                };
+            }
             const vCpuCostPerHour = await pricingClient.getPrice({
                 serviceCode: 'AmazonECS',
                 region: (0, RegionMapper_1.normalizeRegion)(region),
                 filters: [
                     { field: 'productFamily', value: 'Compute' },
-                    { field: 'usagetype', value: `${region}-Fargate-vCPU-Hours:perCPU` },
+                    { field: 'usagetype', value: `${regionPrefix}-Fargate-vCPU-Hours:perCPU` },
                 ],
             });
             const memoryCostPerHour = await pricingClient.getPrice({
                 serviceCode: 'AmazonECS',
                 region: (0, RegionMapper_1.normalizeRegion)(region),
                 filters: [
-                    { field: 'productFamily', value: 'Compute' },
-                    { field: 'usagetype', value: `${region}-Fargate-GB-Hours:perGB` },
+                    { field: 'usagetype', value: `${regionPrefix}-Fargate-GB-Hours` },
                 ],
             });
             if (vCpuCostPerHour === null || memoryCostPerHour === null) {
@@ -93,6 +104,54 @@ class ECSCalculator {
             ],
         };
     }
+    getRegionPrefix(region) {
+        // AWS uses region prefixes in usage types for ECS Fargate
+        // Format: {PREFIX}-Fargate-vCPU-Hours:perCPU or {PREFIX}-Fargate-GB-Hours
+        const prefixMap = {
+            // US Regions
+            'us-east-1': 'USE1',
+            'us-east-2': 'USE2',
+            'us-west-1': 'USW1',
+            'us-west-2': 'USW2',
+            // EU Regions
+            'eu-west-1': 'EUW1',
+            'eu-west-2': 'EUW2',
+            'eu-west-3': 'EUW3',
+            'eu-central-1': 'EUC1',
+            'eu-central-2': 'EUC2',
+            'eu-north-1': 'EUN1',
+            'eu-south-1': 'EUS1',
+            'eu-south-2': 'EUS2',
+            // Asia Pacific Regions
+            'ap-south-1': 'APS1',
+            'ap-south-2': 'APS2',
+            'ap-southeast-1': 'APS3',
+            'ap-southeast-2': 'APS4',
+            'ap-southeast-3': 'APS5',
+            'ap-southeast-4': 'APS6',
+            'ap-northeast-1': 'APN1',
+            'ap-northeast-2': 'APN2',
+            'ap-northeast-3': 'APN3',
+            'ap-east-1': 'APE1',
+            // Canada Regions
+            'ca-central-1': 'CAN1',
+            'ca-west-1': 'CAW1',
+            // South America Regions
+            'sa-east-1': 'SAE1',
+            // Middle East Regions
+            'me-south-1': 'MES1',
+            'me-central-1': 'MEC1',
+            // Africa Regions
+            'af-south-1': 'AFS1',
+            // Israel Regions
+            'il-central-1': 'ILC1',
+            // Other Regions
+            'ap-southeast-5': 'APS7',
+            'us-gov-west-1': 'UGW1',
+            'us-gov-east-1': 'UGE1',
+        };
+        return prefixMap[region] || '';
+    }
 }
 exports.ECSCalculator = ECSCalculator;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ECSCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/ECSCalculator.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';\nimport { normalizeRegion } from '../RegionMapper';\n\nexport class ECSCalculator implements ResourceCostCalculator {\n  supports(resourceType: string): boolean {\n    return resourceType === 'AWS::ECS::Service';\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const desiredCount = (resource.properties.DesiredCount as number) || 1;\n    const launchType = (resource.properties.LaunchType as string) || 'FARGATE';\n\n    if (launchType === 'FARGATE') {\n      return this.calculateFargateCost(resource, desiredCount, region, pricingClient);\n    } else if (launchType === 'EC2') {\n      return this.calculateEC2Cost(desiredCount);\n    } else {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Unsupported launch type: ${launchType}`],\n      };\n    }\n  }\n\n  private async calculateFargateCost(\n    _resource: ResourceWithId,\n    desiredCount: number,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    try {\n      // Default assumptions for Fargate task\n      const assumedVCpu = 0.25; // 0.25 vCPU\n      const assumedMemoryGB = 0.5; // 0.5 GB\n\n      const vCpuCostPerHour = await pricingClient.getPrice({\n        serviceCode: 'AmazonECS',\n        region: normalizeRegion(region),\n        filters: [\n          { field: 'productFamily', value: 'Compute' },\n          { field: 'usagetype', value: `${region}-Fargate-vCPU-Hours:perCPU` },\n        ],\n      });\n\n      const memoryCostPerHour = await pricingClient.getPrice({\n        serviceCode: 'AmazonECS',\n        region: normalizeRegion(region),\n        filters: [\n          { field: 'productFamily', value: 'Compute' },\n          { field: 'usagetype', value: `${region}-Fargate-GB-Hours:perGB` },\n        ],\n      });\n\n      if (vCpuCostPerHour === null || memoryCostPerHour === null) {\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: ['Pricing data not available for ECS Fargate'],\n        };\n      }\n\n      const hoursPerMonth = 730;\n      const vCpuCost = assumedVCpu * vCpuCostPerHour * hoursPerMonth * desiredCount;\n      const memoryCost = assumedMemoryGB * memoryCostPerHour * hoursPerMonth * desiredCount;\n      const monthlyCost = vCpuCost + memoryCost;\n\n      return {\n        amount: monthlyCost,\n        currency: 'USD',\n        confidence: 'medium',\n        assumptions: [\n          `${desiredCount} task(s) running`,\n          `Assumes ${assumedVCpu} vCPU per task`,\n          `Assumes ${assumedMemoryGB} GB memory per task`,\n          `Assumes ${hoursPerMonth} hours per month (24/7 operation)`,\n          'Fargate launch type',\n          'Does not include data transfer or storage costs',\n        ],\n      };\n    } catch (error) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],\n      };\n    }\n  }\n\n  private calculateEC2Cost(desiredCount: number): MonthlyCost {\n    return {\n      amount: 0,\n      currency: 'USD',\n      confidence: 'low',\n      assumptions: [\n        `${desiredCount} task(s) running on EC2 launch type`,\n        'EC2 launch type costs depend on underlying EC2 instances',\n        'Refer to EC2 instance costs for actual pricing',\n        'Does not include ECS task-specific costs (minimal for EC2 launch type)',\n      ],\n    };\n  }\n\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ECSCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/ECSCalculator.ts"],"names":[],"mappings":";;;AAEA,kDAAkD;AAElD,MAAa,aAAa;IACxB,QAAQ,CAAC,YAAoB;QAC3B,OAAO,YAAY,KAAK,mBAAmB,CAAC;IAC9C,CAAC;IAED,KAAK,CAAC,aAAa,CACjB,QAAwB,EACxB,MAAc,EACd,aAA4B;QAE5B,MAAM,YAAY,GAAI,QAAQ,CAAC,UAAU,CAAC,YAAuB,IAAI,CAAC,CAAC;QACvE,MAAM,UAAU,GAAI,QAAQ,CAAC,UAAU,CAAC,UAAqB,IAAI,SAAS,CAAC;QAE3E,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC7B,OAAO,IAAI,CAAC,oBAAoB,CAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC;QAClF,CAAC;aAAM,IAAI,UAAU,KAAK,KAAK,EAAE,CAAC;YAChC,OAAO,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC;QAC7C,CAAC;aAAM,CAAC;YACN,OAAO;gBACL,MAAM,EAAE,CAAC;gBACT,QAAQ,EAAE,KAAK;gBACf,UAAU,EAAE,SAAS;gBACrB,WAAW,EAAE,CAAC,4BAA4B,UAAU,EAAE,CAAC;aACxD,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,oBAAoB,CAChC,SAAyB,EACzB,YAAoB,EACpB,MAAc,EACd,aAA4B;QAE5B,IAAI,CAAC;YACH,uCAAuC;YACvC,MAAM,WAAW,GAAG,IAAI,CAAC,CAAC,YAAY;YACtC,MAAM,eAAe,GAAG,GAAG,CAAC,CAAC,SAAS;YAEtC,MAAM,YAAY,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;YAClD,IAAI,CAAC,YAAY,EAAE,CAAC;gBAClB,OAAO;oBACL,MAAM,EAAE,CAAC;oBACT,QAAQ,EAAE,KAAK;oBACf,UAAU,EAAE,SAAS;oBACrB,WAAW,EAAE;wBACX,+BAA+B,MAAM,EAAE;wBACvC,iCAAiC;qBAClC;iBACF,CAAC;YACJ,CAAC;YAED,MAAM,eAAe,GAAG,MAAM,aAAa,CAAC,QAAQ,CAAC;gBACnD,WAAW,EAAE,WAAW;gBACxB,MAAM,EAAE,IAAA,8BAAe,EAAC,MAAM,CAAC;gBAC/B,OAAO,EAAE;oBACP,EAAE,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,SAAS,EAAE;oBAC5C,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,GAAG,YAAY,4BAA4B,EAAE;iBAC3E;aACF,CAAC,CAAC;YAEH,MAAM,iBAAiB,GAAG,MAAM,aAAa,CAAC,QAAQ,CAAC;gBACrD,WAAW,EAAE,WAAW;gBACxB,MAAM,EAAE,IAAA,8BAAe,EAAC,MAAM,CAAC;gBAC/B,OAAO,EAAE;oBACP,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,GAAG,YAAY,mBAAmB,EAAE;iBAClE;aACF,CAAC,CAAC;YAEH,IAAI,eAAe,KAAK,IAAI,IAAI,iBAAiB,KAAK,IAAI,EAAE,CAAC;gBAC3D,OAAO;oBACL,MAAM,EAAE,CAAC;oBACT,QAAQ,EAAE,KAAK;oBACf,UAAU,EAAE,SAAS;oBACrB,WAAW,EAAE,CAAC,4CAA4C,CAAC;iBAC5D,CAAC;YACJ,CAAC;YAED,MAAM,aAAa,GAAG,GAAG,CAAC;YAC1B,MAAM,QAAQ,GAAG,WAAW,GAAG,eAAe,GAAG,aAAa,GAAG,YAAY,CAAC;YAC9E,MAAM,UAAU,GAAG,eAAe,GAAG,iBAAiB,GAAG,aAAa,GAAG,YAAY,CAAC;YACtF,MAAM,WAAW,GAAG,QAAQ,GAAG,UAAU,CAAC;YAE1C,OAAO;gBACL,MAAM,EAAE,WAAW;gBACnB,QAAQ,EAAE,KAAK;gBACf,UAAU,EAAE,QAAQ;gBACpB,WAAW,EAAE;oBACX,GAAG,YAAY,kBAAkB;oBACjC,WAAW,WAAW,gBAAgB;oBACtC,WAAW,eAAe,qBAAqB;oBAC/C,WAAW,aAAa,mCAAmC;oBAC3D,qBAAqB;oBACrB,iDAAiD;iBAClD;aACF,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO;gBACL,MAAM,EAAE,CAAC;gBACT,QAAQ,EAAE,KAAK;gBACf,UAAU,EAAE,SAAS;gBACrB,WAAW,EAAE,CAAC,4BAA4B,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;aACpG,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,gBAAgB,CAAC,YAAoB;QAC3C,OAAO;YACL,MAAM,EAAE,CAAC;YACT,QAAQ,EAAE,KAAK;YACf,UAAU,EAAE,KAAK;YACjB,WAAW,EAAE;gBACX,GAAG,YAAY,qCAAqC;gBACpD,0DAA0D;gBAC1D,gDAAgD;gBAChD,wEAAwE;aACzE;SACF,CAAC;IACJ,CAAC;IAEO,eAAe,CAAC,MAAc;QACpC,0DAA0D;QAC1D,0EAA0E;QAC1E,MAAM,SAAS,GAA2B;YACxC,aAAa;YACb,WAAW,EAAE,MAAM;YACnB,WAAW,EAAE,MAAM;YACnB,WAAW,EAAE,MAAM;YACnB,WAAW,EAAE,MAAM;YACnB,aAAa;YACb,WAAW,EAAE,MAAM;YACnB,WAAW,EAAE,MAAM;YACnB,WAAW,EAAE,MAAM;YACnB,cAAc,EAAE,MAAM;YACtB,cAAc,EAAE,MAAM;YACtB,YAAY,EAAE,MAAM;YACpB,YAAY,EAAE,MAAM;YACpB,YAAY,EAAE,MAAM;YACpB,uBAAuB;YACvB,YAAY,EAAE,MAAM;YACpB,YAAY,EAAE,MAAM;YACpB,gBAAgB,EAAE,MAAM;YACxB,gBAAgB,EAAE,MAAM;YACxB,gBAAgB,EAAE,MAAM;YACxB,gBAAgB,EAAE,MAAM;YACxB,gBAAgB,EAAE,MAAM;YACxB,gBAAgB,EAAE,MAAM;YACxB,gBAAgB,EAAE,MAAM;YACxB,WAAW,EAAE,MAAM;YACnB,iBAAiB;YACjB,cAAc,EAAE,MAAM;YACtB,WAAW,EAAE,MAAM;YACnB,wBAAwB;YACxB,WAAW,EAAE,MAAM;YACnB,sBAAsB;YACtB,YAAY,EAAE,MAAM;YACpB,cAAc,EAAE,MAAM;YACtB,iBAAiB;YACjB,YAAY,EAAE,MAAM;YACpB,iBAAiB;YACjB,cAAc,EAAE,MAAM;YACtB,gBAAgB;YAChB,gBAAgB,EAAE,MAAM;YACxB,eAAe,EAAE,MAAM;YACvB,eAAe,EAAE,MAAM;SACxB,CAAC;QAEF,OAAO,SAAS,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IACjC,CAAC;CACF;AAxKD,sCAwKC","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';\nimport { normalizeRegion } from '../RegionMapper';\n\nexport class ECSCalculator implements ResourceCostCalculator {\n  supports(resourceType: string): boolean {\n    return resourceType === 'AWS::ECS::Service';\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const desiredCount = (resource.properties.DesiredCount as number) || 1;\n    const launchType = (resource.properties.LaunchType as string) || 'FARGATE';\n\n    if (launchType === 'FARGATE') {\n      return this.calculateFargateCost(resource, desiredCount, region, pricingClient);\n    } else if (launchType === 'EC2') {\n      return this.calculateEC2Cost(desiredCount);\n    } else {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Unsupported launch type: ${launchType}`],\n      };\n    }\n  }\n\n  private async calculateFargateCost(\n    _resource: ResourceWithId,\n    desiredCount: number,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    try {\n      // Default assumptions for Fargate task\n      const assumedVCpu = 0.25; // 0.25 vCPU\n      const assumedMemoryGB = 0.5; // 0.5 GB\n\n      const regionPrefix = this.getRegionPrefix(region);\n      if (!regionPrefix) {\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: [\n            `Region prefix not found for ${region}`,\n            'Unable to query Fargate pricing',\n          ],\n        };\n      }\n\n      const vCpuCostPerHour = await pricingClient.getPrice({\n        serviceCode: 'AmazonECS',\n        region: normalizeRegion(region),\n        filters: [\n          { field: 'productFamily', value: 'Compute' },\n          { field: 'usagetype', value: `${regionPrefix}-Fargate-vCPU-Hours:perCPU` },\n        ],\n      });\n\n      const memoryCostPerHour = await pricingClient.getPrice({\n        serviceCode: 'AmazonECS',\n        region: normalizeRegion(region),\n        filters: [\n          { field: 'usagetype', value: `${regionPrefix}-Fargate-GB-Hours` },\n        ],\n      });\n\n      if (vCpuCostPerHour === null || memoryCostPerHour === null) {\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: ['Pricing data not available for ECS Fargate'],\n        };\n      }\n\n      const hoursPerMonth = 730;\n      const vCpuCost = assumedVCpu * vCpuCostPerHour * hoursPerMonth * desiredCount;\n      const memoryCost = assumedMemoryGB * memoryCostPerHour * hoursPerMonth * desiredCount;\n      const monthlyCost = vCpuCost + memoryCost;\n\n      return {\n        amount: monthlyCost,\n        currency: 'USD',\n        confidence: 'medium',\n        assumptions: [\n          `${desiredCount} task(s) running`,\n          `Assumes ${assumedVCpu} vCPU per task`,\n          `Assumes ${assumedMemoryGB} GB memory per task`,\n          `Assumes ${hoursPerMonth} hours per month (24/7 operation)`,\n          'Fargate launch type',\n          'Does not include data transfer or storage costs',\n        ],\n      };\n    } catch (error) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],\n      };\n    }\n  }\n\n  private calculateEC2Cost(desiredCount: number): MonthlyCost {\n    return {\n      amount: 0,\n      currency: 'USD',\n      confidence: 'low',\n      assumptions: [\n        `${desiredCount} task(s) running on EC2 launch type`,\n        'EC2 launch type costs depend on underlying EC2 instances',\n        'Refer to EC2 instance costs for actual pricing',\n        'Does not include ECS task-specific costs (minimal for EC2 launch type)',\n      ],\n    };\n  }\n\n  private getRegionPrefix(region: string): string {\n    // AWS uses region prefixes in usage types for ECS Fargate\n    // Format: {PREFIX}-Fargate-vCPU-Hours:perCPU or {PREFIX}-Fargate-GB-Hours\n    const prefixMap: Record<string, string> = {\n      // US Regions\n      'us-east-1': 'USE1',\n      'us-east-2': 'USE2',\n      'us-west-1': 'USW1',\n      'us-west-2': 'USW2',\n      // EU Regions\n      'eu-west-1': 'EUW1',\n      'eu-west-2': 'EUW2',\n      'eu-west-3': 'EUW3',\n      'eu-central-1': 'EUC1',\n      'eu-central-2': 'EUC2',\n      'eu-north-1': 'EUN1',\n      'eu-south-1': 'EUS1',\n      'eu-south-2': 'EUS2',\n      // Asia Pacific Regions\n      'ap-south-1': 'APS1',\n      'ap-south-2': 'APS2',\n      'ap-southeast-1': 'APS3',\n      'ap-southeast-2': 'APS4',\n      'ap-southeast-3': 'APS5',\n      'ap-southeast-4': 'APS6',\n      'ap-northeast-1': 'APN1',\n      'ap-northeast-2': 'APN2',\n      'ap-northeast-3': 'APN3',\n      'ap-east-1': 'APE1',\n      // Canada Regions\n      'ca-central-1': 'CAN1',\n      'ca-west-1': 'CAW1',\n      // South America Regions\n      'sa-east-1': 'SAE1',\n      // Middle East Regions\n      'me-south-1': 'MES1',\n      'me-central-1': 'MEC1',\n      // Africa Regions\n      'af-south-1': 'AFS1',\n      // Israel Regions\n      'il-central-1': 'ILC1',\n      // Other Regions\n      'ap-southeast-5': 'APS7',\n      'us-gov-west-1': 'UGW1',\n      'us-gov-east-1': 'UGE1',\n    };\n\n    return prefixMap[region] || '';\n  }\n}\n"]}

package/dist/releasetag.txt

@@ -1 +1 @@
-v0.1.11
+v0.1.13

package/package.json

@@ -56,7 +56,7 @@
     "jest": "^30.2.0",
     "jest-junit": "^16",
     "lint-staged": "^15.0.0",
-    "projen": "^0.99.4",
+    "projen": "^0.99.8",
     "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
@@ -82,7 +82,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.11",
+  "version": "0.1.13",
   "bugs": {
     "url": "https://github.com/buildinginthecloud/cdk-cost-analyzer/issues"
   },
@@ -91,6 +91,12 @@
     "testTimeout": 30000,
     "forceExit": true,
     "detectOpenHandles": true,
+    "testEnvironmentOptions": {
+      "customExportConditions": [
+        "node",
+        "node-addons"
+      ]
+    },
     "testMatch": [
       "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
       "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)",

package/tools/discover-ecs-fargate-pricing.ts

@@ -0,0 +1,179 @@
+#!/usr/bin/env ts-node
+/**
+ * Discovery script for ECS Fargate pricing filters
+ * 
+ * This script helps identify the correct filters for querying
+ * AWS Pricing API for ECS Fargate vCPU and memory pricing.
+ * 
+ * Usage:
+ *   npx ts-node tools/discover-ecs-fargate-pricing.ts
+ */
+
+import { PricingClient as AWSPricingClient, GetProductsCommand } from '@aws-sdk/client-pricing';
+
+async function discoverECSFargatePricing(): Promise<void> {
+  const client = new AWSPricingClient({ 
+    region: 'us-east-1',
+    credentials: undefined, // Will use AWS_PROFILE from environment
+  });
+
+  console.log('='.repeat(80));
+  console.log('ECS Fargate Pricing Discovery');
+  console.log('='.repeat(80));
+  console.log();
+
+  // Test 1: Find all ECS products
+  console.log('Test 1: Searching for ECS products...');
+  try {
+    const command1 = new GetProductsCommand({
+      ServiceCode: 'AmazonECS',
+      MaxResults: 10,
+    });
+    const response1 = await client.send(command1);
+    
+    if (response1.PriceList && response1.PriceList.length > 0) {
+      console.log(`Found ${response1.PriceList.length} ECS products`);
+      console.log('\nSample product attributes:');
+      const sample = JSON.parse(response1.PriceList[0]);
+      console.log(JSON.stringify(sample.product?.attributes, null, 2));
+    }
+  } catch (error) {
+    console.error('Error:', error);
+  }
+  console.log();
+
+  // Test 2: Search for Fargate-specific products
+  console.log('Test 2: Searching for Fargate products...');
+  try {
+    const command2 = new GetProductsCommand({
+      ServiceCode: 'AmazonECS',
+      Filters: [
+        { Type: 'TERM_MATCH', Field: 'productFamily', Value: 'Compute' },
+      ],
+      MaxResults: 10,
+    });
+    const response2 = await client.send(command2);
+    
+    if (response2.PriceList && response2.PriceList.length > 0) {
+      console.log(`Found ${response2.PriceList.length} Compute products`);
+      response2.PriceList.forEach((item: string, idx: number) => {
+        const product = JSON.parse(item);
+        const attrs = product.product?.attributes;
+        console.log(`\nProduct ${idx + 1}:`);
+        console.log(`  usagetype: ${attrs?.usagetype}`);
+        console.log(`  operation: ${attrs?.operation}`);
+        console.log(`  productFamily: ${attrs?.productFamily}`);
+        console.log(`  group: ${attrs?.group}`);
+        console.log(`  groupDescription: ${attrs?.groupDescription}`);
+      });
+    }
+  } catch (error) {
+    console.error('Error:', error);
+  }
+  console.log();
+
+  // Test 3: Search for vCPU pricing
+  console.log('Test 3: Searching for Fargate vCPU pricing...');
+  const vCpuFilters = [
+    [
+      { Type: 'TERM_MATCH', Field: 'productFamily', Value: 'Compute' },
+      { Type: 'TERM_MATCH', Field: 'usagetype', Value: `EUC1-Fargate-vCPU-Hours:perCPU` },
+    ],
+    [
+      { Type: 'TERM_MATCH', Field: 'productFamily', Value: 'Compute' },
+      { Type: 'TERM_MATCH', Field: 'usagetype', Value: `Fargate-vCPU-Hours:perCPU` },
+    ],
+    [
+      { Type: 'TERM_MATCH', Field: 'group', Value: 'Fargate-vCPU-Hours:perCPU' },
+    ],
+  ];
+
+  for (let i = 0; i < vCpuFilters.length; i++) {
+    console.log(`\nAttempt ${i + 1}:`, JSON.stringify(vCpuFilters[i]));
+    try {
+      const command = new GetProductsCommand({
+        ServiceCode: 'AmazonECS',
+        Filters: vCpuFilters[i] as any,
+        MaxResults: 1,
+      });
+      const response = await client.send(command);
+      
+      if (response.PriceList && response.PriceList.length > 0) {
+        const product = JSON.parse(response.PriceList[0]);
+        console.log('✓ SUCCESS! Found vCPU pricing');
+        console.log('  Attributes:', JSON.stringify(product.product?.attributes, null, 2));
+        
+        const onDemand = product.terms?.OnDemand;
+        if (onDemand) {
+          const termKey = Object.keys(onDemand)[0];
+          const priceDimensions = onDemand[termKey]?.priceDimensions;
+          const dimensionKey = Object.keys(priceDimensions)[0];
+          const price = priceDimensions[dimensionKey]?.pricePerUnit?.USD;
+          console.log(`  Price: $${price} per vCPU-hour`);
+        }
+      } else {
+        console.log('✗ No results');
+      }
+    } catch (error) {
+      console.error('✗ Error:', error instanceof Error ? error.message : error);
+    }
+  }
+  console.log();
+
+  // Test 4: Search for memory pricing
+  console.log('Test 4: Searching for Fargate memory pricing...');
+  const memoryFilters = [
+    [
+      { Type: 'TERM_MATCH', Field: 'productFamily', Value: 'Compute' },
+      { Type: 'TERM_MATCH', Field: 'usagetype', Value: `EUC1-Fargate-GB-Hours:perGB` },
+    ],
+    [
+      { Type: 'TERM_MATCH', Field: 'productFamily', Value: 'Compute' },
+      { Type: 'TERM_MATCH', Field: 'usagetype', Value: `EUC1-Fargate-Memory-Hours:perGB` },
+    ],
+    [
+      { Type: 'TERM_MATCH', Field: 'usagetype', Value: `EUC1-Fargate-GB-Hours` },
+    ],
+    [
+      { Type: 'TERM_MATCH', Field: 'cputype', Value: 'perGB' },
+    ],
+  ];
+
+  for (let i = 0; i < memoryFilters.length; i++) {
+    console.log(`\nAttempt ${i + 1}:`, JSON.stringify(memoryFilters[i]));
+    try {
+      const command = new GetProductsCommand({
+        ServiceCode: 'AmazonECS',
+        Filters: memoryFilters[i] as any,
+        MaxResults: 1,
+      });
+      const response = await client.send(command);
+      
+      if (response.PriceList && response.PriceList.length > 0) {
+        const product = JSON.parse(response.PriceList[0]);
+        console.log('✓ SUCCESS! Found memory pricing');
+        console.log('  Attributes:', JSON.stringify(product.product?.attributes, null, 2));
+        
+        const onDemand = product.terms?.OnDemand;
+        if (onDemand) {
+          const termKey = Object.keys(onDemand)[0];
+          const priceDimensions = onDemand[termKey]?.priceDimensions;
+          const dimensionKey = Object.keys(priceDimensions)[0];
+          const price = priceDimensions[dimensionKey]?.pricePerUnit?.USD;
+          console.log(`  Price: $${price} per GB-hour`);
+        }
+      } else {
+        console.log('✗ No results');
+      }
+    } catch (error) {
+      console.error('✗ Error:', error instanceof Error ? error.message : error);
+    }
+  }
+  console.log();
+
+  console.log('='.repeat(80));
+  console.log('Discovery complete');
+  console.log('='.repeat(80));
+}
+
+discoverECSFargatePricing().catch(console.error);