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

weed/telemetry/client.go

@@ -0,0 +1,119 @@
+package telemetry
+
+import (
+	"bytes"
+	"fmt"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/seaweedfs/seaweedfs/telemetry/proto"
+	"github.com/seaweedfs/seaweedfs/weed/glog"
+	protobuf "google.golang.org/protobuf/proto"
+)
+
+type Client struct {
+	url        string
+	enabled    bool
+	instanceID string
+	httpClient *http.Client
+	topologyId string
+	sync.RWMutex
+}
+
+// NewClient creates a new telemetry client
+func NewClient(url string, enabled bool) *Client {
+	return &Client{
+		url:        url,
+		enabled:    enabled,
+		instanceID: uuid.New().String(), // Generate UUID in memory only
+		httpClient: &http.Client{
+			Timeout: 10 * time.Second,
+		},
+	}
+}
+
+func (c *Client) SetTopologyId(topologyId string) {
+	c.Lock()
+	defer c.Unlock()
+	c.topologyId = topologyId
+}
+
+// IsEnabled returns whether telemetry is enabled
+func (c *Client) IsEnabled() bool {
+	return c.enabled && c.url != ""
+}
+
+// SendTelemetry sends telemetry data synchronously using protobuf format
+func (c *Client) SendTelemetry(data *proto.TelemetryData) error {
+	if !c.IsEnabled() {
+		return nil
+	}
+
+	// Work on a copy to avoid mutating the caller's TelemetryData
+	clonedData, ok := protobuf.Clone(data).(*proto.TelemetryData)
+	if !ok {
+		return fmt.Errorf("failed to clone telemetry data")
+	}
+
+	// Set the topology ID
+	c.RLock()
+	if c.topologyId != "" {
+		clonedData.TopologyId = c.topologyId
+	}
+	c.RUnlock()
+
+	return c.sendProtobuf(clonedData)
+}
+
+// SendTelemetryAsync sends telemetry data asynchronously
+func (c *Client) SendTelemetryAsync(data *proto.TelemetryData) {
+	if !c.IsEnabled() {
+		return
+	}
+
+	go func() {
+		if err := c.SendTelemetry(data); err != nil {
+			glog.V(1).Infof("Failed to send telemetry: %v", err)
+		}
+	}()
+}
+
+// sendProtobuf sends data using protobuf format
+func (c *Client) sendProtobuf(data *proto.TelemetryData) error {
+	req := &proto.TelemetryRequest{
+		Data: data,
+	}
+
+	body, err := protobuf.Marshal(req)
+	if err != nil {
+		return fmt.Errorf("failed to marshal protobuf: %w", err)
+	}
+
+	httpReq, err := http.NewRequest("POST", c.url, bytes.NewBuffer(body))
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+
+	httpReq.Header.Set("Content-Type", "application/x-protobuf")
+	httpReq.Header.Set("User-Agent", fmt.Sprintf("SeaweedFS/%s", data.Version))
+
+	resp, err := c.httpClient.Do(httpReq)
+	if err != nil {
+		return fmt.Errorf("failed to send request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("server returned status %d", resp.StatusCode)
+	}
+
+	glog.V(2).Infof("Telemetry sent successfully via protobuf")
+	return nil
+}
+
+// GetInstanceID returns the current instance ID
+func (c *Client) GetInstanceID() string {
+	return c.instanceID
+}

weed/telemetry/collector.go

@@ -0,0 +1,228 @@
+package telemetry
+
+import (
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/telemetry/proto"
+	"github.com/seaweedfs/seaweedfs/weed/cluster"
+	"github.com/seaweedfs/seaweedfs/weed/glog"
+	"github.com/seaweedfs/seaweedfs/weed/storage/needle"
+	"github.com/seaweedfs/seaweedfs/weed/topology"
+)
+
+// Collector gathers telemetry data from a SeaweedFS cluster
+// Only the leader master will send telemetry to avoid duplicates
+type Collector struct {
+	client       *Client
+	topo         *topology.Topology
+	cluster      *cluster.Cluster
+	masterServer interface{} // Will be set to *weed_server.MasterServer to access client tracking
+	version      string
+	os           string
+}
+
+// NewCollector creates a new telemetry collector
+func NewCollector(client *Client, topo *topology.Topology, cluster *cluster.Cluster) *Collector {
+	return &Collector{
+		client:       client,
+		topo:         topo,
+		cluster:      cluster,
+		masterServer: nil,
+		version:      "unknown",
+		os:           "unknown",
+	}
+}
+
+// SetVersion sets the SeaweedFS version
+func (c *Collector) SetVersion(version string) {
+	c.version = version
+}
+
+// SetOS sets the operating system information
+func (c *Collector) SetOS(os string) {
+	c.os = os
+}
+
+// SetMasterServer sets a reference to the master server for client tracking
+func (c *Collector) SetMasterServer(masterServer interface{}) {
+	c.masterServer = masterServer
+}
+
+// isLeader checks if this master is the leader
+func (c *Collector) isLeader() bool {
+	if c.topo == nil {
+		return false
+	}
+	return c.topo.IsLeader()
+}
+
+// CollectAndSendAsync collects telemetry data and sends it asynchronously
+// Only sends telemetry if this master is the leader
+func (c *Collector) CollectAndSendAsync() {
+	if !c.client.IsEnabled() {
+		return
+	}
+
+	if c.topo != nil {
+		c.client.SetTopologyId(c.topo.GetTopologyId())
+	}
+
+	go func() {
+		if data := c.collectData(); data != nil {
+			c.client.SendTelemetryAsync(data)
+		}
+	}()
+}
+
+// StartPeriodicCollection starts sending telemetry data periodically
+func (c *Collector) StartPeriodicCollection(interval time.Duration) {
+	if !c.client.IsEnabled() {
+		glog.V(1).Infof("Telemetry is disabled, skipping periodic collection")
+		return
+	}
+
+	glog.V(0).Infof("Reporting anonymous cluster statistics to %s every %v once %d GiB are stored, use -telemetry=false to opt out", c.client.url, interval, proto.MinDiskBytes>>30)
+
+	// Send initial telemetry after a short delay
+	go func() {
+		time.Sleep(61 * time.Second) // Wait for cluster to stabilize
+		if c.isLeader() {
+			c.CollectAndSendAsync()
+		} else {
+			glog.V(2).Infof("Skipping initial telemetry collection - not the leader master")
+		}
+	}()
+
+	// Start periodic collection
+	ticker := time.NewTicker(interval)
+	go func() {
+		defer ticker.Stop()
+		for range ticker.C {
+			// Check leadership before each collection
+			if c.isLeader() {
+				c.CollectAndSendAsync()
+			} else {
+				glog.V(2).Infof("Skipping periodic telemetry collection - not the leader master")
+			}
+		}
+	}()
+}
+
+// collectData gathers telemetry data from the topology. It returns nil while
+// the cluster stores less than proto.MinDiskBytes, so throwaway clusters never
+// report.
+func (c *Collector) collectData() *proto.TelemetryData {
+	data := &proto.TelemetryData{
+		Version:   c.version,
+		Os:        c.os,
+		Timestamp: time.Now().Unix(),
+	}
+
+	if c.topo != nil {
+		// Collect volume server count
+		data.VolumeServerCount = int32(c.countVolumeServers())
+
+		// Collect total disk usage and volume count
+		diskBytes, volumeCount := c.collectVolumeStats()
+		data.TotalDiskBytes = diskBytes
+		data.TotalVolumeCount = int32(volumeCount)
+	}
+
+	if c.cluster != nil {
+		// Collect filer and broker counts
+		data.FilerCount = int32(c.countFilers())
+		data.BrokerCount = int32(c.countBrokers())
+	}
+
+	if data.TotalDiskBytes < proto.MinDiskBytes {
+		glog.V(2).Infof("Skipping telemetry: %d bytes stored, reporting starts at %d", data.TotalDiskBytes, proto.MinDiskBytes)
+		return nil
+	}
+	return data
+}
+
+// countVolumeServers counts the number of active volume servers
+func (c *Collector) countVolumeServers() int {
+	count := 0
+	for _, dcNode := range c.topo.Children() {
+		dc := dcNode.(*topology.DataCenter)
+		for _, rackNode := range dc.Children() {
+			rack := rackNode.(*topology.Rack)
+			for range rack.Children() {
+				count++
+			}
+		}
+	}
+	return count
+}
+
+// collectVolumeStats collects total disk usage and volume count
+func (c *Collector) collectVolumeStats() (uint64, int) {
+	var totalDiskBytes uint64
+	var totalVolumeCount int
+	ecVolumeIds := make(map[needle.VolumeId]struct{})
+
+	for _, dcNode := range c.topo.Children() {
+		dc := dcNode.(*topology.DataCenter)
+		for _, rackNode := range dc.Children() {
+			rack := rackNode.(*topology.Rack)
+			for _, dnNode := range rack.Children() {
+				dn := dnNode.(*topology.DataNode)
+				volumes := dn.GetVolumes()
+				for _, volumeInfo := range volumes {
+					totalVolumeCount++
+					totalDiskBytes += volumeInfo.Size
+				}
+				// An encoded volume leaves GetVolumes and is reported as
+				// shards, so without this a cluster reports none of the
+				// bytes it erasure-coded. Every shard copy counts, parity
+				// included, the way a replicated volume counts every replica.
+				for _, ecInfo := range dn.GetEcShards() {
+					totalDiskBytes += uint64(ecInfo.ShardsInfo.TotalSize())
+					// One volume's shards are spread over many nodes, so
+					// count the volume once rather than once per holder.
+					ecVolumeIds[ecInfo.VolumeId] = struct{}{}
+				}
+			}
+		}
+	}
+
+	return totalDiskBytes, totalVolumeCount + len(ecVolumeIds)
+}
+
+// countFilers counts the number of active filer servers across all groups
+func (c *Collector) countFilers() int {
+	// Count all filer-type nodes in the cluster
+	// This includes both pure filer servers and S3 servers (which register as filers)
+	count := 0
+	for _, groupName := range c.getAllFilerGroups() {
+		nodes := c.cluster.ListClusterNode(cluster.FilerGroupName(groupName), cluster.FilerType)
+		count += len(nodes)
+	}
+	return count
+}
+
+// countBrokers counts the number of active broker servers
+func (c *Collector) countBrokers() int {
+	// Count brokers across all broker groups
+	count := 0
+	for _, groupName := range c.getAllBrokerGroups() {
+		nodes := c.cluster.ListClusterNode(cluster.FilerGroupName(groupName), cluster.BrokerType)
+		count += len(nodes)
+	}
+	return count
+}
+
+// getAllFilerGroups returns all filer group names
+func (c *Collector) getAllFilerGroups() []string {
+	// For simplicity, we check the default group
+	// In a more sophisticated implementation, we could enumerate all groups
+	return []string{""}
+}
+
+// getAllBrokerGroups returns all broker group names
+func (c *Collector) getAllBrokerGroups() []string {
+	// For simplicity, we check the default group
+	// In a more sophisticated implementation, we could enumerate all groups
+	return []string{""}
+}

weed/telemetry/collector_test.go

@@ -0,0 +1,87 @@
+package telemetry
+
+import (
+	"testing"
+
+	"github.com/seaweedfs/seaweedfs/telemetry/proto"
+	"github.com/seaweedfs/seaweedfs/weed/pb/master_pb"
+	"github.com/seaweedfs/seaweedfs/weed/sequence"
+	"github.com/seaweedfs/seaweedfs/weed/storage/erasure_coding"
+	"github.com/seaweedfs/seaweedfs/weed/storage/needle"
+	"github.com/seaweedfs/seaweedfs/weed/topology"
+)
+
+// ecShardMessage builds a heartbeat message for the given shard ids, each
+// sized (id+1)*sizeUnit bytes.
+func ecShardMessage(vid uint32, sizeUnit int, shardIds ...erasure_coding.ShardId) *master_pb.VolumeEcShardInformationMessage {
+	shards := erasure_coding.NewShardsInfo()
+	for _, id := range shardIds {
+		shards.Set(erasure_coding.NewShardInfo(id, erasure_coding.ShardSize((int(id)+1)*sizeUnit)))
+	}
+	return &master_pb.VolumeEcShardInformationMessage{
+		Id:          vid,
+		EcIndexBits: shards.Bitmap(),
+		ShardSizes:  shards.SizesInt64(),
+	}
+}
+
+func TestCollectVolumeStatsCountsEcShards(t *testing.T) {
+	topo := topology.NewTopology("weedfs", sequence.NewMemorySequencer(), 32*1024, 5, false)
+
+	rack := topo.GetOrCreateDataCenter("dc1").GetOrCreateRack("rack1")
+	maxVolumeCounts := map[string]uint32{"": 25}
+	dn1 := rack.GetOrCreateDataNode("127.0.0.1", 34534, 0, "127.0.0.1", "", maxVolumeCounts)
+	dn2 := rack.GetOrCreateDataNode("127.0.0.2", 34534, 0, "127.0.0.2", "", maxVolumeCounts)
+
+	topo.SyncDataNodeRegistration([]*master_pb.VolumeInformationMessage{
+		{Id: 1, Size: 1000, FileCount: 10, Version: uint32(needle.GetCurrentVersion())},
+		{Id: 2, Size: 2000, FileCount: 20, Version: uint32(needle.GetCurrentVersion())},
+	}, dn1)
+
+	// Volume 10's shards span both nodes, with a second copy of shard 0 on
+	// dn2; volume 20 sits entirely on dn1.
+	topo.SyncDataNodeEcShards([]*master_pb.VolumeEcShardInformationMessage{
+		ecShardMessage(10, 100, 0, 1, 2, 3, 4, 5, 6),
+		ecShardMessage(20, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13),
+	}, dn1)
+	topo.SyncDataNodeEcShards([]*master_pb.VolumeEcShardInformationMessage{
+		ecShardMessage(10, 100, 0, 7, 8, 9, 10, 11, 12, 13),
+	}, dn2)
+
+	collector := NewCollector(nil, topo, nil)
+	diskBytes, volumeCount := collector.collectVolumeStats()
+
+	// 3000 from the two regular volumes, plus every shard copy of volume 10
+	// sized (id+1)*100 — 100..700 on dn1, and 800..1400 plus the second copy
+	// of shard 0 on dn2 — and volume 20's 14 shards at (id+1)*10.
+	const expectedDiskBytes = 3000 + 2800 + (7700 + 100) + 1050
+	if diskBytes != expectedDiskBytes {
+		t.Errorf("Expected %d total disk bytes, got %d", expectedDiskBytes, diskBytes)
+	}
+
+	// 2 regular volumes plus EC volumes 10 and 20 — volume 10 counts once
+	// even though two nodes hold its shards.
+	if volumeCount != 4 {
+		t.Errorf("Expected 4 volumes, got %d", volumeCount)
+	}
+}
+
+func TestCollectDataWaitsForMinDiskBytes(t *testing.T) {
+	topo := topology.NewTopology("weedfs", sequence.NewMemorySequencer(), 32*1024, 5, false)
+	rack := topo.GetOrCreateDataCenter("dc1").GetOrCreateRack("rack1")
+	dn := rack.GetOrCreateDataNode("127.0.0.1", 34534, 0, "127.0.0.1", "", map[string]uint32{"": 25})
+	collector := NewCollector(nil, topo, nil)
+
+	under := &master_pb.VolumeInformationMessage{Id: 1, Size: proto.MinDiskBytes - 1, Version: uint32(needle.GetCurrentVersion())}
+	topo.SyncDataNodeRegistration([]*master_pb.VolumeInformationMessage{under}, dn)
+	if data := collector.collectData(); data != nil {
+		t.Fatalf("cluster under the floor reported %+v", data)
+	}
+
+	one := &master_pb.VolumeInformationMessage{Id: 2, Size: 1, Version: uint32(needle.GetCurrentVersion())}
+	topo.SyncDataNodeRegistration([]*master_pb.VolumeInformationMessage{under, one}, dn)
+	data := collector.collectData()
+	if data == nil || data.TotalDiskBytes != proto.MinDiskBytes {
+		t.Fatalf("cluster on the floor reported %+v", data)
+	}
+}