ruby-dtrace 0.0.6 → 0.2.8

data/lib/dtrace/provider/klass.rb

@@ -0,0 +1,33 @@
+#
+# Ruby-Dtrace
+# (c) 2009 Chris Andrews <chris@nodnol.org>
+#
+
+class Dtrace
+  class Provider
+
+    # A dynamically-created DTrace provider class. 
+    #
+    class Klass
+      
+      def initialize(dof, probes)
+        # must stash a reference to the DOF in the provider:
+        # on OSX at least, freeing the generated DOF removes
+        # the probes from the kernel. 
+        @dof = dof
+        @probes = probes
+      end
+      
+      def method_missing(probe, *args, &block)
+        if @probes[probe].nil?
+          raise Dtrace::Exception.new("no such probe in #{self.to_s}: #{probe.to_s}")
+        else 
+          if @probes[probe].is_enabled?
+            block.call @probes[probe]
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/dtrace/provider/probedef.rb

@@ -0,0 +1,24 @@
+#
+# Ruby-Dtrace
+# (c) 2008 Chris Andrews <chris@nodnol.org>
+#
+
+class Dtrace
+  class Provider
+    class ProbeDef
+      attr_reader :name, :function
+      attr_accessor :args
+
+      def initialize(name, function)
+        @name = name.to_sym
+        @function = function.to_s
+        @args = []
+      end
+
+      def argc
+        @args.length
+      end
+
+    end
+  end
+end

data/lib/{dtracerecord.rb → dtrace/record.rb}

@@ -4,6 +4,8 @@
 #
 # A scalar DTrace record. Its value is as set by the DTrace action
 # which triggered it.
-class DtraceRecord
-  attr_accessor :value
+class Dtrace
+  class Record
+    attr_accessor :value
+  end
 end

data/lib/{dtracestackrecord.rb → dtrace/stackrecord.rb}

@@ -16,14 +16,16 @@
 #            "libruby.1.dylib`rb_apply+0x392",
 #            "libruby.1.dylib`rb_eval_string_wrap+0xe82"]>
 #
-class DtraceStackRecord
-  attr_reader :value
+class Dtrace
+  class StackRecord
+    attr_reader :value
 
-  # Given a stack as a string returned from DTrace, set the value of
-  # this record to a list of stack frames.
-  def parse(raw)
-    frames = raw.split(/\n/)
-    @value = frames.map {|f| f.lstrip }.select {|f| f.length > 0 }
-  end
+    # Given a stack as a string returned from DTrace, set the value of
+    # this record to a list of stack frames.
+    def parse(raw)
+      frames = raw.split(/\n/)
+      @value = frames.map {|f| f.lstrip }.select {|f| f.length > 0 }
+    end
 
+  end
 end

data/lib/dtrace/version.rb

@@ -0,0 +1,9 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+
+class Dtrace
+  VERSION = '0.2.8'
+end
+

data/lib/dtraceconsumer.rb

@@ -3,171 +3,7 @@
 # (c) 2007 Chris Andrews <chris@nodnol.org>
 #
 
-# A DtraceConsumer provides access to the data produced by the running
-# D program. Having compiled and executed a D program, you typically
-# create a DtraceConsumer, and wait for data. 
-#
-# You can either wait indefinitely for data, or consume all the data
-# waiting and then stop: if your D program consists of only of
-# aggregations, returned by printa() actions in the END block, this
-# will be the best approach. If you have a mix of trace() and printf()
-# actions elsewhere, you'll probably want to wait until interrupted,
-# the D program itself exits, or your program decides it has collected
-# enough data.
-#
-# The two approaches are implemented by the +consume+ and
-# +consume_once+ methods.
-#
-# The +consume+ and +consume_once+ methods accept a block to which is
-# yielded complete DtraceData objects, one for each probe which fires.
-#
-# You must have already started tracing when you call +consume+ or
-# +consume_once+, so the general structure will look like:
-#
-#   t = Dtrace.new
-#   progtext = "..."
-#   prog = t.compile progtext
-#   prog.execute
-#   t.go 
-#   c = DtraceConsumer.new(t)
-#   c.consume_once do |d|
-#     # handle DtraceData objects
-#     # ...
-#     # get bored:
-#     c.finish
-#   end
-
-class DtraceConsumer
-
-  def initialize(t)
-    @t = t
-    @done = false
-    @types = []
-
-    @drophandler = nil
-    @errhandler = nil
-  end
-
-  private
-
-  # The consumer callbacks:
-  #
-  # DtraceRecDesc   -> rec_consumer
-  # DtraceProbeData -> probe_consumer
-  # DtraceBufData   -> buf_consumer
-  #
-  # We expect a sequence of calls to these procs, and we accumulate
-  # data in the @curr DtraceData based on this:
-  #
-  # DtraceProbeData (initial callback for a probe firing)
-  # DtraceRecDesc 
-  # ...
-  # DtraceRecDesc = nil (end of data)
-  #
-  
-  def rec_consumer(block)
-    proc do |rec|
-      if rec
-        @curr.add_recdata(rec)
-      else
-        @curr.finish
-        block.call(@curr)
-        @curr = DtraceData.new(@types)
-      end
-    end
-  end
-  
-  def probe_consumer
-    proc do |probe|
-      @curr.add_probedata(probe)
-    end
-  end
-
-  def buf_consumer
-    proc do |buf|
-      @curr.add_bufdata(buf)
-    end
-  end
-
-  def filter_types(types)
-    @types = types
-    @curr = DtraceData.new(types)
-  end
-  
-  public
-
-  # Provide a proc which will be executed when a drop record is
-  # received.
-  def drophandler(&block)
-    @drophandler = block
-    @t.drop_consumer(proc do |drop|
-                       if @drophandler
-                         @drophandler.call(drop)
-                       end
-                     end)
-  end
-
-  # Provide a proc which will be executed when an error record is
-  # received.
-  def errhandler(&block)
-    @errhandler = block
-    @t.err_consumer(proc do |err|
-                      if @errhandler
-                        @errhandler.call(err)
-                      end
-                    end)
-  end
-
-  # Signals that the client wishes to stop consuming trace data. 
-  def finish
-    @t.stop
-    @done = true
-  end
-  
-  # Waits for data from the D program, and yields the records returned
-  # to the block given. Returns when the D program exits.
-  #
-  # Pass a list of classes to restrict the types of data returned,
-  # from:
-  #
-  # * DtraceRecord
-  # * DtracePrintfRecord
-  # * DtraceAggregateSet
-  # * DtraceStackRecord
-  #
-  def consume(*types, &block)
-    filter_types(types)
-    @t.buf_consumer(buf_consumer)
-    begin
-      while(true) do
-        @t.sleep
-        work = @t.work(probe_consumer, rec_consumer(block))
-        if (@done || work > 0)
-          break
-        end
-      end
-    ensure
-      @t.stop
-      @t.work(probe_consumer)
-    end
-  end
-  
-  # Yields the data waiting from the current program, then returns.
-  #
-  # Pass a list of classes to restrict the types of data returned,
-  # from:
-  #
-  # * DtraceRecord
-  # * DtracePrintfRecord
-  # * DtraceAggregateSet
-  # * DtraceStackRecord
-  #
-  def consume_once(*types, &block)
-    filter_types(types)
-    @t.buf_consumer(buf_consumer)
-    @t.stop
-    @t.work(probe_consumer, rec_consumer(block))
-  end
-  
-end
+require 'dtrace/consumer'
 
+# Interface preservation - see Dtrace::Consumer.
+class DtraceConsumer < Dtrace::Consumer; end

data/plugin/dtrace/lib/dtracer.rb

@@ -15,7 +15,7 @@ class Dtracer
       @d = Dtrace.new
       @d.setopt("aggsize", "4m")
       @d.setopt("bufsize", "4m")
-    rescue DtraceException => e
+    rescue Dtrace::Exception => e
       @logger.warn("DTrace start setup: #{e.message}")
       return
     end
@@ -24,7 +24,7 @@ class Dtracer
       prog = @d.compile(@dprogram, pid.to_s)
       prog.execute
       @d.go
-    rescue DtraceException => e
+    rescue Dtrace::Exception => e
       @logger.warn("DTrace start compile: #{e.message}")
     end
   end
@@ -35,11 +35,11 @@ class Dtracer
 
     dtrace_data = nil
     begin
-      c = DtraceConsumer.new(@d)
+      c = Dtrace::Consumer.new(@d)
       c.consume_once do |d|
         dtrace_data = d
       end
-    rescue DtraceException => e
+    rescue Dtrace::Exception => e
       @logger.warn("DTrace end: #{e.message}")
     end
     

data/test/disabled_probe_effect.txt

@@ -0,0 +1,19 @@
+solaris-devx:~/ruby-dtrace-dof/ruby-dtrace chris$ ruby -Iext:lib test/test_disabled_probe_effect.rb
+Loaded suite test/test_disabled_probe_effect
+Started
+      user     system      total        real
+noprobes:  0.020000   0.020000   0.040000 (  0.042108)
+disabled:  0.120000   0.110000   0.230000 (  0.231237)
+enabled:   2.670000   0.260000   2.930000 (  2.940411)
+.
+Finished in 3.220336 seconds.
+
+1 tests, 1 assertions, 0 failures, 0 errors
+
+merge Dtrace::Probe and Dtrace::Stub:
+
+Started
+      user     system      total        real
+noprobes:  0.000000   0.010000   0.010000 (  0.020863)
+disabled:  0.090000   0.090000   0.180000 (  0.170912)
+enabled:   2.690000   0.330000   3.020000 (  3.027719)

data/test/test_disabled_probe_effect.rb

@@ -0,0 +1,56 @@
+#
+# Ruby-Dtrace
+# (c) 2008 Chris Andrews <chris@nodnol.org>
+#
+
+require 'dtrace'
+require 'dtrace/provider'
+require 'test/unit'
+require 'benchmark'
+
+class TestDisabledProbeEffect < Test::Unit::TestCase
+
+  def test_probe_no_args
+    
+    n = 20000
+    Benchmark.bm do |x|
+      
+      x.report "noprobes:" do 
+        # First time a loop with no probes created
+        (1..n).each do |i|
+          # no op
+        end
+      end
+      
+      Dtrace::Provider.create :dpe do |p|
+        p.probe :p1
+      end
+      
+      x.report "disabled:" do 
+        # Second time a loop with probes created but not enabled.
+        (1..n).each do |i|
+          Dtrace::Probe::Dpe.p1 { |p| p.fire }
+        end
+      end
+
+      x.report "enabled: " do
+        # Third time a loop with probes enabled
+        t = Dtrace.new 
+        t.setopt("bufsize", "4m")
+
+        progtext = "dpe#{$$}:::p1 { }"
+        
+        prog = t.compile progtext
+        prog.execute
+        t.go
+        
+        (1..n).each do |i|
+          Dtrace::Probe::Dpe.p1 { |p| p.fire }
+        end
+      end
+    end
+
+    assert 1
+
+  end
+end

data/test/test_dof_generator.rb

@@ -0,0 +1,142 @@
+#
+# Ruby-Dtrace
+# (c) 2008 Chris Andrews <chris@nodnol.org>
+#
+
+require 'dtrace'
+require 'dtrace/dof'
+require 'test/unit'
+require 'pp'
+
+$dof_dir = File.dirname(__FILE__)
+
+# Tests for the Dtrace DOF generator
+
+class TestDofGenerator < Test::Unit::TestCase
+  include Dtrace::Dof::Constants
+
+  def test_generate_section_comments
+    s = Dtrace::Dof::Section.new(DOF_SECT_COMMENTS, 1)
+    s.data = "Ruby-Dtrace D 0.12"
+    dof = s.generate
+    assert dof
+  end
+
+  def test_generate_section_utsname
+    s = Dtrace::Dof::Section.new(DOF_SECT_UTSNAME, 2)
+    dof = s.generate
+    assert dof
+  end
+    
+  def test_generate_section_probes
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROBES, 3)
+    s.data = [
+              {:enoffidx=>14,
+                :argidx=>16,
+                :nenoffs=>1,
+                :offidx=>14,
+                :name=>1,
+                :addr=>0x8082a78,
+                :nargc=>1,
+                :func=>5,
+                :xargc=>1,
+                :nargv=>3,
+                :noffs=>1,
+                :xargv=>3},
+              {:enoffidx=>15,
+                :argidx=>17,
+                :nenoffs=>1,
+                :offidx=>15,
+                :name=>4,
+                :addr=>0x807429c,
+                :nargc=>3,
+                :func=>9,
+                :xargc=>3,
+                :nargv=>6,
+                :noffs=>1,
+                :xargv=>7},
+             ]
+    
+    dof = s.generate
+    assert dof
+  end
+
+  def test_generate_section_strtab
+    s = Dtrace::Dof::Section.new(DOF_SECT_STRTAB, 1)
+    s.data = ['foo', 'bar', 'baz']
+    dof = s.generate
+    assert dof
+  end
+
+  def test_generate_section_prargs
+    s = Dtrace::Dof::Section.new(DOF_SECT_PRARGS, 1)
+    s.data = [ 1, 2 ]
+    dof = s.generate
+    assert dof
+  end
+
+  def test_generate_section_proffs
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROFFS, 1)
+    s.data = [ 3, 4 ]
+    dof = s.generate
+    assert dof
+  end
+
+  def test_generate_section_prenoffs
+    s = Dtrace::Dof::Section.new(DOF_SECT_PRENOFFS, 1)
+    s.data = [ 5, 6 ]
+    dof = s.generate
+    assert dof
+  end
+
+  def test_generate_section_provider
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROVIDER, 1)
+    data = {
+      :strtab => 1,
+      :probes => 2,
+      :prargs => 3,
+      :proffs => 4,
+      :prenoffs => 5,
+      :name => 1,
+      :provattr => { :name => 1, :data => 1, :class => 1 },
+      :modattr  => { :name => 1, :data => 1, :class => 1 },
+      :funcattr => { :name => 1, :data => 1, :class => 1 },
+      :nameattr => { :name => 1, :data => 1, :class => 1 },
+      :argsattr => { :name => 1, :data => 1, :class => 1 }
+    }
+    s.data = data
+    dof = s.generate
+    assert dof
+  end
+
+  def test_dof_generate_section_reltab
+    s = Dtrace::Dof::Section.new(DOF_SECT_RELTAB, 5)
+    data = [
+            { :name   => 20, # main
+              :type   => 1,  # setx?
+              :offset => 0,
+              :data   => 0,
+            }
+           ]
+    s.data = data
+    dof = s.generate
+    assert dof
+  end
+
+  def test_dof_generate_section_urelhdr
+    s = Dtrace::Dof::Section.new(DOF_SECT_URELHDR, 6)
+    data = {
+      :strtab => 0,
+      :relsec => 5,
+      :tgtsec => 1,
+    }
+    s.data = data
+    dof = s.generate
+    assert dof
+  end
+
+  def test_const
+    assert Dtrace::Dof::Constants::DOF_SECT_UTSNAME
+    assert DOF_SECT_UTSNAME
+  end
+end