ec2-instance-running-scheduler 0.2.7 → 0.3.1

package/lib/funcs/running-scheduler.lambda.js

@@ -14,20 +14,31 @@ const client_ec2_1 = require("@aws-sdk/client-ec2");
 const client_resource_groups_tagging_api_1 = require("@aws-sdk/client-resource-groups-tagging-api");
 const web_api_1 = require("@slack/web-api");
 const aws_lambda_secret_fetcher_1 = require("aws-lambda-secret-fetcher");
-const safe_env_getter_1 = require("safe-env-getter");
-const running_scheduler_polling_env_1 = require("./running-scheduler-polling-env");
+const strict_env_resolver_1 = require("strict-env-resolver");
 const running_scheduler_predicates_1 = require("./running-scheduler-predicates");
+const running_scheduler_wait_env_1 = require("./running-scheduler-wait-env");
 /** Mapping of EC2 instance state to display name and emoji for Slack. */
 const STATE_LIST = [
     { name: 'RUNNING', emoji: '😆', state: 'running' },
     { name: 'STOPPED', emoji: '😴', state: 'stopped' },
 ];
 /**
- * Seconds to wait between polling instance state after start/stop or while transitioning.
+ * Seconds to wait between describe iterations after start/stop or while transitioning.
  *
  * Used with {@link processOneResource} durable `wait` calls between describe iterations.
  */
 const STATUS_CHANGE_WAIT_SECONDS = 20;
+/**
+ * Options passed to {@link secretFetcher.getSecretValue} when loading the Slack secret.
+ *
+ * Retries cover transient extension HTTP errors (5xx, 429) and the extension
+ * "not ready to serve traffic" response during cold starts.
+ */
+const SLACK_SECRET_FETCH_OPTIONS = {
+    timeoutMs: 3000,
+    retries: 5,
+    baseBackoffMs: 300,
+};
 /**
  * Returns display name and emoji for an EC2 instance state.
  *
@@ -39,22 +50,22 @@ const getStateDisplay = (current) => {
     return found ? { emoji: found.emoji, name: found.name } : undefined;
 };
 /**
- * Processes one EC2 instance: describes state, issues start/stop when needed, then polls until
+ * Processes one EC2 instance: describes state, issues start/stop when needed, then waits until
  * {@link isDesiredStableState} is satisfied (durable `step` / `wait` between attempts).
  *
- * Each loop iteration checks {@link getPollingAbortReason} before describe. Failures use
- * {@link formatResourcePollingFailure} (`ResourcePollingFailed:*` message prefix).
+ * Each loop iteration checks {@link getWaitAbortReason} before describe. Failures use
+ * {@link formatResourceWaitFailure} (`ResourceWaitFailed:*` message prefix).
  *
  * @param ctx - Durable execution context (child context per instance recommended).
  * @param targetResource - EC2 instance ARN.
  * @param params - Scheduler params (`TagKey`, `TagValues`, `Mode`).
  * @param resourceIndex - Index used in durable step names for this resource.
- * @param pollingLimits - Per-instance caps from {@link parseResourcePollingLimitsFromEnv} (set by the CDK construct).
+ * @param waitLimits - Per-instance caps from {@link parseResourceWaitLimitsFromEnv} (set by the CDK construct).
  * @returns Final resource ARN, EC2 state name, parsed account, region, and instance id.
- * @throws {Error} When polling limits are exceeded (`MaxLoopCountExceeded`, `MaxElapsedTimeExceeded`),
+ * @throws {Error} When wait limits are exceeded (`MaxLoopCountExceeded`, `MaxElapsedTimeExceeded`),
  *   the instance is in an unexpected state (`UnexpectedInstanceState`), or the loop exits without a stable goal state.
  */
-const processOneResource = async (ctx, targetResource, params, resourceIndex, pollingLimits) => {
+const processOneResource = async (ctx, targetResource, params, resourceIndex, waitLimits) => {
     const parts = targetResource.split('/');
     const identifier = parts[parts.length - 1] ?? 'unknown';
     const arnParts = targetResource.split(':');
@@ -67,29 +78,29 @@ const processOneResource = async (ctx, targetResource, params, resourceIndex, po
         region,
         account,
         mode: params.Mode,
-        maxLoopCount: pollingLimits.maxLoopCount,
-        maxElapsedSeconds: pollingLimits.maxElapsedSeconds,
+        maxLoopCount: waitLimits.maxLoopCount,
+        maxElapsedSeconds: waitLimits.maxElapsedSeconds,
     });
-    const startedAtMs = await ctx.step(`${stepPrefix}-polling-started-at`, async () => Date.now());
+    const startedAtMs = await ctx.step(`${stepPrefix}-wait-started-at`, async () => Date.now());
     let loopCount = 0;
     let currentState = '';
     do {
-        const abortReason = await ctx.step(`${stepPrefix}-poll-limit-check-${loopCount}`, async () => (0, running_scheduler_predicates_1.getPollingAbortReason)(loopCount, startedAtMs, Date.now(), pollingLimits));
+        const abortReason = await ctx.step(`${stepPrefix}-wait-limit-check-${loopCount}`, async () => (0, running_scheduler_predicates_1.getWaitAbortReason)(loopCount, startedAtMs, Date.now(), waitLimits));
         if (abortReason) {
-            const message = (0, running_scheduler_predicates_1.formatResourcePollingFailure)(abortReason, {
+            const message = (0, running_scheduler_predicates_1.formatResourceWaitFailure)(abortReason, {
                 identifier,
                 mode: params.Mode,
                 currentState: currentState || 'unknown',
                 loopCount,
-                limits: pollingLimits,
+                limits: waitLimits,
             });
-            ctx.logger.error('processOneResource: polling limit exceeded', {
+            ctx.logger.error('processOneResource: wait limit exceeded', {
                 identifier,
                 abortReason,
                 loopCount,
                 currentState,
-                maxLoopCount: pollingLimits.maxLoopCount,
-                maxElapsedSeconds: pollingLimits.maxElapsedSeconds,
+                maxLoopCount: waitLimits.maxLoopCount,
+                maxElapsedSeconds: waitLimits.maxElapsedSeconds,
             });
             throw new Error(message);
         }
@@ -146,12 +157,12 @@ const processOneResource = async (ctx, targetResource, params, resourceIndex, po
                 loopCount += 1;
                 continue;
             }
-            const message = (0, running_scheduler_predicates_1.formatResourcePollingFailure)('UnexpectedInstanceState', {
+            const message = (0, running_scheduler_predicates_1.formatResourceWaitFailure)('UnexpectedInstanceState', {
                 identifier,
                 mode,
                 currentState,
                 loopCount,
-                limits: pollingLimits,
+                limits: waitLimits,
             });
             ctx.logger.error('processOneResource: unexpected state', {
                 identifier,
@@ -183,16 +194,23 @@ const processOneResource = async (ctx, targetResource, params, resourceIndex, po
  * in parallel (bounded concurrency), posts a parent Slack message and per-instance thread replies,
  * and uses durable `step` / `wait` / `map` so the run can resume across suspensions.
  *
- * Reads per-instance polling limits from `PROCESS_RESOURCE_MAX_LOOP_COUNT` and
- * `PROCESS_RESOURCE_MAX_ELAPSED_SECONDS` via {@link parseResourcePollingLimitsFromEnv}.
+ * Reads per-instance wait limits from `PROCESS_RESOURCE_MAX_LOOP_COUNT` and
+ * `PROCESS_RESOURCE_MAX_ELAPSED_SECONDS` via {@link parseResourceWaitLimitsFromEnv}.
+ * Loads the Slack secret via {@link secretFetcher} (Parameters and Secrets Lambda Extension).
+ * Slack API failures are logged as `running-scheduler: Slack post failed` for CloudWatch log filters.
  *
  * @param event - Payload from EventBridge Scheduler; must include `Params.TagKey`, `Params.TagValues`, `Params.Mode`.
  * @param ctx - Root durable execution context.
  * @returns
  * - `{ status: 'TargetResourcesNotFound' }` when no instances match the tag filter.
  * - `{ status: 'Completed', processed, results }` when instances were handled (`results` entries match {@link processOneResource} return shape).
- * @throws {Error} If `Params` is invalid, polling env vars are invalid, `SLACK_SECRET_NAME` is unset,
- *   the Slack secret is incomplete, or instance processing fails (including `ResourcePollingFailed:*` errors).
+ * @throws {Error} If `Params` is invalid, wait env vars are not positive integers,
+ *   the Slack secret is incomplete, instance processing fails (including `ResourceWaitFailed:*` errors),
+ *   or the secret cannot be read from the extension (e.g. outside Lambda or missing `AWS_SESSION_TOKEN`).
+ * @throws {import('strict-env-resolver').StrictEnvValidationError} When required env vars are missing or not valid numbers.
+ * @throws {import('fetch-retrier').FetchRetrierHttpError} When the extension returns a non-retriable HTTP error.
+ * @throws {import('fetch-retrier').FetchRetrierNetworkError} When extension requests fail at the network level.
+ * @throws {import('fetch-retrier').FetchRetrierAbortError} When extension requests time out after all retries.
  */
 exports.handler = (0, durable_execution_sdk_js_1.withDurableExecution)(async (event, ctx) => {
     const params = event.Params;
@@ -204,12 +222,11 @@ exports.handler = (0, durable_execution_sdk_js_1.withDurableExecution)(async (ev
     if (!params?.TagKey || !params?.TagValues || !params?.Mode) {
         throw new Error('Invalid event: Params.TagKey, Params.TagValues, Params.Mode are required.');
     }
-    const pollingLimits = (0, running_scheduler_polling_env_1.parseResourcePollingLimitsFromEnv)();
-    // safe get Secrets name from environment variable
-    const slackSecretName = safe_env_getter_1.SafeEnvGetter.getEnv('SLACK_SECRET_NAME');
+    const waitLimits = (0, running_scheduler_wait_env_1.parseResourceWaitLimitsFromEnv)();
+    const slackSecretName = strict_env_resolver_1.StrictEnvResolver.resolve('SLACK_SECRET_NAME', strict_env_resolver_1.StrictEnvType.String);
     const slackSecretValue = await ctx.step('fetch-slack-secret', async () => {
         ctx.logger.info('running-scheduler: fetching Slack secret', { secretName: slackSecretName });
-        return aws_lambda_secret_fetcher_1.secretFetcher.getSecretValue(slackSecretName);
+        return aws_lambda_secret_fetcher_1.secretFetcher.getSecretValue(slackSecretName, SLACK_SECRET_FETCH_OPTIONS);
     });
     ctx.logger.info('running-scheduler: Slack secret loaded');
     if (!slackSecretValue?.token || !slackSecretValue?.channel) {
@@ -238,10 +255,20 @@ exports.handler = (0, durable_execution_sdk_js_1.withDurableExecution)(async (ev
     });
     // send slack message
     const slackParentMessageResult = await ctx.step('post-slack-messages', async () => {
-        return client.chat.postMessage({
-            channel,
-            text: `${params.Mode === 'Start' ? '😆 Starts' : '🥱 Stops'} the scheduled EC2 Instance.`,
-        });
+        try {
+            return await client.chat.postMessage({
+                channel,
+                text: `${params.Mode === 'Start' ? '😆 Starts' : '🥱 Stops'} the scheduled EC2 Instance.`,
+            });
+        }
+        catch (error) {
+            ctx.logger.error('running-scheduler: Slack post failed', {
+                step: 'post-slack-messages',
+                channel,
+                errorMessage: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
     });
     ctx.logger.info('running-scheduler: parent Slack message posted', {
         threadTs: slackParentMessageResult?.ts ?? null,
@@ -257,7 +284,7 @@ exports.handler = (0, durable_execution_sdk_js_1.withDurableExecution)(async (ev
     //   ),
     async (mapCtx, targetResource, index) => {
         return mapCtx.runInChildContext(`resource-${index}`, async (childCtx) => {
-            const result = await processOneResource(childCtx, targetResource, params, index, pollingLimits);
+            const result = await processOneResource(childCtx, targetResource, params, index, waitLimits);
             // if (result.status === 'skipped') {
             //   return result;
             // }
@@ -269,22 +296,33 @@ exports.handler = (0, durable_execution_sdk_js_1.withDurableExecution)(async (ev
             // send slack thread message
             await childCtx.step('post-slack-child-messages', async () => {
                 const display = getStateDisplay(result.status);
-                return client.chat.postMessage({
-                    channel,
-                    thread_ts: slackParentMessageResult?.ts,
-                    attachments: [
-                        {
-                            color: '#36a64f',
-                            pretext: `${display?.emoji} The status of the EC2 Instance ${result.identifier} changed to ${display?.name} due to the schedule.`,
-                            fields: [
-                                { title: 'Account', value: result.account, short: true },
-                                { title: 'Region', value: result.region, short: true },
-                                { title: 'Identifier', value: result.identifier, short: true },
-                                { title: 'Status', value: (display?.name ?? 'Unknown'), short: true },
-                            ],
-                        },
-                    ],
-                });
+                try {
+                    return await client.chat.postMessage({
+                        channel,
+                        thread_ts: slackParentMessageResult?.ts,
+                        attachments: [
+                            {
+                                color: '#36a64f',
+                                pretext: `${display?.emoji} The status of the EC2 Instance ${result.identifier} changed to ${display?.name} due to the schedule.`,
+                                fields: [
+                                    { title: 'Account', value: result.account, short: true },
+                                    { title: 'Region', value: result.region, short: true },
+                                    { title: 'Identifier', value: result.identifier, short: true },
+                                    { title: 'Status', value: (display?.name ?? 'Unknown'), short: true },
+                                ],
+                            },
+                        ],
+                    });
+                }
+                catch (error) {
+                    childCtx.logger.error('running-scheduler: Slack post failed', {
+                        step: 'post-slack-child-messages',
+                        channel,
+                        identifier: result.identifier,
+                        errorMessage: error instanceof Error ? error.message : String(error),
+                    });
+                    throw error;
+                }
             });
             return result;
         });
@@ -300,4 +338,4 @@ exports.handler = (0, durable_execution_sdk_js_1.withDurableExecution)(async (ev
         results: resultList,
     };
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"running-scheduler.lambda.js","sourceRoot":"","sources":["../../src/funcs/running-scheduler.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * EC2 Running Scheduler – Durable Functions implementation.\n *\n * Implements the running-control flow using AWS Lambda Durable Execution.\n * Step checkpoints, wait (no charge), and parallel map provide a flow equivalent to Step Functions.\n *\n * @see https://docs.aws.amazon.com/lambda/latest/dg/durable-execution-sdk.html\n */\n\nimport { withDurableExecution, type DurableContext } from '@aws/durable-execution-sdk-js';\nimport {\n  EC2Client,\n  DescribeInstancesCommand,\n  StartInstancesCommand,\n  StopInstancesCommand,\n} from '@aws-sdk/client-ec2';\nimport { GetResourcesCommand, ResourceGroupsTaggingAPIClient } from '@aws-sdk/client-resource-groups-tagging-api';\nimport { WebClient } from '@slack/web-api';\nimport { secretFetcher } from 'aws-lambda-secret-fetcher';\nimport { SafeEnvGetter } from 'safe-env-getter';\nimport { parseResourcePollingLimitsFromEnv } from './running-scheduler-polling-env';\nimport {\n  formatResourcePollingFailure,\n  getPollingAbortReason,\n  isDesiredStableState,\n  isTransitioningState,\n  type ResourcePollingLimits,\n} from './running-scheduler-predicates';\n\n/** Mapping of EC2 instance state to display name and emoji for Slack. */\nconst STATE_LIST = [\n  { name: 'RUNNING', emoji: '😆', state: 'running' },\n  { name: 'STOPPED', emoji: '😴', state: 'stopped' },\n] as const;\n\n/**\n * Seconds to wait between polling instance state after start/stop or while transitioning.\n *\n * Used with {@link processOneResource} durable `wait` calls between describe iterations.\n */\nconst STATUS_CHANGE_WAIT_SECONDS = 20;\n\n/**\n * Event payload from EventBridge Scheduler invoking this Lambda.\n *\n * @see {@link handler}\n */\nexport interface SchedulerEvent {\n  /** Scheduler invocation parameters (tag filter and start/stop mode). */\n  Params: {\n    /** Tag key used to select EC2 instances. */\n    TagKey: string;\n    /** Tag values to match. */\n    TagValues: string[];\n    /** Whether to start or stop instances. */\n    Mode: 'Start' | 'Stop';\n  };\n}\n\n/** Slack credentials and default channel loaded from Secrets Manager (`SLACK_SECRET_NAME`). */\ninterface SlackSecret {\n  /** Slack bot token for the Slack `WebClient`. */\n  token: string;\n  /** Channel ID or name passed to `chat.postMessage`. */\n  channel: string;\n}\n\n/**\n * Returns display name and emoji for an EC2 instance state.\n *\n * @param current - Current instance state (e.g. 'running', 'stopped').\n * @returns Display info or undefined if state is not in STATE_LIST.\n */\nconst getStateDisplay = (current: string): { emoji: string; name: string } | undefined => {\n  const found = STATE_LIST.find((s) => s.state === current);\n  return found ? { emoji: found.emoji, name: found.name } : undefined;\n};\n\n/**\n * Processes one EC2 instance: describes state, issues start/stop when needed, then polls until\n * {@link isDesiredStableState} is satisfied (durable `step` / `wait` between attempts).\n *\n * Each loop iteration checks {@link getPollingAbortReason} before describe. Failures use\n * {@link formatResourcePollingFailure} (`ResourcePollingFailed:*` message prefix).\n *\n * @param ctx - Durable execution context (child context per instance recommended).\n * @param targetResource - EC2 instance ARN.\n * @param params - Scheduler params (`TagKey`, `TagValues`, `Mode`).\n * @param resourceIndex - Index used in durable step names for this resource.\n * @param pollingLimits - Per-instance caps from {@link parseResourcePollingLimitsFromEnv} (set by the CDK construct).\n * @returns Final resource ARN, EC2 state name, parsed account, region, and instance id.\n * @throws {Error} When polling limits are exceeded (`MaxLoopCountExceeded`, `MaxElapsedTimeExceeded`),\n *   the instance is in an unexpected state (`UnexpectedInstanceState`), or the loop exits without a stable goal state.\n */\nconst processOneResource = async (\n  ctx: DurableContext,\n  targetResource: string,\n  params: SchedulerEvent['Params'],\n  resourceIndex: number,\n  pollingLimits: ResourcePollingLimits,\n): Promise<{ resource: string; status: string; account: string; region: string; identifier: string }> => {\n  const parts = targetResource.split('/');\n  const identifier = parts[parts.length - 1] ?? 'unknown';\n  const arnParts = targetResource.split(':');\n  const account = arnParts[4] ?? '';\n  const region = arnParts[3] ?? '';\n  const stepPrefix = `resource-${resourceIndex}-${identifier}`;\n\n  ctx.logger.info('processOneResource: start', {\n    resourceIndex,\n    identifier,\n    region,\n    account,\n    mode: params.Mode,\n    maxLoopCount: pollingLimits.maxLoopCount,\n    maxElapsedSeconds: pollingLimits.maxElapsedSeconds,\n  });\n\n  const startedAtMs = await ctx.step(`${stepPrefix}-polling-started-at`, async () => Date.now());\n\n  let loopCount = 0;\n  let currentState = '';\n  do {\n    const abortReason = await ctx.step(`${stepPrefix}-poll-limit-check-${loopCount}`, async () =>\n      getPollingAbortReason(loopCount, startedAtMs, Date.now(), pollingLimits),\n    );\n    if (abortReason) {\n      const message = formatResourcePollingFailure(abortReason, {\n        identifier,\n        mode: params.Mode,\n        currentState: currentState || 'unknown',\n        loopCount,\n        limits: pollingLimits,\n      });\n      ctx.logger.error('processOneResource: polling limit exceeded', {\n        identifier,\n        abortReason,\n        loopCount,\n        currentState,\n        maxLoopCount: pollingLimits.maxLoopCount,\n        maxElapsedSeconds: pollingLimits.maxElapsedSeconds,\n      });\n      throw new Error(message);\n    }\n\n    currentState = await ctx.step(`${stepPrefix}-describe-${loopCount}`, async () => {\n      const ec2 = new EC2Client({});\n      const out = await ec2.send(new DescribeInstancesCommand({ InstanceIds: [identifier] }));\n      return out.Reservations?.[0]?.Instances?.[0]?.State?.Name ?? 'unknown';\n    });\n\n    ctx.logger.info('processOneResource: described', {\n      identifier,\n      loopCount,\n      currentState,\n      mode: params.Mode,\n    });\n\n    const mode = params.Mode;\n\n    if (mode === 'Start' && currentState === 'stopped') {\n      ctx.logger.info('processOneResource: starting instance', { identifier, loopCount });\n      await ctx.step(`${stepPrefix}-start-${loopCount}`, async () => {\n        const ec2 = new EC2Client({});\n        await ec2.send(new StartInstancesCommand({ InstanceIds: [identifier] }));\n      });\n      ctx.logger.info('processOneResource: wait after start', {\n        identifier,\n        seconds: STATUS_CHANGE_WAIT_SECONDS,\n      });\n      await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });\n      loopCount += 1;\n      continue;\n    }\n\n    if (mode === 'Stop' && currentState === 'running') {\n      ctx.logger.info('processOneResource: stopping instance', { identifier, loopCount });\n      await ctx.step(`${stepPrefix}-stop-${loopCount}`, async () => {\n        const ec2 = new EC2Client({});\n        await ec2.send(new StopInstancesCommand({ InstanceIds: [identifier] }));\n      });\n      ctx.logger.info('processOneResource: wait after stop', {\n        identifier,\n        seconds: STATUS_CHANGE_WAIT_SECONDS,\n      });\n      await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });\n      loopCount += 1;\n      continue;\n    }\n\n    if (!isDesiredStableState(mode, currentState)) {\n      if (isTransitioningState(mode, currentState)) {\n        ctx.logger.info('processOneResource: wait while transitioning', {\n          identifier,\n          loopCount,\n          currentState,\n          mode,\n          seconds: STATUS_CHANGE_WAIT_SECONDS,\n        });\n        await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });\n        loopCount += 1;\n        continue;\n      }\n\n      const message = formatResourcePollingFailure('UnexpectedInstanceState', {\n        identifier,\n        mode,\n        currentState,\n        loopCount,\n        limits: pollingLimits,\n      });\n      ctx.logger.error('processOneResource: unexpected state', {\n        identifier,\n        mode,\n        currentState,\n        loopCount,\n      });\n      throw new Error(message);\n    }\n  } while (!isDesiredStableState(params.Mode, currentState));\n\n  ctx.logger.info('processOneResource: reached desired stable state', {\n    identifier,\n    finalState: currentState,\n    mode: params.Mode,\n    loopCount,\n  });\n\n  return {\n    identifier,\n    account,\n    region,\n    resource: targetResource,\n    status: currentState,\n  };\n};\n\n/**\n * Durable Lambda entry point for the EC2 running scheduler.\n *\n * Resolves instances via Resource Groups Tagging API, runs {@link processOneResource} for each ARN\n * in parallel (bounded concurrency), posts a parent Slack message and per-instance thread replies,\n * and uses durable `step` / `wait` / `map` so the run can resume across suspensions.\n *\n * Reads per-instance polling limits from `PROCESS_RESOURCE_MAX_LOOP_COUNT` and\n * `PROCESS_RESOURCE_MAX_ELAPSED_SECONDS` via {@link parseResourcePollingLimitsFromEnv}.\n *\n * @param event - Payload from EventBridge Scheduler; must include `Params.TagKey`, `Params.TagValues`, `Params.Mode`.\n * @param ctx - Root durable execution context.\n * @returns\n * - `{ status: 'TargetResourcesNotFound' }` when no instances match the tag filter.\n * - `{ status: 'Completed', processed, results }` when instances were handled (`results` entries match {@link processOneResource} return shape).\n * @throws {Error} If `Params` is invalid, polling env vars are invalid, `SLACK_SECRET_NAME` is unset,\n *   the Slack secret is incomplete, or instance processing fails (including `ResourcePollingFailed:*` errors).\n */\nexport const handler = withDurableExecution(async (event: SchedulerEvent, ctx: DurableContext) => {\n\n  const params = event.Params;\n\n  ctx.logger.info('running-scheduler: invocation', {\n    mode: params?.Mode,\n    tagKey: params?.TagKey,\n    tagValueCount: params?.TagValues?.length ?? 0,\n  });\n\n  if (!params?.TagKey || !params?.TagValues || !params?.Mode) {\n    throw new Error('Invalid event: Params.TagKey, Params.TagValues, Params.Mode are required.');\n  }\n\n  const pollingLimits = parseResourcePollingLimitsFromEnv();\n\n  // safe get Secrets name from environment variable\n  const slackSecretName = SafeEnvGetter.getEnv('SLACK_SECRET_NAME');\n\n  const slackSecretValue = await ctx.step('fetch-slack-secret', async () => {\n    ctx.logger.info('running-scheduler: fetching Slack secret', { secretName: slackSecretName });\n    return secretFetcher.getSecretValue<SlackSecret>(slackSecretName);\n  });\n\n  ctx.logger.info('running-scheduler: Slack secret loaded');\n\n  if (!slackSecretValue?.token || !slackSecretValue?.channel) {\n    throw new Error('Slack secret must contain token and channel.');\n  }\n\n  const targetResources = await ctx.step('get-target-resources', async () => {\n    const client = new ResourceGroupsTaggingAPIClient({});\n    const result = await client.send(\n      new GetResourcesCommand({\n        ResourceTypeFilters: ['ec2:instance'],\n        TagFilters: [{ Key: params.TagKey, Values: params.TagValues }],\n      }),\n    );\n    const arns = (result.ResourceTagMappingList ?? [])\n      .map((m: { ResourceARN?: string }) => m.ResourceARN)\n      .filter((arn: string | undefined): arn is string => arn != null);\n    ctx.logger.info('running-scheduler: get-target-resources done', { count: arns.length });\n    return arns;\n  });\n\n  if (targetResources.length === 0) {\n    ctx.logger.info('running-scheduler: no matching instances', { tagKey: params.TagKey });\n    return { status: 'TargetResourcesNotFound' as const };\n  }\n\n  const client = new WebClient(slackSecretValue.token);\n  const channel = slackSecretValue.channel;\n\n  ctx.logger.info('running-scheduler: posting parent Slack message', {\n    instanceCount: targetResources.length,\n  });\n\n  // send slack message\n  const slackParentMessageResult = await ctx.step('post-slack-messages', async () => {\n    return client.chat.postMessage({\n      channel,\n      text: `${params.Mode === 'Start' ? '😆 Starts' : '🥱 Stops'} the scheduled EC2 Instance.`,\n    });\n  });\n\n  ctx.logger.info('running-scheduler: parent Slack message posted', {\n    threadTs: slackParentMessageResult?.ts ?? null,\n  });\n\n  ctx.logger.info('running-scheduler: starting parallel instance processing', {\n    count: targetResources.length,\n    maxConcurrency: 10,\n  });\n\n  const results = await ctx.map(\n    targetResources,\n    // async (ctx: DurableContext, targetResource: string, index: number) =>\n    //   ctx.step(`process-resource-${index}`, async () =>\n    //     processOneResource(ctx, targetResource, params, index),\n    //   ),\n    async (mapCtx: DurableContext, targetResource: string, index: number) => {\n      return mapCtx.runInChildContext(`resource-${index}`, async (childCtx: DurableContext) => {\n        const result = await processOneResource(childCtx, targetResource, params, index, pollingLimits);\n        // if (result.status === 'skipped') {\n        //   return result;\n        // }\n        childCtx.logger.info('running-scheduler: posting thread Slack message', {\n          index,\n          identifier: result.identifier,\n          status: result.status,\n        });\n        // send slack thread message\n        await childCtx.step('post-slack-child-messages', async () => {\n          const display = getStateDisplay(result.status);\n\n          return client.chat.postMessage({\n            channel,\n            thread_ts: slackParentMessageResult?.ts,\n            attachments: [\n              {\n                color: '#36a64f',\n                pretext: `${display?.emoji} The status of the EC2 Instance ${result.identifier} changed to ${display?.name} due to the schedule.`,\n                fields: [\n                  { title: 'Account', value: result.account, short: true },\n                  { title: 'Region', value: result.region, short: true },\n                  { title: 'Identifier', value: result.identifier, short: true },\n                  { title: 'Status', value: (display?.name ?? 'Unknown'), short: true },\n                ],\n              },\n            ],\n          });\n        });\n        return result;\n      });\n    },\n    { maxConcurrency: 10 },\n  );\n\n  const resultList = Array.isArray(results) ? results : [];\n  ctx.logger.info('running-scheduler: completed', {\n    processed: targetResources.length,\n    resultCount: resultList.length,\n  });\n  return {\n    status: 'Completed' as const,\n    processed: targetResources.length,\n    results: resultList,\n  };\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"running-scheduler.lambda.js","sourceRoot":"","sources":["../../src/funcs/running-scheduler.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * EC2 Running Scheduler – Durable Functions implementation.\n *\n * Implements the running-control flow using AWS Lambda Durable Execution.\n * Step checkpoints, wait (no charge), and parallel map provide a flow equivalent to Step Functions.\n *\n * @see https://docs.aws.amazon.com/lambda/latest/dg/durable-execution-sdk.html\n */\n\nimport { withDurableExecution, type DurableContext } from '@aws/durable-execution-sdk-js';\nimport {\n  EC2Client,\n  DescribeInstancesCommand,\n  StartInstancesCommand,\n  StopInstancesCommand,\n} from '@aws-sdk/client-ec2';\nimport { GetResourcesCommand, ResourceGroupsTaggingAPIClient } from '@aws-sdk/client-resource-groups-tagging-api';\nimport { WebClient } from '@slack/web-api';\nimport { secretFetcher, type GetSecretValueOptions } from 'aws-lambda-secret-fetcher';\nimport { StrictEnvResolver, StrictEnvType } from 'strict-env-resolver';\nimport {\n  formatResourceWaitFailure,\n  getWaitAbortReason,\n  isDesiredStableState,\n  isTransitioningState,\n  type ResourceWaitLimits,\n} from './running-scheduler-predicates';\nimport { parseResourceWaitLimitsFromEnv } from './running-scheduler-wait-env';\n\n/** Mapping of EC2 instance state to display name and emoji for Slack. */\nconst STATE_LIST = [\n  { name: 'RUNNING', emoji: '😆', state: 'running' },\n  { name: 'STOPPED', emoji: '😴', state: 'stopped' },\n] as const;\n\n/**\n * Seconds to wait between describe iterations after start/stop or while transitioning.\n *\n * Used with {@link processOneResource} durable `wait` calls between describe iterations.\n */\nconst STATUS_CHANGE_WAIT_SECONDS = 20;\n\n/**\n * Options passed to {@link secretFetcher.getSecretValue} when loading the Slack secret.\n *\n * Retries cover transient extension HTTP errors (5xx, 429) and the extension\n * \"not ready to serve traffic\" response during cold starts.\n */\nconst SLACK_SECRET_FETCH_OPTIONS: GetSecretValueOptions = {\n  timeoutMs: 3000,\n  retries: 5,\n  baseBackoffMs: 300,\n};\n\n/**\n * Event payload from EventBridge Scheduler invoking this Lambda.\n *\n * @see {@link handler}\n */\nexport interface SchedulerEvent {\n  /** Scheduler invocation parameters (tag filter and start/stop mode). */\n  Params: {\n    /** Tag key used to select EC2 instances. */\n    TagKey: string;\n    /** Tag values to match. */\n    TagValues: string[];\n    /** Whether to start or stop instances. */\n    Mode: 'Start' | 'Stop';\n  };\n}\n\n/** Slack credentials and default channel loaded from Secrets Manager (`SLACK_SECRET_NAME`). */\ninterface SlackSecret {\n  /** Slack bot token for the Slack `WebClient`. */\n  token: string;\n  /** Channel ID or name passed to `chat.postMessage`. */\n  channel: string;\n}\n\n/**\n * Returns display name and emoji for an EC2 instance state.\n *\n * @param current - Current instance state (e.g. 'running', 'stopped').\n * @returns Display info or undefined if state is not in STATE_LIST.\n */\nconst getStateDisplay = (current: string): { emoji: string; name: string } | undefined => {\n  const found = STATE_LIST.find((s) => s.state === current);\n  return found ? { emoji: found.emoji, name: found.name } : undefined;\n};\n\n/**\n * Processes one EC2 instance: describes state, issues start/stop when needed, then waits until\n * {@link isDesiredStableState} is satisfied (durable `step` / `wait` between attempts).\n *\n * Each loop iteration checks {@link getWaitAbortReason} before describe. Failures use\n * {@link formatResourceWaitFailure} (`ResourceWaitFailed:*` message prefix).\n *\n * @param ctx - Durable execution context (child context per instance recommended).\n * @param targetResource - EC2 instance ARN.\n * @param params - Scheduler params (`TagKey`, `TagValues`, `Mode`).\n * @param resourceIndex - Index used in durable step names for this resource.\n * @param waitLimits - Per-instance caps from {@link parseResourceWaitLimitsFromEnv} (set by the CDK construct).\n * @returns Final resource ARN, EC2 state name, parsed account, region, and instance id.\n * @throws {Error} When wait limits are exceeded (`MaxLoopCountExceeded`, `MaxElapsedTimeExceeded`),\n *   the instance is in an unexpected state (`UnexpectedInstanceState`), or the loop exits without a stable goal state.\n */\nconst processOneResource = async (\n  ctx: DurableContext,\n  targetResource: string,\n  params: SchedulerEvent['Params'],\n  resourceIndex: number,\n  waitLimits: ResourceWaitLimits,\n): Promise<{ resource: string; status: string; account: string; region: string; identifier: string }> => {\n  const parts = targetResource.split('/');\n  const identifier = parts[parts.length - 1] ?? 'unknown';\n  const arnParts = targetResource.split(':');\n  const account = arnParts[4] ?? '';\n  const region = arnParts[3] ?? '';\n  const stepPrefix = `resource-${resourceIndex}-${identifier}`;\n\n  ctx.logger.info('processOneResource: start', {\n    resourceIndex,\n    identifier,\n    region,\n    account,\n    mode: params.Mode,\n    maxLoopCount: waitLimits.maxLoopCount,\n    maxElapsedSeconds: waitLimits.maxElapsedSeconds,\n  });\n\n  const startedAtMs = await ctx.step(`${stepPrefix}-wait-started-at`, async () => Date.now());\n\n  let loopCount = 0;\n  let currentState = '';\n  do {\n    const abortReason = await ctx.step(`${stepPrefix}-wait-limit-check-${loopCount}`, async () =>\n      getWaitAbortReason(loopCount, startedAtMs, Date.now(), waitLimits),\n    );\n    if (abortReason) {\n      const message = formatResourceWaitFailure(abortReason, {\n        identifier,\n        mode: params.Mode,\n        currentState: currentState || 'unknown',\n        loopCount,\n        limits: waitLimits,\n      });\n      ctx.logger.error('processOneResource: wait limit exceeded', {\n        identifier,\n        abortReason,\n        loopCount,\n        currentState,\n        maxLoopCount: waitLimits.maxLoopCount,\n        maxElapsedSeconds: waitLimits.maxElapsedSeconds,\n      });\n      throw new Error(message);\n    }\n\n    currentState = await ctx.step(`${stepPrefix}-describe-${loopCount}`, async () => {\n      const ec2 = new EC2Client({});\n      const out = await ec2.send(new DescribeInstancesCommand({ InstanceIds: [identifier] }));\n      return out.Reservations?.[0]?.Instances?.[0]?.State?.Name ?? 'unknown';\n    });\n\n    ctx.logger.info('processOneResource: described', {\n      identifier,\n      loopCount,\n      currentState,\n      mode: params.Mode,\n    });\n\n    const mode = params.Mode;\n\n    if (mode === 'Start' && currentState === 'stopped') {\n      ctx.logger.info('processOneResource: starting instance', { identifier, loopCount });\n      await ctx.step(`${stepPrefix}-start-${loopCount}`, async () => {\n        const ec2 = new EC2Client({});\n        await ec2.send(new StartInstancesCommand({ InstanceIds: [identifier] }));\n      });\n      ctx.logger.info('processOneResource: wait after start', {\n        identifier,\n        seconds: STATUS_CHANGE_WAIT_SECONDS,\n      });\n      await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });\n      loopCount += 1;\n      continue;\n    }\n\n    if (mode === 'Stop' && currentState === 'running') {\n      ctx.logger.info('processOneResource: stopping instance', { identifier, loopCount });\n      await ctx.step(`${stepPrefix}-stop-${loopCount}`, async () => {\n        const ec2 = new EC2Client({});\n        await ec2.send(new StopInstancesCommand({ InstanceIds: [identifier] }));\n      });\n      ctx.logger.info('processOneResource: wait after stop', {\n        identifier,\n        seconds: STATUS_CHANGE_WAIT_SECONDS,\n      });\n      await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });\n      loopCount += 1;\n      continue;\n    }\n\n    if (!isDesiredStableState(mode, currentState)) {\n      if (isTransitioningState(mode, currentState)) {\n        ctx.logger.info('processOneResource: wait while transitioning', {\n          identifier,\n          loopCount,\n          currentState,\n          mode,\n          seconds: STATUS_CHANGE_WAIT_SECONDS,\n        });\n        await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });\n        loopCount += 1;\n        continue;\n      }\n\n      const message = formatResourceWaitFailure('UnexpectedInstanceState', {\n        identifier,\n        mode,\n        currentState,\n        loopCount,\n        limits: waitLimits,\n      });\n      ctx.logger.error('processOneResource: unexpected state', {\n        identifier,\n        mode,\n        currentState,\n        loopCount,\n      });\n      throw new Error(message);\n    }\n  } while (!isDesiredStableState(params.Mode, currentState));\n\n  ctx.logger.info('processOneResource: reached desired stable state', {\n    identifier,\n    finalState: currentState,\n    mode: params.Mode,\n    loopCount,\n  });\n\n  return {\n    identifier,\n    account,\n    region,\n    resource: targetResource,\n    status: currentState,\n  };\n};\n\n/**\n * Durable Lambda entry point for the EC2 running scheduler.\n *\n * Resolves instances via Resource Groups Tagging API, runs {@link processOneResource} for each ARN\n * in parallel (bounded concurrency), posts a parent Slack message and per-instance thread replies,\n * and uses durable `step` / `wait` / `map` so the run can resume across suspensions.\n *\n * Reads per-instance wait limits from `PROCESS_RESOURCE_MAX_LOOP_COUNT` and\n * `PROCESS_RESOURCE_MAX_ELAPSED_SECONDS` via {@link parseResourceWaitLimitsFromEnv}.\n * Loads the Slack secret via {@link secretFetcher} (Parameters and Secrets Lambda Extension).\n * Slack API failures are logged as `running-scheduler: Slack post failed` for CloudWatch log filters.\n *\n * @param event - Payload from EventBridge Scheduler; must include `Params.TagKey`, `Params.TagValues`, `Params.Mode`.\n * @param ctx - Root durable execution context.\n * @returns\n * - `{ status: 'TargetResourcesNotFound' }` when no instances match the tag filter.\n * - `{ status: 'Completed', processed, results }` when instances were handled (`results` entries match {@link processOneResource} return shape).\n * @throws {Error} If `Params` is invalid, wait env vars are not positive integers,\n *   the Slack secret is incomplete, instance processing fails (including `ResourceWaitFailed:*` errors),\n *   or the secret cannot be read from the extension (e.g. outside Lambda or missing `AWS_SESSION_TOKEN`).\n * @throws {import('strict-env-resolver').StrictEnvValidationError} When required env vars are missing or not valid numbers.\n * @throws {import('fetch-retrier').FetchRetrierHttpError} When the extension returns a non-retriable HTTP error.\n * @throws {import('fetch-retrier').FetchRetrierNetworkError} When extension requests fail at the network level.\n * @throws {import('fetch-retrier').FetchRetrierAbortError} When extension requests time out after all retries.\n */\nexport const handler = withDurableExecution(async (event: SchedulerEvent, ctx: DurableContext) => {\n\n  const params = event.Params;\n\n  ctx.logger.info('running-scheduler: invocation', {\n    mode: params?.Mode,\n    tagKey: params?.TagKey,\n    tagValueCount: params?.TagValues?.length ?? 0,\n  });\n\n  if (!params?.TagKey || !params?.TagValues || !params?.Mode) {\n    throw new Error('Invalid event: Params.TagKey, Params.TagValues, Params.Mode are required.');\n  }\n\n  const waitLimits = parseResourceWaitLimitsFromEnv();\n\n  const slackSecretName = StrictEnvResolver.resolve('SLACK_SECRET_NAME', StrictEnvType.String);\n\n  const slackSecretValue = await ctx.step('fetch-slack-secret', async () => {\n    ctx.logger.info('running-scheduler: fetching Slack secret', { secretName: slackSecretName });\n    return secretFetcher.getSecretValue<SlackSecret>(slackSecretName, SLACK_SECRET_FETCH_OPTIONS);\n  });\n\n  ctx.logger.info('running-scheduler: Slack secret loaded');\n\n  if (!slackSecretValue?.token || !slackSecretValue?.channel) {\n    throw new Error('Slack secret must contain token and channel.');\n  }\n\n  const targetResources = await ctx.step('get-target-resources', async () => {\n    const client = new ResourceGroupsTaggingAPIClient({});\n    const result = await client.send(\n      new GetResourcesCommand({\n        ResourceTypeFilters: ['ec2:instance'],\n        TagFilters: [{ Key: params.TagKey, Values: params.TagValues }],\n      }),\n    );\n    const arns = (result.ResourceTagMappingList ?? [])\n      .map((m: { ResourceARN?: string }) => m.ResourceARN)\n      .filter((arn: string | undefined): arn is string => arn != null);\n    ctx.logger.info('running-scheduler: get-target-resources done', { count: arns.length });\n    return arns;\n  });\n\n  if (targetResources.length === 0) {\n    ctx.logger.info('running-scheduler: no matching instances', { tagKey: params.TagKey });\n    return { status: 'TargetResourcesNotFound' as const };\n  }\n\n  const client = new WebClient(slackSecretValue.token);\n  const channel = slackSecretValue.channel;\n\n  ctx.logger.info('running-scheduler: posting parent Slack message', {\n    instanceCount: targetResources.length,\n  });\n\n  // send slack message\n  const slackParentMessageResult = await ctx.step('post-slack-messages', async () => {\n    try {\n      return await client.chat.postMessage({\n        channel,\n        text: `${params.Mode === 'Start' ? '😆 Starts' : '🥱 Stops'} the scheduled EC2 Instance.`,\n      });\n    } catch (error: unknown) {\n      ctx.logger.error('running-scheduler: Slack post failed', {\n        step: 'post-slack-messages',\n        channel,\n        errorMessage: error instanceof Error ? error.message : String(error),\n      });\n      throw error;\n    }\n  });\n\n  ctx.logger.info('running-scheduler: parent Slack message posted', {\n    threadTs: slackParentMessageResult?.ts ?? null,\n  });\n\n  ctx.logger.info('running-scheduler: starting parallel instance processing', {\n    count: targetResources.length,\n    maxConcurrency: 10,\n  });\n\n  const results = await ctx.map(\n    targetResources,\n    // async (ctx: DurableContext, targetResource: string, index: number) =>\n    //   ctx.step(`process-resource-${index}`, async () =>\n    //     processOneResource(ctx, targetResource, params, index),\n    //   ),\n    async (mapCtx: DurableContext, targetResource: string, index: number) => {\n      return mapCtx.runInChildContext(`resource-${index}`, async (childCtx: DurableContext) => {\n        const result = await processOneResource(childCtx, targetResource, params, index, waitLimits);\n        // if (result.status === 'skipped') {\n        //   return result;\n        // }\n        childCtx.logger.info('running-scheduler: posting thread Slack message', {\n          index,\n          identifier: result.identifier,\n          status: result.status,\n        });\n        // send slack thread message\n        await childCtx.step('post-slack-child-messages', async () => {\n          const display = getStateDisplay(result.status);\n\n          try {\n            return await client.chat.postMessage({\n              channel,\n              thread_ts: slackParentMessageResult?.ts,\n              attachments: [\n                {\n                  color: '#36a64f',\n                  pretext: `${display?.emoji} The status of the EC2 Instance ${result.identifier} changed to ${display?.name} due to the schedule.`,\n                  fields: [\n                    { title: 'Account', value: result.account, short: true },\n                    { title: 'Region', value: result.region, short: true },\n                    { title: 'Identifier', value: result.identifier, short: true },\n                    { title: 'Status', value: (display?.name ?? 'Unknown'), short: true },\n                  ],\n                },\n              ],\n            });\n          } catch (error: unknown) {\n            childCtx.logger.error('running-scheduler: Slack post failed', {\n              step: 'post-slack-child-messages',\n              channel,\n              identifier: result.identifier,\n              errorMessage: error instanceof Error ? error.message : String(error),\n            });\n            throw error;\n          }\n        });\n        return result;\n      });\n    },\n    { maxConcurrency: 10 },\n  );\n\n  const resultList = Array.isArray(results) ? results : [];\n  ctx.logger.info('running-scheduler: completed', {\n    processed: targetResources.length,\n    resultCount: resultList.length,\n  });\n  return {\n    status: 'Completed' as const,\n    processed: targetResources.length,\n    results: resultList,\n  };\n});\n"]}

package/lib/index.d.ts

@@ -1,7 +1,8 @@
 /**
  * Public API for the EC2 instance running scheduler CDK library.
  *
- * Exports {@link EC2InstanceRunningScheduler}, {@link EC2InstanceRunningScheduleStack}, and related prop types.
+ * Exports {@link EC2InstanceRunningScheduler}, {@link EC2InstanceRunningScheduleStack},
+ * optional {@link FailureDetectionAlarms} / {@link RunningSchedulerFailureDetection}, and related prop types.
  */
 export * from './constructs/ec2-instance-running-scheduler';
 export * from './stacks/ec2-instance-running-schedule-stack';

package/lib/index.js

@@ -17,8 +17,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Public API for the EC2 instance running scheduler CDK library.
  *
- * Exports {@link EC2InstanceRunningScheduler}, {@link EC2InstanceRunningScheduleStack}, and related prop types.
+ * Exports {@link EC2InstanceRunningScheduler}, {@link EC2InstanceRunningScheduleStack},
+ * optional {@link FailureDetectionAlarms} / {@link RunningSchedulerFailureDetection}, and related prop types.
  */
 __exportStar(require("./constructs/ec2-instance-running-scheduler"), exports);
 __exportStar(require("./stacks/ec2-instance-running-schedule-stack"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBOzs7O0dBSUc7QUFDSCw4RUFBNEQ7QUFDNUQsK0VBQTZEIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBQdWJsaWMgQVBJIGZvciB0aGUgRUMyIGluc3RhbmNlIHJ1bm5pbmcgc2NoZWR1bGVyIENESyBsaWJyYXJ5LlxuICpcbiAqIEV4cG9ydHMge0BsaW5rIEVDMkluc3RhbmNlUnVubmluZ1NjaGVkdWxlcn0sIHtAbGluayBFQzJJbnN0YW5jZVJ1bm5pbmdTY2hlZHVsZVN0YWNrfSwgYW5kIHJlbGF0ZWQgcHJvcCB0eXBlcy5cbiAqL1xuZXhwb3J0ICogZnJvbSAnLi9jb25zdHJ1Y3RzL2VjMi1pbnN0YW5jZS1ydW5uaW5nLXNjaGVkdWxlcic7XG5leHBvcnQgKiBmcm9tICcuL3N0YWNrcy9lYzItaW5zdGFuY2UtcnVubmluZy1zY2hlZHVsZS1zdGFjayc7Il19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBOzs7OztHQUtHO0FBQ0gsOEVBQTREO0FBQzVELCtFQUE2RCIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUHVibGljIEFQSSBmb3IgdGhlIEVDMiBpbnN0YW5jZSBydW5uaW5nIHNjaGVkdWxlciBDREsgbGlicmFyeS5cbiAqXG4gKiBFeHBvcnRzIHtAbGluayBFQzJJbnN0YW5jZVJ1bm5pbmdTY2hlZHVsZXJ9LCB7QGxpbmsgRUMySW5zdGFuY2VSdW5uaW5nU2NoZWR1bGVTdGFja30sXG4gKiBvcHRpb25hbCB7QGxpbmsgRmFpbHVyZURldGVjdGlvbkFsYXJtc30gLyB7QGxpbmsgUnVubmluZ1NjaGVkdWxlckZhaWx1cmVEZXRlY3Rpb259LCBhbmQgcmVsYXRlZCBwcm9wIHR5cGVzLlxuICovXG5leHBvcnQgKiBmcm9tICcuL2NvbnN0cnVjdHMvZWMyLWluc3RhbmNlLXJ1bm5pbmctc2NoZWR1bGVyJztcbmV4cG9ydCAqIGZyb20gJy4vc3RhY2tzL2VjMi1pbnN0YW5jZS1ydW5uaW5nLXNjaGVkdWxlLXN0YWNrJzsiXX0=

package/lib/stacks/ec2-instance-running-schedule-stack.d.ts

@@ -1,10 +1,10 @@
 import { Stack, StackProps } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
-import { TargetResource, Secrets, Schedule } from '../constructs/ec2-instance-running-scheduler';
+import { TargetResource, Secrets, Schedule, type FailureDetectionAlarms } from '../constructs/ec2-instance-running-scheduler';
 /**
  * Props for the EC2 instance running schedule CDK stack.
  *
- * @see {@link EC2InstanceRunningSchedulerProps} for construct-level options not exposed here (e.g. `resourcePolling`).
+ * @see {@link EC2InstanceRunningSchedulerProps} for construct-level options not exposed here (e.g. `resourceWait`).
  */
 export interface EC2InstanceRunningScheduleStackProps extends StackProps {
     /** Tag-based target resource for EC2 instances to start/stop. */
@@ -17,9 +17,15 @@ export interface EC2InstanceRunningScheduleStackProps extends StackProps {
     readonly stopSchedule?: Schedule;
     /** Cron schedule for starting instances. */
     readonly startSchedule?: Schedule;
+    /** Optional CloudWatch failure detection alarms and log-based metrics. */
+    readonly failureDetection?: FailureDetectionAlarms;
 }
 /**
  * CDK stack that deploys the EC2 instance running scheduler (EventBridge Scheduler + Durable Lambda).
+ *
+ * Wires {@link EC2InstanceRunningScheduler} with targeting, schedules, secrets, scheduling toggle,
+ * and optional {@link FailureDetectionAlarms}. Does not expose {@link ResourceWaitLimits}; use the
+ * construct directly when custom per-instance wait limits are required.
  */
 export declare class EC2InstanceRunningScheduleStack extends Stack {
     /**
@@ -27,7 +33,7 @@ export declare class EC2InstanceRunningScheduleStack extends Stack {
      *
      * @param scope - Parent construct or app.
      * @param id - Stack id.
-     * @param props - Target resource, schedules, secrets, and standard stack props.
+     * @param props - Target resource, schedules, secrets, optional failure detection, and standard stack props.
      */
     constructor(scope: Construct, id: string, props: EC2InstanceRunningScheduleStackProps);
 }

package/lib/stacks/ec2-instance-running-schedule-stack.js

@@ -6,15 +6,19 @@ const aws_cdk_lib_1 = require("aws-cdk-lib");
 const ec2_instance_running_scheduler_1 = require("../constructs/ec2-instance-running-scheduler");
 /**
  * CDK stack that deploys the EC2 instance running scheduler (EventBridge Scheduler + Durable Lambda).
+ *
+ * Wires {@link EC2InstanceRunningScheduler} with targeting, schedules, secrets, scheduling toggle,
+ * and optional {@link FailureDetectionAlarms}. Does not expose {@link ResourceWaitLimits}; use the
+ * construct directly when custom per-instance wait limits are required.
  */
 class EC2InstanceRunningScheduleStack extends aws_cdk_lib_1.Stack {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "ec2-instance-running-scheduler.EC2InstanceRunningScheduleStack", version: "0.2.7" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "ec2-instance-running-scheduler.EC2InstanceRunningScheduleStack", version: "0.3.1" };
     /**
      * Creates the stack and wires {@link EC2InstanceRunningScheduler}.
      *
      * @param scope - Parent construct or app.
      * @param id - Stack id.
-     * @param props - Target resource, schedules, secrets, and standard stack props.
+     * @param props - Target resource, schedules, secrets, optional failure detection, and standard stack props.
      */
     constructor(scope, id, props) {
         super(scope, id, props);
@@ -24,8 +28,9 @@ class EC2InstanceRunningScheduleStack extends aws_cdk_lib_1.Stack {
             secrets: props.secrets,
             stopSchedule: props.stopSchedule,
             startSchedule: props.startSchedule,
+            failureDetection: props.failureDetection,
         });
     }
 }
 exports.EC2InstanceRunningScheduleStack = EC2InstanceRunningScheduleStack;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ec2-instance-running-scheduler",
-  "description": "AWS CDK construct library that starts and stops EC2 instances on a cron schedule using EventBridge Scheduler and a Durable Execution Lambda. The handler discovers instances with the Resource Groups Tagging API, issues start/stop, polls until each instance reaches a stable target state (durable step / wait), processes multiple instances in parallel (bounded concurrency), and posts Slack summary and per-instance thread messages using a secret from Secrets Manager. The Lambda emits structured application logs alongside JSON platform logs.",
+  "description": "AWS CDK construct library that starts and stops EC2 instances on a cron schedule using EventBridge Scheduler and a Durable Execution Lambda. The handler discovers instances with the Resource Groups Tagging API, issues start/stop, waits until each instance reaches a stable target state (durable step / wait), processes multiple instances in parallel (bounded concurrency), and posts Slack summary and per-instance thread messages using a secret from Secrets Manager. The Lambda emits structured application logs alongside JSON platform logs.",
   "repository": {
     "type": "git",
     "url": "https://github.com/gammarers-aws-cdk-constructs/ec2-instance-running-scheduler.git"
@@ -49,7 +49,7 @@
     "@typescript-eslint/eslint-plugin": "^8",
     "@typescript-eslint/parser": "^8",
     "aws-cdk-lib": "2.232.0",
-    "aws-lambda-secret-fetcher": "^0.3",
+    "aws-lambda-secret-fetcher": "^0.6.1",
     "aws-sdk-client-mock": "^2",
     "aws-sdk-client-mock-jest": "^2",
     "commit-and-tag-version": "^12",
@@ -65,8 +65,8 @@
     "jsii-docgen": "^10.5.0",
     "jsii-pacmak": "^1.138.0",
     "jsii-rosetta": "5.9.x",
-    "projen": "^0.101.4",
-    "safe-env-getter": "^0.3.3",
+    "projen": "^0.101.11",
+    "strict-env-resolver": "^0.5.1",
     "ts-jest": "^29.4.11",
     "ts-node": "^10.9.2",
     "typescript": "5.9.x"
@@ -89,8 +89,7 @@
   },
   "devEngines": {
     "packageManager": {
-      "name": "yarn",
-      "version": "1.22.22",
+      "name": "npm",
       "onFail": "ignore"
     }
   },
@@ -100,7 +99,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.2.7",
+  "version": "0.3.1",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [

package/lib/funcs/running-scheduler-polling-config.d.ts

@@ -1,17 +0,0 @@
-/**
- * Environment variable names for per-instance polling limits.
- *
- * Values are set by {@link EC2InstanceRunningScheduler} and read at handler cold start.
- */
-/**
- * Lambda environment variable name for max poll loop count.
- *
- * @see {@link parseResourcePollingLimitsFromEnv} in `running-scheduler-polling-env.ts`
- */
-export declare const PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV = "PROCESS_RESOURCE_MAX_LOOP_COUNT";
-/**
- * Lambda environment variable name for max poll elapsed seconds.
- *
- * @see {@link parseResourcePollingLimitsFromEnv} in `running-scheduler-polling-env.ts`
- */
-export declare const PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV = "PROCESS_RESOURCE_MAX_ELAPSED_SECONDS";

package/lib/funcs/running-scheduler-polling-config.js

@@ -1,21 +0,0 @@
-"use strict";
-/**
- * Environment variable names for per-instance polling limits.
- *
- * Values are set by {@link EC2InstanceRunningScheduler} and read at handler cold start.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV = exports.PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV = void 0;
-/**
- * Lambda environment variable name for max poll loop count.
- *
- * @see {@link parseResourcePollingLimitsFromEnv} in `running-scheduler-polling-env.ts`
- */
-exports.PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV = 'PROCESS_RESOURCE_MAX_LOOP_COUNT';
-/**
- * Lambda environment variable name for max poll elapsed seconds.
- *
- * @see {@link parseResourcePollingLimitsFromEnv} in `running-scheduler-polling-env.ts`
- */
-exports.PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV = 'PROCESS_RESOURCE_MAX_ELAPSED_SECONDS';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVubmluZy1zY2hlZHVsZXItcG9sbGluZy1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZnVuY3MvcnVubmluZy1zY2hlZHVsZXItcG9sbGluZy1jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7O0dBSUc7OztBQUVIOzs7O0dBSUc7QUFDVSxRQUFBLG1DQUFtQyxHQUFHLGlDQUFpQyxDQUFDO0FBRXJGOzs7O0dBSUc7QUFDVSxRQUFBLHdDQUF3QyxHQUFHLHNDQUFzQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFbnZpcm9ubWVudCB2YXJpYWJsZSBuYW1lcyBmb3IgcGVyLWluc3RhbmNlIHBvbGxpbmcgbGltaXRzLlxuICpcbiAqIFZhbHVlcyBhcmUgc2V0IGJ5IHtAbGluayBFQzJJbnN0YW5jZVJ1bm5pbmdTY2hlZHVsZXJ9IGFuZCByZWFkIGF0IGhhbmRsZXIgY29sZCBzdGFydC5cbiAqL1xuXG4vKipcbiAqIExhbWJkYSBlbnZpcm9ubWVudCB2YXJpYWJsZSBuYW1lIGZvciBtYXggcG9sbCBsb29wIGNvdW50LlxuICpcbiAqIEBzZWUge0BsaW5rIHBhcnNlUmVzb3VyY2VQb2xsaW5nTGltaXRzRnJvbUVudn0gaW4gYHJ1bm5pbmctc2NoZWR1bGVyLXBvbGxpbmctZW52LnRzYFxuICovXG5leHBvcnQgY29uc3QgUFJPQ0VTU19SRVNPVVJDRV9NQVhfTE9PUF9DT1VOVF9FTlYgPSAnUFJPQ0VTU19SRVNPVVJDRV9NQVhfTE9PUF9DT1VOVCc7XG5cbi8qKlxuICogTGFtYmRhIGVudmlyb25tZW50IHZhcmlhYmxlIG5hbWUgZm9yIG1heCBwb2xsIGVsYXBzZWQgc2Vjb25kcy5cbiAqXG4gKiBAc2VlIHtAbGluayBwYXJzZVJlc291cmNlUG9sbGluZ0xpbWl0c0Zyb21FbnZ9IGluIGBydW5uaW5nLXNjaGVkdWxlci1wb2xsaW5nLWVudi50c2BcbiAqL1xuZXhwb3J0IGNvbnN0IFBST0NFU1NfUkVTT1VSQ0VfTUFYX0VMQVBTRURfU0VDT05EU19FTlYgPSAnUFJPQ0VTU19SRVNPVVJDRV9NQVhfRUxBUFNFRF9TRUNPTkRTJztcbiJdfQ==

package/lib/funcs/running-scheduler-polling-env.d.ts

@@ -1,8 +0,0 @@
-import { type ResourcePollingLimits } from './running-scheduler-predicates';
-/**
- * Reads per-instance polling limits from Lambda environment variables set by the CDK construct.
- *
- * @returns Parsed limits, using {@link DEFAULT_RESOURCE_POLLING_LIMITS} when variables are unset.
- * @throws {Error} When a set variable is not a positive integer.
- */
-export declare const parseResourcePollingLimitsFromEnv: () => ResourcePollingLimits;