func ExampleAutoScaling_PutScheduledUpdateGroupAction() { svc := autoscaling.New(nil) params := &autoscaling.PutScheduledUpdateGroupActionInput{ AutoScalingGroupName: aws.String("ResourceName"), // Required ScheduledActionName: aws.String("XmlStringMaxLen255"), // Required DesiredCapacity: aws.Int64(1), EndTime: aws.Time(time.Now()), MaxSize: aws.Int64(1), MinSize: aws.Int64(1), Recurrence: aws.String("XmlStringMaxLen255"), StartTime: aws.Time(time.Now()), Time: aws.Time(time.Now()), } resp, err := svc.PutScheduledUpdateGroupAction(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) }
// return average CPU usage for a given AutoScaling group func awsGetAsgCPU(cw cloudwatch.CloudWatch, md *opentsdb.MultiDataPoint, asg autoscaling.Group) error { params := cloudwatch.GetMetricStatisticsInput{ StartTime: aws.Time(time.Now().UTC().Add(time.Second * -300)), EndTime: aws.Time(time.Now().UTC()), MetricName: aws.String("CPUUtilization"), Period: &aws_period, Namespace: aws.String("AWS/EC2"), Unit: aws.String("Percent"), Statistics: []*string{ aws.String("Average"), }, Dimensions: []*cloudwatch.Dimension{ { Name: aws.String("AutoScalingGroupName"), Value: aws.String(*asg.AutoScalingGroupName), }, }, } resp, err := cw.GetMetricStatistics(¶ms) if err != nil { return err } tags := opentsdb.TagSet{ "autoscalegroup": *asg.AutoScalingGroupName, } for _, datapoint := range resp.Datapoints { AddTS(md, awsASGCPU, datapoint.Timestamp.Unix(), *datapoint.Average, tags, metadata.Gauge, metadata.Pct, descAWSASGCPU) } return nil }
func ExampleAutoScaling_DescribeScheduledActions() { svc := autoscaling.New(nil) params := &autoscaling.DescribeScheduledActionsInput{ AutoScalingGroupName: aws.String("ResourceName"), EndTime: aws.Time(time.Now()), MaxRecords: aws.Int64(1), NextToken: aws.String("XmlString"), ScheduledActionNames: []*string{ aws.String("ResourceName"), // Required // More values... }, StartTime: aws.Time(time.Now()), } resp, err := svc.DescribeScheduledActions(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) }
func awsGetELBHostCounts(cw cloudwatch.CloudWatch, md *opentsdb.MultiDataPoint, loadBalancer *elb.LoadBalancerDescription) error { search := cloudwatch.GetMetricStatisticsInput{ StartTime: aws.Time(time.Now().UTC().Add(time.Second * -60)), EndTime: aws.Time(time.Now().UTC()), MetricName: aws.String("HealthyHostCount"), Period: &aws_period, Statistics: []*string{aws.String("Average")}, Namespace: aws.String("AWS/ELB"), Unit: aws.String("Count"), Dimensions: []*cloudwatch.Dimension{{Name: aws.String("LoadBalancerName"), Value: loadBalancer.LoadBalancerName}}, } resp, err := cw.GetMetricStatistics(&search) if err != nil { return err } for _, datapoint := range resp.Datapoints { AddTS(md, awsELBHostsHealthy, datapoint.Timestamp.Unix(), *datapoint.Average, opentsdb.TagSet{"loadbalancer": *loadBalancer.LoadBalancerName}, metadata.Gauge, metadata.Count, descAWSELBHostCount) } search.MetricName = aws.String("UnhealthyHostCount") resp, err = cw.GetMetricStatistics(&search) if err != nil { return err } if resp.Datapoints == nil { AddTS(md, awsELBHostsUnHealthy, time.Now().UTC().Unix(), 0, opentsdb.TagSet{"loadbalancer": *loadBalancer.LoadBalancerName}, metadata.Gauge, metadata.Count, descAWSELBHostCount) } else { for _, datapoint := range resp.Datapoints { AddTS(md, awsELBHostsUnHealthy, datapoint.Timestamp.Unix(), *datapoint.Average, opentsdb.TagSet{"loadbalancer": *loadBalancer.LoadBalancerName}, metadata.Gauge, metadata.Count, descAWSELBHostCount) } } return nil }
// return sum of 5xx errors from a given ELB func awsGetELB5XX(cw cloudwatch.CloudWatch, md *opentsdb.MultiDataPoint, loadBalancer *elb.LoadBalancerDescription) error { search := cloudwatch.GetMetricStatisticsInput{ StartTime: aws.Time(time.Now().UTC().Add(time.Second * -300)), EndTime: aws.Time(time.Now().UTC()), MetricName: aws.String("HTTPCode_Backend_5XX"), Period: &aws_period, Statistics: []*string{aws.String("Sum")}, Namespace: aws.String("AWS/ELB"), Unit: aws.String("Count"), Dimensions: []*cloudwatch.Dimension{ { Name: aws.String("LoadBalancerName"), Value: loadBalancer.LoadBalancerName, }, }, } resp, err := cw.GetMetricStatistics(&search) if err != nil { return err } for _, datapoint := range resp.Datapoints { AddTS(md, awsELBStatus5XX, datapoint.Timestamp.Unix(), *datapoint.Sum, opentsdb.TagSet{"loadbalancer": *loadBalancer.LoadBalancerName}, metadata.Gauge, metadata.Second, descAWSELBStatus5XX) } return nil }
func awsGetDiskOps(cw cloudwatch.CloudWatch, md *opentsdb.MultiDataPoint, instance *ec2.Instance) error { search := cloudwatch.GetMetricStatisticsInput{ StartTime: aws.Time(time.Now().UTC().Add(time.Second * -300)), EndTime: aws.Time(time.Now().UTC()), MetricName: aws.String("DiskReadOps"), Period: &aws_period, Statistics: []*string{aws.String("Average")}, Namespace: aws.String("AWS/EC2"), Unit: aws.String("Count"), Dimensions: []*cloudwatch.Dimension{{Name: aws.String("InstanceId"), Value: instance.InstanceId}}, } resp, err := cw.GetMetricStatistics(&search) if err != nil { return err } for _, datapoint := range resp.Datapoints { AddTS(md, awsEC2DiskOps, datapoint.Timestamp.Unix(), *datapoint.Average, opentsdb.TagSet{"instance": *instance.InstanceId, "operation": "read"}, metadata.Gauge, metadata.Count, descAWSEC2DiskOps) } search.MetricName = aws.String("DiskWriteOps") resp, err = cw.GetMetricStatistics(&search) if err != nil { return err } for _, datapoint := range resp.Datapoints { AddTS(md, awsEC2DiskOps, datapoint.Timestamp.Unix(), *datapoint.Average, opentsdb.TagSet{"instance": *instance.InstanceId, "operation": "write"}, metadata.Gauge, metadata.Count, descAWSEC2DiskOps) } return nil }
func ExampleCloudWatch_GetMetricStatistics() { svc := cloudwatch.New(nil) 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) }
func awsGetNetwork(cw cloudwatch.CloudWatch, md *opentsdb.MultiDataPoint, instance *ec2.Instance) error { search := cloudwatch.GetMetricStatisticsInput{ StartTime: aws.Time(time.Now().UTC().Add(time.Second * -600)), EndTime: aws.Time(time.Now().UTC()), MetricName: aws.String("NetworkIn"), Period: &aws_period, Statistics: []*string{aws.String("Average")}, Namespace: aws.String("AWS/EC2"), Unit: aws.String("Bytes"), Dimensions: []*cloudwatch.Dimension{{Name: aws.String("InstanceId"), Value: instance.InstanceId}}, } resp, err := cw.GetMetricStatistics(&search) if err != nil { return err } for _, datapoint := range resp.Datapoints { AddTS(md, awsNetwork, datapoint.Timestamp.Unix(), *datapoint.Average, opentsdb.TagSet{"instance": *instance.InstanceId, "direction": "in"}, metadata.Gauge, metadata.Bytes, descAWSEC2NetBytes) } search.MetricName = aws.String("NetworkOut") resp, err = cw.GetMetricStatistics(&search) if err != nil { return err } for _, datapoint := range resp.Datapoints { AddTS(md, awsNetwork, datapoint.Timestamp.Unix(), *datapoint.Average, opentsdb.TagSet{"instance": *instance.InstanceId, "direction": "out"}, metadata.Gauge, metadata.Bytes, descAWSEC2NetBytes) } return nil }
func TestInputService8ProtocolTestTimestampValuesCase1(t *testing.T) { svc := NewInputService8ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService8TestShapeInputService8TestCaseOperation1Input{ TimeArg: aws.Time(time.Unix(1422172800, 0)), } req, _ := svc.InputService8TestCaseOperation1Request(input) r := req.HTTPRequest // build request ec2query.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body, _ := ioutil.ReadAll(r.Body) assert.Equal(t, util.Trim(`Action=OperationName&TimeArg=2015-01-25T08%3A00%3A00Z&Version=2014-01-01`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/", r.URL.String()) // assert headers }
func awsGetELBLatency(cw cloudwatch.CloudWatch, md *opentsdb.MultiDataPoint, loadBalancer *elb.LoadBalancerDescription) error { search := cloudwatch.GetMetricStatisticsInput{ StartTime: aws.Time(time.Now().UTC().Add(time.Second * -300)), EndTime: aws.Time(time.Now().UTC()), MetricName: aws.String("Latency"), Period: &aws_period, Statistics: []*string{aws.String("Average"), aws.String("Minimum"), aws.String("Maximum")}, Namespace: aws.String("AWS/ELB"), Unit: aws.String("Seconds"), Dimensions: []*cloudwatch.Dimension{{Name: aws.String("LoadBalancerName"), Value: loadBalancer.LoadBalancerName}}, } resp, err := cw.GetMetricStatistics(&search) if err != nil { return err } for _, datapoint := range resp.Datapoints { AddTS(md, awsELBLatencyMin, datapoint.Timestamp.Unix(), *datapoint.Minimum, opentsdb.TagSet{"loadbalancer": *loadBalancer.LoadBalancerName}, metadata.Gauge, metadata.Second, descAWSELBLatency) AddTS(md, awsELBLatencyMax, datapoint.Timestamp.Unix(), *datapoint.Maximum, opentsdb.TagSet{"loadbalancer": *loadBalancer.LoadBalancerName}, metadata.Gauge, metadata.Second, descAWSELBLatency) AddTS(md, awsELBLatencyAvg, datapoint.Timestamp.Unix(), *datapoint.Average, opentsdb.TagSet{"loadbalancer": *loadBalancer.LoadBalancerName}, metadata.Gauge, metadata.Second, descAWSELBLatency) } return nil }
func awsGetCPU(cw cloudwatch.CloudWatch, md *opentsdb.MultiDataPoint, instance *ec2.Instance) error { search := cloudwatch.GetMetricStatisticsInput{ StartTime: aws.Time(time.Now().UTC().Add(time.Second * -300)), EndTime: aws.Time(time.Now().UTC()), MetricName: aws.String("CPUUtilization"), Period: &aws_period, Statistics: []*string{aws.String("Average")}, Namespace: aws.String("AWS/EC2"), Unit: aws.String("Percent"), Dimensions: []*cloudwatch.Dimension{{Name: aws.String("InstanceId"), Value: instance.InstanceId}}, } resp, err := cw.GetMetricStatistics(&search) if err != nil { return err } tags := opentsdb.TagSet{ "instance": *instance.InstanceId, } for _, datapoint := range resp.Datapoints { AddTS(md, awsCPU, datapoint.Timestamp.Unix(), *datapoint.Average, tags, metadata.Gauge, metadata.Pct, descAWSEC2CPU) } return nil }
func ExampleCloudWatch_DescribeAlarmHistory() { svc := cloudwatch.New(nil) 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) }
func awsGetStatusChecks(cw cloudwatch.CloudWatch, md *opentsdb.MultiDataPoint, instance *ec2.Instance) error { period := int64(60) search := cloudwatch.GetMetricStatisticsInput{ StartTime: aws.Time(time.Now().UTC().Add(time.Second * -60)), EndTime: aws.Time(time.Now().UTC()), MetricName: aws.String("StatusCheckFailed"), Period: &period, Statistics: []*string{aws.String("Average")}, Namespace: aws.String("AWS/EC2"), Unit: aws.String("Count"), Dimensions: []*cloudwatch.Dimension{{Name: aws.String("InstanceId"), Value: instance.InstanceId}}, } resp, err := cw.GetMetricStatistics(&search) if err != nil { return err } for _, datapoint := range resp.Datapoints { AddTS(md, awsStatusCheckFailed, datapoint.Timestamp.Unix(), *datapoint.Average, opentsdb.TagSet{"instance": *instance.InstanceId}, metadata.Gauge, metadata.Count, descAWSEC2StatusCheck) } search.MetricName = aws.String("StatusCheckFailed_Instance") resp, err = cw.GetMetricStatistics(&search) if err != nil { return err } for _, datapoint := range resp.Datapoints { AddTS(md, awsStatusCheckFailed, datapoint.Timestamp.Unix(), *datapoint.Average, opentsdb.TagSet{"instance": *instance.InstanceId, "category": "instance"}, metadata.Gauge, metadata.Count, descAWSEC2StatusCheck) } search.MetricName = aws.String("StatusCheckFailed_System") resp, err = cw.GetMetricStatistics(&search) if err != nil { return err } for _, datapoint := range resp.Datapoints { AddTS(md, awsStatusCheckFailed, datapoint.Timestamp.Unix(), *datapoint.Average, opentsdb.TagSet{"instance": *instance.InstanceId, "category": "system"}, metadata.Gauge, metadata.Count, descAWSEC2StatusCheck) } return nil }
func ExampleCloudWatch_PutMetricData() { svc := cloudwatch.New(nil) 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) }