[ruby-core:106622] [Ruby master Feature#16663] Add block or filtered forms of Kernel#caller to allow early bail-out

Issue #16663 has been updated by jeremyevans0 (Jeremy Evans).


headius (Charles Nutter) wrote in #note-13:
> I would like to see this feature happen in some way, but most of the use cases I considered will want to process and keep the top X frames, where X is variable at runtime depending on what was called (example: tests and specs that trim our their own internals and shorten the call stack; they do not know how many frames to skip so they request all of them just to ultimately keep N < all).

This makes it sound like you favor `each_caller` (iteration) over `find_caller` (search).  Can you please confirm which you prefer?  I think the expectation is that `find_caller` would return first string/location where block returns truthy, and `each_caller` would return nil.
 
> As it stands today, the only way to trim stack frames down to some search-based depth is to get them all and crop it after the fact.

Yes.  That's why I think this feature would be useful.  We just need to agree on the method name, location, and semantics.  

> This isn't quite correct. We can return a stack trace generator that acts like an Enumerable.

I'm not sure this is true in CRuby, since we need to walk the VM frame stack at the point of call.  I don't think CRuby can support something like the following, unless we make fairly drastic changes:

```ruby
def foo
  each_caller # returns Enumerator
end

def bar
  foo
end

bar.each{|frame|} # iterates
```

This is because when `each` is called, we've already lost the first few frames of the stack (the calls to `caller`, `foo`, and `bar`).

@headius in order to move forward on this, we need to answer Matz's two questions:

matz (Yukihiro Matsumoto) wrote in #note-10:
> * iteration or search
> * place and name of the method

It sounds like you want iteration, and you are recommending with `Thread.each_backtrace` yielding `Thread::Backtrace::Location` objects.  Is that correct? While your Enumerable example would not work in CRuby, you may be able to do:

```ruby
array = []
Thread.each_backtrace do |frame|
  if test_library_frame?(frame)
    break array unless array.empty?
  else
    array << frame
  end
end
```

----------------------------------------
Feature #16663: Add block or filtered forms of Kernel#caller to allow early bail-out
https://bugs.ruby-lang.org/issues/16663#change-95290

* Author: headius (Charles Nutter)
* Status: Open
* Priority: Normal
----------------------------------------
There are many libraries that use `caller` or `caller_locations` to gather stack information for logging or instrumentation. These methods generate an array of informational stack frames based on the current call stack.

Both methods accept parameters for `level` (skip some number of Ruby frames) and `length` (only return this many frames). However many use cases are unable to provide one or both of these.

Instrumentation uses, for example, may need to skip an unknown number of frames at the top of the trace, such as to dig out of rspec plumbing or active_record internals and report the first line of user code. In such cases, the typical pattern is to simply request *all* frames and then filter out the one that is desired.

This leads to a great deal of wasted work gathering those frames and constructing objects to carry them to the user. On optimizing runtimes like JRuby and TruffleRuby, it can have a tremendous impact on performance, since each frame has a much higher cost than on CRuby.

I propose that we need a new form of `caller` that takes a block for processing each element.

```ruby
def find_matching_frame(regex)
  caller do |frame|
    return frame if frame.file =~ regex
  end
end
```

An alternative API would be to allow passing a query object as a keyword argument, avoiding the block dispatch by performing the match internally:

```ruby
def find_matching_frame(regex)
  caller(file: regex)
end
```

This API would provide a middle ground between explicitly specifying a maximum number of stack frames and asking for all frames. Most common, hot-path uses of `caller` could be replaced by these forms, reducing overhead on all Ruby implementations and drastically reducing it where stack traces are expensive.



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

Unsubscribe: <mailto:[e-mail]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>