package main import ( "encoding/json" "flag" "fmt" "html" "os" "path/filepath" "sort" "strconv" "strings" "time" ) type latency struct { P50 float64 `json:"p50"` P95 float64 `json:"p95"` P99 float64 `json:"p99"` } type inputResult struct { Label string `json:"label"` Timestamp string `json:"timestamp"` DurationSeconds float64 `json:"duration_seconds"` WarmupSeconds float64 `json:"warmup_seconds"` Concurrency int `json:"concurrency"` Replicas int `json:"replicas"` APICPUs string `json:"api_cpus_per_replica"` APIMemory string `json:"api_memory_per_replica"` DBMaxConns int `json:"db_max_connections_per_replica"` SuccessfulRequests int `json:"successful_requests"` SuccessfulRPS float64 `json:"successful_rps"` Errors map[string]int `json:"errors"` LatencyMS latency `json:"latency_ms"` Instances []string `json:"instances"` ObservedInstances int `json:"observed_instances"` Prometheus map[string]float64 `json:"prometheus"` } type rawResult struct { Label string `json:"label"` Timestamp string `json:"timestamp"` DurationSeconds float64 `json:"duration_seconds"` WarmupSeconds float64 `json:"warmup_seconds"` Concurrency int `json:"concurrency"` Replicas int `json:"replicas"` APICPUs string `json:"api_cpus_per_replica"` APIMemory string `json:"api_memory_per_replica"` DBMaxConns int `json:"db_max_connections_per_replica"` SuccessfulRequests int `json:"successful_requests"` SuccessfulRPS float64 `json:"successful_rps"` Errors map[string]int `json:"errors"` LatencyMS latency `json:"latency_ms"` ObservedInstances int `json:"observed_instances"` Prometheus map[string]float64 `json:"prometheus"` } type aggregate struct { Label string `json:"label"` Repeats int `json:"repeats"` Concurrency int `json:"concurrency"` Replicas int `json:"replicas"` APICPUs string `json:"api_cpus_per_replica"` APIMemory string `json:"api_memory_per_replica"` DBMaxConns int `json:"db_max_connections_per_replica"` SuccessfulRPSMedian float64 `json:"successful_rps_median"` SuccessfulRPSMin float64 `json:"successful_rps_min"` SuccessfulRPSMax float64 `json:"successful_rps_max"` LatencyP50MedianMS float64 `json:"latency_p50_median_ms"` LatencyP95MedianMS float64 `json:"latency_p95_median_ms"` LatencyP99MedianMS float64 `json:"latency_p99_median_ms"` TotalErrors int `json:"total_errors"` ObservedInstancesMin int `json:"observed_instances_min"` APICPUCoresMedian float64 `json:"api_cpu_cores_median"` APIResidentBytesMedian float64 `json:"api_resident_bytes_median"` PostgresConnectionsMedian float64 `json:"postgres_connections_median"` PrometheusHealthyMin float64 `json:"prometheus_healthy_replicas_min"` } type report struct { GeneratedAt string `json:"generated_at"` Method string `json:"method"` Raw []rawResult `json:"raw"` Summary []aggregate `json:"summary"` } func main() { inputDirectory := flag.String("input", "evidence", "directory with experiment JSON files") outputPath := flag.String("output", "evidence/lab3-scale-results.json", "combined JSON output") chartPath := flag.String("chart", "evidence/lab3-scale-rps.svg", "SVG chart output") flag.Parse() results, err := readResults(*inputDirectory) if err != nil { fatal(err) } aggregates := summarize(results) if err := writeJSON(*outputPath, report{ GeneratedAt: time.Now().UTC().Format(time.RFC3339), Method: "closed-loop HTTP through Nginx; median of three isolated repeats", Raw: sanitize(results), Summary: aggregates, }); err != nil { fatal(err) } if err := writeChart(*chartPath, aggregates); err != nil { fatal(err) } } func readResults(directory string) ([]inputResult, error) { var paths []string for _, pattern := range []string{"lab3-fixed-*.json", "lab3-growing-*.json", "lab3-pool-*.json"} { matches, err := filepath.Glob(filepath.Join(directory, pattern)) if err != nil { return nil, err } paths = append(paths, matches...) } if len(paths) == 0 { return nil, fmt.Errorf("no experiment results in %s", directory) } results := make([]inputResult, 0, len(paths)) for _, path := range paths { data, err := os.ReadFile(path) if err != nil { return nil, err } var result inputResult if err := json.Unmarshal(data, &result); err != nil { return nil, fmt.Errorf("decode %s: %w", path, err) } results = append(results, result) } sort.Slice(results, func(i, j int) bool { return results[i].Label < results[j].Label }) return results, nil } func sanitize(results []inputResult) []rawResult { raw := make([]rawResult, 0, len(results)) for _, value := range results { raw = append(raw, rawResult{ Label: value.Label, Timestamp: value.Timestamp, DurationSeconds: value.DurationSeconds, WarmupSeconds: value.WarmupSeconds, Concurrency: value.Concurrency, Replicas: value.Replicas, APICPUs: value.APICPUs, APIMemory: value.APIMemory, DBMaxConns: value.DBMaxConns, SuccessfulRequests: value.SuccessfulRequests, SuccessfulRPS: value.SuccessfulRPS, Errors: value.Errors, LatencyMS: value.LatencyMS, ObservedInstances: instanceCount(value), Prometheus: value.Prometheus, }) } return raw } func summarize(results []inputResult) []aggregate { groups := make(map[string][]inputResult) for _, value := range results { groups[withoutRepeat(value.Label)] = append(groups[withoutRepeat(value.Label)], value) } labels := make([]string, 0, len(groups)) for label := range groups { labels = append(labels, label) } sort.Strings(labels) aggregates := make([]aggregate, 0, len(labels)) for _, label := range labels { values := groups[label] first := values[0] rps := numbers(values, func(value inputResult) float64 { return value.SuccessfulRPS }) p50 := numbers(values, func(value inputResult) float64 { return value.LatencyMS.P50 }) p95 := numbers(values, func(value inputResult) float64 { return value.LatencyMS.P95 }) p99 := numbers(values, func(value inputResult) float64 { return value.LatencyMS.P99 }) cpu := metricNumbers(values, "api_cpu_cores") memory := metricNumbers(values, "api_resident_bytes") connections := metricNumbers(values, "postgres_connections") healthy := metricNumbers(values, "healthy_replicas") aggregate := aggregate{ Label: label, Repeats: len(values), Concurrency: first.Concurrency, Replicas: first.Replicas, APICPUs: first.APICPUs, APIMemory: first.APIMemory, DBMaxConns: first.DBMaxConns, SuccessfulRPSMedian: median(rps), SuccessfulRPSMin: minimum(rps), SuccessfulRPSMax: maximum(rps), LatencyP50MedianMS: median(p50), LatencyP95MedianMS: median(p95), LatencyP99MedianMS: median(p99), ObservedInstancesMin: instanceCount(first), APICPUCoresMedian: median(cpu), APIResidentBytesMedian: median(memory), PostgresConnectionsMedian: median(connections), PrometheusHealthyMin: minimum(healthy), } for _, value := range values { if count := instanceCount(value); count < aggregate.ObservedInstancesMin { aggregate.ObservedInstancesMin = count } for _, count := range value.Errors { aggregate.TotalErrors += count } } aggregates = append(aggregates, aggregate) } return aggregates } func instanceCount(value inputResult) int { if value.ObservedInstances > 0 { return value.ObservedInstances } return len(value.Instances) } func withoutRepeat(label string) string { index := strings.LastIndex(label, "-n") if index == -1 { return label } if _, err := strconv.Atoi(label[index+2:]); err != nil { return label } return label[:index] } func numbers(values []inputResult, value func(inputResult) float64) []float64 { result := make([]float64, 0, len(values)) for _, item := range values { result = append(result, value(item)) } return result } func metricNumbers(values []inputResult, name string) []float64 { result := make([]float64, 0, len(values)) for _, item := range values { if value, ok := item.Prometheus[name]; ok { result = append(result, value) } } return result } func median(values []float64) float64 { if len(values) == 0 { return 0 } values = append([]float64(nil), values...) sort.Float64s(values) middle := len(values) / 2 if len(values)%2 == 1 { return values[middle] } return (values[middle-1] + values[middle]) / 2 } func minimum(values []float64) float64 { if len(values) == 0 { return 0 } minimum := values[0] for _, value := range values[1:] { if value < minimum { minimum = value } } return minimum } func maximum(values []float64) float64 { if len(values) == 0 { return 0 } maximum := values[0] for _, value := range values[1:] { if value > maximum { maximum = value } } return maximum } func writeJSON(path string, value any) error { data, err := json.MarshalIndent(value, "", " ") if err != nil { return err } return os.WriteFile(path, append(data, '\n'), 0o644) } func writeChart(path string, values []aggregate) error { const width, height = 960, 560 const left, right, top, bottom = 85.0, 240.0, 45.0, 70.0 plotWidth := width - left - right plotHeight := height - top - bottom var selected []aggregate var maxRPS float64 for _, value := range values { if strings.HasPrefix(value.Label, "fixed-") || strings.HasPrefix(value.Label, "growing-") { selected = append(selected, value) if value.SuccessfulRPSMedian > maxRPS { maxRPS = value.SuccessfulRPSMedian } } } if maxRPS == 0 { return fmt.Errorf("no scale results for chart") } maxRPS *= 1.1 var output strings.Builder fmt.Fprintf(&output, ``, width, height, width, height) output.WriteString(``) fmt.Fprintf(&output, `Median successful RPS by replica count`, left) for step := 0; step <= 5; step++ { y := top + plotHeight*float64(5-step)/5 value := maxRPS * float64(step) / 5 fmt.Fprintf(&output, `%.0f`, left, y, left+plotWidth, y, left-10, y+4, value) } fmt.Fprintf(&output, ``, left, top, left, top+plotHeight, left, top+plotHeight, left+plotWidth, top+plotHeight) for index, replicas := range []int{1, 2, 4} { x := left + plotWidth*float64(index)/2 fmt.Fprintf(&output, `%d`, x, top+plotHeight+25, replicas) } fmt.Fprintf(&output, `API replicas`, left+plotWidth/2, height-15) colors := []string{"#1a73e8", "#d93025", "#188038", "#9334e6", "#f29900", "#00897b"} type series struct { name string values []aggregate } groups := make(map[string][]aggregate) for _, value := range selected { name := strings.Split(value.Label, "-r")[0] + ", c=" + strconv.Itoa(value.Concurrency) groups[name] = append(groups[name], value) } var names []string for name := range groups { names = append(names, name) } sort.Strings(names) allSeries := make([]series, 0, len(names)) for _, name := range names { points := groups[name] sort.Slice(points, func(i, j int) bool { return points[i].Replicas < points[j].Replicas }) allSeries = append(allSeries, series{name: name, values: points}) } for index, current := range allSeries { color := colors[index%len(colors)] var coordinates []string for _, point := range current.values { xIndex := map[int]float64{1: 0, 2: 1, 4: 2}[point.Replicas] x := left + plotWidth*xIndex/2 y := top + plotHeight*(1-point.SuccessfulRPSMedian/maxRPS) coordinates = append(coordinates, fmt.Sprintf("%g,%g", x, y)) fmt.Fprintf(&output, ``, x, y, color) } fmt.Fprintf(&output, ``, strings.Join(coordinates, " "), color) legendY := top + 20 + float64(index*28) fmt.Fprintf(&output, `%s`, left+plotWidth+25, legendY, left+plotWidth+50, legendY, color, left+plotWidth+58, legendY+4, html.EscapeString(current.name)) } output.WriteString(``) return os.WriteFile(path, []byte(output.String()), 0o644) } func fatal(err error) { fmt.Fprintln(os.Stderr, err) os.Exit(1) }