Add Namespace Source instrumentation

api/odigos/v1alpha1/source_types.go

@@ -78,6 +78,23 @@ func GetSourceListForWorkload(ctx context.Context, kubeClient client.Client, obj
 		consts.WorkloadKindLabel:      obj.GetObjectKind().GroupVersionKind().Kind,
 	})
 	err := kubeClient.List(ctx, &sourceList, &client.ListOptions{LabelSelector: selector})
+	if err != nil {
+		return sourceList, err
+	}
+
+	namespaceSourceList := SourceList{}
+	namespaceSelector := labels.SelectorFromSet(labels.Set{
+		consts.WorkloadNameLabel:      obj.GetNamespace(),
+		consts.WorkloadNamespaceLabel: obj.GetNamespace(),
+		consts.WorkloadKindLabel:      "Namespace",
+	})
+	err = kubeClient.List(ctx, &namespaceSourceList, &client.ListOptions{LabelSelector: namespaceSelector})
+	if err != nil {
+		return sourceList, err
+	}
+
+	// merge the lists
+	sourceList.Items = append(sourceList.Items, namespaceSourceList.Items...)
 	return sourceList, err
 }
 

common/consts/consts.go

@@ -18,6 +18,7 @@ const (
 	OdigosNamespaceAnnotation    = "odigos.io/workload-namespace"
 	OdigosWorkloadKindAnnotation = "odigos.io/workload-kind"
 	OdigosWorkloadNameAnnotation = "odigos.io/workload-name"
+	OdigosWorkloadExcludedLabel  = "odigos.io/excluded"
 	OdigosReportedNameAnnotation = "odigos.io/reported-name"
 
 	// GatewayMaxConnectionAge and GatewayMaxConnectionAgeGrace are the default values for the gateway collector.

instrumentor/controllers/deleteinstrumentedapplication/common.go

@@ -22,14 +22,18 @@ func reconcileWorkloadObject(ctx context.Context, kubeClient client.Client, work
 	}
 
 	if instEffectiveEnabled {
-		// Check if a Source object exists for this workload
-		sourceList, err := v1alpha1.GetSourceListForWorkload(ctx, kubeClient, workloadObject)
-		if err != nil {
-			return err
-		}
-		if len(sourceList.Items) == 0 {
-			return nil
-		}
+		return nil
+	}
+
+	// Check if a Source object exists for this workload
+	sourceList, err := v1alpha1.GetSourceListForWorkload(ctx, kubeClient, workloadObject)
+	if err != nil {
+		return err
+	}
+	if len(sourceList.Items) > 0 {
+		// Note that if a Source is being deleted, but still has the finalizer, it will still show up in this List
+		// So we can't use this check to trigger un-instrumentation via Source deletion
+		return nil
 	}
 
 	if err := deleteWorkloadInstrumentedApplication(ctx, kubeClient, workloadObject); err != nil {
@@ -46,11 +50,12 @@ func reconcileWorkloadObject(ctx context.Context, kubeClient client.Client, work
 }
 
 func deleteWorkloadInstrumentedApplication(ctx context.Context, kubeClient client.Client, workloadObject client.Object) error {
-
+	logger := log.FromContext(ctx)
 	ns := workloadObject.GetNamespace()
 	name := workloadObject.GetName()
 	kind := workload.WorkloadKindFromClientObject(workloadObject)
 	instrumentedApplicationName := workload.CalculateWorkloadRuntimeObjectName(name, kind)
+	logger.V(1).Info("deleting instrumented application", "name", instrumentedApplicationName, "kind", kind)
 
 	instAppErr := kubeClient.Delete(ctx, &odigosv1.InstrumentedApplication{
 		ObjectMeta: metav1.ObjectMeta{
@@ -73,7 +78,6 @@ func deleteWorkloadInstrumentedApplication(ctx context.Context, kubeClient clien
 		return client.IgnoreNotFound(instConfigErr)
 	}
 
-	logger := log.FromContext(ctx)
 	logger.V(1).Info("instrumented application deleted", "namespace", ns, "name", name, "kind", kind)
 	return nil
 }

instrumentor/controllers/deleteinstrumentedapplication/namespace_controller.go

@@ -20,6 +20,7 @@ import (
 	"context"
 	"errors"
 
+	"github.com/odigos-io/odigos/api/odigos/v1alpha1"
 	"github.com/odigos-io/odigos/common/consts"
 	"github.com/odigos-io/odigos/k8sutils/pkg/workload"
 
@@ -137,7 +138,6 @@ func (r *NamespaceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 }
 
 func syncGenericWorkloadListToNs(ctx context.Context, c client.Client, kind workload.WorkloadKind, key client.ObjectKey) error {
-
 	// it is very important that we make the changes based on a fresh copy of the workload object
 	// if a list operation pulled in state and is now slowly iterating over it, we might be working with stale data
 	freshWorkloadCopy := workload.ClientObjectFromWorkloadKind(kind)
@@ -151,11 +151,14 @@ func syncGenericWorkloadListToNs(ctx context.Context, c client.Client, kind work
 		}
 	}
 
-	if !isInheritingInstrumentationFromNs(freshWorkloadCopy) {
+	inheriting, err := isInheritingInstrumentationFromNs(ctx, c, freshWorkloadCopy)
+	if err != nil {
+		return err
+	}
+	if !inheriting {
 		return nil
 	}
 
-	var err error
 	err = errors.Join(err, deleteWorkloadInstrumentedApplication(ctx, c, freshWorkloadCopy))
 	err = errors.Join(err, removeReportedNameAnnotation(ctx, c, freshWorkloadCopy))
 	return err
@@ -165,11 +168,23 @@ func syncGenericWorkloadListToNs(ctx context.Context, c client.Client, kind work
 // when reconciling the namespace, the usecase is to delete instrumentation for workloads that were only
 // instrumented due to the label on the namespace. These are workloads with the label missing.
 // (they inherit the instrumentation from the namespace this way)
-func isInheritingInstrumentationFromNs(obj client.Object) bool {
+func isInheritingInstrumentationFromNs(ctx context.Context, c client.Client, obj client.Object) (bool, error) {
+	sourceList, err := v1alpha1.GetSourceListForWorkload(ctx, c, obj)
+	if err != nil {
+		return false, err
+	}
+	for _, source := range sourceList.Items {
+		// if a source exists for this workload specifically, then it is not inheriting from Namespace
+		if source.Spec.Workload.Name == obj.GetName() &&
+			source.Spec.Workload.Kind == workload.WorkloadKind(obj.GetObjectKind().GroupVersionKind().Kind) {
+			return false, nil
+		}
+	}
+
 	labels := obj.GetLabels()
 	if labels == nil {
-		return true
+		return true, nil
 	}
 	_, exists := labels[consts.OdigosInstrumentationLabel]
-	return !exists
+	return !exists, nil
 }

instrumentor/controllers/deleteinstrumentedapplication/source_controller.go

@@ -18,11 +18,14 @@ package deleteinstrumentedapplication
 
 import (
 	"context"
+	"errors"
 
 	"github.com/odigos-io/odigos/api/odigos/v1alpha1"
 	"github.com/odigos-io/odigos/k8sutils/pkg/consts"
+	k8sutils "github.com/odigos-io/odigos/k8sutils/pkg/utils"
 	"github.com/odigos-io/odigos/k8sutils/pkg/workload"
 
+	appsv1 "k8s.io/api/apps/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
 	ctrl "sigs.k8s.io/controller-runtime"
@@ -38,7 +41,7 @@ type SourceReconciler struct {
 
 func (r *SourceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
 	logger := log.FromContext(ctx)
-	logger.Info("Reconciling Deleted Source object", "name", req.Name, "namespace", req.Namespace)
+	logger.Info("Reconciling Source object", "name", req.Name, "namespace", req.Namespace)
 
 	source := &v1alpha1.Source{}
 	err := r.Get(ctx, req.NamespacedName, source)
@@ -48,24 +51,86 @@ func (r *SourceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctr
 
 	if !source.DeletionTimestamp.IsZero() {
 		logger.Info("Reconciling workload for deleted Source object", "name", req.Name, "namespace", req.Namespace)
-		obj := workload.ClientObjectFromWorkloadKind(source.Spec.Workload.Kind)
-		err = r.Client.Get(ctx, types.NamespacedName{Name: source.Spec.Workload.Name, Namespace: source.Spec.Workload.Namespace}, obj)
-		if err != nil {
-			// TODO: Deleted objects should be filtered in the event filter
-			return ctrl.Result{}, err
+		if source.Spec.Workload.Kind == "Namespace" {
+			logger.V(2).Info("Uninstrumenting deployments for Namespace Source", "name", req.Name, "namespace", req.Namespace)
+			var deps appsv1.DeploymentList
+			err = r.Client.List(ctx, &deps, client.InNamespace(req.Namespace))
+			if client.IgnoreNotFound(err) != nil {
+				logger.Error(err, "error fetching deployments")
+				return ctrl.Result{}, err
+			}
+
+			for _, dep := range deps.Items {
+				logger.V(4).Info("uninstrumenting deployment", "name", dep.Name, "namespace", dep.Namespace)
+				err := syncGenericWorkloadListToNs(ctx, r.Client, workload.WorkloadKindDeployment, client.ObjectKey{Namespace: dep.Namespace, Name: dep.Name})
+				if err != nil {
+					return ctrl.Result{}, err
+				}
+			}
+
+			logger.V(2).Info("Uninstrumenting statefulsets for Namespace Source", "name", req.Name, "namespace", req.Namespace)
+			var ss appsv1.StatefulSetList
+			err = r.Client.List(ctx, &ss, client.InNamespace(req.Namespace))
+			if client.IgnoreNotFound(err) != nil {
+				logger.Error(err, "error fetching statefulsets")
+				return ctrl.Result{}, err
+			}
+
+			for _, s := range ss.Items {
+				logger.V(4).Info("uninstrumenting statefulset", "name", s.Name, "namespace", s.Namespace)
+				err := syncGenericWorkloadListToNs(ctx, r.Client, workload.WorkloadKindStatefulSet, client.ObjectKey{Namespace: s.Namespace, Name: s.Name})
+				if err != nil {
+					return ctrl.Result{}, err
+				}
+			}
+
+			logger.V(2).Info("Uninstrumenting daemonsets for Namespace Source", "name", req.Name, "namespace", req.Namespace)
+			var ds appsv1.DaemonSetList
+			err = r.Client.List(ctx, &ds, client.InNamespace(req.Namespace))
+			if client.IgnoreNotFound(err) != nil {
+				logger.Error(err, "error fetching daemonsets")
+				return ctrl.Result{}, err
+			}
+
+			for _, d := range ds.Items {
+				logger.V(4).Info("uninstrumenting daemonset", "name", d.Name, "namespace", d.Namespace)
+				err := syncGenericWorkloadListToNs(ctx, r.Client, workload.WorkloadKindDaemonSet, client.ObjectKey{Namespace: d.Namespace, Name: d.Name})
+				if err != nil {
+					return ctrl.Result{}, err
+				}
+			}
+		} else {
+			// This is a Source for a specific workload, not an entire namespace
+			obj := workload.ClientObjectFromWorkloadKind(source.Spec.Workload.Kind)
+			err = r.Client.Get(ctx, types.NamespacedName{Name: source.Spec.Workload.Name, Namespace: source.Spec.Workload.Namespace}, obj)
+			if err != nil {
+				// TODO: Deleted objects should be filtered in the event filter
+				return ctrl.Result{}, err
+			}
+
+			// Check if this workload is also inheriting Instrumentation from namespace
+			inheriting, err := isInheritingInstrumentationFromNs(ctx, r.Client, obj)
+			if err != nil {
+				return ctrl.Result{}, err
+			}
+			if inheriting {
+				// if it is inheriting, don't delete the instrumentation config
+				return ctrl.Result{}, err
+			}
+
+			err = errors.Join(err, deleteWorkloadInstrumentedApplication(ctx, r.Client, obj))
+			err = errors.Join(err, removeReportedNameAnnotation(ctx, r.Client, obj))
+			if err != nil {
+				return ctrl.Result{}, err
+			}
 		}
 
 		if controllerutil.ContainsFinalizer(source, consts.InstrumentedApplicationFinalizer) {
 			controllerutil.RemoveFinalizer(source, consts.InstrumentedApplicationFinalizer)
 			if err := r.Update(ctx, source); err != nil {
-				return ctrl.Result{}, err
+				return k8sutils.K8SUpdateErrorHandler(err)
 			}
 		}
-
-		err = reconcileWorkloadObject(ctx, r.Client, obj)
-		if err != nil {
-			return ctrl.Result{}, err
-		}
 	}
 	return ctrl.Result{}, nil
 }

instrumentor/controllers/startlangdetection/namespace_controller.go

@@ -3,6 +3,7 @@ package startlangdetection
 import (
 	"context"
 
+	"github.com/odigos-io/odigos/api/odigos/v1alpha1"
 	"github.com/odigos-io/odigos/common/consts"
 
 	"github.com/odigos-io/odigos/k8sutils/pkg/workload"
@@ -29,7 +30,13 @@ func (n *NamespacesReconciler) Reconcile(ctx context.Context, request ctrl.Reque
 	}
 
 	if !k8sutils.IsObjectLabeledForInstrumentation(&ns) {
-		return ctrl.Result{}, nil
+		sourceList, err := v1alpha1.GetSourceListForWorkload(ctx, n.Client, &ns)
+		if err != nil {
+			return ctrl.Result{}, err
+		}
+		if len(sourceList.Items) == 0 {
+			return ctrl.Result{}, nil
+		}
 	}
 
 	logger.V(0).Info("Namespace labeled for instrumentation, recalculating runtime details of relevant workloads")