p7 add attach-time trace dimension gating

1 files changed, 104 insertions, 3 deletions

diff --git a/internal/generate/tracepointsgo.go b/internal/generate/tracepointsgo.go
index 0542f64..9d92047 100644
--- a/internal/generate/tracepointsgo.go
+++ b/internal/generate/tracepointsgo.go
@@ -5,14 +5,35 @@ import (
 	"fmt"
 	"io"
 	"regexp"
+	"sort"
 	"strings"
 )
 
 var secRe = regexp.MustCompile(`^SEC.*sys_((?:enter|exit)_[a-z_0-9]+)`)
+var kindLineRe = regexp.MustCompile(`^(sys_enter_[a-z0-9_]+)\s+is a struct\s+([a-z0-9_]+)\s*$`)
 
 // ExtractTracepoints reads generated C code and extracts tracepoint names from
 // SEC annotations, producing the generated_tracepoints.go content.
 func ExtractTracepoints(r io.Reader) (string, error) {
+	return ExtractTracepointsWithKinds(r, strings.NewReader(""))
+}
+
+// ExtractTracepointsWithKinds reads generated C code and the
+// generated_tracepoints_result.txt metadata to produce
+// internal/tracepoints/generated_tracepoints.go.
+func ExtractTracepointsWithKinds(cReader io.Reader, kindsReader io.Reader) (string, error) {
+	tracepoints, err := extractTracepoints(cReader)
+	if err != nil {
+		return "", err
+	}
+	syscallKinds, err := extractSyscallKinds(kindsReader)
+	if err != nil {
+		return "", err
+	}
+	return formatTracepointsGo(tracepoints, syscallKinds), nil
+}
+
+func extractTracepoints(r io.Reader) ([]string, error) {
 	scanner := bufio.NewScanner(r)
 	var tracepoints []string
 
@@ -24,13 +45,58 @@ func ExtractTracepoints(r io.Reader) (string, error) {
 	}
 
 	if err := scanner.Err(); err != nil {
-		return "", fmt.Errorf("scanning input: %w", err)
+		return nil, fmt.Errorf("scanning input: %w", err)
 	}
+	return tracepoints, nil
+}
 
-	return formatTracepointsGo(tracepoints), nil
+func extractSyscallKinds(r io.Reader) (map[string]string, error) {
+	kinds := make(map[string]string)
+	if r == nil {
+		return kinds, nil
+	}
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" {
+			continue
+		}
+		m := kindLineRe.FindStringSubmatch(line)
+		if m == nil {
+			continue
+		}
+		syscall := strings.TrimPrefix(m[1], "sys_enter_")
+		kind := normalizeStructKind(m[2])
+		if kind == "" {
+			continue
+		}
+		kinds[syscall] = kind
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("scan kind metadata: %w", err)
+	}
+	return kinds, nil
+}
+
+func normalizeStructKind(structName string) string {
+	base := strings.TrimSuffix(structName, "_event")
+	switch base {
+	case "mq_open":
+		return "mq-open"
+	case "open_by_handle_at":
+		return "open-by-handle-at"
+	case "two_fd":
+		return "two-fd"
+	case "epoll_ctl":
+		return "epoll-ctl"
+	case "perf_open":
+		return "perf-open"
+	default:
+		return base
+	}
 }
 
-func formatTracepointsGo(tracepoints []string) string {
+func formatTracepointsGo(tracepoints []string, syscallKinds map[string]string) string {
 	var b strings.Builder
 	b.WriteString("// Code generated - don't change manually!\n")
 	b.WriteString("package tracepoints\n\n")
@@ -39,5 +105,40 @@ func formatTracepointsGo(tracepoints []string) string {
 		fmt.Fprintf(&b, "\t%q,\n", tp)
 	}
 	b.WriteString("}\n")
+	b.WriteString("\n")
+	b.WriteString("var syscallFamilies = map[string]string{\n")
+	syscallFamilies := make(map[string]string)
+	for _, tp := range tracepoints {
+		syscall := strings.TrimPrefix(tp, "sys_enter_")
+		syscall = strings.TrimPrefix(syscall, "sys_exit_")
+		if syscall == "" {
+			continue
+		}
+		if _, ok := syscallFamilies[syscall]; ok {
+			continue
+		}
+		family := ClassifySyscallFamily("sys_enter_" + syscall)
+		syscallFamilies[syscall] = string(family)
+	}
+	familySyscalls := make([]string, 0, len(syscallFamilies))
+	for syscall := range syscallFamilies {
+		familySyscalls = append(familySyscalls, syscall)
+	}
+	sort.Strings(familySyscalls)
+	for _, syscall := range familySyscalls {
+		fmt.Fprintf(&b, "\t%q: %q,\n", syscall, syscallFamilies[syscall])
+	}
+	b.WriteString("}\n")
+	b.WriteString("\n")
+	b.WriteString("var syscallKinds = map[string]string{\n")
+	syscalls := make([]string, 0, len(syscallKinds))
+	for syscall := range syscallKinds {
+		syscalls = append(syscalls, syscall)
+	}
+	sort.Strings(syscalls)
+	for _, syscall := range syscalls {
+		fmt.Fprintf(&b, "\t%q: %q,\n", syscall, syscallKinds[syscall])
+	}
+	b.WriteString("}\n")
 	return b.String()
 }