[CECO-1860][DatadogGenericResource] Add monitor support (#1635)

tbavelier · levan-m · web-flow · commit 1c1682256fb6 · 2025-02-14T10:08:42.000+01:00
* refactor based on #1602 * fix finalizer test following refactor * remove dead code following refactor * move id conversion functions to utils.go from notebooks.go * move synthetics status update function to synthetics.go from utils.go (and associated test) * follow-up to 7b2552e: moving away from specific notebook id conversion to generic * nit: fix update error message * add monitor to supported generic resource controller * move id conversion functions to utils.go from notebooks.go * move synthetics status update function to synthetics.go from utils.go (and associated test) * follow-up to 7b2552e: moving away from specific notebook id conversion to generic * nit: fix update error message * lint --------- Co-authored-by: levan-m <116471169+levan-m@users.noreply.github.com>
diff --git a/api/datadoghq/v1alpha1/datadoggenericresource_types.go b/api/datadoghq/v1alpha1/datadoggenericresource_types.go
@@ -13,6 +13,7 @@ type SupportedResourcesType string
 
 // When adding a new type, make sure to update the kubebuilder validation enum marker
 const (
+	Monitor               SupportedResourcesType = "monitor"
 	Notebook              SupportedResourcesType = "notebook"
 	SyntheticsAPITest     SupportedResourcesType = "synthetics_api_test"
 	SyntheticsBrowserTest SupportedResourcesType = "synthetics_browser_test"
@@ -22,7 +23,7 @@ const (
 // +k8s:openapi-gen=true
 type DatadogGenericResourceSpec struct {
 	// Type is the type of the API object
-	// +kubebuilder:validation:Enum=notebook;synthetics_api_test;synthetics_browser_test
+	// +kubebuilder:validation:Enum=monitor;notebook;synthetics_api_test;synthetics_browser_test
 	Type SupportedResourcesType `json:"type"`
 	// JsonSpec is the specification of the API object
 	JsonSpec string `json:"jsonSpec"`
diff --git a/api/datadoghq/v1alpha1/datadoggenericresource_validation.go b/api/datadoghq/v1alpha1/datadoggenericresource_validation.go
@@ -12,10 +12,11 @@ import (
 )
 
 var allowedCustomResourcesEnumMap = map[SupportedResourcesType]string{
+	Monitor:               "",
 	Notebook:              "",
 	SyntheticsAPITest:     "",
 	SyntheticsBrowserTest: "",
-	// mockSubresource is used to mock the subresource in tests
+	// mock_resource is used to mock the subresource in tests
 	"mock_resource": "",
 }
 
diff --git a/config/crd/bases/v1/datadoghq.com_datadoggenericresources.yaml b/config/crd/bases/v1/datadoghq.com_datadoggenericresources.yaml
@@ -57,6 +57,7 @@ spec:
                 type:
                   description: Type is the type of the API object
                   enum:
+                    - monitor
                     - notebook
                     - synthetics_api_test
                     - synthetics_browser_test
diff --git a/config/crd/bases/v1/datadoghq.com_datadoggenericresources_v1alpha1.json b/config/crd/bases/v1/datadoghq.com_datadoggenericresources_v1alpha1.json
@@ -24,6 +24,7 @@
         "type": {
           "description": "Type is the type of the API object",
           "enum": [
+            "monitor",
             "notebook",
             "synthetics_api_test",
             "synthetics_browser_test"
diff --git a/internal/controller/datadoggenericresource/controller.go b/internal/controller/datadoggenericresource/controller.go
@@ -38,24 +38,23 @@ type Reconciler struct {
 	client                  client.Client
 	datadogSyntheticsClient *datadogV1.SyntheticsApi
 	datadogNotebooksClient  *datadogV1.NotebooksApi
-	// TODO: add other clients
-	datadogAuth context.Context
-	scheme      *runtime.Scheme
-	log         logr.Logger
-	recorder    record.EventRecorder
+	datadogMonitorsClient   *datadogV1.MonitorsApi
+	datadogAuth             context.Context
+	scheme                  *runtime.Scheme
+	log                     logr.Logger
+	recorder                record.EventRecorder
 }
 
 func NewReconciler(client client.Client, ddClient datadogclient.DatadogGenericClient, scheme *runtime.Scheme, log logr.Logger, recorder record.EventRecorder) *Reconciler {
 	return &Reconciler{
 		client:                  client,
 		datadogSyntheticsClient: ddClient.SyntheticsClient,
 		datadogNotebooksClient:  ddClient.NotebooksClient,
-		// TODO: add other clients
-		// datadogOtherClient: ddClient.OtherClient,
-		datadogAuth: ddClient.Auth,
-		scheme:      scheme,
-		log:         log,
-		recorder:    recorder,
+		datadogMonitorsClient:   ddClient.MonitorsClient,
+		datadogAuth:             ddClient.Auth,
+		scheme:                  scheme,
+		log:                     log,
+		recorder:                recorder,
 	}
 }
 
diff --git a/internal/controller/datadoggenericresource/controller_test.go b/internal/controller/datadoggenericresource/controller_test.go
@@ -8,6 +8,9 @@ import (
 	"net/url"
 	"testing"
 
+	datadogapi "github.com/DataDog/datadog-api-client-go/v2/api/datadog"
+	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV1"
+	"github.com/stretchr/testify/assert"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
@@ -20,11 +23,8 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/log/zap"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
-	datadogapi "github.com/DataDog/datadog-api-client-go/v2/api/datadog"
-	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV1"
 	datadoghqv1alpha1 "github.com/DataDog/datadog-operator/api/datadoghq/v1alpha1"
 	"github.com/DataDog/datadog-operator/pkg/controller/utils/comparison"
-	"github.com/stretchr/testify/assert"
 )
 
 const (
diff --git a/internal/controller/datadoggenericresource/finalizer_test.go b/internal/controller/datadoggenericresource/finalizer_test.go
@@ -10,19 +10,19 @@ import (
 	"testing"
 	"time"
 
+	"github.com/go-logr/logr"
+	"github.com/stretchr/testify/assert"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes/scheme"
 	"k8s.io/client-go/rest"
+	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
 	"sigs.k8s.io/controller-runtime/pkg/log/zap"
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	"github.com/DataDog/datadog-operator/api/datadoghq/v1alpha1"
 	datadoghqv1alpha1 "github.com/DataDog/datadog-operator/api/datadoghq/v1alpha1"
-	"github.com/go-logr/logr"
-	"github.com/stretchr/testify/assert"
-	ctrl "sigs.k8s.io/controller-runtime"
 )
 
 const (
diff --git a/internal/controller/datadoggenericresource/monitors.go b/internal/controller/datadoggenericresource/monitors.go
@@ -0,0 +1,91 @@
+package datadoggenericresource
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV1"
+	"github.com/go-logr/logr"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	"github.com/DataDog/datadog-operator/api/datadoghq/v1alpha1"
+)
+
+type MonitorHandler struct{}
+
+func (h *MonitorHandler) createResourcefunc(r *Reconciler, logger logr.Logger, instance *v1alpha1.DatadogGenericResource, status *v1alpha1.DatadogGenericResourceStatus, now metav1.Time, hash string) error {
+	createdMonitor, err := createMonitor(r.datadogAuth, r.datadogMonitorsClient, instance)
+	if err != nil {
+		logger.Error(err, "error creating monitor")
+		updateErrStatus(status, now, v1alpha1.DatadogSyncStatusCreateError, "CreatingCustomResource", err)
+		return err
+	}
+	logger.Info("created a new monitor", "monitor Id", createdMonitor.GetId())
+	status.Id = resourceInt64ToStringID(createdMonitor.GetId())
+	createdTime := metav1.NewTime(*createdMonitor.Created)
+	status.Created = &createdTime
+	status.LastForceSyncTime = &createdTime
+	status.Creator = *createdMonitor.GetCreator().Handle
+	status.SyncStatus = v1alpha1.DatadogSyncStatusOK
+	status.CurrentHash = hash
+	return nil
+}
+
+func (h *MonitorHandler) getResourcefunc(r *Reconciler, instance *v1alpha1.DatadogGenericResource) error {
+	_, err := getMonitor(r.datadogAuth, r.datadogMonitorsClient, instance.Status.Id)
+	return err
+}
+func (h *MonitorHandler) updateResourcefunc(r *Reconciler, instance *v1alpha1.DatadogGenericResource) error {
+	_, err := updateMonitor(r.datadogAuth, r.datadogMonitorsClient, instance)
+	return err
+}
+func (h *MonitorHandler) deleteResourcefunc(r *Reconciler, instance *v1alpha1.DatadogGenericResource) error {
+	return deleteMonitor(r.datadogAuth, r.datadogMonitorsClient, instance.Status.Id)
+}
+
+func getMonitor(auth context.Context, client *datadogV1.MonitorsApi, monitorStringID string) (datadogV1.Monitor, error) {
+	monitorID, err := resourceStringToInt64ID(monitorStringID)
+	if err != nil {
+		return datadogV1.Monitor{}, err
+	}
+	monitor, _, err := client.GetMonitor(auth, monitorID)
+	if err != nil {
+		return datadogV1.Monitor{}, translateClientError(err, "error getting monitor")
+	}
+	return monitor, nil
+}
+
+func deleteMonitor(auth context.Context, client *datadogV1.MonitorsApi, monitorStringID string) error {
+	monitorID, err := resourceStringToInt64ID(monitorStringID)
+	if err != nil {
+		return err
+	}
+	if _, _, err := client.DeleteMonitor(auth, monitorID); err != nil {
+		return translateClientError(err, "error deleting monitor")
+	}
+	return nil
+}
+
+func createMonitor(auth context.Context, client *datadogV1.MonitorsApi, instance *v1alpha1.DatadogGenericResource) (datadogV1.Monitor, error) {
+	monitorBody := &datadogV1.Monitor{}
+	json.Unmarshal([]byte(instance.Spec.JsonSpec), monitorBody)
+	monitor, _, err := client.CreateMonitor(auth, *monitorBody)
+	if err != nil {
+		return datadogV1.Monitor{}, translateClientError(err, "error creating monitor")
+	}
+	return monitor, nil
+}
+
+func updateMonitor(auth context.Context, client *datadogV1.MonitorsApi, instance *v1alpha1.DatadogGenericResource) (datadogV1.Monitor, error) {
+	monitorUpdateData := &datadogV1.MonitorUpdateRequest{}
+	json.Unmarshal([]byte(instance.Spec.JsonSpec), monitorUpdateData)
+	monitorID, err := resourceStringToInt64ID(instance.Status.Id)
+	if err != nil {
+		return datadogV1.Monitor{}, err
+	}
+	monitorUpdated, _, err := client.UpdateMonitor(auth, monitorID, *monitorUpdateData)
+	if err != nil {
+		return datadogV1.Monitor{}, translateClientError(err, "error updating monitor")
+	}
+	return monitorUpdated, nil
+}
diff --git a/internal/controller/datadoggenericresource/synthetics_test.go b/internal/controller/datadoggenericresource/synthetics_test.go
@@ -5,10 +5,11 @@ import (
 	"time"
 
 	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV1"
-	"github.com/DataDog/datadog-operator/api/datadoghq/v1alpha1"
 	"github.com/go-logr/logr"
 	"github.com/stretchr/testify/assert"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	"github.com/DataDog/datadog-operator/api/datadoghq/v1alpha1"
 )
 
 func Test_updateStatusFromSyntheticsTest(t *testing.T) {
diff --git a/internal/controller/datadoggenericresource/utils.go b/internal/controller/datadoggenericresource/utils.go
@@ -56,6 +56,8 @@ func apiCreateAndUpdateStatus(r *Reconciler, logger logr.Logger, instance *v1alp
 
 func getHandler(resourceType v1alpha1.SupportedResourcesType) ResourceHandler {
 	switch resourceType {
+	case v1alpha1.Monitor:
+		return &MonitorHandler{}
 	case v1alpha1.Notebook:
 		return &NotebookHandler{}
 	case v1alpha1.SyntheticsAPITest:
diff --git a/internal/controller/datadoggenericresource/utils_test.go b/internal/controller/datadoggenericresource/utils_test.go
@@ -7,11 +7,11 @@ import (
 	"testing"
 
 	datadogapi "github.com/DataDog/datadog-api-client-go/v2/api/datadog"
-	"github.com/DataDog/datadog-operator/api/datadoghq/v1alpha1"
 	"github.com/go-logr/logr"
 	"github.com/stretchr/testify/assert"
-
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	"github.com/DataDog/datadog-operator/api/datadoghq/v1alpha1"
 )
 
 func Test_apiCreateAndUpdateStatus(t *testing.T) {
diff --git a/pkg/datadogclient/client.go b/pkg/datadogclient/client.go
@@ -97,8 +97,8 @@ func InitDatadogDashboardClient(logger logr.Logger, creds config.Creds) (Datadog
 type DatadogGenericClient struct {
 	SyntheticsClient *datadogV1.SyntheticsApi
 	NotebooksClient  *datadogV1.NotebooksApi
-	// TODO: other clients depending on the resource
-	Auth context.Context
+	MonitorsClient   *datadogV1.MonitorsApi
+	Auth             context.Context
 }
 
 // InitDatadogGenericClient initializes the Datadog Generic API Client and establishes credentials.
@@ -111,13 +111,19 @@ func InitDatadogGenericClient(logger logr.Logger, creds config.Creds) (DatadogGe
 	apiClient := datadogapi.NewAPIClient(configV1)
 	syntheticsClient := datadogV1.NewSyntheticsApi(apiClient)
 	notebooksClient := datadogV1.NewNotebooksApi(apiClient)
+	monitorsClient := datadogV1.NewMonitorsApi(apiClient)
 
 	authV1, err := setupAuth(logger, creds)
 	if err != nil {
 		return DatadogGenericClient{}, err
 	}
 
-	return DatadogGenericClient{SyntheticsClient: syntheticsClient, NotebooksClient: notebooksClient, Auth: authV1}, nil
+	return DatadogGenericClient{
+		SyntheticsClient: syntheticsClient,
+		NotebooksClient:  notebooksClient,
+		MonitorsClient:   monitorsClient,
+		Auth:             authV1,
+	}, nil
 }
 
 func setupAuth(logger logr.Logger, creds config.Creds) (context.Context, error) {

Original file line number	Diff line number	Diff line change
`@@ -12,10 +12,11 @@ import (`
`12`	`12`	`)`
`13`	`13`
`14`	`14`	`var allowedCustomResourcesEnumMap = map[SupportedResourcesType]string{`
	`15`	`+ Monitor: "",`
`15`	`16`	`Notebook: "",`
`16`	`17`	`SyntheticsAPITest: "",`
`17`	`18`	`SyntheticsBrowserTest: "",`
`18`		`- // mockSubresource is used to mock the subresource in tests`
	`19`	`+ // mock_resource is used to mock the subresource in tests`
`19`	`20`	`"mock_resource": "",`
`20`	`21`	`}`
`21`	`22`