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 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 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 AddAndGetAnomalyFeedbackWithOptionalDetectionConfigurationFilter()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var dimensions = new Dictionary <string, string>()
{
{ "region", ExpectedRegion }, { "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 AddAndGetChangePointFeedback()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var dimensions = new Dictionary <string, string>()
{
{ "region", ExpectedRegion }, { "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 AddAndGetAnomalyFeedbackWithMinimumSetup(bool useTokenCredential)
{
MetricsAdvisorClient client = GetMetricsAdvisorClient(useTokenCredential);
var dimensions = new Dictionary <string, string>()
{
{ "region", ExpectedRegion }, { "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 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 AddAndGetCommentFeedbackWithOptionalTimeFilters()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var dimensions = new Dictionary <string, string>()
{
{ "region", ExpectedRegion }, { "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 AddAndGetPeriodFeedback()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var dimensions = new Dictionary <string, string>()
{
{ "region", ExpectedRegion }, { "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 AddFeedbackAsync()
{
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 dimensions = new Dictionary <string, string>()
{
{ "region", "Karachi" }
};
var dimensionKey = new DimensionKey(dimensions);
var startsOn = DateTimeOffset.Parse("2020-02-01T00:00:00Z");
var endsOn = DateTimeOffset.Parse("2020-02-03T00:00:00Z");
// Other types of feedback, such as MetricCommentFeedback, MetricChangePointFeedback,
// and MetricPeriodFeedback are supported as well.
var anomalyFeedback = new MetricAnomalyFeedback(metricId, dimensionKey, startsOn, endsOn, AnomalyValue.NotAnomaly);
Response <MetricFeedback> response = await client.AddFeedbackAsync(anomalyFeedback);
MetricFeedback addedFeedback = response.Value;
Console.WriteLine($"Feedback ID: {addedFeedback.Id}");
}
public async Task AddFeedbackAsync()
{
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;
FeedbackDimensionFilter filter = new FeedbackDimensionFilter();
filter.DimensionFilter.AddDimensionColumn("city", "Belo Horizonte");
var startTime = DateTimeOffset.Parse("2020-02-01T00:00:00Z");
var endTime = DateTimeOffset.Parse("2020-02-03T00:00:00Z");
// Other types of feedback, such as MetricCommentFeedback, MetricChangePointFeedback,
// and MetricPeriodFeedback are supported as well.
var anomalyFeedback = new MetricAnomalyFeedback(metricId, filter, startTime, endTime, AnomalyValue.NotAnomaly);
Response <MetricFeedback> response = await client.AddFeedbackAsync(anomalyFeedback);
MetricFeedback addedFeedback = response.Value;
Console.WriteLine($"Feedback ID: {addedFeedback.Id}");
}
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 AddAndGetAnomalyFeedbackWithMinimumSetup(bool useTokenCredential)
{
MetricsAdvisorClient client = GetMetricsAdvisorClient(useTokenCredential);
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 AddAndGetAnomalyFeedbackWithOptionalDetectionConfigurationFilter()
{
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)
{
AnomalyDetectionConfigurationId = DetectionConfigurationId
};
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.EqualTo(DetectionConfigurationId));
// TODO: Add snapshot validation (https://github.com/azure/azure-sdk-for-net/issues/15915)
}
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);
}
private void ValidateMetricFeedback(MetricFeedback feedback, string expectedFeedbackId, DimensionKey expectedDimensionKey)
{
Assert.That(feedback, Is.Not.Null);
Assert.That(feedback.Id, Is.EqualTo(expectedFeedbackId));
Assert.That(feedback.MetricId, Is.EqualTo(MetricId));
Assert.That(feedback.UserPrincipal, Is.Not.Null.And.Not.Empty);
DateTimeOffset justNow = Recording.UtcNow.Subtract(TimeSpan.FromMinutes(5));
Assert.That(feedback.CreatedTime, Is.GreaterThan(justNow));
Assert.That(feedback.DimensionFilter, Is.Not.Null);
Assert.That(feedback.DimensionFilter.DimensionFilter, Is.EqualTo(expectedDimensionKey));
}
public async Task MetricFeedbackGetsUnknownFeedback()
{
MockResponse getResponse = new MockResponse(200);
getResponse.SetContent(UnknownFeedbackContent);
MetricsAdvisorClient client = CreateInstrumentedClient(getResponse);
MetricFeedback feedback = await client.GetFeedbackAsync(FakeGuid);
Assert.That(feedback.Id, Is.EqualTo(FakeGuid));
Assert.That(feedback.CreatedOn, Is.EqualTo(DateTimeOffset.Parse("2021-01-01T00:00:00.000Z")));
Assert.That(feedback.UserPrincipal, Is.EqualTo("*****@*****.**"));
Assert.That(feedback.MetricId, Is.EqualTo(FakeGuid));
Assert.That(feedback.DimensionKey.TryGetValue("city", out string city));
Assert.That(city, Is.EqualTo("Delhi"));
}
public async Task GetFeedbackAsync()
{
string endpoint = MetricsAdvisorUri;
string subscriptionKey = MetricsAdvisorSubscriptionKey;
string apiKey = MetricsAdvisorApiKey;
var credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);
var client = new MetricsAdvisorClient(new Uri(endpoint), credential);
string feedbackId = FeedbackId;
Response <MetricFeedback> response = await client.GetFeedbackAsync(feedbackId);
MetricFeedback feedback = response.Value;
Console.WriteLine($"Feedback ID: {feedback.Id}");
Console.WriteLine($"Metric ID: {feedback.MetricId}");
Console.WriteLine($"Feedback type: {feedback.Type}");
Console.WriteLine();
if (feedback.Type == FeedbackType.Anomaly)
{
MetricAnomalyFeedback anomalyFeedback = feedback as MetricAnomalyFeedback;
Console.WriteLine($"Detection configuration ID: {anomalyFeedback.AnomalyDetectionConfigurationId}");
Console.WriteLine($"Anomaly value: {anomalyFeedback.AnomalyValue}");
}
else if (feedback.Type == FeedbackType.Comment)
{
MetricCommentFeedback commentFeedback = feedback as MetricCommentFeedback;
Console.WriteLine($"Comment: {commentFeedback.Comment}");
}
else if (feedback.Type == FeedbackType.ChangePoint)
{
MetricChangePointFeedback changePointFeedback = feedback as MetricChangePointFeedback;
Console.WriteLine($"Change point value: {changePointFeedback.ChangePointValue}");
}
else if (feedback.Type == FeedbackType.Period)
{
MetricPeriodFeedback periodFeedback = feedback as MetricPeriodFeedback;
Console.WriteLine($"Period type: {periodFeedback.PeriodType}");
Console.WriteLine($"Period value: {periodFeedback.PeriodValue}");
}
}
private void ValidateMetricFeedback(MetricFeedback feedback)
{
Assert.That(feedback, Is.Not.Null);
Assert.That(feedback.Id, Is.Not.Null.And.Not.Empty);
Assert.That(feedback.MetricId, Is.EqualTo(MetricId));
Assert.That(feedback.UserPrincipal, Is.Not.Null.And.Not.Empty);
DateTimeOffset justNow = Recording.UtcNow.Subtract(TimeSpan.FromMinutes(5));
Assert.That(feedback.CreatedTime, Is.GreaterThan(justNow));
Assert.That(feedback.DimensionFilter, Is.Not.Null);
Assert.That(feedback.DimensionFilter.DimensionFilter, Is.Not.Null);
var dimensionColumns = feedback.DimensionFilter.DimensionFilter.AsDictionary();
Assert.That(dimensionColumns.Count, Is.EqualTo(2));
Assert.That(dimensionColumns.ContainsKey("city"));
Assert.That(dimensionColumns.ContainsKey("category"));
Assert.That(dimensionColumns["city"], Is.EqualTo(ExpectedCity));
Assert.That(dimensionColumns["category"], Is.EqualTo(ExpectedCategory));
}
public async Task CreateMetricFeedback()
{
var client = GetMetricsAdvisorClient();
FeedbackDimensionFilter dimensionFilter = new FeedbackDimensionFilter(
new DimensionKey(
new Dictionary <string, string>
{
{ "Dim1", "Common Lime" },
{ "Dim2", "Ant" }
}));
DateTimeOffset start = Recording.UtcNow.AddMonths(-4);
DateTimeOffset end = Recording.UtcNow;
MetricAnomalyFeedback anomalyFeedback = new MetricAnomalyFeedback(MetricId, dimensionFilter, start, end, AnomalyValue.NotAnomaly);
MetricChangePointFeedback changePointFeedback = new MetricChangePointFeedback(MetricId, dimensionFilter, start, end, ChangePointValue.NotChangePoint);
MetricPeriodFeedback periodFeedback = new MetricPeriodFeedback(MetricId, dimensionFilter, PeriodType.AssignValue, 5);
MetricCommentFeedback commentFeedback = new MetricCommentFeedback(MetricId, dimensionFilter, "my comment");
var feedbacks = new List <MetricFeedback>
{
anomalyFeedback,
changePointFeedback,
periodFeedback,
commentFeedback
};
foreach (var feedback in feedbacks)
{
MetricFeedback createdFeedback = await client.CreateMetricFeedbackAsync(feedback).ConfigureAwait(false);
Assert.That(createdFeedback.MetricId, Is.EqualTo(MetricId));
Assert.That(createdFeedback.Id, Is.Not.Null);
MetricFeedback getFeedback = await client.GetMetricFeedbackAsync(feedbackId : createdFeedback.Id).ConfigureAwait(false);
Assert.That(getFeedback.Id, Is.EqualTo(createdFeedback.Id));
}
}
private void ValidateMetricFeedback(MetricFeedback feedback)
{
Assert.That(feedback, Is.Not.Null);
Assert.That(feedback.Id, Is.Not.Null.And.Not.Empty);
Assert.That(feedback.MetricId, Is.EqualTo(MetricId));
Assert.That(feedback.UserPrincipal, Is.Not.Null.And.Not.Empty);
DateTimeOffset justNow = Recording.UtcNow.Subtract(TimeSpan.FromMinutes(5));
Assert.That(feedback.CreatedOn, Is.GreaterThan(justNow));
Assert.That(feedback.DimensionFilter, Is.Not.Null);
DimensionKey dimensionFilter = feedback.DimensionFilter.DimensionKey;
Assert.That(dimensionFilter, Is.Not.Null);
Assert.That(Count(dimensionFilter), Is.EqualTo(2));
Assert.That(dimensionFilter.TryGetValue("region", out string region));
Assert.That(dimensionFilter.TryGetValue("category", out string category));
Assert.That(region, Is.EqualTo(ExpectedRegion));
Assert.That(category, Is.EqualTo(ExpectedCategory));
}
public async Task AddAndGetChangePointFeedback()
{
MetricsAdvisorClient client = GetMetricsAdvisorClient();
var filter = new FeedbackDimensionFilter();
filter.DimensionFilter.AddDimensionColumn("city", ExpectedCity);
filter.DimensionFilter.AddDimensionColumn("category", ExpectedCategory);
var feedbackToAdd = new MetricChangePointFeedback(MetricId, filter, CreatedFeedbackStartTime, CreatedFeedbackEndTime, ChangePointValue.AutoDetect);
MetricFeedback addedFeedback = await client.AddFeedbackAsync(feedbackToAdd);
ValidateMetricFeedback(addedFeedback);
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));
}
