Enqueue Server collector

README.md

@@ -84,7 +84,7 @@ the built-in defaults are tailored for the latest version of SUSE Linux Enterpri
 The program will scan, in order, the current working directory, `$HOME/.config`, `/etc` and `/usr/etc` for files named `sap_host_exporter.(yaml|json|toml)`.
 The first match has precedence, and the CLI flags have precedence over the config file.
 
-Please refer to the example YAML configuration for more details.
+Please refer to the [example YAML configuration](doc/sap_host_exporter.yaml) for more details.
 
 ### systemd integration
 

collector/enqueue_server/enqueue_server.go

@@ -0,0 +1,128 @@
+package enqueue_server
+
+import (
+	log "github.com/sirupsen/logrus"
+
+	"github.com/prometheus/client_golang/prometheus"
+
+	"github.com/SUSE/sap_host_exporter/collector"
+	"github.com/SUSE/sap_host_exporter/internal/sapcontrol"
+)
+
+func NewCollector(webService sapcontrol.WebService) (*EnqueueServerCollector, error) {
+
+	c := &EnqueueServerCollector{
+		collector.NewDefaultCollector("enqueue_server"),
+		webService,
+	}
+
+	// TO-DO: describe all these metrics
+	// https://github.com/SUSE/sap_host_exporter/issues/11
+	c.SetDescriptor("owner_now", "TBD", nil)
+	c.SetDescriptor("owner_high", "TBD", nil)
+	c.SetDescriptor("owner_max", "TBD", nil)
+	c.SetDescriptor("owner_state", "TBD", nil)
+	c.SetDescriptor("arguments_now", "TBD", nil)
+	c.SetDescriptor("arguments_high", "TBD", nil)
+	c.SetDescriptor("arguments_max", "TBD", nil)
+	c.SetDescriptor("arguments_state", "TBD", nil)
+	c.SetDescriptor("locks_now", "TBD", nil)
+	c.SetDescriptor("locks_high", "TBD", nil)
+	c.SetDescriptor("locks_max", "TBD", nil)
+	c.SetDescriptor("locks_state", "TBD", nil)
+	c.SetDescriptor("enqueue_requests", "TBD", nil)
+	c.SetDescriptor("enqueue_rejects", "TBD", nil)
+	c.SetDescriptor("enqueue_errors", "TBD", nil)
+	c.SetDescriptor("dequeue_requests", "TBD", nil)
+	c.SetDescriptor("dequeue_errors", "TBD", nil)
+	c.SetDescriptor("dequeue_all_requests", "TBD", nil)
+	c.SetDescriptor("cleanup_requests", "TBD", nil)
+	c.SetDescriptor("backup_requests", "TBD", nil)
+	c.SetDescriptor("reporting_requests", "TBD", nil)
+	c.SetDescriptor("compress_requests", "TBD", nil)
+	c.SetDescriptor("verify_requests", "TBD", nil)
+	c.SetDescriptor("lock_time", "TBD", nil)
+	c.SetDescriptor("lock_wait_time", "TBD", nil)
+	c.SetDescriptor("server_time", "TBD", nil)
+	c.SetDescriptor("replication_state", "TBD", nil)
+
+	return c, nil
+}
+
+type EnqueueServerCollector struct {
+	collector.DefaultCollector
+	webService sapcontrol.WebService
+}
+
+func (c *EnqueueServerCollector) Collect(ch chan<- prometheus.Metric) {
+	log.Debugln("Collecting Enqueue Server metrics")
+
+	c.recordEnqStats(ch)
+}
+
+func (c *EnqueueServerCollector) recordEnqStats(ch chan<- prometheus.Metric) {
+	enqStatistic, err := c.webService.EnqGetStatistic()
+
+	if err != nil {
+		log.Warnf("SAPControl web service error: %s", err)
+		return
+	}
+
+	ch <- c.MakeGaugeMetric("owner_now", float64(enqStatistic.OwnerNow))
+	ch <- c.MakeGaugeMetric("owner_high", float64(enqStatistic.OwnerHigh))
+	ch <- c.MakeGaugeMetric("owner_max", float64(enqStatistic.OwnerMax))
+
+	ownerState, err := sapcontrol.StateColorToFloat(enqStatistic.OwnerState)
+	if err != nil {
+		log.Warnf("Could not record owner_state metric: %s", err)
+	} else {
+		ch <- c.MakeGaugeMetric("owner_state", ownerState)
+	}
+
+	ch <- c.MakeGaugeMetric("arguments_now", float64(enqStatistic.ArgumentsNow))
+	ch <- c.MakeGaugeMetric("arguments_high", float64(enqStatistic.ArgumentsHigh))
+	ch <- c.MakeGaugeMetric("arguments_max", float64(enqStatistic.ArgumentsMax))
+
+	argumentsState, err := sapcontrol.StateColorToFloat(enqStatistic.ArgumentsState)
+	if err != nil {
+		log.Warnf("Could not record arguments_state metric: %s", err)
+	} else {
+		ch <- c.MakeGaugeMetric("arguments_state", argumentsState)
+	}
+
+	ch <- c.MakeGaugeMetric("locks_now", float64(enqStatistic.LocksNow))
+	ch <- c.MakeGaugeMetric("locks_high", float64(enqStatistic.LocksHigh))
+	ch <- c.MakeGaugeMetric("locks_max", float64(enqStatistic.LocksMax))
+
+	locksState, err := sapcontrol.StateColorToFloat(enqStatistic.LocksState)
+	if err != nil {
+		log.Warnf("Could not record locks_state metric: %s", err)
+	} else {
+		ch <- c.MakeGaugeMetric("locks_state", locksState)
+	}
+
+	ch <- c.MakeGaugeMetric("enqueue_requests", float64(enqStatistic.EnqueueRequests))
+	ch <- c.MakeGaugeMetric("enqueue_rejects", float64(enqStatistic.EnqueueRejects))
+	ch <- c.MakeGaugeMetric("enqueue_errors", float64(enqStatistic.EnqueueErrors))
+
+	ch <- c.MakeGaugeMetric("dequeue_requests", float64(enqStatistic.DequeueRequests))
+	ch <- c.MakeGaugeMetric("dequeue_errors", float64(enqStatistic.DequeueErrors))
+	ch <- c.MakeGaugeMetric("dequeue_all_requests", float64(enqStatistic.DequeueAllRequests))
+
+	ch <- c.MakeGaugeMetric("cleanup_requests", float64(enqStatistic.CleanupRequests))
+	ch <- c.MakeGaugeMetric("backup_requests", float64(enqStatistic.BackupRequests))
+	ch <- c.MakeGaugeMetric("reporting_requests", float64(enqStatistic.ReportingRequests))
+	ch <- c.MakeGaugeMetric("compress_requests", float64(enqStatistic.CompressRequests))
+	ch <- c.MakeGaugeMetric("verify_requests", float64(enqStatistic.VerifyRequests))
+
+	ch <- c.MakeGaugeMetric("lock_time", float64(enqStatistic.LockTime))
+	ch <- c.MakeGaugeMetric("lock_wait_time", float64(enqStatistic.LockWaitTime))
+	ch <- c.MakeGaugeMetric("server_time", float64(enqStatistic.ServerTime))
+
+	replicationState, err := sapcontrol.StateColorToFloat(enqStatistic.ReplicationState)
+	if err != nil {
+		log.Warnf("Could not record replication_state metric: %s", err)
+	} else {
+		ch <- c.MakeGaugeMetric("replication_state", replicationState)
+	}
+}

collector/enqueue_server/enqueue_server_test.go

@@ -0,0 +1,150 @@
+package enqueue_server
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/prometheus/client_golang/prometheus/testutil"
+	"github.com/stretchr/testify/assert"
+
+	"github.com/SUSE/sap_host_exporter/internal/sapcontrol"
+	"github.com/SUSE/sap_host_exporter/test/mock_sapcontrol"
+)
+
+func TestNewCollector(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	mockWebService := mock_sapcontrol.NewMockWebService(ctrl)
+
+	_, err := NewCollector(mockWebService)
+
+	assert.Nil(t, err)
+}
+
+func TestProcessesMetric(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	mockWebService := mock_sapcontrol.NewMockWebService(ctrl)
+	mockWebService.EXPECT().EnqGetStatistic().Return(&sapcontrol.EnqStatisticResponse{
+		OwnerNow:           1,
+		OwnerHigh:          2,
+		OwnerMax:           3,
+		OwnerState:         sapcontrol.STATECOLOR_GREEN,
+		ArgumentsNow:       4,
+		ArgumentsHigh:      5,
+		ArgumentsMax:       6,
+		ArgumentsState:     sapcontrol.STATECOLOR_GRAY,
+		LocksNow:           7,
+		LocksHigh:          8,
+		LocksMax:           9,
+		LocksState:         sapcontrol.STATECOLOR_YELLOW,
+		EnqueueRequests:    10,
+		EnqueueRejects:     11,
+		EnqueueErrors:      12,
+		DequeueRequests:    13,
+		DequeueErrors:      14,
+		DequeueAllRequests: 15,
+		CleanupRequests:    16,
+		BackupRequests:     17,
+		ReportingRequests:  18,
+		CompressRequests:   19,
+		VerifyRequests:     20,
+		LockTime:           21,
+		LockWaitTime:       22,
+		ServerTime:         23,
+		ReplicationState:   sapcontrol.STATECOLOR_RED,
+	}, nil)
+
+	expectedMetrics := `
+	# HELP sap_enqueue_server_arguments_high TBD
+	# TYPE sap_enqueue_server_arguments_high gauge
+	sap_enqueue_server_arguments_high 5
+	# HELP sap_enqueue_server_arguments_max TBD
+	# TYPE sap_enqueue_server_arguments_max gauge
+	sap_enqueue_server_arguments_max 6
+	# HELP sap_enqueue_server_arguments_now TBD
+	# TYPE sap_enqueue_server_arguments_now gauge
+	sap_enqueue_server_arguments_now 4
+	# HELP sap_enqueue_server_arguments_state TBD
+	# TYPE sap_enqueue_server_arguments_state gauge
+	sap_enqueue_server_arguments_state 1
+	# HELP sap_enqueue_server_backup_requests TBD
+	# TYPE sap_enqueue_server_backup_requests gauge
+	sap_enqueue_server_backup_requests 17
+	# HELP sap_enqueue_server_cleanup_requests TBD
+	# TYPE sap_enqueue_server_cleanup_requests gauge
+	sap_enqueue_server_cleanup_requests 16
+	# HELP sap_enqueue_server_compress_requests TBD
+	# TYPE sap_enqueue_server_compress_requests gauge
+	sap_enqueue_server_compress_requests 19
+	# HELP sap_enqueue_server_dequeue_all_requests TBD
+	# TYPE sap_enqueue_server_dequeue_all_requests gauge
+	sap_enqueue_server_dequeue_all_requests 15
+	# HELP sap_enqueue_server_dequeue_errors TBD
+	# TYPE sap_enqueue_server_dequeue_errors gauge
+	sap_enqueue_server_dequeue_errors 14
+	# HELP sap_enqueue_server_dequeue_requests TBD
+	# TYPE sap_enqueue_server_dequeue_requests gauge
+	sap_enqueue_server_dequeue_requests 13
+	# HELP sap_enqueue_server_enqueue_errors TBD
+	# TYPE sap_enqueue_server_enqueue_errors gauge
+	sap_enqueue_server_enqueue_errors 12
+	# HELP sap_enqueue_server_enqueue_rejects TBD
+	# TYPE sap_enqueue_server_enqueue_rejects gauge
+	sap_enqueue_server_enqueue_rejects 11
+	# HELP sap_enqueue_server_enqueue_requests TBD
+	# TYPE sap_enqueue_server_enqueue_requests gauge
+	sap_enqueue_server_enqueue_requests 10
+	# HELP sap_enqueue_server_lock_time TBD
+	# TYPE sap_enqueue_server_lock_time gauge
+	sap_enqueue_server_lock_time 21
+	# HELP sap_enqueue_server_lock_wait_time TBD
+	# TYPE sap_enqueue_server_lock_wait_time gauge
+	sap_enqueue_server_lock_wait_time 22
+	# HELP sap_enqueue_server_locks_high TBD
+	# TYPE sap_enqueue_server_locks_high gauge
+	sap_enqueue_server_locks_high 8
+	# HELP sap_enqueue_server_locks_max TBD
+	# TYPE sap_enqueue_server_locks_max gauge
+	sap_enqueue_server_locks_max 9
+	# HELP sap_enqueue_server_locks_now TBD
+	# TYPE sap_enqueue_server_locks_now gauge
+	sap_enqueue_server_locks_now 7
+	# HELP sap_enqueue_server_locks_state TBD
+	# TYPE sap_enqueue_server_locks_state gauge
+	sap_enqueue_server_locks_state 3
+	# HELP sap_enqueue_server_owner_high TBD
+	# TYPE sap_enqueue_server_owner_high gauge
+	sap_enqueue_server_owner_high 2
+	# HELP sap_enqueue_server_owner_max TBD
+	# TYPE sap_enqueue_server_owner_max gauge
+	sap_enqueue_server_owner_max 3
+	# HELP sap_enqueue_server_owner_now TBD
+	# TYPE sap_enqueue_server_owner_now gauge
+	sap_enqueue_server_owner_now 1
+	# HELP sap_enqueue_server_owner_state TBD
+	# TYPE sap_enqueue_server_owner_state gauge
+	sap_enqueue_server_owner_state 2
+	# HELP sap_enqueue_server_replication_state TBD
+	# TYPE sap_enqueue_server_replication_state gauge
+	sap_enqueue_server_replication_state 4
+	# HELP sap_enqueue_server_reporting_requests TBD
+	# TYPE sap_enqueue_server_reporting_requests gauge
+	sap_enqueue_server_reporting_requests 18
+	# HELP sap_enqueue_server_server_time TBD
+	# TYPE sap_enqueue_server_server_time gauge
+	sap_enqueue_server_server_time 23
+	# HELP sap_enqueue_server_verify_requests TBD
+	# TYPE sap_enqueue_server_verify_requests gauge
+	sap_enqueue_server_verify_requests 20
+	`
+
+	var err error
+	collector, err := NewCollector(mockWebService)
+	assert.NoError(t, err)
+
+	err = testutil.CollectAndCompare(collector, strings.NewReader(expectedMetrics))
+	assert.NoError(t, err)
+}

collector/start_service/start_service.go

@@ -3,18 +3,17 @@ package start_service
 import (
 	"strconv"
 
-	"github.com/hooklift/gowsdl/soap"
 	log "github.com/sirupsen/logrus"
 
+	"github.com/prometheus/client_golang/prometheus"
+
 	"github.com/SUSE/sap_host_exporter/collector"
 	"github.com/SUSE/sap_host_exporter/internal/sapcontrol"
-	"github.com/prometheus/client_golang/prometheus"
 )
 
-func NewCollector(startServiceUrl string) (*soapCollector, error) {
-	webService := sapcontrol.NewWebService(soap.NewClient(startServiceUrl))
+func NewCollector(webService sapcontrol.WebService) (*StartServiceCollector, error) {
 
-	c := &soapCollector{
+	c := &StartServiceCollector{
 		collector.NewDefaultCollector("start_service"),
 		webService,
 	}
@@ -24,22 +23,26 @@ func NewCollector(startServiceUrl string) (*soapCollector, error) {
 	return c, nil
 }
 
-type soapCollector struct {
+type StartServiceCollector struct {
 	collector.DefaultCollector
 	webService sapcontrol.WebService
 }
 
-func (c *soapCollector) Collect(ch chan<- prometheus.Metric) {
+func (c *StartServiceCollector) Collect(ch chan<- prometheus.Metric) {
 	log.Debugln("Collecting SAP Start Service metrics")
 
-	response, err := c.webService.GetProcessList()
+	c.recordProcesses(ch)
+}
+
+func (c *StartServiceCollector) recordProcesses(ch chan<- prometheus.Metric) {
+	processList, err := c.webService.GetProcessList()
 
 	if err != nil {
 		log.Warnf("SAPControl web service error: %s", err)
 		return
 	}
 
-	for _, process := range response.Process.Item {
+	for _, process := range processList.Process.Item {
 		dispStatus, _ := sapcontrol.StateColorToString(process.Dispstatus)
 		ch <- c.MakeGaugeMetric("processes", 1, process.Name, strconv.Itoa(int(process.Pid)), process.Textstatus, dispStatus)
 	}

collector/start_service/start_service_test.go

@@ -12,7 +12,11 @@ import (
 )
 
 func TestNewCollector(t *testing.T) {
-	_, err := NewCollector("foobar")
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	mockWebService := mock_sapcontrol.NewMockWebService(ctrl)
+
+	_, err := NewCollector(mockWebService)
 
 	assert.Nil(t, err)
 }
@@ -28,7 +32,7 @@ func TestProcessesMetric(t *testing.T) {
 				{
 					Name:        "enserver",
 					Description: "foobar",
-					Dispstatus:  sapcontrol.STATECOLORGREEN,
+					Dispstatus:  sapcontrol.STATECOLOR_GREEN,
 					Textstatus:  "Running",
 					Starttime:   "",
 					Elapsedtime: "",
@@ -37,7 +41,7 @@ func TestProcessesMetric(t *testing.T) {
 				{
 					Name:        "msg_server",
 					Description: "foobar2",
-					Dispstatus:  sapcontrol.STATECOLORGREEN,
+					Dispstatus:  sapcontrol.STATECOLOR_GREEN,
 					Textstatus:  "Running",
 					Starttime:   "",
 					Elapsedtime: "",
@@ -55,9 +59,8 @@ func TestProcessesMetric(t *testing.T) {
 	`
 
 	var err error
-	collector, err := NewCollector("foobar")
+	collector, err := NewCollector(mockWebService)
 	assert.NoError(t, err)
-	collector.webService = mockWebService
 
 	err = testutil.CollectAndCompare(collector, strings.NewReader(expectedMetrics), "sap_start_service_processes")
 	assert.NoError(t, err)