《互联网产品的服务端架构·产品、流量与基础能力》11.1 用户视角的 SLI

// file: internal/obs/sli.go
// tier: L1
// verify: go test ./internal/obs/

package obs

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

// Sample 是一次用户请求的观测样本。
// OK 表示用户动作是否成功，LatencyMs 是从用户发起动作到看到结果的耗时。
type Sample struct {
	UserID    string
	OK        bool
	LatencyMs int
}

// SLI 是一段时间内按请求汇总的用户视角指标。
type SLI struct {
	Availability float64
	P95Ms        int
	Samples      int
}

// ErrNoSamples 表示统计窗口内没有任何请求，不能计算 SLI。
var ErrNoSamples = errors.New("obs: no samples")

// Compute 计算可用性与 P95 延迟。
// 可用性按请求计数，同一用户发两次请求就算两个样本；
// P95 使用最近秩法（nearest rank），并且不修改入参顺序。
func Compute(samples []Sample) (SLI, error) {
	if len(samples) == 0 {
		return SLI{}, ErrNoSamples
	}

	ok := 0
	latencies := make([]int, 0, len(samples))
	for i, s := range samples {
		if s.LatencyMs < 0 {
			return SLI{}, fmt.Errorf("obs: sample %d has negative latency %d", i, s.LatencyMs)
		}
		if s.OK {
			ok++
		}
		latencies = append(latencies, s.LatencyMs)
	}

	sort.Ints(latencies)

	// 最近秩：第 ceil(95% * n) 小的值，下标从 0 开始。
	rank := (95*len(latencies) + 99) / 100
	if rank < 1 {
		rank = 1
	}
	p95 := latencies[rank-1]

	return SLI{
		Availability: float64(ok) / float64(len(samples)),
		P95Ms:        p95,
		Samples:      len(samples),
	}, nil
}

// Meets 判断 SLI 是否同时满足可用性目标和延迟预算。
// 两个边界都按“达到即满足”处理；没有样本时一律不满足。
func Meets(s SLI, availabilityTarget float64, p95BudgetMs int) bool {
	if s.Samples <= 0 {
		return false
	}
	return s.Availability >= availabilityTarget && s.P95Ms <= p95BudgetMs
}

// file: internal/obs/sli_test.go
// tier: L1
// verify: go test ./internal/obs/

package obs

import (
	"errors"
	"math"
	"reflect"
	"testing"
)

func TestComputeAvailabilityCountsRequests(t *testing.T) {
	samples := []Sample{
		{UserID: "u-1", OK: true, LatencyMs: 40},
		{UserID: "u-1", OK: false, LatencyMs: 80},
		{UserID: "u-2", OK: true, LatencyMs: 60},
		{UserID: "u-2", OK: true, LatencyMs: 70},
	}

	got, err := Compute(samples)
	if err != nil {
		t.Fatal(err)
	}
	if math.Abs(got.Availability-0.75) > 1e-9 {
		t.Fatalf("availability = %v, want 0.75", got.Availability)
	}
	if got.Samples != 4 {
		t.Fatalf("samples = %d, want 4", got.Samples)
	}
}

func TestComputeNearestRank(t *testing.T) {
	samples := make([]Sample, 0, 100)
	for i := 1; i <= 100; i++ {
		samples = append(samples, Sample{UserID: "u", OK: true, LatencyMs: i})
	}

	got, err := Compute(samples)
	if err != nil {
		t.Fatal(err)
	}
	if got.P95Ms != 95 {
		t.Fatalf("p95 = %d, want 95", got.P95Ms)
	}
}

func TestComputeDoesNotMutateInput(t *testing.T) {
	samples := []Sample{
		{UserID: "u-1", OK: true, LatencyMs: 300},
		{UserID: "u-2", OK: true, LatencyMs: 100},
		{UserID: "u-3", OK: true, LatencyMs: 200},
	}
	before := append([]Sample(nil), samples...)

	if _, err := Compute(samples); err != nil {
		t.Fatal(err)
	}
	if !reflect.DeepEqual(samples, before) {
		t.Fatalf("input changed: got %v, want %v", samples, before)
	}
}

func TestComputeRejectsBadSamples(t *testing.T) {
	if _, err := Compute(nil); !errors.Is(err, ErrNoSamples) {
		t.Fatalf("empty input error = %v, want ErrNoSamples", err)
	}

	_, err := Compute([]Sample{{UserID: "u-1", OK: true, LatencyMs: -1}})
	if err == nil {
		t.Fatal("want error for negative latency")
	}
}

func TestMeetsIncludesBoundaries(t *testing.T) {
	s := SLI{Availability: 0.99, P95Ms: 800, Samples: 10}
	if !Meets(s, 0.99, 800) {
		t.Fatal("boundary values should meet the target")
	}
	if Meets(s, 0.995, 800) {
		t.Fatal("availability below target should not meet")
	}
	if Meets(s, 0.99, 799) {
		t.Fatal("latency above budget should not meet")
	}
	if Meets(SLI{}, 0.99, 800) {
		t.Fatal("empty SLI should not meet")
	}
}

cd .local/checks/webapp-lab
go test ./internal/obs/ -run 'TestCompute|TestMeets' -count=1 -v

=== RUN   TestComputeAvailabilityCountsRequests
--- PASS: TestComputeAvailabilityCountsRequests (0.00s)
=== RUN   TestComputeNearestRank
--- PASS: TestComputeNearestRank (0.00s)
=== RUN   TestComputeDoesNotMutateInput
--- PASS: TestComputeDoesNotMutateInput (0.00s)
=== RUN   TestComputeRejectsBadSamples
--- PASS: TestComputeRejectsBadSamples (0.00s)
=== RUN   TestMeetsIncludesBoundaries
--- PASS: TestMeetsIncludesBoundaries (0.00s)
PASS
ok  	webapp/internal/obs	0.220s