/// <summary>
/// Initiates an asynchronous operation for running the Smart Detector analysis on the specified resources.
/// </summary>
/// <param name="analysisRequest">The analysis request data.</param>
/// <param name="tracer">
/// A tracer used for emitting telemetry from the Smart Detector's execution. This telemetry will be used for troubleshooting and
/// monitoring the Smart Detector's executions.
/// </param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe while waiting for a task to complete.</param>
/// <returns>
/// A <see cref="Task"/> that represents the asynchronous operation, returning the Alerts detected for the target resources.
/// </returns>
public async Task <List <Alert> > AnalyzeResourcesAsync(AnalysisRequest analysisRequest, ITracer tracer, CancellationToken cancellationToken)
{
tracer.TraceInformation("Analyzing the specified resources...");
// Get the metrics client
IMetricClient metricsClient = await analysisRequest.AnalysisServicesFactory.CreateMetricClientAsync(analysisRequest.TargetResources.First(), cancellationToken);
// Get the resource metrics. In the example below, the requested metric values are the total number of messages
// in the storage queue over the last day, in hourly interval
var parameters = new QueryParameters()
{
StartTime = DateTime.UtcNow.Date.AddDays(-1),
EndTime = DateTime.UtcNow.Date,
Aggregations = new List <Aggregation> {
Aggregation.Total
},
MetricName = "QueueMessageCount",
Interval = TimeSpan.FromMinutes(60)
};
IEnumerable <MetricQueryResult> metrics = (await metricsClient.GetResourceMetricsAsync(ServiceType.AzureStorageQueue, parameters, default(CancellationToken)));
// Process the resource metric values and create alerts
List <Alert> alerts = new List <Alert>();
if (metrics.Count() > 0)
{
alerts.Add(new $alertName$("Title", analysisRequest.RequestParameters.First()));
}
tracer.TraceInformation($"Created {alerts.Count()} alerts");
return(alerts);
}
public async Task WhenCreatingMetricClientThenItIsCreatedSuccessfully()
{
IAnalysisServicesFactory factory = new AnalysisServicesFactory(this.tracerMock.Object, this.httpClientWrapperMock.Object, this.credentialsFactoryMock.Object, this.azureResourceManagerClientMock.Object);
IMetricClient client = await factory.CreateMetricClientAsync(SubscriptionId, default(CancellationToken));
Assert.IsNotNull(client);
Assert.IsTrue(client is MetricClient);
}
public StackDriverClient(IErrorReportingClient errorReportingClient, IMetricClient metricClient)
{
ErrorReporting = errorReportingClient;
Metric = metricClient;
}
public void SetUp()
{
_metricClient = MockRepository.GenerateMock<IMetricClient>();
_clientFactory = MockRepository.GenerateMock<ICoreClientFactory>();
_metricRepository = MockRepository.GenerateStub<IMetricRepository>();
_service = new MetricService(_clientFactory, _metricRepository);
}
/// <summary>
/// Read the metric values
/// </summary>
/// <returns>A <see cref="Task"/>, running the current operation, returning the metric values as a <see cref="LineSeries"/></returns>
private async Task <ChartValues <DateTimePoint> > ReadChartValuesAsync()
{
CancellationToken cancellationToken = CancellationToken.None;
// Verify start/end times
DateTime startTime = this.metricChartAlertProperty.StartTimeUtc ?? throw new ApplicationException("Start time cannot be null");
DateTime endTime = this.metricChartAlertProperty.EndTimeUtc ?? throw new ApplicationException("End time cannot be null");
if (endTime > DateTime.UtcNow)
{
endTime = DateTime.UtcNow;
}
// Convert from aggregation type to aggregation
Aggregation aggregation;
switch (this.metricChartAlertProperty.AggregationType)
{
case AggregationType.Average:
aggregation = Aggregation.Average;
break;
case AggregationType.Count:
aggregation = Aggregation.Count;
break;
case AggregationType.Sum:
aggregation = Aggregation.Total;
break;
case AggregationType.Maximum:
aggregation = Aggregation.Maximum;
break;
case AggregationType.Minimum:
aggregation = Aggregation.Minimum;
break;
default:
throw new ApplicationException($"Invalid aggregation type {this.metricChartAlertProperty.AggregationType}");
}
// Create the metrics client
ResourceIdentifier resource = ResourceIdentifier.CreateFromResourceId(this.metricChartAlertProperty.ResourceId);
IMetricClient metricClient = await this.analysisServicesFactory.CreateMetricClientAsync(resource.SubscriptionId, cancellationToken)
.ConfigureAwait(false);
// Send a metric query using the metric client
IEnumerable <MetricQueryResult> metricQueryResults = await metricClient.GetResourceMetricsAsync(
this.metricChartAlertProperty.ResourceId,
new QueryParameters()
{
MetricNamespace = this.metricChartAlertProperty.MetricNamespace,
MetricNames = new List <string>()
{
this.metricChartAlertProperty.MetricName
},
StartTime = startTime,
EndTime = endTime,
Interval = this.metricChartAlertProperty.TimeGrain,
Aggregations = new List <Aggregation>()
{
aggregation
},
},
cancellationToken)
.ConfigureAwait(false);
// Get chart points
ChartValues <DateTimePoint> values = new ChartValues <DateTimePoint>(
metricQueryResults
.Single()
.Timeseries
.Single()
.Data
.Select(p => new DateTimePoint(p.TimeStamp, p.GetValue(aggregation))));
return(values);
}
