Go Concurrency Rate Limiting

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"math"
	"math/rand"
	"sync"
	"time"
)

type inputType struct {
	offset    int
	batchSize int
}

// sleep a random amount of time, and return errors sometimes
func fakeAPI(input inputType) (json.RawMessage, error) {
	rand.Seed(time.Now().UnixNano())
	n := rand.Intn(10)
	time.Sleep(time.Duration(n) * time.Millisecond)

	mod := math.Mod(float64(input.offset), 11)
	if mod == 0 {
		return json.RawMessage{}, fmt.Errorf("error: divisible by 11: %d", input.offset)
	}
	return json.RawMessage(fmt.Sprintf(`{"offset": %d}`, input.offset)), nil
}

func main() {
	queue := make(chan inputType)
	outs := make(chan json.RawMessage)
	errs := make(chan error)
	done := make(chan struct{})
	wg := sync.WaitGroup{}

	// Add jobs to the queue
	go func() {
		defer close(queue)
		for i := 1; i <= 50; i++ {
			queue <- inputType{
				offset:    i,
				batchSize: 1,
			}
		}
	}()

	// Start up 10 workers. Each worker can process one job at a time.
	for i := 0; i <= 10; i++ {
		wg.Add(1)

		go func() {
			defer wg.Done()
			// Read from the queue until the messages run out
			for input := range queue {
				out, err := fakeAPI(input)
				if err != nil {
					errs <- err
					continue
				}
				outs <- out
			}
		}()
	}

	// Close the done channel when all the workers finish
	go func() {
		wg.Wait()
		close(done)
	}()

	// Do stuff while the channels fill up
	for {
		select {
		case err := <-errs:
			// print to stderr
			log.Println(err)
		case response := <-outs:
			// print to stdout
			fmt.Println(string(response))
		case <-done:
			return
		}
	}
}