@fjall/components-infrastructure 39.0.1 → 39.0.2

package/dist/lib/resources/aws/compute/ecsCapacityProviderGate.d.ts

@@ -0,0 +1,41 @@
+import { type AutoScalingGroup } from "aws-cdk-lib/aws-autoscaling";
+import { type ICluster } from "aws-cdk-lib/aws-ecs";
+/** Where the user data installs the gate on the instance. */
+export declare const ECS_CAPACITY_PROVIDER_GATE_PATH = "/usr/local/bin/fjall-ecs-capacity-provider-gate";
+/** Every line the gate prints starts with this, so a console read can find it. */
+export declare const ECS_CAPACITY_PROVIDER_GATE_LOG_PREFIX = "fjall-ecs-capacity-provider-gate:";
+/**
+ * Holds an instance's first ECS registration until a capacity provider naming
+ * its Auto Scaling group is ACTIVE and associated with the cluster.
+ *
+ * ECS binds a container instance to a capacity provider only if the provider
+ * already exists when the instance calls RegisterContainerInstance. An
+ * instance that registers first stays unbound, and a service whose strategy
+ * names only capacity providers never places a task on it. CloudFormation
+ * creates the provider after the group is complete, so the group's first
+ * instances race it (fjall-deploy-tests #94: the provider was created in the
+ * same second the instance registered, and no task was ever created). The
+ * ECS agent starts after cloud-final, so user data that waits here delays the
+ * registration.
+ *
+ * Arguments: cluster name, then optional overall budget, poll interval and
+ * error budget in seconds. It prints only the gate's own lines, AWS error
+ * codes, and the group, provider and cluster names. It exits 0 on every path:
+ * a gate that cannot decide lets the agent register rather than hold the
+ * boot. It never contains `${`, so a renderer that substitutes `${…}` (as
+ * `Fn::Sub` does) passes it through unchanged.
+ */
+export declare const ECS_CAPACITY_PROVIDER_GATE_SCRIPT: string;
+/**
+ * Makes the group's instances wait for their capacity provider before the ECS
+ * agent registers them (see {@link ECS_CAPACITY_PROVIDER_GATE_SCRIPT}), and
+ * grants the two reads the wait needs.
+ *
+ * It applies wherever `cluster.addAsgCapacityProvider` writes the
+ * `ECS_CLUSTER` line as shell, which is every group that is not Windows.
+ * Called before that, the block lands ahead of the line, so it is guarded by
+ * `|| true`: user data may run under `set -e` (ClickHouse's does), and a
+ * failure here would stop it before `ECS_CLUSTER` is written, sending the
+ * agent to the default cluster.
+ */
+export declare function addEcsCapacityProviderGate(autoScalingGroup: AutoScalingGroup, cluster: ICluster): void;

package/dist/lib/resources/aws/compute/ecsCapacityProviderGate.js

@@ -0,0 +1,116 @@
+import { Stack } from "aws-cdk-lib";
+import { OperatingSystemType } from "aws-cdk-lib/aws-ec2";
+import { PolicyStatement } from "aws-cdk-lib/aws-iam";
+/** Where the user data installs the gate on the instance. */
+export const ECS_CAPACITY_PROVIDER_GATE_PATH = "/usr/local/bin/fjall-ecs-capacity-provider-gate";
+/** Every line the gate prints starts with this, so a console read can find it. */
+export const ECS_CAPACITY_PROVIDER_GATE_LOG_PREFIX = "fjall-ecs-capacity-provider-gate:";
+const HEREDOC_DELIMITER = "FJALL_ECS_CAPACITY_PROVIDER_GATE";
+/**
+ * Holds an instance's first ECS registration until a capacity provider naming
+ * its Auto Scaling group is ACTIVE and associated with the cluster.
+ *
+ * ECS binds a container instance to a capacity provider only if the provider
+ * already exists when the instance calls RegisterContainerInstance. An
+ * instance that registers first stays unbound, and a service whose strategy
+ * names only capacity providers never places a task on it. CloudFormation
+ * creates the provider after the group is complete, so the group's first
+ * instances race it (fjall-deploy-tests #94: the provider was created in the
+ * same second the instance registered, and no task was ever created). The
+ * ECS agent starts after cloud-final, so user data that waits here delays the
+ * registration.
+ *
+ * Arguments: cluster name, then optional overall budget, poll interval and
+ * error budget in seconds. It prints only the gate's own lines, AWS error
+ * codes, and the group, provider and cluster names. It exits 0 on every path:
+ * a gate that cannot decide lets the agent register rather than hold the
+ * boot. It never contains `${`, so a renderer that substitutes `${…}` (as
+ * `Fn::Sub` does) passes it through unchanged.
+ */
+export const ECS_CAPACITY_PROVIDER_GATE_SCRIPT = String.raw `#!/bin/bash
+cluster=$1 budget=$2 interval=$3 error_budget=$4
+[ -n "$budget" ] || budget=600
+[ -n "$interval" ] || interval=5
+[ -n "$error_budget" ] || error_budget=120
+say() { echo "${ECS_CAPACITY_PROVIDER_GATE_LOG_PREFIX} $*"; }
+[ -n "$cluster" ] || { say "no cluster named, not waiting"; exit 0; }
+command -v aws >/dev/null 2>&1 || { say "no AWS CLI, not waiting"; exit 0; }
+err=$(mktemp) || { say "no temporary file, not waiting"; exit 0; }
+trap 'rm -f "$err"' EXIT
+imds() { curl -sf --max-time 5 -H "X-aws-ec2-metadata-token: $token" "http://169.254.169.254/latest/meta-data/$1"; }
+ecs() { aws ecs "$@" --region "$region" --output text --cli-connect-timeout 5 --cli-read-timeout 10 2>"$err"; }
+failed() {
+  code=$(sed -n 's/.*An error occurred (\([A-Za-z0-9.]*\)).*/\1/p' "$err" | head -n 1)
+  [ -n "$code" ] || code=CallFailed
+}
+asg= region= since= last= waiting=
+while :; do
+  code=
+  if [ -z "$asg" ] || [ -z "$region" ]; then
+    token=$(curl -sf --max-time 5 -X PUT http://169.254.169.254/latest/api/token -H "X-aws-ec2-metadata-token-ttl-seconds: 300")
+    asg=$(imds tags/instance/aws:autoscaling:groupName) region=$(imds placement/region)
+    [ -n "$asg" ] && [ -n "$region" ] || code=InstanceMetadataUnavailable
+  fi
+  if [ -n "$code" ]; then :
+  elif ! listed=$(ecs describe-clusters --clusters "$cluster" --query 'clusters[0].capacityProviders'); then failed
+  else
+    names=
+    for name in $listed; do case $name in None|FARGATE|FARGATE_SPOT) ;; *) names="$names $name" ;; esac; done
+    if [ -z "$names" ]; then :
+    elif ! rows=$(ecs describe-capacity-providers --capacity-providers $names --query "capacityProviders[?status=='ACTIVE'].[name,autoScalingGroupProvider.autoScalingGroupArn]"); then failed
+    else
+      while read -r name group; do
+        case $group in "$asg"|*":autoScalingGroupName/$asg")
+          say "capacity provider $name names $asg on cluster $cluster after $SECONDS s, registering"; exit 0 ;;
+        esac
+      done <<EOF
+$rows
+EOF
+    fi
+  fi
+  if [ -n "$code" ]; then
+    [ -n "$since" ] || since=$SECONDS
+    [ "$code" = "$last" ] || { say "cannot check yet: $code"; last=$code; }
+    [ $((SECONDS - since)) -lt "$error_budget" ] || { say "gave up after $SECONDS s on $code, registering unbound"; exit 0; }
+  else
+    since= last=
+    [ -n "$waiting" ] || { say "waiting for a capacity provider naming $asg on cluster $cluster"; waiting=1; }
+  fi
+  [ "$SECONDS" -lt "$budget" ] || { say "gave up after $SECONDS s, no capacity provider names $asg on cluster $cluster, registering unbound"; exit 0; }
+  sleep "$interval"
+done
+`;
+/**
+ * Makes the group's instances wait for their capacity provider before the ECS
+ * agent registers them (see {@link ECS_CAPACITY_PROVIDER_GATE_SCRIPT}), and
+ * grants the two reads the wait needs.
+ *
+ * It applies wherever `cluster.addAsgCapacityProvider` writes the
+ * `ECS_CLUSTER` line as shell, which is every group that is not Windows.
+ * Called before that, the block lands ahead of the line, so it is guarded by
+ * `|| true`: user data may run under `set -e` (ClickHouse's does), and a
+ * failure here would stop it before `ECS_CLUSTER` is written, sending the
+ * agent to the default cluster.
+ */
+export function addEcsCapacityProviderGate(autoScalingGroup, cluster) {
+    if (autoScalingGroup.osType === OperatingSystemType.WINDOWS)
+        return;
+    autoScalingGroup.addUserData("{", `cat > ${ECS_CAPACITY_PROVIDER_GATE_PATH} <<'${HEREDOC_DELIMITER}'`, ECS_CAPACITY_PROVIDER_GATE_SCRIPT.trimEnd(), HEREDOC_DELIMITER, `chmod 755 ${ECS_CAPACITY_PROVIDER_GATE_PATH}`, `${ECS_CAPACITY_PROVIDER_GATE_PATH} '${cluster.clusterName}'`, "} || true");
+    autoScalingGroup.addToRolePolicy(new PolicyStatement({
+        actions: ["ecs:DescribeClusters"],
+        resources: [cluster.clusterArn]
+    }));
+    // A provider's name is not known until CloudFormation creates it, and
+    // naming it here would make the role's policy wait for the provider the
+    // instances are waiting for.
+    autoScalingGroup.addToRolePolicy(new PolicyStatement({
+        actions: ["ecs:DescribeCapacityProviders"],
+        resources: [
+            Stack.of(autoScalingGroup).formatArn({
+                service: "ecs",
+                resource: "capacity-provider",
+                resourceName: "*"
+            })
+        ]
+    }));
+}

package/dist/lib/resources/aws/compute/ecsServiceFactory.js

@@ -8,6 +8,7 @@ import { Alarm, ComparisonOperator, MathExpression } from "aws-cdk-lib/aws-cloud
 import { ApplicationScalingAction } from "aws-cdk-lib/aws-cloudwatch-actions";
 import { SecurityGroup } from "../networking/securityGroup.js";
 import { Ec2Instance } from "./ec2.js";
+import { addEcsCapacityProviderGate } from "./ecsCapacityProviderGate.js";
 import { vpcHasNatGateways } from "../../../utils/vpcUtils.js";
 import { toPascalCase } from "../../../utils/capitaliseString.js";
 import { stackScopedExportName } from "../../../utils/exportNaming.js";
@@ -176,6 +177,9 @@ export function getOrCreateAsgCapacityProvider(ctx, serviceProps, state) {
         instanceMonitoring: ec2Config.instanceMonitoring ?? DEFAULT_EC2_INSTANCE_MONITORING,
         capacityRebalance: true,
         ecsClusterArn: ctx.cluster.clusterArn,
+        ...(ctx.props.alertsTopic !== undefined && {
+            alertsTopic: ctx.props.alertsTopic
+        }),
         ...(ec2Config.desiredCapacity !== undefined && {
             desiredCapacity: ec2Config.desiredCapacity
         }),
@@ -207,6 +211,7 @@ export function getOrCreateAsgCapacityProvider(ctx, serviceProps, state) {
         ...(ec2Config.tags !== undefined && { tags: ec2Config.tags })
     });
     const asg = ec2Instance.getAutoScalingGroup();
+    addEcsCapacityProviderGate(asg, ctx.cluster);
     const provider = new AsgCapacityProvider(ctx.scope, `${anchor}AsgCapacityProvider`, {
         autoScalingGroup: asg,
         enableManagedDraining: true,

package/dist/lib/resources/aws/compute/ecsTypes.d.ts

@@ -170,11 +170,12 @@ export interface Ec2CapacityConfig {
     availabilityZones?: string[];
     /**
      * Pairs the EC2 capacity ASG with a standalone EBS data volume that
-     * re-attaches across instance refreshes. Forwarded to `Ec2Instance` which
-     * locates and detaches the volume via TERMINATING/LAUNCHING lifecycle
-     * hooks. Implies a singleton service — a second service declaring the
-     * same slot is rejected at synth (`assertSharedAsgConfigMatches`); give
-     * it its own slot instead.
+     * re-attaches across instance refreshes. Forwarded to `Ec2Instance`, whose
+     * LAUNCHING lifecycle hook attaches the volume to a new instance once the
+     * instance that held it has terminated. Implies a singleton service — a
+     * second service declaring the same slot is rejected at synth
+     * (`assertSharedAsgConfigMatches`); give it its own slot instead. Cannot be
+     * combined with `warmPool`.
      */
     persistentDataVolume?: Ec2InstancePersistentDataVolumeConfig;
     /**

package/dist/lib/resources/aws/compute/lambda.d.ts

@@ -3,6 +3,7 @@ import { type Bucket } from "aws-cdk-lib/aws-s3";
 import { PolicyStatement, type IRole } from "aws-cdk-lib/aws-iam";
 import { type IVpc } from "aws-cdk-lib/aws-ec2";
 import type { RetentionDays } from "aws-cdk-lib/aws-logs";
+import { LogGroup } from "../logging/logGroup.js";
 import { type BackupTier } from "../../../utils/backupTierMapping.js";
 import { type IQueue } from "aws-cdk-lib/aws-sqs";
 import { type ITable } from "aws-cdk-lib/aws-dynamodb";
@@ -127,6 +128,8 @@ export declare class SingletonFunction extends singletonFunction {
     get executionRole(): IRole | undefined;
 }
 export declare class LambdaFunction extends Function {
+    /** The explicit log group this function writes to. */
+    readonly functionLogGroup: LogGroup;
     private functionUrlValue?;
     private readonly asyncFailureQueueProp?;
     private asyncFailureQueueWired?;

package/dist/lib/resources/aws/compute/lambda.js

@@ -172,6 +172,8 @@ export class SingletonFunction extends singletonFunction {
     }
 }
 export class LambdaFunction extends Function {
+    /** The explicit log group this function writes to. */
+    functionLogGroup;
     functionUrlValue;
     asyncFailureQueueProp;
     asyncFailureQueueWired;
@@ -187,6 +189,12 @@ export class LambdaFunction extends Function {
         // Grant-based: Lambda encrypts the environment through a KMS grant the
         // deploying role creates, so the execution role needs no key policy.
         const encryptionKey = StackEncryptionKey.forTier(scope, appBackupTier);
+        const functionLogGroup = new LogGroup(scope, `${id}LogGroup`, {
+            retention: props.logGroupRetention ?? DEFAULT_FRAMEWORK_LOG_RETENTION,
+            ...(encryptionKey !== undefined && {
+                encryptionKey: encryptionKey.forLogGroups()
+            })
+        });
         super(scope, id, {
             ...cdkProps,
             vpcSubnets,
@@ -201,13 +209,9 @@ export class LambdaFunction extends Function {
                 : undefined,
             description: props.lambdaDescription ?? `${id} Lambda`,
             environment: props.environment,
-            logGroup: new LogGroup(scope, `${id}LogGroup`, {
-                retention: props.logGroupRetention ?? DEFAULT_FRAMEWORK_LOG_RETENTION,
-                ...(encryptionKey !== undefined && {
-                    encryptionKey: encryptionKey.forLogGroups()
-                })
-            })
+            logGroup: functionLogGroup
         });
+        this.functionLogGroup = functionLogGroup;
         this.asyncFailureQueueProp = props.asyncFailureQueue;
         addPoliciesToRole(this, props.inlinePolicy);
         applyRoleDescription(this, props.roleDescription);

package/dist/lib/resources/aws/compute/persistentDataVolume.d.ts

@@ -13,6 +13,13 @@ import { SQSQueue } from "../messaging/sqs.js";
  * not silently break the test query.
  */
 export declare const PERSISTENT_DATA_VOLUME_LAUNCHING_DESCRIPTION = "PersistentDataVolume launching handler";
+/**
+ * How long a launching instance waits for its data volume. The Lambda's full
+ * attempt must fit inside it, and the instance's user data waits this long
+ * for the device to appear: the hook ABANDONs the instance when it expires,
+ * so waiting any longer on the instance buys nothing.
+ */
+export declare const PERSISTENT_DATA_VOLUME_LAUNCHING_HEARTBEAT_SECONDS = 900;
 export declare const PERSISTENT_DATA_VOLUME_TAG_LIFECYCLE = "fjall:Lifecycle";
 export declare const PERSISTENT_DATA_VOLUME_TAG_LIFECYCLE_VALUE = "data-volume";
 export declare const PERSISTENT_DATA_VOLUME_TAG_OWNER_LOGICAL_ID = "fjall:OwnerLogicalId";
@@ -66,11 +73,11 @@ export interface PersistentDataVolumeProps {
  * Standalone EBS data volume + ASG `EC2_INSTANCE_LAUNCHING` hook that
  * re-attaches the same physical volume across instance refreshes.
  *
- * Pairs with the TERMINATING-side DetachVolume branch in
- * `ec2GracefulTerminationLambda.source.cjs` (see `DetachVolumeCommand` import
- * + invocation) wired by `ec2GracefulTerminationHandler.ts` when
- * `dataVolumeOwnerLogicalId` is forwarded from `Ec2Instance`. The two
- * Lambdas form a closed re-attach contract.
+ * Nothing detaches the volume. The instance holding it releases it when it
+ * terminates, after `Ec2GracefulTerminationHandler` has proven its tasks
+ * stopped; the LAUNCHING Lambda waits for that release and then attaches the
+ * volume to the new instance. A forced detach would pull the filesystem out
+ * from under a database that is still running.
  *
  * Volume tagging: three tags carry the re-attach identity —
  *   `fjall:Lifecycle = data-volume` (constant; gates IAM scoping)
@@ -82,9 +89,7 @@ export interface PersistentDataVolumeProps {
  *     StackId and cannot collide with the new deploy's volume)
  *
  * The LAUNCHING Lambda filters DescribeVolumes by all three tags AND ABANDONs
- * on multi-match. The TERMINATING handler MUST be configured with the same
- * `ownerLogicalId` (and is in the same stack, so shares the StackId
- * automatically) to locate the volume for detach.
+ * on multi-match.
  *
  * Why three tags. The first two are stable per logical construct; without
  * the StackId discriminator, every prior-iteration orphan (CREATE_ROLLBACK,
@@ -105,12 +110,10 @@ export declare class PersistentDataVolume extends Construct {
     readonly queue: SQSQueue;
     /**
      * Identifier used as the `fjall:OwnerLogicalId` tag on the volume and the
-     * `OWNER_LOGICAL_ID` env on the Lambda. Consumers MUST pass this exact
-     * value to the TERMINATING handler so it locates the same volume for
-     * detach. Carries `props.stableOwnerId` verbatim; changing it across an
-     * existing deployment breaks the re-attach chain (Lambda filter no longer
-     * matches, new instance fails its launch hook) — recovery is a manual
-     * snapshot-restore step.
+     * `OWNER_LOGICAL_ID` env on the Lambda. Carries `props.stableOwnerId`
+     * verbatim; changing it across an existing deployment breaks the re-attach
+     * chain (Lambda filter no longer matches, new instance fails its launch
+     * hook) — recovery is a manual snapshot-restore step.
      */
     readonly ownerLogicalId: string;
     readonly attachFailureAlarm: Alarm;
@@ -120,7 +123,6 @@ declare function validatePersistentDataVolumeProps(props: PersistentDataVolumePr
 export declare const _internals: {
     LAUNCHING_LAMBDA_SOURCE_FILE: string;
     LAMBDA_TIMEOUT_SECONDS: number;
-    LAUNCHING_HOOK_HEARTBEAT_SECONDS: number;
     QUEUE_VISIBILITY_TIMEOUT_SECONDS: number;
     ALARM_EVALUATION_PERIODS: number;
     ALARM_DATAPOINTS_TO_ALARM: number;

package/dist/lib/resources/aws/compute/persistentDataVolume.js

@@ -24,10 +24,19 @@ const LAUNCHING_LAMBDA_SOURCE_FILE = "persistentDataVolumeLambda.source.cjs";
  * not silently break the test query.
  */
 export const PERSISTENT_DATA_VOLUME_LAUNCHING_DESCRIPTION = "PersistentDataVolume launching handler";
-const LAMBDA_TIMEOUT_SECONDS = 180;
-// Heartbeat must comfortably exceed the Lambda's 90s attach deadline.
-const LAUNCHING_HOOK_HEARTBEAT_SECONDS = 300;
-const QUEUE_VISIBILITY_TIMEOUT_SECONDS = 240;
+// Covers the Lambda's release wait (480 s) and attach wait (90 s), each of
+// which may end on a read that started at its deadline, plus the calls around
+// them. Every call is bounded; a test pins the sum.
+const LAMBDA_TIMEOUT_SECONDS = 700;
+// SQS requires a visibility timeout of at least the function timeout.
+const QUEUE_VISIBILITY_TIMEOUT_SECONDS = 720;
+/**
+ * How long a launching instance waits for its data volume. The Lambda's full
+ * attempt must fit inside it, and the instance's user data waits this long
+ * for the device to appear: the hook ABANDONs the instance when it expires,
+ * so waiting any longer on the instance buys nothing.
+ */
+export const PERSISTENT_DATA_VOLUME_LAUNCHING_HEARTBEAT_SECONDS = 900;
 export const PERSISTENT_DATA_VOLUME_TAG_LIFECYCLE = "fjall:Lifecycle";
 export const PERSISTENT_DATA_VOLUME_TAG_LIFECYCLE_VALUE = "data-volume";
 export const PERSISTENT_DATA_VOLUME_TAG_OWNER_LOGICAL_ID = "fjall:OwnerLogicalId";
@@ -39,11 +48,11 @@ const ALARM_THRESHOLD = 1;
  * Standalone EBS data volume + ASG `EC2_INSTANCE_LAUNCHING` hook that
  * re-attaches the same physical volume across instance refreshes.
  *
- * Pairs with the TERMINATING-side DetachVolume branch in
- * `ec2GracefulTerminationLambda.source.cjs` (see `DetachVolumeCommand` import
- * + invocation) wired by `ec2GracefulTerminationHandler.ts` when
- * `dataVolumeOwnerLogicalId` is forwarded from `Ec2Instance`. The two
- * Lambdas form a closed re-attach contract.
+ * Nothing detaches the volume. The instance holding it releases it when it
+ * terminates, after `Ec2GracefulTerminationHandler` has proven its tasks
+ * stopped; the LAUNCHING Lambda waits for that release and then attaches the
+ * volume to the new instance. A forced detach would pull the filesystem out
+ * from under a database that is still running.
  *
  * Volume tagging: three tags carry the re-attach identity —
  *   `fjall:Lifecycle = data-volume` (constant; gates IAM scoping)
@@ -55,9 +64,7 @@ const ALARM_THRESHOLD = 1;
  *     StackId and cannot collide with the new deploy's volume)
  *
  * The LAUNCHING Lambda filters DescribeVolumes by all three tags AND ABANDONs
- * on multi-match. The TERMINATING handler MUST be configured with the same
- * `ownerLogicalId` (and is in the same stack, so shares the StackId
- * automatically) to locate the volume for detach.
+ * on multi-match.
  *
  * Why three tags. The first two are stable per logical construct; without
  * the StackId discriminator, every prior-iteration orphan (CREATE_ROLLBACK,
@@ -78,12 +85,10 @@ export class PersistentDataVolume extends Construct {
     queue;
     /**
      * Identifier used as the `fjall:OwnerLogicalId` tag on the volume and the
-     * `OWNER_LOGICAL_ID` env on the Lambda. Consumers MUST pass this exact
-     * value to the TERMINATING handler so it locates the same volume for
-     * detach. Carries `props.stableOwnerId` verbatim; changing it across an
-     * existing deployment breaks the re-attach chain (Lambda filter no longer
-     * matches, new instance fails its launch hook) — recovery is a manual
-     * snapshot-restore step.
+     * `OWNER_LOGICAL_ID` env on the Lambda. Carries `props.stableOwnerId`
+     * verbatim; changing it across an existing deployment breaks the re-attach
+     * chain (Lambda filter no longer matches, new instance fails its launch
+     * hook) — recovery is a manual snapshot-restore step.
      */
     ownerLogicalId;
     attachFailureAlarm;
@@ -179,7 +184,9 @@ export class PersistentDataVolume extends Construct {
                 completeLifecyclePolicy
             ]
         });
-        this.lambda.addSqsEventSource(this.queue.getQueue());
+        // One lifecycle action per invocation: a batch is processed in turn, so
+        // launches arriving together would share one timeout.
+        this.lambda.addSqsEventSource(this.queue.getQueue(), { batchSize: 1 });
         // Hook name embeds Aws.STACK_NAME (a pseudo-parameter Ref, NOT a resource
         // Ref — does not create a CFN dep) so that LifecycleHookName alone is
         // sufficient to discriminate across stacks in the EB pattern below. The
@@ -191,7 +198,7 @@ export class PersistentDataVolume extends Construct {
             hookName: launchingHookName,
             lifecycleTransition: LifecycleTransition.INSTANCE_LAUNCHING,
             defaultResult: DefaultResult.ABANDON,
-            heartbeatTimeoutSeconds: LAUNCHING_HOOK_HEARTBEAT_SECONDS
+            heartbeatTimeoutSeconds: PERSISTENT_DATA_VOLUME_LAUNCHING_HEARTBEAT_SECONDS
         });
         // Pattern discriminates by LifecycleHookName only — the hook name carries
         // Aws.STACK_NAME so it is unique per stack. AutoScalingGroupName would
@@ -252,7 +259,6 @@ function validatePersistentDataVolumeProps(props) {
 export const _internals = {
     LAUNCHING_LAMBDA_SOURCE_FILE,
     LAMBDA_TIMEOUT_SECONDS,
-    LAUNCHING_HOOK_HEARTBEAT_SECONDS,
     QUEUE_VISIBILITY_TIMEOUT_SECONDS,
     ALARM_EVALUATION_PERIODS,
     ALARM_DATAPOINTS_TO_ALARM,