mirror of
https://github.com/seaweedfs/seaweedfs.git
synced 2026-11-20 03:13:53 +01:00
The versions chart keeps the 8 versions with the most clusters on the last day and folds the rest into "other". A new release starts small, so 4.54 (282 clusters) was folded in while 4.53 shrank as clusters upgraded, which showed as a dip across the named versions. The newest plain release now always keeps its own band. Claude-Session: https://claude.ai/code/session_011UpvafvK8JpagF94MHWqwK Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
185 lines
5.6 KiB
Go
185 lines
5.6 KiB
Go
package storage
|
|
|
|
import (
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// VersionCounts is how many clusters ran one version per day, aligned to the
|
|
// shared date axis of the enclosing VersionSeries.
|
|
type VersionCounts struct {
|
|
Version string `json:"version"`
|
|
Clusters []uint64 `json:"clusters"`
|
|
}
|
|
|
|
// OtherVersions is the versions beyond the caller's limit, summed per day so a
|
|
// stacked chart still adds up to the cluster total.
|
|
type OtherVersions struct {
|
|
Count int `json:"count"`
|
|
Clusters []uint64 `json:"clusters"`
|
|
}
|
|
|
|
// VersionSeries is the version make-up of the fleet over time: one cluster
|
|
// count per version per day, oldest release first.
|
|
type VersionSeries struct {
|
|
Dates []string `json:"dates"`
|
|
Versions []VersionCounts `json:"versions"`
|
|
Other *OtherVersions `json:"other,omitempty"`
|
|
TotalClusters uint64 `json:"total_clusters"` // across all versions on the last day
|
|
}
|
|
|
|
// GetVersionSeries returns the last `days` days of per-version cluster counts
|
|
// across confirmed clusters. Versions beyond `limit` are folded into Other,
|
|
// keeping the ones with the most clusters on the last day.
|
|
func (s *PrometheusStorage) GetVersionSeries(days, limit int) VersionSeries {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
|
|
histories := versionedHistories(s.seriesHistories())
|
|
axis := newDailySeries(days, histories)
|
|
activeSince := time.Now().UTC().AddDate(0, 0, -activeDays).Unix()
|
|
last := len(axis.dates) - 1
|
|
series := VersionSeries{Dates: axis.dates}
|
|
|
|
daily := make(map[string][]uint64)
|
|
for _, history := range histories {
|
|
versions, ok := align(axis, history, activeSince, sampleVersion)
|
|
if !ok {
|
|
continue
|
|
}
|
|
for i, v := range versions {
|
|
if v == "" {
|
|
continue // before the cluster's first day in the window
|
|
}
|
|
counts, ok := daily[v]
|
|
if !ok {
|
|
counts = make([]uint64, len(axis.dates))
|
|
daily[v] = counts
|
|
}
|
|
counts[i]++
|
|
}
|
|
}
|
|
|
|
for v, counts := range daily {
|
|
series.Versions = append(series.Versions, VersionCounts{Version: v, Clusters: counts})
|
|
series.TotalClusters += counts[last]
|
|
}
|
|
// Ordered by release rather than by size: the caller stacks them, and a
|
|
// stack whose order changes with the counts is unreadable over time.
|
|
sort.Slice(series.Versions, func(i, j int) bool {
|
|
return versionLess(series.Versions[i].Version, series.Versions[j].Version)
|
|
})
|
|
|
|
if limit > 0 && len(series.Versions) > limit {
|
|
// Old releases are a long tail of one-cluster bands; keep the versions
|
|
// most of the fleet is on now and sum the rest into one band. The
|
|
// newest release is kept too, while it is still too small to rank, or
|
|
// clusters upgrading to it look like they left the named versions.
|
|
newest := newestRelease(series.Versions, last)
|
|
ranked := append([]VersionCounts(nil), series.Versions...)
|
|
sort.Slice(ranked, func(i, j int) bool {
|
|
if (ranked[i].Version == newest) != (ranked[j].Version == newest) {
|
|
return ranked[i].Version == newest
|
|
}
|
|
if ranked[i].Clusters[last] != ranked[j].Clusters[last] {
|
|
return ranked[i].Clusters[last] > ranked[j].Clusters[last]
|
|
}
|
|
return versionLess(ranked[j].Version, ranked[i].Version)
|
|
})
|
|
other := OtherVersions{Count: len(ranked) - limit, Clusters: make([]uint64, len(axis.dates))}
|
|
for _, v := range ranked[limit:] {
|
|
for i, c := range v.Clusters {
|
|
other.Clusters[i] += c
|
|
}
|
|
}
|
|
kept := make(map[string]bool, limit)
|
|
for _, v := range ranked[:limit] {
|
|
kept[v.Version] = true
|
|
}
|
|
versions := series.Versions[:0]
|
|
for _, v := range series.Versions {
|
|
if kept[v.Version] {
|
|
versions = append(versions, v)
|
|
}
|
|
}
|
|
series.Versions = versions
|
|
series.Other = &other
|
|
}
|
|
return series
|
|
}
|
|
|
|
// newestRelease is the newest plain release, without a build suffix, that
|
|
// clusters run on the last day.
|
|
func newestRelease(versions []VersionCounts, last int) string {
|
|
newest := ""
|
|
for _, v := range versions {
|
|
if _, suffix, ok := versionParts(v.Version); !ok || suffix != "" || v.Clusters[last] == 0 {
|
|
continue
|
|
}
|
|
if newest == "" || versionLess(newest, v.Version) {
|
|
newest = v.Version
|
|
}
|
|
}
|
|
return newest
|
|
}
|
|
|
|
// versionedHistories drops the samples recorded before the reported version was
|
|
// kept in history, so the version series spans the days it actually knows a
|
|
// version for instead of climbing out of a run of blank days.
|
|
func versionedHistories(histories map[string][]HistorySample) map[string][]HistorySample {
|
|
out := make(map[string][]HistorySample, len(histories))
|
|
for id, history := range histories {
|
|
var kept []HistorySample
|
|
for _, sample := range history {
|
|
if sample.Version != "" {
|
|
kept = append(kept, sample)
|
|
}
|
|
}
|
|
if len(kept) > 0 {
|
|
out[id] = kept
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// versionLess orders release strings like "3.97" and "4.40" by their numeric
|
|
// components rather than lexically, which would sort "10.02" before "9.99". A
|
|
// build suffix sits next to the release it was built from. Anything that
|
|
// doesn't parse, such as the "unknown" a client with no version compiled in
|
|
// reports, sorts first.
|
|
func versionLess(a, b string) bool {
|
|
an, aSuffix, aok := versionParts(a)
|
|
bn, bSuffix, bok := versionParts(b)
|
|
if aok != bok {
|
|
return !aok
|
|
}
|
|
if !aok {
|
|
return a < b
|
|
}
|
|
for i := 0; i < len(an) && i < len(bn); i++ {
|
|
if an[i] != bn[i] {
|
|
return an[i] < bn[i]
|
|
}
|
|
}
|
|
if len(an) != len(bn) {
|
|
return len(an) < len(bn)
|
|
}
|
|
return aSuffix < bSuffix
|
|
}
|
|
|
|
func versionParts(v string) ([]int, string, bool) {
|
|
number, suffix, _ := strings.Cut(v, "-")
|
|
fields := strings.Split(number, ".")
|
|
parts := make([]int, 0, len(fields))
|
|
for _, field := range fields {
|
|
n, err := strconv.Atoi(field)
|
|
if err != nil {
|
|
return nil, "", false
|
|
}
|
|
parts = append(parts, n)
|
|
}
|
|
return parts, suffix, len(parts) > 0
|
|
}
|