feat(auto-monitoring): create auto-resource when manual r is deleted

A manually managed Dash0Monitoring resource in a namespace eligible for
automatic namespace monitoring blocks creating the auto resource. This
is by design.

When the manually managed resource is deleted, trigger creating the auto
resource immediately.

Author: basti1302

internal/controller/auto_namespace_monitoring_controller.go

@@ -247,7 +247,7 @@ func (r *AutoNamespaceMonitoringReconciler) ensureNamespaceWatchIsActive(labelSe
 	if labelSelectorPredicate != nil {
 		watchPredicates = append(watchPredicates, labelSelectorPredicate)
 	}
-	logger.Debug("(re)creating the namespace watch")
+	logger.Debug("(re)creating the the namespace controller's namespace watch")
 	if err = namespaceController.Watch(
 		source.TypedKind[*corev1.Namespace, reconcile.Request](
 			r.manager.GetCache(),
@@ -261,6 +261,27 @@ func (r *AutoNamespaceMonitoringReconciler) ensureNamespaceWatchIsActive(labelSe
 	}
 	logger.Info("successfully created a new watch for namespaces")
 
+	// Also watch for deletion of manually managed Dash0Monitoring resources. When a manually managed monitoring
+	// resource is removed from a namespace that should be auto-monitored, we want to create the auto-monitoring
+	// resource immediately rather than waiting for the next namespace reconcile.
+	logger.Debug("(re)creating the namespace controller's watch for monitoring resource deletions")
+	if err = namespaceController.Watch(
+		source.TypedKind[*dash0v1beta1.Dash0Monitoring, reconcile.Request](
+			r.manager.GetCache(),
+			&dash0v1beta1.Dash0Monitoring{},
+			handler.TypedEnqueueRequestsFromMapFunc[*dash0v1beta1.Dash0Monitoring, reconcile.Request](
+				func(_ context.Context, mr *dash0v1beta1.Dash0Monitoring) []reconcile.Request {
+					return []reconcile.Request{{NamespacedName: types.NamespacedName{Name: mr.Namespace}}}
+				},
+			),
+			&manuallyManagedMonitoringResourceDeletePredicate{},
+		),
+	); err != nil {
+		logger.Error(err, "unable to create a new watch for monitoring resource deletions")
+		return
+	}
+	logger.Info("successfully created a new watch for monitoring resource deletions")
+
 	// start the controller
 	backgroundCtx := context.Background()
 	childContextForNamespaceController, stopNamespaceController := context.WithCancel(backgroundCtx)
@@ -970,3 +991,25 @@ func namespaceMatchesLabelSelector(ns *corev1.Namespace, selectorStr string) boo
 	}
 	return selector.Matches(labels.Set(ns.Labels))
 }
+
+// manuallyManagedMonitoringResourceDeletePredicate fires only on the deletion of monitoring resources that are not
+// auto-managed (i.e. they do not carry the dash0.com/auto-monitored-namespace=true label). Create/Update/Generic
+// events are ignored, and deletions of auto-managed resources are ignored to avoid loops with the auto-namespace
+// monitoring controller's own deletes.
+type manuallyManagedMonitoringResourceDeletePredicate struct{}
+
+func (p *manuallyManagedMonitoringResourceDeletePredicate) Create(_ event.TypedCreateEvent[*dash0v1beta1.Dash0Monitoring]) bool {
+	return false
+}
+
+func (p *manuallyManagedMonitoringResourceDeletePredicate) Update(_ event.TypedUpdateEvent[*dash0v1beta1.Dash0Monitoring]) bool {
+	return false
+}
+
+func (p *manuallyManagedMonitoringResourceDeletePredicate) Delete(e event.TypedDeleteEvent[*dash0v1beta1.Dash0Monitoring]) bool {
+	return e.Object.Labels[util.AutoMonitoredNamespaceLabel] != util.TrueString
+}
+
+func (p *manuallyManagedMonitoringResourceDeletePredicate) Generic(_ event.TypedGenericEvent[*dash0v1beta1.Dash0Monitoring]) bool {
+	return false
+}

internal/controller/auto_namespace_monitoring_controller_test.go

@@ -13,6 +13,7 @@ import (
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/utils/ptr"
 	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/event"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
 	dash0common "github.com/dash0hq/dash0-operator/api/operator/common"
@@ -299,7 +300,7 @@ var _ = Describe("The auto-namespace-monitoring controller", Ordered, func() {
 			verifyNamespaceHasAutoMonitoringResource(ctx, Default, testAutoNamespace1)
 		})
 
-		It("does not create a Dash0Monitoring with dash0.com/auto-monitored-namespace when the namespace already contains non-auto monitoring resource", func() {
+		It("does not create a Dash0Monitoring resource with dash0.com/auto-monitored-namespace when the namespace already contains a non-auto monitoring resource", func() {
 			createOperatorConfigurationResourceWithAutoMonitorNamespaces(ctx, new(true), "", nil)
 			EnsureMonitoringResourceWithSpecExistsInNamespace(
 				ctx,
@@ -317,6 +318,30 @@ var _ = Describe("The auto-namespace-monitoring controller", Ordered, func() {
 			Expect(hasAutoMonitoredLabel).To(BeFalse())
 		})
 
+		It("creates the auto-monitoring resource when a manually managed monitoring resource is deleted", func() {
+			createOperatorConfigurationResourceWithAutoMonitorNamespaces(ctx, new(true), "", nil)
+			EnsureMonitoringResourceWithSpecExistsInNamespace(
+				ctx,
+				k8sClient,
+				MonitoringResourceDefaultSpec,
+				manualMonitoringResourceName,
+			)
+			triggerNamespaceWatcherReconcile(ctx, namespaceWatcher, testAutoNamespace1)
+
+			// While the manual resource is in place, no auto-monitoring resource is created.
+			monitoringResources := listMonitoringResources(ctx, Default, testAutoNamespace1)
+			Expect(monitoringResources).To(HaveLen(1))
+			Expect(monitoringResources[0].Name).To(Equal(manualMonitoringResourceName.Name))
+
+			// Simulate the user deleting the manually managed monitoring resource. Once the watch on Dash0Monitoring
+			// deletions observes this, it enqueues a reconcile for the namespace; this test exercises that reconcile
+			// directly.
+			DeleteMonitoringResourceByName(ctx, k8sClient, manualMonitoringResourceName, false)
+			triggerNamespaceWatcherReconcile(ctx, namespaceWatcher, testAutoNamespace1)
+
+			verifyNamespaceHasAutoMonitoringResource(ctx, Default, testAutoNamespace1)
+		})
+
 		It("uses custom settings from the MonitoringTemplate when set", func() {
 			createOperatorConfigurationResourceWithAutoMonitorNamespaces(
 				ctx,
@@ -1021,6 +1046,55 @@ var _ = Describe("The auto-namespace-monitoring controller", Ordered, func() {
 			Expect(t2.Labels).To(Equal(map[string]string{"key": "value-2"}))
 		})
 	})
+
+	Context("manuallyManagedMonitoringResourceDeletePredicate", func() {
+		var p manuallyManagedMonitoringResourceDeletePredicate
+
+		It("ignores Create events", func() {
+			Expect(p.Create(event.TypedCreateEvent[*dash0v1beta1.Dash0Monitoring]{
+				Object: &dash0v1beta1.Dash0Monitoring{},
+			})).To(BeFalse())
+		})
+
+		It("ignores Update events", func() {
+			Expect(p.Update(event.TypedUpdateEvent[*dash0v1beta1.Dash0Monitoring]{
+				ObjectOld: &dash0v1beta1.Dash0Monitoring{},
+				ObjectNew: &dash0v1beta1.Dash0Monitoring{},
+			})).To(BeFalse())
+		})
+
+		It("ignores Generic events", func() {
+			Expect(p.Generic(event.TypedGenericEvent[*dash0v1beta1.Dash0Monitoring]{
+				Object: &dash0v1beta1.Dash0Monitoring{},
+			})).To(BeFalse())
+		})
+
+		It("fires on Delete of a manually managed monitoring resource (no auto-monitored label)", func() {
+			Expect(p.Delete(event.TypedDeleteEvent[*dash0v1beta1.Dash0Monitoring]{
+				Object: &dash0v1beta1.Dash0Monitoring{},
+			})).To(BeTrue())
+		})
+
+		It("fires on Delete of a monitoring resource with unrelated labels", func() {
+			Expect(p.Delete(event.TypedDeleteEvent[*dash0v1beta1.Dash0Monitoring]{
+				Object: &dash0v1beta1.Dash0Monitoring{
+					ObjectMeta: metav1.ObjectMeta{
+						Labels: map[string]string{"some": "label"},
+					},
+				},
+			})).To(BeTrue())
+		})
+
+		It("does not fire on Delete of an auto-managed monitoring resource", func() {
+			Expect(p.Delete(event.TypedDeleteEvent[*dash0v1beta1.Dash0Monitoring]{
+				Object: &dash0v1beta1.Dash0Monitoring{
+					ObjectMeta: metav1.ObjectMeta{
+						Labels: map[string]string{util.AutoMonitoredNamespaceLabel: util.TrueString},
+					},
+				},
+			})).To(BeFalse())
+		})
+	})
 })
 
 func createOperatorConfigurationResourceWithAutoMonitorNamespaces(