public void TrackEvent(string eventName, TimeSpan elapsed, IDictionary <string, string> properties = null) { var dimension = new Dimension { Name = eventName, Value = eventName }; var metric1 = new MetricDatum { Dimensions = new List <Dimension> { dimension }, MetricName = eventName, StatisticValues = new StatisticSet(), TimestampUtc = DateTime.Today, Unit = StandardUnit.Count }; if (properties?.ContainsKey("value") == true) { metric1.Value = long.Parse(properties["value"]); } else { metric1.Value = 1; } var request = new PutMetricDataRequest { MetricData = new List <MetricDatum> { metric1 }, Namespace = eventName }; _telemetryClient.PutMetricDataAsync(request); }
public static async Task PutCountMetricAsync(ILogger log, IAmazonCloudWatch cloudwatch, string functionName, string metricName, int count) { try { var request = new PutMetricDataRequest { Namespace = functionName }; var metric = new MetricDatum { MetricName = metricName, Timestamp = DateTime.UtcNow, Unit = StandardUnit.Count, Value = count, Dimensions = new List <Dimension> { new Dimension { Name = "FunctionName", Value = functionName } } }; request.MetricData.Add(metric); await cloudwatch.PutMetricDataAsync(request).ConfigureAwait(false); } catch (Exception ex) { log.Error(ex.Demystify(), "Cloudwatch put count metric failed. MetricName: {metricName} Count: {count}.", metricName, count); } }
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)); }
MetricDatum to_sdk_metric_datum(Metric m, int numBuckets) { var a = m.Accumulator(); StatisticSet ss = new StatisticSet(); ss.Sum = a.sum(numBuckets); ss.Minimum = a.min(numBuckets); ss.Maximum = a.max(numBuckets); ss.SampleCount = a.count(numBuckets); MetricDatum d = new MetricDatum(); d.StatisticValues = ss; foreach (var p in m.All_dimensions()) { if (p.Key == "MetricName") { d.MetricName = p.Value; } else { d.Dimensions.Add(new Amazon.CloudWatch.Model.Dimension() { Name = p.Key, Value = p.Value }); } } d.Unit = MetricsConstant.unit(d.MetricName); d.Timestamp = DateTime.Now; return(d); }
private static string GetMetricDatumToString(MetricDatum d) { var s = new StringBuilder(); s.Append("(Metric"); if (d.MetricName != null) { s.AppendFormat(", name = {0}", d.MetricName); } if (d.StatisticValues != null) { s.AppendFormat(", stats = (min {0}, max {1}, count {2}, sum {3})", d.StatisticValues.Minimum, d.StatisticValues.Maximum, d.StatisticValues.SampleCount, d.StatisticValues.Sum); } if (d.StatisticValues == null) { s.AppendFormat(", val = {0}", d.Value); } if (d.Unit != null) { s.AppendFormat(", unit = {0}", d.Unit.Value); } s.AppendFormat(", ts = {0}", d.Timestamp.ToString(CultureInfo.InvariantCulture)); s.Append(')'); return(s.ToString()); }
private static MetricDatum Translate(TimerValueSource source, string contextName, DateTimeOffset now) { var mt = new MetricDatum { MetricName = contextName, TimestampUtc = now.UtcDateTime, StatisticValues = new StatisticSet { Maximum = source.Value.Histogram.Max, Minimum = source.Value.Histogram.Min, SampleCount = source.Value.Histogram.Count, Sum = source.Value.Histogram.Sum }, Dimensions = new List <Dimension> { new Dimension { Name = nameof(source.Value.Rate.MeanRate), Value = source.Value.Rate.MeanRate.ToString() }, new Dimension { Name = nameof(source.Value.Rate.OneMinuteRate), Value = source.Value.Rate.OneMinuteRate.ToString() }, new Dimension { Name = nameof(source.Value.Rate.FiveMinuteRate), Value = source.Value.Rate.FiveMinuteRate.ToString() }, new Dimension { Name = nameof(source.Value.Rate.FifteenMinuteRate), Value = source.Value.Rate.FifteenMinuteRate.ToString() }, } }; return(mt); }
private static MetricDatum Translate(MeterValueSource source, string contextName, DateTimeOffset now) { var mt = new MetricDatum { MetricName = contextName, TimestampUtc = now.UtcDateTime, Value = source.ValueProvider.GetValue(source.ResetOnReporting).MeanRate, Dimensions = new List <Dimension> { new Dimension { Name = nameof(source.Value.MeanRate), Value = source.ValueProvider.GetValue(source.ResetOnReporting).MeanRate.ToString() }, new Dimension { Name = nameof(source.Value.OneMinuteRate), Value = source.ValueProvider.GetValue(source.ResetOnReporting).OneMinuteRate.ToString() }, new Dimension { Name = nameof(source.Value.FiveMinuteRate), Value = source.ValueProvider.GetValue(source.ResetOnReporting).FiveMinuteRate.ToString() }, new Dimension { Name = nameof(source.Value.FifteenMinuteRate), Value = source.ValueProvider.GetValue(source.ResetOnReporting).FifteenMinuteRate.ToString() }, } }; return(mt); }
/// <summary> /// Add metadata to a metric datum, only if the value is non-blank /// </summary> public static void AddMetadata(this MetricDatum metricDatum, string key, string value) { if (string.IsNullOrWhiteSpace(value)) { return; } metricDatum.Metadata[key] = value; }
/// <summary> /// Add metadata to a metric datum, only if the value is non-blank (object overload) /// </summary> public static void AddMetadata(this MetricDatum metricDatum, string key, object value) { if (value == null) { return; } metricDatum.AddMetadata(key, value.ToString()); }
/// <summary> /// Add metadata to a metric datum, only if the value is non-blank (bool overload) /// </summary> public static void AddMetadata(this MetricDatum metricDatum, string key, bool value) { string valueStr = "false"; if (value) { valueStr = "true"; } metricDatum.AddMetadata(key, valueStr); }
private static void AddDimensionsFromTags(MetricDatum mt, CounterValueSource source) { int a = 0; foreach (string tagName in source.Tags.Keys) { mt.Dimensions.Add(new Dimension { Name = tagName, Value = source.Tags.Values[a] }); a++; } }
/// Records Telemetry Event: /// Sample event that uses a type from this definition and a type from the common definitions public static void RecordSampleExtendedInvoke(this ITelemetryLogger telemetryLogger, SampleExtendedInvoke payload) { try { var metrics = new Metrics(); if (payload.CreatedOn.HasValue) { metrics.CreatedOn = payload.CreatedOn.Value; } else { metrics.CreatedOn = System.DateTime.Now; } metrics.Data = new List <MetricDatum>(); var datum = new MetricDatum(); datum.MetricName = "sample_extendedInvoke"; datum.Unit = Unit.None; datum.Passive = payload.Passive; if (payload.Value.HasValue) { datum.Value = payload.Value.Value; } else { datum.Value = 1; } datum.AddMetadata("awsAccount", payload.AwsAccount); datum.AddMetadata("awsRegion", payload.AwsRegion); if (payload.Runtime.HasValue) { datum.AddMetadata("runtime", payload.Runtime.Value); } if (payload.ExtendedRuntime.HasValue) { datum.AddMetadata("extendedRuntime", payload.ExtendedRuntime.Value); } datum.AddMetadata("result", payload.Result); metrics.Data.Add(datum); telemetryLogger.Record(metrics); } catch (System.Exception e) { telemetryLogger.Logger.Error("Error recording telemetry event", e); System.Diagnostics.Debug.Assert(false, "Error Recording Telemetry"); } }
private MetricDatum GetCounterData(Counter counter, DateTime time, List <Dimension> dimensions) { var value = new MetricDatum { MetricName = counter.Name, TimestampUtc = time.ToUniversalTime(), Dimensions = dimensions, Unit = StandardUnit.None }; switch (counter.Type) { case CounterType.Increment: value.Value = counter.Count.Value; value.Unit = StandardUnit.Count; break; case CounterType.Interval: value.Unit = StandardUnit.Milliseconds; //value.Value = counter.Average.Value; value.StatisticValues = new StatisticSet { SampleCount = counter.Count.Value, Maximum = counter.Max.Value, Minimum = counter.Min.Value, Sum = counter.Count.Value * counter.Average.Value }; break; case CounterType.Statistics: //value.Value = counter.Average.Value; value.StatisticValues = new StatisticSet { SampleCount = counter.Count.Value, Maximum = counter.Max.Value, Minimum = counter.Min.Value, Sum = counter.Count.Value * counter.Average.Value }; break; case CounterType.LastValue: value.Value = counter.Last.Value; break; case CounterType.Timestamp: value.Value = counter.Time.Value.Ticks; break; } return(value); }
private MetricDatum GetMetricDatum(MetricType metric, string name, object value, double sampleRate, IEnumerable <string> tags) { var metricData = new MetricDatum { TimestampUtc = DateTime.UtcNow, Dimensions = GetDimensions(tags), MetricName = name.Remove(0, settings.CurrentValue.Prefix.Length + 1) }; switch (metric) { case MetricType.Counting: metricData.Value = Convert.ToDouble(value); metricData.Unit = StandardUnit.Count; break; case MetricType.Timing: metricData.Value = Convert.ToDouble(value); metricData.Unit = StandardUnit.Milliseconds; break; case MetricType.Gauge: metricData.Value = Convert.ToDouble(value); metricData.Unit = StandardUnit.None; break; case MetricType.Histogram: metricData.Value = Convert.ToDouble(value); metricData.Unit = StandardUnit.None; break; case MetricType.Distribution: metricData.Value = Convert.ToDouble(value); metricData.Unit = StandardUnit.None; break; case MetricType.Meter: metricData.Value = Convert.ToDouble(value); metricData.Unit = StandardUnit.None; break; case MetricType.Set: metricData.Value = Convert.ToDouble(value); metricData.Unit = StandardUnit.None; break; } return(metricData); }
private bool LogToCloudWatch(MetricLog metric) { try { using (var cloudwatch = new AmazonCloudWatchClient(Environment.GetEnvironmentVariable("AWSAccessKey"), Environment.GetEnvironmentVariable("AWSSecret"), RegionEndpoint.USEast1)) { var timestamp = GetTimestamp(metric); var dataPoint = new MetricDatum { MetricName = metric.Name, Unit = StandardUnit.Count, Value = double.Parse(metric.Value), TimestampUtc = timestamp, Dimensions = new List <Dimension>(), StatisticValues = new StatisticSet() }; var mdr = new PutMetricDataRequest { Namespace = "Environment", MetricData = new List <MetricDatum> { dataPoint } }; var resp = cloudwatch.PutMetricDataAsync(mdr).Result; //Console.WriteLine(resp.HttpStatusCode); Debug.Assert(resp.HttpStatusCode == System.Net.HttpStatusCode.OK); } return(true); } catch (Exception ex) { Console.WriteLine(ex.Message + ex.StackTrace); while (ex.InnerException != null) { ex = ex.InnerException; Console.WriteLine(ex.Message + ex.StackTrace); } return(false); } }
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); } }
private static MetricDatum Translate(CounterValueSource source, string contextName, DateTimeOffset now) { var mt = new MetricDatum { MetricName = contextName, TimestampUtc = now.UtcDateTime, Value = source.ValueProvider.GetValue(source.ResetOnReporting).Count, }; if (source.ReportSetItems) { AddDimensionsFromTags(mt, source); } return(mt); }
private static MetricDatum Translate(HistogramValueSource source, string contextName, DateTimeOffset now) { var mt = new MetricDatum { MetricName = contextName, TimestampUtc = now.UtcDateTime, StatisticValues = new StatisticSet { Maximum = source.Value.Max, Minimum = source.Value.Min, SampleCount = source.Value.Count, Sum = source.Value.Sum } }; return(mt); }
private IEnumerable <MetricDatum> TranslateContext(MetricsContextValueSource ctx, DateTimeOffset now) { var context = Filter != null?ctx.Filter(Filter) : ctx; var contextName = context.Context; foreach (var source in context.ApdexScores) { foreach (var mt in Translate(source, contextName, now)) { yield return(mt); } } foreach (var source in context.Counters) { yield return(Translate(source, contextName, now)); } foreach (var source in context.Gauges) { var mt = new MetricDatum { Value = source.Value, MetricName = contextName, TimestampUtc = now.UtcDateTime }; yield return(mt); } foreach (var source in context.Histograms) { yield return(Translate(source, contextName, now)); } foreach (var source in context.Meters) { yield return(Translate(source, contextName, now)); } foreach (var source in context.Timers) { yield return(Translate(source, contextName, now)); } }
public async Task AddCounter(string metricName, double count) { var metricDatum = new MetricDatum(); metricDatum.MetricName = metricName; metricDatum.Value = count; metricDatum.TimestampUtc = DateTime.UtcNow; metricDatum.Unit = StandardUnit.Count; MetricData.Add(metricDatum); if (MetricData.Count > 10) { var metricData = new PutMetricDataRequest(); metricData.MetricData = MetricData; metricData.Namespace = "CutieBot"; await cloudWatchClient.PutMetricDataAsync(metricData); MetricData.Clear(); } }
/// Records Telemetry Event: /// Sample event that uses types from this definition only public static void RecordSampleReleaseBees(this ITelemetryLogger telemetryLogger, SampleReleaseBees payload) { try { var metrics = new Metrics(); if (payload.CreatedOn.HasValue) { metrics.CreatedOn = payload.CreatedOn.Value; } else { metrics.CreatedOn = System.DateTime.Now; } metrics.Data = new List <MetricDatum>(); var datum = new MetricDatum(); datum.MetricName = "sample_releaseBees"; datum.Unit = Unit.None; datum.Passive = false; if (payload.Value.HasValue) { datum.Value = payload.Value.Value; } else { datum.Value = 1; } datum.AddMetadata("bees", payload.Bees); metrics.Data.Add(datum); telemetryLogger.Record(metrics); } catch (System.Exception e) { telemetryLogger.Logger.Error("Error recording telemetry event", e); System.Diagnostics.Debug.Assert(false, "Error Recording Telemetry"); } }
/// <summary> /// Sends a value to CloudWatch metrics /// </summary> /// <param name="value">Use 1 to indicate the Url was up or 0 to indicate it was down</param> /// <param name="protocol">The protocol used to make the request</param> /// <param name="path">The HTTP or TCP endpoing IP address or host name</param> /// <param name="customerId">The customer Id associated with this check</param> /// <returns>A task that can be awaited for completion of sending the metrics to CloudWatch</returns> private async Task SendCloudWatchUpDownMetric(int value, Models.Protocol protocol, string path, string customerId) { using (AmazonCloudWatchClient Client = new AmazonCloudWatchClient()) { MetricDatum Metric = new MetricDatum() { Dimensions = { new Dimension() { Name = "Path", Value = path }, new Dimension() { Name = "CustomerId", Value = customerId }, new Dimension() { Name = "Protocol", Value = protocol.ToString() } }, MetricName = "Availability", StatisticValues = new StatisticSet(), Timestamp = DateTime.Now, Unit = StandardUnit.Count, Value = value }; PutMetricDataRequest MetricRequest = new PutMetricDataRequest() { MetricData = { Metric }, Namespace = "AWS/AreWeUp" }; PutMetricDataResponse Response = await Client.PutMetricDataAsync(MetricRequest); //Make sure response was successful if ((int)Response.HttpStatusCode < 200 || (int)Response.HttpStatusCode > 299) { this._LambdaContext.LogError($"The CloudWatch metric publish failed with HTTP Status {(int)Response.HttpStatusCode } {Response.HttpStatusCode} : {JsonConvert.SerializeObject(Response.ResponseMetadata) } "); } } }
public async Task ProcessRecord(S3EventNotification.S3EventNotificationRecord record, ILambdaContext context) { var cameraKey = record.S3.Object.Key.Split('/')[1]; var s3GetResult = await s3.GetObjectAsync(record.S3.Bucket.Name, record.S3.Object.Key); var classNamesParameterName = $"/Cameras/{cameraKey}/ClassNames"; var sceneCodeParameterName = $"/Cameras/{cameraKey}/SceneCode"; var observationBoundingBoxParameterName = $"/Cameras/{cameraKey}/ObservationBoundingBox"; if (!cameraParameters.ContainsKey(observationBoundingBoxParameterName)) { try { var getResult = await ssm.GetParameterAsync(new GetParameterRequest { Name = observationBoundingBoxParameterName }); cameraParameters.Add(observationBoundingBoxParameterName, getResult.Parameter.Value); context.Logger.LogLine( $"Set {observationBoundingBoxParameterName} = {cameraParameters[observationBoundingBoxParameterName]}"); } catch (Exception exception) { context.Logger.LogLine($"Didn't add parameter. {observationBoundingBoxParameterName}"); context.Logger.LogLine(exception.Message); } } if (!cameraParameters.ContainsKey(classNamesParameterName)) { var getResult = await ssm.GetParameterAsync(new GetParameterRequest { Name = classNamesParameterName }); cameraParameters.Add(classNamesParameterName, getResult.Parameter.Value); context.Logger.LogLine($"Set {classNamesParameterName} = {cameraParameters[classNamesParameterName]}"); } if (!cameraParameters.ContainsKey(sceneCodeParameterName)) { var getResult = await ssm.GetParameterAsync(new GetParameterRequest { Name = sceneCodeParameterName }); cameraParameters.Add(sceneCodeParameterName, getResult.Parameter.Value); context.Logger.LogLine($"Set {sceneCodeParameterName} = {cameraParameters[sceneCodeParameterName]}"); } var memoryStream = new MemoryStream(); await s3GetResult.ResponseStream.CopyToAsync(memoryStream); // Crop the area of interest. // TODO: Get the x, y, w, h from parmeter store. var croppedMemoryStream = new MemoryStream(); var cropImage = cameraParameters.ContainsKey(observationBoundingBoxParameterName); if (cropImage) { var parts = cameraParameters[observationBoundingBoxParameterName].Split(','); memoryStream.Position = 0; var sourceImage = Image.Load(memoryStream); var x = int.Parse(parts[0]); var y = int.Parse(parts[1]); var lowerX = int.Parse(parts[2]); var lowerY = int.Parse(parts[3]); var w = lowerX - x; var h = lowerY - y; sourceImage.Mutate(i => i.Crop(new Rectangle(x, y, w, h))); context.Logger.LogLine("Trying to save croped image."); sourceImage.Save(croppedMemoryStream, new JpegEncoder()); croppedMemoryStream.Position = 0; } var labelsResult = await rekognition.DetectLabelsAsync(new DetectLabelsRequest { Image = new Amazon.Rekognition.Model.Image { Bytes = cropImage ? croppedMemoryStream : memoryStream }, MaxLabels = 100, MinConfidence = 70 }); if (cropImage) { croppedMemoryStream.Position = 0; } else { memoryStream.Position = 0; } var metricData = new List <MetricDatum>(); var personMetric = new MetricDatum { MetricName = "Confidence", StorageResolution = 1, TimestampUtc = DateTime.UtcNow, Unit = StandardUnit.Percent, Dimensions = new List <Dimension> { new Dimension { Name = "CameraKey", Value = cameraKey }, new Dimension { Name = "Source", Value = "Rekognition" }, new Dimension { Name = "Label", Value = "Person" } } }; if (labelsResult.Labels.Any(label => label.Name == "Person")) { var confidence = Convert.ToDouble(labelsResult.Labels.Single(l => l.Name == "Person").Confidence); personMetric.StatisticValues = new StatisticSet { Minimum = confidence, Maximum = confidence, SampleCount = 1, Sum = 1 }; } else { personMetric.StatisticValues = new StatisticSet { Minimum = 0, Maximum = 0, SampleCount = 1, Sum = 1 }; } metricData.Add(personMetric); var objectDetectionResult = await sageMakerRuntime.InvokeEndpointAsync(new InvokeEndpointRequest { Accept = "application/jsonlines", ContentType = "application/x-image", EndpointName = cameraParameters[sceneCodeParameterName], Body = cropImage ? croppedMemoryStream : memoryStream }); if (cropImage) { croppedMemoryStream.Close(); } else { memoryStream.Close(); } using (var streamReader = new StreamReader(objectDetectionResult.Body)) { var json = streamReader.ReadToEnd(); context.Logger.Log($"SageMaker Endpoint Result: {json}"); var predictionResult = JsonConvert.DeserializeObject <dynamic>(json).prediction; var classNames = cameraParameters[classNamesParameterName].Split(','); var predictions = new List <Prediction>(); foreach (var pr in predictionResult) { predictions.Add(new Prediction { ClassName = classNames[Convert.ToInt32(pr[0].Value)], Confidence = Convert.ToDouble(pr[1].Value) * 100 }); } foreach (var classNotPredicted in classNames.Where(cn => predictions.All(p => p.ClassName != cn))) { predictions.Add(new Prediction { ClassName = classNotPredicted, Confidence = 0 }); } foreach (var classGroup in predictions.GroupBy(p => p.ClassName)) { metricData.Add(new MetricDatum { MetricName = "Confidence", StorageResolution = 1, TimestampUtc = DateTime.UtcNow, Unit = StandardUnit.Percent, Dimensions = new List <Dimension> { new Dimension { Name = "CameraKey", Value = cameraKey }, new Dimension { Name = "Source", Value = cameraParameters[sceneCodeParameterName] }, new Dimension { Name = "Label", Value = classGroup.Key } }, StatisticValues = new StatisticSet { Minimum = classGroup.Min(c => c.Confidence), Maximum = classGroup.Max(c => c.Confidence), Sum = classGroup.Count(), SampleCount = classGroup.Count() } }); } } await cloudWatch.PutMetricDataAsync(new PutMetricDataRequest { Namespace = "Cameras", MetricData = metricData }); }
/// <summary> /// Add metadata to a metric datum, only if the value is non-blank (int overload) /// </summary> public static void AddMetadata(this MetricDatum metricDatum, string key, int value) { metricDatum.AddMetadata(key, value.ToString(System.Globalization.CultureInfo.InvariantCulture)); }
public HomeController(IAmazonCloudWatch cloudwatchClient) { this.CloudwatchClient = cloudwatchClient; 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" }; cloudwatchClient.PutMetricDataAsync(request).GetAwaiter().GetResult(); }
public static void AddData(MetricDatum data) { _data.Add(data); }
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>() { dimension }, MetricName = "Desktop Machines Online", StatisticValues = new StatisticSet(), Timestamp = DateTime.Today, Unit = StandardUnit.Count, Value = 14 }; var metric2 = new MetricDatum { Dimensions = new List <Dimension>() { dimension }, MetricName = "Desktop Machines Offline", StatisticValues = new StatisticSet(), Timestamp = DateTime.Today, Unit = StandardUnit.Count, Value = 7 }; var metric3 = new MetricDatum { Dimensions = new List <Dimension>() { dimension }, MetricName = "Desktop Machines Online", StatisticValues = new StatisticSet(), Timestamp = DateTime.Today, Unit = StandardUnit.Count, Value = 12 }; var metric4 = new MetricDatum { Dimensions = new List <Dimension>() { 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 }
private MetricDatum GetMetricFromPerformanceCounterReader(CounterSampleCollection package) { var data = new MetricDatum() { MetricName = package.CounterName, StatisticValues = new StatisticSet() { Maximum = 0.0, Minimum = 0.0, SampleCount = 0.0, Sum = 0.0 }, Unit = StandardUnit.Count, Timestamp = Epoch, Dimensions = new List <Dimension>(3) }; // Find unit for (int i = 0; i < DataMeasure.Length; i++) { var u = DataMeasure[i]; if (data.MetricName.Contains(u.Value)) { data.Unit = u; } } if (data.MetricName.IndexOf("PerSec", StringComparison.InvariantCultureIgnoreCase) > -1) { data.Unit = data.Unit.Value + "/Second"; } else { for (int i = 0; i < OtherMeasure.Length; i++) { var u = OtherMeasure[i]; if (data.MetricName.Contains(u.Value)) { data.Unit = u; } } } // Collect stats foreach (var sample in package) { data.StatisticValues.Maximum = Math.Max(data.StatisticValues.Maximum, sample.Value); data.StatisticValues.Minimum = Math.Min(data.StatisticValues.Minimum, sample.Value); data.StatisticValues.SampleCount += 1.0; data.StatisticValues.Sum += sample.Value; if (data.Timestamp < sample.Timestamp) { data.Timestamp = sample.Timestamp; } } // Setup dimensions if (!String.IsNullOrEmpty(this.instanceId)) { data.Dimensions.Add(new Dimension() { Name = "InstanceId", Value = this.instanceId }); } if (!String.IsNullOrEmpty(this.autoScalingGroupName)) { data.Dimensions.Add(new Dimension() { Name = "AutoScalingGroupName", Value = this.autoScalingGroupName }); } if (!String.IsNullOrEmpty(this.SenderId)) { data.Dimensions.Add(new Dimension() { Name = "SenderId", Value = this.SenderId }); } return(data); }