dcl-ops-lib 9.7.0 → 9.9.0

package/README.md

@@ -2,6 +2,13 @@
 
 Used to compile pulumi projects
 
+## Releases
+
+Published to npm as `dcl-ops-lib` by GitHub Actions (`.github/workflows/release.yml`)
+via semantic-release, using npm OIDC trusted publishing:
+
+- push to `master` → stable release on the `latest` dist-tag
+- push to `next` → prerelease on the `next` dist-tag
 
 # License
 Published under Apache-2.0

package/StaticWebsite.d.ts

@@ -33,4 +33,13 @@ export type StaticWebsite = {
     responseHeadersPolicyId?: Input<string>;
     objectOwnership?: string;
     overrideContentBucketACL?: string;
+    /**
+     * Tags applied to the content bucket, logs bucket and CloudFront distribution.
+     * Optional: when omitted, no tags are set by buildStatic (existing behavior).
+     *
+     * When provided, each resource receives a default `Name` derived from the domain
+     * (content bucket & distribution: `<domain>`, logs bucket: `<domain>-logs`); a
+     * `Name` supplied here overrides that default.
+     */
+    tags?: Record<string, Input<string>>;
 };

package/buildStatic.js

@@ -20,6 +20,13 @@ function buildStatic(staticSite) {
         additionalDomains: staticSite.additionalDomains ? staticSite.additionalDomains : [],
     };
     const slug = staticSite.domain.replace(/\./g, "-") + "-";
+    // Tags for each resource. When the caller opts into tagging we default a per-resource
+    // `Name` derived from the domain (caller-provided `Name` wins). When `tags` is omitted
+    // the value stays `undefined`, preserving the original untagged behavior.
+    const makeTags = (name) => staticSite.tags && { Name: name, ...staticSite.tags };
+    const contentBucketTags = makeTags(staticSite.domain);
+    const logsBucketTags = makeTags(`${staticSite.domain}-logs`);
+    const cdnTags = makeTags(staticSite.domain);
     // contentBucket is the S3 bucket that the website's contents will be stored in.
     const bucketInfo = {
         acl: staticSite.overrideContentBucketACL ? staticSite.overrideContentBucketACL : "public-read",
@@ -29,7 +36,8 @@ function buildStatic(staticSite) {
             indexDocument: "index.html",
             errorDocument: staticSite.defaultPath ?? "404.html",
         },
-        forceDestroy: staticSite.destroy === true
+        forceDestroy: staticSite.destroy === true,
+        tags: contentBucketTags,
     };
     if (staticSite.corsRules !== undefined) {
         Object.assign(bucketInfo, { corsRules: staticSite.corsRules });
@@ -48,7 +56,8 @@ function buildStatic(staticSite) {
     // logsBucket is an S3 bucket that will contain the CDN's request logs.
     const logsBucket = new aws.s3.Bucket(slug + "logs", {
         acl: "private",
-        forceDestroy: staticSite.destroy === true
+        forceDestroy: staticSite.destroy === true,
+        tags: logsBucketTags,
     }, {
         protect,
     });
@@ -96,7 +105,7 @@ function buildStatic(staticSite) {
         // "All" is the most broad distribution, and also the most expensive.
         // "100" is the least broad, and also the least expensive.
         priceClass: staticSite.priceClass || "PriceClass_100",
-        // You can customize error responses. When CloudFront recieves an error from the origin (e.g. S3 or some other
+        // You can customize error responses. When CloudFront receives an error from the origin (e.g. S3 or some other
         // web service) it can return a different error code, and return the response for a different resource.
         customErrorResponses: [{ errorCode: 404, responseCode: 404, responsePagePath: "/404.html" }],
         restrictions: {
@@ -113,6 +122,7 @@ function buildStatic(staticSite) {
             includeCookies: false,
             prefix: `${config.targetDomain}/`,
         },
+        tags: cdnTags,
     };
     const cdn = new aws.cloudfront.Distribution(slug + "cdn", distributionArgs);
     // Creates a new Route53 DNS record pointing the domain to the CloudFront distribution.

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.9.0",
   "scripts": {
     "build": "tsc && cp bin/* . && node test.js",
     "test": "tsc -p tsconfig.test.json && ENVIRONMENT=dev node bin-test/rateLimiting.test.js",
@@ -21,14 +21,12 @@
         "name": "next",
         "prerelease": true
       }
-    ],
-    "extends": "@semantic-release/gitlab-config"
+    ]
   },
   "devDependencies": {
-    "@semantic-release/gitlab-config": "^14.0.1",
     "@types/mime": "^3.0.4",
     "@types/node": "20.9.3",
-    "semantic-release": "^24.2.9",
+    "semantic-release": "^25.0.5",
     "typescript": "5.3.2"
   },
   "dependencies": {