[ruby-core:94194] [Ruby master Feature#15912] Allow some reentrancy during TracePoint events

[ko1@atdot.net]

Issue #15912 has been updated by ko1 (Koichi Sasada).


In this case, your solution (allow fire different type of trace) because the problematic case `:line` event and `:class` event are different.
However, maybe it is accidentally. Someone can use `:line` event as usual.

`reopen` will allow re-occurrence explicitly by TracePoint users (like byebug), I think.
What do you think about it?

To introduce `#reopen`, we need to consider about:
* name (`reopen`? `allow`? `unmask` like signal mask idiom?).
* do we need to pass allowing events? (e.g.: all events except `:line` event are allowed)


----------------------------------------
Feature #15912: Allow some reentrancy during TracePoint events
https://bugs.ruby-lang.org/issues/15912#change-80488

* Author: deivid (David Rodríguez)
* Status: Assigned
* Priority: Normal
* Assignee: ko1 (Koichi Sasada)
* Target version: 
----------------------------------------
I got a report in byebug about byebug being incompatible with zeitwerk. This one: https://github.com/deivid-rodriguez/byebug/issues/564. This is a problem because zeitwerk is the default Rails code loader, and byebug is the default Rails debugger.

Both of these tools rely on the TracePoint API:

* Byebug uses a bunch of TracePoint events to stop execution at certain points in your program.
* Zeitwek uses `:class` events to be able to resolve some circular edge cases.

I investigated the problem and I think the issue is that while stopped at the byebug prompt, we're actually in the middle of processing a TracePoint event. That means that further TracePoint events triggered at the byebug's prompt will be ignored, because otherwise we could get into an infinite loop where the handling of events would trigger more events that trigger themselves the execution of handlers again.

I understand why the TracePoint API does this, but if we could allow some level of reentrancy here, we could probably make these tools play nice together. I figure if we kept a stack of TracePoint event handlers being run, and check that the current event type is not already in the stack, we would allow :class events to be triggered from :line events, and I think that would allow Zeitwerk to work within byebug.

What do you think about this, @ko1?



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

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