use labels and annotations instead of explcit config

Author: owais

cmd/operator-opamp-bridge/internal/config/config.go

@@ -74,17 +74,6 @@ const (
 	ReportsRemoteConfig            Capability = "ReportsRemoteConfig"
 )
 
-// TargetWorkload describes a Deployment or DaemonSet whose collector config
-// is managed via a ConfigMap. Used only in "standalone" mode.
-type TargetWorkload struct {
-	Name          string `yaml:"name"`
-	Namespace     string `yaml:"namespace"`
-	Kind          string `yaml:"kind"`
-	WorkloadName  string `yaml:"workloadName"`
-	ConfigMapName string `yaml:"configMapName"`
-	ConfigMapKey  string `yaml:"configMapKey"`
-}
-
 type Config struct {
 	// KubeConfigFilePath is empty if InClusterConfig() should be used, otherwise it's a path to where a valid
 	// kubernetes configuration file.
@@ -104,11 +93,8 @@ type Config struct {
 	AgentDescription  AgentDescription    `yaml:"description,omitempty"`
 
 	// Mode selects the operating mode: "operator" (default) uses OpenTelemetryCollector CRDs,
-	// "standalone" manages ConfigMaps for standard Deployments/DaemonSets.
+	// "standalone" discovers Deployments/DaemonSets by label and manages their ConfigMaps.
 	Mode string `yaml:"mode,omitempty"`
-
-	// Targets defines the workloads to manage in "standalone" mode.
-	Targets []TargetWorkload `yaml:"targets,omitempty"`
 }
 
 // AgentDescription is copied from the OpAMP Extension in the collector.
@@ -258,10 +244,6 @@ func (c *Config) IsStandaloneMode() bool {
 	return c.Mode == "standalone"
 }
 
-func (c *Config) GetTargets() []TargetWorkload {
-	return c.Targets
-}
-
 func Load(logger logr.Logger, args []string) (*Config, error) {
 	flagSet := GetFlagSet(pflag.ExitOnError)
 	err := flagSet.Parse(args)

cmd/operator-opamp-bridge/internal/workload/client.go

@@ -23,108 +23,143 @@ const (
 	managedByLabel    = "app.kubernetes.io/managed-by"
 	managedByValue    = "opamp-bridge"
 	restartAnnotation = "kubectl.kubernetes.io/restartedAt"
+
+	// ManagedLabelKey is the label that opts a Deployment or DaemonSet into standalone OpAMP ConfigMap management.
+	// Workloads must carry this label with value "true" to be discovered by the bridge.
+	ManagedLabelKey = "opentelemetry.io/opamp-standalone-configmap"
+
+	// AnnotationConfigMapName is a required annotation specifying the ConfigMap the bridge writes collector config into.
+	AnnotationConfigMapName = "opentelemetry.io/opamp-standalone-configmap-name"
+
+	// AnnotationConfigMapKey is an optional annotation specifying the key within the ConfigMap.
+	// Defaults to the workload name if not set.
+	AnnotationConfigMapKey = "opentelemetry.io/opamp-standalone-configmap-key"
 )
 
 var _ operator.ConfigApplier = &Client{}
 
-// TargetWorkload describes a Deployment or DaemonSet whose collector config
-// is managed via a ConfigMap.
-type TargetWorkload struct {
-	Name          string `yaml:"name"`
-	Namespace     string `yaml:"namespace"`
-	Kind          string `yaml:"kind"`
-	WorkloadName  string `yaml:"workloadName"`
-	ConfigMapName string `yaml:"configMapName"`
-	ConfigMapKey  string `yaml:"configMapKey"`
-}
-
 // Client implements operator.ConfigApplier for standalone Deployment/DaemonSet
-// workloads. Configuration is managed through ConfigMaps rather than CRDs.
+// workloads. It discovers targets dynamically via the ManagedLabelKey label and
+// reads ConfigMap details from annotations on the workload.
 type Client struct {
 	log       logr.Logger
 	k8sClient client.Client
-	targets   map[string]TargetWorkload
 	name      string
 }
 
-func NewClient(name string, log logr.Logger, c client.Client, targets []TargetWorkload) *Client {
-	targetMap := make(map[string]TargetWorkload, len(targets))
-	for _, t := range targets {
-		key := fmt.Sprintf("%s/%s", t.Namespace, t.Name)
-		targetMap[key] = t
-	}
+func NewClient(name string, log logr.Logger, c client.Client) *Client {
 	return &Client{
 		log:       log,
 		k8sClient: c,
-		targets:   targetMap,
 		name:      name,
 	}
 }
 
-func (c *Client) Apply(name, namespace string, configFile *protobufs.AgentConfigFile) error {
-	key := fmt.Sprintf("%s/%s", namespace, name)
-	target, ok := c.targets[key]
-	if !ok {
-		return fmt.Errorf("no target workload configured for %s", key)
+// resolveTarget looks up a Deployment or DaemonSet by name/namespace and returns
+// its ConfigMap name and key from annotations.
+func (c *Client) resolveTarget(ctx context.Context, name, namespace string) (configMapName, configMapKey string, workloadKind string, workloadName string, err error) {
+	// Try Deployment first
+	deploy := &appsv1.Deployment{}
+	if getErr := c.k8sClient.Get(ctx, client.ObjectKey{Name: name, Namespace: namespace}, deploy); getErr == nil {
+		if deploy.Labels[ManagedLabelKey] != "true" {
+			return "", "", "", "", fmt.Errorf("workload %s/%s does not have label %s=true", namespace, name, ManagedLabelKey)
+		}
+		cmName, cmKey := configMapDetailsFromAnnotations(deploy.Annotations, name)
+		return cmName, cmKey, "Deployment", name, nil
+	}
+
+	// Try DaemonSet
+	ds := &appsv1.DaemonSet{}
+	if getErr := c.k8sClient.Get(ctx, client.ObjectKey{Name: name, Namespace: namespace}, ds); getErr == nil {
+		if ds.Labels[ManagedLabelKey] != "true" {
+			return "", "", "", "", fmt.Errorf("workload %s/%s does not have label %s=true", namespace, name, ManagedLabelKey)
+		}
+		cmName, cmKey := configMapDetailsFromAnnotations(ds.Annotations, name)
+		return cmName, cmKey, "DaemonSet", name, nil
 	}
 
-	c.log.Info("Applying config", "name", name, "namespace", namespace, "configMap", target.ConfigMapName)
+	return "", "", "", "", fmt.Errorf("no managed Deployment or DaemonSet named %s found in namespace %s", name, namespace)
+}
+
+func configMapDetailsFromAnnotations(annotations map[string]string, defaultKey string) (cmName, cmKey string) {
+	cmName = annotations[AnnotationConfigMapName]
+	cmKey = annotations[AnnotationConfigMapKey]
+	if cmKey == "" {
+		cmKey = defaultKey
+	}
+	return
+}
 
+func (c *Client) Apply(name, namespace string, configFile *protobufs.AgentConfigFile) error {
 	if len(configFile.Body) == 0 {
 		return fmt.Errorf("invalid config to apply: config is empty")
 	}
 
 	ctx := context.Background()
 
+	configMapName, configMapKey, workloadKind, workloadName, err := c.resolveTarget(ctx, name, namespace)
+	if err != nil {
+		return err
+	}
+	if configMapName == "" {
+		return fmt.Errorf("workload %s/%s is missing annotation %s", namespace, name, AnnotationConfigMapName)
+	}
+
+	c.log.Info("Applying config", "name", name, "namespace", namespace, "configMap", configMapName)
+
 	cm := &v1.ConfigMap{}
-	err := c.k8sClient.Get(ctx, client.ObjectKey{
-		Name:      target.ConfigMapName,
-		Namespace: target.Namespace,
+	err = c.k8sClient.Get(ctx, client.ObjectKey{
+		Name:      configMapName,
+		Namespace: namespace,
 	}, cm)
 
 	if errors.IsNotFound(err) {
 		cm = &v1.ConfigMap{
 			ObjectMeta: metav1.ObjectMeta{
-				Name:      target.ConfigMapName,
-				Namespace: target.Namespace,
+				Name:      configMapName,
+				Namespace: namespace,
 				Labels: map[string]string{
 					managedByLabel: managedByValue,
 				},
 			},
 			Data: map[string]string{
-				target.ConfigMapKey: string(configFile.Body),
+				configMapKey: string(configFile.Body),
 			},
 		}
 		if createErr := c.k8sClient.Create(ctx, cm); createErr != nil {
-			return fmt.Errorf("failed to create ConfigMap %s/%s: %w", target.Namespace, target.ConfigMapName, createErr)
+			return fmt.Errorf("failed to create ConfigMap %s/%s: %w", namespace, configMapName, createErr)
 		}
 	} else if err != nil {
-		return fmt.Errorf("failed to get ConfigMap %s/%s: %w", target.Namespace, target.ConfigMapName, err)
+		return fmt.Errorf("failed to get ConfigMap %s/%s: %w", namespace, configMapName, err)
 	} else {
 		if cm.Data == nil {
 			cm.Data = map[string]string{}
 		}
-		cm.Data[target.ConfigMapKey] = string(configFile.Body)
+		cm.Data[configMapKey] = string(configFile.Body)
 		if updateErr := c.k8sClient.Update(ctx, cm); updateErr != nil {
-			return fmt.Errorf("failed to update ConfigMap %s/%s: %w", target.Namespace, target.ConfigMapName, updateErr)
+			return fmt.Errorf("failed to update ConfigMap %s/%s: %w", namespace, configMapName, updateErr)
 		}
 	}
 
-	return c.triggerRollout(ctx, target)
+	return c.triggerRollout(ctx, workloadKind, workloadName, namespace)
 }
 
 func (c *Client) Delete(name, namespace string) error {
-	key := fmt.Sprintf("%s/%s", namespace, name)
-	target, ok := c.targets[key]
-	if !ok {
+	ctx := context.Background()
+
+	configMapName, _, _, _, err := c.resolveTarget(ctx, name, namespace)
+	if err != nil {
+		// Workload no longer exists or isn't managed; nothing to delete.
+		return nil
+	}
+	if configMapName == "" {
 		return nil
 	}
 
-	ctx := context.Background()
 	cm := &v1.ConfigMap{}
-	err := c.k8sClient.Get(ctx, client.ObjectKey{
-		Name:      target.ConfigMapName,
-		Namespace: target.Namespace,
+	err = c.k8sClient.Get(ctx, client.ObjectKey{
+		Name:      configMapName,
+		Namespace: namespace,
 	}, cm)
 	if err != nil {
 		if errors.IsNotFound(err) {
@@ -139,14 +174,34 @@ func (c *Client) ListInstances() ([]operator.CollectorInstance, error) {
 	ctx := context.Background()
 	var result []operator.CollectorInstance
 
-	for _, target := range c.targets {
-		instance, err := c.getInstance(ctx, target)
+	managedLabel := client.MatchingLabels{ManagedLabelKey: "true"}
+
+	deployList := &appsv1.DeploymentList{}
+	if err := c.k8sClient.List(ctx, deployList, managedLabel); err != nil {
+		return nil, fmt.Errorf("failed to list managed Deployments: %w", err)
+	}
+	for i := range deployList.Items {
+		instance, err := c.getDeploymentInstance(ctx, &deployList.Items[i])
+		if err != nil {
+			c.log.Error(err, "Skipping Deployment", "name", deployList.Items[i].Name, "namespace", deployList.Items[i].Namespace)
+			continue
+		}
+		result = append(result, instance)
+	}
+
+	dsList := &appsv1.DaemonSetList{}
+	if err := c.k8sClient.List(ctx, dsList, managedLabel); err != nil {
+		return nil, fmt.Errorf("failed to list managed DaemonSets: %w", err)
+	}
+	for i := range dsList.Items {
+		instance, err := c.getDaemonSetInstance(ctx, &dsList.Items[i])
 		if err != nil {
-			c.log.Error(err, "Error getting target", "name", target.Name, "namespace", target.Namespace)
+			c.log.Error(err, "Skipping DaemonSet", "name", dsList.Items[i].Name, "namespace", dsList.Items[i].Namespace)
 			continue
 		}
 		result = append(result, instance)
 	}
+
 	return result, nil
 }
 
@@ -157,73 +212,62 @@ func (c *Client) GetCollectorPods(selectorLabels map[string]string, namespace st
 	return podList, err
 }
 
-func (c *Client) getInstance(ctx context.Context, target TargetWorkload) (*standaloneCollectorInstance, error) {
-	var selectorLabels map[string]string
-	var creationTimestamp time.Time
-	var statusReplicas string
+func (c *Client) getDeploymentInstance(ctx context.Context, deploy *appsv1.Deployment) (*standaloneCollectorInstance, error) {
+	cmName, cmKey := configMapDetailsFromAnnotations(deploy.Annotations, deploy.Name)
+	if cmName == "" {
+		return nil, fmt.Errorf("missing annotation %s on Deployment %s/%s", AnnotationConfigMapName, deploy.Namespace, deploy.Name)
+	}
 
-	switch target.Kind {
-	case "Deployment":
-		deploy := &appsv1.Deployment{}
-		if err := c.k8sClient.Get(ctx, client.ObjectKey{
-			Name:      target.WorkloadName,
-			Namespace: target.Namespace,
-		}, deploy); err != nil {
-			return nil, fmt.Errorf("failed to get Deployment %s/%s: %w", target.Namespace, target.WorkloadName, err)
-		}
-		selectorLabels = deploy.Spec.Selector.MatchLabels
-		creationTimestamp = deploy.GetCreationTimestamp().Time
-		var desired int32
-		if deploy.Spec.Replicas != nil {
-			desired = *deploy.Spec.Replicas
-		}
-		statusReplicas = fmt.Sprintf("%d/%d", deploy.Status.ReadyReplicas, desired)
+	var desired int32
+	if deploy.Spec.Replicas != nil {
+		desired = *deploy.Spec.Replicas
+	}
 
-	case "DaemonSet":
-		ds := &appsv1.DaemonSet{}
-		if err := c.k8sClient.Get(ctx, client.ObjectKey{
-			Name:      target.WorkloadName,
-			Namespace: target.Namespace,
-		}, ds); err != nil {
-			return nil, fmt.Errorf("failed to get DaemonSet %s/%s: %w", target.Namespace, target.WorkloadName, err)
-		}
-		selectorLabels = ds.Spec.Selector.MatchLabels
-		creationTimestamp = ds.GetCreationTimestamp().Time
-		statusReplicas = fmt.Sprintf("%d/%d", ds.Status.NumberReady, ds.Status.DesiredNumberScheduled)
+	var configBody []byte
+	cm := &v1.ConfigMap{}
+	if err := c.k8sClient.Get(ctx, client.ObjectKey{Name: cmName, Namespace: deploy.Namespace}, cm); err == nil && cm.Data != nil {
+		configBody = []byte(cm.Data[cmKey])
+	}
+
+	return &standaloneCollectorInstance{
+		name:           deploy.Name,
+		namespace:      deploy.Namespace,
+		createdAt:      deploy.GetCreationTimestamp().Time,
+		selectorLabels: deploy.Spec.Selector.MatchLabels,
+		statusReplicas: fmt.Sprintf("%d/%d", deploy.Status.ReadyReplicas, desired),
+		configBody:     configBody,
+	}, nil
+}
 
-	default:
-		return nil, fmt.Errorf("unsupported workload kind: %s", target.Kind)
+func (c *Client) getDaemonSetInstance(ctx context.Context, ds *appsv1.DaemonSet) (*standaloneCollectorInstance, error) {
+	cmName, cmKey := configMapDetailsFromAnnotations(ds.Annotations, ds.Name)
+	if cmName == "" {
+		return nil, fmt.Errorf("missing annotation %s on DaemonSet %s/%s", AnnotationConfigMapName, ds.Namespace, ds.Name)
 	}
 
 	var configBody []byte
 	cm := &v1.ConfigMap{}
-	if err := c.k8sClient.Get(ctx, client.ObjectKey{
-		Name:      target.ConfigMapName,
-		Namespace: target.Namespace,
-	}, cm); err == nil && cm.Data != nil {
-		configBody = []byte(cm.Data[target.ConfigMapKey])
+	if err := c.k8sClient.Get(ctx, client.ObjectKey{Name: cmName, Namespace: ds.Namespace}, cm); err == nil && cm.Data != nil {
+		configBody = []byte(cm.Data[cmKey])
 	}
 
 	return &standaloneCollectorInstance{
-		name:           target.Name,
-		namespace:      target.Namespace,
-		createdAt:      creationTimestamp,
-		selectorLabels: selectorLabels,
-		statusReplicas: statusReplicas,
+		name:           ds.Name,
+		namespace:      ds.Namespace,
+		createdAt:      ds.GetCreationTimestamp().Time,
+		selectorLabels: ds.Spec.Selector.MatchLabels,
+		statusReplicas: fmt.Sprintf("%d/%d", ds.Status.NumberReady, ds.Status.DesiredNumberScheduled),
 		configBody:     configBody,
 	}, nil
 }
 
-func (c *Client) triggerRollout(ctx context.Context, target TargetWorkload) error {
+func (c *Client) triggerRollout(ctx context.Context, kind, name, namespace string) error {
 	restartVal := time.Now().Format(time.RFC3339)
 
-	switch target.Kind {
+	switch kind {
 	case "Deployment":
 		deploy := &appsv1.Deployment{}
-		if err := c.k8sClient.Get(ctx, client.ObjectKey{
-			Name:      target.WorkloadName,
-			Namespace: target.Namespace,
-		}, deploy); err != nil {
+		if err := c.k8sClient.Get(ctx, client.ObjectKey{Name: name, Namespace: namespace}, deploy); err != nil {
 			return fmt.Errorf("failed to get Deployment for rollout: %w", err)
 		}
 		if deploy.Spec.Template.ObjectMeta.Annotations == nil {
@@ -234,10 +278,7 @@ func (c *Client) triggerRollout(ctx context.Context, target TargetWorkload) erro
 
 	case "DaemonSet":
 		ds := &appsv1.DaemonSet{}
-		if err := c.k8sClient.Get(ctx, client.ObjectKey{
-			Name:      target.WorkloadName,
-			Namespace: target.Namespace,
-		}, ds); err != nil {
+		if err := c.k8sClient.Get(ctx, client.ObjectKey{Name: name, Namespace: namespace}, ds); err != nil {
 			return fmt.Errorf("failed to get DaemonSet for rollout: %w", err)
 		}
 		if ds.Spec.Template.ObjectMeta.Annotations == nil {