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

You can use Amazon CloudWatch Logs to monitor, store, and access your log * files from EC2 instances, CloudTrail, and other sources. You can then retrieve * the associated log data from CloudWatch Logs using the CloudWatch console. * Alternatively, you can use CloudWatch Logs commands in the Amazon Web Services * CLI, CloudWatch Logs API, or CloudWatch Logs SDK.

You can use CloudWatch * Logs to:

  • Monitor logs from EC2 instances in real time: * You can use CloudWatch Logs to monitor applications and systems using log data. * For example, CloudWatch Logs can track the number of errors that occur in your * application logs. Then, it can send you a notification whenever the rate of * errors exceeds a threshold that you specify. CloudWatch Logs uses your log data * for monitoring so no code changes are required. For example, you can monitor * application logs for specific literal terms (such as "NullReferenceException"). * You can also count the number of occurrences of a literal term at a particular * position in log data (such as "404" status codes in an Apache access log). When * the term you are searching for is found, CloudWatch Logs reports the data to a * CloudWatch metric that you specify.

  • Monitor CloudTrail * logged events: You can create alarms in CloudWatch and receive notifications * of particular API activity as captured by CloudTrail. You can use the * notification to perform troubleshooting.

  • Archive log * data: You can use CloudWatch Logs to store your log data in highly durable * storage. You can change the log retention setting so that any log events earlier * than this setting are automatically deleted. The CloudWatch Logs agent helps to * quickly send both rotated and non-rotated log data off of a host and into the * log service. You can then access the raw log data when you need it.

    • *
*/ class AWS_CLOUDWATCHLOGS_API CloudWatchLogsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef CloudWatchLogsClientConfiguration ClientConfigurationType; typedef CloudWatchLogsEndpointProvider 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. */ CloudWatchLogsClient(const Aws::CloudWatchLogs::CloudWatchLogsClientConfiguration& clientConfiguration = Aws::CloudWatchLogs::CloudWatchLogsClientConfiguration(), 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. */ CloudWatchLogsClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::CloudWatchLogs::CloudWatchLogsClientConfiguration& clientConfiguration = Aws::CloudWatchLogs::CloudWatchLogsClientConfiguration()); /** * 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 */ CloudWatchLogsClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::CloudWatchLogs::CloudWatchLogsClientConfiguration& clientConfiguration = Aws::CloudWatchLogs::CloudWatchLogsClientConfiguration()); /* 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. */ CloudWatchLogsClient(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. */ CloudWatchLogsClient(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 */ CloudWatchLogsClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~CloudWatchLogsClient(); /** *

Associates the specified KMS key with either one log group in the account, or * with all stored CloudWatch Logs query insights results in the account.

*

When you use AssociateKmsKey, you specify either the * logGroupName parameter or the resourceIdentifier * parameter. You can't specify both of those parameters in the same operation.

*

  • Specify the logGroupName parameter to cause all log * events stored in the log group to be encrypted with that key. Only the log * events ingested after the key is associated are encrypted with that key.

    *

    Associating a KMS key with a log group overrides any existing associations * between the log group and a KMS key. After a KMS key is associated with a log * group, all newly ingested data for the log group is encrypted using the KMS key. * This association is stored as long as the data encrypted with the KMS key is * still within CloudWatch Logs. This enables CloudWatch Logs to decrypt this data * whenever it is requested.

    Associating a key with a log group does not * cause the results of queries of that log group to be encrypted with that key. To * have query results encrypted with a KMS key, you must use an * AssociateKmsKey operation with the resourceIdentifier * parameter that specifies a query-result resource.

  • *

    Specify the resourceIdentifier parameter with a * query-result resource, to use that key to encrypt the stored * results of all future StartQuery * operations in the account. The response from a GetQueryResults * operation will still return the query results in plain text.

    Even if you * have not associated a key with your query results, the query results are * encrypted when stored, using the default CloudWatch Logs method.

    If you * run a query from a monitoring account that queries logs in a source account, the * query results key from the monitoring account, if any, is used.

*

If you delete the key that is used to encrypt log events or log * group query results, then all the associated stored log events or query results * that were encrypted with that key will be unencryptable and unusable.

*

CloudWatch Logs supports only symmetric KMS keys. Do not * use an associate an asymmetric KMS key with your log group or query results. For * more information, see Using * Symmetric and Asymmetric Keys.

It can take up to 5 minutes * for this operation to take effect.

If you attempt to associate a KMS key * with a log group but the KMS key does not exist or the KMS key is disabled, you * receive an InvalidParameterException error.

See * Also:

AWS * API Reference

*/ virtual Model::AssociateKmsKeyOutcome AssociateKmsKey(const Model::AssociateKmsKeyRequest& request) const; /** * A Callable wrapper for AssociateKmsKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateKmsKeyOutcomeCallable AssociateKmsKeyCallable(const AssociateKmsKeyRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::AssociateKmsKey, request); } /** * An Async wrapper for AssociateKmsKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateKmsKeyAsync(const AssociateKmsKeyRequestT& request, const AssociateKmsKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::AssociateKmsKey, request, handler, context); } /** *

Cancels the specified export task.

The task must be in the * PENDING or RUNNING state.

See Also:

* AWS * API Reference

*/ virtual Model::CancelExportTaskOutcome CancelExportTask(const Model::CancelExportTaskRequest& request) const; /** * A Callable wrapper for CancelExportTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelExportTaskOutcomeCallable CancelExportTaskCallable(const CancelExportTaskRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::CancelExportTask, request); } /** * An Async wrapper for CancelExportTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelExportTaskAsync(const CancelExportTaskRequestT& request, const CancelExportTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::CancelExportTask, request, handler, context); } /** *

Creates an export task so that you can efficiently export data from a log * group to an Amazon S3 bucket. When you perform a CreateExportTask * operation, you must use credentials that have permission to write to the S3 * bucket that you specify as the destination.

Exporting log data to S3 * buckets that are encrypted by KMS is supported. Exporting log data to Amazon S3 * buckets that have S3 Object Lock enabled with a retention period is also * supported.

Exporting to S3 buckets that are encrypted with AES-256 is * supported.

This is an asynchronous call. If all the required information * is provided, this operation initiates an export task and responds with the ID of * the task. After the task has started, you can use DescribeExportTasks * to get the status of the export task. Each account can only have one active * (RUNNING or PENDING) export task at a time. To cancel * an export task, use CancelExportTask.

*

You can export logs from multiple log groups or multiple time ranges to the * same S3 bucket. To separate log data for each export task, specify a prefix to * be used as the Amazon S3 key prefix for all exported objects.

*

Time-based sorting on chunks of log data inside an exported file is not * guaranteed. You can sort the exported log field data by using Linux * utilities.

See Also:

AWS * API Reference

*/ virtual Model::CreateExportTaskOutcome CreateExportTask(const Model::CreateExportTaskRequest& request) const; /** * A Callable wrapper for CreateExportTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateExportTaskOutcomeCallable CreateExportTaskCallable(const CreateExportTaskRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::CreateExportTask, request); } /** * An Async wrapper for CreateExportTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateExportTaskAsync(const CreateExportTaskRequestT& request, const CreateExportTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::CreateExportTask, request, handler, context); } /** *

Creates a log group with the specified name. You can create up to 20,000 log * groups per account.

You must use the following guidelines when naming a * log group:

  • Log group names must be unique within a Region for * an Amazon Web Services account.

  • Log group names can be between * 1 and 512 characters long.

  • Log group names consist of the * following characters: a-z, A-Z, 0-9, '_' (underscore), '-' (hyphen), '/' * (forward slash), '.' (period), and '#' (number sign)

When you * create a log group, by default the log events in the log group do not expire. To * set a retention policy so that events expire and are deleted after a specified * time, use PutRetentionPolicy.

*

If you associate an KMS key with the log group, ingested data is encrypted * using the KMS key. This association is stored as long as the data encrypted with * the KMS key is still within CloudWatch Logs. This enables CloudWatch Logs to * decrypt this data whenever it is requested.

If you attempt to associate a * KMS key with the log group but the KMS key does not exist or the KMS key is * disabled, you receive an InvalidParameterException error.

*

CloudWatch Logs supports only symmetric KMS keys. Do not * associate an asymmetric KMS key with your log group. For more information, see * Using * Symmetric and Asymmetric Keys.

See Also:

AWS * API Reference

*/ virtual Model::CreateLogGroupOutcome CreateLogGroup(const Model::CreateLogGroupRequest& request) const; /** * A Callable wrapper for CreateLogGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLogGroupOutcomeCallable CreateLogGroupCallable(const CreateLogGroupRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::CreateLogGroup, request); } /** * An Async wrapper for CreateLogGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLogGroupAsync(const CreateLogGroupRequestT& request, const CreateLogGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::CreateLogGroup, request, handler, context); } /** *

Creates a log stream for the specified log group. A log stream is a sequence * of log events that originate from a single source, such as an application * instance or a resource that is being monitored.

There is no limit on the * number of log streams that you can create for a log group. There is a limit of * 50 TPS on CreateLogStream operations, after which transactions are * throttled.

You must use the following guidelines when naming a log * stream:

  • Log stream names must be unique within the log * group.

  • Log stream names can be between 1 and 512 characters * long.

  • Don't use ':' (colon) or '*' (asterisk) characters.

    *

See Also:

AWS * API Reference

*/ virtual Model::CreateLogStreamOutcome CreateLogStream(const Model::CreateLogStreamRequest& request) const; /** * A Callable wrapper for CreateLogStream that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLogStreamOutcomeCallable CreateLogStreamCallable(const CreateLogStreamRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::CreateLogStream, request); } /** * An Async wrapper for CreateLogStream that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLogStreamAsync(const CreateLogStreamRequestT& request, const CreateLogStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::CreateLogStream, request, handler, context); } /** *

Deletes a CloudWatch Logs account policy.

To use this operation, you * must be signed on with the logs:DeleteDataProtectionPolicy and * logs:DeleteAccountPolicy permissions.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAccountPolicyOutcome DeleteAccountPolicy(const Model::DeleteAccountPolicyRequest& request) const; /** * A Callable wrapper for DeleteAccountPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAccountPolicyOutcomeCallable DeleteAccountPolicyCallable(const DeleteAccountPolicyRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DeleteAccountPolicy, request); } /** * An Async wrapper for DeleteAccountPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAccountPolicyAsync(const DeleteAccountPolicyRequestT& request, const DeleteAccountPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DeleteAccountPolicy, request, handler, context); } /** *

Deletes the data protection policy from the specified log group.

For * more information about data protection policies, see PutDataProtectionPolicy.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteDataProtectionPolicyOutcome DeleteDataProtectionPolicy(const Model::DeleteDataProtectionPolicyRequest& request) const; /** * A Callable wrapper for DeleteDataProtectionPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDataProtectionPolicyOutcomeCallable DeleteDataProtectionPolicyCallable(const DeleteDataProtectionPolicyRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DeleteDataProtectionPolicy, request); } /** * An Async wrapper for DeleteDataProtectionPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDataProtectionPolicyAsync(const DeleteDataProtectionPolicyRequestT& request, const DeleteDataProtectionPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DeleteDataProtectionPolicy, request, handler, context); } /** *

Deletes the specified destination, and eventually disables all the * subscription filters that publish to it. This operation does not delete the * physical resource encapsulated by the destination.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDestinationOutcome DeleteDestination(const Model::DeleteDestinationRequest& request) const; /** * A Callable wrapper for DeleteDestination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDestinationOutcomeCallable DeleteDestinationCallable(const DeleteDestinationRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DeleteDestination, request); } /** * An Async wrapper for DeleteDestination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDestinationAsync(const DeleteDestinationRequestT& request, const DeleteDestinationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DeleteDestination, request, handler, context); } /** *

Deletes the specified log group and permanently deletes all the archived log * events associated with the log group.

See Also:

AWS * API Reference

*/ virtual Model::DeleteLogGroupOutcome DeleteLogGroup(const Model::DeleteLogGroupRequest& request) const; /** * A Callable wrapper for DeleteLogGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteLogGroupOutcomeCallable DeleteLogGroupCallable(const DeleteLogGroupRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DeleteLogGroup, request); } /** * An Async wrapper for DeleteLogGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteLogGroupAsync(const DeleteLogGroupRequestT& request, const DeleteLogGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DeleteLogGroup, request, handler, context); } /** *

Deletes the specified log stream and permanently deletes all the archived log * events associated with the log stream.

See Also:

AWS * API Reference

*/ virtual Model::DeleteLogStreamOutcome DeleteLogStream(const Model::DeleteLogStreamRequest& request) const; /** * A Callable wrapper for DeleteLogStream that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteLogStreamOutcomeCallable DeleteLogStreamCallable(const DeleteLogStreamRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DeleteLogStream, request); } /** * An Async wrapper for DeleteLogStream that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteLogStreamAsync(const DeleteLogStreamRequestT& request, const DeleteLogStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DeleteLogStream, request, handler, context); } /** *

Deletes the specified metric filter.

See Also:

AWS * API Reference

*/ virtual Model::DeleteMetricFilterOutcome DeleteMetricFilter(const Model::DeleteMetricFilterRequest& request) const; /** * A Callable wrapper for DeleteMetricFilter that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteMetricFilterOutcomeCallable DeleteMetricFilterCallable(const DeleteMetricFilterRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DeleteMetricFilter, request); } /** * An Async wrapper for DeleteMetricFilter that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteMetricFilterAsync(const DeleteMetricFilterRequestT& request, const DeleteMetricFilterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DeleteMetricFilter, request, handler, context); } /** *

Deletes a saved CloudWatch Logs Insights query definition. A query definition * contains details about a saved CloudWatch Logs Insights query.

Each * DeleteQueryDefinition operation can delete one query * definition.

You must have the logs:DeleteQueryDefinition * permission to be able to perform this operation.

See Also:

AWS * API Reference

*/ virtual Model::DeleteQueryDefinitionOutcome DeleteQueryDefinition(const Model::DeleteQueryDefinitionRequest& request) const; /** * A Callable wrapper for DeleteQueryDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteQueryDefinitionOutcomeCallable DeleteQueryDefinitionCallable(const DeleteQueryDefinitionRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DeleteQueryDefinition, request); } /** * An Async wrapper for DeleteQueryDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteQueryDefinitionAsync(const DeleteQueryDefinitionRequestT& request, const DeleteQueryDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DeleteQueryDefinition, request, handler, context); } /** *

Deletes a resource policy from this account. This revokes the access of the * identities in that policy to put log events to this account.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const; /** * A Callable wrapper for DeleteResourcePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DeleteResourcePolicy, request); } /** * An Async wrapper for DeleteResourcePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DeleteResourcePolicy, request, handler, context); } /** *

Deletes the specified retention policy.

Log events do not expire if * they belong to log groups without a retention policy.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteRetentionPolicyOutcome DeleteRetentionPolicy(const Model::DeleteRetentionPolicyRequest& request) const; /** * A Callable wrapper for DeleteRetentionPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRetentionPolicyOutcomeCallable DeleteRetentionPolicyCallable(const DeleteRetentionPolicyRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DeleteRetentionPolicy, request); } /** * An Async wrapper for DeleteRetentionPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRetentionPolicyAsync(const DeleteRetentionPolicyRequestT& request, const DeleteRetentionPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DeleteRetentionPolicy, request, handler, context); } /** *

Deletes the specified subscription filter.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSubscriptionFilterOutcome DeleteSubscriptionFilter(const Model::DeleteSubscriptionFilterRequest& request) const; /** * A Callable wrapper for DeleteSubscriptionFilter that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSubscriptionFilterOutcomeCallable DeleteSubscriptionFilterCallable(const DeleteSubscriptionFilterRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DeleteSubscriptionFilter, request); } /** * An Async wrapper for DeleteSubscriptionFilter that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSubscriptionFilterAsync(const DeleteSubscriptionFilterRequestT& request, const DeleteSubscriptionFilterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DeleteSubscriptionFilter, request, handler, context); } /** *

Returns a list of all CloudWatch Logs account policies in the * account.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAccountPoliciesOutcome DescribeAccountPolicies(const Model::DescribeAccountPoliciesRequest& request) const; /** * A Callable wrapper for DescribeAccountPolicies that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAccountPoliciesOutcomeCallable DescribeAccountPoliciesCallable(const DescribeAccountPoliciesRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DescribeAccountPolicies, request); } /** * An Async wrapper for DescribeAccountPolicies that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAccountPoliciesAsync(const DescribeAccountPoliciesRequestT& request, const DescribeAccountPoliciesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DescribeAccountPolicies, request, handler, context); } /** *

Lists all your destinations. The results are ASCII-sorted by destination * name.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDestinationsOutcome DescribeDestinations(const Model::DescribeDestinationsRequest& request) const; /** * A Callable wrapper for DescribeDestinations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDestinationsOutcomeCallable DescribeDestinationsCallable(const DescribeDestinationsRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DescribeDestinations, request); } /** * An Async wrapper for DescribeDestinations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDestinationsAsync(const DescribeDestinationsRequestT& request, const DescribeDestinationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DescribeDestinations, request, handler, context); } /** *

Lists the specified export tasks. You can list all your export tasks or * filter the results based on task ID or task status.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeExportTasksOutcome DescribeExportTasks(const Model::DescribeExportTasksRequest& request) const; /** * A Callable wrapper for DescribeExportTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeExportTasksOutcomeCallable DescribeExportTasksCallable(const DescribeExportTasksRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DescribeExportTasks, request); } /** * An Async wrapper for DescribeExportTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeExportTasksAsync(const DescribeExportTasksRequestT& request, const DescribeExportTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DescribeExportTasks, request, handler, context); } /** *

Lists the specified log groups. You can list all your log groups or filter * the results by prefix. The results are ASCII-sorted by log group name.

*

CloudWatch Logs doesn’t support IAM policies that control access to the * DescribeLogGroups action by using the * aws:ResourceTag/key-name condition key. Other CloudWatch * Logs actions do support the use of the aws:ResourceTag/key-name * condition key to control access. For more information about using tags * to control access, see Controlling * access to Amazon Web Services resources using tags.

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

See Also:

AWS * API Reference

*/ virtual Model::DescribeLogGroupsOutcome DescribeLogGroups(const Model::DescribeLogGroupsRequest& request) const; /** * A Callable wrapper for DescribeLogGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLogGroupsOutcomeCallable DescribeLogGroupsCallable(const DescribeLogGroupsRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DescribeLogGroups, request); } /** * An Async wrapper for DescribeLogGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLogGroupsAsync(const DescribeLogGroupsRequestT& request, const DescribeLogGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DescribeLogGroups, request, handler, context); } /** *

Lists the log streams for the specified log group. You can list all the log * streams or filter the results by prefix. You can also control how the results * are ordered.

You can specify the log group to search by using either * logGroupIdentifier or logGroupName. You must include * one of these two parameters, but you can't include both.

This operation * has a limit of five transactions per second, after which transactions are * throttled.

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

See Also:

AWS * API Reference

*/ virtual Model::DescribeLogStreamsOutcome DescribeLogStreams(const Model::DescribeLogStreamsRequest& request) const; /** * A Callable wrapper for DescribeLogStreams that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLogStreamsOutcomeCallable DescribeLogStreamsCallable(const DescribeLogStreamsRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DescribeLogStreams, request); } /** * An Async wrapper for DescribeLogStreams that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLogStreamsAsync(const DescribeLogStreamsRequestT& request, const DescribeLogStreamsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DescribeLogStreams, request, handler, context); } /** *

Lists the specified metric filters. You can list all of the metric filters or * filter the results by log name, prefix, metric name, or metric namespace. The * results are ASCII-sorted by filter name.

See Also:

AWS * API Reference

*/ virtual Model::DescribeMetricFiltersOutcome DescribeMetricFilters(const Model::DescribeMetricFiltersRequest& request) const; /** * A Callable wrapper for DescribeMetricFilters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeMetricFiltersOutcomeCallable DescribeMetricFiltersCallable(const DescribeMetricFiltersRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DescribeMetricFilters, request); } /** * An Async wrapper for DescribeMetricFilters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeMetricFiltersAsync(const DescribeMetricFiltersRequestT& request, const DescribeMetricFiltersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DescribeMetricFilters, request, handler, context); } /** *

Returns a list of CloudWatch Logs Insights queries that are scheduled, * running, or have been run recently in this account. You can request all queries * or limit it to queries of a specific log group or queries with a certain * status.

See Also:

AWS * API Reference

*/ virtual Model::DescribeQueriesOutcome DescribeQueries(const Model::DescribeQueriesRequest& request) const; /** * A Callable wrapper for DescribeQueries that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeQueriesOutcomeCallable DescribeQueriesCallable(const DescribeQueriesRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DescribeQueries, request); } /** * An Async wrapper for DescribeQueries that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeQueriesAsync(const DescribeQueriesRequestT& request, const DescribeQueriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DescribeQueries, request, handler, context); } /** *

This operation returns a paginated list of your saved CloudWatch Logs * Insights query definitions.

You can use the * queryDefinitionNamePrefix parameter to limit the results to only * the query definitions that have names that start with a certain * string.

See Also:

AWS * API Reference

*/ virtual Model::DescribeQueryDefinitionsOutcome DescribeQueryDefinitions(const Model::DescribeQueryDefinitionsRequest& request) const; /** * A Callable wrapper for DescribeQueryDefinitions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeQueryDefinitionsOutcomeCallable DescribeQueryDefinitionsCallable(const DescribeQueryDefinitionsRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DescribeQueryDefinitions, request); } /** * An Async wrapper for DescribeQueryDefinitions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeQueryDefinitionsAsync(const DescribeQueryDefinitionsRequestT& request, const DescribeQueryDefinitionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DescribeQueryDefinitions, request, handler, context); } /** *

Lists the resource policies in this account.

See Also:

AWS * API Reference

*/ virtual Model::DescribeResourcePoliciesOutcome DescribeResourcePolicies(const Model::DescribeResourcePoliciesRequest& request) const; /** * A Callable wrapper for DescribeResourcePolicies that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeResourcePoliciesOutcomeCallable DescribeResourcePoliciesCallable(const DescribeResourcePoliciesRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DescribeResourcePolicies, request); } /** * An Async wrapper for DescribeResourcePolicies that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeResourcePoliciesAsync(const DescribeResourcePoliciesRequestT& request, const DescribeResourcePoliciesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DescribeResourcePolicies, request, handler, context); } /** *

Lists the subscription filters for the specified log group. You can list all * the subscription filters or filter the results by prefix. The results are * ASCII-sorted by filter name.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSubscriptionFiltersOutcome DescribeSubscriptionFilters(const Model::DescribeSubscriptionFiltersRequest& request) const; /** * A Callable wrapper for DescribeSubscriptionFilters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSubscriptionFiltersOutcomeCallable DescribeSubscriptionFiltersCallable(const DescribeSubscriptionFiltersRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DescribeSubscriptionFilters, request); } /** * An Async wrapper for DescribeSubscriptionFilters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSubscriptionFiltersAsync(const DescribeSubscriptionFiltersRequestT& request, const DescribeSubscriptionFiltersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DescribeSubscriptionFilters, request, handler, context); } /** *

Disassociates the specified KMS key from the specified log group or from all * CloudWatch Logs Insights query results in the account.

When you use * DisassociateKmsKey, you specify either the * logGroupName parameter or the resourceIdentifier * parameter. You can't specify both of those parameters in the same operation.

*

  • Specify the logGroupName parameter to stop using the * KMS key to encrypt future log events ingested and stored in the log group. * Instead, they will be encrypted with the default CloudWatch Logs method. The log * events that were ingested while the key was associated with the log group are * still encrypted with that key. Therefore, CloudWatch Logs will need permissions * for the key whenever that data is accessed.

  • Specify the * resourceIdentifier parameter with the query-result * resource to stop using the KMS key to encrypt the results of all future StartQuery * operations in the account. They will instead be encrypted with the default * CloudWatch Logs method. The results from queries that ran while the key was * associated with the account are still encrypted with that key. Therefore, * CloudWatch Logs will need permissions for the key whenever that data is * accessed.

It can take up to 5 minutes for this operation to * take effect.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateKmsKeyOutcome DisassociateKmsKey(const Model::DisassociateKmsKeyRequest& request) const; /** * A Callable wrapper for DisassociateKmsKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateKmsKeyOutcomeCallable DisassociateKmsKeyCallable(const DisassociateKmsKeyRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::DisassociateKmsKey, request); } /** * An Async wrapper for DisassociateKmsKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateKmsKeyAsync(const DisassociateKmsKeyRequestT& request, const DisassociateKmsKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::DisassociateKmsKey, request, handler, context); } /** *

Lists log events from the specified log group. You can list all the log * events or filter the results using a filter pattern, a time range, and the name * of the log stream.

You must have the logs:FilterLogEvents * permission to perform this operation.

You can specify the log group to * search by using either logGroupIdentifier or * logGroupName. You must include one of these two parameters, but you * can't include both.

By default, this operation returns as many log * events as can fit in 1 MB (up to 10,000 log events) or all the events found * within the specified time range. If the results include a token, that means * there are more log events available. You can get additional results by * specifying the token in a subsequent call. This operation can return empty * results while there are more log events available through the token.

The * returned log events are sorted by event timestamp, the timestamp when the event * was ingested by CloudWatch Logs, and the ID of the PutLogEvents * request.

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

See Also:

AWS * API Reference

*/ virtual Model::FilterLogEventsOutcome FilterLogEvents(const Model::FilterLogEventsRequest& request) const; /** * A Callable wrapper for FilterLogEvents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::FilterLogEventsOutcomeCallable FilterLogEventsCallable(const FilterLogEventsRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::FilterLogEvents, request); } /** * An Async wrapper for FilterLogEvents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void FilterLogEventsAsync(const FilterLogEventsRequestT& request, const FilterLogEventsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::FilterLogEvents, request, handler, context); } /** *

Returns information about a log group data protection policy.

See * Also:

AWS * API Reference

*/ virtual Model::GetDataProtectionPolicyOutcome GetDataProtectionPolicy(const Model::GetDataProtectionPolicyRequest& request) const; /** * A Callable wrapper for GetDataProtectionPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDataProtectionPolicyOutcomeCallable GetDataProtectionPolicyCallable(const GetDataProtectionPolicyRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::GetDataProtectionPolicy, request); } /** * An Async wrapper for GetDataProtectionPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDataProtectionPolicyAsync(const GetDataProtectionPolicyRequestT& request, const GetDataProtectionPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::GetDataProtectionPolicy, request, handler, context); } /** *

Lists log events from the specified log stream. You can list all of the log * events or filter using a time range.

By default, this operation returns * as many log events as can fit in a response size of 1MB (up to 10,000 log * events). You can get additional log events by specifying one of the tokens in a * subsequent call. This operation can return empty results while there are more * log events available through the token.

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

You can specify the log group to search * by using either logGroupIdentifier or logGroupName. * You must include one of these two parameters, but you can't include both. *

See Also:

AWS * API Reference

*/ virtual Model::GetLogEventsOutcome GetLogEvents(const Model::GetLogEventsRequest& request) const; /** * A Callable wrapper for GetLogEvents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetLogEventsOutcomeCallable GetLogEventsCallable(const GetLogEventsRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::GetLogEvents, request); } /** * An Async wrapper for GetLogEvents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetLogEventsAsync(const GetLogEventsRequestT& request, const GetLogEventsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::GetLogEvents, request, handler, context); } /** *

Returns a list of the fields that are included in log events in the specified * log group. Includes the percentage of log events that contain each field. The * search is limited to a time period that you specify.

You can specify the * log group to search by using either logGroupIdentifier or * logGroupName. You must specify one of these parameters, but you * can't specify both.

In the results, fields that start with * @ are fields generated by CloudWatch Logs. For example, * @timestamp is the timestamp of each log event. For more information * about the fields that are generated by CloudWatch logs, see Supported * Logs and Discovered Fields.

The response results are sorted by the * frequency percentage, starting with the highest percentage.

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

See Also:

AWS * API Reference

*/ virtual Model::GetLogGroupFieldsOutcome GetLogGroupFields(const Model::GetLogGroupFieldsRequest& request) const; /** * A Callable wrapper for GetLogGroupFields that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetLogGroupFieldsOutcomeCallable GetLogGroupFieldsCallable(const GetLogGroupFieldsRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::GetLogGroupFields, request); } /** * An Async wrapper for GetLogGroupFields that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetLogGroupFieldsAsync(const GetLogGroupFieldsRequestT& request, const GetLogGroupFieldsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::GetLogGroupFields, request, handler, context); } /** *

Retrieves all of the fields and values of a single log event. All fields are * retrieved, even if the original query that produced the * logRecordPointer retrieved only a subset of fields. Fields are * returned as field name/field value pairs.

The full unparsed log event is * returned within @message.

See Also:

AWS * API Reference

*/ virtual Model::GetLogRecordOutcome GetLogRecord(const Model::GetLogRecordRequest& request) const; /** * A Callable wrapper for GetLogRecord that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetLogRecordOutcomeCallable GetLogRecordCallable(const GetLogRecordRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::GetLogRecord, request); } /** * An Async wrapper for GetLogRecord that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetLogRecordAsync(const GetLogRecordRequestT& request, const GetLogRecordResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::GetLogRecord, request, handler, context); } /** *

Returns the results from the specified query.

Only the fields * requested in the query are returned, along with a @ptr field, which * is the identifier for the log record. You can use the value of @ptr * in a GetLogRecord * operation to get the full log record.

GetQueryResults does * not start running a query. To run a query, use StartQuery.

*

If the value of the Status field in the output is * Running, this operation returns only partial results. If you see a * value of Scheduled or Running for the status, you can * retry the operation later to see the final results.

If you are using * CloudWatch cross-account observability, you can use this operation in a * monitoring account to start queries in linked source accounts. For more * information, see CloudWatch * cross-account observability.

See Also:

AWS * API Reference

*/ virtual Model::GetQueryResultsOutcome GetQueryResults(const Model::GetQueryResultsRequest& request) const; /** * A Callable wrapper for GetQueryResults that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetQueryResultsOutcomeCallable GetQueryResultsCallable(const GetQueryResultsRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::GetQueryResults, request); } /** * An Async wrapper for GetQueryResults that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetQueryResultsAsync(const GetQueryResultsRequestT& request, const GetQueryResultsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::GetQueryResults, request, handler, context); } /** *

Displays the tags associated with a CloudWatch Logs resource. Currently, log * groups and destinations 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(&CloudWatchLogsClient::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(&CloudWatchLogsClient::ListTagsForResource, request, handler, context); } /** *

Creates an account-level data protection policy that applies to all log * groups in the account. A data protection policy can help safeguard sensitive * data that's ingested by your log groups by auditing and masking the sensitive * log data. Each account can have only one account-level policy.

*

Sensitive data is detected and masked when it is ingested into a log group. * When you set a data protection policy, log events ingested into the log groups * before that time are not masked.

If you use * PutAccountPolicy to create a data protection policy for your whole * account, it applies to both existing log groups and all log groups that are * created later in this account. The account policy is applied to existing log * groups with eventual consistency. It might take up to 5 minutes before sensitive * data in existing log groups begins to be masked.

By default, when a user * views a log event that includes masked data, the sensitive data is replaced by * asterisks. A user who has the logs:Unmask permission can use a GetLogEvents * or FilterLogEvents * operation with the unmask parameter set to true to * view the unmasked log events. Users with the logs:Unmask can also * view unmasked data in the CloudWatch Logs console by running a CloudWatch Logs * Insights query with the unmask query command.

For more * information, including a list of types of data that can be audited and masked, * see Protect * sensitive log data with masking.

To use the * PutAccountPolicy operation, you must be signed on with the * logs:PutDataProtectionPolicy and logs:PutAccountPolicy * permissions.

The PutAccountPolicy operation applies to all * log groups in the account. You can also use PutDataProtectionPolicy * to create a data protection policy that applies to just one log group. If a log * group has its own data protection policy and the account also has an * account-level data protection policy, then the two policies are cumulative. Any * sensitive term specified in either policy is masked.

See Also:

* AWS * API Reference

*/ virtual Model::PutAccountPolicyOutcome PutAccountPolicy(const Model::PutAccountPolicyRequest& request) const; /** * A Callable wrapper for PutAccountPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutAccountPolicyOutcomeCallable PutAccountPolicyCallable(const PutAccountPolicyRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::PutAccountPolicy, request); } /** * An Async wrapper for PutAccountPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutAccountPolicyAsync(const PutAccountPolicyRequestT& request, const PutAccountPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::PutAccountPolicy, request, handler, context); } /** *

Creates a data protection policy for the specified log group. A data * protection policy can help safeguard sensitive data that's ingested by the log * group by auditing and masking the sensitive log data.

*

Sensitive data is detected and masked when it is ingested into the log group. * When you set a data protection policy, log events ingested into the log group * before that time are not masked.

By default, when a user * views a log event that includes masked data, the sensitive data is replaced by * asterisks. A user who has the logs:Unmask permission can use a GetLogEvents * or FilterLogEvents * operation with the unmask parameter set to true to * view the unmasked log events. Users with the logs:Unmask can also * view unmasked data in the CloudWatch Logs console by running a CloudWatch Logs * Insights query with the unmask query command.

For more * information, including a list of types of data that can be audited and masked, * see Protect * sensitive log data with masking.

The * PutDataProtectionPolicy operation applies to only the specified log * group. You can also use PutAccountPolicy * to create an account-level data protection policy that applies to all log groups * in the account, including both existing log groups and log groups that are * created level. If a log group has its own data protection policy and the account * also has an account-level data protection policy, then the two policies are * cumulative. Any sensitive term specified in either policy is * masked.

See Also:

AWS * API Reference

*/ virtual Model::PutDataProtectionPolicyOutcome PutDataProtectionPolicy(const Model::PutDataProtectionPolicyRequest& request) const; /** * A Callable wrapper for PutDataProtectionPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutDataProtectionPolicyOutcomeCallable PutDataProtectionPolicyCallable(const PutDataProtectionPolicyRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::PutDataProtectionPolicy, request); } /** * An Async wrapper for PutDataProtectionPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutDataProtectionPolicyAsync(const PutDataProtectionPolicyRequestT& request, const PutDataProtectionPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::PutDataProtectionPolicy, request, handler, context); } /** *

Creates or updates a destination. This operation is used only to create * destinations for cross-account subscriptions.

A destination encapsulates * a physical resource (such as an Amazon Kinesis stream). With a destination, you * can subscribe to a real-time stream of log events for a different account, * ingested using PutLogEvents.

*

Through an access policy, a destination controls what is written to it. By * default, PutDestination does not set any access policy with the * destination, which means a cross-account user cannot call PutSubscriptionFilter * against this destination. To enable this, the destination owner must call PutDestinationPolicy * after PutDestination.

To perform a * PutDestination operation, you must also have the * iam:PassRole permission.

See Also:

AWS * API Reference

*/ virtual Model::PutDestinationOutcome PutDestination(const Model::PutDestinationRequest& request) const; /** * A Callable wrapper for PutDestination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutDestinationOutcomeCallable PutDestinationCallable(const PutDestinationRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::PutDestination, request); } /** * An Async wrapper for PutDestination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutDestinationAsync(const PutDestinationRequestT& request, const PutDestinationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::PutDestination, request, handler, context); } /** *

Creates or updates an access policy associated with an existing destination. * An access policy is an IAM * policy document that is used to authorize claims to register a subscription * filter against a given destination.

See Also:

AWS * API Reference

*/ virtual Model::PutDestinationPolicyOutcome PutDestinationPolicy(const Model::PutDestinationPolicyRequest& request) const; /** * A Callable wrapper for PutDestinationPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutDestinationPolicyOutcomeCallable PutDestinationPolicyCallable(const PutDestinationPolicyRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::PutDestinationPolicy, request); } /** * An Async wrapper for PutDestinationPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutDestinationPolicyAsync(const PutDestinationPolicyRequestT& request, const PutDestinationPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::PutDestinationPolicy, request, handler, context); } /** *

Uploads a batch of log events to the specified log stream.

*

The sequence token is now ignored in PutLogEvents actions. * PutLogEvents actions are always accepted and never return * InvalidSequenceTokenException or * DataAlreadyAcceptedException even if the sequence token is not * valid. You can use parallel PutLogEvents actions on the same log * stream.

The batch of events must satisfy the following * constraints:

  • The maximum batch size is 1,048,576 bytes. This * size is calculated as the sum of all event messages in UTF-8, plus 26 bytes for * each log event.

  • None of the log events in the batch can be * more than 2 hours in the future.

  • None of the log events in the * batch can be more than 14 days in the past. Also, none of the log events can be * from earlier than the retention period of the log group.

  • The * log events in the batch must be in chronological order by their timestamp. The * timestamp is the time that the event occurred, expressed as the number of * milliseconds after Jan 1, 1970 00:00:00 UTC. (In Amazon Web * Services Tools for PowerShell and the Amazon Web Services SDK for .NET, the * timestamp is specified in .NET format: yyyy-mm-ddThh:mm:ss. For * example, 2017-09-15T13:45:30.)

  • A batch of log * events in a single request cannot span more than 24 hours. Otherwise, the * operation fails.

  • Each log event can be no larger than 256 * KB.

  • The maximum number of log events in a batch is 10,000.

    *

  • The quota of five requests per second per log stream * has been removed. Instead, PutLogEvents actions are throttled based * on a per-second per-account quota. You can request an increase to the per-second * throttling quota by using the Service Quotas service.

    • *

If a call to PutLogEvents returns * "UnrecognizedClientException" the most likely cause is a non-valid Amazon Web * Services access key ID or secret key.

See Also:

AWS * API Reference

*/ virtual Model::PutLogEventsOutcome PutLogEvents(const Model::PutLogEventsRequest& request) const; /** * A Callable wrapper for PutLogEvents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutLogEventsOutcomeCallable PutLogEventsCallable(const PutLogEventsRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::PutLogEvents, request); } /** * An Async wrapper for PutLogEvents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutLogEventsAsync(const PutLogEventsRequestT& request, const PutLogEventsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::PutLogEvents, request, handler, context); } /** *

Creates or updates a metric filter and associates it with the specified log * group. With metric filters, you can configure rules to extract metric data from * log events ingested through PutLogEvents.

*

The maximum number of metric filters that can be associated with a log group * is 100.

When you create a metric filter, you can also optionally assign a * unit and dimensions to the metric that is created.

Metrics * extracted from log events are charged as custom metrics. To prevent unexpected * high charges, do not specify high-cardinality fields such as * IPAddress or requestID as dimensions. Each different * value found for a dimension is treated as a separate metric and accrues charges * as a separate custom metric.

CloudWatch Logs disables a metric filter if * it generates 1,000 different name/value pairs for your specified dimensions * within a certain amount of time. This helps to prevent accidental high * charges.

You can also set up a billing alarm to alert you if your charges * are higher than expected. For more information, see * Creating a Billing Alarm to Monitor Your Estimated Amazon Web Services * Charges.

See Also:

AWS * API Reference

*/ virtual Model::PutMetricFilterOutcome PutMetricFilter(const Model::PutMetricFilterRequest& request) const; /** * A Callable wrapper for PutMetricFilter that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutMetricFilterOutcomeCallable PutMetricFilterCallable(const PutMetricFilterRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::PutMetricFilter, request); } /** * An Async wrapper for PutMetricFilter that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutMetricFilterAsync(const PutMetricFilterRequestT& request, const PutMetricFilterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::PutMetricFilter, request, handler, context); } /** *

Creates or updates a query definition for CloudWatch Logs Insights. For more * information, see Analyzing * Log Data with CloudWatch Logs Insights.

To update a query definition, * specify its queryDefinitionId in your request. The values of * name, queryString, and logGroupNames are * changed to the values that you specify in your update operation. No current * values are retained from the current query definition. For example, imagine * updating a current query definition that includes log groups. If you don't * specify the logGroupNames parameter in your update operation, the * query definition changes to contain no log groups.

You must have the * logs:PutQueryDefinition permission to be able to perform this * operation.

See Also:

AWS * API Reference

*/ virtual Model::PutQueryDefinitionOutcome PutQueryDefinition(const Model::PutQueryDefinitionRequest& request) const; /** * A Callable wrapper for PutQueryDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutQueryDefinitionOutcomeCallable PutQueryDefinitionCallable(const PutQueryDefinitionRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::PutQueryDefinition, request); } /** * An Async wrapper for PutQueryDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutQueryDefinitionAsync(const PutQueryDefinitionRequestT& request, const PutQueryDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::PutQueryDefinition, request, handler, context); } /** *

Creates or updates a resource policy allowing other Amazon Web Services * services to put log events to this account, such as Amazon Route 53. An account * can have up to 10 resource policies per Amazon Web Services * Region.

See Also:

AWS * API Reference

*/ virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const; /** * A Callable wrapper for PutResourcePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::PutResourcePolicy, request); } /** * An Async wrapper for PutResourcePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::PutResourcePolicy, request, handler, context); } /** *

Sets the retention of the specified log group. With a retention policy, you * can configure the number of days for which to retain log events in the specified * log group.

CloudWatch Logs doesn’t immediately delete log events * when they reach their retention setting. It typically takes up to 72 hours after * that before log events are deleted, but in rare situations might take * longer.

To illustrate, imagine that you change a log group to have a * longer retention setting when it contains log events that are past the * expiration date, but haven’t been deleted. Those log events will take up to 72 * hours to be deleted after the new retention date is reached. To make sure that * log data is deleted permanently, keep a log group at its lower retention setting * until 72 hours after the previous retention period ends. Alternatively, wait to * change the retention setting until you confirm that the earlier log events are * deleted.

See Also:

AWS * API Reference

*/ virtual Model::PutRetentionPolicyOutcome PutRetentionPolicy(const Model::PutRetentionPolicyRequest& request) const; /** * A Callable wrapper for PutRetentionPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutRetentionPolicyOutcomeCallable PutRetentionPolicyCallable(const PutRetentionPolicyRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::PutRetentionPolicy, request); } /** * An Async wrapper for PutRetentionPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutRetentionPolicyAsync(const PutRetentionPolicyRequestT& request, const PutRetentionPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::PutRetentionPolicy, request, handler, context); } /** *

Creates or updates a subscription filter and associates it with the specified * log group. With subscription filters, you can subscribe to a real-time stream of * log events ingested through PutLogEvents * and have them delivered to a specific destination. When log events are sent to * the receiving service, they are Base64 encoded and compressed with the GZIP * format.

The following destinations are supported for subscription * filters:

  • An Amazon Kinesis data stream belonging to the same * account as the subscription filter, for same-account delivery.

  • *

    A logical destination created with PutDestination * that belongs to a different account, for cross-account delivery. We currently * support Kinesis Data Streams and Kinesis Data Firehose as logical * destinations.

  • An Amazon Kinesis Data Firehose delivery stream * that belongs to the same account as the subscription filter, for same-account * delivery.

  • An Lambda function that belongs to the same account * as the subscription filter, for same-account delivery.

Each * log group can have up to two subscription filters associated with it. If you are * updating an existing filter, you must specify the correct name in * filterName.

To perform a PutSubscriptionFilter * operation for any destination except a Lambda function, you must also have the * iam:PassRole permission.

See Also:

AWS * API Reference

*/ virtual Model::PutSubscriptionFilterOutcome PutSubscriptionFilter(const Model::PutSubscriptionFilterRequest& request) const; /** * A Callable wrapper for PutSubscriptionFilter that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutSubscriptionFilterOutcomeCallable PutSubscriptionFilterCallable(const PutSubscriptionFilterRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::PutSubscriptionFilter, request); } /** * An Async wrapper for PutSubscriptionFilter that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutSubscriptionFilterAsync(const PutSubscriptionFilterRequestT& request, const PutSubscriptionFilterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::PutSubscriptionFilter, request, handler, context); } /** *

Schedules a query of a log group using CloudWatch Logs Insights. You specify * the log group and time range to query and the query string to use.

For * more information, see CloudWatch * Logs Insights Query Syntax.

After you run a query using * StartQuery, the query results are stored by CloudWatch Logs. You * can use GetQueryResults * to retrieve the results of a query, using the queryId that * StartQuery returns.

If you have associated a KMS key with * the query results in this account, then StartQuery * uses that key to encrypt the results when it stores them. If no key is * associated with query results, the query results are encrypted with the default * CloudWatch Logs encryption method.

Queries time out after 60 minutes of * runtime. If your queries are timing out, reduce the time range being searched or * partition your query into a number of queries.

If you are using * CloudWatch cross-account observability, you can use this operation in a * monitoring account to start a query in a linked source account. For more * information, see CloudWatch * cross-account observability. For a cross-account StartQuery * operation, the query definition must be defined in the monitoring account.

*

You can have up to 30 concurrent CloudWatch Logs insights queries, including * queries that have been added to dashboards.

See Also:

AWS API * Reference

*/ virtual Model::StartQueryOutcome StartQuery(const Model::StartQueryRequest& request) const; /** * A Callable wrapper for StartQuery that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartQueryOutcomeCallable StartQueryCallable(const StartQueryRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::StartQuery, request); } /** * An Async wrapper for StartQuery that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartQueryAsync(const StartQueryRequestT& request, const StartQueryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::StartQuery, request, handler, context); } /** *

Stops a CloudWatch Logs Insights query that is in progress. If the query has * already ended, the operation returns an error indicating that the specified * query is not running.

See Also:

AWS API * Reference

*/ virtual Model::StopQueryOutcome StopQuery(const Model::StopQueryRequest& request) const; /** * A Callable wrapper for StopQuery that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopQueryOutcomeCallable StopQueryCallable(const StopQueryRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::StopQuery, request); } /** * An Async wrapper for StopQuery that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopQueryAsync(const StopQueryRequestT& request, const StopQueryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::StopQuery, request, handler, context); } /** *

Assigns one or more tags (key-value pairs) to the specified CloudWatch Logs * resource. Currently, the only CloudWatch Logs resources that can be tagged are * log groups and destinations.

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 a resource 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 Logs * 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(&CloudWatchLogsClient::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(&CloudWatchLogsClient::TagResource, request, handler, context); } /** *

Tests the filter pattern of a metric filter against a sample of log event * messages. You can use this operation to validate the correctness of a metric * filter pattern.

See Also:

AWS * API Reference

*/ virtual Model::TestMetricFilterOutcome TestMetricFilter(const Model::TestMetricFilterRequest& request) const; /** * A Callable wrapper for TestMetricFilter that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TestMetricFilterOutcomeCallable TestMetricFilterCallable(const TestMetricFilterRequestT& request) const { return SubmitCallable(&CloudWatchLogsClient::TestMetricFilter, request); } /** * An Async wrapper for TestMetricFilter that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TestMetricFilterAsync(const TestMetricFilterRequestT& request, const TestMetricFilterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudWatchLogsClient::TestMetricFilter, 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(&CloudWatchLogsClient::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(&CloudWatchLogsClient::UntagResource, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const CloudWatchLogsClientConfiguration& clientConfiguration); CloudWatchLogsClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace CloudWatchLogs } // namespace Aws