@aws-cdk/toolkit-lib 0.3.2 → 0.3.4

package/lib/api/logs-monitor/find-cloudwatch-logs.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCloudWatchLogGroups = findCloudWatchLogGroups;
+const util_1 = require("../../util");
+const cloudformation_1 = require("../cloudformation");
+const environment_1 = require("../environment");
+const private_1 = require("../io/private");
+const plugin_1 = require("../plugin");
+const toolkit_info_1 = require("../toolkit-info");
+// resource types that have associated CloudWatch Log Groups that should _not_ be monitored
+const IGNORE_LOGS_RESOURCE_TYPES = ['AWS::EC2::FlowLog', 'AWS::CloudTrail::Trail', 'AWS::CodeBuild::Project'];
+async function findCloudWatchLogGroups(sdkProvider, ioHelper, stackArtifact) {
+    let sdk;
+    const resolvedEnv = await sdkProvider.resolveEnvironment(stackArtifact.environment);
+    // try to assume the lookup role and fallback to the default credentials
+    try {
+        sdk = (await new environment_1.EnvironmentAccess(sdkProvider, toolkit_info_1.DEFAULT_TOOLKIT_STACK_NAME, ioHelper).accessStackForLookup(stackArtifact)).sdk;
+    }
+    catch (e) {
+        await ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Failed to access SDK environment: ${(0, util_1.formatErrorMessage)(e)}`));
+        sdk = (await sdkProvider.forEnvironment(resolvedEnv, plugin_1.Mode.ForReading)).sdk;
+    }
+    const listStackResources = new cloudformation_1.LazyListStackResources(sdk, stackArtifact.stackName);
+    const evaluateCfnTemplate = new cloudformation_1.EvaluateCloudFormationTemplate({
+        stackArtifact,
+        parameters: {},
+        account: resolvedEnv.account,
+        region: resolvedEnv.region,
+        partition: (await sdk.currentAccount()).partition,
+        sdk,
+    });
+    const stackResources = await listStackResources.listStackResources();
+    const logGroupNames = findAllLogGroupNames(stackResources, evaluateCfnTemplate);
+    return {
+        env: resolvedEnv,
+        sdk,
+        logGroupNames,
+    };
+}
+/**
+ * Determine if a CloudWatch Log Group is associated
+ * with an ignored resource
+ */
+function isReferencedFromIgnoredResource(logGroupResource, evaluateCfnTemplate) {
+    const resourcesReferencingLogGroup = evaluateCfnTemplate.findReferencesTo(logGroupResource.LogicalResourceId);
+    return resourcesReferencingLogGroup.some((reference) => {
+        return IGNORE_LOGS_RESOURCE_TYPES.includes(reference.Type);
+    });
+}
+const cloudWatchLogsResolvers = {
+    'AWS::Logs::LogGroup': (resource, evaluateCfnTemplate) => {
+        if (isReferencedFromIgnoredResource(resource, evaluateCfnTemplate)) {
+            return undefined;
+        }
+        return resource.PhysicalResourceId?.toString();
+    },
+    // Resource types that will create a CloudWatch log group with a specific name if one is not provided.
+    // The keys are CFN resource types, and the values are the name of the physical name property of that resource
+    // and the service name that is used in the automatically created CloudWatch log group.
+    'AWS::Lambda::Function': (resource, evaluateCfnTemplate) => {
+        const loggingConfig = evaluateCfnTemplate.getResourceProperty(resource.LogicalResourceId, 'LoggingConfig');
+        if (loggingConfig?.LogGroup) {
+            // if LogGroup is a string then use it as the LogGroupName as it is referred by LogGroup.fromLogGroupArn in CDK
+            if (typeof loggingConfig.LogGroup === 'string') {
+                return loggingConfig.LogGroup;
+            }
+            // if { Ref: '...' } is used then try to resolve the LogGroupName from the referenced resource in the template
+            if (typeof loggingConfig.LogGroup === 'object') {
+                if (loggingConfig.LogGroup.Ref) {
+                    return evaluateCfnTemplate.getResourceProperty(loggingConfig.LogGroup.Ref, 'LogGroupName');
+                }
+            }
+        }
+        return `/aws/lambda/${resource.PhysicalResourceId}`;
+    },
+};
+/**
+ * Find all CloudWatch Log Groups in the deployed template.
+ * This will find both explicitly created Log Groups (excluding those associated with ignored resources)
+ * and Log Groups created implicitly (i.e. Lambda Functions)
+ */
+function findAllLogGroupNames(stackResources, evaluateCfnTemplate) {
+    const logGroupNames = [];
+    for (const resource of stackResources) {
+        const logGroupResolver = cloudWatchLogsResolvers[resource.ResourceType];
+        if (logGroupResolver) {
+            const logGroupName = logGroupResolver(resource, evaluateCfnTemplate);
+            if (logGroupName) {
+                logGroupNames.push(logGroupName);
+            }
+        }
+    }
+    return logGroupNames;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"find-cloudwatch-logs.js","sourceRoot":"","sources":["find-cloudwatch-logs.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CloudFormationStackArtifact, Environment } from '@aws-cdk/cx-api';\nimport type { StackResourceSummary } from '@aws-sdk/client-cloudformation';\nimport { formatErrorMessage } from '../../util';\nimport type { SDK, SdkProvider } from '../aws-auth/private';\nimport { EvaluateCloudFormationTemplate, LazyListStackResources } from '../cloudformation';\nimport { EnvironmentAccess } from '../environment';\nimport { IO } from '../io/private';\nimport type { IoHelper } from '../io/private';\nimport { Mode } from '../plugin';\nimport { DEFAULT_TOOLKIT_STACK_NAME } from '../toolkit-info';\n\n// resource types that have associated CloudWatch Log Groups that should _not_ be monitored\nconst IGNORE_LOGS_RESOURCE_TYPES = ['AWS::EC2::FlowLog', 'AWS::CloudTrail::Trail', 'AWS::CodeBuild::Project'];\n\n/**\n * Configuration needed to monitor CloudWatch Log Groups\n * found in a given CloudFormation Stack\n */\nexport interface FoundLogGroupsResult {\n  /**\n   * The resolved environment (account/region) that the log\n   * groups are deployed in\n   */\n  readonly env: Environment;\n\n  /**\n   * The SDK that can be used to read events from the CloudWatch\n   * Log Groups in the given environment\n   */\n  readonly sdk: SDK;\n\n  /**\n   * The names of the relevant CloudWatch Log Groups\n   * in the given CloudFormation template\n   */\n  readonly logGroupNames: string[];\n}\n\nexport async function findCloudWatchLogGroups(\n  sdkProvider: SdkProvider,\n  ioHelper: IoHelper,\n  stackArtifact: CloudFormationStackArtifact,\n): Promise<FoundLogGroupsResult> {\n  let sdk: SDK;\n  const resolvedEnv = await sdkProvider.resolveEnvironment(stackArtifact.environment);\n  // try to assume the lookup role and fallback to the default credentials\n  try {\n    sdk = (await new EnvironmentAccess(sdkProvider, DEFAULT_TOOLKIT_STACK_NAME, ioHelper).accessStackForLookup(stackArtifact)).sdk;\n  } catch (e: any) {\n    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Failed to access SDK environment: ${formatErrorMessage(e)}`));\n    sdk = (await sdkProvider.forEnvironment(resolvedEnv, Mode.ForReading)).sdk;\n  }\n\n  const listStackResources = new LazyListStackResources(sdk, stackArtifact.stackName);\n  const evaluateCfnTemplate = new EvaluateCloudFormationTemplate({\n    stackArtifact,\n    parameters: {},\n    account: resolvedEnv.account,\n    region: resolvedEnv.region,\n    partition: (await sdk.currentAccount()).partition,\n    sdk,\n  });\n\n  const stackResources = await listStackResources.listStackResources();\n  const logGroupNames = findAllLogGroupNames(stackResources, evaluateCfnTemplate);\n\n  return {\n    env: resolvedEnv,\n    sdk,\n    logGroupNames,\n  };\n}\n\n/**\n * Determine if a CloudWatch Log Group is associated\n * with an ignored resource\n */\nfunction isReferencedFromIgnoredResource(\n  logGroupResource: StackResourceSummary,\n  evaluateCfnTemplate: EvaluateCloudFormationTemplate,\n): boolean {\n  const resourcesReferencingLogGroup = evaluateCfnTemplate.findReferencesTo(logGroupResource.LogicalResourceId!);\n  return resourcesReferencingLogGroup.some((reference) => {\n    return IGNORE_LOGS_RESOURCE_TYPES.includes(reference.Type);\n  });\n}\n\ntype CloudWatchLogsResolver = (\n  resource: StackResourceSummary,\n  evaluateCfnTemplate: EvaluateCloudFormationTemplate,\n) => string | undefined;\n\nconst cloudWatchLogsResolvers: Record<string, CloudWatchLogsResolver> = {\n  'AWS::Logs::LogGroup': (resource, evaluateCfnTemplate) => {\n    if (isReferencedFromIgnoredResource(resource, evaluateCfnTemplate)) {\n      return undefined;\n    }\n    return resource.PhysicalResourceId?.toString();\n  },\n\n  // Resource types that will create a CloudWatch log group with a specific name if one is not provided.\n  // The keys are CFN resource types, and the values are the name of the physical name property of that resource\n  // and the service name that is used in the automatically created CloudWatch log group.\n  'AWS::Lambda::Function': (resource, evaluateCfnTemplate) => {\n    const loggingConfig = evaluateCfnTemplate.getResourceProperty(resource.LogicalResourceId!, 'LoggingConfig');\n    if (loggingConfig?.LogGroup) {\n      // if LogGroup is a string then use it as the LogGroupName as it is referred by LogGroup.fromLogGroupArn in CDK\n      if (typeof loggingConfig.LogGroup === 'string') {\n        return loggingConfig.LogGroup;\n      }\n\n      // if { Ref: '...' } is used then try to resolve the LogGroupName from the referenced resource in the template\n      if (typeof loggingConfig.LogGroup === 'object') {\n        if (loggingConfig.LogGroup.Ref) {\n          return evaluateCfnTemplate.getResourceProperty(loggingConfig.LogGroup.Ref, 'LogGroupName');\n        }\n      }\n    }\n\n    return `/aws/lambda/${resource.PhysicalResourceId}`;\n  },\n};\n\n/**\n * Find all CloudWatch Log Groups in the deployed template.\n * This will find both explicitly created Log Groups (excluding those associated with ignored resources)\n * and Log Groups created implicitly (i.e. Lambda Functions)\n */\nfunction findAllLogGroupNames(\n  stackResources: StackResourceSummary[],\n  evaluateCfnTemplate: EvaluateCloudFormationTemplate,\n): string[] {\n  const logGroupNames: string[] = [];\n\n  for (const resource of stackResources) {\n    const logGroupResolver = cloudWatchLogsResolvers[resource.ResourceType!];\n    if (logGroupResolver) {\n      const logGroupName = logGroupResolver(resource, evaluateCfnTemplate);\n      if (logGroupName) {\n        logGroupNames.push(logGroupName);\n      }\n    }\n  }\n\n  return logGroupNames;\n}\n"]}

package/lib/api/logs-monitor/index.d.ts

@@ -0,0 +1,2 @@
+export * from './logs-monitor';
+export * from './find-cloudwatch-logs';

package/lib/api/logs-monitor/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./logs-monitor"), exports);
+__exportStar(require("./find-cloudwatch-logs"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsaURBQStCO0FBQy9CLHlEQUF1QyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbG9ncy1tb25pdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vZmluZC1jbG91ZHdhdGNoLWxvZ3MnO1xuIl19

package/lib/api/logs-monitor/logs-monitor.d.ts

@@ -0,0 +1,76 @@
+import type * as cxapi from '@aws-cdk/cx-api';
+import type { SDK } from '../aws-auth/private';
+import type { IoHelper } from '../io/private';
+export interface CloudWatchLogEventMonitorProps {
+    /**
+     * The IoHost used for messaging
+     */
+    readonly ioHelper: IoHelper;
+    /**
+     * The time from which we start reading log messages
+     *
+     * @default - now
+     */
+    readonly startTime?: Date;
+}
+export declare class CloudWatchLogEventMonitor {
+    /**
+     * Determines which events not to display
+     */
+    private startTime;
+    /**
+     * Map of environment (account:region) to LogGroupsAccessSettings
+     */
+    private readonly envsLogGroupsAccessSettings;
+    /**
+     * After reading events from all CloudWatch log groups
+     * how long should we wait to read more events.
+     *
+     * If there is some error with reading events (i.e. Throttle)
+     * then this is also how long we wait until we try again
+     */
+    private readonly pollingInterval;
+    monitorId?: string;
+    private readonly ioHelper;
+    constructor(props: CloudWatchLogEventMonitorProps);
+    /**
+     * resume reading/printing events
+     */
+    activate(): Promise<void>;
+    /**
+     * deactivates the monitor so no new events are read
+     * use case for this is when we are in the middle of performing a deployment
+     * and don't want to interweave all the logs together with the CFN
+     * deployment logs
+     *
+     * Also resets the start time to be when the new deployment was triggered
+     * and clears the list of tracked log groups
+     */
+    deactivate(): Promise<void>;
+    /**
+     * Adds CloudWatch log groups to read log events from.
+     * Since we could be watching multiple stacks that deploy to
+     * multiple environments (account+region), we need to store a list of log groups
+     * per env along with the SDK object that has access to read from
+     * that environment.
+     */
+    addLogGroups(env: cxapi.Environment, sdk: SDK, logGroupNames: string[]): void;
+    private logGroupNames;
+    private scheduleNextTick;
+    private tick;
+    /**
+     * Reads all new log events from a set of CloudWatch Log Groups
+     * in parallel
+     */
+    private readNewEvents;
+    /**
+     * Print out a cloudwatch event
+     */
+    private print;
+    /**
+     * Reads all new log events from a CloudWatch Log Group
+     * starting at either the time the hotswap was triggered or
+     * when the last event was read on the previous tick
+     */
+    private readEventsFromLogGroup;
+}

package/lib/api/logs-monitor/logs-monitor.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudWatchLogEventMonitor = void 0;
+const util = require("util");
+const chalk = require("chalk");
+const uuid = require("uuid");
+const util_1 = require("../../util");
+const private_1 = require("../io/private");
+class CloudWatchLogEventMonitor {
+    /**
+     * Determines which events not to display
+     */
+    startTime;
+    /**
+     * Map of environment (account:region) to LogGroupsAccessSettings
+     */
+    envsLogGroupsAccessSettings = new Map();
+    /**
+     * After reading events from all CloudWatch log groups
+     * how long should we wait to read more events.
+     *
+     * If there is some error with reading events (i.e. Throttle)
+     * then this is also how long we wait until we try again
+     */
+    pollingInterval = 2_000;
+    monitorId;
+    ioHelper;
+    constructor(props) {
+        this.startTime = props.startTime?.getTime() ?? Date.now();
+        this.ioHelper = props.ioHelper;
+    }
+    /**
+     * resume reading/printing events
+     */
+    async activate() {
+        this.monitorId = uuid.v4();
+        await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_I5032.msg('Start monitoring log groups', {
+            monitor: this.monitorId,
+            logGroupNames: this.logGroupNames(),
+        }));
+        await this.tick();
+        this.scheduleNextTick();
+    }
+    /**
+     * deactivates the monitor so no new events are read
+     * use case for this is when we are in the middle of performing a deployment
+     * and don't want to interweave all the logs together with the CFN
+     * deployment logs
+     *
+     * Also resets the start time to be when the new deployment was triggered
+     * and clears the list of tracked log groups
+     */
+    async deactivate() {
+        const oldMonitorId = this.monitorId;
+        this.monitorId = undefined;
+        this.startTime = Date.now();
+        await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_I5034.msg('Stopped monitoring log groups', {
+            monitor: oldMonitorId,
+            logGroupNames: this.logGroupNames(),
+        }));
+        this.envsLogGroupsAccessSettings.clear();
+    }
+    /**
+     * Adds CloudWatch log groups to read log events from.
+     * Since we could be watching multiple stacks that deploy to
+     * multiple environments (account+region), we need to store a list of log groups
+     * per env along with the SDK object that has access to read from
+     * that environment.
+     */
+    addLogGroups(env, sdk, logGroupNames) {
+        const awsEnv = `${env.account}:${env.region}`;
+        const logGroupsStartTimes = logGroupNames.reduce((acc, groupName) => {
+            acc[groupName] = this.startTime;
+            return acc;
+        }, {});
+        this.envsLogGroupsAccessSettings.set(awsEnv, {
+            sdk,
+            logGroupsStartTimes: {
+                ...this.envsLogGroupsAccessSettings.get(awsEnv)?.logGroupsStartTimes,
+                ...logGroupsStartTimes,
+            },
+        });
+    }
+    logGroupNames() {
+        return Array.from(this.envsLogGroupsAccessSettings.values()).flatMap((settings) => Object.keys(settings.logGroupsStartTimes));
+    }
+    scheduleNextTick() {
+        if (!this.monitorId) {
+            return;
+        }
+        setTimeout(() => void this.tick(), this.pollingInterval);
+    }
+    async tick() {
+        // excluding from codecoverage because this
+        // doesn't always run (depends on timing)
+        /* c8 ignore start */
+        if (!this.monitorId) {
+            return;
+        }
+        /* c8 ignore stop */
+        try {
+            const events = (0, util_1.flatten)(await this.readNewEvents());
+            for (const event of events) {
+                await this.print(event);
+            }
+            // We might have been stop()ped while the network call was in progress.
+            if (!this.monitorId) {
+                return;
+            }
+        }
+        catch (e) {
+            await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_E5035.msg(`Error occurred while monitoring logs: ${String(e)}`, { error: e }));
+        }
+        this.scheduleNextTick();
+    }
+    /**
+     * Reads all new log events from a set of CloudWatch Log Groups
+     * in parallel
+     */
+    async readNewEvents() {
+        const promises = [];
+        for (const settings of this.envsLogGroupsAccessSettings.values()) {
+            for (const group of Object.keys(settings.logGroupsStartTimes)) {
+                promises.push(this.readEventsFromLogGroup(settings, group));
+            }
+        }
+        // Limited set of log groups
+        // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
+        return Promise.all(promises);
+    }
+    /**
+     * Print out a cloudwatch event
+     */
+    async print(event) {
+        await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_I5033.msg(util.format('[%s] %s %s', chalk.blue(event.logGroupName), chalk.yellow(event.timestamp.toLocaleTimeString()), event.message.trim()), event));
+    }
+    /**
+     * Reads all new log events from a CloudWatch Log Group
+     * starting at either the time the hotswap was triggered or
+     * when the last event was read on the previous tick
+     */
+    async readEventsFromLogGroup(logGroupsAccessSettings, logGroupName) {
+        const events = [];
+        // log events from some service are ingested faster than others
+        // so we need to track the start/end time for each log group individually
+        // to make sure that we process all events from each log group
+        const startTime = logGroupsAccessSettings.logGroupsStartTimes[logGroupName] ?? this.startTime;
+        let endTime = startTime;
+        try {
+            const response = await logGroupsAccessSettings.sdk.cloudWatchLogs().filterLogEvents({
+                logGroupName: logGroupName,
+                limit: 100,
+                startTime: startTime,
+            });
+            const filteredEvents = response.events ?? [];
+            for (const event of filteredEvents) {
+                if (event.message) {
+                    events.push({
+                        message: event.message,
+                        logGroupName,
+                        timestamp: event.timestamp ? new Date(event.timestamp) : new Date(),
+                    });
+                    if (event.timestamp && endTime < event.timestamp) {
+                        endTime = event.timestamp;
+                    }
+                }
+            }
+            // As long as there are _any_ events in the log group `filterLogEvents` will return a nextToken.
+            // This is true even if these events are before `startTime`. So if we have 100 events and a nextToken
+            // then assume that we have hit the limit and let the user know some messages have been suppressed.
+            // We are essentially showing them a sampling (10000 events printed out is not very useful)
+            if (filteredEvents.length === 100 && response.nextToken) {
+                events.push({
+                    message: '>>> `watch` shows only the first 100 log messages - the rest have been truncated...',
+                    logGroupName,
+                    timestamp: new Date(endTime),
+                });
+            }
+        }
+        catch (e) {
+            // with Lambda functions the CloudWatch is not created
+            // until something is logged, so just keep polling until
+            // there is somthing to find
+            if (e.name === 'ResourceNotFoundException') {
+                return [];
+            }
+            throw e;
+        }
+        logGroupsAccessSettings.logGroupsStartTimes[logGroupName] = endTime + 1;
+        return events;
+    }
+}
+exports.CloudWatchLogEventMonitor = CloudWatchLogEventMonitor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logs-monitor.js","sourceRoot":"","sources":["logs-monitor.ts"],"names":[],"mappings":"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","sourcesContent":["import * as util from 'util';\nimport type * as cxapi from '@aws-cdk/cx-api';\nimport * as chalk from 'chalk';\nimport * as uuid from 'uuid';\nimport type { CloudWatchLogEvent } from '../../payloads/logs-monitor';\nimport { flatten } from '../../util';\nimport type { SDK } from '../aws-auth/private';\nimport { IO } from '../io/private';\nimport type { IoHelper } from '../io/private';\n\n/**\n * Configuration tracking information on the log groups that are\n * being monitored\n */\ninterface LogGroupsAccessSettings {\n  /**\n   * The SDK for a given environment (account/region)\n   */\n  readonly sdk: SDK;\n\n  /**\n   * A map of log groups and associated startTime in a given account.\n   *\n   * The monitor will read events from the log group starting at the\n   * associated startTime\n   */\n  readonly logGroupsStartTimes: { [logGroupName: string]: number };\n}\n\nexport interface CloudWatchLogEventMonitorProps {\n  /**\n   * The IoHost used for messaging\n   */\n  readonly ioHelper: IoHelper;\n\n  /**\n   * The time from which we start reading log messages\n   *\n   * @default - now\n   */\n  readonly startTime?: Date;\n}\n\nexport class CloudWatchLogEventMonitor {\n  /**\n   * Determines which events not to display\n   */\n  private startTime: number;\n\n  /**\n   * Map of environment (account:region) to LogGroupsAccessSettings\n   */\n  private readonly envsLogGroupsAccessSettings = new Map<string, LogGroupsAccessSettings>();\n\n  /**\n   * After reading events from all CloudWatch log groups\n   * how long should we wait to read more events.\n   *\n   * If there is some error with reading events (i.e. Throttle)\n   * then this is also how long we wait until we try again\n   */\n  private readonly pollingInterval: number = 2_000;\n\n  public monitorId?: string;\n  private readonly ioHelper: IoHelper;\n\n  constructor(props: CloudWatchLogEventMonitorProps) {\n    this.startTime = props.startTime?.getTime() ?? Date.now();\n    this.ioHelper = props.ioHelper;\n  }\n\n  /**\n   * resume reading/printing events\n   */\n  public async activate(): Promise<void> {\n    this.monitorId = uuid.v4();\n\n    await this.ioHelper.notify(IO.CDK_TOOLKIT_I5032.msg('Start monitoring log groups', {\n      monitor: this.monitorId,\n      logGroupNames: this.logGroupNames(),\n    }));\n\n    await this.tick();\n    this.scheduleNextTick();\n  }\n\n  /**\n   * deactivates the monitor so no new events are read\n   * use case for this is when we are in the middle of performing a deployment\n   * and don't want to interweave all the logs together with the CFN\n   * deployment logs\n   *\n   * Also resets the start time to be when the new deployment was triggered\n   * and clears the list of tracked log groups\n   */\n  public async deactivate(): Promise<void> {\n    const oldMonitorId = this.monitorId!;\n    this.monitorId = undefined;\n    this.startTime = Date.now();\n\n    await this.ioHelper.notify(IO.CDK_TOOLKIT_I5034.msg('Stopped monitoring log groups', {\n      monitor: oldMonitorId,\n      logGroupNames: this.logGroupNames(),\n    }));\n\n    this.envsLogGroupsAccessSettings.clear();\n  }\n\n  /**\n   * Adds CloudWatch log groups to read log events from.\n   * Since we could be watching multiple stacks that deploy to\n   * multiple environments (account+region), we need to store a list of log groups\n   * per env along with the SDK object that has access to read from\n   * that environment.\n   */\n  public addLogGroups(env: cxapi.Environment, sdk: SDK, logGroupNames: string[]): void {\n    const awsEnv = `${env.account}:${env.region}`;\n    const logGroupsStartTimes = logGroupNames.reduce(\n      (acc, groupName) => {\n        acc[groupName] = this.startTime;\n        return acc;\n      },\n      {} as { [logGroupName: string]: number },\n    );\n    this.envsLogGroupsAccessSettings.set(awsEnv, {\n      sdk,\n      logGroupsStartTimes: {\n        ...this.envsLogGroupsAccessSettings.get(awsEnv)?.logGroupsStartTimes,\n        ...logGroupsStartTimes,\n      },\n    });\n  }\n\n  private logGroupNames(): string[] {\n    return Array.from(this.envsLogGroupsAccessSettings.values()).flatMap((settings) => Object.keys(settings.logGroupsStartTimes));\n  }\n\n  private scheduleNextTick(): void {\n    if (!this.monitorId) {\n      return;\n    }\n\n    setTimeout(() => void this.tick(), this.pollingInterval);\n  }\n\n  private async tick(): Promise<void> {\n    // excluding from codecoverage because this\n    // doesn't always run (depends on timing)\n    /* c8 ignore start */\n    if (!this.monitorId) {\n      return;\n    }\n    /* c8 ignore stop */\n\n    try {\n      const events = flatten(await this.readNewEvents());\n      for (const event of events) {\n        await this.print(event);\n      }\n\n      // We might have been stop()ped while the network call was in progress.\n      if (!this.monitorId) {\n        return;\n      }\n    } catch (e: any) {\n      await this.ioHelper.notify(IO.CDK_TOOLKIT_E5035.msg(`Error occurred while monitoring logs: ${String(e)}`, { error: e }));\n    }\n\n    this.scheduleNextTick();\n  }\n\n  /**\n   * Reads all new log events from a set of CloudWatch Log Groups\n   * in parallel\n   */\n  private async readNewEvents(): Promise<Array<Array<CloudWatchLogEvent>>> {\n    const promises: Array<Promise<Array<CloudWatchLogEvent>>> = [];\n    for (const settings of this.envsLogGroupsAccessSettings.values()) {\n      for (const group of Object.keys(settings.logGroupsStartTimes)) {\n        promises.push(this.readEventsFromLogGroup(settings, group));\n      }\n    }\n    // Limited set of log groups\n    // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism\n    return Promise.all(promises);\n  }\n\n  /**\n   * Print out a cloudwatch event\n   */\n  private async print(event: CloudWatchLogEvent): Promise<void> {\n    await this.ioHelper.notify(IO.CDK_TOOLKIT_I5033.msg(\n      util.format(\n        '[%s] %s %s',\n        chalk.blue(event.logGroupName),\n        chalk.yellow(event.timestamp.toLocaleTimeString()),\n        event.message.trim(),\n      ),\n      event,\n    ));\n  }\n\n  /**\n   * Reads all new log events from a CloudWatch Log Group\n   * starting at either the time the hotswap was triggered or\n   * when the last event was read on the previous tick\n   */\n  private async readEventsFromLogGroup(\n    logGroupsAccessSettings: LogGroupsAccessSettings,\n    logGroupName: string,\n  ): Promise<Array<CloudWatchLogEvent>> {\n    const events: CloudWatchLogEvent[] = [];\n\n    // log events from some service are ingested faster than others\n    // so we need to track the start/end time for each log group individually\n    // to make sure that we process all events from each log group\n    const startTime = logGroupsAccessSettings.logGroupsStartTimes[logGroupName] ?? this.startTime;\n    let endTime = startTime;\n    try {\n      const response = await logGroupsAccessSettings.sdk.cloudWatchLogs().filterLogEvents({\n        logGroupName: logGroupName,\n        limit: 100,\n        startTime: startTime,\n      });\n      const filteredEvents = response.events ?? [];\n\n      for (const event of filteredEvents) {\n        if (event.message) {\n          events.push({\n            message: event.message,\n            logGroupName,\n            timestamp: event.timestamp ? new Date(event.timestamp) : new Date(),\n          });\n\n          if (event.timestamp && endTime < event.timestamp) {\n            endTime = event.timestamp;\n          }\n        }\n      }\n      // As long as there are _any_ events in the log group `filterLogEvents` will return a nextToken.\n      // This is true even if these events are before `startTime`. So if we have 100 events and a nextToken\n      // then assume that we have hit the limit and let the user know some messages have been suppressed.\n      // We are essentially showing them a sampling (10000 events printed out is not very useful)\n      if (filteredEvents.length === 100 && response.nextToken) {\n        events.push({\n          message: '>>> `watch` shows only the first 100 log messages - the rest have been truncated...',\n          logGroupName,\n          timestamp: new Date(endTime),\n        });\n      }\n    } catch (e: any) {\n      // with Lambda functions the CloudWatch is not created\n      // until something is logged, so just keep polling until\n      // there is somthing to find\n      if (e.name === 'ResourceNotFoundException') {\n        return [];\n      }\n      throw e;\n    }\n    logGroupsAccessSettings.logGroupsStartTimes[logGroupName] = endTime + 1;\n    return events;\n  }\n}\n"]}

package/lib/api/notices/cached-data-source.d.ts

@@ -0,0 +1,13 @@
+import type { Notice, NoticeDataSource } from './types';
+import type { IoDefaultMessages } from '../io/private';
+export declare class CachedDataSource implements NoticeDataSource {
+    private readonly ioMessages;
+    private readonly fileName;
+    private readonly dataSource;
+    private readonly skipCache?;
+    constructor(ioMessages: IoDefaultMessages, fileName: string, dataSource: NoticeDataSource, skipCache?: boolean | undefined);
+    fetch(): Promise<Notice[]>;
+    private fetchInner;
+    private load;
+    private save;
+}

package/lib/api/notices/cached-data-source.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachedDataSource = void 0;
+const fs = require("fs-extra");
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+const TIME_TO_LIVE_SUCCESS = 60 * 60 * 1000; // 1 hour
+const TIME_TO_LIVE_ERROR = 1 * 60 * 1000; // 1 minute
+class CachedDataSource {
+    ioMessages;
+    fileName;
+    dataSource;
+    skipCache;
+    constructor(ioMessages, fileName, dataSource, skipCache) {
+        this.ioMessages = ioMessages;
+        this.fileName = fileName;
+        this.dataSource = dataSource;
+        this.skipCache = skipCache;
+    }
+    async fetch() {
+        const cachedData = await this.load();
+        const data = cachedData.notices;
+        const expiration = cachedData.expiration ?? 0;
+        if (Date.now() > expiration || this.skipCache) {
+            let updatedData = cachedData;
+            try {
+                updatedData = await this.fetchInner();
+            }
+            catch (e) {
+                this.ioMessages.debug(`Could not refresh notices: ${e}`);
+                updatedData = {
+                    expiration: Date.now() + TIME_TO_LIVE_ERROR,
+                    notices: [],
+                };
+                throw toolkit_error_1.ToolkitError.withCause('Failed to load CDK notices. Please try again later.', e);
+            }
+            finally {
+                await this.save(updatedData);
+            }
+            return updatedData.notices;
+        }
+        else {
+            this.ioMessages.debug(`Reading cached notices from ${this.fileName}`);
+            return data;
+        }
+    }
+    async fetchInner() {
+        return {
+            expiration: Date.now() + TIME_TO_LIVE_SUCCESS,
+            notices: await this.dataSource.fetch(),
+        };
+    }
+    async load() {
+        const defaultValue = {
+            expiration: 0,
+            notices: [],
+        };
+        try {
+            return fs.existsSync(this.fileName)
+                ? await fs.readJSON(this.fileName)
+                : defaultValue;
+        }
+        catch (e) {
+            this.ioMessages.debug(`Failed to load notices from cache: ${e}`);
+            return defaultValue;
+        }
+    }
+    async save(cached) {
+        try {
+            await fs.writeJSON(this.fileName, cached);
+        }
+        catch (e) {
+            this.ioMessages.debug(`Failed to store notices in the cache: ${e}`);
+        }
+    }
+}
+exports.CachedDataSource = CachedDataSource;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/notices/filter.d.ts

@@ -0,0 +1,59 @@
+import { type IoDefaultMessages } from '../io/private';
+import type { BootstrappedEnvironment, Notice } from './types';
+export interface NoticesFilterFilterOptions {
+    readonly data: Notice[];
+    readonly cliVersion: string;
+    readonly outDir: string;
+    readonly bootstrappedEnvironments: BootstrappedEnvironment[];
+}
+export declare class NoticesFilter {
+    private readonly ioMessages;
+    constructor(ioMessages: IoDefaultMessages);
+    filter(options: NoticesFilterFilterOptions): FilteredNotice[];
+    /**
+     * From a set of input options, return the notices components we are searching for
+     */
+    private otherComponents;
+    /**
+     * Based on a set of component names, find all notices that match one of the given components
+     */
+    private findForNamedComponents;
+    /**
+     * Whether the given "affected component" name applies to the given actual component name.
+     *
+     * The name matches if the name is exactly the same, or the name in the notice
+     * is a prefix of the node name when the query ends in '.'.
+     */
+    private componentNameMatches;
+    /**
+     * Adds dynamic values from the given ActualComponents
+     *
+     * If there are multiple components with the same dynamic name, they are joined
+     * by a comma.
+     */
+    private addDynamicValues;
+    /**
+     * Treat 'framework' as an alias for either `aws-cdk-lib.` or `@aws-cdk/core.`.
+     *
+     * Because it's EITHER `aws-cdk-lib` or `@aws-cdk/core`, we need to add multiple
+     * arrays at the top level.
+     */
+    private resolveAliases;
+    /**
+     * Load the construct tree from the given directory and return its components
+     */
+    private constructTreeComponents;
+}
+/**
+ * Notice after passing the filter. A filter can augment a notice with
+ * dynamic values as it has access to the dynamic matching data.
+ */
+export declare class FilteredNotice {
+    readonly notice: Notice;
+    private readonly dynamicValues;
+    constructor(notice: Notice);
+    addDynamicValue(key: string, value: string): void;
+    format(): string;
+    private formatOverview;
+    private resolveDynamicValues;
+}