Documentation

Overview

    Package cloudwatchlogs provides the API client, operations, and parameter types for Amazon CloudWatch Logs.

    You can use Amazon CloudWatch Logs to monitor, store, and access your log files from EC2 instances, AWS CloudTrail, or other sources. You can then retrieve the associated log data from CloudWatch Logs using the CloudWatch console, CloudWatch Logs commands in the AWS 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 and 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") or 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 AWS 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 older than this setting are automatically deleted. The CloudWatch Logs agent makes it easy 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.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2014-03-28"
    View Source
    const ServiceID = "CloudWatch Logs"

    Variables

    This section is empty.

    Functions

    func NewDefaultEndpointResolver

    func NewDefaultEndpointResolver() *internalendpoints.Resolver

      NewDefaultEndpointResolver constructs a new service endpoint resolver

      func WithAPIOptions

      func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

        WithAPIOptions returns a functional option for setting the Client's APIOptions option.

        func WithEndpointResolver

        func WithEndpointResolver(v EndpointResolver) func(*Options)

          WithEndpointResolver returns a functional option for setting the Client's EndpointResolver option.

          Types

          type AssociateKmsKeyInput

          type AssociateKmsKeyInput struct {
          
          	// The Amazon Resource Name (ARN) of the CMK to use when encrypting log data. This
          	// must be a symmetric CMK. For more information, see Amazon Resource Names - AWS
          	// Key Management Service (AWS KMS)
          	// (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kms)
          	// and Using Symmetric and Asymmetric Keys
          	// (https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html).
          	//
          	// This member is required.
          	KmsKeyId *string
          
          	// The name of the log group.
          	//
          	// This member is required.
          	LogGroupName *string
          }

          type AssociateKmsKeyOutput

          type AssociateKmsKeyOutput struct {
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type CancelExportTaskInput

          type CancelExportTaskInput struct {
          
          	// The ID of the export task.
          	//
          	// This member is required.
          	TaskId *string
          }

          type CancelExportTaskOutput

          type CancelExportTaskOutput struct {
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type Client

          type Client struct {
          	// contains filtered or unexported fields
          }

            Client provides the API client to make operations call for Amazon CloudWatch Logs.

            func New

            func New(options Options, optFns ...func(*Options)) *Client

              New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

              func NewFromConfig

              func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

                NewFromConfig returns a new client from the provided config.

                func (*Client) AssociateKmsKey

                func (c *Client) AssociateKmsKey(ctx context.Context, params *AssociateKmsKeyInput, optFns ...func(*Options)) (*AssociateKmsKeyOutput, error)

                  Associates the specified AWS Key Management Service (AWS KMS) customer master key (CMK) with the specified log group. Associating an AWS KMS CMK with a log group overrides any existing associations between the log group and a CMK. After a CMK is associated with a log group, all newly ingested data for the log group is encrypted using the CMK. This association is stored as long as the data encrypted with the CMK is still within Amazon CloudWatch Logs. This enables Amazon CloudWatch Logs to decrypt this data whenever it is requested. CloudWatch Logs supports only symmetric CMKs. Do not use an associate an asymmetric CMK with your log group. For more information, see Using Symmetric and Asymmetric Keys (https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html). It can take up to 5 minutes for this operation to take effect. If you attempt to associate a CMK with a log group but the CMK does not exist or the CMK is disabled, you receive an InvalidParameterException error.

                  func (*Client) CancelExportTask

                  func (c *Client) CancelExportTask(ctx context.Context, params *CancelExportTaskInput, optFns ...func(*Options)) (*CancelExportTaskOutput, error)

                    Cancels the specified export task. The task must be in the PENDING or RUNNING state.

                    func (*Client) CreateExportTask

                    func (c *Client) CreateExportTask(ctx context.Context, params *CreateExportTaskInput, optFns ...func(*Options)) (*CreateExportTaskOutput, error)

                      Creates an export task, which allows you to 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. 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 (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeExportTasks.html) 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 (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CancelExportTask.html). You can export logs from multiple log groups or multiple time ranges to the same S3 bucket. To separate out log data for each export task, you can specify a prefix to be used as the Amazon S3 key prefix for all exported objects. Exporting to S3 buckets that are encrypted with AES-256 is supported. Exporting to S3 buckets encrypted with SSE-KMS is not supported.

                      func (*Client) CreateLogGroup

                      func (c *Client) CreateLogGroup(ctx context.Context, params *CreateLogGroupInput, optFns ...func(*Options)) (*CreateLogGroupOutput, error)

                        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 AWS 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 never expire. To set a retention policy so that events expire and are deleted after a specified time, use PutRetentionPolicy (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutRetentionPolicy.html). If you associate a AWS Key Management Service (AWS KMS) customer master key (CMK) with the log group, ingested data is encrypted using the CMK. This association is stored as long as the data encrypted with the CMK is still within Amazon CloudWatch Logs. This enables Amazon CloudWatch Logs to decrypt this data whenever it is requested. If you attempt to associate a CMK with the log group but the CMK does not exist or the CMK is disabled, you receive an InvalidParameterException error. CloudWatch Logs supports only symmetric CMKs. Do not associate an asymmetric CMK with your log group. For more information, see Using Symmetric and Asymmetric Keys (https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html).

                        func (*Client) CreateLogStream

                        func (c *Client) CreateLogStream(ctx context.Context, params *CreateLogStreamInput, optFns ...func(*Options)) (*CreateLogStreamOutput, error)

                          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.

                          * The ':' (colon) and '*' (asterisk) characters are not allowed.

                          func (*Client) DeleteDestination

                          func (c *Client) DeleteDestination(ctx context.Context, params *DeleteDestinationInput, optFns ...func(*Options)) (*DeleteDestinationOutput, error)

                            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.

                            func (*Client) DeleteLogGroup

                            func (c *Client) DeleteLogGroup(ctx context.Context, params *DeleteLogGroupInput, optFns ...func(*Options)) (*DeleteLogGroupOutput, error)

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

                              func (*Client) DeleteLogStream

                              func (c *Client) DeleteLogStream(ctx context.Context, params *DeleteLogStreamInput, optFns ...func(*Options)) (*DeleteLogStreamOutput, error)

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

                                func (*Client) DeleteMetricFilter

                                func (c *Client) DeleteMetricFilter(ctx context.Context, params *DeleteMetricFilterInput, optFns ...func(*Options)) (*DeleteMetricFilterOutput, error)

                                  Deletes the specified metric filter.

                                  func (*Client) DeleteQueryDefinition

                                  func (c *Client) DeleteQueryDefinition(ctx context.Context, params *DeleteQueryDefinitionInput, optFns ...func(*Options)) (*DeleteQueryDefinitionOutput, error)

                                    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.

                                    func (*Client) DeleteResourcePolicy

                                    func (c *Client) DeleteResourcePolicy(ctx context.Context, params *DeleteResourcePolicyInput, optFns ...func(*Options)) (*DeleteResourcePolicyOutput, error)

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

                                      func (*Client) DeleteRetentionPolicy

                                      func (c *Client) DeleteRetentionPolicy(ctx context.Context, params *DeleteRetentionPolicyInput, optFns ...func(*Options)) (*DeleteRetentionPolicyOutput, error)

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

                                        func (*Client) DeleteSubscriptionFilter

                                        func (c *Client) DeleteSubscriptionFilter(ctx context.Context, params *DeleteSubscriptionFilterInput, optFns ...func(*Options)) (*DeleteSubscriptionFilterOutput, error)

                                          Deletes the specified subscription filter.

                                          func (*Client) DescribeDestinations

                                          func (c *Client) DescribeDestinations(ctx context.Context, params *DescribeDestinationsInput, optFns ...func(*Options)) (*DescribeDestinationsOutput, error)

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

                                            func (*Client) DescribeExportTasks

                                            func (c *Client) DescribeExportTasks(ctx context.Context, params *DescribeExportTasksInput, optFns ...func(*Options)) (*DescribeExportTasksOutput, error)

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

                                              func (*Client) DescribeLogGroups

                                              func (c *Client) DescribeLogGroups(ctx context.Context, params *DescribeLogGroupsInput, optFns ...func(*Options)) (*DescribeLogGroupsOutput, error)

                                                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.

                                                func (*Client) DescribeLogStreams

                                                func (c *Client) DescribeLogStreams(ctx context.Context, params *DescribeLogStreamsInput, optFns ...func(*Options)) (*DescribeLogStreamsOutput, error)

                                                  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. This operation has a limit of five transactions per second, after which transactions are throttled.

                                                  func (*Client) DescribeMetricFilters

                                                  func (c *Client) DescribeMetricFilters(ctx context.Context, params *DescribeMetricFiltersInput, optFns ...func(*Options)) (*DescribeMetricFiltersOutput, error)

                                                    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.

                                                    func (*Client) DescribeQueries

                                                    func (c *Client) DescribeQueries(ctx context.Context, params *DescribeQueriesInput, optFns ...func(*Options)) (*DescribeQueriesOutput, error)

                                                      Returns a list of CloudWatch Logs Insights queries that are scheduled, executing, or have been executed 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.

                                                      func (*Client) DescribeQueryDefinitions

                                                      func (c *Client) DescribeQueryDefinitions(ctx context.Context, params *DescribeQueryDefinitionsInput, optFns ...func(*Options)) (*DescribeQueryDefinitionsOutput, error)

                                                        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.

                                                        func (*Client) DescribeResourcePolicies

                                                        func (c *Client) DescribeResourcePolicies(ctx context.Context, params *DescribeResourcePoliciesInput, optFns ...func(*Options)) (*DescribeResourcePoliciesOutput, error)

                                                          Lists the resource policies in this account.

                                                          func (*Client) DescribeSubscriptionFilters

                                                          func (c *Client) DescribeSubscriptionFilters(ctx context.Context, params *DescribeSubscriptionFiltersInput, optFns ...func(*Options)) (*DescribeSubscriptionFiltersOutput, error)

                                                            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.

                                                            func (*Client) DisassociateKmsKey

                                                            func (c *Client) DisassociateKmsKey(ctx context.Context, params *DisassociateKmsKeyInput, optFns ...func(*Options)) (*DisassociateKmsKeyOutput, error)

                                                              Disassociates the associated AWS Key Management Service (AWS KMS) customer master key (CMK) from the specified log group. After the AWS KMS CMK is disassociated from the log group, AWS CloudWatch Logs stops encrypting newly ingested data for the log group. All previously ingested data remains encrypted, and AWS CloudWatch Logs requires permissions for the CMK whenever the encrypted data is requested. Note that it can take up to 5 minutes for this operation to take effect.

                                                              func (*Client) FilterLogEvents

                                                              func (c *Client) FilterLogEvents(ctx context.Context, params *FilterLogEventsInput, optFns ...func(*Options)) (*FilterLogEventsOutput, error)

                                                                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. 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 time range that you specify. If the results include a token, then there are more log events available, and 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.

                                                                func (*Client) GetLogEvents

                                                                func (c *Client) GetLogEvents(ctx context.Context, params *GetLogEventsInput, optFns ...func(*Options)) (*GetLogEventsOutput, error)

                                                                  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.

                                                                  func (*Client) GetLogGroupFields

                                                                  func (c *Client) GetLogGroupFields(ctx context.Context, params *GetLogGroupFieldsInput, optFns ...func(*Options)) (*GetLogGroupFieldsOutput, error)

                                                                    Returns a list of the fields that are included in log events in the specified log group, along with the percentage of log events that contain each field. The search is limited to a time period that you specify. 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 (https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData-discoverable-fields.html). The response results are sorted by the frequency percentage, starting with the highest percentage.

                                                                    func (*Client) GetLogRecord

                                                                    func (c *Client) GetLogRecord(ctx context.Context, params *GetLogRecordInput, optFns ...func(*Options)) (*GetLogRecordOutput, error)

                                                                      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.

                                                                      func (*Client) GetQueryResults

                                                                      func (c *Client) GetQueryResults(ctx context.Context, params *GetQueryResultsInput, optFns ...func(*Options)) (*GetQueryResultsOutput, error)

                                                                        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 (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_GetLogRecord.html) operation to get the full log record. GetQueryResults does not start a query execution. To run a query, use StartQuery (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_StartQuery.html). 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.

                                                                        func (*Client) ListTagsLogGroup

                                                                        func (c *Client) ListTagsLogGroup(ctx context.Context, params *ListTagsLogGroupInput, optFns ...func(*Options)) (*ListTagsLogGroupOutput, error)

                                                                          Lists the tags for the specified log group.

                                                                          func (*Client) PutDestination

                                                                          func (c *Client) PutDestination(ctx context.Context, params *PutDestinationInput, optFns ...func(*Options)) (*PutDestinationOutput, error)

                                                                            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) and enables you to subscribe to a real-time stream of log events for a different account, ingested using PutLogEvents (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html). 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 (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutSubscriptionFilter.html) against this destination. To enable this, the destination owner must call PutDestinationPolicy (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutDestinationPolicy.html) after PutDestination. To perform a PutDestination operation, you must also have the iam:PassRole permission.

                                                                            func (*Client) PutDestinationPolicy

                                                                            func (c *Client) PutDestinationPolicy(ctx context.Context, params *PutDestinationPolicyInput, optFns ...func(*Options)) (*PutDestinationPolicyOutput, error)

                                                                              Creates or updates an access policy associated with an existing destination. An access policy is an IAM policy document (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies_overview.html) that is used to authorize claims to register a subscription filter against a given destination.

                                                                              func (*Client) PutLogEvents

                                                                              func (c *Client) PutLogEvents(ctx context.Context, params *PutLogEventsInput, optFns ...func(*Options)) (*PutLogEventsOutput, error)

                                                                                Uploads a batch of log events to the specified log stream. You must include the sequence token obtained from the response of the previous call. An upload in a newly created log stream does not require a sequence token. You can also get the sequence token in the expectedSequenceToken field from InvalidSequenceTokenException. If you call PutLogEvents twice within a narrow time period using the same value for sequenceToken, both calls might be successful or one might be rejected. 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 older than 14 days or older 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 the event occurred, expressed as the number of milliseconds after Jan 1, 1970 00:00:00 UTC. (In AWS Tools for PowerShell and the AWS 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.

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

                                                                                * There is a quota of 5 requests per second per log stream. Additional requests are throttled. This quota can't be changed.

                                                                                If a call to PutLogEvents returns "UnrecognizedClientException" the most likely cause is an invalid AWS access key ID or secret key.

                                                                                func (*Client) PutMetricFilter

                                                                                func (c *Client) PutMetricFilter(ctx context.Context, params *PutMetricFilterInput, optFns ...func(*Options)) (*PutMetricFilterOutput, error)

                                                                                  Creates or updates a metric filter and associates it with the specified log group. Metric filters allow you to configure rules to extract metric data from log events ingested through PutLogEvents (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html). The maximum number of metric filters that can be associated with a log group is 100.

                                                                                  func (*Client) PutQueryDefinition

                                                                                  func (c *Client) PutQueryDefinition(ctx context.Context, params *PutQueryDefinitionInput, optFns ...func(*Options)) (*PutQueryDefinitionOutput, error)

                                                                                    Creates or updates a query definition for CloudWatch Logs Insights. For more information, see Analyzing Log Data with CloudWatch Logs Insights (https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html). 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, if you update a current query definition that includes log groups, and 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.

                                                                                    func (*Client) PutResourcePolicy

                                                                                    func (c *Client) PutResourcePolicy(ctx context.Context, params *PutResourcePolicyInput, optFns ...func(*Options)) (*PutResourcePolicyOutput, error)

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

                                                                                      func (*Client) PutRetentionPolicy

                                                                                      func (c *Client) PutRetentionPolicy(ctx context.Context, params *PutRetentionPolicyInput, optFns ...func(*Options)) (*PutRetentionPolicyOutput, error)

                                                                                        Sets the retention of the specified log group. A retention policy allows you to configure the number of days for which to retain log events in the specified log group.

                                                                                        func (*Client) PutSubscriptionFilter

                                                                                        func (c *Client) PutSubscriptionFilter(ctx context.Context, params *PutSubscriptionFilterInput, optFns ...func(*Options)) (*PutSubscriptionFilterOutput, error)

                                                                                          Creates or updates a subscription filter and associates it with the specified log group. Subscription filters allow you to subscribe to a real-time stream of log events ingested through PutLogEvents (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html) 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 stream belonging to the same account as the subscription filter, for same-account delivery.

                                                                                          * A logical destination that belongs to a different account, for cross-account delivery.

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

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

                                                                                          There can only be one subscription filter associated with a log group. If you are updating an existing filter, you must specify the correct name in filterName. Otherwise, the call fails because you cannot associate a second filter with a log group. To perform a PutSubscriptionFilter operation, you must also have the iam:PassRole permission.

                                                                                          func (*Client) StartQuery

                                                                                          func (c *Client) StartQuery(ctx context.Context, params *StartQueryInput, optFns ...func(*Options)) (*StartQueryOutput, error)

                                                                                            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 (https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html). Queries time out after 15 minutes of execution. If your queries are timing out, reduce the time range being searched or partition your query into a number of queries.

                                                                                            func (*Client) StopQuery

                                                                                            func (c *Client) StopQuery(ctx context.Context, params *StopQueryInput, optFns ...func(*Options)) (*StopQueryOutput, error)

                                                                                              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.

                                                                                              func (*Client) TagLogGroup

                                                                                              func (c *Client) TagLogGroup(ctx context.Context, params *TagLogGroupInput, optFns ...func(*Options)) (*TagLogGroupOutput, error)

                                                                                                Adds or updates the specified tags for the specified log group. To list the tags for a log group, use ListTagsLogGroup (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_ListTagsLogGroup.html). To remove tags, use UntagLogGroup (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_UntagLogGroup.html). For more information about tags, see Tag Log Groups in Amazon CloudWatch Logs (https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#log-group-tagging) in the Amazon CloudWatch Logs User Guide.

                                                                                                func (*Client) TestMetricFilter

                                                                                                func (c *Client) TestMetricFilter(ctx context.Context, params *TestMetricFilterInput, optFns ...func(*Options)) (*TestMetricFilterOutput, error)

                                                                                                  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.

                                                                                                  func (*Client) UntagLogGroup

                                                                                                  func (c *Client) UntagLogGroup(ctx context.Context, params *UntagLogGroupInput, optFns ...func(*Options)) (*UntagLogGroupOutput, error)

                                                                                                    Removes the specified tags from the specified log group. To list the tags for a log group, use ListTagsLogGroup (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_ListTagsLogGroup.html). To add tags, use TagLogGroup (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_TagLogGroup.html).

                                                                                                    type CreateExportTaskInput

                                                                                                    type CreateExportTaskInput struct {
                                                                                                    
                                                                                                    	// The name of S3 bucket for the exported log data. The bucket must be in the same
                                                                                                    	// AWS region.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	Destination *string
                                                                                                    
                                                                                                    	// The start time of the range for the request, expressed as the number of
                                                                                                    	// milliseconds after Jan 1, 1970 00:00:00 UTC. Events with a timestamp earlier
                                                                                                    	// than this time are not exported.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	From *int64
                                                                                                    
                                                                                                    	// The name of the log group.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	LogGroupName *string
                                                                                                    
                                                                                                    	// The end time of the range for the request, expressed as the number of
                                                                                                    	// milliseconds after Jan 1, 1970 00:00:00 UTC. Events with a timestamp later than
                                                                                                    	// this time are not exported.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	To *int64
                                                                                                    
                                                                                                    	// The prefix used as the start of the key for every object exported. If you don't
                                                                                                    	// specify a value, the default is exportedlogs.
                                                                                                    	DestinationPrefix *string
                                                                                                    
                                                                                                    	// Export only log streams that match the provided prefix. If you don't specify a
                                                                                                    	// value, no prefix filter is applied.
                                                                                                    	LogStreamNamePrefix *string
                                                                                                    
                                                                                                    	// The name of the export task.
                                                                                                    	TaskName *string
                                                                                                    }

                                                                                                    type CreateExportTaskOutput

                                                                                                    type CreateExportTaskOutput struct {
                                                                                                    
                                                                                                    	// The ID of the export task.
                                                                                                    	TaskId *string
                                                                                                    
                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                    }

                                                                                                    type CreateLogGroupInput

                                                                                                    type CreateLogGroupInput struct {
                                                                                                    
                                                                                                    	// The name of the log group.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	LogGroupName *string
                                                                                                    
                                                                                                    	// The Amazon Resource Name (ARN) of the CMK to use when encrypting log data. For
                                                                                                    	// more information, see Amazon Resource Names - AWS Key Management Service (AWS
                                                                                                    	// KMS)
                                                                                                    	// (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kms).
                                                                                                    	KmsKeyId *string
                                                                                                    
                                                                                                    	// The key-value pairs to use for the tags.
                                                                                                    	Tags map[string]string
                                                                                                    }

                                                                                                    type CreateLogGroupOutput

                                                                                                    type CreateLogGroupOutput struct {
                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                    }

                                                                                                    type CreateLogStreamInput

                                                                                                    type CreateLogStreamInput struct {
                                                                                                    
                                                                                                    	// The name of the log group.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	LogGroupName *string
                                                                                                    
                                                                                                    	// The name of the log stream.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	LogStreamName *string
                                                                                                    }

                                                                                                    type CreateLogStreamOutput

                                                                                                    type CreateLogStreamOutput struct {
                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                    }

                                                                                                    type DeleteDestinationInput

                                                                                                    type DeleteDestinationInput struct {
                                                                                                    
                                                                                                    	// The name of the destination.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	DestinationName *string
                                                                                                    }

                                                                                                    type DeleteDestinationOutput

                                                                                                    type DeleteDestinationOutput struct {
                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                    }

                                                                                                    type DeleteLogGroupInput

                                                                                                    type DeleteLogGroupInput struct {
                                                                                                    
                                                                                                    	// The name of the log group.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	LogGroupName *string
                                                                                                    }

                                                                                                    type DeleteLogGroupOutput

                                                                                                    type DeleteLogGroupOutput struct {
                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                    }

                                                                                                    type DeleteLogStreamInput

                                                                                                    type DeleteLogStreamInput struct {
                                                                                                    
                                                                                                    	// The name of the log group.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	LogGroupName *string
                                                                                                    
                                                                                                    	// The name of the log stream.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	LogStreamName *string
                                                                                                    }

                                                                                                    type DeleteLogStreamOutput

                                                                                                    type DeleteLogStreamOutput struct {
                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                    }

                                                                                                    type DeleteMetricFilterInput

                                                                                                    type DeleteMetricFilterInput struct {
                                                                                                    
                                                                                                    	// The name of the metric filter.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	FilterName *string
                                                                                                    
                                                                                                    	// The name of the log group.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	LogGroupName *string
                                                                                                    }

                                                                                                    type DeleteMetricFilterOutput

                                                                                                    type DeleteMetricFilterOutput struct {
                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                    }

                                                                                                    type DeleteQueryDefinitionInput

                                                                                                    type DeleteQueryDefinitionInput struct {
                                                                                                    
                                                                                                    	// The ID of the query definition that you want to delete. You can use
                                                                                                    	// DescribeQueryDefinitions
                                                                                                    	// (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeQueryDefinitions.html)
                                                                                                    	// to retrieve the IDs of your saved query definitions.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	QueryDefinitionId *string
                                                                                                    }

                                                                                                    type DeleteQueryDefinitionOutput

                                                                                                    type DeleteQueryDefinitionOutput struct {
                                                                                                    
                                                                                                    	// A value of TRUE indicates that the operation succeeded. FALSE indicates that the
                                                                                                    	// operation failed.
                                                                                                    	Success bool
                                                                                                    
                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                    }

                                                                                                    type DeleteResourcePolicyInput

                                                                                                    type DeleteResourcePolicyInput struct {
                                                                                                    
                                                                                                    	// The name of the policy to be revoked. This parameter is required.
                                                                                                    	PolicyName *string
                                                                                                    }

                                                                                                    type DeleteResourcePolicyOutput

                                                                                                    type DeleteResourcePolicyOutput struct {
                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                    }

                                                                                                    type DeleteRetentionPolicyInput

                                                                                                    type DeleteRetentionPolicyInput struct {
                                                                                                    
                                                                                                    	// The name of the log group.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	LogGroupName *string
                                                                                                    }

                                                                                                    type DeleteRetentionPolicyOutput

                                                                                                    type DeleteRetentionPolicyOutput struct {
                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                    }

                                                                                                    type DeleteSubscriptionFilterInput

                                                                                                    type DeleteSubscriptionFilterInput struct {
                                                                                                    
                                                                                                    	// The name of the subscription filter.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	FilterName *string
                                                                                                    
                                                                                                    	// The name of the log group.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	LogGroupName *string
                                                                                                    }

                                                                                                    type DeleteSubscriptionFilterOutput

                                                                                                    type DeleteSubscriptionFilterOutput struct {
                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                    }

                                                                                                    type DescribeDestinationsAPIClient

                                                                                                    type DescribeDestinationsAPIClient interface {
                                                                                                    	DescribeDestinations(context.Context, *DescribeDestinationsInput, ...func(*Options)) (*DescribeDestinationsOutput, error)
                                                                                                    }

                                                                                                      DescribeDestinationsAPIClient is a client that implements the DescribeDestinations operation.

                                                                                                      type DescribeDestinationsInput

                                                                                                      type DescribeDestinationsInput struct {
                                                                                                      
                                                                                                      	// The prefix to match. If you don't specify a value, no prefix filter is applied.
                                                                                                      	DestinationNamePrefix *string
                                                                                                      
                                                                                                      	// The maximum number of items returned. If you don't specify a value, the default
                                                                                                      	// is up to 50 items.
                                                                                                      	Limit *int32
                                                                                                      
                                                                                                      	// The token for the next set of items to return. (You received this token from a
                                                                                                      	// previous call.)
                                                                                                      	NextToken *string
                                                                                                      }

                                                                                                      type DescribeDestinationsOutput

                                                                                                      type DescribeDestinationsOutput struct {
                                                                                                      
                                                                                                      	// The destinations.
                                                                                                      	Destinations []types.Destination
                                                                                                      
                                                                                                      	// The token for the next set of items to return. The token expires after 24 hours.
                                                                                                      	NextToken *string
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type DescribeDestinationsPaginator

                                                                                                      type DescribeDestinationsPaginator struct {
                                                                                                      	// contains filtered or unexported fields
                                                                                                      }

                                                                                                        DescribeDestinationsPaginator is a paginator for DescribeDestinations

                                                                                                        func NewDescribeDestinationsPaginator

                                                                                                          NewDescribeDestinationsPaginator returns a new DescribeDestinationsPaginator

                                                                                                          func (*DescribeDestinationsPaginator) HasMorePages

                                                                                                          func (p *DescribeDestinationsPaginator) HasMorePages() bool

                                                                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                                                                            func (*DescribeDestinationsPaginator) NextPage

                                                                                                              NextPage retrieves the next DescribeDestinations page.

                                                                                                              type DescribeDestinationsPaginatorOptions

                                                                                                              type DescribeDestinationsPaginatorOptions struct {
                                                                                                              	// The maximum number of items returned. If you don't specify a value, the default
                                                                                                              	// is up to 50 items.
                                                                                                              	Limit int32
                                                                                                              
                                                                                                              	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                              	// that matches the most recent token provided to the service.
                                                                                                              	StopOnDuplicateToken bool
                                                                                                              }

                                                                                                                DescribeDestinationsPaginatorOptions is the paginator options for DescribeDestinations

                                                                                                                type DescribeExportTasksInput

                                                                                                                type DescribeExportTasksInput struct {
                                                                                                                
                                                                                                                	// The maximum number of items returned. If you don't specify a value, the default
                                                                                                                	// is up to 50 items.
                                                                                                                	Limit *int32
                                                                                                                
                                                                                                                	// The token for the next set of items to return. (You received this token from a
                                                                                                                	// previous call.)
                                                                                                                	NextToken *string
                                                                                                                
                                                                                                                	// The status code of the export task. Specifying a status code filters the results
                                                                                                                	// to zero or more export tasks.
                                                                                                                	StatusCode types.ExportTaskStatusCode
                                                                                                                
                                                                                                                	// The ID of the export task. Specifying a task ID filters the results to zero or
                                                                                                                	// one export tasks.
                                                                                                                	TaskId *string
                                                                                                                }

                                                                                                                type DescribeExportTasksOutput

                                                                                                                type DescribeExportTasksOutput struct {
                                                                                                                
                                                                                                                	// The export tasks.
                                                                                                                	ExportTasks []types.ExportTask
                                                                                                                
                                                                                                                	// The token for the next set of items to return. The token expires after 24 hours.
                                                                                                                	NextToken *string
                                                                                                                
                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                }

                                                                                                                type DescribeLogGroupsAPIClient

                                                                                                                type DescribeLogGroupsAPIClient interface {
                                                                                                                	DescribeLogGroups(context.Context, *DescribeLogGroupsInput, ...func(*Options)) (*DescribeLogGroupsOutput, error)
                                                                                                                }

                                                                                                                  DescribeLogGroupsAPIClient is a client that implements the DescribeLogGroups operation.

                                                                                                                  type DescribeLogGroupsInput

                                                                                                                  type DescribeLogGroupsInput struct {
                                                                                                                  
                                                                                                                  	// The maximum number of items returned. If you don't specify a value, the default
                                                                                                                  	// is up to 50 items.
                                                                                                                  	Limit *int32
                                                                                                                  
                                                                                                                  	// The prefix to match.
                                                                                                                  	LogGroupNamePrefix *string
                                                                                                                  
                                                                                                                  	// The token for the next set of items to return. (You received this token from a
                                                                                                                  	// previous call.)
                                                                                                                  	NextToken *string
                                                                                                                  }

                                                                                                                  type DescribeLogGroupsOutput

                                                                                                                  type DescribeLogGroupsOutput struct {
                                                                                                                  
                                                                                                                  	// The log groups. If the retentionInDays value if not included for a log group,
                                                                                                                  	// then that log group is set to have its events never expire.
                                                                                                                  	LogGroups []types.LogGroup
                                                                                                                  
                                                                                                                  	// The token for the next set of items to return. The token expires after 24 hours.
                                                                                                                  	NextToken *string
                                                                                                                  
                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                  }

                                                                                                                  type DescribeLogGroupsPaginator

                                                                                                                  type DescribeLogGroupsPaginator struct {
                                                                                                                  	// contains filtered or unexported fields
                                                                                                                  }

                                                                                                                    DescribeLogGroupsPaginator is a paginator for DescribeLogGroups

                                                                                                                    func NewDescribeLogGroupsPaginator

                                                                                                                    func NewDescribeLogGroupsPaginator(client DescribeLogGroupsAPIClient, params *DescribeLogGroupsInput, optFns ...func(*DescribeLogGroupsPaginatorOptions)) *DescribeLogGroupsPaginator

                                                                                                                      NewDescribeLogGroupsPaginator returns a new DescribeLogGroupsPaginator

                                                                                                                      func (*DescribeLogGroupsPaginator) HasMorePages

                                                                                                                      func (p *DescribeLogGroupsPaginator) HasMorePages() bool

                                                                                                                        HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                        func (*DescribeLogGroupsPaginator) NextPage

                                                                                                                        func (p *DescribeLogGroupsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeLogGroupsOutput, error)

                                                                                                                          NextPage retrieves the next DescribeLogGroups page.

                                                                                                                          type DescribeLogGroupsPaginatorOptions

                                                                                                                          type DescribeLogGroupsPaginatorOptions struct {
                                                                                                                          	// The maximum number of items returned. If you don't specify a value, the default
                                                                                                                          	// is up to 50 items.
                                                                                                                          	Limit int32
                                                                                                                          
                                                                                                                          	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                          	// that matches the most recent token provided to the service.
                                                                                                                          	StopOnDuplicateToken bool
                                                                                                                          }

                                                                                                                            DescribeLogGroupsPaginatorOptions is the paginator options for DescribeLogGroups

                                                                                                                            type DescribeLogStreamsAPIClient

                                                                                                                            type DescribeLogStreamsAPIClient interface {
                                                                                                                            	DescribeLogStreams(context.Context, *DescribeLogStreamsInput, ...func(*Options)) (*DescribeLogStreamsOutput, error)
                                                                                                                            }

                                                                                                                              DescribeLogStreamsAPIClient is a client that implements the DescribeLogStreams operation.

                                                                                                                              type DescribeLogStreamsInput

                                                                                                                              type DescribeLogStreamsInput struct {
                                                                                                                              
                                                                                                                              	// The name of the log group.
                                                                                                                              	//
                                                                                                                              	// This member is required.
                                                                                                                              	LogGroupName *string
                                                                                                                              
                                                                                                                              	// If the value is true, results are returned in descending order. If the value is
                                                                                                                              	// to false, results are returned in ascending order. The default value is false.
                                                                                                                              	Descending *bool
                                                                                                                              
                                                                                                                              	// The maximum number of items returned. If you don't specify a value, the default
                                                                                                                              	// is up to 50 items.
                                                                                                                              	Limit *int32
                                                                                                                              
                                                                                                                              	// The prefix to match. If orderBy is LastEventTime, you cannot specify this
                                                                                                                              	// parameter.
                                                                                                                              	LogStreamNamePrefix *string
                                                                                                                              
                                                                                                                              	// The token for the next set of items to return. (You received this token from a
                                                                                                                              	// previous call.)
                                                                                                                              	NextToken *string
                                                                                                                              
                                                                                                                              	// If the value is LogStreamName, the results are ordered by log stream name. If
                                                                                                                              	// the value is LastEventTime, the results are ordered by the event time. The
                                                                                                                              	// default value is LogStreamName. If you order the results by event time, you
                                                                                                                              	// cannot specify the logStreamNamePrefix parameter. lastEventTimeStamp represents
                                                                                                                              	// the time of the most recent log event in the log stream in CloudWatch Logs. This
                                                                                                                              	// number is expressed as the number of milliseconds after Jan 1, 1970 00:00:00
                                                                                                                              	// UTC. lastEventTimeStamp updates on an eventual consistency basis. It typically
                                                                                                                              	// updates in less than an hour from ingestion, but in rare situations might take
                                                                                                                              	// longer.
                                                                                                                              	OrderBy types.OrderBy
                                                                                                                              }

                                                                                                                              type DescribeLogStreamsOutput

                                                                                                                              type DescribeLogStreamsOutput struct {
                                                                                                                              
                                                                                                                              	// The log streams.
                                                                                                                              	LogStreams []types.LogStream
                                                                                                                              
                                                                                                                              	// The token for the next set of items to return. The token expires after 24 hours.
                                                                                                                              	NextToken *string
                                                                                                                              
                                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                                              }

                                                                                                                              type DescribeLogStreamsPaginator

                                                                                                                              type DescribeLogStreamsPaginator struct {
                                                                                                                              	// contains filtered or unexported fields
                                                                                                                              }

                                                                                                                                DescribeLogStreamsPaginator is a paginator for DescribeLogStreams

                                                                                                                                func NewDescribeLogStreamsPaginator

                                                                                                                                func NewDescribeLogStreamsPaginator(client DescribeLogStreamsAPIClient, params *DescribeLogStreamsInput, optFns ...func(*DescribeLogStreamsPaginatorOptions)) *DescribeLogStreamsPaginator

                                                                                                                                  NewDescribeLogStreamsPaginator returns a new DescribeLogStreamsPaginator

                                                                                                                                  func (*DescribeLogStreamsPaginator) HasMorePages

                                                                                                                                  func (p *DescribeLogStreamsPaginator) HasMorePages() bool

                                                                                                                                    HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                    func (*DescribeLogStreamsPaginator) NextPage

                                                                                                                                    func (p *DescribeLogStreamsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeLogStreamsOutput, error)

                                                                                                                                      NextPage retrieves the next DescribeLogStreams page.

                                                                                                                                      type DescribeLogStreamsPaginatorOptions

                                                                                                                                      type DescribeLogStreamsPaginatorOptions struct {
                                                                                                                                      	// The maximum number of items returned. If you don't specify a value, the default
                                                                                                                                      	// is up to 50 items.
                                                                                                                                      	Limit int32
                                                                                                                                      
                                                                                                                                      	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                      	// that matches the most recent token provided to the service.
                                                                                                                                      	StopOnDuplicateToken bool
                                                                                                                                      }

                                                                                                                                        DescribeLogStreamsPaginatorOptions is the paginator options for DescribeLogStreams

                                                                                                                                        type DescribeMetricFiltersAPIClient

                                                                                                                                        type DescribeMetricFiltersAPIClient interface {
                                                                                                                                        	DescribeMetricFilters(context.Context, *DescribeMetricFiltersInput, ...func(*Options)) (*DescribeMetricFiltersOutput, error)
                                                                                                                                        }

                                                                                                                                          DescribeMetricFiltersAPIClient is a client that implements the DescribeMetricFilters operation.

                                                                                                                                          type DescribeMetricFiltersInput

                                                                                                                                          type DescribeMetricFiltersInput struct {
                                                                                                                                          
                                                                                                                                          	// The prefix to match. CloudWatch Logs uses the value you set here only if you
                                                                                                                                          	// also include the logGroupName parameter in your request.
                                                                                                                                          	FilterNamePrefix *string
                                                                                                                                          
                                                                                                                                          	// The maximum number of items returned. If you don't specify a value, the default
                                                                                                                                          	// is up to 50 items.
                                                                                                                                          	Limit *int32
                                                                                                                                          
                                                                                                                                          	// The name of the log group.
                                                                                                                                          	LogGroupName *string
                                                                                                                                          
                                                                                                                                          	// Filters results to include only those with the specified metric name. If you
                                                                                                                                          	// include this parameter in your request, you must also include the
                                                                                                                                          	// metricNamespace parameter.
                                                                                                                                          	MetricName *string
                                                                                                                                          
                                                                                                                                          	// Filters results to include only those in the specified namespace. If you include
                                                                                                                                          	// this parameter in your request, you must also include the metricName parameter.
                                                                                                                                          	MetricNamespace *string
                                                                                                                                          
                                                                                                                                          	// The token for the next set of items to return. (You received this token from a
                                                                                                                                          	// previous call.)
                                                                                                                                          	NextToken *string
                                                                                                                                          }

                                                                                                                                          type DescribeMetricFiltersOutput

                                                                                                                                          type DescribeMetricFiltersOutput struct {
                                                                                                                                          
                                                                                                                                          	// The metric filters.
                                                                                                                                          	MetricFilters []types.MetricFilter
                                                                                                                                          
                                                                                                                                          	// The token for the next set of items to return. The token expires after 24 hours.
                                                                                                                                          	NextToken *string
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DescribeMetricFiltersPaginator

                                                                                                                                          type DescribeMetricFiltersPaginator struct {
                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                          }

                                                                                                                                            DescribeMetricFiltersPaginator is a paginator for DescribeMetricFilters

                                                                                                                                            func NewDescribeMetricFiltersPaginator

                                                                                                                                              NewDescribeMetricFiltersPaginator returns a new DescribeMetricFiltersPaginator

                                                                                                                                              func (*DescribeMetricFiltersPaginator) HasMorePages

                                                                                                                                              func (p *DescribeMetricFiltersPaginator) HasMorePages() bool

                                                                                                                                                HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                func (*DescribeMetricFiltersPaginator) NextPage

                                                                                                                                                  NextPage retrieves the next DescribeMetricFilters page.

                                                                                                                                                  type DescribeMetricFiltersPaginatorOptions

                                                                                                                                                  type DescribeMetricFiltersPaginatorOptions struct {
                                                                                                                                                  	// The maximum number of items returned. If you don't specify a value, the default
                                                                                                                                                  	// is up to 50 items.
                                                                                                                                                  	Limit int32
                                                                                                                                                  
                                                                                                                                                  	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                  	// that matches the most recent token provided to the service.
                                                                                                                                                  	StopOnDuplicateToken bool
                                                                                                                                                  }

                                                                                                                                                    DescribeMetricFiltersPaginatorOptions is the paginator options for DescribeMetricFilters

                                                                                                                                                    type DescribeQueriesInput

                                                                                                                                                    type DescribeQueriesInput struct {
                                                                                                                                                    
                                                                                                                                                    	// Limits the returned queries to only those for the specified log group.
                                                                                                                                                    	LogGroupName *string
                                                                                                                                                    
                                                                                                                                                    	// Limits the number of returned queries to the specified number.
                                                                                                                                                    	MaxResults *int32
                                                                                                                                                    
                                                                                                                                                    	// The token for the next set of items to return. The token expires after 24 hours.
                                                                                                                                                    	NextToken *string
                                                                                                                                                    
                                                                                                                                                    	// Limits the returned queries to only those that have the specified status. Valid
                                                                                                                                                    	// values are Cancelled, Complete, Failed, Running, and Scheduled.
                                                                                                                                                    	Status types.QueryStatus
                                                                                                                                                    }

                                                                                                                                                    type DescribeQueriesOutput

                                                                                                                                                    type DescribeQueriesOutput struct {
                                                                                                                                                    
                                                                                                                                                    	// The token for the next set of items to return. The token expires after 24 hours.
                                                                                                                                                    	NextToken *string
                                                                                                                                                    
                                                                                                                                                    	// The list of queries that match the request.
                                                                                                                                                    	Queries []types.QueryInfo
                                                                                                                                                    
                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                    }

                                                                                                                                                    type DescribeQueryDefinitionsInput

                                                                                                                                                    type DescribeQueryDefinitionsInput struct {
                                                                                                                                                    
                                                                                                                                                    	// Limits the number of returned query definitions to the specified number.
                                                                                                                                                    	MaxResults *int32
                                                                                                                                                    
                                                                                                                                                    	// The token for the next set of items to return. The token expires after 24 hours.
                                                                                                                                                    	NextToken *string
                                                                                                                                                    
                                                                                                                                                    	// Use this parameter to filter your results to only the query definitions that
                                                                                                                                                    	// have names that start with the prefix you specify.
                                                                                                                                                    	QueryDefinitionNamePrefix *string
                                                                                                                                                    }

                                                                                                                                                    type DescribeQueryDefinitionsOutput

                                                                                                                                                    type DescribeQueryDefinitionsOutput struct {
                                                                                                                                                    
                                                                                                                                                    	// The token for the next set of items to return. The token expires after 24 hours.
                                                                                                                                                    	NextToken *string
                                                                                                                                                    
                                                                                                                                                    	// The list of query definitions that match your request.
                                                                                                                                                    	QueryDefinitions []types.QueryDefinition
                                                                                                                                                    
                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                    }

                                                                                                                                                    type DescribeResourcePoliciesInput

                                                                                                                                                    type DescribeResourcePoliciesInput struct {
                                                                                                                                                    
                                                                                                                                                    	// The maximum number of resource policies to be displayed with one call of this
                                                                                                                                                    	// API.
                                                                                                                                                    	Limit *int32
                                                                                                                                                    
                                                                                                                                                    	// The token for the next set of items to return. The token expires after 24 hours.
                                                                                                                                                    	NextToken *string
                                                                                                                                                    }

                                                                                                                                                    type DescribeResourcePoliciesOutput

                                                                                                                                                    type DescribeResourcePoliciesOutput struct {
                                                                                                                                                    
                                                                                                                                                    	// The token for the next set of items to return. The token expires after 24 hours.
                                                                                                                                                    	NextToken *string
                                                                                                                                                    
                                                                                                                                                    	// The resource policies that exist in this account.
                                                                                                                                                    	ResourcePolicies []types.ResourcePolicy
                                                                                                                                                    
                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                    }

                                                                                                                                                    type DescribeSubscriptionFiltersAPIClient

                                                                                                                                                    type DescribeSubscriptionFiltersAPIClient interface {
                                                                                                                                                    	DescribeSubscriptionFilters(context.Context, *DescribeSubscriptionFiltersInput, ...func(*Options)) (*DescribeSubscriptionFiltersOutput, error)
                                                                                                                                                    }

                                                                                                                                                      DescribeSubscriptionFiltersAPIClient is a client that implements the DescribeSubscriptionFilters operation.

                                                                                                                                                      type DescribeSubscriptionFiltersInput

                                                                                                                                                      type DescribeSubscriptionFiltersInput struct {
                                                                                                                                                      
                                                                                                                                                      	// The name of the log group.
                                                                                                                                                      	//
                                                                                                                                                      	// This member is required.
                                                                                                                                                      	LogGroupName *string
                                                                                                                                                      
                                                                                                                                                      	// The prefix to match. If you don't specify a value, no prefix filter is applied.
                                                                                                                                                      	FilterNamePrefix *string
                                                                                                                                                      
                                                                                                                                                      	// The maximum number of items returned. If you don't specify a value, the default
                                                                                                                                                      	// is up to 50 items.
                                                                                                                                                      	Limit *int32
                                                                                                                                                      
                                                                                                                                                      	// The token for the next set of items to return. (You received this token from a
                                                                                                                                                      	// previous call.)
                                                                                                                                                      	NextToken *string
                                                                                                                                                      }

                                                                                                                                                      type DescribeSubscriptionFiltersOutput

                                                                                                                                                      type DescribeSubscriptionFiltersOutput struct {
                                                                                                                                                      
                                                                                                                                                      	// The token for the next set of items to return. The token expires after 24 hours.
                                                                                                                                                      	NextToken *string
                                                                                                                                                      
                                                                                                                                                      	// The subscription filters.
                                                                                                                                                      	SubscriptionFilters []types.SubscriptionFilter
                                                                                                                                                      
                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                      }

                                                                                                                                                      type DescribeSubscriptionFiltersPaginator

                                                                                                                                                      type DescribeSubscriptionFiltersPaginator struct {
                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                      }

                                                                                                                                                        DescribeSubscriptionFiltersPaginator is a paginator for DescribeSubscriptionFilters

                                                                                                                                                        func NewDescribeSubscriptionFiltersPaginator

                                                                                                                                                          NewDescribeSubscriptionFiltersPaginator returns a new DescribeSubscriptionFiltersPaginator

                                                                                                                                                          func (*DescribeSubscriptionFiltersPaginator) HasMorePages

                                                                                                                                                          func (p *DescribeSubscriptionFiltersPaginator) HasMorePages() bool

                                                                                                                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                            func (*DescribeSubscriptionFiltersPaginator) NextPage

                                                                                                                                                              NextPage retrieves the next DescribeSubscriptionFilters page.

                                                                                                                                                              type DescribeSubscriptionFiltersPaginatorOptions

                                                                                                                                                              type DescribeSubscriptionFiltersPaginatorOptions struct {
                                                                                                                                                              	// The maximum number of items returned. If you don't specify a value, the default
                                                                                                                                                              	// is up to 50 items.
                                                                                                                                                              	Limit int32
                                                                                                                                                              
                                                                                                                                                              	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                              	// that matches the most recent token provided to the service.
                                                                                                                                                              	StopOnDuplicateToken bool
                                                                                                                                                              }

                                                                                                                                                                DescribeSubscriptionFiltersPaginatorOptions is the paginator options for DescribeSubscriptionFilters

                                                                                                                                                                type DisassociateKmsKeyInput

                                                                                                                                                                type DisassociateKmsKeyInput struct {
                                                                                                                                                                
                                                                                                                                                                	// The name of the log group.
                                                                                                                                                                	//
                                                                                                                                                                	// This member is required.
                                                                                                                                                                	LogGroupName *string
                                                                                                                                                                }

                                                                                                                                                                type DisassociateKmsKeyOutput

                                                                                                                                                                type DisassociateKmsKeyOutput struct {
                                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                                }

                                                                                                                                                                type EndpointResolver

                                                                                                                                                                type EndpointResolver interface {
                                                                                                                                                                	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
                                                                                                                                                                }

                                                                                                                                                                  EndpointResolver interface for resolving service endpoints.

                                                                                                                                                                  func EndpointResolverFromURL

                                                                                                                                                                  func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

                                                                                                                                                                    EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

                                                                                                                                                                    type EndpointResolverFunc

                                                                                                                                                                    type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

                                                                                                                                                                      EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

                                                                                                                                                                      func (EndpointResolverFunc) ResolveEndpoint

                                                                                                                                                                      func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

                                                                                                                                                                      type EndpointResolverOptions

                                                                                                                                                                      type EndpointResolverOptions = internalendpoints.Options

                                                                                                                                                                        EndpointResolverOptions is the service endpoint resolver options

                                                                                                                                                                        type FilterLogEventsAPIClient

                                                                                                                                                                        type FilterLogEventsAPIClient interface {
                                                                                                                                                                        	FilterLogEvents(context.Context, *FilterLogEventsInput, ...func(*Options)) (*FilterLogEventsOutput, error)
                                                                                                                                                                        }

                                                                                                                                                                          FilterLogEventsAPIClient is a client that implements the FilterLogEvents operation.

                                                                                                                                                                          type FilterLogEventsInput

                                                                                                                                                                          type FilterLogEventsInput struct {
                                                                                                                                                                          
                                                                                                                                                                          	// The name of the log group to search.
                                                                                                                                                                          	//
                                                                                                                                                                          	// This member is required.
                                                                                                                                                                          	LogGroupName *string
                                                                                                                                                                          
                                                                                                                                                                          	// The end of the time range, expressed as the number of milliseconds after Jan 1,
                                                                                                                                                                          	// 1970 00:00:00 UTC. Events with a timestamp later than this time are not
                                                                                                                                                                          	// returned.
                                                                                                                                                                          	EndTime *int64
                                                                                                                                                                          
                                                                                                                                                                          	// The filter pattern to use. For more information, see Filter and Pattern Syntax
                                                                                                                                                                          	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html).
                                                                                                                                                                          	// If not provided, all the events are matched.
                                                                                                                                                                          	FilterPattern *string
                                                                                                                                                                          
                                                                                                                                                                          	// If the value is true, the operation makes a best effort to provide responses
                                                                                                                                                                          	// that contain events from multiple log streams within the log group, interleaved
                                                                                                                                                                          	// in a single response. If the value is false, all the matched log events in the
                                                                                                                                                                          	// first log stream are searched first, then those in the next log stream, and so
                                                                                                                                                                          	// on. The default is false. Important: Starting on June 17, 2019, this parameter
                                                                                                                                                                          	// is ignored and the value is assumed to be true. The response from this operation
                                                                                                                                                                          	// always interleaves events from multiple log streams within a log group.
                                                                                                                                                                          	//
                                                                                                                                                                          	// Deprecated: Starting on June 17, 2019, this parameter will be ignored and the
                                                                                                                                                                          	// value will be assumed to be true. The response from this operation will always
                                                                                                                                                                          	// interleave events from multiple log streams within a log group.
                                                                                                                                                                          	Interleaved *bool
                                                                                                                                                                          
                                                                                                                                                                          	// The maximum number of events to return. The default is 10,000 events.
                                                                                                                                                                          	Limit *int32
                                                                                                                                                                          
                                                                                                                                                                          	// Filters the results to include only events from log streams that have names
                                                                                                                                                                          	// starting with this prefix. If you specify a value for both logStreamNamePrefix
                                                                                                                                                                          	// and logStreamNames, but the value for logStreamNamePrefix does not match any log
                                                                                                                                                                          	// stream names specified in logStreamNames, the action returns an
                                                                                                                                                                          	// InvalidParameterException error.
                                                                                                                                                                          	LogStreamNamePrefix *string
                                                                                                                                                                          
                                                                                                                                                                          	// Filters the results to only logs from the log streams in this list. If you
                                                                                                                                                                          	// specify a value for both logStreamNamePrefix and logStreamNames, the action
                                                                                                                                                                          	// returns an InvalidParameterException error.
                                                                                                                                                                          	LogStreamNames []string
                                                                                                                                                                          
                                                                                                                                                                          	// The token for the next set of events to return. (You received this token from a
                                                                                                                                                                          	// previous call.)
                                                                                                                                                                          	NextToken *string
                                                                                                                                                                          
                                                                                                                                                                          	// The start of the time range, expressed as the number of milliseconds after Jan
                                                                                                                                                                          	// 1, 1970 00:00:00 UTC. Events with a timestamp before this time are not returned.
                                                                                                                                                                          	// If you omit startTime and endTime the most recent log events are retrieved, to
                                                                                                                                                                          	// up 1 MB or 10,000 log events.
                                                                                                                                                                          	StartTime *int64
                                                                                                                                                                          }

                                                                                                                                                                          type FilterLogEventsOutput

                                                                                                                                                                          type FilterLogEventsOutput struct {
                                                                                                                                                                          
                                                                                                                                                                          	// The matched events.
                                                                                                                                                                          	Events []types.FilteredLogEvent
                                                                                                                                                                          
                                                                                                                                                                          	// The token to use when requesting the next set of items. The token expires after
                                                                                                                                                                          	// 24 hours.
                                                                                                                                                                          	NextToken *string
                                                                                                                                                                          
                                                                                                                                                                          	// IMPORTANT Starting on May 15, 2020, this parameter will be deprecated. This
                                                                                                                                                                          	// parameter will be an empty list after the deprecation occurs. Indicates which
                                                                                                                                                                          	// log streams have been searched and whether each has been searched completely.
                                                                                                                                                                          	SearchedLogStreams []types.SearchedLogStream
                                                                                                                                                                          
                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                          }

                                                                                                                                                                          type FilterLogEventsPaginator

                                                                                                                                                                          type FilterLogEventsPaginator struct {
                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                          }

                                                                                                                                                                            FilterLogEventsPaginator is a paginator for FilterLogEvents

                                                                                                                                                                            func NewFilterLogEventsPaginator

                                                                                                                                                                            func NewFilterLogEventsPaginator(client FilterLogEventsAPIClient, params *FilterLogEventsInput, optFns ...func(*FilterLogEventsPaginatorOptions)) *FilterLogEventsPaginator

                                                                                                                                                                              NewFilterLogEventsPaginator returns a new FilterLogEventsPaginator

                                                                                                                                                                              func (*FilterLogEventsPaginator) HasMorePages

                                                                                                                                                                              func (p *FilterLogEventsPaginator) HasMorePages() bool

                                                                                                                                                                                HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                func (*FilterLogEventsPaginator) NextPage

                                                                                                                                                                                func (p *FilterLogEventsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*FilterLogEventsOutput, error)

                                                                                                                                                                                  NextPage retrieves the next FilterLogEvents page.

                                                                                                                                                                                  type FilterLogEventsPaginatorOptions

                                                                                                                                                                                  type FilterLogEventsPaginatorOptions struct {
                                                                                                                                                                                  	// The maximum number of events to return. The default is 10,000 events.
                                                                                                                                                                                  	Limit int32
                                                                                                                                                                                  
                                                                                                                                                                                  	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                  	// that matches the most recent token provided to the service.
                                                                                                                                                                                  	StopOnDuplicateToken bool
                                                                                                                                                                                  }

                                                                                                                                                                                    FilterLogEventsPaginatorOptions is the paginator options for FilterLogEvents

                                                                                                                                                                                    type GetLogEventsAPIClient

                                                                                                                                                                                    type GetLogEventsAPIClient interface {
                                                                                                                                                                                    	GetLogEvents(context.Context, *GetLogEventsInput, ...func(*Options)) (*GetLogEventsOutput, error)
                                                                                                                                                                                    }

                                                                                                                                                                                      GetLogEventsAPIClient is a client that implements the GetLogEvents operation.

                                                                                                                                                                                      type GetLogEventsInput

                                                                                                                                                                                      type GetLogEventsInput struct {
                                                                                                                                                                                      
                                                                                                                                                                                      	// The name of the log group.
                                                                                                                                                                                      	//
                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                      	LogGroupName *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// The name of the log stream.
                                                                                                                                                                                      	//
                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                      	LogStreamName *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// The end of the time range, expressed as the number of milliseconds after Jan 1,
                                                                                                                                                                                      	// 1970 00:00:00 UTC. Events with a timestamp equal to or later than this time are
                                                                                                                                                                                      	// not included.
                                                                                                                                                                                      	EndTime *int64
                                                                                                                                                                                      
                                                                                                                                                                                      	// The maximum number of log events returned. If you don't specify a value, the
                                                                                                                                                                                      	// maximum is as many log events as can fit in a response size of 1 MB, up to
                                                                                                                                                                                      	// 10,000 log events.
                                                                                                                                                                                      	Limit *int32
                                                                                                                                                                                      
                                                                                                                                                                                      	// The token for the next set of items to return. (You received this token from a
                                                                                                                                                                                      	// previous call.) Using this token works only when you specify true for
                                                                                                                                                                                      	// startFromHead.
                                                                                                                                                                                      	NextToken *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// If the value is true, the earliest log events are returned first. If the value
                                                                                                                                                                                      	// is false, the latest log events are returned first. The default value is false.
                                                                                                                                                                                      	// If you are using nextToken in this operation, you must specify true for
                                                                                                                                                                                      	// startFromHead.
                                                                                                                                                                                      	StartFromHead *bool
                                                                                                                                                                                      
                                                                                                                                                                                      	// The start of the time range, expressed as the number of milliseconds after Jan
                                                                                                                                                                                      	// 1, 1970 00:00:00 UTC. Events with a timestamp equal to this time or later than
                                                                                                                                                                                      	// this time are included. Events with a timestamp earlier than this time are not
                                                                                                                                                                                      	// included.
                                                                                                                                                                                      	StartTime *int64
                                                                                                                                                                                      }

                                                                                                                                                                                      type GetLogEventsOutput

                                                                                                                                                                                      type GetLogEventsOutput struct {
                                                                                                                                                                                      
                                                                                                                                                                                      	// The events.
                                                                                                                                                                                      	Events []types.OutputLogEvent
                                                                                                                                                                                      
                                                                                                                                                                                      	// The token for the next set of items in the backward direction. The token expires
                                                                                                                                                                                      	// after 24 hours. This token is never null. If you have reached the end of the
                                                                                                                                                                                      	// stream, it returns the same token you passed in.
                                                                                                                                                                                      	NextBackwardToken *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// The token for the next set of items in the forward direction. The token expires
                                                                                                                                                                                      	// after 24 hours. If you have reached the end of the stream, it returns the same
                                                                                                                                                                                      	// token you passed in.
                                                                                                                                                                                      	NextForwardToken *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                      }

                                                                                                                                                                                      type GetLogEventsPaginator

                                                                                                                                                                                      type GetLogEventsPaginator struct {
                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                      }

                                                                                                                                                                                        GetLogEventsPaginator is a paginator for GetLogEvents

                                                                                                                                                                                        func NewGetLogEventsPaginator

                                                                                                                                                                                        func NewGetLogEventsPaginator(client GetLogEventsAPIClient, params *GetLogEventsInput, optFns ...func(*GetLogEventsPaginatorOptions)) *GetLogEventsPaginator

                                                                                                                                                                                          NewGetLogEventsPaginator returns a new GetLogEventsPaginator

                                                                                                                                                                                          func (*GetLogEventsPaginator) HasMorePages

                                                                                                                                                                                          func (p *GetLogEventsPaginator) HasMorePages() bool

                                                                                                                                                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                            func (*GetLogEventsPaginator) NextPage

                                                                                                                                                                                            func (p *GetLogEventsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetLogEventsOutput, error)

                                                                                                                                                                                              NextPage retrieves the next GetLogEvents page.

                                                                                                                                                                                              type GetLogEventsPaginatorOptions

                                                                                                                                                                                              type GetLogEventsPaginatorOptions struct {
                                                                                                                                                                                              	// The maximum number of log events returned. If you don't specify a value, the
                                                                                                                                                                                              	// maximum is as many log events as can fit in a response size of 1 MB, up to
                                                                                                                                                                                              	// 10,000 log events.
                                                                                                                                                                                              	Limit int32
                                                                                                                                                                                              
                                                                                                                                                                                              	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                              	// that matches the most recent token provided to the service.
                                                                                                                                                                                              	StopOnDuplicateToken bool
                                                                                                                                                                                              }

                                                                                                                                                                                                GetLogEventsPaginatorOptions is the paginator options for GetLogEvents

                                                                                                                                                                                                type GetLogGroupFieldsInput

                                                                                                                                                                                                type GetLogGroupFieldsInput struct {
                                                                                                                                                                                                
                                                                                                                                                                                                	// The name of the log group to search.
                                                                                                                                                                                                	//
                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                	LogGroupName *string
                                                                                                                                                                                                
                                                                                                                                                                                                	// The time to set as the center of the query. If you specify time, the 8 minutes
                                                                                                                                                                                                	// before and 8 minutes after this time are searched. If you omit time, the past 15
                                                                                                                                                                                                	// minutes are queried. The time value is specified as epoch time, the number of
                                                                                                                                                                                                	// seconds since January 1, 1970, 00:00:00 UTC.
                                                                                                                                                                                                	Time *int64
                                                                                                                                                                                                }

                                                                                                                                                                                                type GetLogGroupFieldsOutput

                                                                                                                                                                                                type GetLogGroupFieldsOutput struct {
                                                                                                                                                                                                
                                                                                                                                                                                                	// The array of fields found in the query. Each object in the array contains the
                                                                                                                                                                                                	// name of the field, along with the percentage of time it appeared in the log
                                                                                                                                                                                                	// events that were queried.
                                                                                                                                                                                                	LogGroupFields []types.LogGroupField
                                                                                                                                                                                                
                                                                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                                                                }

                                                                                                                                                                                                type GetLogRecordInput

                                                                                                                                                                                                type GetLogRecordInput struct {
                                                                                                                                                                                                
                                                                                                                                                                                                	// The pointer corresponding to the log event record you want to retrieve. You get
                                                                                                                                                                                                	// this from the response of a GetQueryResults operation. In that response, the
                                                                                                                                                                                                	// value of the @ptr field for a log event is the value to use as logRecordPointer
                                                                                                                                                                                                	// to retrieve that complete log event record.
                                                                                                                                                                                                	//
                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                	LogRecordPointer *string
                                                                                                                                                                                                }

                                                                                                                                                                                                type GetLogRecordOutput

                                                                                                                                                                                                type GetLogRecordOutput struct {
                                                                                                                                                                                                
                                                                                                                                                                                                	// The requested log event, as a JSON string.
                                                                                                                                                                                                	LogRecord map[string]string
                                                                                                                                                                                                
                                                                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                                                                }

                                                                                                                                                                                                type GetQueryResultsInput

                                                                                                                                                                                                type GetQueryResultsInput struct {
                                                                                                                                                                                                
                                                                                                                                                                                                	// The ID number of the query.
                                                                                                                                                                                                	//
                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                	QueryId *string
                                                                                                                                                                                                }

                                                                                                                                                                                                type GetQueryResultsOutput

                                                                                                                                                                                                type GetQueryResultsOutput struct {
                                                                                                                                                                                                
                                                                                                                                                                                                	// The log events that matched the query criteria during the most recent time it
                                                                                                                                                                                                	// ran. The results value is an array of arrays. Each log event is one object in
                                                                                                                                                                                                	// the top-level array. Each of these log event objects is an array of field/value
                                                                                                                                                                                                	// pairs.
                                                                                                                                                                                                	Results [][]types.ResultField
                                                                                                                                                                                                
                                                                                                                                                                                                	// Includes the number of log events scanned by the query, the number of log events
                                                                                                                                                                                                	// that matched the query criteria, and the total number of bytes in the log events
                                                                                                                                                                                                	// that were scanned. These values reflect the full raw results of the query.
                                                                                                                                                                                                	Statistics *types.QueryStatistics
                                                                                                                                                                                                
                                                                                                                                                                                                	// The status of the most recent running of the query. Possible values are
                                                                                                                                                                                                	// Cancelled, Complete, Failed, Running, Scheduled, Timeout, and Unknown. Queries
                                                                                                                                                                                                	// time out after 15 minutes of execution. To avoid having your queries time out,
                                                                                                                                                                                                	// reduce the time range being searched or partition your query into a number of
                                                                                                                                                                                                	// queries.
                                                                                                                                                                                                	Status types.QueryStatus
                                                                                                                                                                                                
                                                                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                                                                }

                                                                                                                                                                                                type HTTPClient

                                                                                                                                                                                                type HTTPClient interface {
                                                                                                                                                                                                	Do(*http.Request) (*http.Response, error)
                                                                                                                                                                                                }

                                                                                                                                                                                                type HTTPSignerV4

                                                                                                                                                                                                type HTTPSignerV4 interface {
                                                                                                                                                                                                	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
                                                                                                                                                                                                }

                                                                                                                                                                                                type ListTagsLogGroupInput

                                                                                                                                                                                                type ListTagsLogGroupInput struct {
                                                                                                                                                                                                
                                                                                                                                                                                                	// The name of the log group.
                                                                                                                                                                                                	//
                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                	LogGroupName *string
                                                                                                                                                                                                }

                                                                                                                                                                                                type ListTagsLogGroupOutput

                                                                                                                                                                                                type ListTagsLogGroupOutput struct {
                                                                                                                                                                                                
                                                                                                                                                                                                	// The tags for the log group.
                                                                                                                                                                                                	Tags map[string]string
                                                                                                                                                                                                
                                                                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                                                                }

                                                                                                                                                                                                type Options

                                                                                                                                                                                                type Options struct {
                                                                                                                                                                                                	// Set of options to modify how an operation is invoked. These apply to all
                                                                                                                                                                                                	// operations invoked for this client. Use functional options on operation call to
                                                                                                                                                                                                	// modify this list for per operation behavior.
                                                                                                                                                                                                	APIOptions []func(*middleware.Stack) error
                                                                                                                                                                                                
                                                                                                                                                                                                	// Configures the events that will be sent to the configured logger.
                                                                                                                                                                                                	ClientLogMode aws.ClientLogMode
                                                                                                                                                                                                
                                                                                                                                                                                                	// The credentials object to use when signing requests.
                                                                                                                                                                                                	Credentials aws.CredentialsProvider
                                                                                                                                                                                                
                                                                                                                                                                                                	// The endpoint options to be used when attempting to resolve an endpoint.
                                                                                                                                                                                                	EndpointOptions EndpointResolverOptions
                                                                                                                                                                                                
                                                                                                                                                                                                	// The service endpoint resolver.
                                                                                                                                                                                                	EndpointResolver EndpointResolver
                                                                                                                                                                                                
                                                                                                                                                                                                	// Signature Version 4 (SigV4) Signer
                                                                                                                                                                                                	HTTPSignerV4 HTTPSignerV4
                                                                                                                                                                                                
                                                                                                                                                                                                	// The logger writer interface to write logging messages to.
                                                                                                                                                                                                	Logger logging.Logger
                                                                                                                                                                                                
                                                                                                                                                                                                	// The region to send requests to. (Required)
                                                                                                                                                                                                	Region string
                                                                                                                                                                                                
                                                                                                                                                                                                	// Retryer guides how HTTP requests should be retried in case of recoverable
                                                                                                                                                                                                	// failures. When nil the API client will use a default retryer.
                                                                                                                                                                                                	Retryer aws.Retryer
                                                                                                                                                                                                
                                                                                                                                                                                                	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
                                                                                                                                                                                                	// implementation if nil.
                                                                                                                                                                                                	HTTPClient HTTPClient
                                                                                                                                                                                                }

                                                                                                                                                                                                func (Options) Copy

                                                                                                                                                                                                func (o Options) Copy() Options

                                                                                                                                                                                                  Copy creates a clone where the APIOptions list is deep copied.

                                                                                                                                                                                                  type PutDestinationInput

                                                                                                                                                                                                  type PutDestinationInput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// A name for the destination.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	DestinationName *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The ARN of an IAM role that grants CloudWatch Logs permissions to call the
                                                                                                                                                                                                  	// Amazon Kinesis PutRecord operation on the destination stream.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	RoleArn *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The ARN of an Amazon Kinesis stream to which to deliver matching log events.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	TargetArn *string
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type PutDestinationOutput

                                                                                                                                                                                                  type PutDestinationOutput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The destination.
                                                                                                                                                                                                  	Destination *types.Destination
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type PutDestinationPolicyInput

                                                                                                                                                                                                  type PutDestinationPolicyInput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// An IAM policy document that authorizes cross-account users to deliver their log
                                                                                                                                                                                                  	// events to the associated destination. This can be up to 5120 bytes.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	AccessPolicy *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// A name for an existing destination.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	DestinationName *string
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type PutDestinationPolicyOutput

                                                                                                                                                                                                  type PutDestinationPolicyOutput struct {
                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type PutLogEventsInput

                                                                                                                                                                                                  type PutLogEventsInput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The log events.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	LogEvents []types.InputLogEvent
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The name of the log group.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	LogGroupName *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The name of the log stream.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	LogStreamName *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The sequence token obtained from the response of the previous PutLogEvents call.
                                                                                                                                                                                                  	// An upload in a newly created log stream does not require a sequence token. You
                                                                                                                                                                                                  	// can also get the sequence token using DescribeLogStreams
                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeLogStreams.html).
                                                                                                                                                                                                  	// If you call PutLogEvents twice within a narrow time period using the same value
                                                                                                                                                                                                  	// for sequenceToken, both calls might be successful or one might be rejected.
                                                                                                                                                                                                  	SequenceToken *string
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type PutLogEventsOutput

                                                                                                                                                                                                  type PutLogEventsOutput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The next sequence token.
                                                                                                                                                                                                  	NextSequenceToken *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The rejected events.
                                                                                                                                                                                                  	RejectedLogEventsInfo *types.RejectedLogEventsInfo
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type PutMetricFilterInput

                                                                                                                                                                                                  type PutMetricFilterInput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// A name for the metric filter.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	FilterName *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// A filter pattern for extracting metric data out of ingested log events.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	FilterPattern *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The name of the log group.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	LogGroupName *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// A collection of information that defines how metric data gets emitted.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	MetricTransformations []types.MetricTransformation
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type PutMetricFilterOutput

                                                                                                                                                                                                  type PutMetricFilterOutput struct {
                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type PutQueryDefinitionInput

                                                                                                                                                                                                  type PutQueryDefinitionInput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// A name for the query definition. If you are saving a lot of query definitions,
                                                                                                                                                                                                  	// we recommend that you name them so that you can easily find the ones you want by
                                                                                                                                                                                                  	// using the first part of the name as a filter in the queryDefinitionNamePrefix
                                                                                                                                                                                                  	// parameter of DescribeQueryDefinitions
                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeQueryDefinitions.html).
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	Name *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The query string to use for this definition. For more information, see
                                                                                                                                                                                                  	// CloudWatch Logs Insights Query Syntax
                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html).
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	QueryString *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// Use this parameter to include specific log groups as part of your query
                                                                                                                                                                                                  	// definition. If you are updating a query definition and you omit this parameter,
                                                                                                                                                                                                  	// then the updated definition will contain no log groups.
                                                                                                                                                                                                  	LogGroupNames []string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// If you are updating a query definition, use this parameter to specify the ID of
                                                                                                                                                                                                  	// the query definition that you want to update. You can use
                                                                                                                                                                                                  	// DescribeQueryDefinitions
                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeQueryDefinitions.html)
                                                                                                                                                                                                  	// to retrieve the IDs of your saved query definitions. If you are creating a query
                                                                                                                                                                                                  	// definition, do not specify this parameter. CloudWatch generates a unique ID for
                                                                                                                                                                                                  	// the new query definition and include it in the response to this operation.
                                                                                                                                                                                                  	QueryDefinitionId *string
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type PutQueryDefinitionOutput

                                                                                                                                                                                                  type PutQueryDefinitionOutput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The ID of the query definition.
                                                                                                                                                                                                  	QueryDefinitionId *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type PutResourcePolicyInput

                                                                                                                                                                                                  type PutResourcePolicyInput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// Details of the new policy, including the identity of the principal that is
                                                                                                                                                                                                  	// enabled to put logs to this account. This is formatted as a JSON string. This
                                                                                                                                                                                                  	// parameter is required. The following example creates a resource policy enabling
                                                                                                                                                                                                  	// the Route 53 service to put DNS query logs in to the specified log group.
                                                                                                                                                                                                  	// Replace "logArn" with the ARN of your CloudWatch Logs resource, such as a log
                                                                                                                                                                                                  	// group or log stream. { "Version": "2012-10-17", "Statement": [ { "Sid":
                                                                                                                                                                                                  	// "Route53LogsToCloudWatchLogs", "Effect": "Allow", "Principal": { "Service": [
                                                                                                                                                                                                  	// "route53.amazonaws.com" ] }, "Action":"logs:PutLogEvents", "Resource": "logArn"
                                                                                                                                                                                                  	// } ] }
                                                                                                                                                                                                  	PolicyDocument *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// Name of the new policy. This parameter is required.
                                                                                                                                                                                                  	PolicyName *string
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type PutResourcePolicyOutput

                                                                                                                                                                                                  type PutResourcePolicyOutput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The new policy.
                                                                                                                                                                                                  	ResourcePolicy *types.ResourcePolicy
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type PutRetentionPolicyInput

                                                                                                                                                                                                  type PutRetentionPolicyInput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The name of the log group.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	LogGroupName *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The number of days to retain the log events in the specified log group. Possible
                                                                                                                                                                                                  	// values are: 1, 3, 5, 7, 14, 30, 60, 90, 120, 150, 180, 365, 400, 545, 731, 1827,
                                                                                                                                                                                                  	// and 3653. If you omit retentionInDays in a PutRetentionPolicy operation, the
                                                                                                                                                                                                  	// events in the log group are always retained and never expire.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	RetentionInDays *int32
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type PutRetentionPolicyOutput

                                                                                                                                                                                                  type PutRetentionPolicyOutput struct {
                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type PutSubscriptionFilterInput

                                                                                                                                                                                                  type PutSubscriptionFilterInput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The ARN of the destination to deliver matching log events to. Currently, the
                                                                                                                                                                                                  	// supported destinations are:
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// * An Amazon Kinesis stream belonging to the same
                                                                                                                                                                                                  	// account as the subscription filter, for same-account delivery.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// * A logical
                                                                                                                                                                                                  	// destination (specified using an ARN) belonging to a different account, for
                                                                                                                                                                                                  	// cross-account delivery.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// * An Amazon Kinesis Firehose delivery stream belonging
                                                                                                                                                                                                  	// to the same account as the subscription filter, for same-account delivery.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// * An
                                                                                                                                                                                                  	// AWS Lambda function belonging to the same account as the subscription filter,
                                                                                                                                                                                                  	// for same-account delivery.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	DestinationArn *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// A name for the subscription filter. If you are updating an existing filter, you
                                                                                                                                                                                                  	// must specify the correct name in filterName. Otherwise, the call fails because
                                                                                                                                                                                                  	// you cannot associate a second filter with a log group. To find the name of the
                                                                                                                                                                                                  	// filter currently associated with a log group, use DescribeSubscriptionFilters
                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeSubscriptionFilters.html).
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	FilterName *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// A filter pattern for subscribing to a filtered stream of log events.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	FilterPattern *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The name of the log group.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	LogGroupName *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The method used to distribute log data to the destination. By default, log data
                                                                                                                                                                                                  	// is grouped by log stream, but the grouping can be set to random for a more even
                                                                                                                                                                                                  	// distribution. This property is only applicable when the destination is an Amazon
                                                                                                                                                                                                  	// Kinesis stream.
                                                                                                                                                                                                  	Distribution types.Distribution
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The ARN of an IAM role that grants CloudWatch Logs permissions to deliver
                                                                                                                                                                                                  	// ingested log events to the destination stream. You don't need to provide the ARN
                                                                                                                                                                                                  	// when you are working with a logical destination for cross-account delivery.
                                                                                                                                                                                                  	RoleArn *string
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type PutSubscriptionFilterOutput

                                                                                                                                                                                                  type PutSubscriptionFilterOutput struct {
                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type ResolveEndpoint

                                                                                                                                                                                                  type ResolveEndpoint struct {
                                                                                                                                                                                                  	Resolver EndpointResolver
                                                                                                                                                                                                  	Options  EndpointResolverOptions
                                                                                                                                                                                                  }

                                                                                                                                                                                                  func (*ResolveEndpoint) HandleSerialize

                                                                                                                                                                                                  func (*ResolveEndpoint) ID

                                                                                                                                                                                                  func (*ResolveEndpoint) ID() string

                                                                                                                                                                                                  type StartQueryInput

                                                                                                                                                                                                  type StartQueryInput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The end of the time range to query. The range is inclusive, so the specified end
                                                                                                                                                                                                  	// time is included in the query. Specified as epoch time, the number of seconds
                                                                                                                                                                                                  	// since January 1, 1970, 00:00:00 UTC.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	EndTime *int64
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The query string to use. For more information, see CloudWatch Logs Insights
                                                                                                                                                                                                  	// Query Syntax
                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html).
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	QueryString *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The beginning of the time range to query. The range is inclusive, so the
                                                                                                                                                                                                  	// specified start time is included in the query. Specified as epoch time, the
                                                                                                                                                                                                  	// number of seconds since January 1, 1970, 00:00:00 UTC.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	StartTime *int64
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The maximum number of log events to return in the query. If the query string
                                                                                                                                                                                                  	// uses the fields command, only the specified fields and their values are
                                                                                                                                                                                                  	// returned. The default is 1000.
                                                                                                                                                                                                  	Limit *int32
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The log group on which to perform the query. A StartQuery operation must include
                                                                                                                                                                                                  	// a logGroupNames or a logGroupName parameter, but not both.
                                                                                                                                                                                                  	LogGroupName *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The list of log groups to be queried. You can include up to 20 log groups. A
                                                                                                                                                                                                  	// StartQuery operation must include a logGroupNames or a logGroupName parameter,
                                                                                                                                                                                                  	// but not both.
                                                                                                                                                                                                  	LogGroupNames []string
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type StartQueryOutput

                                                                                                                                                                                                  type StartQueryOutput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The unique ID of the query.
                                                                                                                                                                                                  	QueryId *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type StopQueryInput

                                                                                                                                                                                                  type StopQueryInput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The ID number of the query to stop. To find this ID number, use DescribeQueries.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	QueryId *string
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type StopQueryOutput

                                                                                                                                                                                                  type StopQueryOutput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// This is true if the query was stopped by the StopQuery operation.
                                                                                                                                                                                                  	Success bool
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type TagLogGroupInput

                                                                                                                                                                                                  type TagLogGroupInput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The name of the log group.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	LogGroupName *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The key-value pairs to use for the tags.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	Tags map[string]string
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type TagLogGroupOutput

                                                                                                                                                                                                  type TagLogGroupOutput struct {
                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type TestMetricFilterInput

                                                                                                                                                                                                  type TestMetricFilterInput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// A symbolic description of how CloudWatch Logs should interpret the data in each
                                                                                                                                                                                                  	// log event. For example, a log event can contain timestamps, IP addresses,
                                                                                                                                                                                                  	// strings, and so on. You use the filter pattern to specify what to look for in
                                                                                                                                                                                                  	// the log event message.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	FilterPattern *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The log event messages to test.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	LogEventMessages []string
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type TestMetricFilterOutput

                                                                                                                                                                                                  type TestMetricFilterOutput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The matched events.
                                                                                                                                                                                                  	Matches []types.MetricFilterMatchRecord
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type UntagLogGroupInput

                                                                                                                                                                                                  type UntagLogGroupInput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The name of the log group.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	LogGroupName *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The tag keys. The corresponding tags are removed from the log group.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	Tags []string
                                                                                                                                                                                                  }

                                                                                                                                                                                                  type UntagLogGroupOutput

                                                                                                                                                                                                  type UntagLogGroupOutput struct {
                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                  }

                                                                                                                                                                                                  Directories

                                                                                                                                                                                                  Path Synopsis
                                                                                                                                                                                                  internal