Namespace Amazon.CDK.AWS.CloudWatch
Amazon CloudWatch Construct Library
Metric objects
Metric objects represent a metric that is emitted by AWS services or your own
application, such as CPUUsage
, FailureCount
or Bandwidth
.
Metric objects can be constructed directly or are exposed by resources as
attributes. Resources that expose metrics will have functions that look
like metricXxx()
which will return a Metric object, initialized with defaults
that make sense.
For example, lambda.Function
objects have the fn.metricErrors()
method, which
represents the amount of errors reported by that Lambda function:
Function fn;
var errors = fn.MetricErrors();
Metric
objects can be account and region aware. You can specify account
and region
as properties of the metric, or use the metric.attachTo(Construct)
method. metric.attachTo()
will automatically copy the region
and account
fields of the Construct
, which can come from anywhere in the Construct tree.
You can also instantiate Metric
objects to reference any
published metric
that's not exposed using a convenience method on the CDK construct.
For example:
var hostedZone = new HostedZone(this, "MyHostedZone", new HostedZoneProps { ZoneName = "example.org" });
var metric = new Metric(new MetricProps {
Namespace = "AWS/Route53",
MetricName = "DNSQueries",
DimensionsMap = new Dictionary<string, string> {
{ "HostedZoneId", hostedZone.HostedZoneId }
}
});
Instantiating a new Metric object
If you want to reference a metric that is not yet exposed by an existing construct,
you can instantiate a Metric
object to represent it. For example:
var metric = new Metric(new MetricProps {
Namespace = "MyNamespace",
MetricName = "MyMetric",
DimensionsMap = new Dictionary<string, string> {
{ "ProcessingStep", "Download" }
}
});
Metric Math
Math expressions are supported by instantiating the MathExpression
class.
For example, a math expression that sums two other metrics looks like this:
Function fn;
var allProblems = new MathExpression(new MathExpressionProps {
Expression = "errors + throttles",
UsingMetrics = new Dictionary<string, IMetric> {
{ "errors", fn.MetricErrors() },
{ "throttles", fn.MetricThrottles() }
}
});
You can use MathExpression
objects like any other metric, including using
them in other math expressions:
Function fn;
MathExpression allProblems;
var problemPercentage = new MathExpression(new MathExpressionProps {
Expression = "(problems / invocations) * 100",
UsingMetrics = new Dictionary<string, IMetric> {
{ "problems", allProblems },
{ "invocations", fn.MetricInvocations() }
}
});
Search Expressions
Math expressions also support search expressions. For example, the following search expression returns all CPUUtilization metrics that it finds, with the graph showing the Average statistic with an aggregation period of 5 minutes:
var cpuUtilization = new MathExpression(new MathExpressionProps {
Expression = "SEARCH('{AWS/EC2,InstanceId} MetricName=\"CPUUtilization\"', 'Average', 300)",
// Specifying '' as the label suppresses the default behavior
// of using the expression as metric label. This is especially appropriate
// when using expressions that return multiple time series (like SEARCH()
// or METRICS()), to show the labels of the retrieved metrics only.
Label = ""
});
Cross-account and cross-region search expressions are also supported. Use
the searchAccount
and searchRegion
properties to specify the account
and/or region to evaluate the search expression against.
Aggregation
To graph or alarm on metrics you must aggregate them first, using a function
like Average
or a percentile function like P99
. By default, most Metric objects
returned by CDK libraries will be configured as Average
over 300 seconds
(5 minutes).
The exception is if the metric represents a count of discrete events, such as
failures. In that case, the Metric object will be configured as Sum
over 300 seconds
, i.e. it represents the number of times that event occurred over the
time period.
If you want to change the default aggregation of the Metric object (for example, the function or the period), you can do so by passing additional parameters to the metric function call:
Function fn;
var minuteErrorRate = fn.MetricErrors(new MetricOptions {
Statistic = Stats.AVERAGE,
Period = Duration.Minutes(1),
Label = "Lambda failure rate"
});
The statistic
field accepts a string
; the cloudwatch.Stats
object has a
number of predefined factory functions that help you constructs strings that are
appropriate for CloudWatch. The metricErrors
function also allows changing the
metric label or color, which will be useful when embedding them in graphs (see
below).
Rates versus Sums
The reason for using Sum
to count discrete events is that some events are
emitted as either 0
or 1
(for example Errors
for a Lambda) and some are
only emitted as 1
(for example NumberOfMessagesPublished
for an SNS
topic).
In case 0
-metrics are emitted, it makes sense to take the Average
of this
metric: the result will be the fraction of errors over all executions.
If 0
-metrics are not emitted, the Average
will always be equal to 1
,
and not be very useful.
In order to simplify the mental model of Metric
objects, we default to
aggregating using Sum
, which will be the same for both metrics types. If you
happen to know the Metric you want to alarm on makes sense as a rate
(Average
) you can always choose to change the statistic.
Available Aggregation Statistics
For your metrics aggregation, you can use the following statistics:
Statistic | Short format | Long format | Factory name |
---|---|---|---|
SampleCount (n) | ❌ | ❌ | Stats.SAMPLE_COUNT |
Average (avg) | ❌ | ❌ | Stats.AVERAGE |
Sum | ❌ | ❌ | Stats.SUM |
Minimum (min) | ❌ | ❌ | Stats.MINIMUM |
Maximum (max) | ❌ | ❌ | Stats.MAXIMUM |
Interquartile mean (IQM) | ❌ | ❌ | Stats.IQM |
Percentile (p) | p99 |
❌ | Stats.p(99) |
Winsorized mean (WM) | wm99 = WM(:99%) |
WM(x:y) | WM(x%:y%) | WM(x%:) | WM(:y%) |
Stats.wm(10, 90) |
Trimmed count (TC) | tc99 = TC(:99%) |
TC(x:y) | TC(x%:y%) | TC(x%:) | TC(:y%) |
Stats.tc(10, 90) |
Trimmed sum (TS) | ts99 = TS(:99%) |
TS(x:y) | TS(x%:y%) | TS(x%:) | TS(:y%) |
Stats.ts(10, 90) |
Percentile rank (PR) | ❌ | PR(x:y) | PR(x:) | PR(:y) |
Stats.pr(10, 5000) |
The most common values are provided in the cloudwatch.Stats
class. You can provide any string if your statistic is not in the class.
Read more at CloudWatch statistics definitions.
HostedZone hostedZone;
new Metric(new MetricProps {
Namespace = "AWS/Route53",
MetricName = "DNSQueries",
DimensionsMap = new Dictionary<string, string> {
{ "HostedZoneId", hostedZone.HostedZoneId }
},
Statistic = Stats.SAMPLE_COUNT,
Period = Duration.Minutes(5)
});
new Metric(new MetricProps {
Namespace = "AWS/Route53",
MetricName = "DNSQueries",
DimensionsMap = new Dictionary<string, string> {
{ "HostedZoneId", hostedZone.HostedZoneId }
},
Statistic = Stats.P(99),
Period = Duration.Minutes(5)
});
new Metric(new MetricProps {
Namespace = "AWS/Route53",
MetricName = "DNSQueries",
DimensionsMap = new Dictionary<string, string> {
{ "HostedZoneId", hostedZone.HostedZoneId }
},
Statistic = "TS(7.5%:90%)",
Period = Duration.Minutes(5)
});
Labels
Metric labels are displayed in the legend of graphs that include the metrics.
You can use dynamic labels to show summary information about the displayed time series in the legend. For example, if you use:
Function fn;
var minuteErrorRate = fn.MetricErrors(new MetricOptions {
Statistic = Stats.SUM,
Period = Duration.Hours(1),
// Show the maximum hourly error count in the legend
Label = "[max: ${MAX}] Lambda failure rate"
});
As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend.
If the metric is a math expression producing more than one time series, the maximum will be individually calculated and shown for each time series produce by the math expression.
Alarms
Alarms can be created on metrics in one of two ways. Either create an Alarm
object, passing the Metric
object to set the alarm on:
Function fn;
new Alarm(this, "Alarm", new AlarmProps {
Metric = fn.MetricErrors(),
Threshold = 100,
EvaluationPeriods = 2
});
Alternatively, you can call metric.createAlarm()
:
Function fn;
fn.MetricErrors().CreateAlarm(this, "Alarm", new CreateAlarmOptions {
Threshold = 100,
EvaluationPeriods = 2
});
The most important properties to set while creating an Alarms are:
To create a cross-account alarm, make sure you have enabled cross-account functionality in CloudWatch. Then, set the account
property in the Metric
object either manually or via the metric.attachTo()
method.
Please note that it is not possible to:
Alarm Actions
To add actions to an alarm, use the integration classes from the
aws-cdk-lib/aws-cloudwatch-actions
package. For example, to post a message to
an SNS topic when an alarm breaches, do the following:
using Amazon.CDK.AWS.CloudWatch.Actions;
Alarm alarm;
var topic = new Topic(this, "Topic");
alarm.AddAlarmAction(new SnsAction(topic));
Notification formats
Alarms can be created in one of two "formats":
For backwards compatibility, CDK will try to create classic, top-level CloudWatch alarms as much as possible, unless you are using features that cannot be expressed in that format. Features that require the new-style alarm format are:
The difference between these two does not impact the functionality of the alarm in any way, except that the format of the notifications the Alarm generates is different between them. This affects both the notifications sent out over SNS, as well as the EventBridge events generated by this Alarm. If you are writing code to consume these notifications, be sure to handle both formats.
Composite Alarms
Composite Alarms can be created from existing Alarm resources.
Alarm alarm1;
Alarm alarm2;
Alarm alarm3;
Alarm alarm4;
var alarmRule = AlarmRule.AnyOf(AlarmRule.AllOf(AlarmRule.AnyOf(alarm1, AlarmRule.FromAlarm(alarm2, AlarmState.OK), alarm3), AlarmRule.Not(AlarmRule.FromAlarm(alarm4, AlarmState.INSUFFICIENT_DATA))), AlarmRule.FromBoolean(false));
new CompositeAlarm(this, "MyAwesomeCompositeAlarm", new CompositeAlarmProps {
AlarmRule = alarmRule
});
Actions Suppressor
If you want to disable actions of a Composite Alarm based on a certain condition, you can use Actions Suppression.
Alarm alarm1;
Alarm alarm2;
IAlarmAction onAlarmAction;
IAlarmAction onOkAction;
Alarm actionsSuppressor;
var alarmRule = AlarmRule.AnyOf(alarm1, alarm2);
var myCompositeAlarm = new CompositeAlarm(this, "MyAwesomeCompositeAlarm", new CompositeAlarmProps {
AlarmRule = alarmRule,
ActionsSuppressor = actionsSuppressor
});
myCompositeAlarm.AddAlarmAction(onAlarmAction);
myCompositeAlarm.AddOkAction(onOkAction);
In the provided example, if actionsSuppressor
is in ALARM
state, onAlarmAction
won't be triggered even if myCompositeAlarm
goes into ALARM
state.
Similar, if actionsSuppressor
is in ALARM
state and myCompositeAlarm
goes from ALARM
into OK
state, onOkAction
won't be triggered.
A note on units
In CloudWatch, Metrics datums are emitted with units, such as seconds
or
bytes
. When Metric
objects are given a unit
attribute, it will be used to
filter the stream of metric datums for datums emitted using the same unit
attribute.
In particular, the unit
field is not used to rescale datums or alarm threshold
values (for example, it cannot be used to specify an alarm threshold in
Megabytes if the metric stream is being emitted as bytes).
You almost certainly don't want to specify the unit
property when creating
Metric
objects (which will retrieve all datums regardless of their unit),
unless you have very specific requirements. Note that in any case, CloudWatch
only supports filtering by unit
for Alarms, not in Dashboard graphs.
Please see the following GitHub issue for a discussion on real unit calculations in CDK: https://github.com/aws/aws-cdk/issues/5595
Dashboards
Dashboards are set of Widgets stored server-side which can be accessed quickly from the AWS console. Available widgets are graphs of a metric over time, the current value of a metric, or a static piece of Markdown which explains what the graphs mean.
The following widgets are available:
Graph widget
A graph widget can display any number of metrics on either the left
or
right
vertical axis:
Dashboard dashboard;
Metric executionCountMetric;
Metric errorCountMetric;
dashboard.AddWidgets(new GraphWidget(new GraphWidgetProps {
Title = "Executions vs error rate",
Left = new [] { executionCountMetric },
Right = new [] { errorCountMetric.With(new MetricOptions {
Statistic = Stats.AVERAGE,
Label = "Error rate",
Color = Color.GREEN
}) }
}));
Using the methods addLeftMetric()
and addRightMetric()
you can add metrics to a graph widget later on.
Graph widgets can also display annotations attached to the left or right y-axis or the x-axis.
Dashboard dashboard;
dashboard.AddWidgets(new GraphWidget(new GraphWidgetProps {
// ...
LeftAnnotations = new [] { new HorizontalAnnotation { Value = 1800, Label = Duration.Minutes(30).ToHumanString(), Color = Color.RED }, new HorizontalAnnotation { Value = 3600, Label = "1 hour", Color = "#2ca02c" } },
VerticalAnnotations = new [] { new VerticalAnnotation { Date = "2022-10-19T00:00:00Z", Label = "Deployment", Color = Color.RED } }
}));
The graph legend can be adjusted from the default position at bottom of the widget.
Dashboard dashboard;
dashboard.AddWidgets(new GraphWidget(new GraphWidgetProps {
// ...
LegendPosition = LegendPosition.RIGHT
}));
The graph can publish live data within the last minute that has not been fully aggregated.
Dashboard dashboard;
dashboard.AddWidgets(new GraphWidget(new GraphWidgetProps {
// ...
LiveData = true
}));
The graph view can be changed from default 'timeSeries' to 'bar' or 'pie'.
Dashboard dashboard;
dashboard.AddWidgets(new GraphWidget(new GraphWidgetProps {
// ...
View = GraphWidgetView.BAR
}));
The start
and end
properties can be used to specify the time range for each graph widget independently from those of the dashboard.
The parameters can be specified at GraphWidget
, GaugeWidget
, and SingleValueWidget
.
Dashboard dashboard;
dashboard.AddWidgets(new GraphWidget(new GraphWidgetProps {
// ...
Start = "-P7D",
End = "2018-12-17T06:00:00.000Z"
}));
Table Widget
A TableWidget
can display any number of metrics in tabular form.
Dashboard dashboard;
Metric executionCountMetric;
dashboard.AddWidgets(new TableWidget(new TableWidgetProps {
Title = "Executions",
Metrics = new [] { executionCountMetric }
}));
The layout
property can be used to invert the rows and columns of the table.
The default cloudwatch.TableLayout.HORIZONTAL
means that metrics are shown in rows and datapoints in columns.
cloudwatch.TableLayout.VERTICAL
means that metrics are shown in columns and datapoints in rows.
Dashboard dashboard;
dashboard.AddWidgets(new TableWidget(new TableWidgetProps {
// ...
Layout = TableLayout.VERTICAL
}));
The summary
property allows customizing the table to show summary columns (columns
sub property),
whether to make the summary columns sticky remaining in view while scrolling (sticky
sub property),
and to optionally only present summary columns (hideNonSummaryColumns
sub property).
Dashboard dashboard;
dashboard.AddWidgets(new TableWidget(new TableWidgetProps {
// ...
Summary = new TableSummaryProps {
Columns = new [] { TableSummaryColumn.AVERAGE },
HideNonSummaryColumns = true,
Sticky = true
}
}));
The thresholds
property can be used to highlight cells with a color when the datapoint value falls within the threshold.
Dashboard dashboard;
dashboard.AddWidgets(new TableWidget(new TableWidgetProps {
// ...
Thresholds = new [] { TableThreshold.Above(1000, Color.RED), TableThreshold.Between(500, 1000, Color.ORANGE), TableThreshold.Below(500, Color.GREEN) }
}));
The showUnitsInLabel
property can be used to display what unit is associated with a metric in the label column.
Dashboard dashboard;
dashboard.AddWidgets(new TableWidget(new TableWidgetProps {
// ...
ShowUnitsInLabel = true
}));
The fullPrecision
property can be used to show as many digits as can fit in a cell, before rounding.
Dashboard dashboard;
dashboard.AddWidgets(new TableWidget(new TableWidgetProps {
// ...
FullPrecision = true
}));
Gauge widget
Gauge graph requires the max and min value of the left Y axis, if no value is informed the limits will be from 0 to 100.
Dashboard dashboard;
Alarm errorAlarm;
Metric gaugeMetric;
dashboard.AddWidgets(new GaugeWidget(new GaugeWidgetProps {
Metrics = new [] { gaugeMetric },
LeftYAxis = new YAxisProps {
Min = 0,
Max = 1000
}
}));
Alarm widget
An alarm widget shows the graph and the alarm line of a single alarm:
Dashboard dashboard;
Alarm errorAlarm;
dashboard.AddWidgets(new AlarmWidget(new AlarmWidgetProps {
Title = "Errors",
Alarm = errorAlarm
}));
Single value widget
A single-value widget shows the latest value of a set of metrics (as opposed to a graph of the value over time):
Dashboard dashboard;
Metric visitorCount;
Metric purchaseCount;
dashboard.AddWidgets(new SingleValueWidget(new SingleValueWidgetProps {
Metrics = new [] { visitorCount, purchaseCount }
}));
Show as many digits as can fit, before rounding.
Dashboard dashboard;
dashboard.AddWidgets(new SingleValueWidget(new SingleValueWidgetProps {
Metrics = new [] { },
FullPrecision = true
}));
Sparkline allows you to glance the trend of a metric by displaying a simplified linegraph below the value. You can't use sparkline: true
together with setPeriodToTimeRange: true
Dashboard dashboard;
dashboard.AddWidgets(new SingleValueWidget(new SingleValueWidgetProps {
Metrics = new [] { },
Sparkline = true
}));
Period allows you to set the default period for the widget:
Dashboard dashboard;
dashboard.AddWidgets(new SingleValueWidget(new SingleValueWidgetProps {
Metrics = new [] { },
Period = Duration.Minutes(15)
}));
Text widget
A text widget shows an arbitrary piece of MarkDown. Use this to add explanations to your dashboard:
Dashboard dashboard;
dashboard.AddWidgets(new TextWidget(new TextWidgetProps {
Markdown = "# Key Performance Indicators"
}));
Optionally set the TextWidget background to be transparent
Dashboard dashboard;
dashboard.AddWidgets(new TextWidget(new TextWidgetProps {
Markdown = "# Key Performance Indicators",
Background = TextWidgetBackground.TRANSPARENT
}));
Alarm Status widget
An alarm status widget displays instantly the status of any type of alarms and gives the ability to aggregate one or more alarms together in a small surface.
Dashboard dashboard;
Alarm errorAlarm;
dashboard.AddWidgets(
new AlarmStatusWidget(new AlarmStatusWidgetProps {
Alarms = new [] { errorAlarm }
}));
An alarm status widget only showing firing alarms, sorted by state and timestamp:
Dashboard dashboard;
Alarm errorAlarm;
dashboard.AddWidgets(new AlarmStatusWidget(new AlarmStatusWidgetProps {
Title = "Errors",
Alarms = new [] { errorAlarm },
SortBy = AlarmStatusWidgetSortBy.STATE_UPDATED_TIMESTAMP,
States = new [] { AlarmState.ALARM }
}));
Query results widget
A LogQueryWidget
shows the results of a query from Logs Insights:
Dashboard dashboard;
dashboard.AddWidgets(new LogQueryWidget(new LogQueryWidgetProps {
LogGroupNames = new [] { "my-log-group" },
View = LogQueryVisualizationType.TABLE,
// The lines will be automatically combined using '\n|'.
QueryLines = new [] { "fields @message", "filter @message like /Error/" }
}));
Custom widget
A CustomWidget
shows the result of an AWS Lambda function:
Dashboard dashboard;
// Import or create a lambda function
var fn = Function.FromFunctionArn(dashboard, "Function", "arn:aws:lambda:us-east-1:123456789012:function:MyFn");
dashboard.AddWidgets(new CustomWidget(new CustomWidgetProps {
FunctionArn = fn.FunctionArn,
Title = "My lambda baked widget"
}));
You can learn more about custom widgets in the Amazon Cloudwatch User Guide.
Dashboard Layout
The widgets on a dashboard are visually laid out in a grid that is 24 columns wide. Normally you specify X and Y coordinates for the widgets on a Dashboard, but because this is inconvenient to do manually, the library contains a simple layout system to help you lay out your dashboards the way you want them to.
Widgets have a width
and height
property, and they will be automatically
laid out either horizontally or vertically stacked to fill out the available
space.
Widgets are added to a Dashboard by calling add(widget1, widget2, ...)
.
Widgets given in the same call will be laid out horizontally. Widgets given
in different calls will be laid out vertically. To make more complex layouts,
you can use the following widgets to pack widgets together in different ways:
Column widget
A column widget contains other widgets and they will be laid out in a vertical column. Widgets will be put one after another in order.
IWidget widgetA;
IWidget widgetB;
new Column(widgetA, widgetB);
You can add a widget after object instantiation with the method
addWidget()
. Each new widget will be put at the bottom of the column.
Row widget
A row widget contains other widgets and they will be laid out in a horizontal row. Widgets will be put one after another in order. If the total width of the row exceeds the max width of the grid of 24 columns, the row will wrap automatically and adapt its height.
IWidget widgetA;
IWidget widgetB;
new Row(widgetA, widgetB);
You can add a widget after object instantiation with the method
addWidget()
.
Interval duration for dashboard
Interval duration for metrics in dashboard. You can specify defaultInterval
with
the relative time(eg. 7 days) as Duration.days(7)
.
using Amazon.CDK.AWS.CloudWatch;
var dashboard = new Dashboard(this, "Dash", new DashboardProps {
DefaultInterval = Duration.Days(7)
});
Here, the dashboard would show the metrics for the last 7 days.
Dashboard variables
Dashboard variables are a convenient way to create flexible dashboards that display different content depending on the value of an input field within a dashboard. They create a dashboard on which it's possible to quickly switch between different Lambda functions, Amazon EC2 instances, etc.
You can learn more about Dashboard variables in the Amazon Cloudwatch User Guide
There are two types of dashboard variables available: a property variable and a pattern variable.
A use case of a property variable is a dashboard with the ability to toggle the region
property to see the same dashboard in different regions:
using Amazon.CDK.AWS.CloudWatch;
var dashboard = new Dashboard(this, "Dash", new DashboardProps {
DefaultInterval = Duration.Days(7),
Variables = new [] { new DashboardVariable(new DashboardVariableOptions {
Id = "region",
Type = VariableType.PROPERTY,
Label = "Region",
InputType = VariableInputType.RADIO,
Value = "region",
Values = Values.FromValues(new VariableValue { Label = "IAD", Value = "us-east-1" }, new VariableValue { Label = "DUB", Value = "us-west-2" }),
DefaultValue = DefaultValue.Value("us-east-1"),
Visible = true
}) }
});
This example shows how to change region
everywhere, assuming the current dashboard is showing region us-east-1
already, by using pattern variable
using Amazon.CDK.AWS.CloudWatch;
var dashboard = new Dashboard(this, "Dash", new DashboardProps {
DefaultInterval = Duration.Days(7),
Variables = new [] { new DashboardVariable(new DashboardVariableOptions {
Id = "region2",
Type = VariableType.PATTERN,
Label = "RegionPattern",
InputType = VariableInputType.INPUT,
Value = "us-east-1",
DefaultValue = DefaultValue.Value("us-east-1"),
Visible = true
}) }
});
The following example generates a Lambda function variable, with a radio button for each function. Functions are discovered by a metric query search.
The values
with cw.Values.fromSearchComponents
indicates that the values will be populated from FunctionName
values retrieved from the search expression {AWS/Lambda,FunctionName} MetricName="Duration"
.
The defaultValue
with cw.DefaultValue.FIRST
indicates that the default value will be the first value returned from the search.
using Amazon.CDK.AWS.CloudWatch;
var dashboard = new Dashboard(this, "Dash", new DashboardProps {
DefaultInterval = Duration.Days(7),
Variables = new [] { new DashboardVariable(new DashboardVariableOptions {
Id = "functionName",
Type = VariableType.PATTERN,
Label = "Function",
InputType = VariableInputType.RADIO,
Value = "originalFuncNameInDashboard",
// equivalent to cw.Values.fromSearch('{AWS/Lambda,FunctionName} MetricName=\"Duration\"', 'FunctionName')
Values = Values.FromSearchComponents(new SearchComponents {
Namespace = "AWS/Lambda",
Dimensions = new [] { "FunctionName" },
MetricName = "Duration",
PopulateFrom = "FunctionName"
}),
DefaultValue = DefaultValue.FIRST,
Visible = true
}) }
});
You can add a variable after object instantiation with the method dashboard.addVariable()
.
Classes
Alarm | An alarm on a CloudWatch metric. |
AlarmActionConfig | Properties for an alarm action. |
AlarmBase | The base class for Alarm and CompositeAlarm resources. |
AlarmProps | Properties for Alarms. |
AlarmRule | Class with static functions to build AlarmRule for Composite Alarms. |
AlarmState | Enumeration indicates state of Alarm used in building Alarm Rule. |
AlarmStatusWidget | A dashboard widget that displays alarms in a grid view. |
AlarmStatusWidgetProps | Properties for an Alarm Status Widget. |
AlarmStatusWidgetSortBy | The sort possibilities for AlarmStatusWidgets. |
AlarmWidget | Display the metric associated with an alarm, including the alarm line. |
AlarmWidgetProps | Properties for an AlarmWidget. |
CfnAlarm | The |
CfnAlarm.DimensionProperty | Dimension is an embedded property of the |
CfnAlarm.MetricDataQueryProperty | The |
CfnAlarm.MetricProperty | The |
CfnAlarm.MetricStatProperty | This structure defines the metric to be returned, along with the statistics, period, and units. |
CfnAlarmProps | Properties for defining a |
CfnAnomalyDetector | The |
CfnAnomalyDetector.ConfigurationProperty | Specifies details about how the anomaly detection model is to be trained, including time ranges to exclude when training and updating the model. |
CfnAnomalyDetector.DimensionProperty | A dimension is a name/value pair that is part of the identity of a metric. |
CfnAnomalyDetector.MetricCharacteristicsProperty | This object includes parameters that you can use to provide information to CloudWatch to help it build more accurate anomaly detection models. |
CfnAnomalyDetector.MetricDataQueryProperty | This structure is used in both |
CfnAnomalyDetector.MetricMathAnomalyDetectorProperty | Indicates the CloudWatch math expression that provides the time series the anomaly detector uses as input. |
CfnAnomalyDetector.MetricProperty | Represents a specific metric. |
CfnAnomalyDetector.MetricStatProperty | This structure defines the metric to be returned, along with the statistics, period, and units. |
CfnAnomalyDetector.RangeProperty | Each |
CfnAnomalyDetector.SingleMetricAnomalyDetectorProperty | Designates the CloudWatch metric and statistic that provides the time series the anomaly detector uses as input. |
CfnAnomalyDetectorProps | Properties for defining a |
CfnCompositeAlarm | The |
CfnCompositeAlarmProps | Properties for defining a |
CfnDashboard | The |
CfnDashboardProps | Properties for defining a |
CfnInsightRule | Creates or updates a Contributor Insights rule. |
CfnInsightRuleProps | Properties for defining a |
CfnMetricStream | Creates or updates a metric stream. |
CfnMetricStream.MetricStreamFilterProperty | This structure contains a metric namespace and optionally, a list of metric names, to either include in a metric ' stream or exclude from a metric stream. |
CfnMetricStream.MetricStreamStatisticsConfigurationProperty | This structure specifies a list of additional statistics to stream, and the metrics to stream those additional statistics for. |
CfnMetricStream.MetricStreamStatisticsMetricProperty | A structure that specifies the metric name and namespace for one metric that is going to have additional statistics included in the stream. |
CfnMetricStreamProps | Properties for defining a |
Color | A set of standard colours that can be used in annotations in a GraphWidget. |
Column | A widget that contains other widgets in a vertical column. |
CommonMetricOptions | Options shared by most methods accepting metric options. |
ComparisonOperator | Comparison operator for evaluating alarms. |
CompositeAlarm | A Composite Alarm based on Alarm Rule. |
CompositeAlarmProps | Properties for creating a Composite Alarm. |
ConcreteWidget | A real CloudWatch widget that has its own fixed size and remembers its position. |
CreateAlarmOptions | Properties needed to make an alarm from a metric. |
CustomWidget | A CustomWidget shows the result of a AWS lambda function. |
CustomWidgetProps | The properties for a CustomWidget. |
Dashboard | A CloudWatch dashboard. |
DashboardProps | Properties for defining a CloudWatch Dashboard. |
DashboardVariable | Dashboard Variable. |
DashboardVariableOptions | Options for {@link DashboardVariable}. |
DefaultValue | Default value for use in {@link DashboardVariableOptions}. |
Dimension | Metric dimension. |
GaugeWidget | A dashboard gauge widget that displays metrics. |
GaugeWidgetProps | Properties for a GaugeWidget. |
GraphWidget | A dashboard widget that displays metrics. |
GraphWidgetProps | Properties for a GraphWidget. |
GraphWidgetView | Types of view. |
HorizontalAnnotation | Horizontal annotation to be added to a graph. |
LegendPosition | The position of the legend on a GraphWidget. |
LogQueryVisualizationType | Types of view. |
LogQueryWidget | Display query results from Logs Insights. |
LogQueryWidgetProps | Properties for a Query widget. |
MathExpression | A math expression built with metric(s) emitted by a service. |
MathExpressionOptions | Configurable options for MathExpressions. |
MathExpressionProps | Properties for a MathExpression. |
Metric | A metric emitted by a service. |
MetricConfig | Properties of a rendered metric. |
MetricExpressionConfig | Properties for a concrete metric. |
MetricOptions | Properties of a metric that can be changed. |
MetricProps | Properties for a metric. |
MetricStatConfig | Properties for a concrete metric. |
MetricWidgetProps | Basic properties for widgets that display metrics. |
PeriodOverride | Specify the period for graphs when the CloudWatch dashboard loads. |
Row | A widget that contains other widgets in a horizontal row. |
SearchComponents | Search components for use with {@link Values.fromSearchComponents}. |
Shading | Fill shading options that will be used with a horizontal annotation. |
SingleValueWidget | A dashboard widget that displays the most recent value for every metric. |
SingleValueWidgetProps | Properties for a SingleValueWidget. |
Spacer | A widget that doesn't display anything but takes up space. |
SpacerProps | Props of the spacer. |
Statistic | (deprecated) Statistic to use over the aggregation period. |
Stats | Factory functions for standard statistics strings. |
TableLayout | Layout for TableWidget. |
TableSummaryColumn | Standard table summary columns. |
TableSummaryProps | Properties for TableWidget's summary columns. |
TableThreshold | Thresholds for highlighting cells in TableWidget. |
TableWidget | A dashboard widget that displays metrics. |
TableWidgetProps | Properties for a TableWidget. |
TextWidget | A dashboard widget that displays MarkDown. |
TextWidgetBackground | Background types available. |
TextWidgetProps | Properties for a Text widget. |
TreatMissingData | Specify how missing data points are treated during alarm evaluation. |
Unit | Unit for metric. |
Values | A class for providing values for use with {@link VariableInputType.SELECT} and {@link VariableInputType.RADIO} dashboard variables. |
VariableInputType | |
VariableType | |
VariableValue | |
VerticalAnnotation | Vertical annotation to be added to a graph. |
VerticalShading | Fill shading options that will be used with a vertical annotation. |
YAxisProps | Properties for a Y-Axis. |
Interfaces
CfnAlarm.IDimensionProperty | Dimension is an embedded property of the |
CfnAlarm.IMetricDataQueryProperty | The |
CfnAlarm.IMetricProperty | The |
CfnAlarm.IMetricStatProperty | This structure defines the metric to be returned, along with the statistics, period, and units. |
CfnAnomalyDetector.IConfigurationProperty | Specifies details about how the anomaly detection model is to be trained, including time ranges to exclude when training and updating the model. |
CfnAnomalyDetector.IDimensionProperty | A dimension is a name/value pair that is part of the identity of a metric. |
CfnAnomalyDetector.IMetricCharacteristicsProperty | This object includes parameters that you can use to provide information to CloudWatch to help it build more accurate anomaly detection models. |
CfnAnomalyDetector.IMetricDataQueryProperty | This structure is used in both |
CfnAnomalyDetector.IMetricMathAnomalyDetectorProperty | Indicates the CloudWatch math expression that provides the time series the anomaly detector uses as input. |
CfnAnomalyDetector.IMetricProperty | Represents a specific metric. |
CfnAnomalyDetector.IMetricStatProperty | This structure defines the metric to be returned, along with the statistics, period, and units. |
CfnAnomalyDetector.IRangeProperty | Each |
CfnAnomalyDetector.ISingleMetricAnomalyDetectorProperty | Designates the CloudWatch metric and statistic that provides the time series the anomaly detector uses as input. |
CfnMetricStream.IMetricStreamFilterProperty | This structure contains a metric namespace and optionally, a list of metric names, to either include in a metric ' stream or exclude from a metric stream. |
CfnMetricStream.IMetricStreamStatisticsConfigurationProperty | This structure specifies a list of additional statistics to stream, and the metrics to stream those additional statistics for. |
CfnMetricStream.IMetricStreamStatisticsMetricProperty | A structure that specifies the metric name and namespace for one metric that is going to have additional statistics included in the stream. |
IAlarm | Represents a CloudWatch Alarm. |
IAlarmAction | Interface for objects that can be the targets of CloudWatch alarm actions. |
IAlarmActionConfig | Properties for an alarm action. |
IAlarmProps | Properties for Alarms. |
IAlarmRule | Interface for Alarm Rule. |
IAlarmStatusWidgetProps | Properties for an Alarm Status Widget. |
IAlarmWidgetProps | Properties for an AlarmWidget. |
ICfnAlarmProps | Properties for defining a |
ICfnAnomalyDetectorProps | Properties for defining a |
ICfnCompositeAlarmProps | Properties for defining a |
ICfnDashboardProps | Properties for defining a |
ICfnInsightRuleProps | Properties for defining a |
ICfnMetricStreamProps | Properties for defining a |
ICommonMetricOptions | Options shared by most methods accepting metric options. |
ICompositeAlarmProps | Properties for creating a Composite Alarm. |
ICreateAlarmOptions | Properties needed to make an alarm from a metric. |
ICustomWidgetProps | The properties for a CustomWidget. |
IDashboardProps | Properties for defining a CloudWatch Dashboard. |
IDashboardVariableOptions | Options for {@link DashboardVariable}. |
IDimension | Metric dimension. |
IGaugeWidgetProps | Properties for a GaugeWidget. |
IGraphWidgetProps | Properties for a GraphWidget. |
IHorizontalAnnotation | Horizontal annotation to be added to a graph. |
ILogQueryWidgetProps | Properties for a Query widget. |
IMathExpressionOptions | Configurable options for MathExpressions. |
IMathExpressionProps | Properties for a MathExpression. |
IMetric | Interface for metrics. |
IMetricConfig | Properties of a rendered metric. |
IMetricExpressionConfig | Properties for a concrete metric. |
IMetricOptions | Properties of a metric that can be changed. |
IMetricProps | Properties for a metric. |
IMetricStatConfig | Properties for a concrete metric. |
IMetricWidgetProps | Basic properties for widgets that display metrics. |
ISearchComponents | Search components for use with {@link Values.fromSearchComponents}. |
ISingleValueWidgetProps | Properties for a SingleValueWidget. |
ISpacerProps | Props of the spacer. |
ITableSummaryProps | Properties for TableWidget's summary columns. |
ITableWidgetProps | Properties for a TableWidget. |
ITextWidgetProps | Properties for a Text widget. |
IVariable | A single dashboard variable. |
IVariableValue | |
IVerticalAnnotation | Vertical annotation to be added to a graph. |
IWidget | A single dashboard widget. |
IYAxisProps | Properties for a Y-Axis. |