aws-cdk
Version:
AWS CDK CLI, the command line tool for CDK apps
187 lines • 25.7 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.CloudWatchLogEventMonitor = void 0;
const util = require("util");
const chalk = require("chalk");
const uuid = require("uuid");
const private_1 = require("../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private");
const util_1 = require("../../util");
class CloudWatchLogEventMonitor {
constructor(props) {
/**
* Map of environment (account:region) to LogGroupsAccessSettings
*/
this.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
*/
this.pollingInterval = 2000;
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 next */
if (!this.monitorId) {
return;
}
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: %s', { 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 '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io';\nimport type { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';\nimport { IO } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';\nimport { flatten } from '../../util';\nimport type { SDK } from '../aws-auth';\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 next */\n    if (!this.monitorId) {\n      return;\n    }\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: %s', { 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"]}