Issue #8257 has been updated by headius (Charles Nutter). matz (Yukihiro Matsumoto) wrote: > * Fundamentally accepted. Hooray! > * I am against #cause= java.lang.Throwable does not have #setCause, so I agree. It does have #initCause, which can only be called once (if cause has not already been provided via constructor)...but I have never used it. > * It's OK that #raise to have cause: keyword argument to specify cause Agreed. Unfortunately this would still break backward-compatibility, since it will count as an extra argument on older Ruby versions. This might be the biggest justification for $! capturing. > * I am not sure automagical capturing of $! would not cause wrong capturing or not There are a few small risks: * Many layers of exceptions being raised as an error propagates out would all be chained. This could cause more information/data/memory than necessary to be retained. * Lower layers may not want higher layers to have access to the causing error for security or encapsulation reasons. * Too much magic? But I think the benefits may outweigh them: * I can't think of any concrete examples of the above risks. * Automatic adoption; all exceptions caused by other exceptions will immediately show their lineage. * Reduced backward incompatibility (other than adding #cause) since users won't have to use the constructor to capture cause exception (of course, I still think we should have the cause constructor too). I think the output of exception backtraces should also be enhanced to show cause exception's trace, as in the JVM. This could cause a problem for tools that parse the backtrace, though (IMO nobody should ever parse backtraces and expect that to be stable). ---------------------------------------- Feature #8257: Exception#cause to carry originating exception along with new one https://bugs.ruby-lang.org/issues/8257#change-42384 Author: headius (Charles Nutter) Status: Open Priority: Normal Assignee: matz (Yukihiro Matsumoto) Category: Target version: Ruby 2.1.0 Often when a lower-level API raises an exception, we would like to re-raise a different exception specific to our API or library. Currently in Ruby, only our new exception is ever seen by users; the original exception is lost forever, unless the user decides to dig around our library and log it. We need a way to have an exception carry a "cause" along with it. Java has getCause/setCause and standard constructors that take a cause exception. Printing out an exception's backtrace then reports both that exception and any "cause" exception. Rubinius has added a similar feature: https://gist.github.com/dbussink/b2e01e51d0c50b27004f The changes required for this feature are pretty benign: * Exception#cause and #cause= accessors. * A new set of Kernel#raise overloads that accept (as a trailing argument, probably) the "cause" exception. * Modifications to backtrace-printing logic to also display backtrace information from the "cause" exception (and in turn, from any nested "cause" exceptions). There's some discussion here about alternatives to #cause, none of which are quite as elegant as having it built in: http://www.skorks.com/2013/04/ruby-why-u-no-have-nested-exceptions/ -- http://bugs.ruby-lang.org/