com.amazonaws.services.logs.AWSLogsAsync Maven / Gradle / Ivy
Show all versions of aws-java-sdk-osgi Show documentation
/*
* Copyright 2011-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not
* use this file except in compliance with the License. A copy of the License is
* located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on
* an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package com.amazonaws.services.logs;
import com.amazonaws.services.logs.model.*;
/**
* Interface for accessing Amazon CloudWatch Logs asynchronously. Each
* asynchronous method will return a Java Future object representing the
* asynchronous operation; overloads which accept an {@code AsyncHandler} can be
* used to receive notification when an asynchronous operation completes.
*
* Amazon CloudWatch Logs API Reference
*
* You can use Amazon CloudWatch Logs to monitor, store, and access your log
* files from Amazon Elastic Compute Cloud (Amazon EC2) instances, Amazon
* CloudTrail, or other sources. You can then retrieve the associated log data
* from CloudWatch Logs using the Amazon CloudWatch console, the CloudWatch Logs
* commands in the AWS CLI, the CloudWatch Logs API, or the CloudWatch Logs SDK.
*
*
* You can use CloudWatch Logs to:
*
*
* -
*
* Monitor Logs from Amazon 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 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 Amazon CloudWatch metric that you specify.
*
*
* -
*
* Monitor Amazon CloudTrail Logged Events: You can create alarms in
* Amazon CloudWatch and receive notifications of particular API activity as
* captured by CloudTrail and 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.
*
*
*
*/
public interface AWSLogsAsync extends AWSLogs {
/**
*
* Cancels an export task if it is in PENDING or
* RUNNING state.
*
*
* @param cancelExportTaskRequest
* @return A Java Future containing the result of the CancelExportTask
* operation returned by the service.
* @sample AWSLogsAsync.CancelExportTask
*/
java.util.concurrent.Future cancelExportTaskAsync(
CancelExportTaskRequest cancelExportTaskRequest);
/**
*
* Cancels an export task if it is in PENDING or
* RUNNING state.
*
*
* @param cancelExportTaskRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the CancelExportTask
* operation returned by the service.
* @sample AWSLogsAsyncHandler.CancelExportTask
*/
java.util.concurrent.Future cancelExportTaskAsync(
CancelExportTaskRequest cancelExportTaskRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Creates an ExportTask which allows you to efficiently export
* data from a Log Group to your Amazon S3 bucket.
*
*
* This is an asynchronous call. If all the required information is
* provided, this API will initiate an export task and respond with the task
* Id. Once started, DescribeExportTasks can be used to get the
* status of an export task. You can only have one active (
* RUNNING or PENDING) export task at a time, per
* account.
*
*
* You can export logs from multiple log groups or multiple time ranges to
* the same Amazon S3 bucket. To separate out log data for each export task,
* you can specify a prefix that will be used as the Amazon S3 key prefix
* for all exported objects.
*
*
* @param createExportTaskRequest
* @return A Java Future containing the result of the CreateExportTask
* operation returned by the service.
* @sample AWSLogsAsync.CreateExportTask
*/
java.util.concurrent.Future createExportTaskAsync(
CreateExportTaskRequest createExportTaskRequest);
/**
*
* Creates an ExportTask which allows you to efficiently export
* data from a Log Group to your Amazon S3 bucket.
*
*
* This is an asynchronous call. If all the required information is
* provided, this API will initiate an export task and respond with the task
* Id. Once started, DescribeExportTasks can be used to get the
* status of an export task. You can only have one active (
* RUNNING or PENDING) export task at a time, per
* account.
*
*
* You can export logs from multiple log groups or multiple time ranges to
* the same Amazon S3 bucket. To separate out log data for each export task,
* you can specify a prefix that will be used as the Amazon S3 key prefix
* for all exported objects.
*
*
* @param createExportTaskRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the CreateExportTask
* operation returned by the service.
* @sample AWSLogsAsyncHandler.CreateExportTask
*/
java.util.concurrent.Future createExportTaskAsync(
CreateExportTaskRequest createExportTaskRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Creates a new log group with the specified name. The name of the log
* group must be unique within a region for an AWS account. You can create
* up to 500 log groups per account.
*
*
* You must use the following guidelines when naming a log group:
*
* - Log group names can be between 1 and 512 characters long.
* - Allowed characters are a-z, A-Z, 0-9, '_' (underscore), '-' (hyphen),
* '/' (forward slash), and '.' (period).
*
*
*
* @param createLogGroupRequest
* @return A Java Future containing the result of the CreateLogGroup
* operation returned by the service.
* @sample AWSLogsAsync.CreateLogGroup
*/
java.util.concurrent.Future createLogGroupAsync(
CreateLogGroupRequest createLogGroupRequest);
/**
*
* Creates a new log group with the specified name. The name of the log
* group must be unique within a region for an AWS account. You can create
* up to 500 log groups per account.
*
*
* You must use the following guidelines when naming a log group:
*
* - Log group names can be between 1 and 512 characters long.
* - Allowed characters are a-z, A-Z, 0-9, '_' (underscore), '-' (hyphen),
* '/' (forward slash), and '.' (period).
*
*
*
* @param createLogGroupRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the CreateLogGroup
* operation returned by the service.
* @sample AWSLogsAsyncHandler.CreateLogGroup
*/
java.util.concurrent.Future createLogGroupAsync(
CreateLogGroupRequest createLogGroupRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Creates a new log stream in the specified log group. The name of the log
* stream must be unique within the log group. There is no limit on the
* number of log streams that can exist in a log group.
*
*
* You must use the following guidelines when naming a log stream:
*
* - Log stream names can be between 1 and 512 characters long.
* - The ':' colon character is not allowed.
*
*
*
* @param createLogStreamRequest
* @return A Java Future containing the result of the CreateLogStream
* operation returned by the service.
* @sample AWSLogsAsync.CreateLogStream
*/
java.util.concurrent.Future createLogStreamAsync(
CreateLogStreamRequest createLogStreamRequest);
/**
*
* Creates a new log stream in the specified log group. The name of the log
* stream must be unique within the log group. There is no limit on the
* number of log streams that can exist in a log group.
*
*
* You must use the following guidelines when naming a log stream:
*
* - Log stream names can be between 1 and 512 characters long.
* - The ':' colon character is not allowed.
*
*
*
* @param createLogStreamRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the CreateLogStream
* operation returned by the service.
* @sample AWSLogsAsyncHandler.CreateLogStream
*/
java.util.concurrent.Future createLogStreamAsync(
CreateLogStreamRequest createLogStreamRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes the destination with the specified name and eventually disables
* all the subscription filters that publish to it. This will not delete the
* physical resource encapsulated by the destination.
*
*
* @param deleteDestinationRequest
* @return A Java Future containing the result of the DeleteDestination
* operation returned by the service.
* @sample AWSLogsAsync.DeleteDestination
*/
java.util.concurrent.Future deleteDestinationAsync(
DeleteDestinationRequest deleteDestinationRequest);
/**
*
* Deletes the destination with the specified name and eventually disables
* all the subscription filters that publish to it. This will not delete the
* physical resource encapsulated by the destination.
*
*
* @param deleteDestinationRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteDestination
* operation returned by the service.
* @sample AWSLogsAsyncHandler.DeleteDestination
*/
java.util.concurrent.Future deleteDestinationAsync(
DeleteDestinationRequest deleteDestinationRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes the log group with the specified name and permanently deletes all
* the archived log events associated with it.
*
*
* @param deleteLogGroupRequest
* @return A Java Future containing the result of the DeleteLogGroup
* operation returned by the service.
* @sample AWSLogsAsync.DeleteLogGroup
*/
java.util.concurrent.Future deleteLogGroupAsync(
DeleteLogGroupRequest deleteLogGroupRequest);
/**
*
* Deletes the log group with the specified name and permanently deletes all
* the archived log events associated with it.
*
*
* @param deleteLogGroupRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteLogGroup
* operation returned by the service.
* @sample AWSLogsAsyncHandler.DeleteLogGroup
*/
java.util.concurrent.Future deleteLogGroupAsync(
DeleteLogGroupRequest deleteLogGroupRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes a log stream and permanently deletes all the archived log events
* associated with it.
*
*
* @param deleteLogStreamRequest
* @return A Java Future containing the result of the DeleteLogStream
* operation returned by the service.
* @sample AWSLogsAsync.DeleteLogStream
*/
java.util.concurrent.Future deleteLogStreamAsync(
DeleteLogStreamRequest deleteLogStreamRequest);
/**
*
* Deletes a log stream and permanently deletes all the archived log events
* associated with it.
*
*
* @param deleteLogStreamRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteLogStream
* operation returned by the service.
* @sample AWSLogsAsyncHandler.DeleteLogStream
*/
java.util.concurrent.Future deleteLogStreamAsync(
DeleteLogStreamRequest deleteLogStreamRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes a metric filter associated with the specified log group.
*
*
* @param deleteMetricFilterRequest
* @return A Java Future containing the result of the DeleteMetricFilter
* operation returned by the service.
* @sample AWSLogsAsync.DeleteMetricFilter
*/
java.util.concurrent.Future deleteMetricFilterAsync(
DeleteMetricFilterRequest deleteMetricFilterRequest);
/**
*
* Deletes a metric filter associated with the specified log group.
*
*
* @param deleteMetricFilterRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteMetricFilter
* operation returned by the service.
* @sample AWSLogsAsyncHandler.DeleteMetricFilter
*/
java.util.concurrent.Future deleteMetricFilterAsync(
DeleteMetricFilterRequest deleteMetricFilterRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes the retention policy of the specified log group. Log events would
* not expire if they belong to log groups without a retention policy.
*
*
* @param deleteRetentionPolicyRequest
* @return A Java Future containing the result of the DeleteRetentionPolicy
* operation returned by the service.
* @sample AWSLogsAsync.DeleteRetentionPolicy
*/
java.util.concurrent.Future deleteRetentionPolicyAsync(
DeleteRetentionPolicyRequest deleteRetentionPolicyRequest);
/**
*
* Deletes the retention policy of the specified log group. Log events would
* not expire if they belong to log groups without a retention policy.
*
*
* @param deleteRetentionPolicyRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteRetentionPolicy
* operation returned by the service.
* @sample AWSLogsAsyncHandler.DeleteRetentionPolicy
*/
java.util.concurrent.Future deleteRetentionPolicyAsync(
DeleteRetentionPolicyRequest deleteRetentionPolicyRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes a subscription filter associated with the specified log group.
*
*
* @param deleteSubscriptionFilterRequest
* @return A Java Future containing the result of the
* DeleteSubscriptionFilter operation returned by the service.
* @sample AWSLogsAsync.DeleteSubscriptionFilter
*/
java.util.concurrent.Future deleteSubscriptionFilterAsync(
DeleteSubscriptionFilterRequest deleteSubscriptionFilterRequest);
/**
*
* Deletes a subscription filter associated with the specified log group.
*
*
* @param deleteSubscriptionFilterRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the
* DeleteSubscriptionFilter operation returned by the service.
* @sample AWSLogsAsyncHandler.DeleteSubscriptionFilter
*/
java.util.concurrent.Future deleteSubscriptionFilterAsync(
DeleteSubscriptionFilterRequest deleteSubscriptionFilterRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns all the destinations that are associated with the AWS account
* making the request. The list returned in the response is ASCII-sorted by
* destination name.
*
*
* By default, this operation returns up to 50 destinations. If there are
* more destinations to list, the response would contain a
* nextToken value in the response body. You can
* also limit the number of destinations returned in the response by
* specifying the limit parameter in the request.
*
*
* @param describeDestinationsRequest
* @return A Java Future containing the result of the DescribeDestinations
* operation returned by the service.
* @sample AWSLogsAsync.DescribeDestinations
*/
java.util.concurrent.Future describeDestinationsAsync(
DescribeDestinationsRequest describeDestinationsRequest);
/**
*
* Returns all the destinations that are associated with the AWS account
* making the request. The list returned in the response is ASCII-sorted by
* destination name.
*
*
* By default, this operation returns up to 50 destinations. If there are
* more destinations to list, the response would contain a
* nextToken value in the response body. You can
* also limit the number of destinations returned in the response by
* specifying the limit parameter in the request.
*
*
* @param describeDestinationsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DescribeDestinations
* operation returned by the service.
* @sample AWSLogsAsyncHandler.DescribeDestinations
*/
java.util.concurrent.Future describeDestinationsAsync(
DescribeDestinationsRequest describeDestinationsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the DescribeDestinations operation.
*
* @see #describeDestinationsAsync(DescribeDestinationsRequest)
*/
java.util.concurrent.Future describeDestinationsAsync();
/**
* Simplified method form for invoking the DescribeDestinations operation
* with an AsyncHandler.
*
* @see #describeDestinationsAsync(DescribeDestinationsRequest,
* com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future describeDestinationsAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns all the export tasks that are associated with the AWS account
* making the request. The export tasks can be filtered based on
* TaskId or TaskStatus.
*
*
* By default, this operation returns up to 50 export tasks that satisfy the
* specified filters. If there are more export tasks to list, the response
* would contain a nextToken value in the response
* body. You can also limit the number of export tasks returned in the
* response by specifying the limit parameter in
* the request.
*
*
* @param describeExportTasksRequest
* @return A Java Future containing the result of the DescribeExportTasks
* operation returned by the service.
* @sample AWSLogsAsync.DescribeExportTasks
*/
java.util.concurrent.Future describeExportTasksAsync(
DescribeExportTasksRequest describeExportTasksRequest);
/**
*
* Returns all the export tasks that are associated with the AWS account
* making the request. The export tasks can be filtered based on
* TaskId or TaskStatus.
*
*
* By default, this operation returns up to 50 export tasks that satisfy the
* specified filters. If there are more export tasks to list, the response
* would contain a nextToken value in the response
* body. You can also limit the number of export tasks returned in the
* response by specifying the limit parameter in
* the request.
*
*
* @param describeExportTasksRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DescribeExportTasks
* operation returned by the service.
* @sample AWSLogsAsyncHandler.DescribeExportTasks
*/
java.util.concurrent.Future describeExportTasksAsync(
DescribeExportTasksRequest describeExportTasksRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns all the log groups that are associated with the AWS account
* making the request. The list returned in the response is ASCII-sorted by
* log group name.
*
*
* By default, this operation returns up to 50 log groups. If there are more
* log groups to list, the response would contain a
* nextToken value in the response body. You can
* also limit the number of log groups returned in the response by
* specifying the limit parameter in the request.
*
*
* @param describeLogGroupsRequest
* @return A Java Future containing the result of the DescribeLogGroups
* operation returned by the service.
* @sample AWSLogsAsync.DescribeLogGroups
*/
java.util.concurrent.Future describeLogGroupsAsync(
DescribeLogGroupsRequest describeLogGroupsRequest);
/**
*
* Returns all the log groups that are associated with the AWS account
* making the request. The list returned in the response is ASCII-sorted by
* log group name.
*
*
* By default, this operation returns up to 50 log groups. If there are more
* log groups to list, the response would contain a
* nextToken value in the response body. You can
* also limit the number of log groups returned in the response by
* specifying the limit parameter in the request.
*
*
* @param describeLogGroupsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DescribeLogGroups
* operation returned by the service.
* @sample AWSLogsAsyncHandler.DescribeLogGroups
*/
java.util.concurrent.Future describeLogGroupsAsync(
DescribeLogGroupsRequest describeLogGroupsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the DescribeLogGroups operation.
*
* @see #describeLogGroupsAsync(DescribeLogGroupsRequest)
*/
java.util.concurrent.Future describeLogGroupsAsync();
/**
* Simplified method form for invoking the DescribeLogGroups operation with
* an AsyncHandler.
*
* @see #describeLogGroupsAsync(DescribeLogGroupsRequest,
* com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future describeLogGroupsAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns all the log streams that are associated with the specified log
* group. The list returned in the response is ASCII-sorted by log stream
* name.
*
*
* By default, this operation returns up to 50 log streams. If there are
* more log streams to list, the response would contain a
* nextToken value in the response body. You can
* also limit the number of log streams returned in the response by
* specifying the limit parameter in the request.
* This operation has a limit of five transactions per second, after which
* transactions are throttled.
*
*
* @param describeLogStreamsRequest
* @return A Java Future containing the result of the DescribeLogStreams
* operation returned by the service.
* @sample AWSLogsAsync.DescribeLogStreams
*/
java.util.concurrent.Future describeLogStreamsAsync(
DescribeLogStreamsRequest describeLogStreamsRequest);
/**
*
* Returns all the log streams that are associated with the specified log
* group. The list returned in the response is ASCII-sorted by log stream
* name.
*
*
* By default, this operation returns up to 50 log streams. If there are
* more log streams to list, the response would contain a
* nextToken value in the response body. You can
* also limit the number of log streams returned in the response by
* specifying the limit parameter in the request.
* This operation has a limit of five transactions per second, after which
* transactions are throttled.
*
*
* @param describeLogStreamsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DescribeLogStreams
* operation returned by the service.
* @sample AWSLogsAsyncHandler.DescribeLogStreams
*/
java.util.concurrent.Future describeLogStreamsAsync(
DescribeLogStreamsRequest describeLogStreamsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns all the metrics filters associated with the specified log group.
* The list returned in the response is ASCII-sorted by filter name.
*
*
* By default, this operation returns up to 50 metric filters. If there are
* more metric filters to list, the response would contain a
* nextToken value in the response body. You can
* also limit the number of metric filters returned in the response by
* specifying the limit parameter in the request.
*
*
* @param describeMetricFiltersRequest
* @return A Java Future containing the result of the DescribeMetricFilters
* operation returned by the service.
* @sample AWSLogsAsync.DescribeMetricFilters
*/
java.util.concurrent.Future describeMetricFiltersAsync(
DescribeMetricFiltersRequest describeMetricFiltersRequest);
/**
*
* Returns all the metrics filters associated with the specified log group.
* The list returned in the response is ASCII-sorted by filter name.
*
*
* By default, this operation returns up to 50 metric filters. If there are
* more metric filters to list, the response would contain a
* nextToken value in the response body. You can
* also limit the number of metric filters returned in the response by
* specifying the limit parameter in the request.
*
*
* @param describeMetricFiltersRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DescribeMetricFilters
* operation returned by the service.
* @sample AWSLogsAsyncHandler.DescribeMetricFilters
*/
java.util.concurrent.Future describeMetricFiltersAsync(
DescribeMetricFiltersRequest describeMetricFiltersRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns all the subscription filters associated with the specified log
* group. The list returned in the response is ASCII-sorted by filter name.
*
*
* By default, this operation returns up to 50 subscription filters. If
* there are more subscription filters to list, the response would contain a
* nextToken value in the response body. You can
* also limit the number of subscription filters returned in the response by
* specifying the limit parameter in the request.
*
*
* @param describeSubscriptionFiltersRequest
* @return A Java Future containing the result of the
* DescribeSubscriptionFilters operation returned by the service.
* @sample AWSLogsAsync.DescribeSubscriptionFilters
*/
java.util.concurrent.Future describeSubscriptionFiltersAsync(
DescribeSubscriptionFiltersRequest describeSubscriptionFiltersRequest);
/**
*
* Returns all the subscription filters associated with the specified log
* group. The list returned in the response is ASCII-sorted by filter name.
*
*
* By default, this operation returns up to 50 subscription filters. If
* there are more subscription filters to list, the response would contain a
* nextToken value in the response body. You can
* also limit the number of subscription filters returned in the response by
* specifying the limit parameter in the request.
*
*
* @param describeSubscriptionFiltersRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the
* DescribeSubscriptionFilters operation returned by the service.
* @sample AWSLogsAsyncHandler.DescribeSubscriptionFilters
*/
java.util.concurrent.Future describeSubscriptionFiltersAsync(
DescribeSubscriptionFiltersRequest describeSubscriptionFiltersRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Retrieves log events, optionally filtered by a filter pattern from the
* specified log group. You can provide an optional time range to filter the
* results on the event timestamp. You can limit
* the streams searched to an explicit list of
* logStreamNames.
*
*
* By default, this operation returns as much matching log events as can fit
* in a response size of 1MB, up to 10,000 log events, or all the events
* found within a time-bounded scan window. If the response includes a
* nextToken, then there is more data to search,
* and the search can be resumed with a new request providing the nextToken.
* The response will contain a list of
* searchedLogStreams that contains information
* about which streams were searched in the request and whether they have
* been searched completely or require further pagination. The
* limit parameter in the request. can be used to
* specify the maximum number of events to return in a page.
*
*
* @param filterLogEventsRequest
* @return A Java Future containing the result of the FilterLogEvents
* operation returned by the service.
* @sample AWSLogsAsync.FilterLogEvents
*/
java.util.concurrent.Future filterLogEventsAsync(
FilterLogEventsRequest filterLogEventsRequest);
/**
*
* Retrieves log events, optionally filtered by a filter pattern from the
* specified log group. You can provide an optional time range to filter the
* results on the event timestamp. You can limit
* the streams searched to an explicit list of
* logStreamNames.
*
*
* By default, this operation returns as much matching log events as can fit
* in a response size of 1MB, up to 10,000 log events, or all the events
* found within a time-bounded scan window. If the response includes a
* nextToken, then there is more data to search,
* and the search can be resumed with a new request providing the nextToken.
* The response will contain a list of
* searchedLogStreams that contains information
* about which streams were searched in the request and whether they have
* been searched completely or require further pagination. The
* limit parameter in the request. can be used to
* specify the maximum number of events to return in a page.
*
*
* @param filterLogEventsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the FilterLogEvents
* operation returned by the service.
* @sample AWSLogsAsyncHandler.FilterLogEvents
*/
java.util.concurrent.Future filterLogEventsAsync(
FilterLogEventsRequest filterLogEventsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Retrieves log events from the specified log stream. You can provide an
* optional time range to filter the results on the event
* timestamp.
*
*
* By default, this operation returns as much log events as can fit in a
* response size of 1MB, up to 10,000 log events. The response will always
* include a nextForwardToken and a
* nextBackwardToken in the response body. You can
* use any of these tokens in subsequent
* GetLogEvents requests to paginate through
* events in either forward or backward direction. You can also limit the
* number of log events returned in the response by specifying the
* limit parameter in the request.
*
*
* @param getLogEventsRequest
* @return A Java Future containing the result of the GetLogEvents operation
* returned by the service.
* @sample AWSLogsAsync.GetLogEvents
*/
java.util.concurrent.Future getLogEventsAsync(
GetLogEventsRequest getLogEventsRequest);
/**
*
* Retrieves log events from the specified log stream. You can provide an
* optional time range to filter the results on the event
* timestamp.
*
*
* By default, this operation returns as much log events as can fit in a
* response size of 1MB, up to 10,000 log events. The response will always
* include a nextForwardToken and a
* nextBackwardToken in the response body. You can
* use any of these tokens in subsequent
* GetLogEvents requests to paginate through
* events in either forward or backward direction. You can also limit the
* number of log events returned in the response by specifying the
* limit parameter in the request.
*
*
* @param getLogEventsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetLogEvents operation
* returned by the service.
* @sample AWSLogsAsyncHandler.GetLogEvents
*/
java.util.concurrent.Future getLogEventsAsync(
GetLogEventsRequest getLogEventsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Creates or updates a Destination. A destination encapsulates
* a physical resource (such as a Kinesis stream) and allows you to
* subscribe to a real-time stream of log events of a different account,
* ingested through PutLogEvents requests.
* Currently, the only supported physical resource is a Amazon Kinesis
* stream belonging to the same account as the destination.
*
*
* A destination controls what is written to its Amazon Kinesis stream
* through an access policy. By default, PutDestination does not set any
* access policy with the destination, which means a cross-account user will
* not be able to call PutSubscriptionFilter against this
* destination. To enable that, the destination owner must call
* PutDestinationPolicy after PutDestination.
*
*
* @param putDestinationRequest
* @return A Java Future containing the result of the PutDestination
* operation returned by the service.
* @sample AWSLogsAsync.PutDestination
*/
java.util.concurrent.Future putDestinationAsync(
PutDestinationRequest putDestinationRequest);
/**
*
* Creates or updates a Destination. A destination encapsulates
* a physical resource (such as a Kinesis stream) and allows you to
* subscribe to a real-time stream of log events of a different account,
* ingested through PutLogEvents requests.
* Currently, the only supported physical resource is a Amazon Kinesis
* stream belonging to the same account as the destination.
*
*
* A destination controls what is written to its Amazon Kinesis stream
* through an access policy. By default, PutDestination does not set any
* access policy with the destination, which means a cross-account user will
* not be able to call PutSubscriptionFilter against this
* destination. To enable that, the destination owner must call
* PutDestinationPolicy after PutDestination.
*
*
* @param putDestinationRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the PutDestination
* operation returned by the service.
* @sample AWSLogsAsyncHandler.PutDestination
*/
java.util.concurrent.Future putDestinationAsync(
PutDestinationRequest putDestinationRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Creates or updates an access policy associated with an existing
* Destination. An access policy is an IAM policy document that is used to authorize claims to register a
* subscription filter against a given destination.
*
*
* @param putDestinationPolicyRequest
* @return A Java Future containing the result of the PutDestinationPolicy
* operation returned by the service.
* @sample AWSLogsAsync.PutDestinationPolicy
*/
java.util.concurrent.Future putDestinationPolicyAsync(
PutDestinationPolicyRequest putDestinationPolicyRequest);
/**
*
* Creates or updates an access policy associated with an existing
* Destination. An access policy is an IAM policy document that is used to authorize claims to register a
* subscription filter against a given destination.
*
*
* @param putDestinationPolicyRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the PutDestinationPolicy
* operation returned by the service.
* @sample AWSLogsAsyncHandler.PutDestinationPolicy
*/
java.util.concurrent.Future putDestinationPolicyAsync(
PutDestinationPolicyRequest putDestinationPolicyRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Uploads a batch of log events to the specified log stream.
*
*
* Every PutLogEvents request must include the
* sequenceToken obtained from the response of the
* previous request. An upload in a newly created log stream does not
* require a sequenceToken.
*
*
* The batch of events must satisfy the following constraints:
*
* - The maximum batch size is 1,048,576 bytes, and 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 the
* retention period of the log group.
* - The log events in the batch must be in chronological ordered by their
*
timestamp.
* - The maximum number of log events in a batch is 10,000.
* - A batch of log events in a single PutLogEvents request cannot span
* more than 24 hours. Otherwise, the PutLogEvents operation will fail.
*
*
*
* @param putLogEventsRequest
* @return A Java Future containing the result of the PutLogEvents operation
* returned by the service.
* @sample AWSLogsAsync.PutLogEvents
*/
java.util.concurrent.Future putLogEventsAsync(
PutLogEventsRequest putLogEventsRequest);
/**
*
* Uploads a batch of log events to the specified log stream.
*
*
* Every PutLogEvents request must include the
* sequenceToken obtained from the response of the
* previous request. An upload in a newly created log stream does not
* require a sequenceToken.
*
*
* The batch of events must satisfy the following constraints:
*
* - The maximum batch size is 1,048,576 bytes, and 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 the
* retention period of the log group.
* - The log events in the batch must be in chronological ordered by their
*
timestamp.
* - The maximum number of log events in a batch is 10,000.
* - A batch of log events in a single PutLogEvents request cannot span
* more than 24 hours. Otherwise, the PutLogEvents operation will fail.
*
*
*
* @param putLogEventsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the PutLogEvents operation
* returned by the service.
* @sample AWSLogsAsyncHandler.PutLogEvents
*/
java.util.concurrent.Future putLogEventsAsync(
PutLogEventsRequest putLogEventsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* 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 requests.
*
*
* The maximum number of metric filters that can be associated with a log
* group is 100.
*
*
* @param putMetricFilterRequest
* @return A Java Future containing the result of the PutMetricFilter
* operation returned by the service.
* @sample AWSLogsAsync.PutMetricFilter
*/
java.util.concurrent.Future putMetricFilterAsync(
PutMetricFilterRequest putMetricFilterRequest);
/**
*
* 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 requests.
*
*
* The maximum number of metric filters that can be associated with a log
* group is 100.
*
*
* @param putMetricFilterRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the PutMetricFilter
* operation returned by the service.
* @sample AWSLogsAsyncHandler.PutMetricFilter
*/
java.util.concurrent.Future putMetricFilterAsync(
PutMetricFilterRequest putMetricFilterRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Sets the retention of the specified log group. A retention policy allows
* you to configure the number of days you want to retain log events in the
* specified log group.
*
*
* @param putRetentionPolicyRequest
* @return A Java Future containing the result of the PutRetentionPolicy
* operation returned by the service.
* @sample AWSLogsAsync.PutRetentionPolicy
*/
java.util.concurrent.Future putRetentionPolicyAsync(
PutRetentionPolicyRequest putRetentionPolicyRequest);
/**
*
* Sets the retention of the specified log group. A retention policy allows
* you to configure the number of days you want to retain log events in the
* specified log group.
*
*
* @param putRetentionPolicyRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the PutRetentionPolicy
* operation returned by the service.
* @sample AWSLogsAsyncHandler.PutRetentionPolicy
*/
java.util.concurrent.Future putRetentionPolicyAsync(
PutRetentionPolicyRequest putRetentionPolicyRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* 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 requests and have them delivered
* to a specific destination. 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 (used via an ARN of
Destination)
* belonging to a different account, for cross-account delivery.
* - An Amazon Kinesis Firehose 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.
*
*
*
* Currently there can only be one subscription filter associated with a log
* group.
*
*
* @param putSubscriptionFilterRequest
* @return A Java Future containing the result of the PutSubscriptionFilter
* operation returned by the service.
* @sample AWSLogsAsync.PutSubscriptionFilter
*/
java.util.concurrent.Future putSubscriptionFilterAsync(
PutSubscriptionFilterRequest putSubscriptionFilterRequest);
/**
*
* 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 requests and have them delivered
* to a specific destination. 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 (used via an ARN of
Destination)
* belonging to a different account, for cross-account delivery.
* - An Amazon Kinesis Firehose 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.
*
*
*
* Currently there can only be one subscription filter associated with a log
* group.
*
*
* @param putSubscriptionFilterRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the PutSubscriptionFilter
* operation returned by the service.
* @sample AWSLogsAsyncHandler.PutSubscriptionFilter
*/
java.util.concurrent.Future putSubscriptionFilterAsync(
PutSubscriptionFilterRequest putSubscriptionFilterRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* 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.
*
*
* @param testMetricFilterRequest
* @return A Java Future containing the result of the TestMetricFilter
* operation returned by the service.
* @sample AWSLogsAsync.TestMetricFilter
*/
java.util.concurrent.Future testMetricFilterAsync(
TestMetricFilterRequest testMetricFilterRequest);
/**
*
* 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.
*
*
* @param testMetricFilterRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the
* request. Users can provide an implementation of the callback
* methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the TestMetricFilter
* operation returned by the service.
* @sample AWSLogsAsyncHandler.TestMetricFilter
*/
java.util.concurrent.Future testMetricFilterAsync(
TestMetricFilterRequest testMetricFilterRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
}