@aws-cdk/toolkit-lib 1.30.0 → 1.32.0

package/lib/api/diagnosing/investigate-custom-resource.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.investigateCustomResource = investigateCustomResource;
+const format_utils_1 = require("./format-utils");
+const resource_identifiers_1 = require("./resource-identifiers");
+const util_1 = require("../../util");
+/** Fallback look-back when no failure timestamp is available. */
+const FALLBACK_LOG_WINDOW_MS = 30 * 60 * 1000;
+/**
+ * How far before/after the failure event to search CloudWatch Logs when we have a timestamp.
+ *
+ * The pre-window absorbs minor clock skew; the post-window covers output the function
+ * emits while it runs after the CloudFormation event was recorded.
+ */
+const LOG_WINDOW_BEFORE_MS = 2 * 60 * 1000;
+const LOG_WINDOW_AFTER_MS = 15 * 60 * 1000;
+/**
+ * Investigate a failed custom resource by surfacing its backing Lambda's CloudWatch logs.
+ *
+ * The CloudFormation event does not name the backing function — only the resource's
+ * `ServiceToken` (in the template) does. We resolve that to a function name, derive the
+ * log group (the `/aws/lambda/<fn>` convention, confirmed via the function's LoggingConfig
+ * only if the convention turns up empty), and fetch the relevant log lines.
+ *
+ * When the handler uses the cfn-response library, the failing log stream name is embedded
+ * in the status reason ("See the details in CloudWatch Log Stream: <name>"), so we can
+ * target that exact invocation.
+ */
+async function investigateCustomResource(err, sdk, debug) {
+    if (!err.logicalId) {
+        await debug('Custom resource investigation: no logical ID available');
+        return [];
+    }
+    const stackName = err.stackArn;
+    if (!stackName) {
+        await debug('Custom resource investigation: no stack ARN available');
+        return [];
+    }
+    const cfn = sdk.cloudFormation();
+    const lambda = sdk.lambda();
+    const cwl = sdk.cloudWatchLogs();
+    const region = sdk.currentRegion;
+    // Fetch the template once: it carries both the ServiceToken and (for functions defined in
+    // this stack) the backing function's LoggingConfig. The template survives rollback even
+    // when the function itself is deleted, so it's the most reliable source for the log group.
+    const template = await getStackTemplate(cfn, stackName, debug);
+    if (!template) {
+        return [];
+    }
+    const serviceToken = template.Resources?.[err.logicalId]?.Properties?.ServiceToken;
+    if (serviceToken === undefined) {
+        await debug(`Custom resource investigation: no ServiceToken on resource "${err.logicalId}"`);
+        return [];
+    }
+    const referencedLogicalId = (0, resource_identifiers_1.serviceTokenReferencedLogicalId)(serviceToken);
+    const functionName = await resolveServiceTokenToFunctionName(cfn, stackName, serviceToken, referencedLogicalId, debug);
+    if (!functionName) {
+        await debug('Custom resource investigation: could not resolve ServiceToken to a Lambda function');
+        return [];
+    }
+    // Prefer the function's configured log group as derived from the template (rollback-proof).
+    // Only resolvable when the function is defined in this stack (ServiceToken is a Ref/GetAtt).
+    const templateLogGroup = referencedLogicalId
+        ? await resolveConfiguredLogGroup(cfn, stackName, template, referencedLogicalId, debug)
+        : undefined;
+    // The cfn-response library writes the failing log stream name into the status reason
+    // (and uses it as the default physical ID). Targeting it gives the exact invocation.
+    const streamName = (0, resource_identifiers_1.extractLogStreamName)(err.message) ?? (0, resource_identifiers_1.logStreamNameFromPhysicalId)(err.physicalId);
+    return fetchCustomResourceLogs(cwl, lambda, functionName, templateLogGroup, streamName, err.timestamp, region, debug);
+}
+/**
+ * Fetch and parse the stack's (original) template. Returns `undefined` if it can't be read.
+ */
+async function getStackTemplate(cfn, stackName, debug) {
+    try {
+        const resp = await cfn.getTemplate({ StackName: stackName, TemplateStage: 'Original' });
+        if (!resp.TemplateBody) {
+            await debug('Custom resource investigation: empty template body');
+            return undefined;
+        }
+        return (0, util_1.deserializeStructure)(resp.TemplateBody);
+    }
+    catch (e) {
+        await debug(`Custom resource investigation: failed to read template: ${e.message}`);
+        return undefined;
+    }
+}
+/**
+ * Resolve the backing Lambda's configured log group from the template.
+ *
+ * The template survives rollback (when the live function may not), so it is the preferred
+ * source. Handles the function's `LoggingConfig.LogGroup` as:
+ * - a literal string (returned directly);
+ * - a `Ref` to an `AWS::Logs::LogGroup` with a literal `LogGroupName` (returned directly);
+ * - a `Ref` to an `AWS::Logs::LogGroup` whose name CloudFormation generates (the common CDK
+ *   case) — resolved to its physical name via `describeStackResources`, which still returns
+ *   RETAINed/orphaned resources after a rollback.
+ *
+ * Returns `undefined` when there is no configured log group or it can't be resolved
+ * (caller then falls back to the live function configuration).
+ */
+async function resolveConfiguredLogGroup(cfn, stackName, template, functionLogicalId, debug) {
+    const logGroup = template.Resources?.[functionLogicalId]?.Properties?.LoggingConfig?.LogGroup;
+    if (typeof logGroup === 'string') {
+        return logGroup;
+    }
+    if (logGroup && typeof logGroup === 'object' && typeof logGroup.Ref === 'string') {
+        const referenced = template.Resources?.[logGroup.Ref];
+        const name = referenced?.Properties?.LogGroupName;
+        if (typeof name === 'string') {
+            return name;
+        }
+        // No explicit name (CloudFormation generates it) — resolve the log-group resource's
+        // physical name, which is the log group name.
+        return (await resolveStackResource(cfn, stackName, logGroup.Ref, debug))?.physicalId;
+    }
+    return undefined;
+}
+/**
+ * Resolve a resource's physical ID and type by logical ID. Returns `undefined` on failure.
+ */
+async function resolveStackResource(cfn, stackName, logicalId, debug) {
+    try {
+        const resp = await cfn.describeStackResources({ StackName: stackName, LogicalResourceId: logicalId });
+        const resource = resp.StackResources?.[0];
+        return resource ? { physicalId: resource.PhysicalResourceId, resourceType: resource.ResourceType } : undefined;
+    }
+    catch (e) {
+        await debug(`Custom resource investigation: failed to resolve resource "${logicalId}": ${e.message}`);
+        return undefined;
+    }
+}
+/**
+ * Resolve a `ServiceToken` value (a literal ARN, an `Fn::GetAtt`, or a `Ref`) to a Lambda
+ * function name. Intrinsics are resolved via `describeStackResources`.
+ */
+async function resolveServiceTokenToFunctionName(cfn, stackName, serviceToken, referencedLogicalId, debug) {
+    if (referencedLogicalId) {
+        const resource = await resolveStackResource(cfn, stackName, referencedLogicalId, debug);
+        // Only treat the reference as a Lambda function. Without this, a ServiceToken pointing at
+        // a non-Lambda resource (e.g. an SNS topic) whose physical ID is a bare name would be
+        // mistaken for a function name, producing a misleading /aws/lambda/<name> log lookup.
+        if (resource?.resourceType && resource.resourceType !== 'AWS::Lambda::Function') {
+            await debug(`Custom resource investigation: ServiceToken references a ${resource.resourceType}, not a Lambda function`);
+            return undefined;
+        }
+        return resource?.physicalId ? (0, resource_identifiers_1.functionNameFromArnOrName)(resource.physicalId) : undefined;
+    }
+    if (typeof serviceToken === 'string') {
+        return (0, resource_identifiers_1.functionNameFromArnOrName)(serviceToken);
+    }
+    await debug('Custom resource investigation: unsupported ServiceToken shape');
+    return undefined;
+}
+async function fetchCustomResourceLogs(cwl, lambda, functionName, templateLogGroup, streamName, timestamp, region, debug) {
+    const failureTime = timestamp?.valueOf();
+    const startTime = failureTime !== undefined ? failureTime - LOG_WINDOW_BEFORE_MS : Date.now() - FALLBACK_LOG_WINDOW_MS;
+    const endTime = failureTime !== undefined ? failureTime + LOG_WINDOW_AFTER_MS : undefined;
+    // Convention first; only pay for the configured group if the convention group doesn't yield usable lines (empty group or fetch error).
+    const conventionGroup = `/aws/lambda/${functionName}`;
+    let result = await fetchLogLines(cwl, conventionGroup, streamName, startTime, endTime, debug);
+    // The group we point the user at. Once we learn the function's configured log group, prefer
+    // it for the link even if it too is empty — it's where the function actually logs, whereas
+    // the convention group may not exist for advanced-logging functions.
+    let logGroup = conventionGroup;
+    if (result.kind !== 'lines') {
+        // Prefer the template-derived group (rollback-proof); fall back to the live function
+        // configuration only when the template couldn't tell us (e.g. unresolvable intrinsic, or
+        // the function is defined outside this stack).
+        const configuredGroup = templateLogGroup ?? await configuredLogGroup(lambda, functionName, debug);
+        if (configuredGroup && configuredGroup !== conventionGroup) {
+            logGroup = configuredGroup;
+            const configuredResult = await fetchLogLines(cwl, configuredGroup, streamName, startTime, endTime, debug);
+            // Keep the configured-group result unless it errored while the convention attempt was a
+            // clean empty (an "empty" answer is more informative to surface than a fetch error).
+            if (configuredResult.kind === 'lines' || result.kind !== 'empty') {
+                result = configuredResult;
+            }
+        }
+    }
+    // Lead with the log group so the user can tell which function these logs belong to
+    // (the formatter renders messages but not `source`, and the link is URL-encoded).
+    const header = `Logs from ${logGroup}:`;
+    const body = result.kind === 'lines'
+        ? result.lines
+        : result.kind === 'error'
+            ? ['Could not fetch logs (the log group may not exist, or the credentials lack logs:FilterLogEvents). See the console link below.']
+            : ['No log events found around the time of failure. The function may not have produced output, or logging may not be configured.'];
+    return [{
+            source: 'Custom Resource Lambda Logs',
+            messages: [header, ...body],
+            link: (0, format_utils_1.cloudWatchLogsConsoleUrl)(region, logGroup),
+            linkLabel: 'Logs',
+        }];
+}
+/**
+ * Fetch and trim recent log lines from a group.
+ *
+ * Tries the targeted stream first (most relevant), but the cfn-response stream name can be
+ * stale on update/rollback failures (it's pinned to the original create invocation). If the
+ * targeted query finds nothing, falls back to a group-wide scan over the time window so a
+ * stale stream can't hide the actual failing invocation's logs.
+ */
+async function fetchLogLines(cwl, logGroup, streamName, startTime, endTime, debug) {
+    if (streamName) {
+        const targeted = await filterLogLines(cwl, logGroup, streamName, startTime, endTime, debug);
+        if (targeted.kind === 'lines') {
+            return targeted;
+        }
+    }
+    return filterLogLines(cwl, logGroup, undefined, startTime, endTime, debug);
+}
+async function filterLogLines(cwl, logGroup, streamName, startTime, endTime, debug) {
+    try {
+        const resp = await cwl.filterLogEvents({
+            logGroupName: logGroup,
+            startTime,
+            ...(endTime !== undefined ? { endTime } : {}),
+            limit: 1000,
+            ...(streamName ? { logStreamNames: [streamName] } : {}),
+        });
+        const events = resp.events ?? [];
+        if (events.length === 0) {
+            await debug(`Custom resource investigation: no log events in ${logGroup}${streamName ? ` (stream: ${streamName})` : ''}`);
+            return { kind: 'empty' };
+        }
+        // Lambda log events have a known structure (text- or JSON-format), unlike raw ECS
+        // container output, so we normalize them into readable lines before trimming.
+        return { kind: 'lines', lines: (0, format_utils_1.trimToRecentLines)((0, format_utils_1.parseLambdaLogEvents)(events)) };
+    }
+    catch (e) {
+        await debug(`Custom resource investigation: failed to fetch logs from ${logGroup}: ${e.message}`);
+        return { kind: 'error' };
+    }
+}
+/** Read the function's configured (advanced-logging) log group, if any. */
+async function configuredLogGroup(lambda, functionName, debug) {
+    try {
+        const resp = await lambda.getFunctionConfiguration({ FunctionName: functionName });
+        return resp.LoggingConfig?.LogGroup;
+    }
+    catch (e) {
+        await debug(`Custom resource investigation: failed to read function configuration: ${e.message}`);
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"investigate-custom-resource.js","sourceRoot":"","sources":["investigate-custom-resource.ts"],"names":[],"mappings":"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","sourcesContent":["import { trimToRecentLines, parseLambdaLogEvents, cloudWatchLogsConsoleUrl } from './format-utils';\nimport {\n  serviceTokenReferencedLogicalId,\n  functionNameFromArnOrName,\n  extractLogStreamName,\n  logStreamNameFromPhysicalId,\n} from './resource-identifiers';\nimport type { AdditionalDiagnosticContext } from '../../actions/diagnose';\nimport { deserializeStructure } from '../../util';\nimport type { ICloudFormationClient, ICloudWatchLogsClient, ILambdaClient, 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 * How far before/after the failure event to search CloudWatch Logs when we have a timestamp.\n *\n * The pre-window absorbs minor clock skew; the post-window covers output the function\n * emits while it runs after the CloudFormation event was recorded.\n */\nconst LOG_WINDOW_BEFORE_MS = 2 * 60 * 1000;\nconst LOG_WINDOW_AFTER_MS = 15 * 60 * 1000;\n\n/**\n * Investigate a failed custom resource by surfacing its backing Lambda's CloudWatch logs.\n *\n * The CloudFormation event does not name the backing function — only the resource's\n * `ServiceToken` (in the template) does. We resolve that to a function name, derive the\n * log group (the `/aws/lambda/<fn>` convention, confirmed via the function's LoggingConfig\n * only if the convention turns up empty), and fetch the relevant log lines.\n *\n * When the handler uses the cfn-response library, the failing log stream name is embedded\n * in the status reason (\"See the details in CloudWatch Log Stream: <name>\"), so we can\n * target that exact invocation.\n */\nexport async function investigateCustomResource(\n  err: ResourceError,\n  sdk: SDK,\n  debug: (msg: string) => Promise<void>,\n): Promise<AdditionalDiagnosticContext[]> {\n  if (!err.logicalId) {\n    await debug('Custom resource investigation: no logical ID available');\n    return [];\n  }\n  const stackName = err.stackArn;\n  if (!stackName) {\n    await debug('Custom resource investigation: no stack ARN available');\n    return [];\n  }\n\n  const cfn = sdk.cloudFormation();\n  const lambda = sdk.lambda();\n  const cwl = sdk.cloudWatchLogs();\n  const region = sdk.currentRegion;\n\n  // Fetch the template once: it carries both the ServiceToken and (for functions defined in\n  // this stack) the backing function's LoggingConfig. The template survives rollback even\n  // when the function itself is deleted, so it's the most reliable source for the log group.\n  const template = await getStackTemplate(cfn, stackName, debug);\n  if (!template) {\n    return [];\n  }\n\n  const serviceToken = template.Resources?.[err.logicalId]?.Properties?.ServiceToken;\n  if (serviceToken === undefined) {\n    await debug(`Custom resource investigation: no ServiceToken on resource \"${err.logicalId}\"`);\n    return [];\n  }\n\n  const referencedLogicalId = serviceTokenReferencedLogicalId(serviceToken);\n  const functionName = await resolveServiceTokenToFunctionName(cfn, stackName, serviceToken, referencedLogicalId, debug);\n  if (!functionName) {\n    await debug('Custom resource investigation: could not resolve ServiceToken to a Lambda function');\n    return [];\n  }\n\n  // Prefer the function's configured log group as derived from the template (rollback-proof).\n  // Only resolvable when the function is defined in this stack (ServiceToken is a Ref/GetAtt).\n  const templateLogGroup = referencedLogicalId\n    ? await resolveConfiguredLogGroup(cfn, stackName, template, referencedLogicalId, debug)\n    : undefined;\n\n  // The cfn-response library writes the failing log stream name into the status reason\n  // (and uses it as the default physical ID). Targeting it gives the exact invocation.\n  const streamName = extractLogStreamName(err.message) ?? logStreamNameFromPhysicalId(err.physicalId);\n\n  return fetchCustomResourceLogs(cwl, lambda, functionName, templateLogGroup, streamName, err.timestamp, region, debug);\n}\n\n/**\n * Fetch and parse the stack's (original) template. Returns `undefined` if it can't be read.\n */\nasync function getStackTemplate(\n  cfn: ICloudFormationClient,\n  stackName: string,\n  debug: (msg: string) => Promise<void>,\n): Promise<any | undefined> {\n  try {\n    const resp = await cfn.getTemplate({ StackName: stackName, TemplateStage: 'Original' });\n    if (!resp.TemplateBody) {\n      await debug('Custom resource investigation: empty template body');\n      return undefined;\n    }\n    return deserializeStructure(resp.TemplateBody);\n  } catch (e: any) {\n    await debug(`Custom resource investigation: failed to read template: ${e.message}`);\n    return undefined;\n  }\n}\n\n/**\n * Resolve the backing Lambda's configured log group from the template.\n *\n * The template survives rollback (when the live function may not), so it is the preferred\n * source. Handles the function's `LoggingConfig.LogGroup` as:\n * - a literal string (returned directly);\n * - a `Ref` to an `AWS::Logs::LogGroup` with a literal `LogGroupName` (returned directly);\n * - a `Ref` to an `AWS::Logs::LogGroup` whose name CloudFormation generates (the common CDK\n *   case) — resolved to its physical name via `describeStackResources`, which still returns\n *   RETAINed/orphaned resources after a rollback.\n *\n * Returns `undefined` when there is no configured log group or it can't be resolved\n * (caller then falls back to the live function configuration).\n */\nasync function resolveConfiguredLogGroup(\n  cfn: ICloudFormationClient,\n  stackName: string,\n  template: any,\n  functionLogicalId: string,\n  debug: (msg: string) => Promise<void>,\n): Promise<string | undefined> {\n  const logGroup = template.Resources?.[functionLogicalId]?.Properties?.LoggingConfig?.LogGroup;\n  if (typeof logGroup === 'string') {\n    return logGroup;\n  }\n  if (logGroup && typeof logGroup === 'object' && typeof logGroup.Ref === 'string') {\n    const referenced = template.Resources?.[logGroup.Ref];\n    const name = referenced?.Properties?.LogGroupName;\n    if (typeof name === 'string') {\n      return name;\n    }\n    // No explicit name (CloudFormation generates it) — resolve the log-group resource's\n    // physical name, which is the log group name.\n    return (await resolveStackResource(cfn, stackName, logGroup.Ref, debug))?.physicalId;\n  }\n  return undefined;\n}\n\n/**\n * Resolve a resource's physical ID and type by logical ID. Returns `undefined` on failure.\n */\nasync function resolveStackResource(\n  cfn: ICloudFormationClient,\n  stackName: string,\n  logicalId: string,\n  debug: (msg: string) => Promise<void>,\n): Promise<{ physicalId?: string; resourceType?: string } | undefined> {\n  try {\n    const resp = await cfn.describeStackResources({ StackName: stackName, LogicalResourceId: logicalId });\n    const resource = resp.StackResources?.[0];\n    return resource ? { physicalId: resource.PhysicalResourceId, resourceType: resource.ResourceType } : undefined;\n  } catch (e: any) {\n    await debug(`Custom resource investigation: failed to resolve resource \"${logicalId}\": ${e.message}`);\n    return undefined;\n  }\n}\n\n/**\n * Resolve a `ServiceToken` value (a literal ARN, an `Fn::GetAtt`, or a `Ref`) to a Lambda\n * function name. Intrinsics are resolved via `describeStackResources`.\n */\nasync function resolveServiceTokenToFunctionName(\n  cfn: ICloudFormationClient,\n  stackName: string,\n  serviceToken: any,\n  referencedLogicalId: string | undefined,\n  debug: (msg: string) => Promise<void>,\n): Promise<string | undefined> {\n  if (referencedLogicalId) {\n    const resource = await resolveStackResource(cfn, stackName, referencedLogicalId, debug);\n    // Only treat the reference as a Lambda function. Without this, a ServiceToken pointing at\n    // a non-Lambda resource (e.g. an SNS topic) whose physical ID is a bare name would be\n    // mistaken for a function name, producing a misleading /aws/lambda/<name> log lookup.\n    if (resource?.resourceType && resource.resourceType !== 'AWS::Lambda::Function') {\n      await debug(`Custom resource investigation: ServiceToken references a ${resource.resourceType}, not a Lambda function`);\n      return undefined;\n    }\n    return resource?.physicalId ? functionNameFromArnOrName(resource.physicalId) : undefined;\n  }\n\n  if (typeof serviceToken === 'string') {\n    return functionNameFromArnOrName(serviceToken);\n  }\n\n  await debug('Custom resource investigation: unsupported ServiceToken shape');\n  return undefined;\n}\n\nasync function fetchCustomResourceLogs(\n  cwl: ICloudWatchLogsClient,\n  lambda: ILambdaClient,\n  functionName: string,\n  templateLogGroup: string | undefined,\n  streamName: string | undefined,\n  timestamp: Date | undefined,\n  region: string,\n  debug: (msg: string) => Promise<void>,\n): Promise<AdditionalDiagnosticContext[]> {\n  const failureTime = timestamp?.valueOf();\n  const startTime = failureTime !== undefined ? failureTime - LOG_WINDOW_BEFORE_MS : Date.now() - FALLBACK_LOG_WINDOW_MS;\n  const endTime = failureTime !== undefined ? failureTime + LOG_WINDOW_AFTER_MS : undefined;\n\n  // Convention first; only pay for the configured group if the convention group doesn't yield usable lines (empty group or fetch error).\n  const conventionGroup = `/aws/lambda/${functionName}`;\n  let result = await fetchLogLines(cwl, conventionGroup, streamName, startTime, endTime, debug);\n  // The group we point the user at. Once we learn the function's configured log group, prefer\n  // it for the link even if it too is empty — it's where the function actually logs, whereas\n  // the convention group may not exist for advanced-logging functions.\n  let logGroup = conventionGroup;\n\n  if (result.kind !== 'lines') {\n    // Prefer the template-derived group (rollback-proof); fall back to the live function\n    // configuration only when the template couldn't tell us (e.g. unresolvable intrinsic, or\n    // the function is defined outside this stack).\n    const configuredGroup = templateLogGroup ?? await configuredLogGroup(lambda, functionName, debug);\n    if (configuredGroup && configuredGroup !== conventionGroup) {\n      logGroup = configuredGroup;\n      const configuredResult = await fetchLogLines(cwl, configuredGroup, streamName, startTime, endTime, debug);\n      // Keep the configured-group result unless it errored while the convention attempt was a\n      // clean empty (an \"empty\" answer is more informative to surface than a fetch error).\n      if (configuredResult.kind === 'lines' || result.kind !== 'empty') {\n        result = configuredResult;\n      }\n    }\n  }\n\n  // Lead with the log group so the user can tell which function these logs belong to\n  // (the formatter renders messages but not `source`, and the link is URL-encoded).\n  const header = `Logs from ${logGroup}:`;\n  const body = result.kind === 'lines'\n    ? result.lines\n    : result.kind === 'error'\n      ? ['Could not fetch logs (the log group may not exist, or the credentials lack logs:FilterLogEvents). See the console link below.']\n      : ['No log events found around the time of failure. The function may not have produced output, or logging may not be configured.'];\n\n  return [{\n    source: 'Custom Resource Lambda Logs',\n    messages: [header, ...body],\n    link: cloudWatchLogsConsoleUrl(region, logGroup),\n    linkLabel: 'Logs',\n  }];\n}\n\n/**\n * Result of attempting to fetch logs from a group: the lines on success, or a reason we\n * have none — distinguishing an empty group from a failed fetch (e.g. missing permissions),\n * so the user-facing message can reflect the real cause.\n */\ntype LogFetchResult =\n  | { kind: 'lines'; lines: string[] }\n  | { kind: 'empty' }\n  | { kind: 'error' };\n\n/**\n * Fetch and trim recent log lines from a group.\n *\n * Tries the targeted stream first (most relevant), but the cfn-response stream name can be\n * stale on update/rollback failures (it's pinned to the original create invocation). If the\n * targeted query finds nothing, falls back to a group-wide scan over the time window so a\n * stale stream can't hide the actual failing invocation's logs.\n */\nasync function fetchLogLines(\n  cwl: ICloudWatchLogsClient,\n  logGroup: string,\n  streamName: string | undefined,\n  startTime: number,\n  endTime: number | undefined,\n  debug: (msg: string) => Promise<void>,\n): Promise<LogFetchResult> {\n  if (streamName) {\n    const targeted = await filterLogLines(cwl, logGroup, streamName, startTime, endTime, debug);\n    if (targeted.kind === 'lines') {\n      return targeted;\n    }\n  }\n  return filterLogLines(cwl, logGroup, undefined, startTime, endTime, debug);\n}\n\nasync function filterLogLines(\n  cwl: ICloudWatchLogsClient,\n  logGroup: string,\n  streamName: string | undefined,\n  startTime: number,\n  endTime: number | undefined,\n  debug: (msg: string) => Promise<void>,\n): Promise<LogFetchResult> {\n  try {\n    const resp = await cwl.filterLogEvents({\n      logGroupName: logGroup,\n      startTime,\n      ...(endTime !== undefined ? { endTime } : {}),\n      limit: 1000,\n      ...(streamName ? { logStreamNames: [streamName] } : {}),\n    });\n    const events = resp.events ?? [];\n    if (events.length === 0) {\n      await debug(`Custom resource investigation: no log events in ${logGroup}${streamName ? ` (stream: ${streamName})` : ''}`);\n      return { kind: 'empty' };\n    }\n    // Lambda log events have a known structure (text- or JSON-format), unlike raw ECS\n    // container output, so we normalize them into readable lines before trimming.\n    return { kind: 'lines', lines: trimToRecentLines(parseLambdaLogEvents(events)) };\n  } catch (e: any) {\n    await debug(`Custom resource investigation: failed to fetch logs from ${logGroup}: ${e.message}`);\n    return { kind: 'error' };\n  }\n}\n\n/** Read the function's configured (advanced-logging) log group, if any. */\nasync function configuredLogGroup(\n  lambda: ILambdaClient,\n  functionName: string,\n  debug: (msg: string) => Promise<void>,\n): Promise<string | undefined> {\n  try {\n    const resp = await lambda.getFunctionConfiguration({ FunctionName: functionName });\n    return resp.LoggingConfig?.LogGroup;\n  } catch (e: any) {\n    await debug(`Custom resource investigation: failed to read function configuration: ${e.message}`);\n    return undefined;\n  }\n}\n"]}

package/lib/api/diagnosing/investigate-ecs-service.d.ts

@@ -0,0 +1,20 @@
+import type { AdditionalDiagnosticContext } from '../../actions/diagnose';
+import type { SDK } from '../aws-auth/sdk';
+import type { ResourceError } from '../stack-events/resource-errors';
+/**
+ * Options that influence how a resource is investigated.
+ */
+export interface InvestigateOptions {
+    /**
+     * Whether CloudFormation rollback is enabled for this deployment.
+     *
+     * When rollback is enabled, a failed resource is torn down before we can
+     * inspect its runtime state, so we may suggest re-running with `--no-rollback`
+     * to retain that detail.
+     *
+     * @default true
+     */
+    readonly rollbackEnabled?: boolean;
+}
+export declare function investigateEcsService(err: ResourceError, sdk: SDK, debug: (msg: string) => Promise<void>, options: InvestigateOptions): Promise<AdditionalDiagnosticContext[]>;
+//# sourceMappingURL=investigate-ecs-service.d.ts.map

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"]}