@aws-cdk/toolkit-lib 1.29.1 → 1.31.0

package/lib/api/diagnosing/investigate-ecs-service.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.investigateEcsService = investigateEcsService;
+const format_utils_1 = require("./format-utils");
+const resource_identifiers_1 = require("./resource-identifiers");
+/** Fallback look-back when no failure timestamp is available. */
+const FALLBACK_LOG_WINDOW_MS = 30 * 60 * 1000;
+async function investigateEcsService(err, sdk, debug, options) {
+    const physicalId = err.physicalId;
+    if (!physicalId) {
+        await debug('ECS investigation: no physical ID available');
+        return [];
+    }
+    const { cluster, serviceName } = (0, resource_identifiers_1.parseEcsServiceIdentifier)(physicalId);
+    if (!serviceName) {
+        await debug(`ECS investigation: could not parse service identifier from "${physicalId}"`);
+        return [];
+    }
+    const region = sdk.currentRegion;
+    const ecs = sdk.ecs();
+    const cwl = sdk.cloudWatchLogs();
+    const service = await describeService(ecs, cluster, serviceName, debug);
+    if (!service) {
+        // The service is gone. The most common reason is that CloudFormation rolled the
+        // deployment back and deleted it, taking the task/runtime detail with it. If rollback
+        // was enabled, point the user at the flag that would have retained that detail.
+        if (options.rollbackEnabled) {
+            return [{
+                    source: 'ECS Service',
+                    messages: [
+                        'The service and its tasks were removed during rollback, so container-level failure detail is unavailable.',
+                        'Re-run the deployment with `--no-rollback` to retain the failed tasks and see why they stopped.',
+                    ],
+                }];
+        }
+        return [];
+    }
+    const results = [];
+    const stoppedTaskResult = await getStoppedTaskReasons(ecs, cluster, serviceName, region, service, debug);
+    if (stoppedTaskResult.context) {
+        results.push(stoppedTaskResult.context);
+    }
+    const taskDefinitionArn = service.taskDefinition;
+    if (!taskDefinitionArn) {
+        return results;
+    }
+    const taskDefInfo = await getTaskDefinitionInfo(ecs, taskDefinitionArn, debug);
+    if (!taskDefInfo) {
+        return results;
+    }
+    const logConfigs = taskDefInfo.logConfigs;
+    if (logConfigs.length === 0) {
+        results.push({
+            source: 'CloudWatch Logs',
+            messages: [
+                'No CloudWatch Logs configuration found. Enable logging to see container output on failure.',
+                'Example:',
+                '  taskDefinition.addContainer("app", {',
+                '    // ...',
+                '    logging: ecs.LogDrivers.awsLogs({ streamPrefix: "my-service" }),',
+                '  });',
+            ],
+        });
+        return results;
+    }
+    // `logConfigs` has one entry per container in the task definition that uses the awslogs
+    // driver — a handful at most — so this fan-out is bounded by the task shape and needs no
+    // explicit concurrency limit.
+    // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
+    const logResults = await Promise.all(logConfigs.map(cfg => fetchRecentLogs(cwl, cfg, region, stoppedTaskResult.taskIds, debug)));
+    const logContexts = logResults.filter((c) => c !== undefined);
+    results.push(...logContexts);
+    if (logContexts.length === 0) {
+        results.push({
+            source: 'CloudWatch Logs',
+            messages: ['No CloudWatch Logs found.'],
+        });
+    }
+    return results;
+}
+async function describeService(ecs, cluster, serviceName, debug) {
+    try {
+        const resp = await ecs.describeServices({ cluster, services: [serviceName] });
+        const service = resp.services?.[0];
+        if (!service) {
+            await debug(`ECS investigation: service "${serviceName}" not found`);
+        }
+        return service;
+    }
+    catch (e) {
+        await debug(`ECS investigation: failed to describe service: ${e.message}`);
+        return undefined;
+    }
+}
+async function getStoppedTaskReasons(ecs, cluster, serviceName, region, service, debug) {
+    try {
+        // Ask ECS for the service's stopped tasks. The IDs we need live in "has started 1 tasks: (task <id>)" events
+        const taskIds = await listStoppedTaskIds(ecs, cluster, serviceName, debug);
+        const messages = [];
+        if (taskIds.length > 0) {
+            // Show details from the most recently stopped task only.
+            const tasksResp = await ecs.describeTasks({ cluster, tasks: [taskIds[0]] });
+            const task = tasksResp.tasks?.[0];
+            if (task) {
+                if (task.stoppedReason) {
+                    messages.push(`Task stopped: ${task.stoppedReason}`);
+                }
+                for (const container of task.containers ?? []) {
+                    if (container.reason) {
+                        messages.push(`Container "${container.name}": ${container.reason}`);
+                    }
+                    if (container.exitCode != null && container.exitCode !== 0) {
+                        messages.push(`Container "${container.name}" exited with code ${container.exitCode}`);
+                    }
+                }
+            }
+            if (messages.length > 0 && taskIds.length > 1) {
+                messages.push(`(${taskIds.length - 1} other failed task(s) not shown)`);
+            }
+        }
+        // Fall back to the most relevant service event if we couldn't get a task-level reason
+        // (e.g. tasks already aged out, or no stopped tasks retained).
+        if (messages.length === 0) {
+            const failureEvent = (service.events ?? [])
+                .find(e => e.message?.includes('stopped') || e.message?.includes('failed') || e.message?.includes('unhealthy'));
+            if (failureEvent?.message) {
+                messages.push(failureEvent.message);
+            }
+        }
+        if (messages.length === 0) {
+            return { taskIds };
+        }
+        return {
+            context: {
+                source: 'ECS Stopped Tasks',
+                messages,
+                link: (0, resource_identifiers_1.ecsStoppedTasksConsoleUrl)(region, cluster ?? 'default', serviceName),
+                linkLabel: 'Tasks',
+            },
+            taskIds,
+        };
+    }
+    catch (e) {
+        await debug(`ECS investigation: failed to get stopped task reasons: ${e.message}`);
+        return { taskIds: [] };
+    }
+}
+/**
+ * Maximum number of stopped task IDs to consider. We only render detail for the most
+ * recent one, but keep a few so we can report how many others failed.
+ */
+const MAX_STOPPED_TASKS = 3;
+/**
+ * List the bare task IDs of the service's stopped tasks, newest first.
+ *
+ * Prefers scoping by service name; if that yields nothing (some ECS API versions only
+ * apply the service filter to running tasks), falls back to listing the cluster's stopped
+ * tasks. Returns an empty array if none are retained (e.g. they aged out, or rollback
+ * already drained the cluster).
+ */
+async function listStoppedTaskIds(ecs, cluster, serviceName, debug) {
+    const toIds = (arns) => (arns ?? []).map(arn => arn.split('/').pop()).filter((id) => !!id);
+    let arns;
+    try {
+        const byService = await ecs.listTasks({ cluster, serviceName, desiredStatus: 'STOPPED' });
+        arns = byService.taskArns;
+        if (!arns || arns.length === 0) {
+            const byCluster = await ecs.listTasks({ cluster, desiredStatus: 'STOPPED' });
+            arns = byCluster.taskArns;
+        }
+    }
+    catch (e) {
+        await debug(`ECS investigation: failed to list stopped tasks: ${e.message}`);
+        return [];
+    }
+    return toIds(arns).slice(0, MAX_STOPPED_TASKS);
+}
+async function getTaskDefinitionInfo(ecs, taskDefinitionArn, debug) {
+    try {
+        const resp = await ecs.describeTaskDefinition({ taskDefinition: taskDefinitionArn });
+        const containers = resp.taskDefinition?.containerDefinitions ?? [];
+        const logConfigs = [];
+        for (const container of containers) {
+            const logConfig = container.logConfiguration;
+            if (logConfig?.logDriver === 'awslogs') {
+                const logGroup = logConfig.options?.['awslogs-group'];
+                if (logGroup) {
+                    logConfigs.push({
+                        logGroup,
+                        streamPrefix: logConfig.options?.['awslogs-stream-prefix'],
+                        containerName: container.name,
+                    });
+                }
+            }
+        }
+        return { logConfigs };
+    }
+    catch (e) {
+        await debug(`ECS investigation: failed to describe task definition: ${e.message}`);
+        return undefined;
+    }
+}
+async function fetchRecentLogs(cwl, logConfig, region, taskIds, debug) {
+    try {
+        // Target the most recently failed task's log stream for the most relevant output
+        const lastTaskId = taskIds[0];
+        const targetStream = (logConfig.streamPrefix && logConfig.containerName && lastTaskId)
+            ? `${logConfig.streamPrefix}/${logConfig.containerName}/${lastTaskId}`
+            : undefined;
+        const resp = await cwl.filterLogEvents({
+            logGroupName: logConfig.logGroup,
+            startTime: Date.now() - FALLBACK_LOG_WINDOW_MS,
+            limit: 1000,
+            ...(targetStream
+                ? { logStreamNames: [targetStream] }
+                : logConfig.streamPrefix ? { logStreamNamePrefix: logConfig.streamPrefix } : {}),
+        });
+        const events = resp.events ?? [];
+        if (events.length === 0) {
+            await debug(`ECS investigation: no recent log events in ${logConfig.logGroup}${targetStream ? ` (targeted stream: ${targetStream})` : ''}`);
+            return undefined;
+        }
+        const messages = (0, format_utils_1.trimToRecentLines)(events.map(e => e.message?.trimEnd()).filter((m) => m != null));
+        if (taskIds.length > 1) {
+            messages.push(`(showing logs from last failed task; ${taskIds.length - 1} other failed task(s) available in console)`);
+        }
+        const source = logConfig.containerName
+            ? `CloudWatch Logs: ${logConfig.logGroup} (container: ${logConfig.containerName})`
+            : `CloudWatch Logs: ${logConfig.logGroup}`;
+        return {
+            source,
+            messages,
+            link: (0, format_utils_1.cloudWatchLogsConsoleUrl)(region, logConfig.logGroup),
+            linkLabel: 'Logs',
+        };
+    }
+    catch (e) {
+        await debug(`ECS investigation: failed to fetch logs from ${logConfig.logGroup}: ${e.message}`);
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"investigate-ecs-service.js","sourceRoot":"","sources":["investigate-ecs-service.ts"],"names":[],"mappings":"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","sourcesContent":["import { trimToRecentLines, cloudWatchLogsConsoleUrl } from './format-utils';\nimport { parseEcsServiceIdentifier, ecsStoppedTasksConsoleUrl } from './resource-identifiers';\nimport type { AdditionalDiagnosticContext } from '../../actions/diagnose';\nimport type { ICloudWatchLogsClient, IECSClient, SDK } from '../aws-auth/sdk';\nimport type { ResourceError } from '../stack-events/resource-errors';\n\n/** Fallback look-back when no failure timestamp is available. */\nconst FALLBACK_LOG_WINDOW_MS = 30 * 60 * 1000;\n\n/**\n * Options that influence how a resource is investigated.\n */\nexport interface InvestigateOptions {\n  /**\n   * Whether CloudFormation rollback is enabled for this deployment.\n   *\n   * When rollback is enabled, a failed resource is torn down before we can\n   * inspect its runtime state, so we may suggest re-running with `--no-rollback`\n   * to retain that detail.\n   *\n   * @default true\n   */\n  readonly rollbackEnabled?: boolean;\n}\n\nexport async function investigateEcsService(\n  err: ResourceError,\n  sdk: SDK,\n  debug: (msg: string) => Promise<void>,\n  options: InvestigateOptions,\n): Promise<AdditionalDiagnosticContext[]> {\n  const physicalId = err.physicalId;\n  if (!physicalId) {\n    await debug('ECS investigation: no physical ID available');\n    return [];\n  }\n\n  const { cluster, serviceName } = parseEcsServiceIdentifier(physicalId);\n  if (!serviceName) {\n    await debug(`ECS investigation: could not parse service identifier from \"${physicalId}\"`);\n    return [];\n  }\n\n  const region = sdk.currentRegion;\n  const ecs = sdk.ecs();\n  const cwl = sdk.cloudWatchLogs();\n\n  const service = await describeService(ecs, cluster, serviceName, debug);\n  if (!service) {\n    // The service is gone. The most common reason is that CloudFormation rolled the\n    // deployment back and deleted it, taking the task/runtime detail with it. If rollback\n    // was enabled, point the user at the flag that would have retained that detail.\n    if (options.rollbackEnabled) {\n      return [{\n        source: 'ECS Service',\n        messages: [\n          'The service and its tasks were removed during rollback, so container-level failure detail is unavailable.',\n          'Re-run the deployment with `--no-rollback` to retain the failed tasks and see why they stopped.',\n        ],\n      }];\n    }\n    return [];\n  }\n\n  const results: AdditionalDiagnosticContext[] = [];\n\n  const stoppedTaskResult = await getStoppedTaskReasons(ecs, cluster, serviceName, region, service, debug);\n  if (stoppedTaskResult.context) {\n    results.push(stoppedTaskResult.context);\n  }\n\n  const taskDefinitionArn = service.taskDefinition;\n  if (!taskDefinitionArn) {\n    return results;\n  }\n\n  const taskDefInfo = await getTaskDefinitionInfo(ecs, taskDefinitionArn, debug);\n  if (!taskDefInfo) {\n    return results;\n  }\n\n  const logConfigs = taskDefInfo.logConfigs;\n\n  if (logConfigs.length === 0) {\n    results.push({\n      source: 'CloudWatch Logs',\n      messages: [\n        'No CloudWatch Logs configuration found. Enable logging to see container output on failure.',\n        'Example:',\n        '  taskDefinition.addContainer(\"app\", {',\n        '    // ...',\n        '    logging: ecs.LogDrivers.awsLogs({ streamPrefix: \"my-service\" }),',\n        '  });',\n      ],\n    });\n    return results;\n  }\n\n  // `logConfigs` has one entry per container in the task definition that uses the awslogs\n  // driver — a handful at most — so this fan-out is bounded by the task shape and needs no\n  // explicit concurrency limit.\n  // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism\n  const logResults = await Promise.all(logConfigs.map(cfg => fetchRecentLogs(cwl, cfg, region, stoppedTaskResult.taskIds, debug)));\n  const logContexts = logResults.filter((c): c is AdditionalDiagnosticContext => c !== undefined);\n\n  results.push(...logContexts);\n  if (logContexts.length === 0) {\n    results.push({\n      source: 'CloudWatch Logs',\n      messages: ['No CloudWatch Logs found.'],\n    });\n  }\n\n  return results;\n}\n\nasync function describeService(\n  ecs: IECSClient,\n  cluster: string | undefined,\n  serviceName: string,\n  debug: (msg: string) => Promise<void>,\n) {\n  try {\n    const resp = await ecs.describeServices({ cluster, services: [serviceName] });\n    const service = resp.services?.[0];\n    if (!service) {\n      await debug(`ECS investigation: service \"${serviceName}\" not found`);\n    }\n    return service;\n  } catch (e: any) {\n    await debug(`ECS investigation: failed to describe service: ${e.message}`);\n    return undefined;\n  }\n}\n\ninterface StoppedTaskResult {\n  context?: AdditionalDiagnosticContext;\n  taskIds: string[];\n}\n\nasync function getStoppedTaskReasons(\n  ecs: IECSClient,\n  cluster: string | undefined,\n  serviceName: string,\n  region: string,\n  service: { events?: Array<{ message?: string }>; [key: string]: any },\n  debug: (msg: string) => Promise<void>,\n): Promise<StoppedTaskResult> {\n  try {\n    // Ask ECS for the service's stopped tasks. The IDs we need live in \"has started 1 tasks: (task <id>)\" events\n    const taskIds = await listStoppedTaskIds(ecs, cluster, serviceName, debug);\n\n    const messages: string[] = [];\n\n    if (taskIds.length > 0) {\n      // Show details from the most recently stopped task only.\n      const tasksResp = await ecs.describeTasks({ cluster, tasks: [taskIds[0]] });\n      const task = tasksResp.tasks?.[0];\n      if (task) {\n        if (task.stoppedReason) {\n          messages.push(`Task stopped: ${task.stoppedReason}`);\n        }\n        for (const container of task.containers ?? []) {\n          if (container.reason) {\n            messages.push(`Container \"${container.name}\": ${container.reason}`);\n          }\n          if (container.exitCode != null && container.exitCode !== 0) {\n            messages.push(`Container \"${container.name}\" exited with code ${container.exitCode}`);\n          }\n        }\n      }\n      if (messages.length > 0 && taskIds.length > 1) {\n        messages.push(`(${taskIds.length - 1} other failed task(s) not shown)`);\n      }\n    }\n\n    // Fall back to the most relevant service event if we couldn't get a task-level reason\n    // (e.g. tasks already aged out, or no stopped tasks retained).\n    if (messages.length === 0) {\n      const failureEvent = (service.events ?? [])\n        .find(e => e.message?.includes('stopped') || e.message?.includes('failed') || e.message?.includes('unhealthy'));\n      if (failureEvent?.message) {\n        messages.push(failureEvent.message);\n      }\n    }\n\n    if (messages.length === 0) {\n      return { taskIds };\n    }\n\n    return {\n      context: {\n        source: 'ECS Stopped Tasks',\n        messages,\n        link: ecsStoppedTasksConsoleUrl(region, cluster ?? 'default', serviceName),\n        linkLabel: 'Tasks',\n      },\n      taskIds,\n    };\n  } catch (e: any) {\n    await debug(`ECS investigation: failed to get stopped task reasons: ${e.message}`);\n    return { taskIds: [] };\n  }\n}\n\n/**\n * Maximum number of stopped task IDs to consider. We only render detail for the most\n * recent one, but keep a few so we can report how many others failed.\n */\nconst MAX_STOPPED_TASKS = 3;\n\n/**\n * List the bare task IDs of the service's stopped tasks, newest first.\n *\n * Prefers scoping by service name; if that yields nothing (some ECS API versions only\n * apply the service filter to running tasks), falls back to listing the cluster's stopped\n * tasks. Returns an empty array if none are retained (e.g. they aged out, or rollback\n * already drained the cluster).\n */\nasync function listStoppedTaskIds(\n  ecs: IECSClient,\n  cluster: string | undefined,\n  serviceName: string,\n  debug: (msg: string) => Promise<void>,\n): Promise<string[]> {\n  const toIds = (arns: string[] | undefined) => (arns ?? []).map(arn => arn.split('/').pop()).filter((id): id is string => !!id);\n\n  let arns: string[] | undefined;\n  try {\n    const byService = await ecs.listTasks({ cluster, serviceName, desiredStatus: 'STOPPED' });\n    arns = byService.taskArns;\n    if (!arns || arns.length === 0) {\n      const byCluster = await ecs.listTasks({ cluster, desiredStatus: 'STOPPED' });\n      arns = byCluster.taskArns;\n    }\n  } catch (e: any) {\n    await debug(`ECS investigation: failed to list stopped tasks: ${e.message}`);\n    return [];\n  }\n\n  return toIds(arns).slice(0, MAX_STOPPED_TASKS);\n}\n\ninterface AwsLogsConfig {\n  logGroup: string;\n  streamPrefix?: string;\n  containerName?: string;\n}\n\ninterface TaskDefinitionInfo {\n  logConfigs: AwsLogsConfig[];\n}\n\nasync function getTaskDefinitionInfo(\n  ecs: IECSClient,\n  taskDefinitionArn: string,\n  debug: (msg: string) => Promise<void>,\n): Promise<TaskDefinitionInfo | undefined> {\n  try {\n    const resp = await ecs.describeTaskDefinition({ taskDefinition: taskDefinitionArn });\n    const containers = resp.taskDefinition?.containerDefinitions ?? [];\n    const logConfigs: AwsLogsConfig[] = [];\n    for (const container of containers) {\n      const logConfig = container.logConfiguration;\n      if (logConfig?.logDriver === 'awslogs') {\n        const logGroup = logConfig.options?.['awslogs-group'];\n        if (logGroup) {\n          logConfigs.push({\n            logGroup,\n            streamPrefix: logConfig.options?.['awslogs-stream-prefix'],\n            containerName: container.name,\n          });\n        }\n      }\n    }\n    return { logConfigs };\n  } catch (e: any) {\n    await debug(`ECS investigation: failed to describe task definition: ${e.message}`);\n    return undefined;\n  }\n}\n\nasync function fetchRecentLogs(\n  cwl: ICloudWatchLogsClient,\n  logConfig: AwsLogsConfig,\n  region: string,\n  taskIds: string[],\n  debug: (msg: string) => Promise<void>,\n): Promise<AdditionalDiagnosticContext | undefined> {\n  try {\n    // Target the most recently failed task's log stream for the most relevant output\n    const lastTaskId = taskIds[0];\n    const targetStream = (logConfig.streamPrefix && logConfig.containerName && lastTaskId)\n      ? `${logConfig.streamPrefix}/${logConfig.containerName}/${lastTaskId}`\n      : undefined;\n\n    const resp = await cwl.filterLogEvents({\n      logGroupName: logConfig.logGroup,\n      startTime: Date.now() - FALLBACK_LOG_WINDOW_MS,\n      limit: 1000,\n      ...(targetStream\n        ? { logStreamNames: [targetStream] }\n        : logConfig.streamPrefix ? { logStreamNamePrefix: logConfig.streamPrefix } : {}),\n    });\n\n    const events = resp.events ?? [];\n    if (events.length === 0) {\n      await debug(`ECS investigation: no recent log events in ${logConfig.logGroup}${targetStream ? ` (targeted stream: ${targetStream})` : ''}`);\n      return undefined;\n    }\n\n    const messages = trimToRecentLines(\n      events.map(e => e.message?.trimEnd()).filter((m): m is string => m != null),\n    );\n\n    if (taskIds.length > 1) {\n      messages.push(`(showing logs from last failed task; ${taskIds.length - 1} other failed task(s) available in console)`);\n    }\n\n    const source = logConfig.containerName\n      ? `CloudWatch Logs: ${logConfig.logGroup} (container: ${logConfig.containerName})`\n      : `CloudWatch Logs: ${logConfig.logGroup}`;\n\n    return {\n      source,\n      messages,\n      link: cloudWatchLogsConsoleUrl(region, logConfig.logGroup),\n      linkLabel: 'Logs',\n    };\n  } catch (e: any) {\n    await debug(`ECS investigation: failed to fetch logs from ${logConfig.logGroup}: ${e.message}`);\n    return undefined;\n  }\n}\n"]}

package/lib/api/diagnosing/resource-identifiers.d.ts

@@ -0,0 +1,39 @@
+/** Pure parsers for resource identifiers used during failure diagnosis. */
+/**
+ * Parse an ECS service physical resource ID into cluster and service identifiers.
+ *
+ * The cluster portion is a name (not an ARN) — `describeServices`/`describeTasks`
+ * accept either form for their `cluster` parameter, so this is fine downstream.
+ *
+ * Recognized formats:
+ * - Long ARN: `arn:aws:ecs:region:account:service/cluster-name/service-name` (current default)
+ * - Path: `cluster-name/service-name`
+ * - Bare service name (uses the default cluster)
+ */
+export declare function parseEcsServiceIdentifier(physicalId: string): {
+    cluster?: string;
+    serviceName?: string;
+};
+/**
+ * If a ServiceToken is an `Fn::GetAtt` or `Ref` intrinsic, return the referenced logical ID.
+ */
+export declare function serviceTokenReferencedLogicalId(serviceToken: any): string | undefined;
+/**
+ * Extract a Lambda function name from a function ARN or a bare name.
+ *
+ * Returns `undefined` for non-Lambda ARNs (e.g. an SNS-topic ServiceToken).
+ */
+export declare function functionNameFromArnOrName(arnOrName: string): string | undefined;
+/**
+ * Extract the log stream name out of a cfn-response failure reason
+ * ("See the details in CloudWatch Log Stream: <name>").
+ */
+export declare function extractLogStreamName(message: string | undefined): string | undefined;
+/**
+ * cfn-response defaults the physical ID to the log stream name. Use it only when it looks
+ * like a Lambda log stream (`YYYY/MM/DD/...`), so a user-provided physical ID isn't mistaken
+ * for one.
+ */
+export declare function logStreamNameFromPhysicalId(physicalId: string | undefined): string | undefined;
+export declare function ecsStoppedTasksConsoleUrl(region: string, cluster: string, serviceName: string): string;
+//# sourceMappingURL=resource-identifiers.d.ts.map

package/lib/api/diagnosing/resource-identifiers.js

@@ -0,0 +1,90 @@
+"use strict";
+/** Pure parsers for resource identifiers used during failure diagnosis. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEcsServiceIdentifier = parseEcsServiceIdentifier;
+exports.serviceTokenReferencedLogicalId = serviceTokenReferencedLogicalId;
+exports.functionNameFromArnOrName = functionNameFromArnOrName;
+exports.extractLogStreamName = extractLogStreamName;
+exports.logStreamNameFromPhysicalId = logStreamNameFromPhysicalId;
+exports.ecsStoppedTasksConsoleUrl = ecsStoppedTasksConsoleUrl;
+/**
+ * Parse an ECS service physical resource ID into cluster and service identifiers.
+ *
+ * The cluster portion is a name (not an ARN) — `describeServices`/`describeTasks`
+ * accept either form for their `cluster` parameter, so this is fine downstream.
+ *
+ * Recognized formats:
+ * - Long ARN: `arn:aws:ecs:region:account:service/cluster-name/service-name` (current default)
+ * - Path: `cluster-name/service-name`
+ * - Bare service name (uses the default cluster)
+ */
+function parseEcsServiceIdentifier(physicalId) {
+    const arnMatch = physicalId.match(/^arn:[^:]+:ecs:[^:]*:[^:]*:service\/([^/]+)\/([^/]+)$/);
+    if (arnMatch) {
+        return { cluster: arnMatch[1], serviceName: arnMatch[2] };
+    }
+    const parts = physicalId.split('/');
+    if (parts.length === 2 && parts[0] && parts[1]) {
+        return { cluster: parts[0], serviceName: parts[1] };
+    }
+    if (parts.length === 1 && parts[0]) {
+        return { serviceName: parts[0] };
+    }
+    return {};
+}
+/**
+ * If a ServiceToken is an `Fn::GetAtt` or `Ref` intrinsic, return the referenced logical ID.
+ */
+function serviceTokenReferencedLogicalId(serviceToken) {
+    if (!serviceToken || typeof serviceToken !== 'object') {
+        return undefined;
+    }
+    const getAtt = serviceToken['Fn::GetAtt'];
+    // Array form (JSON / CDK output): ["LogicalId", "Arn"].
+    if (Array.isArray(getAtt) && typeof getAtt[0] === 'string') {
+        return getAtt[0];
+    }
+    // String short-form (how YAML `!GetAtt LogicalId.Arn` deserializes): "LogicalId.Attr".
+    if (typeof getAtt === 'string') {
+        return getAtt.split('.')[0] || undefined;
+    }
+    if (typeof serviceToken.Ref === 'string') {
+        return serviceToken.Ref;
+    }
+    return undefined;
+}
+/**
+ * Extract a Lambda function name from a function ARN or a bare name.
+ *
+ * Returns `undefined` for non-Lambda ARNs (e.g. an SNS-topic ServiceToken).
+ */
+function functionNameFromArnOrName(arnOrName) {
+    const arnMatch = arnOrName.match(/^arn:[^:]+:lambda:[^:]*:[^:]*:function:([^:]+)/);
+    if (arnMatch) {
+        return arnMatch[1];
+    }
+    if (arnOrName.startsWith('arn:')) {
+        return undefined;
+    }
+    return arnOrName || undefined;
+}
+/**
+ * Extract the log stream name out of a cfn-response failure reason
+ * ("See the details in CloudWatch Log Stream: <name>").
+ */
+function extractLogStreamName(message) {
+    const match = message?.match(/CloudWatch Log Stream:\s*(\S+)/);
+    return match ? match[1] : undefined;
+}
+/**
+ * cfn-response defaults the physical ID to the log stream name. Use it only when it looks
+ * like a Lambda log stream (`YYYY/MM/DD/...`), so a user-provided physical ID isn't mistaken
+ * for one.
+ */
+function logStreamNameFromPhysicalId(physicalId) {
+    return physicalId && /^\d{4}\/\d{2}\/\d{2}\/.+/.test(physicalId) ? physicalId : undefined;
+}
+function ecsStoppedTasksConsoleUrl(region, cluster, serviceName) {
+    return `https://${region}.console.aws.amazon.com/ecs/v2/clusters/${cluster}/services/${serviceName}/tasks?status=STOPPED&region=${region}`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/diagnosing/resource-investigation.d.ts

@@ -0,0 +1,13 @@
+import { type InvestigateOptions } from './investigate-ecs-service';
+import type { AdditionalDiagnosticContext } from '../../actions/diagnose';
+import type { SDK } from '../aws-auth/sdk';
+import type { ResourceError } from '../stack-events/resource-errors';
+export type { InvestigateOptions };
+/**
+ * Investigate a failed resource using AWS service APIs to gather additional root cause context.
+ *
+ * Returns additional diagnostic context (e.g. log lines) or an empty array if
+ * investigation is not possible or yields no results for this resource type.
+ */
+export declare function investigateResource(err: ResourceError, sdk: SDK, debug: (msg: string) => Promise<void>, options?: InvestigateOptions): Promise<AdditionalDiagnosticContext[]>;
+//# sourceMappingURL=resource-investigation.d.ts.map

package/lib/api/diagnosing/resource-investigation.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.investigateResource = investigateResource;
+const investigate_custom_resource_1 = require("./investigate-custom-resource");
+const investigate_ecs_service_1 = require("./investigate-ecs-service");
+/**
+ * Investigate a failed resource using AWS service APIs to gather additional root cause context.
+ *
+ * Returns additional diagnostic context (e.g. log lines) or an empty array if
+ * investigation is not possible or yields no results for this resource type.
+ */
+async function investigateResource(err, sdk, debug, options = {}) {
+    const resourceType = err.resourceType ?? '';
+    if (resourceType === 'AWS::ECS::Service') {
+        return (0, investigate_ecs_service_1.investigateEcsService)(err, sdk, debug, options);
+    }
+    if (resourceType === 'AWS::CloudFormation::CustomResource' || resourceType.startsWith('Custom::')) {
+        return (0, investigate_custom_resource_1.investigateCustomResource)(err, sdk, debug);
+    }
+    return [];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/diagnosing/stack-diagnoser.d.ts

@@ -11,7 +11,21 @@ export interface CloudFormationStackDiagnoserProps {
     readonly sourceTracer: ISourceTracer;
     readonly ioHelper: IoHelper;
     readonly topLevelStackHierarchicalId: string;
+    /**
+     * Optionally: a function to return an SDK that can be used for additional
+     * (readonly) exploratory calls.
+     *
+     * Typically, this should be an SDK that is primed with the "lookup" role, or similar.
+     *
+     * This is necessary because the "deploy" role will not typically have permissions to
+     * do very much.
+     *
+     * Regardless, if lookups of additional information fail, they are emitted at debug
+     * level and their information is simply not added to the output.
+     */
+    readonly additionalExplorationSdkProvider?: SdkProvider;
 }
+export type SdkProvider = () => Promise<SDK>;
 /**
  * Diagnose a stack's failed state
  *
@@ -25,10 +39,27 @@ export interface CloudFormationStackDiagnoserProps {
  * This class works at the CloudFormation level, and does not deal with tracing
  * CloudFormation errors to construct code sources yet.
  */
+/**
+ * Options that affect how a diagnosis is performed.
+ */
+export interface DiagnoseOptions {
+    /**
+     * Whether CloudFormation rollback is enabled for this deployment.
+     *
+     * When rollback is enabled, failed resources are torn down before we can
+     * inspect their runtime state (e.g. ECS tasks), so the investigation degrades
+     * to durable sources and may suggest re-running with `--no-rollback`.
+     *
+     * @default true
+     */
+    readonly rollbackEnabled?: boolean;
+}
 export declare class CloudFormationStackDiagnoser {
     private readonly props;
     private readonly cfn;
     private parentStackLogicalIds;
+    private _additionalExplorationSdkPromise?;
+    private rollbackEnabled;
     constructor(props: CloudFormationStackDiagnoserProps);
     /**
      * Diagnose a stack's root cause given no pre-existing state
@@ -41,7 +72,7 @@ export declare class CloudFormationStackDiagnoser {
     /**
      * Diagnose potential problems with the change set
      */
-    diagnoseFromErrorCollection(errors: ResourceErrors, stack: Stack): Promise<StackDiagnosis>;
+    diagnoseFromErrorCollection(errors: ResourceErrors, stack: Stack, allowFallback?: boolean, options?: DiagnoseOptions): Promise<StackDiagnosis>;
     /**
      * Diagnose a deployment failure via stack events
      *
@@ -65,8 +96,9 @@ export declare class CloudFormationStackDiagnoser {
      * error.
      */
     private _reportChangeSetFailureFromEvents;
-    private addErrorTraces;
-    private addErrorTrace;
+    private enhanceErrors;
+    private enhanceError;
+    private investigateResourceBestEffort;
     /**
      * Build a generic stack error from the given change set information
      *
@@ -94,6 +126,10 @@ export declare class CloudFormationStackDiagnoser {
      * ```
      */
     private _tryDetectFailedAutoImport;
+    /**
+     * Return the additional exploration SDK, if available.
+     */
+    private additionalExplorationSdk;
 }
 /**
  * Return true if the given change set has no changes