Method ScalingAggregates

internal/slo/memory_engine.go:82–139

ScalingAggregates derives rolling ratios from completed in-memory records for autoscaler hints. ttftRatio compares mean TTFT in the newer half vs the older half (by completion time); 1.0 means no skew. recentFallbackRate is the fraction of completed requests in the newer half that recorded a fallbac

()

// ttftRatio compares mean TTFT in the newer half vs the older half (by completion time); 1.0 means no skew.
// recentFallbackRate is the fraction of completed requests in the newer half that recorded a fallback.
func (e *MemoryEngine) ScalingAggregates() (ttftRatio float64, recentFallbackRate float64) {
	e.mu.Lock()
	defer e.mu.Unlock()

	type sample struct {
		end      time.Time
		ttftMs   int64
		fallback bool
	}
	samples := make([]sample, 0, len(e.records))
	for _, rec := range e.records {
		if rec.endTime.IsZero() || rec.startTime.IsZero() {
			continue
		}
		var ttft int64
		if !rec.firstTokenTime.IsZero() {
			ttft = rec.firstTokenTime.Sub(rec.startTime).Milliseconds()
		} else {
			ttft = rec.endTime.Sub(rec.startTime).Milliseconds()
		}
		if ttft < 0 {
			ttft = 0
		}
		samples = append(samples, sample{end: rec.endTime, ttftMs: ttft, fallback: rec.fallback})
	}
	if len(samples) < 4 {
		return 1.0, 0
	}
	sort.Slice(samples, func(i, j int) bool { return samples[i].end.Before(samples[j].end) })
	mid := len(samples) / 2
	var oldSum, newSum int64
	oldC := mid
	newC := len(samples) - mid
	for i := 0; i < mid; i++ {
		oldSum += samples[i].ttftMs
	}
	for i := mid; i < len(samples); i++ {
		newSum += samples[i].ttftMs
	}
	if oldC == 0 || newC == 0 {
		return 1.0, 0
	}
	oldAvg := float64(oldSum) / float64(oldC)
	newAvg := float64(newSum) / float64(newC)
	if oldAvg < 1 {
		oldAvg = 1
	}
	ttftRatio = newAvg / oldAvg

	var fbRecent int
	for i := mid; i < len(samples); i++ {
		if samples[i].fallback {
			fbRecent++
		}
	}
	recentFallbackRate = float64(fbRecent) / float64(newC)
	return ttftRatio, recentFallbackRate
}