ruby-prof 1.1.0-x64-mingw32 → 1.4.2-x64-mingw32

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

@@ -17,11 +17,21 @@ module RubyProf
       @output = nil
     end
 
-    # Returns the min_percent of total time a method must take to be included in a profiling report
+    # Returns the min_percent of time a method must take to be included in a profiling report
     def min_percent
       @options[:min_percent] || 0
     end
 
+    # Returns the max_percent of time a method can take to be included in a profiling report
+    def max_percent
+      @options[:max_percent] || 100
+    end
+
+    # Returns the method to filter methods by (when using min_percent and max_percent)
+    def filter_by
+      @options[:filter_by] || :self_time
+    end
+
     # Returns the time format used to show when a profile was run
     def time_format
       '%A, %B %-d at %l:%M:%S %p (%Z)'
@@ -89,7 +99,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: %d\n" % thread.id
       @output << "Fiber ID: %d\n" % thread.fiber_id unless thread.id == thread.fiber_id
       @output << "Total: %0.6f\n" % thread.total_time

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

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 module RubyProf
-  # Prints out the call graph based on CallInfo instances. This
+  # Prints out the call graph based on CallTree instances. This
   # is mainly for debugging purposes as it provides access into
   # into RubyProf's internals.
   #
@@ -19,6 +19,7 @@ module RubyProf
     private
 
     def print_header(thread)
+      @output << "----------------------------------------------------\n"
       @output << "Thread ID: #{thread.id}\n"
       @output << "Fiber ID: #{thread.fiber_id}\n"
       @output << "Total Time: #{thread.total_time}\n"
@@ -27,18 +28,18 @@ module RubyProf
     end
 
     def print_methods(thread)
-      visitor = CallInfoVisitor.new(thread.root_methods)
+      visitor = CallTreeVisitor.new(thread.call_tree)
 
-      visitor.visit do |call_info, event|
+      visitor.visit do |call_tree, event|
         if event == :enter
-          @output << "  " * call_info.depth
-          @output << call_info.target.full_name
+          @output << "  " * call_tree.depth
+          @output << call_tree.target.full_name
           @output << " ("
-          @output << "tt:#{sprintf("%#{TIME_WIDTH}.2f", call_info.total_time)}, "
-          @output << "st:#{sprintf("%#{TIME_WIDTH}.2f", call_info.self_time)}, "
-          @output << "wt:#{sprintf("%#{TIME_WIDTH}.2f", call_info.wait_time)}, "
-          @output << "ct:#{sprintf("%#{TIME_WIDTH}.2f", call_info.children_time)}, "
-          @output << "call:#{call_info.called}, "
+          @output << "tt:#{sprintf("%#{TIME_WIDTH}.2f", call_tree.total_time)}, "
+          @output << "st:#{sprintf("%#{TIME_WIDTH}.2f", call_tree.self_time)}, "
+          @output << "wt:#{sprintf("%#{TIME_WIDTH}.2f", call_tree.wait_time)}, "
+          @output << "ct:#{sprintf("%#{TIME_WIDTH}.2f", call_tree.children_time)}, "
+          @output << "call:#{call_tree.called}, "
           @output << ")"
           @output << "\n"
         end
@@ -46,6 +47,7 @@ module RubyProf
     end
 
     def print_footer(thread)
+      @output << "\n" << "\n"
     end
   end
 end

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.
@@ -46,7 +47,6 @@ module RubyProf
     def print(output = STDOUT, options = {})
       setup_options(options)
       output << @erb.result(binding)
-      a = 1
     end
 
     # :enddoc:
@@ -55,50 +55,49 @@ module RubyProf
       @erb = ERB.new(self.template)
     end
 
-    def print_stack(output, visited, call_info, parent_time)
-      total_time = call_info.total_time
+    def print_stack(output, visited, call_tree, parent_time)
+      total_time = call_tree.total_time
       percent_parent = (total_time/parent_time)*100
       percent_total = (total_time/@overall_time)*100
       return unless percent_total > min_percent
       color = self.color(percent_total)
-      kids = call_info.target.callees
       visible = percent_total >= threshold
       expanded = percent_total >= expansion
       display = visible ? "block" : "none"
 
       output << "<li class=\"color#{color}\" style=\"display:#{display}\">" << "\n"
 
-      if visited.include?(call_info)
+      if visited.include?(call_tree)
         output << "<a href=\"#\" class=\"toggle empty\" ></a>" << "\n"
-        output << "<span>%s %s</span>" % [link(call_info.target, true), graph_link(call_info)] << "\n"
+        output << "<span>%s %s</span>" % [link(call_tree.target, true), graph_link(call_tree)] << "\n"
       else
-        visited << call_info
+        visited << call_tree
 
-        if kids.empty?
+        if call_tree.children.empty?
           output << "<a href=\"#\" class=\"toggle empty\" ></a>" << "\n"
         else
-          visible_children = kids.any?{|ci| (ci.total_time/@overall_time)*100 >= threshold}
+          visible_children = call_tree.children.any?{|ci| (ci.total_time/@overall_time)*100 >= threshold}
           image = visible_children ? (expanded ? "minus" : "plus") : "empty"
           output << "<a href=\"#\" class=\"toggle #{image}\" ></a>" << "\n"
         end
         output << "<span>%4.2f%% (%4.2f%%) %s %s</span>" % [percent_total, percent_parent,
-                                                            link(call_info.target, false), graph_link(call_info)] << "\n"
+                                                            link(call_tree.target, false), graph_link(call_tree)] << "\n"
 
-        unless kids.empty?
+        unless call_tree.children.empty?
           output <<  (expanded ? '<ul>' : '<ul style="display:none">')  << "\n"
-          kids.sort_by{|c| -c.total_time}.each do |child_call_info|
-            print_stack(output, visited, child_call_info, total_time)
+          call_tree.children.sort_by{|c| -c.total_time}.each do |child_call_tree|
+            print_stack(output, visited, child_call_tree, total_time)
           end
           output << '</ul>' << "\n"
         end
 
-        visited.delete(call_info)
+        visited.delete(call_tree)
       end
       output << '</li>' << "\n"
     end
 
-    def name(call_info)
-      method = call_info.target
+    def name(call_tree)
+      method = call_tree.target
       method.full_name
     end
 
@@ -112,19 +111,18 @@ module RubyProf
       end
     end
 
-    def graph_link(call_info)
-      total_calls = call_info.target.called
-      href = "#{method_href(call_info.target)}"
+    def graph_link(call_tree)
+      total_calls = call_tree.target.called
       totals = total_calls.to_s
-      "[#{call_info.called} calls, #{totals} total]"
+      "[#{call_tree.called} calls, #{totals} total]"
     end
 
     def method_href(method)
       h(method.full_name.gsub(/[><#\.\?=:]/,"_"))
     end
 
-    def total_time(call_infos)
-      sum(call_infos.map{|ci| ci.total_time})
+    def total_time(call_trees)
+      sum(call_trees.map{|ci| ci.total_time})
     end
 
     def sum(a)

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

@@ -137,7 +137,7 @@ module RubyProf
       output << "#{method.line} #{convert(method.self_time)}\n"
 
       # Now print out all the children methods
-      method.callees.each do |callee|
+      method.call_trees.callees.each do |callee|
         output << "cfl=#{file(callee.target)}\n"
         output << "cfn=#{self.calltree_name(callee.target)}\n"
         output << "calls=#{callee.called} #{callee.line}\n"

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

@@ -114,12 +114,12 @@ module RubyProf
     end
 
     def print_edges(total_time, method)
-      method.callers.sort_by(&:total_time).reverse.each do |call_info|
-        target_percentage = (call_info.target.total_time / total_time) * 100.0
+      method.call_trees.callers.sort_by(&:total_time).reverse.each do |call_tree|
+        target_percentage = (call_tree.target.total_time / total_time) * 100.0
         next if target_percentage < min_percent
 
         # Get children method
-        puts "#{dot_id(method)} -> #{dot_id(call_info.target)} [label=\"#{call_info.called}/#{call_info.target.called}\" fontsize=10 fontcolor=#{EDGE_COLOR}];"
+        puts "#{dot_id(method)} -> #{dot_id(call_tree.target)} [label=\"#{call_tree.called}/#{call_tree.target.called}\" fontsize=10 fontcolor=#{EDGE_COLOR}];"
       end
     end
 

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"
@@ -78,8 +78,7 @@ module RubyProf
     end
 
     def print_parents(thread, method)
-      return if method.root?
-      method.callers.sort_by(&:total_time).each do |caller|
+      method.call_trees.callers.sort_by(&:total_time).each do |caller|
         @output << " " * 2 * PERCENTAGE_WIDTH
         @output << sprintf("%#{TIME_WIDTH}.3f", caller.total_time)
         @output << sprintf("%#{TIME_WIDTH}.3f", caller.self_time)
@@ -88,13 +87,13 @@ module RubyProf
 
         call_called = "#{caller.called}/#{method.called}"
         @output << sprintf("%#{CALL_WIDTH}s", call_called)
-        @output << sprintf("     %s", caller.parent.full_name)
+        @output << sprintf("     %s", caller.parent.target.full_name)
         @output << "\n"
       end
     end
 
     def print_children(method)
-      method.callees.sort_by(&:total_time).reverse.each do |child|
+      method.call_trees.callees.sort_by(&:total_time).reverse.each do |child|
         # Get children method
 
         @output << " " * 2 * PERCENTAGE_WIDTH

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

@@ -12,7 +12,7 @@ module RubyProf
       @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)
+      @call_info_printer = CallInfoPrinter.new(result) if printers.include?(:call_tree)
 
       @stack_printer = CallStackPrinter.new(result) if printers.include?(:stack)
       @dot_printer = DotPrinter.new(result) if printers.include?(:dot)
@@ -58,7 +58,7 @@ module RubyProf
 
     # the name of the callinfo profile file
     def call_info_report
-      "#{@directory}/#{@profile}.call_info.txt"
+      "#{@directory}/#{@profile}.call_tree.txt"
     end
 
     # the name of the callgrind profile file

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,123 +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
-        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