feat: apibinding_controller is using a golang-commons logger now

Author: kekcleader

listener/controller/apibinding_controller.go

@@ -15,8 +15,8 @@ import (
 
 	kcpapis "github.com/kcp-dev/kcp/sdk/apis/apis/v1alpha1"
 
+	"github.com/openmfp/golang-commons/logger"
 	ctrl "sigs.k8s.io/controller-runtime"
-	"sigs.k8s.io/controller-runtime/pkg/log"
 )
 
 // APIBindingReconciler reconciles an APIBinding object
@@ -25,19 +25,22 @@ type APIBindingReconciler struct {
 	discoveryFactory    discoveryclient.Factory
 	apiSchemaResolver   apischema.Resolver
 	clusterPathResolver clusterpath.Resolver
+	log                 *logger.Logger
 }
 
 func NewAPIBindingReconciler(
 	ioHandler workspacefile.IOHandler,
 	discoveryFactory discoveryclient.Factory,
 	apiSchemaResolver apischema.Resolver,
 	clusterPathResolver clusterpath.Resolver,
+	log *logger.Logger,
 ) *APIBindingReconciler {
 	return &APIBindingReconciler{
 		ioHandler:           ioHandler,
 		discoveryFactory:    discoveryFactory,
 		apiSchemaResolver:   apiSchemaResolver,
 		clusterPathResolver: clusterPathResolver,
+		log:                 log,
 	}
 }
 
@@ -47,70 +50,69 @@ func (r *APIBindingReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 		return ctrl.Result{}, nil
 	}
 
-	logger := log.FromContext(ctx)
+	logger := r.log.With().Str("cluster", req.ClusterName).Str("name", req.Name).Logger()
 	clusterClt, err := r.clusterPathResolver.ClientForCluster(req.ClusterName)
 	if err != nil {
-		logger.Error(err, "failed to get cluster client", "cluster", req.ClusterName)
+		logger.Error().Err(err).Msg("failed to get cluster client")
 		return ctrl.Result{}, err
 	}
 	clusterPath, err := clusterpath.PathForCluster(req.ClusterName, clusterClt)
 	if err != nil {
 		if errors.Is(err, clusterpath.ErrClusterIsDeleted) {
-			logger.Info("cluster is deleted, triggering cleanup")
+			logger.Info().Msg("cluster is deleted, triggering cleanup")
 			if err = r.ioHandler.Delete(clusterPath); err != nil {
-				logger.Error(err, "failed to delete workspace file after cluster deletion")
+				logger.Error().Err(err).Msg("failed to delete workspace file after cluster deletion")
 				return ctrl.Result{}, err
 			}
 
 			return ctrl.Result{}, nil
 		}
-
-		logger.Error(err, "failed to get cluster path", "cluster", req.ClusterName)
+		logger.Error().Err(err).Msg("failed to get cluster path")
 		return ctrl.Result{}, err
 	}
 
-	logger = logger.WithValues("cluster", clusterPath)
-	logger.Info("starting reconciliation...")
+	logger = logger.With().Str("clusterPath", clusterPath).Logger()
+	logger.Info().Msg("starting reconciliation...")
 
 	dc, err := r.discoveryFactory.ClientForCluster(clusterPath)
 	if err != nil {
-		logger.Error(err, "failed to create discovery client for cluster")
+		logger.Error().Err(err).Msg("failed to create discovery client for cluster")
 		return ctrl.Result{}, err
 	}
 
 	rm, err := r.discoveryFactory.RestMapperForCluster(clusterPath)
 	if err != nil {
-		logger.Error(err, "failed to create rest mapper for cluster")
+		logger.Error().Err(err).Msg("failed to create rest mapper for cluster")
 		return ctrl.Result{}, err
 	}
 
 	savedJSON, err := r.ioHandler.Read(clusterPath)
 	if errors.Is(err, fs.ErrNotExist) {
 		actualJSON, err1 := r.apiSchemaResolver.Resolve(dc, rm)
 		if err1 != nil {
-			logger.Error(err1, "failed to resolve server JSON schema")
+			logger.Error().Err(err1).Msg("failed to resolve server JSON schema")
 			return ctrl.Result{}, err1
 		}
 		if err := r.ioHandler.Write(actualJSON, clusterPath); err != nil {
-			logger.Error(err, "failed to write JSON to filesystem")
+			logger.Error().Err(err).Msg("failed to write JSON to filesystem")
 			return ctrl.Result{}, err
 		}
 		return ctrl.Result{}, nil
 	}
 
 	if err != nil {
-		logger.Error(err, "failed to read JSON from filesystem")
+		logger.Error().Err(err).Msg("failed to read JSON from filesystem")
 		return ctrl.Result{}, err
 	}
 
 	actualJSON, err := r.apiSchemaResolver.Resolve(dc, rm)
 	if err != nil {
-		logger.Error(err, "failed to resolve server JSON schema")
+		logger.Error().Err(err).Msg("failed to resolve server JSON schema")
 		return ctrl.Result{}, err
 	}
 	if !bytes.Equal(actualJSON, savedJSON) {
 		if err := r.ioHandler.Write(actualJSON, clusterPath); err != nil {
-			logger.Error(err, "failed to write JSON to filesystem")
+			logger.Error().Err(err).Msg("failed to write JSON to filesystem")
 			return ctrl.Result{}, err
 		}
 	}

listener/controller/apibinding_controller_test.go

@@ -2,15 +2,17 @@ package controller_test
 
 import (
 	"context"
+	"testing"
+
 	kcpcore "github.com/kcp-dev/kcp/sdk/apis/core/v1alpha1"
 	"github.com/openmfp/kubernetes-graphql-gateway/listener/controller"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
-	"testing"
 
+	"github.com/openmfp/golang-commons/logger"
 	controllerRuntimeMocks "github.com/openmfp/kubernetes-graphql-gateway/gateway/resolver/mocks"
 	apischemaMocks "github.com/openmfp/kubernetes-graphql-gateway/listener/apischema/mocks"
 	clusterpathMocks "github.com/openmfp/kubernetes-graphql-gateway/listener/clusterpath/mocks"
@@ -68,8 +70,12 @@ func TestAPIBindingReconciler_Reconcile(t *testing.T) {
 				tt.mockSetup(ioHandler, discoveryFactory, apiSchemaResolver, clusterPathResolver)
 			}
 
-			r := controller.NewAPIBindingReconciler(ioHandler, discoveryFactory, apiSchemaResolver, clusterPathResolver)
-			_, err := r.Reconcile(context.Background(), ctrl.Request{ClusterName: tt.clusterName})
+			loggerCfg := logger.DefaultConfig()
+			loggerCfg.Name = "test-apibinding-reconciler"
+			log, err := logger.New(loggerCfg)
+			assert.NoError(t, err)
+			r := controller.NewAPIBindingReconciler(ioHandler, discoveryFactory, apiSchemaResolver, clusterPathResolver, log)
+			_, err = r.Reconcile(context.Background(), ctrl.Request{ClusterName: tt.clusterName})
 			assert.Equal(t, tt.err, err)
 		})
 	}