PerformanceAlertMonitor.cs

using System;
using Waher.Events;
 
namespace Waher.Service.IoTBroker.Sampling
{
    public class PerformanceAlertMonitor
    {
        private readonly string alertMessage;
        private readonly string alertRecinded;
        private readonly string emergencyMessage;
        private readonly string emergencyRecinded;
        private readonly double alertLevel;
        private readonly int alertConsecutive;
        private readonly double emergencyLevel;
        private readonly int emergencyConsecutive;
        private readonly int sign;
        private int state = 0;
        private int nrAboveAlertLevel = 0;
        private int nrAboveEmergencyLevel = 0;
        private int nrBelowAlertLevel = 0;
        private int nrBelowEmergencyLevel = 0;
 
        public PerformanceAlertMonitor(double AlertLevel, int AlertConsecutive,
            double EmergencyLevel, int EmergencyConsecutive, string AlertMessage,
            string AlertRecinded, string EmergencyMessage, string EmergencyRecinded)
        {
            this.sign = Math.Sign(EmergencyLevel - AlertLevel);
 
            if (AlertConsecutive <= 0)
                throw new ArgumentOutOfRangeException(nameof(AlertConsecutive), "Value must be positive.");
 
            if (EmergencyConsecutive <= 0)
                throw new ArgumentOutOfRangeException(nameof(EmergencyConsecutive), "Value must be positive.");
 
            this.alertLevel = AlertLevel;
            this.alertConsecutive = AlertConsecutive;
            this.alertMessage = AlertMessage;
            this.alertRecinded = AlertRecinded;
            this.emergencyLevel = EmergencyLevel;
            this.emergencyConsecutive = EmergencyConsecutive;
            this.emergencyMessage = EmergencyMessage;
            this.emergencyRecinded = EmergencyRecinded;
        }
 
        public bool IsNormal => this.state == 0;
 
        public bool IsAlert => this.state >= 1;
 
        public bool IsEmergency => this.state >= 2;
 
        public void Sample(double Value)
        {
            if ((Value - this.emergencyLevel) * this.sign >= 0)
            {
                this.nrBelowEmergencyLevel = 0;
                this.nrBelowAlertLevel = 0;
 
                if (this.state < 2)
                {
                    this.nrAboveEmergencyLevel++;
                    this.nrAboveAlertLevel++;
 
                    if (this.nrAboveEmergencyLevel >= this.emergencyConsecutive)
                    {
                        this.state = 2;
 
                        Log.Emergency(this.emergencyMessage);
                        this.Emergency.Raise(this, EventArgs.Empty);
                    }
                }
            }
            else
            {
                this.nrAboveEmergencyLevel = 0;
 
                if (this.state >= 2)
                {
                    this.nrBelowEmergencyLevel++;
                    if (this.nrBelowEmergencyLevel >= this.emergencyConsecutive)
                    {
                        this.state = 1;
 
                        this.EmergencyRecinded.Raise(this, EventArgs.Empty);
 
                        if ((Value - this.alertLevel) * this.sign >= 0)
                        {
                            Log.Alert(this.alertMessage + "\r\n\r\n(" + this.emergencyRecinded + ")");
                            this.Alert.Raise(this, EventArgs.Empty);
                        }
                        else
                            Log.Notice(this.emergencyRecinded);
                    }
                }
 
                if ((Value - this.alertLevel) * this.sign >= 0)
                {
                    this.nrBelowAlertLevel = 0;
 
                    if (this.state < 1)
                    {
                        this.nrAboveAlertLevel++;
 
                        if (this.nrAboveAlertLevel >= this.alertConsecutive)
                        {
                            this.state = 1;
 
                            Log.Alert(this.alertMessage);
                            this.Alert.Raise(this, EventArgs.Empty);
                        }
                    }
                }
                else
                {
                    this.nrAboveAlertLevel = 0;
 
                    if (this.state >= 1)
                    {
                        this.nrBelowAlertLevel++;
                        if (this.nrBelowAlertLevel >= this.alertConsecutive)
                        {
                            this.state = 0;
 
                            Log.Notice(this.alertRecinded);
                            this.AlertRecinded.Raise(this, EventArgs.Empty);
                        }
                    }
                }
            }
        }
 
        public event EventHandler Alert;
 
        public event EventHandler AlertRecinded;
 
        public event EventHandler Emergency;
 
        public event EventHandler EmergencyRecinded;
    }
}