feat(osko): Another batch of undescribeable changes

- remove mimirtool package and moved all function into mimirtool helper
- add debug and pretty output run to Makefile
- changes in MimirRule types
- fix error_budget_rule logic

Signed-off-by: Hy3n4 <hy3nk4@gmail.com>

Makefile

@@ -74,6 +74,10 @@ build: manifests generate fmt vet ## Build manager binary.
 run: manifests generate fmt vet ## Run a controller from your host.
 	go run ./cmd/main.go
 
+.PHONY: run-pretty-debug
+run-pretty-debug: manifests generate fmt vet ## Run a controller from your host with pretty debug output.
+	go run ./cmd/main.go --zap-log-level=debug 2>&1 | zap-pretty
+
 # If you wish built the manager image targeting other platforms you can use the --platform flag.
 # (i.e. docker build --platform linux/arm64 ). However, you must enable docker buildKit for it.
 # More info: https://docs.docker.com/develop/develop-images/build_enhancements/

api/osko/v1alpha1/mimirrule_types.go

@@ -44,6 +44,7 @@ type Rule struct {
 //+kubebuilder:object:root=true
 //+kubebuilder:subresource:status
 //+kubebuilder:printcolumn:name="Ready",type=string,JSONPath=.status.ready,description="The reason for the current status of the MimirRule resource"
+//+kubebuilder:printcolumn:name="Age",type=date,JSONPath=`.metadata.creationTimestamp`
 
 // MimirRule is the Schema for the mimirrules API
 type MimirRule struct {

config/crd/bases/osko.dev_mimirrules.yaml

@@ -19,6 +19,9 @@ spec:
       jsonPath: .status.ready
       name: Ready
       type: string
+    - jsonPath: .metadata.creationTimestamp
+      name: Age
+      type: date
     name: v1alpha1
     schema:
       openAPIV3Schema:

internal/controller/openslo/slo_controller.go

@@ -59,7 +59,7 @@ func (r *SLOReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.R
 	err := r.Get(ctx, req.NamespacedName, slo)
 	if err != nil {
 		if apierrors.IsNotFound(err) {
-			log.Info("SLO resource not found. Object must have been deleted.")
+			log.V(1).Info("SLO resource not found. Object must have been deleted.")
 			return ctrl.Result{}, nil
 		}
 		log.Error(err, errGetSLO)
@@ -73,14 +73,7 @@ func (r *SLOReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.R
 			apierrors.IsNotFound(err)
 			{
 				log.Error(err, errGetSLI)
-				err = utils.UpdateStatus(
-					ctx,
-					slo,
-					r.Client,
-					"Ready",
-					metav1.ConditionFalse,
-					"SLI Object not found",
-				)
+				err = utils.UpdateStatus(ctx, slo, r.Client, "Ready", metav1.ConditionFalse, "SLI Object not found")
 				if err != nil {
 					log.Error(err, "Failed to update SLO status")
 					return ctrl.Result{}, err
@@ -89,7 +82,7 @@ func (r *SLOReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.R
 			}
 		}
 	} else if slo.Spec.Indicator != nil {
-		log.Info("SLO has an inline SLI")
+		log.V(1).Info("SLO has an inline SLI")
 		sli.Name = slo.Spec.Indicator.Metadata.Name
 		sli.Spec.Description = slo.Spec.Indicator.Spec.Description
 		if slo.Spec.Indicator.Spec.RatioMetric != (openslov1.RatioMetricSpec{}) {
@@ -156,15 +149,7 @@ func (r *SLOReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.R
 		log.Info("MimirRule not found. Let's make one.")
 		mimirRule, err = helpers.NewMimirRule(slo, promRule)
 		if err != nil {
-			err = utils.UpdateStatus(
-				ctx,
-				slo,
-				r.Client,
-				"Ready",
-				metav1.ConditionFalse,
-				"Failed to create Mimir Rule Object",
-			)
-			if err != nil {
+			if err = utils.UpdateStatus(ctx, slo, r.Client, "Ready", metav1.ConditionFalse, "Failed to create Mimir Rule Object"); err != nil {
 				log.Error(err, "Failed to update SLO status")
 				return ctrl.Result{}, err
 			}

internal/controller/osko/mimirrule_controller.go

@@ -7,9 +7,10 @@ import (
 	"github.com/grafana/mimir/pkg/mimirtool/rules/rwrulefmt"
 	openslov1 "github.com/oskoperator/osko/api/openslo/v1"
 	"github.com/oskoperator/osko/internal/helpers"
-	"github.com/oskoperator/osko/internal/mimirtool"
 	"github.com/oskoperator/osko/internal/utils"
 	monitoringv1 "github.com/prometheus-operator/prometheus-operator/pkg/apis/monitoring/v1"
+	"github.com/prometheus/prometheus/model/rulefmt"
+	"gopkg.in/yaml.v3"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/tools/record"
@@ -26,9 +27,9 @@ import (
 // MimirRuleReconciler reconciles a MimirRule object
 type MimirRuleReconciler struct {
 	client.Client
-	Scheme   *runtime.Scheme
-	Recorder record.EventRecorder
-	mimirclient.MimirClient
+	Scheme      *runtime.Scheme
+	Recorder    record.EventRecorder
+	MimirClient *mimirclient.MimirClient
 }
 
 const (
@@ -53,6 +54,7 @@ const (
 func (r *MimirRuleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
 	log := ctrllog.FromContext(ctx)
 
+	ds := &openslov1.Datasource{}
 	slo := &openslov1.SLO{}
 	prometheusRule := &monitoringv1.PrometheusRule{}
 	mimirRule := &oskov1alpha1.MimirRule{}
@@ -68,7 +70,6 @@ func (r *MimirRuleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 		return ctrl.Result{}, err
 	}
 
-	ds := &openslov1.Datasource{}
 	if err := r.Get(ctx, client.ObjectKey{
 		Namespace: prometheusRule.Namespace,
 		Name:      "logging-ds",
@@ -77,6 +78,24 @@ func (r *MimirRuleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 		return ctrl.Result{}, err
 	}
 
+	log.Info("Datasource found", "Datasource", ds)
+
+	if err := r.newMimirClient(ds); err != nil {
+		log.Error(err, "Failed to create MimirClient")
+		return ctrl.Result{}, err
+	}
+
+	rgs, err := helpers.NewMimirRuleGroup(prometheusRule)
+	if err != nil {
+		log.Error(err, "Failed to convert MimirRuleGroup")
+		return ctrl.Result{}, err
+	}
+
+	if err := r.createMimirRuleGroupAPI(log, rgs); err != nil {
+		log.Error(err, "Failed to create MimirRuleGroup")
+		return ctrl.Result{}, err
+	}
+
 	err = r.Get(ctx, req.NamespacedName, mimirRule)
 	if err != nil {
 		if apierrors.IsNotFound(err) {
@@ -144,11 +163,6 @@ func (r *MimirRuleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 
 	newMimirRule.ResourceVersion = mimirRule.ResourceVersion
 
-	if err := r.newMimirClient(ds); err != nil {
-		log.Error(err, "Failed to initialize Mimir client")
-		return ctrl.Result{}, err
-	}
-
 	if err := r.Update(ctx, newMimirRule); err != nil {
 		log.Error(err, "Failed to update MimirRule")
 		mimirRule.Status.Ready = "False"
@@ -159,55 +173,87 @@ func (r *MimirRuleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 		return ctrl.Result{}, err
 	}
 
-	if err = helpers.CreateMimirRuleGroupAPI(log, &r.MimirClient, &mimirRule.Spec.Groups[0], ds); err != nil {
-		log.Error(err, "Failed to create MimirRuleGroup")
-		return ctrl.Result{}, err
-	}
-
 	log.Info("MimirRule reconciled")
 	return ctrl.Result{}, nil
 }
 
 func (r *MimirRuleReconciler) newMimirClient(ds *openslov1.Datasource) error {
-	mClient := mimirtool.MimirClientConfig{
+	mClientConfig := helpers.MimirClientConfig{
 		Address:  ds.Spec.ConnectionDetails.Address,
 		TenantId: ds.Spec.ConnectionDetails.TargetTenant,
 	}
 
-	mimirClient, err := mClient.NewMimirClient()
+	mimirClient, err := mClientConfig.NewMimirClient()
 	if err != nil {
 		return err
 	}
 
-	r.MimirClient = *mimirClient
+	r.MimirClient = mimirClient
+
 	return nil
 }
 
-func (r *MimirRuleReconciler) getMimirRuleGroup(log logr.Logger, mimirClient *mimirclient.MimirClient, rule *monitoringv1.PrometheusRule) *rwrulefmt.RuleGroup {
-	mimirRuleGroup, err := mimirClient.GetRuleGroup(context.Background(), mimirRuleNamespace, rule.Name)
-	if err != nil {
-		log.Error(err, "Failed to get rule group")
-		return nil
+func (r *MimirRuleReconciler) createMimirRuleGroupAPI(log logr.Logger, rule *oskov1alpha1.RuleGroup) error {
+	var mimirRuleNodes []rulefmt.RuleNode
+	for _, r := range rule.Rules {
+		mimirRuleNode := rulefmt.RuleNode{
+			Record: yaml.Node{
+				Kind:  8,
+				Value: r.Record,
+			},
+			Alert: yaml.Node{},
+			Expr: yaml.Node{
+				Kind:  8,
+				Value: r.Expr,
+			},
+			Labels: r.Labels,
+		}
+		mimirRuleNodes = append(mimirRuleNodes, mimirRuleNode)
 	}
 
-	return mimirRuleGroup
-}
+	log.Info("Source tenants", "SourceTenants", rule.SourceTenants)
 
-func (r *MimirRuleReconciler) createMimirRuleGroup(log logr.Logger, mimirClient *mimirclient.MimirClient, rule *monitoringv1.PrometheusRule, ds *openslov1.Datasource) error {
-	mimirRuleGroup, err := mimirtool.NewMimirRuleGroup(rule, ds)
-	if err != nil {
-		log.Error(err, "Failed to create Mimir rule group")
-		return err
+	mimirRule := rwrulefmt.RuleGroup{
+		RuleGroup: rulefmt.RuleGroup{
+			Name:          rule.Name,
+			Rules:         mimirRuleNodes,
+			SourceTenants: rule.SourceTenants,
+		},
 	}
 
-	if err := mimirClient.CreateRuleGroup(context.Background(), mimirRuleNamespace, *mimirRuleGroup); err != nil {
+	if err := r.MimirClient.CreateRuleGroup(context.Background(), mimirRuleNamespace, mimirRule); err != nil {
 		log.Error(err, "Failed to create rule group")
 		return err
 	}
 
 	return nil
 }
 
+func (r *MimirRuleReconciler) getMimirRuleGroupAPI(log logr.Logger, rule *monitoringv1.PrometheusRule) *rwrulefmt.RuleGroup {
+	mimirRuleGroup, err := r.MimirClient.GetRuleGroup(context.Background(), mimirRuleNamespace, rule.Name)
+	if err != nil {
+		log.Error(err, "Failed to get rule group")
+		return nil
+	}
+
+	return mimirRuleGroup
+}
+
+//func (r *MimirRuleReconciler) createMimirRuleGroup(log logr.Logger, mimirClient *mimirclient.MimirClient, rule *monitoringv1.PrometheusRule, ds *openslov1.Datasource) error {
+//	mimirRuleGroup, err := helpers.NewMimirRuleGroup(rule)
+//	if err != nil {
+//		log.Error(err, "Failed to create Mimir rule group")
+//		return err
+//	}
+//
+//	if err := mimirClient.CreateRuleGroup(context.Background(), mimirRuleNamespace, *mimirRuleGroup); err != nil {
+//		log.Error(err, "Failed to create rule group")
+//		return err
+//	}
+//
+//	return nil
+//}
+
 func (r *MimirRuleReconciler) deleteMimirRuleGroup(log logr.Logger, mimirClient *mimirclient.MimirClient, ruleGroup *rwrulefmt.RuleGroup) error {
 	if err := mimirClient.DeleteRuleGroup(context.Background(), mimirRuleNamespace, ruleGroup.Name); err != nil {
 		log.Error(err, "Failed to delete rule group")