rbtrace 0.1.0

data/Gemfile

@@ -0,0 +1 @@
+gemspec

data/README.md

@@ -0,0 +1,115 @@
+# rbtrace
+
+like strace, but for ruby code
+
+## usage
+
+### require rbtrace into a process
+
+    % cat server.rb
+    require 'ext/rbtrace'
+
+    class String
+      def multiply_vowels(num)
+        gsub(/[aeiou]/){ |m| m*num }
+      end
+    end
+
+    while true
+      proc {
+        Dir.chdir("/tmp") do
+          Dir.pwd
+          Process.pid
+          'hello'.multiply_vowels(3)
+          sleep rand*0.5
+        end
+      }.call
+    end
+
+### run the process
+
+    % ruby server.rb &
+    [1] 95532
+
+### trace a function using the process's pid
+
+    % ./bin/rbtrace $! sleep
+
+    Kernel#sleep <0.329042>
+    Kernel#sleep <0.035732>
+    Kernel#sleep <0.291189>
+    Kernel#sleep <0.355800>
+    Kernel#sleep <0.238176>
+    Kernel#sleep <0.147345>
+    Kernel#sleep <0.238686>
+    Kernel#sleep <0.239668>
+    Kernel#sleep <0.035512>
+    ^C./bin/rbtrace:113: Interrupt
+
+### trace multiple functions
+
+    % ./bin/rbtrace $! sleep Dir.chdir Dir.pwd Process.pid "String#gsub" "String#*"
+
+    Dir.chdir
+       Dir.pwd <0.000094>
+       Process.pid <0.000016>
+       String#gsub
+          String#* <0.000020>
+          String#* <0.000020>
+       String#gsub <0.000072>
+       Kernel#sleep <0.369630>
+    Dir.chdir <0.370220>
+
+    Dir.chdir
+       Dir.pwd <0.000088>
+       Process.pid <0.000017>
+       String#gsub
+          String#* <0.000020>
+          String#* <0.000020>
+       String#gsub <0.000071>
+    ^C./bin/rbtrace:113: Interrupt
+
+### trace all functions in a class/module
+
+    % ./bin/rbtrace $! "Kernel#"
+
+    Kernel#proc <0.000071>
+    Kernel#rand <0.000029>
+    Kernel#sleep <0.331857>
+    Kernel#proc <0.000019>
+    Kernel#rand <0.000010>
+    Kernel#sleep <0.296361>
+    Kernel#proc <0.000021>
+    Kernel#rand <0.000012>
+    Kernel#sleep <0.281067>
+    ^C./bin/rbtrace:113: Interrupt
+
+### get values of variables and other expressions
+
+    % ./bin/rbtrace $! "String#gsub(self)" "String#*(self)" "String#multiply_vowels(self, self.length, num)"
+
+    String#multiply_vowels(self="hello", self.length=5, num=3)
+       String#gsub(self="hello")
+          String#*(self="e") <0.000021>
+          String#*(self="o") <0.000019>
+       String#gsub <0.000097>
+    String#multiply_vowels <0.000203>
+
+    ^C./bin/rbtrace:113: Interrupt
+
+### watch for method calls slower than 250ms
+
+    % ./bin/rbtrace $! watch 250
+          Kernel#sleep <0.402916>
+       Dir.chdir <0.403122>
+    Proc#call <0.403152>
+
+          Kernel#sleep <0.390635>
+       Dir.chdir <0.390937>
+    Proc#call <0.390983>
+
+          Kernel#sleep <0.399413>
+       Dir.chdir <0.399753>
+    Proc#call <0.399797>
+
+    ^C./bin/rbtrace:113: Interrupt

data/bin/rbtrace

@@ -0,0 +1,270 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'ffi'
+
+module RBTracer
+  def self.process_line(line)
+    @tracers ||= {}
+    @nesting ||= 0
+    @last_tracer ||= nil
+
+    time, event, id, *args = line.strip.split(',')
+    time = time.to_i
+    id = id.to_i
+    tracer = @tracers[id] if id > -1
+
+    case event
+    when 'add'
+      if id == -1
+        puts line
+      else
+        name = args.first
+        @tracers[id] = {
+          :name => name,
+          :times => [],
+          :names => [],
+          :exprs => {},
+          :last => false,
+          :arglist => false
+        }
+      end
+
+    when 'remove'
+      if id == -1
+        puts line
+      else
+        @tracers.delete(id)
+      end
+
+    when 'newexpr'
+      expr_id, expr = *args
+      expr_id = expr_id.to_i
+
+      if expr_id > -1 and tracer
+        tracer[:exprs][expr_id] = expr
+      end
+
+    when 'exprval'
+      expr_id, val = *args
+      expr_id = expr_id.to_i
+      expr = tracer[:exprs][expr_id]
+
+      if tracer[:arglist]
+        print ', '
+      else
+        print '('
+      end
+
+      print "#{expr}="
+      print val
+      tracer[:arglist] = true
+
+    when 'call','ccall'
+      method, is_singleton, klass = *args
+      is_singleton = (is_singleton == '1')
+      name = klass ? "#{klass}#{ is_singleton ? '.' : '#' }" : ''
+      name += method
+
+      tracer[:times] << time
+      tracer[:names] << name
+
+      if @last_tracer and @last_tracer[:arglist]
+        print ')'
+        @last_tracer[:arglist] = false
+      end
+      puts
+      print ' '*@nesting if @nesting > 0
+      print name
+
+      @nesting += 1
+      @last_tracer = tracer
+      tracer[:last] = name
+
+    when 'return','creturn'
+      @nesting -= 1 if @nesting > 0
+
+      if start = tracer[:times].pop
+        name = tracer[:names].pop
+        diff = time - start
+        @last_tracer[:arglist] = false if @last_tracer and @last_tracer[:last] != name
+
+        print ')' if @last_tracer and @last_tracer[:arglist]
+
+        unless tracer == @last_tracer and @last_tracer[:last] == name
+          puts
+          print ' '*@nesting if @nesting > 0
+          print name
+        end
+        print ' <%f>' % (diff/1_000_000.0)
+        puts if @nesting == 0 and (tracer != @last_tracer || @last_tracer[:last] != name)
+      end
+
+      tracer[:arglist] = false
+
+    when 'slow', 'cslow'
+      diff, nesting, method, is_singleton, klass = *args
+      nesting = nesting.to_i
+      diff = diff.to_i
+
+      is_singleton = (is_singleton == '1')
+      name = klass ? "#{klass}#{ is_singleton ? '.' : '#' }" : ''
+      name += method
+
+      print ' '*nesting if nesting > 0
+      print name
+      print ' '
+      puts "<%f>" % (diff/1_000_000.0)
+      puts if nesting == 0
+
+    else
+      puts "unknown event: #{line}"
+
+    end
+  rescue => e
+    puts "error on: #{line}"
+    raise e
+  end
+end
+
+class EventMsg < FFI::Struct
+  BUF_SIZE = RUBY_PLATFORM =~ /linux/ ? 256 : 120
+  IPC_NOWAIT = 004000
+
+  layout :mtype, :long,
+         :buf, [:char, BUF_SIZE]
+
+  def self.send_cmd(q, str)
+    msg = EventMsg.new
+    msg[:mtype] = 1
+    msg[:buf].to_ptr.put_string(0, str)
+
+    ret = MsgQ.msgsnd(q, msg, BUF_SIZE, 0)
+    FFI::LastError.raise if ret == -1
+  end
+
+  def self.recv_cmd(q, block=true)
+    msg = EventMsg.new
+    ret = MsgQ.msgrcv(q, msg, BUF_SIZE, 0, block ? 0 : IPC_NOWAIT)
+    if ret == -1
+      if !block and [Errno::EAGAIN, Errno::ENOMSG].include?(FFI::LastError.exception)
+        return nil
+      end
+
+      FFI::LastError.raise
+    end
+
+    msg[:buf].to_ptr.read_string
+  end
+end
+
+module FFI::LastError
+  def self.exception
+    Errno::constants.map(&Errno.method(:const_get)).find{ |c| c.const_get(:Errno) == error }
+  end
+  def self.raise(msg=nil)
+    Kernel.raise exception, msg
+  end
+end
+
+module MsgQ
+  extend FFI::Library
+
+  ffi_lib 'c'
+  attach_function :msgget, [:int, :int], :int
+  attach_function :msgrcv, [:int, EventMsg.ptr, :size_t, :long, :int], :int
+  attach_function :msgsnd, [:int, EventMsg.ptr, :size_t, :int], :int
+end
+
+if (pids = `ps ax -o pid`.split("\n").map{ |p| p.strip.to_i }).any?
+  ipcs = `ipcs -q`.split("\n").grep(/^q/).map{ |line| line.strip.split[2] }
+  ipcs.each do |ipci|
+    next if ipci.match(/^0xf/)
+
+    qi = ipci.to_i(16)
+    qo = 0xffffffff - qi + 1
+    ipco = "0x#{qo.to_s(16)}"
+
+    if ipcs.include?(ipco) and !pids.include?(qi)
+      STDERR.puts "** removing stale message queue pair: #{ipci}/#{ipco}"
+      system("ipcrm -Q #{ipci} -Q #{ipco}")
+    end
+  end
+end
+
+if File.exists?(msgmnb = "/proc/sys/kernel/msgmnb")
+  max = File.read(msgmnb).to_i
+  if max < 512*1024
+    STDERR.puts "** run `sudo sysctl kernel.msgmnb=#{512*1024}` to prevent losing events"
+  end
+end
+
+raise 'invalid pid' unless ARGV[0]
+
+begin
+  raise ArgumentError unless pid = ARGV[0]
+  pid = pid.to_i
+  raise ArgumentError unless pid > 0
+  Process.kill(0,pid)
+rescue TypeError, ArgumentError
+  raise 'pid required'
+rescue Errno::ESRCH
+  raise 'invalid pid'
+rescue Errno::EPERM
+  raise 'could not signal process (run as root)'
+end
+
+funcs = [ARGV[1] || 'sleep']
+if ARGV.size > 2
+  funcs += ARGV[2..-1]
+end
+
+qi = MsgQ.msgget(pid, 0666)
+qo = MsgQ.msgget(-pid, 0666)
+
+if qi == -1 || qo == -1
+  raise 'invalid pid'
+else
+  begin
+    if funcs.first == 'watch'
+      EventMsg.send_cmd(qo, funcs.join(','))
+      Process.kill 'URG', pid
+    else
+      funcs.each do |func|
+        func.strip!
+        if func =~ /^(.+)\((.+?)\)$/
+          func, args = $1, $2
+          args = args.split(',').map{ |a| a.strip }
+        end
+
+        EventMsg.send_cmd(qo, "add,#{func}")
+        Process.kill 'URG', pid
+
+        if args and args.any?
+          args.each do |arg|
+            EventMsg.send_cmd(qo, "addexpr,#{arg}")
+            Process.kill 'URG', pid
+          end
+        end
+      end
+    end
+
+    while true
+      # block until a message arrives
+      lines = [EventMsg.recv_cmd(qi)]
+
+      # check to see if there are more messages and pull them off
+      # so the queue doesn't fill up in kernel land
+      25.times do
+        break unless line = EventMsg.recv_cmd(qi, false)
+        lines << line
+      end
+
+      lines.each do |line|
+        RBTracer.process_line(line)
+      end
+    end
+  ensure
+    EventMsg.send_cmd(qo, funcs.first == 'watch' ? 'unwatch' : 'delall')
+    Process.kill 'URG', pid
+  end
+end

data/ext/extconf.rb

@@ -0,0 +1,8 @@
+require 'mkmf'
+
+# increase message size on linux
+if RUBY_PLATFORM =~ /linux/
+  $defs.push("-DBUF_SIZE=256")
+end
+
+create_makefile('rbtrace')

data/ext/rbtrace.c

@@ -0,0 +1,593 @@
+#include <inttypes.h>
+#include <errno.h>
+#include <signal.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/ipc.h>
+#include <sys/msg.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <ruby.h>
+
+#ifndef RUBY_VM
+#include <node.h>
+#include <intern.h>
+#endif
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(str) RSTRING(str)->ptr
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(str) RSTRING(str)->len
+#endif
+
+static uint64_t
+timeofday_usec()
+{
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  return (uint64_t)tv.tv_sec*1e6 + (uint64_t)tv.tv_usec;
+}
+
+#define MAX_EXPRS 10
+struct rbtracer_t {
+  int id;
+
+  char *query;
+  VALUE self;
+  VALUE klass;
+  ID mid;
+
+  int num_exprs;
+  char *exprs[MAX_EXPRS];
+};
+typedef struct rbtracer_t rbtracer_t;
+
+#define MAX_TRACERS 100
+static rbtracer_t tracers[MAX_TRACERS];
+static unsigned int num_tracers = 0;
+
+key_t mqi_key, mqo_key;
+int mqi_id = -1, mqo_id = -1;
+
+#ifndef BUF_SIZE
+#define BUF_SIZE 120
+#endif
+
+struct event_msg {
+  long mtype;
+  char buf[BUF_SIZE];
+};
+
+#define SEND_EVENT(format, ...) do {\
+  uint64_t usec = timeofday_usec();\
+  if (false) {\
+    fprintf(stderr, "%" PRIu64 "," format, usec, __VA_ARGS__);\
+    fprintf(stderr, "\n");\
+  } else {\
+    struct event_msg msg;\
+    int ret = -1, n = 0;\
+    \
+    msg.mtype = 1;\
+    snprintf(msg.buf, sizeof(msg.buf), "%" PRIu64 "," format, usec, __VA_ARGS__);\
+    \
+    for (n=0; n<10 && ret==-1; n++)\
+      ret = msgsnd(mqo_id, &msg, sizeof(msg)-sizeof(long), IPC_NOWAIT);\
+    if (ret == -1) {\
+      fprintf(stderr, "msgsnd(): %s\n", strerror(errno));\
+      struct msqid_ds stat;\
+      msgctl(mqo_id, IPC_STAT, &stat);\
+      fprintf(stderr, "cbytes: %lu, qbytes: %lu, qnum: %lu\n", stat.msg_cbytes, stat.msg_qbytes, stat.msg_qnum);\
+    }\
+  }\
+} while (0)
+
+static int in_event_hook = 0;
+static bool event_hook_installed = false;
+
+#define MAX_CALLS 32768
+static struct {
+  bool enabled;
+  uint64_t call_times[ MAX_CALLS ];
+  int num_calls;
+  uint32_t threshold;
+} slow_tracer = {
+  .enabled = false,
+  .num_calls = 0,
+  .threshold = 250
+};
+
+static void
+#ifdef RUBY_VM
+event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE klass)
+#else
+event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
+#endif
+{
+  // do not re-enter this function
+  // after this, must `goto out` instead of `return`
+  if (in_event_hook) return;
+  in_event_hook++;
+
+  // skip allocators
+  if (mid == ID_ALLOCATOR) goto out;
+
+  // normalize klass and check for class-level methods
+  bool singleton = 0;
+  if (klass) {
+    if (TYPE(klass) == T_ICLASS) {
+      klass = RBASIC(klass)->klass;
+    }
+    singleton = FL_TEST(klass, FL_SINGLETON);
+  }
+
+  // are we watching for any slow methods?
+  if (slow_tracer.enabled) {
+    uint64_t usec = timeofday_usec(), diff = 0;
+
+    switch (event) {
+      case RUBY_EVENT_C_CALL:
+      case RUBY_EVENT_CALL:
+        if (slow_tracer.num_calls < MAX_CALLS)
+          slow_tracer.call_times[ slow_tracer.num_calls ] = usec;
+
+        slow_tracer.num_calls++;
+        break;
+
+      case RUBY_EVENT_C_RETURN:
+      case RUBY_EVENT_RETURN:
+        if (slow_tracer.num_calls > 0) {
+          slow_tracer.num_calls--;
+
+          if (slow_tracer.num_calls < MAX_CALLS)
+            diff = usec - slow_tracer.call_times[ slow_tracer.num_calls ];
+        }
+        break;
+    }
+
+    if (diff > slow_tracer.threshold * 1e3) {
+      SEND_EVENT(
+        "%s,-1,%" PRIu64 ",%d,%s,%d,%s",
+        event == RUBY_EVENT_RETURN ? "slow" : "cslow",
+        diff,
+        slow_tracer.num_calls,
+        rb_id2name(mid),
+        singleton,
+        klass ? rb_class2name(singleton ? self : klass) : ""
+      );
+    }
+
+    goto out;
+  }
+
+  // are there specific methods we're waiting for?
+  if (num_tracers == 0) goto out;
+
+  int i, n;
+  rbtracer_t *tracer = NULL;
+
+  for (i=0, n=0; i<MAX_TRACERS && n<num_tracers; i++) {
+    if (tracers[i].query) {
+      n++;
+
+      if (!tracers[i].mid || tracers[i].mid == mid) {
+        if (!tracers[i].klass || tracers[i].klass == klass) {
+          if (!tracers[i].self || tracers[i].self == self) {
+            tracer = &tracers[i];
+          }
+        }
+      }
+    }
+  }
+
+  // no matching method tracer found, so bail!
+  if (!tracer) goto out;
+
+  switch (event) {
+    case RUBY_EVENT_C_CALL:
+    case RUBY_EVENT_CALL:
+      SEND_EVENT(
+        "%s,%d,%s,%d,%s",
+        event == RUBY_EVENT_CALL ? "call" : "ccall",
+        tracer->id,
+        rb_id2name(mid),
+        singleton,
+        klass ? rb_class2name(singleton ? self : klass) : ""
+      );
+
+      if (tracer->num_exprs) {
+        for (i=0; i<tracer->num_exprs; i++) {
+          char *expr = tracer->exprs[i];
+          size_t len = strlen(expr);
+          VALUE str = Qnil, val = Qnil;
+
+          if (len == 4 && strcmp("self", expr) == 0) {
+            val = rb_inspect(self);
+
+          } else if (event == RUBY_EVENT_CALL) {
+            char code[len+50];
+            snprintf(code, len+50, "(begin; %s; rescue Exception => e; e; end).inspect", expr);
+
+            str = rb_str_new2(code);
+            val = rb_obj_instance_eval(1, &str, self);
+          }
+
+          if (RTEST(val) && TYPE(val) == T_STRING) {
+            char *result = RSTRING_PTR(val);
+            SEND_EVENT(
+              "%s,%d,%d,%s",
+              "exprval",
+              tracer->id,
+              i,
+              result
+            );
+          }
+        }
+      }
+      break;
+
+    case RUBY_EVENT_C_RETURN:
+    case RUBY_EVENT_RETURN:
+      SEND_EVENT(
+        "%s,%d",
+        event == RUBY_EVENT_RETURN ? "return" : "creturn",
+        tracer->id
+      );
+      break;
+  }
+
+out:
+  in_event_hook--;
+}
+
+static void
+event_hook_install()
+{
+  if (!event_hook_installed) {
+    rb_add_event_hook(
+      event_hook,
+      RUBY_EVENT_CALL   | RUBY_EVENT_C_CALL |
+      RUBY_EVENT_RETURN | RUBY_EVENT_C_RETURN
+#ifdef RB_EVENT_HOOKS_HAVE_CALLBACK_DATA
+      , 0
+#endif
+    );
+    event_hook_installed = true;
+  }
+}
+
+static void
+event_hook_remove()
+{
+  if (event_hook_installed) {
+    rb_remove_event_hook(event_hook);
+    event_hook_installed = false;
+  }
+}
+
+static int
+rbtracer_remove(char *query, int id)
+{
+  int i;
+  int tracer_id = -1;
+  rbtracer_t *tracer = NULL;
+
+  if (query) {
+    for (i=0; i<MAX_TRACERS; i++) {
+      if (tracers[i].query) {
+        if (0 == strcmp(query, tracers[i].query)) {
+          tracer = &tracers[i];
+          break;
+        }
+      }
+    }
+  } else {
+    if (id >= MAX_TRACERS) goto out;
+    tracer = &tracers[id];
+  }
+
+  if (tracer->query) {
+    tracer_id = tracer->id;
+    tracer->mid = 0;
+
+    free(tracer->query);
+    tracer->query = NULL;
+
+    if (tracer->num_exprs) {
+      for(i=0; i<tracer->num_exprs; i++) {
+        free(tracer->exprs[i]);
+        tracer->exprs[i] = NULL;
+      }
+      tracer->num_exprs = 0;
+    }
+
+    num_tracers--;
+    if (num_tracers == 0)
+      event_hook_remove();
+  }
+
+out:
+  SEND_EVENT(
+    "remove,%d,%s",
+    tracer_id,
+    query
+  );
+  return tracer_id;
+}
+
+static void
+rbtracer_remove_all()
+{
+  int i;
+  for (i=0; i<MAX_TRACERS; i++) {
+    if (tracers[i].query) {
+      rbtracer_remove(NULL, i);
+    }
+  }
+}
+
+static int
+rbtracer_add(char *query)
+{
+  int i;
+  int tracer_id = -1;
+  rbtracer_t *tracer = NULL;
+
+  if (num_tracers >= MAX_TRACERS) goto out;
+
+  for (i=0; i<MAX_TRACERS; i++) {
+    if (!tracers[i].query) {
+      tracer = &tracers[i];
+      tracer_id = i;
+      break;
+    }
+  }
+  if (!tracer) goto out;
+
+  char *idx, *method;
+  VALUE klass = 0, self = 0;
+  ID mid = 0;
+
+  if (NULL != (idx = rindex(query, '.'))) {
+    *idx = 0;
+    self = rb_eval_string_protect(query, 0);
+    *idx = '.';
+
+    method = idx+1;
+  } else if (NULL != (idx = rindex(query, '#'))) {
+    *idx = 0;
+    klass = rb_eval_string_protect(query, 0);
+    *idx = '#';
+
+    method = idx+1;
+  } else {
+    method = query;
+  }
+
+  if (method && *method) {
+    mid = rb_intern(method);
+    if (!mid) goto out;
+  } else if (klass || self) {
+    mid = 0;
+  } else {
+    goto out;
+  }
+
+  memset(tracer, 0, sizeof(*tracer));
+
+  tracer->id = tracer_id;
+  tracer->self = self;
+  tracer->klass = klass;
+  tracer->mid = mid;
+  tracer->query = strdup(query);
+  tracer->num_exprs = 0;
+
+  if (num_tracers == 0)
+    event_hook_install();
+
+  num_tracers++;
+
+out:
+  SEND_EVENT(
+    "add,%d,%s",
+    tracer_id,
+    query
+  );
+  return tracer_id;
+}
+
+static void
+rbtracer_add_expr(int id, char *expr)
+{
+  int expr_id = -1;
+  int tracer_id = -1;
+  rbtracer_t *tracer = NULL;
+
+  if (id >= MAX_TRACERS) goto out;
+  tracer = &tracers[id];
+
+  if (tracer->query) {
+    tracer_id = tracer->id;
+
+    if (tracer->num_exprs < MAX_EXPRS) {
+      expr_id = tracer->num_exprs++;
+      tracer->exprs[expr_id] = strdup(expr);
+    }
+  }
+
+out:
+  SEND_EVENT(
+    "newexpr,%d,%d,%s",
+    tracer_id,
+    expr_id,
+    expr
+  );
+}
+
+static void
+rbtracer_watch(uint32_t threshold)
+{
+  if (!slow_tracer.enabled) {
+    slow_tracer.num_calls = 0;
+    slow_tracer.threshold = threshold;
+    slow_tracer.enabled = true;
+
+    event_hook_install();
+  }
+}
+
+static void
+rbtracer_unwatch()
+{
+  if (slow_tracer.enabled) {
+    event_hook_remove();
+
+    slow_tracer.enabled = false;
+  }
+}
+
+static VALUE
+rbtrace(VALUE self, VALUE query)
+{
+  Check_Type(query, T_STRING);
+
+  char *str = RSTRING_PTR(query);
+  int tracer_id = -1;
+
+  tracer_id = rbtracer_add(str);
+  return tracer_id == -1 ? Qfalse : Qtrue;
+}
+
+static VALUE
+untrace(VALUE self, VALUE query)
+{
+  Check_Type(query, T_STRING);
+
+  char *str = RSTRING_PTR(query);
+  int tracer_id = -1;
+
+  tracer_id = rbtracer_remove(str, -1);
+  return tracer_id == -1 ? Qfalse : Qtrue;
+}
+
+static void
+cleanup()
+{
+  if (mqo_id != -1) {
+    msgctl(mqo_id, IPC_RMID, NULL);
+    mqo_id = -1;
+  }
+  if (mqi_id != -1) {
+    msgctl(mqi_id, IPC_RMID, NULL);
+    mqi_id = -1;
+  }
+}
+
+static void
+cleanup_ruby(VALUE data)
+{
+  cleanup();
+}
+
+static void
+sigurg(int signal)
+{
+  static int last_tracer_id = -1; // hax
+  if (mqi_id == -1) return;
+
+  struct event_msg msg;
+  char *query = NULL;
+  size_t len = 0;
+  int n = 0;
+
+  while (true) {
+    int ret = -1;
+
+    for (n=0; n<10 && ret==-1; n++)
+      ret = msgrcv(mqi_id, &msg, sizeof(msg)-sizeof(long), 0, IPC_NOWAIT);
+
+    if (ret == -1) {
+      break;
+    } else {
+      len = strlen(msg.buf);
+      if (msg.buf[len-1] == '\n')
+        msg.buf[len-1] = 0;
+
+      if (0 == strncmp("add,", msg.buf, 4)) {
+        query = msg.buf + 4;
+        last_tracer_id = rbtracer_add(query);
+
+      } else if (0 == strncmp("del,", msg.buf, 4)) {
+        query = msg.buf + 4;
+        rbtracer_remove(query, -1);
+
+      } else if (0 == strncmp("delall", msg.buf, 6)) {
+        rbtracer_remove_all();
+
+      } else if (0 == strncmp("addexpr,", msg.buf, 8)) {
+        query = msg.buf + 8;
+        rbtracer_add_expr(last_tracer_id, query);
+
+      } else if (0 == strncmp("watch,", msg.buf, 6)) {
+        int msec = 250;
+
+        query = msg.buf + 6;
+        if (query && *query)
+          msec = atoi(query);
+
+        rbtracer_watch(msec);
+
+      } else if (0 == strncmp("unwatch", msg.buf, 7)) {
+        rbtracer_unwatch();
+
+      }
+    }
+  }
+}
+
+void
+Init_rbtrace()
+{
+  atexit(cleanup);
+  rb_set_end_proc(cleanup_ruby, 0);
+
+  signal(SIGURG, sigurg);
+
+  memset(&tracers, 0, sizeof(tracers));
+
+  mqo_key = (key_t) getpid();
+  mqo_id  = msgget(mqo_key, 0666 | IPC_CREAT);
+  if (mqo_id == -1)
+    rb_sys_fail("msgget");
+
+  mqi_key = (key_t) -getpid();
+  mqi_id  = msgget(mqi_key, 0666 | IPC_CREAT);
+  if (mqi_id == -1)
+    rb_sys_fail("msgget");
+
+  /*
+  struct msqid_ds stat;
+  int ret;
+
+  msgctl(mqo_id, IPC_STAT, &stat);
+  printf("cbytes: %lu, qbytes: %lu, qnum: %lu\n", stat.msg_cbytes, stat.msg_qbytes, stat.msg_qnum);
+
+  stat.msg_qbytes += 10;
+  ret = msgctl(mqo_id, IPC_SET, &stat);
+  printf("cbytes: %lu, qbytes: %lu, qnum: %lu\n", stat.msg_cbytes, stat.msg_qbytes, stat.msg_qnum);
+  printf("ret: %d, errno: %d\n", ret, errno);
+
+  msgctl(mqo_id, IPC_STAT, &stat);
+  printf("cbytes: %lu, qbytes: %lu, qnum: %lu\n", stat.msg_cbytes, stat.msg_qbytes, stat.msg_qnum);
+  */
+
+  rb_define_method(rb_cObject, "rbtrace", rbtrace, 1);
+  rb_define_method(rb_cObject, "untrace", untrace, 1);
+}

data/ext/test.rb

@@ -0,0 +1,57 @@
+class Test
+  def call
+    self[:a] = :b
+  end
+  def []=(k,v)
+    Another.new.call
+    :ok
+  end
+end
+
+class Another
+  def call
+    self[:a] = :b
+  end
+  def []=(key, value)
+    (@hash ||= {})[key]=value
+  end
+end
+
+module Do
+  module It
+    def something
+    end
+  end
+end
+
+class Slow
+  include Do::It
+  def self.something
+    sleep 0.01
+  end
+end
+
+require 'rbtrace'
+rbtrace 'Slow.something'
+rbtrace 'Do::It#something'
+rbtrace '[]='
+rbtrace 'call'
+
+1.times do
+  Slow.something
+  Slow.new.something
+  Test.new.call
+end
+
+__END__
+
+Slow.something <10047>
+Do::It#something <4>
+Test#call
+   Test#[]=
+      Another#call
+         Another#[]=          <4>
+      <14>
+   <28>
+<40>
+

data/rbtrace.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |s|
+  s.name = 'rbtrace'
+  s.version = '0.1.0'
+  s.homepage = 'http://github.com/tmm1/rbtrace'
+
+  s.authors = "Aman Gupta"
+  s.email   = "aman@tmm1.net"
+
+  s.files = `git ls-files`.split("\n")
+  s.extensions = "ext/extconf.rb"
+
+  s.bindir = 'bin'
+  s.executables << 'rbtrace'
+
+  s.add_dependency 'ffi'
+
+  s.summary = 'rbtrace: like strace but for ruby code'
+end

data/server.rb

@@ -0,0 +1,18 @@
+require 'ext/rbtrace'
+
+class String
+  def multiply_vowels(num)
+    gsub(/[aeiou]/){ |m| m*num }
+  end
+end
+
+while true
+  proc {
+    Dir.chdir("/tmp") do
+      Dir.pwd
+      Process.pid
+      'hello'.multiply_vowels(3)
+      sleep rand*0.5
+    end
+  }.call
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: rbtrace
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Aman Gupta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-14 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: aman@tmm1.net
+executables: 
+- rbtrace
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- README.md
+- bin/rbtrace
+- ext/extconf.rb
+- ext/rbtrace.c
+- ext/test.rb
+- rbtrace.gemspec
+- server.rb
+has_rdoc: true
+homepage: http://github.com/tmm1/rbtrace
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: "rbtrace: like strace but for ruby code"
+test_files: []
+