public async Task GetMetricDimensionValuesWithOptionalDimensionFilter()
{
const string dimensionName = "Dim1";
const string filter = "JP";
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var options = new GetMetricDimensionValuesOptions()
{
DimensionValueFilter = filter
};
var valueCount = 0;
await foreach (string value in client.GetMetricDimensionValuesAsync(MetricId, dimensionName, options))
{
Assert.That(value, Is.Not.Null.And.Not.Empty);
Assert.That(value.Contains(filter));
if (++valueCount >= MaximumSamplesCount)
{
break;
}
}
Assert.That(valueCount, Is.GreaterThan(0));
}
public async Task GetIncidentsForDetectionConfigurationWithMinimumSetup(bool useTokenCredential)
{
MetricsAdvisorClient client = GetMetricsAdvisorClient(useTokenCredential);
var options = new GetIncidentsForDetectionConfigurationOptions(SamplingStartTime, SamplingEndTime);
var incidentCount = 0;
await foreach (AnomalyIncident incident in client.GetIncidentsForDetectionConfigurationAsync(DetectionConfigurationId, options))
{
Assert.That(incident, Is.Not.Null);
Assert.That(incident.DataFeedId, Is.Null);
Assert.That(incident.MetricId, Is.Null);
Assert.That(incident.Id, Is.Not.Null.And.Not.Empty);
Assert.That(incident.DetectionConfigurationId, Is.EqualTo(DetectionConfigurationId));
Assert.That(incident.StartedOn, Is.GreaterThanOrEqualTo(SamplingStartTime));
Assert.That(incident.LastDetectedOn, Is.LessThanOrEqualTo(SamplingEndTime));
Assert.That(incident.Status, Is.Not.EqualTo(default(AnomalyIncidentStatus)));
Assert.That(incident.Severity, Is.Not.EqualTo(default(AnomalySeverity)));
ValidateSeriesKey(incident.RootSeriesKey);
if (++incidentCount >= MaximumSamplesCount)
{
break;
}
}
Assert.That(incidentCount, Is.GreaterThan(0));
}
public async Task GetMetricEnrichmentStatusesAsync()
{
string endpoint = MetricsAdvisorUri;
string subscriptionKey = MetricsAdvisorSubscriptionKey;
string apiKey = MetricsAdvisorApiKey;
var credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);
var client = new MetricsAdvisorClient(new Uri(endpoint), credential);
string metricId = MetricId;
var startTime = DateTimeOffset.Parse("2020-01-01T00:00:00Z");
var endTime = DateTimeOffset.UtcNow;
var options = new GetMetricEnrichmentStatusesOptions(startTime, endTime)
{
MaxPageSize = 5
};
int statusCount = 0;
await foreach (EnrichmentStatus enrichmentStatus in client.GetMetricEnrichmentStatusesAsync(metricId, options))
{
Console.WriteLine($"Ingestion timestamp: {enrichmentStatus.Timestamp}");
Console.WriteLine($"Status: {enrichmentStatus.Status}");
Console.WriteLine($"Message: {enrichmentStatus.Message}");
Console.WriteLine();
// Print at most 5 entries.
if (++statusCount >= 5)
{
break;
}
}
}
public async Task GetAlertsWithTokenCredential()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient(useTokenCredential: true);
var options = new GetAlertsOptions(SamplingStartTime, SamplingEndTime, AlertQueryTimeMode.AnomalyDetectedOn);
var alertCount = 0;
await foreach (AnomalyAlert alert in client.GetAlertsAsync(AlertConfigurationId, options))
{
Assert.That(alert, Is.Not.Null);
Assert.That(alert.Id, Is.Not.Null.And.Not.Empty);
Assert.That(alert.Timestamp, Is.Not.EqualTo(default(DateTimeOffset)));
Assert.That(alert.CreatedOn, Is.Not.EqualTo(default(DateTimeOffset)));
Assert.That(alert.LastModified, Is.Not.EqualTo(default(DateTimeOffset)));
Assert.That(alert.Timestamp, Is.InRange(SamplingStartTime, SamplingEndTime));
if (++alertCount >= MaximumSamplesCount)
{
break;
}
}
Assert.That(alertCount, Is.GreaterThan(0));
}
public async Task GetIncidentRootCausesForIncidentFromAlert()
{
const string incidentId = "5a0692283edccf37ce825b3a8d475f4e-17571a77000";
MetricsAdvisorClient client = GetMetricsAdvisorClient();
AnomalyIncident incident = null;
await foreach (AnomalyIncident currentIncident in client.GetIncidentsAsync(AlertConfigurationId, AlertId))
{
if (currentIncident.Id == incidentId)
{
incident = currentIncident;
break;
}
}
Assert.That(incident, Is.Not.Null);
var rootCauseCount = 0;
await foreach (IncidentRootCause rootCause in client.GetIncidentRootCausesAsync(incident))
{
ValidateIncidentRootCause(rootCause);
if (++rootCauseCount >= MaximumSamplesCount)
{
break;
}
}
Assert.That(rootCauseCount, Is.GreaterThan(0));
}
public async Task GetMetricDimensionValuesAsync()
{
string endpoint = MetricsAdvisorUri;
string subscriptionKey = MetricsAdvisorSubscriptionKey;
string apiKey = MetricsAdvisorApiKey;
var credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);
var client = new MetricsAdvisorClient(new Uri(endpoint), credential);
string metricId = MetricId;
string dimensionName = "city";
var options = new GetMetricDimensionValuesOptions()
{
MaxPageSize = 10
};
Console.WriteLine($"The dimension '{dimensionName}' can assume the following values (limited to 10):");
int dimensionValueCount = 0;
await foreach (string dimensionValue in client.GetMetricDimensionValuesAsync(metricId, dimensionName, options))
{
Console.WriteLine($" {dimensionValue}");
// Print at most 10 values.
if (++dimensionValueCount >= 10)
{
break;
}
}
}
public async Task AddAndGetAnomalyFeedbackWithMinimumSetup(bool useTokenCredential)
{
MetricsAdvisorClient client = GetMetricsAdvisorClient(useTokenCredential);
var filter = new FeedbackDimensionFilter();
filter.DimensionFilter.AddDimensionColumn("city", ExpectedCity);
filter.DimensionFilter.AddDimensionColumn("category", ExpectedCategory);
var feedbackToAdd = new MetricAnomalyFeedback(MetricId, filter, CreatedFeedbackStartTime, CreatedFeedbackEndTime, AnomalyValue.AutoDetect);
MetricFeedback addedFeedback = await client.AddFeedbackAsync(feedbackToAdd);
ValidateMetricFeedback(addedFeedback);
Assert.That(addedFeedback.Type, Is.EqualTo(FeedbackType.Anomaly));
var anomalyFeedback = addedFeedback as MetricAnomalyFeedback;
Assert.That(anomalyFeedback, Is.Not.Null);
Assert.That(anomalyFeedback.AnomalyValue, Is.EqualTo(AnomalyValue.AutoDetect));
Assert.That(anomalyFeedback.StartTime, Is.EqualTo(CreatedFeedbackStartTime));
Assert.That(anomalyFeedback.EndTime, Is.EqualTo(CreatedFeedbackEndTime));
Assert.That(anomalyFeedback.AnomalyDetectionConfigurationId, Is.Null);
Assert.That(anomalyFeedback.AnomalyDetectionConfigurationSnapshot, Is.Null);
}
public async Task GetIncidentRootCausesForIncidentFromAlert()
{
const string incidentId = "88ecf25a0e6bd330ef9e7b49b7c5b92b-17f9f794800";
MetricsAdvisorClient client = GetMetricsAdvisorClient();
AnomalyIncident incident = null;
await foreach (AnomalyIncident currentIncident in client.GetIncidentsForAlertAsync(AlertConfigurationId, AlertId))
{
if (currentIncident.Id == incidentId)
{
incident = currentIncident;
break;
}
}
Assert.That(incident, Is.Not.Null);
var rootCauseCount = 0;
await foreach (IncidentRootCause rootCause in client.GetIncidentRootCausesAsync(incident))
{
ValidateIncidentRootCause(rootCause);
if (++rootCauseCount >= MaximumSamplesCount)
{
break;
}
}
Assert.That(rootCauseCount, Is.GreaterThan(0));
}
public async Task AddAndGetCommentFeedbackWithOptionalTimeFilters()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var filter = new FeedbackDimensionFilter();
filter.DimensionFilter.AddDimensionColumn("city", ExpectedCity);
filter.DimensionFilter.AddDimensionColumn("category", ExpectedCategory);
var comment = "Feedback created in a .NET test.";
var feedbackToAdd = new MetricCommentFeedback(MetricId, filter, comment)
{
StartTime = CreatedFeedbackStartTime,
EndTime = CreatedFeedbackEndTime
};
MetricFeedback addedFeedback = await client.AddFeedbackAsync(feedbackToAdd);
ValidateMetricFeedback(addedFeedback);
Assert.That(addedFeedback.Type, Is.EqualTo(FeedbackType.Comment));
var commentFeedback = addedFeedback as MetricCommentFeedback;
Assert.That(commentFeedback, Is.Not.Null);
Assert.That(commentFeedback.Comment, Is.EqualTo(comment));
Assert.That(commentFeedback.StartTime, Is.EqualTo(CreatedFeedbackStartTime));
Assert.That(commentFeedback.EndTime, Is.EqualTo(CreatedFeedbackEndTime));
}
public async Task AddAndGetPeriodFeedback()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var filter = new FeedbackDimensionFilter();
filter.DimensionFilter.AddDimensionColumn("city", ExpectedCity);
filter.DimensionFilter.AddDimensionColumn("category", ExpectedCategory);
var periodValue = 10;
var feedbackToAdd = new MetricPeriodFeedback(MetricId, filter, PeriodType.AutoDetect, periodValue);
MetricFeedback addedFeedback = await client.AddFeedbackAsync(feedbackToAdd);
ValidateMetricFeedback(addedFeedback);
Assert.That(addedFeedback.Type, Is.EqualTo(FeedbackType.Period));
var periodFeedback = addedFeedback as MetricPeriodFeedback;
Assert.That(periodFeedback, Is.Not.Null);
Assert.That(periodFeedback.PeriodType, Is.EqualTo(PeriodType.AutoDetect));
Assert.That(periodFeedback.PeriodValue, Is.EqualTo(periodValue));
}
public async Task AddAndGetCommentFeedbackWithMinimumSetup()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var dimensions = new Dictionary <string, string>()
{
{ "Dim1", ExpectedDim1 }, { "Dim2", ExpectedDim2 }
};
var dimensionKey = new DimensionKey(dimensions);
var comment = "Feedback created in a .NET test.";
var feedbackToAdd = new MetricCommentFeedback(MetricId, dimensionKey, comment);
MetricFeedback addedFeedback = await client.AddFeedbackAsync(feedbackToAdd);
ValidateMetricFeedback(addedFeedback);
Assert.That(addedFeedback.FeedbackKind, Is.EqualTo(MetricFeedbackKind.Comment));
var commentFeedback = addedFeedback as MetricCommentFeedback;
Assert.That(commentFeedback, Is.Not.Null);
Assert.That(commentFeedback.Comment, Is.EqualTo(comment));
Assert.That(commentFeedback.StartsOn, Is.Null);
Assert.That(commentFeedback.EndsOn, Is.Null);
Assert.That(commentFeedback.UserPrincipal, Is.Not.Null.And.Not.Empty);
}
public async Task AddAndGetChangePointFeedback()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var dimensionKey = new DimensionKey();
dimensionKey.AddDimensionColumn("city", "Delhi");
dimensionKey.AddDimensionColumn("category", "Handmade");
var filter = new FeedbackDimensionFilter(dimensionKey);
var feedbackToAdd = new MetricChangePointFeedback(MetricId, filter, CreatedFeedbackStartTime, CreatedFeedbackEndTime, ChangePointValue.AutoDetect);
string feedbackId = await client.AddFeedbackAsync(feedbackToAdd);
Assert.That(feedbackId, Is.Not.Null);
MetricFeedback addedFeedback = await client.GetFeedbackAsync(feedbackId);
ValidateMetricFeedback(addedFeedback, feedbackId, dimensionKey);
Assert.That(addedFeedback.Type, Is.EqualTo(FeedbackType.ChangePoint));
var changePointFeedback = addedFeedback as MetricChangePointFeedback;
Assert.That(changePointFeedback, Is.Not.Null);
Assert.That(changePointFeedback.ChangePointValue, Is.EqualTo(ChangePointValue.AutoDetect));
Assert.That(changePointFeedback.StartTime, Is.EqualTo(CreatedFeedbackStartTime));
Assert.That(changePointFeedback.EndTime, Is.EqualTo(CreatedFeedbackEndTime));
}
public async Task AddAndGetAnomalyFeedbackWithMinimumSetup()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var dimensionKey = new DimensionKey();
dimensionKey.AddDimensionColumn("city", "Delhi");
dimensionKey.AddDimensionColumn("category", "Handmade");
var filter = new FeedbackDimensionFilter(dimensionKey);
var feedbackToAdd = new MetricAnomalyFeedback(MetricId, filter, CreatedFeedbackStartTime, CreatedFeedbackEndTime, AnomalyValue.AutoDetect);
string feedbackId = await client.AddFeedbackAsync(feedbackToAdd);
Assert.That(feedbackId, Is.Not.Null);
MetricFeedback addedFeedback = await client.GetFeedbackAsync(feedbackId);
ValidateMetricFeedback(addedFeedback, feedbackId, dimensionKey);
Assert.That(addedFeedback.Type, Is.EqualTo(FeedbackType.Anomaly));
var anomalyFeedback = addedFeedback as MetricAnomalyFeedback;
Assert.That(anomalyFeedback, Is.Not.Null);
Assert.That(anomalyFeedback.AnomalyValue, Is.EqualTo(AnomalyValue.AutoDetect));
Assert.That(anomalyFeedback.StartTime, Is.EqualTo(CreatedFeedbackStartTime));
Assert.That(anomalyFeedback.EndTime, Is.EqualTo(CreatedFeedbackEndTime));
Assert.That(anomalyFeedback.AnomalyDetectionConfigurationId, Is.Null);
Assert.That(anomalyFeedback.AnomalyDetectionConfigurationSnapshot, Is.Null);
}
public async Task AddAndGetPeriodFeedback()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var dimensionKey = new DimensionKey();
dimensionKey.AddDimensionColumn("city", "Delhi");
dimensionKey.AddDimensionColumn("category", "Handmade");
var filter = new FeedbackDimensionFilter(dimensionKey);
var periodValue = 10;
var feedbackToAdd = new MetricPeriodFeedback(MetricId, filter, PeriodType.AutoDetect, periodValue);
string feedbackId = await client.AddFeedbackAsync(feedbackToAdd);
Assert.That(feedbackId, Is.Not.Null);
MetricFeedback addedFeedback = await client.GetFeedbackAsync(feedbackId);
ValidateMetricFeedback(addedFeedback, feedbackId, dimensionKey);
Assert.That(addedFeedback.Type, Is.EqualTo(FeedbackType.Period));
var periodFeedback = addedFeedback as MetricPeriodFeedback;
Assert.That(periodFeedback, Is.Not.Null);
Assert.That(periodFeedback.PeriodType, Is.EqualTo(PeriodType.AutoDetect));
Assert.That(periodFeedback.PeriodValue, Is.EqualTo(periodValue));
}
public async Task AddAndGetAnomalyFeedbackWithOptionalDetectionConfigurationFilter()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var filter = new FeedbackDimensionFilter();
filter.DimensionFilter.AddDimensionColumn("city", ExpectedCity);
filter.DimensionFilter.AddDimensionColumn("category", ExpectedCategory);
var feedbackToAdd = new MetricAnomalyFeedback(MetricId, filter, CreatedFeedbackStartTime, CreatedFeedbackEndTime, AnomalyValue.AutoDetect)
{
AnomalyDetectionConfigurationId = DetectionConfigurationId
};
MetricFeedback addedFeedback = await client.AddFeedbackAsync(feedbackToAdd);
ValidateMetricFeedback(addedFeedback);
Assert.That(addedFeedback.Type, Is.EqualTo(FeedbackType.Anomaly));
var anomalyFeedback = addedFeedback as MetricAnomalyFeedback;
Assert.That(anomalyFeedback, Is.Not.Null);
Assert.That(anomalyFeedback.AnomalyValue, Is.EqualTo(AnomalyValue.AutoDetect));
Assert.That(anomalyFeedback.StartTime, Is.EqualTo(CreatedFeedbackStartTime));
Assert.That(anomalyFeedback.EndTime, Is.EqualTo(CreatedFeedbackEndTime));
Assert.That(anomalyFeedback.AnomalyDetectionConfigurationId, Is.EqualTo(DetectionConfigurationId));
// TODO: Add snapshot validation (https://github.com/azure/azure-sdk-for-net/issues/15915)
}
public async Task GetIncidentRootCausesForIncidentFromDetectionConfiguration()
{
const string incidentId = "88ecf25a0e6bd330ef9e7b49b7c5b92b-17fc385cc00";
MetricsAdvisorClient client = GetMetricsAdvisorClient();
AnomalyIncident incident = null;
var options = new GetIncidentsForDetectionConfigurationOptions(SamplingStartTime, SamplingEndTime);
await foreach (AnomalyIncident currentIncident in client.GetIncidentsForDetectionConfigurationAsync(DetectionConfigurationId, options))
{
if (currentIncident.Id == incidentId)
{
incident = currentIncident;
break;
}
}
Assert.That(incident, Is.Not.Null);
var rootCauseCount = 0;
await foreach (IncidentRootCause rootCause in client.GetIncidentRootCausesAsync(incident))
{
ValidateIncidentRootCause(rootCause);
if (++rootCauseCount >= MaximumSamplesCount)
{
break;
}
}
Assert.That(rootCauseCount, Is.GreaterThan(0));
}
public async Task AddAndGetCommentFeedbackWithOptionalTimeFilters()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var dimensions = new Dictionary <string, string>()
{
{ "city", ExpectedCity }, { "category", ExpectedCategory }
};
var dimensionKey = new DimensionKey(dimensions);
var comment = "Feedback created in a .NET test.";
var feedbackToAdd = new MetricCommentFeedback(MetricId, dimensionKey, comment)
{
StartsOn = CreatedFeedbackStartTime,
EndsOn = CreatedFeedbackEndTime
};
MetricFeedback addedFeedback = await client.AddFeedbackAsync(feedbackToAdd);
ValidateMetricFeedback(addedFeedback);
Assert.That(addedFeedback.FeedbackKind, Is.EqualTo(MetricFeedbackKind.Comment));
var commentFeedback = addedFeedback as MetricCommentFeedback;
Assert.That(commentFeedback, Is.Not.Null);
Assert.That(commentFeedback.Comment, Is.EqualTo(comment));
Assert.That(commentFeedback.StartsOn, Is.EqualTo(CreatedFeedbackStartTime));
Assert.That(commentFeedback.EndsOn, Is.EqualTo(CreatedFeedbackEndTime));
Assert.That(commentFeedback.UserPrincipal, Is.Not.Null.And.Not.Empty);
}
public async Task GetAnomalyDimensionValuesWithOptionalDimensionFilter()
{
const string dimensionName = "Dim1";
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var dimensions = new Dictionary <string, string>()
{
{ "Dim2", "JP" }
};
var options = new GetAnomalyDimensionValuesOptions(SamplingStartTime, SamplingEndTime)
{
SeriesGroupKey = new DimensionKey(dimensions)
};
var valueCount = 0;
await foreach (string value in client.GetAnomalyDimensionValuesAsync(DetectionConfigurationId, dimensionName, options))
{
Assert.That(value, Is.Not.Null.And.Not.Empty);
if (++valueCount >= MaximumSamplesCount)
{
break;
}
}
Assert.That(valueCount, Is.GreaterThan(0));
}
public async Task AddAndGetPeriodFeedback()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var dimensions = new Dictionary <string, string>()
{
{ "city", ExpectedCity }, { "category", ExpectedCategory }
};
var dimensionKey = new DimensionKey(dimensions);
var periodValue = 10;
var feedbackToAdd = new MetricPeriodFeedback(MetricId, dimensionKey, MetricPeriodType.AutoDetect, periodValue);
MetricFeedback addedFeedback = await client.AddFeedbackAsync(feedbackToAdd);
ValidateMetricFeedback(addedFeedback);
Assert.That(addedFeedback.FeedbackKind, Is.EqualTo(MetricFeedbackKind.Period));
var periodFeedback = addedFeedback as MetricPeriodFeedback;
Assert.That(periodFeedback, Is.Not.Null);
Assert.That(periodFeedback.PeriodType, Is.EqualTo(MetricPeriodType.AutoDetect));
Assert.That(periodFeedback.PeriodValue, Is.EqualTo(periodValue));
Assert.That(periodFeedback.UserPrincipal, Is.Not.Null.And.Not.Empty);
}
public async Task GetValuesOfDimensionWithAnomalies(bool populateOptionalMembers)
{
const string dimensionName = "city";
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var options = new GetValuesOfDimensionWithAnomaliesOptions(SamplingStartTime, SamplingEndTime);
if (populateOptionalMembers)
{
options.DimensionToFilter = new DimensionKey();
options.DimensionToFilter.AddDimensionColumn("category", "Handmade");
}
var valueCount = 0;
await foreach (string value in client.GetValuesOfDimensionWithAnomaliesAsync(DetectionConfigurationId, dimensionName, options))
{
Assert.That(value, Is.Not.Null.And.Not.Empty);
if (++valueCount >= MaximumSamplesCount)
{
break;
}
}
Assert.That(valueCount, Is.GreaterThan(0));
}
public async Task AddAndGetAnomalyFeedbackWithMinimumSetup(bool useTokenCredential)
{
MetricsAdvisorClient client = GetMetricsAdvisorClient(useTokenCredential);
var dimensions = new Dictionary <string, string>()
{
{ "city", ExpectedCity }, { "category", ExpectedCategory }
};
var dimensionKey = new DimensionKey(dimensions);
var feedbackToAdd = new MetricAnomalyFeedback(MetricId, dimensionKey, CreatedFeedbackStartTime, CreatedFeedbackEndTime, AnomalyValue.AutoDetect);
MetricFeedback addedFeedback = await client.AddFeedbackAsync(feedbackToAdd);
ValidateMetricFeedback(addedFeedback);
Assert.That(addedFeedback.FeedbackKind, Is.EqualTo(MetricFeedbackKind.Anomaly));
var anomalyFeedback = addedFeedback as MetricAnomalyFeedback;
Assert.That(anomalyFeedback, Is.Not.Null);
Assert.That(anomalyFeedback.AnomalyValue, Is.EqualTo(AnomalyValue.AutoDetect));
Assert.That(anomalyFeedback.StartsOn, Is.EqualTo(CreatedFeedbackStartTime));
Assert.That(anomalyFeedback.EndsOn, Is.EqualTo(CreatedFeedbackEndTime));
Assert.That(anomalyFeedback.UserPrincipal, Is.Not.Null.And.Not.Empty);
Assert.That(anomalyFeedback.DetectionConfigurationId, Is.Null);
Assert.That(anomalyFeedback.DetectionConfigurationSnapshot, Is.Null);
}
public async Task GetAnomalyDimensionValuesAsync()
{
string endpoint = MetricsAdvisorUri;
string subscriptionKey = MetricsAdvisorSubscriptionKey;
string apiKey = MetricsAdvisorApiKey;
var credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);
var client = new MetricsAdvisorClient(new Uri(endpoint), credential);
string detectionConfigurationId = DetectionConfigurationId;
string dimensionName = "city";
var startTime = DateTimeOffset.Parse("2020-01-01T00:00:00Z");
var endTime = DateTimeOffset.UtcNow;
var options = new GetAnomalyDimensionValuesOptions(startTime, endTime)
{
MaxPageSize = 10
};
Console.WriteLine($"The dimension '{dimensionName}' assumed the following values on anomalous data points (limited to 10):");
int dimensionValueCount = 0;
await foreach (string dimensionValue in client.GetAnomalyDimensionValuesAsync(detectionConfigurationId, dimensionName, options))
{
Console.WriteLine($" {dimensionValue}");
// Print at most 10 values.
if (++dimensionValueCount >= 10)
{
break;
}
}
}
public async Task AddAndGetAnomalyFeedbackWithOptionalDetectionConfigurationFilter()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var dimensions = new Dictionary <string, string>()
{
{ "city", ExpectedCity }, { "category", ExpectedCategory }
};
var dimensionKey = new DimensionKey(dimensions);
var feedbackToAdd = new MetricAnomalyFeedback(MetricId, dimensionKey, CreatedFeedbackStartTime, CreatedFeedbackEndTime, AnomalyValue.AutoDetect)
{
DetectionConfigurationId = DetectionConfigurationId
};
MetricFeedback addedFeedback = await client.AddFeedbackAsync(feedbackToAdd);
ValidateMetricFeedback(addedFeedback);
Assert.That(addedFeedback.FeedbackKind, Is.EqualTo(MetricFeedbackKind.Anomaly));
var anomalyFeedback = addedFeedback as MetricAnomalyFeedback;
Assert.That(anomalyFeedback, Is.Not.Null);
Assert.That(anomalyFeedback.AnomalyValue, Is.EqualTo(AnomalyValue.AutoDetect));
Assert.That(anomalyFeedback.StartsOn, Is.EqualTo(CreatedFeedbackStartTime));
Assert.That(anomalyFeedback.EndsOn, Is.EqualTo(CreatedFeedbackEndTime));
Assert.That(anomalyFeedback.UserPrincipal, Is.Not.Null.And.Not.Empty);
Assert.That(anomalyFeedback.DetectionConfigurationId, Is.EqualTo(DetectionConfigurationId));
// TODO: Add snapshot validation (https://github.com/azure/azure-sdk-for-net/issues/15915)
}
public async Task GetIncidentsForAlert(bool useTokenCredential)
{
MetricsAdvisorClient client = GetMetricsAdvisorClient(useTokenCredential);
var incidentCount = 0;
await foreach (AnomalyIncident incident in client.GetIncidentsForAlertAsync(AlertConfigurationId, AlertId))
{
Assert.That(incident, Is.Not.Null);
Assert.That(incident.Id, Is.Not.Null.And.Not.Empty);
Assert.That(incident.DataFeedId, Is.Not.Null.And.Not.Empty);
Assert.That(incident.MetricId, Is.Not.Null.And.Not.Empty);
Assert.That(incident.DetectionConfigurationId, Is.Not.Null.And.Not.Empty);
Assert.That(incident.StartedOn, Is.Not.EqualTo(default(DateTimeOffset)));
Assert.That(incident.LastDetectedOn, Is.Not.EqualTo(default(DateTimeOffset)));
Assert.That(incident.Status, Is.Not.EqualTo(default(AnomalyIncidentStatus)));
// Service bug: https://github.com/Azure/azure-sdk-for-net/issues/16581
//Assert.That(incident.Severity, Is.Not.EqualTo(default(AnomalySeverity)));
ValidateSeriesKey(incident.RootSeriesKey);
if (++incidentCount >= MaximumSamplesCount)
{
break;
}
}
Assert.That(incidentCount, Is.GreaterThan(0));
}
public async Task AddAndGetChangePointFeedback()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var dimensions = new Dictionary <string, string>()
{
{ "city", ExpectedCity }, { "category", ExpectedCategory }
};
var dimensionKey = new DimensionKey(dimensions);
var feedbackToAdd = new MetricChangePointFeedback(MetricId, dimensionKey, CreatedFeedbackStartTime, CreatedFeedbackEndTime, ChangePointValue.AutoDetect);
MetricFeedback addedFeedback = await client.AddFeedbackAsync(feedbackToAdd);
ValidateMetricFeedback(addedFeedback);
Assert.That(addedFeedback.FeedbackKind, Is.EqualTo(MetricFeedbackKind.ChangePoint));
var changePointFeedback = addedFeedback as MetricChangePointFeedback;
Assert.That(changePointFeedback, Is.Not.Null);
Assert.That(changePointFeedback.ChangePointValue, Is.EqualTo(ChangePointValue.AutoDetect));
Assert.That(changePointFeedback.StartsOn, Is.EqualTo(CreatedFeedbackStartTime));
Assert.That(changePointFeedback.EndsOn, Is.EqualTo(CreatedFeedbackEndTime));
Assert.That(changePointFeedback.UserPrincipal, Is.Not.Null.And.Not.Empty);
}
public async Task GetAnomaliesForAlert(bool useTokenCredential)
{
MetricsAdvisorClient client = GetMetricsAdvisorClient(useTokenCredential);
var anomalyCount = 0;
await foreach (DataPointAnomaly anomaly in client.GetAnomaliesForAlertAsync(AlertConfigurationId, AlertId))
{
Assert.That(anomaly, Is.Not.Null);
Assert.That(anomaly.DataFeedId, Is.Not.Null.And.Not.Empty);
Assert.That(anomaly.MetricId, Is.Not.Null.And.Not.Empty);
Assert.That(anomaly.DetectionConfigurationId, Is.Not.Null.And.Not.Empty);
Assert.That(anomaly.Timestamp, Is.Not.EqualTo(default(DateTimeOffset)));
Assert.That(anomaly.CreatedOn, Is.Not.EqualTo(default(DateTimeOffset)));
Assert.That(anomaly.LastModified, Is.Not.EqualTo(default(DateTimeOffset)));
Assert.That(anomaly.Status, Is.Not.EqualTo(default(AnomalyStatus)));
Assert.That(anomaly.Severity, Is.Not.EqualTo(default(AnomalySeverity)));
ValidateSeriesKey(anomaly.SeriesKey);
if (++anomalyCount >= MaximumSamplesCount)
{
break;
}
}
Assert.That(anomalyCount, Is.GreaterThan(0));
}
public async Task GetAnomaliesForDetectionConfigurationWithMinimumSetup(bool useTokenCredential)
{
MetricsAdvisorClient client = GetMetricsAdvisorClient(useTokenCredential);
var options = new GetAnomaliesForDetectionConfigurationOptions(SamplingStartTime, SamplingEndTime);
var anomalyCount = 0;
await foreach (DataPointAnomaly anomaly in client.GetAnomaliesForDetectionConfigurationAsync(DetectionConfigurationId, options))
{
Assert.That(anomaly, Is.Not.Null);
Assert.That(anomaly.DataFeedId, Is.Null);
Assert.That(anomaly.MetricId, Is.Null);
Assert.That(anomaly.DetectionConfigurationId, Is.Null);
Assert.That(anomaly.CreatedOn, Is.Null);
Assert.That(anomaly.LastModified, Is.Null);
Assert.That(anomaly.Status, Is.Null);
Assert.That(anomaly.Timestamp, Is.InRange(SamplingStartTime, SamplingEndTime));
Assert.That(anomaly.Severity, Is.Not.EqualTo(default(AnomalySeverity)));
ValidateSeriesKey(anomaly.SeriesKey);
if (++anomalyCount >= MaximumSamplesCount)
{
break;
}
}
Assert.That(anomalyCount, Is.GreaterThan(0));
}
public async Task AddAndGetCommentFeedbackWithOptionalTimeFilters()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var dimensionKey = new DimensionKey();
dimensionKey.AddDimensionColumn("city", "Delhi");
dimensionKey.AddDimensionColumn("category", "Handmade");
var filter = new FeedbackDimensionFilter(dimensionKey);
var comment = "Feedback created in a .NET test.";
var feedbackToAdd = new MetricCommentFeedback(MetricId, filter, comment)
{
StartTime = CreatedFeedbackStartTime,
EndTime = CreatedFeedbackEndTime
};
string feedbackId = await client.AddFeedbackAsync(feedbackToAdd);
Assert.That(feedbackId, Is.Not.Null);
MetricFeedback addedFeedback = await client.GetFeedbackAsync(feedbackId);
ValidateMetricFeedback(addedFeedback, feedbackId, dimensionKey);
Assert.That(addedFeedback.Type, Is.EqualTo(FeedbackType.Comment));
var commentFeedback = addedFeedback as MetricCommentFeedback;
Assert.That(commentFeedback, Is.Not.Null);
Assert.That(commentFeedback.Comment, Is.EqualTo(comment));
Assert.That(commentFeedback.StartTime, Is.EqualTo(CreatedFeedbackStartTime));
Assert.That(commentFeedback.EndTime, Is.EqualTo(CreatedFeedbackEndTime));
}
public async Task GetMetricSeriesDataAsync()
{
string endpoint = MetricsAdvisorUri;
string subscriptionKey = MetricsAdvisorSubscriptionKey;
string apiKey = MetricsAdvisorApiKey;
var credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);
var client = new MetricsAdvisorClient(new Uri(endpoint), credential);
string metricId = MetricId;
var startsOn = DateTimeOffset.Parse("2020-01-01T00:00:00Z");
var endsOn = DateTimeOffset.UtcNow;
var options = new GetMetricSeriesDataOptions(startsOn, endsOn);
// Only the two time series with the keys specified below will be returned.
var dimensions = new Dictionary <string, string>()
{
{ "Dim1", "JPN" },
{ "Dim2", "__SUM__" }
};
var seriesKey1 = new DimensionKey(dimensions);
dimensions = new Dictionary <string, string>()
{
{ "Dim1", "USD" },
{ "Dim2", "US" }
};
var seriesKey2 = new DimensionKey(dimensions);
options.SeriesKeys.Add(seriesKey1);
options.SeriesKeys.Add(seriesKey2);
await foreach (MetricSeriesData seriesData in client.GetMetricSeriesDataAsync(metricId, options))
{
Console.WriteLine($"Time series metric ID: {seriesData.MetricId}");
Console.WriteLine("Time series key:");
foreach (KeyValuePair <string, string> keyValuePair in seriesData.SeriesKey)
{
Console.WriteLine($" Dimension '{keyValuePair.Key}': {keyValuePair.Value}");
}
Console.WriteLine("Data points:");
// Print at most 3 points per time series.
int totalPoints = seriesData.Timestamps.Count < 3 ? seriesData.Timestamps.Count : 3;
for (int pointIndex = 0; pointIndex < totalPoints; pointIndex++)
{
Console.WriteLine($" Point {pointIndex}:");
Console.WriteLine($" - Timestamp: {seriesData.Timestamps[pointIndex]}");
Console.WriteLine($" - Metric value: {seriesData.MetricValues[pointIndex]}");
}
Console.WriteLine();
}
}
public async Task GetIncidentsForDetectionConfigurationAsync()
{
string endpoint = MetricsAdvisorUri;
string subscriptionKey = MetricsAdvisorSubscriptionKey;
string apiKey = MetricsAdvisorApiKey;
var credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);
var client = new MetricsAdvisorClient(new Uri(endpoint), credential);
string detectionConfigurationId = DetectionConfigurationId;
// Only incidents from time series that are part of one of the groups specified
// will be returned.
var groupKey1 = new DimensionKey();
groupKey1.AddDimensionColumn("city", "Bengaluru");
var groupKey2 = new DimensionKey();
groupKey2.AddDimensionColumn("city", "Hong Kong");
groupKey2.AddDimensionColumn("category", "Industrial & Scientific");
var startTime = DateTimeOffset.Parse("2020-01-01T00:00:00Z");
var endTime = DateTimeOffset.UtcNow;
var options = new GetIncidentsForDetectionConfigurationOptions(startTime, endTime)
{
DimensionsToFilter = new List <DimensionKey>()
{
groupKey1, groupKey2
},
TopCount = 3
};
int incidentCount = 0;
await foreach (AnomalyIncident incident in client.GetIncidentsForDetectionConfigurationAsync(detectionConfigurationId, options))
{
Console.WriteLine($"Incident ID: {incident.Id}");
Console.WriteLine($"First associated anomaly occurred at: {incident.StartTime}");
Console.WriteLine($"Last associated anomaly occurred at: {incident.LastTime}");
Console.WriteLine($"Status: {incident.Status}");
Console.WriteLine($"Severity: {incident.Severity}");
Console.WriteLine("Series key:");
foreach (KeyValuePair <string, string> keyValuePair in incident.DimensionKey.AsDictionary())
{
Console.WriteLine($" Dimension '{keyValuePair.Key}': {keyValuePair.Value}");
}
Console.WriteLine();
// Print at most 3 incidents.
if (++incidentCount >= 3)
{
break;
}
}
}
