add server metrics

Author: sbueringer

main.go

@@ -232,7 +232,7 @@ func updateMetrics(provider *gophercloud.ProviderClient, eo gophercloud.Endpoint
 	var errs []error
 	scrapeStart := time.Now()
 
-	cinderClient, neutronClient, loadbalancerClient, err := getClients(provider, eo)
+	cinderClient, neutronClient, loadbalancerClient, computeClient, err := getClients(provider, eo)
 	if err != nil {
 		err := logError("creating openstack clients failed: %v", err)
 		errs = append(errs, err)
@@ -252,6 +252,11 @@ func updateMetrics(provider *gophercloud.ProviderClient, eo gophercloud.Endpoint
 			errs = append(errs, err)
 		}
 
+		if err := metrics.PublishServerMetrics(computeClient, tenantID); err != nil {
+			err := logError("scraping server metrics failed: %v", err)
+			errs = append(errs, err)
+		}
+
 		// check if Neutron is using FWaaS v1
 		// if FWaaS v2 is enabled, the extension alias is fwaas_v2 (the directories are the extension names)
 		// https://godoc.org/github.com/gophercloud/gophercloud/acceptance/openstack/networking/v2/extensions
@@ -292,27 +297,32 @@ func updateMetrics(provider *gophercloud.ProviderClient, eo gophercloud.Endpoint
 	return nil
 }
 
-func getClients(provider *gophercloud.ProviderClient, endpointOpts gophercloud.EndpointOpts) (cinder, neutron, loadbalancer *gophercloud.ServiceClient, err error) {
+func getClients(provider *gophercloud.ProviderClient, endpointOpts gophercloud.EndpointOpts) (cinder, neutron, loadbalancer, compute *gophercloud.ServiceClient, err error) {
 	cinderClient, err := openstack.NewBlockStorageV2(provider, endpointOpts)
 	if err != nil {
-		return nil, nil, nil, fmt.Errorf("unable to get cinder client: %v", err)
+		return nil, nil, nil, nil, fmt.Errorf("unable to get cinder client: %v", err)
 	}
 
 	neutronClient, err := openstack.NewNetworkV2(provider, endpointOpts)
 	if err != nil {
-		return nil, nil, nil, fmt.Errorf("unable to get neutron client: %v", err)
+		return nil, nil, nil, nil, fmt.Errorf("unable to get neutron client: %v", err)
+	}
+
+	computeClient, err := openstack.NewComputeV2(provider, endpointOpts)
+	if err != nil {
+		return nil, nil, nil, nil, fmt.Errorf("unable to get compute client: %v", err)
 	}
 
 	if _, err := provider.EndpointLocator(gophercloud.EndpointOpts{Type: "load-balancer", Availability: gophercloud.AvailabilityPublic}); err != nil {
 		// we can use the neutron client to access lbaas because no octavia is available
-		return cinderClient, neutronClient, neutronClient, nil
+		return cinderClient, neutronClient, neutronClient, computeClient, nil
 	}
 
 	loadbalancerClient, err := openstack.NewLoadBalancerV2(provider, endpointOpts)
 	if err != nil {
-		return nil, nil, nil, fmt.Errorf("failed to create loadbalancer service client: %v", err)
+		return nil, nil, nil, nil, fmt.Errorf("failed to create loadbalancer service client: %v", err)
 	}
-	return cinderClient, neutronClient, loadbalancerClient, nil
+	return cinderClient, neutronClient, loadbalancerClient, computeClient, nil
 }
 
 func min(a, b time.Duration) time.Duration {

pkg/metrics/loadbalancer.go

@@ -23,7 +23,7 @@ func registerLoadBalancerMetrics() {
 	loadbalancerAdminStateUp = prometheus.NewGaugeVec(
 		prometheus.GaugeOpts{
 			Name: generateName("loadbalancer_admin_state_up"),
-			Help: "Load balancer status",
+			Help: "Load balancer admin state up",
 		},
 		loadBalancerLabels,
 	)
@@ -69,7 +69,7 @@ func PublishLoadBalancerMetrics(client *gophercloud.ServiceClient, tenantID stri
 	return nil
 }
 
-// publishLoadBalancerMetric extracts data from a floating ip and exposes the metrics via prometheus
+// publishLoadBalancerMetric extracts data from a load balancer and exposes the metrics via prometheus
 func publishLoadBalancerMetric(lb loadbalancers.LoadBalancer) {
 	labels := []string{lb.ID, lb.VipAddress, lb.Provider, lb.VipPortID}
 

pkg/metrics/metrics.go

@@ -23,6 +23,7 @@ func RegisterMetrics(prefix string) {
 	registerLoadBalancerMetrics()
 	registerOpenStackMetrics()
 	registerFWaaSV1Metrics()
+	registerServerMetrics()
 }
 
 // AddPrefix adds the given prefix to the string, if set

pkg/metrics/nova.go

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: MIT
+
+package metrics
+
+import (
+	"github.com/gophercloud/gophercloud"
+	"github.com/gophercloud/gophercloud/openstack/compute/v2/servers"
+	"github.com/prometheus/client_golang/prometheus"
+	"k8s.io/klog"
+)
+
+var (
+	serverStatus                *prometheus.GaugeVec
+	serverVolumeAttachmentCount *prometheus.GaugeVec
+
+	// possible server states, from https://github.com/openstack/nova/blob/master/nova/objects/fields.py#L949
+	states = []string{"ACTIVE", "BUILDING", "PAUSED", "SUSPENDED", "STOPPED", "RESCUED", "RESIZED", "SOFT_DELETED", "DELETED", "ERROR", "SHELVED", "SHELVED_OFFLOADED"}
+
+	serverLabels = []string{"id"}
+)
+
+func registerServerMetrics() {
+	serverStatus = prometheus.NewGaugeVec(
+		prometheus.GaugeOpts{
+			Name: generateName("server_status"),
+			Help: "Server status",
+		},
+		append(serverLabels, "status"),
+	)
+	serverVolumeAttachmentCount = prometheus.NewGaugeVec(
+		prometheus.GaugeOpts{
+			Name: generateName("server_volume_attachment_count"),
+			Help: "Server volume attachment count",
+		},
+		serverLabels,
+	)
+
+	prometheus.MustRegister(serverStatus)
+	prometheus.MustRegister(serverVolumeAttachmentCount)
+}
+
+// PublishServerMetrics makes the list request to the server api and
+// passes the result to a publish function.
+func PublishServerMetrics(client *gophercloud.ServiceClient, tenantID string) error {
+	// first step: gather the data
+	mc := newOpenStackMetric("server", "list")
+	pages, err := servers.List(client, servers.ListOpts{}).AllPages()
+	if mc.Observe(err) != nil {
+		// only warn, maybe the next list will work.
+		klog.Warningf("Unable to list servers: %v", err)
+		return err
+	}
+	serversList, err := servers.ExtractServers(pages)
+	if err != nil {
+		// only warn, maybe the next publish will work.
+		klog.Warningf("Unable to extract servers: %v", err)
+		return err
+	}
+
+	// second step: reset the old metrics
+	serverStatus.Reset()
+	serverVolumeAttachmentCount.Reset()
+
+	// third step: publish the metrics
+	for _, srv := range serversList {
+		publishServerMetric(srv)
+	}
+
+	return nil
+}
+
+// publishServerMetric extracts data from a server and exposes the metrics via prometheus
+func publishServerMetric(srv servers.Server) {
+	labels := []string{srv.ID}
+
+	serverVolumeAttachmentCount.WithLabelValues(labels...).Set(float64(len(srv.AttachedVolumes)))
+
+	// create one metric per status
+	for _, state := range states {
+		stateLabels := append(labels, state)
+		serverStatus.WithLabelValues(stateLabels...).Set(boolFloat64(srv.Status == state))
+	}
+}