Give controllers their own names and User-Agent

Signed-off-by: Nolan Brubaker <nolan@nbrubaker.com>

pkg/reconciler/apis/apibinding/apibinding_controller.go

@@ -51,7 +51,7 @@ import (
 )
 
 const (
-	controllerName = "kcp-apibinding"
+	ControllerName = "kcp-apibinding"
 )
 
 var (
@@ -71,7 +71,7 @@ func NewController(
 	temporaryRemoteShardApiResourceSchemaInformer apisinformers.APIResourceSchemaInformer, /*TODO(p0lyn0mial): replace with multi-shard informers*/
 	crdInformer apiextensionsinformers.CustomResourceDefinitionInformer,
 ) (*controller, error) {
-	queue := workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), controllerName)
+	queue := workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), ControllerName)
 
 	c := &controller{
 		queue:                queue,
@@ -130,7 +130,7 @@ func NewController(
 		commit:            committer.NewCommitter[*APIBinding, *APIBindingSpec, *APIBindingStatus](kcpClusterClient.ApisV1alpha1().APIBindings()),
 	}
 
-	logger := logging.WithReconciler(klog.Background(), controllerName)
+	logger := logging.WithReconciler(klog.Background(), ControllerName)
 	apiBindingInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
 		AddFunc:    func(obj interface{}) { c.enqueueAPIBinding(obj, logger, "") },
 		UpdateFunc: func(_, obj interface{}) { c.enqueueAPIBinding(obj, logger, "") },
@@ -342,7 +342,7 @@ func (c *controller) Start(ctx context.Context, numThreads int) {
 	defer runtime.HandleCrash()
 	defer c.queue.ShutDown()
 
-	logger := logging.WithReconciler(klog.FromContext(ctx), controllerName)
+	logger := logging.WithReconciler(klog.FromContext(ctx), ControllerName)
 	ctx = klog.NewContext(ctx, logger)
 	logger.Info("Starting controller")
 	defer logger.Info("Shutting down controller")
@@ -376,7 +376,7 @@ func (c *controller) processNextWorkItem(ctx context.Context) bool {
 	defer c.queue.Done(key)
 
 	if err := c.process(ctx, key); err != nil {
-		runtime.HandleError(fmt.Errorf("%q controller failed to sync %q, err: %w", controllerName, key, err))
+		runtime.HandleError(fmt.Errorf("%q controller failed to sync %q, err: %w", ControllerName, key, err))
 		c.queue.AddRateLimited(key)
 		return true
 	}

pkg/reconciler/apis/apibindingdeletion/apibinding_deletion_controller.go

@@ -51,7 +51,7 @@ import (
 )
 
 const (
-	controllerName = "kcp-apibindingdeletion"
+	ControllerName = "kcp-apibindingdeletion"
 
 	APIBindingFinalizer = "apis.kcp.dev/apibinding-finalizer"
 
@@ -75,7 +75,7 @@ func NewController(
 	kcpClusterClient kcpclient.Interface,
 	apiBindingInformer apisinformers.APIBindingInformer,
 ) *Controller {
-	queue := workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), controllerName)
+	queue := workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), ControllerName)
 
 	c := &Controller{
 		queue:             queue,
@@ -117,7 +117,7 @@ func (c *Controller) enqueue(obj interface{}) {
 		runtime.HandleError(err)
 		return
 	}
-	logger := logging.WithQueueKey(logging.WithReconciler(klog.Background(), controllerName), key)
+	logger := logging.WithQueueKey(logging.WithReconciler(klog.Background(), ControllerName), key)
 	logger.V(2).Info("queueing APIBinding")
 	c.queue.Add(key)
 }
@@ -126,7 +126,7 @@ func (c *Controller) Start(ctx context.Context, numThreads int) {
 	defer runtime.HandleCrash()
 	defer c.queue.ShutDown()
 
-	logger := logging.WithReconciler(klog.FromContext(ctx), controllerName)
+	logger := logging.WithReconciler(klog.FromContext(ctx), ControllerName)
 	ctx = klog.NewContext(ctx, logger)
 	logger.Info("Starting controller")
 	defer logger.Info("Shutting down controller")

pkg/reconciler/apis/apiexport/apiexport_controller.go

@@ -52,7 +52,7 @@ import (
 )
 
 const (
-	controllerName = "kcp-apiexport"
+	ControllerName = "kcp-apiexport"
 
 	DefaultIdentitySecretNamespace = "kcp-system"
 )
@@ -67,7 +67,7 @@ func NewController(
 	secretInformer coreinformers.SecretInformer,
 	apiBindingInformer apisinformers.APIBindingInformer,
 ) (*controller, error) {
-	queue := workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), controllerName)
+	queue := workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), ControllerName)
 
 	c := &controller{
 		queue:             queue,
@@ -209,7 +209,7 @@ func (c *controller) enqueueAPIExport(obj interface{}) {
 		return
 	}
 
-	logger := logging.WithQueueKey(logging.WithReconciler(klog.Background(), controllerName), key)
+	logger := logging.WithQueueKey(logging.WithReconciler(klog.Background(), ControllerName), key)
 	logger.V(4).Info("queueing APIExport")
 	c.queue.Add(key)
 }
@@ -221,7 +221,7 @@ func (c *controller) enqueueAllAPIExports(clusterWorkspaceShard interface{}) {
 		return
 	}
 
-	logger := logging.WithObject(logging.WithReconciler(klog.Background(), controllerName), clusterWorkspaceShard.(*tenancyv1alpha1.ClusterWorkspaceShard))
+	logger := logging.WithObject(logging.WithReconciler(klog.Background(), ControllerName), clusterWorkspaceShard.(*tenancyv1alpha1.ClusterWorkspaceShard))
 	for i := range list {
 		key, err := kcpcache.MetaClusterNamespaceKeyFunc(list[i])
 		if err != nil {
@@ -247,7 +247,7 @@ func (c *controller) enqueueSecret(obj interface{}) {
 		return
 	}
 
-	logger := logging.WithObject(logging.WithReconciler(klog.Background(), controllerName), obj.(*corev1.Secret))
+	logger := logging.WithObject(logging.WithReconciler(klog.Background(), ControllerName), obj.(*corev1.Secret))
 	for _, apiExport := range apiExports {
 		key, err := kcpcache.DeletionHandlingMetaClusterNamespaceKeyFunc(apiExport)
 		if err != nil {
@@ -270,7 +270,7 @@ func (c *controller) enqueueFromAPIBinding(obj interface{}) {
 		return
 	}
 
-	logger := logging.WithObject(logging.WithReconciler(klog.Background(), controllerName), binding)
+	logger := logging.WithObject(logging.WithReconciler(klog.Background(), ControllerName), binding)
 
 	if binding.Spec.Reference.Workspace == nil {
 		return
@@ -286,7 +286,7 @@ func (c *controller) Start(ctx context.Context, numThreads int) {
 	defer runtime.HandleCrash()
 	defer c.queue.ShutDown()
 
-	logger := logging.WithReconciler(klog.FromContext(ctx), controllerName)
+	logger := logging.WithReconciler(klog.FromContext(ctx), ControllerName)
 	ctx = klog.NewContext(ctx, logger)
 	logger.Info("Starting controller")
 	defer logger.Info("Shutting down controller")
@@ -320,7 +320,7 @@ func (c *controller) processNextWorkItem(ctx context.Context) bool {
 	defer c.queue.Done(key)
 
 	if err := c.process(ctx, key); err != nil {
-		runtime.HandleError(fmt.Errorf("%q controller failed to sync %q, err: %w", controllerName, key, err))
+		runtime.HandleError(fmt.Errorf("%q controller failed to sync %q, err: %w", ControllerName, key, err))
 		c.queue.AddRateLimited(key)
 		return true
 	}

pkg/reconciler/apis/apiresource/controller.go

@@ -44,7 +44,7 @@ import (
 )
 
 const clusterNameAndGVRIndexName = "clusterNameAndGVR"
-const controllerName = "kcp-apiresource"
+const ControllerName = "kcp-apiresource"
 
 func GetClusterNameAndGVRIndexKey(clusterName logicalcluster.Name, gvr metav1.GroupVersionResource) string {
 	return clusterName.String() + "$" + gvr.String()
@@ -295,7 +295,7 @@ func (c *Controller) Start(ctx context.Context, numThreads int) {
 	defer runtime.HandleCrash()
 	defer c.queue.ShutDown()
 
-	logger := logging.WithReconciler(klog.FromContext(ctx), controllerName)
+	logger := logging.WithReconciler(klog.FromContext(ctx), ControllerName)
 	ctx = klog.NewContext(ctx, logger)
 	logger.Info("Starting controller")
 	defer logger.Info("Shutting down controller")
@@ -334,7 +334,7 @@ func (c *Controller) processNextWorkItem(ctx context.Context) bool {
 	defer c.queue.Done(key)
 
 	if err := c.process(ctx, key); err != nil {
-		runtime.HandleError(fmt.Errorf("%q controller failed to sync %v, err: %w", controllerName, key, err))
+		runtime.HandleError(fmt.Errorf("%q controller failed to sync %v, err: %w", ControllerName, key, err))
 		c.queue.AddRateLimited(key)
 		return true
 	}

pkg/reconciler/apis/permissionclaimlabel/permissionclaimlabel_controller.go

@@ -49,7 +49,7 @@ import (
 )
 
 const (
-	controllerName = "kcp-permissionclaimlabel"
+	ControllerName = "kcp-permissionclaimlabel"
 )
 
 // NewController returns a new controller for handling permission claims for an APIBinding.
@@ -61,9 +61,9 @@ func NewController(
 	apiBindingInformer apisinformers.APIBindingInformer,
 	apiExportInformer apisinformers.APIExportInformer,
 ) (*controller, error) {
-	logger := logging.WithReconciler(klog.Background(), controllerName)
+	logger := logging.WithReconciler(klog.Background(), ControllerName)
 
-	queue := workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), controllerName)
+	queue := workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), ControllerName)
 
 	c := &controller{
 		queue:                queue,
@@ -124,7 +124,7 @@ func (c *controller) Start(ctx context.Context, numThreads int) {
 	defer runtime.HandleCrash()
 	defer c.queue.ShutDown()
 
-	logger := logging.WithReconciler(klog.FromContext(ctx), controllerName)
+	logger := logging.WithReconciler(klog.FromContext(ctx), ControllerName)
 	ctx = klog.NewContext(ctx, logger)
 	logger.Info("starting controller")
 	defer logger.Info("shutting down controller")
@@ -158,7 +158,7 @@ func (c *controller) processNextWorkItem(ctx context.Context) bool {
 	defer c.queue.Done(key)
 
 	if err := c.process(ctx, key); err != nil {
-		runtime.HandleError(fmt.Errorf("%q controller failed to sync %q, err: %w", controllerName, key, err))
+		runtime.HandleError(fmt.Errorf("%q controller failed to sync %q, err: %w", ControllerName, key, err))
 		c.queue.AddRateLimited(key)
 		return true
 	}

pkg/reconciler/apis/permissionclaimlabel/permissionclaimlabel_resource_controller.go

@@ -44,7 +44,7 @@ import (
 )
 
 const (
-	resourceControllerName = "kcp-resource-permissionclaimlabel"
+	ResourceControllerName = "kcp-resource-permissionclaimlabel"
 )
 
 // NewController returns a new controller for labeling resources for accepted permission claims.
@@ -63,15 +63,14 @@ func NewResourceController(
 	}
 
 	c := &resourceController{
-		queue:                  workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), resourceControllerName),
+		queue:                  workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), ResourceControllerName),
 		kcpClusterClient:       kcpClusterClient,
 		dynamicClusterClient:   dynamicClusterClient,
 		ddsif:                  dynamicDiscoverySharedInformerFactory,
 		permissionClaimLabeler: permissionclaim.NewLabeler(apiBindingInformer),
 	}
 
-	logger := logging.WithReconciler(klog.Background(), controllerName)
-
+	logger := logging.WithReconciler(klog.Background(), ControllerName)
 	c.ddsif.AddEventHandler(informer.GVREventHandlerFuncs{
 		AddFunc:    func(gvr schema.GroupVersionResource, obj interface{}) { c.enqueueForResource(logger, gvr, obj) },
 		UpdateFunc: func(gvr schema.GroupVersionResource, _, obj interface{}) { c.enqueueForResource(logger, gvr, obj) },
@@ -112,7 +111,7 @@ func (c *resourceController) Start(ctx context.Context, numThreads int) {
 	defer utilruntime.HandleCrash()
 	defer c.queue.ShutDown()
 
-	logger := logging.WithReconciler(klog.FromContext(ctx), resourceControllerName)
+	logger := logging.WithReconciler(klog.FromContext(ctx), ResourceControllerName)
 	ctx = klog.NewContext(ctx, logger)
 	logger.Info("starting controller")
 	defer logger.Info("shutting down controller")
@@ -146,7 +145,7 @@ func (c *resourceController) processNextWorkItem(ctx context.Context) bool {
 	defer c.queue.Done(key)
 
 	if err := c.process(ctx, key); err != nil {
-		utilruntime.HandleError(fmt.Errorf("%q controller failed to sync %q, err: %w", resourceControllerName, key, err))
+		utilruntime.HandleError(fmt.Errorf("%q controller failed to sync %q, err: %w", ResourceControllerName, key, err))
 		c.queue.AddRateLimited(key)
 		return true
 	}

pkg/reconciler/kubequota/kubequota_controller.go

@@ -49,7 +49,7 @@ import (
 )
 
 const (
-	controllerName = "kcp-kube-quota"
+	ControllerName = "kcp-kube-quota"
 )
 
 // Controller manages per-workspace resource quota controllers.
@@ -92,7 +92,7 @@ func NewController(
 	informersStarted <-chan struct{},
 ) (*Controller, error) {
 	c := &Controller{
-		queue: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), controllerName),
+		queue: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), ControllerName),
 
 		dynamicDiscoverySharedInformerFactory: dynamicDiscoverySharedInformerFactory,
 		kubeClusterClient:                     kubeClusterClient,
@@ -154,7 +154,7 @@ func (c *Controller) enqueue(obj interface{}) {
 		return
 	}
 
-	logger := logging.WithQueueKey(logging.WithReconciler(klog.Background(), controllerName), key)
+	logger := logging.WithQueueKey(logging.WithReconciler(klog.Background(), ControllerName), key)
 	logger.V(2).Info("queueing ClusterWorkspace")
 	c.queue.Add(key)
 }
@@ -164,7 +164,7 @@ func (c *Controller) Start(ctx context.Context, numThreads int) {
 	defer utilruntime.HandleCrash()
 	defer c.queue.ShutDown()
 
-	logger := logging.WithReconciler(klog.FromContext(ctx), controllerName)
+	logger := logging.WithReconciler(klog.FromContext(ctx), ControllerName)
 	ctx = klog.NewContext(ctx, logger)
 	logger.Info("Starting controller")
 	defer logger.Info("Shutting down controller")
@@ -200,7 +200,7 @@ func (c *Controller) processNextWorkItem(ctx context.Context) bool {
 	defer c.queue.Done(key)
 
 	if err := c.process(ctx, key); err != nil {
-		utilruntime.HandleError(fmt.Errorf("%q controller failed to sync %q, err: %w", controllerName, key, err))
+		utilruntime.HandleError(fmt.Errorf("%q controller failed to sync %q, err: %w", ControllerName, key, err))
 		c.queue.AddRateLimited(key)
 		return true
 	}

pkg/reconciler/scheduling/placement/placement_controller.go

@@ -50,9 +50,9 @@ import (
 )
 
 const (
-	controllerName      = "kcp-scheduling-placement"
-	byWorkspace         = controllerName + "-byWorkspace" // will go away with scoping
-	byLocationWorkspace = controllerName + "-byLocationWorkspace"
+	ControllerName      = "kcp-scheduling-placement"
+	byWorkspace         = ControllerName + "-byWorkspace" // will go away with scoping
+	byLocationWorkspace = ControllerName + "-byLocationWorkspace"
 )
 
 // NewController returns a new controller placing namespaces onto locations by create
@@ -63,7 +63,7 @@ func NewController(
 	locationInformer schedulinginformers.LocationInformer,
 	placementInformer schedulinginformers.PlacementInformer,
 ) (*controller, error) {
-	queue := workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), controllerName)
+	queue := workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), ControllerName)
 
 	c := &controller{
 		queue: queue,
@@ -176,14 +176,14 @@ func (c *controller) enqueuePlacement(obj interface{}) {
 		return
 	}
 
-	logger := logging.WithQueueKey(logging.WithReconciler(klog.Background(), controllerName), key)
+	logger := logging.WithQueueKey(logging.WithReconciler(klog.Background(), ControllerName), key)
 	logger.V(2).Info("queueing Placement")
 	c.queue.Add(key)
 }
 
 // enqueueNamespace enqueues all placements for the namespace.
 func (c *controller) enqueueNamespace(obj interface{}) {
-	logger := logging.WithReconciler(klog.Background(), controllerName)
+	logger := logging.WithReconciler(klog.Background(), ControllerName)
 	key, err := kcpcache.DeletionHandlingMetaClusterNamespaceKeyFunc(obj)
 	if err != nil {
 		runtime.HandleError(err)
@@ -211,7 +211,7 @@ func (c *controller) enqueueNamespace(obj interface{}) {
 }
 
 func (c *controller) enqueueLocation(obj interface{}) {
-	logger := logging.WithReconciler(klog.Background(), controllerName)
+	logger := logging.WithReconciler(klog.Background(), ControllerName)
 	key, err := kcpcache.DeletionHandlingMetaClusterNamespaceKeyFunc(obj)
 	if err != nil {
 		runtime.HandleError(err)
@@ -243,7 +243,7 @@ func (c *controller) Start(ctx context.Context, numThreads int) {
 	defer runtime.HandleCrash()
 	defer c.queue.ShutDown()
 
-	logger := logging.WithReconciler(klog.FromContext(ctx), controllerName)
+	logger := logging.WithReconciler(klog.FromContext(ctx), ControllerName)
 	ctx = klog.NewContext(ctx, logger)
 	logger.Info("Starting controller")
 	defer logger.Info("Shutting down controller")
@@ -277,7 +277,7 @@ func (c *controller) processNextWorkItem(ctx context.Context) bool {
 	defer c.queue.Done(key)
 
 	if err := c.process(ctx, key); err != nil {
-		runtime.HandleError(fmt.Errorf("%q controller failed to sync %q, err: %w", controllerName, key, err))
+		runtime.HandleError(fmt.Errorf("%q controller failed to sync %q, err: %w", ControllerName, key, err))
 		c.queue.AddRateLimited(key)
 		return true
 	}

pkg/reconciler/tenancy/bootstrap/bootstrap_controller.go

@@ -49,7 +49,7 @@ import (
 )
 
 const (
-	controllerNameBase = "kcp-clusterworkspacetypes-bootstrap"
+	ControllerNameBase = "kcp-clusterworkspacetypes-bootstrap"
 )
 
 func NewController(
@@ -62,7 +62,7 @@ func NewController(
 	bootstrap func(context.Context, discovery.DiscoveryInterface, dynamic.Interface, kcpclient.Interface, sets.String) error,
 	batteriesIncluded sets.String,
 ) (*controller, error) {
-	controllerName := fmt.Sprintf("%s-%s", controllerNameBase, workspaceType)
+	controllerName := fmt.Sprintf("%s-%s", ControllerNameBase, workspaceType)
 	queue := workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), controllerName)
 
 	c := &controller{