Design your client: go way

The Golang standard library provides a lot of examples of code design practices and patterns which allow us to create great things. However in practice engineers often ignore them.
I`m going to tell the story about one little library: the way from write-to-work stage to the idiomatic go implementation.

Transcript

1. DESIGN YOUR CLIENT Mike Kabischev
2. JUNO ▸250k lines of code ▸~70 microservices ▸hundreds of running containers ▸thousands RPS ▸40+ backend engineers
3. CODE BELONGS TO THE TEAM, NOT THE INDIVIDUAL
5. CLEAN CODE ▸Simple ▸Adaptable ▸Testable
6. ONE CLIENT STORY
7. 3-RD PARTY SERVICE A SERVICE B SERVICE C
8. 3-RD PARTY SERVICE A SERVICE B SERVICE C
9. HTTP CLIENT
10. // HTTPClient wraps httpClient type HTTPClient struct { httpClient *http.Client } // Do sends HTTP request func (c *HTTPClient) Do(r *http.Request) (*http.Response, error) { return http.DefaultClient.Do(r) } HTTP CLIENT
11. HTTP CLIENT ‣Authorization ‣Logging ‣Instrumentation ‣Backoff retries ‣Load balancing
12. // Do sends HTTP request with authorization, load balancing, // retries, metrics & logging func (c *HTTPClient) Do(r *http.Request) (res *http.Response, err error) { r.Header.Add("Authorization", c.AuthToken) for i := 0; i < c.RetryAttempts; i++ { r.URL.Host = c.Backends[rand.Intn(len(c.Backends))] c.Logger.Printf("make HTTP call. Method: %v. URL: %v", r.Method, r.URL) start := time.Now() res, err = http.DefaultClient.Do(r) c.DurationSummary.Observe(time.Since(start).Seconds()) if err != nil { c.Logger.Printf("error while making HTTP call: %v", err) time.Sleep(time.Duration(i) * c.RetryDelay) continue } break } c.Logger.Printf("response code: %v", res.StatusCode) return res, err } HTTP CLIENT
14. // Do sends HTTP request with authorization, load balancing, // retries, metrics & logging func (c *HTTPClient) Do(r *http.Request) (res *http.Response, err error) { r.Header.Add("Authorization", c.AuthToken) for i := 0; i < c.RetryAttempts; i++ { r.URL.Host = c.Backends[rand.Intn(len(c.Backends))] c.Logger.Printf("make HTTP call. Method: %v. URL: %v", r.Method, r.URL) start := time.Now() res, err = http.DefaultClient.Do(r) c.DurationSummary.Observe(time.Since(start).Seconds()) if err != nil { c.Logger.Printf("error while making HTTP call: %v", err) time.Sleep(time.Duration(i) * c.RetryDelay) continue } break } c.Logger.Printf("response code: %v", res.StatusCode) return res, err } HTTP CLIENT
15. EVERYTHING IS ALREADY INVENTED
16. // A Handler responds to an HTTP request. type Handler interface { ServeHTTP(ResponseWriter, *Request) } // The HandlerFunc type is an adapter to allow the use of // ordinary functions as HTTP handlers. If f is a function // with the appropriate signature, HandlerFunc(f) is a // Handler that calls f. type HandlerFunc func(ResponseWriter, *Request) // ServeHTTP calls f(w, r). func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) { f(w, r) } HTTP HANDLERS
17. MIDDLEWARE // Middleware adds additional behaviour to handler type Middleware func(http.Handler) http.Handler
18. MIDDLEWARE CHAIN HANDLER REQUEST Middleware A Middleware B Middleware C
19. MIDDLEWARE CHAIN HANDLER REQUEST Middleware A Middleware B Middleware C
20. MIDDLEWARE CHAIN HANDLER REQUEST Middleware A Middleware B Middleware C
21. MIDDLEWARE CHAIN HANDLER REQUEST Middleware A Middleware B Middleware C
22. MIDDLEWARE CHAIN HANDLER REQUEST Middleware A Middleware B Middleware C
23. MIDDLEWARE CHAIN HANDLER RESPONSE Middleware A Middleware B Middleware C
24. MIDDLEWARE CHAIN CLIENT RESPONSE Middleware A Middleware B Middleware C
25. MIDDLEWARE CHAIN CLIENT RESPONSE Middleware A Middleware B Middleware C
26. MIDDLEWARE CHAIN HANDLER RESPONSE Middleware A Middleware B Middleware C
27. MIDDLEWARE CHAIN HANDLER RESPONSE Middleware A Middleware B Middleware C
28. PROJECT IT TO THE CLIENT SIDE
29. CLIENT INTERFACE // Client is an interface supported by http.Client type Client interface { Do(req *http.Request) (*http.Response, error) } // ClientFn is a function that implements Client type ClientFn func(*http.Request) (*http.Response, error) // Do is an implementation of Client interface func (c ClientFn) Do(r *http.Request) (*http.Response, error) { return c(r) }
30. MIDDLEWARE // Middleware adds additional behaviour to Client type Middleware func(Client) Client
31. LOGGING // Logging returns a Middleware that logs request func Logging(l *log.Logger) Middleware { return func(c Client) Client { return ClientFn(func(r *http.Request) (*http.Response, error) { l.Printf("HTTP call. Method: %v. URL: %v", r.Method, r.URL) return c.Do(r) }) } }
32. HEADERS // Header adds specified header to request func Header(key, value string) Middleware { return func(c Client) Client { return ClientFn(func(r *http.Request) (*http.Response, error) { r.Header.Add(key, value) return c.Do(r) }) } } // BasicAuthorization adds header for Basic HTTP Authorization func BasicAuthorization(username, password string) Middleware { value := []byte(username + ":" + password) encoded := base64.StdEncoding.EncodeToString(value) return Header("Authorization", "Basic "+encoded) }
33. METRICS // Metrics returns a Middleware that measures the time taken by request func Metrics(s prometheus.Summary) Middleware { return func(c Client) Client { return ClientFn(func(r *http.Request) (*http.Response, error) { defer func(t time.Time) { s.Observe(time.Since(t).Seconds()) }(time.Now()) return c.Do(r) }) } }
34. BACKOFF // Backoff returns a Middleware that makes configured number of attemps // to make HTTP call func Backoff(attemps int, delay time.Duration) Middleware { return func(c Client) Client { return ClientFn(func(r *http.Request) (res *http.Response, err error) { for i := 0; i < attemps; i++ { if res, err := c.Do(r); err == nil { break } time.Sleep(time.Duration(i) * delay) } return res, err }) } }
35. LOAD BALANCING // LoadBalancing returns a Middleware that chooses random backend from // the specified list func LoadBalancing(backends ...string) Middleware { return func(c Client) Client { return ClientFn(func(r *http.Request) (*http.Response, error) { r.URL.Host = backends[rand.Intn(len(backends))] return c.Do® }) } }
36. RECOVER // Recover returns a middleware that recovers all panics func Recover() Middleware { return func(c Client) Client { return ClientFn(func(r *http.Request) (res *http.Response, err error) { defer func() { if r := recover(); r != nil { err = fmt.Errorf("recovered panic: %v", r) } }() return c.Do(r) }) } }
38. MIDDLEWARE CHAIN // Chain wraps a Client c with all the given middlewares func Chain(c Client, mw ...Middleware) Client { result := c for _, middleware := range mw { result = middleware(result) } return result }
39. MIDDLEWARE CHAIN client := Chain( &http.Client{}, Logging(log.New(os.Stdout, "http: ", log.LstdFlags)), )
40. MIDDLEWARE CHAIN client := Chain( &http.Client{}, Logging(log.New(os.Stdout, "http: ", log.LstdFlags)), BasicAuthorization("username", "password"), )
41. MIDDLEWARE CHAIN client := Chain( &http.Client{}, Logging(log.New(os.Stdout, "http: ", log.LstdFlags)), BasicAuthorization("username", "password"), Metrics(NewSummary("request_duration_seconds")), )
42. MIDDLEWARE CHAIN client := Chain( &http.Client{}, Logging(log.New(os.Stdout, "http: ", log.LstdFlags)), BasicAuthorization("username", "password"), Metrics(NewSummary("request_duration_seconds")), Backoff(3, 20*time.Millisecond), )
43. MIDDLEWARE CHAIN client := Chain( &http.Client{}, Logging(log.New(os.Stdout, "http: ", log.LstdFlags)), BasicAuthorization("username", "password"), Metrics(NewSummary("request_duration_seconds")), Backoff(3, 20*time.Millisecond), LoadBalancing("instance01", "instance02", "instance03"), )
44. MIDDLEWARE CHAIN client := Chain( &http.Client{}, Logging(log.New(os.Stdout, "http: ", log.LstdFlags)), BasicAuthorization("username", "password"), Metrics(NewSummary("request_duration_seconds")), Backoff(3, 20*time.Millisecond), LoadBalancing("instance01", "instance02", "instance03"), Recover(), )
45. http://idiomaticgo.com/post/best-practice/accept-interfaces-return-structs/ ACCEPT INTERFACES RETURN STRUCTS
46. https://github.com/gojuno/go-zooz GO WAY
47. NOT GO WAY googlemaps.github.io/maps github.com/aws/aws-sdk-go github.com/coreos/go-etcd github.com/moby/moby github.com/openzipkin/zipkin-go-opentracing github.com/stripe/stripe-go ... and more ...
49. DON'T FORGET THE BASICS https://go-proverbs.github.io https://golang.org/doc/effective_go.html https://github.com/golang/go/wiki/CodeReviewComments
50. SIMPLICITY IS COMPLICATED Rob Pike
51. QUESTIONS?