ruby-prof 0.18.0-x64-mingw32 → 1.1.0-x64-mingw32

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

data/test/block_test.rb

@@ -1,74 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path("../test_helper", __FILE__)
-
-class BlockMethodTest < 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_block
-    result = RubyProf.profile do
-      1.times { RubyProf::C1.new.hello }
-    end
-
-    # Methods called
-    #  Kernel#sleep
-    #  <Class::BasicObject>#allocate
-    #  #{RubyProf.parent_object}#inizialize
-    #  RubyProf::C1#hello
-    #  Class#new
-    #  Integer#times
-    #  BlockMethodTest#test_block
-
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(RubyProf.ruby_2? ? 6 : 7, methods.length)
-
-    # Check times
-    assert_equal("BlockMethodTest#test_block", methods[0].full_name)
-    assert_in_delta(0.2, methods[0].total_time, 0.02)
-    assert_in_delta(0.0, methods[0].wait_time, 0.02)
-    assert_in_delta(0.0, methods[0].self_time, 0.02)
-
-    assert_equal("Integer#times", methods[1].full_name)
-    assert_in_delta(0.2, methods[1].total_time, 0.02)
-    assert_in_delta(0.0, methods[1].wait_time, 0.02)
-    assert_in_delta(0.0, methods[1].self_time, 0.02)
-
-    assert_equal("RubyProf::C1#hello", methods[2].full_name)
-    assert_in_delta(0.2, methods[2].total_time, 0.02)
-    assert_in_delta(0.0, methods[2].wait_time, 0.02)
-    assert_in_delta(0.0, methods[2].self_time, 0.02)
-
-    assert_equal("Kernel#sleep", methods[3].full_name)
-    assert_in_delta(0.2, methods[3].total_time, 0.01)
-    assert_in_delta(0.0, methods[3].wait_time, 0.01)
-    assert_in_delta(0.2, methods[3].self_time, 0.01)
-
-    assert_equal("Class#new", methods[4].full_name)
-    assert_in_delta(0.0, methods[4].total_time, 0.01)
-    assert_in_delta(0.0, methods[4].wait_time, 0.01)
-    assert_in_delta(0.0, methods[4].self_time, 0.01)
-
-    # the timing difference between #initialize and #allocate is so small
-    # that we cannot rely on #initialize appearing first.
-    # so switch them, if necessary
-    if methods[5].full_name =~ /#allocate/
-      methods[5], methods[6] = methods[6], methods[5]
-    end
-
-    assert_equal("#{RubyProf.parent_object}#initialize", methods[5].full_name)
-    assert_in_delta(0.0, methods[5].total_time, 0.01)
-    assert_in_delta(0.0, methods[5].wait_time, 0.01)
-    assert_in_delta(0.0, methods[5].self_time, 0.01)
-
-    unless RubyProf.ruby_2?
-      assert_equal("<Class::#{RubyProf.parent_object}>#allocate", methods[6].full_name)
-      assert_in_delta(0.0, methods[6].total_time, 0.01)
-      assert_in_delta(0.0, methods[6].wait_time, 0.01)
-      assert_in_delta(0.0, methods[6].self_time, 0.01)
-    end
-  end
-end