19075895534

Committed 04 Nov 2025 04:36PM UTC coverage: 76.775% (-0.5%) from 77.239%

Build # 19075895534

Build Type

Pull #3835

github

Committed by

web-flow

Commit Message

Merge 7ff4689c0 into f64d16a69

Pull Request Pull Request #3835: [WIP] Add Cluster Memory Load Perses dashboard

Run Details

0 of 62 new or added lines in 2 files covered. (0.0%)

7917 of 10312 relevant lines covered (76.77%)

1.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

61.64

/controllers/observability/observability_controller.go

package observability

import (
        "context"
        "fmt"
        "time"

        appsv1 "k8s.io/api/apps/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/client-go/rest"
        "k8s.io/utils/ptr"
        ctrl "sigs.k8s.io/controller-runtime"
        "sigs.k8s.io/controller-runtime/pkg/client"
        "sigs.k8s.io/controller-runtime/pkg/event"
        "sigs.k8s.io/controller-runtime/pkg/handler"
        logf "sigs.k8s.io/controller-runtime/pkg/log"
        "sigs.k8s.io/controller-runtime/pkg/source"

        "github.com/kubevirt/hyperconverged-cluster-operator/pkg/alertmanager"
        "github.com/kubevirt/hyperconverged-cluster-operator/pkg/monitoring/observability/rules"
        "github.com/kubevirt/hyperconverged-cluster-operator/pkg/util"
)

var (
        log         = logf.Log.WithName("controller_observability")
        periodicity = 1 * time.Hour
)

type Reconciler struct {
        client.Client

        namespace string
        config    *rest.Config
        events    chan event.GenericEvent
        owner     *metav1.OwnerReference

        amApi *alertmanager.Api
}

func (r *Reconciler) Reconcile(ctx context.Context, _ ctrl.Request) (ctrl.Result, error) {
        log.Info("Reconciling Observability")

        var errors []error

        if err := r.ensurePodDisruptionBudgetAtLimitIsSilenced(); err != nil {
                errors = append(errors, err)
        }

        if err := r.ReconcileAlerts(ctx); err != nil {
                errors = append(errors, err)
        }

        // Apply Perses dashboards/datasources shipped with the operator, if any
        if err := r.ReconcilePersesResources(ctx); err != nil {
                errors = append(errors, err)
        }

        if len(errors) > 0 {
                err := fmt.Errorf("reconciliation failed: %v", errors)
                log.Error(err, "Reconciliation failed")
                return ctrl.Result{}, err
        }

        return ctrl.Result{}, nil
}

func NewReconciler(mgr ctrl.Manager, namespace string, ownerDeployment *appsv1.Deployment) *Reconciler {
        return &Reconciler{
                Client:    mgr.GetClient(),
                namespace: namespace,
                config:    mgr.GetConfig(),
                events:    make(chan event.GenericEvent, 1),
                owner:     buildOwnerReference(ownerDeployment),
        }
}

func SetupWithManager(mgr ctrl.Manager, ownerDeployment *appsv1.Deployment) error {
        log.Info("Setting up controller")

        namespace := util.GetOperatorNamespaceFromEnv()

        err := rules.SetupRules()
        if err != nil {
                return fmt.Errorf("failed to setup Prometheus rules: %v", err)
        }

        r := NewReconciler(mgr, namespace, ownerDeployment)
        r.startEventLoop()

        return ctrl.NewControllerManagedBy(mgr).
                Named("observability").
                WatchesRawSource(source.Channel(
                        r.events,
                        &handler.EnqueueRequestForObject{},
                )).
                Complete(r)
}

func (r *Reconciler) startEventLoop() {
        ticker := time.NewTicker(periodicity)

        go func() {
                r.events <- event.GenericEvent{
                        Object: &metav1.PartialObjectMetadata{},
                }

                for range ticker.C {
                        r.events <- event.GenericEvent{
                                Object: &metav1.PartialObjectMetadata{},
                        }
                }
        }()
}

func buildOwnerReference(ownerDeployment *appsv1.Deployment) *metav1.OwnerReference {
        if ownerDeployment == nil {
                return nil
        }

        return &metav1.OwnerReference{
                APIVersion:         appsv1.SchemeGroupVersion.String(),
                Kind:               "Deployment",
                Name:               ownerDeployment.GetName(),
                UID:                ownerDeployment.GetUID(),
                BlockOwnerDeletion: ptr.To(false),
                Controller:         ptr.To(false),
        }
}

1	package observability
2
3	import (
4	"context"
5	"fmt"
6	"time"
7
8	appsv1 "k8s.io/api/apps/v1"
9	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
10	"k8s.io/client-go/rest"
11	"k8s.io/utils/ptr"
12	ctrl "sigs.k8s.io/controller-runtime"
13	"sigs.k8s.io/controller-runtime/pkg/client"
14	"sigs.k8s.io/controller-runtime/pkg/event"
15	"sigs.k8s.io/controller-runtime/pkg/handler"
16	logf "sigs.k8s.io/controller-runtime/pkg/log"
17	"sigs.k8s.io/controller-runtime/pkg/source"
18
19	"github.com/kubevirt/hyperconverged-cluster-operator/pkg/alertmanager"
20	"github.com/kubevirt/hyperconverged-cluster-operator/pkg/monitoring/observability/rules"
21	"github.com/kubevirt/hyperconverged-cluster-operator/pkg/util"
22	)
23
24	var (
25	log = logf.Log.WithName("controller_observability")
26	periodicity = 1 * time.Hour
27	)
28
29	type Reconciler struct {
30	client.Client
31
32	namespace string
33	config *rest.Config
34	events chan event.GenericEvent
35	owner *metav1.OwnerReference
36
37	amApi *alertmanager.Api
38	}
39
40	func (r *Reconciler) Reconcile(ctx context.Context, _ ctrl.Request) (ctrl.Result, error) {	×
41	log.Info("Reconciling Observability")	×
42		×
43	var errors []error	×
44		×
45	if err := r.ensurePodDisruptionBudgetAtLimitIsSilenced(); err != nil {	×
46	errors = append(errors, err)	×
47	}	×
48
49	if err := r.ReconcileAlerts(ctx); err != nil {	×
50	errors = append(errors, err)	×
51	}	×
52
53	// Apply Perses dashboards/datasources shipped with the operator, if any
NEW 54	if err := r.ReconcilePersesResources(ctx); err != nil {	×
NEW 55	errors = append(errors, err)	×
NEW 56	}	×
57
58	if len(errors) > 0 {	×
59	err := fmt.Errorf("reconciliation failed: %v", errors)	×
60	log.Error(err, "Reconciliation failed")	×
61	return ctrl.Result{}, err	×
62	}	×
63
64	return ctrl.Result{}, nil	×
65	}
66
67	func NewReconciler(mgr ctrl.Manager, namespace string, ownerDeployment appsv1.Deployment) Reconciler {	1✔
68	return &Reconciler{	1✔
69	Client: mgr.GetClient(),	1✔
70	namespace: namespace,	1✔
71	config: mgr.GetConfig(),	1✔
72	events: make(chan event.GenericEvent, 1),	1✔
73	owner: buildOwnerReference(ownerDeployment),	1✔
74	}	1✔
75	}	1✔
76
77	func SetupWithManager(mgr ctrl.Manager, ownerDeployment *appsv1.Deployment) error {	1✔
78	log.Info("Setting up controller")	1✔
79		1✔
80	namespace := util.GetOperatorNamespaceFromEnv()	1✔
81		1✔
82	err := rules.SetupRules()	1✔
83	if err != nil {	1✔
84	return fmt.Errorf("failed to setup Prometheus rules: %v", err)	×
85	}	×
86
87	r := NewReconciler(mgr, namespace, ownerDeployment)	1✔
88	r.startEventLoop()	1✔
89		1✔
90	return ctrl.NewControllerManagedBy(mgr).	1✔
91	Named("observability").	1✔
92	WatchesRawSource(source.Channel(	1✔
93	r.events,	1✔
94	&handler.EnqueueRequestForObject{},	1✔
95	)).	1✔
96	Complete(r)	1✔
97	}
98
99	func (r *Reconciler) startEventLoop() {	1✔
100	ticker := time.NewTicker(periodicity)	1✔
101		1✔
102	go func() {	2✔
103	r.events <- event.GenericEvent{	1✔
104	Object: &metav1.PartialObjectMetadata{},	1✔
105	}	1✔
106		1✔
107	for range ticker.C {	1✔
108	r.events <- event.GenericEvent{	×
109	Object: &metav1.PartialObjectMetadata{},	×
110	}	×
111	}	×
112	}()
113	}
114
115	func buildOwnerReference(ownerDeployment appsv1.Deployment) metav1.OwnerReference {	1✔
116	if ownerDeployment == nil {	1✔
117	return nil	×
118	}	×
119
120	return &metav1.OwnerReference{	1✔
121	APIVersion: appsv1.SchemeGroupVersion.String(),	1✔
122	Kind: "Deployment",	1✔
123	Name: ownerDeployment.GetName(),	1✔
124	UID: ownerDeployment.GetUID(),	1✔
125	BlockOwnerDeletion: ptr.To(false),	1✔
126	Controller: ptr.To(false),	1✔
127	}	1✔
128	}

kubevirt / hyperconverged-cluster-operator / 19075895534

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous