@aws-cdk/toolkit-lib 1.23.0 → 1.25.0

package/lib/api/source-tracing/private/stack-source-tracing.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StackArtifactSourceTracer = void 0;
+const fs = require("fs");
+const path = require("path");
+const cxapi = require("@aws-cdk/cloud-assembly-api");
+const cxschema = require("@aws-cdk/cloud-assembly-schema");
+/**
+ * Use a stack artifact as the root for tracing problems with this deployment
+ *
+ * The stack can be either the stack itself, or a nested stack inside it.
+ *
+ * ## Strategy
+ *
+ * The first thing we need to do is translate the given resource to a
+ * construct path.
+ *
+ * - The construct path can be found in the target template, if that option was
+ *   enabled during synthesis; or
+ * - We can (try to) dig it out of the `tree.json` once
+ *   https://github.com/aws/aws-cdk/pull/37630 is merged (although we still
+ *   need some information about the stack).
+ *
+ * Especially for nested stacks the above is hard, since this called from a
+ * place where we only have CloudFormation information (stack name). The stack
+ * name of a nested stack cannot be predicted in advance, and even if we have
+ * the list of logical IDs to get to the nested stack (which we do), finding
+ * the actual template is not easy.
+ */
+class StackArtifactSourceTracer {
+    stack;
+    constructor(stack) {
+        this.stack = stack;
+    }
+    async traceResource(_stackName, nestedStackLogicalIds, logicalId, propertyName) {
+        const containingTemplate = getStackTemplate(this.stack, nestedStackLogicalIds);
+        const constructPath = containingTemplate?.Resources?.[logicalId]?.Metadata?.[cxapi.PATH_METADATA_KEY];
+        if (!constructPath) {
+            return undefined;
+        }
+        return {
+            constructPath,
+            creationStackTrace: findCreationStackTrace(this.stack, constructPath),
+            mutationStackTraces: propertyName ? findMutationStackTraces(this.stack, constructPath, propertyName) : undefined,
+        };
+    }
+    async traceStack(_stackName, nestedStackLogicalIds) {
+        // This can either be a stack or nested stack. If it's a nested stack, trace the resource
+        // in the parent stack.
+        if (nestedStackLogicalIds.length > 0) {
+            const lastLogicalId = nestedStackLogicalIds.pop();
+            return this.traceResource(_stackName, nestedStackLogicalIds, lastLogicalId);
+        }
+        // Must be the root stack
+        const constructPath = this.stack.hierarchicalId;
+        return {
+            constructPath,
+            creationStackTrace: findCreationStackTrace(this.stack, constructPath),
+        };
+    }
+}
+exports.StackArtifactSourceTracer = StackArtifactSourceTracer;
+/**
+ * Try to find the creation stack trace for the given construct
+ *
+ * - This can be the 'trace' of adding the 'aws:cdk:logicalId' metadata.
+ * - This can also be dedicated metadata (we haven't added it yet).
+ *
+ * The construct path in metadata ALWAYS starts with a `/` while the construct path
+ * we have here probably doesn't, account for that as well.
+ *
+ * Stack's currently don't emit any stack traces.
+ */
+function findCreationStackTrace(stack, constructPath) {
+    const candidates = [
+        // logical ID traces
+        ...resourceMetadata(stack, constructPath, cxschema.ArtifactMetadataEntryType.LOGICAL_ID).flatMap((m) => {
+            if (m.trace) {
+                return [m.trace];
+            }
+            return [];
+        }),
+        // Creation stack
+        ...resourceMetadata(stack, constructPath, 'aws:cdk:creationStack').flatMap((m) => {
+            if (m.data) {
+                return [m.data];
+            }
+            return [];
+        }),
+    ];
+    return candidates[0];
+}
+/**
+ * Find property mutation stack traces
+ *
+ * These are all places in the code where a property's value is overwritten after
+ * construct creation.
+ */
+function findMutationStackTraces(stack, constructPath, propertyName) {
+    const assignments = resourceMetadata(stack, constructPath, 'aws:cdk:propertyAssignment');
+    return assignments.flatMap((m) => {
+        const data = m.data;
+        if (data?.propertyName === propertyName) {
+            return [data.stackTrace];
+        }
+        return [];
+    });
+}
+function resourceMetadata(stack, constructPath, metadataType) {
+    if (!constructPath.startsWith('/')) {
+        constructPath = '/' + constructPath;
+    }
+    return (stack.metadata[constructPath] ?? []).filter((m) => m.type === metadataType);
+}
+/**
+ * Find the stack template given a root stack and a logical ID path into nested stacks
+ */
+function getStackTemplate(stack, logicalIdPath) {
+    let template = stack.template;
+    const segments = [...logicalIdPath];
+    while (segments.length > 0) {
+        const next = segments.shift();
+        // The nested stack resource has metadata to tell us which (local) file
+        // we are looking for: "aws:asset:path".
+        const nextTemplateFile = template.Resources[next]?.Metadata?.[cxapi.ASSET_RESOURCE_METADATA_PATH_KEY];
+        if (!nextTemplateFile) {
+            return undefined;
+        }
+        const nextTemplatePath = path.join(path.dirname(stack.templateFullPath), nextTemplateFile);
+        template = JSON.parse(fs.readFileSync(nextTemplatePath, 'utf-8'));
+    }
+    return template;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-source-tracing.js","sourceRoot":"","sources":["stack-source-tracing.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport * as cxapi from '@aws-cdk/cloud-assembly-api';\nimport * as cxschema from '@aws-cdk/cloud-assembly-schema';\nimport type { SourceTrace } from '../types';\nimport type { ISourceTracer } from './source-tracing';\n\n/**\n * Use a stack artifact as the root for tracing problems with this deployment\n *\n * The stack can be either the stack itself, or a nested stack inside it.\n *\n * ## Strategy\n *\n * The first thing we need to do is translate the given resource to a\n * construct path.\n *\n * - The construct path can be found in the target template, if that option was\n *   enabled during synthesis; or\n * - We can (try to) dig it out of the `tree.json` once\n *   https://github.com/aws/aws-cdk/pull/37630 is merged (although we still\n *   need some information about the stack).\n *\n * Especially for nested stacks the above is hard, since this called from a\n * place where we only have CloudFormation information (stack name). The stack\n * name of a nested stack cannot be predicted in advance, and even if we have\n * the list of logical IDs to get to the nested stack (which we do), finding\n * the actual template is not easy.\n */\nexport class StackArtifactSourceTracer implements ISourceTracer {\n  constructor(private readonly stack: cxapi.CloudFormationStackArtifact) {\n  }\n\n  public async traceResource(\n    _stackName: string,\n    nestedStackLogicalIds: string[],\n    logicalId: string,\n    propertyName?: string,\n  ): Promise<SourceTrace | undefined> {\n    const containingTemplate = getStackTemplate(this.stack, nestedStackLogicalIds);\n\n    const constructPath = containingTemplate?.Resources?.[logicalId]?.Metadata?.[cxapi.PATH_METADATA_KEY];\n    if (!constructPath) {\n      return undefined;\n    }\n\n    return {\n      constructPath,\n      creationStackTrace: findCreationStackTrace(this.stack, constructPath),\n      mutationStackTraces: propertyName ? findMutationStackTraces(this.stack, constructPath, propertyName) : undefined,\n    };\n  }\n\n  public async traceStack(_stackName: string, nestedStackLogicalIds: string[]): Promise<SourceTrace | undefined> {\n    // This can either be a stack or nested stack. If it's a nested stack, trace the resource\n    // in the parent stack.\n    if (nestedStackLogicalIds.length > 0) {\n      const lastLogicalId = nestedStackLogicalIds.pop()!;\n      return this.traceResource(_stackName, nestedStackLogicalIds, lastLogicalId);\n    }\n\n    // Must be the root stack\n    const constructPath = this.stack.hierarchicalId;\n    return {\n      constructPath,\n      creationStackTrace: findCreationStackTrace(this.stack, constructPath),\n    };\n  }\n}\n\n/**\n * Try to find the creation stack trace for the given construct\n *\n * - This can be the 'trace' of adding the 'aws:cdk:logicalId' metadata.\n * - This can also be dedicated metadata (we haven't added it yet).\n *\n * The construct path in metadata ALWAYS starts with a `/` while the construct path\n * we have here probably doesn't, account for that as well.\n *\n * Stack's currently don't emit any stack traces.\n */\nfunction findCreationStackTrace(stack: cxapi.CloudFormationStackArtifact, constructPath: string): string[] | undefined {\n  const candidates = [\n    // logical ID traces\n    ...resourceMetadata(stack, constructPath, cxschema.ArtifactMetadataEntryType.LOGICAL_ID).flatMap((m) => {\n      if (m.trace) {\n        return [m.trace];\n      }\n      return [];\n    }),\n    // Creation stack\n    ...resourceMetadata(stack, constructPath, 'aws:cdk:creationStack').flatMap((m) => {\n      if (m.data) {\n        return [m.data as unknown as string[]];\n      }\n      return [];\n    }),\n  ];\n\n  return candidates[0];\n}\n\n/**\n * Find property mutation stack traces\n *\n * These are all places in the code where a property's value is overwritten after\n * construct creation.\n */\nfunction findMutationStackTraces(stack: cxapi.CloudFormationStackArtifact, constructPath: string, propertyName: string): string[][] | undefined {\n  const assignments = resourceMetadata(stack, constructPath, 'aws:cdk:propertyAssignment');\n\n  return assignments.flatMap((m) => {\n    const data: PropertyAssignmentData | undefined = m.data as any;\n    if (data?.propertyName === propertyName) {\n      return [data.stackTrace];\n    }\n    return [];\n  });\n}\n\nfunction resourceMetadata(stack: cxapi.CloudFormationStackArtifact, constructPath: string, metadataType: string): cxschema.MetadataEntry[] {\n  if (!constructPath.startsWith('/')) {\n    constructPath = '/' + constructPath;\n  }\n\n  return (stack.metadata[constructPath] ?? []).filter((m) => m.type === metadataType);\n}\n\n/**\n * Find the stack template given a root stack and a logical ID path into nested stacks\n */\nfunction getStackTemplate(stack: cxapi.CloudFormationStackArtifact, logicalIdPath: readonly string[]): any | undefined {\n  let template = stack.template;\n  const segments = [...logicalIdPath];\n  while (segments.length > 0) {\n    const next = segments.shift()!;\n\n    // The nested stack resource has metadata to tell us which (local) file\n    // we are looking for: \"aws:asset:path\".\n    const nextTemplateFile = template.Resources[next]?.Metadata?.[cxapi.ASSET_RESOURCE_METADATA_PATH_KEY];\n    if (!nextTemplateFile) {\n      return undefined;\n    }\n\n    const nextTemplatePath = path.join(path.dirname(stack.templateFullPath), nextTemplateFile);\n    template = JSON.parse(fs.readFileSync(nextTemplatePath, 'utf-8'));\n  }\n\n  return template;\n}\n\ninterface PropertyAssignmentData {\n  propertyName: string;\n  stackTrace: string[];\n}\n"]}

package/lib/api/source-tracing/types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Enough information to locate a certain CloudFormation resource in a CDK app
+ */
+export interface SourceTrace {
+    readonly constructPath: string;
+    readonly creationStackTrace?: string[];
+    readonly mutationStackTraces?: string[][];
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/api/source-tracing/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ0eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiXG4vKipcbiAqIEVub3VnaCBpbmZvcm1hdGlvbiB0byBsb2NhdGUgYSBjZXJ0YWluIENsb3VkRm9ybWF0aW9uIHJlc291cmNlIGluIGEgQ0RLIGFwcFxuICovXG5leHBvcnQgaW50ZXJmYWNlIFNvdXJjZVRyYWNlIHtcbiAgcmVhZG9ubHkgY29uc3RydWN0UGF0aDogc3RyaW5nO1xuICByZWFkb25seSBjcmVhdGlvblN0YWNrVHJhY2U/OiBzdHJpbmdbXTtcbiAgcmVhZG9ubHkgbXV0YXRpb25TdGFja1RyYWNlcz86IHN0cmluZ1tdW107XG59XG4iXX0=

package/lib/api/stack-events/resource-errors.d.ts

@@ -0,0 +1,82 @@
+import type { StackEvent } from '@aws-sdk/client-cloudformation';
+import type { ResourceEvent } from './stack-event-poller';
+export interface ResourceError {
+    /**
+     * The stack this resource error occurred in
+     *
+     * NOTE: This will be a stack ID (which is a full ARN including the unique identifier),
+     * not just a name.
+     */
+    readonly stackArn: string;
+    /**
+     * IDs of parent stacks of the resource, in case of resources in nested stacks
+     */
+    readonly parentStackLogicalIds: string[];
+    /**
+     * Logical ID of the resource
+     *
+     * (May be absent in case this message is about the stack itself)
+     */
+    readonly logicalId?: string;
+    /**
+     * Resource type
+     */
+    readonly resourceType?: string;
+    /**
+     * Physical ID of the resource
+     */
+    readonly physicalId?: string;
+    /**
+     * Error message of the resource
+     */
+    readonly message: string;
+    /**
+     * Error code of the resource
+     */
+    readonly errorCode?: string;
+}
+/**
+ * Class used to send stack event errors into, to come up with root causes.
+ */
+export declare class ResourceErrors {
+    /**
+     * A list of all non-cancellation errors we have seen.
+     *
+     * By the nature of the order we see events in, will be ordered from oldest to newest.
+     */
+    private readonly _errors;
+    isEmpty(): boolean;
+    get all(): ReadonlyArray<ResourceError>;
+    /**
+     * Update the error collection with the given stack activity
+     *
+     * May be from a nested stack as well.
+     *
+     * This class expects to see all events in chronological order.
+     */
+    update(...events: ResourceEvent[]): void;
+    /**
+     * Take our best guess at the error code of the root cause
+     *
+     * The first error that occurs is the root cause.
+     */
+    get rootCauseErrorCode(): string | undefined;
+    /**
+     * Return error messages of all encountered errors (that aren't cancellations)
+     */
+    get allErrorMessages(): string[];
+    /**
+     * Return error codeds of all encountered errors (that aren't cancellations nor stack errors)
+     *
+     * We don't need to include nested stack errors because our poller will poll the nested stack,
+     * and have returned the actual error as well.
+     */
+    get allErrorCodes(): string[];
+}
+/**
+ * Extract an error code from the given stack event.
+ *
+ * Always contains the services, and includes the handler error code if available.
+ */
+export declare function extractErrorCode(event: StackEvent): string;
+//# sourceMappingURL=resource-errors.d.ts.map

package/lib/api/stack-events/resource-errors.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceErrors = void 0;
+exports.extractErrorCode = extractErrorCode;
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+const cloudformation_1 = require("../../util/cloudformation");
+/**
+ * Class used to send stack event errors into, to come up with root causes.
+ */
+class ResourceErrors {
+    /**
+     * A list of all non-cancellation errors we have seen.
+     *
+     * By the nature of the order we see events in, will be ordered from oldest to newest.
+     */
+    _errors = [];
+    isEmpty() {
+        return this._errors.length === 0;
+    }
+    get all() {
+        return this._errors;
+    }
+    /**
+     * Update the error collection with the given stack activity
+     *
+     * May be from a nested stack as well.
+     *
+     * This class expects to see all events in chronological order.
+     */
+    update(...events) {
+        for (const event of events) {
+            if ((0, cloudformation_1.isErrorEvent)(event.event)) {
+                // Cancelled is not an interesting failure reason, nor is the stack message (stack
+                // message will just say something like "stack failed to update")
+                if (!(0, cloudformation_1.isCancellationEvent)(event.event) && (0, cloudformation_1.isRegularResourceEvent)(event.event)) {
+                    this._errors.push(errorFromEvent(event));
+                }
+            }
+        }
+    }
+    /**
+     * Take our best guess at the error code of the root cause
+     *
+     * The first error that occurs is the root cause.
+     */
+    get rootCauseErrorCode() {
+        return this.allErrorCodes[0];
+    }
+    /**
+     * Return error messages of all encountered errors (that aren't cancellations)
+     */
+    get allErrorMessages() {
+        return this._errors.map(e => e.message);
+    }
+    /**
+     * Return error codeds of all encountered errors (that aren't cancellations nor stack errors)
+     *
+     * We don't need to include nested stack errors because our poller will poll the nested stack,
+     * and have returned the actual error as well.
+     */
+    get allErrorCodes() {
+        return this._errors.map(e => e.errorCode).filter(x => typeof x === 'string');
+    }
+}
+exports.ResourceErrors = ResourceErrors;
+function errorFromEvent(ev) {
+    // FIXME: Check hooks
+    return {
+        logicalId: ev.event.LogicalResourceId ?? '',
+        message: ev.event.ResourceStatusReason ?? '',
+        parentStackLogicalIds: ev.parentStackLogicalIds,
+        resourceType: ev.event.ResourceType ?? '',
+        stackArn: ev.event.StackId ?? '',
+        errorCode: extractErrorCode(ev.event),
+        physicalId: ev.event.PhysicalResourceId,
+    };
+}
+/**
+ * Extract an error code from the given stack event.
+ *
+ * Always contains the services, and includes the handler error code if available.
+ */
+function extractErrorCode(event) {
+    const isOurCustomResource = OUR_CUSTOM_RESOURCE_TYPES.includes(event.ResourceType ?? '');
+    // Get the resource type; if it is non-AWS then we are done.
+    const resourceTypeParts = (event.ResourceType ?? '').split('::');
+    if (resourceTypeParts[0] !== 'AWS' && !isOurCustomResource) {
+        return toolkit_error_1.DeploymentErrorCodes.PRIVATE_RESOURCE_ERROR;
+    }
+    const resourceType = isOurCustomResource ? resourceTypeParts.join('') : resourceTypeParts.slice(1).join('');
+    const reason = event.ResourceStatusReason ?? '';
+    const errorRe = /(?:HandlerErrorCode:|Error Code:) ([a-zA-Z0-9:-]+)/;
+    const handlerCode = reason.match(errorRe);
+    return `${resourceType}:${handlerCode ? handlerCode[1] : toolkit_error_1.DeploymentErrorCodes.UNKNOWN_ERROR}`;
+}
+// Some custom resource types that the CDK standard library creates that we
+// would like to see it if they fail.
+const OUR_CUSTOM_RESOURCE_TYPES = [
+    'Custom::AWS',
+    'Custom::AWSCDK-EKS-Cluster',
+    'Custom::AWSCDK-EKS-FargateProfile',
+    'Custom::AWSCDK-EKS-HelmChart',
+    'Custom::AWSCDK-EKS-KubernetesObjectValue',
+    'Custom::AWSCDK-EKS-KubernetesPatch',
+    'Custom::AWSCDK-EKS-KubernetesResource',
+    'Custom::AWSCDKCfnJson',
+    'Custom::AWSCDKCfnJsonStringify',
+    'Custom::AWSCDKOpenIdConnectProvider',
+    'Custom::CDKBucketDeployment',
+    'Custom::CloudwatchLogResourcePolicy',
+    'Custom::CrossAccountZoneDelegation',
+    'Custom::CrossRegionExportReader',
+    'Custom::CrossRegionExportWriter',
+    'Custom::CrossRegionStringParameterReader',
+    'Custom::DeleteExistingRecordSet',
+    'Custom::DescribeCognitoUserPoolClient',
+    'Custom::DynamoDBReplica',
+    'Custom::ECRAutoDeleteImages',
+    'Custom::ElasticsearchAccessPolicy',
+    'Custom::LogRetention',
+    'Custom::OpenSearchAccessPolicy',
+    'Custom::S3AutoDeleteObjects',
+    'Custom::S3BucketNotifications',
+    'Custom::SyntheticsAutoDeleteUnderlyingResources',
+    'Custom::Trigger',
+    'Custom::UserPoolCloudFrontDomainName',
+    'Custom::VpcRestrictDefaultSG',
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource-errors.js","sourceRoot":"","sources":["resource-errors.ts"],"names":[],"mappings":"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","sourcesContent":["import type { StackEvent } from '@aws-sdk/client-cloudformation';\nimport type { ResourceEvent } from './stack-event-poller';\nimport { DeploymentErrorCodes } from '../../toolkit/toolkit-error';\nimport { isCancellationEvent, isErrorEvent, isRegularResourceEvent } from '../../util/cloudformation';\n\nexport interface ResourceError {\n  /**\n   * The stack this resource error occurred in\n   *\n   * NOTE: This will be a stack ID (which is a full ARN including the unique identifier),\n   * not just a name.\n   */\n  readonly stackArn: string;\n\n  /**\n   * IDs of parent stacks of the resource, in case of resources in nested stacks\n   */\n  readonly parentStackLogicalIds: string[];\n\n  /**\n   * Logical ID of the resource\n   *\n   * (May be absent in case this message is about the stack itself)\n   */\n  readonly logicalId?: string;\n\n  /**\n   * Resource type\n   */\n  readonly resourceType?: string;\n\n  /**\n   * Physical ID of the resource\n   */\n  readonly physicalId?: string;\n\n  /**\n   * Error message of the resource\n   */\n  readonly message: string;\n\n  /**\n   * Error code of the resource\n   */\n  readonly errorCode?: string;\n}\n\n/**\n * Class used to send stack event errors into, to come up with root causes.\n */\nexport class ResourceErrors {\n  /**\n   * A list of all non-cancellation errors we have seen.\n   *\n   * By the nature of the order we see events in, will be ordered from oldest to newest.\n   */\n  private readonly _errors: ResourceError[] = [];\n\n  public isEmpty() {\n    return this._errors.length === 0;\n  }\n\n  public get all(): ReadonlyArray<ResourceError> {\n    return this._errors;\n  }\n\n  /**\n   * Update the error collection with the given stack activity\n   *\n   * May be from a nested stack as well.\n   *\n   * This class expects to see all events in chronological order.\n   */\n  public update(...events: ResourceEvent[]) {\n    for (const event of events) {\n      if (isErrorEvent(event.event)) {\n        // Cancelled is not an interesting failure reason, nor is the stack message (stack\n        // message will just say something like \"stack failed to update\")\n        if (!isCancellationEvent(event.event) && isRegularResourceEvent(event.event)) {\n          this._errors.push(errorFromEvent(event));\n        }\n      }\n    }\n  }\n\n  /**\n   * Take our best guess at the error code of the root cause\n   *\n   * The first error that occurs is the root cause.\n   */\n  public get rootCauseErrorCode(): string | undefined {\n    return this.allErrorCodes[0];\n  }\n\n  /**\n   * Return error messages of all encountered errors (that aren't cancellations)\n   */\n  public get allErrorMessages(): string[] {\n    return this._errors.map(e => e.message);\n  }\n\n  /**\n   * Return error codeds of all encountered errors (that aren't cancellations nor stack errors)\n   *\n   * We don't need to include nested stack errors because our poller will poll the nested stack,\n   * and have returned the actual error as well.\n   */\n  public get allErrorCodes(): string[] {\n    return this._errors.map(e => e.errorCode).filter(x => typeof x === 'string');\n  }\n}\n\nfunction errorFromEvent(ev: ResourceEvent): ResourceError {\n  // FIXME: Check hooks\n\n  return {\n    logicalId: ev.event.LogicalResourceId ?? '',\n    message: ev.event.ResourceStatusReason ?? '',\n    parentStackLogicalIds: ev.parentStackLogicalIds,\n    resourceType: ev.event.ResourceType ?? '',\n    stackArn: ev.event.StackId ?? '',\n    errorCode: extractErrorCode(ev.event),\n    physicalId: ev.event.PhysicalResourceId,\n  };\n}\n\n/**\n * Extract an error code from the given stack event.\n *\n * Always contains the services, and includes the handler error code if available.\n */\nexport function extractErrorCode(event: StackEvent): string {\n  const isOurCustomResource = OUR_CUSTOM_RESOURCE_TYPES.includes(event.ResourceType ?? '');\n\n  // Get the resource type; if it is non-AWS then we are done.\n  const resourceTypeParts = (event.ResourceType ?? '').split('::');\n  if (resourceTypeParts[0] !== 'AWS' && !isOurCustomResource) {\n    return DeploymentErrorCodes.PRIVATE_RESOURCE_ERROR;\n  }\n\n  const resourceType = isOurCustomResource ? resourceTypeParts.join('') : resourceTypeParts.slice(1).join('');\n\n  const reason = event.ResourceStatusReason ?? '';\n\n  const errorRe = /(?:HandlerErrorCode:|Error Code:) ([a-zA-Z0-9:-]+)/;\n  const handlerCode = reason.match(errorRe);\n\n  return `${resourceType}:${handlerCode ? handlerCode[1] : DeploymentErrorCodes.UNKNOWN_ERROR}`;\n}\n\n// Some custom resource types that the CDK standard library creates that we\n// would like to see it if they fail.\nconst OUR_CUSTOM_RESOURCE_TYPES = [\n  'Custom::AWS',\n  'Custom::AWSCDK-EKS-Cluster',\n  'Custom::AWSCDK-EKS-FargateProfile',\n  'Custom::AWSCDK-EKS-HelmChart',\n  'Custom::AWSCDK-EKS-KubernetesObjectValue',\n  'Custom::AWSCDK-EKS-KubernetesPatch',\n  'Custom::AWSCDK-EKS-KubernetesResource',\n  'Custom::AWSCDKCfnJson',\n  'Custom::AWSCDKCfnJsonStringify',\n  'Custom::AWSCDKOpenIdConnectProvider',\n  'Custom::CDKBucketDeployment',\n  'Custom::CloudwatchLogResourcePolicy',\n  'Custom::CrossAccountZoneDelegation',\n  'Custom::CrossRegionExportReader',\n  'Custom::CrossRegionExportWriter',\n  'Custom::CrossRegionStringParameterReader',\n  'Custom::DeleteExistingRecordSet',\n  'Custom::DescribeCognitoUserPoolClient',\n  'Custom::DynamoDBReplica',\n  'Custom::ECRAutoDeleteImages',\n  'Custom::ElasticsearchAccessPolicy',\n  'Custom::LogRetention',\n  'Custom::OpenSearchAccessPolicy',\n  'Custom::S3AutoDeleteObjects',\n  'Custom::S3BucketNotifications',\n  'Custom::SyntheticsAutoDeleteUnderlyingResources',\n  'Custom::Trigger',\n  'Custom::UserPoolCloudFrontDomainName',\n  'Custom::VpcRestrictDefaultSG',\n];\n"]}

package/lib/api/stack-events/stack-activity-monitor.d.ts

@@ -1,5 +1,4 @@
 import type { CloudFormationStackArtifact } from '@aws-cdk/cloud-assembly-api';
-import type { StackEvent } from '@aws-sdk/client-cloudformation';
 import type { ICloudFormationClient } from '../aws-auth/private';
 import type { EnvironmentResources } from '../environment';
 import { type IoHelper } from '../io/private';
@@ -76,12 +75,6 @@ export declare class StackActivityMonitor {
      * Printers can decide to update a view less frequently if desired
      */
     private readonly pollingInterval;
-    /**
-     * A list of all non-cancellation errors we have seen.
-     *
-     * By the nature of the order we see events in, will be ordered from oldest to newest.
-     */
-    private readonly _errors;
     private monitorId?;
     private readonly progressMonitor;
     /**
@@ -99,22 +92,9 @@ export declare class StackActivityMonitor {
     private readonly envResources?;
     constructor({ cfn, ioHelper, stack, stackName, resourcesTotal, changeSetCreationTime, pollingInterval, envResources, }: StackActivityMonitorProps);
     /**
-     * Return error messages of all encountered errors (that aren't cancellations)
-     */
-    get allErrorMessages(): string[];
-    /**
-     * Return error codeds of all encountered errors (that aren't cancellations nor stack errors)
-     *
-     * We don't need to include nested stack errors because our poller will poll the nested stack,
-     * and have returned the actual error as well.
-     */
-    get allErrorCodes(): string[];
-    /**
-     * Take our best guess at the error code of the root cause
-     *
-     * The first error that occurs is the root cause.
+     * The resource errors that were discovered during monitoring of this stack
      */
-    get rootCauseErrorCode(): string | undefined;
+    get errors(): import("./resource-errors").ResourceErrors;
     start(): Promise<this>;
     stop(): Promise<void>;
     private scheduleNextTick;
@@ -149,12 +129,5 @@ export declare class StackActivityMonitor {
      * Formats a stack activity into a basic string
      */
     private formatActivity;
-    private checkForErrors;
 }
-/**
- * Extract an error code from the given stack event.
- *
- * Always contains the services, and includes the handler error code if available.
- */
-export declare function extractErrorCode(event: StackEvent): string;
 //# sourceMappingURL=stack-activity-monitor.d.ts.map