Add integration test

Author: MMulthaupt

.gitignore

@@ -1,2 +1,3 @@
 exporter/exporter
-
+proc_exporter_integration_dummy
+dummyfile

cmd/exporter/exporter

@@ -2,14 +2,15 @@ package flags
 
 import "flag"
 
-func Parse(arguments []string) (namespace, binary, argName string) {
+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.")
-	argNamePtr := flagSet.String("argname", "name", "Set Prometheus \"name\"-label value to value of this command line argument of the monitored processes.")
+	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)
 	if err != nil {
 		panic(err)
 	}
-	return *namespacePtr, *binaryPtr, *argNamePtr
+	return *namespacePtr, *binaryPtr, *nameFlagPtr, *portPtr
 }

cmd/exporter/flags/flags.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"fmt"
 	"log"
 	"net/http"
 	"os"
@@ -10,7 +11,7 @@ import (
 )
 
 func main() {
-	namespace, procBinaryName, argName := flags.Parse(os.Args[1:])
-	http.Handle("/metrics", newHttpHandler(metrics.NewProcessMetricsSet(namespace, procBinaryName, argName)))
-	log.Fatal(http.ListenAndServe(":8771", nil))
+	namespace, procBinaryName, nameFlag, port := flags.Parse(os.Args[1:])
+	http.Handle("/metrics", newHttpHandler(metrics.NewProcessMetricsSet(namespace, procBinaryName, nameFlag)))
+	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", port), nil))
 }

cmd/exporter/main.go

@@ -5,7 +5,7 @@ import (
 	"testing"
 
 	"github.com/mitchellh/go-ps"
-	"github.com/setlog/libvirt_exporter/metrics"
+	"github.com/setlog/process_exporter/cmd/exporter/metrics"
 )
 
 type proc struct {

cmd/exporter/metrics/metrics_test.go

@@ -1,7 +1,6 @@
 package metrics
 
 import (
-	"flag"
 	"fmt"
 	"path/filepath"
 
@@ -14,15 +13,15 @@ type ProcessMetricsSet struct {
 	processMetrics map[int]*PrometheusProcessMetrics
 	namespace      string
 	procBinaryName string
-	procArgName    string
+	nameFlag       string
 }
 
-func NewProcessMetricsSet(namespace, procBinaryName, procArgName string) *ProcessMetricsSet {
+func NewProcessMetricsSet(namespace, procBinaryName, nameFlag string) *ProcessMetricsSet {
 	return &ProcessMetricsSet{
 		processMetrics: make(map[int]*PrometheusProcessMetrics),
 		namespace:      namespace,
 		procBinaryName: procBinaryName,
-		procArgName:    procArgName,
+		nameFlag:       nameFlag,
 	}
 }
 
@@ -31,7 +30,7 @@ func (set *ProcessMetricsSet) UpdateMonitoredSet() {
 		panic("called update on disposed ProcessMetricsSet")
 	}
 	processIds := findProcesses(set.procBinaryName)
-	errs := AdjustMetricsMap(set.processMetrics, processIds, set.namespace)
+	errs := AdjustMetricsMap(set.processMetrics, processIds, set.namespace, set.nameFlag)
 	for _, err := range errs {
 		log.Warn(fmt.Sprintf("Could not report metrics for process: %v.", err))
 	}
@@ -52,7 +51,6 @@ func findProcesses(processName string) (pids map[int]ps.Process) {
 	}
 	for _, proc := range procs {
 		name := proc.Executable()
-		fmt.Println(name)
 		if processName == "" || filepath.Base(name) == processName {
 			pid := proc.Pid()
 			pids[pid] = proc
@@ -61,10 +59,10 @@ func findProcesses(processName string) (pids map[int]ps.Process) {
 	return pids
 }
 
-func AdjustMetricsMap(metricMap map[int]*PrometheusProcessMetrics, pids map[int]ps.Process, metricNamespace string) (errs []error) {
+func AdjustMetricsMap(metricMap map[int]*PrometheusProcessMetrics, pids map[int]ps.Process, metricNamespace string, nameFlag string) (errs []error) {
 	removePids, newPids := FindPidDifferences(metricMap, pids)
 	for _, pid := range newPids {
-		name, err := procDescriptiveName(pid)
+		name, err := procDescriptiveName(pid, nameFlag)
 		if err != nil {
 			errs = append(errs, fmt.Errorf("failed to get descriptive process name for PID %d: %w", pid, err))
 			continue
@@ -82,7 +80,7 @@ func AdjustMetricsMap(metricMap map[int]*PrometheusProcessMetrics, pids map[int]
 		m := metricMap[pid]
 		m.Unregister()
 		delete(metricMap, pid)
-		log.Infof("Stopped monitoring of process with PID %d.", pids[pid].Pid())
+		log.Infof("Stopped monitoring of process with PID %d.", pid)
 	}
 	return errs
 }
@@ -116,7 +114,7 @@ func updateMetrics(pm *PrometheusProcessMetrics, withPid int) {
 	pm.Set(processMetrics)
 }
 
-func procDescriptiveName(pid int) (string, error) {
+func procDescriptiveName(pid int, nameFlag string) (string, error) {
 	proc, err := process.NewProcess(int32(pid))
 	if err != nil {
 		return "", err
@@ -125,23 +123,25 @@ func procDescriptiveName(pid int) (string, error) {
 	if err != nil {
 		return "", err
 	}
-	return descriptiveNameFromArgs(args)
+	return descriptiveNameFromArgs(args, nameFlag)
 }
 
-func descriptiveNameFromArgs(args []string) (string, error) {
+func descriptiveNameFromArgs(args []string, flagName string) (string, error) {
 	if len(args) <= 1 {
 		return "", fmt.Errorf("too few arguments")
 	}
 	args = args[1:]
-	flagSet := flag.NewFlagSet("", flag.ContinueOnError)
-	flagSet.Usage = func() {}
-	name := flagSet.String("name", "", "")
-	err := flagSet.Parse(args)
-	if err != nil {
-		return "", err
+	nextIsName := false
+	for _, arg := range args {
+		if nextIsName {
+			return arg, nil
+		}
+		if arg == "-"+flagName || arg == "--"+flagName {
+			nextIsName = true
+		}
 	}
-	if *name == "" {
-		return "", fmt.Errorf("name not found or empty")
+	if nextIsName {
+		return "", fmt.Errorf("no value for flag \"%s\" in args %v", flagName, args)
 	}
-	return *name, nil
+	return "", fmt.Errorf("no flag \"%s\" in args %v", flagName, args)
 }

cmd/exporter/metrics/prom_proc_metrics_set.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+)
+
+const dummyFilePath = "dummyfile"
+
+func main() {
+	defer os.Remove(dummyFilePath)
+	writeTestFile()
+	fmt.Printf(".")
+	ioutil.ReadAll(os.Stdin)
+}
+
+func writeTestFile() {
+	f, err := os.OpenFile(dummyFilePath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0600)
+	if err != nil {
+		panic(err)
+	}
+	defer f.Close()
+	f.WriteString("What a beautiful string") // 23 bytes
+}

test/dummy/main.go

@@ -0,0 +1,65 @@
+package integration
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"testing"
+)
+
+func TestIntegration(t *testing.T) {
+	const port = "8771"
+	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")
+	err := cmd.Start()
+	if err != nil {
+		panic(err)
+	}
+	cmdDummy := exec.Command("proc_exporter_integration_dummy", "-name", "iamdummy")
+	dummyReader, err := cmdDummy.StdoutPipe()
+	if err != nil {
+		panic(err)
+	}
+	dummyWriter, err := cmdDummy.StdinPipe()
+	if err != nil {
+		panic(err)
+	}
+	err = cmdDummy.Start()
+	if err != nil {
+		panic(err)
+	}
+	b := make([]byte, 1, 1)
+	_, err = io.ReadAtLeast(dummyReader, b, 1)
+	if err != nil {
+		panic(err)
+	}
+	resp, err := http.Get("http://localhost:" + port)
+	if err != nil {
+		panic(err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		panic(fmt.Sprintf("got code %d when %d expected", resp.StatusCode, http.StatusOK))
+	}
+	err = dummyWriter.Close()
+	if err != nil {
+		panic(err)
+	}
+	err = cmdDummy.Wait()
+	if err != nil {
+		panic(err)
+	}
+
+}
+
+func run(command string, args ...string) {
+	cmd := exec.Command(command, args...)
+	err := cmd.Run()
+	if err != nil {
+		panic(err)
+	}
+}