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();
}
public async Task<SummaryResult> GetDataBlob()
{
var cloudwatch = new AmazonCloudWatchClient(RegionEndpoint.APNortheast1);
var res = await cloudwatch.GetMetricStatisticsAsync(new GetMetricStatisticsRequest()
{
Namespace = @"AWS/ELB",
MetricName = "RequestCount",
Statistics = new List<string>() { "Sum" },
Unit = StandardUnit.Count,
Dimensions = new List<Dimension>()
{
new Dimension() { Name = "LoadBalancerName", Value = ConfigurationManager.AppSettings["ELBName"] },
new Dimension() { Name = "AvailabilityZone", Value = ConfigurationManager.AppSettings["AvailabilityZone"] }
},
StartTime = DateTime.UtcNow - TimeSpan.FromDays(30),
EndTime = DateTime.UtcNow,
Period = 60 * 60
});
return new SummaryResult()
{
MaxValue = (int)res.Datapoints.Max(d => d.Sum),
MinValue = (int)res.Datapoints.Min(d => d.Sum),
Groups = res.Datapoints.Select(d => new DateData() { Date = d.Timestamp.Date, Hour = d.Timestamp.Hour, Y = d.Sum })
.GroupBy(d => d.Date)
.OrderBy(d => d.Key)
.ToDictionary(d => d.Key, d => d.OrderBy(da => da.Hour).ToList())
.Select(pair => new DateGroup()
{
Key = pair.Key,
Values = pair.Value,
})
};
}
private static GetMetricStatisticsResponse GetCWMetrics(Metric metric, List <string> statisticTypeList, int metricPeriod)
{
var clientCW = new Amazon.CloudWatch.AmazonCloudWatchClient();
var cwMetrics = clientCW.GetMetricStatistics(new GetMetricStatisticsRequest
{
Namespace = metric.Namespace,
MetricName = metric.MetricName,
StartTime = DateTime.UtcNow.AddDays(-1),
EndTime = DateTime.UtcNow,
Period = metricPeriod,
Statistics = statisticTypeList,
Dimensions = metric.Dimensions
});
return(cwMetrics);
}
public void GetMetrics()
{
var clientCW = new Amazon.CloudWatch.AmazonCloudWatchClient();
var instanceList = GetInstanceList();
var availableMetrics = clientCW.ListMetrics();
foreach (var metric in availableMetrics.Metrics)
{
var statisticTypes = ConfigurationManager.AppSettings["MetricStatisticTypes"];
var statisticTypeList = statisticTypes.Split(';').ToList();
int metricPeriod = Convert.ToInt32(ConfigurationManager.AppSettings["MetricPeriod"]);
var cwMetrics = GetCWMetrics(metric, statisticTypeList, metricPeriod);
Instance instance = (metric.Dimensions.Count > 0) ? GetInstance(instanceList, metric.Dimensions[0].Value) : null;
DBManager.SaveCWMetrics(metric, cwMetrics, instance, statisticTypeList);
FileManager.SaveCWMetrics(metric, cwMetrics, instance, statisticTypeList);
}
S3Manager.UploadMetricFile();
}
static void Main(string[] args)
{
PerformanceCounter percentPageFile = new PerformanceCounter("Paging File", "% Usage", "_Total");
PerformanceCounter peakPageFile = new PerformanceCounter("Paging File", "% Usage Peak", "_Total");
IAmazonCloudWatch client = new AmazonCloudWatchClient(RegionEndpoint.USWest2);
// Once a minute, send paging file usage statistics to CloudWatch
for (; ; )
{
List<MetricDatum> data = new List<MetricDatum>();
data.Add(new MetricDatum()
{
MetricName = "PagingFilePctUsage",
Timestamp = DateTime.Now,
Unit = StandardUnit.Percent,
Value = percentPageFile.NextValue()
});
data.Add(new MetricDatum()
{
MetricName = "PagingFilePctUsagePeak",
Timestamp = DateTime.Now,
Unit = StandardUnit.Percent,
Value = peakPageFile.NextValue()
});
client.PutMetricData(new PutMetricDataRequest()
{
MetricData = data,
Namespace = "System/Windows"
});
Thread.Sleep(1000 * 60);
}
}
public static void CWDisableAlarmActions()
{
#region CWDisableAlarmActions
var client = new AmazonCloudWatchClient();
var request = new DisableAlarmActionsRequest
{
AlarmNames = new List<string>()
{ "awseb-e-kkbEXAMPLE-stack-CloudwatchAlarmLow-1WVXD9EXAMPLE" }
};
client.DisableAlarmActions(request);
#endregion
}
public static void CWSetAlarmState()
{
#region CWSetAlarmState
var client = new AmazonCloudWatchClient();
var request = new SetAlarmStateRequest
{
AlarmName = "Offline Instances",
StateReason = "Too many instances are offline.",
StateValue = StateValue.ALARM
};
client.SetAlarmState(request);
#endregion
}
/// <summary>
/// Given a Profile and Region, return a table with data about bucket sizes,
/// collected from CloudWatch.
/// </summary>
/// <param name="aprofile"></param>
/// <param name="Region2Scan"></param>
/// <returns></returns>
public DataTable S3SizeCloudWatch(string aprofile, string Region2Scan)
{
DataTable ToReturn =AWSTables.GetS3SizesTable();
string accountid = GetAccountID(aprofile);
RegionEndpoint Endpoint2scan = RegionEndpoint.USEast1;
//Convert the Region2Scan to an AWS Endpoint.
foreach (var aregion in RegionEndpoint.EnumerableAllRegions)
{
if (aregion.DisplayName.Equals(Region2Scan))
{
Endpoint2scan = aregion;
continue;
}
}
DataTable metlist = new DataTable();
try
{
var credential = new Amazon.Runtime.StoredProfileAWSCredentials(aprofile);
AmazonCloudWatchClient CWClient = new AmazonCloudWatchClient(credential, Endpoint2scan);
Amazon.CloudWatch.Model.ListMetricsRequest LMReq = new Amazon.CloudWatch.Model.ListMetricsRequest();
//Using to explore the metrics
LMReq.Namespace = "AWS/S3";
LMReq.MetricName = "BucketSizeBytes";
var getmetrics = CWClient.ListMetrics(LMReq).Metrics;
//This is just stuff I used to view data from the List
metlist.Columns.Add("MetricName");
metlist.Columns.Add("NameSpace");
//These are the dimensions for S3.
metlist.Columns.Add("Bucketname");
metlist.Columns.Add("StorageType");
foreach (var ametric in getmetrics)
{
var DR = metlist.NewRow();
try
{
DR["MetricName"] = ametric.MetricName;
DR["NameSpace"] = ametric.Namespace;
var dim = ametric.Dimensions;
//These are the dimensions for S3.
DR["BucketName"] = dim[0].Value;
DR["StorageType"] = dim[1].Value;
metlist.Rows.Add(DR);
}
catch(Exception ex)
{
}
}
// Okay, collect the daters for these here buckets
foreach (var abucket in metlist.AsEnumerable())
{
Amazon.CloudWatch.Model.GetMetricStatisticsRequest GMReq = new Amazon.CloudWatch.Model.GetMetricStatisticsRequest();
string bucketname = abucket[2].ToString();
string storagetype = abucket[3].ToString();
try
{
Amazon.CloudWatch.Model.Dimension dimbo = new Amazon.CloudWatch.Model.Dimension();
dimbo.Name = "BucketName";
dimbo.Value = bucketname;
GMReq.Dimensions.Add(dimbo);
Amazon.CloudWatch.Model.Dimension dimbo2 = new Amazon.CloudWatch.Model.Dimension();
dimbo2.Name = "StorageType";
dimbo2.Value = storagetype;
GMReq.Dimensions.Add(dimbo2);
//Build the request:
GMReq.Namespace = "AWS/S3";
GMReq.EndTime = DateTime.Now;
GMReq.StartTime = DateTime.Now - TimeSpan.FromDays(21);
GMReq.Period = (60 * 60 * 24 * 7);//Seconds in a week.
GMReq.Statistics.Add("Minimum");
GMReq.Statistics.Add("Maximum");
GMReq.Statistics.Add("Average");
GMReq.MetricName = "BucketSizeBytes";
//Execute request:
var metricresponse = CWClient.GetMetricStatistics(GMReq);
//Process Return
var dp = metricresponse.Datapoints;
if(dp.Count==0)
{
//none
}
var arow = ToReturn.NewRow();
Dictionary<DateTime, Amazon.CloudWatch.Model.Datapoint> sortem = new Dictionary<DateTime, Amazon.CloudWatch.Model.Datapoint>();
foreach(var ap in dp)
{
sortem.Add(ap.Timestamp, ap);
}
var sorteddates = sortem.Keys.ToList();
sorteddates.Sort();
var firstpass = true;
foreach(var key in sorteddates)
{
var ap = sortem[key];
var min = ap.Minimum;
var max = ap.Maximum;
var av = ap.Average;
var ts = ap.Timestamp;
if (firstpass)
{
firstpass = false;
arow["AccountID"] = accountid;
arow["Profile"] = aprofile;
arow["Bucket"] = bucketname;
arow["Region"] = Region2Scan;
arow["StartDate"] = ts.ToShortDateString();
arow["EndDate"] = ts.ToShortDateString();
arow["StartSizeMin"] =GetFileSize( min);
arow["StartSizeMax"] =GetFileSize( max);
arow["StartSizeAVG"]= GetFileSize(av);
}
else
{
arow["EndDate"] = ts.ToShortDateString();
arow["EndSizeMin"] = GetFileSize(min);
arow["EndSizeAVG"] = GetFileSize(av);
arow["EndSizeMax"] = GetFileSize(max);
arow["EndSizeMaxBytes"] = Math.Round(av);
}
}
ToReturn.Rows.Add(arow.ItemArray);
}
catch(Exception ex)
{
}
}
}
catch(Exception ex)
{
}
int buckets = metlist.Rows.Count;
int returning = ToReturn.Rows.Count;
return ToReturn;
}
public static void CWDescribeAlarmsForMetric()
{
#region CWDescribeAlarmsForMetric
var client = new AmazonCloudWatchClient();
var dimension = new Dimension
{
Name = "AutoScalingGroupName",
Value = "awseb-e-kkbEXAMPLE-stack-AutoScalingGroup-F4TAUEXAMPLE"
};
var request = new DescribeAlarmsForMetricRequest
{
Dimensions = new List<Dimension>() { dimension },
MetricName = "NetworkOut",
Namespace = "AWS/EC2"
};
var response = client.DescribeAlarmsForMetric(request);
if (response.MetricAlarms.Count > 0)
{
foreach (var alarm in response.MetricAlarms)
{
Console.WriteLine();
Console.WriteLine(alarm.AlarmName);
Console.WriteLine(alarm.AlarmDescription);
Console.WriteLine(alarm.MetricName + " " +
alarm.ComparisonOperator + " " + alarm.Threshold);
}
}
else
{
Console.WriteLine("No alarms.");
}
#endregion
Console.ReadLine();
}
public static void CWPutMetricAlarm()
{
#region CWPutMetricAlarm
var client = new AmazonCloudWatchClient();
var dimension = new Dimension
{
Name = "Desktop Machine Metrics",
Value = "Virtual Desktop Machine Usage"
};
var request = new PutMetricAlarmRequest
{
ActionsEnabled = true,
AlarmActions = new List<string>()
{ "arn:aws:sns:us-east-1:80398EXAMPLE:CodingTestResults" },
AlarmDescription = "Too many instances offline",
AlarmName = "Offline Instances",
ComparisonOperator = ComparisonOperator.GreaterThanOrEqualToThreshold,
Dimensions = new List<Dimension>() { dimension },
EvaluationPeriods = 1,
MetricName = "Desktop Machines Offline",
Namespace = "Example.com Custom Metrics",
Period = (int)TimeSpan.FromMinutes(5).TotalSeconds,
Statistic = new Statistic("Maximum"),
Threshold = 5,
Unit = StandardUnit.Count
};
client.PutMetricAlarm(request);
#endregion
}
public static void CWDescribeAlarmHistory()
{
#region CWDescribeAlarmHistory
var client = new AmazonCloudWatchClient();
var request = new DescribeAlarmHistoryRequest
{
AlarmName =
"awseb-e-kkbEXAMPLE-stack-CloudwatchAlarmLow-1WVXD9EXAMPLE",
EndDate = DateTime.Today,
HistoryItemType = HistoryItemType.Action,
MaxRecords = 1,
StartDate = DateTime.Today.Subtract(TimeSpan.FromDays(30))
};
var response = new DescribeAlarmHistoryResponse();
do
{
response = client.DescribeAlarmHistory(request);
foreach (var item in response.AlarmHistoryItems)
{
Console.WriteLine(item.AlarmName);
Console.WriteLine(item.HistorySummary);
Console.WriteLine();
}
request.NextToken = response.NextToken;
} while (!string.IsNullOrEmpty(response.NextToken));
#endregion
Console.ReadLine();
}
public static void CWDescribeAlarms()
{
#region CWDescribeAlarms
var client = new AmazonCloudWatchClient();
var request = new DescribeAlarmsRequest
{
AlarmNames = new List<string>()
{ "awseb-e-b36EXAMPLE-stack-CloudwatchAlarmLow-1KAKH4EXAMPLE" },
MaxRecords = 1,
StateValue = StateValue.ALARM
};
var response = new DescribeAlarmsResponse();
do
{
response = client.DescribeAlarms(request);
foreach (var alarm in response.MetricAlarms)
{
Console.WriteLine(alarm.AlarmName);
Console.WriteLine(alarm.AlarmDescription);
Console.WriteLine(alarm.MetricName + " " +
alarm.ComparisonOperator + " " + alarm.Threshold);
Console.WriteLine();
}
request.NextToken = response.NextToken;
} while (!string.IsNullOrEmpty(response.NextToken));
#endregion
Console.ReadLine();
}
public static void CWListMetrics()
{
#region CWListMetrics
var client = new AmazonCloudWatchClient();
var filter = new DimensionFilter
{
Name = "InstanceType",
Value = "t1.micro"
};
var request = new ListMetricsRequest
{
Dimensions = new List<DimensionFilter>() { filter },
MetricName = "CPUUtilization",
Namespace = "AWS/EC2"
};
var response = new ListMetricsResponse();
do
{
response = client.ListMetrics(request);
if (response.Metrics.Count > 0)
{
foreach (var metric in response.Metrics)
{
Console.WriteLine(metric.MetricName +
" (" + metric.Namespace + ")");
foreach (var dimension in metric.Dimensions)
{
Console.WriteLine(" " + dimension.Name + ": "
+ dimension.Value);
}
}
}
else
{
Console.WriteLine("No metrics found.");
}
request.NextToken = response.NextToken;
} while (!string.IsNullOrEmpty(response.NextToken));
#endregion
Console.ReadLine();
}
public static void CWDeleteAlarms()
{
#region CWDeleteAlarms
var client = new AmazonCloudWatchClient();
var request = new DeleteAlarmsRequest
{
AlarmNames = new List<string>() { "t1.microCPUUtilization" }
};
client.DeleteAlarms(request);
#endregion
}
protected virtual AmazonCloudWatch GetClient()
{
AmazonCredentials.KeyPair credentials = base.GetCredentials();
AmazonCloudWatch client = new AmazonCloudWatchClient(credentials.AwsAccessKeyId, credentials.AwsSecretAccessKey);
return client;
}
/// <summary>
/// Sets the Amazon Web Services credentials.
/// </summary>
/// <param name="accessKeyId">The access key id.</param>
/// <param name="secretAccessKey">The secret access key.</param>
public void SetAwsCredentials(string accessKeyId, string secretAccessKey)
{
logger.Info("Setting new AWS credentials with AccessKeyID '{0}'", accessKeyId);
//
// Update configuration
//
lock (Configuration)
{
Configuration.AwsAccessKeyId = accessKeyId;
Configuration.AwsSecretAccessKey = secretAccessKey;
Configuration.Save();
}
//
// Replace AWS client
//
lock (awsClientSyncRoot)
{
AwsClient = new AmazonCloudWatchClient(accessKeyId, secretAccessKey);
}
}
/// <summary>
/// Starts collecting and uploading metrics.
/// </summary>
public void Start()
{
logger.Info("Starting CloudWatch Service");
Configuration = CloudWatchServiceConfiguration.Load();
lock (Configuration)
{
logger.Info("Creating AWS Client with AccessKeyID '{0}'", Configuration.AwsAccessKeyId);
AwsClient = new AmazonCloudWatchClient(Configuration.AwsAccessKeyId, Configuration.AwsSecretAccessKey);
foreach (var metric in Configuration.Metrics)
{
metric.StopEvent = new ManualResetEvent(false);
logger.Info("Registering Metric '{0}'", metric.Name);
RegisterMetricForProcessing(metric);
}
}
try
{
logger.Info("Opening Mangement interface at {0}", ManagementServiceHost.BaseAddresses[0]);
ManagementServiceHost.Open();
}
catch (Exception ex)
{
logger.Error(ex);
}
try
{
logger.Info("Retrieving Instance ID for EC2 instance");
var client = new System.Net.WebClient();
InstanceId = client.DownloadString("http://169.254.169.254/2009-04-04/meta-data/instance-id");
logger.Info("Local Instance ID is '{0}'", InstanceId);
}
catch (Exception ex)
{
logger.Error(ex);
}
try
{
logger.Info("Retrieving Availability Zone for EC2 instance");
var client = new System.Net.WebClient();
AvailabilityZone = client.DownloadString("http://169.254.169.254/2009-04-04/meta-data/placement/availability-zone");
logger.Info("Availability Zone is '{0}'", AvailabilityZone);
}
catch (Exception ex)
{
logger.Error(ex);
}
}
public static void CWPutMetricData()
{
#region CWPutMetricData
var client = new AmazonCloudWatchClient();
var dimension = new Dimension
{
Name = "Desktop Machine Metrics",
Value = "Virtual Desktop Machine Usage"
};
var metric1 = new MetricDatum
{
Dimensions = new List<Dimension>(),
MetricName = "Desktop Machines Online",
StatisticValues = new StatisticSet(),
Timestamp = DateTime.Today,
Unit = StandardUnit.Count,
Value = 14
};
var metric2 = new MetricDatum
{
Dimensions = new List<Dimension>(),
MetricName = "Desktop Machines Offline",
StatisticValues = new StatisticSet(),
Timestamp = DateTime.Today,
Unit = StandardUnit.Count,
Value = 7
};
var metric3 = new MetricDatum
{
Dimensions = new List<Dimension>(),
MetricName = "Desktop Machines Online",
StatisticValues = new StatisticSet(),
Timestamp = DateTime.Today,
Unit = StandardUnit.Count,
Value = 12
};
var metric4 = new MetricDatum
{
Dimensions = new List<Dimension>(),
MetricName = "Desktop Machines Offline",
StatisticValues = new StatisticSet(),
Timestamp = DateTime.Today,
Unit = StandardUnit.Count,
Value = 9
};
var request = new PutMetricDataRequest
{
MetricData = new List<MetricDatum>() { metric1, metric2,
metric3, metric4 },
Namespace = "Example.com Custom Metrics"
};
client.PutMetricData(request);
#endregion
}
