Display performance stats of the current page in a bar on top

perf/perf.go

@@ -0,0 +1,195 @@
package perf
import (
	"context"
	"encoding/json"
	"fmt"
	"html/template"
	"log"
	"math/rand"
	"net/http"
	"strings"
	"sync"
	"time"
)
func init() {
	rand.Seed(time.Now().UnixNano())
}
type Perf struct {
	mu           sync.Mutex
	measurements map[string]map[string]interface{}
}
func NewPerf() *Perf {
	return &Perf{
		measurements: make(map[string]map[string]interface{}),
	}
}
type key int
var perfKey key = 0
func (p *Perf) MeasureRequest(req *http.Request) {
	id := p.RequestID(req)
	start := time.Now()
	ctx := req.Context()
	go func() {
		select {
		case <-ctx.Done():
			p.measure(id, "request-time", time.Since(start).String())
		}
		time.Sleep(1 * time.Second)
		p.Delete(id)
	}()
}
func (p *Perf) Measure(req *http.Request, key string, val interface{}) {
	p.measure(p.RequestID(req), key, val)
}
func (p *Perf) measure(id string, key string, val interface{}) {
	p.mu.Lock()
	data, ok := p.measurements[id]
	if !ok {
		data = make(map[string]interface{})
		p.measurements[id] = data
	}
	data[key] = val
	p.mu.Unlock()
}
func (p *Perf) RequestID(req *http.Request) string {
	id, ok := req.Context().Value(perfKey).(string)
	if !ok {
		data := make([]byte, 10)
		_, err := rand.Read(data)
		if err != nil {
			panic(err)
		}
		id = fmt.Sprintf("%x", data)
		*req = *req.WithContext(context.WithValue(req.Context(), perfKey, id))
	}
	return id
}
func (p *Perf) Measurements(id string) map[string]interface{} {
	p.mu.Lock()
	ms := p.measurements[id]
	p.mu.Unlock()
	return ms
}
func (p *Perf) Delete(id string) {
	p.mu.Lock()
	delete(p.measurements, id)
	p.mu.Unlock()
}
func (p *Perf) Size() int {
	p.mu.Lock()
	defer p.mu.Unlock()
	return len(p.measurements)
}
func (p *Perf) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	parts := strings.SplitN(req.URL.Path, "/", 3)
	if len(parts) < 3 {
		http.Error(w, "missing request id", http.StatusBadRequest)
		return
	}
	id := parts[2]
	perfData := p.Measurements(id)
	data, err := json.MarshalIndent(perfData, "", "  ")
	if err != nil {
		log.Fatal("marshaling perf data: ", err)
		http.Error(w, "internal server error", http.StatusInternalServerError)
		return
	}
	w.Header().Set("Content-Type", "application/json")
	w.Write(data)
}
func (p *Perf) Render(req *http.Request) template.HTML {
	return template.HTML(`<style>
body {
	transform: translate(0, 2.5em);
}
#performance-bar {
	display: flex;
	position: fixed;
	width: 100vw;
	transform: translate(-0.5em, -3em);
	padding: 0.75em;
	margin-bottom: 1em;
	background-color: #222;
	color: #ddd;
}
.performance-pair {
	margin-right: 1em;
	font-family: sans-serif;
}
.performance-value {
	color: #eee;
	font-weight: 600;
}
.performance-key {
	margin-right: 0.5em;
	color: #777;
}
</style>
` + `
<script>var performanceId = "` + p.RequestID(req) + `";
</script>
` + `
<script>
	var performanceBar = document.getElementById("performance-bar");
	var xhr = new XMLHttpRequest();
	xhr.open("GET", "/__performance__/" + performanceId);
	xhr.responseType = "json";
	xhr.onreadystatechange = ev => {
		if (xhr.readyState != XMLHttpRequest.DONE || xhr.status != 200) {
			return
		}
		var performanceData = xhr.response;
		if (performanceData == null) {
			performanceBar.style = "color: red;";
			performanceBar.textContent = "Could not load performance data";
		}
		Object.keys(performanceData).forEach(k => {
			var kv = document.createElement("div");
			kv.className = "performance-pair";
			var ke = document.createElement("span");
			ke.className = "performance-key";
			ke.textContent = k;
			kv.appendChild(ke);
			var ve = document.createElement("span");
			ve.className = "performance-value";
			ve.textContent = performanceData[k];
			kv.appendChild(ve);
			performanceBar.appendChild(kv);
		})
	};
	xhr.send();
</script>`)
}

quit.go

@@ -17,8 +17,12 @@ import (
	"github.com/libgit2/git2go"
	"github.com/russross/blackfriday"
	"github.com/heyLu/quit/perf"
)
var performance = perf.NewPerf()
func main() {
	repoPath := "."
	if len(os.Args) > 1 {
@@ -36,12 +40,17 @@ func main() {
	}
	http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
		performance.MeasureRequest(req)
		buf := new(bytes.Buffer)
		start := time.Now()
		err = repoTmpl.Execute(buf, map[string]interface{}{
			"RepoPath": path.Base(repoPath),
			"Repo":     NewFancyRepo(repo),
			"Style":    template.CSS(repoStyle),
			"RepoPath":    path.Base(repoPath),
			"Repo":        NewFancyRepo(repo),
			"Style":       template.CSS(repoStyle),
			"Performance": performance.Render(req),
		})
		performance.Measure(req, "template", time.Since(start).String())
		if err != nil {
			log.Println("rendering repo: ", err)
			http.Error(w, "internal server error", http.StatusInternalServerError)
@@ -49,6 +58,7 @@ func main() {
		}
		io.Copy(w, buf)
	})
	http.Handle("/__performance__/", performance)
	log.Fatal(http.ListenAndServe("localhost:12345", nil))
}
@@ -484,6 +494,8 @@ var repoTmpl = template.Must(template.New("").Funcs(repoFuncs).Parse(`<!doctype
	</head>
	<body>
		<section id="performance-bar"></section>
		<div id="container">
		<section id="repo" class="repo-info">
@@ -535,6 +547,8 @@ var repoTmpl = template.Must(template.New("").Funcs(repoFuncs).Parse(`<!doctype
		{{ end }}
		</div>
		{{ .Performance }}
	</body>
</html>
`))