public static MetricAlertData GetBasicMetricAlertData(AzureLocation location, ActionGroupResource actionGroup)
        {
            IEnumerable <string> scopes = new List <string>()
            {
                "/subscriptions/db1ab6f0-4769-4b27-930e-01e2ef9c123c/resourceGroups/deleteme0122/providers/Microsoft.Compute/virtualMachines/MetricAlertActionTestVM01",
                // "/subscriptions/db1ab6f0-4769-4b27-930e-01e2ef9c123c/resourceGroups/deleteme0122/providers/Microsoft.Compute/virtualMachines/MetricAlertActionTestVM02"
            };
            var metricAlertAction = new MetricAlertAction()
            {
                ActionGroupId     = actionGroup.Id.ToString(),
                WebHookProperties = { new KeyValuePair <string, string>("key1", "value1") }
            };
            var metricCriteria = new MetricCriteria("High_CPU_80", "Percentage CPU", AggregationTypeEnum.Average, Operator.GreaterThan, 80.50)
            {
            };

            return(new MetricAlertData(
                       location,
                       3,
                       true,
                       scopes,
                       new TimeSpan(0, 1, 0),
                       new TimeSpan(0, 5, 0),
                       new MetricAlertSingleResourceMultipleMetricCriteria()
            {
                AllOf = { metricCriteria }
            })
            {
                Actions = { metricAlertAction }
            });
        }
Example #2
0
        protected override void ProcessRecordInternal()
        {
            if (String.IsNullOrWhiteSpace(this.DynamicThreshold))
            {
                List <MetricDimension> metricDimensions = new List <MetricDimension>();

                if (this.DimensionSelection != null && this.DimensionSelection.Length > 0)
                {
                    foreach (var dimension in this.DimensionSelection)
                    {
                        if (dimension.IncludeValues != null && dimension.IncludeValues.Count() > 0)
                        {
                            metricDimensions.Add(new MetricDimension(dimension.Dimension, "Include", dimension.IncludeValues));
                        }
                        if (dimension.ExcludeValues != null && dimension.ExcludeValues.Count() > 0)
                        {
                            metricDimensions.Add(new MetricDimension(dimension.Dimension, "Exclude", dimension.ExcludeValues));
                        }
                    }
                }
                else
                {
                    metricDimensions = null;
                }
                MetricCriteria   metricCriteria = new MetricCriteria(name: "metric1", metricName: this.MetricName, operatorProperty: this.Operator, timeAggregation: this.TimeAggregation, threshold: this.Threshold, metricNamespace: this.MetricNamespace, dimensions: metricDimensions);
                PSMetricCriteria result         = new PSMetricCriteria(metricCriteria);
                WriteObject(sendToPipeline: result);
            }
            else
            {
                WriteExceptionError(new Exception("Creating criteria for Dynamic Threshold is not yet supported"));
            }
        }
Example #3
0
 /// <summary>
 /// Initiliazes a PS object for static metric criteria
 /// </summary>
 /// <param name="metricCriteria">The original static metric criteria object</param>
 public PSMetricCriteria(MetricCriteria metricCriteria)
     : base(name: metricCriteria.Name,
            metricName: metricCriteria.MetricName,
            operatorProperty: metricCriteria.OperatorProperty,
            timeAggregation: metricCriteria.TimeAggregation,
            threshold: metricCriteria.Threshold,
            metricNamespace: metricCriteria.MetricNamespace,
            dimensions: metricCriteria.Dimensions)
 {
 }
        protected override void ProcessRecordInternal()
        {
            List <MetricDimension> metricDimensions = new List <MetricDimension>();

            if (this.DimensionSelection != null && this.DimensionSelection.Length > 0)
            {
                foreach (var dimension in this.DimensionSelection)
                {
                    if (dimension.IncludeValues != null && dimension.IncludeValues.Count() > 0)
                    {
                        metricDimensions.Add(new MetricDimension(dimension.Dimension, "Include", dimension.IncludeValues));
                    }
                    if (dimension.ExcludeValues != null && dimension.ExcludeValues.Count() > 0)
                    {
                        metricDimensions.Add(new MetricDimension(dimension.Dimension, "Exclude", dimension.ExcludeValues));
                    }
                }
            }
            else
            {
                metricDimensions = null;
            }

            IPSMultiMetricCriteria result;

            if (this.WebTest.IsPresent || !string.IsNullOrWhiteSpace(this.WebTestId))
            {
                WebtestLocationAvailabilityCriteria webtestMetricCriteria = new WebtestLocationAvailabilityCriteria(this.WebTestId, this.ApplicationInsightsId, this.FailedLocationCount);
                result = new PSWebtestLocationAvailabilityCriteria(webtestMetricCriteria);
            }
            else if (this.DynamicThreshold.IsPresent)
            {
                DynamicThresholdFailingPeriods failingPeriods        = new DynamicThresholdFailingPeriods(this.ExaminedAggregatedPointCount, this.ViolationCount);
                DynamicMetricCriteria          dynamicMetricCriteria = new DynamicMetricCriteria(name: "metric1",
                                                                                                 metricName: this.MetricName,
                                                                                                 operatorProperty: this.Operator,
                                                                                                 timeAggregation: this.TimeAggregation,
                                                                                                 metricNamespace: this.MetricNamespace,
                                                                                                 dimensions: metricDimensions,
                                                                                                 failingPeriods: failingPeriods,
                                                                                                 alertSensitivity: this.ThresholdSensitivity,
                                                                                                 ignoreDataBefore: this.IsParameterBound(c => c.IgnoreDataBefore) ? (DateTime?)this.IgnoreDataBefore : null,
                                                                                                 skipMetricValidation: this.SkipMetricValidation
                                                                                                 );
                result = new PSDynamicMetricCriteria(dynamicMetricCriteria);
            }
            else
            {
                MetricCriteria metricCriteria = new MetricCriteria(name: "metric1", metricName: this.MetricName, operatorProperty: this.Operator, timeAggregation: this.TimeAggregation, threshold: this.Threshold, metricNamespace: this.MetricNamespace, dimensions: metricDimensions, skipMetricValidation: this.SkipMetricValidation);
                result = new PSMetricCriteria(metricCriteria);
            }

            WriteObject(sendToPipeline: result);
        }
Example #5
0
 ///GENMHASH:E381A45ED049153522E82595CE5F86B2:72BCD000BF4EABB33CA6F6D35F7D248F
 internal MetricAlertConditionImpl(string name, MetricCriteria innerObject, MetricAlertImpl parent)
     : base(innerObject)
 {
     this.Inner.Name = name;
     this.parent     = parent;
     this.dimensions = new Dictionary <string, Models.MetricDimension>();
     if (this.Inner.Dimensions != null)
     {
         foreach (var md in this.Inner.Dimensions)
         {
             dimensions.Add(md.Name, md);
         }
     }
 }
 public static void AreEqual(MetricCriteria exp, MetricCriteria act)
 {
     if (exp != null)
     {
         Assert.Equal(exp.MetricName, act.MetricName);
         Assert.Equal(exp.Name, act.Name);
         Assert.Equal(exp.MetricNamespace, act.MetricNamespace);
         AreEqual(exp.Dimensions, act.Dimensions);
         Assert.Equal(exp.OperatorProperty, act.OperatorProperty);
         Assert.Equal(exp.TimeAggregation, act.TimeAggregation);
         Assert.Equal(exp.Threshold, act.Threshold);
     }
     else
     {
         Assert.Null(act);
     }
 }
Example #7
0
        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 <PSMetricCriteria>();
            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)
                {
                    var            obj            = JsonConvert.SerializeObject(condition.AdditionalProperties, Newtonsoft.Json.Formatting.Indented);
                    MetricCriteria metricCriteria = JsonConvert.DeserializeObject <MetricCriteria>(obj);
                    Criteria.Add(new PSMetricCriteria(metricCriteria));
                }
            }
            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;
        }