Cdklabs.CdkMonitoringConstructs 10.3.2

CDK Monitoring Constructs

Easy-to-use CDK constructs for monitoring your AWS infrastructure with Amazon CloudWatch.

• Easily add commonly-used alarms using predefined properties
• Generate concise CloudWatch dashboards that indicate your alarms
• Extend the library with your own extensions or custom metrics
• Consume the library in multiple supported languages

Installation

<details><summary><strong>TypeScript</strong></summary>

https://www.npmjs.com/package/cdk-monitoring-constructs

In your package.json:

{
  "dependencies": {
    "cdk-monitoring-constructs": "^9.0.0",

    // peer dependencies of cdk-monitoring-constructs
    "aws-cdk-lib": "^2.160.0",
    "constructs": "^10.0.5"

    // ...your other dependencies...
  }
}

</details><details><summary><strong>Java</strong></summary>

See https://mvnrepository.com/artifact/io.github.cdklabs/cdkmonitoringconstructs

</details><details><summary><strong>Python</strong></summary>

See https://pypi.org/project/cdk-monitoring-constructs/

</details><details><summary><strong>C#</strong></summary>

See https://www.nuget.org/packages/Cdklabs.CdkMonitoringConstructs/

</details>

Features

You can browse the documentation at https://constructs.dev/packages/cdk-monitoring-constructs/

Getting started

Create a facade

Important note: Please, do NOT import anything from the /dist/lib package. This is unsupported and might break any time.

1. Create an instance of MonitoringFacade, which is the main entrypoint.
2. Call methods on the facade like .monitorLambdaFunction() and chain them together to define your monitors. You can also use methods to add your own widgets, headers of various sizes, and more.

For examples of monitoring different resources, refer to the unit tests.

// Example automatically generated from non-compiling source. May contain errors.
class MonitoringStackProps : DeploymentStackProps
{
}

// This could be in the same stack as your resources, as a nested stack, or a separate stack as you see fit
class MonitoringStack : DeploymentStack
{
    public MonitoringStack(App parent, string name, MonitoringStackProps props) : base(parent, name, props)
    {

        var monitoring = new MonitoringFacade(this, "Monitoring", new Struct {
            // Defaults are provided for these, but they can be customized as desired
            MetricFactoryDefaults = new Struct { ... },
            AlarmFactoryDefaults = new Struct { ... },
            DashboardFactory = new Struct { ... }
        });

        // Monitor your resources
        monitoring.AddLargeHeader("Storage").MonitorDynamoTable(new Struct { }).MonitorDynamoTable(new Struct { }).MonitorLambdaFunction(new Struct { }).MonitorCustom(new Struct { });
    }
}

Customize actions

Alarms should have actions set up, otherwise they are not very useful.

Example of notifying an SNS topic:

// Example automatically generated from non-compiling source. May contain errors.
ITopic onAlarmTopic;

var monitoring = new MonitoringFacade(this, "Monitoring", new Struct {
    // ...other props
    AlarmFactoryDefaults = new Struct {
        // ....other props
        Action = new SnsAlarmActionStrategy(new Struct { OnAlarmTopic = onAlarmTopic })
    }
});

You can override the default topic for any alarm like this:

// Example automatically generated from non-compiling source. May contain errors.
monitoring.MonitorSomething(something, new Struct {
    AddSomeAlarm = new Struct {
        Warning = new Struct {
            // ...other props
            Threshold = 42,
            ActionOverride = new SnsAlarmActionStrategy(new Struct { OnAlarmTopic = onAlarmTopic })
        }
    }
});

Supported actions can be found here, including SNS and Lambda.

You can also compose multiple actions using multipleActions:

// Example automatically generated from non-compiling source. May contain errors.
ITopic onAlarmTopic;
IFunction onAlarmFunction;

var action = MultipleActions(NotifySns(onAlarmTopic), TriggerLambda(onAlarmFunction));

Custom metrics

For simply adding some custom metrics, you can use .monitorCustom() and specify your own title and metric groups. Each metric group will be rendered as a single graph widget, and all widgets will be placed next to each other. All the widgets will have the same size, which is chosen based on the number of groups to maximize dashboard space usage.

Custom metric monitoring can be created for simple metrics, simple metrics with anomaly detection and search metrics. The first two also support alarming.

Below we are listing a couple of examples. Let us assume that there are three existing metric variables: m1, m2, m3. They can either be created by hand (new Metric({...})) or (preferably) by using metricFactory (that can be obtained from facade). The advantage of using the shared metricFactory is that you do not need to worry about period, etc.

// Example automatically generated from non-compiling source. May contain errors.
// create metrics manually
var m1 = new Metric();

// Example automatically generated from non-compiling source. May contain errors.
var metricFactory = monitoringFacade.CreateMetricFactory();

// create metrics using metric factory
var m1 = metricFactory.CreateMetric();

Example: metric with anomaly detection

In this case, only one metric is supported. Multiple metrics cannot be rendered with anomaly detection in a single widget due to a CloudWatch limitation.

MonitorCustom(new Dictionary<string, object> {
    { "title", "Metric with anomaly detection" },
    { "metricGroups", new [] { new Struct {
        Metric = m1,
        AnomalyDetectionStandardDeviationToRender = 3
    } } }
});

Adding an alarm:

MonitorCustom(new Dictionary<string, object> {
    { "title", "Metric with anomaly detection and alarm" },
    { "metricGroups", new [] { new Struct {
        Metric = m1,
        AlarmFriendlyName = "MetricWithAnomalyDetectionAlarm",
        AnomalyDetectionStandardDeviationToRender = 3,
        AddAlarmOnAnomaly = new Struct {
            Warning = new Struct {
                StandardDeviationForAlarm = 4,
                AlarmWhenAboveTheBand = true,
                AlarmWhenBelowTheBand = true
            }
        }
    } } }
});

Example: search metrics

MonitorCustom(new Dictionary<string, object> {
    { "title", "Metric search" },
    { "metricGroups", new [] { new Struct {
        SearchQuery = "My.Prefix.",
        DimensionsMap = new Struct {
            FirstDimension = "FirstDimensionValue",
            // Allow any value for the given dimension (pardon the weird typing to satisfy DimensionsMap)
            SecondDimension = (string)(object)undefined
        },
        Statistic = MetricStatistic.SUM
    } } }
});

Search metrics do not support setting an alarm, which is a CloudWatch limitation.

Route53 Health Checks

Route53 has strict requirements as to which alarms are allowed to be referenced in Health Checks. You adjust the metric for an alarm so that it can be used in a Route53 Health Checks as follows:

monitoring.MonitorSomething(something, new Struct {
    AddSomeAlarm = new Struct {
        Warning = new Struct {
            // ...other props
            MetricAdjuster = Route53HealthCheckMetricAdjuster.INSTANCE
        }
    }
});

This will ensure the alarm can be used on a Route53 Health Check or otherwise throw an Error indicating why the alarm can't be used. In order to easily find your Route53 Health Check alarms later on, you can apply a custom tag to them as follows:

// Example automatically generated from non-compiling source. May contain errors.
using Amazon.CDK.AWS.Route53;

monitoring.MonitorSomething(something, new Struct {
    AddSomeAlarm = new Struct {
        Warning = new Struct {
            // ...other props
            CustomTags = new [] { "route53-health-check" },
            MetricAdjuster = Route53HealthCheckMetricAdjuster.INSTANCE
        }
    }
});

var alarms = monitoring.CreatedAlarmsWithTag("route53-health-check");

var healthChecks = alarms.Map(({ alarm }) => {
  const id = getHealthCheckConstructId(alarm);

  return new CfnHealthCheck(scope, id, {
    healthCheckConfig: {
      // ...other props
      type: "CLOUDWATCH_METRIC",
      alarmIdentifier: {
        name: alarm.alarmName,
        region: alarm.stack.region,
      },
    },
  });
});

Custom monitoring segments

If you want even more flexibility, you can create your own segment.

This is a general procedure on how to do it:

1. Extend the Monitoring class
2. Override the widgets() method (and/or similar ones)
3. Leverage the metric factory and alarm factory provided by the base class (you can create additional factories, if you will)
4. Add all alarms to .addAlarm() so they are visible to the user and being placed on the alarm summary dashboard

Both of these monitoring base classes are dashboard segments, so you can add them to your monitoring by calling .addSegment() on the MonitoringFacade.

Modifying or omitting widgets from default dashboard segments

While the dashboard widgets defined in the library are meant to cover most use cases, they might not be what you're looking for.

To modify the widgets:

1. Extend the appropriate Monitoring class (e.g., LambdaFunctionMonitoring for monitorLambdaFunction) and override the relevant methods (e.g., widgets):

   // Example automatically generated from non-compiling source. May contain errors.
   class MyCustomizedLambdaFunctionMonitoring : LambdaFunctionMonitoring
   {
       public void[] Widgets()
       {
           return new [] {  };
       }
   }
   

2. Use the facade's addSegment method with your custom class:

   // Example automatically generated from non-compiling source. May contain errors.
   MonitoringFacade facade;
   
   facade.AddSegment(
   new MyCustomizedLambdaFunctionMonitoring(facade, new Struct { }));
   

Custom dashboards

If you want even more flexibility, you can take complete control over dashboard generation by leveraging dynamic dashboarding features. This allows you to create an arbitrary number of dashboards while configuring each of them separately. You can do this in three simple steps:

1. Create a dynamic dashboard factory
2. Create IDynamicDashboardSegment implementations
3. Add Dynamic Segments to your MonitoringFacade

Create a dynamic dashboard factory

The below code sample will generate two dashboards with the following names:

• ExampleDashboards-HostedService
• ExampleDashboards-Infrastructure

// Example automatically generated from non-compiling source. May contain errors.
// create the dynamic dashboard factory.
var factory = new DynamicDashboardFactory(stack, "DynamicDashboards", new Struct {
    DashboardNamePrefix = "ExampleDashboards",
    DashboardConfigs = new [] { new Struct { Name = "HostedService" }, new Struct {
        Name = "Infrastructure",
        Range = Duration.Hours(3),
        PeriodOverride = PeriodOverride.AUTO,
        RenderingPreference = DashboardRenderingPreference.BITMAP_ONLY
    } }
});

Create IDynamicDashboardSegment implementations

For each construct you want monitored, you will need to create an implementation of an IDynamicDashboardSegment. The following is a basic reference implementation as an example:

// Example automatically generated from non-compiling source. May contain errors.
export enum DashboardTypes {
  HostedService = "HostedService",
  Infrastructure = "Infrastructure",
}

class ExampleSegment : IDynamicDashboardSegment
{
    public void[] WidgetsForDashboard(string name)
    {switch (name) {
              case DashboardTypes.HostedService:
                return [
                  new TextWidget({
                    markdown:
                      "This shows metrics for your service hosted on AWS Infrastructure",
                  }),
                ];
              case DashboardTypes.Infrastructure:
                return [
                  new TextWidget({
                    markdown:
                      "This shows metrics for the AWS Infrastructure supporting your hosted service",
                  }),
                ];
              default:
                throw new Error("Unexpected dashboard name!");
            }
    }
}

Add Dynamic Segments to MonitoringFacade

When you have instances of an IDynamicDashboardSegment to use, they can be added to your dashboard like this:

// Example automatically generated from non-compiling source. May contain errors.
monitoring.AddDynamicSegment(new ExampleSegment());

Now, this widget will be added to both dashboards and will show different content depending on the dashboard. Using the above example code, two dashboards will be generated with the following content:

• Dashboard Name: "ExampleDashboards-HostedService"

  • Content: "This shows metrics for your service hosted on AWS Infrastructure"

• Dashboard Name: "ExampleDashboards-Infrastructure"

  • Content: "This shows metrics for the AWS Infrastructure supporting your hosted service"

Cross-account cross-Region Dashboards

Facades can be configured for different regions/accounts as a whole:

new MonitoringFacade(stack, "Monitoring", new MonitoringFacadeProps {
    MetricFactoryDefaults = new MetricFactoryDefaults {
        // Different region/account than what you're deploying to
        Region = "us-west-2",
        Account = "01234567890"
    }
});

Or at a more granular level:

monitoring.MonitorDynamoTable(new Struct {
    // Table from the same account/region
    Table = Table.FromTableName(stack, "ImportedTable", "MyTableName")
}).MonitorDynamoTable(new Struct {
    // Table from another account/region
    Table = Table.FromTableArn(stack, "XaXrImportedTable", "arn:aws:dynamodb:us-west-2:01234567890:table/my-other-table"),
    Region = "us-west-2",
    Account = "01234567890"
});

The order of precedence of the region/account values is:

1. The individual metric factory's props (e.g. via the monitorDynamoTable props).
2. The facade's metricFactoryDefaults props.
3. The region/account that the stack is deployed to.

Note that while this allows for cross-account cross-Region dashboarding, cross-Region alarming is not supported by CloudWatch.

Monitoring scopes

You can monitor complete CDK construct scopes using an aspect. It will automatically discover all monitorable resources within the scope recursively and add them to your dashboard.

monitoring.MonitorScope(stack, new Struct {
    // With optional configuration
    Lambda = new Struct {
        Props = new Struct {
            AddLatencyP50Alarm = new Struct {
                Critical = new Struct { MaxLatency = Duration.Seconds(10) }
            }
        }
    },

    // Some resources that aren't dependent on nodes (e.g. general metrics across instances/account) may be included
    // by default, which can be explicitly disabled.
    Billing = new Struct { Enabled = false },
    Ec2 = new Struct { Enabled = false },
    ElasticCache = new Struct { Enabled = false }
});

Cloning alarms

You can also create alarms by cloning other alarms and applying a modification function. When given a list of alarms created using MonitoringFacade, the facade can apply a user-supplied function on each, generating new alarms with customizations from the function.

// Example automatically generated from non-compiling source. May contain errors.
// Clone alarms using a cloning-function
var criticalAlarms = monitoring.CreatedAlarmsWithDisambiguator("Critical");
var clones = monitoring.CloneAlarms(criticalAlarms, (a) => {
  // Define a new alarm that has values inspired by the original alarm
  // Adjust some of those values using arbitrary, user-provided logic
  return {
    ...a.alarmDefinition.addAlarmProps,
    actionsEnabled: false,
    disambiguator: "ClonedCritical",
    alarmDescription: "Cloned alarm of " + a.alarmDescription,
    // Bump the threshold a bit
    threshold: a.alarmDefinition.addAlarmProps.threshold * 1.1,
    // Tighten the number of datapoints a bit
    datapointsToAlarm: a.alarmDefinition.datapointsToAlarm - 1,
    // Keep the same number of evaluation periods
    evaluationPeriods: a.alarmDefinition.evaluationPeriods,
  };
});

This technique is particularly useful when you are using alarms for multiple purposes. For instance, you may want to ensure regressions that result in an SLA-breach are automatically rolled back before a ticketing action takes effect. This scheme uses pairs of alarms for each metric: a conservative ticketing alarm and an aggressive rollback alarm.

Rather that specifying both alarms throughout your application, you can automatically create the companion alarms by cloning with a scaling function. This library provides a ScaleFunction implementation that can be configured with multiplication factors for threshold, datapointsToAlarm, and evaluationPeriods; scaling factors between 0.0 and 1.0 will generate more aggressive alarms.

// Clone critical alarms using a tighting scaling function
var criticalAlarms = monitoring.CreatedAlarmsWithDisambiguator("Critical");
var rollbackAlarms = monitoring.CloneAlarms(criticalAlarms, ScaleAlarms(new ScaleAlarmsProps {
    Disambiguator = "Rollback",
    ThresholdMultiplier = 0.8,
    DatapointsToAlarmMultiplier = 0.3,
    EvaluationPeriodsMultiplier = 0.5
}));

Contributing

See CONTRIBUTING for more information.

Security policy

See SECURITY for more information.

License

This project is licensed under the Apache-2.0 License.