The main issue with debuggers versus logging is debuggers usually help you understand a point in time & space. The debugger just isn't a particularly great tool for understanding what's happened even if you do have a stack traces, and in a modern async world stack traces are often quite broken.
What I do love is tracing, which is an incredible view over time of all the various little subprocesses going on. Attaching some trace attributes to tell me key pieces of data or collection sizes leaves useful clues that future views can see.
It's crazy what my company pays for logs. Our effective price per gigabyte is colossal. And most of our services run pretty quiet, but still it's a huge cost. Meanwhile we must be generating vastly more trace data, orders of magnitudes more, trying us every handler and detail of what's happening, everywhere, and theres no pressure to reduce our tracing.
Tracing gives an enormously beautiful view over time of what's happening. At the same time, logging can still be better because trace views don't make at a glance reading of trace attributes possible. It's still. Better to log because you can select & pick the data you want and view all of it on screen in sequence over time, as it happens. Where-as with tracing you have a very compelling & powerful structured view of execution, but you have to keep clicking in to each span to dig out the specifics. Otherwise I feel like tracing would be a total lock.
I have yet to see another developer who has done local development with the assistance of tracing. I love it, and swear by it, and it's largely outmoded logging for understanding my systems. I usually have such a good view of my systems that I don't need a debugger!
In general it feels like a lot of these tools haven't moved much. Another commenter talked about logging over debugging, because it's persistent & can be returned to, where-as debugging is an ephemeral activity & we don't have tools to save/restore debugging analysis; we re-debug aknew each time we run into an issue. Logging lets us build up a consistent base (albeit at the risk of allowing ephemeral logging to cruft up our environment over time). Tracing seems like a much more powerful paradigm than logging, with much more for free & done consistently, but we still have a fairly unrefined ephemeral system for doing trace-based debugging.
Getting beyond debugging as an ephemeral technique seems like a big leap we need, if folks are really going to find lasting value in their tools.
The main issue with debuggers versus logging is debuggers usually help you understand a point in time & space. The debugger just isn't a particularly great tool for understanding what's happened even if you do have a stack traces, and in a modern async world stack traces are often quite broken.
What I do love is tracing, which is an incredible view over time of all the various little subprocesses going on. Attaching some trace attributes to tell me key pieces of data or collection sizes leaves useful clues that future views can see.
It's crazy what my company pays for logs. Our effective price per gigabyte is colossal. And most of our services run pretty quiet, but still it's a huge cost. Meanwhile we must be generating vastly more trace data, orders of magnitudes more, trying us every handler and detail of what's happening, everywhere, and theres no pressure to reduce our tracing.
Tracing gives an enormously beautiful view over time of what's happening. At the same time, logging can still be better because trace views don't make at a glance reading of trace attributes possible. It's still. Better to log because you can select & pick the data you want and view all of it on screen in sequence over time, as it happens. Where-as with tracing you have a very compelling & powerful structured view of execution, but you have to keep clicking in to each span to dig out the specifics. Otherwise I feel like tracing would be a total lock.
I have yet to see another developer who has done local development with the assistance of tracing. I love it, and swear by it, and it's largely outmoded logging for understanding my systems. I usually have such a good view of my systems that I don't need a debugger!
In general it feels like a lot of these tools haven't moved much. Another commenter talked about logging over debugging, because it's persistent & can be returned to, where-as debugging is an ephemeral activity & we don't have tools to save/restore debugging analysis; we re-debug aknew each time we run into an issue. Logging lets us build up a consistent base (albeit at the risk of allowing ephemeral logging to cruft up our environment over time). Tracing seems like a much more powerful paradigm than logging, with much more for free & done consistently, but we still have a fairly unrefined ephemeral system for doing trace-based debugging.
Getting beyond debugging as an ephemeral technique seems like a big leap we need, if folks are really going to find lasting value in their tools.