airbnb-ruby-prof 0.0.1

data/test/printing_recursive_graph_test.rb

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'stringio'
+require 'fileutils'
+
+# --- 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: 70238775664960
+Fiber ID: 70238784046840
+Total Time: 2.040249824523926
+Sort by: total_time
+
+  %total   %self      total       self       wait      child            calls    Name
+--------------------------------------------------------------------------------
+ 100.00%   0.00%      2.040      0.000      0.000      2.040                1      PrintingRecursiveGraphTest#setup
+                      2.040      0.000      0.000      2.040              1/1      PRGT#run
+--------------------------------------------------------------------------------
+                      2.040      0.000      0.000      2.040              1/1      PrintingRecursiveGraphTest#setup
+ 100.00%   0.00%      2.040      0.000      0.000      2.040                1      PRGT#run
+                      2.040      0.000      0.000      2.040              1/5      Integer#times
+--------------------------------------------------------------------------------
+                      0.409      0.000      0.000      0.409              2/5      Prgt#f
+                      1.631      0.000      0.000      1.631              2/5      PRGT#g
+                      2.040      0.000      0.000      2.040              1/5      PRGT#run
+ 100.00%   0.00%      2.040      0.000      0.000      2.040                5     *Integer#times
+                      2.040      2.040      0.000      0.000            12/12      Kernel#sleep
+                      1.631      0.000      0.000      1.631              2/2      PRGT#g
+                      0.409      0.000      0.000      0.409              2/2      PRGT#f
+--------------------------------------------------------------------------------
+                      2.040      2.040      0.000      0.000            12/12      Integer#times
+  99.99%  99.99%      2.040      2.040      0.000      0.000               12      Kernel#sleep
+--------------------------------------------------------------------------------
+                      1.631      0.000      0.000      1.631              2/2      Integer#times
+  79.94%   0.00%      1.631      0.000      0.000      1.631                2      PRGT#g
+                      1.631      0.000      0.000      1.631              2/5      Integer#times
+--------------------------------------------------------------------------------
+                      0.409      0.000      0.000      0.409              2/2      Integer#times
+  20.05%   0.00%      0.409      0.000      0.000      0.409                2      PRGT#f
+                      0.409      0.000      0.000      0.409              2/5      Integer#times
+
+* indicates recursively called methods
+=end
+
+class PrintingRecursiveGraphTest < TestCase
+  include PrinterTestHelper
+
+  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"
+
+    parsed_output = MetricsArray.parse(buffer)
+
+    assert( integer_times  = parsed_output.metrics_for("*Integer#times") )
+
+    actual_parents = integer_times.parents.map(&:name)
+    expected_parents = %w(PRGT#f PRGT#g PRGT#run)
+    assert_equal expected_parents, actual_parents
+
+    actual_children = integer_times.children.map(&:name)
+    expected_children = %w(Kernel#sleep PRGT#g PRGT#f)
+    assert_equal expected_children, actual_children
+
+    assert( fp = integer_times.parent("PRGT#f") )
+    assert_in_delta(fp.total, fp.child, 0.01)
+    assert_equal("2/5", fp.calls)
+
+    assert( gp = integer_times.parent("PRGT#g") )
+    assert_in_delta(gp.total, gp.child, 0.01)
+    assert_equal("2/5", gp.calls)
+
+    assert( rp = integer_times.parent("PRGT#run") )
+    assert_in_delta(rp.total, rp.child, 0.01)
+    assert_equal("1/5", rp.calls)
+
+    assert_in_delta(4*fp.total, gp.total, 0.05)
+    assert_in_delta(fp.total + gp.total, rp.total, 0.05)
+    assert_in_delta(integer_times.metrics.total, rp.total, 0.05)
+
+    assert( fc = integer_times.child("PRGT#f") )
+    assert_in_delta(fc.total, fc.child, 0.01)
+    assert_equal("2/2", fc.calls)
+
+    assert( gc = integer_times.child("PRGT#g") )
+    assert_in_delta(gc.total, gc.child, 0.01)
+    assert_equal("2/2", gc.calls)
+
+    assert( ks = integer_times.child("Kernel#sleep") )
+    assert_in_delta(ks.total, ks.self_t, 0.01)
+    assert_equal("12/12", ks.calls)
+
+    assert_in_delta(4*fc.total, gc.total, 0.05)
+    assert_in_delta(fp.total + gc.total, ks.total, 0.05)
+    assert_in_delta(integer_times.metrics.total, ks.total, 0.05)
+  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

@@ -0,0 +1,212 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+module SimpleRecursion
+  # 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
+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(2)
+    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)
+    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: SimpleRecursion#simple
+    method = methods[1]
+    assert_equal('SimpleRecursion#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->SimpleRecursion#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->SimpleRecursion#simple->SimpleRecursion#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->SimpleRecursion#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->SimpleRecursion#simple->SimpleRecursion#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
+    assert_equal(5, methods.length)
+
+    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('SimpleRecursion#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->SimpleRecursion#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->SimpleRecursion#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->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial->Integer#times', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+    assert(call_info.recursive?)
+
+    method = methods[3]
+    assert_equal('SimpleRecursion#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->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial', call_info.call_sequence)
+    assert_equal(3, call_info.children.length)
+    assert(!call_info.recursive?)
+
+    call_info = method.call_infos[1]
+    assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial->SimpleRecursion#render_partial', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+    assert(call_info.recursive?)
+
+    call_info = method.call_infos[2]
+    assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial->Integer#times->SimpleRecursion#render_partial', call_info.call_sequence)
+    assert_equal(1, 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->SimpleRecursion#render->Integer#times->SimpleRecursion#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->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial->SimpleRecursion#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->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial->Integer#times->SimpleRecursion#render_partial->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+    assert(!call_info.recursive?)
+  end
+end

data/test/singleton_test.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'timeout'
+
+# --  Test for bug [#5657]
+# http://rubyforge.org/tracker/index.php?func=detail&aid=5657&group_id=1814&atid=7060
+
+
+class A
+  attr_accessor :as
+  def initialize
+    @as = []
+    class << @as
+      def <<(an_a)
+        super
+      end
+    end
+  end
+
+  def <<(an_a)
+    @as << an_a
+  end
+end
+
+class SingletonTest < TestCase
+  def test_singleton
+    result = RubyProf.profile do
+      a = A.new
+      a << :first_thing
+      assert_equal(1, a.as.size)
+    end
+    printer = RubyProf::FlatPrinter.new(result)
+    output = ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT'] == "1" ? STDOUT : ''
+    printer.print(output)
+  end
+end