Make test succeed

Author: MMulthaupt

cmd/exporter/flags/flags.go

@@ -5,7 +5,7 @@ import "flag"
 func Parse(arguments []string) (namespace, binary, argName string, port int) {
 	flagSet := flag.NewFlagSet("flags", flag.ExitOnError)
 	namespacePtr := flagSet.String("namespace", "mine", "Prometheus metric namespace.")
-	binaryPtr := flagSet.String("binary", "", "Filter which processes to watch by binary name.")
+	binaryPtr := flagSet.String("binary", "", "Filter which processes to watch by binary name. This is limited to 15 bytes because of the kernel.")
 	nameFlagPtr := flagSet.String("nameflag", "name", "Set Prometheus \"name\"-label value to value of this command line argument of the monitored processes.")
 	portPtr := flagSet.Int("port", 80, "Port on which to listen to requests to /metrics.")
 	err := flagSet.Parse(arguments)

cmd/exporter/metrics/prom_proc_metrics.go

@@ -9,6 +9,7 @@ import (
 )
 
 type PrometheusProcessMetrics struct {
+	lastMetricsSnapshot    *ProcessMetrics
 	cpuGauge               prometheus.Gauge
 	ramGauge               prometheus.Gauge
 	swapGauge              prometheus.Gauge
@@ -22,6 +23,7 @@ type PrometheusProcessMetrics struct {
 
 func newProcessMetrics(proc ps.Process, descriptiveName, metricNamespace string) (processMetrics *PrometheusProcessMetrics) {
 	processMetrics = &PrometheusProcessMetrics{}
+	processMetrics.lastMetricsSnapshot = &ProcessMetrics{}
 	binaryName := filepath.Base(proc.Executable())
 	pid := fmt.Sprintf("%d", proc.Pid())
 	processMetrics.makeGauges(metricNamespace, pid, binaryName, descriptiveName)
@@ -132,4 +134,12 @@ func (pm *PrometheusProcessMetrics) Update() {
 func (pm *PrometheusProcessMetrics) Set(processMetrics *ProcessMetrics) {
 	pm.cpuGauge.Set(processMetrics.cpu)
 	pm.ramGauge.Set(float64(processMetrics.ram))
+	pm.swapGauge.Set(float64(processMetrics.swap))
+	pm.diskReadBytesCounter.Add(float64(processMetrics.diskReadBytes - pm.lastMetricsSnapshot.diskReadBytes))
+	pm.diskWriteBytesCounter.Add(float64(processMetrics.diskWriteBytes - pm.lastMetricsSnapshot.diskWriteBytes))
+	pm.diskReadCountCounter.Add(float64(processMetrics.diskReadCount - pm.lastMetricsSnapshot.diskReadCount))
+	pm.diskWriteCountCounter.Add(float64(processMetrics.diskWriteCount - pm.lastMetricsSnapshot.diskWriteCount))
+	pm.networkInBytesCounter.Add(float64(processMetrics.networkInBytes - pm.lastMetricsSnapshot.networkInBytes))
+	pm.networkOutBytesCounter.Add(float64(processMetrics.networkOutBytes - pm.lastMetricsSnapshot.networkOutBytes))
+	pm.lastMetricsSnapshot = processMetrics
 }

test/dummy/main.go

@@ -11,7 +11,7 @@ const dummyFilePath = "dummyfile"
 func main() {
 	defer os.Remove(dummyFilePath)
 	writeTestFile()
-	fmt.Printf(".")
+	fmt.Printf("\x2A")
 	ioutil.ReadAll(os.Stdin)
 }
 
@@ -21,5 +21,7 @@ func writeTestFile() {
 		panic(err)
 	}
 	defer f.Close()
-	f.WriteString("What a beautiful string") // 23 bytes
+	for i := 0; i < 16; i++ { // Write 1024 bytes
+		f.WriteString("What a beautiful string which is exactly 64 bytes in length!!!!!")
+	}
 }

test/integration/integration_test.go

@@ -3,24 +3,32 @@ package integration
 import (
 	"fmt"
 	"io"
+	"io/ioutil"
 	"net/http"
 	"os"
 	"os/exec"
+	"strconv"
+	"strings"
 	"testing"
+	"time"
 )
 
 func TestIntegration(t *testing.T) {
 	const port = "8771"
+	const dummyBinaryName = "prcexpintdum"
+	const dummyDescripiveName = "iamdummy"
 	run("go", "build", "-o", "exporter", "github.com/setlog/process_exporter/cmd/exporter")
 	defer os.Remove("exporter")
-	run("go", "build", "-o", "proc_exporter_integration_dummy", "github.com/setlog/process_exporter/test/dummy")
-	defer os.Remove("proc_exporter_integration_dummy")
-	cmd := exec.Command("exporter", "-port", port, "-binary", "proc_exporter_integration_dummy")
+	run("go", "build", "-o", dummyBinaryName, "github.com/setlog/process_exporter/test/dummy")
+	defer os.Remove(dummyBinaryName)
+	cmd := exec.Command("./exporter", "-port", port, "-binary", dummyBinaryName)
 	err := cmd.Start()
 	if err != nil {
 		panic(err)
 	}
-	cmdDummy := exec.Command("proc_exporter_integration_dummy", "-name", "iamdummy")
+	defer cmd.Process.Signal(os.Interrupt)
+
+	cmdDummy := exec.Command("./"+dummyBinaryName, "-name", dummyDescripiveName)
 	dummyReader, err := cmdDummy.StdoutPipe()
 	if err != nil {
 		panic(err)
@@ -29,26 +37,53 @@ func TestIntegration(t *testing.T) {
 	if err != nil {
 		panic(err)
 	}
+	defer dummyWriter.Close()
 	err = cmdDummy.Start()
 	if err != nil {
 		panic(err)
 	}
-	b := make([]byte, 1, 1)
+	b := []byte{0}
 	_, err = io.ReadAtLeast(dummyReader, b, 1)
 	if err != nil {
 		panic(err)
 	}
-	resp, err := http.Get("http://localhost:" + port)
+	if b[0] != 0x2A {
+		panic(fmt.Sprintf("Byte was %x. Expected 0x2A", b[0]))
+	}
+	time.Sleep(time.Second)
+
+	resp, err := http.Get("http://localhost:" + port + "/metrics")
 	if err != nil {
 		panic(err)
 	}
+	defer resp.Body.Close()
+	dummyWriter.Close()
 	if resp.StatusCode != http.StatusOK {
 		panic(fmt.Sprintf("got code %d when %d expected", resp.StatusCode, http.StatusOK))
 	}
-	err = dummyWriter.Close()
+	contents, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
 		panic(err)
 	}
+	contentsString := string(contents)
+	lines := strings.Split(contentsString, "\n")
+	gotLine := false
+	for _, line := range lines {
+		prefix := fmt.Sprintf("mine_disk_write_bytes{bin=\"%s\",name=\"%s\",pid=\"%d\"} ", dummyBinaryName, dummyDescripiveName, cmdDummy.Process.Pid)
+		if strings.HasPrefix(line, prefix) {
+			writeBytes, err := strconv.Atoi(line[len(prefix):])
+			if err != nil {
+				panic(fmt.Sprintf("failed to parse write_bytes from line %s: %v", line, err))
+			}
+			if writeBytes < 1024 || writeBytes > 8192 {
+				panic(fmt.Sprintf("exporter reported %d bytes written. Expected something in the range [1024;8192].", writeBytes))
+			}
+			gotLine = true
+		}
+	}
+	if !gotLine {
+		panic(fmt.Sprintf("exporter did not report io byte write count"))
+	}
 	err = cmdDummy.Wait()
 	if err != nil {
 		panic(err)