zacharysyoung · March 30, 2023 21:33
diff --git a/README.md b/README.md
diff --git a/main.go b/main.go
 // Make n-number Airtable API requests, as concurrently as possible.
 package main

 import (
 	"encoding/csv"
 	"encoding/json"
 	"fmt"
 	"log"
 	"math"
 	"net/http"
 	"os"
 	"strconv"
 	"time"
 )

 const (
 	api = "https://api.airtable.com/v0"
 	app = "app3n84SwUnqPsvgC"
 	tbl = "Table_1"
 	viw = "Single_record"
 	URL = api + "/" + app + "/" + tbl + "?view=" + viw
 )

 type CSVMethod string

 const (
 	csvResults CSVMethod = "results"
 	csvStats   CSVMethod = "stats"
 )

 func usage() {
 	fmt.Printf("usage: go run main.go CONFIG_JSON N_REQS [%s|%s]\n", csvResults, csvStats)
 	os.Exit(1)
 }

 var (
 	apiKey string
 	nReqs  int
 	method CSVMethod
 )

 func init() {
 	args := os.Args
 	if len(args) < 4 {
 		usage()
 	}

 	data, err := os.ReadFile(args[1])
 	must(err)

 	// Get API key secret out of a JSON file
 	var config struct {
 		APIKey string `json:"APIKey"`
 	}
 	err = json.Unmarshal(data, &config)
 	must(err)

 	apiKey = config.APIKey

 	nReqs, err = strconv.Atoi(args[2])
 	must(err)

 	method = CSVMethod(args[3])
 	if method != csvResults && method != csvStats {
 		usage()
 	}
 }

 // GETResult holds stats on an HTTP GET request and its response.
 type GETResult struct {
 	x        int           // initial order
 	start    time.Time     // request start time
 	code     int           // response status code
 	duration time.Duration // how long the response took
 	err      error         // any other error while requesting/responding
 }

 var nilTime = time.Time{}

 func (gr GETResult) Header() []string {
 	return []string{"X", "Err", "Start (Unix µs)", "StatusCode", "Duration (ms)"}
 }

 func (gr GETResult) ToRecord() []string {
 	x := strconv.Itoa(gr.x)
 	err := ""
 	if gr.err != nil {
 		err = gr.err.Error()
 	}
 	start := strconv.Itoa(int(gr.start.UnixMicro()))
 	code := strconv.Itoa(gr.code)
 	dur := strconv.Itoa(int(gr.duration.Milliseconds()))

 	return []string{x, err, start, code, dur}
 }

 func main() {
 	chResult := make(chan GETResult, nReqs)
 	results := make([]GETResult, nReqs)

 	// Start concurrent requests and accumulate all responses
 	for i := 0; i < nReqs; i++ {
 		go func(x int) {
 			makeRequest(x, chResult)
 		}(i)
 	}
 	for i := 0; i < nReqs; i++ {
 		results[i] = <-chResult
 	}

 	var records [][]string
 	switch method {
 	case csvResults:
 		records = makeResultsCSV(results)
 	case csvStats:
 		records = makeStatsCSV(results)
 	}

 	w := csv.NewWriter(os.Stdout)
 	w.WriteAll(records)
 	w.Flush()
 	if err := w.Error(); err != nil {
 		fmt.Println(err)
 	}
 }

 func makeRequest(x int, ch chan<- GETResult) {
 	gr := GETResult{x: x, start: nilTime, code: -1, duration: -1, err: nil}

 	req, err := http.NewRequest("GET", URL, nil)
 	if err != nil {
 		gr.err = err
 		ch <- gr
 		return
 	}
 	req.Header.Add("Authorization", "Bearer "+apiKey)

 	gr.start = time.Now()
 	client := &http.Client{}

 	resp, err := client.Do(req)
 	if err != nil {
 		gr.err = err
 		ch <- gr
 		return
 	}
 	gr.code = resp.StatusCode
 	gr.duration = time.Since(gr.start)

 	ch <- gr
 }

 func makeResultsCSV(results []GETResult) (records [][]string) {
 	records = make([][]string, len(results)+1)
 	records[0] = results[0].Header()
 	for i, result := range results {
 		records[i+1] = result.ToRecord()
 	}
 	return
 }

 func makeStatsCSV(results []GETResult) (records [][]string) {
 	var (
 		ct = 0

 		min    = math.MaxInt
 		mean   = 0.0
 		max    = math.MinInt
 		stddev = 0.0

 		sum = 0.0

 		ct200   = 0
 		ct429   = 0
 		ctErr   = 0
 		ctOther = 0

 		dur = 0 // milliseconds

 		durs    []float64
 		durElem = 0.0
 	)

 	ct = len(results)

 	// Loop to count statuses; get min and max; sum for mean; store durs for Stddev
 	durs = make([]float64, ct)
 	for i, gr := range results {
 		switch {
 		case gr.err != nil:
 			ctErr += 1
 		case gr.code == 200:
 			ct200 += 1
 		case gr.code == 429:
 			ct429 += 1
 		default:
 			ctOther += 1
 		}

 		if gr.code != 200 {
 			continue
 		}

 		dur = int(gr.duration.Milliseconds())
 		switch {
 		case dur < min:
 			min = dur
 		case dur > max:
 			max = dur
 		}
 		sum += float64(dur)

 		durs[i] = float64(dur)
 	}

 	mean = sum / float64(ct)

 	sum = 0.0
 	for _, dur := range durs {
 		durElem = dur - mean
 		sum += durElem * durElem
 	}
 	stddev = math.Sqrt(sum / float64(ct-1))

 	_i := func(x int) string { return strconv.Itoa(x) }
 	_f := func(x float64) string { return strconv.Itoa(int(math.Round(x))) }

 	records = make([][]string, 2)
 	records[0] = []string{
 		"N Resp", "Min (ms)", "Mean (ms)", "Max (ms)", "Stddev (ms)", "200s", "429s", "Errors", "Other",
 	}
 	records[1] = []string{
 		_i(ct), _i(min), _f(mean), _i(max), _f(stddev), _i(ct200), _i(ct429), _i(ctErr), _i(ctOther),
 	}

 	return
 }

 func must(err error) {
 	if err != nil {
 		log.Fatal(err)
 	}
 }
diff --git a/stats.sh b/stats.sh
 #!/bin/sh

 # Clean previous
 rm -rf stats*.csv

 # 3 runs of 5, 10, ...
 for x in 5 10 25 40 50; do
    for y in 1 2 3; do
        go run main.go .secrets.json "$x" stats > "stats_${x}_${y}.csv"
    done
 done

 # Combine stats
 gocsv stack stats_*.csv | gocsv sort -c 1 > stats.csv

 # Convert to MD
 echo '# Stats' > stats.md
 echo >> stats.md
 gocsv viewmd stats.csv | sed 's/-|/-:|/g' >> stats.md
N Resp	Min (ms)	Mean (ms)	Max (ms)	Stddev (ms)	200s	429s
5	447	476	522	28	5	0
5	452	494	533	34	5	0
5	540	670	725	76	5	0
10	454	526	590	47	10	0
10	425	504	570	47	10	0
10	451	510	566	39	10	0
25	423	655	826	116	25	0
25	422	593	741	91	25	0
25	413	615	800	112	25	0
40	429	759	1035	178	40	0
40	426	718	968	149	40	0
40	458	770	1101	202	40	0
50	432	563	1004	312	40	10
50	429	566	970	318	40	10
50	414	562	961	316	40	10
	// Make n-number Airtable API requests, as concurrently as possible.
	package main

	import (
	"encoding/csv"
	"encoding/json"
	"fmt"
	"log"
	"math"
	"net/http"
	"os"
	"strconv"
	"time"
	)

	const (
	api = "https://api.airtable.com/v0"
	app = "app3n84SwUnqPsvgC"
	tbl = "Table_1"
	viw = "Single_record"
	URL = api + "/" + app + "/" + tbl + "?view=" + viw
	)

	type CSVMethod string

	const (
	csvResults CSVMethod = "results"
	csvStats CSVMethod = "stats"
	)

	func usage() {
	fmt.Printf("usage: go run main.go CONFIG_JSON N_REQS [%s\|%s]\n", csvResults, csvStats)
	os.Exit(1)
	}

	var (
	apiKey string
	nReqs int
	method CSVMethod
	)

	func init() {
	args := os.Args
	if len(args) < 4 {
	usage()
	}

	data, err := os.ReadFile(args[1])
	must(err)

	// Get API key secret out of a JSON file
	var config struct {
	APIKey string `json:"APIKey"`
	}
	err = json.Unmarshal(data, &config)
	must(err)

	apiKey = config.APIKey

	nReqs, err = strconv.Atoi(args[2])
	must(err)

	method = CSVMethod(args[3])
	if method != csvResults && method != csvStats {
	usage()
	}
	}

	// GETResult holds stats on an HTTP GET request and its response.
	type GETResult struct {
	x int // initial order
	start time.Time // request start time
	code int // response status code
	duration time.Duration // how long the response took
	err error // any other error while requesting/responding
	}

	var nilTime = time.Time{}

	func (gr GETResult) Header() []string {
	return []string{"X", "Err", "Start (Unix µs)", "StatusCode", "Duration (ms)"}
	}

	func (gr GETResult) ToRecord() []string {
	x := strconv.Itoa(gr.x)
	err := ""
	if gr.err != nil {
	err = gr.err.Error()
	}
	start := strconv.Itoa(int(gr.start.UnixMicro()))
	code := strconv.Itoa(gr.code)
	dur := strconv.Itoa(int(gr.duration.Milliseconds()))

	return []string{x, err, start, code, dur}
	}

	func main() {
	chResult := make(chan GETResult, nReqs)
	results := make([]GETResult, nReqs)

	// Start concurrent requests and accumulate all responses
	for i := 0; i < nReqs; i++ {
	go func(x int) {
	makeRequest(x, chResult)
	}(i)
	}
	for i := 0; i < nReqs; i++ {
	results[i] = <-chResult
	}

	var records [][]string
	switch method {
	case csvResults:
	records = makeResultsCSV(results)
	case csvStats:
	records = makeStatsCSV(results)
	}

	w := csv.NewWriter(os.Stdout)
	w.WriteAll(records)
	w.Flush()
	if err := w.Error(); err != nil {
	fmt.Println(err)
	}
	}

	func makeRequest(x int, ch chan<- GETResult) {
	gr := GETResult{x: x, start: nilTime, code: -1, duration: -1, err: nil}

	req, err := http.NewRequest("GET", URL, nil)
	if err != nil {
	gr.err = err
	ch <- gr
	return
	}
	req.Header.Add("Authorization", "Bearer "+apiKey)

	gr.start = time.Now()
	client := &http.Client{}

	resp, err := client.Do(req)
	if err != nil {
	gr.err = err
	ch <- gr
	return
	}
	gr.code = resp.StatusCode
	gr.duration = time.Since(gr.start)

	ch <- gr
	}

	func makeResultsCSV(results []GETResult) (records [][]string) {
	records = make([][]string, len(results)+1)
	records[0] = results[0].Header()
	for i, result := range results {
	records[i+1] = result.ToRecord()
	}
	return
	}

	func makeStatsCSV(results []GETResult) (records [][]string) {
	var (
	ct = 0

	min = math.MaxInt
	mean = 0.0
	max = math.MinInt
	stddev = 0.0

	sum = 0.0

	ct200 = 0
	ct429 = 0
	ctErr = 0
	ctOther = 0

	dur = 0 // milliseconds

	durs []float64
	durElem = 0.0
	)

	ct = len(results)

	// Loop to count statuses; get min and max; sum for mean; store durs for Stddev
	durs = make([]float64, ct)
	for i, gr := range results {
	switch {
	case gr.err != nil:
	ctErr += 1
	case gr.code == 200:
	ct200 += 1
	case gr.code == 429:
	ct429 += 1
	default:
	ctOther += 1
	}

	if gr.code != 200 {
	continue
	}

	dur = int(gr.duration.Milliseconds())
	switch {
	case dur < min:
	min = dur
	case dur > max:
	max = dur
	}
	sum += float64(dur)

	durs[i] = float64(dur)
	}

	mean = sum / float64(ct)

	sum = 0.0
	for _, dur := range durs {
	durElem = dur - mean
	sum += durElem * durElem
	}
	stddev = math.Sqrt(sum / float64(ct-1))

	_i := func(x int) string { return strconv.Itoa(x) }
	_f := func(x float64) string { return strconv.Itoa(int(math.Round(x))) }

	records = make([][]string, 2)
	records[0] = []string{
	"N Resp", "Min (ms)", "Mean (ms)", "Max (ms)", "Stddev (ms)", "200s", "429s", "Errors", "Other",
	}
	records[1] = []string{
	_i(ct), _i(min), _f(mean), _i(max), _f(stddev), _i(ct200), _i(ct429), _i(ctErr), _i(ctOther),
	}

	return
	}

	func must(err error) {
	if err != nil {
	log.Fatal(err)
	}
	}
	#!/bin/sh

	# Clean previous
	rm -rf stats*.csv

	# 3 runs of 5, 10, ...
	for x in 5 10 25 40 50; do
	for y in 1 2 3; do
	go run main.go .secrets.json "$x" stats > "stats_${x}_${y}.csv"
	done
	done

	# Combine stats
	gocsv stack stats_*.csv \| gocsv sort -c 1 > stats.csv

	# Convert to MD
	echo '# Stats' > stats.md
	echo >> stats.md
	gocsv viewmd stats.csv \| sed 's/-\|/-:\|/g' >> stats.md