Skip to content

Commit 30f53a3

Browse files
sradcoCursor AI Agent
sradco
and
Cursor AI Agent
committed
k8s: add relabel config, relabeled rules, alerting health and AlertingRule CRD support
Add remaining k8s layer capabilities: - AlertRelabelConfig CRUD operations for OpenShift AlertRelabelConfig CRs - RelabeledRules: applies Prometheus relabel configs to derive effective alert rules with source/management labels - AlertingHealth: route reachability checks for platform and user-workload Prometheus/Alertmanager endpoints - AlertingRule CRUD operations for OpenShift AlertingRule CRs - ExternalManagement label helpers Also adds supporting leaf packages: - pkg/managementlabels: management label constants and helpers - pkg/classification: alert classification validation - pkg/alert_rule: alert rule ID generation and parsing Signed-off-by: avlitman <alitman@redhat.com> Signed-off-by: Shirly Radco <sradco@redhat.com> Signed-off-by: machadovilaca <machadovilaca@gmail.com> Co-authored-by: Cursor AI Agent <cursor-ai@users.noreply.github.com> Made-with: Cursor
1 parent 8828c5a commit 30f53a3

9 files changed

Lines changed: 979 additions & 0 deletions

File tree

‎pkg/alert_rule/alert_rule.go‎

Lines changed: 83 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,83 @@
1+
package alertrule
2+
3+
import (
4+
"crypto/sha256"
5+
"encoding/base64"
6+
"fmt"
7+
"sort"
8+
"strings"
9+
"unicode/utf8"
10+
11+
"github.com/openshift/monitoring-plugin/pkg/classification"
12+
"github.com/openshift/monitoring-plugin/pkg/managementlabels"
13+
monitoringv1 "github.com/prometheus-operator/prometheus-operator/pkg/apis/monitoring/v1"
14+
)
15+
16+
func GetAlertingRuleId(alertRule *monitoringv1.Rule) string {
17+
var name string
18+
var kind string
19+
if alertRule.Alert != "" {
20+
name = alertRule.Alert
21+
kind = "alert"
22+
} else if alertRule.Record != "" {
23+
name = alertRule.Record
24+
kind = "record"
25+
} else {
26+
return ""
27+
}
28+
29+
expr := normalizeExpr(alertRule.Expr.String())
30+
forDuration := ""
31+
if alertRule.For != nil {
32+
forDuration = strings.TrimSpace(string(*alertRule.For))
33+
}
34+
35+
labelsBlock := normalizedBusinessLabelsBlock(alertRule.Labels)
36+
37+
// Canonical payload is intentionally derived from rule spec (expr/for/labels) and identity (kind/name),
38+
// and excludes annotations and openshift_io_* provenance/system labels.
39+
canonicalPayload := strings.Join([]string{kind, name, expr, forDuration, labelsBlock}, "\n---\n")
40+
41+
// Generate SHA256 hash
42+
hash := sha256.Sum256([]byte(canonicalPayload))
43+
44+
return "rid_" + base64.RawURLEncoding.EncodeToString(hash[:])
45+
}
46+
47+
func normalizeExpr(expr string) string {
48+
// Collapse consecutive whitespace so cosmetic formatting changes do not churn ids.
49+
return strings.Join(strings.Fields(strings.TrimSpace(expr)), " ")
50+
}
51+
52+
func normalizedBusinessLabelsBlock(in map[string]string) string {
53+
if len(in) == 0 {
54+
return ""
55+
}
56+
57+
lines := make([]string, 0, len(in))
58+
for k, v := range in {
59+
key := strings.TrimSpace(k)
60+
if key == "" {
61+
continue
62+
}
63+
if strings.HasPrefix(key, "openshift_io_") || key == managementlabels.AlertNameLabel {
64+
// Skip system labels
65+
continue
66+
}
67+
if !classification.ValidatePromLabelName(key) {
68+
continue
69+
}
70+
if v == "" {
71+
// Align with specHash behavior: drop empty values
72+
continue
73+
}
74+
if !utf8.ValidString(v) {
75+
continue
76+
}
77+
78+
lines = append(lines, fmt.Sprintf("%s=%s", key, v))
79+
}
80+
81+
sort.Strings(lines)
82+
return strings.Join(lines, "\n")
83+
}

‎pkg/classification/validation.go‎

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
package classification
2+
3+
import (
4+
"regexp"
5+
"strings"
6+
)
7+
8+
var allowedLayers = map[string]struct{}{
9+
"cluster": {},
10+
"namespace": {},
11+
}
12+
13+
var labelValueRegexp = regexp.MustCompile(`^[A-Za-z0-9]([A-Za-z0-9_.-]*[A-Za-z0-9])?$`)
14+
var labelNameRegexp = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*$`)
15+
16+
// ValidateLayer returns true if the provided layer is one of the allowed values.
17+
func ValidateLayer(layer string) bool {
18+
_, ok := allowedLayers[strings.ToLower(strings.TrimSpace(layer))]
19+
return ok
20+
}
21+
22+
// ValidateComponent returns true if the component is a reasonable label value.
23+
// Accept 1-253 chars, [A-Za-z0-9._-], must start/end alphanumeric.
24+
func ValidateComponent(component string) bool {
25+
c := strings.TrimSpace(component)
26+
if c == "" || len(c) > 253 {
27+
return false
28+
}
29+
return labelValueRegexp.MatchString(c)
30+
}
31+
32+
func ValidatePromLabelName(name string) bool {
33+
return labelNameRegexp.MatchString(strings.TrimSpace(name))
34+
}

‎pkg/k8s/alert_relabel_config.go‎

Lines changed: 99 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,99 @@
1+
package k8s
2+
3+
import (
4+
"context"
5+
"fmt"
6+
7+
osmv1 "github.com/openshift/api/monitoring/v1"
8+
osmv1client "github.com/openshift/client-go/monitoring/clientset/versioned"
9+
"k8s.io/apimachinery/pkg/api/errors"
10+
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
11+
"k8s.io/apimachinery/pkg/fields"
12+
"k8s.io/client-go/tools/cache"
13+
)
14+
15+
type alertRelabelConfigManager struct {
16+
clientset *osmv1client.Clientset
17+
arcInformer cache.SharedIndexInformer
18+
}
19+
20+
func newAlertRelabelConfigManager(ctx context.Context, clientset *osmv1client.Clientset) (*alertRelabelConfigManager, error) {
21+
arcInformer := cache.NewSharedIndexInformer(
22+
alertRelabelConfigListWatchForAllNamespaces(clientset),
23+
&osmv1.AlertRelabelConfig{},
24+
0,
25+
cache.Indexers{},
26+
)
27+
28+
arcm := &alertRelabelConfigManager{
29+
clientset: clientset,
30+
arcInformer: arcInformer,
31+
}
32+
33+
go arcm.arcInformer.Run(ctx.Done())
34+
35+
cache.WaitForNamedCacheSync("AlertRelabelConfig informer", ctx.Done(),
36+
arcm.arcInformer.HasSynced,
37+
)
38+
39+
return arcm, nil
40+
}
41+
42+
func alertRelabelConfigListWatchForAllNamespaces(clientset *osmv1client.Clientset) *cache.ListWatch {
43+
return cache.NewListWatchFromClient(clientset.MonitoringV1().RESTClient(), "alertrelabelconfigs", "", fields.Everything())
44+
}
45+
46+
func (arcm *alertRelabelConfigManager) List(ctx context.Context, namespace string) ([]osmv1.AlertRelabelConfig, error) {
47+
arcs := arcm.arcInformer.GetStore().List()
48+
49+
alertRelabelConfigs := make([]osmv1.AlertRelabelConfig, 0, len(arcs))
50+
for _, item := range arcs {
51+
arc, ok := item.(*osmv1.AlertRelabelConfig)
52+
if !ok {
53+
continue
54+
}
55+
alertRelabelConfigs = append(alertRelabelConfigs, *arc)
56+
}
57+
58+
return alertRelabelConfigs, nil
59+
}
60+
61+
func (arcm *alertRelabelConfigManager) Get(ctx context.Context, namespace string, name string) (*osmv1.AlertRelabelConfig, bool, error) {
62+
arc, err := arcm.clientset.MonitoringV1().AlertRelabelConfigs(namespace).Get(ctx, name, metav1.GetOptions{})
63+
if err != nil {
64+
if errors.IsNotFound(err) {
65+
return nil, false, nil
66+
}
67+
68+
return nil, false, err
69+
}
70+
71+
return arc, true, nil
72+
}
73+
74+
func (arcm *alertRelabelConfigManager) Create(ctx context.Context, arc osmv1.AlertRelabelConfig) (*osmv1.AlertRelabelConfig, error) {
75+
created, err := arcm.clientset.MonitoringV1().AlertRelabelConfigs(arc.Namespace).Create(ctx, &arc, metav1.CreateOptions{})
76+
if err != nil {
77+
return nil, fmt.Errorf("failed to create AlertRelabelConfig %s/%s: %w", arc.Namespace, arc.Name, err)
78+
}
79+
80+
return created, nil
81+
}
82+
83+
func (arcm *alertRelabelConfigManager) Update(ctx context.Context, arc osmv1.AlertRelabelConfig) error {
84+
_, err := arcm.clientset.MonitoringV1().AlertRelabelConfigs(arc.Namespace).Update(ctx, &arc, metav1.UpdateOptions{})
85+
if err != nil {
86+
return fmt.Errorf("failed to update AlertRelabelConfig %s/%s: %w", arc.Namespace, arc.Name, err)
87+
}
88+
89+
return nil
90+
}
91+
92+
func (arcm *alertRelabelConfigManager) Delete(ctx context.Context, namespace string, name string) error {
93+
err := arcm.clientset.MonitoringV1().AlertRelabelConfigs(namespace).Delete(ctx, name, metav1.DeleteOptions{})
94+
if err != nil {
95+
return fmt.Errorf("failed to delete AlertRelabelConfig %s: %w", name, err)
96+
}
97+
98+
return nil
99+
}

‎pkg/k8s/alerting_health.go‎

Lines changed: 127 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,127 @@
1+
package k8s
2+
3+
import (
4+
"context"
5+
"fmt"
6+
"strings"
7+
"sync"
8+
9+
"gopkg.in/yaml.v2"
10+
corev1 "k8s.io/api/core/v1"
11+
"k8s.io/apimachinery/pkg/fields"
12+
"k8s.io/client-go/kubernetes"
13+
"k8s.io/client-go/tools/cache"
14+
)
15+
16+
const (
17+
clusterMonitoringConfigMap = "cluster-monitoring-config"
18+
clusterMonitoringConfigKey = "config.yaml"
19+
)
20+
21+
type clusterMonitoringConfig struct {
22+
EnableUserWorkload bool `yaml:"enableUserWorkload"`
23+
}
24+
25+
// clusterMonitoringConfigManager watches the cluster-monitoring-config ConfigMap
26+
// via an informer and caches the parsed enableUserWorkload value so that
27+
// AlertingHealth never needs a live API call.
28+
type clusterMonitoringConfigManager struct {
29+
informer cache.SharedIndexInformer
30+
31+
mu sync.RWMutex
32+
enabled bool
33+
err error
34+
}
35+
36+
func newClusterMonitoringConfigManager(ctx context.Context, clientset *kubernetes.Clientset) (*clusterMonitoringConfigManager, error) {
37+
informer := cache.NewSharedIndexInformer(
38+
cache.NewListWatchFromClient(
39+
clientset.CoreV1().RESTClient(),
40+
"configmaps",
41+
ClusterMonitoringNamespace,
42+
fields.OneTermEqualSelector("metadata.name", clusterMonitoringConfigMap),
43+
),
44+
&corev1.ConfigMap{},
45+
0,
46+
cache.Indexers{},
47+
)
48+
49+
m := &clusterMonitoringConfigManager{
50+
informer: informer,
51+
}
52+
53+
_, err := informer.AddEventHandler(cache.ResourceEventHandlerFuncs{
54+
AddFunc: func(obj interface{}) {
55+
cm, ok := obj.(*corev1.ConfigMap)
56+
if !ok {
57+
return
58+
}
59+
m.handleUpdate(cm)
60+
},
61+
UpdateFunc: func(_, newObj interface{}) {
62+
cm, ok := newObj.(*corev1.ConfigMap)
63+
if !ok {
64+
return
65+
}
66+
m.handleUpdate(cm)
67+
},
68+
DeleteFunc: func(_ interface{}) {
69+
m.mu.Lock()
70+
defer m.mu.Unlock()
71+
m.enabled = false
72+
m.err = nil
73+
},
74+
})
75+
if err != nil {
76+
return nil, fmt.Errorf("failed to add event handler to cluster-monitoring-config informer: %w", err)
77+
}
78+
79+
go informer.Run(ctx.Done())
80+
81+
cache.WaitForNamedCacheSync("ClusterMonitoringConfig informer", ctx.Done(),
82+
informer.HasSynced,
83+
)
84+
85+
return m, nil
86+
}
87+
88+
func (m *clusterMonitoringConfigManager) handleUpdate(cm *corev1.ConfigMap) {
89+
m.mu.Lock()
90+
defer m.mu.Unlock()
91+
92+
raw, ok := cm.Data[clusterMonitoringConfigKey]
93+
if !ok || strings.TrimSpace(raw) == "" {
94+
m.enabled = false
95+
m.err = nil
96+
return
97+
}
98+
99+
var cfg clusterMonitoringConfig
100+
if err := yaml.Unmarshal([]byte(raw), &cfg); err != nil {
101+
m.enabled = false
102+
m.err = fmt.Errorf("parse cluster monitoring config.yaml: %w", err)
103+
return
104+
}
105+
106+
m.enabled = cfg.EnableUserWorkload
107+
m.err = nil
108+
}
109+
110+
func (m *clusterMonitoringConfigManager) userWorkloadEnabled() (bool, error) {
111+
m.mu.RLock()
112+
defer m.mu.RUnlock()
113+
return m.enabled, m.err
114+
}
115+
116+
// AlertingHealth returns alerting route health and UWM enablement status.
117+
func (c *client) AlertingHealth(ctx context.Context) (AlertingHealth, error) {
118+
health := c.prometheusAlerts.alertingHealth(ctx)
119+
120+
enabled, err := c.clusterMonitoringConfig.userWorkloadEnabled()
121+
if err != nil {
122+
return health, fmt.Errorf("failed to determine user workload enablement: %w", err)
123+
}
124+
health.UserWorkloadEnabled = enabled
125+
126+
return health, nil
127+
}

0 commit comments

Comments
 (0)