private static MetricAlertMultipleResourceMultipleMetricCriteria GetSampleMultiResourceMetricCriteria()
{
MetricDimension metricDimension = new MetricDimension()
{
Name = "name1",
OperatorProperty = "Include",
Values = new List <string>()
{
"Primary"
}
};
MetricDimension[] metricDimensions = new MetricDimension[1] {
metricDimension
};
return(new MetricAlertMultipleResourceMultipleMetricCriteria(
allOf: new List <MultiMetricCriteria>
{
new MetricCriteria()
{
MetricName = "Metric Name",
Name = "metric1",
Dimensions = metricDimensions,
Threshold = 100,
OperatorProperty = "GreaterThan",
TimeAggregation = "Avergage"
}
}
));
}
private IEnumerator LoadData(string dimensionName)
{
var dataRequestForm = new WWWForm();
dataRequestForm.AddField("dimension", dimensionName);
var dataWebRequest = new WWW(String.Format("{0}:{1}/api/graph/data", Globals.SurfaceServerIp, Globals.SurfaceWebPort), dataRequestForm);
yield return(dataWebRequest);
var response = JsonUtility.FromJson <DataResponse>(dataWebRequest.text);
Dimension dimension;
if (response.isMetric)
{
var metricDimension = new MetricDimension();
metricDimension.PossibleTicks = response.ticks;
metricDimension.IsTimeBased = response.isTimeBased;
metricDimension.TimeFormat = response.timeFormat;
dimension = metricDimension;
}
else
{
var catDimension = new CategoricalDimension();
foreach (var mapping in response.mappings)
{
catDimension.Mappings.Add(new Dimension.Mapping {
Name = mapping.name, Value = mapping.value
});
}
dimension = catDimension;
}
var data = new Dimension.DimData[response.data.Length];
for (var i = 0; i < response.data.Length; i++)
{
// assuming ids are 0 - data.length
data[i].Id = int.Parse(response.data[i].id);
data[i].Value = response.data[i].value;
data[i].IsNull = response.data[i].isNull;
}
dimension.Data = data;
dimension.Name = response.name;
dimension.DisplayName = response.displayName;
dimension.DomainMin = response.domain.min;
dimension.DomainMax = response.domain.max;
dimension.HideTicks = response.hideTicks;
dimension.RebuildData();
foreach (var onDataLoaded in _loadOperations[dimensionName])
{
onDataLoaded(dimension);
}
_loadOperations.Remove(dimensionName);
}
public void CreateScrapeDefinition_MetricDimensionIsDistinguishable_UsesValueComparison()
{
// Arrange
var dimension1 = new MetricDimension {
Name = "MetricDimension1"
};
var dimension2 = new MetricDimension {
Name = "MetricDimension2"
};
// Assert
Assert.NotEqual(dimension1, dimension2);
}
public void CreateScrapeDefinition_MetricDimensionIsEquatable_UsesValueComparison()
{
// Arrange
var dimension1 = new MetricDimension {
Name = "MyMetricDimension"
};
var dimension2 = new MetricDimension {
Name = dimension1.Name
};
// Assert
Assert.Equal(dimension1, dimension2);
}
public static void AreEqual(MetricDimension exp, MetricDimension act)
{
if (exp != null)
{
Assert.Equal(exp.Name, act.Name);
Assert.Equal(exp.OperatorProperty, act.OperatorProperty);
AreEqual(exp.Values, act.Values);
}
else
{
Assert.Null(act);
}
}
///GENMHASH:DD75FFCB37A60861E81671503DB8AC7D:699F63E25F9B0B29EF53C7C4E377174F
public MetricAlertConditionImpl WithDimensionFilter(string dimensionName, params string[] values)
{
if (this.dimensions.ContainsKey(dimensionName))
{
dimensions.Remove(dimensionName);
}
var md = new MetricDimension
{
Name = dimensionName,
OperatorProperty = "Include",
Values = values
};
dimensions.Add(dimensionName, md);
return(this);
}
private static MetricAlertMultipleResourceMultipleMetricCriteria GetSampleDynamicMetricCriteria()
{
MetricDimension metricDimension = new MetricDimension()
{
Name = "name1",
OperatorProperty = "Include",
Values = new List <string>()
{
"Primary"
}
};
MetricDimension[] metricDimensions = new MetricDimension[1] {
metricDimension
};
return(new MetricAlertMultipleResourceMultipleMetricCriteria(
allOf: new List <MultiMetricCriteria>()
{
new DynamicMetricCriteria()
{
MetricName = "Metric Name",
Name = "metric1",
Dimensions = metricDimensions,
MetricNamespace = "Namespace",
AlertSensitivity = "High",
IgnoreDataBefore = null,
FailingPeriods = new DynamicThresholdFailingPeriods()
{
MinFailingPeriodsToAlert = 4,
NumberOfEvaluationPeriods = 4
},
OperatorProperty = "GreaterThan",
TimeAggregation = "Avergage"
}
}
));
}
protected override string DetermineMetricDimension(TResourceDefinition resourceDefinition, MetricDimension dimension)
{
if (IsEntityDeclared(resourceDefinition))
{
return(base.DetermineMetricDimension(resourceDefinition, dimension));
}
Logger.LogTrace("Using 'EntityName' dimension since no topic was configured.");
return("EntityName");
}
private static IEnumerable <Metric> CreateTransactionMetric(MetricFilter filter, MetricDimension metricDimension, IEnumerable <DynamicTableEntity> entities)
{
List <Metric> metrics = new List <Metric>();
// Get supported metric dimension
MetricFilterDimension filterDimension = metricDimension.Dimensions == null
? null
: metricDimension.Dimensions.FirstOrDefault(fd =>
string.Equals(fd.Name, StorageConstants.Dimensions.ApiDimensionName, StringComparison.OrdinalIgnoreCase));
// no dimensions (or no supported dimensions) means only get aggregate values (user;All)
if (filterDimension == null)
{
metrics.Add(new Metric()
{
Name = new LocalizableString()
{
Value = metricDimension.Name,
LocalizedValue = metricDimension.Name
},
StartTime = filter.StartTime,
EndTime = filter.EndTime,
TimeGrain = filter.TimeGrain,
Properties = new Dictionary <string, string>(),
MetricValues = entities
.Where(e => string.Equals(e.RowKey, GetTransactionRowKey(StorageConstants.Dimensions.ApiDimensionAggregateValue), StringComparison.OrdinalIgnoreCase))
.Select(e => GetMetricValueFromEntity(e, metricDimension.Name)).ToList()
});
}
// Dimension specified, get samples with requested dimension value
else
{
// This is the function for filtering based on dimension value (row key)
Func <IGrouping <string, DynamicTableEntity>, bool> groupFilter;
// dimension specified, but no values means get all and group by dimension value (row key)
if (filterDimension.Values == null || !filterDimension.Values.Any())
{
// select all groups, but leave off aggregate. Each group becomes one metric
groupFilter = (entityGroup) =>
!string.Equals(entityGroup.Key, GetTransactionRowKey(StorageConstants.Dimensions.ApiDimensionName), StringComparison.OrdinalIgnoreCase);
}
else
{
// select only groups specified by dimension values
groupFilter = (entityGroup) => filterDimension.Values.Select(GetTransactionRowKey).Contains(entityGroup.Key);
}
// Construct and add the metrics to the collection to return
metrics.AddRange(entities
.GroupBy(e => e.RowKey)
.Where(groupFilter)
.Select(entityGroup => new Metric()
{
Name = new LocalizableString()
{
Value = metricDimension.Name,
LocalizedValue = metricDimension.Name
},
StartTime = filter.StartTime,
EndTime = filter.EndTime,
TimeGrain = filter.TimeGrain,
Properties = new Dictionary <string, string>(),
MetricValues = entityGroup.Select(e => GetMetricValueFromEntity(e, metricDimension.Name)).ToList()
}));
}
// return only values specified
return(metrics);
}
public void CanCRUDMetricAlerts()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var rgName = SdkContext.RandomResourceName("jMonitor_", 18);
var saName = SdkContext.RandomResourceName("jMonitorSa", 18);
var dsName = SdkContext.RandomResourceName("jMonitorDs_", 18);
var ehName = SdkContext.RandomResourceName("jMonitorEH", 18);
var azure = TestHelper.CreateRollupClient();
try
{
var sa = azure.StorageAccounts.Define(saName)
.WithRegion(Region.USEast2)
.WithNewResourceGroup(rgName)
.Create();
var ag = azure.ActionGroups.Define("simpleActionGroup")
.WithExistingResourceGroup(rgName)
.DefineReceiver("first")
.WithPushNotification("*****@*****.**")
.WithEmail("*****@*****.**")
.WithSms("1", "4255655665")
.WithVoice("1", "2062066050")
.WithWebhook("https://www.rate.am")
.Attach()
.DefineReceiver("second")
.WithEmail("*****@*****.**")
.WithWebhook("https://www.spyur.am")
.Attach()
.Create();
var ma = azure.AlertRules.MetricAlerts.Define("somename")
.WithExistingResourceGroup(rgName)
.WithTargetResource(sa.Id)
.WithPeriod(TimeSpan.FromMinutes(15))
.WithFrequency(TimeSpan.FromMinutes(1))
.WithAlertDetails(3, "This alert rule is for U3 - Single resource multiple-criteria with dimensions-single timeseries")
.WithActionGroups(ag.Id)
.DefineAlertCriteria("Metric1")
.WithMetricName("Transactions", "Microsoft.Storage/storageAccounts")
.WithCondition(MetricAlertRuleCondition.GreaterThan, MetricAlertRuleTimeAggregation.Total, 100)
.WithDimension("ResponseType", "Success")
.WithDimension("ApiName", "GetBlob")
.Attach()
.Create();
Assert.NotNull(ma);
Assert.Equal(1, ma.Scopes.Count);
Assert.Equal(sa.Id, ma.Scopes.First());
Assert.Equal("This alert rule is for U3 - Single resource multiple-criteria with dimensions-single timeseries", ma.Description);
Assert.Equal(TimeSpan.FromMinutes(15), ma.WindowSize);
Assert.Equal(TimeSpan.FromMinutes(1), ma.EvaluationFrequency);
Assert.Equal(3, ma.Severity);
Assert.True(ma.Enabled);
Assert.True(ma.AutoMitigate);
Assert.Equal(1, ma.ActionGroupIds.Count);
Assert.Equal(ag.Id, ma.ActionGroupIds.First());
Assert.Equal(1, ma.AlertCriterias.Count);
var ac1 = ma.AlertCriterias.Values.First();
Assert.Equal("Metric1", ac1.Name);
Assert.Equal("Transactions", ac1.MetricName);
Assert.Equal("Microsoft.Storage/storageAccounts", ac1.MetricNamespace);
Assert.Equal(MetricAlertRuleCondition.GreaterThan, ac1.Condition);
Assert.Equal(MetricAlertRuleTimeAggregation.Total, ac1.TimeAggregation);
Assert.Equal(100.0, ac1.Threshold, 4);
Assert.Equal(2, ac1.Dimensions.Count);
MetricDimension d1 = ac1.Dimensions.ElementAt(0);
MetricDimension d2 = ac1.Dimensions.ElementAt(1);
Assert.Equal("ResponseType", d1.Name);
Assert.Equal(1, d1.Values.Count);
Assert.Equal("Success", d1.Values.ElementAt(0));
Assert.Equal("ApiName", d2.Name);
Assert.Equal(1, d2.Values.Count);
Assert.Equal("GetBlob", d2.Values.ElementAt(0));
var maFromGet = azure.AlertRules.MetricAlerts.GetById(ma.Id);
Assert.NotNull(maFromGet);
Assert.Equal(ma.Scopes.Count, maFromGet.Scopes.Count);
Assert.Equal(ma.Scopes.First(), maFromGet.Scopes.First());
Assert.Equal(ma.Description, maFromGet.Description);
Assert.Equal(ma.WindowSize, maFromGet.WindowSize);
Assert.Equal(ma.EvaluationFrequency, maFromGet.EvaluationFrequency);
Assert.Equal(ma.Severity, maFromGet.Severity);
Assert.Equal(ma.Enabled, maFromGet.Enabled);
Assert.Equal(ma.AutoMitigate, maFromGet.AutoMitigate);
Assert.Equal(ma.ActionGroupIds.Count, maFromGet.ActionGroupIds.Count);
Assert.Equal(ma.ActionGroupIds.First(), maFromGet.ActionGroupIds.First());
Assert.Equal(ma.AlertCriterias.Count, maFromGet.AlertCriterias.Count);
ac1 = maFromGet.AlertCriterias.Values.First();
Assert.Equal("Metric1", ac1.Name);
Assert.Equal("Transactions", ac1.MetricName);
Assert.Equal("Microsoft.Storage/storageAccounts", ac1.MetricNamespace);
Assert.Equal(MetricAlertRuleCondition.GreaterThan, ac1.Condition);
Assert.Equal(MetricAlertRuleTimeAggregation.Total, ac1.TimeAggregation);
Assert.Equal(100.00, ac1.Threshold, 4);
Assert.Equal(2, ac1.Dimensions.Count);
d1 = ac1.Dimensions.ElementAt(0);
d2 = ac1.Dimensions.ElementAt(1);
Assert.Equal("ResponseType", d1.Name);
Assert.Equal(1, d1.Values.Count);
Assert.Equal("Success", d1.Values.First());
Assert.Equal("ApiName", d2.Name);
Assert.Equal(1, d2.Values.Count);
Assert.Equal("GetBlob", d2.Values.First());
ma.Update()
.WithRuleDisabled()
.UpdateAlertCriteria("Metric1")
.WithCondition(MetricAlertRuleCondition.GreaterThan, MetricAlertRuleTimeAggregation.Total, 99)
.Parent()
.DefineAlertCriteria("Metric2")
.WithMetricName("SuccessE2ELatency", "Microsoft.Storage/storageAccounts")
.WithCondition(MetricAlertRuleCondition.GreaterThan, MetricAlertRuleTimeAggregation.Average, 200)
.WithDimension("ApiName", "GetBlob")
.Attach()
.Apply();
Assert.NotNull(ma);
Assert.Equal(1, ma.Scopes.Count);
Assert.Equal(sa.Id, ma.Scopes.First());
Assert.Equal("This alert rule is for U3 - Single resource multiple-criteria with dimensions-single timeseries", ma.Description);
Assert.Equal(TimeSpan.FromMinutes(15), ma.WindowSize);
Assert.Equal(TimeSpan.FromMinutes(1), ma.EvaluationFrequency);
Assert.Equal(3, ma.Severity);
Assert.False(ma.Enabled);
Assert.True(ma.AutoMitigate);
Assert.Equal(1, ma.ActionGroupIds.Count);
Assert.Equal(ag.Id, ma.ActionGroupIds.First());
Assert.Equal(2, ma.AlertCriterias.Count);
ac1 = ma.AlertCriterias.Values.ElementAt(0);
var ac2 = ma.AlertCriterias.Values.ElementAt(1);
Assert.Equal("Metric1", ac1.Name);
Assert.Equal("Transactions", ac1.MetricName);
Assert.Equal(MetricAlertRuleCondition.GreaterThan, ac1.Condition);
Assert.Equal(MetricAlertRuleTimeAggregation.Total, ac1.TimeAggregation);
Assert.Equal(99.0, ac1.Threshold, 4);
Assert.Equal(2, ac1.Dimensions.Count);
d1 = ac1.Dimensions.ElementAt(0);
d2 = ac1.Dimensions.ElementAt(1);
Assert.Equal("ResponseType", d1.Name);
Assert.Equal(1, d1.Values.Count);
Assert.Equal("Success", d1.Values.First());
Assert.Equal("ApiName", d2.Name);
Assert.Equal(1, d2.Values.Count);
Assert.Equal("GetBlob", d2.Values.First());
Assert.Equal("Metric2", ac2.Name);
Assert.Equal("SuccessE2ELatency", ac2.MetricName);
Assert.Equal("Microsoft.Storage/storageAccounts", ac2.MetricNamespace);
Assert.Equal(MetricAlertRuleCondition.GreaterThan, ac2.Condition);
Assert.Equal(MetricAlertRuleTimeAggregation.Average, ac2.TimeAggregation);
Assert.Equal(200.0, ac2.Threshold, 4);
Assert.Equal(1, ac2.Dimensions.Count);
d1 = ac2.Dimensions.First();
Assert.Equal("ApiName", d1.Name);
Assert.Equal(1, d1.Values.Count);
Assert.Equal("GetBlob", d1.Values.First());
maFromGet = azure.AlertRules.MetricAlerts.GetById(ma.Id);
Assert.NotNull(maFromGet);
Assert.Equal(1, maFromGet.Scopes.Count);
Assert.Equal(sa.Id, maFromGet.Scopes.First());
Assert.Equal("This alert rule is for U3 - Single resource multiple-criteria with dimensions-single timeseries", ma.Description);
Assert.Equal(TimeSpan.FromMinutes(15), maFromGet.WindowSize);
Assert.Equal(TimeSpan.FromMinutes(1), maFromGet.EvaluationFrequency);
Assert.Equal(3, maFromGet.Severity);
Assert.False(maFromGet.Enabled);
Assert.True(maFromGet.AutoMitigate);
Assert.Equal(1, maFromGet.ActionGroupIds.Count);
Assert.Equal(ag.Id, maFromGet.ActionGroupIds.First());
Assert.Equal(2, maFromGet.AlertCriterias.Count);
ac1 = maFromGet.AlertCriterias.Values.ElementAt(0);
ac2 = maFromGet.AlertCriterias.Values.ElementAt(1);
Assert.Equal("Metric1", ac1.Name);
Assert.Equal("Transactions", ac1.MetricName);
Assert.Equal(MetricAlertRuleCondition.GreaterThan, ac1.Condition);
Assert.Equal(MetricAlertRuleTimeAggregation.Total, ac1.TimeAggregation);
Assert.Equal(99.0, ac1.Threshold, 4);
Assert.Equal(2, ac1.Dimensions.Count);
d1 = ac1.Dimensions.ElementAt(0);
d2 = ac1.Dimensions.ElementAt(1);
Assert.Equal("ResponseType", d1.Name);
Assert.Equal(1, d1.Values.Count);
Assert.Equal("Success", d1.Values.First());
Assert.Equal("ApiName", d2.Name);
Assert.Equal(1, d2.Values.Count);
Assert.Equal("GetBlob", d2.Values.First());
Assert.Equal("Metric2", ac2.Name);
Assert.Equal("SuccessE2ELatency", ac2.MetricName);
Assert.Equal("Microsoft.Storage/storageAccounts", ac2.MetricNamespace);
Assert.Equal(MetricAlertRuleCondition.GreaterThan, ac2.Condition);
Assert.Equal(MetricAlertRuleTimeAggregation.Average, ac2.TimeAggregation);
Assert.Equal(200.0, ac2.Threshold, 4);
Assert.Equal(1, ac2.Dimensions.Count);
d1 = ac2.Dimensions.ElementAt(0);
Assert.Equal("ApiName", d1.Name);
Assert.Equal(1, d1.Values.Count);
Assert.Equal("GetBlob", d1.Values.First());
var alertsInRg = azure.AlertRules.MetricAlerts.ListByResourceGroup(rgName);
Assert.Single(alertsInRg);
maFromGet = alertsInRg.First();
Assert.NotNull(maFromGet);
Assert.Equal(1, maFromGet.Scopes.Count);
Assert.Equal(sa.Id, maFromGet.Scopes.First());
Assert.Equal("This alert rule is for U3 - Single resource multiple-criteria with dimensions-single timeseries", ma.Description);
Assert.Equal(TimeSpan.FromMinutes(15), maFromGet.WindowSize);
Assert.Equal(TimeSpan.FromMinutes(1), maFromGet.EvaluationFrequency);
Assert.Equal(3, maFromGet.Severity);
Assert.False(maFromGet.Enabled);
Assert.True(maFromGet.AutoMitigate);
Assert.Equal(1, maFromGet.ActionGroupIds.Count);
Assert.Equal(ag.Id, maFromGet.ActionGroupIds.First());
Assert.Equal(2, maFromGet.AlertCriterias.Count);
ac1 = maFromGet.AlertCriterias.Values.ElementAt(0);
ac2 = maFromGet.AlertCriterias.Values.ElementAt(1);
Assert.Equal("Metric1", ac1.Name);
Assert.Equal("Transactions", ac1.MetricName);
Assert.Equal(MetricAlertRuleCondition.GreaterThan, ac1.Condition);
Assert.Equal(MetricAlertRuleTimeAggregation.Total, ac1.TimeAggregation);
Assert.Equal(99.0, ac1.Threshold, 4);
Assert.Equal(2, ac1.Dimensions.Count);
d1 = ac1.Dimensions.ElementAt(0);
d2 = ac1.Dimensions.ElementAt(1);
Assert.Equal("ResponseType", d1.Name);
Assert.Equal(1, d1.Values.Count);
Assert.Equal("Success", d1.Values.First());
Assert.Equal("ApiName", d2.Name);
Assert.Equal(1, d2.Values.Count);
Assert.Equal("GetBlob", d2.Values.First());
Assert.Equal("Metric2", ac2.Name);
Assert.Equal("SuccessE2ELatency", ac2.MetricName);
Assert.Equal("Microsoft.Storage/storageAccounts", ac2.MetricNamespace);
Assert.Equal(MetricAlertRuleCondition.GreaterThan, ac2.Condition);
Assert.Equal(MetricAlertRuleTimeAggregation.Average, ac2.TimeAggregation);
Assert.Equal(200.0, ac2.Threshold, 4);
Assert.Equal(1, ac2.Dimensions.Count);
d1 = ac2.Dimensions.First();
Assert.Equal("ApiName", d1.Name);
Assert.Equal(1, d1.Values.Count);
Assert.Equal("GetBlob", d1.Values.First());
azure.AlertRules.MetricAlerts.DeleteById(ma.Id);
}
finally
{
try
{
azure.ResourceGroups.BeginDeleteByName(rgName);
}
catch { }
}
}
}
public void TestOperationsList()
{
testOutputHelper.WriteLine($"Running in {HttpMockServer.GetCurrentMode()} mode.");
using (StorageCacheTestContext context = new StorageCacheTestContext(this))
{
var client = context.GetClient <StorageCacheManagementClient>();
client.ApiVersion = StorageCacheTestEnvironmentUtilities.APIVersion;
ApiOperationDisplay stopOperationDisplay = new ApiOperationDisplay("Stop the cache", "Microsoft Azure HPC Cache", "Cache", "Stops the cache");
ApiOperationListResult result = OperationsExtensions.List(client.Operations);
IList <MetricSpecification> metrics = new List <MetricSpecification>();
MetricDimension dim = new MetricDimension
{
DisplayName = "dname",
InternalName = "iname",
Name = "name",
ToBeExportedForShoebox = false
};
IList <MetricDimension> dims = new List <MetricDimension>();
dims.Add(dim);
IList <string> aggrTypes = new List <string>();
aggrTypes.Add("string");
MetricSpecification metric = new MetricSpecification
{
AggregationType = "string",
Unit = "unit",
Name = "name",
MetricClass = "metricClass",
DisplayName = "displayName",
DisplayDescription = "displayDescription",
SupportedAggregationTypes = aggrTypes,
Dimensions = dims
};
ApiOperationPropertiesServiceSpecification serviceSpecification = new ApiOperationPropertiesServiceSpecification();
serviceSpecification.MetricSpecifications = metrics;
foreach (ApiOperation api in result.Value)
{
if (api.Name == "Microsoft.StorageCache/caches/Stop/action")
{
Assert.Equal(api.Display.Resource, stopOperationDisplay.Resource);
Assert.Equal(api.Display.Provider, stopOperationDisplay.Provider);
Assert.Equal(api.Display.Description, stopOperationDisplay.Description);
Assert.Equal(api.Display.Operation, stopOperationDisplay.Operation);
}
if (api.Name == "Microsoft.StorageCache/caches/providers/Microsoft.Insights/metricDefinitions/read")
{
testOutputHelper.WriteLine("Microsoft.StorageCache/caches/providers/Microsoft.Insights/metricDefinitions/read");
testOutputHelper.WriteLine($"isDataAction {api.IsDataAction}");
testOutputHelper.WriteLine($"origin {api.Origin}");
if (api.Display != null)
{
ApiOperationDisplay display = api.Display;
testOutputHelper.WriteLine($"Display operation {display.Operation}");
testOutputHelper.WriteLine($"Display provider {display.Provider}");
testOutputHelper.WriteLine($"Display resource {display.Resource}");
testOutputHelper.WriteLine($"Display description {display.Description}");
}
ApiOperationPropertiesServiceSpecification aopss = api.ServiceSpecification;
if (aopss != null)
{
IList <MetricSpecification> mss = aopss.MetricSpecifications;
foreach (MetricSpecification ms in mss)
{
testOutputHelper.WriteLine($"Metric Specification Name {ms.Name}");
testOutputHelper.WriteLine($"Metric Specification Display Name {ms.DisplayName}");
testOutputHelper.WriteLine($"Metric Specification Display Description {ms.DisplayDescription}");
testOutputHelper.WriteLine($"Metric Specification Unit {ms.Unit}");
testOutputHelper.WriteLine($"Metric Specification AggrType {ms.AggregationType}");
testOutputHelper.WriteLine($"Metric Specification MetricClass {ms.MetricClass}");
foreach (string sat in ms.SupportedAggregationTypes)
{
testOutputHelper.WriteLine($"Metric Specification Supported Aggr Type {sat}");
}
}
}
}
}
testOutputHelper.WriteLine($"NextLink {result.NextLink}");
Assert.True(result.Value.Count > 1);
// Try one with a null client.
Assert.Throws <System.NullReferenceException>(() => OperationsExtensions.List(null));
}
}
protected override string DetermineMetricDimension(string metricName, DataShareResourceDefinition resourceDefinition, MetricDimension dimension)
{
if (IsShareNameConfigured(resourceDefinition))
{
return(base.DetermineMetricDimension(metricName, resourceDefinition, dimension));
}
var dimensionName = GetMetricFilterFieldName(metricName);
Logger.LogTrace($"Using '{dimensionName}' dimension since no share name was configured.");
return(dimensionName);
}
private static IEnumerable<Metric> CreateTransactionMetric(MetricFilter filter, MetricDimension metricDimension, IEnumerable<DynamicTableEntity> entities)
{
List<Metric> metrics = new List<Metric>();
// Get supported metric dimension
MetricFilterDimension filterDimension = metricDimension.Dimensions == null
? null
: metricDimension.Dimensions.FirstOrDefault(fd =>
string.Equals(fd.Name, StorageConstants.Dimensions.ApiDimensionName, StringComparison.OrdinalIgnoreCase));
// no dimensions (or no supported dimensions) means only get aggregate values (user;All)
if (filterDimension == null)
{
metrics.Add(new Metric()
{
Name = new LocalizableString()
{
Value = metricDimension.Name,
LocalizedValue = metricDimension.Name
},
StartTime = filter.StartTime,
EndTime = filter.EndTime,
TimeGrain = filter.TimeGrain,
Properties = new Dictionary<string, string>(),
MetricValues = entities
.Where(e => string.Equals(e.RowKey, GetTransactionRowKey(StorageConstants.Dimensions.ApiDimensionAggregateValue), StringComparison.OrdinalIgnoreCase))
.Select(e => GetMetricValueFromEntity(e, metricDimension.Name)).ToList()
});
}
// Dimension specified, get samples with requested dimension value
else
{
// This is the function for filtering based on dimension value (row key)
Func<IGrouping<string, DynamicTableEntity>, bool> groupFilter;
// dimension specified, but no values means get all and group by dimension value (row key)
if (filterDimension.Values == null || !filterDimension.Values.Any())
{
// select all groups, but leave off aggregate. Each group becomes one metric
groupFilter = (entityGroup) =>
!string.Equals(entityGroup.Key, GetTransactionRowKey(StorageConstants.Dimensions.ApiDimensionName), StringComparison.OrdinalIgnoreCase);
}
else
{
// select only groups specified by dimension values
groupFilter = (entityGroup) => filterDimension.Values.Select(GetTransactionRowKey).Contains(entityGroup.Key);
}
// Construct and add the metrics to the collection to return
metrics.AddRange(entities
.GroupBy(e => e.RowKey)
.Where(groupFilter)
.Select(entityGroup => new Metric()
{
Name = new LocalizableString()
{
Value = metricDimension.Name,
LocalizedValue = metricDimension.Name
},
StartTime = filter.StartTime,
EndTime = filter.EndTime,
TimeGrain = filter.TimeGrain,
Properties = new Dictionary<string, string>(),
MetricValues = entityGroup.Select(e => GetMetricValueFromEntity(e, metricDimension.Name)).ToList()
}));
}
// return only values specified
return metrics;
}
