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));
}
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());
}
private async Task <bool> SendMetrics(List <MetricDatum> metrics)
{
var request = new PutMetricDataRequest
{
MetricData = metrics,
Namespace = _namespace
};
try
{
var response = await _client.PutMetricDataAsync(request);
metrics.Clear();
if (response.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
return(true);
}
Logger.Warn($"CloudMetrics returned error code {response.HttpStatusCode}");
return(false);
}
catch (Exception ex)
{
Logger.Warn(ex, "CloudMetrics error");
return(false);
}
}
void upload_one(PutMetricDataRequest pmdr, UploadContext ctx)
{
var cw_client_ = new Amazon.CloudWatch.AmazonCloudWatchClient(config_.AWSMetricsCredentials.Akid, config_.AWSMetricsCredentials.SecretKey, config_.AWSMetricsCredentials.SessionToken, region_);
CancellationTokenSource cts = new CancellationTokenSource();
var token = cts.Token;
cw_client_.PutMetricDataAsync(pmdr, token).ContinueWith
(
(pmdresp) =>
{
if (pmdresp.Result.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
return;
}
//Do error handling
ctx.attempts++;
var msg = pmdresp.Exception.Message;
if (ctx.created > DateTime.Now.AddMinutes(-30))
{
StdErrorOut.Instance.StdError("Metrics upload failed. Error Mesg : " + msg);
}
else
{
if (ctx.attempts == 5)
{
StdErrorOut.Instance.StdOut(LogLevel.warn, string.Format("Metrics upload failed. | Code: {0} | Message: {1} | Request was: {3}", pmdresp.Result.HttpStatusCode, msg, pmdr.MetricData.ToString()));
}
executor.Schedule(() => { upload_one(pmdr, ctx); }, retry_delay_);
}
}
);
}
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);
}
}
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);
}
bool ValidatePutRequestBody(PutMetricDataRequest request, MetricData data, CloudWatchMetricPersisterConfiguration configuration)
{
Assert.That(request.Namespace, Is.EqualTo(configuration.Namespace));
Assert.That(request.MetricData, Has.Exactly(1).InstanceOf <MetricDatum>());
return(true);
}
public async Task PushAsync(MetricData data)
{
if (!configuration.SkipDataValidation && !IsDataSufficient(data))
{
logger.LogWarning("Collected data is not sufficient for configured metrics");
}
var now = DateTimeOffset.UtcNow.UtcDateTime;
var metrics = from item in configuration.Metrics
where data.Metrics.ContainsKey(item.Metric)
let mitem = data.Metrics[item.Metric]
where mitem != null
select new MetricDatum
{
MetricName = item.Name,
Unit = item.Unit,
StorageResolution = (int)item.StorageResolution,
Timestamp = now,
Value = mitem.ReadAsDouble(),
Dimensions = new List <Dimension>(from dim in item.Dimensions
where data.Dimensions.ContainsKey(dim)
let ditem = data.Dimensions[dim]
where ditem != null
select new Dimension
{
Name = dim.Name,
Value = ditem.ToString()
})
};
var request = new PutMetricDataRequest
{
Namespace = configuration.Namespace,
MetricData = new List <MetricDatum>(metrics)
};
if (request.MetricData.Count > 0)
{
try
{
var response = await cloudWatch.PutMetricDataAsync(request);
logger.LogDebug($"Pushed {request.MetricData.Count} metrics to CloudWatch");
}
catch (Exception ex)
{
logger.LogError(ex, "Unable to push metrics to CloudWatch");
throw;
}
}
else
{
logger.LogDebug("No metric was pushed to CloudWatch. Check your configuration.");
}
}
bool ValidateMetricDatumDimensions(PutMetricDataRequest request, MetricData data, CloudWatchMetricPersisterConfiguration configuration)
{
var metric = configuration.Metrics[0];
var datum = request.MetricData[0];
Assert.That(datum.Dimensions, Has.Exactly(metric.Dimensions.Count).InstanceOf <Dimension>());
return(true);
}
/// <summary>
/// Sends the specified metric immediately to the destination.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="metric">The metric.</param>
/// <param name="name">The name.</param>
/// <param name="value">The value.</param>
/// <param name="sampleRate">The sample rate.</param>
/// <param name="tags">The tags.</param>
public void Send <T>(MetricType metric, string name, T value, double sampleRate, IEnumerable <string> tags)
{
var request = new PutMetricDataRequest {
Namespace = settings.CurrentValue.Prefix,
MetricData = new List <MetricDatum> {
{ GetMetricDatum(metric, name, value, sampleRate, tags) }
}
};
cloudwatch.PutMetricDataAsync(request).ConfigureAwait(false).GetAwaiter().GetResult();
}
bool ValidateMetricDatum(PutMetricDataRequest request, MetricData data, CloudWatchMetricPersisterConfiguration configuration)
{
var metric = configuration.Metrics[0];
var datum = request.MetricData[0];
Assert.That(datum.Value, Is.EqualTo(data.Metrics[metric.Metric].ReadAsDouble()));
Assert.That(datum.Unit, Is.EqualTo(metric.Unit));
Assert.That(datum.StorageResolution, Is.EqualTo((int)metric.StorageResolution));
return(true);
}
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);
}
}
public async Task Handle(SqsStats stats, CancellationToken cancellationToken)
{
if (stats == null)
{
throw new ArgumentNullException(nameof(stats));
}
if (!stats.HasConsumerStats)
{
return;
}
var metricRequest = new PutMetricDataRequest
{
Namespace = _options.CloudWatchNamespace,
MetricData = new List <MetricDatum>
{
new MetricDatum
{
MetricName = "EcsServiceBacklog",
Value = stats.EcsServiceBacklogCount,
Dimensions =
{
new Dimension {
Name = "Queue", Value = stats.QueueName
},
new Dimension {
Name = "Cluster", Value = stats.EcsCluster
},
new Dimension {
Name = "Service", Value = stats.EcsService
}
}
}
}
};
try
{
using (_logger.TimeOperation("Sending metrics to CloudWatch"))
{
await _cloudWatchClient.PutMetricDataAsync(metricRequest, cancellationToken);
}
}
catch (Exception ex)
{
_logger.Error(ex, "Error sending metrics to CloudWatch");
}
}
private async Task SendMetricsBatchAsync(string metricNamespace, params MetricDatum[] metricList)
{
try
{
PutMetricDataRequest request = new PutMetricDataRequest
{
Namespace = metricNamespace,
MetricData = new List <MetricDatum>(metricList)
};
await CloudwatchClient.PutMetricDataAsync(request);
}
catch (Exception ex)
{
Console.WriteLine("Exception while sending cloudwatch metrics: " + ex);
}
}
void uploadClient(List <Metric> uploads)
{
for (int i = 1; i <= uploads.Count; i++)
{
int step = uploads.Count / i;
if (step > 20)
{
continue;
}
List <PutMetricDataRequest> batches = new List <PutMetricDataRequest>();
for (int j = 0; j < uploads.Count; j += step)
{
int k = Math.Min(j + step, uploads.Count);
PutMetricDataRequest req = new PutMetricDataRequest();
req.MetricData = new List <MetricDatum>();
req.Namespace = cw_namespace;
for (int z = j; z < k; z++)
{
req.MetricData.Add(to_sdk_metric_datum(uploads[z], kNumBuckets));
}
batches.Add(req);
}
bool small_enough = true;
foreach (var pmdr in batches)
{
if (pmdr.MetricData.Count > 38 * 1024)
{
small_enough = false;
break;
}
}
if (small_enough)
{
foreach (var pmdr in batches)
{
upload_one(pmdr, new UploadContext(DateTime.Now));
}
}
break;
}
}
private async Task SendDataToAwsAsync(List <MetricDatum> metrics)
{
var request = new PutMetricDataRequest
{
MetricData = metrics,
Namespace = _metricsConfiguration.Namespace
};
try
{
await _amazonCloudWatchClient.PutMetricDataAsync(request);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
}
}
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();
}
}
//TrackAggregateMetric contains the aggregation logic of just send to the AppInsights when the BeginComputeMetric and EndComputeMeric
//is called. With some key is not registred
public override void TrackAggregateMetric(object metricTelemetry)
{
PutMetricDataRequest putMetricDataRequest = new PutMetricDataRequest()
{
MetricData = new List <MetricDatum>()
{
new MetricDatum()
{
MetricName = (string)metricTelemetry.GetType().GetProperty("Name").GetValue(metricTelemetry),
Value = (double)metricTelemetry.GetType().GetProperty("Sum").GetValue(metricTelemetry),
Timestamp = DateTime.Now,
Unit = "aggregated"
}
},
Namespace = "AMAW/Logs"
};
//Client send to AWS a metric for be registred.
this._amazonCloud.PutMetricDataAsync(putMetricDataRequest);
}
/// <summary>
/// Sends queued metrics to the destination.
/// </summary>
public void Flush()
{
// We only want to lock/block on flush so we get concurrent adds
isFlushing = true;
// sweep into a local array for processing...
MetricDatum[] metrics = queue.ToArray();
queue.Clear();
//...and release the lock as soon as possible. This allows adds again while the slow IO happens later
// using the copied array.
isFlushing = false;
Monitor.PulseAll(monitor);
var request = new PutMetricDataRequest
{
Namespace = settings.CurrentValue.Prefix,
MetricData = new List <MetricDatum>(metrics)
};
cloudwatch.PutMetricDataAsync(request).ConfigureAwait(false).GetAwaiter().GetResult();
}
/// <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) } ");
}
}
}
//TrackMetric sends to the AppInsights metrics related to some point of view.
//For example, you can measure how much time was spent to persist data in the database.
public override void TrackMetric(string metricLabel, double value)
{
//Create a object to send the event PutMetricDataRequest
PutMetricDataRequest putMetricDataRequest = new PutMetricDataRequest()
{
//Create a Entries of the request
MetricData = new List <MetricDatum>()
{
new MetricDatum()
{
MetricName = metricLabel,
Value = value,
Timestamp = DateTime.Now,
Unit = "none"
}
},
//Directory that will be save all telemetrys
Namespace = "AMAW/Logs"
};
//Client send to AWS a metric for be registred.
this._amazonCloud.PutMetricDataAsync(putMetricDataRequest);
}
private PutMetricDataResponse PutMetricDataResponse(PutMetricDataRequest metricDataRequest)
{
var response = PutMetricData(metricDataRequest);
return(response);
}
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
}
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 void PutMetricData(PutMetricDataRequest putMetricDataRequest)
{
metrics.OnNext(putMetricDataRequest);
}
/// <summary>
/// 该接口为自定义监控数据上报的接口，方便您将自己采集的时序数据上报到云监控。不同region域名上报不同region的数据，参考：<a href="https://docs.jdcloud.com/cn/monitoring/reporting-monitoring-data">调用说明</a>可上报原始数据和已聚合的统计数据。支持批量上报方式。单次请求最多包含 50 个数据点；数据大小不超过 256k。
/// </summary>
/// <param name="request">请求参数信息</param>
/// <returns>请求结果信息</returns>
public PutMetricDataResponse PutMetricData(PutMetricDataRequest request)
{
return(new PutMetricDataExecutor().Client(this).Execute <PutMetricDataResponse, PutMetricDataResult, PutMetricDataRequest>(request));
}
/// <summary>
/// 该接口为自定义监控数据上报的接口，方便您将自己采集的时序数据上报到云监控。不同region域名上报不同region的数据，参考：<a href="https://docs.jdcloud.com/cn/monitoring/reporting-monitoring-data">调用说明</a>可上报原始数据和已聚合的统计数据。支持批量上报方式。单次请求最多包含 50 个数据点；数据大小不超过 256k。
/// </summary>
/// <param name="request">请求参数信息</param>
/// <returns>请求结果信息</returns>
public async Task <PutMetricDataResponse> PutMetricData(PutMetricDataRequest request)
{
return(await new PutMetricDataExecutor().Client(this).Execute <PutMetricDataResponse, PutMetricDataResult, PutMetricDataRequest>(request).ConfigureAwait(false));
}
private void PublishMetricData(List <MetricDatum> data)
{
if (data.Count <= 0)
{
return;
}
if (this.settings.AutoNamespace)
{
while (data.Count > 0)
{
var first = data[data.Count - 1];
data.RemoveAt(data.Count - 1);
var nsi = first.MetricName.LastIndexOf('.');
if (nsi > 0)
{
var ns = first.MetricName.Substring(0, nsi).Replace('.', '/');
first.MetricName = first.MetricName.Substring(nsi + 1);
var nons = new PutMetricDataRequest()
{
MetricData = new List <MetricDatum>()
{
first
},
Namespace = this.settings.AWSCloudWatchNamespace + '/' + ns
};
for (var i = data.Count - 1; i >= 0; i--)
{
var d = data[i];
if (d.MetricName.StartsWith(ns))
{
d.MetricName = d.MetricName.Substring(nsi + 1);
nons.MetricData.Add(d);
data.RemoveAt(i);
}
}
if (Log.IsDebugEnabled)
{
foreach (var d in nons.MetricData)
{
Log.DebugFormat("Report metric at ns://{0}: {1}, {2}", nons.Namespace, d.MetricName, GetMetricDatumToString(d));
}
}
this.cloudWatchClient.PutMetricData(nons);
}
else
{
// Collect all without dots
var nons = new PutMetricDataRequest()
{
MetricData = new List <MetricDatum>()
{
first
},
Namespace = this.settings.AWSCloudWatchNamespace
};
for (var i = data.Count - 1; i >= 0; i--)
{
if (data[i].MetricName.IndexOf('.') < 0)
{
nons.MetricData.Add(data[i]);
data.RemoveAt(i);
}
}
if (Log.IsDebugEnabled)
{
foreach (var d in nons.MetricData)
{
Log.DebugFormat("Report metric at ns://{0}, {1}, {2}", nons.Namespace, d.MetricName, GetMetricDatumToString(d));
}
}
this.cloudWatchClient.PutMetricData(nons);
}
}
}
else
{
if (Log.IsDebugEnabled)
{
foreach (var d in data)
{
Log.DebugFormat("Report metric: {0}, {1}", d.MetricName, GetMetricDatumToString(d));
}
}
this.cloudWatchClient.PutMetricData(
new PutMetricDataRequest()
{
MetricData = data,
Namespace = this.settings.AWSCloudWatchNamespace
});
}
}
public CloudwatchMetrics(IAlteredPipeline <TRequest, TResponse> operation, CloudwatchMetricsSink metrics, string name) : base(async(request) =>
{
var response = await operation.Execute(request);
var dimensions = new List <Dimension>
{
new Dimension
{
Name = nameof(AlteredEnvironment.App),
Value = AlteredEnvironment.App ?? "-"
},
new Dimension
{
Name = nameof(AlteredEnvironment.Env),
Value = AlteredEnvironment.Env ?? "-"
},
//new Dimension
//{
// Name = nameof(AlteredEnvironment.Sha),
// Value = AlteredEnvironment.Sha ?? "-"
//},
new Dimension
{
Name = "Name",
Value = name ?? "-"
}
};
var metricData = new List <MetricDatum>
{
new MetricDatum
{
MetricName = $"{name} Count",
TimestampUtc = DateTime.UtcNow,
Unit = StandardUnit.None,
Dimensions = dimensions
},
new MetricDatum
{
MetricName = $"{name} {nameof(response.RequestDuration)}",
TimestampUtc = DateTime.UtcNow,
Unit = StandardUnit.Milliseconds,
Dimensions = dimensions,
Value = response.RequestDuration
},
new MetricDatum
{
MetricName = $"{name} {response.StatusCode/100}XX Count",
TimestampUtc = DateTime.UtcNow,
Unit = StandardUnit.None,
Dimensions = dimensions
},
new MetricDatum
{
MetricName = $"{name} {response.StatusCode/100}XX {nameof(response.RequestDuration)}",
TimestampUtc = DateTime.UtcNow,
Unit = StandardUnit.Milliseconds,
Dimensions = dimensions,
Value = response.RequestDuration
}
};
var putMetricDataRequest = new PutMetricDataRequest
{
Namespace = AlteredEnvironment.Name,
MetricData = metricData
};
metrics.PutMetricData(putMetricDataRequest);
return(response);
})
{ }
