ruby-prof 1.1.0

data/lib/ruby-prof/compatibility.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+
+# These methods are deprecated and are available for backwards compatability.
+module RubyProf
+  # call-seq:
+  # measure_mode -> measure_mode
+  #
+  # Returns what ruby-prof is measuring.  Valid values include:
+  #
+  # * RubyProf::WALL_TIME
+  # * RubyProf::PROCESS_TIME
+  # * RubyProf::ALLOCATIONS
+  # * RubyProf::MEMORY
+  def self.measure_mode
+    @measure_mode ||= RubyProf::WALL_TIME
+  end
+
+  # call-seq:
+  # measure_mode=value -> void
+  #
+  # Specifies what ruby-prof should measure.  Valid values include:
+  #
+  # * RubyProf::WALL_TIME - Wall time measures the real-world time elapsed between any two moments. If there are other processes concurrently running on the system that use significant CPU or disk time during a profiling run then the reported results will be larger than expected. On Windows, wall time is measured using GetTickCount(), on MacOS by mach_absolute_time, on Linux by clock_gettime and otherwise by gettimeofday.
+  # * RubyProf::PROCESS_TIME - Process time measures the time used by a process between any two moments. It is unaffected by other processes concurrently running on the system. Remember with process time that calls to methods like sleep will not be included in profiling results. On Windows, process time is measured using GetProcessTimes and on other platforms by clock_gettime.
+  # * RubyProf::ALLOCATIONS - Object allocations measures show how many objects each method in a program allocates. Measurements are done via Ruby's GC.stat api.
+  # * RubyProf::MEMORY - Memory measures how much memory each method in a program uses. Measurements are done via Ruby's TracePoint api.
+  def self.measure_mode=(value)
+    @measure_mode = value
+  end
+
+  # Returns the threads that ruby-prof should exclude from profiling
+  def self.exclude_threads
+    @exclude_threads ||= Array.new
+  end
+
+  # Specifies which threads ruby-prof should exclude from profiling
+  def self.exclude_threads=(value)
+    @exclude_threads = value
+  end
+
+  # Starts profiling
+  def self.start
+    ensure_not_running!
+    @profile = Profile.new(:measure_mode => measure_mode, :exclude_threads => exclude_threads)
+    @profile.start
+  end
+
+  # Pauses profiling
+  def self.pause
+    ensure_running!
+    @profile.pause
+  end
+
+  # Is a profile running?
+  def self.running?
+    if defined?(@profile) and @profile
+      @profile.running?
+    else
+      false
+    end
+  end
+
+  # Resume profiling
+  def self.resume
+    ensure_running!
+    @profile.resume
+  end
+
+  # Stops profiling
+  def self.stop
+    ensure_running!
+    result = @profile.stop
+    @profile = nil
+    result
+  end
+
+  # Profiles a block
+  def self.profile(options = {}, &block)
+    ensure_not_running!
+    options = {:measure_mode => measure_mode, :exclude_threads => exclude_threads }.merge!(options)
+    Profile.profile(options, &block)
+  end
+
+  # :nodoc:
+  def self.measure_mode_string
+    case measure_mode
+      when WALL_TIME    then "wall_time"
+      when PROCESS_TIME then "process_time"
+      when ALLOCATIONS  then "allocations"
+      when MEMORY       then "memory"
+    end
+  end
+
+  # :nodoc:
+  def self.start_script(script)
+    start
+    load script
+  end
+
+  private
+
+  def self.ensure_running!
+    raise(RuntimeError, "RubyProf.start was not yet called") unless running?
+  end
+
+  def self.ensure_not_running!
+    raise(RuntimeError, "RubyProf is already running") if running?
+  end
+end

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,14 @@
+module RubyProf
+  # The Measurement class is a helper class used by RubyProf::MethodInfo to store information about the method.
+  # You cannot create a CallInfo object directly, they are generated while running a profile.
+  class Measurement
+    # :nodoc:
+    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,90 @@
+# 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
+
+    # The min call depth of this method
+    def min_depth
+      @min_depth ||= callers.map(&:depth).min
+    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.min_depth < other.min_depth
+        1
+      elsif self.min_depth > other.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
+
+    # Remove method from the call graph. should not be called directly.
+    def eliminate!
+      # $stderr.puts "eliminating #{self}"
+      callers.each{ |call_info| call_info.eliminate! }
+      callers.clear
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# 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 total time a method must take to be included in a profiling report
+    def min_percent
+      @options[:min_percent] || 0
+    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" % RubyProf.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