Logging All HTTP Request and Response from done through an HTTP Client

I have the following simple http.Client:

import (
 "net/http"
 "log"
)
...
func main() {
   ...
   link = "http://example.com"
   method = "GET"
   req, _ := http.NewRequest(method, link, nil)

   client := &http.Client{}

   myZapLogger.Info("Sending a %s request to %s\n", method, link)

   resp, err := client.Do(req)
   if err != nil {
      myZapLogger.Error(..., err) // I'm logging rather than fatal-ing or so
   } else { 
      myZapLogger.Info("Received a %d on request X", resp.StatusCode)
   }
   ...
}

...

I was looking for a way to do the above for each request through a hook (or so), so that it's triggered automatically each time. I can write a function the encloses all that, but in a case where I'm passing an http client to some other package, I wouldn't be able to control/log such requests that way (e.g. aws-go-sdk).

Is there a way to do this through contexts or attaching hooks to the client?

Thanks

eudore's comment answers the question; I'll just put it into code:

type MyRoundTripper struct {}

func (t MyRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
	
	// Do work before the request is sent

	resp, err := http.DefaultTransport.RoundTrip(req)
	if err != nil {
		return resp, err
	}
	
	// Do work after the response is received

	return resp, err
}

To use it, you'll just pass it to your HTTP Client:

rt := MyRoundTripper{}
client := http.Client{Transport: rt}

I've remixed a few different places and came up with this code:

package matrix
import (
"bytes"
"mylogger/colorlogger"
"io"
"net/http"
)
func filterAuthorization(headers http.Header) http.Header {
filteredHeaders := make(http.Header)
for k, v := range headers {
if k == "Authorization" {
filteredHeaders[k] = []string{"<removed>"}
} else {
filteredHeaders[k] = v
}
}
return filteredHeaders
}
// https://stackoverflow.com/questions/23070876/reading-body-of-http-request-without-modifying-request-state
// https://stackoverflow.com/questions/69276445/logging-all-http-request-and-response-from-done-through-an-http-client
type MyRoundTripper struct{}
func (t MyRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
var reqStr string
var respStr string
if req.Body != nil {
reqbuf, e := io.ReadAll(req.Body)
if e != nil {
colorlogger.Log.Fatal("Reading http response from RoundTrip injector error: ", e)
} else {
reqrdr1 := io.NopCloser(bytes.NewBuffer(reqbuf))
reqrdr2 := io.NopCloser(bytes.NewBuffer(reqbuf))
req.Body = reqrdr2
// read resp.Body to string
breq, errreq := io.ReadAll(reqrdr1)
if errreq != nil {
colorlogger.Log.Error("Reading http request from RoundTrip injector error: ", errreq)
} else {
reqStr = string(breq)
}
}
}
// Do work before the request is sent
resp, err := http.DefaultTransport.RoundTrip(req)
if err != nil {
return resp, err
}
if resp.Body != nil {
respbuf, e := io.ReadAll(resp.Body)
if e != nil {
colorlogger.Log.Fatal("Reading http response from RoundTrip injector error: ", e)
} else {
resprdr2 := io.NopCloser(bytes.NewBuffer(respbuf))
resp.Body = resprdr2
resprdr1 := io.NopCloser(bytes.NewBuffer(respbuf))
// read resp.Body to string
b, errresp := io.ReadAll(resprdr1)
if errresp != nil {
colorlogger.Log.Error("Reading http response from RoundTrip injector error: ", errresp)
} else {
respStr = string(b)
}
}
}
// Do work after the response is received
colorlogger.Log.Debugf("%sREQUEST(%s) %s, Headers: %+v, Body: %s, RESPONSE(%d), Headers: %+v, Body: %s%s",
colorlogger.Blue,
req.Method,
req.URL.Path,
filterAuthorization(req.Header),
reqStr,
resp.StatusCode,
resp.Header,
respStr,
colorlogger.CLR)
return resp, err
}

And as show below, this is integrated like this:

> To use it, you'll just pass it to your HTTP Client:
>
> rt := MyRoundTripper{} client := http.Client{Transport: rt}

Note: I might change error handling a bit because of the fatal.

Note: I also liked https://medium.com/@motemen/add-a-single-line-to-your-go-source-and-track-every-http-requests-responses-37f2f15eb72f but I'd like to be able to change from debug to none-debug during runtime later.