Debugging handlers

[sevberg]

I've created a basic web app using actix-web, and also created a test for it following the official documentation. The app is working well, and so is the test. I can even step through the test function with a debugger.

However, to simulate the experience of having to unravel some error in my handler, I tried debugging INTO my handler function and I realized that my debugger would always step over the line let resp = test::call_service(&app, req).await;. Technically, it does step into something, but after a few hops it comes out again and never stops at the breakpoint I have set in the handler which I'm invoking.

So I'd like to understand if this behavior is expected? Or would you expect that one would be able to debug into a handler function itself? If this is expected, is there some special configuration I can use to allow debugging in to the handler?

For the moment, I'm only looking to answer this question in the general sense, which is why I haven't shown any code yet (I can try to come up with some minimally-reproducing code later, if needed). But for now, maybe it's enough to know that I'm using VSCode with the CodeLLDB extension.

[robjtede]

As you've pointed out, the handler itself is not being called or you would have seen the break. Middleware errors would cause a panic under call_service so it can not be that. So, assuming the request path and method is correct, one explanation could be that an extractor is failing; since the handler is called with them, they naturally all need to be processed first.

[sevberg]

Hi @robjtede, thanks for the fast response. Apologies for not explaining myself clearly enough, but I had already ensured that the handler function was indeed running by placing a println! statement inside of it, and of course by also returning a response which is unique to this endpoint. Instead of saying "the test is working well", I should have said that the expected response was received (as well as the printed output), so I am confident that the handler was running.

Nevertheless, I took from your response that you would certainly expect my debugger to catch the break point in my handler function without needing to do any special configurations. So thanks for confirming that!

Based on that, I began playing around a little bit more and found some interesting behavior. In short, the debugger will reliably catch the breakpoint in the handler function when there is a tokio::time::sleep(...).await call. Perhaps any awaiting anything would have been fine? Anyway, the duration doesn't seem to matter (even when setting the sleep time to 1 microsecond), however commenting-out this line recovers the behavior where the debugger will pass over the call_service line, so it seems to be consistent.

I'm not sure if this information will be helpful for you, or for someone in the future. But nevertheless, unless you have some further thoughts, this can be considered "solved"