alert-mgmt-01: k8s foundation and server bootstrap for alert management API

Signed-off-by: Shirly Radco <sradco@redhat.com>
Signed-off-by: João Vilaça <jvilaca@redhat.com>
Signed-off-by: Aviv Litman <alitman@redhat.com>
Co-authored-by: AI Assistant <noreply@cursor.com>

Author: sradco

cmd/plugin-backend.go

@@ -8,15 +8,16 @@ import (
 	"strconv"
 	"strings"
 
-	server "github.com/openshift/monitoring-plugin/pkg"
 	"github.com/sirupsen/logrus"
+
+	server "github.com/openshift/monitoring-plugin/pkg"
 )
 
 var (
 	portArg             = flag.Int("port", 0, "server port to listen on (default: 9443)\nports 9444 and 9445 reserved for other use")
 	certArg             = flag.String("cert", "", "cert file path to enable TLS (disabled by default)")
 	keyArg              = flag.String("key", "", "private key file path to enable TLS (disabled by default)")
-	featuresArg         = flag.String("features", "", "enabled features, comma separated.\noptions: ['acm-alerting', 'incidents', 'dev-config', 'perses-dashboards']")
+	featuresArg         = flag.String("features", "", "enabled features, comma separated.\noptions: ['acm-alerting', 'incidents', 'dev-config', 'perses-dashboards', 'alert-management-api']")
 	staticPathArg       = flag.String("static-path", "", "static files path to serve frontend (default: './web/dist')")
 	configPathArg       = flag.String("config-path", "", "config files path (default: './config')")
 	pluginConfigArg     = flag.String("plugin-config-path", "", "plugin yaml configuration")

pkg/k8s/client.go

@@ -8,7 +8,6 @@ import (
 	"k8s.io/client-go/rest"
 
 	osmv1client "github.com/openshift/client-go/monitoring/clientset/versioned"
-	routeclient "github.com/openshift/client-go/route/clientset/versioned"
 	monitoringv1client "github.com/prometheus-operator/prometheus-operator/pkg/client/versioned"
 	"github.com/sirupsen/logrus"
 )
@@ -23,14 +22,8 @@ type client struct {
 	osmv1clientset        *osmv1client.Clientset
 	config                *rest.Config
 
-	prometheusAlerts *prometheusAlerts
-
-	prometheusRuleManager     *prometheusRuleManager
-	alertRelabelConfigManager *alertRelabelConfigManager
-	alertingRuleManager       *alertingRuleManager
-	namespaceManager          *namespaceManager
-	relabeledRulesManager     *relabeledRulesManager
-	clusterMonitoringConfig   *clusterMonitoringConfigManager
+	prometheusRuleManager *prometheusRuleManager
+	namespaceManager      *namespaceManager
 }
 
 func newClient(ctx context.Context, config *rest.Config) (Client, error) {
@@ -49,11 +42,6 @@ func newClient(ctx context.Context, config *rest.Config) (Client, error) {
 		return nil, fmt.Errorf("failed to create osmv1 clientset: %w", err)
 	}
 
-	routeClientset, err := routeclient.NewForConfig(config)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create route clientset: %w", err)
-	}
-
 	c := &client{
 		clientset:             clientset,
 		monitoringv1clientset: monitoringv1clientset,
@@ -63,33 +51,11 @@ func newClient(ctx context.Context, config *rest.Config) (Client, error) {
 
 	c.prometheusRuleManager = newPrometheusRuleManager(ctx, monitoringv1clientset)
 
-	c.prometheusAlerts = newPrometheusAlerts(routeClientset, clientset.CoreV1(), config, c.prometheusRuleManager)
-
-	c.alertRelabelConfigManager, err = newAlertRelabelConfigManager(ctx, osmv1clientset)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create alert relabel config manager: %w", err)
-	}
-
-	c.alertingRuleManager, err = newAlertingRuleManager(ctx, osmv1clientset)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create alerting rule manager: %w", err)
-	}
-
 	c.namespaceManager, err = newNamespaceManager(ctx, clientset)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create namespace manager: %w", err)
 	}
 
-	c.clusterMonitoringConfig, err = newClusterMonitoringConfigManager(ctx, clientset)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create cluster monitoring config manager: %w", err)
-	}
-
-	c.relabeledRulesManager, err = newRelabeledRulesManager(ctx, c.namespaceManager, c.alertRelabelConfigManager, monitoringv1clientset, clientset)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create relabeled rules config manager: %w", err)
-	}
-
 	return c, nil
 }
 
@@ -101,26 +67,10 @@ func (c *client) TestConnection(_ context.Context) error {
 	return nil
 }
 
-func (c *client) PrometheusAlerts() PrometheusAlertsInterface {
-	return c.prometheusAlerts
-}
-
 func (c *client) PrometheusRules() PrometheusRuleInterface {
 	return c.prometheusRuleManager
 }
 
-func (c *client) AlertRelabelConfigs() AlertRelabelConfigInterface {
-	return c.alertRelabelConfigManager
-}
-
-func (c *client) AlertingRules() AlertingRuleInterface {
-	return c.alertingRuleManager
-}
-
-func (c *client) RelabeledRules() RelabeledRulesInterface {
-	return c.relabeledRulesManager
-}
-
 func (c *client) Namespace() NamespaceInterface {
 	return c.namespaceManager
 }

pkg/k8s/namespace.go

@@ -90,7 +90,11 @@ func (nm *namespaceManager) updateMonitoringNamespace(ns *corev1.Namespace) {
 	nm.mu.Lock()
 	defer nm.mu.Unlock()
 
-	nm.monitoringNamespaces[ns.Name] = true
+	if ns.Labels != nil && ns.Labels[ClusterMonitoringLabel] == "true" {
+		nm.monitoringNamespaces[ns.Name] = true
+	} else {
+		delete(nm.monitoringNamespaces, ns.Name)
+	}
 }
 
 func (nm *namespaceManager) removeMonitoringNamespace(name string) {

pkg/k8s/types.go

@@ -3,9 +3,7 @@ package k8s
 import (
 	"context"
 
-	osmv1 "github.com/openshift/api/monitoring/v1"
 	monitoringv1 "github.com/prometheus-operator/prometheus-operator/pkg/apis/monitoring/v1"
-	"github.com/prometheus/prometheus/model/relabel"
 	"k8s.io/apimachinery/pkg/types"
 )
 
@@ -21,23 +19,29 @@ type Client interface {
 	// TestConnection tests the connection to the Kubernetes cluster
 	TestConnection(ctx context.Context) error
 
-	// PrometheusAlerts retrieves active Prometheus alerts
-	PrometheusAlerts() PrometheusAlertsInterface
-
 	// PrometheusRules returns the PrometheusRule interface
 	PrometheusRules() PrometheusRuleInterface
 
-	// AlertRelabelConfigs returns the AlertRelabelConfig interface
-	AlertRelabelConfigs() AlertRelabelConfigInterface
+	// Namespace returns the Namespace interface
+	Namespace() NamespaceInterface
+}
 
-	// AlertingRules returns the AlertingRule interface
-	AlertingRules() AlertingRuleInterface
+// PrometheusRuleInterface defines operations for managing PrometheusRules
+type PrometheusRuleInterface interface {
+	// List lists all PrometheusRules in the cluster
+	List(ctx context.Context, namespace string) ([]monitoringv1.PrometheusRule, error)
 
-	// RelabeledRules returns the RelabeledRules interface
-	RelabeledRules() RelabeledRulesInterface
+	// Get retrieves a PrometheusRule by namespace and name
+	Get(ctx context.Context, namespace string, name string) (*monitoringv1.PrometheusRule, bool, error)
 
-	// Namespace returns the Namespace interface
-	Namespace() NamespaceInterface
+	// Update updates an existing PrometheusRule
+	Update(ctx context.Context, pr monitoringv1.PrometheusRule) error
+
+	// Delete deletes a PrometheusRule by namespace and name
+	Delete(ctx context.Context, namespace string, name string) error
+
+	// AddRule adds a new rule to the specified PrometheusRule
+	AddRule(ctx context.Context, namespacedName types.NamespacedName, groupName string, rule monitoringv1.Rule) error
 }
 
 // RouteStatus describes the availability state of a monitoring route.
@@ -71,81 +75,6 @@ type AlertingHealth struct {
 	UserWorkload        *AlertingStackHealth `json:"userWorkload"`
 }
 
-// PrometheusAlertsInterface defines operations for managing PrometheusAlerts
-type PrometheusAlertsInterface interface {
-	// GetAlerts retrieves Prometheus alerts with optional state filtering
-	GetAlerts(ctx context.Context, req GetAlertsRequest) ([]PrometheusAlert, error)
-	// GetRules retrieves Prometheus alerting rules and active alerts
-	GetRules(ctx context.Context, req GetRulesRequest) ([]PrometheusRuleGroup, error)
-}
-
-// PrometheusRuleInterface defines operations for managing PrometheusRules
-type PrometheusRuleInterface interface {
-	// List lists all PrometheusRules in the cluster
-	List(ctx context.Context, namespace string) ([]monitoringv1.PrometheusRule, error)
-
-	// Get retrieves a PrometheusRule by namespace and name
-	Get(ctx context.Context, namespace string, name string) (*monitoringv1.PrometheusRule, bool, error)
-
-	// Update updates an existing PrometheusRule
-	Update(ctx context.Context, pr monitoringv1.PrometheusRule) error
-
-	// Delete deletes a PrometheusRule by namespace and name
-	Delete(ctx context.Context, namespace string, name string) error
-
-	// AddRule adds a new rule to the specified PrometheusRule
-	AddRule(ctx context.Context, namespacedName types.NamespacedName, groupName string, rule monitoringv1.Rule) error
-}
-
-// AlertRelabelConfigInterface defines operations for managing AlertRelabelConfigs
-type AlertRelabelConfigInterface interface {
-	// List lists all AlertRelabelConfigs in the cluster
-	List(ctx context.Context, namespace string) ([]osmv1.AlertRelabelConfig, error)
-
-	// Get retrieves an AlertRelabelConfig by namespace and name
-	Get(ctx context.Context, namespace string, name string) (*osmv1.AlertRelabelConfig, bool, error)
-
-	// Create creates a new AlertRelabelConfig
-	Create(ctx context.Context, arc osmv1.AlertRelabelConfig) (*osmv1.AlertRelabelConfig, error)
-
-	// Update updates an existing AlertRelabelConfig
-	Update(ctx context.Context, arc osmv1.AlertRelabelConfig) error
-
-	// Delete deletes an AlertRelabelConfig by namespace and name
-	Delete(ctx context.Context, namespace string, name string) error
-}
-
-// AlertingRuleInterface defines operations for managing AlertingRules
-// in the cluster monitoring namespace
-type AlertingRuleInterface interface {
-	// List lists all AlertingRules in the cluster
-	List(ctx context.Context) ([]osmv1.AlertingRule, error)
-
-	// Get retrieves an AlertingRule by name
-	Get(ctx context.Context, name string) (*osmv1.AlertingRule, bool, error)
-
-	// Create creates a new AlertingRule
-	Create(ctx context.Context, ar osmv1.AlertingRule) (*osmv1.AlertingRule, error)
-
-	// Update updates an existing AlertingRule
-	Update(ctx context.Context, ar osmv1.AlertingRule) error
-
-	// Delete deletes an AlertingRule by name
-	Delete(ctx context.Context, name string) error
-}
-
-// RelabeledRulesInterface defines operations for managing relabeled rules
-type RelabeledRulesInterface interface {
-	// List retrieves the relabeled rules for a given PrometheusRule
-	List(ctx context.Context) []monitoringv1.Rule
-
-	// Get retrieves the relabeled rule for a given id
-	Get(ctx context.Context, id string) (monitoringv1.Rule, bool)
-
-	// Config returns the list of alert relabel configs
-	Config() []*relabel.Config
-}
-
 // NamespaceInterface defines operations for Namespaces
 type NamespaceInterface interface {
 	// IsClusterMonitoringNamespace checks if a namespace has the openshift.io/cluster-monitoring=true label

pkg/server.go

@@ -12,7 +12,6 @@ import (
 
 	"github.com/gorilla/handlers"
 	"github.com/gorilla/mux"
-	"github.com/openshift/monitoring-plugin/pkg/proxy"
 	"github.com/sirupsen/logrus"
 	"gopkg.in/yaml.v2"
 	v1 "k8s.io/api/core/v1"
@@ -21,6 +20,8 @@ import (
 	"k8s.io/client-go/kubernetes/scheme"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/record"
+
+	"github.com/openshift/monitoring-plugin/pkg/proxy"
 )
 
 var log = logrus.WithField("module", "server")
@@ -56,10 +57,11 @@ type PluginConfig struct {
 type Feature string
 
 const (
-	AcmAlerting      Feature = "acm-alerting"
-	Incidents        Feature = "incidents"
-	DevConfig        Feature = "dev-config"
-	PersesDashboards Feature = "perses-dashboards"
+	AcmAlerting        Feature = "acm-alerting"
+	Incidents          Feature = "incidents"
+	DevConfig          Feature = "dev-config"
+	PersesDashboards   Feature = "perses-dashboards"
+	AlertManagementAPI Feature = "alert-management-api"
 )
 
 func (pluginConfig *PluginConfig) MarshalJSON() ([]byte, error) {
@@ -103,6 +105,8 @@ func (s *PluginServer) Shutdown(ctx context.Context) error {
 
 func createHTTPServer(ctx context.Context, cfg *Config) (*http.Server, error) {
 	acmMode := cfg.Features[AcmAlerting]
+	alertManagementAPIMode := cfg.Features[AlertManagementAPI]
+
 	acmLocationsLength := len(cfg.AlertmanagerUrl) + len(cfg.ThanosQuerierUrl)
 
 	if acmLocationsLength > 0 && !acmMode {
@@ -116,15 +120,19 @@ func createHTTPServer(ctx context.Context, cfg *Config) (*http.Server, error) {
 		return nil, fmt.Errorf("cannot set default port to reserved port %d", cfg.Port)
 	}
 
+	var k8sconfig *rest.Config
+	var err error
+
 	// Uncomment the following line for local development:
-	// k8sconfig, err := clientcmd.BuildConfigFromFlags("", "$HOME/.kube/config")
+	// k8sconfig, err = clientcmd.BuildConfigFromFlags("", os.Getenv("KUBECONFIG"))
+	// if err != nil {
+	// 	return nil, fmt.Errorf("cannot get kubeconfig from file: %w", err)
+	// }
 
 	// Comment the following line for local development:
 	var k8sclient *dynamic.DynamicClient
-	if acmMode {
-
-		k8sconfig, err := rest.InClusterConfig()
-
+	if acmMode || alertManagementAPIMode {
+		k8sconfig, err = rest.InClusterConfig()
 		if err != nil {
 			return nil, fmt.Errorf("cannot get in cluster config: %w", err)
 		}