ruby-prof 1.0.0

data/lib/ruby-prof/call_info.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+module RubyProf
+  # The CallInfo class is used to track the relationships between methods. It is a helper class used by
+  # RubyProf::MethodInfo to keep track of which methods called a given method and which methods a given
+  # method called. Each CallInfo has a parent and target method. You cannot create a CallInfo object directly,
+  # they are generated while running a profile.
+  class CallInfo
+    # The number of times the parent method called the target method
+    def called
+      self.measurement.called
+    end
+
+    # The total time resulting from the parent method calling the target method
+    def total_time
+      self.measurement.total_time
+    end
+
+    # The self time (of the parent) resulting from the parent method calling the target method
+    def self_time
+      self.measurement.self_time
+    end
+
+    # The wait time (of the parent) resulting from the parent method calling the target method
+    def wait_time
+      self.measurement.wait_time
+    end
+
+    # The time spent in child methods resulting from the parent method calling the target method
+    def children_time
+      self.total_time - self.self_time - self.wait_time
+    end
+
+    # Compares two CallInfo instances. The comparison is based on the CallInfo#parent, CallInfo#target,
+    # and total time.
+    def <=>(other)
+      if self.target == other.target && self.parent == other.parent
+        0
+      elsif self.total_time < other.total_time
+        -1
+      elsif self.total_time > other.total_time
+        1
+      else
+        self.target.full_name <=> other.target.full_name
+      end
+    end
+
+    # :nodoc:
+    def to_s
+      "#{parent ? parent.full_name : '<nil>'} - #{target.full_name}"
+    end
+
+    def inspect
+      super + "(#{self.to_s})"
+    end
+  end
+end

data/lib/ruby-prof/call_info_visitor.rb

@@ -0,0 +1,38 @@
+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

@@ -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