add k8s events logging to alloy

CHANGELOG.md

@@ -9,10 +9,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- Add kubernetes events logging in Alloy.
 - Add support for Private CAs in alloy logs.
 - Add KubeEventsLogger option and related methods in loggedCLuster package.
 - Add `events-logger` flag in the operator.
 - Add toggle for `events-logger` in observability-bundle configmap.
+- Add tests for `alloy-events` in events-logger-config.
 
 ### Changed
 

main.go

@@ -167,15 +167,15 @@ func main() {
 		DefaultWorkloadClusterNamespaces: defaultNamespaces,
 	}
 
-	eventsLoggerSecret := eventsloggersecret.Reconciler{
-		Client: mgr.GetClient(),
-	}
-
 	eventsLoggerConfig := eventsloggerconfig.Reconciler{
 		Client:                           mgr.GetClient(),
 		DefaultWorkloadClusterNamespaces: defaultNamespaces,
 	}
 
+	eventsLoggerSecret := eventsloggersecret.Reconciler{
+		Client: mgr.GetClient(),
+	}
+
 	loggedcluster.O.EnableLoggingFlag = enableLogging
 	loggedcluster.O.LoggingAgent = loggingAgent
 	loggedcluster.O.KubeEventsLogger = eventsLogger

pkg/common/common.go

@@ -40,6 +40,10 @@ const (
 	AlloyLogAgentAppName      = "alloy-logs"
 	AlloyLogAgentAppNamespace = "kube-system"
 
+	// Alloy app name and namespace when using Alloy as events logger.
+	AlloyEventsLoggerAppName      = "alloy-events"
+	AlloyEventsLoggerAppNamespace = "kube-system"
+
 	MaxBackoffPeriod = "10m"
 	LokiURLFormat    = "https://%s/loki/api/v1/push"
 )

pkg/resource/agents-toggle/observability_bundle_configmap.go

@@ -59,30 +59,33 @@ func GenerateObservabilityBundleConfigMap(ctx context.Context, lc loggedcluster.
 		return v1.ConfigMap{}, errors.Errorf("unsupported logging agent %q", lc.GetLoggingAgent())
 	}
 
-	// Enforce grafana-agent as events logger when observability-bundle version < 1.9.0 because this needs alloy 0.7.0.
-	if observabilityBundleVersion.LT(semver.MustParse("1.9.0")) && lc.GetKubeEventsLogger() == common.EventsLoggerAlloy {
-		logger := log.FromContext(ctx)
-		logger.Info("Alloy events logger is not supported by observability bundle, using grafana-agent instead.", "observability-bundle-version", observabilityBundleVersion, "events-logger", lc.GetKubeEventsLogger())
-		lc.SetKubeEventsLogger(common.EventsLoggerGrafanaAgent)
-	}
-
-	switch lc.GetKubeEventsLogger() {
-	case common.EventsLoggerGrafanaAgent:
-		appsToEnable["grafanaAgent"] = app{
-			Enabled: true,
-		}
-		appsToEnable["alloyEvents"] = app{
-			Enabled: false,
+	// If observability-bundle version >= 0.9.0, events loggers can be enabled.
+	if observabilityBundleVersion.GT(semver.MustParse("0.9.0")) {
+		// Enforce grafana-agent as events logger when observability-bundle version < 1.9.0 because this needs alloy 0.7.0.
+		if observabilityBundleVersion.LT(semver.MustParse("1.9.0")) && lc.GetKubeEventsLogger() == common.EventsLoggerAlloy {
+			logger := log.FromContext(ctx)
+			logger.Info("Alloy events logger is not supported by observability bundle, using grafana-agent instead.", "observability-bundle-version", observabilityBundleVersion, "events-logger", lc.GetKubeEventsLogger())
+			lc.SetKubeEventsLogger(common.EventsLoggerGrafanaAgent)
 		}
-	case common.EventsLoggerAlloy:
-		appsToEnable["grafanaAgent"] = app{
-			Enabled: false,
-		}
-		appsToEnable["alloyEvents"] = app{
-			Enabled: true,
+
+		switch lc.GetKubeEventsLogger() {
+		case common.EventsLoggerGrafanaAgent:
+			appsToEnable["grafanaAgent"] = app{
+				Enabled: true,
+			}
+			appsToEnable["alloyEvents"] = app{
+				Enabled: false,
+			}
+		case common.EventsLoggerAlloy:
+			appsToEnable["grafanaAgent"] = app{
+				Enabled: false,
+			}
+			appsToEnable["alloyEvents"] = app{
+				Enabled: true,
+			}
+		default:
+			return v1.ConfigMap{}, errors.Errorf("unsupported events logger %q", lc.GetKubeEventsLogger())
 		}
-	default:
-		return v1.ConfigMap{}, errors.Errorf("unsupported events logger %q", lc.GetKubeEventsLogger())
 	}
 
 	values := Values{

pkg/resource/agents-toggle/reconciler.go

@@ -28,36 +28,36 @@ type Reconciler struct {
 	Scheme *runtime.Scheme
 }
 
-// ReconcileCreate ensure logging agents are enabled in the given cluster.
+// ReconcileCreate ensure logging agents and events loggers are enabled in the given cluster.
 func (r *Reconciler) ReconcileCreate(ctx context.Context, lc loggedcluster.Interface) (ctrl.Result, error) {
 	logger := log.FromContext(ctx)
-	logger.Info("Logging agents toggle create")
+	logger.Info("agents toggle create")
 
 	observabilityBundleVersion, err := common.GetObservabilityBundleAppVersion(lc, r.Client, ctx)
 	if err != nil {
 		// Handle case where the app is not found.
 		if apimachineryerrors.IsNotFound(err) {
-			logger.Info("logging-agents-toggle - observability bundle app not found, requeueing")
+			logger.Info("agents-toggle - observability bundle app not found, requeueing")
 			// If the app is not found we should requeue and try again later (5 minutes is the app platform default reconciliation time)
 			return ctrl.Result{RequeueAfter: time.Duration(5 * time.Minute)}, nil
 		}
 		return ctrl.Result{}, errors.WithStack(err)
 	}
 
-	// Get desired configmap to enable logging agents.
+	// Get desired configmap to enable logging agents and events loggers.
 	desiredConfigMap, err := GenerateObservabilityBundleConfigMap(ctx, lc, observabilityBundleVersion)
 	if err != nil {
 		return ctrl.Result{}, errors.WithStack(err)
 	}
 
 	// Check if configmap is already installed.
-	logger.Info("Logging agents toggle checking", "namespace", desiredConfigMap.GetNamespace(), "name", desiredConfigMap.GetName())
+	logger.Info("agents toggle checking", "namespace", desiredConfigMap.GetNamespace(), "name", desiredConfigMap.GetName())
 	var currentConfigMap v1.ConfigMap
 	err = r.Client.Get(ctx, types.NamespacedName{Name: desiredConfigMap.GetName(), Namespace: desiredConfigMap.GetNamespace()}, &currentConfigMap)
 	if err != nil {
 		if apimachineryerrors.IsNotFound(err) {
 			// Install configmap.
-			logger.Info("Logging agents toggle not found, creating")
+			logger.Info("agents toggle not found, creating")
 			err = r.Client.Create(ctx, &desiredConfigMap)
 		}
 		if err != nil {
@@ -66,24 +66,24 @@ func (r *Reconciler) ReconcileCreate(ctx context.Context, lc loggedcluster.Inter
 	}
 
 	if needUpdate(currentConfigMap, desiredConfigMap) {
-		logger.Info("Logging agents toggle updating")
+		logger.Info("agents toggle updating")
 		// Update configmap
 		// Configmap is installed and need to be updated.
 		err := r.Client.Update(ctx, &desiredConfigMap)
 		if err != nil {
 			return ctrl.Result{}, errors.WithStack(err)
 		}
 	} else {
-		logger.Info("Logging agents toggle up to date")
+		logger.Info("agents toggle up to date")
 	}
 
 	return ctrl.Result{}, nil
 }
 
-// ReconcileDelete ensure logging agents are disabled for the given cluster.
+// ReconcileDelete ensure logging agents and events loggers are disabled for the given cluster.
 func (r *Reconciler) ReconcileDelete(ctx context.Context, lc loggedcluster.Interface) (ctrl.Result, error) {
 	logger := log.FromContext(ctx)
-	logger.Info("Logging agents toggle delete")
+	logger.Info("agents toggle delete")
 
 	// Get observability bundle app metadata.
 	appMeta := common.ObservabilityBundleAppMeta(lc)
@@ -93,7 +93,7 @@ func (r *Reconciler) ReconcileDelete(ctx context.Context, lc loggedcluster.Inter
 	if err != nil {
 		// Handle case where the app is not found.
 		if apimachineryerrors.IsNotFound(err) {
-			logger.Info("logging-agents-toggle - observability bundle app not found, skipping deletion")
+			logger.Info("agents-toggle - observability bundle app not found, skipping deletion")
 			// If the app is not found we ignore the error and return, as this means the app was already deleted.
 			return ctrl.Result{}, nil
 		}
@@ -105,25 +105,30 @@ func (r *Reconciler) ReconcileDelete(ctx context.Context, lc loggedcluster.Inter
 		return ctrl.Result{}, errors.WithStack(err)
 	}
 
+	// If the observability-bundle version is too old, we don't need to do anything.
+	if observabilityBundleVersion.LT(semver.MustParse("0.9.0")) {
+		return ctrl.Result{}, nil
+	}
+
 	// Get expected configmap.
 	desiredConfigMap, err := GenerateObservabilityBundleConfigMap(ctx, lc, observabilityBundleVersion)
 	if err != nil {
 		return ctrl.Result{}, errors.WithStack(err)
 	}
 
 	// Delete configmap.
-	logger.Info("Logging agents toggle deleting", "namespace", desiredConfigMap.GetNamespace(), "name", desiredConfigMap.GetName())
+	logger.Info("agents toggle deleting", "namespace", desiredConfigMap.GetNamespace(), "name", desiredConfigMap.GetName())
 	err = r.Client.Delete(ctx, &desiredConfigMap)
 	if err != nil {
 		if apimachineryerrors.IsNotFound(err) {
 			// Do no throw error in case it was not found, as this means
 			// it was already deleted.
-			logger.Info("Logging agents toggle already deleted")
+			logger.Info("agents toggle already deleted")
 		} else if err != nil {
 			return ctrl.Result{}, errors.WithStack(err)
 		}
 	} else {
-		logger.Info("Logging agents toggle deleted")
+		logger.Info("agents toggle deleted")
 	}
 
 	return ctrl.Result{}, nil

pkg/resource/events-logger-config/alloy-events-config.go

@@ -0,0 +1,86 @@
+package eventsloggerconfig
+
+import (
+	"bytes"
+	_ "embed"
+	"fmt"
+	"text/template"
+
+	"github.com/Masterminds/sprig/v3"
+
+	"github.com/giantswarm/logging-operator/pkg/common"
+	loggedcluster "github.com/giantswarm/logging-operator/pkg/logged-cluster"
+	loggingsecret "github.com/giantswarm/logging-operator/pkg/resource/logging-secret"
+)
+
+var (
+	//go:embed alloy/events-logger.alloy.template
+	alloyEvents         string
+	alloyEventsTemplate *template.Template
+
+	//go:embed alloy/events-logger-config.alloy.yaml.template
+	alloyEventsConfig         string
+	alloyEventsConfigTemplate *template.Template
+)
+
+func init() {
+	alloyEventsTemplate = template.Must(template.New("events-logger.alloy").Funcs(sprig.FuncMap()).Parse(alloyEvents))
+	alloyEventsConfigTemplate = template.Must(template.New("events-logger-config.alloy.yaml").Funcs(sprig.FuncMap()).Parse(alloyEventsConfig))
+}
+
+func generateAlloyEventsConfig(lc loggedcluster.Interface, defaultNamespaces []string) (string, error) {
+	var values bytes.Buffer
+
+	alloyConfig, err := generateAlloyConfig(lc, defaultNamespaces)
+	if err != nil {
+		return "", err
+	}
+
+	data := struct {
+		AlloyConfig string
+		SecretName  string
+	}{
+		AlloyConfig: alloyConfig,
+		SecretName:  common.AlloyEventsLoggerAppName,
+	}
+
+	err = alloyEventsConfigTemplate.Execute(&values, data)
+	if err != nil {
+		return "", err
+	}
+
+	return values.String(), nil
+}
+
+func generateAlloyConfig(lc loggedcluster.Interface, defaultNamespaces []string) (string, error) {
+	var values bytes.Buffer
+
+	data := struct {
+		ClusterID                   string
+		Installation                string
+		InsecureSkipVerify          string
+		MaxBackoffPeriod            string
+		LokiURLEnvVarName           string
+		TenantIDEnvVarName          string
+		BasicAuthUsernameEnvVarName string
+		BasicAuthPasswordEnvVarName string
+		ScrapedNamespaces           string
+	}{
+		ClusterID:                   lc.GetClusterName(),
+		Installation:                lc.GetInstallationName(),
+		InsecureSkipVerify:          fmt.Sprintf("%t", lc.IsInsecureCA()),
+		MaxBackoffPeriod:            common.MaxBackoffPeriod,
+		LokiURLEnvVarName:           loggingsecret.AlloyLokiURLEnvVarName,
+		TenantIDEnvVarName:          loggingsecret.AlloyTenantIDEnvVarName,
+		BasicAuthUsernameEnvVarName: loggingsecret.AlloyBasicAuthUsernameEnvVarName,
+		BasicAuthPasswordEnvVarName: loggingsecret.AlloyBasicAuthPasswordEnvVarName,
+		ScrapedNamespaces:           common.FormatScrapedNamespaces(lc, defaultNamespaces),
+	}
+
+	err := alloyEventsTemplate.Execute(&values, data)
+	if err != nil {
+		return "", err
+	}
+
+	return values.String(), nil
+}

pkg/resource/events-logger-config/alloy-events-config_test.go

@@ -0,0 +1,73 @@
+package eventsloggerconfig
+
+import (
+	_ "embed"
+	"os"
+	"path/filepath"
+	"testing"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	capi "sigs.k8s.io/cluster-api/api/v1beta1"
+
+	"github.com/google/go-cmp/cmp"
+
+	loggedcluster "github.com/giantswarm/logging-operator/pkg/logged-cluster"
+	"github.com/giantswarm/logging-operator/pkg/logged-cluster/capicluster"
+)
+
+func TestGenerateAlloyEventsConfig(t *testing.T) {
+	testCases := []struct {
+		goldenFile        string
+		defaultNamespaces []string
+		installationName  string
+		clusterName       string
+	}{
+		{
+			goldenFile:       "alloy/test/events-logger-config.alloy.MC.yaml",
+			installationName: "test-installation",
+			clusterName:      "test-installation",
+		},
+		{
+			goldenFile:       "alloy/test/events-logger-config.alloy.WC.yaml",
+			installationName: "test-installation",
+			clusterName:      "test-cluster",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(filepath.Base(tc.goldenFile), func(t *testing.T) {
+			golden, err := os.ReadFile(tc.goldenFile)
+			if err != nil {
+				t.Fatalf("Failed to read golden file: %v", err)
+			}
+
+			loggedCluster := &capicluster.Object{
+				Object: &capi.Cluster{
+					ObjectMeta: metav1.ObjectMeta{
+						Name: tc.clusterName,
+					},
+				},
+				Options: loggedcluster.Options{
+					InstallationName: tc.installationName,
+					KubeEventsLogger: "alloy",
+				},
+			}
+
+			config, err := generateAlloyEventsConfig(loggedCluster, []string{"kube-system", "giantswarm"})
+			if err != nil {
+				t.Fatalf("Failed to generate alloy config: %v", err)
+			}
+
+			if string(golden) != config {
+				t.Logf("Generated config differs from %s, diff:\n%s", tc.goldenFile, cmp.Diff(string(golden), config))
+				t.Fail()
+				if *update {
+					//nolint:gosec
+					if err := os.WriteFile(tc.goldenFile, []byte(config), 0644); err != nil {
+						t.Fatalf("Failed to update golden file: %v", err)
+					}
+				}
+			}
+		})
+	}
+}