Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
package alerts
import (
"encoding/json"
"fmt"
"strings"
"github.com/rcourtman/pulse-go-rewrite/internal/models"
)
// evaluateFilterCondition evaluates a single filter condition against a guest
func (m *Manager) evaluateFilterCondition(guest any, condition FilterCondition) bool {
snapshot, ok := extractGuestSnapshot(guest)
if !ok {
return false
}
return evaluateGuestCondition(snapshot.metrics(), condition)
}
// guestMetrics holds common metrics for filter evaluation
type guestMetrics struct {
CPU float64 // CPU usage as percentage (0-100)
MemUsage float64 // Memory usage percentage
DiskUsage float64 // Disk usage percentage
MemoryUnavailable bool
DiskUnavailable bool
DiskRead int64 // Bytes/s
DiskWrite int64 // Bytes/s
NetworkIn int64 // Bytes/s
NetworkOut int64 // Bytes/s
IORateValidity models.IORateValidity
Name string
Node string
ID string
Status string
}
// extractGuestMetrics extracts common metrics from a VM or Container
func extractGuestMetrics(guest any) (guestMetrics, bool) {
snapshot, ok := extractGuestSnapshot(guest)
if !ok {
return guestMetrics{}, false
}
return snapshot.metrics(), true
}
// evaluateGuestCondition evaluates a filter condition against guest metrics
func evaluateGuestCondition(metrics guestMetrics, condition FilterCondition) bool {
switch condition.Type {
case "metric":
value := 0.0
validity := metrics.IORateValidity.EffectiveForRates(
metrics.DiskRead,
metrics.DiskWrite,
metrics.NetworkIn,
metrics.NetworkOut,
)
switch strings.ToLower(condition.Field) {
case "cpu":
value = metrics.CPU
case "memory":
if metrics.MemoryUnavailable {
return false
}
value = metrics.MemUsage
case "disk":
if metrics.DiskUnavailable {
return false
}
value = metrics.DiskUsage
case "diskread":
if !validity.DiskRead {
return false
}
value = float64(metrics.DiskRead) / 1024 / 1024 // Convert to MB/s
case "diskwrite":
if !validity.DiskWrite {
return false
}
value = float64(metrics.DiskWrite) / 1024 / 1024
case "networkin":
if !validity.NetworkIn {
return false
}
value = float64(metrics.NetworkIn) / 1024 / 1024
case "networkout":
if !validity.NetworkOut {
return false
}
value = float64(metrics.NetworkOut) / 1024 / 1024
default:
return false
}
return evaluateNumericCondition(value, condition)
case "text":
searchValue := strings.ToLower(fmt.Sprintf("%v", condition.Value))
switch strings.ToLower(condition.Field) {
case "name":
return strings.Contains(strings.ToLower(metrics.Name), searchValue)
case "node":
return strings.Contains(strings.ToLower(metrics.Node), searchValue)
case "vmid":
return strings.Contains(metrics.ID, searchValue)
}
case "raw":
if condition.RawText != "" {
term := strings.ToLower(condition.RawText)
return strings.Contains(strings.ToLower(metrics.Name), term) ||
strings.Contains(metrics.ID, term) ||
strings.Contains(strings.ToLower(metrics.Node), term) ||
strings.Contains(strings.ToLower(metrics.Status), term)
}
}
return false
}
// evaluateNumericCondition evaluates a numeric comparison
func evaluateNumericCondition(value float64, condition FilterCondition) bool {
condValue, ok := numericConditionValue(condition.Value)
if !ok {
return false
}
switch condition.Operator {
case ">":
return value > condValue
case "<":
return value < condValue
case ">=":
return value >= condValue
case "<=":
return value <= condValue
case "=", "==":
return value >= condValue-0.5 && value <= condValue+0.5
}
return false
}
func numericConditionValue(raw any) (float64, bool) {
switch value := raw.(type) {
case float64:
return value, true
case float32:
return float64(value), true
case int:
return float64(value), true
case int8:
return float64(value), true
case int16:
return float64(value), true
case int32:
return float64(value), true
case int64:
return float64(value), true
case uint:
return float64(value), true
case uint8:
return float64(value), true
case uint16:
return float64(value), true
case uint32:
return float64(value), true
case uint64:
return float64(value), true
case json.Number:
parsed, err := value.Float64()
if err != nil {
return 0, false
}
return parsed, true
default:
return 0, false
}
}
// evaluateVMCondition evaluates a filter condition against a VM
func (m *Manager) evaluateVMCondition(vm models.VM, condition FilterCondition) bool {
return evaluateGuestCondition(guestSnapshotFromVM(vm).metrics(), condition)
}
// evaluateContainerCondition evaluates a filter condition against a Container
func (m *Manager) evaluateContainerCondition(ct models.Container, condition FilterCondition) bool {
return evaluateGuestCondition(guestSnapshotFromContainer(ct).metrics(), condition)
}
// evaluateFilterStack evaluates a filter stack against a guest
func (m *Manager) evaluateFilterStack(guest any, stack FilterStack) bool {
if len(stack.Filters) == 0 {
return true
}
results := make([]bool, len(stack.Filters))
for i, filter := range stack.Filters {
results[i] = m.evaluateFilterCondition(guest, filter)
}
// Apply logical operator
if stack.LogicalOperator == "AND" {
for _, result := range results {
if !result {
return false
}
}
return true
}
// OR
for _, result := range results {
if result {
return true
}
}
return false
}
// getGuestThresholds returns the appropriate thresholds for a guest
// Priority: Guest-specific overrides > Custom rules (by priority) > Global defaults
func (m *Manager) getGuestThresholds(guest any, guestID string) ThresholdConfig {
return m.effectiveAlertPolicyNoLock(alertPolicyQuery{TypeKey: "vm", ResourceID: guestID, Guest: guest}).Thresholds
}