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);
}
