Issue #15778 has been updated by duerst (Martin D=FCrst).


During today's meeting, it was mentioned that production deployments may no=
t want to include this functionality.

To do this, one solution would be to make this functionality available as a=
 bundled gem.

----------------------------------------
Feature #15778: Expose an API to pry-open the stack frames in Ruby
https://bugs.ruby-lang.org/issues/15778#change-81245

* Author: gsamokovarov (Genadi Samokovarov)
* Status: Open
* Priority: Normal
* Assignee: ko1 (Koichi Sasada)
* Target version: =

----------------------------------------
Hello,

I'm the maintainer of the web-console (https://github.com/rails/web-console=
/) gem, where one of our features is to jump between the frames in which an=
 error occurred. To accomplish this, I currently use the Debug Inspector CR=
uby API. I think we should expose this functionality in Rubyland, so tools =
like web-console don't need to resort to C code for this. This also makes i=
t quite harder for me to support different implementations like JRuby or Tr=
uffleRuby as everyone is having a different way to create Ruby Binding obje=
cts that represent the frames.

Here the API ideas:

Add `Thread::Backtrace::Location#binding` method that can create a binding =
for a specific caller of the current frame. We can reuse the existing `Kern=
el.caller_locations` method to generate the array of `Thread::Backtrace::Lo=
cation` objects. We can optionally have the `Kernel.caller_locations(debug:=
 true)` argument if we cannot generate the bindings lazily on the VM that c=
an instruct the VM to do the slower operation.

- `Thread::Backtrace::Location#binding` returns `Binding|nil`. Nil result m=
ay mean that the current location is a C frame or a JITted/optimized frame =
and we cannot debug it.

We can also expose the DebugInspector API directly, as done in the https://=
github.com/banister/debug_inspector gem, but for tools like web-console, we=
'd need to map the bindings with the backtrace, as we cannot generate Bindi=
ngs for every frame (C frames) and this needs to be done in application cod=
e, so I think the `Thread::Backtrace::Location#binding` is the better API f=
or Ruby-land.

Such API can help us eventually write most of our debuggers in Ruby as righ=
t now we don't have a way to do Post-Mortem debugging without native code o=
r even start our debuggers without monkey-patching `Binding`.

I have presented this idea in a RubyKaigi's 2019 talk called "Writing Debug=
gers in Plain Ruby", you can check-out the slides for more context: http://=
kaigi-debuggers-in-ruby.herokuapp.com.



-- =

https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=3Dunsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>