aws-cdk 0.0.0

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCloudWatchLogGroups = findCloudWatchLogGroups;
+const logging_1 = require("../../logging");
+const error_1 = require("../../util/error");
+const environment_access_1 = require("../environment-access");
+const evaluate_cloudformation_template_1 = require("../evaluate-cloudformation-template");
+const mode_1 = require("../plugin/mode");
+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, 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_access_1.EnvironmentAccess(sdkProvider, toolkit_info_1.DEFAULT_TOOLKIT_STACK_NAME).accessStackForLookup(stackArtifact)).sdk;
+    }
+    catch (e) {
+        (0, logging_1.debug)(`Failed to access SDK environment: ${(0, error_1.formatErrorMessage)(e)}`);
+        sdk = (await sdkProvider.forEnvironment(resolvedEnv, mode_1.Mode.ForReading)).sdk;
+    }
+    const listStackResources = new evaluate_cloudformation_template_1.LazyListStackResources(sdk, stackArtifact.stackName);
+    const evaluateCfnTemplate = new evaluate_cloudformation_template_1.EvaluateCloudFormationTemplate({
+        stackName: stackArtifact.stackName,
+        template: stackArtifact.template,
+        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) => {
+        var _a;
+        if (isReferencedFromIgnoredResource(resource, evaluateCfnTemplate)) {
+            return undefined;
+        }
+        return (_a = resource.PhysicalResourceId) === null || _a === void 0 ? void 0 : _a.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 === null || loggingConfig === void 0 ? void 0 : 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 { debug } from '../../logging';\nimport { formatErrorMessage } from '../../util/error';\nimport type { SDK, SdkProvider } from '../aws-auth';\nimport { EnvironmentAccess } from '../environment-access';\nimport { EvaluateCloudFormationTemplate, LazyListStackResources } from '../evaluate-cloudformation-template';\nimport { Mode } from '../plugin/mode';\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  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).accessStackForLookup(stackArtifact)).sdk;\n  } catch (e: any) {\n    debug(`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    stackName: stackArtifact.stackName,\n    template: stackArtifact.template,\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/logs-monitor.d.ts

@@ -0,0 +1,53 @@
+import * as cxapi from '@aws-cdk/cx-api';
+import type { SDK } from '../aws-auth';
+export declare class CloudWatchLogEventMonitor {
+    /**
+     * Determines which events not to display
+     */
+    private startTime;
+    /**
+     * Map of environment (account:region) to LogGroupsAccessSettings
+     */
+    private readonly envsLogGroupsAccessSettings;
+    private active;
+    constructor(startTime?: Date);
+    /**
+     * resume reading/printing events
+     */
+    activate(): 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(): 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 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/logs-monitor.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudWatchLogEventMonitor = void 0;
+const util = require("util");
+const chalk = require("chalk");
+const logging_1 = require("../../logging");
+const arrays_1 = require("../../util/arrays");
+/**
+ * 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
+ */
+const SLEEP = 2000;
+class CloudWatchLogEventMonitor {
+    constructor(startTime) {
+        var _a;
+        /**
+         * Map of environment (account:region) to LogGroupsAccessSettings
+         */
+        this.envsLogGroupsAccessSettings = new Map();
+        this.active = false;
+        this.startTime = (_a = startTime === null || startTime === void 0 ? void 0 : startTime.getTime()) !== null && _a !== void 0 ? _a : Date.now();
+    }
+    /**
+     * resume reading/printing events
+     */
+    activate() {
+        this.active = true;
+        this.scheduleNextTick(0);
+    }
+    /**
+     * 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() {
+        this.active = false;
+        this.startTime = Date.now();
+        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) {
+        var _a;
+        const awsEnv = `${env.account}:${env.region}`;
+        const logGroupsStartTimes = logGroupNames.reduce((acc, groupName) => {
+            acc[groupName] = this.startTime;
+            return acc;
+        }, {});
+        this.envsLogGroupsAccessSettings.set(awsEnv, {
+            sdk,
+            logGroupsStartTimes: {
+                ...(_a = this.envsLogGroupsAccessSettings.get(awsEnv)) === null || _a === void 0 ? void 0 : _a.logGroupsStartTimes,
+                ...logGroupsStartTimes,
+            },
+        });
+    }
+    scheduleNextTick(sleep) {
+        setTimeout(() => void this.tick(), sleep);
+    }
+    async tick() {
+        // excluding from codecoverage because this
+        // doesn't always run (depends on timing)
+        /* istanbul ignore next */
+        if (!this.active) {
+            return;
+        }
+        try {
+            const events = (0, arrays_1.flatten)(await this.readNewEvents());
+            events.forEach((event) => {
+                this.print(event);
+            });
+        }
+        catch (e) {
+            (0, logging_1.error)('Error occurred while monitoring logs: %s', e);
+        }
+        this.scheduleNextTick(SLEEP);
+    }
+    /**
+     * 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
+     */
+    print(event) {
+        (0, logging_1.info)(util.format('[%s] %s %s', chalk.blue(event.logGroupName), chalk.yellow(event.timestamp.toLocaleTimeString()), event.message.trim()));
+    }
+    /**
+     * 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) {
+        var _a, _b;
+        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 = (_a = logGroupsAccessSettings.logGroupsStartTimes[logGroupName]) !== null && _a !== void 0 ? _a : this.startTime;
+        let endTime = startTime;
+        try {
+            const response = await logGroupsAccessSettings.sdk.cloudWatchLogs().filterLogEvents({
+                logGroupName: logGroupName,
+                limit: 100,
+                startTime: startTime,
+            });
+            const filteredEvents = (_b = response.events) !== null && _b !== void 0 ? _b : [];
+            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 * as cxapi from '@aws-cdk/cx-api';\nimport * as chalk from 'chalk';\nimport { info, error } from '../../logging';\nimport { flatten } from '../../util/arrays';\nimport type { SDK } from '../aws-auth';\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 */\nconst SLEEP = 2_000;\n\n/**\n * Represents a CloudWatch Log Event that will be\n * printed to the terminal\n */\ninterface CloudWatchLogEvent {\n  /**\n   * The log event message\n   */\n  readonly message: string;\n\n  /**\n   * The name of the log group\n   */\n  readonly logGroupName: string;\n\n  /**\n   * The time at which the event occurred\n   */\n  readonly timestamp: Date;\n}\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 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  private active = false;\n\n  constructor(startTime?: Date) {\n    this.startTime = startTime?.getTime() ?? Date.now();\n  }\n\n  /**\n   * resume reading/printing events\n   */\n  public activate(): void {\n    this.active = true;\n    this.scheduleNextTick(0);\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 deactivate(): void {\n    this.active = false;\n    this.startTime = Date.now();\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 scheduleNextTick(sleep: number): void {\n    setTimeout(() => void this.tick(), sleep);\n  }\n\n  private async tick(): Promise<void> {\n    // excluding from codecoverage because this\n    // doesn't always run (depends on timing)\n    /* istanbul ignore next */\n    if (!this.active) {\n      return;\n    }\n    try {\n      const events = flatten(await this.readNewEvents());\n      events.forEach((event) => {\n        this.print(event);\n      });\n    } catch (e) {\n      error('Error occurred while monitoring logs: %s', e);\n    }\n\n    this.scheduleNextTick(SLEEP);\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 print(event: CloudWatchLogEvent): void {\n    info(\n      util.format(\n        '[%s] %s %s',\n        chalk.blue(event.logGroupName),\n        chalk.yellow(event.timestamp.toLocaleTimeString()),\n        event.message.trim(),\n      ),\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/plugin/context-provider-plugin.d.ts

@@ -0,0 +1,6 @@
+export interface ContextProviderPlugin {
+    getValue(args: {
+        [key: string]: any;
+    }): Promise<any>;
+}
+export declare function isContextProviderPlugin(x: unknown): x is ContextProviderPlugin;

package/lib/api/plugin/context-provider-plugin.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isContextProviderPlugin = isContextProviderPlugin;
+function isContextProviderPlugin(x) {
+    return typeof x === 'object' && !!x && !!x.getValue;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC1wcm92aWRlci1wbHVnaW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjb250ZXh0LXByb3ZpZGVyLXBsdWdpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUlBLDBEQUVDO0FBRkQsU0FBZ0IsdUJBQXVCLENBQUMsQ0FBVTtJQUNoRCxPQUFPLE9BQU8sQ0FBQyxLQUFLLFFBQVEsSUFBSSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBRSxDQUFTLENBQUMsUUFBUSxDQUFDO0FBQy9ELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIENvbnRleHRQcm92aWRlclBsdWdpbiB7XG4gIGdldFZhbHVlKGFyZ3M6IHtba2V5OiBzdHJpbmddOiBhbnl9KTogUHJvbWlzZTxhbnk+O1xufVxuXG5leHBvcnQgZnVuY3Rpb24gaXNDb250ZXh0UHJvdmlkZXJQbHVnaW4oeDogdW5rbm93bik6IHggaXMgQ29udGV4dFByb3ZpZGVyUGx1Z2luIHtcbiAgcmV0dXJuIHR5cGVvZiB4ID09PSAnb2JqZWN0JyAmJiAhIXggJiYgISEoeCBhcyBhbnkpLmdldFZhbHVlO1xufVxuIl19

package/lib/api/plugin/index.d.ts

@@ -0,0 +1,3 @@
+export * from './plugin';
+export * from './mode';
+export * from './context-provider-plugin';

package/lib/api/plugin/index.js

@@ -0,0 +1,20 @@
+"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("./plugin"), exports);
+__exportStar(require("./mode"), exports);
+__exportStar(require("./context-provider-plugin"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMkNBQXlCO0FBQ3pCLHlDQUF1QjtBQUN2Qiw0REFBMEMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3BsdWdpbic7XG5leHBvcnQgKiBmcm9tICcuL21vZGUnO1xuZXhwb3J0ICogZnJvbSAnLi9jb250ZXh0LXByb3ZpZGVyLXBsdWdpbic7XG4iXX0=

package/lib/api/plugin/mode.d.ts

@@ -0,0 +1,4 @@
+export declare enum Mode {
+    ForReading,
+    ForWriting
+}

package/lib/api/plugin/mode.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mode = void 0;
+var Mode;
+(function (Mode) {
+    Mode[Mode["ForReading"] = 0] = "ForReading";
+    Mode[Mode["ForWriting"] = 1] = "ForWriting";
+})(Mode || (exports.Mode = Mode = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm1vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUEsSUFBWSxJQUdYO0FBSEQsV0FBWSxJQUFJO0lBQ2QsMEJBQWEsQ0FBNEIsZ0JBQUEsQ0FBQTtJQUN6QywwQkFBYSxDQUE0QixnQkFBQSxDQUFBO0FBQzNDLENBQUMsRUFIVyxJQUFJLG9CQUFKLElBQUksUUFHZiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRm9yUmVhZGluZyBhcyBQbHVnaW5Gb3JSZWFkaW5nLCBGb3JXcml0aW5nIGFzIFBsdWdpbkZvcldyaXRpbmcgfSBmcm9tICdAYXdzLWNkay9jbGktcGx1Z2luLWNvbnRyYWN0JztcblxuZXhwb3J0IGVudW0gTW9kZSB7XG4gIEZvclJlYWRpbmcgPSAwIHNhdGlzZmllcyBQbHVnaW5Gb3JSZWFkaW5nLFxuICBGb3JXcml0aW5nID0gMSBzYXRpc2ZpZXMgUGx1Z2luRm9yV3JpdGluZyxcbn1cbiJdfQ==

package/lib/api/plugin/plugin.d.ts

@@ -0,0 +1,63 @@
+import type { CredentialProviderSource, IPluginHost } from '@aws-cdk/cli-plugin-contract';
+import { type ContextProviderPlugin } from './context-provider-plugin';
+export declare let TESTING: boolean;
+export declare function markTesting(): void;
+/**
+ * A utility to manage plug-ins.
+ *
+ */
+export declare class PluginHost implements IPluginHost {
+    static instance: PluginHost;
+    /**
+     * Access the currently registered CredentialProviderSources. New sources can
+     * be registered using the +registerCredentialProviderSource+ method.
+     */
+    readonly credentialProviderSources: CredentialProviderSource[];
+    readonly contextProviderPlugins: Record<string, ContextProviderPlugin>;
+    constructor();
+    /**
+     * Loads a plug-in into this PluginHost.
+     *
+     * @param moduleSpec the specification (path or name) of the plug-in module to be loaded.
+     */
+    load(moduleSpec: string): void;
+    /**
+     * Allows plug-ins to register new CredentialProviderSources.
+     *
+     * @param source a new CredentialProviderSource to register.
+     */
+    registerCredentialProviderSource(source: CredentialProviderSource): void;
+    /**
+     * (EXPERIMENTAL) Allow plugins to register context providers
+     *
+     * Context providers are objects with the following method:
+     *
+     * ```ts
+     *   getValue(args: {[key: string]: any}): Promise<any>;
+     * ```
+     *
+     * Currently, they cannot reuse the CDK's authentication mechanisms, so they
+     * must be prepared to either not make AWS calls or use their own source of
+     * AWS credentials.
+     *
+     * This feature is experimental, and only intended to be used internally at Amazon
+     * as a trial.
+     *
+     * After registering with 'my-plugin-name', the provider must be addressed as follows:
+     *
+     * ```ts
+     * const value = ContextProvider.getValue(this, {
+     *   providerName: 'plugin',
+     *   props: {
+     *     pluginName: 'my-plugin-name',
+     *     myParameter1: 'xyz',
+     *   },
+     *   includeEnvironment: true | false,
+     *   dummyValue: 'what-to-return-on-the-first-pass',
+     * })
+     * ```
+     *
+     * @experimental
+     */
+    registerContextProviderAlpha(pluginProviderName: string, provider: ContextProviderPlugin): void;
+}

package/lib/api/plugin/plugin.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginHost = exports.TESTING = void 0;
+exports.markTesting = markTesting;
+const util_1 = require("util");
+const chalk = require("chalk");
+const context_provider_plugin_1 = require("./context-provider-plugin");
+const logging_1 = require("../../logging");
+const error_1 = require("../../toolkit/error");
+exports.TESTING = false;
+function markTesting() {
+    exports.TESTING = true;
+}
+/**
+ * A utility to manage plug-ins.
+ *
+ */
+class PluginHost {
+    constructor() {
+        /**
+         * Access the currently registered CredentialProviderSources. New sources can
+         * be registered using the +registerCredentialProviderSource+ method.
+         */
+        this.credentialProviderSources = new Array();
+        this.contextProviderPlugins = {};
+        if (!exports.TESTING && PluginHost.instance && PluginHost.instance !== this) {
+            throw new error_1.ToolkitError('New instances of PluginHost must not be built. Use PluginHost.instance instead!');
+        }
+    }
+    /**
+     * Loads a plug-in into this PluginHost.
+     *
+     * @param moduleSpec the specification (path or name) of the plug-in module to be loaded.
+     */
+    load(moduleSpec) {
+        try {
+            /* eslint-disable @typescript-eslint/no-require-imports */
+            const plugin = require(moduleSpec);
+            /* eslint-enable */
+            if (!isPlugin(plugin)) {
+                (0, logging_1.error)(`Module ${chalk.green(moduleSpec)} is not a valid plug-in, or has an unsupported version.`);
+                throw new error_1.ToolkitError(`Module ${moduleSpec} does not define a valid plug-in.`);
+            }
+            if (plugin.init) {
+                plugin.init(this);
+            }
+        }
+        catch (e) {
+            (0, logging_1.error)(`Unable to load ${chalk.green(moduleSpec)}: ${e.stack}`);
+            throw new error_1.ToolkitError(`Unable to load plug-in: ${moduleSpec}: ${e}`);
+        }
+        function isPlugin(x) {
+            return x != null && x.version === '1';
+        }
+    }
+    /**
+     * Allows plug-ins to register new CredentialProviderSources.
+     *
+     * @param source a new CredentialProviderSource to register.
+     */
+    registerCredentialProviderSource(source) {
+        // Forward to the right credentials-related plugin host
+        this.credentialProviderSources.push(source);
+    }
+    /**
+     * (EXPERIMENTAL) Allow plugins to register context providers
+     *
+     * Context providers are objects with the following method:
+     *
+     * ```ts
+     *   getValue(args: {[key: string]: any}): Promise<any>;
+     * ```
+     *
+     * Currently, they cannot reuse the CDK's authentication mechanisms, so they
+     * must be prepared to either not make AWS calls or use their own source of
+     * AWS credentials.
+     *
+     * This feature is experimental, and only intended to be used internally at Amazon
+     * as a trial.
+     *
+     * After registering with 'my-plugin-name', the provider must be addressed as follows:
+     *
+     * ```ts
+     * const value = ContextProvider.getValue(this, {
+     *   providerName: 'plugin',
+     *   props: {
+     *     pluginName: 'my-plugin-name',
+     *     myParameter1: 'xyz',
+     *   },
+     *   includeEnvironment: true | false,
+     *   dummyValue: 'what-to-return-on-the-first-pass',
+     * })
+     * ```
+     *
+     * @experimental
+     */
+    registerContextProviderAlpha(pluginProviderName, provider) {
+        if (!(0, context_provider_plugin_1.isContextProviderPlugin)(provider)) {
+            throw new error_1.ToolkitError(`Object you gave me does not look like a ContextProviderPlugin: ${(0, util_1.inspect)(provider)}`);
+        }
+        this.contextProviderPlugins[pluginProviderName] = provider;
+    }
+}
+exports.PluginHost = PluginHost;
+PluginHost.instance = new PluginHost();
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/settings.d.ts

@@ -0,0 +1,29 @@
+export type SettingsMap = {
+    [key: string]: any;
+};
+/**
+ * If a context value is an object with this key set to a truthy value, it won't be saved to cdk.context.json
+ */
+export declare const TRANSIENT_CONTEXT_KEY = "$dontSaveContext";
+/**
+ * A single bag of settings
+ */
+export declare class Settings {
+    private settings;
+    readonly readOnly: boolean;
+    static mergeAll(...settings: Settings[]): Settings;
+    constructor(settings?: SettingsMap, readOnly?: boolean);
+    load(fileName: string): Promise<this>;
+    save(fileName: string): Promise<this>;
+    get all(): any;
+    merge(other: Settings): Settings;
+    subSettings(keyPrefix: string[]): Settings;
+    makeReadOnly(): Settings;
+    clear(): void;
+    get empty(): boolean;
+    get(path: string[]): any;
+    set(path: string[], value: any): Settings;
+    unset(path: string[]): void;
+    private prohibitContextKey;
+    private warnAboutContextKey;
+}