ruby-prof 0.18.0 → 1.2.0

data/lib/ruby-prof/compatibility.rb

@@ -1,53 +1,16 @@
 # encoding: utf-8
 
-# These methods are here for backwards compatability with previous RubyProf releases
+# These methods are deprecated and are available for backwards compatability.
 module RubyProf
-  # Measurements
-  def self.cpu_frequency
-    Measure::CpuTime.frequency
-  end
-
-  def self.measure_allocations
-    Measure::Allocations.measure
-  end
-
-  def self.measure_cpu_time
-    Measure::CpuTime.measure
-  end
-
-  def self.measure_gc_runs
-    Measure::GcRuns.measure
-  end
-
-  def self.measure_gc_time
-    Measure::GcTime.measure
-  end
-
-  def self.measure_memory
-    Measure::Memory.measure
-  end
-
-  def self.measure_process_time
-    Measure::ProcessTime.measure
-  end
-
-  def self.measure_wall_time
-    Measure::WallTime.measure
-  end
-
   # call-seq:
   # measure_mode -> measure_mode
   #
   # Returns what ruby-prof is measuring.  Valid values include:
   #
-  # *RubyProf::WALL_TIME - Measure wall time using gettimeofday on Linx and GetLocalTime on Windows.  This is default.
-  # *RubyProf::PROCESS_TIME - Measure process time.  It is implemented using the clock functions in the C Runtime library.
-  # *RubyProf::CPU_TIME - Measure time using the CPU clock counter.  This mode is only supported on Pentium or PowerPC platforms.
-  # *RubyProf::ALLOCATIONS - Measure object allocations.  This requires a patched Ruby interpreter.
-  # *RubyProf::MEMORY - Measure memory size.  This requires a patched Ruby interpreter.
-  # *RubyProf::GC_RUNS - Measure number of garbage collections.  This requires a patched Ruby interpreter.
-  # *RubyProf::GC_TIME - Measure time spent doing garbage collection.  This requires a patched Ruby interpreter.*/
-
+  # * RubyProf::WALL_TIME
+  # * RubyProf::PROCESS_TIME
+  # * RubyProf::ALLOCATIONS
+  # * RubyProf::MEMORY
   def self.measure_mode
     @measure_mode ||= RubyProf::WALL_TIME
   end
@@ -57,66 +20,38 @@ module RubyProf
   #
   # Specifies what ruby-prof should measure.  Valid values include:
   #
-  # *RubyProf::WALL_TIME - Measure wall time using gettimeofday on Linx and GetLocalTime on Windows.  This is default.
-  # *RubyProf::PROCESS_TIME - Measure process time.  It is implemented using the clock functions in the C Runtime library.
-  # *RubyProf::CPU_TIME - Measure time using the CPU clock counter.  This mode is only supported on Pentium or PowerPC platforms.
-  # *RubyProf::ALLOCATIONS - Measure object allocations.  This requires a patched Ruby interpreter.
-  # *RubyProf::MEMORY - Measure memory size.  This requires a patched Ruby interpreter.
-  # *RubyProf::GC_RUNS - Measure number of garbage collections.  This requires a patched Ruby interpreter.
-  # *RubyProf::GC_TIME - Measure time spent doing garbage collection.  This requires a patched Ruby interpreter.*/
+  # * 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
 
-  def self.measure_mode_string
-    case measure_mode
-    when WALL_TIME    then "wall_time"
-    when CPU_TIME     then "cpu_time"
-    when PROCESS_TIME then "process_time_time"
-    when ALLOCATIONS  then "allocations"
-    when MEMORY       then "memory"
-    when GC_TIME      then "gc_time"
-    when GC_RUNS      then "gc_runs"
-    end
-  end
-
-  # call-seq:
-  # exclude_threads -> exclude_threads
-  #
-  # Returns threads ruby-prof should exclude from profiling
-
+  # Returns the threads that ruby-prof should exclude from profiling
   def self.exclude_threads
     @exclude_threads ||= Array.new
   end
 
-  # call-seq:
-  # exclude_threads= -> void
-  #
-  # Specifies what threads ruby-prof should exclude from profiling
-
+  # Specifies which threads ruby-prof should exclude from profiling
   def self.exclude_threads=(value)
     @exclude_threads = value
   end
 
-  # Profiling
-  def self.start_script(script)
-    start
-    load script
-  end
-
+  # Starts profiling
   def self.start
     ensure_not_running!
-    @profile = Profile.new(measure_mode: measure_mode, exclude_threads: exclude_threads)
-    enable_gc_stats_if_needed
+    @profile = Profile.new(:measure_mode => measure_mode, :exclude_threads => exclude_threads)
     @profile.start
   end
 
+  # Pauses profiling
   def self.pause
     ensure_running!
-    disable_gc_stats_if_needed
     @profile.pause
   end
 
+  # Is a profile running?
   def self.running?
     if defined?(@profile) and @profile
       @profile.running?
@@ -125,55 +60,50 @@ module RubyProf
     end
   end
 
+  # Resume profiling
   def self.resume
     ensure_running!
-    enable_gc_stats_if_needed
     @profile.resume
   end
 
+  # Stops profiling
   def self.stop
     ensure_running!
     result = @profile.stop
-    disable_gc_stats_if_needed
     @profile = nil
     result
   end
 
-  # Profile a block
+  # Profiles a block
   def self.profile(options = {}, &block)
     ensure_not_running!
-    gc_stat_was_enabled = enable_gc_stats_if_needed
-    options = { measure_mode: measure_mode, exclude_threads: exclude_threads }.merge!(options)
-    result = Profile.profile(options, &block)
-  ensure
-    disable_gc_stats_if_needed(gc_stat_was_enabled)
-    result
+    options = {:measure_mode => measure_mode, :exclude_threads => exclude_threads }.merge!(options)
+    Profile.profile(options, &block)
   end
 
-
-private
-  def self.ensure_running!
-    raise(RuntimeError, "RubyProf.start was not yet called") unless running?
+  # :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
 
-  def self.ensure_not_running!
-    raise(RuntimeError, "RubyProf is already running") if running?
+  # :nodoc:
+  def self.start_script(script)
+    start
+    load script
   end
 
-  # for GC.allocated_size to work GC statistics should be enabled
-  def self.enable_gc_stats_if_needed
-    if measure_mode_requires_gc_stats_enabled?
-      @gc_stat_was_enabled = GC.enable_stats
-    end
-  end
+  private
 
-  def self.disable_gc_stats_if_needed(was_enabled=nil)
-    was_enabled ||= defined?(@gc_stat_was_enabled) && @gc_stat_was_enabled
-    GC.disable_stats if measure_mode_requires_gc_stats_enabled? && !was_enabled
+  def self.ensure_running!
+    raise(RuntimeError, "RubyProf.start was not yet called") unless running?
   end
 
-  def self.measure_mode_requires_gc_stats_enabled?
-    GC.respond_to?(:enable_stats) &&
-      [RubyProf::MEMORY, RubyProf::GC_TIME, RubyProf::GC_RUNS].include?(measure_mode)
+  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,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

@@ -1,121 +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
 
-    def <=>(other)
-      if 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
+    # 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
-      @called ||= begin
-        call_infos.inject(0) do |sum, call_info|
-          sum + call_info.called
-        end
-      end
+      self.measurement.called
     end
 
+    # The total time this method took - includes self time + wait time + child time
     def total_time
-      @total_time ||= begin
-        call_infos.inject(0) do |sum, call_info|
-          sum += call_info.total_time if !call_info.recursive?
-          sum
-        end
-      end
+      self.measurement.total_time
     end
 
+    # The time this method took to execute
     def self_time
-      @self_time ||= begin
-        call_infos.inject(0) do |sum, call_info|
-          sum += call_info.self_time if !call_info.recursive?
-          sum
-        end
-      end
+      self.measurement.self_time
     end
 
+    # The time this method waited for other fibers/threads to execute
     def wait_time
-      @wait_time ||= begin
-        call_infos.inject(0) do |sum, call_info|
-          sum += call_info.wait_time if !call_info.recursive?
-          sum
-        end
-      end
+      self.measurement.wait_time
     end
 
+    # The time this method's children took to execute
     def children_time
-      @children_time ||= begin
-        call_infos.inject(0) do |sum, call_info|
-          sum += call_info.children_time if !call_info.recursive?
-          sum
-        end
-      end
-    end
-
-    def min_depth
-      @min_depth ||= call_infos.map(&:depth).min
-    end
-
-    def root?
-      @root ||= begin
-        call_infos.find do |call_info|
-          not call_info.root?
-        end.nil?
-      end
-    end
-
-    def children
-      @children ||= call_infos.map(&:children).flatten
+      self.total_time - self.self_time - self.wait_time
     end
 
-    def parents
-      @parents ||= call_infos.map(&:parent)
-    end
-
-    def aggregate_parents
-      # group call infos based on their parents
-      groups = self.call_infos.each_with_object({}) do |call_info, hash|
-        key = call_info.parent ? call_info.parent.target : self
-        (hash[key] ||= []) << call_info
-      end
-
-      groups.map do |key, value|
-        AggregateCallInfo.new(value, self)
-      end
-    end
-
-    def aggregate_children
-      # group call infos based on their targets
-      groups = self.children.each_with_object({}) do |call_info, hash|
-        key = call_info.target
-        (hash[key] ||= []) << call_info
-      end
-
-      groups.map do |key, value|
-        AggregateCallInfo.new(value, self)
+    # :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
-
-    # remove method from the call graph. should not be called directly.
-    def eliminate!
-      # $stderr.puts "eliminating #{self}"
-      call_infos.each{ |call_info| call_info.eliminate! }
-      call_infos.clear
-    end
-
   end
 end