main.go.orig

package main

import (
	"errors"
	"fmt"
	"log"
	"math/rand"
	"net/http"
	"time"

	"github.com/autometrics-dev/autometrics-go/prometheus/autometrics"
	"github.com/autometrics-dev/autometrics-go/prometheus/midhttp"
	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/client_golang/prometheus/promhttp"
)

// This should be `//go:generate autometrics` in practice. Those are hacks to get the example working, see
// README
//go:generate go run ../../../cmd/autometrics/main.go

var (
	Version = "development"
	Commit  = "n/a"
	Branch  string
)

func main() {
	rand.Seed(time.Now().UnixNano())

	// Everything in BuildInfo is optional.
	// You can also use any string variable whose value is
	// injected at build time by ldflags.
	autometrics.Init(
		nil,
		autometrics.DefBuckets,
		autometrics.BuildInfo{
			Version: Version,
			Commit:  Commit,
			Branch:  Branch,
		},
	)

	http.HandleFunc("/", errorable(indexHandler))
	// Wrapping a route in Autometrics middleware
	http.Handle("/random-error", midhttp.Autometrics(
		http.HandlerFunc(randomErrorHandler),
		autometrics.WithSloName("API"),
		autometrics.WithAlertSuccess(90),
	))
	http.Handle("/metrics", promhttp.HandlerFor(
		prometheus.DefaultGatherer,
		promhttp.HandlerOpts{
			EnableOpenMetrics: true,
		}))

	log.Println("binding on http://localhost:62086")
	log.Fatal(http.ListenAndServe(":62086", nil))
}

// indexHandler handles the / route.
//
// It always succeeds and says hello.
//
//autometrics:inst --slo "API" --latency-target 99 --latency-ms 5
func indexHandler(w http.ResponseWriter, r *http.Request) error {

	msSleep :=  rand.Intn(200)
	time.Sleep(time.Duration(msSleep) * time.Millisecond)

	_, err := fmt.Fprintf(w, "Slept %v ms\n", msSleep)

	return err
}

var handlerError = errors.New("failed to handle request")

// randomErrorHandler handles the /random-error route.
//
// It returns an error around 90% of the time.
func randomErrorHandler(w http.ResponseWriter, r *http.Request) {
	isOk := rand.Intn(10) == 0

	if !isOk {
		http.Error(w, handlerError.Error(), http.StatusInternalServerError)
	} else {
		w.WriteHeader(http.StatusOK)
	}

	return
}

// errorable is a wrapper to allow using functions that return `error` in route handlers.
func errorable(handler func(w http.ResponseWriter, r *http.Request) error) func(w http.ResponseWriter, r *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		if err := handler(w, r); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
	}
}