Merge pull request vmware-tanzu#41 from dilyar85/feature/add-vm-publish-metrics

Add VM publish related metrics in virtualmachinepublishrequest controller

Author: dilyar85

controllers/virtualmachinepublishrequest/virtualmachinepublishrequest_controller.go

@@ -33,6 +33,7 @@ import (
 	imgregv1a1 "github.com/vmware-tanzu/vm-operator/external/image-registry/api/v1alpha1"
 
 	"github.com/vmware-tanzu/vm-operator/pkg/context"
+	"github.com/vmware-tanzu/vm-operator/pkg/metrics"
 	"github.com/vmware-tanzu/vm-operator/pkg/patch"
 	"github.com/vmware-tanzu/vm-operator/pkg/record"
 	"github.com/vmware-tanzu/vm-operator/pkg/vmprovider"
@@ -132,6 +133,7 @@ func NewReconciler(
 		Logger:     logger,
 		Recorder:   recorder,
 		VMProvider: vmProvider,
+		Metrics:    metrics.NewVMPublishMetrics(),
 	}
 }
 
@@ -141,6 +143,7 @@ type Reconciler struct {
 	Logger     logr.Logger
 	Recorder   record.Recorder
 	VMProvider vmprovider.VirtualMachineProviderInterface
+	Metrics    *metrics.VMPublishMetrics
 }
 
 func requeueDelay(ctx *context.VirtualMachinePublishRequestContext) time.Duration {
@@ -166,6 +169,10 @@ func (r *Reconciler) Reconcile(ctx goctx.Context, req ctrl.Request) (_ ctrl.Resu
 	vmPublishReq := &vmopv1alpha1.VirtualMachinePublishRequest{}
 	err := r.Get(ctx, req.NamespacedName, vmPublishReq)
 	if err != nil {
+		// Delete registered metrics if the resource is not found.
+		if apiErrors.IsNotFound(err) {
+			r.Metrics.DeleteMetrics(r.Logger, req.Name, req.Namespace)
+		}
 		return ctrl.Result{}, client.IgnoreNotFound(err)
 	}
 
@@ -594,9 +601,31 @@ func (r *Reconciler) ReconcileNormal(ctx *context.VirtualMachinePublishRequestCo
 	ctx.Logger.Info("Reconciling VirtualMachinePublishRequest")
 	vmPublishReq := ctx.VMPublishRequest
 
+	// Register VM publish request metrics based on the reconcile result.
+	var isComplete, isDeleted bool
+	defer func() {
+		if isDeleted {
+			r.Metrics.DeleteMetrics(ctx.Logger, vmPublishReq.Name, vmPublishReq.Namespace)
+			return
+		}
+
+		var res metrics.PublishResult
+		switch {
+		case isComplete:
+			res = metrics.PublishSucceeded
+		case reterr != nil:
+			res = metrics.PublishFailed
+		default:
+			res = metrics.PublishInProgress
+		}
+
+		r.Metrics.RegisterVMPublishRequest(r.Logger, vmPublishReq.Name, vmPublishReq.Namespace, res)
+	}()
+
 	// In case the .spec.ttlSecondsAfterFinished is not set, we can return early and no need to do any reconcile.
-	if vmPublishReq.IsComplete() {
-		requeueAfter, _, err := r.removeVMPubResourceFromCluster(ctx)
+	if isComplete = vmPublishReq.IsComplete(); isComplete {
+		requeueAfter, deleted, err := r.removeVMPubResourceFromCluster(ctx)
+		isDeleted = deleted
 		return ctrl.Result{RequeueAfter: requeueAfter}, err
 	}
 
@@ -651,19 +680,21 @@ func (r *Reconciler) ReconcileNormal(ctx *context.VirtualMachinePublishRequestCo
 		return ctrl.Result{}, err
 	}
 
-	if r.checkIsComplete(ctx) {
+	if isComplete = r.checkIsComplete(ctx); isComplete {
 		// remove VirtualMachinePublishRequest from the cluster if ttlSecondsAfterFinished is set.
 		requeueAfter, deleted, err := r.removeVMPubResourceFromCluster(ctx)
 		if deleted {
 			skipPatch = true
 		}
+		isDeleted = deleted
 		return ctrl.Result{RequeueAfter: requeueAfter}, err
 	}
 
 	return ctrl.Result{RequeueAfter: requeueDelay(ctx)}, nil
 }
 
-func (r *Reconciler) ReconcileDelete(_ *context.VirtualMachinePublishRequestContext) (ctrl.Result, error) {
+func (r *Reconciler) ReconcileDelete(ctx *context.VirtualMachinePublishRequestContext) (ctrl.Result, error) {
+	r.Metrics.DeleteMetrics(ctx.Logger, ctx.VMPublishRequest.Name, ctx.VMPublishRequest.Namespace)
 	// no op
 	return ctrl.Result{}, nil
 }

pkg/metrics/vmpub_metrics.go

@@ -0,0 +1,76 @@
+// Copyright (c) 2022 VMware, Inc. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package metrics
+
+import (
+	"sync"
+
+	"sigs.k8s.io/controller-runtime/pkg/metrics"
+
+	"github.com/go-logr/logr"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+type PublishResult int
+
+const (
+	PublishFailed     PublishResult = -1
+	PublishInProgress PublishResult = 0
+	PublishSucceeded  PublishResult = 1
+)
+
+var (
+	vmPubMetricsOnce sync.Once
+	vmPubMetrics     *VMPublishMetrics
+)
+
+type VMPublishMetrics struct {
+	vmPubRequest *prometheus.GaugeVec
+}
+
+// NewVMPublishMetrics initializes a singleton and registers all the defined metrics.
+func NewVMPublishMetrics() *VMPublishMetrics {
+	vmPubMetricsOnce.Do(func() {
+		vmPubMetrics = &VMPublishMetrics{
+			vmPubRequest: prometheus.NewGaugeVec(prometheus.GaugeOpts{
+				Namespace: metricsNamespace,
+				Subsystem: "vm",
+				Name:      "publish_request",
+				Help:      "VirtualMachine publish request result",
+			}, []string{
+				"name",
+				"namespace",
+			}),
+		}
+
+		metrics.Registry.MustRegister(
+			vmPubMetrics.vmPubRequest,
+		)
+	})
+
+	return vmPubMetrics
+}
+
+// RegisterVMPublishRequest registers VM publish request metrics with the given value.
+func (m *VMPublishMetrics) RegisterVMPublishRequest(logger logr.Logger, reqName, ns string, val PublishResult) {
+	labels := getVMPubRequestLabels(reqName, ns)
+	m.vmPubRequest.With(labels).Set(float64(val))
+
+	logger.V(5).WithValues("labels", labels, "result", val).Info("Set metrics for VM publish request")
+}
+
+// DeleteMetrics deletes all the related VM publish request metrics from the given name and namespace.
+func (m *VMPublishMetrics) DeleteMetrics(logger logr.Logger, reqName, ns string) {
+	labels := getVMPubRequestLabels(reqName, ns)
+	deleted := m.vmPubRequest.Delete(labels)
+
+	logger.V(5).WithValues("labels", labels, "deleted", deleted).Info("Delete VM publish request metrics")
+}
+
+func getVMPubRequestLabels(name, ns string) prometheus.Labels {
+	return prometheus.Labels{
+		"name":      name,
+		"namespace": ns,
+	}
+}