2511 lines
84 KiB
Go
2511 lines
84 KiB
Go
// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
|
|
|
|
// Package cloudwatchlogs provides a client for Amazon CloudWatch Logs.
|
|
package cloudwatchlogs
|
|
|
|
import (
|
|
"github.com/aws/aws-sdk-go/aws/awsutil"
|
|
"github.com/aws/aws-sdk-go/aws/request"
|
|
"github.com/aws/aws-sdk-go/private/protocol"
|
|
"github.com/aws/aws-sdk-go/private/protocol/jsonrpc"
|
|
)
|
|
|
|
const opCancelExportTask = "CancelExportTask"
|
|
|
|
// CancelExportTaskRequest generates a request for the CancelExportTask operation.
|
|
func (c *CloudWatchLogs) CancelExportTaskRequest(input *CancelExportTaskInput) (req *request.Request, output *CancelExportTaskOutput) {
|
|
op := &request.Operation{
|
|
Name: opCancelExportTask,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &CancelExportTaskInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
|
|
req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
|
|
output = &CancelExportTaskOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// Cancels an export task if it is in PENDING or RUNNING state.
|
|
func (c *CloudWatchLogs) CancelExportTask(input *CancelExportTaskInput) (*CancelExportTaskOutput, error) {
|
|
req, out := c.CancelExportTaskRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
const opCreateExportTask = "CreateExportTask"
|
|
|
|
// CreateExportTaskRequest generates a request for the CreateExportTask operation.
|
|
func (c *CloudWatchLogs) CreateExportTaskRequest(input *CreateExportTaskInput) (req *request.Request, output *CreateExportTaskOutput) {
|
|
op := &request.Operation{
|
|
Name: opCreateExportTask,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &CreateExportTaskInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
output = &CreateExportTaskOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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.
|
|
func (c *CloudWatchLogs) CreateExportTask(input *CreateExportTaskInput) (*CreateExportTaskOutput, error) {
|
|
req, out := c.CreateExportTaskRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
const opCreateLogGroup = "CreateLogGroup"
|
|
|
|
// CreateLogGroupRequest generates a request for the CreateLogGroup operation.
|
|
func (c *CloudWatchLogs) CreateLogGroupRequest(input *CreateLogGroupInput) (req *request.Request, output *CreateLogGroupOutput) {
|
|
op := &request.Operation{
|
|
Name: opCreateLogGroup,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &CreateLogGroupInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
|
|
req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
|
|
output = &CreateLogGroupOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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).
|
|
func (c *CloudWatchLogs) CreateLogGroup(input *CreateLogGroupInput) (*CreateLogGroupOutput, error) {
|
|
req, out := c.CreateLogGroupRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
const opCreateLogStream = "CreateLogStream"
|
|
|
|
// CreateLogStreamRequest generates a request for the CreateLogStream operation.
|
|
func (c *CloudWatchLogs) CreateLogStreamRequest(input *CreateLogStreamInput) (req *request.Request, output *CreateLogStreamOutput) {
|
|
op := &request.Operation{
|
|
Name: opCreateLogStream,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &CreateLogStreamInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
|
|
req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
|
|
output = &CreateLogStreamOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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.
|
|
func (c *CloudWatchLogs) CreateLogStream(input *CreateLogStreamInput) (*CreateLogStreamOutput, error) {
|
|
req, out := c.CreateLogStreamRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
const opDeleteDestination = "DeleteDestination"
|
|
|
|
// DeleteDestinationRequest generates a request for the DeleteDestination operation.
|
|
func (c *CloudWatchLogs) DeleteDestinationRequest(input *DeleteDestinationInput) (req *request.Request, output *DeleteDestinationOutput) {
|
|
op := &request.Operation{
|
|
Name: opDeleteDestination,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &DeleteDestinationInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
|
|
req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
|
|
output = &DeleteDestinationOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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.
|
|
func (c *CloudWatchLogs) DeleteDestination(input *DeleteDestinationInput) (*DeleteDestinationOutput, error) {
|
|
req, out := c.DeleteDestinationRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
const opDeleteLogGroup = "DeleteLogGroup"
|
|
|
|
// DeleteLogGroupRequest generates a request for the DeleteLogGroup operation.
|
|
func (c *CloudWatchLogs) DeleteLogGroupRequest(input *DeleteLogGroupInput) (req *request.Request, output *DeleteLogGroupOutput) {
|
|
op := &request.Operation{
|
|
Name: opDeleteLogGroup,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &DeleteLogGroupInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
|
|
req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
|
|
output = &DeleteLogGroupOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// Deletes the log group with the specified name and permanently deletes all
|
|
// the archived log events associated with it.
|
|
func (c *CloudWatchLogs) DeleteLogGroup(input *DeleteLogGroupInput) (*DeleteLogGroupOutput, error) {
|
|
req, out := c.DeleteLogGroupRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
const opDeleteLogStream = "DeleteLogStream"
|
|
|
|
// DeleteLogStreamRequest generates a request for the DeleteLogStream operation.
|
|
func (c *CloudWatchLogs) DeleteLogStreamRequest(input *DeleteLogStreamInput) (req *request.Request, output *DeleteLogStreamOutput) {
|
|
op := &request.Operation{
|
|
Name: opDeleteLogStream,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &DeleteLogStreamInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
|
|
req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
|
|
output = &DeleteLogStreamOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// Deletes a log stream and permanently deletes all the archived log events
|
|
// associated with it.
|
|
func (c *CloudWatchLogs) DeleteLogStream(input *DeleteLogStreamInput) (*DeleteLogStreamOutput, error) {
|
|
req, out := c.DeleteLogStreamRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
const opDeleteMetricFilter = "DeleteMetricFilter"
|
|
|
|
// DeleteMetricFilterRequest generates a request for the DeleteMetricFilter operation.
|
|
func (c *CloudWatchLogs) DeleteMetricFilterRequest(input *DeleteMetricFilterInput) (req *request.Request, output *DeleteMetricFilterOutput) {
|
|
op := &request.Operation{
|
|
Name: opDeleteMetricFilter,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &DeleteMetricFilterInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
|
|
req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
|
|
output = &DeleteMetricFilterOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// Deletes a metric filter associated with the specified log group.
|
|
func (c *CloudWatchLogs) DeleteMetricFilter(input *DeleteMetricFilterInput) (*DeleteMetricFilterOutput, error) {
|
|
req, out := c.DeleteMetricFilterRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
const opDeleteRetentionPolicy = "DeleteRetentionPolicy"
|
|
|
|
// DeleteRetentionPolicyRequest generates a request for the DeleteRetentionPolicy operation.
|
|
func (c *CloudWatchLogs) DeleteRetentionPolicyRequest(input *DeleteRetentionPolicyInput) (req *request.Request, output *DeleteRetentionPolicyOutput) {
|
|
op := &request.Operation{
|
|
Name: opDeleteRetentionPolicy,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &DeleteRetentionPolicyInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
|
|
req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
|
|
output = &DeleteRetentionPolicyOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// Deletes the retention policy of the specified log group. Log events would
|
|
// not expire if they belong to log groups without a retention policy.
|
|
func (c *CloudWatchLogs) DeleteRetentionPolicy(input *DeleteRetentionPolicyInput) (*DeleteRetentionPolicyOutput, error) {
|
|
req, out := c.DeleteRetentionPolicyRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
const opDeleteSubscriptionFilter = "DeleteSubscriptionFilter"
|
|
|
|
// DeleteSubscriptionFilterRequest generates a request for the DeleteSubscriptionFilter operation.
|
|
func (c *CloudWatchLogs) DeleteSubscriptionFilterRequest(input *DeleteSubscriptionFilterInput) (req *request.Request, output *DeleteSubscriptionFilterOutput) {
|
|
op := &request.Operation{
|
|
Name: opDeleteSubscriptionFilter,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &DeleteSubscriptionFilterInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
|
|
req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
|
|
output = &DeleteSubscriptionFilterOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// Deletes a subscription filter associated with the specified log group.
|
|
func (c *CloudWatchLogs) DeleteSubscriptionFilter(input *DeleteSubscriptionFilterInput) (*DeleteSubscriptionFilterOutput, error) {
|
|
req, out := c.DeleteSubscriptionFilterRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
const opDescribeDestinations = "DescribeDestinations"
|
|
|
|
// DescribeDestinationsRequest generates a request for the DescribeDestinations operation.
|
|
func (c *CloudWatchLogs) DescribeDestinationsRequest(input *DescribeDestinationsInput) (req *request.Request, output *DescribeDestinationsOutput) {
|
|
op := &request.Operation{
|
|
Name: opDescribeDestinations,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
Paginator: &request.Paginator{
|
|
InputTokens: []string{"nextToken"},
|
|
OutputTokens: []string{"nextToken"},
|
|
LimitToken: "limit",
|
|
TruncationToken: "",
|
|
},
|
|
}
|
|
|
|
if input == nil {
|
|
input = &DescribeDestinationsInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
output = &DescribeDestinationsOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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.
|
|
func (c *CloudWatchLogs) DescribeDestinations(input *DescribeDestinationsInput) (*DescribeDestinationsOutput, error) {
|
|
req, out := c.DescribeDestinationsRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
func (c *CloudWatchLogs) DescribeDestinationsPages(input *DescribeDestinationsInput, fn func(p *DescribeDestinationsOutput, lastPage bool) (shouldContinue bool)) error {
|
|
page, _ := c.DescribeDestinationsRequest(input)
|
|
page.Handlers.Build.PushBack(request.MakeAddToUserAgentFreeFormHandler("Paginator"))
|
|
return page.EachPage(func(p interface{}, lastPage bool) bool {
|
|
return fn(p.(*DescribeDestinationsOutput), lastPage)
|
|
})
|
|
}
|
|
|
|
const opDescribeExportTasks = "DescribeExportTasks"
|
|
|
|
// DescribeExportTasksRequest generates a request for the DescribeExportTasks operation.
|
|
func (c *CloudWatchLogs) DescribeExportTasksRequest(input *DescribeExportTasksInput) (req *request.Request, output *DescribeExportTasksOutput) {
|
|
op := &request.Operation{
|
|
Name: opDescribeExportTasks,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &DescribeExportTasksInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
output = &DescribeExportTasksOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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.
|
|
func (c *CloudWatchLogs) DescribeExportTasks(input *DescribeExportTasksInput) (*DescribeExportTasksOutput, error) {
|
|
req, out := c.DescribeExportTasksRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
const opDescribeLogGroups = "DescribeLogGroups"
|
|
|
|
// DescribeLogGroupsRequest generates a request for the DescribeLogGroups operation.
|
|
func (c *CloudWatchLogs) DescribeLogGroupsRequest(input *DescribeLogGroupsInput) (req *request.Request, output *DescribeLogGroupsOutput) {
|
|
op := &request.Operation{
|
|
Name: opDescribeLogGroups,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
Paginator: &request.Paginator{
|
|
InputTokens: []string{"nextToken"},
|
|
OutputTokens: []string{"nextToken"},
|
|
LimitToken: "limit",
|
|
TruncationToken: "",
|
|
},
|
|
}
|
|
|
|
if input == nil {
|
|
input = &DescribeLogGroupsInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
output = &DescribeLogGroupsOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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.
|
|
func (c *CloudWatchLogs) DescribeLogGroups(input *DescribeLogGroupsInput) (*DescribeLogGroupsOutput, error) {
|
|
req, out := c.DescribeLogGroupsRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
func (c *CloudWatchLogs) DescribeLogGroupsPages(input *DescribeLogGroupsInput, fn func(p *DescribeLogGroupsOutput, lastPage bool) (shouldContinue bool)) error {
|
|
page, _ := c.DescribeLogGroupsRequest(input)
|
|
page.Handlers.Build.PushBack(request.MakeAddToUserAgentFreeFormHandler("Paginator"))
|
|
return page.EachPage(func(p interface{}, lastPage bool) bool {
|
|
return fn(p.(*DescribeLogGroupsOutput), lastPage)
|
|
})
|
|
}
|
|
|
|
const opDescribeLogStreams = "DescribeLogStreams"
|
|
|
|
// DescribeLogStreamsRequest generates a request for the DescribeLogStreams operation.
|
|
func (c *CloudWatchLogs) DescribeLogStreamsRequest(input *DescribeLogStreamsInput) (req *request.Request, output *DescribeLogStreamsOutput) {
|
|
op := &request.Operation{
|
|
Name: opDescribeLogStreams,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
Paginator: &request.Paginator{
|
|
InputTokens: []string{"nextToken"},
|
|
OutputTokens: []string{"nextToken"},
|
|
LimitToken: "limit",
|
|
TruncationToken: "",
|
|
},
|
|
}
|
|
|
|
if input == nil {
|
|
input = &DescribeLogStreamsInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
output = &DescribeLogStreamsOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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.
|
|
func (c *CloudWatchLogs) DescribeLogStreams(input *DescribeLogStreamsInput) (*DescribeLogStreamsOutput, error) {
|
|
req, out := c.DescribeLogStreamsRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
func (c *CloudWatchLogs) DescribeLogStreamsPages(input *DescribeLogStreamsInput, fn func(p *DescribeLogStreamsOutput, lastPage bool) (shouldContinue bool)) error {
|
|
page, _ := c.DescribeLogStreamsRequest(input)
|
|
page.Handlers.Build.PushBack(request.MakeAddToUserAgentFreeFormHandler("Paginator"))
|
|
return page.EachPage(func(p interface{}, lastPage bool) bool {
|
|
return fn(p.(*DescribeLogStreamsOutput), lastPage)
|
|
})
|
|
}
|
|
|
|
const opDescribeMetricFilters = "DescribeMetricFilters"
|
|
|
|
// DescribeMetricFiltersRequest generates a request for the DescribeMetricFilters operation.
|
|
func (c *CloudWatchLogs) DescribeMetricFiltersRequest(input *DescribeMetricFiltersInput) (req *request.Request, output *DescribeMetricFiltersOutput) {
|
|
op := &request.Operation{
|
|
Name: opDescribeMetricFilters,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
Paginator: &request.Paginator{
|
|
InputTokens: []string{"nextToken"},
|
|
OutputTokens: []string{"nextToken"},
|
|
LimitToken: "limit",
|
|
TruncationToken: "",
|
|
},
|
|
}
|
|
|
|
if input == nil {
|
|
input = &DescribeMetricFiltersInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
output = &DescribeMetricFiltersOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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.
|
|
func (c *CloudWatchLogs) DescribeMetricFilters(input *DescribeMetricFiltersInput) (*DescribeMetricFiltersOutput, error) {
|
|
req, out := c.DescribeMetricFiltersRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
func (c *CloudWatchLogs) DescribeMetricFiltersPages(input *DescribeMetricFiltersInput, fn func(p *DescribeMetricFiltersOutput, lastPage bool) (shouldContinue bool)) error {
|
|
page, _ := c.DescribeMetricFiltersRequest(input)
|
|
page.Handlers.Build.PushBack(request.MakeAddToUserAgentFreeFormHandler("Paginator"))
|
|
return page.EachPage(func(p interface{}, lastPage bool) bool {
|
|
return fn(p.(*DescribeMetricFiltersOutput), lastPage)
|
|
})
|
|
}
|
|
|
|
const opDescribeSubscriptionFilters = "DescribeSubscriptionFilters"
|
|
|
|
// DescribeSubscriptionFiltersRequest generates a request for the DescribeSubscriptionFilters operation.
|
|
func (c *CloudWatchLogs) DescribeSubscriptionFiltersRequest(input *DescribeSubscriptionFiltersInput) (req *request.Request, output *DescribeSubscriptionFiltersOutput) {
|
|
op := &request.Operation{
|
|
Name: opDescribeSubscriptionFilters,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
Paginator: &request.Paginator{
|
|
InputTokens: []string{"nextToken"},
|
|
OutputTokens: []string{"nextToken"},
|
|
LimitToken: "limit",
|
|
TruncationToken: "",
|
|
},
|
|
}
|
|
|
|
if input == nil {
|
|
input = &DescribeSubscriptionFiltersInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
output = &DescribeSubscriptionFiltersOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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.
|
|
func (c *CloudWatchLogs) DescribeSubscriptionFilters(input *DescribeSubscriptionFiltersInput) (*DescribeSubscriptionFiltersOutput, error) {
|
|
req, out := c.DescribeSubscriptionFiltersRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
func (c *CloudWatchLogs) DescribeSubscriptionFiltersPages(input *DescribeSubscriptionFiltersInput, fn func(p *DescribeSubscriptionFiltersOutput, lastPage bool) (shouldContinue bool)) error {
|
|
page, _ := c.DescribeSubscriptionFiltersRequest(input)
|
|
page.Handlers.Build.PushBack(request.MakeAddToUserAgentFreeFormHandler("Paginator"))
|
|
return page.EachPage(func(p interface{}, lastPage bool) bool {
|
|
return fn(p.(*DescribeSubscriptionFiltersOutput), lastPage)
|
|
})
|
|
}
|
|
|
|
const opFilterLogEvents = "FilterLogEvents"
|
|
|
|
// FilterLogEventsRequest generates a request for the FilterLogEvents operation.
|
|
func (c *CloudWatchLogs) FilterLogEventsRequest(input *FilterLogEventsInput) (req *request.Request, output *FilterLogEventsOutput) {
|
|
op := &request.Operation{
|
|
Name: opFilterLogEvents,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
Paginator: &request.Paginator{
|
|
InputTokens: []string{"nextToken"},
|
|
OutputTokens: []string{"nextToken"},
|
|
LimitToken: "limit",
|
|
TruncationToken: "",
|
|
},
|
|
}
|
|
|
|
if input == nil {
|
|
input = &FilterLogEventsInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
output = &FilterLogEventsOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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.
|
|
func (c *CloudWatchLogs) FilterLogEvents(input *FilterLogEventsInput) (*FilterLogEventsOutput, error) {
|
|
req, out := c.FilterLogEventsRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
func (c *CloudWatchLogs) FilterLogEventsPages(input *FilterLogEventsInput, fn func(p *FilterLogEventsOutput, lastPage bool) (shouldContinue bool)) error {
|
|
page, _ := c.FilterLogEventsRequest(input)
|
|
page.Handlers.Build.PushBack(request.MakeAddToUserAgentFreeFormHandler("Paginator"))
|
|
return page.EachPage(func(p interface{}, lastPage bool) bool {
|
|
return fn(p.(*FilterLogEventsOutput), lastPage)
|
|
})
|
|
}
|
|
|
|
const opGetLogEvents = "GetLogEvents"
|
|
|
|
// GetLogEventsRequest generates a request for the GetLogEvents operation.
|
|
func (c *CloudWatchLogs) GetLogEventsRequest(input *GetLogEventsInput) (req *request.Request, output *GetLogEventsOutput) {
|
|
op := &request.Operation{
|
|
Name: opGetLogEvents,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
Paginator: &request.Paginator{
|
|
InputTokens: []string{"nextToken"},
|
|
OutputTokens: []string{"nextForwardToken"},
|
|
LimitToken: "limit",
|
|
TruncationToken: "",
|
|
},
|
|
}
|
|
|
|
if input == nil {
|
|
input = &GetLogEventsInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
output = &GetLogEventsOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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.
|
|
func (c *CloudWatchLogs) GetLogEvents(input *GetLogEventsInput) (*GetLogEventsOutput, error) {
|
|
req, out := c.GetLogEventsRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
func (c *CloudWatchLogs) GetLogEventsPages(input *GetLogEventsInput, fn func(p *GetLogEventsOutput, lastPage bool) (shouldContinue bool)) error {
|
|
page, _ := c.GetLogEventsRequest(input)
|
|
page.Handlers.Build.PushBack(request.MakeAddToUserAgentFreeFormHandler("Paginator"))
|
|
return page.EachPage(func(p interface{}, lastPage bool) bool {
|
|
return fn(p.(*GetLogEventsOutput), lastPage)
|
|
})
|
|
}
|
|
|
|
const opPutDestination = "PutDestination"
|
|
|
|
// PutDestinationRequest generates a request for the PutDestination operation.
|
|
func (c *CloudWatchLogs) PutDestinationRequest(input *PutDestinationInput) (req *request.Request, output *PutDestinationOutput) {
|
|
op := &request.Operation{
|
|
Name: opPutDestination,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &PutDestinationInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
output = &PutDestinationOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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.
|
|
func (c *CloudWatchLogs) PutDestination(input *PutDestinationInput) (*PutDestinationOutput, error) {
|
|
req, out := c.PutDestinationRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
const opPutDestinationPolicy = "PutDestinationPolicy"
|
|
|
|
// PutDestinationPolicyRequest generates a request for the PutDestinationPolicy operation.
|
|
func (c *CloudWatchLogs) PutDestinationPolicyRequest(input *PutDestinationPolicyInput) (req *request.Request, output *PutDestinationPolicyOutput) {
|
|
op := &request.Operation{
|
|
Name: opPutDestinationPolicy,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &PutDestinationPolicyInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
|
|
req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
|
|
output = &PutDestinationPolicyOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// Creates or updates an access policy associated with an existing Destination.
|
|
// An access policy is an IAM policy document (http://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 (c *CloudWatchLogs) PutDestinationPolicy(input *PutDestinationPolicyInput) (*PutDestinationPolicyOutput, error) {
|
|
req, out := c.PutDestinationPolicyRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
const opPutLogEvents = "PutLogEvents"
|
|
|
|
// PutLogEventsRequest generates a request for the PutLogEvents operation.
|
|
func (c *CloudWatchLogs) PutLogEventsRequest(input *PutLogEventsInput) (req *request.Request, output *PutLogEventsOutput) {
|
|
op := &request.Operation{
|
|
Name: opPutLogEvents,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &PutLogEventsInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
output = &PutLogEventsOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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.
|
|
func (c *CloudWatchLogs) PutLogEvents(input *PutLogEventsInput) (*PutLogEventsOutput, error) {
|
|
req, out := c.PutLogEventsRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
const opPutMetricFilter = "PutMetricFilter"
|
|
|
|
// PutMetricFilterRequest generates a request for the PutMetricFilter operation.
|
|
func (c *CloudWatchLogs) PutMetricFilterRequest(input *PutMetricFilterInput) (req *request.Request, output *PutMetricFilterOutput) {
|
|
op := &request.Operation{
|
|
Name: opPutMetricFilter,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &PutMetricFilterInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
|
|
req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
|
|
output = &PutMetricFilterOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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.
|
|
func (c *CloudWatchLogs) PutMetricFilter(input *PutMetricFilterInput) (*PutMetricFilterOutput, error) {
|
|
req, out := c.PutMetricFilterRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
const opPutRetentionPolicy = "PutRetentionPolicy"
|
|
|
|
// PutRetentionPolicyRequest generates a request for the PutRetentionPolicy operation.
|
|
func (c *CloudWatchLogs) PutRetentionPolicyRequest(input *PutRetentionPolicyInput) (req *request.Request, output *PutRetentionPolicyOutput) {
|
|
op := &request.Operation{
|
|
Name: opPutRetentionPolicy,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &PutRetentionPolicyInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
|
|
req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
|
|
output = &PutRetentionPolicyOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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.
|
|
func (c *CloudWatchLogs) PutRetentionPolicy(input *PutRetentionPolicyInput) (*PutRetentionPolicyOutput, error) {
|
|
req, out := c.PutRetentionPolicyRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
const opPutSubscriptionFilter = "PutSubscriptionFilter"
|
|
|
|
// PutSubscriptionFilterRequest generates a request for the PutSubscriptionFilter operation.
|
|
func (c *CloudWatchLogs) PutSubscriptionFilterRequest(input *PutSubscriptionFilterInput) (req *request.Request, output *PutSubscriptionFilterOutput) {
|
|
op := &request.Operation{
|
|
Name: opPutSubscriptionFilter,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &PutSubscriptionFilterInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
|
|
req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
|
|
output = &PutSubscriptionFilterOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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.
|
|
func (c *CloudWatchLogs) PutSubscriptionFilter(input *PutSubscriptionFilterInput) (*PutSubscriptionFilterOutput, error) {
|
|
req, out := c.PutSubscriptionFilterRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
const opTestMetricFilter = "TestMetricFilter"
|
|
|
|
// TestMetricFilterRequest generates a request for the TestMetricFilter operation.
|
|
func (c *CloudWatchLogs) TestMetricFilterRequest(input *TestMetricFilterInput) (req *request.Request, output *TestMetricFilterOutput) {
|
|
op := &request.Operation{
|
|
Name: opTestMetricFilter,
|
|
HTTPMethod: "POST",
|
|
HTTPPath: "/",
|
|
}
|
|
|
|
if input == nil {
|
|
input = &TestMetricFilterInput{}
|
|
}
|
|
|
|
req = c.newRequest(op, input, output)
|
|
output = &TestMetricFilterOutput{}
|
|
req.Data = output
|
|
return
|
|
}
|
|
|
|
// 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 (c *CloudWatchLogs) TestMetricFilter(input *TestMetricFilterInput) (*TestMetricFilterOutput, error) {
|
|
req, out := c.TestMetricFilterRequest(input)
|
|
err := req.Send()
|
|
return out, err
|
|
}
|
|
|
|
type CancelExportTaskInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// Id of the export task to cancel.
|
|
TaskId *string `locationName:"taskId" min:"1" type:"string" required:"true"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s CancelExportTaskInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s CancelExportTaskInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type CancelExportTaskOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s CancelExportTaskOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s CancelExportTaskOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type CreateExportTaskInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// Name of Amazon S3 bucket to which the log data will be exported.
|
|
//
|
|
// Note: Only buckets in the same AWS region are supported.
|
|
Destination *string `locationName:"destination" min:"1" type:"string" required:"true"`
|
|
|
|
// Prefix that will be used as the start of Amazon S3 key for every object exported.
|
|
// If not specified, this defaults to 'exportedlogs'.
|
|
DestinationPrefix *string `locationName:"destinationPrefix" type:"string"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC. It indicates the start time of the range for the request. Events
|
|
// with a timestamp prior to this time will not be exported.
|
|
From *int64 `locationName:"from" type:"long" required:"true"`
|
|
|
|
// The name of the log group to export.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string" required:"true"`
|
|
|
|
// Will only export log streams that match the provided logStreamNamePrefix.
|
|
// If you don't specify a value, no prefix filter is applied.
|
|
LogStreamNamePrefix *string `locationName:"logStreamNamePrefix" min:"1" type:"string"`
|
|
|
|
// The name of the export task.
|
|
TaskName *string `locationName:"taskName" min:"1" type:"string"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC. It indicates the end time of the range for the request. Events
|
|
// with a timestamp later than this time will not be exported.
|
|
To *int64 `locationName:"to" type:"long" required:"true"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s CreateExportTaskInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s CreateExportTaskInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type CreateExportTaskOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// Id of the export task that got created.
|
|
TaskId *string `locationName:"taskId" min:"1" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s CreateExportTaskOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s CreateExportTaskOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type CreateLogGroupInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// The name of the log group to create.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string" required:"true"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s CreateLogGroupInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s CreateLogGroupInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type CreateLogGroupOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s CreateLogGroupOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s CreateLogGroupOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type CreateLogStreamInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// The name of the log group under which the log stream is to be created.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string" required:"true"`
|
|
|
|
// The name of the log stream to create.
|
|
LogStreamName *string `locationName:"logStreamName" min:"1" type:"string" required:"true"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s CreateLogStreamInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s CreateLogStreamInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type CreateLogStreamOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s CreateLogStreamOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s CreateLogStreamOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DeleteDestinationInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// The name of destination to delete.
|
|
DestinationName *string `locationName:"destinationName" min:"1" type:"string" required:"true"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DeleteDestinationInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DeleteDestinationInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DeleteDestinationOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DeleteDestinationOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DeleteDestinationOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DeleteLogGroupInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// The name of the log group to delete.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string" required:"true"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DeleteLogGroupInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DeleteLogGroupInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DeleteLogGroupOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DeleteLogGroupOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DeleteLogGroupOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DeleteLogStreamInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// The name of the log group under which the log stream to delete belongs.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string" required:"true"`
|
|
|
|
// The name of the log stream to delete.
|
|
LogStreamName *string `locationName:"logStreamName" min:"1" type:"string" required:"true"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DeleteLogStreamInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DeleteLogStreamInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DeleteLogStreamOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DeleteLogStreamOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DeleteLogStreamOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DeleteMetricFilterInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// The name of the metric filter to delete.
|
|
FilterName *string `locationName:"filterName" min:"1" type:"string" required:"true"`
|
|
|
|
// The name of the log group that is associated with the metric filter to delete.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string" required:"true"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DeleteMetricFilterInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DeleteMetricFilterInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DeleteMetricFilterOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DeleteMetricFilterOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DeleteMetricFilterOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DeleteRetentionPolicyInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// The name of the log group that is associated with the retention policy to
|
|
// delete.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string" required:"true"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DeleteRetentionPolicyInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DeleteRetentionPolicyInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DeleteRetentionPolicyOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DeleteRetentionPolicyOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DeleteRetentionPolicyOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DeleteSubscriptionFilterInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// The name of the subscription filter to delete.
|
|
FilterName *string `locationName:"filterName" min:"1" type:"string" required:"true"`
|
|
|
|
// The name of the log group that is associated with the subscription filter
|
|
// to delete.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string" required:"true"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DeleteSubscriptionFilterInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DeleteSubscriptionFilterInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DeleteSubscriptionFilterOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DeleteSubscriptionFilterOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DeleteSubscriptionFilterOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DescribeDestinationsInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// Will only return destinations that match the provided destinationNamePrefix.
|
|
// If you don't specify a value, no prefix is applied.
|
|
DestinationNamePrefix *string `min:"1" type:"string"`
|
|
|
|
// The maximum number of results to return.
|
|
Limit *int64 `locationName:"limit" min:"1" type:"integer"`
|
|
|
|
// A string token used for pagination that points to the next page of results.
|
|
// It must be a value obtained from the response of the previous request. The
|
|
// token expires after 24 hours.
|
|
NextToken *string `locationName:"nextToken" min:"1" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DescribeDestinationsInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DescribeDestinationsInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DescribeDestinationsOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
Destinations []*Destination `locationName:"destinations" type:"list"`
|
|
|
|
// A string token used for pagination that points to the next page of results.
|
|
// It must be a value obtained from the response of the previous request. The
|
|
// token expires after 24 hours.
|
|
NextToken *string `locationName:"nextToken" min:"1" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DescribeDestinationsOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DescribeDestinationsOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DescribeExportTasksInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// The maximum number of items returned in the response. If you don't specify
|
|
// a value, the request would return up to 50 items.
|
|
Limit *int64 `locationName:"limit" min:"1" type:"integer"`
|
|
|
|
// A string token used for pagination that points to the next page of results.
|
|
// It must be a value obtained from the response of the previous DescribeExportTasks
|
|
// request.
|
|
NextToken *string `locationName:"nextToken" min:"1" type:"string"`
|
|
|
|
// All export tasks that matches the specified status code will be returned.
|
|
// This can return zero or more export tasks.
|
|
StatusCode *string `locationName:"statusCode" type:"string" enum:"ExportTaskStatusCode"`
|
|
|
|
// Export task that matches the specified task Id will be returned. This can
|
|
// result in zero or one export task.
|
|
TaskId *string `locationName:"taskId" min:"1" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DescribeExportTasksInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DescribeExportTasksInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DescribeExportTasksOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A list of export tasks.
|
|
ExportTasks []*ExportTask `locationName:"exportTasks" type:"list"`
|
|
|
|
// A string token used for pagination that points to the next page of results.
|
|
// It must be a value obtained from the response of the previous request. The
|
|
// token expires after 24 hours.
|
|
NextToken *string `locationName:"nextToken" min:"1" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DescribeExportTasksOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DescribeExportTasksOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DescribeLogGroupsInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// The maximum number of items returned in the response. If you don't specify
|
|
// a value, the request would return up to 50 items.
|
|
Limit *int64 `locationName:"limit" min:"1" type:"integer"`
|
|
|
|
// Will only return log groups that match the provided logGroupNamePrefix. If
|
|
// you don't specify a value, no prefix filter is applied.
|
|
LogGroupNamePrefix *string `locationName:"logGroupNamePrefix" min:"1" type:"string"`
|
|
|
|
// A string token used for pagination that points to the next page of results.
|
|
// It must be a value obtained from the response of the previous DescribeLogGroups
|
|
// request.
|
|
NextToken *string `locationName:"nextToken" min:"1" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DescribeLogGroupsInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DescribeLogGroupsInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DescribeLogGroupsOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A list of log groups.
|
|
LogGroups []*LogGroup `locationName:"logGroups" type:"list"`
|
|
|
|
// A string token used for pagination that points to the next page of results.
|
|
// It must be a value obtained from the response of the previous request. The
|
|
// token expires after 24 hours.
|
|
NextToken *string `locationName:"nextToken" min:"1" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DescribeLogGroupsOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DescribeLogGroupsOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DescribeLogStreamsInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// If set to true, results are returned in descending order. If you don't specify
|
|
// a value or set it to false, results are returned in ascending order.
|
|
Descending *bool `locationName:"descending" type:"boolean"`
|
|
|
|
// The maximum number of items returned in the response. If you don't specify
|
|
// a value, the request would return up to 50 items.
|
|
Limit *int64 `locationName:"limit" min:"1" type:"integer"`
|
|
|
|
// The log group name for which log streams are to be listed.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string" required:"true"`
|
|
|
|
// Will only return log streams that match the provided logStreamNamePrefix.
|
|
// If you don't specify a value, no prefix filter is applied.
|
|
LogStreamNamePrefix *string `locationName:"logStreamNamePrefix" min:"1" type:"string"`
|
|
|
|
// A string token used for pagination that points to the next page of results.
|
|
// It must be a value obtained from the response of the previous DescribeLogStreams
|
|
// request.
|
|
NextToken *string `locationName:"nextToken" min:"1" type:"string"`
|
|
|
|
// Specifies what to order the returned log streams by. Valid arguments are
|
|
// 'LogStreamName' or 'LastEventTime'. If you don't specify a value, results
|
|
// are ordered by LogStreamName. If 'LastEventTime' is chosen, the request cannot
|
|
// also contain a logStreamNamePrefix.
|
|
OrderBy *string `locationName:"orderBy" type:"string" enum:"OrderBy"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DescribeLogStreamsInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DescribeLogStreamsInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DescribeLogStreamsOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A list of log streams.
|
|
LogStreams []*LogStream `locationName:"logStreams" type:"list"`
|
|
|
|
// A string token used for pagination that points to the next page of results.
|
|
// It must be a value obtained from the response of the previous request. The
|
|
// token expires after 24 hours.
|
|
NextToken *string `locationName:"nextToken" min:"1" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DescribeLogStreamsOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DescribeLogStreamsOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DescribeMetricFiltersInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// Will only return metric filters that match the provided filterNamePrefix.
|
|
// If you don't specify a value, no prefix filter is applied.
|
|
FilterNamePrefix *string `locationName:"filterNamePrefix" min:"1" type:"string"`
|
|
|
|
// The maximum number of items returned in the response. If you don't specify
|
|
// a value, the request would return up to 50 items.
|
|
Limit *int64 `locationName:"limit" min:"1" type:"integer"`
|
|
|
|
// The log group name for which metric filters are to be listed.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string" required:"true"`
|
|
|
|
// A string token used for pagination that points to the next page of results.
|
|
// It must be a value obtained from the response of the previous DescribeMetricFilters
|
|
// request.
|
|
NextToken *string `locationName:"nextToken" min:"1" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DescribeMetricFiltersInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DescribeMetricFiltersInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DescribeMetricFiltersOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
MetricFilters []*MetricFilter `locationName:"metricFilters" type:"list"`
|
|
|
|
// A string token used for pagination that points to the next page of results.
|
|
// It must be a value obtained from the response of the previous request. The
|
|
// token expires after 24 hours.
|
|
NextToken *string `locationName:"nextToken" min:"1" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DescribeMetricFiltersOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DescribeMetricFiltersOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DescribeSubscriptionFiltersInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// Will only return subscription filters that match the provided filterNamePrefix.
|
|
// If you don't specify a value, no prefix filter is applied.
|
|
FilterNamePrefix *string `locationName:"filterNamePrefix" min:"1" type:"string"`
|
|
|
|
// The maximum number of results to return.
|
|
Limit *int64 `locationName:"limit" min:"1" type:"integer"`
|
|
|
|
// The log group name for which subscription filters are to be listed.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string" required:"true"`
|
|
|
|
// A string token used for pagination that points to the next page of results.
|
|
// It must be a value obtained from the response of the previous request. The
|
|
// token expires after 24 hours.
|
|
NextToken *string `locationName:"nextToken" min:"1" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DescribeSubscriptionFiltersInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DescribeSubscriptionFiltersInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type DescribeSubscriptionFiltersOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A string token used for pagination that points to the next page of results.
|
|
// It must be a value obtained from the response of the previous request. The
|
|
// token expires after 24 hours.
|
|
NextToken *string `locationName:"nextToken" min:"1" type:"string"`
|
|
|
|
SubscriptionFilters []*SubscriptionFilter `locationName:"subscriptionFilters" type:"list"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s DescribeSubscriptionFiltersOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s DescribeSubscriptionFiltersOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
// A cross account destination that is the recipient of subscription log events.
|
|
type Destination struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// An IAM policy document that governs which AWS accounts can create subscription
|
|
// filters against this destination.
|
|
AccessPolicy *string `locationName:"accessPolicy" min:"1" type:"string"`
|
|
|
|
// ARN of this destination.
|
|
Arn *string `locationName:"arn" type:"string"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC specifying when this destination was created.
|
|
CreationTime *int64 `locationName:"creationTime" type:"long"`
|
|
|
|
// Name of the destination.
|
|
DestinationName *string `locationName:"destinationName" min:"1" type:"string"`
|
|
|
|
// A role for impersonation for delivering log events to the target.
|
|
RoleArn *string `locationName:"roleArn" min:"1" type:"string"`
|
|
|
|
// ARN of the physical target where the log events will be delivered (eg. ARN
|
|
// of a Kinesis stream).
|
|
TargetArn *string `locationName:"targetArn" min:"1" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s Destination) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s Destination) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
// Represents an export task.
|
|
type ExportTask struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// Name of Amazon S3 bucket to which the log data was exported.
|
|
Destination *string `locationName:"destination" min:"1" type:"string"`
|
|
|
|
// Prefix that was used as the start of Amazon S3 key for every object exported.
|
|
DestinationPrefix *string `locationName:"destinationPrefix" type:"string"`
|
|
|
|
// Execution info about the export task.
|
|
ExecutionInfo *ExportTaskExecutionInfo `locationName:"executionInfo" type:"structure"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC. Events with a timestamp prior to this time are not exported.
|
|
From *int64 `locationName:"from" type:"long"`
|
|
|
|
// The name of the log group from which logs data was exported.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string"`
|
|
|
|
// Status of the export task.
|
|
Status *ExportTaskStatus `locationName:"status" type:"structure"`
|
|
|
|
// Id of the export task.
|
|
TaskId *string `locationName:"taskId" min:"1" type:"string"`
|
|
|
|
// The name of the export task.
|
|
TaskName *string `locationName:"taskName" min:"1" type:"string"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC. Events with a timestamp later than this time are not exported.
|
|
To *int64 `locationName:"to" type:"long"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s ExportTask) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s ExportTask) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
// Represents the status of an export task.
|
|
type ExportTaskExecutionInfo struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A point in time when the export task got completed.
|
|
CompletionTime *int64 `locationName:"completionTime" type:"long"`
|
|
|
|
// A point in time when the export task got created.
|
|
CreationTime *int64 `locationName:"creationTime" type:"long"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s ExportTaskExecutionInfo) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s ExportTaskExecutionInfo) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
// Represents the status of an export task.
|
|
type ExportTaskStatus struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// Status code of the export task.
|
|
Code *string `locationName:"code" type:"string" enum:"ExportTaskStatusCode"`
|
|
|
|
// Status message related to the code.
|
|
Message *string `locationName:"message" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s ExportTaskStatus) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s ExportTaskStatus) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type FilterLogEventsInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC. If provided, events with a timestamp later than this time are
|
|
// not returned.
|
|
EndTime *int64 `locationName:"endTime" type:"long"`
|
|
|
|
// A valid CloudWatch Logs filter pattern to use for filtering the response.
|
|
// If not provided, all the events are matched.
|
|
FilterPattern *string `locationName:"filterPattern" type:"string"`
|
|
|
|
// If provided, the API will make a best effort to provide responses that contain
|
|
// events from multiple log streams within the log group interleaved in a single
|
|
// response. If not provided, all the matched log events in the first log stream
|
|
// will be searched first, then those in the next log stream, etc.
|
|
Interleaved *bool `locationName:"interleaved" type:"boolean"`
|
|
|
|
// The maximum number of events to return in a page of results. Default is 10,000
|
|
// events.
|
|
Limit *int64 `locationName:"limit" min:"1" type:"integer"`
|
|
|
|
// The name of the log group to query.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string" required:"true"`
|
|
|
|
// Optional list of log stream names within the specified log group to search.
|
|
// Defaults to all the log streams in the log group.
|
|
LogStreamNames []*string `locationName:"logStreamNames" min:"1" type:"list"`
|
|
|
|
// A pagination token obtained from a FilterLogEvents response to continue paginating
|
|
// the FilterLogEvents results. This token is omitted from the response when
|
|
// there are no other events to display.
|
|
NextToken *string `locationName:"nextToken" min:"1" type:"string"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC. If provided, events with a timestamp prior to this time are
|
|
// not returned.
|
|
StartTime *int64 `locationName:"startTime" type:"long"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s FilterLogEventsInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s FilterLogEventsInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type FilterLogEventsOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A list of FilteredLogEvent objects representing the matched events from the
|
|
// request.
|
|
Events []*FilteredLogEvent `locationName:"events" type:"list"`
|
|
|
|
// A pagination token obtained from a FilterLogEvents response to continue paginating
|
|
// the FilterLogEvents results. This token is omitted from the response when
|
|
// there are no other events to display.
|
|
NextToken *string `locationName:"nextToken" min:"1" type:"string"`
|
|
|
|
// A list of SearchedLogStream objects indicating which log streams have been
|
|
// searched in this request and whether each has been searched completely or
|
|
// still has more to be paginated.
|
|
SearchedLogStreams []*SearchedLogStream `locationName:"searchedLogStreams" type:"list"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s FilterLogEventsOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s FilterLogEventsOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
// Represents a matched event from a FilterLogEvents request.
|
|
type FilteredLogEvent struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A unique identifier for this event.
|
|
EventId *string `locationName:"eventId" type:"string"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC.
|
|
IngestionTime *int64 `locationName:"ingestionTime" type:"long"`
|
|
|
|
// The name of the log stream this event belongs to.
|
|
LogStreamName *string `locationName:"logStreamName" min:"1" type:"string"`
|
|
|
|
// The data contained in the log event.
|
|
Message *string `locationName:"message" min:"1" type:"string"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC.
|
|
Timestamp *int64 `locationName:"timestamp" type:"long"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s FilteredLogEvent) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s FilteredLogEvent) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type GetLogEventsInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC.
|
|
EndTime *int64 `locationName:"endTime" type:"long"`
|
|
|
|
// The maximum number of log events returned in the response. If you don't specify
|
|
// a value, the request would return as many log events as can fit in a response
|
|
// size of 1MB, up to 10,000 log events.
|
|
Limit *int64 `locationName:"limit" min:"1" type:"integer"`
|
|
|
|
// The name of the log group to query.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string" required:"true"`
|
|
|
|
// The name of the log stream to query.
|
|
LogStreamName *string `locationName:"logStreamName" min:"1" type:"string" required:"true"`
|
|
|
|
// A string token used for pagination that points to the next page of results.
|
|
// It must be a value obtained from the nextForwardToken or nextBackwardToken
|
|
// fields in the response of the previous GetLogEvents request.
|
|
NextToken *string `locationName:"nextToken" min:"1" type:"string"`
|
|
|
|
// If set to true, the earliest log events would be returned first. The default
|
|
// is false (the latest log events are returned first).
|
|
StartFromHead *bool `locationName:"startFromHead" type:"boolean"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC.
|
|
StartTime *int64 `locationName:"startTime" type:"long"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s GetLogEventsInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s GetLogEventsInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type GetLogEventsOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
Events []*OutputLogEvent `locationName:"events" type:"list"`
|
|
|
|
// A string token used for pagination that points to the next page of results.
|
|
// It must be a value obtained from the response of the previous request. The
|
|
// token expires after 24 hours.
|
|
NextBackwardToken *string `locationName:"nextBackwardToken" min:"1" type:"string"`
|
|
|
|
// A string token used for pagination that points to the next page of results.
|
|
// It must be a value obtained from the response of the previous request. The
|
|
// token expires after 24 hours.
|
|
NextForwardToken *string `locationName:"nextForwardToken" min:"1" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s GetLogEventsOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s GetLogEventsOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
// A log event is a record of some activity that was recorded by the application
|
|
// or resource being monitored. The log event record that CloudWatch Logs understands
|
|
// contains two properties: the timestamp of when the event occurred, and the
|
|
// raw event message.
|
|
type InputLogEvent struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
Message *string `locationName:"message" min:"1" type:"string" required:"true"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC.
|
|
Timestamp *int64 `locationName:"timestamp" type:"long" required:"true"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s InputLogEvent) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s InputLogEvent) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type LogGroup struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
Arn *string `locationName:"arn" type:"string"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC.
|
|
CreationTime *int64 `locationName:"creationTime" type:"long"`
|
|
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string"`
|
|
|
|
// The number of metric filters associated with the log group.
|
|
MetricFilterCount *int64 `locationName:"metricFilterCount" type:"integer"`
|
|
|
|
// Specifies the number of days you want to retain 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, 3653.
|
|
RetentionInDays *int64 `locationName:"retentionInDays" type:"integer"`
|
|
|
|
StoredBytes *int64 `locationName:"storedBytes" type:"long"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s LogGroup) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s LogGroup) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
// A log stream is sequence of log events from a single emitter of logs.
|
|
type LogStream struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
Arn *string `locationName:"arn" type:"string"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC.
|
|
CreationTime *int64 `locationName:"creationTime" type:"long"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC.
|
|
FirstEventTimestamp *int64 `locationName:"firstEventTimestamp" type:"long"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC.
|
|
LastEventTimestamp *int64 `locationName:"lastEventTimestamp" type:"long"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC.
|
|
LastIngestionTime *int64 `locationName:"lastIngestionTime" type:"long"`
|
|
|
|
LogStreamName *string `locationName:"logStreamName" min:"1" type:"string"`
|
|
|
|
StoredBytes *int64 `locationName:"storedBytes" type:"long"`
|
|
|
|
// A string token used for making PutLogEvents requests. A sequenceToken can
|
|
// only be used once, and PutLogEvents requests must include the sequenceToken
|
|
// obtained from the response of the previous request.
|
|
UploadSequenceToken *string `locationName:"uploadSequenceToken" min:"1" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s LogStream) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s LogStream) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
// Metric filters can be used to express how CloudWatch Logs would extract metric
|
|
// observations from ingested log events and transform them to metric data in
|
|
// a CloudWatch metric.
|
|
type MetricFilter struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC.
|
|
CreationTime *int64 `locationName:"creationTime" type:"long"`
|
|
|
|
// A name for a metric or subscription filter.
|
|
FilterName *string `locationName:"filterName" min:"1" type:"string"`
|
|
|
|
// A symbolic description of how CloudWatch Logs should interpret the data in
|
|
// each log event. For example, a log event may contain timestamps, IP addresses,
|
|
// strings, and so on. You use the filter pattern to specify what to look for
|
|
// in the log event message.
|
|
FilterPattern *string `locationName:"filterPattern" type:"string"`
|
|
|
|
MetricTransformations []*MetricTransformation `locationName:"metricTransformations" min:"1" type:"list"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s MetricFilter) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s MetricFilter) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type MetricFilterMatchRecord struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
EventMessage *string `locationName:"eventMessage" min:"1" type:"string"`
|
|
|
|
EventNumber *int64 `locationName:"eventNumber" type:"long"`
|
|
|
|
ExtractedValues map[string]*string `locationName:"extractedValues" type:"map"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s MetricFilterMatchRecord) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s MetricFilterMatchRecord) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type MetricTransformation struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// The name of the CloudWatch metric to which the monitored log information
|
|
// should be published. For example, you may publish to a metric called ErrorCount.
|
|
MetricName *string `locationName:"metricName" type:"string" required:"true"`
|
|
|
|
// The destination namespace of the new CloudWatch metric.
|
|
MetricNamespace *string `locationName:"metricNamespace" type:"string" required:"true"`
|
|
|
|
// What to publish to the metric. For example, if you're counting the occurrences
|
|
// of a particular term like "Error", the value will be "1" for each occurrence.
|
|
// If you're counting the bytes transferred the published value will be the
|
|
// value in the log event.
|
|
MetricValue *string `locationName:"metricValue" type:"string" required:"true"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s MetricTransformation) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s MetricTransformation) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type OutputLogEvent struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC.
|
|
IngestionTime *int64 `locationName:"ingestionTime" type:"long"`
|
|
|
|
Message *string `locationName:"message" min:"1" type:"string"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC.
|
|
Timestamp *int64 `locationName:"timestamp" type:"long"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s OutputLogEvent) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s OutputLogEvent) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type PutDestinationInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A name for the destination.
|
|
DestinationName *string `locationName:"destinationName" min:"1" type:"string" required:"true"`
|
|
|
|
// The ARN of an IAM role that grants CloudWatch Logs permissions to do Amazon
|
|
// Kinesis PutRecord requests on the desitnation stream.
|
|
RoleArn *string `locationName:"roleArn" min:"1" type:"string" required:"true"`
|
|
|
|
// The ARN of an Amazon Kinesis stream to deliver matching log events to.
|
|
TargetArn *string `locationName:"targetArn" min:"1" type:"string" required:"true"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s PutDestinationInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s PutDestinationInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type PutDestinationOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A cross account destination that is the recipient of subscription log events.
|
|
Destination *Destination `locationName:"destination" type:"structure"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s PutDestinationOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s PutDestinationOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type PutDestinationPolicyInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// An IAM policy document that authorizes cross-account users to deliver their
|
|
// log events to associated destination.
|
|
AccessPolicy *string `locationName:"accessPolicy" min:"1" type:"string" required:"true"`
|
|
|
|
// A name for an existing destination.
|
|
DestinationName *string `locationName:"destinationName" min:"1" type:"string" required:"true"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s PutDestinationPolicyInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s PutDestinationPolicyInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type PutDestinationPolicyOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s PutDestinationPolicyOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s PutDestinationPolicyOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type PutLogEventsInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A list of log events belonging to a log stream.
|
|
LogEvents []*InputLogEvent `locationName:"logEvents" min:"1" type:"list" required:"true"`
|
|
|
|
// The name of the log group to put log events to.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string" required:"true"`
|
|
|
|
// The name of the log stream to put log events to.
|
|
LogStreamName *string `locationName:"logStreamName" min:"1" type:"string" required:"true"`
|
|
|
|
// A string token that must be obtained from the response of the previous PutLogEvents
|
|
// request.
|
|
SequenceToken *string `locationName:"sequenceToken" min:"1" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s PutLogEventsInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s PutLogEventsInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type PutLogEventsOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A string token used for making PutLogEvents requests. A sequenceToken can
|
|
// only be used once, and PutLogEvents requests must include the sequenceToken
|
|
// obtained from the response of the previous request.
|
|
NextSequenceToken *string `locationName:"nextSequenceToken" min:"1" type:"string"`
|
|
|
|
RejectedLogEventsInfo *RejectedLogEventsInfo `locationName:"rejectedLogEventsInfo" type:"structure"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s PutLogEventsOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s PutLogEventsOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type PutMetricFilterInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A name for the metric filter.
|
|
FilterName *string `locationName:"filterName" min:"1" type:"string" required:"true"`
|
|
|
|
// A valid CloudWatch Logs filter pattern for extracting metric data out of
|
|
// ingested log events.
|
|
FilterPattern *string `locationName:"filterPattern" type:"string" required:"true"`
|
|
|
|
// The name of the log group to associate the metric filter with.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string" required:"true"`
|
|
|
|
// A collection of information needed to define how metric data gets emitted.
|
|
MetricTransformations []*MetricTransformation `locationName:"metricTransformations" min:"1" type:"list" required:"true"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s PutMetricFilterInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s PutMetricFilterInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type PutMetricFilterOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s PutMetricFilterOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s PutMetricFilterOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type PutRetentionPolicyInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// The name of the log group to associate the retention policy with.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string" required:"true"`
|
|
|
|
// Specifies the number of days you want to retain 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, 3653.
|
|
RetentionInDays *int64 `locationName:"retentionInDays" type:"integer" required:"true"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s PutRetentionPolicyInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s PutRetentionPolicyInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type PutRetentionPolicyOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s PutRetentionPolicyOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s PutRetentionPolicyOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type PutSubscriptionFilterInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// 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 (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.
|
|
DestinationArn *string `locationName:"destinationArn" min:"1" type:"string" required:"true"`
|
|
|
|
// A name for the subscription filter.
|
|
FilterName *string `locationName:"filterName" min:"1" type:"string" required:"true"`
|
|
|
|
// A valid CloudWatch Logs filter pattern for subscribing to a filtered stream
|
|
// of log events.
|
|
FilterPattern *string `locationName:"filterPattern" type:"string" required:"true"`
|
|
|
|
// The name of the log group to associate the subscription filter with.
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string" required:"true"`
|
|
|
|
// 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 (used via an ARN
|
|
// of Destination) for cross-account delivery.
|
|
RoleArn *string `locationName:"roleArn" min:"1" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s PutSubscriptionFilterInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s PutSubscriptionFilterInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type PutSubscriptionFilterOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s PutSubscriptionFilterOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s PutSubscriptionFilterOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type RejectedLogEventsInfo struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
ExpiredLogEventEndIndex *int64 `locationName:"expiredLogEventEndIndex" type:"integer"`
|
|
|
|
TooNewLogEventStartIndex *int64 `locationName:"tooNewLogEventStartIndex" type:"integer"`
|
|
|
|
TooOldLogEventEndIndex *int64 `locationName:"tooOldLogEventEndIndex" type:"integer"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s RejectedLogEventsInfo) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s RejectedLogEventsInfo) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
// An object indicating the search status of a log stream in a FilterLogEvents
|
|
// request.
|
|
type SearchedLogStream struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// The name of the log stream.
|
|
LogStreamName *string `locationName:"logStreamName" min:"1" type:"string"`
|
|
|
|
// Indicates whether all the events in this log stream were searched or more
|
|
// data exists to search by paginating further.
|
|
SearchedCompletely *bool `locationName:"searchedCompletely" type:"boolean"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s SearchedLogStream) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s SearchedLogStream) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type SubscriptionFilter struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A point in time expressed as the number of milliseconds since Jan 1, 1970
|
|
// 00:00:00 UTC.
|
|
CreationTime *int64 `locationName:"creationTime" type:"long"`
|
|
|
|
DestinationArn *string `locationName:"destinationArn" min:"1" type:"string"`
|
|
|
|
// A name for a metric or subscription filter.
|
|
FilterName *string `locationName:"filterName" min:"1" type:"string"`
|
|
|
|
// A symbolic description of how CloudWatch Logs should interpret the data in
|
|
// each log event. For example, a log event may contain timestamps, IP addresses,
|
|
// strings, and so on. You use the filter pattern to specify what to look for
|
|
// in the log event message.
|
|
FilterPattern *string `locationName:"filterPattern" type:"string"`
|
|
|
|
LogGroupName *string `locationName:"logGroupName" min:"1" type:"string"`
|
|
|
|
RoleArn *string `locationName:"roleArn" min:"1" type:"string"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s SubscriptionFilter) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s SubscriptionFilter) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type TestMetricFilterInput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
// A symbolic description of how CloudWatch Logs should interpret the data in
|
|
// each log event. For example, a log event may contain timestamps, IP addresses,
|
|
// strings, and so on. You use the filter pattern to specify what to look for
|
|
// in the log event message.
|
|
FilterPattern *string `locationName:"filterPattern" type:"string" required:"true"`
|
|
|
|
// A list of log event messages to test.
|
|
LogEventMessages []*string `locationName:"logEventMessages" min:"1" type:"list" required:"true"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s TestMetricFilterInput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s TestMetricFilterInput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
type TestMetricFilterOutput struct {
|
|
_ struct{} `type:"structure"`
|
|
|
|
Matches []*MetricFilterMatchRecord `locationName:"matches" type:"list"`
|
|
}
|
|
|
|
// String returns the string representation
|
|
func (s TestMetricFilterOutput) String() string {
|
|
return awsutil.Prettify(s)
|
|
}
|
|
|
|
// GoString returns the string representation
|
|
func (s TestMetricFilterOutput) GoString() string {
|
|
return s.String()
|
|
}
|
|
|
|
const (
|
|
// @enum ExportTaskStatusCode
|
|
ExportTaskStatusCodeCancelled = "CANCELLED"
|
|
// @enum ExportTaskStatusCode
|
|
ExportTaskStatusCodeCompleted = "COMPLETED"
|
|
// @enum ExportTaskStatusCode
|
|
ExportTaskStatusCodeFailed = "FAILED"
|
|
// @enum ExportTaskStatusCode
|
|
ExportTaskStatusCodePending = "PENDING"
|
|
// @enum ExportTaskStatusCode
|
|
ExportTaskStatusCodePendingCancel = "PENDING_CANCEL"
|
|
// @enum ExportTaskStatusCode
|
|
ExportTaskStatusCodeRunning = "RUNNING"
|
|
)
|
|
|
|
const (
|
|
// @enum OrderBy
|
|
OrderByLogStreamName = "LogStreamName"
|
|
// @enum OrderBy
|
|
OrderByLastEventTime = "LastEventTime"
|
|
)
|