Merge pull request #1 from MCBrandenburg/moremetrics

Moremetrics

Author: MCBrandenburg

.github/workflows/go.yml

@@ -5,10 +5,10 @@ jobs:
     name: Build
     runs-on: ubuntu-latest
     steps:
-      - name: Set up Go 1.13
+      - name: Set up Go 1.18
         uses: actions/setup-go@v1
         with:
-          go-version: 1.13
+          go-version: 1.18
         id: go
 
       - name: Check out code into the Go module directory

Dockerfile

@@ -1,5 +1,5 @@
 # build stage
-FROM golang:1.13.2-alpine AS go-build-env
+FROM golang:1.18-alpine AS go-build-env
 
 RUN apk add --no-cache --update make git alpine-sdk gcc build-base
 

go.mod

@@ -1,29 +1,47 @@
 module github.com/mjavier2k/solidfire-exporter
 
-go 1.15
+go 1.18
 
 require (
 	github.com/K-Phoen/grabana v0.16.3
 	github.com/amoghe/distillog v0.0.0-20180726233512-ae382b35b717
+	github.com/prometheus/client_golang v1.10.0
+	github.com/spf13/pflag v1.0.5
+	github.com/spf13/viper v1.7.1
+	github.com/stretchr/testify v1.7.0
+	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
+	gopkg.in/h2non/gock.v1 v1.0.16
+)
+
+require (
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/cespare/xxhash/v2 v2.1.1 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/fsnotify/fsnotify v1.4.9 // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/gosimple/slug v1.9.0 // indirect
 	github.com/grafana-tools/sdk v0.0.0-20210521150820-354cd37a4b4e // indirect
+	github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542 // indirect
+	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/magiconair/properties v1.8.5 // indirect
+	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
 	github.com/mitchellh/mapstructure v1.4.1 // indirect
 	github.com/pelletier/go-toml v1.9.1 // indirect
-	github.com/prometheus/client_golang v1.10.0
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/prometheus/client_model v0.2.0 // indirect
 	github.com/prometheus/common v0.25.0 // indirect
+	github.com/prometheus/procfs v0.6.0 // indirect
+	github.com/rainycape/unidecode v0.0.0-20150907023854-cb7f23ec59be // indirect
 	github.com/spf13/afero v1.6.0 // indirect
 	github.com/spf13/cast v1.3.1 // indirect
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect
-	github.com/spf13/pflag v1.0.5
-	github.com/spf13/viper v1.7.1
 	github.com/stretchr/objx v0.3.0 // indirect
-	github.com/stretchr/testify v1.7.0
-	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
+	github.com/subosito/gotenv v1.2.0 // indirect
 	golang.org/x/sys v0.0.0-20210521203332-0cec03c779c1 // indirect
 	golang.org/x/text v0.3.6 // indirect
-	gopkg.in/h2non/gock.v1 v1.0.16
+	google.golang.org/protobuf v1.26.0 // indirect
 	gopkg.in/ini.v1 v1.62.0 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
 )

go.sum

@@ -166,15 +166,28 @@ func (c *SolidfireCollector) Describe(ch chan<- *prometheus.Desc) {
 	ch <- MetricDescriptions.DriveCapacityBytes
 
 	ch <- MetricDescriptions.NodeISCSISessions
+
+	ch <- MetricDescriptions.VolumeCount
+	ch <- MetricDescriptions.AccountCount
+	ch <- MetricDescriptions.ClusterAdminCount
+	ch <- MetricDescriptions.InitiatorCount
+	ch <- MetricDescriptions.VolumeAccessGroupCount
 }
 
-func (c *SolidfireCollector) collectVolumeMeta(ctx context.Context) error {
+func (c *SolidfireCollector) collectVolumeMeta(ctx context.Context, ch chan<- prometheus.Metric) error {
 	volumes, err := c.client.ListVolumes(ctx)
 	if err != nil {
 		return err
 	}
 	mu.Lock()
 	defer mu.Unlock()
+
+	ch <- prometheus.MustNewConstMetric(
+		MetricDescriptions.VolumeCount,
+		prometheus.CounterValue,
+		float64(len(volumes.Result.Volumes)),
+	)
+
 	for _, vol := range volumes.Result.Volumes {
 		c.volumeNamesByID[vol.VolumeID] = vol.Name
 	}
@@ -218,6 +231,7 @@ func (c *SolidfireCollector) collectNodeMeta(ctx context.Context, ch chan<- prom
 	}
 	return nil
 }
+
 func (c *SolidfireCollector) collectVolumeStats(ctx context.Context, ch chan<- prometheus.Metric) error {
 	volumeStats, err := c.client.ListVolumeStats(ctx)
 	if err != nil {
@@ -1251,6 +1265,65 @@ func (c *SolidfireCollector) collectISCSISessions(ctx context.Context, ch chan<-
 	return nil
 }
 
+func (c *SolidfireCollector) collectAccounts(ctx context.Context, ch chan<- prometheus.Metric) error {
+	accounts, err := c.client.ListAccounts(ctx)
+	if err != nil {
+		return err
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	ch <- prometheus.MustNewConstMetric(
+		MetricDescriptions.AccountCount,
+		prometheus.CounterValue,
+		float64(len(accounts.Result.Accounts)),
+	)
+	return nil
+}
+
+func (c *SolidfireCollector) collectClusterAdmins(ctx context.Context, ch chan<- prometheus.Metric) error {
+	clusterAdmins, err := c.client.ListClusterAdmins(ctx)
+	if err != nil {
+		return err
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	ch <- prometheus.MustNewConstMetric(
+		MetricDescriptions.ClusterAdminCount,
+		prometheus.CounterValue,
+		float64(len(clusterAdmins.Result.ClusterAdmins)),
+	)
+	return nil
+}
+
+func (c *SolidfireCollector) collectInitiators(ctx context.Context, ch chan<- prometheus.Metric) error {
+	initiators, err := c.client.ListInitiators(ctx)
+	if err != nil {
+		return err
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	ch <- prometheus.MustNewConstMetric(
+		MetricDescriptions.InitiatorCount,
+		prometheus.CounterValue,
+		float64(len(initiators.Result.Initiators)),
+	)
+	return nil
+}
+func (c *SolidfireCollector) collectVolumeAccessGroups(ctx context.Context, ch chan<- prometheus.Metric) error {
+	volumeAccessGroups, err := c.client.ListVolumeAccessGroups(ctx)
+	if err != nil {
+		return err
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	ch <- prometheus.MustNewConstMetric(
+		MetricDescriptions.VolumeAccessGroupCount,
+		prometheus.CounterValue,
+		float64(len(volumeAccessGroups.Result.VolumeAccessGroups)),
+	)
+	return nil
+}
+
 func (c *SolidfireCollector) Collect(ch chan<- prometheus.Metric) {
 	var up float64 = 0
 	defer func() { ch <- prometheus.MustNewConstMetric(MetricDescriptions.upDesc, prometheus.GaugeValue, up) }()
@@ -1259,7 +1332,7 @@ func (c *SolidfireCollector) Collect(ch chan<- prometheus.Metric) {
 
 	metadataGroup, ctx := errgroup.WithContext(parentCtx)
 	metadataGroup.Go(func() error {
-		return c.collectVolumeMeta(ctx)
+		return c.collectVolumeMeta(ctx, ch)
 	})
 	metadataGroup.Go(func() error {
 		return c.collectNodeMeta(ctx, ch)
@@ -1296,6 +1369,18 @@ func (c *SolidfireCollector) Collect(ch chan<- prometheus.Metric) {
 	metricsGroup.Go(func() error {
 		return c.collectISCSISessions(ctx, ch)
 	})
+	metricsGroup.Go(func() error {
+		return c.collectAccounts(ctx, ch)
+	})
+	metricsGroup.Go(func() error {
+		return c.collectClusterAdmins(ctx, ch)
+	})
+	metricsGroup.Go(func() error {
+		return c.collectInitiators(ctx, ch)
+	})
+	metricsGroup.Go(func() error {
+		return c.collectVolumeAccessGroups(ctx, ch)
+	})
 	if err := metricsGroup.Wait(); err != nil {
 		log.Errorln(err)
 		return

pkg/prom/collector.go

@@ -231,5 +231,33 @@ func newMockedClient(t *testing.T, mockErrs mockErrors) *testutils.MockSolidfire
 	require.NoError(t, json.Unmarshal(bytes, &listVolumeStatsResponse))
 	mockSfClient.On(string(call), mock.Anything).Return(listVolumeStatsResponse, mockErrs[call])
 
+	listAccountsResponse := solidfire.ListAccountsResponse{}
+	call = solidfire.RPCListAccounts
+	bytes, err = ioutil.ReadFile(testutils.ResolveFixturePath(fixtureBasePath, call))
+	require.NoError(t, err)
+	require.NoError(t, json.Unmarshal(bytes, &listAccountsResponse))
+	mockSfClient.On(string(call), mock.Anything).Return(listAccountsResponse, mockErrs[call])
+
+	listClusterAdminsResponse := solidfire.ListClusterAdminsResponse{}
+	call = solidfire.RPCListClusterAdmins
+	bytes, err = ioutil.ReadFile(testutils.ResolveFixturePath(fixtureBasePath, call))
+	require.NoError(t, err)
+	require.NoError(t, json.Unmarshal(bytes, &listClusterAdminsResponse))
+	mockSfClient.On(string(call), mock.Anything).Return(listClusterAdminsResponse, mockErrs[call])
+
+	listInitiatorsResponse := solidfire.ListInitiatorsResponse{}
+	call = solidfire.RPCListInitiators
+	bytes, err = ioutil.ReadFile(testutils.ResolveFixturePath(fixtureBasePath, call))
+	require.NoError(t, err)
+	require.NoError(t, json.Unmarshal(bytes, &listInitiatorsResponse))
+	mockSfClient.On(string(call), mock.Anything).Return(listInitiatorsResponse, mockErrs[call])
+
+	listVolumeAccessGroupsResponse := solidfire.ListVolumeAccessGroupsResponse{}
+	call = solidfire.RPCListVolumeAccessGroups
+	bytes, err = ioutil.ReadFile(testutils.ResolveFixturePath(fixtureBasePath, call))
+	require.NoError(t, err)
+	require.NoError(t, json.Unmarshal(bytes, &listVolumeAccessGroupsResponse))
+	mockSfClient.On(string(call), mock.Anything).Return(listVolumeAccessGroupsResponse, mockErrs[call])
+
 	return mockSfClient
 }

pkg/prom/collector_test.go

@@ -141,6 +141,13 @@ type Descriptions struct {
 
 	NodeISCSISessions *prometheus.Desc
 	//NodeISCSIVolumes       *prometheus.Desc
+
+	InitiatorCount         *prometheus.Desc
+	AccountCount           *prometheus.Desc
+	ClusterAdminCount      *prometheus.Desc
+	VolumeCount            *prometheus.Desc
+	VolumeAccessGroupCount *prometheus.Desc
+	VolumeAccessGroupLun   *prometheus.Desc
 }
 
 func NewMetricDescriptions(namespace string) *Descriptions {
@@ -926,5 +933,40 @@ func NewMetricDescriptions(namespace string) *Descriptions {
 		nil,
 	)
 
+	d.VolumeCount = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "cluster_volume_count"),
+		"The total number of volumes in cluster",
+		nil,
+		nil,
+	)
+
+	d.AccountCount = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "cluster_account_count"),
+		"The total number of accounts in cluster",
+		nil,
+		nil,
+	)
+
+	d.ClusterAdminCount = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "cluster_admin_account"),
+		"The total number of admin accounts in the cluster",
+		nil,
+		nil,
+	)
+
+	d.InitiatorCount = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "cluster_initiator_count"),
+		"The total number of initiators in cluster",
+		nil,
+		nil,
+	)
+
+	d.VolumeAccessGroupCount = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "cluster_volume_access_group_count"),
+		"The total number of volume access groups in cluster",
+		nil,
+		nil,
+	)
+
 	return &d
 }

pkg/prom/metrics.go

@@ -29,6 +29,10 @@ const (
 	RPCListVolumeQoSHistograms RPC = "ListVolumeQoSHistograms"
 	RPCListVolumes             RPC = "ListVolumes"
 	RPCListVolumeStats         RPC = "ListVolumeStats"
+	RPCListAccounts            RPC = "ListAccounts"
+	RPCListClusterAdmins       RPC = "ListClusterAdmins"
+	RPCListInitiators          RPC = "ListInitiators"
+	RPCListVolumeAccessGroups  RPC = "ListVolumeAccessGroups"
 )
 
 func NewSolidfireClient() (*Client, error) {
@@ -324,3 +328,91 @@ func (s *Client) ListISCSISessions(ctx context.Context) (ListISCSISessionsRespon
 	}
 	return r, nil
 }
+
+func (s *Client) ListClusterAdmins(ctx context.Context) (ListClusterAdminsResponse, error) {
+	payload := &RPCBody{
+		Method: RPCListClusterAdmins,
+		Params: ListClusterAdminsParams{},
+		ID:     1,
+	}
+
+	payloadBytes, err := json.Marshal(&payload)
+	r := ListClusterAdminsResponse{}
+	bodyBytes, err := s.doRpcCall(ctx, payloadBytes)
+
+	if err != nil {
+		return r, err
+	}
+	err = json.Unmarshal(bodyBytes, &r)
+
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+func (s *Client) ListAccounts(ctx context.Context) (ListAccountsResponse, error) {
+	payload := &RPCBody{
+		Method: RPCListAccounts,
+		Params: ListAccountsParams{},
+		ID:     1,
+	}
+
+	payloadBytes, err := json.Marshal(&payload)
+	r := ListAccountsResponse{}
+	bodyBytes, err := s.doRpcCall(ctx, payloadBytes)
+
+	if err != nil {
+		return r, err
+	}
+	err = json.Unmarshal(bodyBytes, &r)
+
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+func (s *Client) ListInitiators(ctx context.Context) (ListInitiatorsResponse, error) {
+	payload := &RPCBody{
+		Method: RPCListInitiators,
+		Params: ListInitiatorsParams{},
+		ID:     1,
+	}
+
+	payloadBytes, err := json.Marshal(&payload)
+	r := ListInitiatorsResponse{}
+	bodyBytes, err := s.doRpcCall(ctx, payloadBytes)
+
+	if err != nil {
+		return r, err
+	}
+	err = json.Unmarshal(bodyBytes, &r)
+
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}
+
+func (s *Client) ListVolumeAccessGroups(ctx context.Context) (ListVolumeAccessGroupsResponse, error) {
+	payload := &RPCBody{
+		Method: RPCListVolumeAccessGroups,
+		Params: ListVolumeAccessGroupsParams{},
+		ID:     1,
+	}
+
+	payloadBytes, err := json.Marshal(&payload)
+	r := ListVolumeAccessGroupsResponse{}
+	bodyBytes, err := s.doRpcCall(ctx, payloadBytes)
+
+	if err != nil {
+		return r, err
+	}
+	err = json.Unmarshal(bodyBytes, &r)
+
+	if err != nil {
+		return r, err
+	}
+	return r, nil
+}