ruby-prof 0.18.0-x64-mingw32 → 1.1.0-x64-mingw32

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

@@ -5,11 +5,17 @@ module RubyProf
   # one profiling run. Currently prints a flat profile, a callgrind
   # profile, a call stack profile and a graph profile.
   class MultiPrinter
-    def initialize(result, printers = [:stack, :graph, :tree, :flat])
-      @stack_printer = CallStackPrinter.new(result) if printers.include?(:stack)
-      @graph_printer = GraphHtmlPrinter.new(result) if printers.include?(:graph)
-      @tree_printer = CallTreePrinter.new(result) if printers.include?(:tree)
+    def initialize(result, printers = [:flat, :graph_html])
       @flat_printer = FlatPrinter.new(result) if printers.include?(:flat)
+
+      @graph_printer = GraphPrinter.new(result) if printers.include?(:graph)
+      @graph_html_printer = GraphHtmlPrinter.new(result) if printers.include?(:graph_html)
+
+      @tree_printer = CallTreePrinter.new(result) if printers.include?(:tree)
+      @call_info_printer = CallInfoPrinter.new(result) if printers.include?(:call_info)
+
+      @stack_printer = CallStackPrinter.new(result) if printers.include?(:stack)
+      @dot_printer = DotPrinter.new(result) if printers.include?(:dot)
     end
 
     def self.needs_dir?
@@ -18,48 +24,79 @@ module RubyProf
 
     # create profile files under options[:path] or the current
     # directory. options[:profile] is used as the base name for the
-    # pofile file, defaults to "profile".
+    # profile file, defaults to "profile".
     def print(options)
       validate_print_params(options)
 
       @profile = options.delete(:profile) || "profile"
       @directory = options.delete(:path) || File.expand_path(".")
 
-      print_to_stack(options) if @stack_printer
+      print_to_flat(options) if @flat_printer
+
       print_to_graph(options) if @graph_printer
+      print_to_graph_html(options) if @graph_html_printer
+
+      print_to_stack(options) if @stack_printer
+      print_to_call_info(options) if @call_info_printer
       print_to_tree(options) if @tree_printer
-      print_to_flat(options) if @flat_printer
+      print_to_dot(options) if @dot_printer
     end
 
-    # the name of the call stack profile file
-    def stack_profile
-      "#{@directory}/#{@profile}.stack.html"
+    # the name of the flat profile file
+    def flat_report
+      "#{@directory}/#{@profile}.flat.txt"
     end
 
     # the name of the graph profile file
-    def graph_profile
+    def graph_report
+      "#{@directory}/#{@profile}.graph.txt"
+    end
+
+    def graph_html_report
       "#{@directory}/#{@profile}.graph.html"
     end
 
+    # the name of the callinfo profile file
+    def call_info_report
+      "#{@directory}/#{@profile}.call_info.txt"
+    end
+
     # the name of the callgrind profile file
-    def tree_profile
+    def tree_report
       "#{@directory}/#{@profile}.callgrind.out.#{$$}"
     end
 
-    # the name of the flat profile file
-    def flat_profile
-      "#{@directory}/#{@profile}.flat.txt"
+    # the name of the call stack profile file
+    def stack_report
+      "#{@directory}/#{@profile}.stack.html"
     end
 
-    def print_to_stack(options)
-      File.open(stack_profile, "w") do |f|
-        @stack_printer.print(f, options.merge(:graph => "#{@profile}.graph.html"))
+    # the name of the call stack profile file
+    def dot_report
+      "#{@directory}/#{@profile}.dot"
+    end
+
+    def print_to_flat(options)
+      File.open(flat_report, "wb") do |file|
+        @flat_printer.print(file, options)
       end
     end
 
     def print_to_graph(options)
-      File.open(graph_profile, "w") do |f|
-        @graph_printer.print(f, options)
+      File.open(graph_report, "wb") do |file|
+        @graph_printer.print(file, options)
+      end
+    end
+
+    def print_to_graph_html(options)
+      File.open(graph_html_report, "wb") do |file|
+        @graph_html_printer.print(file, options)
+      end
+    end
+
+    def print_to_call_info(options)
+      File.open(call_info_report, "wb") do |file|
+        @call_info_printer.print(file, options)
       end
     end
 
@@ -67,9 +104,15 @@ module RubyProf
       @tree_printer.print(options.merge(:path => @directory, :profile => @profile))
     end
 
-    def print_to_flat(options)
-      File.open(flat_profile, "w") do |f|
-        @flat_printer.print(f, options)
+    def print_to_stack(options)
+      File.open(stack_report, "wb") do |file|
+        @stack_printer.print(file, options.merge(:graph => "#{@profile}.graph.html"))
+      end
+    end
+
+    def print_to_dot(options)
+      File.open(dot_report, "wb") do |file|
+        @dot_printer.print(file, options)
       end
     end
 

data/lib/ruby-prof/profile.rb

@@ -1,11 +1,18 @@
 # encoding: utf-8
 
-require 'ruby-prof/profile/exclude_common_methods'
-require 'ruby-prof/profile/legacy_method_elimination'
+require 'ruby-prof/exclude_common_methods'
 
 module RubyProf
   class Profile
-    include LegacyMethodElimination
+    # :nodoc:
+    def measure_mode_string
+      case self.measure_mode
+        when WALL_TIME    then "wall_time"
+        when PROCESS_TIME then "process_time"
+        when ALLOCATIONS  then "allocations"
+        when MEMORY       then "memory"
+      end
+    end
 
     # Hides methods that, when represented as a call graph, have
     # extremely large in and out degrees and make navigation impossible.

data/lib/ruby-prof/rack.rb

@@ -126,9 +126,6 @@ module Rack
         if @options[:request_thread_only]
           options[:include_threads] = [Thread.current]
         end
-        if @options[:merge_fibers]
-          options[:merge_fibers] = true
-        end
         options
       end
 

data/lib/ruby-prof/thread.rb

@@ -1,31 +1,31 @@
 module RubyProf
   class Thread
-    def top_methods
+    # Returns the root methods (ie, methods that were not called by other methods) that were profiled while
+    # this thread was executing. Generally there is only one root method (multiple root methods can occur
+    # when Profile#pause is used). By starting with the root methods, you can descend down the profile
+    # call tree.
+    def root_methods
       self.methods.select do |method_info|
-        method_info.call_infos.detect(&:root?)
+        method_info.root?
       end
     end
 
-    def top_call_infos
-      top_methods.map(&:call_infos).flatten.select(&:root?)
-    end
-
+    # Returns the total time this thread was executed.
     def total_time
-      self.top_methods.inject(0) do |sum, method_info|
-        method_info.call_infos.each do |call_info|
-          if call_info.parent.nil?
-            sum += call_info.total_time
-          end
+      self.root_methods.inject(0) do |sum, method_info|
+        method_info.callers.each do |call_info|
+          sum += call_info.total_time
         end
         sum
       end
     end
 
+    # Returns the amount of time this thread waited while other thread executed.
     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|
+        method_info.callers.each do |call_info|
           sum += call_info.wait_time
         end
         sum

data/lib/ruby-prof/version.rb

@@ -1,3 +1,3 @@
 module RubyProf
-  VERSION = "0.18.0"
+  VERSION = "1.1.0"
 end

data/ruby-prof.gemspec

@@ -43,13 +43,13 @@ EOF
                    'lib/ruby-prof.rb',
                    'lib/unprof.rb',
                    'lib/ruby-prof/*.rb',
-                   'lib/ruby-prof/assets/*.{html,png}',
+                   'lib/ruby-prof/assets/*',
                    'lib/ruby-prof/profile/*.rb',
                    'lib/ruby-prof/printers/*.rb',
                    'test/*.rb']
 
   spec.test_files = Dir["test/test_*.rb"]
-  spec.required_ruby_version = '>= 1.9.3'
+  spec.required_ruby_version = '>= 2.4.0'
   spec.date = Time.now.strftime('%Y-%m-%d')
   spec.homepage = 'https://github.com/ruby-prof/ruby-prof'
   spec.add_development_dependency('minitest')

data/test/abstract_printer_test.rb

@@ -11,33 +11,6 @@ class AbstractPrinterTest < TestCase
     @printer.setup_options(@options)
   end
 
-  def test_editor_uri
-    env = {}
-
-    with_const_stubbed('ENV', env) do
-      @options[:editor_uri] = 'nvim'
-
-      env['RUBY_PROF_EDITOR_URI'] = 'atm'
-      assert_equal('atm', @printer.editor_uri)
-
-      env['RUBY_PROF_EDITOR_URI'] = nil
-      assert_equal(false, @printer.editor_uri)
-
-      env.delete('RUBY_PROF_EDITOR_URI')
-      assert_equal('nvim', @printer.editor_uri)
-
-      with_const_stubbed('RUBY_PLATFORM', 'x86_64-darwin18') do
-        assert_equal('nvim', @printer.editor_uri)
-
-        @options.delete(:editor_uri)
-        assert_equal('txmt', @printer.editor_uri)
-      end
-      with_const_stubbed('RUBY_PLATFORM', 'windows') do
-        assert_equal(false, @printer.editor_uri)
-      end
-    end
-  end
-
   private
 
   def with_const_stubbed(name, value)

data/test/alias_test.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path("../test_helper", __FILE__)
+
+class AliasTest < TestCase
+  class TestMe
+    def some_method
+      sleep(0.1)
+    end
+
+    alias :some_method_original :some_method
+    def some_method
+      some_method_original
+    end
+  end
+
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  # This test only correct works on Ruby 2.5 and higher because - see:
+  # https://bugs.ruby-lang.org/issues/12747
+  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
+    def test_alias
+      result = RubyProf.profile do
+        TestMe.new.some_method
+      end
+
+      methods = result.threads.first.methods
+      assert_equal(6, methods.count)
+
+      # Method 0
+      method = methods[0]
+      assert_equal('AliasTest#test_alias', method.full_name)
+      assert_equal(28, method.line)
+      refute(method.recursive?)
+
+      assert_equal(1, method.callers.count)
+      call_info = method.callers[0]
+      assert_nil(call_info.parent)
+      assert_equal(28, call_info.line)
+
+      assert_equal(2, method.callees.count)
+      call_info = method.callees[0]
+      assert_equal('Class#new', call_info.target.full_name)
+      assert_equal(28, call_info.line)
+
+      call_info = method.callees[1]
+      assert_equal('AliasTest::TestMe#some_method', call_info.target.full_name)
+      assert_equal(28, call_info.line)
+
+      # Method 1
+      method = methods[1]
+      assert_equal('Class#new', method.full_name)
+      assert_equal(0, method.line)
+      refute(method.recursive?)
+
+      assert_equal(1, method.callers.count)
+      call_info = method.callers[0]
+      assert_equal('AliasTest#test_alias', call_info.parent.full_name)
+      assert_equal(28, call_info.line)
+
+      assert_equal(1, method.callees.count)
+      call_info = method.callees[0]
+      assert_equal('BasicObject#initialize', call_info.target.full_name)
+      assert_equal(0, call_info.line)
+
+      # Method 2
+      method = methods[2]
+      assert_equal('BasicObject#initialize', method.full_name)
+      assert_equal(0, method.line)
+      refute(method.recursive?)
+
+      assert_equal(1, method.callers.count)
+      call_info = method.callers[0]
+      assert_equal('Class#new', call_info.parent.full_name)
+      assert_equal(0, call_info.line)
+
+      assert_equal(0, method.callees.count)
+
+      # Method 3
+      method = methods[3]
+      assert_equal('AliasTest::TestMe#some_method', method.full_name)
+      assert_equal(13, method.line)
+      refute(method.recursive?)
+
+      assert_equal(1, method.callers.count)
+      call_info = method.callers[0]
+      assert_equal('AliasTest#test_alias', call_info.parent.full_name)
+      assert_equal(28, call_info.line)
+
+      assert_equal(1, method.callees.count)
+      call_info = method.callees[0]
+      assert_equal('AliasTest::TestMe#some_method_original', call_info.target.full_name)
+      assert_equal(14, call_info.line)
+
+      # Method 4
+      method = methods[4]
+      assert_equal('AliasTest::TestMe#some_method_original', method.full_name)
+      assert_equal(8, method.line)
+      refute(method.recursive?)
+
+      assert_equal(1, method.callers.count)
+      call_info = method.callers[0]
+      assert_equal('AliasTest::TestMe#some_method', call_info.parent.full_name)
+      assert_equal(14, call_info.line)
+
+      assert_equal(1, method.callees.count)
+      call_info = method.callees[0]
+      assert_equal('Kernel#sleep', call_info.target.full_name)
+      assert_equal(9, call_info.line)
+
+      # Method 5
+      method = methods[5]
+      assert_equal('Kernel#sleep', method.full_name)
+      assert_equal(0, method.line)
+      refute(method.recursive?)
+
+      assert_equal(1, method.callers.count)
+      call_info = method.callers[0]
+      assert_equal('AliasTest::TestMe#some_method_original', call_info.parent.full_name)
+      assert_equal(9, call_info.line)
+
+      assert_equal(0, method.callees.count)
+    end
+  end
+end

data/test/basic_test.rb

@@ -2,6 +2,7 @@
 # encoding: UTF-8
 
 require File.expand_path('../test_helper', __FILE__)
+require_relative './measure_times'
 
 class BasicTest < TestCase
   def setup
@@ -11,7 +12,7 @@ class BasicTest < TestCase
 
   def start
     RubyProf.start
-    RubyProf::C1.hello
+    RubyProf::C1.sleep_wait
   end
 
   def test_running
@@ -53,76 +54,76 @@ class BasicTest < TestCase
     assert_equal(1, profile.threads.count)
 
     thread = profile.threads.first
-    assert_in_delta(0.25, thread.total_time, 0.015)
+    assert_in_delta(0.25, thread.total_time, 0.05)
 
-    top_methods = thread.top_methods.sort
-    assert_equal(2, top_methods.count)
-    assert_equal("BasicTest#start", top_methods[0].full_name)
-    assert_equal("BasicTest#test_leave_method", top_methods[1].full_name)
+    root_methods = thread.root_methods.sort
+    assert_equal(2, root_methods.count)
+    assert_equal("BasicTest#start", root_methods[0].full_name)
+    assert_equal("BasicTest#test_leave_method", root_methods[1].full_name)
 
     assert_equal(4, thread.methods.length)
     methods = profile.threads.first.methods.sort
 
     # Check times
-    assert_equal("<Class::RubyProf::C1>#hello", methods[0].full_name)
-    assert_in_delta(0.1, methods[0].total_time, 0.015)
-    assert_in_delta(0.0,  methods[0].wait_time, 0.015)
-    assert_in_delta(0.0,  methods[0].self_time, 0.015)
+    assert_equal("<Class::RubyProf::C1>#sleep_wait", methods[0].full_name)
+    assert_in_delta(0.1, methods[0].total_time, 0.05)
+    assert_in_delta(0.0,  methods[0].wait_time, 0.05)
+    assert_in_delta(0.0,  methods[0].self_time, 0.05)
 
     assert_equal("BasicTest#start", methods[1].full_name)
-    assert_in_delta(0.1, methods[1].total_time, 0.015)
-    assert_in_delta(0.0, methods[1].wait_time, 0.015)
-    assert_in_delta(0.0, methods[1].self_time, 0.015)
+    assert_in_delta(0.1, methods[1].total_time, 0.05)
+    assert_in_delta(0.0, methods[1].wait_time, 0.05)
+    assert_in_delta(0.0, methods[1].self_time, 0.05)
 
     assert_equal("BasicTest#test_leave_method", methods[2].full_name)
-    assert_in_delta(0.15, methods[2].total_time, 0.015)
-    assert_in_delta(0.0, methods[2].wait_time, 0.015)
-    assert_in_delta(0.0, methods[2].self_time, 0.015)
+    assert_in_delta(0.15, methods[2].total_time, 0.05)
+    assert_in_delta(0.0, methods[2].wait_time, 0.05)
+    assert_in_delta(0.0, methods[2].self_time, 0.05)
 
     assert_equal("Kernel#sleep", methods[3].full_name)
-    assert_in_delta(0.25, methods[3].total_time, 0.015)
-    assert_in_delta(0.0, methods[3].wait_time, 0.015)
-    assert_in_delta(0.25, methods[3].self_time, 0.015)
+    assert_in_delta(0.25, methods[3].total_time, 0.05)
+    assert_in_delta(0.0, methods[3].wait_time, 0.05)
+    assert_in_delta(0.25, methods[3].self_time, 0.05)
   end
 
   def test_leave_method_2
     start
-    RubyProf::C1.hello
-    RubyProf::C1.hello
+    RubyProf::C1.sleep_wait
+    RubyProf::C1.sleep_wait
     profile = RubyProf.stop
 
     assert_equal(1, profile.threads.count)
 
     thread = profile.threads.first
-    assert_in_delta(0.3, thread.total_time, 0.015)
+    assert_in_delta(0.3, thread.total_time, 0.05)
 
-    top_methods = thread.top_methods.sort
-    assert_equal(2, top_methods.count)
-    assert_equal("BasicTest#start", top_methods[0].full_name)
-    assert_equal("BasicTest#test_leave_method_2", top_methods[1].full_name)
+    root_methods = thread.root_methods.sort
+    assert_equal(2, root_methods.count)
+    assert_equal("BasicTest#start", root_methods[0].full_name)
+    assert_equal("BasicTest#test_leave_method_2", root_methods[1].full_name)
 
     assert_equal(4, thread.methods.length)
     methods = profile.threads.first.methods.sort
 
     # Check times
     assert_equal("BasicTest#start", methods[0].full_name)
-    assert_in_delta(0.1, methods[0].total_time, 0.015)
-    assert_in_delta(0.0, methods[0].wait_time, 0.015)
-    assert_in_delta(0.0, methods[0].self_time, 0.015)
+    assert_in_delta(0.1, methods[0].total_time, 0.05)
+    assert_in_delta(0.0, methods[0].wait_time, 0.05)
+    assert_in_delta(0.0, methods[0].self_time, 0.05)
 
     assert_equal("BasicTest#test_leave_method_2", methods[1].full_name)
-    assert_in_delta(0.2, methods[1].total_time, 0.015)
-    assert_in_delta(0.0, methods[1].wait_time, 0.015)
-    assert_in_delta(0.0, methods[1].self_time, 0.015)
+    assert_in_delta(0.2, methods[1].total_time, 0.05)
+    assert_in_delta(0.0, methods[1].wait_time, 0.05)
+    assert_in_delta(0.0, methods[1].self_time, 0.05)
 
     assert_equal("Kernel#sleep", methods[2].full_name)
-    assert_in_delta(0.3, methods[2].total_time, 0.015)
-    assert_in_delta(0.0, methods[2].wait_time, 0.015)
-    assert_in_delta(0.3, methods[2].self_time, 0.015)
-
-    assert_equal("<Class::RubyProf::C1>#hello", methods[3].full_name)
-    assert_in_delta(0.3, methods[3].total_time, 0.015)
-    assert_in_delta(0.0, methods[3].wait_time, 0.015)
-    assert_in_delta(0.0, methods[3].self_time, 0.015)
+    assert_in_delta(0.3, methods[2].total_time, 0.05)
+    assert_in_delta(0.0, methods[2].wait_time, 0.05)
+    assert_in_delta(0.3, methods[2].self_time, 0.05)
+
+    assert_equal("<Class::RubyProf::C1>#sleep_wait", methods[3].full_name)
+    assert_in_delta(0.3, methods[3].total_time, 0.05)
+    assert_in_delta(0.0, methods[3].wait_time, 0.05)
+    assert_in_delta(0.0, methods[3].self_time, 0.05)
   end
 end