ruby-prof 0.16.2 → 0.17.0

data/lib/ruby-prof/thread.rb

@@ -10,12 +10,6 @@ module RubyProf
       top_methods.map(&:call_infos).flatten.select(&:root?)
     end
 
-    # This method detect recursive calls in the call tree of a given thread
-    # It should be called only once for each thread
-    def detect_recursion
-      top_call_infos.each(&:detect_recursion)
-    end
-
     def total_time
       self.top_methods.inject(0) do |sum, method_info|
         method_info.call_infos.each do |call_info|

data/lib/ruby-prof/version.rb

@@ -1,3 +1,3 @@
 module RubyProf
-  VERSION = "0.16.2"
+  VERSION = "0.17.0"
 end

data/ruby-prof.gemspec

@@ -44,6 +44,7 @@ EOF
                    'lib/unprof.rb',
                    'lib/ruby-prof/*.rb',
                    'lib/ruby-prof/assets/*.{html,png}',
+                   'lib/ruby-prof/profile/*.rb',
                    'lib/ruby-prof/printers/*.rb',
                    'test/*.rb']
 
@@ -51,7 +52,7 @@ EOF
   spec.required_ruby_version = '>= 1.9.3'
   spec.date = Time.now.strftime('%Y-%m-%d')
   spec.homepage = 'https://github.com/ruby-prof/ruby-prof'
-  spec.add_development_dependency('minitest', '~> 5.8.3')
-  spec.add_development_dependency('rake-compiler')
-  spec.add_development_dependency('rdoc')
+  spec.add_development_dependency('minitest', '~> 5.0')
+  spec.add_development_dependency('rake-compiler', '~> 1.0')
+  spec.add_development_dependency('rdoc', '~> 5.0')
 end

data/test/aggregate_test.rb

@@ -44,7 +44,7 @@ class AggregateTest < TestCase
     methods = result.threads.first.methods.sort.reverse
     methods.each do |m|
       m.call_infos.each do |ci|
-        assert(!ci.recursive)
+        assert(!ci.recursive?)
       end
     end
   end

data/test/exclude_methods_test.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+module ExcludeMethodsModule
+  def c
+    1.times { |i| ExcludeMethodsModule.d }
+  end
+
+  def self.d
+    1.times { |i| ExcludeMethodsClass.e }
+  end
+end
+
+class ExcludeMethodsClass
+  include ExcludeMethodsModule
+
+  def a
+    1.times { |i| b }
+  end
+
+  def b
+    1.times { |i| c; self.class.e }
+  end
+
+  def self.e
+    1.times { |i| f }
+  end
+
+  def self.f
+    sleep 0.1
+  end
+end
+
+class ExcludeMethodsTest < TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def test_methods_can_be_profiled
+    obj = ExcludeMethodsClass.new
+    prf = RubyProf::Profile.new
+
+    result = prf.profile { 5.times {obj.a} }
+    methods = result.threads.first.methods.sort.reverse
+
+    assert_equal(10, methods.count)
+    assert_equal('ExcludeMethodsTest#test_methods_can_be_profiled', methods[0].full_name)
+    assert_equal('Integer#times', methods[1].full_name)
+    assert_equal('ExcludeMethodsClass#a', methods[2].full_name)
+    assert_equal('ExcludeMethodsClass#b', methods[3].full_name)
+    assert_equal('<Class::ExcludeMethodsClass>#e', methods[4].full_name)
+    assert_equal('<Class::ExcludeMethodsClass>#f', methods[5].full_name)
+    assert_equal('Kernel#sleep', methods[6].full_name)
+    assert_equal('ExcludeMethodsModule#c', methods[7].full_name)
+    assert_equal('<Module::ExcludeMethodsModule>#d', methods[8].full_name)
+    assert_equal('Kernel#class', methods[9].full_name)
+  end
+
+  def test_methods_can_be_hidden1
+    obj = ExcludeMethodsClass.new
+    prf = RubyProf::Profile.new
+
+    prf.exclude_methods!(Integer, :times)
+
+    result = prf.profile { 5.times {obj.a} }
+    methods = result.threads.first.methods.sort.reverse
+
+    assert_equal(9, methods.count)
+    assert_equal('ExcludeMethodsTest#test_methods_can_be_hidden1', methods[0].full_name)
+    assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+    assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+    assert_equal('<Class::ExcludeMethodsClass>#e', methods[3].full_name)
+    assert_equal('<Class::ExcludeMethodsClass>#f', methods[4].full_name)
+    assert_equal('Kernel#sleep', methods[5].full_name)
+    assert_equal('ExcludeMethodsModule#c', methods[6].full_name)
+    assert_equal('<Module::ExcludeMethodsModule>#d', methods[7].full_name)
+    assert_equal('Kernel#class', methods[8].full_name)
+  end
+
+  def test_methods_can_be_hidden2
+    obj = ExcludeMethodsClass.new
+    prf = RubyProf::Profile.new
+
+    prf.exclude_methods!(Integer, :times)
+    prf.exclude_methods!(ExcludeMethodsClass.singleton_class, :f)
+    prf.exclude_methods!(ExcludeMethodsModule.singleton_class, :d)
+
+    result = prf.profile { 5.times {obj.a} }
+    methods = result.threads.first.methods.sort.reverse
+
+    assert_equal(7, methods.count)
+    assert_equal('ExcludeMethodsTest#test_methods_can_be_hidden2', methods[0].full_name)
+    assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+    assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+    assert_equal('<Class::ExcludeMethodsClass>#e', methods[3].full_name)
+    assert_equal('Kernel#sleep', methods[4].full_name)
+    assert_equal('ExcludeMethodsModule#c', methods[5].full_name)
+    assert_equal('Kernel#class', methods[6].full_name)
+  end
+
+  def test_exclude_common_methods1
+    obj = ExcludeMethodsClass.new
+    prf = RubyProf::Profile.new
+
+    prf.exclude_common_methods!
+
+    result = prf.profile { 5.times {obj.a} }
+    methods = result.threads.first.methods.sort.reverse
+
+    assert_equal(9, methods.count)
+    assert_equal('ExcludeMethodsTest#test_exclude_common_methods1', methods[0].full_name)
+    assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+    assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+  end
+
+  def test_exclude_common_methods2
+    obj = ExcludeMethodsClass.new
+
+    result = RubyProf.profile(exclude_common: true) { 5.times {obj.a} }
+    methods = result.threads.first.methods.sort.reverse
+
+    assert_equal(9, methods.count)
+    assert_equal('ExcludeMethodsTest#test_exclude_common_methods2', methods[0].full_name)
+    assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+    assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+  end
+
+  private
+
+  def assert_method_has_been_eliminated(result, eliminated_method)
+    result.threads.each do |thread|
+      thread.methods.each do |method|
+        method.call_infos.each do |ci|
+          assert(ci.target != eliminated_method, "broken self")
+          assert(ci.parent.target != eliminated_method, "broken parent") if ci.parent
+          ci.children.each do |callee|
+            assert(callee.target != eliminated_method, "broken kid")
+          end
+        end
+      end
+    end
+  end
+end

data/test/line_number_test.rb

@@ -34,7 +34,11 @@ class LineNumbersTest < TestCase
 
     method = methods[1]
     assert_equal('LineNumbers#method2', method.full_name)
-    assert_equal(10, method.line)
+    if RUBY_VERSION < "2.5"
+      assert_equal(10, method.line)
+    else
+      assert_equal(11, method.line)
+    end
 
     method = methods[2]
     assert_equal('LineNumbers#method1', method.full_name)
@@ -62,10 +66,15 @@ class LineNumbersTest < TestCase
 
     method = methods[1]
     assert_equal('LineNumbers#method3', method.full_name)
-    assert_equal(14, method.line)
+    if RUBY_VERSION < "2.5"
+      assert_equal(14, method.line)
+    else
+      assert_equal(15, method.line)
+    end
 
     method = methods[2]
     assert_equal('LineNumbersTest#test_c_function', method.full_name)
-    assert_equal(48, method.line)
+    assert_equal(52, method.line)
   end
+
 end

data/test/multi_printer_test.rb

@@ -32,6 +32,28 @@ class MultiPrinterTest < TestCase
     RubyProf::measure_mode = RubyProf::WALL_TIME
   end
 
+  def test_refuses_io_objects
+    # we don't need a real profile for this test
+    p = RubyProf::MultiPrinter.new nil
+    begin
+      p.print(STDOUT)
+      flunk "should have raised an ArgumentError"
+    rescue ArgumentError => e
+      assert_match(/IO/, e.to_s)
+    end
+  end
+
+  def test_refuses_non_hashes
+    # we don't need a real profile for this test
+    p = RubyProf::MultiPrinter.new nil
+    begin
+      p.print([])
+      flunk "should have raised an ArgumentError"
+    rescue ArgumentError => e
+      assert_match(/hash/, e.to_s)
+    end
+  end
+
   def test_all_profiles_can_be_created
     start_time = Time.now
     RubyProf.start
@@ -39,8 +61,7 @@ class MultiPrinterTest < TestCase
     result = RubyProf.stop
     end_time = Time.now
     expected_time = end_time - start_time
-    stack = graph = nil
-    assert_nothing_raised { stack, graph = print(result) }
+    graph = print(result)[1]
     re = Regexp.new('
 \s*<table>
 \s*<tr>

data/test/no_method_class_test.rb

@@ -10,6 +10,6 @@ end
 
 methods = result.threads.first.methods
 global_method = methods.sort_by {|method| method.full_name}.first
-if global_method.full_name != 'Global#[No method]'
+if global_method.full_name != 'Kernel#sleep'
   raise(RuntimeError, "Wrong method name.  Expected: Global#[No method].  Actual: #{global_method.full_name}")
 end

data/test/printers_test.rb

@@ -63,6 +63,26 @@ class PrintersTest < TestCase
     end
   end
 
+  def test_refuses_io_objects
+    p = RubyProf::MultiPrinter.new(@result)
+    begin
+      p.print(STDOUT)
+      flunk "should have raised an ArgumentError"
+    rescue ArgumentError => e
+      assert_match(/IO/, e.to_s)
+    end
+  end
+
+  def test_refuses_non_hashes
+    p = RubyProf::MultiPrinter.new (@result)
+    begin
+      p.print([])
+      flunk "should have raised an ArgumentError"
+    rescue ArgumentError => e
+      assert_match(/hash/, e.to_s)
+    end
+  end
+
   def test_flat_string
     output = helper_test_flat_string(RubyProf::FlatPrinter)
     refute_match(/prime.rb/, output)
@@ -120,7 +140,7 @@ class PrintersTest < TestCase
     main_output_file_name = File.join(RubyProf.tmpdir, "lolcat.callgrind.out.#{$$}")
     assert(File.exist?(main_output_file_name))
     output = File.read(main_output_file_name)
-    assert_match(/fn=Object#find_primes/i, output)
+    assert_match(/fn=Object::find_primes/i, output)
     assert_match(/events: wall_time/i, output)
     refute_match(/d\d\d\d\d\d/, output) # old bug looked [in error] like Object::run_primes(d5833116)
   end

data/test/rack_test.rb

@@ -24,6 +24,16 @@ module Rack
   end
 end
 
+module Rack
+  class RubyProf
+    attr_reader :_profiler
+
+    def public_delete_profiler!
+      delete_profiler!
+    end
+  end
+end
+
 class RackTest < TestCase
   def test_create_print_path
     path = Dir.mktmpdir
@@ -90,4 +100,58 @@ class RackTest < TestCase
     file_path = ::File.join(path, 'path-to-resource.json-dynamic.txt')
     assert(File.exist?(file_path))
   end
+
+  def test_works_for_multiple_requests
+    path = Dir.mktmpdir
+
+    adapter = Rack::RubyProf.new(FakeRackApp.new, :path => path, :max_requests => 2)
+
+    # make a 1st request, and check that this didn't create any files
+    adapter.call(:fake_env)
+    assert(Dir["#{path}/*"].empty?)
+
+    # now a second request should create all the expected files
+    adapter.call(:fake_env)
+    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
+      file_path = ::File.join(path, "multi-requests-2-#{base_name}")
+      assert(File.exist?(file_path))
+    end
+
+    # let's clean up
+    FileUtils.rm_rf(Dir["#{path}/*"])
+
+    # and do the same again for the next 2 requests
+    adapter.call(:fake_env)
+    assert(Dir["#{path}/*"].empty?)
+
+    adapter.call(:fake_env)
+    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
+      file_path = ::File.join(path, "multi-requests-2-#{base_name}")
+      assert(File.exist?(file_path))
+    end
+  end
+
+  def test_tries_to_print_results_if_shut_down_before_max_requests_reached
+    path = Dir.mktmpdir
+
+    adapter = Rack::RubyProf.new(FakeRackApp.new, :path => path, :max_requests => 100)
+
+    # make a 1st request, and check that this didn't create any files
+    adapter.call(:fake_env)
+    assert(Dir["#{path}/*"].empty?)
+
+    adapter.public_delete_profiler!
+
+    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
+      file_path = ::File.join(path, "multi-requests-1-#{base_name}")
+      assert(File.exist?(file_path))
+    end
+  end
+
+  def test_it_uses_separate_profilers_if_not_aggregating_multiple_requests
+    adapter1 = Rack::RubyProf.new(FakeRackApp.new)
+    adapter2 = Rack::RubyProf.new(FakeRackApp.new)
+
+    assert(adapter1.object_id != adapter2.object_id)
+  end
 end

data/test/recursive_test.rb

@@ -64,7 +64,7 @@ class RecursiveTest < TestCase
 
     assert_equal(1, method.call_infos.length)
     call_info = method.call_infos[0]
-    assert(!call_info.recursive)
+    assert(!call_info.recursive?)
     assert_equal('RecursiveTest#test_simple', call_info.call_sequence)
     assert_equal(1, call_info.children.length)
 
@@ -82,12 +82,12 @@ class RecursiveTest < TestCase
     call_info = method.call_infos.first
     assert_equal(2, call_info.children.length)
     assert_equal('RecursiveTest#test_simple->SimpleRecursion#simple', call_info.call_sequence)
-    assert(!call_info.recursive)
+    assert(!call_info.recursive?)
 
     call_info = method.call_infos.last
     assert_equal(1, call_info.children.length)
     assert_equal('RecursiveTest#test_simple->SimpleRecursion#simple->SimpleRecursion#simple', call_info.call_sequence)
-    assert(call_info.recursive)
+    assert(call_info.recursive?)
 
     method = methods[2]
     assert_equal('Kernel#sleep', method.full_name)
@@ -101,12 +101,12 @@ class RecursiveTest < TestCase
     call_info = method.call_infos[0]
     assert_equal('RecursiveTest#test_simple->SimpleRecursion#simple->Kernel#sleep', call_info.call_sequence)
     assert_equal(0, call_info.children.length)
-    assert(!call_info.recursive)
+    assert(!call_info.recursive?)
 
     call_info = method.call_infos[1]
     assert_equal('RecursiveTest#test_simple->SimpleRecursion#simple->SimpleRecursion#simple->Kernel#sleep', call_info.call_sequence)
     assert_equal(0, call_info.children.length)
-    assert(!call_info.recursive)
+    assert(!call_info.recursive?)
   end
 
   def test_cycle
@@ -129,7 +129,7 @@ class RecursiveTest < TestCase
     call_info = method.call_infos[0]
     assert_equal('RecursiveTest#test_cycle', call_info.call_sequence)
     assert_equal(1, call_info.children.length)
-    assert(!call_info.recursive)
+    assert(!call_info.recursive?)
 
     method = methods[1]
     assert_equal('SimpleRecursion#render', method.full_name)
@@ -143,7 +143,7 @@ class RecursiveTest < TestCase
     call_info = method.call_infos[0]
     assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render', call_info.call_sequence)
     assert_equal(1, call_info.children.length)
-    assert(!call_info.recursive)
+    assert(!call_info.recursive?)
 
     method = methods[2]
     assert_equal('Integer#times', method.full_name)
@@ -157,12 +157,12 @@ class RecursiveTest < TestCase
     call_info = method.call_infos[0]
     assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times', call_info.call_sequence)
     assert_equal(1, call_info.children.length)
-    assert(!call_info.recursive)
+    assert(!call_info.recursive?)
 
     call_info = method.call_infos[1]
     assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial->Integer#times', call_info.call_sequence)
     assert_equal(1, call_info.children.length)
-    assert(call_info.recursive)
+    assert(call_info.recursive?)
 
     method = methods[3]
     assert_equal('SimpleRecursion#render_partial', method.full_name)
@@ -176,17 +176,17 @@ class RecursiveTest < TestCase
     call_info = method.call_infos[0]
     assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial', call_info.call_sequence)
     assert_equal(3, call_info.children.length)
-    assert(!call_info.recursive)
+    assert(!call_info.recursive?)
 
     call_info = method.call_infos[1]
     assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial->SimpleRecursion#render_partial', call_info.call_sequence)
     assert_equal(1, call_info.children.length)
-    assert(call_info.recursive)
+    assert(call_info.recursive?)
 
     call_info = method.call_infos[2]
     assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial->Integer#times->SimpleRecursion#render_partial', call_info.call_sequence)
     assert_equal(1, call_info.children.length)
-    assert(call_info.recursive)
+    assert(call_info.recursive?)
 
     method = methods[4]
     assert_equal('Kernel#sleep', method.full_name)
@@ -200,16 +200,16 @@ class RecursiveTest < TestCase
     call_info = method.call_infos[0]
     assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial->Kernel#sleep', call_info.call_sequence)
     assert_equal(0, call_info.children.length)
-    assert(!call_info.recursive)
+    assert(!call_info.recursive?)
 
     call_info = method.call_infos[1]
     assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial->SimpleRecursion#render_partial->Kernel#sleep', call_info.call_sequence)
     assert_equal(0, call_info.children.length)
-    assert(!call_info.recursive)
+    assert(!call_info.recursive?)
 
     call_info = method.call_infos[2]
     assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial->Integer#times->SimpleRecursion#render_partial->Kernel#sleep', call_info.call_sequence)
     assert_equal(0, call_info.children.length)
-    assert(!call_info.recursive)
+    assert(!call_info.recursive?)
   end
 end