Issue #19197 has been updated by AMomchilov (Alexander Momchilov).
mame (Yusuke Endoh) wrote in #note-8:
Discussed at the dev meeting.
Please elaborate the use case a bit more.
I was experimenting around in an IRB session with some code that raised an exception
wrapped by another exception. Actually getting to the root cause is pretty cumbersome. In
a REPL environment, the best you can do is `Enumerator.produce(e) { |e| e.cause or raise
StopIteration }.to_a.last`, which is still a handfull.
Do you have in mind an application monitor service
like DataDog or Sentry? If so, what you need is not a Ruby method, but a request to ask
the service.
In our case it was Bugsnag. They do already have an API to let you decide how to group
things by any arbitrary value. We wanted to group some things by root causes, and to do
that we needed to iterate these error linked lists ourselves to get those ourselves.
The proposed method is easy to implement in Ruby.
Yep, and I did I write the Ruby code to get the root cause, and that's fine, but it
just felt like a pretty basic (albeit niche) thing that should be built in.
----------------------------------------
Feature #19197: Add Exception#root_cause
https://bugs.ruby-lang.org/issues/19197#change-103390
* Author: AMomchilov (Alexander Momchilov)
* Status: Open
* Priority: Normal
----------------------------------------
### Description
I would like to add a `#root_cause` method to `Exception`.
It returns the last exception in linked-list of causality chain, that is, the original
exception (whose own `cause` is `nil`).
### Example
```ruby
e = begin
raise 'A' # This is the root cause
rescue => a
begin
raise 'B'
rescue => B
begin
raise 'C' # This is the outermost cause assigned to `e`
rescue => c
c
end
end
end
# Here's what the structure looks like:
# C -> B -> A -> nil
p(e) # => #<RuntimeError: C>
p(e.cause) # => #<RuntimeError: B>
p(e.cause.cause) # => #<RuntimeError: A>
p(e.cause.cause.cause) # => nil
# Here's the proposed API, showing that A is the root cause of e
p(e.root_cause) # => #<RuntimeError: A>
# And that the root_cause has no further cause
p(e.root_cause.cause) # => nil
```
### Motivation
There are some kinds of exceptions that can occur all over the place (and might be wrapped
by arbitrarily many middlemen), but are attributable to a singular global cause. For
example, a database outage could raise exceptions in almost every line of business logic
of an app that uses ActiveRecord models.
Fundamentally, you wouldn't want an error report for every one of these lines.
You'd want to look at the root cause, and bucket all SQL-connection issues into a
single report, regardless of where they surface.
### Implementation
Draft PR:
https://github.com/ruby/ruby/pull/6913
--
https://bugs.ruby-lang.org/