《MMO 服务器开发》8.3 演练与事故复盘

// snippet: internal/dr/drill.go —— 判据判定：没测到 = 没达标
func EvaluateDrill(s DrillScript, obs []Observation) DrillResult {
	vals := map[string]float64{}
	for _, o := range obs {
		vals[o.Metric] = o.Value
	}
	res := DrillResult{ScriptName: s.Name}
	for _, c := range s.Criteria {
		v, ok := vals[c.Metric]
		if !ok {
			res.Missing = append(res.Missing, c.Metric) // 没测到
			res.Failed = append(res.Failed, c.ID)        // 也算失败
			continue
		}
		res.Checked++
		if !compare(v, c.Op, c.Threshold) {
			res.Failed = append(res.Failed, c.ID)
		}
	}
	res.Passed = len(res.Failed) == 0
	return res
}

// file: internal/dr/postmortem.go
// tier: L1
// verify: go test ./internal/dr/ -run TestPostmortem -v
package dr

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

// EventKind 是事故时间线里一个事件的性质。
type EventKind string

const (
	KindAlert     EventKind = "alert"     // 告警发出
	KindDetected  EventKind = "detected"  // 人确认「出事了」
	KindDeclared  EventKind = "declared"  // 宣布事故、拉起应急
	KindMitigated EventKind = "mitigated" // 止血：影响不再扩大
	KindRecovered EventKind = "recovered" // 完全恢复
)

// IncidentEvent 是时间线上的一条记录。
type IncidentEvent struct {
	At    time.Time
	Kind  EventKind
	Actor string
	Note  string
}

// Timeline 是重建后的时间线。
type Timeline struct {
	Events []IncidentEvent
	// TTD 是「发现时间」：告警到人确认。
	TTD time.Duration
	// TTM 是「止血时间」：确认到影响不再扩大。
	TTM time.Duration
	// TTR 是「恢复时间」：告警到完全恢复。
	TTR time.Duration
	// MaxGap 是相邻事件之间的最大空档；复盘最该盯的就是它。
	MaxGap        time.Duration
	MaxGapBetween [2]time.Time
}

// ReconstructTimeline 把散落的事件按时间排序，重建关键时长与最大空档。
//
// 复盘时最容易被忽略的是 MaxGap：它标出「这段时间里没人推进」，
// 往往正是根因之外、真正拉长故障的那一段。
func ReconstructTimeline(events []IncidentEvent) (Timeline, error) {
	if len(events) == 0 {
		return Timeline{}, errors.New("dr: 时间线为空")
	}
	evs := append([]IncidentEvent(nil), events...)
	sort.Slice(evs, func(i, j int) bool { return evs[i].At.Before(evs[j].At) })
	tl := Timeline{Events: evs}

	for i := 1; i < len(evs); i++ {
		gap := evs[i].At.Sub(evs[i-1].At)
		if gap > tl.MaxGap {
			tl.MaxGap = gap
			tl.MaxGapBetween = [2]time.Time{evs[i-1].At, evs[i].At}
		}
	}
	first := func(k EventKind) (time.Time, bool) {
		for _, e := range evs {
			if e.Kind == k {
				return e.At, true
			}
		}
		return time.Time{}, false
	}
	alertAt, ok := first(KindAlert)
	if !ok {
		return tl, errors.New("dr: 时间线缺少告警事件，无法算 TTD/TTR")
	}
	if detectAt, ok := first(KindDetected); ok {
		tl.TTD = detectAt.Sub(alertAt)
		if mitigateAt, ok := first(KindMitigated); ok {
			tl.TTM = mitigateAt.Sub(detectAt)
		}
	}
	if recoverAt, ok := first(KindRecovered); ok {
		tl.TTR = recoverAt.Sub(alertAt)
	}
	return tl, nil
}

// snippet: internal/dr/improvement.go —— 闭环必须有证据，否则拒绝关闭
func (t *Tracker) Close(id, evidence string, verified bool, now time.Time) error {
	it, ok := t.items[id]
	if !ok {
		return fmt.Errorf("dr: 未知改进项 %s", id)
	}
	if evidence == "" {
		return fmt.Errorf("dr: 改进项 %s 缺少闭环证据", id)
	}
	it.Evidence = evidence
	it.ClosedAt = now
	if verified {
		it.Status = StatusVerified // 经演练或线上验证
	} else {
		it.Status = StatusDone // 已做但未验证
	}
	return nil
}

// Overdue 返回已过期但尚未闭环的改进项 ID。
func (t *Tracker) Overdue(now time.Time) []string {
	var out []string
	for _, id := range t.order {
		it := t.items[id]
		if (it.Status == StatusOpen || it.Status == StatusInProgress) && now.After(it.DueAt) {
			out = append(out, id)
		}
	}
	sort.Strings(out)
	return out
}

=== RUN   TestDrillEvaluatePass
    drill_test.go:50: 判据全过，注入执行序=F1,F3,F2
--- PASS: TestDrillEvaluatePass (0.00s)
=== RUN   TestPostmortemTimelineAndTracker
    drill_test.go:94: TTD=2m0s TTM=4m0s TTR=20m0s 最大空档=14m0s
    drill_test.go:114: 改进项 3 条，已验证闭环 1 条，过期=[A3]，闭环率=0.33
--- PASS: TestPostmortemTimelineAndTracker (0.00s)
PASS
ok  	aegis/internal/dr	0.866s