feat: robust logging

On-behalf-of: @SAP [email protected]
Signed-off-by: Artem Shcherbatiuk <[email protected]>

Author: vertex451

cmd/listener.go

@@ -105,7 +105,7 @@ var listenCmd = &cobra.Command{
 		// Create the appropriate reconciler based on configuration
 		var reconcilerInstance reconciler.CustomReconciler
 		if appCfg.EnableKcp {
-			kcpReconciler, err := kcp.NewKCPReconciler(appCfg, reconcilerOpts, log)
+			kcpReconciler, err := kcp.NewKCPReconciler(appCfg, reconcilerOpts, *log)
 			if err != nil {
 				log.Error().Err(err).Msg("unable to create KCP reconciler")
 				os.Exit(1)
@@ -123,7 +123,7 @@ var listenCmd = &cobra.Command{
 
 			reconcilerInstance = kcpReconciler
 		} else {
-			reconcilerInstance, err = clusteraccess.CreateMultiClusterReconciler(appCfg, reconcilerOpts, log)
+			reconcilerInstance, err = clusteraccess.NewClusterAccessReconciler(ctx, appCfg, reconcilerOpts, nil, nil, *log)
 			if err != nil {
 				log.Error().Err(err).Msg("unable to create cluster access reconciler")
 				os.Exit(1)

go.mod

@@ -34,6 +34,7 @@ require (
 	github.com/stretchr/testify v1.10.0
 	go.opentelemetry.io/otel v1.37.0
 	go.opentelemetry.io/otel/trace v1.37.0
+	golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b
 	gopkg.in/yaml.v3 v3.0.1
 	k8s.io/api v0.33.2
 	k8s.io/apiextensions-apiserver v0.32.4
@@ -116,7 +117,6 @@ require (
 	go.yaml.in/yaml/v2 v2.4.2 // indirect
 	go.yaml.in/yaml/v3 v3.0.3 // indirect
 	golang.org/x/crypto v0.39.0 // indirect
-	golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b // indirect
 	golang.org/x/net v0.41.0 // indirect
 	golang.org/x/oauth2 v0.30.0 // indirect
 	golang.org/x/sync v0.15.0 // indirect

listener/pkg/apischema/builder.go

@@ -4,22 +4,21 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"maps"
 	"slices"
 	"strings"
 
-	"k8s.io/apimachinery/pkg/api/meta"
-	"sigs.k8s.io/controller-runtime/pkg/client/apiutil"
-
 	"github.com/hashicorp/go-multierror"
-	"github.com/openmfp/golang-commons/logger"
-	"github.com/openmfp/kubernetes-graphql-gateway/common"
+	"golang.org/x/exp/maps"
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
+	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	k8sschema "k8s.io/apimachinery/pkg/runtime/schema"
 	runtimeSchema "k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/client-go/openapi"
 	"k8s.io/kube-openapi/pkg/validation/spec"
+	"sigs.k8s.io/controller-runtime/pkg/client/apiutil"
+
+	"github.com/openmfp/golang-commons/logger"
+	"github.com/openmfp/kubernetes-graphql-gateway/common"
 )
 
 var (
@@ -33,18 +32,19 @@ var (
 	ErrUnmarshalGVK         = errors.New("failed to unmarshal GVK extension")
 )
 
-// SchemaBuilder helps construct GraphQL field config arguments
 type SchemaBuilder struct {
 	schemas map[string]*spec.Schema
 	err     *multierror.Error
-	log     *logger.Logger
+	log     logger.Logger
 }
 
 func NewSchemaBuilder(oc openapi.Client, preferredApiGroups []string) *SchemaBuilder {
-	return NewSchemaBuilderWithLogger(oc, preferredApiGroups, nil)
+	// Create a default logger if none provided
+	defaultLogPtr, _ := logger.New(logger.DefaultConfig())
+	return NewSchemaBuilderWithLogger(oc, preferredApiGroups, *defaultLogPtr)
 }
 
-func NewSchemaBuilderWithLogger(oc openapi.Client, preferredApiGroups []string, log *logger.Logger) *SchemaBuilder {
+func NewSchemaBuilderWithLogger(oc openapi.Client, preferredApiGroups []string, log logger.Logger) *SchemaBuilder {
 	b := &SchemaBuilder{
 		schemas: make(map[string]*spec.Schema),
 		log:     log,
@@ -59,9 +59,7 @@ func NewSchemaBuilderWithLogger(oc openapi.Client, preferredApiGroups []string,
 	for path, gv := range apiv3Paths {
 		schema, err := getSchemaForPath(preferredApiGroups, path, gv)
 		if err != nil {
-			if b.log != nil {
-				b.log.Debug().Err(err).Str("path", path).Msg("skipping schema path")
-			}
+			b.log.Debug().Err(err).Str("path", path).Msg("skipping schema path")
 			continue
 		}
 		maps.Copy(b.schemas, schema)
@@ -100,26 +98,22 @@ func (b *SchemaBuilder) WithScope(rm meta.RESTMapper) *SchemaBuilder {
 		}
 
 		if len(gvks) != 1 {
-			if b.log != nil {
-				b.log.Debug().Int("gvkCount", len(gvks)).Msg("skipping schema with unexpected GVK count")
-			}
+			b.log.Debug().Int("gvkCount", len(gvks)).Msg("skipping schema with unexpected GVK count")
 			continue
 		}
 
-		namespaced, err := apiutil.IsGVKNamespaced(k8sschema.GroupVersionKind{
+		namespaced, err := apiutil.IsGVKNamespaced(runtimeSchema.GroupVersionKind{
 			Group:   gvks[0].Group,
 			Version: gvks[0].Version,
 			Kind:    gvks[0].Kind,
 		}, rm)
 
 		if err != nil {
-			if b.log != nil {
-				b.log.Debug().Err(err).
-					Str("group", gvks[0].Group).
-					Str("version", gvks[0].Version).
-					Str("kind", gvks[0].Kind).
-					Msg("failed to determine if GVK is namespaced")
-			}
+			b.log.Debug().Err(err).
+				Str("group", gvks[0].Group).
+				Str("version", gvks[0].Version).
+				Str("kind", gvks[0].Kind).
+				Msg("failed to determine if GVK is namespaced")
 			continue
 		}
 

listener/pkg/apischema/crd_resolver.go

@@ -3,6 +3,7 @@ package apischema
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"slices"
 	"strings"
 
@@ -49,7 +50,7 @@ func (cr *CRDResolver) ResolveApiSchema(crd *apiextensionsv1.CustomResourceDefin
 		return nil, errors.Join(ErrGetServerPreferred, err)
 	}
 
-	preferredApiGroups, err := errorIfCRDNotInPreferredApiGroups(gkv, apiResLists, nil)
+	preferredApiGroups, err := errorIfCRDNotInPreferredApiGroups(gkv, apiResLists, mustCreateLogger())
 	if err != nil {
 		return nil, errors.Join(ErrFilterPreferredResources, err)
 	}
@@ -60,28 +61,33 @@ func (cr *CRDResolver) ResolveApiSchema(crd *apiextensionsv1.CustomResourceDefin
 		Complete()
 }
 
-func errorIfCRDNotInPreferredApiGroups(gkv *GroupKindVersions, apiResLists []*metav1.APIResourceList, log *logger.Logger) ([]string, error) {
-	isKindFound := false
-	preferredApiGroups := make([]string, 0, len(apiResLists))
-	for _, apiResources := range apiResLists {
-		gv, err := schema.ParseGroupVersion(apiResources.GroupVersion)
-		if err != nil {
-			if log != nil {
-				log.Error().Err(err).Str("groupVersion", apiResources.GroupVersion).Msg("failed to parse group version")
+func errorIfCRDNotInPreferredApiGroups(gkv *GroupKindVersions, apiResLists []*metav1.APIResourceList, log logger.Logger) ([]string, error) {
+	groupVersionStrings := make([]string, 0, len(gkv.Versions))
+	for _, version := range gkv.Versions {
+		gv := schema.GroupVersion{Group: gkv.Group, Version: version}
+		gvString := gv.String()
+		groupVersionStrings = append(groupVersionStrings, gvString)
+		log.Debug().Str("groupVersion", gvString).Msg("checking if CRD group version is in preferred APIs")
+		found := false
+		for _, apiResList := range apiResLists {
+			if apiResList.GroupVersion == gvString {
+				found = true
+				break
 			}
-			continue
 		}
-		isGroupFound := gkv.Group == gv.Group
-		isVersionFound := slices.Contains(gkv.Versions, gv.Version)
-		if isGroupFound && isVersionFound && !isKindFound {
-			isKindFound = isCRDKindIncluded(gkv, apiResources)
+		if !found {
+			return groupVersionStrings, fmt.Errorf("CRD group version %s is not in preferred APIs", gvString)
 		}
-		preferredApiGroups = append(preferredApiGroups, apiResources.GroupVersion)
 	}
-	if !isKindFound {
-		return nil, ErrGVKNotPreferred
+	return groupVersionStrings, nil
+}
+
+func mustCreateLogger() logger.Logger {
+	logPtr, err := logger.New(logger.DefaultConfig())
+	if err != nil {
+		panic(fmt.Sprintf("failed to create default logger: %v", err))
 	}
-	return preferredApiGroups, nil
+	return *logPtr
 }
 
 func isCRDKindIncluded(gvk *GroupKindVersions, apiResources *metav1.APIResourceList) bool {

listener/reconciler/clusteraccess/export_test_integration.go

@@ -1,15 +1,20 @@
 package clusteraccess
 
-// Integration testing exports for cross-package access
-// Unit tests within this package should use export_test.go instead
+import (
+	"context"
 
-// ClusterAccessReconcilerPublic exposes the reconciler for integration testing
-type ClusterAccessReconcilerPublic = ClusterAccessReconciler
+	"github.com/openmfp/golang-commons/logger"
+	gatewayv1alpha1 "github.com/openmfp/kubernetes-graphql-gateway/common/apis/v1alpha1"
+)
 
-// GenerateSchemaSubroutinePublic exposes the subroutine for integration testing
-type GenerateSchemaSubroutinePublic = generateSchemaSubroutine
+// This file exports internal functions for integration testing
 
-// NewGenerateSchemaSubroutineForTesting creates a new subroutine for integration testing
-func NewGenerateSchemaSubroutineForTesting(reconciler *ClusterAccessReconciler) *GenerateSchemaSubroutinePublic {
-	return &generateSchemaSubroutine{reconciler: reconciler}
+// For integration tests that need access to schema generation functionality
+func GenerateSchemaForClusterAccessForTesting(
+	ctx context.Context,
+	clusterAccess gatewayv1alpha1.ClusterAccess,
+	reconcilerInstance *ClusterAccessReconciler,
+	log logger.Logger,
+) error {
+	return generateSchemaForClusterAccess(ctx, clusterAccess, reconcilerInstance, log)
 }

listener/reconciler/clusteraccess/metadata_injector.go

@@ -10,7 +10,7 @@ import (
 	"github.com/openmfp/kubernetes-graphql-gateway/common/auth"
 )
 
-func injectClusterMetadata(ctx context.Context, schemaJSON []byte, clusterAccess gatewayv1alpha1.ClusterAccess, k8sClient client.Client, log *logger.Logger) ([]byte, error) {
+func injectClusterMetadata(ctx context.Context, schemaJSON []byte, clusterAccess gatewayv1alpha1.ClusterAccess, k8sClient client.Client, log logger.Logger) ([]byte, error) {
 	// Determine the path
 	path := clusterAccess.Spec.Path
 	if path == "" {
@@ -26,5 +26,5 @@ func injectClusterMetadata(ctx context.Context, schemaJSON []byte, clusterAccess
 	}
 
 	// Use the common metadata injection function
-	return auth.InjectClusterMetadata(ctx, schemaJSON, config, k8sClient, log)
+	return auth.InjectClusterMetadata(ctx, schemaJSON, config, k8sClient, &log)
 }