Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type DataAlreadyAcceptedException

type DataAlreadyAcceptedException struct {
	Message *string

	ExpectedSequenceToken *string
}

    The event was already logged.

    func (*DataAlreadyAcceptedException) Error

    func (*DataAlreadyAcceptedException) ErrorCode

    func (e *DataAlreadyAcceptedException) ErrorCode() string

    func (*DataAlreadyAcceptedException) ErrorFault

    func (*DataAlreadyAcceptedException) ErrorMessage

    func (e *DataAlreadyAcceptedException) ErrorMessage() string

    type Destination

    type Destination struct {
    
    	// An IAM policy document that governs which AWS accounts can create subscription
    	// filters against this destination.
    	AccessPolicy *string
    
    	// The ARN of this destination.
    	Arn *string
    
    	// The creation time of the destination, expressed as the number of milliseconds
    	// after Jan 1, 1970 00:00:00 UTC.
    	CreationTime *int64
    
    	// The name of the destination.
    	DestinationName *string
    
    	// A role for impersonation, used when delivering log events to the target.
    	RoleArn *string
    
    	// The Amazon Resource Name (ARN) of the physical target where the log events are
    	// delivered (for example, a Kinesis stream).
    	TargetArn *string
    }

      Represents a cross-account destination that receives subscription log events.

      type Distribution

      type Distribution string
      const (
      	DistributionRandom      Distribution = "Random"
      	DistributionByLogStream Distribution = "ByLogStream"
      )

        Enum values for Distribution

        func (Distribution) Values

        func (Distribution) Values() []Distribution

          Values returns all known values for Distribution. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

          type ExportTask

          type ExportTask struct {
          
          	// The name of the S3 bucket to which the log data was exported.
          	Destination *string
          
          	// The prefix that was used as the start of Amazon S3 key for every object
          	// exported.
          	DestinationPrefix *string
          
          	// Execution information about the export task.
          	ExecutionInfo *ExportTaskExecutionInfo
          
          	// The start time, expressed as the number of milliseconds after Jan 1, 1970
          	// 00:00:00 UTC. Events with a timestamp before this time are not exported.
          	From *int64
          
          	// The name of the log group from which logs data was exported.
          	LogGroupName *string
          
          	// The status of the export task.
          	Status *ExportTaskStatus
          
          	// The ID of the export task.
          	TaskId *string
          
          	// The name of the export task.
          	TaskName *string
          
          	// The end time, expressed as the number of milliseconds after Jan 1, 1970 00:00:00
          	// UTC. Events with a timestamp later than this time are not exported.
          	To *int64
          }

            Represents an export task.

            type ExportTaskExecutionInfo

            type ExportTaskExecutionInfo struct {
            
            	// The completion time of the export task, expressed as the number of milliseconds
            	// after Jan 1, 1970 00:00:00 UTC.
            	CompletionTime *int64
            
            	// The creation time of the export task, expressed as the number of milliseconds
            	// after Jan 1, 1970 00:00:00 UTC.
            	CreationTime *int64
            }

              Represents the status of an export task.

              type ExportTaskStatus

              type ExportTaskStatus struct {
              
              	// The status code of the export task.
              	Code ExportTaskStatusCode
              
              	// The status message related to the status code.
              	Message *string
              }

                Represents the status of an export task.

                type ExportTaskStatusCode

                type ExportTaskStatusCode string
                const (
                	ExportTaskStatusCodeCancelled     ExportTaskStatusCode = "CANCELLED"
                	ExportTaskStatusCodeCompleted     ExportTaskStatusCode = "COMPLETED"
                	ExportTaskStatusCodeFailed        ExportTaskStatusCode = "FAILED"
                	ExportTaskStatusCodePending       ExportTaskStatusCode = "PENDING"
                	ExportTaskStatusCodePendingCancel ExportTaskStatusCode = "PENDING_CANCEL"
                	ExportTaskStatusCodeRunning       ExportTaskStatusCode = "RUNNING"
                )

                  Enum values for ExportTaskStatusCode

                  func (ExportTaskStatusCode) Values

                    Values returns all known values for ExportTaskStatusCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                    type FilteredLogEvent

                    type FilteredLogEvent struct {
                    
                    	// The ID of the event.
                    	EventId *string
                    
                    	// The time the event was ingested, expressed as the number of milliseconds after
                    	// Jan 1, 1970 00:00:00 UTC.
                    	IngestionTime *int64
                    
                    	// The name of the log stream to which this event belongs.
                    	LogStreamName *string
                    
                    	// The data contained in the log event.
                    	Message *string
                    
                    	// The time the event occurred, expressed as the number of milliseconds after Jan
                    	// 1, 1970 00:00:00 UTC.
                    	Timestamp *int64
                    }

                      Represents a matched event.

                      type InputLogEvent

                      type InputLogEvent struct {
                      
                      	// The raw event message.
                      	//
                      	// This member is required.
                      	Message *string
                      
                      	// The time the event occurred, expressed as the number of milliseconds after Jan
                      	// 1, 1970 00:00:00 UTC.
                      	//
                      	// This member is required.
                      	Timestamp *int64
                      }

                        Represents a log event, which is a record of activity that was recorded by the application or resource being monitored.

                        type InvalidOperationException

                        type InvalidOperationException struct {
                        	Message *string
                        }

                          The operation is not valid on the specified resource.

                          func (*InvalidOperationException) Error

                          func (e *InvalidOperationException) Error() string

                          func (*InvalidOperationException) ErrorCode

                          func (e *InvalidOperationException) ErrorCode() string

                          func (*InvalidOperationException) ErrorFault

                          func (*InvalidOperationException) ErrorMessage

                          func (e *InvalidOperationException) ErrorMessage() string

                          type InvalidParameterException

                          type InvalidParameterException struct {
                          	Message *string
                          }

                            A parameter is specified incorrectly.

                            func (*InvalidParameterException) Error

                            func (e *InvalidParameterException) Error() string

                            func (*InvalidParameterException) ErrorCode

                            func (e *InvalidParameterException) ErrorCode() string

                            func (*InvalidParameterException) ErrorFault

                            func (*InvalidParameterException) ErrorMessage

                            func (e *InvalidParameterException) ErrorMessage() string

                            type InvalidSequenceTokenException

                            type InvalidSequenceTokenException struct {
                            	Message *string
                            
                            	ExpectedSequenceToken *string
                            }

                              The sequence token is not valid. You can get the correct sequence token in the expectedSequenceToken field in the InvalidSequenceTokenException message.

                              func (*InvalidSequenceTokenException) Error

                              func (*InvalidSequenceTokenException) ErrorCode

                              func (e *InvalidSequenceTokenException) ErrorCode() string

                              func (*InvalidSequenceTokenException) ErrorFault

                              func (*InvalidSequenceTokenException) ErrorMessage

                              func (e *InvalidSequenceTokenException) ErrorMessage() string

                              type LimitExceededException

                              type LimitExceededException struct {
                              	Message *string
                              }

                                You have reached the maximum number of resources that can be created.

                                func (*LimitExceededException) Error

                                func (e *LimitExceededException) Error() string

                                func (*LimitExceededException) ErrorCode

                                func (e *LimitExceededException) ErrorCode() string

                                func (*LimitExceededException) ErrorFault

                                func (e *LimitExceededException) ErrorFault() smithy.ErrorFault

                                func (*LimitExceededException) ErrorMessage

                                func (e *LimitExceededException) ErrorMessage() string

                                type LogGroup

                                type LogGroup struct {
                                
                                	// The Amazon Resource Name (ARN) of the log group.
                                	Arn *string
                                
                                	// The creation time of the log group, expressed as the number of milliseconds
                                	// after Jan 1, 1970 00:00:00 UTC.
                                	CreationTime *int64
                                
                                	// The Amazon Resource Name (ARN) of the CMK to use when encrypting log data.
                                	KmsKeyId *string
                                
                                	// The name of the log group.
                                	LogGroupName *string
                                
                                	// The number of metric filters.
                                	MetricFilterCount *int32
                                
                                	// The number of days to retain the log events in the specified log group. Possible
                                	// values are: 1, 3, 5, 7, 14, 30, 60, 90, 120, 150, 180, 365, 400, 545, 731, 1827,
                                	// and 3653. If you omit retentionInDays in a PutRetentionPolicy operation, the
                                	// events in the log group are always retained and never expire.
                                	RetentionInDays *int32
                                
                                	// The number of bytes stored.
                                	StoredBytes *int64
                                }

                                  Represents a log group.

                                  type LogGroupField

                                  type LogGroupField struct {
                                  
                                  	// The name of a log field.
                                  	Name *string
                                  
                                  	// The percentage of log events queried that contained the field.
                                  	Percent int32
                                  }

                                    The fields contained in log events found by a GetLogGroupFields operation, along with the percentage of queried log events in which each field appears.

                                    type LogStream

                                    type LogStream struct {
                                    
                                    	// The Amazon Resource Name (ARN) of the log stream.
                                    	Arn *string
                                    
                                    	// The creation time of the stream, expressed as the number of milliseconds after
                                    	// Jan 1, 1970 00:00:00 UTC.
                                    	CreationTime *int64
                                    
                                    	// The time of the first event, expressed as the number of milliseconds after Jan
                                    	// 1, 1970 00:00:00 UTC.
                                    	FirstEventTimestamp *int64
                                    
                                    	// The time of the most recent log event in the log stream in CloudWatch Logs. This
                                    	// number is expressed as the number of milliseconds after Jan 1, 1970 00:00:00
                                    	// UTC. The lastEventTime value updates on an eventual consistency basis. It
                                    	// typically updates in less than an hour from ingestion, but in rare situations
                                    	// might take longer.
                                    	LastEventTimestamp *int64
                                    
                                    	// The ingestion time, expressed as the number of milliseconds after Jan 1, 1970
                                    	// 00:00:00 UTC.
                                    	LastIngestionTime *int64
                                    
                                    	// The name of the log stream.
                                    	LogStreamName *string
                                    
                                    	// The number of bytes stored. Important: On June 17, 2019, this parameter was
                                    	// deprecated for log streams, and is always reported as zero. This change applies
                                    	// only to log streams. The storedBytes parameter for log groups is not affected.
                                    	//
                                    	// Deprecated: Starting on June 17, 2019, this parameter will be deprecated for log
                                    	// streams, and will be reported as zero. This change applies only to log streams.
                                    	// The storedBytes parameter for log groups is not affected.
                                    	StoredBytes *int64
                                    
                                    	// The sequence token.
                                    	UploadSequenceToken *string
                                    }

                                      Represents a log stream, which is a sequence of log events from a single emitter of logs.

                                      type MalformedQueryException

                                      type MalformedQueryException struct {
                                      	Message *string
                                      
                                      	QueryCompileError *QueryCompileError
                                      }

                                        The query string is not valid. Details about this error are displayed in a QueryCompileError object. For more information, see QueryCompileError (https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_QueryCompileError.html). For more information about valid query syntax, see CloudWatch Logs Insights Query Syntax (https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html).

                                        func (*MalformedQueryException) Error

                                        func (e *MalformedQueryException) Error() string

                                        func (*MalformedQueryException) ErrorCode

                                        func (e *MalformedQueryException) ErrorCode() string

                                        func (*MalformedQueryException) ErrorFault

                                        func (e *MalformedQueryException) ErrorFault() smithy.ErrorFault

                                        func (*MalformedQueryException) ErrorMessage

                                        func (e *MalformedQueryException) ErrorMessage() string

                                        type MetricFilter

                                        type MetricFilter struct {
                                        
                                        	// The creation time of the metric filter, expressed as the number of milliseconds
                                        	// after Jan 1, 1970 00:00:00 UTC.
                                        	CreationTime *int64
                                        
                                        	// The name of the metric filter.
                                        	FilterName *string
                                        
                                        	// A symbolic description of how CloudWatch Logs should interpret the data in each
                                        	// log event. For example, a log event can contain timestamps, IP addresses,
                                        	// strings, and so on. You use the filter pattern to specify what to look for in
                                        	// the log event message.
                                        	FilterPattern *string
                                        
                                        	// The name of the log group.
                                        	LogGroupName *string
                                        
                                        	// The metric transformations.
                                        	MetricTransformations []MetricTransformation
                                        }

                                          Metric filters express how CloudWatch Logs would extract metric observations from ingested log events and transform them into metric data in a CloudWatch metric.

                                          type MetricFilterMatchRecord

                                          type MetricFilterMatchRecord struct {
                                          
                                          	// The raw event data.
                                          	EventMessage *string
                                          
                                          	// The event number.
                                          	EventNumber int64
                                          
                                          	// The values extracted from the event data by the filter.
                                          	ExtractedValues map[string]string
                                          }

                                            Represents a matched event.

                                            type MetricTransformation

                                            type MetricTransformation struct {
                                            
                                            	// The name of the CloudWatch metric.
                                            	//
                                            	// This member is required.
                                            	MetricName *string
                                            
                                            	// A custom namespace to contain your metric in CloudWatch. Use namespaces to group
                                            	// together metrics that are similar. For more information, see Namespaces
                                            	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html#Namespace).
                                            	//
                                            	// This member is required.
                                            	MetricNamespace *string
                                            
                                            	// The value to publish to the CloudWatch metric when a filter pattern matches a
                                            	// log event.
                                            	//
                                            	// This member is required.
                                            	MetricValue *string
                                            
                                            	// (Optional) The value to emit when a filter pattern does not match a log event.
                                            	// This value can be null.
                                            	DefaultValue *float64
                                            }

                                              Indicates how to transform ingested log events to metric data in a CloudWatch metric.

                                              type OperationAbortedException

                                              type OperationAbortedException struct {
                                              	Message *string
                                              }

                                                Multiple requests to update the same resource were in conflict.

                                                func (*OperationAbortedException) Error

                                                func (e *OperationAbortedException) Error() string

                                                func (*OperationAbortedException) ErrorCode

                                                func (e *OperationAbortedException) ErrorCode() string

                                                func (*OperationAbortedException) ErrorFault

                                                func (*OperationAbortedException) ErrorMessage

                                                func (e *OperationAbortedException) ErrorMessage() string

                                                type OrderBy

                                                type OrderBy string
                                                const (
                                                	OrderByLogStreamName OrderBy = "LogStreamName"
                                                	OrderByLastEventTime OrderBy = "LastEventTime"
                                                )

                                                  Enum values for OrderBy

                                                  func (OrderBy) Values

                                                  func (OrderBy) Values() []OrderBy

                                                    Values returns all known values for OrderBy. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                    type OutputLogEvent

                                                    type OutputLogEvent struct {
                                                    
                                                    	// The time the event was ingested, expressed as the number of milliseconds after
                                                    	// Jan 1, 1970 00:00:00 UTC.
                                                    	IngestionTime *int64
                                                    
                                                    	// The data contained in the log event.
                                                    	Message *string
                                                    
                                                    	// The time the event occurred, expressed as the number of milliseconds after Jan
                                                    	// 1, 1970 00:00:00 UTC.
                                                    	Timestamp *int64
                                                    }

                                                      Represents a log event.

                                                      type QueryCompileError

                                                      type QueryCompileError struct {
                                                      
                                                      	// Reserved.
                                                      	Location *QueryCompileErrorLocation
                                                      
                                                      	// Reserved.
                                                      	Message *string
                                                      }

                                                        Reserved.

                                                        type QueryCompileErrorLocation

                                                        type QueryCompileErrorLocation struct {
                                                        
                                                        	// Reserved.
                                                        	EndCharOffset *int32
                                                        
                                                        	// Reserved.
                                                        	StartCharOffset *int32
                                                        }

                                                          Reserved.

                                                          type QueryDefinition

                                                          type QueryDefinition struct {
                                                          
                                                          	// The date that the query definition was most recently modified.
                                                          	LastModified *int64
                                                          
                                                          	// If this query definition contains a list of log groups that it is limited to,
                                                          	// that list appears here.
                                                          	LogGroupNames []string
                                                          
                                                          	// The name of the query definition.
                                                          	Name *string
                                                          
                                                          	// The unique ID of the query definition.
                                                          	QueryDefinitionId *string
                                                          
                                                          	// The query string to use for this definition. For more information, see
                                                          	// CloudWatch Logs Insights Query Syntax
                                                          	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html).
                                                          	QueryString *string
                                                          }

                                                            This structure contains details about a saved CloudWatch Logs Insights query definition.

                                                            type QueryInfo

                                                            type QueryInfo struct {
                                                            
                                                            	// The date and time that this query was created.
                                                            	CreateTime *int64
                                                            
                                                            	// The name of the log group scanned by this query.
                                                            	LogGroupName *string
                                                            
                                                            	// The unique ID number of this query.
                                                            	QueryId *string
                                                            
                                                            	// The query string used in this query.
                                                            	QueryString *string
                                                            
                                                            	// The status of this query. Possible values are Cancelled, Complete, Failed,
                                                            	// Running, Scheduled, and Unknown.
                                                            	Status QueryStatus
                                                            }

                                                              Information about one CloudWatch Logs Insights query that matches the request in a DescribeQueries operation.

                                                              type QueryStatistics

                                                              type QueryStatistics struct {
                                                              
                                                              	// The total number of bytes in the log events scanned during the query.
                                                              	BytesScanned float64
                                                              
                                                              	// The number of log events that matched the query string.
                                                              	RecordsMatched float64
                                                              
                                                              	// The total number of log events scanned during the query.
                                                              	RecordsScanned float64
                                                              }

                                                                Contains the number of log events scanned by the query, the number of log events that matched the query criteria, and the total number of bytes in the log events that were scanned.

                                                                type QueryStatus

                                                                type QueryStatus string
                                                                const (
                                                                	QueryStatusScheduled QueryStatus = "Scheduled"
                                                                	QueryStatusRunning   QueryStatus = "Running"
                                                                	QueryStatusComplete  QueryStatus = "Complete"
                                                                	QueryStatusFailed    QueryStatus = "Failed"
                                                                	QueryStatusCancelled QueryStatus = "Cancelled"
                                                                )

                                                                  Enum values for QueryStatus

                                                                  func (QueryStatus) Values

                                                                  func (QueryStatus) Values() []QueryStatus

                                                                    Values returns all known values for QueryStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                    type RejectedLogEventsInfo

                                                                    type RejectedLogEventsInfo struct {
                                                                    
                                                                    	// The expired log events.
                                                                    	ExpiredLogEventEndIndex *int32
                                                                    
                                                                    	// The log events that are too new.
                                                                    	TooNewLogEventStartIndex *int32
                                                                    
                                                                    	// The log events that are too old.
                                                                    	TooOldLogEventEndIndex *int32
                                                                    }

                                                                      Represents the rejected events.

                                                                      type ResourceAlreadyExistsException

                                                                      type ResourceAlreadyExistsException struct {
                                                                      	Message *string
                                                                      }

                                                                        The specified resource already exists.

                                                                        func (*ResourceAlreadyExistsException) Error

                                                                        func (*ResourceAlreadyExistsException) ErrorCode

                                                                        func (e *ResourceAlreadyExistsException) ErrorCode() string

                                                                        func (*ResourceAlreadyExistsException) ErrorFault

                                                                        func (*ResourceAlreadyExistsException) ErrorMessage

                                                                        func (e *ResourceAlreadyExistsException) ErrorMessage() string

                                                                        type ResourceNotFoundException

                                                                        type ResourceNotFoundException struct {
                                                                        	Message *string
                                                                        }

                                                                          The specified resource does not exist.

                                                                          func (*ResourceNotFoundException) Error

                                                                          func (e *ResourceNotFoundException) Error() string

                                                                          func (*ResourceNotFoundException) ErrorCode

                                                                          func (e *ResourceNotFoundException) ErrorCode() string

                                                                          func (*ResourceNotFoundException) ErrorFault

                                                                          func (*ResourceNotFoundException) ErrorMessage

                                                                          func (e *ResourceNotFoundException) ErrorMessage() string

                                                                          type ResourcePolicy

                                                                          type ResourcePolicy struct {
                                                                          
                                                                          	// Timestamp showing when this policy was last updated, expressed as the number of
                                                                          	// milliseconds after Jan 1, 1970 00:00:00 UTC.
                                                                          	LastUpdatedTime *int64
                                                                          
                                                                          	// The details of the policy.
                                                                          	PolicyDocument *string
                                                                          
                                                                          	// The name of the resource policy.
                                                                          	PolicyName *string
                                                                          }

                                                                            A policy enabling one or more entities to put logs to a log group in this account.

                                                                            type ResultField

                                                                            type ResultField struct {
                                                                            
                                                                            	// The log event field.
                                                                            	Field *string
                                                                            
                                                                            	// The value of this field.
                                                                            	Value *string
                                                                            }

                                                                              Contains one field from one log event returned by a CloudWatch Logs Insights query, along with the value of that field. For more information about the fields that are generated by CloudWatch logs, see Supported Logs and Discovered Fields (https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData-discoverable-fields.html).

                                                                              type SearchedLogStream

                                                                              type SearchedLogStream struct {
                                                                              
                                                                              	// The name of the log stream.
                                                                              	LogStreamName *string
                                                                              
                                                                              	// Indicates whether all the events in this log stream were searched.
                                                                              	SearchedCompletely *bool
                                                                              }

                                                                                Represents the search status of a log stream.

                                                                                type ServiceUnavailableException

                                                                                type ServiceUnavailableException struct {
                                                                                	Message *string
                                                                                }

                                                                                  The service cannot complete the request.

                                                                                  func (*ServiceUnavailableException) Error

                                                                                  func (*ServiceUnavailableException) ErrorCode

                                                                                  func (e *ServiceUnavailableException) ErrorCode() string

                                                                                  func (*ServiceUnavailableException) ErrorFault

                                                                                  func (*ServiceUnavailableException) ErrorMessage

                                                                                  func (e *ServiceUnavailableException) ErrorMessage() string

                                                                                  type SubscriptionFilter

                                                                                  type SubscriptionFilter struct {
                                                                                  
                                                                                  	// The creation time of the subscription filter, expressed as the number of
                                                                                  	// milliseconds after Jan 1, 1970 00:00:00 UTC.
                                                                                  	CreationTime *int64
                                                                                  
                                                                                  	// The Amazon Resource Name (ARN) of the destination.
                                                                                  	DestinationArn *string
                                                                                  
                                                                                  	// The method used to distribute log data to the destination, which can be either
                                                                                  	// random or grouped by log stream.
                                                                                  	Distribution Distribution
                                                                                  
                                                                                  	// The name of the subscription filter.
                                                                                  	FilterName *string
                                                                                  
                                                                                  	// A symbolic description of how CloudWatch Logs should interpret the data in each
                                                                                  	// log event. For example, a log event can contain timestamps, IP addresses,
                                                                                  	// strings, and so on. You use the filter pattern to specify what to look for in
                                                                                  	// the log event message.
                                                                                  	FilterPattern *string
                                                                                  
                                                                                  	// The name of the log group.
                                                                                  	LogGroupName *string
                                                                                  
                                                                                  	//
                                                                                  	RoleArn *string
                                                                                  }

                                                                                    Represents a subscription filter.

                                                                                    type UnrecognizedClientException

                                                                                    type UnrecognizedClientException struct {
                                                                                    	Message *string
                                                                                    }

                                                                                      The most likely cause is an invalid AWS access key ID or secret key.

                                                                                      func (*UnrecognizedClientException) Error

                                                                                      func (*UnrecognizedClientException) ErrorCode

                                                                                      func (e *UnrecognizedClientException) ErrorCode() string

                                                                                      func (*UnrecognizedClientException) ErrorFault

                                                                                      func (*UnrecognizedClientException) ErrorMessage

                                                                                      func (e *UnrecognizedClientException) ErrorMessage() string