Merge pull request #24 from SoulKyu/hidden-alert-filtering

Hidden alert filtering

Author: SoulKyu

internal/webui/handlers/dashboard_handlers.go

@@ -1,9 +1,11 @@
 package handlers
 
 import (
+	"encoding/json"
 	"fmt"
 	"log"
 	"net/http"
+	"regexp"
 	"sort"
 	"strconv"
 	"strings"
@@ -204,6 +206,22 @@ func parseDashboardFilters(c *gin.Context) webuimodels.DashboardFilters {
 		}
 	}
 
+	// Parse filter-specific hidden alerts (JSON)
+	if hiddenAlertsJSON := c.Query("filterHiddenAlerts"); hiddenAlertsJSON != "" {
+		var hiddenAlerts []webuimodels.FilterHiddenAlert
+		if err := json.Unmarshal([]byte(hiddenAlertsJSON), &hiddenAlerts); err == nil {
+			filters.FilterHiddenAlerts = hiddenAlerts
+		}
+	}
+
+	// Parse filter-specific hidden rules (JSON)
+	if hiddenRulesJSON := c.Query("filterHiddenRules"); hiddenRulesJSON != "" {
+		var hiddenRules []webuimodels.FilterHiddenRule
+		if err := json.Unmarshal([]byte(hiddenRulesJSON), &hiddenRules); err == nil {
+			filters.FilterHiddenRules = hiddenRules
+		}
+	}
+
 	return filters
 }
 
@@ -311,9 +329,26 @@ func getAcknowledgedAlerts() []*webuimodels.DashboardAlert {
 func applyDashboardFilters(alerts []*webuimodels.DashboardAlert, filters webuimodels.DashboardFilters, sessionID string) []*webuimodels.DashboardAlert {
 	var filtered []*webuimodels.DashboardAlert
 
+	// Pre-compile filter-specific hidden rules for performance
+	var compiledFilterRules map[int]*regexp.Regexp
+	if len(filters.FilterHiddenRules) > 0 && hiddenAlertsService != nil {
+		compiledFilterRules = hiddenAlertsService.CompileFilterRules(filters.FilterHiddenRules)
+	}
+
 	for _, alert := range alerts {
 		// Handle hidden alerts based on display mode
-		isHidden := hiddenAlertsService != nil && hiddenAlertsService.IsAlertHidden(sessionID, alert)
+		// Check both global hidden and filter-specific hidden (additive)
+		isGlobalHidden := hiddenAlertsService != nil && hiddenAlertsService.IsAlertHidden(sessionID, alert)
+		isFilterHidden := false
+		if hiddenAlertsService != nil && (len(filters.FilterHiddenAlerts) > 0 || len(filters.FilterHiddenRules) > 0) {
+			isFilterHidden = hiddenAlertsService.IsAlertHiddenByFilter(
+				alert,
+				filters.FilterHiddenAlerts,
+				filters.FilterHiddenRules,
+				compiledFilterRules,
+			)
+		}
+		isHidden := isGlobalHidden || isFilterHidden
 
 		if filters.DisplayMode == webuimodels.DisplayModeHidden {
 			// For hidden mode, only show hidden alerts

internal/webui/models/dashboard.go

@@ -91,6 +91,10 @@ type DashboardFilters struct {
 	DisplayMode         DashboardDisplayMode `json:"displayMode"`
 	ViewMode            DashboardViewMode    `json:"viewMode"`
 	ResolvedAlertsLimit int                  `json:"resolvedAlertsLimit,omitempty"` // Client-side limit for resolved alerts display
+
+	// Filter-specific hidden alerts (from active saved filter, additive with global hidden)
+	FilterHiddenAlerts []FilterHiddenAlert `json:"filterHiddenAlerts,omitempty"`
+	FilterHiddenRules  []FilterHiddenRule  `json:"filterHiddenRules,omitempty"`
 }
 
 // DashboardSorting represents sorting configuration

internal/webui/models/filter_preset.go

@@ -42,6 +42,30 @@ type FilterPresetData struct {
 
 	// Column Configuration
 	ColumnConfigs []ColumnConfig `json:"column_configs,omitempty"`
+
+	// Filter-specific hidden alerts (additive with global hidden alerts)
+	HiddenAlerts []FilterHiddenAlert `json:"hidden_alerts,omitempty"`
+
+	// Filter-specific hidden rules (additive with global hidden rules)
+	HiddenRules []FilterHiddenRule `json:"hidden_rules,omitempty"`
+}
+
+// FilterHiddenAlert represents an alert hidden specifically within a saved filter
+type FilterHiddenAlert struct {
+	Fingerprint string `json:"fingerprint"`
+	AlertName   string `json:"alert_name"`
+	Instance    string `json:"instance,omitempty"`
+	Reason      string `json:"reason,omitempty"`
+}
+
+// FilterHiddenRule represents a label-based hiding rule specific to a saved filter
+type FilterHiddenRule struct {
+	Name        string `json:"name"`
+	Description string `json:"description,omitempty"`
+	LabelKey    string `json:"label_key"`
+	LabelValue  string `json:"label_value"`
+	IsRegex     bool   `json:"is_regex"`
+	IsEnabled   bool   `json:"is_enabled"`
 }
 
 // FilterPresetRequest is used for creating/updating presets

internal/webui/services/hidden_alerts_service.go

@@ -154,6 +154,77 @@ func (s *HiddenAlertsService) IsAlertHidden(sessionID string, alert *webuimodels
 	return false
 }
 
+// IsAlertHiddenByFilter checks if an alert is hidden by filter-specific hidden alerts/rules
+// This is used for per-filter hiding that's additive to global hidden alerts
+func (s *HiddenAlertsService) IsAlertHiddenByFilter(
+	alert *webuimodels.DashboardAlert,
+	filterHiddenAlerts []webuimodels.FilterHiddenAlert,
+	filterHiddenRules []webuimodels.FilterHiddenRule,
+	compiledRules map[int]*regexp.Regexp,
+) bool {
+	if alert == nil {
+		return false
+	}
+
+	// Check specific hidden alerts by fingerprint
+	for _, hiddenAlert := range filterHiddenAlerts {
+		if hiddenAlert.Fingerprint == alert.Fingerprint {
+			return true
+		}
+	}
+
+	// Check hidden rules
+	for i, rule := range filterHiddenRules {
+		if !rule.IsEnabled {
+			continue
+		}
+
+		// Check if the alert has the label
+		labelValue, exists := alert.Labels[rule.LabelKey]
+		if !exists {
+			continue
+		}
+
+		// Check if the label value matches
+		if rule.IsRegex {
+			// Use compiled regex if available
+			if compiledRules != nil {
+				if regex, ok := compiledRules[i]; ok && regex != nil {
+					if regex.MatchString(labelValue) {
+						return true
+					}
+				}
+			}
+		} else {
+			// Exact match or empty value (match all)
+			if rule.LabelValue == "" || rule.LabelValue == labelValue {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+// CompileFilterRules pre-compiles regex rules for a filter preset
+// Returns a map from rule index to compiled regex
+func (s *HiddenAlertsService) CompileFilterRules(rules []webuimodels.FilterHiddenRule) map[int]*regexp.Regexp {
+	compiledRules := make(map[int]*regexp.Regexp)
+
+	for i, rule := range rules {
+		if rule.IsRegex && rule.LabelValue != "" {
+			regex, err := regexp.Compile(rule.LabelValue)
+			if err != nil {
+				log.Printf("Failed to compile filter regex for rule %s: %v", rule.Name, err)
+				continue
+			}
+			compiledRules[i] = regex
+		}
+	}
+
+	return compiledRules
+}
+
 // HideAlert hides a specific alert for a user
 func (s *HiddenAlertsService) HideAlert(sessionID string, alert *webuimodels.DashboardAlert, reason string) error {
 	err := s.backendClient.HideAlert(sessionID, alert.Fingerprint, alert.AlertName, alert.Instance, reason)