cloudwatch

package
v1.4.22 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 25, 2016 License: Apache-2.0 Imports: 10 Imported by: 0

Documentation

Overview

Package cloudwatch provides a client for Amazon CloudWatch.

Index

Examples

Constants

View Source
const (
	// ComparisonOperatorGreaterThanOrEqualToThreshold is a ComparisonOperator enum value
	ComparisonOperatorGreaterThanOrEqualToThreshold = "GreaterThanOrEqualToThreshold"

	// ComparisonOperatorGreaterThanThreshold is a ComparisonOperator enum value
	ComparisonOperatorGreaterThanThreshold = "GreaterThanThreshold"

	// ComparisonOperatorLessThanThreshold is a ComparisonOperator enum value
	ComparisonOperatorLessThanThreshold = "LessThanThreshold"

	// ComparisonOperatorLessThanOrEqualToThreshold is a ComparisonOperator enum value
	ComparisonOperatorLessThanOrEqualToThreshold = "LessThanOrEqualToThreshold"
)
View Source
const (
	// HistoryItemTypeConfigurationUpdate is a HistoryItemType enum value
	HistoryItemTypeConfigurationUpdate = "ConfigurationUpdate"

	// HistoryItemTypeStateUpdate is a HistoryItemType enum value
	HistoryItemTypeStateUpdate = "StateUpdate"

	// HistoryItemTypeAction is a HistoryItemType enum value
	HistoryItemTypeAction = "Action"
)
View Source
const (
	// StandardUnitSeconds is a StandardUnit enum value
	StandardUnitSeconds = "Seconds"

	// StandardUnitMicroseconds is a StandardUnit enum value
	StandardUnitMicroseconds = "Microseconds"

	// StandardUnitMilliseconds is a StandardUnit enum value
	StandardUnitMilliseconds = "Milliseconds"

	// StandardUnitBytes is a StandardUnit enum value
	StandardUnitBytes = "Bytes"

	// StandardUnitKilobytes is a StandardUnit enum value
	StandardUnitKilobytes = "Kilobytes"

	// StandardUnitMegabytes is a StandardUnit enum value
	StandardUnitMegabytes = "Megabytes"

	// StandardUnitGigabytes is a StandardUnit enum value
	StandardUnitGigabytes = "Gigabytes"

	// StandardUnitTerabytes is a StandardUnit enum value
	StandardUnitTerabytes = "Terabytes"

	// StandardUnitBits is a StandardUnit enum value
	StandardUnitBits = "Bits"

	// StandardUnitKilobits is a StandardUnit enum value
	StandardUnitKilobits = "Kilobits"

	// StandardUnitMegabits is a StandardUnit enum value
	StandardUnitMegabits = "Megabits"

	// StandardUnitGigabits is a StandardUnit enum value
	StandardUnitGigabits = "Gigabits"

	// StandardUnitTerabits is a StandardUnit enum value
	StandardUnitTerabits = "Terabits"

	// StandardUnitPercent is a StandardUnit enum value
	StandardUnitPercent = "Percent"

	// StandardUnitCount is a StandardUnit enum value
	StandardUnitCount = "Count"

	// StandardUnitBytesSecond is a StandardUnit enum value
	StandardUnitBytesSecond = "Bytes/Second"

	// StandardUnitKilobytesSecond is a StandardUnit enum value
	StandardUnitKilobytesSecond = "Kilobytes/Second"

	// StandardUnitMegabytesSecond is a StandardUnit enum value
	StandardUnitMegabytesSecond = "Megabytes/Second"

	// StandardUnitGigabytesSecond is a StandardUnit enum value
	StandardUnitGigabytesSecond = "Gigabytes/Second"

	// StandardUnitTerabytesSecond is a StandardUnit enum value
	StandardUnitTerabytesSecond = "Terabytes/Second"

	// StandardUnitBitsSecond is a StandardUnit enum value
	StandardUnitBitsSecond = "Bits/Second"

	// StandardUnitKilobitsSecond is a StandardUnit enum value
	StandardUnitKilobitsSecond = "Kilobits/Second"

	// StandardUnitMegabitsSecond is a StandardUnit enum value
	StandardUnitMegabitsSecond = "Megabits/Second"

	// StandardUnitGigabitsSecond is a StandardUnit enum value
	StandardUnitGigabitsSecond = "Gigabits/Second"

	// StandardUnitTerabitsSecond is a StandardUnit enum value
	StandardUnitTerabitsSecond = "Terabits/Second"

	// StandardUnitCountSecond is a StandardUnit enum value
	StandardUnitCountSecond = "Count/Second"

	// StandardUnitNone is a StandardUnit enum value
	StandardUnitNone = "None"
)
View Source
const (
	// StateValueOk is a StateValue enum value
	StateValueOk = "OK"

	// StateValueAlarm is a StateValue enum value
	StateValueAlarm = "ALARM"

	// StateValueInsufficientData is a StateValue enum value
	StateValueInsufficientData = "INSUFFICIENT_DATA"
)
View Source
const (
	// StatisticSampleCount is a Statistic enum value
	StatisticSampleCount = "SampleCount"

	// StatisticAverage is a Statistic enum value
	StatisticAverage = "Average"

	// StatisticSum is a Statistic enum value
	StatisticSum = "Sum"

	// StatisticMinimum is a Statistic enum value
	StatisticMinimum = "Minimum"

	// StatisticMaximum is a Statistic enum value
	StatisticMaximum = "Maximum"
)
View Source
const ServiceName = "monitoring"

A ServiceName is the name of the service the client will make API calls to.

Variables

This section is empty.

Functions

This section is empty.

Types

type AlarmHistoryItem

type AlarmHistoryItem struct {

	// The descriptive name for the alarm.
	AlarmName *string `min:"1" type:"string"`

	// Machine-readable data about the alarm in JSON format.
	HistoryData *string `min:"1" type:"string"`

	// The type of alarm history item.
	HistoryItemType *string `type:"string" enum:"HistoryItemType"`

	// A human-readable summary of the alarm history.
	HistorySummary *string `min:"1" type:"string"`

	// The time stamp for the alarm history item.
	Timestamp *time.Time `type:"timestamp" timestampFormat:"iso8601"`
	// contains filtered or unexported fields
}

The AlarmHistoryItem data type contains descriptive information about the history of a specific alarm. If you call DescribeAlarmHistory, Amazon CloudWatch returns this data type as part of the DescribeAlarmHistoryResult data type.

func (AlarmHistoryItem) GoString added in v0.6.6

func (s AlarmHistoryItem) GoString() string

GoString returns the string representation

func (AlarmHistoryItem) String added in v0.6.6

func (s AlarmHistoryItem) String() string

String returns the string representation

type CloudWatch

type CloudWatch struct {
	*client.Client
}

Amazon CloudWatch monitors your Amazon Web Services (AWS) resources and the applications you run on AWS in real-time. You can use CloudWatch to collect and track metrics, which are the variables you want to measure for your resources and applications.

CloudWatch alarms send notifications or automatically make changes to the resources you are monitoring based on rules that you define. For example, you can monitor the CPU usage and disk reads and writes of your Amazon Elastic Compute Cloud (Amazon EC2) instances and then use this data to determine whether you should launch additional instances to handle increased load. You can also use this data to stop under-used instances to save money.

In addition to monitoring the built-in metrics that come with AWS, you can monitor your own custom metrics. With CloudWatch, you gain system-wide visibility into resource utilization, application performance, and operational health. The service client's operations are safe to be used concurrently. It is not safe to mutate any of the client's properties though.

func New

func New(p client.ConfigProvider, cfgs ...*aws.Config) *CloudWatch

New creates a new instance of the CloudWatch client with a session. If additional configuration is needed for the client instance use the optional aws.Config parameter to add your extra config.

Example:

// Create a CloudWatch client from just a session.
svc := cloudwatch.New(mySession)

// Create a CloudWatch client with additional configuration
svc := cloudwatch.New(mySession, aws.NewConfig().WithRegion("us-west-2"))

func (*CloudWatch) DeleteAlarms

func (c *CloudWatch) DeleteAlarms(input *DeleteAlarmsInput) (*DeleteAlarmsOutput, error)

DeleteAlarms API operation for Amazon CloudWatch.

Deletes all specified alarms. In the event of an error, no alarms are deleted.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the AWS API reference guide for Amazon CloudWatch's API operation DeleteAlarms for usage and error information.

Returned Error Codes:

  • ResourceNotFound The named resource does not exist.
Example
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cloudwatch"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cloudwatch.New(sess)

	params := &cloudwatch.DeleteAlarmsInput{
		AlarmNames: []*string{ // Required
			aws.String("AlarmName"), // Required
			// More values...
		},
	}
	resp, err := svc.DeleteAlarms(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}
Output:

func (*CloudWatch) DeleteAlarmsRequest

func (c *CloudWatch) DeleteAlarmsRequest(input *DeleteAlarmsInput) (req *request.Request, output *DeleteAlarmsOutput)

DeleteAlarmsRequest generates a "aws/request.Request" representing the client's request for the DeleteAlarms operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

See DeleteAlarms for usage and error information.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the DeleteAlarms method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request.

// Example sending a request using the DeleteAlarmsRequest method.
req, resp := client.DeleteAlarmsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CloudWatch) DescribeAlarmHistory

func (c *CloudWatch) DescribeAlarmHistory(input *DescribeAlarmHistoryInput) (*DescribeAlarmHistoryOutput, error)

DescribeAlarmHistory API operation for Amazon CloudWatch.

Retrieves history for the specified alarm. Filter alarms by date range or item type. If an alarm name is not specified, Amazon CloudWatch returns histories for all of the owner's alarms.

Amazon CloudWatch retains the history of an alarm for two weeks, whether or not you delete the alarm.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the AWS API reference guide for Amazon CloudWatch's API operation DescribeAlarmHistory for usage and error information.

Returned Error Codes:

  • InvalidNextToken The next token specified is invalid.
Example
package main

import (
	"fmt"
	"time"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cloudwatch"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cloudwatch.New(sess)

	params := &cloudwatch.DescribeAlarmHistoryInput{
		AlarmName:       aws.String("AlarmName"),
		EndDate:         aws.Time(time.Now()),
		HistoryItemType: aws.String("HistoryItemType"),
		MaxRecords:      aws.Int64(1),
		NextToken:       aws.String("NextToken"),
		StartDate:       aws.Time(time.Now()),
	}
	resp, err := svc.DescribeAlarmHistory(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}
Output:

func (*CloudWatch) DescribeAlarmHistoryPages

func (c *CloudWatch) DescribeAlarmHistoryPages(input *DescribeAlarmHistoryInput, fn func(p *DescribeAlarmHistoryOutput, lastPage bool) (shouldContinue bool)) error

DescribeAlarmHistoryPages iterates over the pages of a DescribeAlarmHistory operation, calling the "fn" function with the response data for each page. To stop iterating, return false from the fn function.

See DescribeAlarmHistory method for more information on how to use this operation.

Note: This operation can generate multiple requests to a service.

// Example iterating over at most 3 pages of a DescribeAlarmHistory operation.
pageNum := 0
err := client.DescribeAlarmHistoryPages(params,
    func(page *DescribeAlarmHistoryOutput, lastPage bool) bool {
        pageNum++
        fmt.Println(page)
        return pageNum <= 3
    })

func (*CloudWatch) DescribeAlarmHistoryRequest

func (c *CloudWatch) DescribeAlarmHistoryRequest(input *DescribeAlarmHistoryInput) (req *request.Request, output *DescribeAlarmHistoryOutput)

DescribeAlarmHistoryRequest generates a "aws/request.Request" representing the client's request for the DescribeAlarmHistory operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

See DescribeAlarmHistory for usage and error information.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the DescribeAlarmHistory method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request.

// Example sending a request using the DescribeAlarmHistoryRequest method.
req, resp := client.DescribeAlarmHistoryRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CloudWatch) DescribeAlarms

func (c *CloudWatch) DescribeAlarms(input *DescribeAlarmsInput) (*DescribeAlarmsOutput, error)

DescribeAlarms API operation for Amazon CloudWatch.

Retrieves alarms with the specified names. If no name is specified, all alarms for the user are returned. Alarms can be retrieved by using only a prefix for the alarm name, the alarm state, or a prefix for any action.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the AWS API reference guide for Amazon CloudWatch's API operation DescribeAlarms for usage and error information.

Returned Error Codes:

  • InvalidNextToken The next token specified is invalid.
Example
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cloudwatch"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cloudwatch.New(sess)

	params := &cloudwatch.DescribeAlarmsInput{
		ActionPrefix:    aws.String("ActionPrefix"),
		AlarmNamePrefix: aws.String("AlarmNamePrefix"),
		AlarmNames: []*string{
			aws.String("AlarmName"), // Required
			// More values...
		},
		MaxRecords: aws.Int64(1),
		NextToken:  aws.String("NextToken"),
		StateValue: aws.String("StateValue"),
	}
	resp, err := svc.DescribeAlarms(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}
Output:

func (*CloudWatch) DescribeAlarmsForMetric

func (c *CloudWatch) DescribeAlarmsForMetric(input *DescribeAlarmsForMetricInput) (*DescribeAlarmsForMetricOutput, error)

DescribeAlarmsForMetric API operation for Amazon CloudWatch.

Retrieves all alarms for a single metric. Specify a statistic, period, or unit to filter the set of alarms further.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the AWS API reference guide for Amazon CloudWatch's API operation DescribeAlarmsForMetric for usage and error information.

Example
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cloudwatch"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cloudwatch.New(sess)

	params := &cloudwatch.DescribeAlarmsForMetricInput{
		MetricName: aws.String("MetricName"), // Required
		Namespace:  aws.String("Namespace"),  // Required
		Dimensions: []*cloudwatch.Dimension{
			{ // Required
				Name:  aws.String("DimensionName"),  // Required
				Value: aws.String("DimensionValue"), // Required
			},
			// More values...
		},
		Period:    aws.Int64(1),
		Statistic: aws.String("Statistic"),
		Unit:      aws.String("StandardUnit"),
	}
	resp, err := svc.DescribeAlarmsForMetric(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}
Output:

func (*CloudWatch) DescribeAlarmsForMetricRequest

func (c *CloudWatch) DescribeAlarmsForMetricRequest(input *DescribeAlarmsForMetricInput) (req *request.Request, output *DescribeAlarmsForMetricOutput)

DescribeAlarmsForMetricRequest generates a "aws/request.Request" representing the client's request for the DescribeAlarmsForMetric operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

See DescribeAlarmsForMetric for usage and error information.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the DescribeAlarmsForMetric method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request.

// Example sending a request using the DescribeAlarmsForMetricRequest method.
req, resp := client.DescribeAlarmsForMetricRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CloudWatch) DescribeAlarmsPages

func (c *CloudWatch) DescribeAlarmsPages(input *DescribeAlarmsInput, fn func(p *DescribeAlarmsOutput, lastPage bool) (shouldContinue bool)) error

DescribeAlarmsPages iterates over the pages of a DescribeAlarms operation, calling the "fn" function with the response data for each page. To stop iterating, return false from the fn function.

See DescribeAlarms method for more information on how to use this operation.

Note: This operation can generate multiple requests to a service.

// Example iterating over at most 3 pages of a DescribeAlarms operation.
pageNum := 0
err := client.DescribeAlarmsPages(params,
    func(page *DescribeAlarmsOutput, lastPage bool) bool {
        pageNum++
        fmt.Println(page)
        return pageNum <= 3
    })

func (*CloudWatch) DescribeAlarmsRequest

func (c *CloudWatch) DescribeAlarmsRequest(input *DescribeAlarmsInput) (req *request.Request, output *DescribeAlarmsOutput)

DescribeAlarmsRequest generates a "aws/request.Request" representing the client's request for the DescribeAlarms operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

See DescribeAlarms for usage and error information.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the DescribeAlarms method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request.

// Example sending a request using the DescribeAlarmsRequest method.
req, resp := client.DescribeAlarmsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CloudWatch) DisableAlarmActions

func (c *CloudWatch) DisableAlarmActions(input *DisableAlarmActionsInput) (*DisableAlarmActionsOutput, error)

DisableAlarmActions API operation for Amazon CloudWatch.

Disables actions for the specified alarms. When an alarm's actions are disabled the alarm's state may change, but none of the alarm's actions will execute.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the AWS API reference guide for Amazon CloudWatch's API operation DisableAlarmActions for usage and error information.

Example
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cloudwatch"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cloudwatch.New(sess)

	params := &cloudwatch.DisableAlarmActionsInput{
		AlarmNames: []*string{ // Required
			aws.String("AlarmName"), // Required
			// More values...
		},
	}
	resp, err := svc.DisableAlarmActions(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}
Output:

func (*CloudWatch) DisableAlarmActionsRequest

func (c *CloudWatch) DisableAlarmActionsRequest(input *DisableAlarmActionsInput) (req *request.Request, output *DisableAlarmActionsOutput)

DisableAlarmActionsRequest generates a "aws/request.Request" representing the client's request for the DisableAlarmActions operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

See DisableAlarmActions for usage and error information.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the DisableAlarmActions method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request.

// Example sending a request using the DisableAlarmActionsRequest method.
req, resp := client.DisableAlarmActionsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CloudWatch) EnableAlarmActions

func (c *CloudWatch) EnableAlarmActions(input *EnableAlarmActionsInput) (*EnableAlarmActionsOutput, error)

EnableAlarmActions API operation for Amazon CloudWatch.

Enables actions for the specified alarms.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the AWS API reference guide for Amazon CloudWatch's API operation EnableAlarmActions for usage and error information.

Example
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cloudwatch"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cloudwatch.New(sess)

	params := &cloudwatch.EnableAlarmActionsInput{
		AlarmNames: []*string{ // Required
			aws.String("AlarmName"), // Required
			// More values...
		},
	}
	resp, err := svc.EnableAlarmActions(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}
Output:

func (*CloudWatch) EnableAlarmActionsRequest

func (c *CloudWatch) EnableAlarmActionsRequest(input *EnableAlarmActionsInput) (req *request.Request, output *EnableAlarmActionsOutput)

EnableAlarmActionsRequest generates a "aws/request.Request" representing the client's request for the EnableAlarmActions operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

See EnableAlarmActions for usage and error information.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the EnableAlarmActions method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request.

// Example sending a request using the EnableAlarmActionsRequest method.
req, resp := client.EnableAlarmActionsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CloudWatch) GetMetricStatistics

func (c *CloudWatch) GetMetricStatistics(input *GetMetricStatisticsInput) (*GetMetricStatisticsOutput, error)

GetMetricStatistics API operation for Amazon CloudWatch.

Gets statistics for the specified metric.

The maximum number of data points that can be queried is 50,850, whereas the maximum number of data points returned from a single GetMetricStatistics request is 1,440. If you make a request that generates more than 1,440 data points, Amazon CloudWatch returns an error. In such a case, you can alter the request by narrowing the specified time range or increasing the specified period. A period can be as short as one minute (60 seconds) or as long as one day (86,400 seconds). Alternatively, you can make multiple requests across adjacent time ranges. GetMetricStatistics does not return the data in chronological order.

Amazon CloudWatch aggregates data points based on the length of the period that you specify. For example, if you request statistics with a one-minute granularity, Amazon CloudWatch aggregates data points with time stamps that fall within the same one-minute period. In such a case, the data points queried can greatly outnumber the data points returned.

The following examples show various statistics allowed by the data point query maximum of 50,850 when you call GetMetricStatistics on Amazon EC2 instances with detailed (one-minute) monitoring enabled:

  • Statistics for up to 400 instances for a span of one hour

  • Statistics for up to 35 instances over a span of 24 hours

  • Statistics for up to 2 instances over a span of 2 weeks

For information about the namespace, metric names, and dimensions that other Amazon Web Services products use to send metrics to CloudWatch, go to Amazon CloudWatch Metrics, Namespaces, and Dimensions Reference (http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/CW_Support_For_AWS.html) in the Amazon CloudWatch Developer Guide.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the AWS API reference guide for Amazon CloudWatch's API operation GetMetricStatistics for usage and error information.

Returned Error Codes:

  • InvalidParameterValue Bad or out-of-range value was supplied for the input parameter.

  • MissingParameter An input parameter that is mandatory for processing the request is not supplied.

  • InvalidParameterCombination Parameters that must not be used together were used together.

  • InternalServiceError Indicates that the request processing has failed due to some unknown error, exception, or failure.

Example
package main

import (
	"fmt"
	"time"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cloudwatch"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cloudwatch.New(sess)

	params := &cloudwatch.GetMetricStatisticsInput{
		EndTime:    aws.Time(time.Now()),     // Required
		MetricName: aws.String("MetricName"), // Required
		Namespace:  aws.String("Namespace"),  // Required
		Period:     aws.Int64(1),             // Required
		StartTime:  aws.Time(time.Now()),     // Required
		Statistics: []*string{ // Required
			aws.String("Statistic"), // Required
			// More values...
		},
		Dimensions: []*cloudwatch.Dimension{
			{ // Required
				Name:  aws.String("DimensionName"),  // Required
				Value: aws.String("DimensionValue"), // Required
			},
			// More values...
		},
		Unit: aws.String("StandardUnit"),
	}
	resp, err := svc.GetMetricStatistics(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}
Output:

func (*CloudWatch) GetMetricStatisticsRequest

func (c *CloudWatch) GetMetricStatisticsRequest(input *GetMetricStatisticsInput) (req *request.Request, output *GetMetricStatisticsOutput)

GetMetricStatisticsRequest generates a "aws/request.Request" representing the client's request for the GetMetricStatistics operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

See GetMetricStatistics for usage and error information.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the GetMetricStatistics method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request.

// Example sending a request using the GetMetricStatisticsRequest method.
req, resp := client.GetMetricStatisticsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CloudWatch) ListMetrics

func (c *CloudWatch) ListMetrics(input *ListMetricsInput) (*ListMetricsOutput, error)

ListMetrics API operation for Amazon CloudWatch.

Returns a list of valid metrics stored for the AWS account owner. Returned metrics can be used with GetMetricStatistics to obtain statistical data for a given metric.

Up to 500 results are returned for any one call. To retrieve further results, use returned NextToken values with subsequent ListMetrics operations.

If you create a metric with PutMetricData, allow up to fifteen minutes for the metric to appear in calls to ListMetrics. Statistics about the metric, however, are available sooner using GetMetricStatistics.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the AWS API reference guide for Amazon CloudWatch's API operation ListMetrics for usage and error information.

Returned Error Codes:

  • InternalServiceError Indicates that the request processing has failed due to some unknown error, exception, or failure.

  • InvalidParameterValue Bad or out-of-range value was supplied for the input parameter.

Example
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cloudwatch"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cloudwatch.New(sess)

	params := &cloudwatch.ListMetricsInput{
		Dimensions: []*cloudwatch.DimensionFilter{
			{ // Required
				Name:  aws.String("DimensionName"), // Required
				Value: aws.String("DimensionValue"),
			},
			// More values...
		},
		MetricName: aws.String("MetricName"),
		Namespace:  aws.String("Namespace"),
		NextToken:  aws.String("NextToken"),
	}
	resp, err := svc.ListMetrics(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}
Output:

func (*CloudWatch) ListMetricsPages

func (c *CloudWatch) ListMetricsPages(input *ListMetricsInput, fn func(p *ListMetricsOutput, lastPage bool) (shouldContinue bool)) error

ListMetricsPages iterates over the pages of a ListMetrics operation, calling the "fn" function with the response data for each page. To stop iterating, return false from the fn function.

See ListMetrics method for more information on how to use this operation.

Note: This operation can generate multiple requests to a service.

// Example iterating over at most 3 pages of a ListMetrics operation.
pageNum := 0
err := client.ListMetricsPages(params,
    func(page *ListMetricsOutput, lastPage bool) bool {
        pageNum++
        fmt.Println(page)
        return pageNum <= 3
    })

func (*CloudWatch) ListMetricsRequest

func (c *CloudWatch) ListMetricsRequest(input *ListMetricsInput) (req *request.Request, output *ListMetricsOutput)

ListMetricsRequest generates a "aws/request.Request" representing the client's request for the ListMetrics operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

See ListMetrics for usage and error information.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the ListMetrics method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request.

// Example sending a request using the ListMetricsRequest method.
req, resp := client.ListMetricsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CloudWatch) PutMetricAlarm

func (c *CloudWatch) PutMetricAlarm(input *PutMetricAlarmInput) (*PutMetricAlarmOutput, error)

PutMetricAlarm API operation for Amazon CloudWatch.

Creates or updates an alarm and associates it with the specified Amazon CloudWatch metric. Optionally, this operation can associate one or more Amazon SNS resources with the alarm.

When this operation creates an alarm, the alarm state is immediately set to INSUFFICIENT_DATA. The alarm is evaluated and its StateValue is set appropriately. Any actions associated with the StateValue are then executed.

When updating an existing alarm, its StateValue is left unchanged, but it completely overwrites the alarm's previous configuration.

If you are using an AWS Identity and Access Management (IAM) account to create or modify an alarm, you must have the following Amazon EC2 permissions:

ec2:DescribeInstanceStatus and ec2:DescribeInstances for all alarms on Amazon EC2 instance status metrics.

ec2:StopInstances for alarms with stop actions.

ec2:TerminateInstances for alarms with terminate actions.

ec2:DescribeInstanceRecoveryAttribute, and ec2:RecoverInstances for alarms with recover actions.

If you have read/write permissions for Amazon CloudWatch but not for Amazon EC2, you can still create an alarm but the stop or terminate actions won't be performed on the Amazon EC2 instance. However, if you are later granted permission to use the associated Amazon EC2 APIs, the alarm actions you created earlier will be performed. For more information about IAM permissions, see Permissions and Policies (http://docs.aws.amazon.com/IAM/latest/UserGuide/PermissionsAndPolicies.html) in Using IAM.

If you are using an IAM role (e.g., an Amazon EC2 instance profile), you cannot stop or terminate the instance using alarm actions. However, you can still see the alarm state and perform any other actions such as Amazon SNS notifications or Auto Scaling policies.

If you are using temporary security credentials granted using the AWS Security Token Service (AWS STS), you cannot stop or terminate an Amazon EC2 instance using alarm actions.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the AWS API reference guide for Amazon CloudWatch's API operation PutMetricAlarm for usage and error information.

Returned Error Codes:

  • LimitExceeded The quota for alarms for this customer has already been reached.
Example
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cloudwatch"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cloudwatch.New(sess)

	params := &cloudwatch.PutMetricAlarmInput{
		AlarmName:          aws.String("AlarmName"),          // Required
		ComparisonOperator: aws.String("ComparisonOperator"), // Required
		EvaluationPeriods:  aws.Int64(1),                     // Required
		MetricName:         aws.String("MetricName"),         // Required
		Namespace:          aws.String("Namespace"),          // Required
		Period:             aws.Int64(1),                     // Required
		Statistic:          aws.String("Statistic"),          // Required
		Threshold:          aws.Float64(1.0),                 // Required
		ActionsEnabled:     aws.Bool(true),
		AlarmActions: []*string{
			aws.String("ResourceName"), // Required
			// More values...
		},
		AlarmDescription: aws.String("AlarmDescription"),
		Dimensions: []*cloudwatch.Dimension{
			{ // Required
				Name:  aws.String("DimensionName"),  // Required
				Value: aws.String("DimensionValue"), // Required
			},
			// More values...
		},
		InsufficientDataActions: []*string{
			aws.String("ResourceName"), // Required
			// More values...
		},
		OKActions: []*string{
			aws.String("ResourceName"), // Required
			// More values...
		},
		Unit: aws.String("StandardUnit"),
	}
	resp, err := svc.PutMetricAlarm(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}
Output:

func (*CloudWatch) PutMetricAlarmRequest

func (c *CloudWatch) PutMetricAlarmRequest(input *PutMetricAlarmInput) (req *request.Request, output *PutMetricAlarmOutput)

PutMetricAlarmRequest generates a "aws/request.Request" representing the client's request for the PutMetricAlarm operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

See PutMetricAlarm for usage and error information.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the PutMetricAlarm method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request.

// Example sending a request using the PutMetricAlarmRequest method.
req, resp := client.PutMetricAlarmRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CloudWatch) PutMetricData

func (c *CloudWatch) PutMetricData(input *PutMetricDataInput) (*PutMetricDataOutput, error)

PutMetricData API operation for Amazon CloudWatch.

Publishes metric data points to Amazon CloudWatch. Amazon CloudWatch associates the data points with the specified metric. If the specified metric does not exist, Amazon CloudWatch creates the metric. When Amazon CloudWatch creates a metric, it can take up to fifteen minutes for the metric to appear in calls to ListMetrics.

Each PutMetricData request is limited to 8 KB in size for HTTP GET requests and is limited to 40 KB in size for HTTP POST requests.

Although the Value parameter accepts numbers of type Double, Amazon CloudWatch rejects values that are either too small or too large. Values must be in the range of 8.515920e-109 to 1.174271e+108 (Base 10) or 2e-360 to 2e360 (Base 2). In addition, special values (e.g., NaN, +Infinity, -Infinity) are not supported.

Data that is timestamped 24 hours or more in the past may take in excess of 48 hours to become available from submission time using GetMetricStatistics.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the AWS API reference guide for Amazon CloudWatch's API operation PutMetricData for usage and error information.

Returned Error Codes:

  • InvalidParameterValue Bad or out-of-range value was supplied for the input parameter.

  • MissingParameter An input parameter that is mandatory for processing the request is not supplied.

  • InvalidParameterCombination Parameters that must not be used together were used together.

  • InternalServiceError Indicates that the request processing has failed due to some unknown error, exception, or failure.

Example
package main

import (
	"fmt"
	"time"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cloudwatch"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cloudwatch.New(sess)

	params := &cloudwatch.PutMetricDataInput{
		MetricData: []*cloudwatch.MetricDatum{ // Required
			{ // Required
				MetricName: aws.String("MetricName"), // Required
				Dimensions: []*cloudwatch.Dimension{
					{ // Required
						Name:  aws.String("DimensionName"),  // Required
						Value: aws.String("DimensionValue"), // Required
					},
					// More values...
				},
				StatisticValues: &cloudwatch.StatisticSet{
					Maximum:     aws.Float64(1.0), // Required
					Minimum:     aws.Float64(1.0), // Required
					SampleCount: aws.Float64(1.0), // Required
					Sum:         aws.Float64(1.0), // Required
				},
				Timestamp: aws.Time(time.Now()),
				Unit:      aws.String("StandardUnit"),
				Value:     aws.Float64(1.0),
			},
			// More values...
		},
		Namespace: aws.String("Namespace"), // Required
	}
	resp, err := svc.PutMetricData(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}
Output:

func (*CloudWatch) PutMetricDataRequest

func (c *CloudWatch) PutMetricDataRequest(input *PutMetricDataInput) (req *request.Request, output *PutMetricDataOutput)

PutMetricDataRequest generates a "aws/request.Request" representing the client's request for the PutMetricData operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

See PutMetricData for usage and error information.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the PutMetricData method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request.

// Example sending a request using the PutMetricDataRequest method.
req, resp := client.PutMetricDataRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CloudWatch) SetAlarmState

func (c *CloudWatch) SetAlarmState(input *SetAlarmStateInput) (*SetAlarmStateOutput, error)

SetAlarmState API operation for Amazon CloudWatch.

Temporarily sets the state of an alarm for testing purposes. When the updated StateValue differs from the previous value, the action configured for the appropriate state is invoked. For example, if your alarm is configured to send an Amazon SNS message when an alarm is triggered, temporarily changing the alarm's state to ALARM sends an Amazon SNS message. The alarm returns to its actual state (often within seconds). Because the alarm state change happens very quickly, it is typically only visible in the alarm's History tab in the Amazon CloudWatch console or through DescribeAlarmHistory.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the AWS API reference guide for Amazon CloudWatch's API operation SetAlarmState for usage and error information.

Returned Error Codes:

  • ResourceNotFound The named resource does not exist.

  • InvalidFormat Data was not syntactically valid JSON.

Example
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/cloudwatch"
)

func main() {
	sess, err := session.NewSession()
	if err != nil {
		fmt.Println("failed to create session,", err)
		return
	}

	svc := cloudwatch.New(sess)

	params := &cloudwatch.SetAlarmStateInput{
		AlarmName:       aws.String("AlarmName"),   // Required
		StateReason:     aws.String("StateReason"), // Required
		StateValue:      aws.String("StateValue"),  // Required
		StateReasonData: aws.String("StateReasonData"),
	}
	resp, err := svc.SetAlarmState(params)

	if err != nil {
		// Print the error, cast err to awserr.Error to get the Code and
		// Message from an error.
		fmt.Println(err.Error())
		return
	}

	// Pretty-print the response data.
	fmt.Println(resp)
}
Output:

func (*CloudWatch) SetAlarmStateRequest

func (c *CloudWatch) SetAlarmStateRequest(input *SetAlarmStateInput) (req *request.Request, output *SetAlarmStateOutput)

SetAlarmStateRequest generates a "aws/request.Request" representing the client's request for the SetAlarmState operation. The "output" return value can be used to capture response data after the request's "Send" method is called.

See SetAlarmState for usage and error information.

Creating a request object using this method should be used when you want to inject custom logic into the request's lifecycle using a custom handler, or if you want to access properties on the request object before or after sending the request. If you just want the service response, call the SetAlarmState method directly instead.

Note: You must call the "Send" method on the returned request object in order to execute the request.

// Example sending a request using the SetAlarmStateRequest method.
req, resp := client.SetAlarmStateRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*CloudWatch) WaitUntilAlarmExists added in v1.1.33

func (c *CloudWatch) WaitUntilAlarmExists(input *DescribeAlarmsInput) error

WaitUntilAlarmExists uses the CloudWatch API operation DescribeAlarms to wait for a condition to be met before returning. If the condition is not meet within the max attempt window an error will be returned.

type Datapoint

type Datapoint struct {

	// The average of metric values that correspond to the datapoint.
	Average *float64 `type:"double"`

	// The maximum of the metric value used for the datapoint.
	Maximum *float64 `type:"double"`

	// The minimum metric value used for the datapoint.
	Minimum *float64 `type:"double"`

	// The number of metric values that contributed to the aggregate value of this
	// datapoint.
	SampleCount *float64 `type:"double"`

	// The sum of metric values used for the datapoint.
	Sum *float64 `type:"double"`

	// The time stamp used for the datapoint.
	Timestamp *time.Time `type:"timestamp" timestampFormat:"iso8601"`

	// The standard unit used for the datapoint.
	Unit *string `type:"string" enum:"StandardUnit"`
	// contains filtered or unexported fields
}

The Datapoint data type encapsulates the statistical data that Amazon CloudWatch computes from metric data.

func (Datapoint) GoString added in v0.6.6

func (s Datapoint) GoString() string

GoString returns the string representation

func (Datapoint) String added in v0.6.6

func (s Datapoint) String() string

String returns the string representation

type DeleteAlarmsInput

type DeleteAlarmsInput struct {

	// A list of alarms to be deleted.
	//
	// AlarmNames is a required field
	AlarmNames []*string `type:"list" required:"true"`
	// contains filtered or unexported fields
}

Describes the inputs for DeleteAlarms.

func (DeleteAlarmsInput) GoString added in v0.6.6

func (s DeleteAlarmsInput) GoString() string

GoString returns the string representation

func (DeleteAlarmsInput) String added in v0.6.6

func (s DeleteAlarmsInput) String() string

String returns the string representation

func (*DeleteAlarmsInput) Validate added in v1.1.24

func (s *DeleteAlarmsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DeleteAlarmsOutput

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

func (DeleteAlarmsOutput) GoString added in v0.6.6

func (s DeleteAlarmsOutput) GoString() string

GoString returns the string representation

func (DeleteAlarmsOutput) String added in v0.6.6

func (s DeleteAlarmsOutput) String() string

String returns the string representation

type DescribeAlarmHistoryInput

type DescribeAlarmHistoryInput struct {

	// The name of the alarm.
	AlarmName *string `min:"1" type:"string"`

	// The ending date to retrieve alarm history.
	EndDate *time.Time `type:"timestamp" timestampFormat:"iso8601"`

	// The type of alarm histories to retrieve.
	HistoryItemType *string `type:"string" enum:"HistoryItemType"`

	// The maximum number of alarm history records to retrieve.
	MaxRecords *int64 `min:"1" type:"integer"`

	// The token returned by a previous call to indicate that there is more data
	// available.
	NextToken *string `type:"string"`

	// The starting date to retrieve alarm history.
	StartDate *time.Time `type:"timestamp" timestampFormat:"iso8601"`
	// contains filtered or unexported fields
}

Describes the inputs for DescribeAlarmHistory.

func (DescribeAlarmHistoryInput) GoString added in v0.6.6

func (s DescribeAlarmHistoryInput) GoString() string

GoString returns the string representation

func (DescribeAlarmHistoryInput) String added in v0.6.6

func (s DescribeAlarmHistoryInput) String() string

String returns the string representation

func (*DescribeAlarmHistoryInput) Validate added in v1.1.24

func (s *DescribeAlarmHistoryInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DescribeAlarmHistoryOutput

type DescribeAlarmHistoryOutput struct {

	// A list of alarm histories in JSON format.
	AlarmHistoryItems []*AlarmHistoryItem `type:"list"`

	// A string that marks the start of the next batch of returned results.
	NextToken *string `type:"string"`
	// contains filtered or unexported fields
}

The output for DescribeAlarmHistory.

func (DescribeAlarmHistoryOutput) GoString added in v0.6.6

func (s DescribeAlarmHistoryOutput) GoString() string

GoString returns the string representation

func (DescribeAlarmHistoryOutput) String added in v0.6.6

String returns the string representation

type DescribeAlarmsForMetricInput

type DescribeAlarmsForMetricInput struct {

	// The list of dimensions associated with the metric. If the metric has any
	// associated dimensions, you must specify them in order for the DescribeAlarmsForMetric
	// to succeed.
	Dimensions []*Dimension `type:"list"`

	// The name of the metric.
	//
	// MetricName is a required field
	MetricName *string `min:"1" type:"string" required:"true"`

	// The namespace of the metric.
	//
	// Namespace is a required field
	Namespace *string `min:"1" type:"string" required:"true"`

	// The period in seconds over which the statistic is applied.
	Period *int64 `min:"60" type:"integer"`

	// The statistic for the metric.
	Statistic *string `type:"string" enum:"Statistic"`

	// The unit for the metric.
	Unit *string `type:"string" enum:"StandardUnit"`
	// contains filtered or unexported fields
}

Describes the inputs for DescribeAlarmsForMetric.

func (DescribeAlarmsForMetricInput) GoString added in v0.6.6

func (s DescribeAlarmsForMetricInput) GoString() string

GoString returns the string representation

func (DescribeAlarmsForMetricInput) String added in v0.6.6

String returns the string representation

func (*DescribeAlarmsForMetricInput) Validate added in v1.1.24

func (s *DescribeAlarmsForMetricInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DescribeAlarmsForMetricOutput

type DescribeAlarmsForMetricOutput struct {

	// A list of information for each alarm with the specified metric.
	MetricAlarms []*MetricAlarm `type:"list"`
	// contains filtered or unexported fields
}

The output for DescribeAlarmsForMetric.

func (DescribeAlarmsForMetricOutput) GoString added in v0.6.6

GoString returns the string representation

func (DescribeAlarmsForMetricOutput) String added in v0.6.6

String returns the string representation

type DescribeAlarmsInput

type DescribeAlarmsInput struct {

	// The action name prefix.
	ActionPrefix *string `min:"1" type:"string"`

	// The alarm name prefix. AlarmNames cannot be specified if this parameter is
	// specified.
	AlarmNamePrefix *string `min:"1" type:"string"`

	// A list of alarm names to retrieve information for.
	AlarmNames []*string `type:"list"`

	// The maximum number of alarm descriptions to retrieve.
	MaxRecords *int64 `min:"1" type:"integer"`

	// The token returned by a previous call to indicate that there is more data
	// available.
	NextToken *string `type:"string"`

	// The state value to be used in matching alarms.
	StateValue *string `type:"string" enum:"StateValue"`
	// contains filtered or unexported fields
}

Describes the inputs for DescribeAlarms.

func (DescribeAlarmsInput) GoString added in v0.6.6

func (s DescribeAlarmsInput) GoString() string

GoString returns the string representation

func (DescribeAlarmsInput) String added in v0.6.6

func (s DescribeAlarmsInput) String() string

String returns the string representation

func (*DescribeAlarmsInput) Validate added in v1.1.24

func (s *DescribeAlarmsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DescribeAlarmsOutput

type DescribeAlarmsOutput struct {

	// A list of information for the specified alarms.
	MetricAlarms []*MetricAlarm `type:"list"`

	// A string that marks the start of the next batch of returned results.
	NextToken *string `type:"string"`
	// contains filtered or unexported fields
}

The output for DescribeAlarms.

func (DescribeAlarmsOutput) GoString added in v0.6.6

func (s DescribeAlarmsOutput) GoString() string

GoString returns the string representation

func (DescribeAlarmsOutput) String added in v0.6.6

func (s DescribeAlarmsOutput) String() string

String returns the string representation

type Dimension

type Dimension struct {

	// The name of the dimension.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// The value representing the dimension measurement
	//
	// Value is a required field
	Value *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

The Dimension data type further expands on the identity of a metric using a Name, Value pair.

For examples that use one or more dimensions, see PutMetricData.

func (Dimension) GoString added in v0.6.6

func (s Dimension) GoString() string

GoString returns the string representation

func (Dimension) String added in v0.6.6

func (s Dimension) String() string

String returns the string representation

func (*Dimension) Validate added in v1.1.24

func (s *Dimension) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DimensionFilter

type DimensionFilter struct {

	// The dimension name to be matched.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// The value of the dimension to be matched.
	//
	// Specifying a Name without specifying a Value returns all values associated
	// with that Name.
	Value *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

The DimensionFilter data type is used to filter ListMetrics results.

func (DimensionFilter) GoString added in v0.6.6

func (s DimensionFilter) GoString() string

GoString returns the string representation

func (DimensionFilter) String added in v0.6.6

func (s DimensionFilter) String() string

String returns the string representation

func (*DimensionFilter) Validate added in v1.1.24

func (s *DimensionFilter) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DisableAlarmActionsInput

type DisableAlarmActionsInput struct {

	// The names of the alarms to disable actions for.
	//
	// AlarmNames is a required field
	AlarmNames []*string `type:"list" required:"true"`
	// contains filtered or unexported fields
}

func (DisableAlarmActionsInput) GoString added in v0.6.6

func (s DisableAlarmActionsInput) GoString() string

GoString returns the string representation

func (DisableAlarmActionsInput) String added in v0.6.6

func (s DisableAlarmActionsInput) String() string

String returns the string representation

func (*DisableAlarmActionsInput) Validate added in v1.1.24

func (s *DisableAlarmActionsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DisableAlarmActionsOutput

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

func (DisableAlarmActionsOutput) GoString added in v0.6.6

func (s DisableAlarmActionsOutput) GoString() string

GoString returns the string representation

func (DisableAlarmActionsOutput) String added in v0.6.6

func (s DisableAlarmActionsOutput) String() string

String returns the string representation

type EnableAlarmActionsInput

type EnableAlarmActionsInput struct {

	// The names of the alarms to enable actions for.
	//
	// AlarmNames is a required field
	AlarmNames []*string `type:"list" required:"true"`
	// contains filtered or unexported fields
}

Describes the inputs for EnableAlarmActions.

func (EnableAlarmActionsInput) GoString added in v0.6.6

func (s EnableAlarmActionsInput) GoString() string

GoString returns the string representation

func (EnableAlarmActionsInput) String added in v0.6.6

func (s EnableAlarmActionsInput) String() string

String returns the string representation

func (*EnableAlarmActionsInput) Validate added in v1.1.24

func (s *EnableAlarmActionsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type EnableAlarmActionsOutput

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

func (EnableAlarmActionsOutput) GoString added in v0.6.6

func (s EnableAlarmActionsOutput) GoString() string

GoString returns the string representation

func (EnableAlarmActionsOutput) String added in v0.6.6

func (s EnableAlarmActionsOutput) String() string

String returns the string representation

type GetMetricStatisticsInput

type GetMetricStatisticsInput struct {

	// A list of dimensions describing qualities of the metric.
	Dimensions []*Dimension `type:"list"`

	// The time stamp to use for determining the last datapoint to return. The value
	// specified is exclusive; results will include datapoints up to the time stamp
	// specified. The time stamp must be in ISO 8601 UTC format (e.g., 2014-09-03T23:00:00Z).
	//
	// EndTime is a required field
	EndTime *time.Time `type:"timestamp" timestampFormat:"iso8601" required:"true"`

	// The name of the metric, with or without spaces.
	//
	// MetricName is a required field
	MetricName *string `min:"1" type:"string" required:"true"`

	// The namespace of the metric, with or without spaces.
	//
	// Namespace is a required field
	Namespace *string `min:"1" type:"string" required:"true"`

	// The granularity, in seconds, of the returned datapoints. A Period can be
	// as short as one minute (60 seconds) or as long as one day (86,400 seconds),
	// and must be a multiple of 60. The default value is 60.
	//
	// Period is a required field
	Period *int64 `min:"60" type:"integer" required:"true"`

	// The time stamp to use for determining the first datapoint to return. The
	// value specified is inclusive; results include datapoints with the time stamp
	// specified. The time stamp must be in ISO 8601 UTC format (e.g., 2014-09-03T23:00:00Z).
	//
	// The specified start time is rounded down to the nearest value. Datapoints
	// are returned for start times up to two weeks in the past. Specified start
	// times that are more than two weeks in the past will not return datapoints
	// for metrics that are older than two weeks.
	//
	// Data that is timestamped 24 hours or more in the past may take in excess
	// of 48 hours to become available from submission time using GetMetricStatistics.
	//
	// StartTime is a required field
	StartTime *time.Time `type:"timestamp" timestampFormat:"iso8601" required:"true"`

	// The metric statistics to return. For information about specific statistics
	// returned by GetMetricStatistics, see Statistics (http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/cloudwatch_concepts.html#Statistic)
	// in the Amazon CloudWatch Developer Guide.
	//
	// Statistics is a required field
	Statistics []*string `min:"1" type:"list" required:"true"`

	// The specific unit for a given metric. Metrics may be reported in multiple
	// units. Not supplying a unit results in all units being returned. If the metric
	// only ever reports one unit, specifying a unit will have no effect.
	Unit *string `type:"string" enum:"StandardUnit"`
	// contains filtered or unexported fields
}

Describes the inputs for GetMetricStatistics.

func (GetMetricStatisticsInput) GoString added in v0.6.6

func (s GetMetricStatisticsInput) GoString() string

GoString returns the string representation

func (GetMetricStatisticsInput) String added in v0.6.6

func (s GetMetricStatisticsInput) String() string

String returns the string representation

func (*GetMetricStatisticsInput) Validate added in v1.1.24

func (s *GetMetricStatisticsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type GetMetricStatisticsOutput

type GetMetricStatisticsOutput struct {

	// The datapoints for the specified metric.
	Datapoints []*Datapoint `type:"list"`

	// A label describing the specified metric.
	Label *string `type:"string"`
	// contains filtered or unexported fields
}

The output for GetMetricStatistics.

func (GetMetricStatisticsOutput) GoString added in v0.6.6

func (s GetMetricStatisticsOutput) GoString() string

GoString returns the string representation

func (GetMetricStatisticsOutput) String added in v0.6.6

func (s GetMetricStatisticsOutput) String() string

String returns the string representation

type ListMetricsInput

type ListMetricsInput struct {

	// A list of dimensions to filter against.
	Dimensions []*DimensionFilter `type:"list"`

	// The name of the metric to filter against.
	MetricName *string `min:"1" type:"string"`

	// The namespace to filter against.
	Namespace *string `min:"1" type:"string"`

	// The token returned by a previous call to indicate that there is more data
	// available.
	NextToken *string `type:"string"`
	// contains filtered or unexported fields
}

Describes the inputs for ListMetrics.

func (ListMetricsInput) GoString added in v0.6.6

func (s ListMetricsInput) GoString() string

GoString returns the string representation

func (ListMetricsInput) String added in v0.6.6

func (s ListMetricsInput) String() string

String returns the string representation

func (*ListMetricsInput) Validate added in v1.1.24

func (s *ListMetricsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ListMetricsOutput

type ListMetricsOutput struct {

	// A list of metrics used to generate statistics for an AWS account.
	Metrics []*Metric `type:"list"`

	// A string that marks the start of the next batch of returned results.
	NextToken *string `type:"string"`
	// contains filtered or unexported fields
}

The output for ListMetrics.

func (ListMetricsOutput) GoString added in v0.6.6

func (s ListMetricsOutput) GoString() string

GoString returns the string representation

func (ListMetricsOutput) String added in v0.6.6

func (s ListMetricsOutput) String() string

String returns the string representation

type Metric

type Metric struct {

	// A list of dimensions associated with the metric.
	Dimensions []*Dimension `type:"list"`

	// The name of the metric.
	MetricName *string `min:"1" type:"string"`

	// The namespace of the metric.
	Namespace *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

The Metric data type contains information about a specific metric. If you call ListMetrics, Amazon CloudWatch returns information contained by this data type.

The example in the Examples section publishes two metrics named buffers and latency. Both metrics are in the examples namespace. Both metrics have two dimensions, InstanceID and InstanceType.

func (Metric) GoString added in v0.6.6

func (s Metric) GoString() string

GoString returns the string representation

func (Metric) String added in v0.6.6

func (s Metric) String() string

String returns the string representation

type MetricAlarm

type MetricAlarm struct {

	// Indicates whether actions should be executed during any changes to the alarm's
	// state.
	ActionsEnabled *bool `type:"boolean"`

	// The list of actions to execute when this alarm transitions into an ALARM
	// state from any other state. Each action is specified as an Amazon Resource
	// Name (ARN).
	AlarmActions []*string `type:"list"`

	// The Amazon Resource Name (ARN) of the alarm.
	AlarmArn *string `min:"1" type:"string"`

	// The time stamp of the last update to the alarm configuration.
	AlarmConfigurationUpdatedTimestamp *time.Time `type:"timestamp" timestampFormat:"iso8601"`

	// The description for the alarm.
	AlarmDescription *string `type:"string"`

	// The name of the alarm.
	AlarmName *string `min:"1" type:"string"`

	// The arithmetic operation to use when comparing the specified Statistic and
	// Threshold. The specified Statistic value is used as the first operand.
	ComparisonOperator *string `type:"string" enum:"ComparisonOperator"`

	// The list of dimensions associated with the alarm's associated metric.
	Dimensions []*Dimension `type:"list"`

	// The number of periods over which data is compared to the specified threshold.
	EvaluationPeriods *int64 `min:"1" type:"integer"`

	// The list of actions to execute when this alarm transitions into an INSUFFICIENT_DATA
	// state from any other state. Each action is specified as an Amazon Resource
	// Name (ARN).
	//
	// The current WSDL lists this attribute as UnknownActions.
	InsufficientDataActions []*string `type:"list"`

	// The name of the alarm's metric.
	MetricName *string `min:"1" type:"string"`

	// The namespace of alarm's associated metric.
	Namespace *string `min:"1" type:"string"`

	// The list of actions to execute when this alarm transitions into an OK state
	// from any other state. Each action is specified as an Amazon Resource Name
	// (ARN).
	OKActions []*string `type:"list"`

	// The period in seconds over which the statistic is applied.
	Period *int64 `min:"60" type:"integer"`

	// A human-readable explanation for the alarm's state.
	StateReason *string `type:"string"`

	// An explanation for the alarm's state in machine-readable JSON format
	StateReasonData *string `type:"string"`

	// The time stamp of the last update to the alarm's state.
	StateUpdatedTimestamp *time.Time `type:"timestamp" timestampFormat:"iso8601"`

	// The state value for the alarm.
	StateValue *string `type:"string" enum:"StateValue"`

	// The statistic to apply to the alarm's associated metric.
	Statistic *string `type:"string" enum:"Statistic"`

	// The value against which the specified statistic is compared.
	Threshold *float64 `type:"double"`

	// The unit of the alarm's associated metric.
	Unit *string `type:"string" enum:"StandardUnit"`
	// contains filtered or unexported fields
}

The MetricAlarm data type represents an alarm. You can use PutMetricAlarm to create or update an alarm.

func (MetricAlarm) GoString added in v0.6.6

func (s MetricAlarm) GoString() string

GoString returns the string representation

func (MetricAlarm) String added in v0.6.6

func (s MetricAlarm) String() string

String returns the string representation

type MetricDatum

type MetricDatum struct {

	// A list of dimensions associated with the metric. Note, when using the Dimensions
	// value in a query, you need to append .member.N to it (e.g., Dimensions.member.N).
	Dimensions []*Dimension `type:"list"`

	// The name of the metric.
	//
	// MetricName is a required field
	MetricName *string `min:"1" type:"string" required:"true"`

	// A set of statistical values describing the metric.
	StatisticValues *StatisticSet `type:"structure"`

	// The time stamp used for the metric in ISO 8601 Universal Coordinated Time
	// (UTC) format. If not specified, the default value is set to the time the
	// metric data was received.
	Timestamp *time.Time `type:"timestamp" timestampFormat:"iso8601"`

	// The unit of the metric.
	Unit *string `type:"string" enum:"StandardUnit"`

	// The value for the metric.
	//
	// Although the Value parameter accepts numbers of type Double, Amazon CloudWatch
	// rejects values that are either too small or too large. Values must be in
	// the range of 8.515920e-109 to 1.174271e+108 (Base 10) or 2e-360 to 2e360
	// (Base 2). In addition, special values (e.g., NaN, +Infinity, -Infinity) are
	// not supported.
	Value *float64 `type:"double"`
	// contains filtered or unexported fields
}

The MetricDatum data type encapsulates the information sent with PutMetricData to either create a new metric or add new values to be aggregated into an existing metric.

func (MetricDatum) GoString added in v0.6.6

func (s MetricDatum) GoString() string

GoString returns the string representation

func (MetricDatum) String added in v0.6.6

func (s MetricDatum) String() string

String returns the string representation

func (*MetricDatum) Validate added in v1.1.24

func (s *MetricDatum) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type PutMetricAlarmInput

type PutMetricAlarmInput struct {

	// Indicates whether or not actions should be executed during any changes to
	// the alarm's state.
	ActionsEnabled *bool `type:"boolean"`

	// The list of actions to execute when this alarm transitions into an ALARM
	// state from any other state. Each action is specified as an Amazon Resource
	// Name (ARN).
	//
	// Valid Values: arn:aws:automate:region (e.g., us-east-1):ec2:stop | arn:aws:automate:region
	// (e.g., us-east-1):ec2:terminate | arn:aws:automate:region (e.g., us-east-1):ec2:recover
	//
	// Valid Values (for use with IAM roles): arn:aws:swf:us-east-1:{customer-account}:action/actions/AWS_EC2.InstanceId.Stop/1.0
	// | arn:aws:swf:us-east-1:{customer-account}:action/actions/AWS_EC2.InstanceId.Terminate/1.0
	// | arn:aws:swf:us-east-1:{customer-account}:action/actions/AWS_EC2.InstanceId.Reboot/1.0
	//
	// Note: You must create at least one stop, terminate, or reboot alarm using
	// the Amazon EC2 or CloudWatch console to create the EC2ActionsAccess IAM role
	// for the first time. After this IAM role is created, you can create stop,
	// terminate, or reboot alarms using the CLI.
	AlarmActions []*string `type:"list"`

	// The description for the alarm.
	AlarmDescription *string `type:"string"`

	// The descriptive name for the alarm. This name must be unique within the user's
	// AWS account
	//
	// AlarmName is a required field
	AlarmName *string `min:"1" type:"string" required:"true"`

	// The arithmetic operation to use when comparing the specified Statistic and
	// Threshold. The specified Statistic value is used as the first operand.
	//
	// ComparisonOperator is a required field
	ComparisonOperator *string `type:"string" required:"true" enum:"ComparisonOperator"`

	// The dimensions for the alarm's associated metric.
	Dimensions []*Dimension `type:"list"`

	// The number of periods over which data is compared to the specified threshold.
	//
	// EvaluationPeriods is a required field
	EvaluationPeriods *int64 `min:"1" type:"integer" required:"true"`

	// The list of actions to execute when this alarm transitions into an INSUFFICIENT_DATA
	// state from any other state. Each action is specified as an Amazon Resource
	// Name (ARN).
	//
	// Valid Values: arn:aws:automate:region (e.g., us-east-1):ec2:stop | arn:aws:automate:region
	// (e.g., us-east-1):ec2:terminate | arn:aws:automate:region (e.g., us-east-1):ec2:recover
	//
	// Valid Values (for use with IAM roles): arn:aws:swf:us-east-1:{customer-account}:action/actions/AWS_EC2.InstanceId.Stop/1.0
	// | arn:aws:swf:us-east-1:{customer-account}:action/actions/AWS_EC2.InstanceId.Terminate/1.0
	// | arn:aws:swf:us-east-1:{customer-account}:action/actions/AWS_EC2.InstanceId.Reboot/1.0
	//
	// Note: You must create at least one stop, terminate, or reboot alarm using
	// the Amazon EC2 or CloudWatch console to create the EC2ActionsAccess IAM role
	// for the first time. After this IAM role is created, you can create stop,
	// terminate, or reboot alarms using the CLI.
	InsufficientDataActions []*string `type:"list"`

	// The name for the alarm's associated metric.
	//
	// MetricName is a required field
	MetricName *string `min:"1" type:"string" required:"true"`

	// The namespace for the alarm's associated metric.
	//
	// Namespace is a required field
	Namespace *string `min:"1" type:"string" required:"true"`

	// The list of actions to execute when this alarm transitions into an OK state
	// from any other state. Each action is specified as an Amazon Resource Name
	// (ARN).
	//
	// Valid Values: arn:aws:automate:region (e.g., us-east-1):ec2:stop | arn:aws:automate:region
	// (e.g., us-east-1):ec2:terminate | arn:aws:automate:region (e.g., us-east-1):ec2:recover
	//
	// Valid Values (for use with IAM roles): arn:aws:swf:us-east-1:{customer-account}:action/actions/AWS_EC2.InstanceId.Stop/1.0
	// | arn:aws:swf:us-east-1:{customer-account}:action/actions/AWS_EC2.InstanceId.Terminate/1.0
	// | arn:aws:swf:us-east-1:{customer-account}:action/actions/AWS_EC2.InstanceId.Reboot/1.0
	//
	// Note: You must create at least one stop, terminate, or reboot alarm using
	// the Amazon EC2 or CloudWatch console to create the EC2ActionsAccess IAM role
	// for the first time. After this IAM role is created, you can create stop,
	// terminate, or reboot alarms using the CLI.
	OKActions []*string `type:"list"`

	// The period in seconds over which the specified statistic is applied.
	//
	// Period is a required field
	Period *int64 `min:"60" type:"integer" required:"true"`

	// The statistic to apply to the alarm's associated metric.
	//
	// Statistic is a required field
	Statistic *string `type:"string" required:"true" enum:"Statistic"`

	// The value against which the specified statistic is compared.
	//
	// Threshold is a required field
	Threshold *float64 `type:"double" required:"true"`

	// The statistic's unit of measure. For example, the units for the Amazon EC2
	// NetworkIn metric are Bytes because NetworkIn tracks the number of bytes that
	// an instance receives on all network interfaces. You can also specify a unit
	// when you create a custom metric. Units help provide conceptual meaning to
	// your data. Metric data points that specify a unit of measure, such as Percent,
	// are aggregated separately.
	//
	// Note: If you specify a unit, you must use a unit that is appropriate for
	// the metric. Otherwise, this can cause an Amazon CloudWatch alarm to get stuck
	// in the INSUFFICIENT DATA state.
	Unit *string `type:"string" enum:"StandardUnit"`
	// contains filtered or unexported fields
}

Describes the inputs for PutMetricAlarm.

func (PutMetricAlarmInput) GoString added in v0.6.6

func (s PutMetricAlarmInput) GoString() string

GoString returns the string representation

func (PutMetricAlarmInput) String added in v0.6.6

func (s PutMetricAlarmInput) String() string

String returns the string representation

func (*PutMetricAlarmInput) Validate added in v1.1.24

func (s *PutMetricAlarmInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type PutMetricAlarmOutput

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

func (PutMetricAlarmOutput) GoString added in v0.6.6

func (s PutMetricAlarmOutput) GoString() string

GoString returns the string representation

func (PutMetricAlarmOutput) String added in v0.6.6

func (s PutMetricAlarmOutput) String() string

String returns the string representation

type PutMetricDataInput

type PutMetricDataInput struct {

	// A list of data describing the metric.
	//
	// MetricData is a required field
	MetricData []*MetricDatum `type:"list" required:"true"`

	// The namespace for the metric data.
	//
	// You cannot specify a namespace that begins with "AWS/". Namespaces that begin
	// with "AWS/" are reserved for other Amazon Web Services products that send
	// metrics to Amazon CloudWatch.
	//
	// Namespace is a required field
	Namespace *string `min:"1" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Describes the inputs for PutMetricData.

func (PutMetricDataInput) GoString added in v0.6.6

func (s PutMetricDataInput) GoString() string

GoString returns the string representation

func (PutMetricDataInput) String added in v0.6.6

func (s PutMetricDataInput) String() string

String returns the string representation

func (*PutMetricDataInput) Validate added in v1.1.24

func (s *PutMetricDataInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type PutMetricDataOutput

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

func (PutMetricDataOutput) GoString added in v0.6.6

func (s PutMetricDataOutput) GoString() string

GoString returns the string representation

func (PutMetricDataOutput) String added in v0.6.6

func (s PutMetricDataOutput) String() string

String returns the string representation

type SetAlarmStateInput

type SetAlarmStateInput struct {

	// The descriptive name for the alarm. This name must be unique within the user's
	// AWS account. The maximum length is 255 characters.
	//
	// AlarmName is a required field
	AlarmName *string `min:"1" type:"string" required:"true"`

	// The reason that this alarm is set to this specific state (in human-readable
	// text format)
	//
	// StateReason is a required field
	StateReason *string `type:"string" required:"true"`

	// The reason that this alarm is set to this specific state (in machine-readable
	// JSON format)
	StateReasonData *string `type:"string"`

	// The value of the state.
	//
	// StateValue is a required field
	StateValue *string `type:"string" required:"true" enum:"StateValue"`
	// contains filtered or unexported fields
}

Describes the inputs for SetAlarmState.

func (SetAlarmStateInput) GoString added in v0.6.6

func (s SetAlarmStateInput) GoString() string

GoString returns the string representation

func (SetAlarmStateInput) String added in v0.6.6

func (s SetAlarmStateInput) String() string

String returns the string representation

func (*SetAlarmStateInput) Validate added in v1.1.24

func (s *SetAlarmStateInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type SetAlarmStateOutput

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

func (SetAlarmStateOutput) GoString added in v0.6.6

func (s SetAlarmStateOutput) GoString() string

GoString returns the string representation

func (SetAlarmStateOutput) String added in v0.6.6

func (s SetAlarmStateOutput) String() string

String returns the string representation

type StatisticSet

type StatisticSet struct {

	// The maximum value of the sample set.
	//
	// Maximum is a required field
	Maximum *float64 `type:"double" required:"true"`

	// The minimum value of the sample set.
	//
	// Minimum is a required field
	Minimum *float64 `type:"double" required:"true"`

	// The number of samples used for the statistic set.
	//
	// SampleCount is a required field
	SampleCount *float64 `type:"double" required:"true"`

	// The sum of values for the sample set.
	//
	// Sum is a required field
	Sum *float64 `type:"double" required:"true"`
	// contains filtered or unexported fields
}

The StatisticSet data type describes the StatisticValues component of MetricDatum, and represents a set of statistics that describes a specific metric.

func (StatisticSet) GoString added in v0.6.6

func (s StatisticSet) GoString() string

GoString returns the string representation

func (StatisticSet) String added in v0.6.6

func (s StatisticSet) String() string

String returns the string representation

func (*StatisticSet) Validate added in v1.1.24

func (s *StatisticSet) Validate() error

Validate inspects the fields of the type to determine if they are valid.

Directories

Path Synopsis
Package cloudwatchiface provides an interface to enable mocking the Amazon CloudWatch service client for testing your code.
Package cloudwatchiface provides an interface to enable mocking the Amazon CloudWatch service client for testing your code.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL