ruby-prof 0.16.2 → 1.1.0

data/lib/ruby-prof/call_info_visitor.rb

@@ -1,40 +1,38 @@
-# The call info visitor class does a depth-first traversal across a
-# list of method infos. At each call_info node, the visitor executes
-# the block provided in the #visit method. The block is passed two
-# parameters, the event and the call_info instance. Event will be
-# either :enter or :exit.
-#
-#   visitor = RubyProf::CallInfoVisitor.new(result.threads.first.top_call_infos)
-#
-#   method_names = Array.new
-#
-#   visitor.visit do |call_info, event|
-#     method_names << call_info.target.full_name if event == :enter
-#   end
-#
-#   puts method_names
-
-module RubyProf
-  class CallInfoVisitor
-
-    def initialize(call_infos)
-      @call_infos = CallInfo.roots_of(call_infos)
-    end
-
-    def visit(&block)
-      @call_infos.each do |call_info|
-        visit_call_info(call_info, &block)
-      end
-    end
-
-    private
-    def visit_call_info(call_info, &block)
-      yield call_info, :enter
-      call_info.children.each do |child|
-        visit_call_info(child, &block)
-      end
-      yield call_info, :exit
-    end
-  end
-
-end
+module RubyProf
+  # The call info visitor class does a depth-first traversal across a
+  # list of method infos. At each call_info node, the visitor executes
+  # the block provided in the #visit method. The block is passed two
+  # parameters, the event and the call_info instance. Event will be
+  # either :enter or :exit.
+  #
+  #   visitor = RubyProf::CallInfoVisitor.new(result.threads.first.root_methods)
+  #
+  #   method_names = Array.new
+  #
+  #   visitor.visit do |call_info, event|
+  #     method_names << call_info.target.full_name if event == :enter
+  #   end
+  #
+  #   puts method_names
+  class CallInfoVisitor
+    def initialize(root_methods)
+      @call_infos = root_methods.map(&:callers).flatten
+    end
+
+    def visit(&block)
+      @call_infos.each do |call_info|
+        visit_call_info(call_info, &block)
+      end
+    end
+
+    private
+
+    def visit_call_info(call_info, &block)
+      yield call_info, :enter
+      call_info.target.callees.each do |child|
+        visit_call_info(child, &block)
+      end
+      yield call_info, :exit
+    end
+  end
+end

data/lib/ruby-prof/compatibility.rb

@@ -1,178 +1,109 @@
-# encoding: utf-8
-
-# These methods are here for backwards compatability with previous RubyProf releases
-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.*/
-
-  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 - 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.*/
-  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
-
-  def self.exclude_threads
-    @exclude_threads ||= Array.new
-  end
-
-  # call-seq:
-  # exclude_threads= -> void
-  #
-  # Specifies what 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
-
-  def self.start
-    ensure_not_running!
-    @profile = Profile.new(measure_mode: measure_mode, exclude_threads: exclude_threads)
-    enable_gc_stats_if_needed
-    @profile.start
-  end
-
-  def self.pause
-    ensure_running!
-    disable_gc_stats_if_needed
-    @profile.pause
-  end
-
-  def self.running?
-    if defined?(@profile) and @profile
-      @profile.running?
-    else
-      false
-    end
-  end
-
-  def self.resume
-    ensure_running!
-    enable_gc_stats_if_needed
-    @profile.resume
-  end
-
-  def self.stop
-    ensure_running!
-    result = @profile.stop
-    disable_gc_stats_if_needed
-    @profile = nil
-    result
-  end
-
-  # Profile 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)
-    disable_gc_stats_if_needed(gc_stat_was_enabled)
-    result
-  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
-
-  # 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
-
-  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
-  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)
-  end
-end
+# 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