《游戏服务端架构·规模化、全球化与成本》1.1 承载指标：不要只看在线人数

10 玩家 × 30 条/秒 × 10 接收者 = 3000 条/秒

并发数 = 到达速率 × 平均停留时间

8 × 1800 秒 = 14400

// file: internal/capacitymetrics/metrics.go
// tier: L1
// verify: go test ./internal/capacitymetrics/
package capacitymetrics

import (
	"errors"
	"fmt"
	"sort"
	"time"
)

// Kind names a metric. Two teams quoting the same Kind must also agree on the
// window, the dimension and the sampling step, or they are quoting two metrics.
type Kind string

const (
	CCU      Kind = "ccu"
	PCU      Kind = "pcu"
	Rooms    Kind = "rooms"
	TickMS   Kind = "tick_ms"
	MsgPS    Kind = "msg_per_sec"
	LoginQPS Kind = "login_qps"
)

// Sample is one reading of one metric. At must be in a single fixed zone and
// samples must be evenly spaced; gaps change what a window means.
type Sample struct {
	At    time.Time
	Value float64
}

// Peak is the highest window average, not the highest single sample. Start and
// End are the first and last sample times inside the winning window.
type Peak struct {
	Value float64
	Start time.Time
	End   time.Time
	Index int
}

var (
	ErrNoSamples = errors.New("capacitymetrics: no samples")
	ErrWindow    = errors.New("capacitymetrics: window must be a positive multiple of step")
	ErrSpacing   = errors.New("capacitymetrics: samples must be evenly spaced at step")
)

// PeakWindow averages samples over a sliding window of window/step samples and
// returns the highest average. A one-minute spike diluted by a five-minute
// window is the difference between a capacity plan and an incident report.
func PeakWindow(samples []Sample, step, window time.Duration) (Peak, error) {
	if step <= 0 || window <= 0 || window%step != 0 {
		return Peak{}, ErrWindow
	}
	if len(samples) == 0 {
		return Peak{}, ErrNoSamples
	}
	n := int(window / step)
	if n > len(samples) {
		return Peak{}, fmt.Errorf("%w: window needs %d samples, have %d", ErrWindow, n, len(samples))
	}
	for i := 1; i < len(samples); i++ {
		if gap := samples[i].At.Sub(samples[i-1].At); gap != step {
			return Peak{}, fmt.Errorf("%w: gap %s at index %d", ErrSpacing, gap, i)
		}
	}
	sum := 0.0
	for i := 0; i < n; i++ {
		sum += samples[i].Value
	}
	best := Peak{Value: sum / float64(n), Start: samples[0].At, End: samples[n-1].At}
	for i := n; i < len(samples); i++ {
		sum += samples[i].Value - samples[i-n].Value
		if avg := sum / float64(n); avg > best.Value {
			best = Peak{Value: avg, Start: samples[i-n+1].At, End: samples[i].At, Index: i - n + 1}
		}
	}
	return best, nil
}

// ConcurrentUsers applies Little's law: concurrency = arrival rate × dwell.
// perSecond is logins per second and dwell is the mean session length.
func ConcurrentUsers(perSecond float64, dwell time.Duration) float64 {
	if perSecond <= 0 || dwell <= 0 {
		return 0
	}
	return perSecond * dwell.Seconds()
}

// PeakFromAverage turns an average CCU into a planning peak. factor must come
// from the same product and the same time band as avg.
func PeakFromAverage(avg, factor float64) float64 {
	if avg <= 0 || factor <= 0 {
		return 0
	}
	return avg * factor
}

// FanoutMessages is the server-side message rate a room produces: every player
// sends inputHz inputs per second and every input is delivered to recipients.
func FanoutMessages(players int, inputHz float64, recipients int) float64 {
	if players <= 0 || inputHz <= 0 || recipients <= 0 {
		return 0
	}
	return float64(players) * inputHz * float64(recipients)
}

// Dimension is the axis a number is comparable on. Numbers from different
// dimensions are not a trend; they are two unrelated numbers.
type Dimension struct {
	Product  string
	Shard    string
	RoomType string
}

// Ledger stores one series per dimension and refuses to mix sampling steps.
type Ledger struct {
	step   time.Duration
	series map[Dimension][]Sample
}

func NewLedger(step time.Duration) (*Ledger, error) {
	if step <= 0 {
		return nil, ErrWindow
	}
	return &Ledger{step: step, series: map[Dimension][]Sample{}}, nil
}

func (l *Ledger) Step() time.Duration { return l.step }

func (l *Ledger) Add(d Dimension, at time.Time, v float64) error {
	s := l.series[d]
	if len(s) > 0 {
		if gap := at.Sub(s[len(s)-1].At); gap != l.step {
			return fmt.Errorf("%w: gap %s at %s", ErrSpacing, gap, d)
		}
	}
	l.series[d] = append(s, Sample{At: at, Value: v})
	return nil
}

func (l *Ledger) Peak(d Dimension, window time.Duration) (Peak, error) {
	return PeakWindow(l.series[d], l.step, window)
}

func (l *Ledger) Dimensions() []Dimension {
	out := make([]Dimension, 0, len(l.series))
	for d := range l.series {
		out = append(out, d)
	}
	sort.Slice(out, func(i, j int) bool {
		if out[i].Product != out[j].Product {
			return out[i].Product < out[j].Product
		}
		if out[i].Shard != out[j].Shard {
			return out[i].Shard < out[j].Shard
		}
		return out[i].RoomType < out[j].RoomType
	})
	return out
}