private void PutPerformanceMetricDataForProcess(AmazonCloudWatchClient client, Process process) { var memoryUsage = 0.0; var cpuUsage = 0.0f; using (process) { var instance = new PerformanceCounter("Process", "% Processor Time", process.ProcessName, true); memoryUsage = Math.Round(process.PrivateMemorySize64 / 1024.0 / 1024.0, 2); cpuUsage = instance.NextValue(); } client.PutMetricData(new PutMetricDataRequest { Namespace = $"MemoryCPUServicesUsage/{process.ProcessName}", MetricData = new List <MetricDatum> { new MetricDatum { MetricName = "Memory Usage", Unit = StandardUnit.Megabits, Value = memoryUsage, Dimensions = MetricDatumDimensions }, new MetricDatum { MetricName = "CPU Usage", Unit = StandardUnit.Percent, Value = cpuUsage, Dimensions = MetricDatumDimensions } } }); }
public static async Task Main() { IAmazonCloudWatch cwClient = new AmazonCloudWatchClient(); var dashboards = await ListDashboardsAsync(cwClient); DisplayDashboardList(dashboards); }
/// <summary> /// Opens the component. /// </summary> /// <param name="correlationId">(optional) transaction id to trace execution through call chain.</param> public async Task OpenAsync(string correlationId) { if (_opened) { return; } var awsConnection = await _connectionResolver.ResolveAsync(correlationId); // Validate connection params var err = awsConnection.Validate(correlationId); if (err != null) { throw err; } // Create client var region = RegionEndpoint.GetBySystemName(awsConnection.Region); var config = new AmazonCloudWatchConfig() { RegionEndpoint = region }; _client = new AmazonCloudWatchClient(awsConnection.AccessId, awsConnection.AccessKey, config); _opened = true; await Task.Delay(0); }
public CloudWatchMetrics(AmazonCloudWatchClient cloudWatchClient, ILogger <CloudWatchMetrics> logger) { this.cloudWatchClient = cloudWatchClient; this.logger = logger; MetricData = new List <MetricDatum>(); }
public static string PushMetrics(string ns, List <MetricDatum> metrics) { var request = new PutMetricDataRequest { Namespace = ns, MetricData = metrics }; // Amazon.Runtime.AWSCredentials credentials = null; if (Configuration.IsLinux()) { string AccessKey = "xxx"; string SecretKey = "xxx"; credentials = new Amazon.Runtime.BasicAWSCredentials(AccessKey, SecretKey); } else { credentials = new Amazon.Runtime.StoredProfileAWSCredentials("cloudwatch"); } // var client = new AmazonCloudWatchClient(credentials, Amazon.RegionEndpoint.APSoutheast1); System.Threading.Tasks.Task <PutMetricDataResponse> task = client.PutMetricDataAsync(request); PutMetricDataResponse response = task.Result; // System.Net.HttpStatusCode statusCode = response.HttpStatusCode; Console.WriteLine(DateTime.Now.ToString("HH:mm ") + statusCode.ToString()); return(statusCode.ToString()); }
public CloudWatchMetricsReporter(MetricsReportingCloudWatchOptions options) { if (options == null) { throw new ArgumentNullException(nameof(options)); } if (options.FlushInterval < TimeSpan.Zero) { throw new InvalidOperationException($"{nameof(MetricsReportingCloudWatchOptions.FlushInterval)} must not be less than zero"); } FlushInterval = options.FlushInterval > TimeSpan.Zero ? options.FlushInterval : AppMetricsConstants.Reporting.DefaultFlushInterval; Filter = options.Filter; _namespace = options.AwsNamespace; if (!string.IsNullOrEmpty(options.AccessKeyId) && !string.IsNullOrEmpty(options.SecretAccessKey)) { _client = new AmazonCloudWatchClient(options.AccessKeyId, options.SecretAccessKey, options.Endpoint); } else { _client = new AmazonCloudWatchClient(options.Endpoint); } _dimensions = options.Dimensions; Logger.Info($"Using Metrics Reporter {this}. FlushInterval: {FlushInterval}"); }
/// <summary> /// Closes component and frees used resources. /// </summary> /// <param name="correlationId">(optional) transaction id to trace execution through call chain.</param> public async Task CloseAsync(string correlationId) { _opened = false; _client = null; await Task.Delay(0); }
public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems) { AmazonCloudWatchConfig config = new AmazonCloudWatchConfig(); config.RegionEndpoint = region; ConfigureClient(config); AmazonCloudWatchClient client = new AmazonCloudWatchClient(creds, config); ListMetricsResponse resp = new ListMetricsResponse(); do { ListMetricsRequest req = new ListMetricsRequest { NextToken = resp.NextToken }; resp = client.ListMetrics(req); CheckError(resp.HttpStatusCode, "200"); foreach (var obj in resp.Metrics) { AddObject(obj); } }while (!string.IsNullOrEmpty(resp.NextToken)); }
public static void PutMetricAlarm() { var client = new AmazonCloudWatchClient(RegionEndpoint.USWest2); client.PutMetricAlarm(new PutMetricAlarmRequest { AlarmName = "Web_Server_CPU_Utilization", ComparisonOperator = ComparisonOperator.GreaterThanThreshold, EvaluationPeriods = 1, MetricName = "CPUUtilization", Namespace = "AWS/EC2", Period = 60, Statistic = Statistic.Average, Threshold = 70.0, ActionsEnabled = true, AlarmActions = new List <string> { "arn:aws:swf:us-west-2:" + "customerAccount" + ":action/actions/AWS_EC2.InstanceId.Reboot/1.0" }, AlarmDescription = "Alarm when server CPU exceeds 70%", Dimensions = new List <Dimension> { new Dimension { Name = "InstanceId", Value = "INSTANCE_ID" } }, Unit = StandardUnit.Seconds }); }
private async Task <PutMetricDataResponse> LogAPICall(PagerDutyAPICallType apiCallType) { IAmazonCloudWatch client = new AmazonCloudWatchClient(); Dimension dimension = new Dimension() { Name = "PagerDuty", Value = "API Calls" }; MetricDatum point = new MetricDatum() { Dimensions = new List <Dimension>() { dimension }, MetricName = apiCallType.ToString(), Unit = StandardUnit.Count, StorageResolution = 1, Value = 1.0 }; PutMetricDataRequest request = new PutMetricDataRequest { MetricData = new List <MetricDatum>() { point }, Namespace = "External API Calls" }; return(await client.PutMetricDataAsync(request)); }
/// <summary> /// Check service health. /// </summary> /// <param name="client">Instance of <see cref="AmazonCloudWatchClient"/> class.</param> /// <returns>Success, RountTripTime.</returns> public static async Task <(bool, double)> CheckServiceReachable(AmazonCloudWatchClient client) { var stopwatch = new Stopwatch(); try { stopwatch.Start(); await client.DescribeAlarmsAsync(new DescribeAlarmsRequest { AlarmNamePrefix = "KinesisTap" }); stopwatch.Stop(); } catch (AmazonCloudWatchException) { stopwatch.Stop(); // Any exception is fine, we are currently only looking to // check if the service is reachable and what is the RTT. return(true, stopwatch.ElapsedMilliseconds); } catch (Exception) { stopwatch.Stop(); return(false, stopwatch.ElapsedMilliseconds); } return(true, stopwatch.ElapsedMilliseconds); }
private static QueueSource InitializeQueueSource() { var creds = CredentialsReader.GetCredentials(); var cloudWatchClient = new AmazonCloudWatchClient(creds, RegionEndpoint.EUWest1); return(new QueueSource(cloudWatchClient)); }
public ShowSentimentMessageProcessor(DiscordClient discordClient, CloudWatchMetrics metrics, ILogger <AbstractDiscordMessageProcessor> logger, AmazonCloudWatchClient cloudWatchClient) : base(discordClient, metrics, logger) { CloudWatchClient = cloudWatchClient; }
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 async Task Main() { IAmazonCloudWatch cwClient = new AmazonCloudWatchClient(); var alarmNames = CreateAlarmNameList(); await DeleteAlarmsAsyncExample(cwClient, alarmNames); }
public static AmazonCloudWatchClient GetAmazonCloudWatchClient() { AmazonCloudWatchClient amazon_cloud_watch_client = (!string.IsNullOrEmpty(access_key_id) && !string.IsNullOrEmpty(secret_access_key) ? new AmazonCloudWatchClient(access_key_id, secret_access_key, GetRegion()) : new AmazonCloudWatchClient(GetRegion())); return(amazon_cloud_watch_client); }
public async Task <GetMetricStatisticsResponse> GetMetricStatistics(GetMetricStatisticsRequest metricStatisticsRequest) { using (var amazonCloudWatchClient = new AmazonCloudWatchClient(awsCredentials, RegionEndpoint.GetBySystemName(Region))) { var response = await amazonCloudWatchClient.GetMetricStatisticsAsync(metricStatisticsRequest); return(response); } }
public static async Task Main() { IAmazonCloudWatch cwClient = new AmazonCloudWatchClient(); string dashboardName = "CloudWatch-Default"; var body = await GetDashboardAsync(cwClient, dashboardName); Console.WriteLine(body); }
public async Task <ListMetricsResponse> ListMetrics() { using (var amazonCloudWatchClient = new AmazonCloudWatchClient(awsCredentials, RegionEndpoint.GetBySystemName(Region))) { var response = await amazonCloudWatchClient.ListMetricsAsync(); return(response); } }
private static IAlarmFinder MakeAlarmFinder() { var cloudwatch = new AmazonCloudWatchClient(CredentialsReader.GetCredentials(), new AmazonCloudWatchConfig { RegionEndpoint = RegionEndpoint.EUWest1 }); return(new AlarmFinder(new ConsoleAlarmLogger(false), cloudwatch)); }
public static void CloudWatchMetricsTest() { var logGroupName = "LogGroupName"; DimensionFilter dimensionFilter = new DimensionFilter() { Name = logGroupName }; var dimensionFilterList = new List <DimensionFilter>(); dimensionFilterList.Add(dimensionFilter); var dimension = new Dimension { Name = "UniquePages", Value = "URLs" }; using (var cw = new AmazonCloudWatchClient(RegionEndpoint.USWest2)) { var listMetricsResponse = cw.ListMetrics(new ListMetricsRequest { Dimensions = dimensionFilterList, MetricName = "IncomingLogEvents", Namespace = "AWS/Logs" }); Console.WriteLine(listMetricsResponse.Metrics); cw.PutMetricData(new PutMetricDataRequest { MetricData = new List <MetricDatum> { new MetricDatum { MetricName = "PagesVisited", Dimensions = new List <Dimension> { dimension }, Unit = "None", Value = 1.0 } }, Namespace = "SITE/TRAFFIC" }); var describeMetricsResponse = cw.DescribeAlarmsForMetric(new DescribeAlarmsForMetricRequest { MetricName = "PagesVisited", Dimensions = new List <Dimension>() { dimension }, Namespace = "SITE/TRAFFIC" }); Console.WriteLine(describeMetricsResponse.MetricAlarms); } }
// Initialize all clients for send to cloudWatch with the clients AmazonCloudWatchEventsClient and AmazonCloudWatchClient public override void Initialize() { //Get all configuration on appsettings. CloudWatchConfiguration cloudWatchConfiuration = LightConfigurator.Config <CloudWatchConfiguration>("CloudWatch"); //Generate a client to send events with te configuration access key and secret key. _amazonCloudEvents = new AmazonCloudWatchEventsClient(cloudWatchConfiuration.AccessKeyID, cloudWatchConfiuration.SecretAccessKey); //Generate a client to send metrics and alarms with te configuration access key and secret key. _amazonCloud = new AmazonCloudWatchClient(cloudWatchConfiuration.AccessKeyID, cloudWatchConfiuration.SecretAccessKey); }
/// <summary> /// Retrieves a list of alarms and then passes each name to the /// DescribeAlarmHistoriesAsync method to retrieve its history. /// </summary> public static async Task Main() { IAmazonCloudWatch cwClient = new AmazonCloudWatchClient(); var response = await cwClient.DescribeAlarmsAsync(); foreach (var alarm in response.MetricAlarms) { await DescribeAlarmHistoriesAsync(cwClient, alarm.AlarmName); } }
public static void DeleteAlarm(List <string> alarmNames) { using (var cloudWatch = new AmazonCloudWatchClient(RegionEndpoint.USWest2)) { var response = cloudWatch.DeleteAlarms( new DeleteAlarmsRequest { AlarmNames = alarmNames }); } }
public static void DisableAlarmActions() { using (var client = new AmazonCloudWatchClient(RegionEndpoint.USWest2)) { client.DisableAlarmActions(new DisableAlarmActionsRequest { AlarmNames = new List <string> { "Web_Server_CPU_Utilization" } }); } }
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 async Task Main() { IAmazonCloudWatch cwClient = new AmazonCloudWatchClient(); var filter = new DimensionFilter { Name = "InstanceType", Value = "t1.micro", }; string metricName = "CPUUtilization"; string namespaceName = "AWS/EC2"; await ListMetricsAsync(cwClient, filter, metricName, namespaceName); }
protected IAmazonCloudWatch CreateClient(AWSCredentials credentials, RegionEndpoint region) { var config = new AmazonCloudWatchConfig { RegionEndpoint = region }; Amazon.PowerShell.Utils.Common.PopulateConfig(this, config); this.CustomizeClientConfig(config); var client = new AmazonCloudWatchClient(credentials, config); client.BeforeRequestEvent += RequestEventHandler; client.AfterResponseEvent += ResponseEventHandler; return(client); }
public TelemetryLogService(ILogger <TelemetryLogService> logger, ICacheStore store, AwsConfiguration awsConfiguration = null, MetricsConfiguration metricsConfiguration = null) { _logger = logger; _metricsConfiguration = metricsConfiguration; _redisStore = store as RedisCacheStore; if (awsConfiguration != null && metricsConfiguration != null) { _amazonCloudWatchClient = new AmazonCloudWatchClient(awsConfiguration.AccessKeyId, awsConfiguration.SecretAccessKey, RegionEndpoint.GetBySystemName(awsConfiguration.Region)); } }
public static void EnableAlarmAction(string instanceId, string customerAccount) { using (var client = new AmazonCloudWatchClient(Amazon.RegionEndpoint.USWest2)) { client.PutMetricAlarm(new PutMetricAlarmRequest { AlarmName = "Web_Server_CPU_Utilization", ComparisonOperator = ComparisonOperator.GreaterThanThreshold, EvaluationPeriods = 1, MetricName = "CPUUtilization", Namespace = "AWS/EC2", Period = 60, Statistic = Statistic.Average, Threshold = 70.0, ActionsEnabled = true, AlarmActions = new List <string> { "arn:aws:swf:us-west-2:" + customerAccount + ":action/actions/AWS_EC2.InstanceId.Reboot/1.0" }, AlarmDescription = "Alarm when server CPU exceeds 70%", Dimensions = new List <Dimension> { new Dimension { Name = "InstanceId", Value = instanceId } }, Unit = StandardUnit.Seconds }); client.EnableAlarmActions(new EnableAlarmActionsRequest { AlarmNames = new List <string> { "Web_Server_CPU_Utilization" } }); MetricDatum metricDatum = new MetricDatum { MetricName = "CPUUtilization" }; PutMetricDataRequest putMetricDatarequest = new PutMetricDataRequest { MetricData = new List <MetricDatum> { metricDatum } }; client.PutMetricData(putMetricDatarequest); } }