minstrel 0.1.20101115013901 → 0.2.20101115030455

data/README.textile

@@ -3,11 +3,19 @@ h1. Ruby Minstrel
 Minstrel allows you to wrap every method call for a given class so you can more
 easily observe how a class and its methods are being used.
 
+h2. Get it
+
+* gem install minstrel
+* or download versions here: http://rubygems.org/gems/minstrel
+* or github: https://github.com/jordansissel/ruby-minstrel
+
 h2. Why?
 
 Fun. Also, sometimes ruby-prof and similar tools are overkill when I am trying
 to debug or dig into how a piece of code works.
 
+It's a lot like strace/tcpdump/dtrace for ruby, or aims to be, anyway.
+
 h2. Examples
 
 h3. From the commandline

data/bin/minstrel

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+#
+require "rubygems"
+require "minstrel"
+
+load ARGV[0]

data/lib/minstrel.rb

@@ -18,11 +18,18 @@
 module Minstrel; class Instrument
   attr_accessor :counter
 
+  class << self
+    @@deferred_wraps = {}
+  end
+
   # Put methods we must not be wrapping here.
-  DONOTWRAP = [Kernel, Object, Module, Class, Minstrel::Instrument].collect do |obj|
+  #DONOTWRAP = #[Kernel, Object, Module, Class,
+  DONOTWRAP = [Minstrel::Instrument].collect do |obj|
     obj.methods.collect { |m| m.to_sym }
   end.flatten
   DONOTWRAP << :to_sym
+  DONOTWRAP << :respond_to?
+  DONOTWRAP << :send
 
   # Wrap a class's instance methods with your block.
   # The block will be called with 4 arguments, and called
@@ -33,35 +40,118 @@ module Minstrel; class Instrument
   #   * method - the method (symbol) being called
   #   * *args - the arguments (array) passed to this method.
   def wrap(klass, &block)
+    #puts "Instrumenting #{klass.name} with #{block.inspect}"
     instrumenter = self
-    self.counter = 0
 
     klass.instance_methods.each do |method|
       next if DONOTWRAP.include?(method.to_sym)
       klass.class_eval do
         orig_method = "#{method}_original(wrapped)".to_sym
         alias_method orig_method, method.to_sym
-        instrumenter.counter += 1
         method = method.to_sym
+        #block.call(:wrap, klass, method)
         define_method(method) do |*args, &argblock|
+          puts "call #{klass.name}##{method}(#{args.inspect}, #{block_given?})"
           block.call(:enter, klass, method, *args)
-          val = send(orig_method, *args, &argblock)
-          block.call(:exit, klass, method, *args)
+          exception = false
+          begin
+            m = self.method(orig_method)
+            val = m.call(*args, &argblock)
+          rescue => e
+            exception = e
+          end
+          if exception
+            block.call(:exit_exception, klass, method, *args)
+            raise e if exception
+          else
+            block.call(:exit, klass, method, *args)
+          end
           return val
         end
       end # klass.class_eval
     end # klass.instance_methods.each
+
+    klass.methods.each do |method|
+      next if DONOTWRAP.include?(method.to_sym)
+      klass.instance_eval do
+        orig_method = "#{method}_original(classwrapped)".to_sym
+        (class << self; self; end).instance_eval do
+          begin
+            alias_method orig_method, method.to_sym
+          rescue NameError => e
+            # No such method, strange but true.
+            orig_method = self.method(method.to_sym)
+          end
+          method = method.to_sym
+          define_method(method) do |*args, &argblock|
+            block.call(:class_enter, klass, method, *args)
+            exception = false
+            begin
+              if orig_method.is_a?(Symbol)
+                val = send(orig_method, *args, &argblock)
+              else
+                val = orig_method.call(*args, &argblock)
+              end
+            rescue => e
+              exception = e
+            end
+            if exception
+              block.call(:class_exit_exception, klass, method, *args)
+              raise e if exception
+            else
+              block.call(:class_exit, klass, method, *args)
+            end
+            return val
+          end
+        end
+        #block.call(:class_wrap, klass, method, self.method(method))
+      end # klass.class_eval
+    end # klass.instance_methods.each
   end # def wrap
+
+  def wrap_classname(klassname, &block)
+    begin
+      klass = eval(klassname)
+      self.wrap(klass, &block) 
+      return true
+    rescue NameError => e
+      @@deferred_wraps[klassname] = block
+    end
+    return false
+  end
+
+  def self.wrap_require
+    Kernel.class_eval do
+      alias_method :old_require, :require
+      def require(*args)
+        return Minstrel::Instrument::instrumented_require(*args)
+      end
+    end
+  end
+
+  def self.instrumented_require(*args)
+    ret = old_require(*args)
+    klasses = @@deferred_wraps.keys
+    klasses.each do |klassname|
+      block = @@deferred_wraps[klassname]
+      instrument = Minstrel::Instrument.new
+      if instrument.wrap_classname(klassname, &block)
+        puts "Wrap of #{klassname} successful"
+        @@deferred_wraps.delete(klassname)
+      end
+    end
+    return ret
+  end
 end; end # class Minstrel::Instrument
 
+Minstrel::Instrument.wrap_require
+
 # Provide a way to instrument a class using the command line:
 # RUBY_INSTRUMENT=String ruby -rminstrel ./your/program
 if ENV["RUBY_INSTRUMENT"]
   ENV["RUBY_INSTRUMENT"].split(",").each do |klassname|
     instrument = Minstrel::Instrument.new 
-    klass = eval(klassname)
-    instrument.wrap(klass) do |point, klass, method, *args|
-      next if point == :end
+    instrument.wrap_classname(klassname) do |point, klass, method, *args|
       puts "#{point} #{klass.name}##{method}(#{args.inspect})"
     end
   end

data/minstrel.gemspec

@@ -8,11 +8,13 @@ Gem::Specification.new do |spec|
 
   rev = Time.now.strftime("%Y%m%d%H%M%S")
   spec.name = "minstrel"
-  spec.version = "0.1.#{rev}"
+  spec.version = "0.2.#{rev}"
   spec.summary = "minstrel - a ruby instrumentation tool"
   spec.description = "Instrument class methods"
   spec.files = files
   spec.require_paths << "lib"
+  spec.bindir = "bin"
+  spec.executables << "minstrel"
 
   spec.author = "Jordan Sissel"
   spec.email = "jls@semicomplete.com"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: minstrel
 version: !ruby/object:Gem::Version 
-  hash: 40202230027777
+  hash: 40202230060921
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 20101115013901
-  version: 0.1.20101115013901
+  - 2
+  - 20101115030455
+  version: 0.2.20101115030455
 platform: ruby
 authors: 
 - Jordan Sissel
@@ -21,8 +21,8 @@ dependencies: []
 
 description: Instrument class methods
 email: jls@semicomplete.com
-executables: []
-
+executables: 
+- minstrel
 extensions: []
 
 extra_rdoc_files: []
@@ -31,6 +31,7 @@ files:
 - ./lib/minstrel.rb
 - ./README.textile
 - ./minstrel.gemspec
+- bin/minstrel
 has_rdoc: true
 homepage: https://github.com/jordansissel/ruby-minstrel
 licenses: []