// Graph takes an OpenTSDB request data structure and queries OpenTSDB. Use the
// json parameter to pass JSON. Use the b64 parameter to pass base64-encoded
// JSON.
func Graph(t miniprofiler.Timer, w http.ResponseWriter, r *http.Request) (interface{}, error) {
j := []byte(r.FormValue("json"))
if bs := r.FormValue("b64"); bs != "" {
b, err := base64.StdEncoding.DecodeString(bs)
if err != nil {
return nil, err
}
j = b
}
if len(j) == 0 {
return nil, fmt.Errorf("either json or b64 required")
}
oreq, err := opentsdb.RequestFromJSON(j)
if err != nil {
return nil, err
}
if ads_v := r.FormValue("autods"); ads_v != "" {
ads_i, err := strconv.Atoi(ads_v)
if err != nil {
return nil, err
}
if err := oreq.AutoDownsample(ads_i); err != nil {
return nil, err
}
}
ar := make(map[int]bool)
for _, v := range r.Form["autorate"] {
if i, err := strconv.Atoi(v); err == nil {
ar[i] = true
}
}
queries := make([]string, len(oreq.Queries))
var start, end string
var startT, endT time.Time
if s, ok := oreq.Start.(string); ok && strings.Contains(s, "-ago") {
startT, err = opentsdb.ParseTime(s)
if err != nil {
return nil, err
}
start = strings.TrimSuffix(s, "-ago")
}
if s, ok := oreq.End.(string); ok && strings.Contains(s, "-ago") {
endT, err = opentsdb.ParseTime(s)
if err != nil {
return nil, err
}
end = strings.TrimSuffix(s, "-ago")
}
if start == "" && end == "" {
s, sok := oreq.Start.(int64)
e, eok := oreq.End.(int64)
if sok && eok {
start = fmt.Sprintf("%vs", e-s)
startT = time.Unix(s, 0)
endT = time.Unix(e, 0)
if err != nil {
return nil, err
}
}
}
if endT.Equal(time.Time{}) {
endT = time.Now().UTC()
}
m_units := make(map[string]string)
for i, q := range oreq.Queries {
if ar[i] {
meta, err := schedule.MetadataMetrics(q.Metric)
if err != nil {
return nil, err
}
if meta == nil {
return nil, fmt.Errorf("no metadata for %s: cannot use auto rate", q)
}
if meta.Unit != "" {
m_units[q.Metric] = meta.Unit
}
if meta.Rate != "" {
switch meta.Rate {
case metadata.Gauge:
// ignore
case metadata.Rate:
q.Rate = true
case metadata.Counter:
q.Rate = true
q.RateOptions = opentsdb.RateOptions{
Counter: true,
ResetValue: 1,
}
default:
return nil, fmt.Errorf("unknown metadata rate: %s", meta.Rate)
}
}
}
queries[i] = fmt.Sprintf(`q("%v", "%v", "%v")`, q, start, end)
if !schedule.SystemConf.GetTSDBContext().Version().FilterSupport() {
if err := schedule.Search.Expand(q); err != nil {
return nil, err
}
}
}
var tr opentsdb.ResponseSet
b, _ := json.MarshalIndent(oreq, "", " ")
t.StepCustomTiming("tsdb", "query", string(b), func() {
h := schedule.SystemConf.GetTSDBHost()
if h == "" {
err = fmt.Errorf("tsdbHost not set")
return
}
tr, err = oreq.Query(h)
})
if err != nil {
return nil, err
}
cs, err := makeChart(tr, m_units)
if err != nil {
return nil, err
}
if _, present := r.Form["png"]; present {
c := chart.ScatterChart{
Title: fmt.Sprintf("%v - %v", oreq.Start, queries),
}
c.XRange.Time = true
if min, err := strconv.ParseFloat(r.FormValue("min"), 64); err == nil {
c.YRange.MinMode.Fixed = true
c.YRange.MinMode.Value = min
}
if max, err := strconv.ParseFloat(r.FormValue("max"), 64); err == nil {
c.YRange.MaxMode.Fixed = true
c.YRange.MaxMode.Value = max
}
for ri, r := range cs {
pts := make([]chart.EPoint, len(r.Data))
for idx, v := range r.Data {
pts[idx].X = v[0]
pts[idx].Y = v[1]
}
slice.Sort(pts, func(i, j int) bool {
return pts[i].X < pts[j].X
})
c.AddData(r.Name, pts, chart.PlotStyleLinesPoints, sched.Autostyle(ri))
}
w.Header().Set("Content-Type", "image/svg+xml")
white := color.RGBA{0xff, 0xff, 0xff, 0xff}
const width = 800
const height = 600
s := svg.New(w)
s.Start(width, height)
s.Rect(0, 0, width, height, "fill: #ffffff")
sgr := svgg.AddTo(s, 0, 0, width, height, "", 12, white)
c.Plot(sgr)
s.End()
return nil, nil
}
var a []annotate.Annotation
warnings := []string{}
if schedule.SystemConf.AnnotateEnabled() {
a, err = annotateBackend.GetAnnotations(&startT, &endT)
if err != nil {
warnings = append(warnings, fmt.Sprintf("unable to get annotations: %v", err))
}
}
return struct {
Queries []string
Series []*chartSeries
Annotations []annotate.Annotation
Warnings []string
}{
queries,
cs,
a,
warnings,
}, nil
}
func InitStatsHUD() {
plots := chart.ScatterChart{Title: "", Options: glchart.DarkStyle}
start := time.Now()
l := float64(start.UnixNano())
r := float64(start.Add(2 * time.Second).UnixNano())
plots.XRange.Fixed(l, r, 1e9)
plots.YRange.Fixed(0.1, 100, 10)
plots.XRange.TicSetting.Tics, plots.YRange.TicSetting.Tics = 1, 1
plots.XRange.TicSetting.Mirror, plots.YRange.TicSetting.Mirror = 2, 2
plots.XRange.TicSetting.Grid, plots.YRange.TicSetting.Grid = 2, 2
plots.YRange.ShowZero = true
//plots.XRange.Log = true
//plots.YRange.Log = true
plots.Key.Pos, plots.Key.Cols = "obc", 3
plots.XRange.TicSetting.Format = func(f float64) string {
t := time.Unix(int64(f)/1e9, int64(f)%1e9)
return fmt.Sprintf("%.3v", time.Since(t))
}
memhelper.GetMaxRSS()
var gpufree float64
gpupoll := gpuinfo.PollGPUMemory()
go func() {
for gpustatus := range gpupoll {
gpufree = float64(memhelper.ByteSize(gpustatus.Free()) * memhelper.MiB)
}
}()
statistics := &Statistics{}
statistics.Add(&plots, "GPU Free", "#FF9F00", func() float64 { return gpufree })
statistics.Add(&plots, "SpareRAM()", "#ff0000", func() float64 { return float64(SpareRAM() * 1e6) })
statistics.Add(&plots, "MaxRSS", "#FFE240", func() float64 { return float64(memhelper.GetMaxRSS()) })
statistics.Add(&plots, "Heap Idle", "#33ff33", func() float64 { return float64(memstats.HeapIdle) })
statistics.Add(&plots, "Alloc", "#FF6600", func() float64 { return float64(memstats.Alloc) })
statistics.Add(&plots, "Heap Alloc", "#006699", func() float64 { return float64(memstats.HeapAlloc) })
statistics.Add(&plots, "Sys", "#996699", func() float64 { return float64(memstats.Sys) })
statistics.Add(&plots, "System Free", "#3333ff", func() float64 { return float64(SystemFree()) })
statistics.Add(&plots, "nBlocks x 1e6", "#FFCC00", func() float64 { return float64(nblocks * 1e6) })
statistics.Add(&plots, "nDrawn x 1e6", "#9C8AA5", func() float64 { return float64(blocks_rendered * 1e6) })
go func() {
top := 0.
i := -1
for {
time.Sleep(250 * time.Millisecond)
max := statistics.Update()
if max > top {
top = max
}
i++
if i%4 != 0 {
continue
}
segment := float64(1e9)
if time.Since(start) > 10*time.Second {
segment = 5e9
}
if time.Since(start) > 1*time.Minute {
segment = 30e9
}
// Update axis limits
nr := float64(time.Now().Add(2 * time.Second).UnixNano())
plots.XRange.Fixed(l, nr, segment)
plots.YRange.Fixed(-1e9, top*1.1, 500e6)
}
}()
const pw, ph = 640, 480
scalex, scaley := 0.4, 0.5
chart_gfxcontext := glchart.New(pw, ph, "", 10, color.RGBA{})
StatsHUD = func() {
glh.With(glh.Matrix{gl.PROJECTION}, func() {
gl.LoadIdentity()
gl.Translated(1-scalex, scaley-1, 0)
gl.Scaled(scalex, scaley, 1)
gl.Ortho(0, pw, ph, 0, -1, 1)
gl.Translated(0, -50, 0)
glh.With(glh.Attrib{gl.ENABLE_BIT}, func() {
gl.Disable(gl.DEPTH_TEST)
glh.With(&Timer{Name: "Chart"}, func() {
plots.Plot(chart_gfxcontext)
})
})
})
}
// TODO: figure out why this is broken
DumpStatsHUD = func() {
s2f, _ := os.Create("statshud-dump.svg")
mysvg := svg.New(s2f)
mysvg.Start(1600, 800)
mysvg.Rect(0, 0, 2000, 800, "fill: #ffffff")
sgr := svgg.New(mysvg, 2000, 800, "Arial", 18,
color.RGBA{0xff, 0xff, 0xff, 0xff})
sgr.Begin()
plots.Plot(sgr)
sgr.End()
mysvg.End()
s2f.Close()
log.Print("Saved statshud-dump.svg")
}
//log.Print("InitStatsHUD()")
}
