dcl-ops-lib 9.7.0 → 9.8.0

package/createFargateTask.d.ts

@@ -76,14 +76,7 @@ export type FargateTaskOptions = {
     appAutoscaling?: {
         maxCapacity: number;
         minCapacity?: number;
-        policy?: {
-            metricName: string;
-            targetValue: number;
-            metricDimensionValue: pulumi.Output<string>;
-            statistic: "Average" | "Minimum" | "Maximum";
-            scaleOutCooldown: number;
-            scaleInCooldown: number;
-        }[];
+        policy?: AppAutoscalingPolicy[];
         scheduleAction?: {
             minCapacity: number;
             maxCapacity: number;
@@ -99,6 +92,41 @@ export type FargateTaskOptions = {
     };
     enableExecuteCommand?: boolean;
 };
+/**
+ * One ECS Service Application-Auto-Scaling target-tracking policy.
+ *
+ * Tracks `metricName` (today only `ApproximateNumberOfMessagesVisible` is
+ * understood as an SQS queue depth — anything else falls through with no
+ * `customizedMetricSpecification` set) against `targetValue`. Required
+ * cooldowns are enforced by AWS.
+ *
+ * Choose ONE of:
+ * - `metricDimensionValue`: a single SQS queue URL. The policy tracks that
+ *   queue's depth directly.
+ * - `metricDimensionValues`: 2+ SQS queue URLs. The policy uses CloudWatch
+ *   metric math to track the SUM of their depths under one signal — useful
+ *   when several queues feed the same worker pool and the desired pod count
+ *   must reflect total pending work, not the max of any one queue. (AWS's
+ *   default with N parallel target-tracking policies is max-of-all, which
+ *   undercounts when multiple queues have load simultaneously.)
+ *
+ * Setting both fields, or neither, throws at apply time.
+ */
+export type AppAutoscalingPolicy = {
+    metricName: string;
+    targetValue: number;
+    /** Single-queue form. Mutually exclusive with `metricDimensionValues`. */
+    metricDimensionValue?: pulumi.Output<string>;
+    /**
+     * Multi-queue (sum) form. Mutually exclusive with `metricDimensionValue`.
+     * Must contain ≥1 entry; with a single entry, prefer `metricDimensionValue`
+     * for clarity.
+     */
+    metricDimensionValues?: pulumi.Output<string>[];
+    statistic: "Average" | "Minimum" | "Maximum";
+    scaleOutCooldown: number;
+    scaleInCooldown: number;
+};
 /**
  *
  * @param serviceName A name for this service. For example, "builder-api"
@@ -152,14 +180,7 @@ export type InternalServiceOptions = {
     appAutoscaling?: {
         maxCapacity: number;
         minCapacity?: number;
-        policy?: {
-            metricName: string;
-            targetValue: number;
-            metricDimensionValue: pulumi.Output<string>;
-            statistic: "Average" | "Minimum" | "Maximum";
-            scaleOutCooldown: number;
-            scaleInCooldown: number;
-        }[];
+        policy?: AppAutoscalingPolicy[];
         scheduleAction?: {
             maxCapacity: number;
             minCapacity: number;

package/createFargateTask.js

@@ -430,26 +430,78 @@ function setAutoscaling(service, serviceName, config) {
         scalableDimension: "ecs:service:DesiredCount",
         serviceNamespace: "ecs",
     });
+    // The dcl-ops-lib SQS queue convention is to pass `queue.id` (the queue's
+    // URL, e.g., https://sqs.us-east-1.amazonaws.com/.../my-queue) as the
+    // metric dimension value. CloudWatch wants just the queue NAME ("my-queue")
+    // in the dimension, so we trim everything up to and including the last `/`.
+    const extractQueueName = (queueUrl) => queueUrl.apply((value) => value.split("/").pop());
     if (config.appAutoscaling.policy) {
         config.appAutoscaling.policy.forEach((item, index) => {
-            const CSM_ApproximateNumberOfMessagesVisible = {
-                metricName: item.metricName,
-                namespace: "AWS/SQS",
-                dimensions: [
-                    {
-                        name: "QueueName",
-                        value: item.metricDimensionValue.apply((value) => {
-                            return value.split("/").pop();
-                        }),
-                    },
-                ],
-                statistic: item.statistic,
-                unit: "Count",
-            };
+            // Validate the singular/plural choice. Done per-item so the user sees
+            // the failure on the offending policy entry rather than a vague top-
+            // level error after Pulumi has already started planning resources.
+            const hasSingle = item.metricDimensionValue !== undefined;
+            const hasMulti = item.metricDimensionValues !== undefined &&
+                item.metricDimensionValues.length > 0;
+            if (hasSingle && hasMulti) {
+                throw new Error(`appAutoscaling.policy[${index}] sets both metricDimensionValue and metricDimensionValues; pick one.`);
+            }
+            if (!hasSingle && !hasMulti) {
+                throw new Error(`appAutoscaling.policy[${index}] must set either metricDimensionValue or metricDimensionValues (non-empty).`);
+            }
             let TTS_CustomizedMetricSpecification = undefined;
             if (item.metricName === "ApproximateNumberOfMessagesVisible") {
-                TTS_CustomizedMetricSpecification =
-                    CSM_ApproximateNumberOfMessagesVisible;
+                if (hasMulti) {
+                    // Metric-math form: SUM the queue depths into one signal. Each
+                    // queue contributes a `mN` metric stat with returnData=false, and
+                    // a final `e0` expression `m0 + m1 + ...` is the value the scaling
+                    // target tracks. AWS evaluates the expression at policy time.
+                    const dims = item.metricDimensionValues;
+                    const metricStats = dims.map((queueUrl, i) => ({
+                        id: `m${i}`,
+                        metricStat: {
+                            metric: {
+                                metricName: item.metricName,
+                                namespace: "AWS/SQS",
+                                dimensions: [
+                                    {
+                                        name: "QueueName",
+                                        value: extractQueueName(queueUrl),
+                                    },
+                                ],
+                            },
+                            stat: item.statistic,
+                            unit: "Count",
+                        },
+                        returnData: false,
+                    }));
+                    const expression = dims.map((_, i) => `m${i}`).join(" + ");
+                    TTS_CustomizedMetricSpecification = {
+                        metrics: [
+                            ...metricStats,
+                            {
+                                id: "e0",
+                                expression,
+                                returnData: true,
+                            },
+                        ],
+                    };
+                }
+                else {
+                    // Single-queue form (existing behavior, byte-identical output).
+                    TTS_CustomizedMetricSpecification = {
+                        metricName: item.metricName,
+                        namespace: "AWS/SQS",
+                        dimensions: [
+                            {
+                                name: "QueueName",
+                                value: extractQueueName(item.metricDimensionValue),
+                            },
+                        ],
+                        statistic: item.statistic,
+                        unit: "Count",
+                    };
+                }
             }
             return new aws.appautoscaling.Policy(`ecs-autoscaling-policy-${(0, stack_1.getStackScopedName)(serviceName)}-${index.toString()}`, // distinct policies by id
             {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcl-ops-lib",
-  "version": "9.7.0",
+  "version": "9.8.0",
   "scripts": {
     "build": "tsc && cp bin/* . && node test.js",
     "test": "tsc -p tsconfig.test.json && ENVIRONMENT=dev node bin-test/rateLimiting.test.js",