ruby-prof 0.18.0 → 1.2.0

data/lib/ruby-prof/call_info_visitor.rb

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

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

@@ -1,83 +0,0 @@
-# encoding: utf-8
-
-module RubyProf
-  # Generates flat[link:files/examples/flat_txt.html] profile reports as text.
-  # To use the flat printer with line numbers:
-  #
-  #   result = RubyProf.profile do
-  #     [code to profile]
-  #   end
-  #
-  #   printer = RubyProf::FlatPrinterWithLineNumbers.new(result)
-  #   printer.print(STDOUT, {})
-  #
-  class FlatPrinterWithLineNumbers < FlatPrinter
-    def print_methods(thread)
-      @editor = editor_uri
-      total_time = thread.total_time
-
-      methods = thread.methods.sort_by(&sort_method).reverse
-      sum = 0
-      methods.each do |method|
-        self_percent = (method.self_time / total_time) * 100
-        next if self_percent < min_percent
-
-        sum += method.self_time
-        #self_time_called = method.called > 0 ? method.self_time/method.called : 0
-        #total_time_called = method.called > 0? method.total_time/method.called : 0
-
-        @output << "%6.2f  %9.3f %9.3f %9.3f %9.3f %8d  %s%s" % [
-            method.self_time / total_time * 100, # %self
-            method.total_time,                   # total
-            method.self_time,                    # self
-            method.wait_time,                    # wait
-            method.children_time,                # children
-            method.called,                       # calls
-            method.recursive? ? "*" : " ",       # cycle
-            method_name(method)                  # name
-        ]
-         if method.source_file == 'ruby_runtime'
-           @output << "\n"
-         else
-           @output << "\n    defined at:\n"
-           @output << defined_at_format % [File.expand_path(method.source_file), method.line]
-         end
-
-         callers = []
-         method.call_infos.each do |ci|
-           if ci.parent && ci.parent.target.source_file != 'ruby_runtime'
-             callers << [method_name(ci.parent.target), File.expand_path(ci.parent.target.source_file), ci.parent.target.line]
-           end
-         end
-         # make sure callers are unique
-         callers.uniq!
-
-         unless callers.empty?
-           @output << "    called from:\n"
-           callers.each do |args|
-             @output << called_from_format % args
-           end
-         end
-         @output << "\n"
-      end
-    end
-
-    private
-
-    def defined_at_format
-      if @editor
-        "      #{@editor}://open?url=file://%s&line=%s\n"
-      else
-        "      %s:%s\n"
-      end
-    end
-
-    def called_from_format
-      if @editor
-        "      %s (#{@editor}://open?url=file://%s&line=%s)\n"
-      else
-        "      %s (%s:%s)\n"
-      end
-    end
-  end
-end

data/lib/ruby-prof/profile/exclude_common_methods.rb

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

data/lib/ruby-prof/profile/legacy_method_elimination.rb

@@ -1,50 +0,0 @@
-module RubyProf
-  class Profile
-    module LegacyMethodElimination
-      # eliminate some calls from the graph by merging the information into callers.
-      # matchers can be a list of strings or regular expressions or the name of a file containing regexps.
-      def eliminate_methods!(matchers)
-        RubyProf.deprecation_warning(
-          "Method 'eliminate_methods!' is deprecated",
-          "Please call 'exclude_methods!' before starting the profile run instead."
-        )
-        matchers = read_regexps_from_file(matchers) if matchers.is_a?(String)
-        eliminated = []
-        threads.each do |thread|
-          matchers.each{ |matcher| eliminated.concat(eliminate_methods(thread.methods, matcher)) }
-        end
-        eliminated
-      end
-
-      private
-
-      # read regexps from file
-      def read_regexps_from_file(file_name)
-        matchers = []
-        File.open(file_name).each_line do |l|
-          next if (l =~ /^(#.*|\s*)$/) # emtpy lines and lines starting with #
-          matchers << Regexp.new(l.strip)
-        end
-        matchers
-      end
-
-      # eliminate methods matching matcher
-      def eliminate_methods(methods, matcher)
-        eliminated = []
-        i = 0
-        while i < methods.size
-          method_info = methods[i]
-          method_name = method_info.full_name
-          if matcher === method_name
-            raise "can't eliminate root method" if method_info.root?
-            eliminated << methods.delete_at(i)
-            method_info.eliminate!
-          else
-            i += 1
-          end
-        end
-        eliminated
-      end
-    end
-  end
-end

data/test/aggregate_test.rb

@@ -1,136 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-# Test data
-#   A   B   C
-#   |   |   |
-#   Z   A   A
-#       |   |
-#       Z   Z
-
-class AggClass
-  def z
-    sleep 1
-  end
-
-  def a
-    z
-  end
-
-  def b
-    a
-  end
-
-  def c
-    a
-  end
-end
-
-class AggregateTest < TestCase
-  def setup
-    # Need to use wall time for this test due to the sleep calls
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-  end
-
-  def test_all_call_infos_are_not_recursive
-    c1 = AggClass.new
-    result = RubyProf.profile do
-      c1.a
-      c1.b
-      c1.c
-    end
-    methods = result.threads.first.methods.sort.reverse
-    methods.each do |m|
-      m.call_infos.each do |ci|
-        assert(!ci.recursive?)
-      end
-    end
-  end
-
-  def test_call_infos
-    c1 = AggClass.new
-    result = RubyProf.profile do
-      c1.a
-      c1.b
-      c1.c
-    end
-
-    methods = result.threads.first.methods.sort.reverse
-    method = methods.find {|meth| meth.full_name == 'AggClass#z'}
-
-    # Check AggClass#z
-    assert_equal('AggClass#z', method.full_name)
-    assert_equal(3, method.called)
-    assert_in_delta(3, method.total_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(3, method.children_time, 0.05)
-    assert_equal(3, method.call_infos.length)
-
-    call_info = method.call_infos[0]
-    assert_equal('AggregateTest#test_call_infos->AggClass#a->AggClass#z', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-
-    call_info = method.call_infos[1]
-    assert_equal('AggregateTest#test_call_infos->AggClass#b->AggClass#a->AggClass#z', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-
-    call_info = method.call_infos[2]
-    assert_equal('AggregateTest#test_call_infos->AggClass#c->AggClass#a->AggClass#z', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-  end
-
-  def test_aggregates_parents
-    c1 = AggClass.new
-    result = RubyProf.profile do
-      c1.a
-      c1.b
-      c1.c
-    end
-
-    methods = result.threads.first.methods.sort.reverse
-    method = methods.find {|meth| meth.full_name == 'AggClass#z'}
-
-    # Check AggClass#z
-    assert_equal('AggClass#z', method.full_name)
-
-    call_infos = method.aggregate_parents
-    assert_equal(1, call_infos.length)
-
-    call_info = call_infos.first
-    assert_equal('AggClass#a', call_info.parent.target.full_name)
-    assert_in_delta(3, call_info.total_time, 0.05)
-    assert_in_delta(0, call_info.wait_time, 0.05)
-    assert_in_delta(0, call_info.self_time, 0.05)
-    assert_in_delta(3, call_info.children_time, 0.05)
-    assert_equal(3, call_info.called)
-  end
-
-  def test_aggregates_children
-    c1 = AggClass.new
-    result = RubyProf.profile do
-      c1.a
-      c1.b
-      c1.c
-    end
-
-    methods = result.threads.first.methods.sort.reverse
-    method = methods.find {|meth| meth.full_name == 'AggClass#a'}
-
-    # Check AggClass#a
-    assert_equal('AggClass#a', method.full_name)
-
-    call_infos = method.aggregate_children
-    assert_equal(1, call_infos.length)
-
-    call_info = call_infos.first
-    assert_equal('AggClass#z', call_info.target.full_name)
-    assert_in_delta(3, call_info.total_time, 0.05)
-    assert_in_delta(0, call_info.wait_time, 0.05)
-    assert_in_delta(0, call_info.self_time, 0.05)
-    assert_in_delta(3, call_info.children_time, 0.05)
-    assert_equal(3, call_info.called)
-  end
-end