update perf collectors

Author: genegr

internal/openmetrics-exporter/aaa.sh

@@ -7,10 +7,10 @@ import (
 
 type ArrayPerformanceCollector struct {
 	LatencyDesc     *prometheus.Desc
-        ThroughputDesc  *prometheus.Desc
-        BandwidthDesc   *prometheus.Desc
-        AverageSizeDesc *prometheus.Desc
-        QueueDepthDesc  *prometheus.Desc
+	ThroughputDesc  *prometheus.Desc
+	BandwidthDesc   *prometheus.Desc
+	AverageSizeDesc *prometheus.Desc
+	QueueDepthDesc  *prometheus.Desc
 	Client          *client.FAClient
 }
 
@@ -27,198 +27,198 @@ func (c *ArrayPerformanceCollector) Collect(ch chan<- prometheus.Metric) {
 	ch <- prometheus.MustNewConstMetric(
 		c.LatencyDesc,
 		prometheus.GaugeValue,
-		float64(ap.QueueUsecPerMirroredWriteOp),
+		ap.QueueUsecPerMirroredWriteOp,
 		"queue_usec_per_mirrored_write_op",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.LatencyDesc,
 		prometheus.GaugeValue,
-		float64(ap.QueueUsecPerReadOp),
+		ap.QueueUsecPerReadOp,
 		"queue_usec_per_read_op",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.LatencyDesc,
 		prometheus.GaugeValue,
-		float64(ap.QueueUsecPerWriteOp),
+		ap.QueueUsecPerWriteOp,
 		"queue_usec_per_write_op",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.LatencyDesc,
 		prometheus.GaugeValue,
-		float64(ap.SanUsecPerMirroredWriteOp),
+		ap.SanUsecPerMirroredWriteOp,
 		"san_usec_per_mirrored_write_op",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.LatencyDesc,
 		prometheus.GaugeValue,
-		float64(ap.SanUsecPerReadOp),
+		ap.SanUsecPerReadOp,
 		"san_usec_per_read_op",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.LatencyDesc,
 		prometheus.GaugeValue,
-		float64(ap.SanUsecPerWriteOp),
+		ap.SanUsecPerWriteOp,
 		"san_usec_per_write_op",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.LatencyDesc,
 		prometheus.GaugeValue,
-		float64(ap.ServiceUsecPerMirroredWriteOp),
+		ap.ServiceUsecPerMirroredWriteOp,
 		"service_usec_per_mirrored_write_op",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.LatencyDesc,
 		prometheus.GaugeValue,
-		float64(ap.ServiceUsecPerReadOp),
+		ap.ServiceUsecPerReadOp,
 		"service_usec_per_read_op",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.LatencyDesc,
 		prometheus.GaugeValue,
-		float64(ap.ServiceUsecPerWriteOp),
+		ap.ServiceUsecPerWriteOp,
 		"service_usec_per_write_op",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.LatencyDesc,
 		prometheus.GaugeValue,
-		float64(ap.UsecPerMirroredWriteOp),
+		ap.UsecPerMirroredWriteOp,
 		"usec_per_mirrored_write_op",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.LatencyDesc,
 		prometheus.GaugeValue,
-		float64(ap.UsecPerReadOp),
+		ap.UsecPerReadOp,
 		"usec_per_read_op",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.LatencyDesc,
 		prometheus.GaugeValue,
-		float64(ap.UsecPerWriteOp),
+		ap.UsecPerWriteOp,
 		"usec_per_write_op",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.LatencyDesc,
 		prometheus.GaugeValue,
-		float64(ap.ServiceUsecPerReadOpCacheReduction),
+		ap.ServiceUsecPerReadOpCacheReduction,
 		"service_usec_per_read_op_cache_reduction",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.LatencyDesc,
 		prometheus.GaugeValue,
-		float64(ap.LocalQueueUsecPerOp),
+		ap.LocalQueueUsecPerOp,
 		"local_queue_usec_per_op",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.LatencyDesc,
 		prometheus.GaugeValue,
-		float64(ap.UsecPerOtherOp),
+		ap.UsecPerOtherOp,
 		"usec_per_other_op",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.BandwidthDesc,
 		prometheus.GaugeValue,
-		float64(ap.MirroredWriteBytesPerSec),
+		ap.MirroredWriteBytesPerSec,
 		"mirrored_write_bytes_per_sec",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.BandwidthDesc,
 		prometheus.GaugeValue,
-		float64(ap.ReadBytesPerSec),
+		ap.ReadBytesPerSec,
 		"read_bytes_per_sec",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.BandwidthDesc,
 		prometheus.GaugeValue,
-		float64(ap.WriteBytesPerSec),
+		ap.WriteBytesPerSec,
 		"write_bytes_per_sec",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.ThroughputDesc,
 		prometheus.GaugeValue,
-		float64(ap.MirroredWritesPerSec),
+		ap.MirroredWritesPerSec,
 		"mirrored_writes_per_sec",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.ThroughputDesc,
 		prometheus.GaugeValue,
-		float64(ap.ReadsPerSec),
+		ap.ReadsPerSec,
 		"reads_per_sec",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.ThroughputDesc,
 		prometheus.GaugeValue,
-		float64(ap.WritesPerSec),
+		ap.WritesPerSec,
 		"writes_per_sec",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.ThroughputDesc,
 		prometheus.GaugeValue,
-		float64(ap.OthersPerSec),
+		ap.OthersPerSec,
 		"others_per_sec",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.AverageSizeDesc,
 		prometheus.GaugeValue,
-		float64(ap.BytesPerMirroredWrite),
+		ap.BytesPerMirroredWrite,
 		"bytes_per_mirrored_write",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.AverageSizeDesc,
 		prometheus.GaugeValue,
-		float64(ap.BytesPerOp),
+		ap.BytesPerOp,
 		"bytes_per_op",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.AverageSizeDesc,
 		prometheus.GaugeValue,
-		float64(ap.BytesPerRead),
+		ap.BytesPerRead,
 		"bytes_per_read",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.AverageSizeDesc,
 		prometheus.GaugeValue,
-		float64(ap.BytesPerWrite),
+		ap.BytesPerWrite,
 		"bytes_per_write",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.QueueDepthDesc,
 		prometheus.GaugeValue,
-		float64(ap.QueueDepth),
+		ap.QueueDepth,
 	)
 }
 
 func NewArraysPerformanceCollector(fa *client.FAClient) *ArrayPerformanceCollector {
 	return &ArrayPerformanceCollector{
-                LatencyDesc: prometheus.NewDesc(
-                        "purefa_array_performance_latency_usec",
-                        "FlashArray array latency",
-                        []string{"dimension"},
-                        prometheus.Labels{},
-                ),
-                ThroughputDesc: prometheus.NewDesc(
-                        "purefa_array_performance_throughput_iops",
-                        "FlashArray array throughput",
-                        []string{"dimension"},
-                        prometheus.Labels{},
-                ),
-                BandwidthDesc: prometheus.NewDesc(
-                        "purefa_array_performance_bandwidth_bytes",
-                        "FlashArray array throughput",
-                        []string{"dimension"},
-                        prometheus.Labels{},
-                ),
-                AverageSizeDesc: prometheus.NewDesc(
-                        "purefa_array_performance_average_bytes",
-                        "FlashArray array average operations size",
-                        []string{"dimension"},
-                        prometheus.Labels{},
-                ),
-                QueueDepthDesc: prometheus.NewDesc(
-                        "purefa_array_performance_queue_depth_ops",
-                        "FlashArray array queue depth size",
-                        []string{},
-                        prometheus.Labels{},
-                ),
+		LatencyDesc: prometheus.NewDesc(
+			"purefa_array_performance_latency_usec",
+			"FlashArray array latency",
+			[]string{"dimension"},
+			prometheus.Labels{},
+		),
+		ThroughputDesc: prometheus.NewDesc(
+			"purefa_array_performance_throughput_iops",
+			"FlashArray array throughput",
+			[]string{"dimension"},
+			prometheus.Labels{},
+		),
+		BandwidthDesc: prometheus.NewDesc(
+			"purefa_array_performance_bandwidth_bytes",
+			"FlashArray array throughput",
+			[]string{"dimension"},
+			prometheus.Labels{},
+		),
+		AverageSizeDesc: prometheus.NewDesc(
+			"purefa_array_performance_average_bytes",
+			"FlashArray array average operations size",
+			[]string{"dimension"},
+			prometheus.Labels{},
+		),
+		QueueDepthDesc: prometheus.NewDesc(
+			"purefa_array_performance_queue_depth_ops",
+			"FlashArray array queue depth size",
+			[]string{},
+			prometheus.Labels{},
+		),
 		Client: fa,
 	}
 }

internal/openmetrics-exporter/arrays_performance_collector.go

@@ -4,39 +4,39 @@ package collectors
 import (
 	"fmt"
 	"testing"
-        "regexp"
-        "strings"
+	"regexp"
+	"strings"
 	"net/http"
 	"net/http/httptest"
-        "encoding/json"
-        "io/ioutil"
+	"encoding/json"
+	"io/ioutil"
 
-        "purestorage/fa-openmetrics-exporter/internal/rest-client"
+	"purestorage/fa-openmetrics-exporter/internal/rest-client"
 )
 
 func TestArrayPerformanceCollector(t *testing.T) {
 
 	res, _ := ioutil.ReadFile("../../test/data/arrays_performance.json")
 	vers, _ := ioutil.ReadFile("../../test/data/versions.json")
-        var arrs client.ArraysPerformanceList
-        json.Unmarshal(res, &arrs)
+	var arrs client.ArraysPerformanceList
+	json.Unmarshal(res, &arrs)
 	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-	        valid := regexp.MustCompile(`^/api/([0-9]+.[0-9]+)?/arrays/performance$`)
-                if r.URL.Path == "/api/api_version" {
+		valid := regexp.MustCompile(`^/api/([0-9]+.[0-9]+)?/arrays/performance$`)
+		if r.URL.Path == "/api/api_version" {
                         w.Header().Set("Content-Type", "application/json")
                         w.WriteHeader(http.StatusOK)
                         w.Write([]byte(vers))
-                } else if valid.MatchString(r.URL.Path) {
-			w.Header().Set("x-auth-token", "faketoken")
-			w.Header().Set("Content-Type", "application/json")
-			w.WriteHeader(http.StatusOK)
-			w.Write([]byte(res))
+		} else if valid.MatchString(r.URL.Path) {
+                        w.Header().Set("x-auth-token", "faketoken")
+                        w.Header().Set("Content-Type", "application/json")
+                        w.WriteHeader(http.StatusOK)
+                        w.Write([]byte(res))
 		}
 	   }))
-        endp := strings.Split(server.URL, "/")
-        e := endp[len(endp)-1]
+	endp := strings.Split(server.URL, "/")
+	e := endp[len(endp)-1]
+	defer server.Close()
 	p := arrs.Items[0]
-        defer server.Close()
 	want := make(map[string]bool)
 	want[fmt.Sprintf("label:<name:\"dimension\" value:\"queue_usec_per_mirrored_write_op\" > gauge:<value:%g > ", p.QueueUsecPerMirroredWriteOp)] = true
 	want[fmt.Sprintf("label:<name:\"dimension\" value:\"queue_usec_per_read_op\" > gauge:<value:%g > ", p.QueueUsecPerReadOp)] = true
@@ -65,8 +65,7 @@ func TestArrayPerformanceCollector(t *testing.T) {
 	want[fmt.Sprintf("label:<name:\"dimension\" value:\"bytes_per_read\" > gauge:<value:%g > ", p.BytesPerRead)] = true
 	want[fmt.Sprintf("label:<name:\"dimension\" value:\"bytes_per_write\" > gauge:<value:%g > ", p.BytesPerWrite)] = true
 	want[fmt.Sprintf("gauge:<value:%g > ", p.QueueDepth)] = true
-
 	c := client.NewRestClient(e, "fake-api-token", "latest")
-        asc := NewArraysPerformanceCollector(c)
-	metricsCheck(t, asc, want)
+	pc := NewArraysPerformanceCollector(c)
+	metricsCheck(t, pc, want)
 }