thread_backtrace 0.1

data/README.markdown

@@ -0,0 +1,18 @@
+**THIS IS VERY-VERY EXPERIMENTAL AND HACKISH. USE ON YOUR OWN RISK.**
+
+Thread Backtrace
+================
+
+It adds Thread#backtrace. Although I abuse private APIs of Ruby, no ruby patches are required. It **does not** work with 1.9.
+
+Example
+-------
+
+    >> require 'thread_backtrace'
+    => true
+    >> def a; b; end; def b; c; end; def c; sleep 10; end
+    => nil
+    >> Thread.fork { a }.backtrace
+    => ["(irb):2:in `c'", "(irb):2:in `b'", "(irb):2:in `a'", "(irb):3:in `irb_binding'", "(irb):3:in `fork'", "(irb):3:in `irb_binding'", "/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/irb/workspace.rb:52:in `irb_binding'", "/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/irb/workspace.rb:52"]
+
+Also it adds caller_for_all_threads method to kernel. But it's not the same as output of REE (it doesn't skip the first entry for the current thread).

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rubygems'  unless defined?(Gem)
+require 'rake'      unless defined?(Rake)
+require 'rake/gempackagetask'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'thread_backtrace'
+  s.version = '0.1'
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.markdown"]
+  s.summary = "Adds Thread\#backtrace"
+  s.description = "Adds Thread\#backtrace for inspecting bactrace of a thread. Only works on 1.8"
+  s.files = PKG_FILES = %w(README.markdown Rakefile) + Dir.glob("{ext,lib}/**/*.{rb,c}")
+  s.extensions << 'ext/thread_backtrace/extconf.rb'
+  s.require_paths = ["lib"]
+  s.required_ruby_version = "~>1.8"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end

data/ext/thread_backtrace/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('thread_backtrace/thread_backtrace')

data/ext/thread_backtrace/thread_backtrace.c

@@ -0,0 +1,73 @@
+#include <ruby.h>
+#include <node.h>
+#include <env.h>
+
+extern rb_thread_t rb_main_thread, rb_curr_thread;
+extern struct FRAME * ruby_frame;
+
+static rb_thread_t find_thread(VALUE thread)
+{
+  rb_thread_t t = rb_main_thread;
+  do {
+    if (t->thread == thread) return t;
+
+    t = t->next;
+  } while (t != rb_main_thread);
+
+  // todo: raise exception
+  return 0;
+}
+
+static void * convert_pointer(rb_thread_t thread, void * ptr)
+{
+  VALUE *p = (VALUE*)ptr;
+
+  if(thread == rb_curr_thread) return ptr;
+
+  if(p >= thread->stk_pos && p <= thread->stk_pos + thread->stk_len)
+    return (p - thread->stk_pos) + thread->stk_ptr;
+
+  return p;
+}
+
+static VALUE thread_backtrace(VALUE self)
+{
+  rb_thread_t t = find_thread(self);
+  struct FRAME *frame, *prev_frame;
+  char buf[BUFSIZ];
+  VALUE ary;
+  NODE *n;
+
+  if (t == rb_curr_thread) {
+    frame = ruby_frame;
+  } else {
+    frame = convert_pointer(t, t->frame);
+  }
+
+  ary = rb_ary_new();
+  if (frame->last_func == ID_ALLOCATOR) {
+    frame = convert_pointer(t, frame->prev);
+  }
+
+  for (; frame && (n = frame->node); frame = prev_frame) {
+    prev_frame = convert_pointer(t, frame->prev);
+
+    if (prev_frame && prev_frame->last_func) {
+      if (prev_frame->node == n) {
+        if (prev_frame->last_func == frame->last_func) continue;
+      }
+      snprintf(buf, BUFSIZ, "%s:%d:in `%s'", n->nd_file, nd_line(n), rb_id2name(prev_frame->last_func));
+    } else {
+      snprintf(buf, BUFSIZ, "%s:%d", n->nd_file, nd_line(n));
+    }
+    rb_ary_push(ary, rb_str_new2(buf));
+  }
+
+  return ary;
+}
+
+void Init_thread_backtrace()
+{
+  VALUE cThread = rb_define_class("Thread", rb_cObject);
+  rb_define_method(cThread, "backtrace", thread_backtrace, 0);
+}

data/lib/thread_backtrace.rb

@@ -0,0 +1,11 @@
+require 'thread_backtrace/thread_backtrace'
+
+module Kernel
+  def caller_for_all_threads
+    c, Thread.critical = Thread.critical, true
+
+    Thread.list.inject({}) { |h, t| h.update t => t.backtrace }
+  ensure
+    Thread.critical = c
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: thread_backtrace
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: []
+
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-16 00:00:00 +03:00
+default_executable: 
+dependencies: []
+
+description: Adds Thread#backtrace for inspecting bactrace of a thread. Only works on 1.8
+email: 
+executables: []
+
+extensions: 
+- ext/thread_backtrace/extconf.rb
+extra_rdoc_files: 
+- README.markdown
+files: 
+- README.markdown
+- Rakefile
+- ext/thread_backtrace/extconf.rb
+- ext/thread_backtrace/thread_backtrace.c
+- lib/thread_backtrace.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ~>
+    - !ruby/object:Gem::Version 
+      version: "1.8"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Adds Thread#backtrace
+test_files: []
+