@aws-cdk/toolkit-lib 1.29.1 → 1.31.0

package/lib/api/diagnosing/format-utils.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sideBySide = sideBySide;
+exports.wrapText = wrapText;
+exports.trimToRecentLines = trimToRecentLines;
+exports.parseLambdaLogEvents = parseLambdaLogEvents;
+exports.cloudWatchLogsConsoleUrl = cloudWatchLogsConsoleUrl;
+function sideBySide(left, sep, right) {
+    const width = left.map(x => x.length).reduce((acc, n) => Math.max(acc, n), 0);
+    const ret = [];
+    for (let i = 0; i < left.length || i < right.length; i++) {
+        const l = i < left.length ? left[i] : ' '.repeat(width);
+        const r = i < right.length ? right[i] : '';
+        ret.push(`${l}${sep}${r}`);
+    }
+    return ret;
+}
+function wrapText(n, text) {
+    const breakers = [' ', '\n'];
+    const ret = [];
+    let lineStart = 0;
+    while (lineStart < text.length) {
+        let lineEnd = lineStart + n;
+        while (lineEnd > lineStart && lineEnd < text.length && !breakers.includes(text[lineEnd])) {
+            lineEnd -= 1;
+        }
+        if (lineEnd === lineStart) {
+            // Could not find a space in this line. Seek forward to the first space to get the smallest line overflow
+            lineEnd = lineStart + n;
+            while (lineEnd < text.length && !breakers.includes(text[lineEnd])) {
+                lineEnd += 1;
+            }
+        }
+        ret.push(text.slice(lineStart, lineEnd));
+        lineStart = lineEnd + 1;
+    }
+    return ret;
+}
+// --- CloudWatch log formatting ---
+/**
+ * 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;
+/**
+ * Trim already-extracted log lines to the set we render.
+ *
+ * Keeps only the most recent {@link MAX_LOG_LINES} (newer output is more useful for
+ * diagnosis) and prepends an "N earlier lines omitted" marker when truncation happened.
+ * This is the single truncation point shared by all CloudWatch contexts — the formatter
+ * renders the result verbatim.
+ */
+function trimToRecentLines(lines) {
+    const messages = lines.slice(-MAX_LOG_LINES);
+    const omitted = lines.length - messages.length;
+    if (omitted > 0) {
+        messages.unshift(`... (${omitted} earlier lines omitted)`);
+    }
+    return messages;
+}
+/**
+ * Lambda platform log lines (text format) that carry no application signal.
+ */
+const LAMBDA_PLATFORM_LINE = /^(INIT_START|START RequestId:|END RequestId:|REPORT RequestId:)/;
+/**
+ * Normalize Lambda CloudWatch log events into readable lines.
+ *
+ * Lambda emits logs in one of two formats (per the function's `LoggingConfig.LogFormat`):
+ * - **Text**: `<timestamp>\t<requestId>\t<LEVEL>\t<message>`, plus platform lines.
+ * - **JSON**: one JSON object per event (`{ timestamp, level, message, ... }`).
+ *
+ * For both we surface `LEVEL  message` (or just the message when there's no level), strip the
+ * redundant per-line timestamp/requestId (it's all one invocation), and drop pure platform
+ * boilerplate. The level and message are combined into a single rendered line. We never drop
+ * application output — failure detail is often logged at INFO (e.g. the cfn-response "Response
+ * body" line). Anything we don't recognize passes through verbatim, and the full logs remain
+ * available via the console link.
+ *
+ * This is Lambda-specific; it is not applied to ECS logs, which are arbitrary container output.
+ */
+function parseLambdaLogEvents(events) {
+    const out = [];
+    for (const e of events) {
+        const raw = e.message;
+        if (raw == null) {
+            continue;
+        }
+        const normalized = normalizeLambdaLine(raw);
+        if (normalized !== undefined) {
+            out.push(normalized);
+        }
+    }
+    return out;
+}
+/**
+ * Normalize a single Lambda log line. Returns `undefined` to drop the line (platform noise),
+ * or the cleaned-up text to keep.
+ */
+function normalizeLambdaLine(raw) {
+    const trimmed = raw.trimEnd();
+    // JSON-format event: { timestamp, level, message, ... } (one object per line).
+    const jsonResult = normalizeJsonLogLine(trimmed);
+    if (jsonResult !== undefined) {
+        return jsonResult || undefined;
+    }
+    // Text-format platform boilerplate: drop.
+    if (LAMBDA_PLATFORM_LINE.test(trimmed)) {
+        return undefined;
+    }
+    // Text-format app line: `<ISO timestamp>\t<requestId>\t<LEVEL>\t<message>`.
+    // Strip the timestamp + requestId prefix; keep `LEVEL message` (or the rest verbatim).
+    const parts = trimmed.split('\t');
+    if (parts.length >= 4 && /^\d{4}-\d{2}-\d{2}T/.test(parts[0])) {
+        const level = parts[2];
+        const message = parts.slice(3).join('\t');
+        return formatLeveledLine(level, message);
+    }
+    // Unrecognized (continuation line, plain stdout, etc.) — keep verbatim.
+    return trimmed;
+}
+/**
+ * If `line` is a JSON-format Lambda log object, render it as `LEVEL  message` (the level
+ * space-padded to a fixed width; or just the message when there's no level). Returns
+ * `undefined` when it isn't JSON.
+ *
+ * Drops JSON platform events (`type`/`record` envelopes for `platform.*`), which carry no
+ * application signal.
+ */
+function normalizeJsonLogLine(line) {
+    if (!line.startsWith('{')) {
+        return undefined;
+    }
+    let obj;
+    try {
+        obj = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    if (!obj || typeof obj !== 'object') {
+        return undefined;
+    }
+    // Platform events (e.g. { type: 'platform.report', record: {...} }) — drop.
+    if (typeof obj.type === 'string' && obj.type.startsWith('platform.')) {
+        return '';
+    }
+    const level = typeof obj.level === 'string' ? obj.level : undefined;
+    // Lambda uses `message`; a thrown error envelope uses `errorMessage` (+ optional stackTrace).
+    let message;
+    if (typeof obj.message === 'string') {
+        message = obj.message;
+    }
+    else if (typeof obj.errorMessage === 'string') {
+        message = Array.isArray(obj.stackTrace) ? [obj.errorMessage, ...obj.stackTrace].join('\n') : obj.errorMessage;
+    }
+    else {
+        // JSON, but not a shape we recognize — render compactly rather than dropping signal.
+        message = line;
+    }
+    return level ? formatLeveledLine(level, message) : message;
+}
+/**
+ * Render a log level and message as `LEVEL  message`, padding the level to a fixed width so
+ * lines align in the terminal. Multi-line messages keep their internal newlines.
+ */
+function formatLeveledLine(level, message) {
+    return `${level.padEnd(5)} ${message}`;
+}
+// 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}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"format-utils.js","sourceRoot":"","sources":["format-utils.ts"],"names":[],"mappings":"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","sourcesContent":["export function sideBySide(left: string[], sep: string, right: string[]) {\n  const width = left.map(x => x.length).reduce((acc, n) => Math.max(acc, n), 0);\n\n  const ret: string[] = [];\n  for (let i = 0; i < left.length || i < right.length; i++) {\n    const l = i < left.length ? left[i] : ' '.repeat(width);\n    const r = i < right.length ? right[i] : '';\n    ret.push(`${l}${sep}${r}`);\n  }\n  return ret;\n}\n\nexport function wrapText(n: number, text: string): string[] {\n  const breakers = [' ', '\\n'];\n\n  const ret: string[] = [];\n  let lineStart = 0;\n  while (lineStart < text.length) {\n    let lineEnd = lineStart + n;\n    while (lineEnd > lineStart && lineEnd < text.length && !breakers.includes(text[lineEnd])) {\n      lineEnd -= 1;\n    }\n    if (lineEnd === lineStart) {\n      // Could not find a space in this line. Seek forward to the first space to get the smallest line overflow\n      lineEnd = lineStart + n;\n      while (lineEnd < text.length && !breakers.includes(text[lineEnd])) {\n        lineEnd += 1;\n      }\n    }\n\n    ret.push(text.slice(lineStart, lineEnd));\n    lineStart = lineEnd + 1;\n  }\n  return ret;\n}\n\n// --- CloudWatch log formatting ---\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 * Trim already-extracted log lines to the set we render.\n *\n * Keeps only the most recent {@link MAX_LOG_LINES} (newer output is more useful for\n * diagnosis) and prepends an \"N earlier lines omitted\" marker when truncation happened.\n * This is the single truncation point shared by all CloudWatch contexts — the formatter\n * renders the result verbatim.\n */\nexport function trimToRecentLines(lines: string[]): string[] {\n  const messages = lines.slice(-MAX_LOG_LINES);\n  const omitted = lines.length - messages.length;\n  if (omitted > 0) {\n    messages.unshift(`... (${omitted} earlier lines omitted)`);\n  }\n  return messages;\n}\n\n/**\n * Lambda platform log lines (text format) that carry no application signal.\n */\nconst LAMBDA_PLATFORM_LINE = /^(INIT_START|START RequestId:|END RequestId:|REPORT RequestId:)/;\n\n/**\n * Normalize Lambda CloudWatch log events into readable lines.\n *\n * Lambda emits logs in one of two formats (per the function's `LoggingConfig.LogFormat`):\n * - **Text**: `<timestamp>\\t<requestId>\\t<LEVEL>\\t<message>`, plus platform lines.\n * - **JSON**: one JSON object per event (`{ timestamp, level, message, ... }`).\n *\n * For both we surface `LEVEL  message` (or just the message when there's no level), strip the\n * redundant per-line timestamp/requestId (it's all one invocation), and drop pure platform\n * boilerplate. The level and message are combined into a single rendered line. We never drop\n * application output — failure detail is often logged at INFO (e.g. the cfn-response \"Response\n * body\" line). Anything we don't recognize passes through verbatim, and the full logs remain\n * available via the console link.\n *\n * This is Lambda-specific; it is not applied to ECS logs, which are arbitrary container output.\n */\nexport function parseLambdaLogEvents(events: Array<{ message?: string }>): string[] {\n  const out: string[] = [];\n  for (const e of events) {\n    const raw = e.message;\n    if (raw == null) {\n      continue;\n    }\n    const normalized = normalizeLambdaLine(raw);\n    if (normalized !== undefined) {\n      out.push(normalized);\n    }\n  }\n  return out;\n}\n\n/**\n * Normalize a single Lambda log line. Returns `undefined` to drop the line (platform noise),\n * or the cleaned-up text to keep.\n */\nfunction normalizeLambdaLine(raw: string): string | undefined {\n  const trimmed = raw.trimEnd();\n\n  // JSON-format event: { timestamp, level, message, ... } (one object per line).\n  const jsonResult = normalizeJsonLogLine(trimmed);\n  if (jsonResult !== undefined) {\n    return jsonResult || undefined;\n  }\n\n  // Text-format platform boilerplate: drop.\n  if (LAMBDA_PLATFORM_LINE.test(trimmed)) {\n    return undefined;\n  }\n\n  // Text-format app line: `<ISO timestamp>\\t<requestId>\\t<LEVEL>\\t<message>`.\n  // Strip the timestamp + requestId prefix; keep `LEVEL message` (or the rest verbatim).\n  const parts = trimmed.split('\\t');\n  if (parts.length >= 4 && /^\\d{4}-\\d{2}-\\d{2}T/.test(parts[0])) {\n    const level = parts[2];\n    const message = parts.slice(3).join('\\t');\n    return formatLeveledLine(level, message);\n  }\n\n  // Unrecognized (continuation line, plain stdout, etc.) — keep verbatim.\n  return trimmed;\n}\n\n/**\n * If `line` is a JSON-format Lambda log object, render it as `LEVEL  message` (the level\n * space-padded to a fixed width; or just the message when there's no level). Returns\n * `undefined` when it isn't JSON.\n *\n * Drops JSON platform events (`type`/`record` envelopes for `platform.*`), which carry no\n * application signal.\n */\nfunction normalizeJsonLogLine(line: string): string | undefined {\n  if (!line.startsWith('{')) {\n    return undefined;\n  }\n  let obj: any;\n  try {\n    obj = JSON.parse(line);\n  } catch {\n    return undefined;\n  }\n  if (!obj || typeof obj !== 'object') {\n    return undefined;\n  }\n\n  // Platform events (e.g. { type: 'platform.report', record: {...} }) — drop.\n  if (typeof obj.type === 'string' && obj.type.startsWith('platform.')) {\n    return '';\n  }\n\n  const level = typeof obj.level === 'string' ? obj.level : undefined;\n  // Lambda uses `message`; a thrown error envelope uses `errorMessage` (+ optional stackTrace).\n  let message: string;\n  if (typeof obj.message === 'string') {\n    message = obj.message;\n  } else if (typeof obj.errorMessage === 'string') {\n    message = Array.isArray(obj.stackTrace) ? [obj.errorMessage, ...obj.stackTrace].join('\\n') : obj.errorMessage;\n  } else {\n    // JSON, but not a shape we recognize — render compactly rather than dropping signal.\n    message = line;\n  }\n  return level ? formatLeveledLine(level, message) : message;\n}\n\n/**\n * Render a log level and message as `LEVEL  message`, padding the level to a fixed width so\n * lines align in the terminal. Multi-line messages keep their internal newlines.\n */\nfunction formatLeveledLine(level: string, message: string): string {\n  return `${level.padEnd(5)} ${message}`;\n}\n\n// CloudWatch console uses double-URI-encoding with '$' replacing '%' for the log group in the fragment.\nexport function 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"]}

package/lib/api/diagnosing/investigate-custom-resource.d.ts

@@ -0,0 +1,17 @@
+import type { AdditionalDiagnosticContext } from '../../actions/diagnose';
+import type { SDK } from '../aws-auth/sdk';
+import type { ResourceError } from '../stack-events/resource-errors';
+/**
+ * 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.
+ */
+export declare function investigateCustomResource(err: ResourceError, sdk: SDK, debug: (msg: string) => Promise<void>): Promise<AdditionalDiagnosticContext[]>;
+//# sourceMappingURL=investigate-custom-resource.d.ts.map

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