Emit GKE PDCSI component version metric

cmd/gce-pd-csi-driver/main.go

@@ -28,6 +28,7 @@ import (
 	gce "sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/pkg/gce-cloud-provider/compute"
 	metadataservice "sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/pkg/gce-cloud-provider/metadata"
 	driver "sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/pkg/gce-pd-csi-driver"
+	"sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/pkg/metrics"
 	mountmanager "sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/pkg/mount-manager"
 )
 
@@ -36,6 +37,8 @@ var (
 	endpoint             = flag.String("endpoint", "unix:/tmp/csi.sock", "CSI endpoint")
 	runControllerService = flag.Bool("run-controller-service", true, "If set to false then the CSI driver does not activate its controller service (default: true)")
 	runNodeService       = flag.Bool("run-node-service", true, "If set to false then the CSI driver does not activate its node service (default: true)")
+	httpEndpoint         = flag.String("http-endpoint", "", "The TCP network address where the prometheus metrics endpoint will listen (example: `:8080`). The default is empty string, which means metrics endpoint is disabled.")
+	metricsPath          = flag.String("metrics-path", "/metrics", "The HTTP path where prometheus metrics will be exposed. Default is `/metrics`.")
 	extraVolumeLabels    map[string]string
 	version              string
 )
@@ -70,6 +73,12 @@ func handle() {
 	}
 	klog.V(2).Infof("Driver vendor version %v", version)
 
+	if *runControllerService && *httpEndpoint != "" && metrics.IsGKEComponentVersionAvailable() {
+		mm := metrics.NewMetricsManager()
+		mm.InitializeHttpHandler(*httpEndpoint, *metricsPath)
+		mm.EmitGKEComponentVersion()
+	}
+
 	gceDriver := driver.GetGCEDriver()
 
 	//Initialize GCE Driver

pkg/metrics/metrics.go

@@ -0,0 +1,124 @@
+/*
+Copyright 2020 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package metrics
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+
+	"k8s.io/component-base/metrics"
+	"k8s.io/klog"
+)
+
+const (
+	// envGKEPDCSIVersion is an environment variable set in the PDCSI controller manifest
+	// with the current version of the GKE component.
+	envGKEPDCSIVersion = "GKE_PDCSI_VERSION"
+)
+
+var (
+	// This metric is exposed only from the controller driver component when GKE_PDCSI_VERSION env variable is set.
+	gkeComponentVersion = metrics.NewGaugeVec(&metrics.GaugeOpts{
+		Name: "component_version",
+		Help: "Metric to expose the version of the PDCSI GKE component.",
+	}, []string{"component_version"})
+)
+
+type metricsManager struct {
+	registry metrics.KubeRegistry
+}
+
+func NewMetricsManager() metricsManager {
+	mm := metricsManager{
+		registry: metrics.NewKubeRegistry(),
+	}
+	return mm
+}
+
+func (mm *metricsManager) GetRegistry() metrics.KubeRegistry {
+	return mm.registry
+}
+
+func (mm *metricsManager) registerComponentVersionMetric() {
+	mm.registry.MustRegister(gkeComponentVersion)
+}
+
+func (mm *metricsManager) recordComponentVersionMetric() error {
+	v := getEnvVar(envGKEPDCSIVersion)
+	if v == "" {
+		klog.V(2).Info("Skip emitting component version metric")
+		return fmt.Errorf("Failed to register GKE component version metric, env variable %v not defined", envGKEPDCSIVersion)
+	}
+
+	gkeComponentVersion.WithLabelValues(v).Set(1.0)
+	return nil
+}
+
+func (mm *metricsManager) EmitGKEComponentVersion() error {
+	mm.registerComponentVersionMetric()
+	if err := mm.recordComponentVersionMetric(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Server represents any type that could serve HTTP requests for the metrics
+// endpoint.
+type Server interface {
+	Handle(pattern string, handler http.Handler)
+}
+
+// RegisterToServer registers an HTTP handler for this metrics manager to the
+// given server at the specified address/path.
+func (mm *metricsManager) registerToServer(s Server, metricsPath string) {
+	s.Handle(metricsPath, metrics.HandlerFor(
+		mm.GetRegistry(),
+		metrics.HandlerOpts{
+			ErrorHandling: metrics.ContinueOnError}))
+}
+
+// InitializeHttpHandler sets up a server and creates a handler for metrics.
+func (mm *metricsManager) InitializeHttpHandler(address, path string) {
+	mux := http.NewServeMux()
+	mm.registerToServer(mux, path)
+	go func() {
+		klog.Infof("Metric server listening at %q", address)
+		if err := http.ListenAndServe(address, mux); err != nil {
+			klog.Fatalf("Failed to start metric server at specified address (%q) and path (%q): %s", address, path, err)
+		}
+	}()
+}
+
+func getEnvVar(envVarName string) string {
+	v, ok := os.LookupEnv(envVarName)
+	if !ok {
+		klog.Warningf("%q env not set", envVarName)
+		return ""
+	}
+
+	return v
+}
+
+func IsGKEComponentVersionAvailable() bool {
+	if getEnvVar(envGKEPDCSIVersion) == "" {
+		return false
+	}
+
+	return true
+}