// addCalculatedTraces adds the traces returned from evaluating the given // formula over the given tile to the QueryResponse. func addCalculatedTraces(qr *QueryResponse, tile *tiling.Tile, formula string) error { ctx := parser.NewContext(tile) traces, err := ctx.Eval(formula) if err != nil { return fmt.Errorf("Failed to evaluate formula %q: %s", formula, err) } hasFormula := false for _, tr := range traces { if tiling.IsFormulaID(tr.Params()["id"]) { hasFormula = true } tg := traceGuiFromTrace(tr, tr.Params()["id"], tile) qr.Traces = append(qr.Traces, tg) } if !hasFormula { // If we haven't added the formula trace to the response yet, add it in now. f := types.NewPerfTraceN(len(tile.Commits)) tg := traceGuiFromTrace(f, tiling.AsFormulaID(formula), tile) qr.Traces = append(qr.Traces, tg) } return nil }
// queryHandler handles queries for and about traces. // // Queries look like: // // /query/0/-1/?arch=Arm7&arch=x86&scale=1 // // Where they keys and values in the query params are from the ParamSet. // Repeated parameters are matched via OR. I.e. the above query will include // anything that has an arch of Arm7 or x86. // // The first two path paramters are tile scale and tile number, where -1 means // the last tile at the given scale. // // The normal response is JSON of the form: // // { // "matches": 187, // } // // If the path is: // // /query/0/-1/traces/?arch=Arm7&arch=x86&scale=1 // // Then the response is the set of traces that match that query. // // { // "traces": [ // { // // All of these keys and values should be exactly what Flot consumes. // data: [[1, 1.1], [20, 30]], // label: "key1", // _params: {"os: "Android", ...} // }, // { // data: [[1.2, 2.1], [20, 35]], // label: "key2", // _params: {"os: "Android", ...} // } // ] // } // // If the path is: // // /query/0/-1/traces/?__shortcut=11 // // Then the traces in the shortcut with that ID are returned, along with the // git hash at the step function, if the shortcut came from an alert. // // { // "traces": [ // { // // All of these keys and values should be exactly what Flot consumes. // data: [[1, 1.1], [20, 30]], // label: "key1", // _params: {"os: "Android", ...} // }, // ... // ], // "hash": "a012334...", // } // // // TODO Add ability to query across a range of tiles. func queryHandler(w http.ResponseWriter, r *http.Request) { glog.Infof("Query Handler: %q\n", r.URL.Path) match := queryHandlerPath.FindStringSubmatch(r.URL.Path) glog.Infof("%#v", match) if r.Method != "GET" || match == nil || len(match) != 4 { http.NotFound(w, r) return } if err := r.ParseForm(); err != nil { util.ReportError(w, r, err, "Failed to parse query params.") } tileScale, err := strconv.ParseInt(match[1], 10, 0) if err != nil { util.ReportError(w, r, err, "Failed parsing tile scale.") return } tileNumber, err := strconv.ParseInt(match[2], 10, 0) if err != nil { util.ReportError(w, r, err, "Failed parsing tile number.") return } glog.Infof("tile: %d %d", tileScale, tileNumber) tile := masterTileBuilder.GetTile() w.Header().Set("Content-Type", "application/json") ret := &QueryResponse{ Traces: []*tiling.TraceGUI{}, Hash: "", } if match[3] == "" { // We only want the count. total := 0 for _, tr := range tile.Traces { if tiling.Matches(tr, r.Form) { total++ } } glog.Info("Count: ", total) inc := json.NewEncoder(w) if err := inc.Encode(map[string]int{"matches": total}); err != nil { glog.Errorf("Failed to write or encode output: %s", err) return } } else { // We want the matching traces. shortcutID := r.Form.Get("__shortcut") if shortcutID != "" { sh, err := shortcut.Get(shortcutID) if err != nil { http.NotFound(w, r) return } if sh.Issue != "" { if tile, err = trybot.TileWithTryData(tile, sh.Issue); err != nil { util.ReportError(w, r, err, "Failed to populate shortcut data with trybot result.") return } } ret.Hash = sh.Hash for _, k := range sh.Keys { if tr, ok := tile.Traces[k]; ok { tg := traceGuiFromTrace(tr.(*types.PerfTrace), k, tile) if tg != nil { ret.Traces = append(ret.Traces, tg) } } else if tiling.IsFormulaID(k) { // Re-evaluate the formula and add all the results to the response. formula := tiling.FormulaFromID(k) if err := addCalculatedTraces(ret, tile, formula); err != nil { glog.Errorf("Failed evaluating formula (%q) while processing shortcut %s: %s", formula, shortcutID, err) } } else if strings.HasPrefix(k, "!") { glog.Errorf("A calculated trace is slipped through: (%s) in shortcut %s: %s", k, shortcutID, err) } } } else { for key, tr := range tile.Traces { if tiling.Matches(tr, r.Form) { tg := traceGuiFromTrace(tr.(*types.PerfTrace), key, tile) if tg != nil { ret.Traces = append(ret.Traces, tg) } } } } enc := json.NewEncoder(w) if err := enc.Encode(ret); err != nil { glog.Errorf("Failed to write or encode output: %s", err) return } } }