RubyException.printBacktrace omits the first line

It appears to me that the only case where this makes a difference is when we raise an non-NativeException exception while backtrace style is 'mri'.

As you can see below, the first element of the backtrace is a rather ugly duplicate. So it seems OK for me to skip it. Why this is the case, I have not investigated.

The short of it, though, is that this appears to be a WONTFIX.

Here is the comparison for the backtrace:

1. Reference (MRI 2.0 - trunk 35540)

   $ ruby2.0 -ve 'raise "error"'
   ruby 2.0.0dev (2012-05-05 trunk 35540) [x86_64-darwin11.3.0]
   -e:1:in `<main>': error (RuntimeError)
   

2. JRuby, indexing starting at 1

   $ jruby -v -e 'raise "error"'
   jruby 1.7.0.dev (ruby-1.9.3-p139) (2012-05-04 b0c4eaa) (Java HotSpot(TM) 64-Bit Server VM 1.7.0_04) [darwin-x86_64-java]
   RuntimeError: error
     (root) at -e:1
   

3. JRuby, indexing starting at 1, using the "mri" backtrace style

   $ jruby -Xbacktrace.style=mri -v -e 'raise "error"'
   jruby 1.7.0.dev (ruby-1.9.3-p139) (2012-05-04 b0c4eaa) (Java HotSpot(TM) 64-Bit Server VM 1.7.0_04) [darwin-x86_64-java]
   -e:1:in `(root)': error (RuntimeError)
   

4. JRuby, indexing starting at 0

   $ jruby -v -e 'raise "error"'                      
   jruby 1.7.0.dev (ruby-1.9.3-p139) (2012-05-04 b0c4eaa) (Java HotSpot(TM) 64-Bit Server VM 1.7.0_04) [darwin-x86_64-java]
   RuntimeError: error
     (root) at -e:1
   

5. JRuby, indexing starting at 0, using the "mri" backtrace style

   $ jruby -Xbacktrace.style=mri -v -e 'raise "error"'
   jruby 1.7.0.dev (ruby-1.9.3-p139) (2012-05-04 b0c4eaa) (Java HotSpot(TM) 64-Bit Server VM 1.7.0_04) [darwin-x86_64-java]
   -e:1:in `(root)': error (RuntimeError)
   	from -e:1:in `(root)'
   

I tracked this down to this commit: https://github.com/jruby/jruby/commit/53278235b77a3297d5e7d9cc2642d45edf7a6821

Ok, thanks Hiro. I was using RubyException.printBacktrace directly (from some Java code that calls into JRuby), and in that situation it was surprising that one line was missing. However, if the method isn't intended to be used that way (i.e. everyone who calls it already adds the first line anyway), then I guess these semantics are ok.

Martin,

Do you have a case where the lost first item causes a problem for you?

My use case: I have a Ruby class that implements a Java interface. The interface specifies that methods should throw a particular Java exception, but the underlying Ruby code throws a Ruby exception, and I want to preserve the Ruby backtrace information for easier debugging. So I have a wrapper that translates from Ruby exceptions to Java exceptions, like this:

public interface MyInterface {
    void foo() throws MyException;
}

class MyException extends Exception {
    private String backtrace;

    public MyException(RubyException cause) {
        this.backtrace = ???; // how do I format cause's exception nicely as a string?
    }

    public String getBacktrace() {
        return backtrace;
    }
}


# In Ruby:

class MyImplementation
  include Java::MyInterface

  def foo
    # do stuff
  rescue => e
    raise Java::MyException.new(e)
  end
end

I was originally using RubyException.printBacktrace (with a PrintStream based on ByteArrayOutputStream) to generate the string representation of the Ruby backtrace (the ??? place above).

However, with the first line missing, the backtrace wasn't very useful. So instead I'm now iterating over the backtrace lines returned by RubyException.getBacktrace(), and constructing the string myself. That's actually quite reasonable.

Yah, I agree that printBacktrace should print the first line too...it's stupid that it doesn't.

Hiro's right about the MRI trace behaving a bit differently, but I think fixing printBacktrace would be sufficient for this bug. Looking into it.

Actually, I think I got my wires crossed a bit.

The Java exception printStackTrace (from RaiseException) should print all lines, and I believe it does.

printBacktrace on RubyException is, as Hiro mentions, used for printing the exception in multiple formats where the first line is treated specially. I will add javadoc to that effect and add an alternative method for printing the same thing RaiseException.printStackTrace does.

Excellent, thank you!