ruby-prof 1.4.4-x64-mingw-ucrt

data/lib/ruby-prof/rack.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+require 'tmpdir'
+
+module Rack
+  class RubyProf
+    def initialize(app, options = {})
+      @app = app
+      @options = options
+      @options[:min_percent] ||= 1
+
+      @tmpdir = options[:path] || Dir.tmpdir
+      FileUtils.mkdir_p(@tmpdir)
+
+      @printer_klasses = @options[:printers]  || {::RubyProf::FlatPrinter => 'flat.txt',
+                                                  ::RubyProf::GraphPrinter => 'graph.txt',
+                                                  ::RubyProf::GraphHtmlPrinter => 'graph.html',
+                                                  ::RubyProf::CallStackPrinter => 'call_stack.html'}
+
+      @skip_paths = options[:skip_paths] || [%r{^/assets}, %r{\.(css|js|png|jpeg|jpg|gif)$}]
+      @only_paths = options[:only_paths]
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+
+      if should_profile?(request.path)
+        begin
+          result = nil
+          data = ::RubyProf::Profile.profile(profiling_options) do
+            result = @app.call(env)
+          end
+
+          path = request.path.gsub('/', '-')
+          path.slice!(0)
+
+          print(data, path)
+          result
+        end
+      else
+        @app.call(env)
+      end
+    end
+
+    private
+
+    def should_profile?(path)
+      return false if paths_match?(path, @skip_paths)
+
+      @only_paths ? paths_match?(path, @only_paths) : true
+    end
+
+    def paths_match?(path, paths)
+      paths.any? { |skip_path| skip_path =~ path }
+    end
+
+    def profiling_options
+      options = {}
+      options[:measure_mode] = ::RubyProf.measure_mode
+      options[:exclude_threads] =
+        if @options[:ignore_existing_threads]
+          Thread.list.select{|t| t != Thread.current}
+        else
+          ::RubyProf.exclude_threads
+        end
+      if @options[:request_thread_only]
+        options[:include_threads] = [Thread.current]
+      end
+      if @options[:merge_fibers]
+        options[:merge_fibers] = true
+      end
+      options
+    end
+
+    def print(data, path)
+      @printer_klasses.each do |printer_klass, base_name|
+        printer = printer_klass.new(data)
+
+        if base_name.respond_to?(:call)
+          base_name = base_name.call
+        end
+
+        if printer_klass == ::RubyProf::MultiPrinter
+          printer.print(@options.merge(:profile => "#{path}-#{base_name}"))
+        elsif printer_klass == ::RubyProf::CallTreePrinter
+          printer.print(@options.merge(:profile => "#{path}-#{base_name}"))
+        else
+          file_name = ::File.join(@tmpdir, "#{path}-#{base_name}")
+          ::File.open(file_name, 'wb') do |file|
+            printer.print(file, @options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby-prof/task.rb

@@ -0,0 +1,147 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'rake'
+require 'rake/testtask'
+require 'fileutils'
+
+module RubyProf
+
+  # Define a task library for profiling unit tests with ruby-prof.
+  #
+  # All of the options provided by
+  # the Rake:TestTask are supported except the loader
+  # which is set to ruby-prof.  For detailed information
+  # please refer to the Rake:TestTask documentation.
+  #
+  # ruby-prof specific options include:
+  #
+  #   output_dir - For each file specified an output
+  #                file with profile information will be
+  #                written to the output directory.
+  #                By default, the output directory is
+  #                called "profile" and is created underneath
+  #                the current working directory.
+  #
+  #   printer - Specifies the output printer.  Valid values include
+  #             :flat, :graph, :graph_html and :call_tree.
+  #
+  #   min_percent - Methods that take less than the specified percent
+  #                 will not be written out.
+  #
+  # Example:
+  #
+  #   require 'ruby-prof/task'
+  #
+  #   RubyProf::ProfileTask.new do |t|
+  #     t.test_files = FileList['test/test*.rb']
+  #     t.output_dir = "c:/temp"
+  #     t.printer = :graph
+  #     t.min_percent = 10
+  #   end
+  #
+  # If rake is invoked with a "TEST=filename" command line option,
+  # then the list of test files will be overridden to include only the
+  # filename specified on the command line.  This provides an easy way
+  # to run just one test.
+  #
+  # If rake is invoked with a "TESTOPTS=options" command line option,
+  # then the given options are passed to the test process after a
+  # '--'.  This allows Test::Unit options to be passed to the test
+  # suite.
+  #
+  # Examples:
+  #
+  #   rake profile                           # run tests normally
+  #   rake profile TEST=just_one_file.rb     # run just one test file.
+  #   rake profile TESTOPTS="-v"             # run in verbose mode
+  #   rake profile TESTOPTS="--runner=fox"   # use the fox test runner
+
+  class ProfileTask < Rake::TestTask
+    attr_accessor :output_dir
+    attr_accessor :min_percent
+    attr_accessor :printer
+
+    def initialize(name = :profile)
+      super(name)
+    end
+
+    # Create the tasks defined by this task lib.
+    def define
+      lib_path = @libs.join(File::PATH_SEPARATOR)
+      desc "Profile" + (@name==:profile ? "" : " for #{@name}")
+
+      task @name do
+        create_output_directory
+
+        @ruby_opts.unshift( "-I#{lib_path}" )
+        @ruby_opts.unshift( "-w" ) if @warning
+        @ruby_opts.push("-S ruby-prof")
+        @ruby_opts.push("--printer #{@printer}")
+        @ruby_opts.push("--min_percent #{@min_percent}")
+
+        file_list.each do |file_path|
+          run_script(file_path)
+        end
+      end
+      self
+    end
+
+    # Run script
+    def run_script(script_path)
+      run_code = ''
+      RakeFileUtils.verbose(@verbose) do
+        file_name = File.basename(script_path, File.extname(script_path))
+        case @printer
+          when :flat, :graph, :call_tree
+            file_name += ".txt"
+          when :graph_html
+            file_name += ".html"
+          else
+            file_name += ".txt"
+        end
+
+        output_file_path = File.join(output_directory, file_name)
+
+        command_line = @ruby_opts.join(" ") +
+                      " --file=" + output_file_path +
+                      " " + script_path
+
+        puts "ruby " + command_line
+        # We have to catch the exeption to continue on.  However,
+        # the error message will have been output to STDERR
+        # already by the time we get here so we don't have to
+        # do that again
+        begin
+          ruby command_line
+        rescue => e
+          STDOUT << e << "\n"
+          STDOUT.flush
+        end
+        puts ""
+        puts ""
+      end
+    end
+
+    def output_directory
+      File.expand_path(@output_dir)
+    end
+
+    def create_output_directory
+      if not File.exist?(output_directory)
+        Dir.mkdir(output_directory)
+      end
+    end
+
+    def clean_output_directory
+      if File.exist?(output_directory)
+        files = Dir.glob(output_directory + '/*')
+        FileUtils.rm(files)
+      end
+    end
+
+    def option_list # :nodoc:
+      ENV['OPTIONS'] || @options.join(" ") || ""
+    end
+  end
+end

data/lib/ruby-prof/thread.rb

@@ -0,0 +1,20 @@
+module RubyProf
+  class Thread
+    # Returns the total time this thread was executed.
+    def total_time
+      self.call_tree.total_time
+    end
+
+    # Returns the amount of time this thread waited while other thread executed.
+    def wait_time
+      # wait_time, like self:time, is always method local
+      # thus we need to sum over all methods and call infos
+      self.methods.inject(0) do |sum, method_info|
+        method_info.callers.each do |call_tree|
+          sum += call_tree.wait_time
+        end
+        sum
+      end
+    end
+  end
+end

data/lib/ruby-prof/version.rb

@@ -0,0 +1,3 @@
+module RubyProf
+  VERSION = "1.4.4"
+end

data/lib/ruby-prof.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+require 'rubygems/version'
+
+# Load the C-based binding.
+begin
+  version = Gem::Version.new(RUBY_VERSION)
+  require "#{version.segments[0..1].join('.')}/ruby_prof.so"
+rescue LoadError
+  require_relative "../ext/ruby_prof/ruby_prof.so"
+end
+
+require 'ruby-prof/version'
+require 'ruby-prof/call_tree'
+require 'ruby-prof/compatibility'
+require 'ruby-prof/measurement'
+require 'ruby-prof/method_info'
+require 'ruby-prof/profile'
+require 'ruby-prof/rack'
+require 'ruby-prof/thread'
+
+module RubyProf
+  autoload :CallTreeVisitor, 'ruby-prof/call_tree_visitor'
+  autoload :AbstractPrinter, 'ruby-prof/printers/abstract_printer'
+  autoload :CallInfoPrinter, 'ruby-prof/printers/call_info_printer'
+  autoload :CallStackPrinter, 'ruby-prof/printers/call_stack_printer'
+  autoload :CallTreePrinter, 'ruby-prof/printers/call_tree_printer'
+  autoload :DotPrinter, 'ruby-prof/printers/dot_printer'
+  autoload :FlatPrinter, 'ruby-prof/printers/flat_printer'
+  autoload :GraphHtmlPrinter, 'ruby-prof/printers/graph_html_printer'
+  autoload :GraphPrinter, 'ruby-prof/printers/graph_printer'
+  autoload :MultiPrinter, 'ruby-prof/printers/multi_printer'
+
+  # :nodoc:
+  # Checks if the user specified the clock mode via
+  # the RUBY_PROF_MEASURE_MODE environment variable
+  def self.figure_measure_mode
+    case ENV["RUBY_PROF_MEASURE_MODE"]
+    when "wall", "wall_time"
+      RubyProf.measure_mode = RubyProf::WALL_TIME
+    when "allocations"
+      RubyProf.measure_mode = RubyProf::ALLOCATIONS
+    when "memory"
+      RubyProf.measure_mode = RubyProf::MEMORY
+    when "process", "process_time"
+      RubyProf.measure_mode = RubyProf::PROCESS_TIME
+    else
+      # the default is defined in the measure_mode reader
+    end
+  end
+end
+
+RubyProf::figure_measure_mode

data/lib/unprof.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require "ruby-prof"
+
+at_exit {
+  result = RubyProf.stop
+  printer = RubyProf::FlatPrinter.new(result)
+  printer.print(STDOUT)
+}
+RubyProf.start

data/ruby-prof.gemspec

@@ -0,0 +1,64 @@
+# -*- encoding: utf-8 -*-
+
+$:.push File.expand_path("../lib", __FILE__)
+require "ruby-prof/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "ruby-prof"
+
+  spec.homepage = "https://github.com/ruby-prof/ruby-prof/"
+  spec.summary = "Fast Ruby profiler"
+  spec.description = <<-EOF
+ruby-prof is a fast code profiler for Ruby. It is a C extension and
+therefore is many times faster than the standard Ruby profiler. It
+supports both flat and graph profiles.  For each method, graph profiles
+show how long the method ran, which methods called it and which
+methods it called. RubyProf generate both text and html and can output
+it to standard out or to a file.
+EOF
+  spec.license = 'BSD-2-Clause'
+  spec.version = RubyProf::VERSION
+
+  spec.metadata = {
+    "bug_tracker_uri"   => "https://github.com/ruby-prof/ruby-prof/issues",
+    "changelog_uri"     => "https://github.com/ruby-prof/ruby-prof/blob/master/CHANGES",
+    "documentation_uri" => "https://ruby-prof.github.io/",
+    "source_code_uri"   => "https://github.com/ruby-prof/ruby-prof/tree/v#{spec.version}",
+  }
+
+  spec.author = "Shugo Maeda, Charlie Savage, Roger Pack, Stefan Kaes"
+  spec.email = "shugo@ruby-lang.org, cfis@savagexi.com, rogerdpack@gmail.com, skaes@railsexpress.de"
+  spec.platform = Gem::Platform::RUBY
+  spec.require_path = "lib"
+  spec.bindir = "bin"
+  spec.executables = ["ruby-prof", "ruby-prof-check-trace"]
+  spec.extensions = ["ext/ruby_prof/extconf.rb"]
+  spec.files = Dir['CHANGES',
+                   'LICENSE',
+                   'Rakefile',
+                   'README.md',
+                   'ruby-prof.gemspec',
+                   'bin/ruby-prof',
+                   'bin/ruby-prof-check-trace',
+                   'doc/**/*',
+                   'examples/*',
+                   'ext/ruby_prof/extconf.rb',
+                   'ext/ruby_prof/*.c',
+                   'ext/ruby_prof/*.h',
+                   'ext/ruby_prof/vc/*.sln',
+                   'ext/ruby_prof/vc/*.vcxproj',
+                   'lib/ruby-prof.rb',
+                   'lib/unprof.rb',
+                   'lib/ruby-prof/*.rb',
+                   'lib/ruby-prof/assets/*',
+                   'lib/ruby-prof/profile/*.rb',
+                   'lib/ruby-prof/printers/*.rb',
+                   'test/*.rb']
+
+  spec.test_files = Dir["test/test_*.rb"]
+  spec.required_ruby_version = '>= 2.7.0'
+  spec.date = Time.now.strftime('%Y-%m-%d')
+  spec.homepage = 'https://github.com/ruby-prof/ruby-prof'
+  spec.add_development_dependency('minitest')
+  spec.add_development_dependency('rake-compiler')
+end

data/test/abstract_printer_test.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class AbstractPrinterTest < TestCase
+  def setup
+    @result = {}
+    @printer = RubyProf::AbstractPrinter.new(@result)
+    @options = {}
+    @printer.setup_options(@options)
+  end
+
+  private
+
+  def with_const_stubbed(name, value)
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    old_value = Object.const_get(name)
+
+    Object.const_set(name, value)
+    yield
+    Object.const_set(name, old_value)
+
+    $VERBOSE = old_verbose
+  end
+end

data/test/alias_test.rb

@@ -0,0 +1,122 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path("../test_helper", __FILE__)
+
+class AliasTest < TestCase
+  class TestMe
+    def some_method
+      sleep(0.1)
+    end
+
+    alias :some_method_original :some_method
+    def some_method
+      some_method_original
+    end
+  end
+
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def test_alias
+    result = RubyProf.profile do
+      TestMe.new.some_method
+    end
+
+    methods = result.threads.first.methods
+    assert_equal(6, methods.count)
+
+    # Method 0
+    method = methods[0]
+    assert_equal('AliasTest#test_alias', method.full_name)
+    assert_equal(25, method.line)
+    refute(method.recursive?)
+
+    assert_equal(0, method.call_trees.callers.count)
+
+    assert_equal(2, method.call_trees.callees.count)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('Class#new', call_tree.target.full_name)
+    assert_equal(25, call_tree.line)
+
+    call_tree = method.call_trees.callees[1]
+    assert_equal('AliasTest::TestMe#some_method', call_tree.target.full_name)
+    assert_equal(25, call_tree.line)
+
+    # Method 1
+    method = methods[1]
+    assert_equal('Class#new', method.full_name)
+    assert_equal(0, method.line)
+    refute(method.recursive?)
+
+    assert_equal(1, method.call_trees.callers.count)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('AliasTest#test_alias', call_tree.parent.target.full_name)
+    assert_equal(25, call_tree.line)
+
+    assert_equal(1, method.call_trees.callees.count)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('BasicObject#initialize', call_tree.target.full_name)
+    assert_equal(0, call_tree.line)
+
+    # Method 2
+    method = methods[2]
+    assert_equal('BasicObject#initialize', method.full_name)
+    assert_equal(0, method.line)
+    refute(method.recursive?)
+
+    assert_equal(1, method.call_trees.callers.count)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('Class#new', call_tree.parent.target.full_name)
+    assert_equal(0, call_tree.line)
+
+    assert_equal(0, method.call_trees.callees.count)
+
+    # Method 3
+    method = methods[3]
+    assert_equal('AliasTest::TestMe#some_method', method.full_name)
+    assert_equal(13, method.line)
+    refute(method.recursive?)
+
+    assert_equal(1, method.call_trees.callers.count)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('AliasTest#test_alias', call_tree.parent.target.full_name)
+    assert_equal(25, call_tree.line)
+
+    assert_equal(1, method.call_trees.callees.count)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('AliasTest::TestMe#some_method_original', call_tree.target.full_name)
+    assert_equal(14, call_tree.line)
+
+    # Method 4
+    method = methods[4]
+    assert_equal('AliasTest::TestMe#some_method_original', method.full_name)
+    assert_equal(8, method.line)
+    refute(method.recursive?)
+
+    assert_equal(1, method.call_trees.callers.count)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('AliasTest::TestMe#some_method', call_tree.parent.target.full_name)
+    assert_equal(14, call_tree.line)
+
+    assert_equal(1, method.call_trees.callees.count)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('Kernel#sleep', call_tree.target.full_name)
+    assert_equal(9, call_tree.line)
+
+    # Method 5
+    method = methods[5]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(0, method.line)
+    refute(method.recursive?)
+
+    assert_equal(1, method.call_trees.callers.count)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('AliasTest::TestMe#some_method_original', call_tree.parent.target.full_name)
+    assert_equal(9, call_tree.line)
+
+    assert_equal(0, method.call_trees.callees.count)
+  end
+end

data/test/basic_test.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require_relative './measure_times'
+
+class BasicTest < 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_running
+    assert(!RubyProf.running?)
+    RubyProf.start
+    assert(RubyProf.running?)
+    RubyProf.stop
+    assert(!RubyProf.running?)
+  end
+
+  def test_double_profile
+    RubyProf.start
+    assert_raises(RuntimeError) do
+      RubyProf.start
+    end
+    RubyProf.stop
+  end
+
+  def test_no_block
+    assert_raises(ArgumentError) do
+      RubyProf.profile
+    end
+  end
+
+  def test_traceback
+    RubyProf.start
+    assert_raises(NoMethodError) do
+      RubyProf.xxx
+    end
+
+    RubyProf.stop
+  end
+end

data/test/call_tree_visitor_test.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require_relative './measure_times'
+
+class CallTreeVisitorTest < 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_visit
+    result = RubyProf.profile do
+      RubyProf::C1.sleep_wait
+    end
+
+    visitor = RubyProf::CallTreeVisitor.new(result.threads.first.call_tree)
+
+    method_names = Array.new
+
+    visitor.visit do |call_tree, event|
+      method_names << call_tree.target.full_name if event == :enter
+    end
+
+    assert_equal(3, method_names.length)
+    assert_equal("CallTreeVisitorTest#test_visit", method_names[0])
+    assert_equal("<Class::RubyProf::C1>#sleep_wait", method_names[1])
+    assert_equal("Kernel#sleep", method_names[2])
+  end
+end
+

data/test/call_trees_test.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# --  Tests ----
+class CallTreesTest < TestCase
+  def some_method_1
+    some_method_2
+  end
+
+  def some_method_2
+  end
+
+  def test_call_infos
+    result = RubyProf.profile do
+      some_method_1
+    end
+
+    thread = result.threads.first
+    assert_equal(3, thread.methods.length)
+
+    method = thread.methods[0]
+    assert_equal('CallTreesTest#test_call_infos', method.full_name)
+
+    call_trees = method.call_trees
+    assert_empty(call_trees.callers)
+    assert_equal(1, call_trees.callees.length)
+    assert_kind_of(RubyProf::AggregateCallTree, call_trees.callees[0])
+    assert_equal('CallTreesTest#some_method_1', call_trees.callees[0].target.full_name)
+
+    method = thread.methods[1]
+    assert_equal('CallTreesTest#some_method_1', method.full_name)
+
+    call_trees = method.call_trees
+    assert_equal(1, call_trees.callers.length)
+    assert_kind_of(RubyProf::AggregateCallTree, call_trees.callers[0])
+    assert_equal('CallTreesTest#test_call_infos', call_trees.callers[0].parent.target.full_name)
+    assert_equal(1, call_trees.callees.length)
+    assert_kind_of(RubyProf::AggregateCallTree, call_trees.callees[0])
+    assert_equal('CallTreesTest#some_method_2', call_trees.callees[0].target.full_name)
+
+    method = thread.methods[2]
+    assert_equal('CallTreesTest#some_method_2', method.full_name)
+
+    call_trees = method.call_trees
+    assert_equal(1, call_trees.callers.length)
+    assert_kind_of(RubyProf::AggregateCallTree, call_trees.callers[0])
+    assert_equal('CallTreesTest#some_method_1', call_trees.callers[0].parent.target.full_name)
+    assert_empty(call_trees.callees)
+  end
+
+  def test_gc
+    result = RubyProf.profile do
+      some_method_1
+    end
+
+    method = result.threads.first.methods[1]
+
+    100.times do |i|
+      method.call_trees.callers
+      GC.start
+    end
+    assert(true)
+  end
+end