ruby-prof 0.15.9 → 0.16.0

data/lib/ruby-prof/printers/dot_printer.rb

@@ -22,7 +22,7 @@ module RubyProf
     CLASS_COLOR = '"#666666"'
     EDGE_COLOR  = '"#666666"'
 
-    # Creates the DotPrinter using a RubyProf::Result.
+    # Creates the DotPrinter using a RubyProf::Proile.
     def initialize(result)
       super(result)
       @seen_methods = Set.new

data/lib/ruby-prof/printers/multi_printer.rb

@@ -18,15 +18,17 @@ module RubyProf
     def print(options)
       @profile = options.delete(:profile) || "profile"
       @directory = options.delete(:path) || File.expand_path(".")
+
       File.open(stack_profile, "w") do |f|
         @stack_printer.print(f, options.merge(:graph => "#{@profile}.graph.html"))
       end
+
       File.open(graph_profile, "w") do |f|
         @graph_printer.print(f, options)
       end
-      File.open(tree_profile, "w") do |f|
-        @tree_printer.print(f, options)
-      end
+
+      @tree_printer.print(options.merge(:path => @directory, :profile => @profile))
+
       File.open(flat_profile, "w") do |f|
         @flat_printer.print(f, options)
       end
@@ -44,7 +46,7 @@ module RubyProf
 
     # the name of the callgrind profile file
     def tree_profile
-      "#{@directory}/#{@profile}.grind.dat"
+      "#{@directory}/#{@profile}.callgrind.out.#{$$}"
     end
 
     # the name of the flat profile file

data/lib/ruby-prof/profile.rb

@@ -1,6 +1,5 @@
 # encoding: utf-8
 
-require 'set'
 module RubyProf
   class Profile
     # This method gets called once profiling has been completed

data/lib/ruby-prof/rack.rb

@@ -16,30 +16,61 @@ module Rack
                                                   ::RubyProf::GraphHtmlPrinter => 'graph.html',
                                                   ::RubyProf::CallStackPrinter => 'call_stack.html'}
 
-      @skip_paths = options[:skip_paths] || [%r{^/assets}, %r{\.css$}, %r{\.js$}, %r{\.png$}, %r{\.jpeg$}, %r{\.jpg$}, %r{\.gif$}]
+      @skip_paths = options[:skip_paths] || [%r{^/assets}, %r{\.(css|js|png|jpeg|jpg|gif)$}]
+      @only_paths = options[:only_paths]
     end
 
     def call(env)
       request = Rack::Request.new(env)
 
-      if @skip_paths.any? {|skip_path| skip_path =~ request.path}
-        @app.call(env)
-      else
-        result = nil
-        data = ::RubyProf::Profile.profile do
-          result = @app.call(env)
-        end
+      if should_profile?(request.path)
+        begin
+          result = nil
+          data = ::RubyProf::Profile.profile(profiling_options) do
+            result = @app.call(env)
+          end
 
-        path = request.path.gsub('/', '-')
-        path.slice!(0)
+          path = request.path.gsub('/', '-')
+          path.slice!(0)
 
-        print(data, path)
-        result
+          print(data, path)
+          result
+        end
+      else
+        @app.call(env)
       end
     end
 
     private
 
+    def should_profile?(path)
+      return false if paths_match?(path, @skip_paths)
+
+      @only_paths ? paths_match?(path, @only_paths) : true
+    end
+
+    def paths_match?(path, paths)
+      paths.any? { |skip_path| skip_path =~ path }
+    end
+
+    def profiling_options
+      options = {}
+      options[:measure_mode] = ::RubyProf.measure_mode
+      options[:exclude_threads] =
+        if @options[:ignore_existing_threads]
+          Thread.list.select{|t| t != Thread.current}
+        else
+          ::RubyProf.exclude_threads
+        end
+      if @options[:request_thread_only]
+        options[:include_threads] = [Thread.current]
+      end
+      if @options[:merge_fibers]
+        options[:merge_fibers] = true
+      end
+      options
+    end
+
     def print(data, path)
       @printer_klasses.each do |printer_klass, base_name|
         printer = printer_klass.new(data)
@@ -48,11 +79,17 @@ module Rack
           base_name = base_name.call
         end
 
-        file_name = ::File.join(@tmpdir, "#{path}-#{base_name}")
-        ::File.open(file_name, 'wb') do |file|
-          printer.print(file, @options)
+        if printer_klass == ::RubyProf::MultiPrinter
+          printer.print(@options.merge(:profile => "#{path}-#{base_name}"))
+        elsif printer_klass == ::RubyProf::CallTreePrinter
+          printer.print(@options.merge(:profile => "#{path}-#{base_name}"))
+        else
+          file_name = ::File.join(@tmpdir, "#{path}-#{base_name}")
+          ::File.open(file_name, 'wb') do |file|
+            printer.print(file, @options)
+          end
         end
       end
     end
   end
-end
+end

data/lib/ruby-prof/thread.rb

@@ -26,5 +26,16 @@ module RubyProf
         sum
       end
     end
+
+    def wait_time
+      # wait_time, like self:time, is always method local
+      # thus we need to sum over all methods and call infos
+      self.methods.inject(0) do |sum, method_info|
+        method_info.call_infos.each do |call_info|
+          sum += call_info.wait_time
+        end
+        sum
+      end
+    end
   end
 end

data/lib/ruby-prof/version.rb

@@ -1,3 +1,3 @@
 module RubyProf
-  VERSION = "0.15.9"
+  VERSION = "0.16.0"
 end

data/test/exclude_threads_test.rb

@@ -26,7 +26,8 @@ class ExcludeThreadsTest < TestCase
       thread2_proc
     end
 
-    RubyProf::exclude_threads = [ thread2 ]
+    # exclude_threads already includes the minitest thread pool
+    RubyProf.exclude_threads += [ thread2 ]
 
     RubyProf.start
 
@@ -35,8 +36,6 @@ class ExcludeThreadsTest < TestCase
 
     result = RubyProf.stop
 
-    RubyProf::exclude_threads = nil
-
     assert_equal(2, result.threads.length)
 
     output = Array.new

data/test/fiber_test.rb

@@ -37,18 +37,18 @@ class FiberTest < TestCase
     @fiber_ids  = Set.new
     @root_fiber = Fiber.current.object_id
     @thread_id  = Thread.current.object_id
-    @result     = RubyProf.profile { fiber_test }
   end
 
   def test_fibers
-    profiled_fiber_ids = @result.threads.map(&:fiber_id)
-    assert_equal(2, @result.threads.length)
-    assert_equal([@thread_id], @result.threads.map(&:id).uniq)
+    result  = RubyProf.profile { fiber_test }
+    profiled_fiber_ids = result.threads.map(&:fiber_id)
+    assert_equal(2, result.threads.length)
+    assert_equal([@thread_id], result.threads.map(&:id).uniq)
     assert_equal(@fiber_ids, Set.new(profiled_fiber_ids))
 
     assert profiled_fiber_ids.include?(@root_fiber)
-    assert(root_fiber_profile = @result.threads.detect{|t| t.fiber_id == @root_fiber})
-    assert(enum_fiber_profile = @result.threads.detect{|t| t.fiber_id != @root_fiber})
+    assert(root_fiber_profile = result.threads.detect{|t| t.fiber_id == @root_fiber})
+    assert(enum_fiber_profile = result.threads.detect{|t| t.fiber_id != @root_fiber})
 
     assert_in_delta(0.3, root_fiber_profile.total_time, 0.05)
     assert_in_delta(0.2, enum_fiber_profile.total_time, 0.05)
@@ -58,8 +58,22 @@ class FiberTest < TestCase
 
     assert_in_delta(0.2, method_next.total_time, 0.05)
     assert_in_delta(0.2, method_each.total_time, 0.05)
+  end
+
+  def test_merged_fibers
+    result  = RubyProf.profile(merge_fibers: true) { fiber_test }
+    assert_equal(1, result.threads.length)
+
+    profile = result.threads.first
+    assert_equal 0, profile.fiber_id
+
+    assert_in_delta(0.3, profile.total_time, 0.05)
 
-    # RubyProf::CallInfoPrinter.new(@result).print
+    assert(method_next = profile.methods.detect{|m| m.full_name == "Enumerator#next"})
+    assert(method_each = profile.methods.detect{|m| m.full_name == "Enumerator#each"})
+
+    assert_in_delta(0.2, method_next.total_time, 0.05)
+    assert_in_delta(0.2, method_each.total_time, 0.05)
   end
 
 end

data/test/measure_cpu_time_test.rb

@@ -8,8 +8,11 @@ class MeasureCpuTimeTest < TestCase
     RubyProf::measure_mode = RubyProf::CPU_TIME
   end
 
+  def teardown
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
   def test_mode
-    RubyProf::measure_mode = RubyProf::CPU_TIME
     assert_equal(RubyProf::CPU_TIME, RubyProf::measure_mode)
   end
 
@@ -19,12 +22,12 @@ class MeasureCpuTimeTest < TestCase
 
   def test_class_methods
     result = RubyProf.profile do
-      RubyProf::C7.hello
+      RubyProf::C7.busy_wait
     end
 
     # Length should be greater 2:
     #   MeasureCpuTimeTest#test_class_methods
-    #   <Class::RubyProf::C1>#hello
+    #   <Class::RubyProf::C1>#busy_wait
     #   ....
 
     methods = result.threads.first.methods.sort.reverse[0..1]
@@ -32,21 +35,21 @@ class MeasureCpuTimeTest < TestCase
 
     # Check the names
     assert_equal('MeasureCpuTimeTest#test_class_methods', methods[0].full_name)
-    assert_equal('<Class::RubyProf::C7>#hello', methods[1].full_name)
+    assert_equal('<Class::RubyProf::C7>#busy_wait', methods[1].full_name)
 
     # Check times
-    assert_in_delta(0.1, methods[0].total_time, 0.03)
-    assert_in_delta(0, methods[0].wait_time, 0.03)
-    assert_in_delta(0, methods[0].self_time, 0.03)
+    assert_in_delta(0.1, methods[0].total_time, 0.05)
+    assert_in_delta(0, methods[0].wait_time, 0.05)
+    assert_in_delta(0, methods[0].self_time, 0.05)
 
-    assert_in_delta(0.1, methods[1].total_time, 0.03)
-    assert_in_delta(0, methods[1].wait_time, 0.03)
-    assert_in_delta(0, methods[1].self_time, 0.03)
+    assert_in_delta(0.1, methods[1].total_time, 0.05)
+    assert_in_delta(0, methods[1].wait_time, 0.05)
+    assert_in_delta(0, methods[1].self_time, 0.05)
   end
 
   def test_instance_methods
     result = RubyProf.profile do
-      RubyProf::C7.new.hello
+      RubyProf::C7.new.busy_wait
     end
 
     methods = result.threads.first.methods.sort.reverse[0..1]
@@ -54,12 +57,12 @@ class MeasureCpuTimeTest < TestCase
 
     # Methods at this point:
     #   MeasureCpuTimeTest#test_instance_methods
-    #   C7#hello
+    #   C7#busy_wait
     #   ...
 
     names = methods.map(&:full_name)
     assert_equal('MeasureCpuTimeTest#test_instance_methods', names[0])
-    assert_equal('RubyProf::C7#hello', names[1])
+    assert_equal('RubyProf::C7#busy_wait', names[1])
 
 
     # Check times
@@ -69,24 +72,24 @@ class MeasureCpuTimeTest < TestCase
 
     assert_in_delta(0.2, methods[1].total_time, 0.03)
     assert_in_delta(0, methods[1].wait_time, 0.03)
-    assert_in_delta(0, methods[1].self_time, 0.1)
+    assert_in_delta(0, methods[1].self_time, 0.2)
   end
 
   def test_module_methods
     result = RubyProf.profile do
-      RubyProf::C8.hello
+      RubyProf::C8.busy_wait
     end
 
     # Methods:
     #   MeasureCpuTimeTest#test_module_methods
-    #   M1#hello
+    #   M1#busy_wait
     #   ...
 
     methods = result.threads.first.methods.sort.reverse[0..1]
     assert_equal(2, methods.length)
 
     assert_equal('MeasureCpuTimeTest#test_module_methods', methods[0].full_name)
-    assert_equal('RubyProf::M7#hello', methods[1].full_name)
+    assert_equal('RubyProf::M7#busy_wait', methods[1].full_name)
 
     # Check times
     assert_in_delta(0.3, methods[0].total_time, 0.1)
@@ -100,26 +103,26 @@ class MeasureCpuTimeTest < TestCase
 
   def test_module_instance_methods
     result = RubyProf.profile do
-      RubyProf::C8.new.hello
+      RubyProf::C8.new.busy_wait
     end
 
     # Methods:
     #   MeasureCpuTimeTest#test_module_instance_methods
-    #   M7#hello
+    #   M7#busy_wait
     #   ...
 
     methods = result.threads.first.methods.sort.reverse[0..1]
     assert_equal(2, methods.length)
     names = methods.map(&:full_name)
     assert_equal('MeasureCpuTimeTest#test_module_instance_methods', names[0])
-    assert_equal('RubyProf::M7#hello', names[1])
+    assert_equal('RubyProf::M7#busy_wait', names[1])
 
     # Check times
     assert_in_delta(0.3, methods[0].total_time, 0.1)
     assert_in_delta(0, methods[0].wait_time, 0.1)
     assert_in_delta(0, methods[0].self_time, 0.1)
 
-    assert_in_delta(0.3, methods[1].total_time, 0.02)
+    assert_in_delta(0.3, methods[1].total_time, 0.1)
     assert_in_delta(0, methods[1].wait_time, 0.01)
     assert_in_delta(0, methods[1].self_time, 0.1)
   end
@@ -128,19 +131,19 @@ class MeasureCpuTimeTest < TestCase
     c3 = RubyProf::C3.new
 
     class << c3
-      def hello
+      def busy_wait
       end
     end
 
     result = RubyProf.profile do
-      c3.hello
+      c3.busy_wait
     end
 
     methods = result.threads.first.methods.sort.reverse
     assert_equal(2, methods.length)
 
     assert_equal('MeasureCpuTimeTest#test_singleton', methods[0].full_name)
-    assert_equal('<Object::RubyProf::C3>#hello', methods[1].full_name)
+    assert_equal('<Object::RubyProf::C3>#busy_wait', methods[1].full_name)
 
     assert_in_delta(0, methods[0].total_time, 0.01)
     assert_in_delta(0, methods[0].wait_time, 0.01)
@@ -150,4 +153,61 @@ class MeasureCpuTimeTest < TestCase
     assert_in_delta(0, methods[1].wait_time, 0.01)
     assert_in_delta(0, methods[1].self_time, 0.01)
   end
+
+
+  def test_sleeping_does_accumulate_wall_time
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+    result = RubyProf.profile do
+      sleep 0.1
+    end
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(["MeasureCpuTimeTest#test_sleeping_does_accumulate_wall_time", "Kernel#sleep"], methods.map(&:full_name))
+    assert_in_delta(0.1, methods[1].total_time, 0.01)
+    assert_equal(0, methods[1].wait_time)
+    assert_in_delta(0.1, methods[1].self_time, 0.01)
+  end
+
+  def test_sleeping_does_not_accumulate_significant_cpu_time
+    result = RubyProf.profile do
+      sleep 0.1
+    end
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(["MeasureCpuTimeTest#test_sleeping_does_not_accumulate_significant_cpu_time", "Kernel#sleep"], methods.map(&:full_name))
+    assert_in_delta(0, methods[1].total_time, 0.01)
+    assert_equal(0, methods[1].wait_time)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+  end
+
+  def test_waiting_for_threads_does_not_accumulate_cpu_time
+    background_thread = nil
+    result = RubyProf.profile do
+      background_thread = Thread.new{ sleep 0.1 }
+      background_thread.join
+    end
+    # check number of threads
+    assert_equal(2, result.threads.length)
+    fg, bg = result.threads
+    assert(fg.methods.map(&:full_name).include?("Thread#join"))
+    assert(bg.methods.map(&:full_name).include?("Kernel#sleep"))
+    assert_in_delta(0, fg.total_time, 0.01)
+    assert_in_delta(0, bg.total_time, 0.01)
+  end
+
+  def test_waiting_for_threads_does_accumulate_wall_time
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+    background_thread = nil
+    result = RubyProf.profile do
+      background_thread = Thread.new{ sleep 0.1 }
+      background_thread.join
+    end
+    # check number of threads
+    assert_equal(2, result.threads.length)
+    fg, bg = result.threads
+    assert(fg.methods.map(&:full_name).include?("Thread#join"))
+    assert(bg.methods.map(&:full_name).include?("Kernel#sleep"))
+    assert_in_delta(0.1, fg.total_time, 0.01)
+    assert_in_delta(0.1, fg.wait_time, 0.01)
+    assert_in_delta(0.1, bg.total_time, 0.01)
+  end
+
 end