debug: add verbose informer logging

cmd/gateway/main.go

@@ -61,21 +61,27 @@ func main() {
 
 	// Start ServiceAdapter informer to watch CRDs (8.1 integration)
 	var informerMgr *serviceadapter.InformerManager
+	log.Printf("[INFORMER] Starting ServiceAdapter informer initialization")
 	if kubeConfig, err := rest.InClusterConfig(); err == nil {
+		log.Printf("[INFORMER] InClusterConfig succeeded")
 		if dynamicClient, err := dynamic.NewForConfig(kubeConfig); err == nil {
+			log.Printf("[INFORMER] Dynamic client created")
 			if informer, err := serviceadapter.NewInformerManager(dynamicClient, registry, "api"); err == nil {
+				log.Printf("[INFORMER] InformerManager created, calling Start()")
 				informerMgr = informer
 				if err := informer.Start(context.Background()); err != nil {
-					log.Printf("warning: failed to start ServiceAdapter informer: %v", err)
+					log.Printf("[INFORMER] ERROR: failed to start: %v", err)
+				} else {
+					log.Printf("[INFORMER] Start() completed successfully")
 				}
 			} else {
-				log.Printf("warning: failed to create ServiceAdapter informer: %v", err)
+				log.Printf("[INFORMER] ERROR: failed to create InformerManager: %v", err)
 			}
 		} else {
-			log.Printf("warning: failed to create dynamic client: %v", err)
+			log.Printf("[INFORMER] ERROR: failed to create dynamic client: %v", err)
 		}
 	} else {
-		log.Printf("warning: not running in cluster, ServiceAdapter CRDs won't be watched")
+		log.Printf("[INFORMER] ERROR: InClusterConfig failed: %v (running outside cluster)", err)
 	}
 
 	// Create router that handles health endpoints, X-Service (ServiceAdapter) routing,

internal/serviceadapter/informer.go

@@ -23,6 +23,7 @@ type InformerManager struct {
 
 // NewInformerManager creates a new informer that watches ServiceAdapters in the api namespace.
 func NewInformerManager(dynamicClient dynamic.Interface, registry *Registry, namespace string) (*InformerManager, error) {
+	log.Printf("[INFORMER] NewInformerManager called with namespace=%s", namespace)
 	if registry == nil {
 		return nil, fmt.Errorf("registry cannot be nil")
 	}
@@ -30,6 +31,7 @@ func NewInformerManager(dynamicClient dynamic.Interface, registry *Registry, nam
 	if namespace == "" {
 		namespace = "api"
 	}
+	log.Printf("[INFORMER] Using namespace: %s", namespace)
 
 	// ServiceAdapter GVR
 	gvr := schema.GroupVersionResource{
@@ -37,37 +39,50 @@ func NewInformerManager(dynamicClient dynamic.Interface, registry *Registry, nam
 		Version:  "v1",
 		Resource: "serviceadapters",
 	}
+	log.Printf("[INFORMER] GVR: %s/%s/%s", gvr.Group, gvr.Version, gvr.Resource)
 
 	// Create informer factory scoped to namespace
+	log.Printf("[INFORMER] Creating filtered informer factory")
 	factory := dynamicinformer.NewFilteredDynamicSharedInformerFactory(
 		dynamicClient,
 		30*time.Second,
 		namespace,
 		nil,
 	)
+	log.Printf("[INFORMER] Factory created")
 
 	// Get the informer for ServiceAdapters
+	log.Printf("[INFORMER] Getting informer for ServiceAdapters")
 	informer := factory.ForResource(gvr).Informer()
+	log.Printf("[INFORMER] Informer obtained")
 
 	// Add event handlers
+	log.Printf("[INFORMER] Adding event handlers")
 	_, err := informer.AddEventHandler(cache.ResourceEventHandlerFuncs{
 		AddFunc: func(obj interface{}) {
+			log.Printf("[INFORMER] AddFunc called")
 			unstructObj := obj.(*unstructured.Unstructured)
 			if adapter, err := parseServiceAdapter(unstructObj); err == nil {
+				log.Printf("[INFORMER] Parsed adapter: %s/%s", adapter.Namespace, adapter.ServiceName)
 				if registry.Add(adapter) == nil {
-					log.Printf("[INFO] ServiceAdapter added: %s/%s", adapter.Namespace, adapter.ServiceName)
+					log.Printf("[INFORMER] ServiceAdapter added: %s/%s", adapter.Namespace, adapter.ServiceName)
 				}
+			} else {
+				log.Printf("[INFORMER] ERROR parsing adapter: %v", err)
 			}
 		},
 		UpdateFunc: func(oldObj, newObj interface{}) {
+			log.Printf("[INFORMER] UpdateFunc called")
 			unstructObj := newObj.(*unstructured.Unstructured)
 			if adapter, err := parseServiceAdapter(unstructObj); err == nil {
+				log.Printf("[INFORMER] ServiceAdapter updated: %s/%s", adapter.Namespace, adapter.ServiceName)
 				if registry.Update(adapter) == nil {
-					log.Printf("[INFO] ServiceAdapter updated: %s/%s", adapter.Namespace, adapter.ServiceName)
+					log.Printf("[INFORMER] Update succeeded")
 				}
 			}
 		},
 		DeleteFunc: func(obj interface{}) {
+			log.Printf("[INFORMER] DeleteFunc called")
 			unstructObj, ok := obj.(*unstructured.Unstructured)
 			if !ok {
 				// Handle tombstone (for objects that were deleted)
@@ -83,10 +98,11 @@ func NewInformerManager(dynamicClient dynamic.Interface, registry *Registry, nam
 
 			if name, ok := unstructObj.Object["metadata"].(map[string]interface{})["name"]; ok {
 				registry.Delete(name.(string))
-				log.Printf("[INFO] ServiceAdapter deleted: %s", name)
+				log.Printf("[INFORMER] ServiceAdapter deleted: %s", name)
 			}
 		},
 	})
+	log.Printf("[INFORMER] Event handlers added")
 
 	if err != nil {
 		return nil, err
@@ -102,14 +118,29 @@ func NewInformerManager(dynamicClient dynamic.Interface, registry *Registry, nam
 
 // Start begins watching ServiceAdapter resources.
 func (im *InformerManager) Start(ctx context.Context) error {
+	log.Printf("[INFORMER] Start() called")
 	im.factory.Start(im.stopChan)
+	log.Printf("[INFORMER] Factory started, waiting for cache sync")
 
-	// Wait for informer cache to sync
+	// Wait for informer cache to sync with 30-second timeout
-	if !cache.WaitForCacheSync(im.stopChan, im.informer.HasSynced) {
+	done := make(chan bool, 1)
-		return fmt.Errorf("failed to sync ServiceAdapter informer cache")
+	go func() {
+		done <- cache.WaitForCacheSync(im.stopChan, im.informer.HasSynced)
+	}()
+
+	select {
+	case synced := <-done:
+		if !synced {
+			log.Printf("[INFORMER] ERROR: Failed to sync cache")
+			return fmt.Errorf("failed to sync ServiceAdapter informer cache")
+		}
+		log.Printf("[INFORMER] Cache synced successfully!")
+	case <-time.After(30 * time.Second):
+		log.Printf("[INFORMER] ERROR: Cache sync timed out after 30s")
+		return fmt.Errorf("timeout waiting for cache sync")
 	}
 
-	log.Printf("[INFO] ServiceAdapter informer started, synced from cluster")
+	log.Printf("[INFORMER] ServiceAdapter informer started, synced from cluster")
 	return nil
 }