private void GetMetricAlertRule(MonitorManagementClient insightsClient)
{
MetricAlertResource expectedParameters = GetCreateOrUpdateRuleParameters();
MetricAlertResource alertRule = insightsClient.MetricAlerts.Get(resourceGroupName: ResourceGroupName, ruleName: RuleName);
Utilities.AreEqual(expectedParameters, alertRule);
}
protected override void ProcessRecordInternal()
{
if (this.IsParameterBound(c => c.ResourceId))
{
var resourceIdentifier = new ResourceIdentifier(this.ResourceId);
this.ResourceGroupName = resourceIdentifier.ResourceGroupName;
this.Name = resourceIdentifier.ResourceName;
}
if (!string.IsNullOrWhiteSpace(this.Name))
{
MetricAlertResource result = this.MonitorManagementClient.MetricAlerts.GetAsync(resourceGroupName: this.ResourceGroupName, ruleName: this.Name).Result;
PSMetricAlertRuleV2 finalResult;
if (result.Criteria is MetricAlertSingleResourceMultipleMetricCriteria)
{
finalResult = new PSMetricAlertRuleV2SingleResource(result);
}
else
{
finalResult = new PSMetricAlertRuleV2(result);
}
WriteObject(sendToPipeline: finalResult);
}
else if (!string.IsNullOrWhiteSpace(this.ResourceGroupName))
{
IEnumerable <MetricAlertResource> result = this.MonitorManagementClient.MetricAlerts.ListByResourceGroupAsync(resourceGroupName: this.ResourceGroupName).Result;
List <PSMetricAlertRuleV2> finalResult = new List <PSMetricAlertRuleV2>();
result.ToArray().ForEach((metricAlertResource) =>
{
if (metricAlertResource.Criteria is MetricAlertSingleResourceMultipleMetricCriteria)
{
finalResult.Add(new PSMetricAlertRuleV2SingleResource(metricAlertResource));
}
else
{
finalResult.Add(new PSMetricAlertRuleV2(metricAlertResource));
}
}
);
WriteObject(sendToPipeline: finalResult.ToList(), enumerateCollection: true);
}
else
{
IEnumerable <MetricAlertResource> result = this.MonitorManagementClient.MetricAlerts.ListBySubscriptionAsync().Result;
List <PSMetricAlertRuleV2> finalResult = new List <PSMetricAlertRuleV2>();
result.ToArray().ForEach((metricAlertResource) =>
{
if (metricAlertResource.Criteria is MetricAlertSingleResourceMultipleMetricCriteria)
{
finalResult.Add(new PSMetricAlertRuleV2SingleResource(metricAlertResource));
}
else
{
finalResult.Add(new PSMetricAlertRuleV2(metricAlertResource));
}
}
);
WriteObject(sendToPipeline: finalResult.ToList(), enumerateCollection: true);
}
}
public PSMetricAlertRuleV2SingleResource(MetricAlertResource metricAlertResource)
: base(metricAlertResource)
{
if (metricAlertResource.Criteria is MetricAlertSingleResourceMultipleMetricCriteria)
{
this.TargetResourceId = metricAlertResource.Scopes[0];
}
}
public async Task Get()
{
var alertName = Recording.GenerateAssetName("testMetricAlert-");
var alert = await CreateMetricAlertAsync(alertName);
MetricAlertResource actionGroup2 = await alert.GetAsync();
ResourceDataHelper.AssertMetricAlert(alert.Data, actionGroup2.Data);
}
private void CreateOrUpdateMetricAlertRule(MonitorManagementClient insightsClient)
{
MetricAlertResource expectedParameters = GetCreateOrUpdateRuleParameters();
MetricAlertResource result = insightsClient.MetricAlerts.CreateOrUpdate(
resourceGroupName: ResourceGroupName,
ruleName: RuleName,
parameters: expectedParameters);
Utilities.AreEqual(expectedParameters, result);
}
private void AreEqual(MetricAlertResource exp, MetricAlertResource act)
{
Assert.AreEqual(exp.AutoMitigate, act.AutoMitigate);
Assert.AreEqual(exp.Description, act.Description);
Assert.AreEqual(exp.Enabled, act.Enabled);
Assert.AreEqual(exp.EvaluationFrequency, act.EvaluationFrequency);
Assert.AreEqual(exp.Id, act.Id);
Assert.AreEqual(exp.LastUpdatedTime, act.LastUpdatedTime);
Assert.AreEqual(exp.Location, act.Location);
Assert.AreEqual(exp.Name, act.Name);
Assert.AreEqual(exp.Severity, act.Severity);
Assert.AreEqual(exp.TargetResourceRegion, act.TargetResourceRegion);
Assert.AreEqual(exp.TargetResourceType, act.TargetResourceType);
Assert.AreEqual(exp.Type, act.Type);
Assert.AreEqual(exp.WindowSize, act.WindowSize);
}
public async Task Get()
{
var resourceGroup = await CreateResourceGroupAsync().ConfigureAwait(false);
var metricAlertCollection = resourceGroup.GetMetricAlerts();
var actionGroupCollection = resourceGroup.GetActionGroups();
var actionGroupName = Recording.GenerateAssetName("testActionGroup-");
var actionGroupData = ResourceDataHelper.GetBasicActionGroupData("Global");
var actionGroup = (await actionGroupCollection.CreateOrUpdateAsync(WaitUntil.Completed, actionGroupName, actionGroupData).ConfigureAwait(false)).Value;
var metricAlertData = ResourceDataHelper.GetBasicMetricAlertData("global", actionGroup);
var metricAlertName = Recording.GenerateAssetName("testMetricAlert");
var alert1 = (await metricAlertCollection.CreateOrUpdateAsync(WaitUntil.Completed, metricAlertName, metricAlertData)).Value;
MetricAlertResource alert2 = await metricAlertCollection.GetAsync(metricAlertName);
ResourceDataHelper.AssertMetricAlert(alert1.Data, alert2.Data);
}
public void CreateUpdateDynamicMetricAlertRuleTest()
{
MetricAlertResource expectedParams = GetSampleDynamicMetricRuleResourceParams();
var handler = new RecordedDelegatingHandler();
var insightClient = GetMonitorManagementClient(handler);
var serializedObject = Microsoft.Rest.Serialization.SafeJsonConvert.SerializeObject(expectedParams, insightClient.SerializationSettings);
var expectedResponse = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(serializedObject)
};
handler = new RecordedDelegatingHandler(expectedResponse);
insightClient = GetMonitorManagementClient(handler);
var result = insightClient.MetricAlerts.CreateOrUpdate(resourceGroupName: "rg1", ruleName: "Rule1", parameters: expectedParams);
Utilities.AreEqual(expectedParams, result);
}
public static void AreEqual(MetricAlertResource exp, MetricAlertResource act)
{
if (exp != null)
{
Assert.Equal(exp.Description, act.Description);
Assert.Equal(exp.Location, act.Location);
Assert.Equal(exp.Severity, act.Severity);
Assert.Equal(exp.Enabled, act.Enabled);
AreEqual(exp.Scopes, act.Scopes);
Assert.Equal(exp.EvaluationFrequency, act.EvaluationFrequency);
Assert.Equal(exp.WindowSize, act.WindowSize);
AreEqual(exp.Criteria, act.Criteria);
Assert.Equal(exp.AutoMitigate, act.AutoMitigate);
AreEqual(exp.Actions, act.Actions);
}
else
{
Assert.Null(act);
}
}
public PSMetricAlertRuleV2(MetricAlertResource metricAlertResource)
: base(location: metricAlertResource.Location, description: metricAlertResource.Description, severity: metricAlertResource.Severity, enabled: metricAlertResource.Enabled, evaluationFrequency: metricAlertResource.EvaluationFrequency, windowSize: metricAlertResource.WindowSize, criteria: metricAlertResource.Criteria, id: metricAlertResource.Id, name: metricAlertResource.Name, type: metricAlertResource.Type, tags: metricAlertResource.Tags, scopes: metricAlertResource.Scopes, autoMitigate: metricAlertResource.AutoMitigate, actions: metricAlertResource.Actions, lastUpdatedTime: metricAlertResource.LastUpdatedTime, targetResourceRegion: metricAlertResource.TargetResourceRegion, targetResourceType: metricAlertResource.TargetResourceType)
{
Criteria = new List <IPSMultiMetricCriteria>();
if (metricAlertResource.Criteria is MetricAlertSingleResourceMultipleMetricCriteria)
{
var criteria = metricAlertResource.Criteria as MetricAlertSingleResourceMultipleMetricCriteria;
foreach (var condition in criteria.AllOf)
{
Criteria.Add(new PSMetricCriteria(condition));
}
}
else if (metricAlertResource.Criteria is MetricAlertMultipleResourceMultipleMetricCriteria)
{
var criteria = metricAlertResource.Criteria as MetricAlertMultipleResourceMultipleMetricCriteria;
foreach (var condition in criteria.AllOf)
{
if (condition is MetricCriteria)
{
Criteria.Add(new PSMetricCriteria(condition as MetricCriteria));
}
else
{
Criteria.Add(new PSDynamicMetricCriteria(condition as DynamicMetricCriteria));
}
}
}
else
{
//Web-Test
}
Actions = new ActivityLogAlertActionGroup[metricAlertResource.Actions.Count];
for (int i = 0; i < metricAlertResource.Actions.Count; i++)
{
Actions[i] = new ActivityLogAlertActionGroup(metricAlertResource.Actions[i].ActionGroupId, metricAlertResource.Actions[i].WebhookProperties);
}
var resourceIdentifier = new ResourceIdentifier(metricAlertResource.Id);
ResourceGroup = resourceIdentifier.ResourceGroupName;
}
protected override void ProcessRecordInternal()
{
if (this.TargetResourceScope == null)//Single Resource Metric Alert Rule
{
var scopes = new List <string>();
scopes.Add(this.TargetResourceId);
var metricCriteria = new List <MetricCriteria>();
foreach (var condition in this.Condition)
{
metricCriteria.Add(new MetricCriteria(name: condition.Name, metricName: condition.MetricName, operatorProperty: condition.OperatorProperty.ToString(), timeAggregation: condition.TimeAggregation.ToString(), threshold: condition.Threshold, metricNamespace: condition.MetricNamespace, dimensions: condition.Dimensions));
}
var criteria = new MetricAlertSingleResourceMultipleMetricCriteria(
allOf: metricCriteria
);
var actions = new List <MetricAlertAction>();
foreach (var actionGroup in this.ActionGroup)
{
actions.Add(new MetricAlertAction(actionGroupId: actionGroup.ActionGroupId, webhookProperties: actionGroup.WebhookProperties));
}
var metricAlertResource = new MetricAlertResource(
description: this.Description ?? Utilities.GetDefaultDescription("new Metric alert rule"),
severity: this.Severity,
location: "global",
enabled: !this.DisableRule,
scopes: scopes,
evaluationFrequency: this.Frequency,
windowSize: this.WindowSize,
criteria: criteria,
actions: actions
);
if (ShouldProcess(
target: string.Format("Create/update an alert rule: {0} from resource group: {1}", this.Name, this.ResourceGroupName),
action: "Create/update an alert rule"))
{
var result = this.MonitorManagementClient.MetricAlerts.CreateOrUpdateAsync(resourceGroupName: this.ResourceGroupName, ruleName: this.Name, parameters: metricAlertResource).Result;
WriteObject(result);
}
}
else// Multi Resource Metric Alert Rule
{
List <MultiMetricCriteria> multiMetricCriterias = new List <MultiMetricCriteria>();
foreach (var condition in this.Condition)
{
multiMetricCriterias.Add(new MetricCriteria(name: condition.Name, metricName: condition.MetricName, operatorProperty: condition.OperatorProperty.ToString(), timeAggregation: condition.TimeAggregation.ToString(), threshold: condition.Threshold, metricNamespace: condition.MetricNamespace, dimensions: condition.Dimensions));
}
MetricAlertMultipleResourceMultipleMetricCriteria metricCriteria = new MetricAlertMultipleResourceMultipleMetricCriteria(
allOf: multiMetricCriterias
);
var actions = new List <MetricAlertAction>();
foreach (var actionGroup in this.ActionGroup)
{
actions.Add(new MetricAlertAction(actionGroupId: actionGroup.ActionGroupId, webhookProperties: actionGroup.WebhookProperties));
}
var metricAlertResource = new MetricAlertResource(
description: this.Description ?? Utilities.GetDefaultDescription("New multi resource Metric alert rule"),
severity: this.Severity,
location: "global",
enabled: !this.DisableRule,
scopes: this.TargetResourceScope,
targetResourceRegion: this.TargetResourceRegion,
targetResourceType: this.TargetResourceType,
evaluationFrequency: this.Frequency,
windowSize: this.WindowSize,
criteria: metricCriteria,
actions: actions
);
if (ShouldProcess(
target: string.Format("Create/update an alert rule: {0} from resource group: {1}", this.Name, this.ResourceGroupName),
action: "Create/update an alert rule"))
{
var result = this.MonitorManagementClient.MetricAlerts.CreateOrUpdateAsync(resourceGroupName: this.ResourceGroupName, ruleName: this.Name, parameters: metricAlertResource).Result;
WriteObject(result);
}
}
}
/// <summary>
/// Create or update an metric alert definition.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='ruleName'>
/// The name of the rule.
/// </param>
/// <param name='parameters'>
/// The parameters of the rule to create or update.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <MetricAlertResource> CreateOrUpdateAsync(this IMetricAlertsOperations operations, string resourceGroupName, string ruleName, MetricAlertResource parameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, ruleName, parameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Create or update an metric alert definition.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='ruleName'>
/// The name of the rule.
/// </param>
/// <param name='parameters'>
/// The parameters of the rule to create or update.
/// </param>
public static MetricAlertResource CreateOrUpdate(this IMetricAlertsOperations operations, string resourceGroupName, string ruleName, MetricAlertResource parameters)
{
return(operations.CreateOrUpdateAsync(resourceGroupName, ruleName, parameters).GetAwaiter().GetResult());
}
protected override void ProcessRecordInternal()
{
var actions = new List <MetricAlertAction>();
if (this.ActionGroup != null && this.ActionGroup.Length > 0)
{
actions.AddRange(this.ActionGroup.Select(actionGroup => new MetricAlertAction(actionGroupId: actionGroup.ActionGroupId, webHookProperties: actionGroup.WebhookProperties)));
}
if (this.ActionGroupId != null && this.ActionGroupId.Length > 0)
{
var newActionGroupIds = this.ActionGroupId.Where(id => !actions.Exists(action => action.ActionGroupId == id));
actions.AddRange(newActionGroupIds.Select(actionGroupId => new MetricAlertAction(actionGroupId: actionGroupId)));
}
if (this.Condition.Any(c => c.CriterionType == CriterionType.DynamicThresholdCriterion))
{
this.TargetResourceScope = this.TargetResourceScope ?? new string[] { this.TargetResourceId };
}
IDictionary <string, string> tags = null;
if (this.TargetResourceScope == null)//Single Resource Metric Alert Rule
{
var scopes = new List <string> {
this.TargetResourceId
};
MetricAlertCriteria criteria;
if (this.Condition.Any(c => c.CriterionType == CriterionType.WebtestLocationAvailabilityCriterion))
{
if (this.Condition.Count > 1)
{
throw new ArgumentException("Only single Webtest location availability criterion is supported");
}
var psWebtestCriteria = this.Condition.First() as PSWebtestLocationAvailabilityCriteria;
criteria = new WebtestLocationAvailabilityCriteria(psWebtestCriteria.WebTestId, psWebtestCriteria.ComponentId, psWebtestCriteria.FailedLocationCount);
scopes.Add(psWebtestCriteria.ComponentId);
tags = new Dictionary <string, string>()
{
{ $"hidden-link:{psWebtestCriteria.WebTestId}", "Resource" },
{ $"hidden-link:{psWebtestCriteria.ComponentId}", "Resource" }
};
}
else
{
var metricCriteria = new List <MetricCriteria>();
foreach (var metricCondition in this.Condition)
{
var condition = metricCondition as PSMetricCriteria;
metricCriteria.Add(new MetricCriteria(name: condition.Name, metricName: condition.MetricName, operatorProperty: condition.OperatorProperty.ToString(), timeAggregation: condition.TimeAggregation.ToString(), threshold: condition.Threshold, metricNamespace: condition.MetricNamespace, dimensions: condition.Dimensions, skipMetricValidation: condition.SkipMetricValidation));
}
criteria = new MetricAlertSingleResourceMultipleMetricCriteria(
allOf: metricCriteria
);
}
var metricAlertResource = new MetricAlertResource(
description: this.Description ?? Utilities.GetDefaultDescription("new Metric alert rule"),
severity: this.Severity,
location: "global",
enabled: !this.DisableRule,
scopes: scopes,
evaluationFrequency: this.Frequency,
windowSize: this.WindowSize,
criteria: criteria,
actions: actions,
tags: tags
);
if (ShouldProcess(
target: $"Create/update an alert rule: {this.Name} from resource group: {this.ResourceGroupName}",
action: "Create/update an alert rule"))
{
var result = this.MonitorManagementClient.MetricAlerts.CreateOrUpdateAsync(resourceGroupName: this.ResourceGroupName, ruleName: this.Name, parameters: metricAlertResource).Result;
WriteObject(result);
}
}
else// Multi Resource Metric Alert Rule
{
List <MultiMetricCriteria> multiMetricCriteria = new List <MultiMetricCriteria>();
foreach (var condition in this.Condition)
{
if (condition is PSMetricCriteria)
{
var psStaticMetricCriteria = condition as PSMetricCriteria;
multiMetricCriteria.Add(new MetricCriteria(name: psStaticMetricCriteria.Name, metricName: psStaticMetricCriteria.MetricName, operatorProperty: psStaticMetricCriteria.OperatorProperty.ToString(), timeAggregation: psStaticMetricCriteria.TimeAggregation.ToString(), threshold: psStaticMetricCriteria.Threshold, metricNamespace: psStaticMetricCriteria.MetricNamespace, dimensions: psStaticMetricCriteria.Dimensions, skipMetricValidation: psStaticMetricCriteria.SkipMetricValidation));
}
else
{
var psDynamicMetricCriteria = condition as PSDynamicMetricCriteria;
multiMetricCriteria.Add(new DynamicMetricCriteria(name: psDynamicMetricCriteria.Name, metricName: psDynamicMetricCriteria.MetricName, operatorProperty: psDynamicMetricCriteria.OperatorProperty.ToString(), timeAggregation: psDynamicMetricCriteria.TimeAggregation.ToString(), metricNamespace: psDynamicMetricCriteria.MetricNamespace, dimensions: psDynamicMetricCriteria.Dimensions, alertSensitivity: psDynamicMetricCriteria.AlertSensitivity, failingPeriods: psDynamicMetricCriteria.FailingPeriods, ignoreDataBefore: psDynamicMetricCriteria.IgnoreDataBefore, skipMetricValidation: psDynamicMetricCriteria.SkipMetricValidation));
}
}
MetricAlertMultipleResourceMultipleMetricCriteria metricCriteria = new MetricAlertMultipleResourceMultipleMetricCriteria(
allOf: multiMetricCriteria
);
var metricAlertResource = new MetricAlertResource(
description: this.Description ?? Utilities.GetDefaultDescription("New multi resource Metric alert rule"),
severity: this.Severity,
location: "global",
enabled: !this.DisableRule,
scopes: this.TargetResourceScope,
targetResourceRegion: this.TargetResourceRegion,
targetResourceType: this.TargetResourceType,
evaluationFrequency: this.Frequency,
windowSize: this.WindowSize,
criteria: metricCriteria,
actions: actions
);
if (ShouldProcess(
target: string.Format("Create/update an alert rule: {0} from resource group: {1}", this.Name, this.ResourceGroupName),
action: "Create/update an alert rule"))
{
var result = this.MonitorManagementClient.MetricAlerts.CreateOrUpdateAsync(resourceGroupName: this.ResourceGroupName, ruleName: this.Name, parameters: metricAlertResource).Result;
WriteObject(result);
}
}
}
public virtual async Task <Response <MetricAlertResource> > CreateOrUpdateAsync(string resourceGroupName, string ruleName, MetricAlertResource parameters, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("MetricAlertsOperations.CreateOrUpdate");
scope.Start();
try
{
return(await RestClient.CreateOrUpdateAsync(resourceGroupName, ruleName, parameters, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
protected override void ProcessRecordInternal()
{
if (this.Condition.Any(c => c.CriterionType == CriterionType.DynamicThresholdCriterion))
{
this.TargetResourceScope = this.TargetResourceScope ?? new string[] { this.TargetResourceId };
}
var actions = new List <MetricAlertAction>();
if (this.ActionGroup != null)
{
actions.AddRange(this.ActionGroup.Select(actionGroup => new MetricAlertAction(actionGroupId: actionGroup.ActionGroupId, webhookProperties: actionGroup.WebhookProperties)));
}
if (this.ActionGroupId != null)
{
actions.AddRange(this.ActionGroupId.Select(actionGroupId => new MetricAlertAction(actionGroupId: actionGroupId)));
}
if (this.TargetResourceScope == null)//Single Resource Metric Alert Rule
{
var scopes = new List <string>();
scopes.Add(this.TargetResourceId);
var metricCriteria = new List <MetricCriteria>();
foreach (var metricCondition in this.Condition)
{
var condition = metricCondition as PSMetricCriteria;
metricCriteria.Add(new MetricCriteria(name: condition.Name, metricName: condition.MetricName, operatorProperty: condition.OperatorProperty.ToString(), timeAggregation: condition.TimeAggregation.ToString(), threshold: condition.Threshold, metricNamespace: condition.MetricNamespace, dimensions: condition.Dimensions));
}
var criteria = new MetricAlertSingleResourceMultipleMetricCriteria(
allOf: metricCriteria
);
var metricAlertResource = new MetricAlertResource(
description: this.Description ?? Utilities.GetDefaultDescription("new Metric alert rule"),
severity: this.Severity,
location: "global",
enabled: !this.DisableRule,
scopes: scopes,
evaluationFrequency: this.Frequency,
windowSize: this.WindowSize,
criteria: criteria,
actions: actions
);
if (ShouldProcess(
target: string.Format("Create/update an alert rule: {0} from resource group: {1}", this.Name, this.ResourceGroupName),
action: "Create/update an alert rule"))
{
var result = this.MonitorManagementClient.MetricAlerts.CreateOrUpdateAsync(resourceGroupName: this.ResourceGroupName, ruleName: this.Name, parameters: metricAlertResource).Result;
WriteObject(result);
}
}
else// Multi Resource Metric Alert Rule
{
List <MultiMetricCriteria> multiMetricCriteria = new List <MultiMetricCriteria>();
foreach (var condition in this.Condition)
{
if (condition is PSMetricCriteria)
{
var psStaticMetricCriteria = condition as PSMetricCriteria;
multiMetricCriteria.Add(new MetricCriteria(name: psStaticMetricCriteria.Name, metricName: psStaticMetricCriteria.MetricName, operatorProperty: psStaticMetricCriteria.OperatorProperty.ToString(), timeAggregation: psStaticMetricCriteria.TimeAggregation.ToString(), threshold: psStaticMetricCriteria.Threshold, metricNamespace: psStaticMetricCriteria.MetricNamespace, dimensions: psStaticMetricCriteria.Dimensions));
}
else
{
var psDynamicMetricCriteria = condition as PSDynamicMetricCriteria;
multiMetricCriteria.Add(new DynamicMetricCriteria(name: psDynamicMetricCriteria.Name, metricName: psDynamicMetricCriteria.MetricName, operatorProperty: psDynamicMetricCriteria.OperatorProperty.ToString(), timeAggregation: psDynamicMetricCriteria.TimeAggregation.ToString(), metricNamespace: psDynamicMetricCriteria.MetricNamespace, dimensions: psDynamicMetricCriteria.Dimensions, alertSensitivity: psDynamicMetricCriteria.AlertSensitivity, failingPeriods: psDynamicMetricCriteria.FailingPeriods, ignoreDataBefore: psDynamicMetricCriteria.IgnoreDataBefore));
}
}
MetricAlertMultipleResourceMultipleMetricCriteria metricCriteria = new MetricAlertMultipleResourceMultipleMetricCriteria(
allOf: multiMetricCriteria
);
var metricAlertResource = new MetricAlertResource(
description: this.Description ?? Utilities.GetDefaultDescription("New multi resource Metric alert rule"),
severity: this.Severity,
location: "global",
enabled: !this.DisableRule,
scopes: this.TargetResourceScope,
targetResourceRegion: this.TargetResourceRegion,
targetResourceType: this.TargetResourceType,
evaluationFrequency: this.Frequency,
windowSize: this.WindowSize,
criteria: metricCriteria,
actions: actions
);
if (ShouldProcess(
target: string.Format("Create/update an alert rule: {0} from resource group: {1}", this.Name, this.ResourceGroupName),
action: "Create/update an alert rule"))
{
var result = this.MonitorManagementClient.MetricAlerts.CreateOrUpdateAsync(resourceGroupName: this.ResourceGroupName, ruleName: this.Name, parameters: metricAlertResource).Result;
WriteObject(result);
}
}
}
