/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include #include namespace Aws { namespace CloudWatch { /** *

Amazon CloudWatch monitors your Amazon Web Services (Amazon Web Services) * resources and the applications you run on Amazon Web Services in real time. You * can use CloudWatch to collect and track metrics, which are the variables you * want to measure for your resources and applications.

CloudWatch alarms * send notifications or automatically change the resources you are monitoring * based on rules that you define. For example, you can monitor the CPU usage and * disk reads and writes of your Amazon EC2 instances. Then, use this data to * determine whether you should launch additional instances to handle increased * load. You can also use this data to stop under-used instances to save money.

*

In addition to monitoring the built-in metrics that come with Amazon Web * Services, you can monitor your own custom metrics. With CloudWatch, you gain * system-wide visibility into resource utilization, application performance, and * operational health.

*/ class AWS_CLOUDWATCH_API CloudWatchClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef CloudWatchClientConfiguration ClientConfigurationType; typedef CloudWatchEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ CloudWatchClient(const Aws::CloudWatch::CloudWatchClientConfiguration& clientConfiguration = Aws::CloudWatch::CloudWatchClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ CloudWatchClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::CloudWatch::CloudWatchClientConfiguration& clientConfiguration = Aws::CloudWatch::CloudWatchClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ CloudWatchClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::CloudWatch::CloudWatchClientConfiguration& clientConfiguration = Aws::CloudWatch::CloudWatchClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ CloudWatchClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ CloudWatchClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ CloudWatchClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~CloudWatchClient(); /** * Converts any request object to a presigned URL with the GET method, using region for the signer and a timeout of 15 minutes. */ Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const; /** *

Deletes the specified alarms. You can delete up to 100 alarms in one * operation. However, this total can include no more than one composite alarm. For * example, you could delete 99 metric alarms and one composite alarms with one * operation, but you can't delete two composite alarms with one operation.

* If you specify an incorrect alarm name or make any other error in the operation, * no alarms are deleted. To confirm that alarms were deleted successfully, you can * use the DescribeAlarms * operation after using DeleteAlarms.

It is possible to * create a loop or cycle of composite alarms, where composite alarm A depends on * composite alarm B, and composite alarm B also depends on composite alarm A. In * this scenario, you can't delete any composite alarm that is part of the cycle * because there is always still a composite alarm that depends on that alarm that * you want to delete.

To get out of such a situation, you must break the * cycle by changing the rule of one of the composite alarms in the cycle to remove * a dependency that creates the cycle. The simplest change to make to break a * cycle is to change the AlarmRule of one of the alarms to * false.

Additionally, the evaluation of composite alarms * stops if CloudWatch detects a cycle in the evaluation path.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteAlarmsOutcome DeleteAlarms(const Model::DeleteAlarmsRequest& request) const; /** * A Callable wrapper for DeleteAlarms that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAlarmsOutcomeCallable DeleteAlarmsCallable(const DeleteAlarmsRequestT& request) const { return SubmitCallable(&CloudWatchClient::DeleteAlarms, request); } /** * An Async wrapper for DeleteAlarms that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAlarmsAsync(const DeleteAlarmsRequestT& request, const DeleteAlarmsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::DeleteAlarms, request, handler, context); } /** *

Deletes the specified anomaly detection model from your account. For more * information about how to delete an anomaly detection model, see Deleting * an anomaly detection model in the CloudWatch User Guide. *

See Also:

AWS * API Reference

*/ virtual Model::DeleteAnomalyDetectorOutcome DeleteAnomalyDetector(const Model::DeleteAnomalyDetectorRequest& request) const; /** * A Callable wrapper for DeleteAnomalyDetector that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAnomalyDetectorOutcomeCallable DeleteAnomalyDetectorCallable(const DeleteAnomalyDetectorRequestT& request) const { return SubmitCallable(&CloudWatchClient::DeleteAnomalyDetector, request); } /** * An Async wrapper for DeleteAnomalyDetector that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAnomalyDetectorAsync(const DeleteAnomalyDetectorRequestT& request, const DeleteAnomalyDetectorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::DeleteAnomalyDetector, request, handler, context); } /** *

Deletes all dashboards that you specify. You can specify up to 100 dashboards * to delete. If there is an error during this call, no dashboards are * deleted.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDashboardsOutcome DeleteDashboards(const Model::DeleteDashboardsRequest& request) const; /** * A Callable wrapper for DeleteDashboards that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDashboardsOutcomeCallable DeleteDashboardsCallable(const DeleteDashboardsRequestT& request) const { return SubmitCallable(&CloudWatchClient::DeleteDashboards, request); } /** * An Async wrapper for DeleteDashboards that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDashboardsAsync(const DeleteDashboardsRequestT& request, const DeleteDashboardsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::DeleteDashboards, request, handler, context); } /** *

Permanently deletes the specified Contributor Insights rules.

If you * create a rule, delete it, and then re-create it with the same name, historical * data from the first time the rule was created might not be * available.

See Also:

AWS * API Reference

*/ virtual Model::DeleteInsightRulesOutcome DeleteInsightRules(const Model::DeleteInsightRulesRequest& request) const; /** * A Callable wrapper for DeleteInsightRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteInsightRulesOutcomeCallable DeleteInsightRulesCallable(const DeleteInsightRulesRequestT& request) const { return SubmitCallable(&CloudWatchClient::DeleteInsightRules, request); } /** * An Async wrapper for DeleteInsightRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteInsightRulesAsync(const DeleteInsightRulesRequestT& request, const DeleteInsightRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::DeleteInsightRules, request, handler, context); } /** *

Permanently deletes the metric stream that you specify.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteMetricStreamOutcome DeleteMetricStream(const Model::DeleteMetricStreamRequest& request) const; /** * A Callable wrapper for DeleteMetricStream that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteMetricStreamOutcomeCallable DeleteMetricStreamCallable(const DeleteMetricStreamRequestT& request) const { return SubmitCallable(&CloudWatchClient::DeleteMetricStream, request); } /** * An Async wrapper for DeleteMetricStream that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteMetricStreamAsync(const DeleteMetricStreamRequestT& request, const DeleteMetricStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::DeleteMetricStream, request, handler, context); } /** *

Retrieves the history for the specified alarm. You can filter the results by * date range or item type. If an alarm name is not specified, the histories for * either all metric alarms or all composite alarms are returned.

CloudWatch * retains the history of an alarm even if you delete the alarm.

To use this * operation and return information about a composite alarm, you must be signed on * with the cloudwatch:DescribeAlarmHistory permission that is scoped * to *. You can't return information about composite alarms if your * cloudwatch:DescribeAlarmHistory permission has a narrower * scope.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAlarmHistoryOutcome DescribeAlarmHistory(const Model::DescribeAlarmHistoryRequest& request) const; /** * A Callable wrapper for DescribeAlarmHistory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAlarmHistoryOutcomeCallable DescribeAlarmHistoryCallable(const DescribeAlarmHistoryRequestT& request) const { return SubmitCallable(&CloudWatchClient::DescribeAlarmHistory, request); } /** * An Async wrapper for DescribeAlarmHistory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAlarmHistoryAsync(const DescribeAlarmHistoryRequestT& request, const DescribeAlarmHistoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::DescribeAlarmHistory, request, handler, context); } /** *

Retrieves the specified alarms. You can filter the results by specifying a * prefix for the alarm name, the alarm state, or a prefix for any action.

*

To use this operation and return information about composite alarms, you must * be signed on with the cloudwatch:DescribeAlarms permission that is * scoped to *. You can't return information about composite alarms if * your cloudwatch:DescribeAlarms permission has a narrower * scope.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAlarmsOutcome DescribeAlarms(const Model::DescribeAlarmsRequest& request) const; /** * A Callable wrapper for DescribeAlarms that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAlarmsOutcomeCallable DescribeAlarmsCallable(const DescribeAlarmsRequestT& request) const { return SubmitCallable(&CloudWatchClient::DescribeAlarms, request); } /** * An Async wrapper for DescribeAlarms that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAlarmsAsync(const DescribeAlarmsRequestT& request, const DescribeAlarmsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::DescribeAlarms, request, handler, context); } /** *

Retrieves the alarms for the specified metric. To filter the results, specify * a statistic, period, or unit.

This operation retrieves only standard * alarms that are based on the specified metric. It does not return alarms based * on math expressions that use the specified metric, or composite alarms that use * the specified metric.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAlarmsForMetricOutcome DescribeAlarmsForMetric(const Model::DescribeAlarmsForMetricRequest& request) const; /** * A Callable wrapper for DescribeAlarmsForMetric that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAlarmsForMetricOutcomeCallable DescribeAlarmsForMetricCallable(const DescribeAlarmsForMetricRequestT& request) const { return SubmitCallable(&CloudWatchClient::DescribeAlarmsForMetric, request); } /** * An Async wrapper for DescribeAlarmsForMetric that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAlarmsForMetricAsync(const DescribeAlarmsForMetricRequestT& request, const DescribeAlarmsForMetricResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::DescribeAlarmsForMetric, request, handler, context); } /** *

Lists the anomaly detection models that you have created in your account. For * single metric anomaly detectors, you can list all of the models in your account * or filter the results to only the models that are related to a certain * namespace, metric name, or metric dimension. For metric math anomaly detectors, * you can list them by adding METRIC_MATH to the * AnomalyDetectorTypes array. This will return all metric math * anomaly detectors in your account.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAnomalyDetectorsOutcome DescribeAnomalyDetectors(const Model::DescribeAnomalyDetectorsRequest& request) const; /** * A Callable wrapper for DescribeAnomalyDetectors that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAnomalyDetectorsOutcomeCallable DescribeAnomalyDetectorsCallable(const DescribeAnomalyDetectorsRequestT& request) const { return SubmitCallable(&CloudWatchClient::DescribeAnomalyDetectors, request); } /** * An Async wrapper for DescribeAnomalyDetectors that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAnomalyDetectorsAsync(const DescribeAnomalyDetectorsRequestT& request, const DescribeAnomalyDetectorsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::DescribeAnomalyDetectors, request, handler, context); } /** *

Returns a list of all the Contributor Insights rules in your account.

*

For more information about Contributor Insights, see Using * Contributor Insights to Analyze High-Cardinality Data.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeInsightRulesOutcome DescribeInsightRules(const Model::DescribeInsightRulesRequest& request) const; /** * A Callable wrapper for DescribeInsightRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInsightRulesOutcomeCallable DescribeInsightRulesCallable(const DescribeInsightRulesRequestT& request) const { return SubmitCallable(&CloudWatchClient::DescribeInsightRules, request); } /** * An Async wrapper for DescribeInsightRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInsightRulesAsync(const DescribeInsightRulesRequestT& request, const DescribeInsightRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::DescribeInsightRules, request, handler, context); } /** *

Disables the actions for the specified alarms. When an alarm's actions are * disabled, the alarm actions do not execute when the alarm state * changes.

See Also:

AWS * API Reference

*/ virtual Model::DisableAlarmActionsOutcome DisableAlarmActions(const Model::DisableAlarmActionsRequest& request) const; /** * A Callable wrapper for DisableAlarmActions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableAlarmActionsOutcomeCallable DisableAlarmActionsCallable(const DisableAlarmActionsRequestT& request) const { return SubmitCallable(&CloudWatchClient::DisableAlarmActions, request); } /** * An Async wrapper for DisableAlarmActions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableAlarmActionsAsync(const DisableAlarmActionsRequestT& request, const DisableAlarmActionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::DisableAlarmActions, request, handler, context); } /** *

Disables the specified Contributor Insights rules. When rules are disabled, * they do not analyze log groups and do not incur costs.

See Also:

* AWS * API Reference

*/ virtual Model::DisableInsightRulesOutcome DisableInsightRules(const Model::DisableInsightRulesRequest& request) const; /** * A Callable wrapper for DisableInsightRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableInsightRulesOutcomeCallable DisableInsightRulesCallable(const DisableInsightRulesRequestT& request) const { return SubmitCallable(&CloudWatchClient::DisableInsightRules, request); } /** * An Async wrapper for DisableInsightRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableInsightRulesAsync(const DisableInsightRulesRequestT& request, const DisableInsightRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::DisableInsightRules, request, handler, context); } /** *

Enables the actions for the specified alarms.

See Also:

AWS * API Reference

*/ virtual Model::EnableAlarmActionsOutcome EnableAlarmActions(const Model::EnableAlarmActionsRequest& request) const; /** * A Callable wrapper for EnableAlarmActions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableAlarmActionsOutcomeCallable EnableAlarmActionsCallable(const EnableAlarmActionsRequestT& request) const { return SubmitCallable(&CloudWatchClient::EnableAlarmActions, request); } /** * An Async wrapper for EnableAlarmActions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableAlarmActionsAsync(const EnableAlarmActionsRequestT& request, const EnableAlarmActionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::EnableAlarmActions, request, handler, context); } /** *

Enables the specified Contributor Insights rules. When rules are enabled, * they immediately begin analyzing log data.

See Also:

AWS * API Reference

*/ virtual Model::EnableInsightRulesOutcome EnableInsightRules(const Model::EnableInsightRulesRequest& request) const; /** * A Callable wrapper for EnableInsightRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableInsightRulesOutcomeCallable EnableInsightRulesCallable(const EnableInsightRulesRequestT& request) const { return SubmitCallable(&CloudWatchClient::EnableInsightRules, request); } /** * An Async wrapper for EnableInsightRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableInsightRulesAsync(const EnableInsightRulesRequestT& request, const EnableInsightRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::EnableInsightRules, request, handler, context); } /** *

Displays the details of the dashboard that you specify.

To copy an * existing dashboard, use GetDashboard, and then use the data * returned within DashboardBody as the template for the new dashboard * when you call PutDashboard to create the copy.

See * Also:

AWS * API Reference

*/ virtual Model::GetDashboardOutcome GetDashboard(const Model::GetDashboardRequest& request) const; /** * A Callable wrapper for GetDashboard that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDashboardOutcomeCallable GetDashboardCallable(const GetDashboardRequestT& request) const { return SubmitCallable(&CloudWatchClient::GetDashboard, request); } /** * An Async wrapper for GetDashboard that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDashboardAsync(const GetDashboardRequestT& request, const GetDashboardResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::GetDashboard, request, handler, context); } /** *

This operation returns the time series data collected by a Contributor * Insights rule. The data includes the identity and number of contributors to the * log group.

You can also optionally return one or more statistics about * each data point in the time series. These statistics can include the * following:

  • UniqueContributors -- the number of * unique contributors for each data point.

  • * MaxContributorValue -- the value of the top contributor for each * data point. The identity of the contributor might change for each data point in * the graph.

    If this rule aggregates by COUNT, the top contributor for each * data point is the contributor with the most occurrences in that period. If the * rule aggregates by SUM, the top contributor is the contributor with the highest * sum in the log field specified by the rule's Value, during that * period.

  • SampleCount -- the number of data points * matched by the rule.

  • Sum -- the sum of the * values from all contributors during the time period represented by that data * point.

  • Minimum -- the minimum value from a * single observation during the time period represented by that data point.

    *

  • Maximum -- the maximum value from a single * observation during the time period represented by that data point.

    • *

  • Average -- the average value from all contributors during * the time period represented by that data point.

See * Also:

AWS * API Reference

*/ virtual Model::GetInsightRuleReportOutcome GetInsightRuleReport(const Model::GetInsightRuleReportRequest& request) const; /** * A Callable wrapper for GetInsightRuleReport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInsightRuleReportOutcomeCallable GetInsightRuleReportCallable(const GetInsightRuleReportRequestT& request) const { return SubmitCallable(&CloudWatchClient::GetInsightRuleReport, request); } /** * An Async wrapper for GetInsightRuleReport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInsightRuleReportAsync(const GetInsightRuleReportRequestT& request, const GetInsightRuleReportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::GetInsightRuleReport, request, handler, context); } /** *

You can use the GetMetricData API to retrieve CloudWatch metric * values. The operation can also include a CloudWatch Metrics Insights query, and * one or more metric math functions.

A GetMetricData operation * that does not include a query can retrieve as many as 500 different metrics in a * single request, with a total of as many as 100,800 data points. You can also * optionally perform metric math expressions on the values of the returned * statistics, to create new time series that represent new insights into your * data. For example, using Lambda metrics, you could divide the Errors metric by * the Invocations metric to get an error rate time series. For more information * about metric math expressions, see Metric * Math Syntax and Functions in the Amazon CloudWatch User Guide.

*

If you include a Metrics Insights query, each GetMetricData * operation can include only one query. But the same GetMetricData * operation can also retrieve other metrics. Metrics Insights queries can query * only the most recent three hours of metric data. For more information about * Metrics Insights, see Query * your metrics with CloudWatch Metrics Insights.

Calls to the * GetMetricData API have a different pricing structure than calls to * GetMetricStatistics. For more information about pricing, see Amazon CloudWatch * Pricing.

Amazon CloudWatch retains metric data as follows:

    *

  • Data points with a period of less than 60 seconds are available for 3 * hours. These data points are high-resolution metrics and are available only for * custom metrics that have been defined with a StorageResolution of * 1.

  • Data points with a period of 60 seconds (1-minute) are * available for 15 days.

  • Data points with a period of 300 * seconds (5-minute) are available for 63 days.

  • Data points with * a period of 3600 seconds (1 hour) are available for 455 days (15 months).

    *

Data points that are initially published with a shorter period * are aggregated together for long-term storage. For example, if you collect data * using a period of 1 minute, the data remains available for 15 days with 1-minute * resolution. After 15 days, this data is still available, but is aggregated and * retrievable only with a resolution of 5 minutes. After 63 days, the data is * further aggregated and is available with a resolution of 1 hour.

If you * omit Unit in your request, all data that was collected with any * unit is returned, along with the corresponding units that were specified when * the data was reported to CloudWatch. If you specify a unit, the operation * returns only data that was collected with that unit specified. If you specify a * unit that does not match the data collected, the results of the operation are * null. CloudWatch does not perform unit conversions.

Using Metrics * Insights queries with metric math

You can't mix a Metric Insights * query and metric math syntax in the same expression, but you can reference * results from a Metrics Insights query within other Metric math expressions. A * Metrics Insights query without a GROUP BY clause returns a single * time-series (TS), and can be used as input for a metric math expression that * expects a single time series. A Metrics Insights query with a GROUP BY * clause returns an array of time-series (TS[]), and can be used as input for a * metric math expression that expects an array of time series.

See * Also:

AWS * API Reference

*/ virtual Model::GetMetricDataOutcome GetMetricData(const Model::GetMetricDataRequest& request) const; /** * A Callable wrapper for GetMetricData that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMetricDataOutcomeCallable GetMetricDataCallable(const GetMetricDataRequestT& request) const { return SubmitCallable(&CloudWatchClient::GetMetricData, request); } /** * An Async wrapper for GetMetricData that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMetricDataAsync(const GetMetricDataRequestT& request, const GetMetricDataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::GetMetricData, request, handler, context); } /** *

Gets statistics for the specified metric.

The maximum number of data * points returned from a single call is 1,440. If you request more than 1,440 data * points, CloudWatch returns an error. To reduce the number of data points, you * can narrow the specified time range and make multiple requests across adjacent * time ranges, or you can increase the specified period. Data points are not * returned in chronological order.

CloudWatch aggregates data points based * on the length of the period that you specify. For example, if you request * statistics with a one-hour period, CloudWatch aggregates all data points with * time stamps that fall within each one-hour period. Therefore, the number of * values aggregated by CloudWatch is larger than the number of data points * returned.

CloudWatch needs raw data points to calculate percentile * statistics. If you publish data using a statistic set instead, you can only * retrieve percentile statistics for this data if one of the following conditions * is true:

  • The SampleCount value of the statistic set is 1.

    *

  • The Min and the Max values of the statistic set are equal.

    *

Percentile statistics are not available for metrics when any of * the metric values are negative numbers.

Amazon CloudWatch retains metric * data as follows:

  • Data points with a period of less than 60 * seconds are available for 3 hours. These data points are high-resolution metrics * and are available only for custom metrics that have been defined with a * StorageResolution of 1.

  • Data points with a period * of 60 seconds (1-minute) are available for 15 days.

  • Data * points with a period of 300 seconds (5-minute) are available for 63 days.

    *

  • Data points with a period of 3600 seconds (1 hour) are available * for 455 days (15 months).

Data points that are initially * published with a shorter period are aggregated together for long-term storage. * For example, if you collect data using a period of 1 minute, the data remains * available for 15 days with 1-minute resolution. After 15 days, this data is * still available, but is aggregated and retrievable only with a resolution of 5 * minutes. After 63 days, the data is further aggregated and is available with a * resolution of 1 hour.

CloudWatch started retaining 5-minute and 1-hour * metric data as of July 9, 2016.

For information about metrics and * dimensions supported by Amazon Web Services services, see the Amazon * CloudWatch Metrics and Dimensions Reference in the Amazon CloudWatch User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetMetricStatisticsOutcome GetMetricStatistics(const Model::GetMetricStatisticsRequest& request) const; /** * A Callable wrapper for GetMetricStatistics that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMetricStatisticsOutcomeCallable GetMetricStatisticsCallable(const GetMetricStatisticsRequestT& request) const { return SubmitCallable(&CloudWatchClient::GetMetricStatistics, request); } /** * An Async wrapper for GetMetricStatistics that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMetricStatisticsAsync(const GetMetricStatisticsRequestT& request, const GetMetricStatisticsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::GetMetricStatistics, request, handler, context); } /** *

Returns information about the metric stream that you specify.

See * Also:

AWS * API Reference

*/ virtual Model::GetMetricStreamOutcome GetMetricStream(const Model::GetMetricStreamRequest& request) const; /** * A Callable wrapper for GetMetricStream that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMetricStreamOutcomeCallable GetMetricStreamCallable(const GetMetricStreamRequestT& request) const { return SubmitCallable(&CloudWatchClient::GetMetricStream, request); } /** * An Async wrapper for GetMetricStream that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMetricStreamAsync(const GetMetricStreamRequestT& request, const GetMetricStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::GetMetricStream, request, handler, context); } /** *

You can use the GetMetricWidgetImage API to retrieve a snapshot * graph of one or more Amazon CloudWatch metrics as a bitmap image. You can then * embed this image into your services and products, such as wiki pages, reports, * and documents. You could also retrieve images regularly, such as every minute, * and create your own custom live dashboard.

The graph you retrieve can * include all CloudWatch metric graph features, including metric math and * horizontal and vertical annotations.

There is a limit of 20 transactions * per second for this API. Each GetMetricWidgetImage action has the * following limits:

  • As many as 100 metrics in the graph.

    *

  • Up to 100 KB uncompressed payload.

See * Also:

AWS * API Reference

*/ virtual Model::GetMetricWidgetImageOutcome GetMetricWidgetImage(const Model::GetMetricWidgetImageRequest& request) const; /** * A Callable wrapper for GetMetricWidgetImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMetricWidgetImageOutcomeCallable GetMetricWidgetImageCallable(const GetMetricWidgetImageRequestT& request) const { return SubmitCallable(&CloudWatchClient::GetMetricWidgetImage, request); } /** * An Async wrapper for GetMetricWidgetImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMetricWidgetImageAsync(const GetMetricWidgetImageRequestT& request, const GetMetricWidgetImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::GetMetricWidgetImage, request, handler, context); } /** *

Returns a list of the dashboards for your account. If you include * DashboardNamePrefix, only those dashboards with names starting with * the prefix are listed. Otherwise, all dashboards in your account are listed. *

ListDashboards returns up to 1000 results on one page. If * there are more than 1000 dashboards, you can call ListDashboards * again and include the value you received for NextToken in the first * call, to receive the next 1000 results.

See Also:

AWS * API Reference

*/ virtual Model::ListDashboardsOutcome ListDashboards(const Model::ListDashboardsRequest& request) const; /** * A Callable wrapper for ListDashboards that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDashboardsOutcomeCallable ListDashboardsCallable(const ListDashboardsRequestT& request) const { return SubmitCallable(&CloudWatchClient::ListDashboards, request); } /** * An Async wrapper for ListDashboards that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDashboardsAsync(const ListDashboardsRequestT& request, const ListDashboardsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::ListDashboards, request, handler, context); } /** *

Returns a list that contains the number of managed Contributor Insights * rules in your account.

See Also:

AWS * API Reference

*/ virtual Model::ListManagedInsightRulesOutcome ListManagedInsightRules(const Model::ListManagedInsightRulesRequest& request) const; /** * A Callable wrapper for ListManagedInsightRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListManagedInsightRulesOutcomeCallable ListManagedInsightRulesCallable(const ListManagedInsightRulesRequestT& request) const { return SubmitCallable(&CloudWatchClient::ListManagedInsightRules, request); } /** * An Async wrapper for ListManagedInsightRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListManagedInsightRulesAsync(const ListManagedInsightRulesRequestT& request, const ListManagedInsightRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::ListManagedInsightRules, request, handler, context); } /** *

Returns a list of metric streams in this account.

See Also:

* AWS * API Reference

*/ virtual Model::ListMetricStreamsOutcome ListMetricStreams(const Model::ListMetricStreamsRequest& request) const; /** * A Callable wrapper for ListMetricStreams that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListMetricStreamsOutcomeCallable ListMetricStreamsCallable(const ListMetricStreamsRequestT& request) const { return SubmitCallable(&CloudWatchClient::ListMetricStreams, request); } /** * An Async wrapper for ListMetricStreams that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListMetricStreamsAsync(const ListMetricStreamsRequestT& request, const ListMetricStreamsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::ListMetricStreams, request, handler, context); } /** *

List the specified metrics. You can use the returned metrics with GetMetricData * or GetMetricStatistics * to get statistical data.

Up to 500 results are returned for any one call. * To retrieve additional results, use the returned token with subsequent * calls.

After you create a metric, allow up to 15 minutes for the metric * to appear. To see metric statistics sooner, use GetMetricData * or GetMetricStatistics.

*

If you are using CloudWatch cross-account observability, you can use this * operation in a monitoring account and view metrics from the linked source * accounts. For more information, see CloudWatch * cross-account observability.

ListMetrics doesn't return * information about metrics if those metrics haven't reported data in the past two * weeks. To retrieve those metrics, use GetMetricData * or GetMetricStatistics.

See * Also:

AWS * API Reference

*/ virtual Model::ListMetricsOutcome ListMetrics(const Model::ListMetricsRequest& request) const; /** * A Callable wrapper for ListMetrics that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListMetricsOutcomeCallable ListMetricsCallable(const ListMetricsRequestT& request) const { return SubmitCallable(&CloudWatchClient::ListMetrics, request); } /** * An Async wrapper for ListMetrics that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListMetricsAsync(const ListMetricsRequestT& request, const ListMetricsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::ListMetrics, request, handler, context); } /** *

Displays the tags associated with a CloudWatch resource. Currently, alarms * and Contributor Insights rules support tagging.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&CloudWatchClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::ListTagsForResource, request, handler, context); } /** *

Creates an anomaly detection model for a CloudWatch metric. You can use the * model to display a band of expected normal values when the metric is * graphed.

For more information, see CloudWatch * Anomaly Detection.

See Also:

AWS * API Reference

*/ virtual Model::PutAnomalyDetectorOutcome PutAnomalyDetector(const Model::PutAnomalyDetectorRequest& request) const; /** * A Callable wrapper for PutAnomalyDetector that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutAnomalyDetectorOutcomeCallable PutAnomalyDetectorCallable(const PutAnomalyDetectorRequestT& request) const { return SubmitCallable(&CloudWatchClient::PutAnomalyDetector, request); } /** * An Async wrapper for PutAnomalyDetector that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutAnomalyDetectorAsync(const PutAnomalyDetectorRequestT& request, const PutAnomalyDetectorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::PutAnomalyDetector, request, handler, context); } /** *

Creates or updates a composite alarm. When you create a composite * alarm, you specify a rule expression for the alarm that takes into account the * alarm states of other alarms that you have created. The composite alarm goes * into ALARM state only if all conditions of the rule are met.

The alarms * specified in a composite alarm's rule expression can include metric alarms and * other composite alarms. The rule expression of a composite alarm can include as * many as 100 underlying alarms. Any single alarm can be included in the rule * expressions of as many as 150 composite alarms.

Using composite alarms * can reduce alarm noise. You can create multiple metric alarms, and also create a * composite alarm and set up alerts only for the composite alarm. For example, you * could create a composite alarm that goes into ALARM state only when more than * one of the underlying metric alarms are in ALARM state.

Currently, the * only alarm actions that can be taken by composite alarms are notifying SNS * topics.

It is possible to create a loop or cycle of composite * alarms, where composite alarm A depends on composite alarm B, and composite * alarm B also depends on composite alarm A. In this scenario, you can't delete * any composite alarm that is part of the cycle because there is always still a * composite alarm that depends on that alarm that you want to delete.

To * get out of such a situation, you must break the cycle by changing the rule of * one of the composite alarms in the cycle to remove a dependency that creates the * cycle. The simplest change to make to break a cycle is to change the * AlarmRule of one of the alarms to false.

*

Additionally, the evaluation of composite alarms stops if CloudWatch detects * a cycle in the evaluation path.

When this operation creates an * alarm, the alarm state is immediately set to INSUFFICIENT_DATA. The * alarm is then evaluated and its state is set appropriately. Any actions * associated with the new state are then executed. For a composite alarm, this * initial time after creation is the only time that the alarm can be in * INSUFFICIENT_DATA state.

When you update an existing alarm, * its state is left unchanged, but the update completely overwrites the previous * configuration of the alarm.

To use this operation, you must be signed on * with the cloudwatch:PutCompositeAlarm permission that is scoped to * *. You can't create a composite alarms if your * cloudwatch:PutCompositeAlarm permission has a narrower scope.

*

If you are an IAM user, you must have * iam:CreateServiceLinkedRole to create a composite alarm that has * Systems Manager OpsItem actions.

See Also:

AWS * API Reference

*/ virtual Model::PutCompositeAlarmOutcome PutCompositeAlarm(const Model::PutCompositeAlarmRequest& request) const; /** * A Callable wrapper for PutCompositeAlarm that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutCompositeAlarmOutcomeCallable PutCompositeAlarmCallable(const PutCompositeAlarmRequestT& request) const { return SubmitCallable(&CloudWatchClient::PutCompositeAlarm, request); } /** * An Async wrapper for PutCompositeAlarm that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutCompositeAlarmAsync(const PutCompositeAlarmRequestT& request, const PutCompositeAlarmResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::PutCompositeAlarm, request, handler, context); } /** *

Creates a dashboard if it does not already exist, or updates an existing * dashboard. If you update a dashboard, the entire contents are replaced with what * you specify here.

All dashboards in your account are global, not * region-specific.

A simple way to create a dashboard using * PutDashboard is to copy an existing dashboard. To copy an existing * dashboard using the console, you can load the dashboard and then use the * View/edit source command in the Actions menu to display the JSON block for that * dashboard. Another way to copy a dashboard is to use GetDashboard, * and then use the data returned within DashboardBody as the template * for the new dashboard when you call PutDashboard.

When you * create a dashboard with PutDashboard, a good practice is to add a * text widget at the top of the dashboard with a message that the dashboard was * created by script and should not be changed in the console. This message could * also point console users to the location of the DashboardBody * script or the CloudFormation template used to create the * dashboard.

See Also:

AWS * API Reference

*/ virtual Model::PutDashboardOutcome PutDashboard(const Model::PutDashboardRequest& request) const; /** * A Callable wrapper for PutDashboard that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutDashboardOutcomeCallable PutDashboardCallable(const PutDashboardRequestT& request) const { return SubmitCallable(&CloudWatchClient::PutDashboard, request); } /** * An Async wrapper for PutDashboard that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutDashboardAsync(const PutDashboardRequestT& request, const PutDashboardResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::PutDashboard, request, handler, context); } /** *

Creates a Contributor Insights rule. Rules evaluate log events in a * CloudWatch Logs log group, enabling you to find contributor data for the log * events in that log group. For more information, see Using * Contributor Insights to Analyze High-Cardinality Data.

If you create * a rule, delete it, and then re-create it with the same name, historical data * from the first time the rule was created might not be available.

See * Also:

AWS * API Reference

*/ virtual Model::PutInsightRuleOutcome PutInsightRule(const Model::PutInsightRuleRequest& request) const; /** * A Callable wrapper for PutInsightRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutInsightRuleOutcomeCallable PutInsightRuleCallable(const PutInsightRuleRequestT& request) const { return SubmitCallable(&CloudWatchClient::PutInsightRule, request); } /** * An Async wrapper for PutInsightRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutInsightRuleAsync(const PutInsightRuleRequestT& request, const PutInsightRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::PutInsightRule, request, handler, context); } /** *

Creates a managed Contributor Insights rule for a specified Amazon Web * Services resource. When you enable a managed rule, you create a Contributor * Insights rule that collects data from Amazon Web Services services. You cannot * edit these rules with PutInsightRule. The rules can be enabled, * disabled, and deleted using EnableInsightRules, * DisableInsightRules, and DeleteInsightRules. If a * previously created managed rule is currently disabled, a subsequent call to this * API will re-enable it. Use ListManagedInsightRules to describe all * available rules.

See Also:

AWS * API Reference

*/ virtual Model::PutManagedInsightRulesOutcome PutManagedInsightRules(const Model::PutManagedInsightRulesRequest& request) const; /** * A Callable wrapper for PutManagedInsightRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutManagedInsightRulesOutcomeCallable PutManagedInsightRulesCallable(const PutManagedInsightRulesRequestT& request) const { return SubmitCallable(&CloudWatchClient::PutManagedInsightRules, request); } /** * An Async wrapper for PutManagedInsightRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutManagedInsightRulesAsync(const PutManagedInsightRulesRequestT& request, const PutManagedInsightRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::PutManagedInsightRules, request, handler, context); } /** *

Creates or updates an alarm and associates it with the specified metric, * metric math expression, anomaly detection model, or Metrics Insights query. For * more information about using a Metrics Insights query for an alarm, see Create * alarms on Metrics Insights queries.

Alarms based on anomaly detection * models cannot have Auto Scaling actions.

When this operation creates an * alarm, the alarm state is immediately set to INSUFFICIENT_DATA. The * alarm is then evaluated and its state is set appropriately. Any actions * associated with the new state are then executed.

When you update an * existing alarm, its state is left unchanged, but the update completely * overwrites the previous configuration of the alarm.

If you are an IAM * user, you must have Amazon EC2 permissions for some alarm operations:

    *

  • The iam:CreateServiceLinkedRole permission for all alarms * with EC2 actions

  • The iam:CreateServiceLinkedRole * permissions to create an alarm with Systems Manager OpsItem or response plan * actions.

The first time you create an alarm in the Amazon Web * Services Management Console, the CLI, or by using the PutMetricAlarm API, * CloudWatch creates the necessary service-linked role for you. The service-linked * roles are called AWSServiceRoleForCloudWatchEvents and * AWSServiceRoleForCloudWatchAlarms_ActionSSM. For more information, * see Amazon * Web Services service-linked role.

Each PutMetricAlarm * action has a maximum uncompressed payload of 120 KB.

Cross-account * alarms

You can set an alarm on metrics in the current account, or in * another account. To create a cross-account alarm that watches a metric in a * different account, you must have completed the following pre-requisites:

*

  • The account where the metrics are located (the sharing * account) must already have a sharing role named * CloudWatch-CrossAccountSharingRole. If it does not already have this * role, you must create it using the instructions in Set up a sharing * account in * Cross-account cross-Region CloudWatch console. The policy for that role must * grant access to the ID of the account where you are creating the alarm.

    *

  • The account where you are creating the alarm (the monitoring * account) must already have a service-linked role named * AWSServiceRoleForCloudWatchCrossAccount to allow CloudWatch to assume the * sharing role in the sharing account. If it does not, you must create it * following the directions in Set up a monitoring account in * Cross-account cross-Region CloudWatch console.

See * Also:

AWS * API Reference

*/ virtual Model::PutMetricAlarmOutcome PutMetricAlarm(const Model::PutMetricAlarmRequest& request) const; /** * A Callable wrapper for PutMetricAlarm that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutMetricAlarmOutcomeCallable PutMetricAlarmCallable(const PutMetricAlarmRequestT& request) const { return SubmitCallable(&CloudWatchClient::PutMetricAlarm, request); } /** * An Async wrapper for PutMetricAlarm that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutMetricAlarmAsync(const PutMetricAlarmRequestT& request, const PutMetricAlarmResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::PutMetricAlarm, request, handler, context); } /** *

Publishes metric data points to Amazon CloudWatch. CloudWatch associates the * data points with the specified metric. If the specified metric does not exist, * CloudWatch creates the metric. When CloudWatch creates a metric, it can take up * to fifteen minutes for the metric to appear in calls to ListMetrics.

*

You can publish either individual data points in the Value * field, or arrays of values and the number of times each value occurred during * the period by using the Values and Counts fields in * the MetricDatum structure. Using the Values and * Counts method enables you to publish up to 150 values per metric * with one PutMetricData request, and supports retrieving percentile * statistics on this data.

Each PutMetricData request is * limited to 1 MB in size for HTTP POST requests. You can send a payload * compressed by gzip. Each request is also limited to no more than 1000 different * metrics.

Although the Value parameter accepts numbers of * type Double, CloudWatch rejects values that are either too small or * too large. Values must be in the range of -2^360 to 2^360. In addition, special * values (for example, NaN, +Infinity, -Infinity) are not supported.

You * can use up to 30 dimensions per metric to further clarify what data the metric * collects. Each dimension consists of a Name and Value pair. For more information * about specifying dimensions, see Publishing * Metrics in the Amazon CloudWatch User Guide.

You specify the * time stamp to be associated with each data point. You can specify time stamps * that are as much as two weeks before the current date, and as much as 2 hours * after the current day and time.

Data points with time stamps from 24 * hours ago or longer can take at least 48 hours to become available for GetMetricData * or GetMetricStatistics * from the time they are submitted. Data points with time stamps between 3 and 24 * hours ago can take as much as 2 hours to become available for for GetMetricData * or GetMetricStatistics.

*

CloudWatch needs raw data points to calculate percentile statistics. If you * publish data using a statistic set instead, you can only retrieve percentile * statistics for this data if one of the following conditions is true:

    *

  • The SampleCount value of the statistic set is 1 and * Min, Max, and Sum are all equal.

    *

  • The Min and Max are equal, and * Sum is equal to Min multiplied by * SampleCount.

See Also:

AWS * API Reference

*/ virtual Model::PutMetricDataOutcome PutMetricData(const Model::PutMetricDataRequest& request) const; /** * A Callable wrapper for PutMetricData that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutMetricDataOutcomeCallable PutMetricDataCallable(const PutMetricDataRequestT& request) const { return SubmitCallable(&CloudWatchClient::PutMetricData, request); } /** * An Async wrapper for PutMetricData that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutMetricDataAsync(const PutMetricDataRequestT& request, const PutMetricDataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::PutMetricData, request, handler, context); } /** *

Creates or updates a metric stream. Metric streams can automatically stream * CloudWatch metrics to Amazon Web Services destinations, including Amazon S3, and * to many third-party solutions.

For more information, see * Using Metric Streams.

To create a metric stream, you must be signed * in to an account that has the iam:PassRole permission and either * the CloudWatchFullAccess policy or the * cloudwatch:PutMetricStream permission.

When you create or * update a metric stream, you choose one of the following:

  • Stream * metrics from all metric namespaces in the account.

  • Stream * metrics from all metric namespaces in the account, except for the namespaces * that you list in ExcludeFilters.

  • Stream metrics * from only the metric namespaces that you list in * IncludeFilters.

By default, a metric stream * always sends the MAX, MIN, SUM, and * SAMPLECOUNT statistics for each metric that is streamed. You can * use the StatisticsConfigurations parameter to have the metric * stream send additional statistics in the stream. Streaming additional statistics * incurs additional costs. For more information, see Amazon CloudWatch Pricing. *

When you use PutMetricStream to create a new metric stream, * the stream is created in the running state. If you use it to update * an existing stream, the state of the stream is not changed.

If you are * using CloudWatch cross-account observability and you create a metric stream in a * monitoring account, you can choose whether to include metrics from source * accounts in the stream. For more information, see CloudWatch * cross-account observability.

See Also:

AWS * API Reference

*/ virtual Model::PutMetricStreamOutcome PutMetricStream(const Model::PutMetricStreamRequest& request) const; /** * A Callable wrapper for PutMetricStream that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutMetricStreamOutcomeCallable PutMetricStreamCallable(const PutMetricStreamRequestT& request) const { return SubmitCallable(&CloudWatchClient::PutMetricStream, request); } /** * An Async wrapper for PutMetricStream that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutMetricStreamAsync(const PutMetricStreamRequestT& request, const PutMetricStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::PutMetricStream, request, handler, context); } /** *

Temporarily sets the state of an alarm for testing purposes. When the updated * state differs from the previous value, the action configured for the appropriate * state is invoked. For example, if your alarm is configured to send an Amazon SNS * message when an alarm is triggered, temporarily changing the alarm state to * ALARM sends an SNS message.

Metric alarms returns to their * actual state quickly, often within seconds. Because the metric alarm state * change happens quickly, it is typically only visible in the alarm's * History tab in the Amazon CloudWatch console or through DescribeAlarmHistory.

*

If you use SetAlarmState on a composite alarm, the composite * alarm is not guaranteed to return to its actual state. It returns to its actual * state only once any of its children alarms change state. It is also reevaluated * if you update its configuration.

If an alarm triggers EC2 Auto Scaling * policies or application Auto Scaling policies, you must include information in * the StateReasonData parameter to enable the policy to take the * correct action.

See Also:

AWS * API Reference

*/ virtual Model::SetAlarmStateOutcome SetAlarmState(const Model::SetAlarmStateRequest& request) const; /** * A Callable wrapper for SetAlarmState that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetAlarmStateOutcomeCallable SetAlarmStateCallable(const SetAlarmStateRequestT& request) const { return SubmitCallable(&CloudWatchClient::SetAlarmState, request); } /** * An Async wrapper for SetAlarmState that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetAlarmStateAsync(const SetAlarmStateRequestT& request, const SetAlarmStateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::SetAlarmState, request, handler, context); } /** *

Starts the streaming of metrics for one or more of your metric * streams.

See Also:

AWS * API Reference

*/ virtual Model::StartMetricStreamsOutcome StartMetricStreams(const Model::StartMetricStreamsRequest& request) const; /** * A Callable wrapper for StartMetricStreams that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartMetricStreamsOutcomeCallable StartMetricStreamsCallable(const StartMetricStreamsRequestT& request) const { return SubmitCallable(&CloudWatchClient::StartMetricStreams, request); } /** * An Async wrapper for StartMetricStreams that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartMetricStreamsAsync(const StartMetricStreamsRequestT& request, const StartMetricStreamsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::StartMetricStreams, request, handler, context); } /** *

Stops the streaming of metrics for one or more of your metric * streams.

See Also:

AWS * API Reference

*/ virtual Model::StopMetricStreamsOutcome StopMetricStreams(const Model::StopMetricStreamsRequest& request) const; /** * A Callable wrapper for StopMetricStreams that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopMetricStreamsOutcomeCallable StopMetricStreamsCallable(const StopMetricStreamsRequestT& request) const { return SubmitCallable(&CloudWatchClient::StopMetricStreams, request); } /** * An Async wrapper for StopMetricStreams that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopMetricStreamsAsync(const StopMetricStreamsRequestT& request, const StopMetricStreamsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::StopMetricStreams, request, handler, context); } /** *

Assigns one or more tags (key-value pairs) to the specified CloudWatch * resource. Currently, the only CloudWatch resources that can be tagged are alarms * and Contributor Insights rules.

Tags can help you organize and categorize * your resources. You can also use them to scope user permissions by granting a * user permission to access or change only resources with certain tag values.

*

Tags don't have any semantic meaning to Amazon Web Services and are * interpreted strictly as strings of characters.

You can use the * TagResource action with an alarm that already has tags. If you * specify a new tag key for the alarm, this tag is appended to the list of tags * associated with the alarm. If you specify a tag key that is already associated * with the alarm, the new tag value that you specify replaces the previous value * for that tag.

You can associate as many as 50 tags with a CloudWatch * resource.

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&CloudWatchClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::TagResource, request, handler, context); } /** *

Removes one or more tags from the specified resource.

See * Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&CloudWatchClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchClient::UntagResource, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const CloudWatchClientConfiguration& clientConfiguration); CloudWatchClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace CloudWatch } // namespace Aws