ruby-prof 1.1.0

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

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+module RubyProf
+  # Generates flat[link:files/examples/flat_txt.html] profile reports as text.
+  # To use the flat printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::FlatPrinter.new(result)
+  #   printer.print(STDOUT, {})
+  #
+  class FlatPrinter < AbstractPrinter
+    # Override for this printer to sort by self time by default
+    def sort_method
+      @options[:sort_method] || :self_time
+    end
+
+    private
+
+    def print_column_headers
+      @output << " %self      total      self      wait     child     calls  name                           location\n"
+    end
+
+    def print_methods(thread)
+      total_time = thread.total_time
+      methods = thread.methods.sort_by(&sort_method).reverse
+
+      sum = 0
+      methods.each do |method|
+        self_percent = (method.self_time / total_time) * 100
+        next if self_percent < min_percent
+
+        sum += method.self_time
+        #self_time_called = method.called > 0 ? method.self_time/method.called : 0
+        #total_time_called = method.called > 0? method.total_time/method.called : 0
+
+        @output << "%6.2f  %9.3f %9.3f %9.3f %9.3f %8d  %s%-30s %s\n" % [
+                      method.self_time / total_time * 100, # %self
+                      method.total_time,                   # total
+                      method.self_time,                    # self
+                      method.wait_time,                    # wait
+                      method.children_time,                # children
+                      method.called,                       # calls
+                      method.recursive? ? "*" : " ",       # cycle
+                      method.full_name,                    # method_name]
+                      method_location(method)]             # location]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+require 'erb'
+
+module RubyProf
+  # Generates graph[link:files/examples/graph_html.html] profile reports as html.
+  # To use the graph html printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::GraphHtmlPrinter.new(result)
+  #   printer.print(STDOUT, :min_percent=>0)
+  #
+  # The Graph printer takes the following options in its print methods:
+
+  class GraphHtmlPrinter < AbstractPrinter
+    include ERB::Util
+
+    def setup_options(options)
+      super(options)
+      @erb = ERB.new(self.template)
+    end
+
+    def print(output = STDOUT, options = {})
+      setup_options(options)
+      output << @erb.result(binding)
+    end
+
+    # Creates a link to a method.  Note that we do not create
+    # links to methods which are under the min_perecent
+    # specified by the user, since they will not be
+    # printed out.
+    def create_link(thread, overall_time, method)
+      total_percent = (method.total_time/overall_time) * 100
+      if total_percent < min_percent
+        # Just return name
+        h method.full_name
+      else
+        href = '#' + method_href(thread, method)
+        "<a href=\"#{href}\">#{h method.full_name}</a>"
+      end
+    end
+
+    def method_href(thread, method)
+      h(method.full_name.gsub(/[><#\.\?=:]/,"_") + "_" + thread.fiber_id.to_s)
+    end
+
+    def file_link(path, linenum)
+      if path.nil?
+        ""
+      else
+        srcfile = File.expand_path(path)
+        "<a href=\"file://#{h srcfile}##{linenum}\" title=\"#{h srcfile}:#{linenum}\">#{linenum}</a>"
+      end
+    end
+
+    def template
+      open_asset('graph_printer.html.erb')
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# encoding: utf-8
+
+module RubyProf
+  # Generates graph[link:files/examples/graph_txt.html] profile reports as text.
+  # To use the graph printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::GraphPrinter.new(result)
+  #   printer.print(STDOUT, {})
+  #
+  # The constructor takes two arguments. See the README
+
+  class GraphPrinter < AbstractPrinter
+    PERCENTAGE_WIDTH = 8
+    TIME_WIDTH = 11
+    CALL_WIDTH = 17
+
+    private
+
+    def sort_method
+      @options[:sort_method] || :total_time
+    end
+
+    def print_header(thread)
+      @output << "Measure Mode: %s\n" % RubyProf.measure_mode_string
+      @output << "Thread ID: #{thread.id}\n"
+      @output << "Fiber ID: #{thread.fiber_id}\n"
+      @output << "Total Time: #{thread.total_time}\n"
+      @output << "Sort by: #{sort_method}\n"
+      @output << "\n"
+
+      # 1 is for % sign
+      @output << sprintf("%#{PERCENTAGE_WIDTH}s", "%total")
+      @output << sprintf("%#{PERCENTAGE_WIDTH}s", "%self")
+      @output << sprintf("%#{TIME_WIDTH}s", "total")
+      @output << sprintf("%#{TIME_WIDTH}s", "self")
+      @output << sprintf("%#{TIME_WIDTH}s", "wait")
+      @output << sprintf("%#{TIME_WIDTH}s", "child")
+      @output << sprintf("%#{CALL_WIDTH}s", "calls")
+      @output << "     name"
+      @output << "                          location"
+      @output << "\n"
+    end
+
+    def print_methods(thread)
+      total_time = thread.total_time
+      # Sort methods from longest to shortest total time
+      methods = thread.methods.sort_by(&sort_method)
+
+      # Print each method in total time order
+      methods.reverse_each do |method|
+        total_percentage = (method.total_time/total_time) * 100
+        next if total_percentage < min_percent
+
+        self_percentage = (method.self_time/total_time) * 100
+
+        @output << "-" * 150 << "\n"
+        print_parents(thread, method)
+
+        # 1 is for % sign
+        @output << sprintf("%#{PERCENTAGE_WIDTH-1}.2f%%", total_percentage)
+        @output << sprintf("%#{PERCENTAGE_WIDTH-1}.2f%%", self_percentage)
+        @output << sprintf("%#{TIME_WIDTH}.3f", method.total_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", method.self_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", method.wait_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", method.children_time)
+        @output << sprintf("%#{CALL_WIDTH}i", method.called)
+        @output << sprintf("    %s",  method.recursive? ? "*" : " ")
+        @output << sprintf("%-30s", method.full_name)
+        @output << sprintf(" %s", method_location(method))
+        @output << "\n"
+
+        print_children(method)
+      end
+    end
+
+    def print_parents(thread, method)
+      return if method.root?
+      method.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)
+        @output << sprintf("%#{TIME_WIDTH}.3f", caller.wait_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", caller.children_time)
+
+        call_called = "#{caller.called}/#{method.called}"
+        @output << sprintf("%#{CALL_WIDTH}s", call_called)
+        @output << sprintf("     %s", caller.parent.full_name)
+        @output << "\n"
+      end
+    end
+
+    def print_children(method)
+      method.callees.sort_by(&:total_time).reverse.each do |child|
+        # Get children method
+
+        @output << " " * 2 * PERCENTAGE_WIDTH
+
+        @output << sprintf("%#{TIME_WIDTH}.3f", child.total_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", child.self_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", child.wait_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", child.children_time)
+
+        call_called = "#{child.called}/#{child.target.called}"
+        @output << sprintf("%#{CALL_WIDTH}s", call_called)
+        @output << sprintf("     %s", child.target.full_name)
+        @output << "\n"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# encoding: utf-8
+
+module RubyProf
+  # Helper class to simplify printing profiles of several types from
+  # 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 = [: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?
+      true
+    end
+
+    # create profile files under options[:path] or the current
+    # directory. options[:profile] is used as the base name for the
+    # 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_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_dot(options) if @dot_printer
+    end
+
+    # the name of the flat profile file
+    def flat_report
+      "#{@directory}/#{@profile}.flat.txt"
+    end
+
+    # the name of the graph profile file
+    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_report
+      "#{@directory}/#{@profile}.callgrind.out.#{$$}"
+    end
+
+    # the name of the call stack profile file
+    def stack_report
+      "#{@directory}/#{@profile}.stack.html"
+    end
+
+    # 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_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
+
+    def print_to_tree(options)
+      @tree_printer.print(options.merge(:path => @directory, :profile => @profile))
+    end
+
+    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
+
+    def validate_print_params(options)
+      if options.is_a?(IO)
+        raise ArgumentError, "#{self.class.name}#print cannot print to IO objects"
+      elsif !options.is_a?(Hash)
+        raise ArgumentError, "#{self.class.name}#print requires an options hash"
+      end
+    end
+  end
+end

data/lib/ruby-prof/profile.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'ruby-prof/exclude_common_methods'
+
+module RubyProf
+  class Profile
+    # :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.
+    def exclude_common_methods!
+      ExcludeCommonMethods.apply!(self)
+    end
+
+    def exclude_methods!(mod, *method_or_methods)
+      [method_or_methods].flatten.each do |name|
+        exclude_method!(mod, name)
+      end
+    end
+
+    def exclude_singleton_methods!(mod, *method_or_methods)
+      exclude_methods!(mod.singleton_class, *method_or_methods)
+    end
+  end
+end

data/lib/ruby-prof/rack.rb

@@ -0,0 +1,171 @@
+# encoding: utf-8
+require 'tmpdir'
+
+module Rack
+  class RubyProf
+    def initialize(app, options = {})
+      @app = app
+
+      options[:min_percent] ||= 1
+
+      options[:path] ||= Dir.tmpdir
+      FileUtils.mkdir_p(options[:path])
+
+      @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
+
+        if profiler.max_requests_reached?
+          prefix = if aggregate_requests?
+              nil
+            else
+              request.path.gsub('/', '-')[1..-1]
+            end
+
+          profiler.print!(prefix)
+          delete_profiler!
+        end
+
+        result
+      else
+        @app.call(env)
+      end
+    end
+
+    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
+
+        @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
+
+      def resume
+        @profile.resume
+      end
+
+      def pause
+        @profile.pause
+        @requests_count += 1
+      end
+
+      def max_requests_reached?
+        @requests_count >= @max_requests
+      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
+
+          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
+        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
+          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