Go Programming

Go Programming

1630848852

fasthttp: Fast HTTP implementation for Go

fasthttp

Fast HTTP implementation for Go.

Currently fasthttp is successfully used by VertaMedia in a production serving up to 200K rps from more than 1.5M concurrent keep-alive connections per physical server.

HTTP server performance comparison with net/http

In short, fasthttp server is up to 10 times faster than net/http. Below are benchmark results.

GOMAXPROCS=1

net/http server:

$ GOMAXPROCS=1 go test -bench=NetHTTPServerGet -benchmem -benchtime=10s
BenchmarkNetHTTPServerGet1ReqPerConn                     1000000         12052 ns/op        2297 B/op          29 allocs/op
BenchmarkNetHTTPServerGet2ReqPerConn                     1000000         12278 ns/op        2327 B/op          24 allocs/op
BenchmarkNetHTTPServerGet10ReqPerConn                    2000000          8903 ns/op        2112 B/op          19 allocs/op
BenchmarkNetHTTPServerGet10KReqPerConn                   2000000          8451 ns/op        2058 B/op          18 allocs/op
BenchmarkNetHTTPServerGet1ReqPerConn10KClients            500000         26733 ns/op        3229 B/op          29 allocs/op
BenchmarkNetHTTPServerGet2ReqPerConn10KClients           1000000         23351 ns/op        3211 B/op          24 allocs/op
BenchmarkNetHTTPServerGet10ReqPerConn10KClients          1000000         13390 ns/op        2483 B/op          19 allocs/op
BenchmarkNetHTTPServerGet100ReqPerConn10KClients         1000000         13484 ns/op        2171 B/op          18 allocs/op

fasthttp server:

$ GOMAXPROCS=1 go test -bench=kServerGet -benchmem -benchtime=10s
BenchmarkServerGet1ReqPerConn                           10000000          1559 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet2ReqPerConn                           10000000          1248 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet10ReqPerConn                          20000000           797 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet10KReqPerConn                         20000000           716 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet1ReqPerConn10KClients                 10000000          1974 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet2ReqPerConn10KClients                 10000000          1352 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet10ReqPerConn10KClients                20000000           789 ns/op           2 B/op           0 allocs/op
BenchmarkServerGet100ReqPerConn10KClients               20000000           604 ns/op           0 B/op           0 allocs/op

GOMAXPROCS=4

net/http server:

$ GOMAXPROCS=4 go test -bench=NetHTTPServerGet -benchmem -benchtime=10s
BenchmarkNetHTTPServerGet1ReqPerConn-4                       3000000          4529 ns/op        2389 B/op          29 allocs/op
BenchmarkNetHTTPServerGet2ReqPerConn-4                       5000000          3896 ns/op        2418 B/op          24 allocs/op
BenchmarkNetHTTPServerGet10ReqPerConn-4                      5000000          3145 ns/op        2160 B/op          19 allocs/op
BenchmarkNetHTTPServerGet10KReqPerConn-4                     5000000          3054 ns/op        2065 B/op          18 allocs/op
BenchmarkNetHTTPServerGet1ReqPerConn10KClients-4             1000000         10321 ns/op        3710 B/op          30 allocs/op
BenchmarkNetHTTPServerGet2ReqPerConn10KClients-4             2000000          7556 ns/op        3296 B/op          24 allocs/op
BenchmarkNetHTTPServerGet10ReqPerConn10KClients-4            5000000          3905 ns/op        2349 B/op          19 allocs/op
BenchmarkNetHTTPServerGet100ReqPerConn10KClients-4           5000000          3435 ns/op        2130 B/op          18 allocs/op

fasthttp server:

$ GOMAXPROCS=4 go test -bench=kServerGet -benchmem -benchtime=10s
BenchmarkServerGet1ReqPerConn-4                             10000000          1141 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet2ReqPerConn-4                             20000000           707 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet10ReqPerConn-4                            30000000           341 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet10KReqPerConn-4                           50000000           310 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet1ReqPerConn10KClients-4                   10000000          1119 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet2ReqPerConn10KClients-4                   20000000           644 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet10ReqPerConn10KClients-4                  30000000           346 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet100ReqPerConn10KClients-4                 50000000           282 ns/op           0 B/op           0 allocs/op

HTTP client comparison with net/http

In short, fasthttp client is up to 10 times faster than net/http. Below are benchmark results.

GOMAXPROCS=1

net/http client:

$ GOMAXPROCS=1 go test -bench='HTTPClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
BenchmarkNetHTTPClientDoFastServer                       1000000         12567 ns/op        2616 B/op          35 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1TCP                     200000         67030 ns/op        5028 B/op          56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd10TCP                    300000         51098 ns/op        5031 B/op          56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd100TCP                   300000         45096 ns/op        5026 B/op          55 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1Inmemory                500000         24779 ns/op        5035 B/op          57 allocs/op
BenchmarkNetHTTPClientGetEndToEnd10Inmemory              1000000         26425 ns/op        5035 B/op          57 allocs/op
BenchmarkNetHTTPClientGetEndToEnd100Inmemory              500000         28515 ns/op        5045 B/op          57 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1000Inmemory             500000         39511 ns/op        5096 B/op          56 allocs/op

fasthttp client:

$ GOMAXPROCS=1 go test -bench='kClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
BenchmarkClientDoFastServer                             20000000           865 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd1TCP                           1000000         18711 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd10TCP                          1000000         14664 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd100TCP                         1000000         14043 ns/op           1 B/op           0 allocs/op
BenchmarkClientGetEndToEnd1Inmemory                      5000000          3965 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd10Inmemory                     3000000          4060 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd100Inmemory                    5000000          3396 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd1000Inmemory                   5000000          3306 ns/op           2 B/op           0 allocs/op

GOMAXPROCS=4

net/http client:

$ GOMAXPROCS=4 go test -bench='HTTPClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
BenchmarkNetHTTPClientDoFastServer-4                         2000000          8774 ns/op        2619 B/op          35 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1TCP-4                       500000         22951 ns/op        5047 B/op          56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd10TCP-4                     1000000         19182 ns/op        5037 B/op          55 allocs/op
BenchmarkNetHTTPClientGetEndToEnd100TCP-4                    1000000         16535 ns/op        5031 B/op          55 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1Inmemory-4                 1000000         14495 ns/op        5038 B/op          56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd10Inmemory-4                1000000         10237 ns/op        5034 B/op          56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd100Inmemory-4               1000000         10125 ns/op        5045 B/op          56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1000Inmemory-4              1000000         11132 ns/op        5136 B/op          56 allocs/op

fasthttp client:

$ GOMAXPROCS=4 go test -bench='kClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
BenchmarkClientDoFastServer-4                               50000000           397 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd1TCP-4                             2000000          7388 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd10TCP-4                            2000000          6689 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd100TCP-4                           3000000          4927 ns/op           1 B/op           0 allocs/op
BenchmarkClientGetEndToEnd1Inmemory-4                       10000000          1604 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd10Inmemory-4                      10000000          1458 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd100Inmemory-4                     10000000          1329 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd1000Inmemory-4                    10000000          1316 ns/op           5 B/op           0 allocs/op

Install

go get -u github.com/valyala/fasthttp

Switching from net/http to fasthttp

Unfortunately, fasthttp doesn't provide API identical to net/http. See the FAQ for details. There is net/http -> fasthttp handler converter, but it is better to write fasthttp request handlers by hand in order to use all of the fasthttp advantages (especially high performance :) ).

Important points:

Fasthttp works with RequestHandler functions instead of objects implementing Handler interface. Fortunately, it is easy to pass bound struct methods to fasthttp:

type MyHandler struct {
	foobar string
}

// request handler in net/http style, i.e. method bound to MyHandler struct.
func (h *MyHandler) HandleFastHTTP(ctx *fasthttp.RequestCtx) {
	// notice that we may access MyHandler properties here - see h.foobar.
	fmt.Fprintf(ctx, "Hello, world! Requested path is %q. Foobar is %q",
		ctx.Path(), h.foobar)
}

// request handler in fasthttp style, i.e. just plain function.
func fastHTTPHandler(ctx *fasthttp.RequestCtx) {
	fmt.Fprintf(ctx, "Hi there! RequestURI is %q", ctx.RequestURI())
}

// pass bound struct method to fasthttp
myHandler := &MyHandler{
	foobar: "foobar",
}
fasthttp.ListenAndServe(":8080", myHandler.HandleFastHTTP)

// pass plain function to fasthttp
fasthttp.ListenAndServe(":8081", fastHTTPHandler)

The RequestHandler accepts only one argument - RequestCtx. It contains all the functionality required for http request processing and response writing. Below is an example of a simple request handler conversion from net/http to fasthttp.

// net/http request handler
requestHandler := func(w http.ResponseWriter, r *http.Request) {
	switch r.URL.Path {
	case "/foo":
		fooHandler(w, r)
	case "/bar":
		barHandler(w, r)
	default:
		http.Error(w, "Unsupported path", http.StatusNotFound)
	}
}
// the corresponding fasthttp request handler
requestHandler := func(ctx *fasthttp.RequestCtx) {
	switch string(ctx.Path()) {
	case "/foo":
		fooHandler(ctx)
	case "/bar":
		barHandler(ctx)
	default:
		ctx.Error("Unsupported path", fasthttp.StatusNotFound)
	}
}

Fasthttp allows setting response headers and writing response body in an arbitrary order. There is no 'headers first, then body' restriction like in net/http. The following code is valid for fasthttp:

requestHandler := func(ctx *fasthttp.RequestCtx) {
	// set some headers and status code first
	ctx.SetContentType("foo/bar")
	ctx.SetStatusCode(fasthttp.StatusOK)

	// then write the first part of body
	fmt.Fprintf(ctx, "this is the first part of body\n")

	// then set more headers
	ctx.Response.Header.Set("Foo-Bar", "baz")

	// then write more body
	fmt.Fprintf(ctx, "this is the second part of body\n")

	// then override already written body
	ctx.SetBody([]byte("this is completely new body contents"))

	// then update status code
	ctx.SetStatusCode(fasthttp.StatusNotFound)

	// basically, anything may be updated many times before
	// returning from RequestHandler.
	//
	// Unlike net/http fasthttp doesn't put response to the wire until
	// returning from RequestHandler.
}

Fasthttp doesn't provide ServeMux, but there are more powerful third-party routers and web frameworks with fasthttp support:

Net/http code with simple ServeMux is trivially converted to fasthttp code:

// net/http code

m := &http.ServeMux{}
m.HandleFunc("/foo", fooHandlerFunc)
m.HandleFunc("/bar", barHandlerFunc)
m.Handle("/baz", bazHandler)

http.ListenAndServe(":80", m)
// the corresponding fasthttp code
m := func(ctx *fasthttp.RequestCtx) {
	switch string(ctx.Path()) {
	case "/foo":
		fooHandlerFunc(ctx)
	case "/bar":
		barHandlerFunc(ctx)
	case "/baz":
		bazHandler.HandlerFunc(ctx)
	default:
		ctx.Error("not found", fasthttp.StatusNotFound)
	}
}

fasthttp.ListenAndServe(":80", m)

net/http -> fasthttp conversion table:

  • All the pseudocode below assumes w, r and ctx have these types:
  var (
  	w http.ResponseWriter
  	r *http.Request
  	ctx *fasthttp.RequestCtx
  )

VERY IMPORTANT! Fasthttp disallows holding references to RequestCtx or to its' members after returning from RequestHandler. Otherwise data races are inevitable. Carefully inspect all the net/http request handlers converted to fasthttp whether they retain references to RequestCtx or to its' members after returning. RequestCtx provides the following band aids for this case:

  • Wrap RequestHandler into TimeoutHandler.
  • Call TimeoutError before returning from RequestHandler if there are references to RequestCtx or to its' members. See the example for more details.

Use this brilliant tool - race detector - for detecting and eliminating data races in your program. If you detected data race related to fasthttp in your program, then there is high probability you forgot calling TimeoutError before returning from RequestHandler.

Blind switching from net/http to fasthttp won't give you performance boost. While fasthttp is optimized for speed, its' performance may be easily saturated by slow RequestHandler. So profile and optimize your code after switching to fasthttp. For instance, use quicktemplate instead of html/template.

See also fasthttputil, fasthttpadaptor and expvarhandler.

Performance optimization tips for multi-core systems

  • Use reuseport listener.
  • Run a separate server instance per CPU core with GOMAXPROCS=1.
  • Pin each server instance to a separate CPU core using taskset.
  • Ensure the interrupts of multiqueue network card are evenly distributed between CPU cores. See this article for details.
  • Use the latest version of Go as each version contains performance improvements.

Fasthttp best practices

  • Do not allocate objects and []byte buffers - just reuse them as much as possible. Fasthttp API design encourages this.
  • sync.Pool is your best friend.
  • Profile your program in production. go tool pprof --alloc_objects your-program mem.pprof usually gives better insights for optimization opportunities than go tool pprof your-program cpu.pprof.
  • Write tests and benchmarks for hot paths.
  • Avoid conversion between []byte and string, since this may result in memory allocation+copy. Fasthttp API provides functions for both []byte and string - use these functions instead of converting manually between []byte and string. There are some exceptions - see this wiki page for more details.
  • Verify your tests and production code under race detector on a regular basis.
  • Prefer quicktemplate instead of html/template in your webserver.

Tricks with []byte buffers

The following tricks are used by fasthttp. Use them in your code too.

  • Standard Go functions accept nil buffers
var (
	// both buffers are uninitialized
	dst []byte
	src []byte
)
dst = append(dst, src...)  // is legal if dst is nil and/or src is nil
copy(dst, src)  // is legal if dst is nil and/or src is nil
(string(src) == "")  // is true if src is nil
(len(src) == 0)  // is true if src is nil
src = src[:0]  // works like a charm with nil src

// this for loop doesn't panic if src is nil
for i, ch := range src {
	doSomething(i, ch)
}

So throw away nil checks for []byte buffers from you code. For example,

srcLen := 0
if src != nil {
	srcLen = len(src)
}

becomes

srcLen := len(src)

String may be appended to []byte buffer with append

dst = append(dst, "foobar"...)

[]byte buffer may be extended to its' capacity.

All fasthttp functions accept nil []byte buffer

statusCode, body, err := fasthttp.Get(nil, "http://google.com/")
uintBuf := fasthttp.AppendUint(nil, 1234)

Related projects

  • fasthttp - various useful helpers for projects based on fasthttp.
  • fasthttp-routing - fast and powerful routing package for fasthttp servers.
  • http2 - HTTP/2 implementation for fasthttp.
  • router - a high performance fasthttp request router that scales well.
  • fastws - Bloatless WebSocket package made for fasthttp to handle Read/Write operations concurrently.
  • gramework - a web framework made by one of fasthttp maintainers
  • lu - a high performance go middleware web framework which is based on fasthttp.
  • websocket - Gorilla-based websocket implementation for fasthttp.
  • websocket - Event-based high-performance WebSocket library for zero-allocation websocket servers and clients.
  • fasthttpsession - a fast and powerful session package for fasthttp servers.
  • atreugo - High performance and extensible micro web framework with zero memory allocations in hot paths.
  • kratgo - Simple, lightweight and ultra-fast HTTP Cache to speed up your websites.
  • kit-plugins - go-kit transport implementation for fasthttp.
  • Fiber - An Expressjs inspired web framework running on Fasthttp
  • Gearbox - :gear: gearbox is a web framework written in Go with a focus on high performance and memory optimization

FAQ

Why creating yet another http package instead of optimizing net/http?

Because net/http API limits many optimization opportunities. For example:

  • net/http Request object lifetime isn't limited by request handler execution time. So the server must create a new request object per each request instead of reusing existing objects like fasthttp does.
  • net/http headers are stored in a map[string][]string. So the server must parse all the headers, convert them from []byte to string and put them into the map before calling user-provided request handler. This all requires unnecessary memory allocations avoided by fasthttp.
  • net/http client API requires creating a new response object per each request.

Why fasthttp API is incompatible with net/http?

Because net/http API limits many optimization opportunities. See the answer above for more details. Also certain net/http API parts are suboptimal for use:

Why fasthttp doesn't support HTTP/2.0 and WebSockets?

HTTP/2.0 support is in progress. WebSockets has been done already. Third parties also may use RequestCtx.Hijack for implementing these goodies.

Are there known net/http advantages comparing to fasthttp?

Yes:

  • net/http supports HTTP/2.0 starting from go1.6.
  • net/http API is stable, while fasthttp API constantly evolves.
  • net/http handles more HTTP corner cases.
  • net/http should contain less bugs, since it is used and tested by much wider audience.
  • net/http works on Go older than 1.5.

Why fasthttp API prefers returning []byte instead of string?

Because []byte to string conversion isn't free - it requires memory allocation and copy. Feel free wrapping returned []byte result into string() if you prefer working with strings instead of byte slices. But be aware that this has non-zero overhead.

Which GO versions are supported by fasthttp?

Go1.5+. Older versions won't be supported, since their standard package miss useful functions.

NOTE: Go 1.9.7 is the oldest tested version. We recommend you to update as soon as you can. As of 1.11.3 we will drop 1.9.x support.

Please provide real benchmark data and server information

See this issue.

Are there plans to add request routing to fasthttp?

There are no plans to add request routing into fasthttp. Use third-party routers and web frameworks with fasthttp support:

I detected data race in fasthttp!

Cool! File a bug. But before doing this check the following in your code:

I didn't find an answer for my question here

Try exploring these questions.

Download Details:
Author: valyala
Download Link: Download The Source Code
Official Website: https://github.com/valyala/fasthttp 
License: MIT

#go #golang #programming #developer 

What is GEEK

Buddha Community

fasthttp: Fast HTTP implementation for Go
Fannie  Zemlak

Fannie Zemlak

1599854400

What's new in the go 1.15

Go announced Go 1.15 version on 11 Aug 2020. Highlighted updates and features include Substantial improvements to the Go linker, Improved allocation for small objects at high core counts, X.509 CommonName deprecation, GOPROXY supports skipping proxies that return errors, New embedded tzdata package, Several Core Library improvements and more.

As Go promise for maintaining backward compatibility. After upgrading to the latest Go 1.15 version, almost all existing Golang applications or programs continue to compile and run as older Golang version.

#go #golang #go 1.15 #go features #go improvement #go package #go new features

Go Programming

Go Programming

1630848852

fasthttp: Fast HTTP implementation for Go

fasthttp

Fast HTTP implementation for Go.

Currently fasthttp is successfully used by VertaMedia in a production serving up to 200K rps from more than 1.5M concurrent keep-alive connections per physical server.

HTTP server performance comparison with net/http

In short, fasthttp server is up to 10 times faster than net/http. Below are benchmark results.

GOMAXPROCS=1

net/http server:

$ GOMAXPROCS=1 go test -bench=NetHTTPServerGet -benchmem -benchtime=10s
BenchmarkNetHTTPServerGet1ReqPerConn                     1000000         12052 ns/op        2297 B/op          29 allocs/op
BenchmarkNetHTTPServerGet2ReqPerConn                     1000000         12278 ns/op        2327 B/op          24 allocs/op
BenchmarkNetHTTPServerGet10ReqPerConn                    2000000          8903 ns/op        2112 B/op          19 allocs/op
BenchmarkNetHTTPServerGet10KReqPerConn                   2000000          8451 ns/op        2058 B/op          18 allocs/op
BenchmarkNetHTTPServerGet1ReqPerConn10KClients            500000         26733 ns/op        3229 B/op          29 allocs/op
BenchmarkNetHTTPServerGet2ReqPerConn10KClients           1000000         23351 ns/op        3211 B/op          24 allocs/op
BenchmarkNetHTTPServerGet10ReqPerConn10KClients          1000000         13390 ns/op        2483 B/op          19 allocs/op
BenchmarkNetHTTPServerGet100ReqPerConn10KClients         1000000         13484 ns/op        2171 B/op          18 allocs/op

fasthttp server:

$ GOMAXPROCS=1 go test -bench=kServerGet -benchmem -benchtime=10s
BenchmarkServerGet1ReqPerConn                           10000000          1559 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet2ReqPerConn                           10000000          1248 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet10ReqPerConn                          20000000           797 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet10KReqPerConn                         20000000           716 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet1ReqPerConn10KClients                 10000000          1974 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet2ReqPerConn10KClients                 10000000          1352 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet10ReqPerConn10KClients                20000000           789 ns/op           2 B/op           0 allocs/op
BenchmarkServerGet100ReqPerConn10KClients               20000000           604 ns/op           0 B/op           0 allocs/op

GOMAXPROCS=4

net/http server:

$ GOMAXPROCS=4 go test -bench=NetHTTPServerGet -benchmem -benchtime=10s
BenchmarkNetHTTPServerGet1ReqPerConn-4                       3000000          4529 ns/op        2389 B/op          29 allocs/op
BenchmarkNetHTTPServerGet2ReqPerConn-4                       5000000          3896 ns/op        2418 B/op          24 allocs/op
BenchmarkNetHTTPServerGet10ReqPerConn-4                      5000000          3145 ns/op        2160 B/op          19 allocs/op
BenchmarkNetHTTPServerGet10KReqPerConn-4                     5000000          3054 ns/op        2065 B/op          18 allocs/op
BenchmarkNetHTTPServerGet1ReqPerConn10KClients-4             1000000         10321 ns/op        3710 B/op          30 allocs/op
BenchmarkNetHTTPServerGet2ReqPerConn10KClients-4             2000000          7556 ns/op        3296 B/op          24 allocs/op
BenchmarkNetHTTPServerGet10ReqPerConn10KClients-4            5000000          3905 ns/op        2349 B/op          19 allocs/op
BenchmarkNetHTTPServerGet100ReqPerConn10KClients-4           5000000          3435 ns/op        2130 B/op          18 allocs/op

fasthttp server:

$ GOMAXPROCS=4 go test -bench=kServerGet -benchmem -benchtime=10s
BenchmarkServerGet1ReqPerConn-4                             10000000          1141 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet2ReqPerConn-4                             20000000           707 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet10ReqPerConn-4                            30000000           341 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet10KReqPerConn-4                           50000000           310 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet1ReqPerConn10KClients-4                   10000000          1119 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet2ReqPerConn10KClients-4                   20000000           644 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet10ReqPerConn10KClients-4                  30000000           346 ns/op           0 B/op           0 allocs/op
BenchmarkServerGet100ReqPerConn10KClients-4                 50000000           282 ns/op           0 B/op           0 allocs/op

HTTP client comparison with net/http

In short, fasthttp client is up to 10 times faster than net/http. Below are benchmark results.

GOMAXPROCS=1

net/http client:

$ GOMAXPROCS=1 go test -bench='HTTPClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
BenchmarkNetHTTPClientDoFastServer                       1000000         12567 ns/op        2616 B/op          35 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1TCP                     200000         67030 ns/op        5028 B/op          56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd10TCP                    300000         51098 ns/op        5031 B/op          56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd100TCP                   300000         45096 ns/op        5026 B/op          55 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1Inmemory                500000         24779 ns/op        5035 B/op          57 allocs/op
BenchmarkNetHTTPClientGetEndToEnd10Inmemory              1000000         26425 ns/op        5035 B/op          57 allocs/op
BenchmarkNetHTTPClientGetEndToEnd100Inmemory              500000         28515 ns/op        5045 B/op          57 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1000Inmemory             500000         39511 ns/op        5096 B/op          56 allocs/op

fasthttp client:

$ GOMAXPROCS=1 go test -bench='kClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
BenchmarkClientDoFastServer                             20000000           865 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd1TCP                           1000000         18711 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd10TCP                          1000000         14664 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd100TCP                         1000000         14043 ns/op           1 B/op           0 allocs/op
BenchmarkClientGetEndToEnd1Inmemory                      5000000          3965 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd10Inmemory                     3000000          4060 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd100Inmemory                    5000000          3396 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd1000Inmemory                   5000000          3306 ns/op           2 B/op           0 allocs/op

GOMAXPROCS=4

net/http client:

$ GOMAXPROCS=4 go test -bench='HTTPClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
BenchmarkNetHTTPClientDoFastServer-4                         2000000          8774 ns/op        2619 B/op          35 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1TCP-4                       500000         22951 ns/op        5047 B/op          56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd10TCP-4                     1000000         19182 ns/op        5037 B/op          55 allocs/op
BenchmarkNetHTTPClientGetEndToEnd100TCP-4                    1000000         16535 ns/op        5031 B/op          55 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1Inmemory-4                 1000000         14495 ns/op        5038 B/op          56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd10Inmemory-4                1000000         10237 ns/op        5034 B/op          56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd100Inmemory-4               1000000         10125 ns/op        5045 B/op          56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1000Inmemory-4              1000000         11132 ns/op        5136 B/op          56 allocs/op

fasthttp client:

$ GOMAXPROCS=4 go test -bench='kClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
BenchmarkClientDoFastServer-4                               50000000           397 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd1TCP-4                             2000000          7388 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd10TCP-4                            2000000          6689 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd100TCP-4                           3000000          4927 ns/op           1 B/op           0 allocs/op
BenchmarkClientGetEndToEnd1Inmemory-4                       10000000          1604 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd10Inmemory-4                      10000000          1458 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd100Inmemory-4                     10000000          1329 ns/op           0 B/op           0 allocs/op
BenchmarkClientGetEndToEnd1000Inmemory-4                    10000000          1316 ns/op           5 B/op           0 allocs/op

Install

go get -u github.com/valyala/fasthttp

Switching from net/http to fasthttp

Unfortunately, fasthttp doesn't provide API identical to net/http. See the FAQ for details. There is net/http -> fasthttp handler converter, but it is better to write fasthttp request handlers by hand in order to use all of the fasthttp advantages (especially high performance :) ).

Important points:

Fasthttp works with RequestHandler functions instead of objects implementing Handler interface. Fortunately, it is easy to pass bound struct methods to fasthttp:

type MyHandler struct {
	foobar string
}

// request handler in net/http style, i.e. method bound to MyHandler struct.
func (h *MyHandler) HandleFastHTTP(ctx *fasthttp.RequestCtx) {
	// notice that we may access MyHandler properties here - see h.foobar.
	fmt.Fprintf(ctx, "Hello, world! Requested path is %q. Foobar is %q",
		ctx.Path(), h.foobar)
}

// request handler in fasthttp style, i.e. just plain function.
func fastHTTPHandler(ctx *fasthttp.RequestCtx) {
	fmt.Fprintf(ctx, "Hi there! RequestURI is %q", ctx.RequestURI())
}

// pass bound struct method to fasthttp
myHandler := &MyHandler{
	foobar: "foobar",
}
fasthttp.ListenAndServe(":8080", myHandler.HandleFastHTTP)

// pass plain function to fasthttp
fasthttp.ListenAndServe(":8081", fastHTTPHandler)

The RequestHandler accepts only one argument - RequestCtx. It contains all the functionality required for http request processing and response writing. Below is an example of a simple request handler conversion from net/http to fasthttp.

// net/http request handler
requestHandler := func(w http.ResponseWriter, r *http.Request) {
	switch r.URL.Path {
	case "/foo":
		fooHandler(w, r)
	case "/bar":
		barHandler(w, r)
	default:
		http.Error(w, "Unsupported path", http.StatusNotFound)
	}
}
// the corresponding fasthttp request handler
requestHandler := func(ctx *fasthttp.RequestCtx) {
	switch string(ctx.Path()) {
	case "/foo":
		fooHandler(ctx)
	case "/bar":
		barHandler(ctx)
	default:
		ctx.Error("Unsupported path", fasthttp.StatusNotFound)
	}
}

Fasthttp allows setting response headers and writing response body in an arbitrary order. There is no 'headers first, then body' restriction like in net/http. The following code is valid for fasthttp:

requestHandler := func(ctx *fasthttp.RequestCtx) {
	// set some headers and status code first
	ctx.SetContentType("foo/bar")
	ctx.SetStatusCode(fasthttp.StatusOK)

	// then write the first part of body
	fmt.Fprintf(ctx, "this is the first part of body\n")

	// then set more headers
	ctx.Response.Header.Set("Foo-Bar", "baz")

	// then write more body
	fmt.Fprintf(ctx, "this is the second part of body\n")

	// then override already written body
	ctx.SetBody([]byte("this is completely new body contents"))

	// then update status code
	ctx.SetStatusCode(fasthttp.StatusNotFound)

	// basically, anything may be updated many times before
	// returning from RequestHandler.
	//
	// Unlike net/http fasthttp doesn't put response to the wire until
	// returning from RequestHandler.
}

Fasthttp doesn't provide ServeMux, but there are more powerful third-party routers and web frameworks with fasthttp support:

Net/http code with simple ServeMux is trivially converted to fasthttp code:

// net/http code

m := &http.ServeMux{}
m.HandleFunc("/foo", fooHandlerFunc)
m.HandleFunc("/bar", barHandlerFunc)
m.Handle("/baz", bazHandler)

http.ListenAndServe(":80", m)
// the corresponding fasthttp code
m := func(ctx *fasthttp.RequestCtx) {
	switch string(ctx.Path()) {
	case "/foo":
		fooHandlerFunc(ctx)
	case "/bar":
		barHandlerFunc(ctx)
	case "/baz":
		bazHandler.HandlerFunc(ctx)
	default:
		ctx.Error("not found", fasthttp.StatusNotFound)
	}
}

fasthttp.ListenAndServe(":80", m)

net/http -> fasthttp conversion table:

  • All the pseudocode below assumes w, r and ctx have these types:
  var (
  	w http.ResponseWriter
  	r *http.Request
  	ctx *fasthttp.RequestCtx
  )

VERY IMPORTANT! Fasthttp disallows holding references to RequestCtx or to its' members after returning from RequestHandler. Otherwise data races are inevitable. Carefully inspect all the net/http request handlers converted to fasthttp whether they retain references to RequestCtx or to its' members after returning. RequestCtx provides the following band aids for this case:

  • Wrap RequestHandler into TimeoutHandler.
  • Call TimeoutError before returning from RequestHandler if there are references to RequestCtx or to its' members. See the example for more details.

Use this brilliant tool - race detector - for detecting and eliminating data races in your program. If you detected data race related to fasthttp in your program, then there is high probability you forgot calling TimeoutError before returning from RequestHandler.

Blind switching from net/http to fasthttp won't give you performance boost. While fasthttp is optimized for speed, its' performance may be easily saturated by slow RequestHandler. So profile and optimize your code after switching to fasthttp. For instance, use quicktemplate instead of html/template.

See also fasthttputil, fasthttpadaptor and expvarhandler.

Performance optimization tips for multi-core systems

  • Use reuseport listener.
  • Run a separate server instance per CPU core with GOMAXPROCS=1.
  • Pin each server instance to a separate CPU core using taskset.
  • Ensure the interrupts of multiqueue network card are evenly distributed between CPU cores. See this article for details.
  • Use the latest version of Go as each version contains performance improvements.

Fasthttp best practices

  • Do not allocate objects and []byte buffers - just reuse them as much as possible. Fasthttp API design encourages this.
  • sync.Pool is your best friend.
  • Profile your program in production. go tool pprof --alloc_objects your-program mem.pprof usually gives better insights for optimization opportunities than go tool pprof your-program cpu.pprof.
  • Write tests and benchmarks for hot paths.
  • Avoid conversion between []byte and string, since this may result in memory allocation+copy. Fasthttp API provides functions for both []byte and string - use these functions instead of converting manually between []byte and string. There are some exceptions - see this wiki page for more details.
  • Verify your tests and production code under race detector on a regular basis.
  • Prefer quicktemplate instead of html/template in your webserver.

Tricks with []byte buffers

The following tricks are used by fasthttp. Use them in your code too.

  • Standard Go functions accept nil buffers
var (
	// both buffers are uninitialized
	dst []byte
	src []byte
)
dst = append(dst, src...)  // is legal if dst is nil and/or src is nil
copy(dst, src)  // is legal if dst is nil and/or src is nil
(string(src) == "")  // is true if src is nil
(len(src) == 0)  // is true if src is nil
src = src[:0]  // works like a charm with nil src

// this for loop doesn't panic if src is nil
for i, ch := range src {
	doSomething(i, ch)
}

So throw away nil checks for []byte buffers from you code. For example,

srcLen := 0
if src != nil {
	srcLen = len(src)
}

becomes

srcLen := len(src)

String may be appended to []byte buffer with append

dst = append(dst, "foobar"...)

[]byte buffer may be extended to its' capacity.

All fasthttp functions accept nil []byte buffer

statusCode, body, err := fasthttp.Get(nil, "http://google.com/")
uintBuf := fasthttp.AppendUint(nil, 1234)

Related projects

  • fasthttp - various useful helpers for projects based on fasthttp.
  • fasthttp-routing - fast and powerful routing package for fasthttp servers.
  • http2 - HTTP/2 implementation for fasthttp.
  • router - a high performance fasthttp request router that scales well.
  • fastws - Bloatless WebSocket package made for fasthttp to handle Read/Write operations concurrently.
  • gramework - a web framework made by one of fasthttp maintainers
  • lu - a high performance go middleware web framework which is based on fasthttp.
  • websocket - Gorilla-based websocket implementation for fasthttp.
  • websocket - Event-based high-performance WebSocket library for zero-allocation websocket servers and clients.
  • fasthttpsession - a fast and powerful session package for fasthttp servers.
  • atreugo - High performance and extensible micro web framework with zero memory allocations in hot paths.
  • kratgo - Simple, lightweight and ultra-fast HTTP Cache to speed up your websites.
  • kit-plugins - go-kit transport implementation for fasthttp.
  • Fiber - An Expressjs inspired web framework running on Fasthttp
  • Gearbox - :gear: gearbox is a web framework written in Go with a focus on high performance and memory optimization

FAQ

Why creating yet another http package instead of optimizing net/http?

Because net/http API limits many optimization opportunities. For example:

  • net/http Request object lifetime isn't limited by request handler execution time. So the server must create a new request object per each request instead of reusing existing objects like fasthttp does.
  • net/http headers are stored in a map[string][]string. So the server must parse all the headers, convert them from []byte to string and put them into the map before calling user-provided request handler. This all requires unnecessary memory allocations avoided by fasthttp.
  • net/http client API requires creating a new response object per each request.

Why fasthttp API is incompatible with net/http?

Because net/http API limits many optimization opportunities. See the answer above for more details. Also certain net/http API parts are suboptimal for use:

Why fasthttp doesn't support HTTP/2.0 and WebSockets?

HTTP/2.0 support is in progress. WebSockets has been done already. Third parties also may use RequestCtx.Hijack for implementing these goodies.

Are there known net/http advantages comparing to fasthttp?

Yes:

  • net/http supports HTTP/2.0 starting from go1.6.
  • net/http API is stable, while fasthttp API constantly evolves.
  • net/http handles more HTTP corner cases.
  • net/http should contain less bugs, since it is used and tested by much wider audience.
  • net/http works on Go older than 1.5.

Why fasthttp API prefers returning []byte instead of string?

Because []byte to string conversion isn't free - it requires memory allocation and copy. Feel free wrapping returned []byte result into string() if you prefer working with strings instead of byte slices. But be aware that this has non-zero overhead.

Which GO versions are supported by fasthttp?

Go1.5+. Older versions won't be supported, since their standard package miss useful functions.

NOTE: Go 1.9.7 is the oldest tested version. We recommend you to update as soon as you can. As of 1.11.3 we will drop 1.9.x support.

Please provide real benchmark data and server information

See this issue.

Are there plans to add request routing to fasthttp?

There are no plans to add request routing into fasthttp. Use third-party routers and web frameworks with fasthttp support:

I detected data race in fasthttp!

Cool! File a bug. But before doing this check the following in your code:

I didn't find an answer for my question here

Try exploring these questions.

Download Details:
Author: valyala
Download Link: Download The Source Code
Official Website: https://github.com/valyala/fasthttp 
License: MIT

#go #golang #programming #developer 

Go-vcr: Record and Replay Your HTTP interactions for Fast

go-vcr

go-vcr simplifies testing by recording your HTTP interactions and replaying them in future runs in order to provide fast, deterministic and accurate testing of your code.

go-vcr was inspired by the VCR library for Ruby.

Installation

Install go-vcr by executing the command below:

$ go get github.com/dnaeon/go-vcr/v2/recorder

Usage

Here is a simple example of recording and replaying etcd HTTP interactions.

You can find other examples in the example directory of this repository as well.

package main

import (
    "log"
    "time"

    "github.com/dnaeon/go-vcr/v2/recorder"

    "github.com/coreos/etcd/client"
    "golang.org/x/net/context"
)

func main() {
    // Start our recorder
    r, err := recorder.New("fixtures/etcd")
    if err != nil {
        log.Fatal(err)
    }
    defer r.Stop() // Make sure recorder is stopped once done with it

    // Create an etcd configuration using our transport
    cfg := client.Config{
        Endpoints:               []string{"http://127.0.0.1:2379"},
        HeaderTimeoutPerRequest: time.Second,
        Transport:               r, // Inject as transport!
    }

    // Create an etcd client using the above configuration
    c, err := client.New(cfg)
    if err != nil {
        log.Fatalf("Failed to create etcd client: %s", err)
    }

    // Get an example key from etcd
    etcdKey := "/foo"
    kapi := client.NewKeysAPI(c)
    resp, err := kapi.Get(context.Background(), etcdKey, nil)

    if err != nil {
        log.Fatalf("Failed to get etcd key %s: %s", etcdKey, err)
    }

    log.Printf("Successfully retrieved etcd key %s: %s", etcdKey, resp.Node.Value)
}

Custom Request Matching

During replay mode, You can customize the way incoming requests are matched against the recorded request/response pairs by defining a Matcher function. For example, the following matcher will match on method, URL and body:

r, err := recorder.New("fixtures/matchers")
if err != nil {
    log.Fatal(err)
}
defer r.Stop() // Make sure recorder is stopped once done with it

r.SetMatcher(func(r *http.Request, i cassette.Request) bool {
    if r.Body == nil {
        return cassette.DefaultMatcher(r, i)
    }
    var b bytes.Buffer
    if _, err := b.ReadFrom(r.Body); err != nil {
        return false
    }
    r.Body = ioutil.NopCloser(&b)
    return cassette.DefaultMatcher(r, i) && (b.String() == "" || b.String() == i.Body)
})

Protecting Sensitive Data

You often provide sensitive data, such as API credentials, when making requests against a service. By default, this data will be stored in the recorded data but you probably don't want this. Removing or replacing data before it is stored can be done by adding one or more Filters to your Recorder. Here is an example that removes the Authorization header from all requests:

r, err := recorder.New("fixtures/filters")
if err != nil {
    log.Fatal(err)
}
defer r.Stop() // Make sure recorder is stopped once done with it

// Add a filter which removes Authorization headers from all requests:
r.AddFilter(func(i *cassette.Interaction) error {
    delete(i.Request.Headers, "Authorization")
    return nil
})

Sensitive data in responses

Filters added using *Recorder.AddFilter are applied within VCR's custom http.Transport. This means that if you edit a response in such a filter then subsequent test code will see the edited response. This may not be desirable in all cases. For instance, if a response body contains an OAuth access token that is needed for subsequent requests, then redact the access token in SaveFilter will result in authorization failures.

Another way to edit recorded interactions is to use *Recorder.AddSaveFilter. Filters added with this method are applied just before interactions are saved when *Recorder.Stop is called.

r, err := recorder.New("fixtures/filters")
if err != nil {
    log.Fatal(err)
}
defer r.Stop() // Make sure recorder is stopped once done with it

// Your test code will continue to see the real access token and
// it is redacted before the recorded interactions are saved     
r.AddSaveFilter(func(i *cassette.Interaction) error {
    if strings.Contains(i.URL, "/oauth/token") {
        i.Response.Body = `{"access_token": "[REDACTED]"}`
    }

    return nil
})

Passing Through Requests

Sometimes you want to allow specific requests to pass through to the remote server without recording anything.

Globally, you can use ModeDisabled for this, but if you want to disable the recorder for individual requests, you can add Passthrough functions to the recorder. The function takes a pointer to the original request, and returns a boolean, indicating if the request should pass through to the remote server.

Here's an example to pass through requests to a specific endpoint:

// Pass through the request to the remote server if the path matches "/login".
r.AddPassthrough(func(req *http.Request) bool {
    return req.URL.Path == "/login"
})

Author: Dnaeon
Source Code: https://github.com/dnaeon/go-vcr 
License: View license

#go #golang #http 

Nigel  Uys

Nigel Uys

1651097100

Request: Go Request, Go Http Client

Request

HTTP Client for golang, Inspired by Javascript-axios Python-request. If you have experience about axios or requests, you will love it. No 3rd dependency.

Features

  • Make http requests from Golang
  • Transform request and response data

Installing

go mod:

go get github.com/monaco-io/request

Methods

  • OPTIONS
  • GET
  • HEAD
  • POST
  • PUT
  • DELETE
  • TRACE
  • CONNECT

Example

POST

package main

import (
    "github.com/monaco-io/request"
)

func main() {
    var body = struct {
         A string
         B int
        }{A: "A", B: 1}
    var result interface{}

    c := request.Client{
        URL:    "https://google.com",
        Method: "POST",
        Query: map[string]string{"hello": "world"},
        JSON:   body,
    }
    resp := c.Send().Scan(&result)
    if !resp.OK(){
        // handle error
        log.Println(resp.Error())
    }

    // str := resp.String()
    // bytes := resp.Bytes()

POST with local files

package main

import (
    "github.com/monaco-io/request"
)

func main() {
    c := request.Client{
        URL:    "https://google.com",
        Method: "POST",
        Query: map[string]string{"hello": "world"},
        MultipartForm: MultipartForm{
            Fields: map[string]string{"a": "1"},
            Files:  []string{"doc.txt"},
        },
    }
    resp := c.Send().Scan(&result)
    ...

POST step by step

package main

import (
    "github.com/monaco-io/request"
)

func main() {
    var response interface{}

    resp := request.
        New().
        POST("http://httpbin.org/post").
        AddHeader(map[string]string{"Google": "google"}).
        AddBasicAuth("google", "google").
        AddURLEncodedForm(map[string]string{"data": "google"}).
        Send().
        Scan(&response)
    ...

POST with context (1/2)

package main

import (
    "github.com/monaco-io/request"
    "context"
)

func main() {
    c := request.Client{
        Context: context.Background(),
        URL:       "https://google.com",
        Method:    "POST",
        BasicAuth: request.BasicAuth{
            Username: "google",
            Password: "google",
        },
    }
    resp := c.Send()
    ...

POST with context (2/2)

package main

import (
    "github.com/monaco-io/request"
    "context"
)

func main() {
    var response interface{}

    resp := request.
        NewWithContext(context.TODO()).
        POST("http://httpbin.org/post").
        AddHeader(map[string]string{"Google": "google"}).
        AddBasicAuth("google", "google").
        AddURLEncodedForm(map[string]string{"data": "google"}).
        Send().
        Scan(&response)
    ...

Authorization

package main

import (
    "github.com/monaco-io/request"
)

func main() {
    c := request.Client{
        URL:       "https://google.com",
        Method:    "POST",
        BasicAuth: request.BasicAuth{
            Username: "google",
            Password: "google",
        },
    }
    resp := c.Send()
}

Timeout

package main

import (
    "github.com/monaco-io/request"
)

func main() {
    c := request.Client{
        URL:       "https://google.com",
        Method:    "POST",
        Timeout:   time.Second*10,
    }
}

Cookies

package main

import (
    "github.com/monaco-io/request"
)

func main() {
    c := request.Client{
        URL:       "https://google.com",
        CookiesMap: map[string]string{
            "cookie_name": "cookie_value",
        }
    }
}

TLS

package main

import (

    "github.com/monaco-io/request"
)

func main() {
    c := request.Client{
        URL:       "https://google.com",
        TLSConfig: &tls.Config{InsecureSkipVerify: true},
    }
}

Author: Monaco-io
Source Code: https://github.com/monaco-io/request 
License: MIT License

#go #golang #http #client 

Nigel  Uys

Nigel Uys

1651048380

Go-retryablehttp: Retryable HTTP Client in Go

go-retryablehttp 

The retryablehttp package provides a familiar HTTP client interface with automatic retries and exponential backoff. It is a thin wrapper over the standard net/http client library and exposes nearly the same public API. This makes retryablehttp very easy to drop into existing programs.

retryablehttp performs automatic retries under certain conditions. Mainly, if an error is returned by the client (connection errors, etc.), or if a 500-range response code is received (except 501), then a retry is invoked after a wait period. Otherwise, the response is returned and left to the caller to interpret.

The main difference from net/http is that requests which take a request body (POST/PUT et. al) can have the body provided in a number of ways (some more or less efficient) that allow "rewinding" the request body if the initial request fails so that the full request can be attempted again. See the godoc for more details.

Version 0.6.0 and before are compatible with Go prior to 1.12. From 0.6.1 onward, Go 1.12+ is required. From 0.6.7 onward, Go 1.13+ is required.

Example Use

Using this library should look almost identical to what you would do with net/http. The most simple example of a GET request is shown below:

resp, err := retryablehttp.Get("/foo")
if err != nil {
    panic(err)
}

The returned response object is an *http.Response, the same thing you would usually get from net/http. Had the request failed one or more times, the above call would block and retry with exponential backoff.

Retrying cases that fail after a seeming success

It's possible for a request to succeed in the sense that the expected response headers are received, but then to encounter network-level errors while reading the response body. In go-retryablehttp's most basic usage, this error would not be retryable, due to the out-of-band handling of the response body. In some cases it may be desirable to handle the response body as part of the retryable operation.

A toy example (which will retry the full request and succeed on the second attempt) is shown below:

c := retryablehttp.NewClient()
r := retryablehttp.NewRequest("GET", "://foo", nil)
handlerShouldRetry := true
r.SetResponseHandler(func(*http.Response) error {
    if !handlerShouldRetry {
        return nil
    }
    handlerShouldRetry = false
    return errors.New("retryable error")
})

Getting a stdlib *http.Client with retries

It's possible to convert a *retryablehttp.Client directly to a *http.Client. This makes use of retryablehttp broadly applicable with minimal effort. Simply configure a *retryablehttp.Client as you wish, and then call StandardClient():

retryClient := retryablehttp.NewClient()
retryClient.RetryMax = 10

standardClient := retryClient.StandardClient() // *http.Client

For more usage and examples see the godoc.

Author: Hashicorp
Source Code: https://github.com/hashicorp/go-retryablehttp 
License: MPL-2.0 License

#go #golang #http