Can't use a custom transport

[stuart-mclaren-hpe]

Doing something like this:

	restyClient := resty.NewWithClient(
		&http.Client{
			Transport: otelhttp.NewTransport(http.DefaultTransport),
		},
	)

gives the following (with some extra debug):

ERROR RESTY current transport is not an *http.Transport instance XXX Type of Transport: *otelhttp.Transport

and the request fails.

Is there a trick to use a custom transport that I'm missing? Thanks.

[jeevatkm]

@stuart-mclaren-hpe You could initialize as follows.

client := resty.New().
		SetTransport(otelhttp.NewTransport(http.DefaultTransport))

fmt.Println(client)

[stuart-mclaren-hpe]

@jeevatkm

Thanks for your suggestion.

I think the issue is any of the methods that call c.Transport()

For example this:

package main

import (
        "github.com/go-resty/resty/v2"
        "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
        "net/http"
)

func main() {
        client := resty.New().
                SetTransport(otelhttp.NewTransport(http.DefaultTransport))
        client.SetProxy("http://foo")
}

will error with

2025/03/26 21:31:53.069131 ERROR RESTY current transport is not an *http.Transport instance XXX Type of Transport: *otelhttp.Transport

[jeevatkm]

This is not directly Resty-related issues. This is true for any non-standard transport because typically any custom transport does not support underlying transport configuration. So I have to do that check.

In this case, otelhttp.Transport does not support any functionality from http.Transport.
See here - https://github.com/open-telemetry/opentelemetry-go-contrib/blob/main/instrumentation/net/http/otelhttp/transport.go#L26-L38

If you want customize the transport, then you can do -

customTransport := &http.Transport { /* initialize your needs */ }

client := resty.New().
		SetTransport(otelhttp.NewTransport(customTransport))

fmt.Println(client)

[stuart-mclaren-hpe]

@jeevatkm

Thanks again for your response.
I got the same behaviour when I tried your new suggestion:

package main

import (
	"github.com/go-resty/resty/v2"
	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
	"net/http"
)

func main() {
	customTransport := &http.Transport{ /* initialize your needs */ }
	client := resty.New().
		SetTransport(otelhttp.NewTransport(customTransport))
	client.SetProxy("http://foo")
}

output:

2025/03/27 11:12:45.428143 ERROR RESTY current transport is not an *http.Transport instance XXX Type of Transport: *otelhttp.Transport

What's going on here is subtle. My understanding is as follows:

Go's http client defines a RoundTripper interface. This interface
has a single method (RoundTrip). (Generally, the fewer methods a Go interface
has the more powerful/flexible it is. Using an interface is more powerful
than using a specific type.)

At compile time, a resty user can pass anything that satisfies the
RoundTripper interface to SetTransport. However, at run time, a
type assertion performs a check -- not for http.RoundTripper -- but for
http.Transport. This leads to indeterminite behaviour (in my "real" use case
I am ultimately getting stack traces).

As far as I can tell (and please correct me if I'm wrong): if resty wants to
be able to work with third party libraries that use the standard http.RoundTripper interface
(which I think is fairly common, because that is how the interface is intended
to be used) I don't think it can continue to enforce the type check (and other assumptions)
about http.Transport. I suspect this may be what other client libraries do.

[jeevatkm]

@stuart-mclaren-hpe FYI, proxy, TLS config, etc., cannot be done via the HTTP.RoundTripper interface. It's not just Resty; you won't be able to use it with any HTTP library. That's why I suggested you explicitly initialize the proxy or any transport settings using the following approach. OR you could use the env variable HTTP_PROXY approach, too.

customTransport := &http.Transport{
     Proxy: http.ProxyURL("http://foo")
}

So, you won't be able to use client.SetProxy, client. SetTLSClientConfig, etc.

[stuart-mclaren-hpe]

Thanks again @jeevatkm

Setting the proxy in the Transport before creating the client and avoiding SetProxy works.

As mentioned, currently SetTransport takes a RoundTripper

func (c *Client) SetTransport(transport http.RoundTripper) *Client {

but getting the Transport assumes http.Transport

func (c *Client) Transport() (*http.Transport, error) {

I think this mismatch is what's causing (in my case) the original, unexpected behaviour.

I wonder if there may be a case for making some of these settings immutable, so they
can be set at creation time, but not afterwards.

resty.NewWithProxy(proxy)
resty.NewWithTransport(transport)
resty.NewWithClient(client)

it may be the case that modifying, eg, Transport after client creation is not always encouraged.
(Probably would need a new major version for any changes like this.)

Thanks again.