ruby-prof 0.13.1 → 1.4.2

data/test/printing_recursive_graph_test.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'fileutils'
+require 'stringio'
+
+# --- code to be tested ---
+module PRGT
+  extend self
+
+  def f(n)
+    n.times { sleep 0.1 }
+  end
+
+  def g(n)
+    n.times { sleep 0.2 }
+  end
+
+  def run
+    2.times { f(2); g(4) }
+  end
+end
+
+# --- expected test output ---
+=begin
+Measure Mode: wall_time
+Thread ID: 1307675084040
+Fiber ID: 1307708787440
+Total Time: 2.0939999999973224
+Sort by:
+
+  %total   %self      total       self       wait      child            calls     name
+--------------------------------------------------------------------------------
+                      1.657      0.000      0.000      1.657              2/2     Integer#times
+  79.13%   0.00%      1.657      0.000      0.000      1.657                2     PRGT#g
+                      1.657      0.000      0.000      1.657              2/5     Integer#times
+--------------------------------------------------------------------------------
+                      2.094      2.094      0.000      0.000            12/12     Integer#times
+ 100.00% 100.00%      2.094      2.094      0.000      0.000               12     Kernel#sleep
+--------------------------------------------------------------------------------
+                      0.437      0.000      0.000      0.437              2/2     Integer#times
+  20.87%   0.00%      0.437      0.000      0.000      0.437                2     PRGT#f
+                      0.437      0.000      0.000      0.437              2/5     Integer#times
+--------------------------------------------------------------------------------
+                      0.437      0.000      0.000      0.437              2/5     PRGT#f
+                      1.657      0.000      0.000      1.657              2/5     PRGT#g
+                      2.094      0.000      0.000      2.094              1/5     PRGT#run
+ 100.00%   0.00%      2.094      0.000      0.000      2.094                5    *Integer#times
+                      2.094      2.094      0.000      0.000            12/12     Kernel#sleep
+                      1.657      0.000      0.000      1.657              2/2     PRGT#g
+                      0.437      0.000      0.000      0.437              2/2     PRGT#f
+--------------------------------------------------------------------------------
+                      2.094      0.000      0.000      2.094              1/1     PrintingRecursiveGraphTest#setup
+ 100.00%   0.00%      2.094      0.000      0.000      2.094                1     PRGT#run
+                      2.094      0.000      0.000      2.094              1/5     Integer#times
+--------------------------------------------------------------------------------
+ 100.00%   0.00%      2.094      0.000      0.000      2.094                1     PrintingRecursiveGraphTest#setup
+                      2.094      0.000      0.000      2.094              1/1     PRGT#run
+
+* indicates recursively called methods
+=end
+
+class PrintingRecursiveGraphTest < TestCase
+  def setup
+    # WALL_TIME so we can use sleep in our test and get same measurements on linux and windows
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+    @result = RubyProf.profile do
+      PRGT.run
+    end
+  end
+
+  def test_printing_rescursive_graph
+    printer = RubyProf::GraphPrinter.new(@result)
+    buffer = ''
+    printer.print(StringIO.new(buffer))
+    puts buffer if ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT'] == "1"
+
+    refute_nil(buffer)
+  end
+end

data/test/profile_test.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class ProfileTest < TestCase
+  def test_measure_mode
+    profile = RubyProf::Profile.new(:measure_mode => RubyProf::PROCESS_TIME)
+    assert_equal(RubyProf::PROCESS_TIME, profile.measure_mode)
+  end
+
+  def test_measure_mode_string
+    profile = RubyProf::Profile.new(:measure_mode => RubyProf::PROCESS_TIME)
+    assert_equal("process_time", profile.measure_mode_string)
+  end
+end

data/test/rack_test.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class FakeRackApp
+  def call(env)
+  end
+end
+
+module Rack
+  class Request
+    def initialize(env)
+      if env == :fake_env
+        @env = {}
+      else
+        @env = env
+      end
+    end
+
+    def path
+      @env[:path] || '/path/to/resource.json'
+    end
+  end
+end
+
+class RackTest < TestCase
+  def test_create_print_path
+    path = Dir.mktmpdir
+    Dir.delete(path)
+
+    Rack::RubyProf.new(FakeRackApp.new, :path => path)
+
+    assert(Dir.exist?(path))
+  end
+
+  def test_create_profile_reports
+    path = Dir.mktmpdir
+
+    adapter = Rack::RubyProf.new(FakeRackApp.new, :path => path)
+
+    adapter.call(:fake_env)
+
+    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
+      file_path = ::File.join(path, "path-to-resource.json-#{base_name}")
+      assert(File.exist?(file_path))
+    end
+  end
+
+  def test_skip_paths
+    path = Dir.mktmpdir
+
+    adapter = Rack::RubyProf.new(FakeRackApp.new, :path => path, :skip_paths => [%r{\.json$}])
+
+    adapter.call(:fake_env)
+
+    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
+      file_path = ::File.join(path, "path-to-resource.json-#{base_name}")
+      assert(!File.exist?(file_path))
+    end
+  end
+
+  def test_only_paths
+    path = Dir.mktmpdir
+
+    adapter = Rack::RubyProf.new(FakeRackApp.new, :path => path, :only_paths => [%r{\.json$}])
+
+    adapter.call({path: '/path/to/resource.json'})
+
+    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
+      file_path = ::File.join(path, "path-to-resource.json-#{base_name}")
+      assert(File.exist?(file_path))
+    end
+
+    adapter.call({path: '/path/to/resource.html'})
+    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
+      file_path = ::File.join(path, "path-to-resource.html-#{base_name}")
+      assert(!File.exist?(file_path))
+    end
+  end
+
+  def test_allows_lazy_filename_setting
+    path = Dir.mktmpdir
+
+    printer = {::RubyProf::FlatPrinter => lambda { 'dynamic.txt' }}
+    adapter = Rack::RubyProf.new(FakeRackApp.new, :path => path, :printers => printer)
+
+    adapter.call(:fake_env)
+
+    file_path = ::File.join(path, 'path-to-resource.json-dynamic.txt')
+    assert(File.exist?(file_path))
+  end
+end

data/test/recursive_test.rb

@@ -1,215 +1,206 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-# Simple recursive test
-def simple(n)
-  sleep(1)
-  n -= 1
-  return if n == 0
-  simple(n)
-end
-
-
-# More complicated recursive test
-def render_partial(i)
-  sleep(1)
-  case i
-  when 0
-    render_partial(10)
-  when 1
-    2.times do |j|
-      render_partial(j + 10)
-    end
-  end
-end
-
-def render
-  2.times do |i|
-    render_partial(i)
-  end
-end
-
-# --  Tests ----
-class RecursiveTest < Test::Unit::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_simple
-    result = RubyProf.profile do
-      simple(2)
-    end
-
-    # Remove Fixnum+, Fixnum== for less than Ruby 1.9
-    result.eliminate_methods!(%w(Fixnum#== Fixnum#-))
-
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(3, methods.length)
-
-    # Method 0: RecursiveTest#test_simple
-    method = methods[0]
-    assert_equal('RecursiveTest#test_simple', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.1)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(2, method.children_time, 0.1)
-
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert(!call_info.recursive)
-    assert_equal('RecursiveTest#test_simple', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-
-    # Method 1: Object#simple
-    method = methods[1]
-    assert_equal('Object#simple', method.full_name)
-    assert_equal(2, method.called)
-    assert_in_delta(2, method.total_time, 0.1)
-    assert_in_delta(0, method.self_time, 0.1)
-    assert_in_delta(0, method.wait_time, 0.1)
-    assert_in_delta(2, method.children_time, 0.1)
-
-    assert_equal(2, method.call_infos.length)
-
-    call_info = method.call_infos.first
-    assert_equal(2, call_info.children.length)
-    assert_equal('RecursiveTest#test_simple->Object#simple', call_info.call_sequence)
-    assert(!call_info.recursive)
-
-    call_info = method.call_infos.last
-    assert_equal(1, call_info.children.length)
-    assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple', call_info.call_sequence)
-    assert(call_info.recursive)
-
-    method = methods[2]
-    assert_equal('Kernel#sleep', method.full_name)
-    assert_equal(2, method.called)
-    assert_in_delta(2, method.total_time, 0.1)
-    assert_in_delta(2, method.self_time, 0.1)
-    assert_in_delta(0, method.wait_time, 0.1)
-    assert_in_delta(0, method.children_time, 0.1)
-
-    assert_equal(2, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_simple->Object#simple->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-    assert(!call_info.recursive)
-
-    call_info = method.call_infos[1]
-    assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-    assert(!call_info.recursive)
-  end
-
-  def test_cycle
-    result = RubyProf.profile do
-      render
-    end
-
-    methods = result.threads.first.methods.sort.reverse
-    if RUBY_VERSION < '1.9' # Fixnum#+, Fixnum#===, Kernel#===
-      assert_equal(8, methods.length)
-    else
-      assert_equal(5, methods.length)
-    end
-
-    method = methods[0]
-    assert_equal('RecursiveTest#test_cycle', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(5, method.total_time, 0.1)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(5, method.children_time, 0.1)
-
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_cycle', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-    assert(!call_info.recursive)
-
-    method = methods[1]
-    assert_equal('Object#render', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(5, method.total_time, 0.1)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(5, method.children_time, 0.1)
-
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_cycle->Object#render', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-    assert(!call_info.recursive)
-
-    method = methods[2]
-    assert_equal('Integer#times', method.full_name)
-    assert_equal(2, method.called)
-    assert_in_delta(5, method.total_time, 0.1)
-    assert_in_delta(0, method.self_time, 0.1)
-    assert_in_delta(0, method.wait_time, 0.1)
-    assert_in_delta(5, method.children_time, 0.1)
-
-    assert_equal(2, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-    assert(!call_info.recursive)
-
-    call_info = method.call_infos[1]
-    assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial->Integer#times', call_info.call_sequence)
-    assert_equal(1 + (RUBY_VERSION < '1.9.0' ? 1 : 0), call_info.children.length)
-    assert(call_info.recursive)
-
-    method = methods[3]
-    assert_equal('Object#render_partial', method.full_name)
-    assert_equal(5, method.called)
-    assert_in_delta(5, method.total_time, 0.1)
-    assert_in_delta(0, method.self_time, 0.1)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(5, method.children_time, 0.05)
-
-    assert_equal(3, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial', call_info.call_sequence)
-    assert_equal(3 + (RUBY_VERSION < '1.9.0' ? 1 : 0), call_info.children.length)
-    assert(!call_info.recursive)
-
-    call_info = method.call_infos[1]
-    assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial->Object#render_partial', call_info.call_sequence)
-    assert_equal(1 + (RUBY_VERSION < '1.9.0' ? 1 : 0), call_info.children.length)
-    assert(call_info.recursive)
-
-    call_info = method.call_infos[2]
-    assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial->Integer#times->Object#render_partial', call_info.call_sequence)
-    assert_equal(1 + (RUBY_VERSION < '1.9.0' ? 1 : 0), call_info.children.length)
-    assert(call_info.recursive)
-
-    method = methods[4]
-    assert_equal('Kernel#sleep', method.full_name)
-    assert_equal(5, method.called)
-    assert_in_delta(5, method.total_time, 0.1)
-    assert_in_delta(5, method.self_time, 0.1)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(0, method.children_time, 0.01)
-
-    assert_equal(3, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-    assert(!call_info.recursive)
-
-    call_info = method.call_infos[1]
-    assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial->Object#render_partial->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-    assert(!call_info.recursive)
-
-    call_info = method.call_infos[2]
-    assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial->Integer#times->Object#render_partial->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-    assert(!call_info.recursive)
-  end
-end
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+module SimpleRecursion
+  # Simple recursive test
+  def simple(n)
+    sleep(1)
+    return if n == 0
+    simple(n-1)
+  end
+
+  # More complicated recursive test
+  def render_partial(i)
+    sleep(1)
+    case i
+    when 0
+      render_partial(10)
+    when 1
+      2.times do |j|
+        render_partial(j + 10)
+      end
+    end
+  end
+
+  def render
+    2.times do |i|
+      render_partial(i)
+    end
+  end
+end
+
+# --  Tests ----
+class RecursiveTest < TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  include SimpleRecursion
+
+  def test_simple
+    result = RubyProf.profile do
+      simple(1)
+    end
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(3, methods.length)
+
+    # Method 0: RecursiveTest#test_simple
+    method = methods[0]
+    assert_equal('RecursiveTest#test_simple', method.full_name)
+    assert_equal(1, method.called)
+    refute(method.recursive?)
+    assert_in_delta(2, method.total_time, 0.1)
+    assert_in_delta(0, method.self_time, 0.01)
+    assert_in_delta(0, method.wait_time, 0.01)
+    assert_in_delta(2, method.children_time, 0.1)
+
+    assert_equal(0, method.call_trees.callers.length)
+
+    assert_equal(1, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('SimpleRecursion#simple', call_tree.target.full_name)
+
+    # Method 1: SimpleRecursion#simple
+    method = methods[1]
+    assert_equal('SimpleRecursion#simple', method.full_name)
+    assert_equal(2, method.called)
+    assert(method.recursive?)
+    assert_in_delta(2, method.total_time, 0.1)
+    assert_in_delta(0, method.self_time, 0.1)
+    assert_in_delta(0, method.wait_time, 0.1)
+    assert_in_delta(2, method.children_time, 0.1)
+
+    assert_equal(2, method.call_trees.callers.length)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('RecursiveTest#test_simple', call_tree.parent.target.full_name)
+
+    call_tree = method.call_trees.callers[1]
+    assert_equal('SimpleRecursion#simple', call_tree.parent.target.full_name)
+
+    assert_equal(2, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('Kernel#sleep', call_tree.target.full_name)
+
+    call_tree = method.call_trees.callees[1]
+    assert_equal('SimpleRecursion#simple', call_tree.target.full_name)
+
+    # Method 2: Kernel#sleep
+    method = methods[2]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(2, method.called)
+    refute(method.recursive?)
+    assert_in_delta(2, method.total_time, 0.1)
+    assert_in_delta(2, method.self_time, 0.1)
+    assert_in_delta(0, method.wait_time, 0.1)
+    assert_in_delta(0, method.children_time, 0.1)
+
+    assert_equal(1, method.call_trees.callers.length)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('SimpleRecursion#simple', call_tree.parent.target.full_name)
+    assert_equal(0, method.call_trees.callees.length)
+
+    assert_equal(0, method.call_trees.callees.length)
+  end
+
+  def test_cycle
+    result = RubyProf.profile do
+      render
+    end
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(5, methods.length)
+
+    method = methods[0]
+    assert_equal('RecursiveTest#test_cycle', method.full_name)
+    assert_equal(1, method.called)
+    refute(method.recursive?)
+    assert_in_delta(5, method.total_time, 0.1)
+    assert_in_delta(0, method.self_time, 0.01)
+    assert_in_delta(0, method.wait_time, 0.01)
+    assert_in_delta(5, method.children_time, 0.1)
+
+    assert_equal(0, method.call_trees.callers.length)
+
+    assert_equal(1, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('SimpleRecursion#render', call_tree.target.full_name)
+
+    method = methods[1]
+    assert_equal('SimpleRecursion#render', method.full_name)
+    assert_equal(1, method.called)
+    refute(method.recursive?)
+    assert_in_delta(5, method.total_time, 0.1)
+    assert_in_delta(0, method.self_time, 0.01)
+    assert_in_delta(0, method.wait_time, 0.01)
+    assert_in_delta(5, method.children_time, 0.1)
+
+    assert_equal(1, method.call_trees.callers.length)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('RecursiveTest#test_cycle', call_tree.parent.target.full_name)
+
+    assert_equal(1, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('Integer#times', call_tree.target.full_name)
+
+    method = methods[2]
+    assert_equal('Integer#times', method.full_name)
+    assert_equal(2, method.called)
+    assert(method.recursive?)
+    assert_in_delta(5, method.total_time, 0.1)
+    assert_in_delta(0, method.self_time, 0.1)
+    assert_in_delta(0, method.wait_time, 0.1)
+    assert_in_delta(5, method.children_time, 0.1)
+
+    assert_equal(2, method.call_trees.callers.length)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('SimpleRecursion#render', call_tree.parent.target.full_name)
+
+    call_tree = method.call_trees.callers[1]
+    assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
+
+    assert_equal(1, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('SimpleRecursion#render_partial', call_tree.target.full_name)
+
+    method = methods[3]
+    assert_equal('SimpleRecursion#render_partial', method.full_name)
+    assert_equal(5, method.called)
+    assert(method.recursive?)
+    assert_in_delta(5, method.total_time, 0.1)
+    assert_in_delta(0, method.self_time, 0.1)
+    assert_in_delta(0, method.wait_time, 0.01)
+    assert_in_delta(5, method.children_time, 0.05)
+
+    assert_equal(2, method.call_trees.callers.length)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('Integer#times', call_tree.parent.target.full_name)
+
+    call_tree = method.call_trees.callers[1]
+    assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
+
+    assert_equal(3, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('Kernel#sleep', call_tree.target.full_name)
+
+    call_tree = method.call_trees.callees[1]
+    assert_equal('SimpleRecursion#render_partial', call_tree.target.full_name)
+
+    call_tree = method.call_trees.callees[2]
+    assert_equal('Integer#times', call_tree.target.full_name)
+
+    method = methods[4]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(5, method.called)
+    refute(method.recursive?)
+    assert_in_delta(5, method.total_time, 0.1)
+    assert_in_delta(5, method.self_time, 0.1)
+    assert_in_delta(0, method.wait_time, 0.01)
+    assert_in_delta(0, method.children_time, 0.01)
+
+    assert_equal(0, method.call_trees.callees.length)
+  end
+end