@aws-cdk/toolkit-lib 1.29.0 → 1.30.0

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

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.investigateResource = investigateResource;
+exports.parseEcsServiceIdentifier = parseEcsServiceIdentifier;
+/**
+ * Maximum number of log lines included per CloudWatch Logs context block.
+ *
+ * The formatter renders the messages array verbatim, so this is the
+ * single user-visible cap.
+ */
+const MAX_LOG_LINES = 50;
+/**
+ * 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 = {}) {
+    switch (err.resourceType) {
+        case 'AWS::ECS::Service':
+            return investigateEcsService(err, sdk, debug, options);
+        default:
+            return [];
+    }
+}
+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 } = 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;
+}
+/**
+ * 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 {};
+}
+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: 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() - 30 * 60 * 1000,
+            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;
+        }
+        // Keep the most recent lines (newer output is more useful for diagnosis).
+        // This is the only truncation point — the formatter renders these verbatim.
+        const allMessages = events
+            .map(e => e.message?.trimEnd())
+            .filter((m) => m != null);
+        const messages = allMessages.slice(-MAX_LOG_LINES);
+        const omitted = allMessages.length - messages.length;
+        if (omitted > 0) {
+            messages.unshift(`... (${omitted} earlier lines omitted)`);
+        }
+        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: cloudWatchLogsConsoleUrl(region, logConfig.logGroup),
+            linkLabel: 'Logs',
+        };
+    }
+    catch (e) {
+        await debug(`ECS investigation: failed to fetch logs from ${logConfig.logGroup}: ${e.message}`);
+        return undefined;
+    }
+}
+// CloudWatch console uses double-URI-encoding with '$' replacing '%' for the log group in the fragment.
+function cloudWatchLogsConsoleUrl(region, logGroup) {
+    const encodedLogGroup = encodeURIComponent(encodeURIComponent(logGroup)).replace(/%/g, '$');
+    return `https://${region}.console.aws.amazon.com/cloudwatch/home?region=${region}#logsV2:log-groups/log-group/${encodedLogGroup}`;
+}
+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,{"version":3,"file":"resource-investigation.js","sourceRoot":"","sources":["resource-investigation.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AdditionalDiagnosticContext } from '../../actions/diagnose';\nimport type { ICloudWatchLogsClient, IECSClient, SDK } from '../aws-auth/sdk';\nimport type { ResourceError } from '../stack-events/resource-errors';\n\n/**\n * Maximum number of log lines included per CloudWatch Logs context block.\n *\n * The formatter renders the messages array verbatim, so this is the\n * single user-visible cap.\n */\nconst MAX_LOG_LINES = 50;\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\n/**\n * Investigate a failed resource using AWS service APIs to gather additional root cause context.\n *\n * Returns additional diagnostic context (e.g. log lines) or an empty array if\n * investigation is not possible or yields no results for this resource type.\n */\nexport async function investigateResource(\n  err: ResourceError,\n  sdk: SDK,\n  debug: (msg: string) => Promise<void>,\n  options: InvestigateOptions = {},\n): Promise<AdditionalDiagnosticContext[]> {\n  switch (err.resourceType) {\n    case 'AWS::ECS::Service':\n      return investigateEcsService(err, sdk, debug, options);\n    default:\n      return [];\n  }\n}\n\nasync 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\n/**\n * Parse an ECS service physical resource ID into cluster and service identifiers.\n *\n * The cluster portion is a name (not an ARN) — `describeServices`/`describeTasks`\n * accept either form for their `cluster` parameter, so this is fine downstream.\n *\n * Recognized formats:\n * - Long ARN: `arn:aws:ecs:region:account:service/cluster-name/service-name` (current default)\n * - Path: `cluster-name/service-name`\n * - Bare service name (uses the default cluster)\n */\nexport function parseEcsServiceIdentifier(physicalId: string): { cluster?: string; serviceName?: string } {\n  const arnMatch = physicalId.match(/^arn:[^:]+:ecs:[^:]*:[^:]*:service\\/([^/]+)\\/([^/]+)$/);\n  if (arnMatch) {\n    return { cluster: arnMatch[1], serviceName: arnMatch[2] };\n  }\n\n  const parts = physicalId.split('/');\n  if (parts.length === 2 && parts[0] && parts[1]) {\n    return { cluster: parts[0], serviceName: parts[1] };\n  }\n  if (parts.length === 1 && parts[0]) {\n    return { serviceName: parts[0] };\n  }\n\n  return {};\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() - 30 * 60 * 1000,\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    // Keep the most recent lines (newer output is more useful for diagnosis).\n    // This is the only truncation point — the formatter renders these verbatim.\n    const allMessages = events\n      .map(e => e.message?.trimEnd())\n      .filter((m): m is string => m != null);\n    const messages: string[] = allMessages.slice(-MAX_LOG_LINES);\n    const omitted = allMessages.length - messages.length;\n    if (omitted > 0) {\n      messages.unshift(`... (${omitted} earlier lines omitted)`);\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\n// CloudWatch console uses double-URI-encoding with '$' replacing '%' for the log group in the fragment.\nfunction cloudWatchLogsConsoleUrl(region: string, logGroup: string): string {\n  const encodedLogGroup = encodeURIComponent(encodeURIComponent(logGroup)).replace(/%/g, '$');\n  return `https://${region}.console.aws.amazon.com/cloudwatch/home?region=${region}#logsV2:log-groups/log-group/${encodedLogGroup}`;\n}\n\nfunction ecsStoppedTasksConsoleUrl(region: string, cluster: string, serviceName: string): string {\n  return `https://${region}.console.aws.amazon.com/ecs/v2/clusters/${cluster}/services/${serviceName}/tasks?status=STOPPED&region=${region}`;\n}\n"]}

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