public async Task <GetMetricStatisticsResponse> GetMetricStatistics(GetMetricStatisticsRequest metricStatisticsRequest) { using (var amazonCloudWatchClient = new AmazonCloudWatchClient(awsCredentials, RegionEndpoint.GetBySystemName(Region))) { var response = await amazonCloudWatchClient.GetMetricStatisticsAsync(metricStatisticsRequest); return(response); } }
private bool RetryUntilSucceed(GetMetricStatisticsRequest request, int expected) { int attempts = 0; while (!CheckMetricExistence(request, expected)) { attempts++; Console.WriteLine( $"No metrics yet. Sleeping before trying again. Attempt #{attempts}"); Thread.Sleep(2000); } return(true); }
IEnumerable <DataPoint> GetCPUUtilizationForInstance(string instanceId, DateTime start, DateTime end) { //build request var req = new GetMetricStatisticsRequest() { Dimensions = { new Dimension { Name = "InstanceId", Value = instanceId } }, MetricName = "CPUUtilization", Statistics = new List <String> { "Average" }, Period = 60, Unit = "Percent", Namespace = "AWS/EC2", StartTime = start, EndTime = end }; //send request //cloudwatch client var cloudWatch = AWSClientFactory.CreateAmazonCloudWatchClient(AWSAccessKey, AWSSecretKey, new AmazonCloudWatchConfig() { ServiceURL = RegionHelper.CloudWatchEndpointForRegion(EC2Region) } ); try { var response = cloudWatch.GetMetricStatistics(req); if (response.GetMetricStatisticsResult == null) { return(null); } return(response.GetMetricStatisticsResult.Datapoints.Select(datapoint => new DataPoint { Value = datapoint.Average, TimeStamp = datapoint.Timestamp })); } catch (Exception ex) { return(null); } }
protected long GetConsumedCapacityUnits(string table_name, string index_name, string metric_name, int look_back_minutes) { List <Dimension> dimensions = new List <Dimension> { new Dimension { Name = "TableName", Value = table_name } }; if (!string.IsNullOrWhiteSpace(index_name)) { dimensions.Add(new Dimension { Name = "GlobalSecondaryIndexName", Value = index_name }); } DateTime end_time = DateTime.UtcNow.AddMinutes(-5); DateTime start_time = end_time.AddMinutes(-look_back_minutes); AmazonCloudWatchClient amazon_cloud_watch_client = AWS.GetAmazonCloudWatchClient(); GetMetricStatisticsRequest get_metric_statistics_request = new GetMetricStatisticsRequest { Namespace = "AWS/DynamoDB", Dimensions = dimensions, MetricName = metric_name, StartTime = start_time, EndTime = end_time, Period = 300, Statistics = new List <string> { "Sum" } }; GetMetricStatisticsResponse get_metric_statistics_response = amazon_cloud_watch_client.GetMetricStatistics(get_metric_statistics_request); long consumed_capacity_units = 0; if (get_metric_statistics_response != null && get_metric_statistics_response.Datapoints.Any()) { double total_seconds = (end_time - start_time).TotalSeconds; double total_sum = get_metric_statistics_response.Datapoints.Sum(datapoint => datapoint.Sum); consumed_capacity_units = (long)Math.Ceiling(total_sum / total_seconds); } return(consumed_capacity_units); }
public static void CWGetMetricStatistics() { #region CWGetMetricStatistics var client = new AmazonCloudWatchClient(); var dimension = new Dimension { Name = "InstanceType", Value = "t1.micro" }; var request = new GetMetricStatisticsRequest { Dimensions = new List <Dimension>() { dimension }, EndTime = DateTime.Today, MetricName = "CPUUtilization", Namespace = "AWS/EC2", // Get statistics by day. Period = (int)TimeSpan.FromDays(1).TotalSeconds, // Get statistics for the past month. StartTime = DateTime.Today.Subtract(TimeSpan.FromDays(30)), Statistics = new List <string>() { "Minimum" }, Unit = StandardUnit.Percent }; var response = client.GetMetricStatistics(request); if (response.Datapoints.Count > 0) { foreach (var point in response.Datapoints) { Console.WriteLine(point.Timestamp.ToShortDateString() + " " + point.Minimum + "%"); } } #endregion Console.ReadLine(); }
public async Task <TimingStatSummary> GetTimerStatsAsync(string name, DateTime?start = default(DateTime?), DateTime?end = default(DateTime?), int dataPoints = 20) { if (!start.HasValue) { start = SystemClock.UtcNow.AddHours(-4); } if (!end.HasValue) { end = SystemClock.UtcNow; } var request = new GetMetricStatisticsRequest { Namespace = _namespace, MetricName = GetMetricName(MetricType.Counter, name), Period = GetStatsPeriod(start.Value, end.Value), StartTime = start.Value, EndTime = end.Value, Unit = StandardUnit.Milliseconds, Statistics = new List <string> { "Sum", "Minimum", "Maximum", "SampleCount" } }; var response = await _client.Value.GetMetricStatisticsAsync(request).AnyContext(); if (response.HttpStatusCode != System.Net.HttpStatusCode.OK) { throw new AmazonCloudWatchException("Unable to retrieve metrics."); } return(new TimingStatSummary( name, response.Datapoints.Select(dp => new TimingStat { MinDuration = (int)dp.Minimum, MaxDuration = (int)dp.Maximum, TotalDuration = (long)dp.Sum, Count = (int)dp.SampleCount, Time = dp.Timestamp }).ToList(), start.Value, end.Value)); }
public void CWExceptionTest() { GetMetricStatisticsRequest getMetricRequest = new GetMetricStatisticsRequest() { MetricName = "CPUUtilization", Namespace = "AWS/EC2", StartTime = DateTime.Parse("2008-02-26T19:00:00+00:00"), EndTime = DateTime.Parse("2011-02-26T19:00:00+00:00"), Statistics = new List <string> { "Average" }, Unit = "Percent", Period = 60 }; var exception = AssertExtensions.ExpectExceptionAsync <InvalidParameterCombinationException>(Client.GetMetricStatisticsAsync(getMetricRequest)).Result; AssertValidException(exception); Assert.AreEqual("InvalidParameterCombination", exception.ErrorCode); }
private GetMetricStatisticsRequest BuildRequest(String metricName) { List <Dimension> dimensions = new List <Dimension>() { GetDimension("ServiceName", _serviceName), GetDimension("ServiceType", _serviceType), GetDimension(_dimensionName, _dimensionValue) }; var metricRequest = new GetMetricStatisticsRequest(); metricRequest.Namespace = "aws-embedded-metrics"; metricRequest.MetricName = metricName; metricRequest.Dimensions = dimensions; metricRequest.Period = 60; metricRequest.StartTimeUtc = _testStartTime; metricRequest.EndTimeUtc = DateTime.UtcNow.RoundUp(TimeSpan.FromMinutes(1)); metricRequest.Statistics.Add(Statistic.SampleCount); return(metricRequest); }
// TODO: sampleCounts is calculated wrongly bool CheckMetricExistence(GetMetricStatisticsRequest request, double expectedSampleCount) { AmazonCloudWatchClient client = new AmazonCloudWatchClient(); Task <GetMetricStatisticsResponse> response = client.GetMetricStatisticsAsync(request); if (response == null) { return(false); } var datapoints = response.Result.Datapoints; var sampleCounts = 0.0; foreach (var datapoint in datapoints) { sampleCounts += datapoint.SampleCount; } Console.WriteLine($"Found {sampleCounts}. Expected {expectedSampleCount}"); return(sampleCounts.Equals(expectedSampleCount)); }
private async Task <double> GetConsumptionMetric(string tableName, string metricName, string indexName = null) { var getMetricsRequest = new GetMetricStatisticsRequest { Dimensions = new List <Dimension> { new Dimension { Name = "TableName", Value = tableName } }, Namespace = AwsNamespace.DynamoDb, MetricName = metricName, Period = 60, Statistics = new List <string> { "Sum" }, Unit = StandardUnit.Count }; if (!string.IsNullOrEmpty(indexName)) { getMetricsRequest.Dimensions.Add(new Dimension { Name = "GlobalSecondaryIndexName", Value = indexName }); } var allDataPoints = new List <Datapoint>(); for (var i = 0; i <= ReportDuration; i++) { getMetricsRequest.StartTimeUtc = DateTime.UtcNow.AddDays(-(i + 1)); getMetricsRequest.EndTimeUtc = DateTime.UtcNow.AddDays(-i); allDataPoints.AddRange((await _cloudwatch.GetMetricStatisticsAsync(getMetricsRequest)).Datapoints); } return(allDataPoints.Count > 0 ? allDataPoints.Max(x => x.Sum) : 0); }
private static async Task <InstanceResults> FindInstancesAndCategorize() { var instances = await FindInstances(); AmazonCloudWatchClient cwClient = new AmazonCloudWatchClient(AccessKey, SecretKey, Region); var instanceResults = new InstanceResults(); //this was written this way to facilite better control over throttling (vs Parallel.ForEach with MaxConcurrency) //in addition a future enhancement could be batching instances to GetMatricStatistics call await instances.ForEachAsync(MaxMetricConcurrency, async (instance) => { //var instance = instances[i]; var dim = new Dimension() { Name = "InstanceId", Value = instance.InstanceId, }; var request = new GetMetricStatisticsRequest() { Dimensions = new List <Dimension> { dim }, Namespace = "AWS/EC2", MetricName = "CPUUtilization", Unit = StandardUnit.Percent, Statistics = new List <string>() { "Average" }, StartTime = DateTime.UtcNow.Subtract(TimeSpan.FromHours(MetricRetrievalInHours)), EndTime = DateTime.UtcNow, Period = (int)TimeSpan.FromMinutes(PeriodInMinutes).TotalSeconds, }; var response = await cwClient.GetMetricStatisticsAsync(request); var max = UnknownCpuPercent; var avg = 0.0d; var stdDev = 0.0d; var count = response.Datapoints.Count; if (count >= MinServerMetricsToJudge) { // first loop to calculate max and sum var sum = 0.0d; foreach (var dp in response.Datapoints) { if (dp.Average > max) { max = dp.Average; } sum += dp.Average; } avg = sum / count; // second loop allows us to calculate std deviation var varianceSum = 0.0d; foreach (var dp in response.Datapoints) { varianceSum += Math.Pow(dp.Average - avg, 2.0d); } stdDev = Math.Sqrt(varianceSum / count); } if (max == UnknownCpuPercent) { instanceResults.UnknownInstances.Add(new InstanceResult(instance, "Unknown CPU", max)); } else if (max < MaxBadCpuPercent) { // if the CPU is basically doing nothing //Console.WriteLine($"LOW {instance.Hostname}\tMax={max}, Avg={avg}, StdDev={stdDev}"); instanceResults.BadInstances.Add(new InstanceResult(instance, "Low CPU", max)); } else if (max > MinStalledCpuPercent && stdDev < MaxStdDevStalledCpuPercent) { // if the CPU is above a floor (MinStalledCpuPercent) but is essentially flatlined //Console.WriteLine($"FLAT {instance.Hostname}\tMax={max}, Avg={avg}, StdDev={stdDev}"); instanceResults.BadInstances.Add(new InstanceResult(instance, "Flatlined CPU", stdDev)); } else { instanceResults.GoodInstances.Add(new InstanceResult(instance, null, max)); } var processed = instanceResults.BadInstances.Count + instanceResults.UnknownInstances.Count + instanceResults.GoodInstances.Count; Console.Write("\rProcessed {0}/{1} instances.", processed, instances.Count); //depending on your AWS setup you might need to throttle these calls more aggressively //Thread.Sleep(50); }); Console.WriteLine(); return(instanceResults); }
private static async Task <InstanceResults> FindInstancesAndCategorize() { var instances = await FindInstances(); AmazonCloudWatchClient cwClient = new AmazonCloudWatchClient(AccessKey, SecretKey, Region); var instanceResults = new InstanceResults(); //this was written this way to facilite better control over throttling (vs Parallel.ForEach with MaxConcurrency) //in addition a future enhancement could be batching instances to GetMatricStatistics call await instances.ForEachAsync(MaxMetricConcurrency, async (instance) => { //var instance = instances[i]; var dim = new Dimension() { Name = "InstanceId", Value = instance.InstanceId, }; var request = new GetMetricStatisticsRequest() { Dimensions = new List <Dimension> { dim }, Namespace = "AWS/EC2", MetricName = "CPUUtilization", Unit = StandardUnit.Percent, Statistics = new List <string>() { "Average" }, StartTime = DateTime.UtcNow.Subtract(TimeSpan.FromHours(MetricRetrievalInHours)), EndTime = DateTime.UtcNow, Period = (int)TimeSpan.FromMinutes(PeriodInMinutes).TotalSeconds, }; var response = await cwClient.GetMetricStatisticsAsync(request); var max = response.Datapoints.Count < MinServerMetricsToJudge ? UnknownCpuPercent : response.Datapoints.Max(p => p.Average); if (max == UnknownCpuPercent) { instanceResults.UnknownInstances.Add(new InstanceResult(instance, max)); } else if (max < MaxBadCpuPercent) { instanceResults.BadInstances.Add(new InstanceResult(instance, max)); } else { instanceResults.GoodInstances.Add(new InstanceResult(instance, max)); } var processed = instanceResults.BadInstances.Count + instanceResults.UnknownInstances.Count + instanceResults.GoodInstances.Count; Console.Write("\rProcessed {0}/{1} instances.", processed, instances.Count); //depending on your AWS setup you might need to throttle these calls more aggressively //Thread.Sleep(50); }); Console.WriteLine(); return(instanceResults); }