tripperware

package main

import (
	"fmt"
	"log"
	"net"
	"net/http"

	"github.com/gol4ng/httpware/v4/correlation_id"
	"github.com/gol4ng/httpware/v4/tripperware"
)

func main() {
	// Example Need a random ephemeral port (to have a free port)
	ln, err := net.Listen("tcp", ":0")
	if err != nil {
		log.Fatal(err)
	}

	// create http client using the tripperwareStack as RoundTripper
	client := http.Client{
		Transport: tripperware.CorrelationId(
			correlation_id.WithHeaderName("my-personal-header-name"),
			correlation_id.WithIdGenerator(func(request *http.Request) string {
				return "my-fixed-request-id"
			}),
		),
	}

	// create a server in order to show it work
	srv := &http.Server{
		Handler: http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
			fmt.Println("server receive request with request id:", request.Header.Get("my-personal-header-name"))
		}),
	}
	go func() {
		if err := srv.Serve(ln); err != nil {
			panic(err)
		}
	}()

	_, _ = client.Get("http://" + ln.Addr().String())

}

Output:

server receive request with request id: my-fixed-request-id

// Example Need a random ephemeral port (to have a free port)
ln, err := net.Listen("tcp", ":0")
if err != nil {
	log.Fatal(err)
}

enableDummyTripperware := true //false
dummyTripperware := func(next http.RoundTripper) http.RoundTripper {
	return httpware.RoundTripFunc(func(request *http.Request) (*http.Response, error) {
		request.Header.Set("FakeHeader", "this header is set when not /home url")
		return next.RoundTrip(request)
	})
}

// create http client using the tripperwareStack as RoundTripper
client := http.Client{
	Transport: tripperware.Enable(enableDummyTripperware, dummyTripperware),
}

// create a server in order to show it work
srv := &http.Server{
	Handler: http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
		fmt.Println("server receive request with request:", request.Header.Get("FakeHeader"))
	}),
}
go func() {
	if err := srv.Serve(ln); err != nil {
		panic(err)
	}
}()

_, _ = client.Get("http://" + ln.Addr().String())

Output:

server receive request with request: this header is set when not /home url

// we recommend to use TripperwareStack to simplify managing all wanted tripperware
// caution tripperware order matter
stack := httpware.TripperwareStack(
	tripperware.Interceptor(
		tripperware.WithBefore(func(request *http.Request) {
			reqData, err := ioutil.ReadAll(request.Body)
			fmt.Println("before callback", string(reqData), err)
		}),
		tripperware.WithAfter(func(response *http.Response, request *http.Request) {
			reqData, err := ioutil.ReadAll(request.Body)
			fmt.Println("after callback", string(reqData), err)
		}),
	),
)

// create http client using the tripperwareStack as RoundTripper
client := http.Client{
	Transport: stack,
}

_, _ = client.Post("fake-address.foo", "plain/text", bytes.NewBufferString("my_fake_body"))

Output:

before callback my_fake_body <nil>
after callback my_fake_body <nil>

recorder := prometheus.NewRecorder(prometheus.Config{}).RegisterOn(nil)

// we recommend to use MiddlewareStack to simplify managing all wanted middleware
// caution middleware order matter
stack := httpware.TripperwareStack(
	tripperware.Metrics(recorder, metrics.WithIdentifierProvider(func(req *http.Request) string {
		return req.URL.Host + " -> " + req.URL.Path
	})),
)

// create http client using the tripperwareStack as RoundTripper
client := http.Client{
	Transport: stack,
}

_, _ = client.Get("fake-address.foo")

package main

import (
	"errors"
	"fmt"
	"net"
	"net/http"
	"time"

	"github.com/gol4ng/httpware/v4/rate_limit"
	"github.com/gol4ng/httpware/v4/tripperware"
)

func main() {
	// Example Need a random ephemeral port (to have a free port)
	ln, err := net.Listen("tcp", ":0")
	if err != nil {
		panic(err)
	}

	rl := rate_limit.NewTokenBucket(1*time.Second, 1)
	defer rl.Stop()

	client := http.Client{Transport: tripperware.RateLimit(rl)}

	srv := &http.Server{
		Handler: http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
			fmt.Println("server receive request")
		}),
	}
	go func() {
		if err := srv.Serve(ln); err != nil {
			panic(err)
		}
	}()

	_, err = client.Get("http://" + ln.Addr().String())
	fmt.Println(err)

	_, err = client.Get("http://" + ln.Addr().String())
	fmt.Println(errors.Unwrap(err))

	time.Sleep(2 * time.Second)
	_, err = client.Get("http://" + ln.Addr().String())
	fmt.Println(err)
}

Output:

server receive request
<nil>
request limit reached
server receive request
<nil>

// Example Need a random ephemeral port (to have a free port)
ln, err := net.Listen("tcp", ":0")
if err != nil {
	panic(err)
}

dummyTripperware := func(next http.RoundTripper) http.RoundTripper {
	return httpware.RoundTripFunc(func(request *http.Request) (*http.Response, error) {
		request.Header.Set("FakeHeader", "this header is set when not /home url")
		return next.RoundTrip(request)
	})
}

// create http client using the tripperwareStack as RoundTripper
client := http.Client{
	Transport: tripperware.Skip(func(request *http.Request) bool {
		return request.URL.Path == "/home"
	}, dummyTripperware),
}

srv := &http.Server{
	Handler: http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
		fmt.Println("server receive request with request:", request.Header.Get("FakeHeader"))
	}),
}
go func() {
	if err := srv.Serve(ln); err != nil {
		panic(err)
	}
}()

_, _ = client.Get("http://" + ln.Addr().String())
_, _ = client.Get("http://" + ln.Addr().String() + "/home")

Output:

server receive request with request: this header is set when not /home url
server receive request with request: