snapshot of https://github.com/seaweedfs/seaweedfs.git (master, 2026-09-16; blobs > 131072B omitted)

telemetry/server/api/handlers.go

@@ -0,0 +1,231 @@
+package api
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/telemetry/proto"
+	"github.com/seaweedfs/seaweedfs/telemetry/server/storage"
+	protobuf "google.golang.org/protobuf/proto"
+)
+
+type Handler struct {
+	storage *storage.PrometheusStorage
+}
+
+func NewHandler(storage *storage.PrometheusStorage) *Handler {
+	return &Handler{storage: storage}
+}
+
+func (h *Handler) CollectTelemetry(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	contentType := r.Header.Get("Content-Type")
+
+	// Only accept protobuf content type
+	if contentType != "application/x-protobuf" && contentType != "application/protobuf" {
+		http.Error(w, "Content-Type must be application/x-protobuf", http.StatusUnsupportedMediaType)
+		return
+	}
+
+	// Read protobuf request; real reports are well under 1 KB
+	body, err := io.ReadAll(http.MaxBytesReader(w, r.Body, maxRequestBytes))
+	if err != nil {
+		http.Error(w, "Failed to read request body", http.StatusBadRequest)
+		return
+	}
+
+	req := &proto.TelemetryRequest{}
+	if err := protobuf.Unmarshal(body, req); err != nil {
+		http.Error(w, "Invalid protobuf data", http.StatusBadRequest)
+		return
+	}
+
+	data := req.Data
+	if data == nil {
+		http.Error(w, "Missing telemetry data", http.StatusBadRequest)
+		return
+	}
+
+	if err := validateTelemetryData(data); err != nil {
+		http.Error(w, "Invalid telemetry data: "+err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// Set timestamp if not provided
+	if data.Timestamp == 0 {
+		data.Timestamp = time.Now().Unix()
+	}
+
+	// Store the telemetry data
+	if err := h.storage.StoreTelemetry(data); err != nil {
+		http.Error(w, "Failed to store data", http.StatusInternalServerError)
+		return
+	}
+
+	// Return protobuf response
+	resp := &proto.TelemetryResponse{
+		Success: true,
+		Message: "Telemetry data received",
+	}
+
+	respData, err := protobuf.Marshal(resp)
+	if err != nil {
+		http.Error(w, "Failed to marshal response", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/x-protobuf")
+	w.WriteHeader(http.StatusOK)
+	w.Write(respData)
+}
+
+func (h *Handler) GetStats(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	stats, err := h.storage.GetStats()
+	if err != nil {
+		http.Error(w, "Failed to get stats", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(stats)
+}
+
+func (h *Handler) GetInstances(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	limitStr := r.URL.Query().Get("limit")
+	limit := 100 // default
+	if limitStr != "" {
+		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 1000 {
+			limit = l
+		}
+	}
+
+	instances, err := h.storage.GetInstances(limit)
+	if err != nil {
+		http.Error(w, "Failed to get instances", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(instances)
+}
+
+func (h *Handler) GetMetrics(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	daysStr := r.URL.Query().Get("days")
+	days := 30 // default
+	if daysStr != "" {
+		if d, err := strconv.Atoi(daysStr); err == nil && d > 0 && d <= 365 {
+			days = d
+		}
+	}
+
+	metrics, err := h.storage.GetMetrics(days)
+	if err != nil {
+		http.Error(w, "Failed to get metrics", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(metrics)
+}
+
+func (h *Handler) GetClusterSizes(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	days := 30 // default
+	if daysStr := r.URL.Query().Get("days"); daysStr != "" {
+		if d, err := strconv.Atoi(daysStr); err == nil && d > 0 && d <= 365 {
+			days = d
+		}
+	}
+
+	limit := 20 // default
+	if limitStr := r.URL.Query().Get("limit"); limitStr != "" {
+		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 1000 {
+			limit = l
+		}
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(h.storage.GetClusterSizeSeries(days, limit))
+}
+
+func (h *Handler) GetVersions(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	days := 30 // default
+	if daysStr := r.URL.Query().Get("days"); daysStr != "" {
+		if d, err := strconv.Atoi(daysStr); err == nil && d > 0 && d <= 365 {
+			days = d
+		}
+	}
+
+	limit := 8 // default, the number of colours the version stack has
+	if limitStr := r.URL.Query().Get("limit"); limitStr != "" {
+		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 1000 {
+			limit = l
+		}
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(h.storage.GetVersionSeries(days, limit))
+}
+
+func (h *Handler) GetHistory(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	clusterId := r.URL.Query().Get("cluster_id")
+	if clusterId == "" {
+		http.Error(w, "cluster_id is required", http.StatusBadRequest)
+		return
+	}
+
+	days := 90 // default
+	if daysStr := r.URL.Query().Get("days"); daysStr != "" {
+		if d, err := strconv.Atoi(daysStr); err == nil && d > 0 && d <= 365 {
+			days = d
+		}
+	}
+
+	samples, ok := h.storage.GetHistory(clusterId, days)
+	if !ok {
+		http.Error(w, "Unknown cluster_id", http.StatusNotFound)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"cluster_id": clusterId,
+		"samples":    samples,
+	})
+}

telemetry/server/api/handlers_test.go

@@ -0,0 +1,140 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/seaweedfs/seaweedfs/telemetry/proto"
+	"github.com/seaweedfs/seaweedfs/telemetry/server/storage"
+	protobuf "google.golang.org/protobuf/proto"
+)
+
+// promauto registers on the global registry: one storage per test binary.
+var testHandler = NewHandler(storage.NewPrometheusStorage())
+
+func validReport() *proto.TelemetryData {
+	return &proto.TelemetryData{
+		TopologyId:        "38422678-6a0d-4482-aa33-65b90010ac47",
+		Version:           "4.40",
+		Os:                "linux/amd64",
+		VolumeServerCount: 5,
+		TotalDiskBytes:    123 << 30,
+		TotalVolumeCount:  42,
+		FilerCount:        2,
+		BrokerCount:       1,
+	}
+}
+
+func postCollect(t *testing.T, h *Handler, body []byte, contentType string) *httptest.ResponseRecorder {
+	t.Helper()
+	req := httptest.NewRequest(http.MethodPost, "/api/collect", bytes.NewReader(body))
+	req.Header.Set("Content-Type", contentType)
+	w := httptest.NewRecorder()
+	h.CollectTelemetry(w, req)
+	return w
+}
+
+func marshalReport(t *testing.T, data *proto.TelemetryData) []byte {
+	t.Helper()
+	body, err := protobuf.Marshal(&proto.TelemetryRequest{Data: data})
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+	return body
+}
+
+func TestCollectTelemetryValidation(t *testing.T) {
+	h := testHandler
+
+	t.Run("valid report accepted", func(t *testing.T) {
+		if w := postCollect(t, h, marshalReport(t, validReport()), "application/x-protobuf"); w.Code != http.StatusOK {
+			t.Errorf("got %d, want 200: %s", w.Code, w.Body.String())
+		}
+	})
+
+	t.Run("enterprise version accepted", func(t *testing.T) {
+		data := validReport()
+		data.Version = "4.40-enterprise"
+		if w := postCollect(t, h, marshalReport(t, data), "application/x-protobuf"); w.Code != http.StatusOK {
+			t.Errorf("got %d, want 200: %s", w.Code, w.Body.String())
+		}
+	})
+
+	rejected := []struct {
+		name   string
+		mutate func(*proto.TelemetryData)
+	}{
+		{"non-UUID topology_id", func(d *proto.TelemetryData) { d.TopologyId = "claude-diagnostic-probe" }},
+		{"empty topology_id", func(d *proto.TelemetryData) { d.TopologyId = "" }},
+		{"junk version", func(d *proto.TelemetryData) { d.Version = "probe" }},
+		{"version with suffix", func(d *proto.TelemetryData) { d.Version = "4.40-nightly" }},
+		{"junk os", func(d *proto.TelemetryData) { d.Os = "probe/probe" }},
+		{"os without slash", func(d *proto.TelemetryData) { d.Os = "linux" }},
+		{"negative count", func(d *proto.TelemetryData) { d.VolumeServerCount = -1 }},
+		{"absurd server count", func(d *proto.TelemetryData) { d.VolumeServerCount = 1_000_000 }},
+		{"absurd disk size", func(d *proto.TelemetryData) { d.TotalDiskBytes = 1 << 62 }},
+	}
+	for _, tc := range rejected {
+		t.Run(tc.name+" rejected", func(t *testing.T) {
+			data := validReport()
+			tc.mutate(data)
+			if w := postCollect(t, h, marshalReport(t, data), "application/x-protobuf"); w.Code != http.StatusBadRequest {
+				t.Errorf("got %d, want 400: %s", w.Code, w.Body.String())
+			}
+		})
+	}
+
+	t.Run("wrong content type rejected", func(t *testing.T) {
+		if w := postCollect(t, h, marshalReport(t, validReport()), "application/json"); w.Code != http.StatusUnsupportedMediaType {
+			t.Errorf("got %d, want 415", w.Code)
+		}
+	})
+
+	t.Run("oversized body rejected", func(t *testing.T) {
+		if w := postCollect(t, h, make([]byte, maxRequestBytes+1), "application/x-protobuf"); w.Code != http.StatusBadRequest {
+			t.Errorf("got %d, want 400", w.Code)
+		}
+	})
+}
+
+// The dashboard looks confirmation windows up by the select's string value,
+// so the stats JSON must key confirmed_by_days by decimal strings and carry
+// unmet thresholds as zeros.
+func TestStatsSerializedThresholds(t *testing.T) {
+	data := validReport()
+	data.TopologyId = "49533789-7b1e-4593-bb44-76ca1121bd58"
+	if w := postCollect(t, testHandler, marshalReport(t, data), "application/x-protobuf"); w.Code != http.StatusOK {
+		t.Fatalf("collect: got %d: %s", w.Code, w.Body.String())
+	}
+
+	req := httptest.NewRequest(http.MethodGet, "/api/stats", nil)
+	w := httptest.NewRecorder()
+	testHandler.GetStats(w, req)
+	if w.Code != http.StatusOK {
+		t.Fatalf("stats: got %d", w.Code)
+	}
+
+	var stats struct {
+		ConfirmedByDays map[string]int `json:"confirmed_by_days"`
+	}
+	if err := json.Unmarshal(w.Body.Bytes(), &stats); err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	if len(stats.ConfirmedByDays) != 5 {
+		t.Fatalf("confirmed_by_days = %v, want the 5 thresholds", stats.ConfirmedByDays)
+	}
+	for _, key := range []string{"1", "3", "7", "14", "30"} {
+		if _, ok := stats.ConfirmedByDays[key]; !ok {
+			t.Errorf("confirmed_by_days missing %q: %v", key, stats.ConfirmedByDays)
+		}
+	}
+	if stats.ConfirmedByDays["1"] < 1 {
+		t.Errorf("fresh cluster missing from the 1-day count: %v", stats.ConfirmedByDays)
+	}
+	if stats.ConfirmedByDays["30"] != 0 {
+		t.Errorf("unmet threshold not zero: %v", stats.ConfirmedByDays)
+	}
+}

telemetry/server/api/validate.go

@@ -0,0 +1,58 @@
+package api
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/seaweedfs/seaweedfs/telemetry/proto"
+)
+
+// The collect endpoint is anonymous, so reports can't be authenticated —
+// these checks only reject values a real SeaweedFS master can't produce,
+// to keep casual junk out of the collected data.
+
+const (
+	maxRequestBytes = 4096
+	maxServerCount  = 100_000       // volume servers / filers / brokers per cluster
+	maxVolumeCount  = 100_000_000   // volumes per cluster
+	maxDiskBytes    = uint64(1) << 60 // 1 EiB
+)
+
+var (
+	// TopologyId is a raft-generated UUID.
+	uuidRe = regexp.MustCompile(`^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`)
+	// Version is VERSION_NUMBER, e.g. "4.40", plus "-enterprise" for enterprise builds.
+	versionRe = regexp.MustCompile(`^\d+\.\d+(-enterprise)?$`)
+
+	validGoos = map[string]bool{
+		"linux": true, "darwin": true, "windows": true,
+		"freebsd": true, "openbsd": true, "netbsd": true,
+	}
+	validGoarch = map[string]bool{
+		"amd64": true, "arm64": true, "arm": true, "386": true,
+		"riscv64": true, "ppc64le": true, "s390x": true,
+		"mips64": true, "mips64le": true, "loong64": true,
+	}
+)
+
+func validateTelemetryData(data *proto.TelemetryData) error {
+	if !uuidRe.MatchString(data.TopologyId) {
+		return fmt.Errorf("topology_id is not a UUID")
+	}
+	if !versionRe.MatchString(data.Version) {
+		return fmt.Errorf("unrecognized version")
+	}
+	goos, goarch, ok := strings.Cut(data.Os, "/")
+	if !ok || !validGoos[goos] || !validGoarch[goarch] {
+		return fmt.Errorf("unrecognized os")
+	}
+	if data.VolumeServerCount < 0 || data.VolumeServerCount > maxServerCount ||
+		data.FilerCount < 0 || data.FilerCount > maxServerCount ||
+		data.BrokerCount < 0 || data.BrokerCount > maxServerCount ||
+		data.TotalVolumeCount < 0 || data.TotalVolumeCount > maxVolumeCount ||
+		data.TotalDiskBytes > maxDiskBytes {
+		return fmt.Errorf("values out of range")
+	}
+	return nil
+}