Import example app from juliusv/prometheus_workshop

Author: Matthias Rampke

example_golang/client.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+	"bytes"
+	"flag"
+	"math"
+	"net/http"
+	"time"
+)
+
+var oscillationPeriod = flag.Duration("oscillation-period", 5*time.Minute, "The duration of the rate oscillation period.")
+
+func startClient(servAddr string) {
+
+	oscillationFactor := func() float64 {
+		return 2 + math.Sin(math.Sin(2*math.Pi*float64(time.Since(start))/float64(*oscillationPeriod)))
+	}
+
+	ignoreRequest := func(resp *http.Response, err error) {
+		if err != nil {
+			return
+		}
+		resp.Body.Close()
+	}
+
+	// GET /api/foo.
+	go func() {
+		for {
+			ignoreRequest(http.Get("http://" + servAddr + "/api/foo"))
+			time.Sleep(time.Duration(10*oscillationFactor()) * time.Millisecond)
+		}
+	}()
+	// POST /api/foo.
+	go func() {
+		for {
+			ignoreRequest(http.Post("http://"+servAddr+"/api/foo", "text/plain", &bytes.Buffer{}))
+			time.Sleep(time.Duration(150*oscillationFactor()) * time.Millisecond)
+		}
+	}()
+	// GET /api/bar.
+	go func() {
+		for {
+			ignoreRequest(http.Get("http://" + servAddr + "/api/bar"))
+			time.Sleep(time.Duration(20*oscillationFactor()) * time.Millisecond)
+		}
+	}()
+	// POST /api/bar.
+	go func() {
+		for {
+			ignoreRequest(http.Post("http://"+servAddr+"/api/bar", "text/plain", &bytes.Buffer{}))
+			time.Sleep(time.Duration(100*oscillationFactor()) * time.Millisecond)
+		}
+	}()
+	// GET /api/nonexistent.
+	go func() {
+		for {
+			ignoreRequest(http.Get("http://" + servAddr + "/api/nonexistent"))
+			time.Sleep(time.Duration(500*oscillationFactor()) * time.Millisecond)
+		}
+	}()
+}

example_golang/main.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"flag"
+	"net/http"
+	"os"
+	"time"
+
+	"github.com/justinas/alice"
+	"github.com/streadway/handy/report"
+)
+
+var (
+	addr = flag.String("listen-address", ":8080", "The address to listen on for HTTP requests.")
+
+	start = time.Now()
+)
+
+func main() {
+	flag.Parse()
+
+	http.HandleFunc("/api/", handleAPI)
+
+	// Log every received HTTP request to stdout.
+	go http.ListenAndServe(*addr, alice.New(
+		report.JSONMiddleware(os.Stdout),
+	).Then(http.DefaultServeMux))
+
+	startClient(*addr)
+
+	select {}
+}

example_golang/server.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	"math/rand"
+	"net/http"
+	_ "net/http/pprof"
+	"time"
+)
+
+type responseOpts struct {
+	baseLatency time.Duration
+	errorRatio  float64
+
+	// Whenever 10*outageDuration has passed, an outage will be simulated
+	// that lasts for outageDuration. During the outage, errorRatio is
+	// increased by a factor of 10, and baseLatency by a factor of 3.  At
+	// start-up time, an outage is simulated, too (so that you can see the
+	// effects right ahead and don't have to wait for 10*outageDuration).
+	outageDuration time.Duration
+}
+
+var opts = map[string]map[string]responseOpts{
+	"/api/foo": map[string]responseOpts{
+		"GET": responseOpts{
+			baseLatency:    10 * time.Millisecond,
+			errorRatio:     0.005,
+			outageDuration: 23 * time.Second,
+		},
+		"POST": responseOpts{
+			baseLatency:    20 * time.Millisecond,
+			errorRatio:     0.02,
+			outageDuration: time.Minute,
+		},
+	},
+	"/api/bar": map[string]responseOpts{
+		"GET": responseOpts{
+			baseLatency:    15 * time.Millisecond,
+			errorRatio:     0.0025,
+			outageDuration: 13 * time.Second,
+		},
+		"POST": responseOpts{
+			baseLatency:    50 * time.Millisecond,
+			errorRatio:     0.01,
+			outageDuration: 47 * time.Second,
+		},
+	},
+}
+
+func handleAPI(w http.ResponseWriter, r *http.Request) {
+	pathOpts, ok := opts[r.URL.Path]
+	if !ok {
+		http.Error(w, "Not Found", http.StatusNotFound)
+		return
+	}
+	methodOpts, ok := pathOpts[r.Method]
+	if !ok {
+		http.Error(w, "Method not Allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	latencyFactor := time.Duration(1)
+	errorFactor := 1.
+	if time.Since(start)%(10*methodOpts.outageDuration) < methodOpts.outageDuration {
+		latencyFactor *= 3
+		errorFactor *= 10
+	}
+	time.Sleep(
+		(methodOpts.baseLatency + time.Duration(rand.NormFloat64()*float64(methodOpts.baseLatency)/10)) * latencyFactor,
+	)
+	if rand.Float64() <= methodOpts.errorRatio*errorFactor {
+		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+	}
+}