First version working

Author: dfradehubs

api/v1alpha1/ruleraction_types.go

@@ -42,8 +42,7 @@ type RulerActionSpec struct {
 	// INSERT ADDITIONAL SPEC FIELDS - desired state of cluster
 	// Important: Run "make" to regenerate code after modifying this file
 
-	Webhook        Webhook `json:"webhook"`
-	FiringInterval string  `json:"firingInterval"`
+	Webhook Webhook `json:"webhook"`
 }
 
 // RulerActionStatus defines the observed state of RulerAction.

config/crd/bases/searchruler.prosimcorp.com_ruleractions.yaml

@@ -39,8 +39,6 @@ spec:
           spec:
             description: RulerActionSpec defines the desired state of RulerAction.
             properties:
-              firingInterval:
-                type: string
               webhook:
                 description: WebHook TODO
                 properties:
@@ -79,7 +77,6 @@ spec:
                 - verb
                 type: object
             required:
-            - firingInterval
             - webhook
             type: object
           status:

config/samples/searchruler_v1alpha1_ruleraction.yaml

@@ -6,12 +6,13 @@ metadata:
     app.kubernetes.io/managed-by: kustomize
   name: ruleraction-sample
 spec:
-  firingInterval: 1m
   webhook:
-    url: https://webhook.site/7688d5a6-af64-40d4-9991-01cb3b9035a7
+    url: https://webhook.site/3f2e28af-68b2-47bd-b603-f8abcdf2ac93
     verb: POST
     headers: {}
-    validator: alertmanager
+
+    #validator: alertmanager
+
     # credentials:   
     #   secretRef:
     #     name: alertmanager-credentials

config/samples/searchruler_v1alpha1_searchrule.yaml

@@ -13,7 +13,7 @@ spec:
     name: queryconnector-sample
 
   # Interval time for checking the value of the query
-  checkInterval: 5s
+  checkInterval: 30s
 
   # Query to execute in the QueryConnector
   elasticsearch:
@@ -82,15 +82,15 @@ spec:
     # greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual or equal
     operator: "greaterThan"
     threshold: "100"
-    for: "15s"
+    for: "1m"
 
   # SearchAction item
   actionRef:
     name: ruleraction-sample
     data: |
       {{- $object := .object -}}
       {{- $value := .value -}}
-      {{ printf "Hi, I'm on fire!" -}}
-      {{ printf "Name: %s" $object.Name -}}
-      {{ printf "Description: %s" $object.Spec.Description -}}
-      {{ printf "Current value: %v" $value -}}
+      {{ printf "Hi, I'm on fire!" }}
+      {{ printf "Name: %s" $object.Name }}
+      {{ printf "Description: %s" $object.Spec.Description }}
+      {{ printf "Current value: %v" $value }}

go.mod

@@ -3,6 +3,8 @@ module prosimcorp.com/SearchRuler
 go 1.22.0
 
 require (
+	github.com/BurntSushi/toml v1.4.0
+	github.com/Masterminds/sprig v2.22.0+incompatible
 	github.com/onsi/ginkgo/v2 v2.19.0
 	github.com/onsi/gomega v1.33.1
 	github.com/tidwall/gjson v1.18.0
@@ -11,13 +13,12 @@ require (
 	k8s.io/apimachinery v0.31.0
 	k8s.io/client-go v0.31.0
 	sigs.k8s.io/controller-runtime v0.19.0
+	sigs.k8s.io/yaml v1.4.0
 )
 
 require (
-	github.com/BurntSushi/toml v1.4.0 // indirect
 	github.com/Masterminds/goutils v1.1.1 // indirect
 	github.com/Masterminds/semver v1.5.0 // indirect
-	github.com/Masterminds/sprig v2.22.0+incompatible // indirect
 	github.com/antlr4-go/antlr/v4 v4.13.0 // indirect
 	github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
@@ -105,5 +106,4 @@ require (
 	sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.30.3 // indirect
 	sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd // indirect
 	sigs.k8s.io/structured-merge-diff/v4 v4.4.1 // indirect
-	sigs.k8s.io/yaml v1.4.0 // indirect
 )

internal/controller/ruleraction_controller.go

@@ -19,16 +19,18 @@ package controller
 import (
 	"context"
 	"fmt"
-	"time"
 
 	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
 	searchrulerv1alpha1 "prosimcorp.com/SearchRuler/api/v1alpha1"
 	"prosimcorp.com/SearchRuler/internal/pools"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
 	"sigs.k8s.io/controller-runtime/pkg/event"
+	"sigs.k8s.io/controller-runtime/pkg/handler"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
 )
@@ -56,7 +58,6 @@ type RulerActionReconciler struct {
 func (r *RulerActionReconciler) Reconcile(ctx context.Context, req ctrl.Request) (result ctrl.Result, err error) {
 
 	logger := log.FromContext(ctx)
-	triggeredByEvent := false
 
 	// 1. Get the content of the Patch
 
@@ -65,16 +66,31 @@ func (r *RulerActionReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 	err = r.Get(ctx, req.NamespacedName, RulerActionResource)
 
 	// 1.2 If there are an error, try with Event type resource
-	if err != nil {
+	if errors.IsNotFound(err) {
 		EventResource := &corev1.Event{}
 		err = r.Get(ctx, req.NamespacedName, EventResource)
-		if err != nil {
-			triggeredByEvent = true
+
+		// If the resource is an event, then get the SearchRule resource associated to the event
+		// and then the RulerAction resource associated to the SearchRule
+		if err == nil {
+			SearchRuleResource := &searchrulerv1alpha1.SearchRule{}
+			SearchRuleNamespacedName := types.NamespacedName{
+				Namespace: EventResource.InvolvedObject.Namespace,
+				Name:      EventResource.InvolvedObject.Name,
+			}
+			err = r.Get(ctx, SearchRuleNamespacedName, SearchRuleResource)
+			if err == nil {
+				RulerActionNamespacedName := types.NamespacedName{
+					Namespace: SearchRuleResource.Namespace,
+					Name:      SearchRuleResource.Spec.ActionRef.Name,
+				}
+				err = r.Get(ctx, RulerActionNamespacedName, RulerActionResource)
+			}
 		}
 	}
 
 	// 2. If it is not Event or RulerAction, then check existence on the cluster
-	if err != nil && !triggeredByEvent {
+	if err != nil {
 
 		// 2.1 It does NOT exist: manage removal
 		if err = client.IgnoreNotFound(err); err == nil {
@@ -88,7 +104,7 @@ func (r *RulerActionReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 	}
 
 	// 3. Check if the SearchRule instance is marked to be deleted: indicated by the deletion timestamp being set
-	if !RulerActionResource.DeletionTimestamp.IsZero() && !triggeredByEvent {
+	if !RulerActionResource.DeletionTimestamp.IsZero() {
 		if controllerutil.ContainsFinalizer(RulerActionResource, resourceFinalizer) {
 			// Remove the finalizers on Patch CR
 			controllerutil.RemoveFinalizer(RulerActionResource, resourceFinalizer)
@@ -104,7 +120,7 @@ func (r *RulerActionReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 	}
 
 	// 4. Add finalizer to the SearchRule CR
-	if !controllerutil.ContainsFinalizer(RulerActionResource, resourceFinalizer) && !triggeredByEvent {
+	if !controllerutil.ContainsFinalizer(RulerActionResource, resourceFinalizer) {
 		controllerutil.AddFinalizer(RulerActionResource, resourceFinalizer)
 		err = r.Update(ctx, RulerActionResource)
 		if err != nil {
@@ -118,22 +134,27 @@ func (r *RulerActionReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 		if err != nil {
 			logger.Info(fmt.Sprintf(resourceConditionUpdateError, RulerActionResourceType, req.NamespacedName, err.Error()))
 		}
+
 	}()
 
 	// 6. Schedule periodical request
-	if !triggeredByEvent {
-		RequeueTime, err := time.ParseDuration(RulerActionResource.Spec.FiringInterval)
-		if err != nil {
-			logger.Info(fmt.Sprintf(resourceSyncTimeRetrievalError, RulerActionResourceType, req.NamespacedName, err.Error()))
-			return result, err
-		}
-		result = ctrl.Result{
-			RequeueAfter: RequeueTime,
-		}
-	}
+	// if !triggeredByEvent {
+	// 	RequeueTime, err := time.ParseDuration(RulerActionResource.Spec.FiringInterval)
+	// 	if err != nil {
+	// 		logger.Info(fmt.Sprintf(resourceSyncTimeRetrievalError, RulerActionResourceType, req.NamespacedName, err.Error()))
+	// 		return result, err
+	// 	}
+	// 	result = ctrl.Result{
+	// 		RequeueAfter: RequeueTime,
+	// 	}
+	// }
 
 	// 7. Sync credentials if defined
 	err = r.Sync(ctx, RulerActionResource)
+	if err != nil {
+		logger.Info(fmt.Sprintf("error: %v", err.Error()))
+		return result, err
+	}
 	if err != nil {
 		r.UpdateConditionKubernetesApiCallFailure(RulerActionResource)
 		logger.Info(fmt.Sprintf(syncTargetError, RulerActionResourceType, req.NamespacedName, err.Error()))
@@ -162,5 +183,6 @@ func (r *RulerActionReconciler) SetupWithManager(mgr ctrl.Manager) error {
 				return false
 			},
 		}).
+		Watches(&corev1.Event{}, &handler.EnqueueRequestForObject{}).
 		Complete(r)
 }

internal/controller/ruleraction_sync.go

@@ -11,9 +11,28 @@ import (
 	"k8s.io/apimachinery/pkg/types"
 	"prosimcorp.com/SearchRuler/api/v1alpha1"
 	"prosimcorp.com/SearchRuler/internal/template"
+	"prosimcorp.com/SearchRuler/internal/validators"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 )
 
+const (
+	//
+	HttpEventPattern = `{"data":"%s","timestamp":"%s"}`
+
+	//
+	ValidatorNotFoundErrorMessage   = "validator %s not found"
+	ValidationFailedErrorMessage    = "validation failed: %s"
+	HttpRequestCreationErrorMessage = "error creating http request: %s"
+	HttpRequestSendingErrorMessage  = "error sending http request: %s"
+)
+
+var (
+	// validatorsMap is a map of integration names and their respective validation functions
+	validatorsMap = map[string]func(data string) (result bool, hint string, err error){
+		"alertmanager": validators.ValidateAlertmanager,
+	}
+)
+
 // Sync
 func (r *RulerActionReconciler) Sync(ctx context.Context, resource *v1alpha1.RulerAction) (err error) {
 
@@ -44,7 +63,6 @@ func (r *RulerActionReconciler) Sync(ctx context.Context, resource *v1alpha1.Rul
 	}
 
 	// Check alerts
-	logger.Info(fmt.Sprintf("Triggered by: %s", resource.Name))
 	alerts := r.AlertsPool.GetByRegex(fmt.Sprintf("%s/%s/*", resource.Namespace, resource.Name))
 	for _, alert := range alerts {
 
@@ -62,6 +80,25 @@ func (r *RulerActionReconciler) Sync(ctx context.Context, resource *v1alpha1.Rul
 			httpRequest.Header.Set(headerKey, headerValue)
 		}
 
+		// Check if the webhook has a validator and execute it when available
+		if resource.Spec.Webhook.Validator != "" {
+
+			_, validatorFound := validatorsMap[resource.Spec.Webhook.Validator]
+			if !validatorFound {
+				return fmt.Errorf(ValidatorNotFoundErrorMessage, resource.Spec.Webhook.Validator)
+			}
+
+			//
+			validatorResult, validatorHint, err := validatorsMap[resource.Spec.Webhook.Validator](alert.SearchRule.Spec.ActionRef.Data)
+			if err != nil {
+				return fmt.Errorf(ValidationFailedErrorMessage, err.Error())
+			}
+
+			if !validatorResult {
+				return fmt.Errorf(ValidationFailedErrorMessage, validatorHint)
+			}
+		}
+
 		// Add data to the request
 		templateInjectedObject := map[string]interface{}{}
 		templateInjectedObject["value"] = alert.Value

internal/controller/searchrule_ruler.go

@@ -70,7 +70,6 @@ func evaluateCondition(value float64, operator string, threshold string) (bool,
 
 // createKubeEvent creates a modern event in Kubernetes with data given by params
 func createKubeEvent(ctx context.Context, rule v1alpha1.SearchRule, action, message string) (err error) {
-
 	eventObj := eventsv1.Event{
 		ObjectMeta: metav1.ObjectMeta{
 			GenerateName: "alert-",

internal/validators/validators.go

@@ -0,0 +1,64 @@
+package validators
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+)
+
+const (
+	amgrAlertDataUnmarshalErrorMessage         = "error decoding JSON from 'message.data' for Alertmanager validator: %s"
+	amgrAlertDataRequiredStructureErrorMessage = "notification field 'message.data' does not meet the syntax requirements for Alertmanager: %s"
+)
+
+// TODO
+type AlertmanagerAlertList []AlertmanagerAlert
+
+// Alert represents the structure of an alert in Alertmanager
+// Ref: https://prometheus.io/docs/alerting/latest/clients/
+// Ref: https://raw.githubusercontent.com/prometheus/alertmanager/main/api/v2/openapi.yaml
+type AlertmanagerAlert struct {
+	Labels      map[string]string `json:"labels"`
+	Annotations map[string]string `json:"annotations"`
+
+	// Optional params
+	StartsAt     string `json:"startsAt,omitempty"`
+	EndsAt       string `json:"endsAt,omitempty"`
+	GeneratorUrl string `json:"generatorURL,omitempty"`
+}
+
+// ValidateAlertmanager checks whether the notification data meets the requirements for Alertmanager
+func ValidateAlertmanager(data string) (result bool, hint string, err error) {
+
+	alertList := AlertmanagerAlertList{AlertmanagerAlert{}}
+
+	//
+	err = json.Unmarshal([]byte(data), &alertList)
+	if err != nil {
+		return false, hint, fmt.Errorf(amgrAlertDataUnmarshalErrorMessage, err)
+	}
+
+	if reflect.ValueOf(alertList).IsZero() {
+		return false, amgrAlertDataRequiredStructureErrorMessage, nil
+	}
+
+	//
+	for _, alert := range alertList {
+
+		// Check the main label for the alert.
+		// This is required only on API v1
+		_, alertNameFound := alert.Labels["alertname"]
+		if !alertNameFound {
+			hint = fmt.Sprintf("%s: %s", amgrAlertDataRequiredStructureErrorMessage, "label 'alertname' not found")
+			return false, hint, nil
+		}
+
+		// Check whether startAt field is set
+		if alert.StartsAt == "" {
+			hint = fmt.Sprintf("%s: %s", amgrAlertDataRequiredStructureErrorMessage, "field 'startsAt' not found")
+			return false, hint, nil
+		}
+	}
+
+	return true, hint, nil
+}