thread-dump 0.0.1

data/ext/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+extension_name = "thread_dumper"
+dir_config(extension_name)
+create_makefile(extension_name)

data/ext/thread_dumper.c

@@ -0,0 +1,70 @@
+#include "thread_dumper.h"
+
+static VALUE rb_mThreadDump;
+static VALUE rb_cDumper;
+
+static VALUE backtrace(rb_thread_t th)
+{
+  char buf[BUFSIZ];
+  VALUE ary;
+  NODE *n;
+  struct FRAME *frame;
+
+  n = th->node;
+  frame = th->frame;
+  ary = rb_ary_new();
+
+  rb_ary_push(ary, rb_obj_id(th->thread));
+
+  if (n) {
+    snprintf(buf, BUFSIZ, "%s:%d", n->nd_file, nd_line(n));
+    rb_ary_push(ary, rb_str_new2(buf));
+  } 
+
+    /*for (; frame && (n = frame->node); frame = frame->prev) {
+	if (frame->prev && frame->prev->last_func) {
+	    if (frame->prev->node == n) continue;
+	    snprintf(buf, BUFSIZ, "%s:%d:in `%s'",
+		     n->nd_file, nd_line(n),
+		     rb_id2name(frame->prev->last_func));
+	}
+	else {
+	    snprintf(buf, BUFSIZ, "%s:%d", n->nd_file, nd_line(n));
+	}
+	rb_ary_push(ary, rb_str_new2(buf));
+    }*/
+
+  return ary;
+}
+
+static VALUE
+dump() 
+{
+  VALUE ary_dump;
+  VALUE curr_rb_thread;
+  struct thread* curr_thread;
+  struct thread* th;
+
+  ary_dump = rb_ary_new();
+   
+  curr_rb_thread = rb_thread_current();
+  Data_Get_Struct(curr_rb_thread, struct thread, curr_thread);
+
+  if (curr_thread) {
+    FOREACH_THREAD_FROM(curr_thread, th) {
+      if (th) {
+        rb_ary_push(ary_dump, backtrace(th));
+      }
+    } END_FOREACH_FROM(curr_thread, th);
+  }
+
+  return ary_dump;
+}
+
+void
+Init_thread_dumper()
+{
+  rb_mThreadDump = rb_define_module("ThreadDump");
+  rb_cDumper = rb_define_class_under(rb_mThreadDump, "Dumper", rb_cObject);
+  rb_define_method(rb_cDumper, "dump", dump, 0);
+}

data/ext/thread_dumper.h

@@ -0,0 +1,81 @@
+#include "ruby.h"
+#include "env.h"
+#include "node.h"
+#include "st.h"
+#include "setjmp.h"
+
+#define FOREACH_THREAD_FROM(f,x) x = f; do { x = x->next;
+#define END_FOREACH_FROM(f,x) } while (x != f)
+
+typedef jmp_buf rb_jmpbuf_t;
+
+enum thread_status {
+    THREAD_TO_KILL,
+    THREAD_RUNNABLE,
+    THREAD_STOPPED,
+    THREAD_KILLED,
+};
+
+typedef struct thread * rb_thread_t; 
+
+struct thread {
+    struct thread *next, *prev;
+    rb_jmpbuf_t context;
+#ifdef SAVE_WIN32_EXCEPTION_LIST
+    DWORD win32_exception_list;
+#endif
+
+    VALUE result;
+
+    long   stk_len;
+    long   stk_max;
+    VALUE *stk_ptr;
+    VALUE *stk_pos;
+#ifdef __ia64__
+    VALUE *bstr_ptr;
+    long   bstr_len;
+#endif
+
+    struct FRAME *frame;
+    struct SCOPE *scope;
+    struct RVarmap *dyna_vars;
+    struct BLOCK *block;
+    struct iter *iter;
+    struct tag *tag;
+    VALUE klass;
+    VALUE wrapper;
+    NODE *cref;
+
+    int flags;		/* misc. states (vmode/rb_trap_immediate/raised) */
+
+    NODE *node;
+
+    int tracing;
+    VALUE errinfo;
+    VALUE last_status;
+    VALUE last_line;
+    VALUE last_match;
+
+    int safe;
+
+    enum thread_status status;
+    int wait_for;
+    int fd;
+    fd_set readfds;
+    fd_set writefds;
+    fd_set exceptfds;
+    int select_value;
+    double delay;
+    rb_thread_t join;
+
+    int abort;
+    int priority;
+    VALUE thgroup;
+
+    st_table *locals;
+
+    VALUE thread;
+};
+
+static rb_thread_t curr_thread = 0;
+static VALUE backtrace(rb_thread_t);

data/lib/thread-dump.rb

@@ -0,0 +1,21 @@
+require 'thread_dumper'
+
+trap("QUIT") do
+  Thread.start do
+    out_arr = []
+
+    ThreadDump::Dumper.new.dump.each do |thread_info| 
+      out_arr << "Thread #{thread_info[0]}: #{thread_info[1]}"
+    end
+
+    max_l_out_arr = out_arr.map { |out| out.size }.max
+
+    out_arr.each do |out|
+      STDERR << "-" * max_l_out_arr + "\n"
+      STDERR << out + "\n"
+    end
+
+    STDERR << "-" * max_l_out_arr + "\n"
+    STDERR.flush
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: thread-dump
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-07-23 00:00:00 -07:00
+summary: Utility which will cause thread dumps during ctrl-break of Ruby process.
+require_paths: 
+- lib
+email: 
+homepage: 
+rubyforge_project: thread-dump
+description: 
+autorequire: lib
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Greg Fodor
+files: 
+- ext/thread_dumper.c
+- ext/thread_dumper.h
+- lib/thread-dump.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: 
+- ext/extconf.rb
+requirements: []
+
+dependencies: []
+