ruby-prof 1.4.4-x64-mingw-ucrt

data/lib/ruby-prof/exclude_common_methods.rb

@@ -0,0 +1,198 @@
+require 'set'
+
+# :enddoc:
+module RubyProf
+  module ExcludeCommonMethods
+    ENUMERABLE_NAMES = Enumerable.instance_methods(false)
+
+    def self.apply!(profile)
+      ##
+      #  Kernel Methods
+      ##
+
+      exclude_methods(profile, Kernel, [
+        :dup,
+        :initialize_dup,
+        :tap,
+        :send,
+        :public_send,
+      ])
+
+      ##
+      #  Fundamental Types
+      ##
+
+      exclude_methods(profile, BasicObject,  :"!=")
+      exclude_methods(profile, Method,       :"[]")
+      exclude_methods(profile, Module,       :new)
+      exclude_methods(profile, Class,        :new)
+      exclude_methods(profile, Proc,         :call, :yield)
+      exclude_methods(profile, Range,        :each)
+      exclude_methods(profile, Integer,      :times)
+
+      ##
+      #  Value Types
+      ##
+
+      exclude_methods(profile, String, [
+        :sub,
+        :sub!,
+        :gsub,
+        :gsub!,
+      ])
+
+      ##
+      #  Emumerables
+      ##
+
+      exclude_enumerable(profile, Enumerable)
+      exclude_enumerable(profile, Enumerator)
+
+      ##
+      #  Collections
+      ##
+
+      exclude_enumerable(profile, Array, [
+        :each_index,
+        :map!,
+        :select!,
+        :reject!,
+        :collect!,
+        :sort!,
+        :sort_by!,
+        :index,
+        :delete_if,
+        :keep_if,
+        :drop_while,
+        :uniq,
+        :uniq!,
+        :"==",
+        :eql?,
+        :hash,
+        :to_json,
+        :as_json,
+        :encode_json,
+      ])
+
+      exclude_enumerable(profile, Hash, [
+        :dup,
+        :initialize_dup,
+        :fetch,
+        :"[]",
+        :"[]=",
+        :each_key,
+        :each_value,
+        :each_pair,
+        :map!,
+        :select!,
+        :reject!,
+        :collect!,
+        :delete_if,
+        :keep_if,
+        :slice,
+        :slice!,
+        :except,
+        :except!,
+        :"==",
+        :eql?,
+        :hash,
+        :to_json,
+        :as_json,
+        :encode_json,
+      ])
+
+      exclude_enumerable(profile, Set, [
+        :map!,
+        :select!,
+        :reject!,
+        :collect!,
+        :classify,
+        :delete_if,
+        :keep_if,
+        :divide,
+        :"==",
+        :eql?,
+        :hash,
+        :to_json,
+        :as_json,
+        :encode_json,
+      ])
+
+      ##
+      #  Garbage Collection
+      ##
+
+      exclude_singleton_methods(profile, GC, [
+        :start
+      ])
+
+      ##
+      #  Unicorn
+      ##
+
+      if defined?(Unicorn)
+        exclude_methods(profile, Unicorn::HttpServer, :process_client)
+      end
+
+      if defined?(Unicorn::OobGC)
+        exclude_methods(profile, Unicorn::OobGC, :process_client)
+      end
+
+      ##
+      #  New Relic
+      ##
+
+      if defined?(NewRelic::Agent)
+        if defined?(NewRelic::Agent::Instrumentation::MiddlewareTracing)
+          exclude_methods(profile, NewRelic::Agent::Instrumentation::MiddlewareTracing, [
+            :call
+          ])
+        end
+
+        if defined?(NewRelic::Agent::MethodTracerHelpers)
+          exclude_methods(profile, NewRelic::Agent::MethodTracerHelpers, [
+            :trace_execution_scoped,
+            :log_errors,
+          ])
+
+          exclude_singleton_methods(profile, NewRelic::Agent::MethodTracerHelpers, [
+            :trace_execution_scoped,
+            :log_errors,
+          ])
+        end
+
+        if defined?(NewRelic::Agent::MethodTracer)
+          exclude_methods(profile, NewRelic::Agent::MethodTracer, [
+            :trace_execution_scoped,
+            :trace_execution_unscoped,
+          ])
+        end
+      end
+
+        ##
+        #  Miscellaneous Methods
+        ##
+
+      if defined?(Mustache)
+        exclude_methods(profile, Mustache::Context, [
+          :fetch
+        ])
+      end
+    end
+
+    private
+
+    def self.exclude_enumerable(profile, mod, *method_or_methods)
+      exclude_methods(profile, mod, [:each, *method_or_methods])
+      exclude_methods(profile, mod, ENUMERABLE_NAMES)
+    end
+
+    def self.exclude_methods(profile, mod, *method_or_methods)
+      profile.exclude_methods!(mod, method_or_methods)
+    end
+
+    def self.exclude_singleton_methods(profile, mod, *method_or_methods)
+      profile.exclude_singleton_methods!(mod, method_or_methods)
+    end
+  end
+end

data/lib/ruby-prof/measurement.rb

@@ -0,0 +1,17 @@
+module RubyProf
+  # The Measurement class is a helper class used by RubyProf::MethodInfo to store information about the method.
+  # You cannot create a CallTree object directly, they are generated while running a profile.
+  class Measurement
+    def children_time
+      self.total_time - self.self_time - self.wait_time
+    end
+
+    def to_s
+      "c: #{called}, tt: #{total_time}, st: #{self_time}"
+    end
+
+    def inspect
+      super + "(#{self.to_s})"
+    end
+  end
+end

data/lib/ruby-prof/method_info.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+module RubyProf
+  # The MethodInfo class is used to track information about each method that is profiled.
+  # You cannot create a MethodInfo object directly, they are generated while running a profile.
+  class MethodInfo
+    include Comparable
+
+    # Returns the full name of a class. The interpretation of method names is:
+    #
+    # * MyObject#test - An method defined in a class
+    # * <Class:MyObject>#test - A method defined in a singleton class.
+    # * <Module:MyObject>#test - A method defined in a singleton module.
+    # * <Object:MyObject>#test - A method defined in a singleton object.
+    def full_name
+      decorated_class_name = case self.klass_flags
+                             when 0x2
+                               "<Class::#{klass_name}>"
+                             when 0x4
+                               "<Module::#{klass_name}>"
+                             when 0x8
+                               "<Object::#{klass_name}>"
+                             else
+                               klass_name
+                             end
+
+      "#{decorated_class_name}##{method_name}"
+    end
+
+    # The number of times this method was called
+    def called
+      self.measurement.called
+    end
+
+    # The total time this method took - includes self time + wait time + child time
+    def total_time
+      self.measurement.total_time
+    end
+
+    # The time this method took to execute
+    def self_time
+      self.measurement.self_time
+    end
+
+    # The time this method waited for other fibers/threads to execute
+    def wait_time
+      self.measurement.wait_time
+    end
+
+    # The time this method's children took to execute
+    def children_time
+      self.total_time - self.self_time - self.wait_time
+    end
+
+    # :enddoc:
+    def <=>(other)
+      if other.nil?
+        -1
+      elsif self.full_name == other.full_name
+        0
+      elsif self.total_time < other.total_time
+        -1
+      elsif self.total_time > other.total_time
+        1
+      elsif self.call_trees.min_depth < other.call_trees.min_depth
+        1
+      elsif self.call_trees.min_depth > other.call_trees.min_depth
+        -1
+      else
+        self.full_name <=> other.full_name
+      end
+    end
+
+    def to_s
+      "#{self.full_name} (c: #{self.called}, tt: #{self.total_time}, st: #{self.self_time}, wt: #{wait_time}, ct: #{self.children_time})"
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# encoding: utf-8
+
+module RubyProf
+  # This is the base class for all Printers. It is never used directly.
+  class AbstractPrinter
+    # :stopdoc:
+    def self.needs_dir?
+      false
+    end
+    # :startdoc:
+
+    # Create a new printer.
+    #
+    # result should be the output generated from a profiling run
+    def initialize(result)
+      @result = result
+      @output = nil
+    end
+
+    # 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)'
+    end
+
+    # Returns how profile data should be sorted
+    def sort_method
+      @options[:sort_method]
+    end
+
+    # Prints a report to the provided output.
+    #
+    # output - Any IO object, including STDOUT or a file.
+    # The default value is STDOUT.
+    #
+    # options - Hash of print options. Note that each printer can
+    # define its own set of options.
+    #
+    #   :min_percent - Number 0 to 100 that specifes the minimum
+    #                  %self (the methods self time divided by the
+    #                  overall total time) that a method must take
+    #                  for it to be printed out in the report.
+    #                  Default value is 0.
+    #
+    #   :sort_method - Specifies method used for sorting method infos.
+    #                  Available values are :total_time, :self_time,
+    #                  :wait_time, :children_time
+    #                  Default value is :total_time
+    def print(output = STDOUT, options = {})
+      @output = output
+      setup_options(options)
+      print_threads
+    end
+
+    # :nodoc:
+    def setup_options(options = {})
+      @options = options
+    end
+
+    def method_location(method)
+      if method.source_file
+        "#{method.source_file}:#{method.line}"
+      end
+    end
+
+    def method_href(thread, method)
+      h(method.full_name.gsub(/[><#\.\?=:]/,"_") + "_" + thread.fiber_id.to_s)
+    end
+
+    def open_asset(file)
+      path = File.join(File.expand_path('../../assets', __FILE__), file)
+      File.open(path, 'rb').read
+    end
+
+    def print_threads
+      @result.threads.each do |thread|
+        print_thread(thread)
+      end
+    end
+
+    def print_thread(thread)
+      print_header(thread)
+      print_methods(thread)
+      print_footer(thread)
+    end
+
+    def print_header(thread)
+      @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
+      @output << "Sort by: #{sort_method}\n"
+      @output << "\n"
+      print_column_headers
+    end
+
+    def print_column_headers
+    end
+
+    def print_footer(thread)
+      @output << <<~EOT
+
+        * recursively called methods
+
+        Columns are:
+
+          %self     - The percentage of time spent in this method, derived from self_time/total_time.
+          total     - The time spent in this method and its children.
+          self      - The time spent in this method.
+          wait      - The amount of time this method waited for other threads.
+          child     - The time spent in this method's children.
+          calls     - The number of times this method was called.
+          name      - The name of the method.
+          location  - The location of the method.
+
+        The interpretation of method names is:
+
+          * MyObject#test - An instance method "test" of the class "MyObject"
+          * <Object:MyObject>#test - The <> characters indicate a method on a singleton class.
+      EOT
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module RubyProf
+  # Prints out the call graph based on CallTree instances. This
+  # is mainly for debugging purposes as it provides access into
+  # into RubyProf's internals.
+  #
+  # To use the printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::CallInfoPrinter.new(result)
+  #   printer.print(STDOUT)
+  class CallInfoPrinter < AbstractPrinter
+    TIME_WIDTH = 0
+
+    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"
+      @output << "Sort by: #{sort_method}\n"
+      @output << "\n"
+    end
+
+    def print_methods(thread)
+      visitor = CallTreeVisitor.new(thread.call_tree)
+
+      visitor.visit do |call_tree, event|
+        if event == :enter
+          @output << "  " * call_tree.depth
+          @output << call_tree.target.full_name
+          @output << " ("
+          @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
+      end
+    end
+
+    def print_footer(thread)
+      @output << "\n" << "\n"
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+# encoding: utf-8
+
+require 'erb'
+require 'fileutils'
+require 'base64'
+require 'set'
+require 'stringio'
+
+module RubyProf
+  # Prints a HTML visualization of the call tree.
+  #
+  # To use the printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::CallStackPrinter.new(result)
+  #   printer.print(STDOUT)
+
+  class CallStackPrinter < AbstractPrinter
+    include ERB::Util
+
+    # Specify print options.
+    #
+    # options - Hash table
+    #   :min_percent - Number 0 to 100 that specifes the minimum
+    #                  %self (the methods self time divided by the
+    #                  overall total time) that a method must take
+    #                  for it to be printed out in the report.
+    #                  Default value is 0.
+    #
+    #   :threshold   - a float from 0 to 100 that sets the threshold of
+    #                  results displayed.
+    #                  Default value is 1.0
+    #
+    #   :title       - a String to overide the default "ruby-prof call tree"
+    #                  title of the report.
+    #
+    #   :expansion   - a float from 0 to 100 that sets the threshold of
+    #                  results that are expanded, if the percent_total
+    #                  exceeds it.
+    #                  Default value is 10.0
+    #
+    #   :application - a String to overide the name of the application,
+    #                  as it appears on the report.
+    def print(output = STDOUT, options = {})
+      setup_options(options)
+      output << @erb.result(binding)
+    end
+
+    # :enddoc:
+    def setup_options(options)
+      super(options)
+      @erb = ERB.new(self.template)
+    end
+
+    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)
+      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_tree)
+        output << "<a href=\"#\" class=\"toggle empty\" ></a>" << "\n"
+        output << "<span>%s %s</span>" % [link(call_tree.target, true), graph_link(call_tree)] << "\n"
+      else
+        visited << call_tree
+
+        if call_tree.children.empty?
+          output << "<a href=\"#\" class=\"toggle empty\" ></a>" << "\n"
+        else
+          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_tree.target, false), graph_link(call_tree)] << "\n"
+
+        unless call_tree.children.empty?
+          output <<  (expanded ? '<ul>' : '<ul style="display:none">')  << "\n"
+          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_tree)
+      end
+      output << '</li>' << "\n"
+    end
+
+    def name(call_tree)
+      method = call_tree.target
+      method.full_name
+    end
+
+    def link(method, recursive)
+      method_name = "#{recursive ? '*' : ''}#{method.full_name}"
+      if method.source_file.nil?
+        h method_name
+      else
+        file = File.expand_path(method.source_file)
+       "<a href=\"file://#{file}##{method.line}\">#{h method_name}</a>"
+      end
+    end
+
+    def graph_link(call_tree)
+      total_calls = call_tree.target.called
+      totals = total_calls.to_s
+      "[#{call_tree.called} calls, #{totals} total]"
+    end
+
+    def method_href(method)
+      h(method.full_name.gsub(/[><#\.\?=:]/,"_"))
+    end
+
+    def total_time(call_trees)
+      sum(call_trees.map{|ci| ci.total_time})
+    end
+
+    def sum(a)
+      a.inject(0.0){|s,t| s+=t}
+    end
+
+    def dump(ci)
+      $stderr.printf "%s/%d t:%f s:%f w:%f  \n", ci, ci.object_id, ci.total_time, ci.self_time, ci.wait_time
+    end
+
+    def color(p)
+      case i = p.to_i
+      when 0..5
+        "01"
+      when 5..10
+        "05"
+      when 100
+        "9"
+      else
+        "#{i/10}"
+      end
+    end
+
+    def application
+      @options[:application] || $PROGRAM_NAME
+    end
+
+    def arguments
+      ARGV.join(' ')
+    end
+
+    def title
+      @title ||= @options.delete(:title) || "ruby-prof call tree"
+    end
+
+    def threshold
+      @options[:threshold] || 1.0
+    end
+
+    def expansion
+      @options[:expansion] || 10.0
+    end
+
+    def base64_image
+      @data ||= begin
+        file = open_asset('call_stack_printer.png')
+        Base64.encode64(file).gsub(/\n/, '')
+      end
+    end
+
+    def template
+      open_asset('call_stack_printer.html.erb')
+    end
+  end
+end