ruby_ext_backtrace 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ruby_ext_backtrace.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Vasily Fedoseyev
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,86 @@
+# RubyExtBacktrace
+
+Provides extended backtrace for ruby, including method parameters values.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ruby_ext_backtrace'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ruby_ext_backtrace
+
+## Usage
+
+Once loaded, gem provides global method caller_ext, similar to `Kernel#caller`, but returning an array of hashes.
+
+```ruby
+
+require 'pp'
+require 'ruby_ext_backtrace'
+
+def some_method2 param
+  pp caller(0); puts; pp caller_ext(0)
+end
+
+def some_method param1, param2=nil, &blk
+  yield "block_param0", "block_param1"
+end
+
+some_method(1111){|bp1,bp2|
+  some_method2 "some_method2_param"
+}
+```
+
+this outputs:
+
+```ruby
+
+["./test.rb:10:in `meth'",
+ "./test.rb:17:in `some_method2'",
+ "./test.rb:25:in `block in <main>'",
+ "./test.rb:21:in `some_method'",
+ "./test.rb:24:in `<main>'"]
+
+[{:file=>"./test.rb",
+  :line=>10,
+  :method=>"meth",
+  :argc=>1,
+  0=>"default_meth_param"},
+ {:file=>"./test.rb",
+  :line=>17,
+  :method=>"some_method2",
+  :argc=>1,
+  0=>"some_method2_param"},
+ {:file=>"./test.rb",
+  :line=>25,
+  :method=>"block in <main>",
+  :argc=>2,
+  0=>"block_param0",
+  1=>"block_param1"},
+ {:file=>"./test.rb",
+  :line=>21,
+  :method=>"some_method",
+  :argc=>3,
+  0=>1111,
+  1=>nil,
+  2=>#<Proc:0x007f8c5b02fff0@./test.rb:24>},
+ {:file=>"./test.rb", :line=>24, :method=>"<main>", :argc=>0}]
+```
+
+Note that fetching parameters for CFUNCs with variable parameters (argc&lt;0) is not supported.
+Also instead of "&lt;ruby&gt;" `:file` can be `nil`, so does `:method` for unknown methods.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new('ruby_ext_backtrace')

data/ext/ruby_ext_backtrace/extconf.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+#encoding: utf-8
+
+require 'mkmf'
+require 'debugger/ruby_core_source'
+
+hdrs = proc {
+  have_header("vm_core.h") # and have_header("iseq.h")
+}
+
+dir_config("ruby") # allow user to pass in non-standard core include directory
+
+if !Debugger::RubyCoreSource::create_makefile_with_core(hdrs, "ruby_ext_backtrace")
+  exit(1)
+end

data/ext/ruby_ext_backtrace/ruby_ext_backtrace.c

@@ -0,0 +1,117 @@
+#include <ruby.h>
+
+#define TRUE 1
+#define FALSE 0
+
+#ifdef RUBY_VM
+#include "vm_core.h"
+//#include "eval_intern.h"
+#else
+#error Need RubyVM, use another ruby
+#endif
+
+typedef int (rb_backtrace_iter_ext_func)(void *arg, VALUE file, int line, VALUE method_name, int argc, VALUE* argv);
+
+static int
+vm_backtrace_each_ext(rb_thread_t *th, int lev, void (*init)(void *), rb_backtrace_iter_ext_func *iter, void *arg)
+{
+  const rb_control_frame_t *limit_cfp = th->cfp;
+  const rb_control_frame_t *cfp = (void *)(th->stack + th->stack_size);
+  VALUE file = Qnil;
+  int line_no = 0;
+
+  cfp -= 2;
+  //skip lev frames:
+  while (lev-- >= 0) {
+    if (++limit_cfp > cfp)
+        return FALSE;
+  }
+
+  if (init) (*init)(arg);
+
+  limit_cfp = RUBY_VM_NEXT_CONTROL_FRAME(limit_cfp);
+  if (th->vm->progname) file = th->vm->progname;
+
+  while (cfp > limit_cfp) {
+    if (cfp->iseq != 0) {
+        if (cfp->pc != 0) {
+          rb_iseq_t *iseq = cfp->iseq;
+
+          line_no = rb_vm_get_sourceline(cfp);
+          file = iseq->filename;
+
+          //arguments pushed this way: *reg_cfp->sp++ = recv; for (i = 0; i < argc; i++) *reg_cfp->sp++ = argv[i];
+          //local vars = cfp->iseq->local_size - cfp->iseq->arg_size;
+          //in memory: receiver params locals (bp(incremented))
+          VALUE* argv = &cfp->bp[- cfp->iseq->local_size - 1];
+          if ((*iter)(arg, file, line_no, iseq->name, cfp->iseq->arg_size, argv)) break;
+        }
+    } else
+      if (RUBYVM_CFUNC_FRAME_P(cfp)) {
+        ID id = cfp->me->def? cfp->me->def->original_id : cfp->me->called_id;
+        extern VALUE ruby_engine_name;
+        if (NIL_P(file)) file = ruby_engine_name;
+
+        if (id != ID_ALLOCATOR){
+          VALUE* argv = NULL;
+          // when argc==-1/-2(variable length params without/with splat) - the cfp has no info on params count :(
+          //TODO: infere from somewhere ex. find self in stack? (not guaranted btw, for example: obj.method(obj, 123, obj) - will find last param instead of self)
+          if(cfp->me->def->body.cfunc.argc >= 0){ //only fixed args
+            argv = &cfp->bp[- cfp->me->def->body.cfunc.argc - 2]; // args+self, bp was incremented thus minus 2
+          }
+          //file+line no from previous iseq frame
+          if((*iter)(arg, file, line_no, rb_id2str(id), cfp->me->def->body.cfunc.argc, argv)) break;
+        }
+      }
+    cfp = RUBY_VM_NEXT_CONTROL_FRAME(cfp);
+  }
+  return TRUE;
+}
+
+VALUE sym_file, sym_line, sym_method, sym_argc;
+
+static int backtrace_iter(void *arg, VALUE file, int line, VALUE method_name, int argc, VALUE* argv)
+{
+    VALUE arr = (VALUE)arg;
+
+    const char *filename = NIL_P(file) ? "ruby" : RSTRING_PTR(file);
+    VALUE hash = rb_hash_new();
+    rb_hash_aset(hash, sym_file, file); //may be nil
+    rb_hash_aset(hash, sym_line, INT2FIX(line));
+    rb_hash_aset(hash, sym_method, method_name); //may be nil
+    rb_hash_aset(hash, sym_argc, INT2FIX(argc));
+
+    int i;
+    for(i = 0; i < argc; i++){
+      rb_hash_aset(hash, INT2FIX(i), argv[i]);
+    }
+    rb_ary_unshift(arr, hash);
+    return FALSE;
+}
+
+// trim(1 by default, but may pass 0 to include current method in trace)
+// like in 'Kernel#caller'
+static VALUE rb_caller_ext(int argc, VALUE argv[], VALUE self){
+  int trim = 1;
+  if(argc > 1)
+    rb_raise(rb_eArgError, "wrong number of arguments(%d for 0-1)", argc);
+  if(argc > 0){
+    trim = FIX2INT(argv[0]);
+  }
+
+  rb_thread_t *th = GET_THREAD();
+  //we know frames count, thus array size is known too, eliminate relocations
+  int frames = (int)((rb_control_frame_t*)(th->stack + th->stack_size) - th->cfp - 3 - trim);
+
+  VALUE res = rb_ary_new2(frames);
+  vm_backtrace_each_ext(th, trim, NULL/*init func*/, backtrace_iter, (void*)res /*param*/);
+  return res;
+}
+
+void Init_ruby_ext_backtrace(){
+  sym_file = ID2SYM(rb_intern("file"));
+  sym_line = ID2SYM(rb_intern("line"));
+  sym_method = ID2SYM(rb_intern("method"));
+  sym_argc = ID2SYM(rb_intern("argc"));
+  rb_define_global_function("caller_ext", rb_caller_ext, -1);
+}

data/ext/ruby_ext_backtrace/test.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+#encoding: utf-8
+
+$:.unshift(File.dirname(__FILE__))
+
+require 'pp'
+require 'ruby_ext_backtrace'
+
+def some_method2 param
+  pp caller(0); puts; pp caller_ext(0)
+end
+
+def some_method param1, param2=nil, &blk
+  yield "block_param0", "block_param1"
+end
+
+some_method(1111){|bp1,bp2|
+  some_method2 "some_method2_param"
+}

data/lib/ruby_ext_backtrace.rb

@@ -0,0 +1,8 @@
+require "ruby_ext_backtrace/version"
+
+require 'rbconfig'
+require "ruby_ext_backtrace.#{RbConfig::CONFIG['DLEXT']}"
+
+module RubyExtBacktrace
+  # Everything is in extension atm
+end

data/lib/ruby_ext_backtrace/version.rb

@@ -0,0 +1,3 @@
+module RubyExtBacktrace
+  VERSION = "0.0.1"
+end

data/ruby_ext_backtrace.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby_ext_backtrace/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "ruby_ext_backtrace"
+  gem.version       = RubyExtBacktrace::VERSION
+  gem.authors       = ["Vasily Fedoseyev"]
+  gem.email         = ["vasilyfedoseyev@gmail.com"]
+  gem.description   = %q{Extended backtrace for ruby}
+  gem.summary       = %q{have you ever wanted to see method parameters in backtrace?}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.extensions = "ext/ruby_ext_backtrace/extconf.rb"
+
+  gem.add_dependency "debugger-ruby_core_source"
+  gem.add_development_dependency('rake-compiler')
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: ruby_ext_backtrace
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Vasily Fedoseyev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: debugger-ruby_core_source
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Extended backtrace for ruby
+email:
+- vasilyfedoseyev@gmail.com
+executables: []
+extensions:
+- ext/ruby_ext_backtrace/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/ruby_ext_backtrace/extconf.rb
+- ext/ruby_ext_backtrace/ruby_ext_backtrace.c
+- ext/ruby_ext_backtrace/test.rb
+- lib/ruby_ext_backtrace.rb
+- lib/ruby_ext_backtrace/version.rb
+- ruby_ext_backtrace.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -835126318862271968
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -835126318862271968
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: have you ever wanted to see method parameters in backtrace?
+test_files: []