ruby-prof 1.3.0 → 1.4.2

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

@@ -4,6 +4,7 @@ require 'erb'
 require 'fileutils'
 require 'base64'
 require 'set'
+require 'stringio'
 
 module RubyProf
   # Prints a HTML visualization of the call tree.

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

@@ -29,8 +29,9 @@ module RubyProf
 
       sum = 0
       methods.each do |method|
-        self_percent = (method.self_time / total_time) * 100
-        next if self_percent < min_percent
+        percent = (method.send(filter_by) / total_time) * 100
+        next if percent < min_percent
+        next if percent > max_percent
 
         sum += method.self_time
         #self_time_called = method.called > 0 ? method.self_time/method.called : 0

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

@@ -25,7 +25,7 @@ module RubyProf
     end
 
     def print_header(thread)
-      @output << "Measure Mode: %s\n" % RubyProf.measure_mode_string
+      @output << "Measure Mode: %s\n" % @result.measure_mode_string
       @output << "Thread ID: #{thread.id}\n"
       @output << "Fiber ID: #{thread.fiber_id}\n"
       @output << "Total Time: #{thread.total_time}\n"

data/lib/ruby-prof/profile.rb

@@ -7,10 +7,14 @@ module RubyProf
     # :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"
+        when WALL_TIME
+          "wall_time"
+        when PROCESS_TIME
+          "process_time"
+        when ALLOCATIONS
+          "allocations"
+        when MEMORY
+          "memory"
       end
     end
 

data/lib/ruby-prof/rack.rb

@@ -5,43 +5,37 @@ module Rack
   class RubyProf
     def initialize(app, options = {})
       @app = app
+      @options = options
+      @options[:min_percent] ||= 1
 
-      options[:min_percent] ||= 1
+      @tmpdir = options[:path] || Dir.tmpdir
+      FileUtils.mkdir_p(@tmpdir)
 
-      options[:path] ||= Dir.tmpdir
-      FileUtils.mkdir_p(options[:path])
+      @printer_klasses = @options[:printers]  || {::RubyProf::FlatPrinter => 'flat.txt',
+                                                  ::RubyProf::GraphPrinter => 'graph.txt',
+                                                  ::RubyProf::GraphHtmlPrinter => 'graph.html',
+                                                  ::RubyProf::CallStackPrinter => 'call_stack.html'}
 
       @skip_paths = options[:skip_paths] || [%r{^/assets}, %r{\.(css|js|png|jpeg|jpg|gif)$}]
       @only_paths = options[:only_paths]
-
-      @max_requests = options[:max_requests]
-
-      @options = options
     end
 
     def call(env)
       request = Rack::Request.new(env)
 
       if should_profile?(request.path)
-        profiler.resume
         begin
-          result = @app.call(env)
-        ensure
-          profiler.pause
-        end
+          result = nil
+          data = ::RubyProf::Profile.profile(profiling_options) do
+            result = @app.call(env)
+          end
 
-        if profiler.max_requests_reached?
-          prefix = if aggregate_requests?
-              nil
-            else
-              request.path.gsub('/', '-')[1..-1]
-            end
+          path = request.path.gsub('/', '-')
+          path.slice!(0)
 
-          profiler.print!(prefix)
-          delete_profiler!
+          print(data, path)
+          result
         end
-
-        result
       else
         @app.call(env)
       end
@@ -49,126 +43,53 @@ module Rack
 
     private
 
-    class RackProfiler
-      def initialize(options)
-        @options = options
-
-        @profile = ::RubyProf::Profile.new(profiling_options)
-        @profile.start
-        @profile.pause
-
-        @printer_klasses = options[:printers] || default_printers
-
-        @tmpdir = options[:path]
-
-        @max_requests = options[:max_requests] || 1
-        @requests_count = 0
+    def should_profile?(path)
+      return false if paths_match?(path, @skip_paths)
 
-        @printed = false
-        # if running across multiple requests, we want to make sure that the
-        # ongoing profile is not lost if the process shuts down before the
-        # max request count is reached
-        ObjectSpace.define_finalizer(self, proc { print! })
-      end
+      @only_paths ? paths_match?(path, @only_paths) : true
+    end
 
-      def resume
-        @profile.resume
-      end
+    def paths_match?(path, paths)
+      paths.any? { |skip_path| skip_path =~ path }
+    end
 
-      def pause
-        @profile.pause
-        @requests_count += 1
+    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
-
-      def max_requests_reached?
-        @requests_count >= @max_requests
+      if @options[:merge_fibers]
+        options[:merge_fibers] = true
       end
+      options
+    end
 
-      def print!(prefix = nil)
-        return false if @printed || @requests_count == 0
-
-        data = @profile.stop
-
-        prefix ||= "multi-requests-#{@requests_count}"
-
-        @printer_klasses.each do |printer_klass, base_name|
-          printer = printer_klass.new(data)
-
-          if base_name.respond_to?(:call)
-            base_name = base_name.call
-          end
+    def print(data, path)
+      @printer_klasses.each do |printer_klass, base_name|
+        printer = printer_klass.new(data)
 
-          if printer_klass == ::RubyProf::MultiPrinter \
-              || printer_klass == ::RubyProf::CallTreePrinter
-            printer.print(@options.merge(:profile => "#{prefix}-#{base_name}"))
-          else
-            file_name = ::File.join(@tmpdir, "#{prefix}-#{base_name}")
-            ::File.open(file_name, 'wb') do |file|
-              printer.print(file, @options)
-            end
-          end
+        if base_name.respond_to?(:call)
+          base_name = base_name.call
         end
 
-        @printed = true
-      end
-
-      private
-
-      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
+        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
-        if @options[:request_thread_only]
-          options[:include_threads] = [Thread.current]
         end
-        if @options[:merge_fibers]
-          options[:merge_fibers] = true
-        end
-        options
-      end
-
-      def default_printers
-        {::RubyProf::FlatPrinter => 'flat.txt',
-         ::RubyProf::GraphPrinter => 'graph.txt',
-         ::RubyProf::GraphHtmlPrinter => 'graph.html',
-         ::RubyProf::CallStackPrinter => 'call_stack.html'}
       end
     end
-
-    def profiler
-      if aggregate_requests?
-        @@_shared_profiler ||= RackProfiler.new(@options)
-      else
-        @_profiler ||= RackProfiler.new(@options)
-      end
-    end
-
-    def delete_profiler!
-      if aggregate_requests?
-        @@_shared_profiler.print! if @@_shared_profiler
-        @@_shared_profiler = nil
-      else
-        @_profiler = nil
-      end
-    end
-
-    def aggregate_requests?
-      !@max_requests.nil?
-    end
-
-    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
   end
 end

data/lib/ruby-prof/version.rb

@@ -1,3 +1,3 @@
 module RubyProf
-  VERSION = "1.3.0"
+  VERSION = "1.4.2"
 end

data/test/fiber_test.rb

@@ -8,254 +8,122 @@ require 'set'
 
 # --  Tests ----
 class FiberTest < TestCase
+
   def enumerator_with_fibers
-    @fiber_ids << Fiber.current.object_id
     enum = Enumerator.new do |yielder|
       [1,2].each do |x|
-        @fiber_ids << Fiber.current.object_id
-        sleep 0.1
         yielder.yield x
       end
     end
-    while true
-      begin
-        enum.next
-      rescue StopIteration
-        break
-      end
-    end
-    sleep 0.1
+
+    enum.next
+    enum.next
+  end
+
+  def fiber_yield_resume
+    fiber = Fiber.new do
+              Fiber.yield 1
+              Fiber.yield 2
+            end
+
+    fiber.resume
+    fiber.resume
   end
 
   def setup
     # Need to use wall time for this test due to the sleep calls
     RubyProf::measure_mode = RubyProf::WALL_TIME
-    @fiber_ids  = Set.new
-    @root_fiber = Fiber.current.object_id
-    @thread_id  = Thread.current.object_id
   end
 
   def test_fibers
     result  = RubyProf.profile { enumerator_with_fibers }
 
-    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_equal(2, result.threads.size)
 
-    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_in_delta(0.33, root_fiber_profile.total_time, 0.05)
-    assert_in_delta(0.33, enum_fiber_profile.total_time, 0.05)
-
-    methods = result.threads[0].methods.sort.reverse
-    assert_equal(12, methods.count)
+    thread1 = result.threads[0]
+    methods = thread1.methods.sort.reverse
+    assert_equal(5, methods.count)
 
     method = methods[0]
     assert_equal('FiberTest#test_fibers', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0.33, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0.33, method.children_time, 0.05)
 
     method = methods[1]
     assert_equal('FiberTest#enumerator_with_fibers', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0.33, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0.33, method.children_time, 0.05)
 
     method = methods[2]
     assert_equal('Enumerator#next', method.full_name)
-    assert_equal(3, method.called)
-    assert_in_delta(0.22, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0.22, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
+    assert_equal(2, method.called)
 
     method = methods[3]
-    assert_equal('Kernel#sleep', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(0.11, method.total_time, 0.05)
-    assert_in_delta(0.11, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
-
-    # Since these methods have such short times their order is a bit indeterminate
-    method = methods.detect {|a_method| a_method.full_name == 'Class#new'}
     assert_equal('Class#new', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
-
-    if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
-      method = methods.detect {|a_method| a_method.full_name == 'Set#<<'}
-      assert_equal('Set#<<', method.full_name)
-      assert_equal(1, method.called)
-      assert_in_delta(0, method.total_time, 0.05)
-      assert_in_delta(0, method.self_time, 0.05)
-      assert_in_delta(0, method.wait_time, 0.05)
-      assert_in_delta(0, method.children_time, 0.05)
-    end
 
-    method = methods.detect {|a_method| a_method.full_name == 'Module#==='}
-    assert_equal('Module#===', method.full_name)
+    method = methods[4]
+    assert_equal('Enumerator#initialize', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
 
-    method = methods.detect {|a_method| a_method.full_name == 'Kernel#object_id'}
-    assert_equal('Kernel#object_id', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
+    thread2 = result.threads[1]
+    methods = thread2.methods.sort.reverse
+    assert_equal(4, methods.count)
 
-    method = methods.detect {|a_method| a_method.full_name == '<Class::Fiber>#current'}
-    assert_equal('<Class::Fiber>#current', method.full_name)
+    method = methods[0]
+    assert_equal('Enumerator#each', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
 
-    method = methods.detect {|a_method| a_method.full_name == 'Exception#exception'}
-    assert_equal('Exception#exception', method.full_name)
+    method = methods[1]
+    assert_equal('Enumerator::Generator#each', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
 
-    method = methods.detect {|a_method| a_method.full_name == 'Exception#backtrace'}
-    assert_equal('Exception#backtrace', method.full_name)
+    method = methods[2]
+    assert_equal('Array#each', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
 
-    method = methods.detect {|a_method| a_method.full_name == 'Enumerator#initialize'}
-    assert_equal('Enumerator#initialize', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
+    method = methods[3]
+    assert_equal('Enumerator::Yielder#yield', method.full_name)
+    assert_equal(2, method.called)
+  end
 
-    methods = result.threads[1].methods.sort.reverse
+  def test_fiber_resume
+    result  = RubyProf.profile { fiber_yield_resume }
 
-    if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.6.0')
-      assert_equal(10, methods.count)
-    else
-      assert_equal(11, methods.count)
-    end
+    assert_equal(2, result.threads.size)
+
+    thread1 = result.threads[0]
+    methods = thread1.methods.sort.reverse
+    assert_equal(5, methods.count)
 
     method = methods[0]
-    assert_equal('RubyProf::Profile#_inserted_parent_', method.full_name)
+    assert_equal('FiberTest#test_fiber_resume', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0.33, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0.11, method.wait_time, 0.05)
-    assert_in_delta(0.22, method.children_time, 0.05)
 
     method = methods[1]
-    assert_equal('Enumerator#each', method.full_name)
+    assert_equal('FiberTest#fiber_yield_resume', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0.22, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0.22, method.children_time, 0.05)
 
     method = methods[2]
-    assert_equal('Enumerator::Generator#each', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(0.22, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0.22, method.children_time, 0.05)
+    assert_equal('Fiber#resume', method.full_name)
+    assert_equal(2, method.called)
 
     method = methods[3]
-    assert_equal('Array#each', method.full_name)
+    assert_equal('Class#new', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0.22, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0.22, method.children_time, 0.05)
 
     method = methods[4]
-    assert_equal('Kernel#sleep', method.full_name)
-    assert_equal(2, method.called)
-    assert_in_delta(0.22, method.total_time, 0.05)
-    assert_in_delta(0.22, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
-
-    # Since these methods have such short times their order is a bit indeterminate
-    method = methods.detect {|a_method| a_method.full_name == 'Exception#initialize'}
-    assert_equal('Exception#initialize', method.full_name)
+    assert_equal('Fiber#initialize', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
-
-    if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
-      method = methods.detect {|a_method| a_method.full_name == 'Set#<<'}
-      assert_equal('Set#<<', method.full_name)
-      assert_equal(2, method.called)
-      assert_in_delta(0, method.total_time, 0.05)
-      assert_in_delta(0, method.self_time, 0.05)
-      assert_in_delta(0, method.wait_time, 0.05)
-      assert_in_delta(0, method.children_time, 0.05)
-    end
 
-    method = methods.detect {|a_method| a_method.full_name == 'Kernel#object_id'}
-    assert_equal('Kernel#object_id', method.full_name)
-    assert_equal(2, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
+    thread1 = result.threads[1]
+    methods = thread1.methods.sort.reverse
+    assert_equal(2, methods.count)
 
-    method = methods.detect {|a_method| a_method.full_name == 'Enumerator::Yielder#yield'}
-    assert_equal('Enumerator::Yielder#yield', method.full_name)
-    assert_equal(2, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
+    method = methods[0]
+    assert_equal('FiberTest#fiber_yield_resume', method.full_name)
+    assert_equal(1, method.called)
 
-    method = methods.detect {|a_method| a_method.full_name == '<Class::Fiber>#current'}
-    assert_equal('<Class::Fiber>#current', method.full_name)
+    method = methods[1]
+    assert_equal('<Class::Fiber>#yield', method.full_name)
     assert_equal(2, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
-  end
-
-  def test_merged_fibers
-    result  = RubyProf.profile(merge_fibers: true) { enumerator_with_fibers }
-
-    assert_equal(1, result.threads.length)
-
-    thread = result.threads.first
-    assert_equal(thread.id, thread.fiber_id)
-    assert_in_delta(0.3, thread.total_time, 0.05)
-
-    assert(method_next = thread.methods.detect{|m| m.full_name == "Enumerator#next"})
-    assert(method_each = thread.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