public static void CWGetMetricStatistics()
{
#region CWGetMetricStatistics
var client = new AmazonCloudWatchClient();
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();
}
protected override void OnCreate (Bundle bundle)
{
base.OnCreate (bundle);
// Set our view from the "main" layout resource
SetContentView (Resource.Layout.Main);
// Get our button from the layout resource,
// and attach an event to it
Button button = FindViewById<Button> (Resource.Id.getcloudwatchdata);
EditText cloudwatchdata = FindViewById<EditText> (Resource.Id.cloudwatchdata);
button.Click += delegate {
const string ACCESS_KEY = "";
const string SECRET_KEY = "";
IAmazonCloudWatch cw = Amazon.AWSClientFactory.CreateAmazonCloudWatchClient (ACCESS_KEY, SECRET_KEY, Amazon.RegionEndpoint.USWest1);
string measureName = "CPUUtilization";
GetMetricStatisticsRequest request = new GetMetricStatisticsRequest ();
request.StartTime = DateTime.Now.AddDays (-1);
request.Namespace = "AWS/EC2";
request.Period = 5 * 60;
var dimensions = new Dimension ();
dimensions.Name = "InstanceType";
dimensions.Value = "t1.micro";
request.Dimensions = new List<Dimension>{ dimensions };
request.MetricName = measureName;
request.Statistics = new List<string>{"Average", "Maximum", "Minimum"};
request.EndTime = DateTime.Now;
List<Datapoint> datapoints = cw.GetMetricStatistics(request).Datapoints;
datapoints.ForEach(d => cloudwatchdata.Text = String.Format("Min: {0} Max: {1} Average: {3} Unit: {4}\n", d.Minimum, d.Maximum, d.Average, d.Unit));
};
}
void HandleTouchUpInside (object sender, EventArgs e)
{
const string ACCESS_KEY = "";
const string SECRET_KEY = "";
IAmazonCloudWatch cw = Amazon.AWSClientFactory.CreateAmazonCloudWatchClient (ACCESS_KEY, SECRET_KEY, Amazon.RegionEndpoint.USWest1);
string measureName = "CPUUtilization";
GetMetricStatisticsRequest request = new GetMetricStatisticsRequest ();
request.StartTime = DateTime.Now.AddDays (-1);
request.Namespace = "AWS/EC2";
request.Period = 5 * 60;
var dimensions = new Dimension ();
dimensions.Name = "InstanceType";
dimensions.Value = "t1.micro";
request.Dimensions = new List<Dimension>{ dimensions };
request.MetricName = measureName;
request.Statistics = new List<string>{"Average", "Maximum", "Minimum"};
request.EndTime = DateTime.Now;
List<Datapoint> datapoints = cw.GetMetricStatistics(request).Datapoints;
datapoints.ForEach(d =>
this.View.Add(new UILabel(){
Text = String.Format("Min: {0} Max: {1} Average: {3} Unit: {4}\n", d.Minimum, d.Maximum, d.Average, d.Unit),
Frame = (new RectangleF(20, 40*datapoints.FindIndex(dp => dp==d), 280, 21))
}));
}
public static List<CloudWatchResultRecord> GetCpuUtilization(string instanceId, int minutesBack)
{
var cloudWatchClient = CloudWatchConnectionProvider.GetCloudWatchConnection();
var dimension = new Dimension
{
Name = "InstanceId",
Value = instanceId,
};
var request = new GetMetricStatisticsRequest();
request.Dimensions.Add(dimension);
var currentTime = DateTime.UtcNow;
var startTime = currentTime.AddDays(-1);
request.StartTime = startTime;
request.EndTime = currentTime;
request.Namespace = "AWS/EC2";
request.Statistics.Add("Maximum");
request.Statistics.Add("Average");
request.MetricName = "CPUUtilization";
request.Period = 60;
var response = cloudWatchClient.GetMetricStatistics(request);
if (response.GetMetricStatisticsResult.Datapoints.Count > 0)
{
var result = new List<CloudWatchResultRecord>();
int counter = 0;
foreach(var dataPoint in response.GetMetricStatisticsResult.Datapoints)
{
result.Add(new CloudWatchResultRecord()
{
RecordId = counter,
CpuAverage = dataPoint.Average
});
}
return result;
}
else
{
return null;
}
}
/// <summary>
/// Initiates the asynchronous execution of the GetMetricStatistics operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetMetricStatistics operation on AmazonCloudWatchClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetMetricStatistics
/// operation.</returns>
public IAsyncResult BeginGetMetricStatistics(GetMetricStatisticsRequest request, AsyncCallback callback, object state)
{
var marshaller = new GetMetricStatisticsRequestMarshaller();
var unmarshaller = GetMetricStatisticsResponseUnmarshaller.Instance;
return BeginInvoke<GetMetricStatisticsRequest>(request, marshaller, unmarshaller,
callback, state);
}
/// <summary>
/// Gets statistics for the specified metric.
///
///
/// <para>
/// The maximum number of data points returned from a single <code>GetMetricStatistics</code>
/// request is 1,440, wereas the maximum number of data points that can be queried is
/// 50,850. 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. Alternatively, you can make multiple
/// requests across adjacent time ranges.
/// </para>
///
/// <para>
/// Amazon CloudWatch aggregates data points based on the length of the <code>period</code>
/// 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.
/// </para>
///
/// <para>
/// The following examples show various statistics allowed by the data point query maximum
/// of 50,850 when you call <code>GetMetricStatistics</code> on Amazon EC2 instances with
/// detailed (one-minute) monitoring enabled:
/// </para>
/// <ul> <li>Statistics for up to 400 instances for a span of one hour</li> <li>Statistics
/// for up to 35 instances over a span of 24 hours</li> <li>Statistics for up to 2 instances
/// over a span of 2 weeks</li> </ul>
/// <para>
/// For information about the namespace, metric names, and dimensions that other Amazon
/// Web Services products use to send metrics to Cloudwatch, go to <a href="http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/CW_Support_For_AWS.html">Amazon
/// CloudWatch Metrics, Namespaces, and Dimensions Reference</a> in the <i>Amazon CloudWatch
/// Developer Guide</i>.
/// </para>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetMetricStatistics service method.</param>
///
/// <returns>The response from the GetMetricStatistics service method, as returned by CloudWatch.</returns>
/// <exception cref="Amazon.CloudWatch.Model.InternalServiceException">
/// Indicates that the request processing has failed due to some unknown error, exception,
/// or failure.
/// </exception>
/// <exception cref="Amazon.CloudWatch.Model.InvalidParameterCombinationException">
/// Parameters that must not be used together were used together.
/// </exception>
/// <exception cref="Amazon.CloudWatch.Model.InvalidParameterValueException">
/// Bad or out-of-range value was supplied for the input parameter.
/// </exception>
/// <exception cref="Amazon.CloudWatch.Model.MissingRequiredParameterException">
/// An input parameter that is mandatory for processing the request is not supplied.
/// </exception>
public GetMetricStatisticsResponse GetMetricStatistics(GetMetricStatisticsRequest request)
{
var marshaller = new GetMetricStatisticsRequestMarshaller();
var unmarshaller = GetMetricStatisticsResponseUnmarshaller.Instance;
return Invoke<GetMetricStatisticsRequest,GetMetricStatisticsResponse>(request, marshaller, unmarshaller);
}
/// <summary>
/// <para> Gets statistics for the specified metric. </para> <para> The maximum number of data points returned from a single
/// <c>GetMetricStatistics</c> request is 1,440, wereas the maximum number of data points that can be queried is 50,850. 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. Alternatively, you can make multiple requests across adjacent time ranges. </para>
/// <para> Amazon CloudWatch aggregates data points based on the length of the <c>period</c> 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. </para> <para> The following examples show
/// various statistics allowed by the data point query maximum of 50,850 when you call <c>GetMetricStatistics</c> on Amazon EC2 instances with
/// detailed (one-minute) monitoring enabled: </para>
/// <ul>
/// <li>Statistics for up to 400 instances for a span of one hour</li>
/// <li>Statistics for up to 35 instances over a span of 24 hours</li>
/// <li>Statistics for up to 2 instances over a span of 2 weeks</li>
///
/// </ul>
/// <para> For information about the namespace, metric names, and dimensions that other Amazon Web Services products use to send metrics to
/// Cloudwatch, go to <a href="http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/CW_Support_For_AWS.html">Amazon CloudWatch
/// Metrics, Namespaces, and Dimensions Reference</a> in the <i>Amazon CloudWatch Developer Guide</i> .
/// </para>
/// </summary>
///
/// <param name="getMetricStatisticsRequest">Container for the necessary parameters to execute the GetMetricStatistics service method on
/// AmazonCloudWatch.</param>
///
/// <returns>The response from the GetMetricStatistics service method, as returned by AmazonCloudWatch.</returns>
///
/// <exception cref="T:Amazon.CloudWatch.Model.InvalidParameterValueException" />
/// <exception cref="T:Amazon.CloudWatch.Model.InternalServiceException" />
/// <exception cref="T:Amazon.CloudWatch.Model.InvalidParameterCombinationException" />
/// <exception cref="T:Amazon.CloudWatch.Model.MissingRequiredParameterException" />
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
public Task<GetMetricStatisticsResponse> GetMetricStatisticsAsync(GetMetricStatisticsRequest getMetricStatisticsRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetMetricStatisticsRequestMarshaller();
var unmarshaller = GetMetricStatisticsResponseUnmarshaller.GetInstance();
return Invoke<IRequest, GetMetricStatisticsRequest, GetMetricStatisticsResponse>(getMetricStatisticsRequest, marshaller, unmarshaller, signer, cancellationToken);
}
internal GetMetricStatisticsResponse GetMetricStatistics(GetMetricStatisticsRequest request)
{
var task = GetMetricStatisticsAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
throw e.InnerException;
}
}
/// <summary>
/// <para> Gets statistics for the specified metric. </para> <para> The maximum number of data points returned from a single
/// <c>GetMetricStatistics</c> request is 1,440, wereas the maximum number of data points that can be queried is 50,850. 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. Alternatively, you can make multiple requests across adjacent time ranges. </para>
/// <para> Amazon CloudWatch aggregates data points based on the length of the <c>period</c> 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. </para> <para> The following examples show
/// various statistics allowed by the data point query maximum of 50,850 when you call <c>GetMetricStatistics</c> on Amazon EC2 instances with
/// detailed (one-minute) monitoring enabled: </para>
/// <ul>
/// <li>Statistics for up to 400 instances for a span of one hour</li>
/// <li>Statistics for up to 35 instances over a span of 24 hours</li>
/// <li>Statistics for up to 2 instances over a span of 2 weeks</li>
///
/// </ul>
/// <para> For information about the namespace, metric names, and dimensions that other Amazon Web Services products use to send metrics to
/// Cloudwatch, go to <a href="http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/CW_Support_For_AWS.html">Amazon CloudWatch
/// Metrics, Namespaces, and Dimensions Reference</a> in the <i>Amazon CloudWatch Developer Guide</i> .
/// </para>
/// </summary>
///
/// <param name="getMetricStatisticsRequest">Container for the necessary parameters to execute the GetMetricStatistics service method on
/// AmazonCloudWatch.</param>
///
/// <returns>The response from the GetMetricStatistics service method, as returned by AmazonCloudWatch.</returns>
///
/// <exception cref="T:Amazon.CloudWatch.Model.InvalidParameterValueException" />
/// <exception cref="T:Amazon.CloudWatch.Model.InternalServiceException" />
/// <exception cref="T:Amazon.CloudWatch.Model.InvalidParameterCombinationException" />
/// <exception cref="T:Amazon.CloudWatch.Model.MissingRequiredParameterException" />
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
public async Task<GetMetricStatisticsResponse> GetMetricStatisticsAsync(GetMetricStatisticsRequest getMetricStatisticsRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetMetricStatisticsRequestMarshaller();
var unmarshaller = GetMetricStatisticsResponseUnmarshaller.GetInstance();
var response = await Invoke<IRequest, GetMetricStatisticsRequest, GetMetricStatisticsResponse>(getMetricStatisticsRequest, marshaller, unmarshaller, signer, cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
return response;
}
private async Task<GetMetricStatisticsResponse> GetMetricResponse(string tableName, string indexName, string metricName, CancellationToken cancellationToken)
{
var dimensions = GetDimensions(tableName, indexName);
var completeMetricName = CalculateMetricName(tableName, indexName, metricName);
var request = new GetMetricStatisticsRequest
{
Namespace = DynamoDbMetricNamespace,
Dimensions = dimensions,
MetricName = completeMetricName,
Period = 60,
StartTime = DateTime.UtcNow.Subtract(MetricTimeSpan),
EndTime = DateTime.UtcNow,
Statistics = new[] { "Average", "Sum" }.ToList()
};
return await client.GetMetricStatisticsAsync(request, cancellationToken);
}
private Amazon.CloudWatch.Model.GetMetricStatisticsResponse CallAWSServiceOperation(IAmazonCloudWatch client, Amazon.CloudWatch.Model.GetMetricStatisticsRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon CloudWatch", "GetMetricStatistics");
try
{
#if DESKTOP
return(client.GetMetricStatistics(request));
#elif CORECLR
return(client.GetMetricStatisticsAsync(request).GetAwaiter().GetResult());
#else
#error "Unknown build edition"
#endif
}
catch (AmazonServiceException exc)
{
var webException = exc.InnerException as System.Net.WebException;
if (webException != null)
{
throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
}
throw;
}
}
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginPutMetricData.</param>
public PutMetricDataResponse EndPutMetricData(IAsyncResult asyncResult)
{
return endOperation<PutMetricDataResponse>(asyncResult);
}
IAsyncResult invokePutMetricData(PutMetricDataRequest putMetricDataRequest, AsyncCallback callback, object state, bool synchronized)
{
IRequest irequest = new PutMetricDataRequestMarshaller().Marshall(putMetricDataRequest);
var unmarshaller = PutMetricDataResponseUnmarshaller.GetInstance();
AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
Invoke(result);
return result;
}
internal GetMetricStatisticsResponse GetMetricStatistics(GetMetricStatisticsRequest request)
{
var task = GetMetricStatisticsAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return null;
}
}
/// <summary>
/// Initiates the asynchronous execution of the GetMetricStatistics operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetMetricStatistics operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<GetMetricStatisticsResponse> GetMetricStatisticsAsync(GetMetricStatisticsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetMetricStatisticsRequestMarshaller();
var unmarshaller = GetMetricStatisticsResponseUnmarshaller.Instance;
return InvokeAsync<GetMetricStatisticsRequest,GetMetricStatisticsResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
protected override void ProcessRecord()
{
AmazonCloudWatch client = base.GetClient();
Amazon.CloudWatch.Model.GetMetricStatisticsRequest request = new Amazon.CloudWatch.Model.GetMetricStatisticsRequest();
if (string.IsNullOrEmpty(this._Statistics))
{
request.Statistics.Add(this._Statistics);
}
request.Period = this._Period;
request.MeasureName = this._MeasureName;
request.StartTime = this._StartTime;
request.EndTime = this._EndTime;
request.Unit = this._Unit;
request.CustomUnit = this._CustomUnit;
request.Namespace = this._Namespace;
Amazon.CloudWatch.Model.GetMetricStatisticsResponse response = client.GetMetricStatistics(request);
base.WriteObject(response.GetMetricStatisticsResult, true);
}
#endregion
#region DescribeAlarmsForMetric
/// <summary>
/// <para> Retrieves all alarms for a single metric. Specify a statistic, period, or unit to filter the set of alarms further. </para>
/// </summary>
///
/// <param name="describeAlarmsForMetricRequest">Container for the necessary parameters to execute the DescribeAlarmsForMetric service method on
/// AmazonCloudWatch.</param>
///
/// <returns>The response from the DescribeAlarmsForMetric service method, as returned by AmazonCloudWatch.</returns>
///
public DescribeAlarmsForMetricResponse DescribeAlarmsForMetric(DescribeAlarmsForMetricRequest describeAlarmsForMetricRequest)
{
IAsyncResult asyncResult = invokeDescribeAlarmsForMetric(describeAlarmsForMetricRequest, null, null, true);
return EndDescribeAlarmsForMetric(asyncResult);
}
/// <summary>
/// Initiates the asynchronous execution of the DescribeAlarmsForMetric operation.
/// <seealso cref="Amazon.CloudWatch.AmazonCloudWatch.DescribeAlarmsForMetric"/>
/// </summary>
///
/// <param name="describeAlarmsForMetricRequest">Container for the necessary parameters to execute the DescribeAlarmsForMetric operation on
/// AmazonCloudWatch.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking
public object Execute(ExecutorContext context)
{
var cmdletContext = context as CmdletContext;
// create request
var request = new Amazon.CloudWatch.Model.GetMetricStatisticsRequest();
if (cmdletContext.Dimension != null)
{
request.Dimensions = cmdletContext.Dimension;
}
if (cmdletContext.UtcEndTime != null)
{
request.EndTimeUtc = cmdletContext.UtcEndTime.Value;
}
if (cmdletContext.ExtendedStatistic != null)
{
request.ExtendedStatistics = cmdletContext.ExtendedStatistic;
}
if (cmdletContext.MetricName != null)
{
request.MetricName = cmdletContext.MetricName;
}
if (cmdletContext.Namespace != null)
{
request.Namespace = cmdletContext.Namespace;
}
if (cmdletContext.Period != null)
{
request.Period = cmdletContext.Period.Value;
}
if (cmdletContext.UtcStartTime != null)
{
request.StartTimeUtc = cmdletContext.UtcStartTime.Value;
}
if (cmdletContext.Statistic != null)
{
request.Statistics = cmdletContext.Statistic;
}
if (cmdletContext.Unit != null)
{
request.Unit = cmdletContext.Unit;
}
#pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute
if (cmdletContext.EndTime != null)
{
if (cmdletContext.UtcEndTime != null)
{
throw new System.ArgumentException("Parameters EndTime and UtcEndTime are mutually exclusive.", nameof(this.EndTime));
}
request.EndTime = cmdletContext.EndTime.Value;
}
#pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute
#pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute
if (cmdletContext.StartTime != null)
{
if (cmdletContext.UtcStartTime != null)
{
throw new System.ArgumentException("Parameters StartTime and UtcStartTime are mutually exclusive.", nameof(this.StartTime));
}
request.StartTime = cmdletContext.StartTime.Value;
}
#pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute
CmdletOutput output;
// issue call
var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
try
{
var response = CallAWSServiceOperation(client, request);
object pipelineOutput = null;
pipelineOutput = cmdletContext.Select(response, this);
output = new CmdletOutput
{
PipelineOutput = pipelineOutput,
ServiceResponse = response
};
}
catch (Exception e)
{
output = new CmdletOutput {
ErrorResponse = e
};
}
return(output);
}
/// <summary>
/// Finishes the asynchronous execution of the EnableAlarmActions operation.
/// <seealso cref="Amazon.CloudWatch.AmazonCloudWatch.EnableAlarmActions"/>
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginEnableAlarmActions.</param>
public EnableAlarmActionsResponse EndEnableAlarmActions(IAsyncResult asyncResult)
{
/// <summary>
/// <para> Gets statistics for the specified metric. </para>
/// <para><b>NOTE:</b> The maximum number of data points returned from a
/// single GetMetricStatistics request is 1,440. If a request is made that
/// generates more than 1,440 data points, Amazon CloudWatch returns an
/// error. In such a case, alter the request by narrowing the specified
/// time range or increasing the specified period. Alternatively, make
/// multiple requests across adjacent time ranges. </para> <para> Amazon
/// CloudWatch aggregates data points based on the length of the
/// <c>period</c> 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. </para> <para><b>NOTE:</b> The maximum number of data
/// points that can be queried is 50,850; whereas the maximum number of
/// data points returned is 1,440. </para> <para> The following examples
/// show various statistics allowed by the data point query maximum of
/// 50,850 when you call <c>GetMetricStatistics</c> on Amazon EC2
/// instances with detailed (one-minute) monitoring enabled: </para>
/// <ul>
/// <li>Statistics for up to 400 instances for a span of one hour</li>
/// <li>Statistics for up to 35 instances over a span of 24 hours</li>
/// <li>Statistics for up to 2 instances over a span of 2 weeks</li>
///
/// </ul>
/// </summary>
///
/// <param name="getMetricStatisticsRequest">Container for the necessary
/// parameters to execute the GetMetricStatistics service method on
/// AmazonCloudWatch.</param>
///
/// <returns>The response from the GetMetricStatistics service method, as
/// returned by AmazonCloudWatch.</returns>
///
/// <exception cref="InvalidParameterValueException"/>
/// <exception cref="InternalServiceException"/>
/// <exception cref="InvalidParameterCombinationException"/>
/// <exception cref="MissingRequiredParameterException"/>
public GetMetricStatisticsResponse GetMetricStatistics(GetMetricStatisticsRequest getMetricStatisticsRequest)
{
IRequest<GetMetricStatisticsRequest> request = new GetMetricStatisticsRequestMarshaller().Marshall(getMetricStatisticsRequest);
GetMetricStatisticsResponse response = Invoke<GetMetricStatisticsRequest, GetMetricStatisticsResponse> (request, this.signer, GetMetricStatisticsResponseUnmarshaller.GetInstance());
return response;
}
private List<Datapoint> getData(int metricID, DateTime startdate, int days, int period)
{
List<Datapoint> datapoints = new List<Datapoint>();
Metric metric = metricList[metricID];
GetMetricStatisticsRequest request = new GetMetricStatisticsRequest();
request.MetricName = metric.MetricName;
request.Namespace = metric.Namespace;
request.Dimensions = metric.Dimensions;
request.Statistics.AddRange(statList);
request.Period = period;
try
{
for (int day = 0; day < days; day++)
{
request.StartTime = startdate.AddDays(day);
request.EndTime = startdate.AddDays(day + 1);
GetMetricStatisticsResult result = cw.GetMetricStatistics(request).GetMetricStatisticsResult;
datapoints.AddRange(result.Datapoints);
}
datapoints.Sort((p1, p2) => DateTime.Compare(p1.Timestamp, p2.Timestamp));
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return datapoints;
}
