rbtrace 0.4.2 → 0.4.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NmQ5ZDFlYWZkMTFjNGFhNzc1ZTNiM2RjNDAxYjQwMmYzMDcxYzEwOQ==
+    Y2Y5ZDY3NmVmZWY1ODA5YWVjYzJmNmI2ZDI0NWM3OTMwYmM0M2VkMA==
   data.tar.gz: !binary |-
-    N2Q2M2YxMzE3N2JhNTA0MmE3NzU1OWMwODY3MGFjMDRkZGM4YzVlMg==
+    NWVhZWRkOGJhNzE3NTE4ZjRiM2U1YTcyOGFiMzJiODE0ZDc0MmRlYQ==
 SHA512:
   metadata.gz: !binary |-
-    MzQ1NzUyZDgxMzM1OWZiZTg2OThhZjZiNmIyZDdjNTI4YzJjYzgxYmQ5MWVk
-    NWQxMWU0MWY1MzlmNmM1MmE5M2VmMzkxOGRkOTI1M2U1YWU3YWZmZTQzMjA4
-    ZDJiZjAyM2FlNWFlNDQ4OWNhN2QxNzM5OTMzYjdmZTM5MmE3ZWM=
+    YzM0Yjk4YjViNjgwNTk1N2Y5NzY5YzBiMjg3N2MzZGE5NjIwMjU3Zjg4NzQz
+    MGNmNjM0MzUzNGUwZWVlNDI1MGVkZTlkNDQwZmJjYzliMTlmZTY2OGNhYzdh
+    NjBiNmNjOWZjNmU4MjJjMTU5MTkwYTk0N2ExYzU0ZWFkNTBmNjM=
   data.tar.gz: !binary |-
-    YTUxNzAyMDQyZThkMjJlOGNhNTliNjE0NjYwYjI0NjFhZjZlOTNlZTRmYjhi
-    MWFhZmJlNzVmNGY4MzY4OTlkYjQ0ZWJlNDEzMmNjYTcxMTgzOWVjODA5ZDky
-    N2Q3ZjQ5NDIyMTJkNTc5ZWYzMzUyMGY4YTc1YzI0OGE3ZmFiYTc=
+    ODg5ZGI2NTEyZGM4Y2I1ZjcwYTQ2YzA5NWZkMTFhNDNlNWI2MTlkYWE3ZWU3
+    MGZhZTcxMWQyZmZkNDFkNmU3NGExZDAyMmU4NmNlNTU1OTIxYjIzNGRjNzUw
+    OTdlMmU5YTFjYjg1NGJmOTNiMjI0MTQ4ZjI5MDg1ZTBlODZkNGM=

data/.gitignore

@@ -1 +1,3 @@
 *.gem
+.bundle
+ext/src/msgpack*

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rbtrace (0.4.2)
+    rbtrace (0.4.3)
       ffi (>= 1.0.6)
       msgpack (>= 0.4.3)
       trollop (>= 1.16.2)

data/bin/rbtrace

@@ -1,1080 +1,5 @@
 #!/usr/bin/env ruby
-require 'socket'
-require 'fileutils'
 require 'rubygems'
-require 'ffi'
-require 'msgpack'
-require 'trollop'
+require 'rbtrace/cli'
 
-class String
-  alias :bytesize :size
-end unless ''.respond_to?(:bytesize)
-
-module FFI::LastError
-  Errnos = Errno::constants.map(&Errno.method(:const_get)).inject({}) do |hash, c|
-    hash[ c.const_get(:Errno) ] = c
-    hash
-  end
-
-  def self.exception
-    Errnos[error]
-  end
-  def self.raise(msg=nil)
-    Kernel.raise exception, msg
-  end
-end
-
-module MsgQ
-  extend FFI::Library
-  ffi_lib FFI::CURRENT_PROCESS
-
-  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)
-      MsgQ.rb_enable_interrupt if RUBY_VERSION > '1.9' && RUBY_VERSION < '2.0'
-
-      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_length(BUF_SIZE)
-    ensure
-      MsgQ.rb_disable_interrupt if RUBY_VERSION > '1.9' && RUBY_VERSION < '2.0'
-    end
-  end
-
-  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
-
-  if RUBY_VERSION > '1.9' && RUBY_VERSION < '2.0'
-    attach_function :rb_enable_interrupt,  [], :void
-    attach_function :rb_disable_interrupt, [], :void
-  end
-end
-
-class RBTracer
-  # Suggest increasing the maximum number of bytes allowed on
-  # a message queue to 1MB.
-  #
-  # This defaults to 16k on Linux, and is hardcoded to 2k in OSX kernel.
-  #
-  # Returns nothing.
-  def self.check_msgmnb
-    if File.exists?(msgmnb = "/proc/sys/kernel/msgmnb")
-      curr = File.read(msgmnb).to_i
-      max = 1024*1024
-      cmd = "sysctl kernel.msgmnb=#{max}"
-
-      if curr < max
-        if Process.uid == 0
-          STDERR.puts "*** running `#{cmd}` for you to prevent losing events (currently: #{curr} bytes)"
-          system(cmd)
-        else
-          STDERR.puts "*** run `sudo #{cmd}` to prevent losing events (currently: #{curr} bytes)"
-        end
-      end
-    end
-  end
-
-  # Look for any message queues pairs (pid/-pid) that no longer have an
-  # associated process alive, and remove them.
-  #
-  # Returns nothing.
-  def self.cleanup_queues
-    if (pids = `ps ax -o pid`.split("\n").map{ |p| p.strip.to_i }).any?
-      ipcs = `ipcs -q`.split("\n").grep(/^(q|0x)/).map{ |line| line[/(0x[a-f0-9]+)/,1] }
-      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
-  end
-
-  # Public: The Fixnum pid of the traced process.
-  attr_reader   :pid
-
-  # Public: The IO where tracing output is written (default: STDOUT).
-  attr_accessor :out
-
-  # Public: The timeout before giving up on attaching/detaching to a process.
-  attr_accessor :timeout
-
-  # The String prefix used on nested method calls (default: ' ').
-  attr_accessor :prefix
-
-  # The Boolean flag for showing how long method calls take (default: true).
-  attr_accessor :show_duration
-
-  # The Boolean flag for showing the timestamp when method calls start (default: false).
-  attr_accessor :show_time
-
-  # Create a new tracer
-  #
-  # pid - The String of Fixnum process id
-  #
-  # Returns a tracer.
-  def initialize(pid)
-    begin
-      raise ArgumentError unless pid
-      @pid = pid.to_i
-      raise ArgumentError unless @pid > 0
-      Process.kill(0, @pid)
-    rescue TypeError, ArgumentError
-      raise ArgumentError, 'pid required'
-    rescue Errno::ESRCH
-      raise ArgumentError, 'invalid pid'
-    rescue Errno::EPERM
-      raise ArgumentError, 'could not signal process, are you running as root?'
-    end
-
-    path = "/tmp/rbtrace-#{@pid}.sock"
-    @sock = Socket.new Socket::AF_UNIX, Socket::SOCK_DGRAM, 0
-    @sockaddr = Socket.pack_sockaddr_un(path)
-    @sock.bind(@sockaddr)
-    FileUtils.chmod 0666, path
-    at_exit{ FileUtils.rm(path) if File.exists?(path) }
-
-    5.times do
-      signal
-      sleep 0.15 # wait for process to create msgqs
-
-      @qo = MsgQ.msgget(-pid, 0666)
-
-      break if @qo > -1
-    end
-
-    if @qo == -1
-      raise ArgumentError, 'pid is not listening for messages, did you `require "rbtrace"`'
-    end
-
-    @klasses = {}
-    @methods = {}
-    @tracers = Hash.new{ |h,k|
-      h[k] = {
-        :query => nil,
-        :times => [],
-        :names => [],
-        :exprs => {},
-        :last => false,
-        :arglist => false
-      }
-    }
-    @max_nesting = @last_nesting = @nesting = 0
-    @last_tracer = nil
-
-    @timeout = 5
-
-    @out = STDOUT
-    @out.sync = true
-    @prefix = '  '
-    @printed_newline = true
-
-    @show_time = false
-    @show_duration = true
-    @watch_slow = false
-
-    attach
-  end
-
-  # Watch for method calls slower than a threshold.
-  #
-  # msec - The Fixnum threshold in milliseconds
-  #
-  # Returns nothing.
-  def watch(msec, cpu_only=false)
-    @watch_slow = true
-    send_cmd(cpu_only ? :watchcpu : :watch, msec)
-  end
-
-  # Turn on the firehose (show all method calls).
-  #
-  # Returns nothing.
-  def firehose
-    send_cmd(:firehose)
-  end
-
-  # Turn on dev mode.
-  #
-  # Returns nothing.
-  def devmode
-    send_cmd(:devmode)
-  end
-
-  # Fork the process and return the copy's pid.
-  #
-  # Returns a Fixnum pid.
-  def fork
-    send_cmd(:fork)
-    if wait('for fork', 30){ !!@forked_pid }
-      @forked_pid
-    else
-      STDERR.puts '*** timed out waiting for fork'
-    end
-  end
-
-  # Evaluate some ruby code.
-  #
-  # Returns the String result.
-  def eval(code)
-    if (err = valid_syntax?(code)) != true
-      raise ArgumentError, "#{err.class} for expression #{code.inspect}"
-    end
-
-    send_cmd(:eval, code)
-
-    if wait('for eval response', 15){ !!@eval_result }
-      @eval_result
-    else
-      STDERR.puts '*** timed out waiting for eval response'
-    end
-  end
-
-  # Turn on GC tracing.
-  #
-  # Returns nothing.
-  def gc
-    send_cmd(:gc)
-  end
-
-  # Restrict slow tracing to a specific list of methods.
-  #
-  # methods - The String or Array of method selectors.
-  #
-  # Returns nothing.
-  def add_slow(methods)
-    add(methods, true)
-  end
-
-  # Add tracers for the given list of methods.
-  #
-  # methods - The String or Array of method selectors to trace.
-  #
-  # Returns nothing.
-  def add(methods, slow=false)
-    Array(methods).each do |func|
-      func = func.strip
-      next if func.empty?
-
-      if func =~ /^(.+?)\((.+)\)$/
-        name, args = $1, $2
-        args = args.split(',').map{ |a| a.strip }
-      end
-
-      send_cmd(:add, name || func, slow)
-
-      if args and args.any?
-        args.each do |arg|
-          if (err = valid_syntax?(arg)) != true
-            raise ArgumentError, "#{err.class} for expression #{arg.inspect} in method #{func.inspect}"
-          end
-          if arg =~ /^@/ and arg !~ /^@[_a-z][_a-z0-9]+$/i
-            # arg[0]=='@' means ivar, but if this is an expr
-            # we can hack a space in front so it gets eval'd instead
-            arg = " #{arg}"
-          end
-          send_cmd(:addexpr, arg)
-        end
-      end
-    end
-  end
-
-  # Attach to the process.
-  #
-  # Returns nothing.
-  def attach
-    send_cmd(:attach, Process.pid)
-    if wait('to attach'){ @attached == true }
-      STDERR.puts "*** attached to process #{pid}"
-    else
-      raise ArgumentError, 'process already being traced?'
-    end
-  end
-
-  # Detach from the traced process.
-  #
-  # Returns nothing.
-  def detach
-    begin
-      send_cmd(:detach)
-    rescue Errno::ESRCH
-    end
-
-    newline
-
-    if wait('to detach cleanly'){ @attached == false }
-      newline
-      STDERR.puts "*** detached from process #{pid}"
-    else
-      newline
-      STDERR.puts "*** could not detach cleanly from process #{pid}"
-    end
-  rescue Errno::EINVAL, Errno::EIDRM
-    newline
-    STDERR.puts "*** process #{pid} is gone"
-    # STDERR.puts "*** #{$!.inspect}"
-    # STDERR.puts $!.backtrace.join("\n  ")
-  rescue Interrupt, SignalException
-    retry
-  end
-
-  # Process events from the traced process.
-  #
-  # Returns nothing.
-  def recv_loop
-    while true
-      # block until a message arrives
-      process_line(recv_cmd)
-
-      # process any remaining messages
-      recv_lines
-    end
-  rescue Errno::EINVAL, Errno::EIDRM
-    # process went away
-  end
-
-  # Process events from the traced process, without blocking if
-  # there is nothing to do. This is a useful way to drain the buffer
-  # so messages do not accumulate in kernel land.
-  #
-  # Returns nothing.
-  def recv_lines
-    50.times do
-      break unless line = recv_cmd(false)
-      process_line(line)
-    end
-  end
-
-  def puts(arg=nil)
-    @printed_newline = true
-    arg ? @out.puts(arg) : @out.puts
-  end
-
-  private
-
-  def signal
-    Process.kill 'URG', @pid
-  end
-
-  # Process incoming events until either a timeout or a condition becomes true.
-  #
-  # time - The Fixnum timeout in seconds.
-  # block - The Block that is checked every 50ms until it returns true.
-  #
-  # Returns true when the condition was met, or false on a timeout.
-  def wait(reason, time=@timeout)
-    wait = 0.05 # polling interval
-
-    (time/wait).to_i.times do
-      begin
-        recv_lines
-        sleep(wait)
-        begin
-          signal
-        rescue Errno::ESRCH
-          break
-        end
-        time -= wait
-
-        return true if yield
-      rescue Interrupt
-        STDERR.puts "*** waiting #{reason} (#{time.to_i}s left)"
-        retry
-      end
-    end
-
-    false
-  end
-
-  def send_cmd(*cmd)
-    begin
-      msg = cmd.to_msgpack
-      raise ArgumentError, 'command is too long' if msg.bytesize > MsgQ::EventMsg::BUF_SIZE
-      MsgQ::EventMsg.send_cmd(@qo, msg)
-    rescue Errno::EINTR
-      retry
-    end
-    signal
-    recv_lines
-  end
-
-  def recv_cmd(block=true)
-    if block
-      @sock.recv(65536)
-    else
-      @sock.recv_nonblock(65536)
-    end
-  rescue Errno::EAGAIN
-    nil
-  end
-
-  def valid_syntax?(code)
-    begin
-      Kernel.eval("#{code}\nBEGIN {return true}", nil, 'rbtrace_expression', 0)
-    rescue Exception => e
-      e
-    end
-  end
-
-  def print(arg)
-    @printed_newline = false
-    @out.print(arg)
-  end
-
-  def newline
-    puts unless @printed_newline
-    @printed_newline = true
-  end
-
-  def parse_cmd(line)
-    unpacker = MessagePack::Unpacker.new
-    unpacker.feed(line)
-
-    obj = nil
-    unpacker.each{|o| obj = o; break }
-    obj
-  end
-
-  def process_line(line)
-    return unless cmd = parse_cmd(line)
-    event = cmd.shift
-
-    case event
-    when 'during_gc'
-      sleep 0.01
-      signal
-      return
-
-    when 'attached'
-      tracer_pid, = *cmd
-      if tracer_pid != Process.pid
-        STDERR.puts "*** process #{pid} is already being traced (#{tracer_pid} != #{Process.pid})"
-        exit!(-1)
-      end
-
-      @attached = true
-      return
-
-    when 'detached'
-      tracer_pid, = *cmd
-      if tracer_pid != Process.pid
-        STDERR.puts "*** process #{pid} detached #{tracer_pid}, but we are #{Process.pid}"
-      else
-        @attached = false
-      end
-
-      return
-    end
-
-    unless @attached
-      STDERR.puts "*** got #{event} before attaching"
-      return
-    end
-
-    case event
-    when 'forked'
-      pid, = *cmd
-      @forked_pid = pid
-
-    when 'evaled'
-      res, = *cmd
-      @eval_result = res
-
-    when 'mid'
-      mid, name = *cmd
-      @methods[mid] = name
-
-    when 'klass'
-      kid, name = *cmd
-      @klasses[kid] = name
-
-    when 'add'
-      tracer_id, query = *cmd
-      if tracer_id == -1
-        STDERR.puts "*** unable to add tracer for #{query}"
-      else
-        @tracers.delete(tracer_id)
-        @tracers[tracer_id][:query] = query
-      end
-
-    when 'newexpr'
-      tracer_id, expr_id, expr = *cmd
-      tracer = @tracers[tracer_id]
-
-      if expr_id > -1
-        tracer[:exprs][expr_id] = expr.strip
-      end
-
-    when 'exprval'
-      tracer_id, expr_id, val = *cmd
-
-      tracer = @tracers[tracer_id]
-      expr = tracer[:exprs][expr_id]
-
-      if tracer[:arglist]
-        print ', '
-      else
-        print '('
-      end
-
-      print "#{expr}="
-      print val
-      tracer[:arglist] = true
-
-    when 'call','ccall'
-      time, tracer_id, mid, is_singleton, klass = *cmd
-
-      tracer = @tracers[tracer_id]
-      klass = @klasses[klass]
-      name = klass ? "#{klass}#{ is_singleton ? '.' : '#' }" : ''
-      name += @methods[mid] || '(unknown)'
-
-      tracer[:times] << time
-      tracer[:names] << name
-
-      if @last_tracer and @last_tracer[:arglist]
-        print ')'
-        @last_tracer[:arglist] = false
-      end
-      newline
-      if @show_time
-        t = Time.at(time/1_000_000)
-        print t.strftime("%H:%M:%S.")
-        print "%06d " % (time - t.to_f*1_000_000).round
-      end
-      print @prefix*@nesting if @nesting > 0
-      print name
-
-      @nesting += 1
-      @max_nesting = @nesting if @nesting > @max_nesting
-      @last_nesting = @nesting
-      @last_tracer = tracer
-      tracer[:last] = "#{name}:#{@nesting-1}"
-
-    when 'return','creturn'
-      time, tracer_id = *cmd
-      tracer = @tracers[tracer_id]
-
-      @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}:#{@nesting}"
-
-        print ')' if @last_tracer and @last_tracer[:arglist]
-
-        unless tracer == @last_tracer and @last_tracer[:last] == "#{name}:#{@nesting}"
-          newline
-          print ' '*16 if @show_time
-          print @prefix*@nesting if @nesting > 0
-          print name
-        end
-        print ' <%f>' % (diff/1_000_000.0) if @show_duration
-        newline
-
-        if @nesting == 0 and @max_nesting > 1
-          # unless tracer == @last_tracer and @last_tracer[:last] == name
-            puts
-          # end
-        end
-      end
-
-      tracer[:arglist] = false
-      @last_nesting = @nesting
-
-    when 'slow', 'cslow'
-      time, diff, nesting, mid, is_singleton, klass = *cmd
-
-      klass = @klasses[klass]
-      name = klass ? "#{klass}#{ is_singleton ? '.' : '#' }" : ''
-      name += @methods[mid] || '(unknown)'
-
-      newline
-      nesting = @nesting if @nesting > 0
-
-      if @show_time
-        t = Time.at(time/1_000_000)
-        print t.strftime("%H:%M:%S.")
-        print "%06d " % (time - t.to_f*1_000_000).round
-      end
-
-      print @prefix*nesting if nesting > 0
-      print name
-      if @show_duration
-        print ' '
-        print "<%f>" % (diff/1_000_000.0)
-      end
-      puts
-      puts if nesting == 0 and @max_nesting > 1
-
-      @max_nesting = nesting if nesting > @max_nesting
-      @last_nesting = nesting
-
-    when 'gc_start'
-      time, = *cmd
-      @gc_start = time
-      print 'garbage_collect'
-
-    when 'gc_end'
-      time, = *cmd
-      diff = time - @gc_start
-      # if @gc_mark
-      #   mark = ((@gc_mark - @gc_start) * 100.0 / diff).to_i
-      #   print '(mark: %d%%, sweep: %d%%)' % [mark, 100-mark]
-      # end
-      print ' <%f>' % (diff/1_000_000.0) if @show_duration
-      @gc_start = nil
-      newline
-
-    when 'gc'
-      time, = *cmd
-      @gc_mark = time
-
-      unless @gc_start
-        newline
-        if @show_time
-          t = Time.at(time/1_000_000)
-          print t.strftime("%H:%M:%S.")
-          print "%06d " % (time - t.to_f*1_000_000).round
-        end
-        print @prefix*@last_nesting if @last_nesting > 0
-        print "garbage_collect"
-        puts if @watch_slow
-      end
-
-    else
-      puts "unknown event #{event}: #{cmd.inspect}"
-
-    end
-  rescue => e
-    STDERR.puts "error on #{event}: #{cmd.inspect}"
-    raise e
-  end
-
-  def self.run
-    check_msgmnb
-    cleanup_queues
-
-    parser = Trollop::Parser.new do
-      version <<-EOS
-rbtrace: like strace, but for ruby code
-  version 0.4.0
-  (c) 2013 Aman Gupta (tmm1)
-  http://github.com/tmm1/rbtrace
-EOS
-
-      banner <<-EOS
-rbtrace shows you method calls happening inside another ruby process in real time.
-
-to use rbtrace, simply `require "rbtrace"` in your ruby app.
-
-for examples and more information, see http://github.com/tmm1/rbtrace
-
-Usage:
-
-  rbtrace --exec <CMD>     # run and trace <CMD>
-  rbtrace --pid <PID+>     # trace the given process(es)
-  rbtrace --ps <CMD>       # look for running <CMD> processes to trace
-
-  rbtrace -o <FILE>        # write output to file
-  rbtrace -t               # show method call start time
-  rbtrace -n               # hide duration of each method call
-  rbtrace -r 3             # use 3 spaces to nest method calls
-
-Tracers:
-
-  rbtrace --firehose       # trace all method calls
-  rbtrace --slow=250       # trace method calls slower than 250ms
-  rbtrace --methods a b c  # trace calls to given methods
-  rbtrace --gc             # trace garbage collections
-
-  rbtrace -c io            # trace common input/output functions
-  rbtrace -c eventmachine  # trace common eventmachine functions
-  rbtrace -c my.tracer     # trace all methods listed in my.tracer
-
-Method Selectors:
-
-  sleep                    # any instance or class method named sleep
-  String#gsub              # specific instance method
-  Process.pid              # specific class method
-  Dir.                     # any class methods in Dir
-  Fixnum#                  # any instance methods of Fixnum
-
-Trace Expressions:
-
-  method(self)             # value of self at method invocation
-  method(@ivar)            # value of given instance variable
-  method(arg1, arg2)       # value of argument local variables
-  method(self.attr)        # value of arbitrary ruby expression
-  method(__source__)       # source file/line of callsite
-
-
-All Options:\n
-
-EOS
-      opt :exec,
-        "spawn new ruby process and attach to it",
-        :type => :strings,
-        :short => nil
-
-      opt :pid,
-        "pid of the ruby process to trace",
-        :type => :ints,
-        :short => '-p'
-
-      opt :ps,
-        "find any matching processes to trace",
-        :type => :string,
-        :short => nil
-
-      opt :firehose,
-        "show all method calls",
-        :short => '-f'
-
-      opt :slow,
-        "watch for method calls slower than 250 milliseconds",
-        :default => 250,
-        :short => '-s'
-
-      opt :slowcpu,
-        "watch for method calls slower than 250 milliseconds (cpu time only)",
-        :default => 250,
-        :short => nil
-
-      opt :slow_methods,
-        "method(s) to restrict --slow to",
-        :type => :strings
-
-      opt :methods,
-        "method(s) to trace (valid formats: sleep String#gsub Process.pid Kernel# Dir.)",
-        :type => :strings,
-        :short => '-m'
-
-      opt :gc,
-        "trace garbage collections"
-
-      opt :start_time,
-        "show start time for each method call",
-        :short => '-t'
-
-      opt :no_duration,
-        "hide time spent in each method call",
-        :default => false,
-        :short => '-n'
-
-      opt :output,
-        "write trace to filename",
-        :type => String,
-        :short => '-o'
-
-      opt :append,
-        "append to output file instead of overwriting",
-        :short => '-a'
-
-      opt :prefix,
-        "prefix nested method calls with N spaces",
-        :default => 2,
-        :short => '-r'
-
-      opt :config,
-        "config file",
-        :type => :strings,
-        :short => '-c'
-
-      opt :devmode,
-        "assume the ruby process is reloading classes and methods"
-
-      opt :fork,
-        "fork a copy of the process for debugging (so you can attach gdb.rb)"
-
-      opt :eval,
-        "evaluate a ruby expression in the process",
-        :type => String,
-        :short => '-e'
-
-      opt :backtrace,
-        "get lines from the current backtrace in the process",
-        :type => :int
-
-      opt :wait,
-        "seconds to wait before attaching to process",
-        :default => 0,
-        :short => nil
-
-      opt :timeout,
-        "seconds to wait before giving up on attach/detach",
-        :default => 5
-    end
-
-    opts = Trollop.with_standard_exception_handling(parser) do
-      raise Trollop::HelpNeeded if ARGV.empty?
-      parser.stop_on '--exec'
-      parser.parse(ARGV)
-    end
-
-    if ARGV.first == '--exec'
-      ARGV.shift
-      opts[:exec_given] = true
-      opts[:exec] = ARGV.dup
-      ARGV.clear
-    end
-
-    unless %w[ fork eval backtrace slow slowcpu firehose methods config gc ].find{ |n| opts[:"#{n}_given"] }
-      $stderr.puts "Error: --slow, --slowcpu, --gc, --firehose, --methods or --config required."
-      $stderr.puts "Try --help for help."
-      exit(-1)
-    end
-
-    if opts[:fork_given] and opts[:pid].size != 1
-      parser.die :fork, '(can only be invoked with one pid)'
-    end
-
-    if opts[:exec_given]
-      if opts[:pid_given]
-        parser.die :exec, '(cannot exec and attach to pid)'
-      end
-      if opts[:fork_given]
-        parser.die :fork, '(cannot fork inside newly execed process)'
-      end
-    end
-
-    methods, smethods = [], []
-
-    if opts[:methods_given]
-      methods += opts[:methods]
-    end
-    if opts[:slow_methods_given]
-      smethods += opts[:slow_methods]
-    end
-
-    if opts[:config_given]
-      Array(opts[:config]).each do |config|
-        file = [
-          config,
-          File.expand_path("../../tracers/#{config}.tracer", __FILE__)
-        ].find{ |f| File.exists?(f) }
-
-        unless file
-          parser.die :config, '(file does not exist)'
-        end
-
-        File.readlines(file).each do |line|
-          line.strip!
-          next if line =~ /^#/
-          next if line.empty?
-
-          methods << line
-        end
-      end
-    end
-
-    tracee = nil
-
-    if opts[:ps_given]
-      list = `ps aux`.split("\n")
-      filtered = list.grep(Regexp.new opts[:ps])
-      filtered.reject! do |line|
-        line =~ /^\w+\s+(#{Process.pid}|#{Process.ppid})\s+/ # cannot trace self
-      end
-
-      if filtered.size > 0
-        max_len = filtered.size.to_s.size
-
-        STDERR.puts "*** found #{filtered.size} processes matching #{opts[:ps].inspect}"
-        filtered.each_with_index do |line, i|
-          STDERR.puts "   [#{(i+1).to_s.rjust(max_len)}]   #{line.strip}"
-        end
-        STDERR.puts   "   [#{'0'.rjust(max_len)}]   all #{filtered.size} processes"
-
-        while true
-          STDERR.sync = true
-          STDERR.print "*** trace which processes? (0/1,4): "
-
-          begin
-            input = gets
-          rescue Interrupt
-            exit 1
-          end
-
-          if input =~ /^(\d+,?)+$/
-            if input.strip == '0'
-              pids = filtered.map do |line|
-                line.split[1].to_i
-              end
-            else
-              indices = input.split(',').map(&:to_i)
-              pids = indices.map do |i|
-                if i > 0 and line = filtered[i-1]
-                  line.split[1].to_i
-                end
-              end
-            end
-
-            unless pids.include?(nil)
-              opts[:pid] = pids
-              break
-            end
-          end
-        end
-      else
-        STDERR.puts "*** could not find any processes matching #{opts[:ps].inspect}"
-        exit 1
-      end
-    end
-
-    if opts[:exec_given]
-      tracee = fork{
-        Process.setsid
-        ENV['RUBYOPT'] = "-r#{File.expand_path('../../lib/rbtrace',__FILE__)}"
-        exec(*opts[:exec])
-      }
-      STDERR.puts "*** spawned child #{tracee}: #{opts[:exec].inspect[1..-2]}"
-
-      if (secs = opts[:wait]) > 0
-        STDERR.puts "*** waiting #{secs} seconds for child to boot up"
-        sleep secs
-      end
-
-    elsif opts[:pid].size <= 1
-      tracee = opts[:pid].first
-
-    else
-      tracers = []
-
-      opts[:pid].each do |pid|
-        if child = fork
-          tracers << child
-        else
-          Process.setpgrp
-          STDIN.reopen '/dev/null'
-          $0 = "rbtrace -p #{pid} (parent: #{Process.ppid})"
-
-          opts[:output] += ".#{pid}" if opts[:output]
-          tracee = pid
-
-          # fall through and start tracing
-          break
-        end
-      end
-
-      if tracee.nil?
-        # this is the parent
-        while true
-          begin
-            break if tracers.empty?
-            if pid = Process.wait
-              tracers.delete(pid)
-            end
-          rescue Interrupt, SignalException
-            STDERR.puts "*** waiting on child tracers: #{tracers.inspect}"
-            tracers.each do |pid|
-              begin
-                Process.kill 'INT', pid
-              rescue Errno::ESRCH
-              end
-            end
-          end
-        end
-
-        exit!
-      end
-    end
-
-    if out = opts[:output]
-      output = File.open(out, opts[:append] ? 'a+' : 'w')
-      output.sync = true
-    end
-
-    begin
-      begin
-        tracer = RBTracer.new(tracee)
-      rescue ArgumentError => e
-        parser.die :pid, "(#{e.message})"
-      end
-
-      if opts[:fork_given]
-        pid = tracer.fork
-        STDERR.puts "*** forked off a busy looping copy at #{pid} (make sure to kill -9 it when you're done)"
-
-      elsif opts[:backtrace_given]
-        num = opts[:backtrace]
-        code = "caller.first(#{num}).join('|')"
-
-        if res = tracer.eval(code)
-          tracer.puts res[1..-2].split('|').join("\n  ")
-        end
-
-      elsif opts[:eval_given]
-        if res = tracer.eval(code = opts[:eval])
-          tracer.puts ">> #{code}"
-          tracer.puts "=> #{res}"
-        end
-
-      else
-        tracer.out = output if output
-        tracer.timeout = opts[:timeout] if opts[:timeout] > 0
-        tracer.prefix = ' ' * opts[:prefix]
-        tracer.show_time = opts[:start_time]
-        tracer.show_duration = !opts[:no_duration]
-
-        tracer.devmode if opts[:devmode_given]
-        tracer.gc if opts[:gc_given]
-
-        if opts[:firehose_given]
-          tracer.firehose
-        else
-          tracer.add(methods)       if methods.any?
-          if opts[:slow_given] || opts[:slowcpu_given]
-            tracer.watch(opts[:slowcpu_given] ? opts[:slowcpu] : opts[:slow], opts[:slowcpu_given])
-            tracer.add_slow(smethods) if smethods.any?
-          end
-        end
-        begin
-          tracer.recv_loop
-        rescue Interrupt, SignalException
-        end
-      end
-    ensure
-      if tracer
-        tracer.detach
-      end
-
-      if opts[:exec_given]
-        STDERR.puts "*** waiting on spawned child #{tracee}"
-        Process.kill 'TERM', tracee
-        Process.waitpid(tracee)
-      end
-    end
-  end
-end
-
-RBTracer.run
+RBTraceCLI.run