How do you debug your API calls as you develop your client?

[malikoth]

I'm currently using code like this:

import asyncio
import contextlib
import logging
from http.client import HTTPConnection

from client import client


def debug_requests_on():
    """Switches on logging of the requests module."""
    HTTPConnection.debuglevel = 1

    logging.basicConfig()
    logging.getLogger().setLevel(logging.DEBUG)
    requests_log = logging.getLogger('requests.packages.urllib3')
    requests_log.setLevel(logging.DEBUG)
    requests_log.propagate = True


def debug_requests_off():
    """Switches off logging of the requests module, might be some side-effects"""
    HTTPConnection.debuglevel = 0

    root_logger = logging.getLogger()
    root_logger.setLevel(logging.WARNING)
    root_logger.handlers = []
    requests_log = logging.getLogger('requests.packages.urllib3')
    requests_log.setLevel(logging.WARNING)
    requests_log.propagate = False


@contextlib.contextmanager
def debug_requests():
    """Use with 'with'!"""
    debug_requests_on()
    yield
    debug_requests_off()


async def amain() -> None:
    result = await client.call_some_endpoint()
    print(result)

def main() -> None:
    result = client.call_some_endpoint()
    print(result)


if __name__ == '__main__':
    with debug_requests():
    # asyncio.run(amain())
        main()

Unfortunately, I don't actually want to use requests for this, I want to use httpx via the uplink-httpx library. So I started by trying to get it working the way I wanted it, and then I started having to comment out the HttpxClient() in the the uplink client instantiation, and delete all the async and await keywords everywhere, and scaffold the client use with a synchronous main method, etc. It's a big pain in the butt.

At this point, I'm just going to use requests during development now, and then switch to httpx when I'm ready to stop developing and start using.

I'd just like to be able to print or otherwise see what URL is being generated for each request. Is there a better way to do this?

[torchss]

I just started to use uplink myself and chanced upon your question when looking at discussions. It would be helpful to have a minimally reproduce sample. Until then, you could try writing a ResponseTracer as a hook:

        client = Client(
            token=TOKEN,
            hooks=ResponseTracer()
        )

[selimt]

We do something like this:

class RequestLogger(RequestTemplate):
    """Template class for logging API requests."""

    def before_request(self, request):
        # type: (requests.Request) -> None
        LOGGER.debug("%s %s" % (request[0], request[1]))
        for k, v in viewitems(request[2]):
            if k == "headers":
                continue
            LOGGER.debug("%s: %s" % (k, v))
            
class request_handler(decorators.MethodAnnotation):  # noqa: N801
    """Request handler for tracing API calls to the server.

    It is based on the uplink.retry.retry decorator.
    It registers the RequestLogger template to log request
    url, json and params.
    """

    def modify_request(self, request_builder):
        # type: (RequestBuilder) -> None
        """Add the request template to the request builder.

        Args:
            request_builder (:obj:`uplink.helpers.RequestBuilder`): Request builder.

        """
        request_builder.add_request_template(self._create_template(request_builder))

    def _create_template(self, request_builder):
        # type: (RequestBuilder) -> RequestLogger
        """Instantiate and return the request template.

        Args:
            request_builder (:obj:`uplink.helpers.RequestBuilder`): Request builder.

        Returns:
            RequestLogger: Request template instance which handles logging before the request.

        """
        return RequestLogger()

Then for the consumer class we use the above as a decorator:

        @request_handler()
        class GitHub(Consumer):
            ....

[torchss]

@selimt I had an orthogonal question for you. If I should create a new issue instead, let me know!

This works fine:

@uplink.returns.json
@uplink.get("zones")
def get_zones(self) -> List[Zone]:
    pass

but this:

@uplink.returns.json
@uplink.get
def get_json():
    pass

@get_json("zones")
def get_zones(self) -> List[Zone]:
    pass

throws:

An error occurred: 1 validation error for Zone
  Input should be a valid dictionary or instance of Zone [type=model_type, input_value=[{'name': 'foo.v6....-08-02T03:47:52+02:00'}], input_type=list]

[selimt]

@torchss I don't think you can chain consumer methods as decorators like that. Where did you find that use case ?

[torchss]

@selimt I really appreciate your quick response. Did I mis-interpret https://uplink.prkumar.dev/user/tips/#extend-consumer-methods-to-reduce-boilerplate ?

[selimt]

Interesting. I never used it that way. One thing the example has that yours doesn't is the @uplink.json decorator. Apart from that I am not sure why you are getting that error.

[malikoth]

So as I've been working with Uplink more, this is the code I ultimately found to be the simplest way to log requests and responses going through Uplink. This could obviously be extended to give more info about the request, but for now, the URL is sufficient.

from pprint import pprint

import uplink
from requests import Response


@uplink.response_handler
def response_logger(response: Response) -> Response:
    """Inspect the raw request and response objets for a transaction

    To use this, add @response_logger as a decorator to an Uplink
    interface method.
    """
    print('Raw Request URL:', response.request.url)
    print('Raw Response Status Code:', response.status_code)
    print('Raw Response Headers:')
    pprint(dict(response.headers))
    print('Raw Response Text (decoded):')
    pprint(response.json())
    return response