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