init

Author: akvlad

reader/controller/prof.go

@@ -204,6 +204,49 @@ func (pc *ProfController) Settings(w http.ResponseWriter, r *http.Request) {
 	pc.writeResponse(w, r, res)
 }
 
+func (pc *ProfController) Render(w http.ResponseWriter, r *http.Request) {
+	for _, param := range []string{"query", "from", "until"} {
+		if len(r.URL.Query()[param]) == 0 || r.URL.Query()[param][0] == "" {
+			defaultError(w, 400, fmt.Sprintf("Missing required parameter: %s", param))
+			return
+		}
+	}
+
+	query := r.URL.Query()["query"][0]
+	var from, to time.Time
+	for _, v := range [][2]any{{"from", &from}, {"until", &to}} {
+		strVal := r.URL.Query()[v[0].(string)][0]
+		iVal, err := strconv.ParseInt(strVal, 10, 64)
+		if err != nil {
+			defaultError(w, 400, fmt.Sprintf("Invalid value for %s: %s", html.EscapeString(v[0].(string)), html.EscapeString(strVal)))
+			return
+		}
+		*(v[1].(*time.Time)) = time.Unix(iVal, 0)
+	}
+
+	format := r.URL.Query().Get("format")
+
+	if format == "dot" {
+		dot, err := pc.ProfService.RenderDot(r.Context(), query, from, to)
+		if err != nil {
+			defaultError(w, 500, err.Error())
+			return
+		}
+		w.Header().Set("Content-Type", "text/vnd.graphviz; charset=utf-8")
+		w.Write([]byte(dot))
+		return
+	}
+
+	fb, err := pc.ProfService.Render(r.Context(), query, from, to)
+	if err != nil {
+		defaultError(w, 500, err.Error())
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(fb.FlamebearerProfileV1)
+}
+
 func (pc *ProfController) RenderDiff(w http.ResponseWriter, r *http.Request) {
 	for _, param := range []string{"leftQuery", "leftFrom", "leftUntil", "rightQuery", "rightFrom", "rightUntil"} {
 		if len(r.URL.Query()[param]) == 0 || r.URL.Query()[param][0] == "" {

reader/router/prof.go

@@ -21,6 +21,6 @@ func RouteProf(app *mux.Router, dataSession model.IDBRegistry) {
 	app.HandleFunc(prof.QuerierService_GetProfileStats_FullMethodName, ctrl.ProfileStats).Methods("POST", "OPTIONS")
 	app.HandleFunc(prof.SettingsService_Get_FullMethodName, ctrl.Settings).Methods("POST", "OPTIONS")
 	app.HandleFunc(prof.QuerierService_AnalyzeQuery_FullMethodName, ctrl.AnalyzeQuery).Methods("POST", "OPTIONS")
-	// app.HandleFunc("/pyroscope/render", ctrl.NotImplemented).Methods("GET")
+	app.HandleFunc("/pyroscope/render", ctrl.Render).Methods("GET", "OPTIONS")
 	app.HandleFunc("/pyroscope/render-diff", ctrl.RenderDiff).Methods("GET", "OPTIONS")
 }

reader/service/prof.go

@@ -421,6 +421,75 @@ func (ps *ProfService) Settings(ctx context.Context) (*prof.GetSettingsResponse,
 	}, nil
 }
 
+func (ps *ProfService) Render(ctx context.Context, strQuery string, from, to time.Time) (*Flamebearer, error) {
+	db, err := ps.DataSession.GetDB(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	strTypeId, strScript, err := ps.detachTypeId(strQuery)
+	if err != nil {
+		return nil, err
+	}
+
+	scripts, err := ps.parseScripts([]string{strScript})
+	if err != nil {
+		return nil, err
+	}
+
+	typeId, err := shared.ParseTypeId(strTypeId)
+	if err != nil {
+		return nil, err
+	}
+
+	tree, err := ps.getTree(ctx, scripts[0], &typeId, from, to, db)
+	if err != nil {
+		return nil, err
+	}
+
+	sampleTypeUnit := fmt.Sprintf("%s:%s", typeId.SampleType, typeId.SampleUnit)
+	levels := tree.BFS(sampleTypeUnit)
+
+	flameGraph := &prof.FlameGraph{
+		Names:   tree.Names,
+		Levels:  levels,
+		Total:   tree.Total()[0],
+		MaxSelf: tree.MaxSelf()[0],
+	}
+
+	return ps.flameGraphToFlameBearer(flameGraph, &typeId), nil
+}
+
+func (ps *ProfService) RenderDot(ctx context.Context, strQuery string, from, to time.Time) (string, error) {
+	db, err := ps.DataSession.GetDB(ctx)
+	if err != nil {
+		return "", err
+	}
+
+	strTypeId, strScript, err := ps.detachTypeId(strQuery)
+	if err != nil {
+		return "", err
+	}
+
+	scripts, err := ps.parseScripts([]string{strScript})
+	if err != nil {
+		return "", err
+	}
+
+	typeId, err := shared.ParseTypeId(strTypeId)
+	if err != nil {
+		return "", err
+	}
+
+	tree, err := ps.getTree(ctx, scripts[0], &typeId, from, to, db)
+	if err != nil {
+		return "", err
+	}
+
+	sampleTypeUnit := fmt.Sprintf("%s:%s", typeId.SampleType, typeId.SampleUnit)
+	return tree.ToDot(sampleTypeUnit, strTypeId), nil
+}
+
 func (ps *ProfService) RenderDiff(ctx context.Context,
 	strLeftQuery string, strRightQuery string,
 	leftFrom time.Time, rightFrom time.Time,

reader/service/prof_tree.go

@@ -1,7 +1,9 @@
 package service
 
 import (
+	"fmt"
 	"sort"
+	"strings"
 
 	"github.com/metrico/qryn/v4/reader/prof"
 )
@@ -457,3 +459,127 @@ func findNode(nodeID uint64, children []*TreeNodeV2) int {
 	}
 	return -1
 }
+
+// ToDot converts the tree to Graphviz DOT format suitable for flamegraph visualization and AI analysis.
+// sampleType should be in "type:unit" form (e.g. "cpu:nanoseconds").
+// profileName is used as the graph title (e.g. "process_cpu:cpu:nanoseconds:cpu:nanoseconds").
+func (t *Tree) ToDot(sampleType string, profileName string) string {
+	sampleTypeIndex := -1
+	for i, st := range t.SampleTypes {
+		if st == sampleType {
+			sampleTypeIndex = i
+			break
+		}
+	}
+	if sampleTypeIndex == -1 {
+		return "digraph flamegraph {}\n"
+	}
+
+	total := t.Total()
+	var totalVal int64
+	if len(total) > sampleTypeIndex {
+		totalVal = total[sampleTypeIndex]
+	}
+
+	pct := func(v int64) float64 {
+		if totalVal == 0 {
+			return 0
+		}
+		return float64(v) / float64(totalVal) * 100
+	}
+	// weight is an integer 1–100 proportional to the child's share of total samples.
+	// Graphviz requires weight >= 1 and works best with small integers.
+	edgeWeight := func(v int64) int {
+		w := int(pct(v))
+		if w < 1 {
+			w = 1
+		}
+		return w
+	}
+
+	// Map raw NodeIDs to compact sequential integers so Graphviz node names stay small.
+	seqID := make(map[uint64]int)
+	nextID := 0
+	assignID := func(nodeID uint64) int {
+		if id, ok := seqID[nodeID]; ok {
+			return id
+		}
+		seqID[nodeID] = nextID
+		nextID++
+		return nextID - 1
+	}
+
+	var sb strings.Builder
+	sb.WriteString(fmt.Sprintf("digraph %q {\n", profileName))
+	sb.WriteString("  node [shape=box fontsize=12];\n")
+	sb.WriteString("  edge [fontsize=10];\n")
+	rootSeq := assignID(0)
+	sb.WriteString(fmt.Sprintf("  N%d [label=%q style=filled fillcolor=\"#eeeeee\"];\n",
+		rootSeq, fmt.Sprintf("total\nsamples: %d (100%%)", totalVal)))
+
+	visited := make(map[uint64]bool)
+	visited[0] = true
+	queue := []uint64{0}
+
+	for len(queue) > 0 {
+		parentID := queue[0]
+		queue = queue[1:]
+		parentSeq := seqID[parentID]
+
+		children, ok := t.Nodes[parentID]
+		if !ok {
+			continue
+		}
+
+		for _, child := range children {
+			if visited[child.NodeID] {
+				continue
+			}
+			visited[child.NodeID] = true
+			childSeq := assignID(child.NodeID)
+
+			name := "n/a"
+			if idx, exists := t.NamesMap[child.FnID]; exists && idx < len(t.Names) {
+				name = t.Names[idx]
+			}
+
+			selfVal := child.Self[sampleTypeIndex]
+			childTotal := child.Total[sampleTypeIndex]
+			label := fmt.Sprintf("%s\ntotal: %d (%.1f%%) self: %d (%.1f%%)",
+				name, childTotal, pct(childTotal), selfVal, pct(selfVal))
+
+			fillColor := heatColor(selfVal, totalVal)
+
+			sb.WriteString(fmt.Sprintf("  N%d [label=%q style=filled fillcolor=%q];\n",
+				childSeq, label, fillColor))
+			sb.WriteString(fmt.Sprintf("  N%d -> N%d [label=%q weight=%d];\n",
+				parentSeq, childSeq,
+				fmt.Sprintf("%.1f%%", pct(childTotal)),
+				edgeWeight(childTotal)))
+
+			queue = append(queue, child.NodeID)
+		}
+	}
+
+	sb.WriteString("}\n")
+	return sb.String()
+}
+
+// heatColor returns a hex fill color for a DOT node based on self-sample fraction.
+// 0% self → light gray, 100% self → red.
+func heatColor(self, total int64) string {
+	if total == 0 || self == 0 {
+		return "#f8f8f8"
+	}
+	ratio := float64(self) / float64(total)
+	if ratio > 1 {
+		ratio = 1
+	}
+	r := 248 - int(ratio*float64(248-255))
+	if r > 255 {
+		r = 255
+	}
+	g := int(248 - ratio*248)
+	b := int(248 - ratio*248)
+	return fmt.Sprintf("#%02x%02x%02x", r, g, b)
+}