ruby-prof 1.5.0 → 1.6.2

data/ext/ruby_prof/rp_thread.h

@@ -1,39 +1,39 @@
-/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
-   Please see the LICENSE file for copyright and distribution information */
-
-#ifndef __RP_THREAD__
-#define __RP_THREAD__
-
-#include "ruby_prof.h"
-#include "rp_stack.h"
-
-/* Profiling information for a thread. */
-typedef struct thread_data_t
-{
-    prof_owner_t owner;               /* Who owns this object */
-    VALUE object;                     /* Cache to wrapped object */
-    VALUE fiber;                      /* Fiber */
-    prof_stack_t* stack;              /* Stack of frames */
-    bool trace;                       /* Are we tracking this thread */
-    prof_call_tree_t* call_tree;      /* The root of the call tree*/
-    VALUE thread_id;                  /* Thread id */
-    VALUE fiber_id;                   /* Fiber id */
-    VALUE methods;                    /* Array of RubyProf::MethodInfo */
-    st_table* method_table;           /* Methods called in the thread */
-} thread_data_t;
-
-void rp_init_thread(void);
-st_table* threads_table_create(void);
-thread_data_t* threads_table_lookup(void* profile, VALUE fiber);
-thread_data_t* threads_table_insert(void* profile, VALUE fiber);
-void threads_table_free(st_table* table);
-
-thread_data_t* prof_get_thread(VALUE self);
-VALUE prof_thread_wrap(thread_data_t* thread);
-void prof_thread_mark(void* data);
-
-void switch_thread(void* profile, thread_data_t* thread_data, double measurement);
-int pause_thread(st_data_t key, st_data_t value, st_data_t data);
-int unpause_thread(st_data_t key, st_data_t value, st_data_t data);
-
-#endif //__RP_THREAD__
+/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RP_THREAD__
+#define __RP_THREAD__
+
+#include "ruby_prof.h"
+#include "rp_stack.h"
+
+/* Profiling information for a thread. */
+typedef struct thread_data_t
+{
+    prof_owner_t owner;               /* Who owns this object */
+    VALUE object;                     /* Cache to wrapped object */
+    VALUE fiber;                      /* Fiber */
+    prof_stack_t* stack;              /* Stack of frames */
+    bool trace;                       /* Are we tracking this thread */
+    prof_call_tree_t* call_tree;      /* The root of the call tree*/
+    VALUE thread_id;                  /* Thread id */
+    VALUE fiber_id;                   /* Fiber id */
+    VALUE methods;                    /* Array of RubyProf::MethodInfo */
+    st_table* method_table;           /* Methods called in the thread */
+} thread_data_t;
+
+void rp_init_thread(void);
+st_table* threads_table_create(void);
+thread_data_t* threads_table_lookup(void* profile, VALUE fiber);
+thread_data_t* threads_table_insert(void* profile, VALUE fiber);
+void threads_table_free(st_table* table);
+
+thread_data_t* prof_get_thread(VALUE self);
+VALUE prof_thread_wrap(thread_data_t* thread);
+void prof_thread_mark(void* data);
+
+void switch_thread(void* profile, thread_data_t* thread_data, double measurement);
+int pause_thread(st_data_t key, st_data_t value, st_data_t data);
+int unpause_thread(st_data_t key, st_data_t value, st_data_t data);
+
+#endif //__RP_THREAD__

data/ext/ruby_prof/vc/ruby_prof.vcxproj

@@ -66,7 +66,7 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <TargetExt>.so</TargetExt>
-    <OutDir>$(SolutionDir)\..\..\..\lib\</OutDir>
+    <OutDir>$(SolutionDir)\..</OutDir>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -104,17 +104,20 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
-      <AdditionalIncludeDirectories>C:\msys64\usr\local\ruby-3.2.0-vc\include\ruby-3.2.0\x64-mswin64_140;C:\msys64\usr\local\ruby-3.2.0-vc\include\ruby-3.2.0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>C:\msys64\usr\local\ruby-3.2.1-vc\include\ruby-3.2.0\x64-mswin64_140;C:\msys64\usr\local\ruby-3.2.1-vc\include\ruby-3.2.0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <WarningLevel>Level3</WarningLevel>
     </ClCompile>
     <Link>
-      <AdditionalLibraryDirectories>C:\msys64\usr\local\ruby-3.2.0-vc\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalLibraryDirectories>C:\msys64\usr\local\ruby-3.2.1-vc\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <AdditionalDependencies>x64-vcruntime140-ruby320.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ModuleDefinitionFile>ruby_prof.def</ModuleDefinitionFile>
       <SubSystem>Console</SubSystem>
     </Link>
+    <ProjectReference>
+      <LinkLibraryDependencies>false</LinkLibraryDependencies>
+    </ProjectReference>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <ClCompile>

data/lib/ruby-prof/compatibility.rb

@@ -96,4 +96,18 @@ module RubyProf
   def self.ensure_not_running!
     raise(RuntimeError, "RubyProf is already running") if running?
   end
+
+  class << self
+    extend Gem::Deprecate
+    deprecate :measure_mode, "Profile#measure_mode", 2023, 6
+    deprecate :measure_mode=, "Profile#measure_mode=", 2023, 6
+    deprecate :exclude_threads, "Profile#exclude_threads", 2023, 6
+    deprecate :exclude_threads=, "Profile#initialize", 2023, 6
+    deprecate :start, "Profile#start", 2023, 6
+    deprecate :pause, "Profile#pause", 2023, 6
+    deprecate :stop, "Profile#stop", 2023, 6
+    deprecate :resume, "Profile#resume", 2023, 6
+    deprecate :running?, "Profile#running?", 2023, 6
+    deprecate :profile, "Profile.profile", 2023, 6
+  end
 end

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

@@ -50,7 +50,7 @@ module RubyProf
     # options - Hash of print options. Note that each printer can
     # define its own set of options.
     #
-    #   :min_percent - Number 0 to 100 that specifes the minimum
+    #   :min_percent - Number 0 to 100 that specifies the minimum
     #                  %self (the methods self time divided by the
     #                  overall total time) that a method must take
     #                  for it to be printed out in the report.
@@ -131,6 +131,7 @@ module RubyProf
 
           * MyObject#test - An instance method "test" of the class "MyObject"
           * <Object:MyObject>#test - The <> characters indicate a method on a singleton class.
+
       EOT
     end
   end

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

@@ -27,7 +27,7 @@ module RubyProf
 
     def determine_event_specification_and_value_scale
       @event_specification = "events: "
-      case RubyProf.measure_mode
+      case @result.measure_mode
         when RubyProf::PROCESS_TIME
           @value_scale = RubyProf::CLOCKS_PER_SEC
           @event_specification << 'process_time'

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

@@ -6,16 +6,16 @@ module RubyProf
   # profile, a call stack profile and a graph profile.
   class MultiPrinter
     def initialize(result, printers = [:flat, :graph_html])
-      @flat_printer = FlatPrinter.new(result) if printers.include?(:flat)
+      @flat_printer = printers.include?(:flat) ? FlatPrinter.new(result) : nil
 
-      @graph_printer = GraphPrinter.new(result) if printers.include?(:graph)
-      @graph_html_printer = GraphHtmlPrinter.new(result) if printers.include?(:graph_html)
+      @graph_printer = printers.include?(:graph) ? GraphPrinter.new(result) : nil
+      @graph_html_printer = printers.include?(:graph_html) ? GraphHtmlPrinter.new(result) : nil
 
-      @tree_printer = CallTreePrinter.new(result) if printers.include?(:tree)
-      @call_info_printer = CallInfoPrinter.new(result) if printers.include?(:call_tree)
+      @tree_printer = printers.include?(:tree) ? CallTreePrinter.new(result) : nil
+      @call_info_printer = printers.include?(:call_tree) ? CallInfoPrinter.new(result) : nil
 
-      @stack_printer = CallStackPrinter.new(result) if printers.include?(:stack)
-      @dot_printer = DotPrinter.new(result) if printers.include?(:dot)
+      @stack_printer = printers.include?(:stack) ? CallStackPrinter.new(result) : nil
+      @dot_printer = printers.include?(:dot) ? DotPrinter.new(result) : nil
     end
 
     def self.needs_dir?
@@ -28,7 +28,7 @@ module RubyProf
     def print(options)
       validate_print_params(options)
 
-      @profile = options.delete(:profile) || "profile"
+      @file_name = options.delete(:profile) || "profile"
       @directory = options.delete(:path) || File.expand_path(".")
 
       print_to_flat(options) if @flat_printer
@@ -44,36 +44,36 @@ module RubyProf
 
     # the name of the flat profile file
     def flat_report
-      "#{@directory}/#{@profile}.flat.txt"
+      "#{@directory}/#{@file_name}.flat.txt"
     end
 
     # the name of the graph profile file
     def graph_report
-      "#{@directory}/#{@profile}.graph.txt"
+      "#{@directory}/#{@file_name}.graph.txt"
     end
 
     def graph_html_report
-      "#{@directory}/#{@profile}.graph.html"
+      "#{@directory}/#{@file_name}.graph.html"
     end
 
     # the name of the callinfo profile file
     def call_info_report
-      "#{@directory}/#{@profile}.call_tree.txt"
+      "#{@directory}/#{@file_name}.call_tree.txt"
     end
 
     # the name of the callgrind profile file
     def tree_report
-      "#{@directory}/#{@profile}.callgrind.out.#{$$}"
+      "#{@directory}/#{@file_name}.callgrind.out.#{$$}"
     end
 
     # the name of the call stack profile file
     def stack_report
-      "#{@directory}/#{@profile}.stack.html"
+      "#{@directory}/#{@file_name}.stack.html"
     end
 
     # the name of the call stack profile file
     def dot_report
-      "#{@directory}/#{@profile}.dot"
+      "#{@directory}/#{@file_name}.dot"
     end
 
     def print_to_flat(options)
@@ -101,12 +101,12 @@ module RubyProf
     end
 
     def print_to_tree(options)
-      @tree_printer.print(options.merge(:path => @directory, :profile => @profile))
+      @tree_printer.print(options.merge(:path => @directory, :profile => @file_name))
     end
 
     def print_to_stack(options)
       File.open(stack_report, "wb") do |file|
-        @stack_printer.print(file, options.merge(:graph => "#{@profile}.graph.html"))
+        @stack_printer.print(file, options.merge(:graph => "#{@file_name}.graph.html"))
       end
     end
 

data/lib/ruby-prof/profile.rb

@@ -1,70 +1,70 @@
-# encoding: utf-8
-
-require 'ruby-prof/exclude_common_methods'
-
-module RubyProf
-  class Profile
-    def measure_mode_string
-      case self.measure_mode
-        when WALL_TIME
-          "wall_time"
-        when PROCESS_TIME
-          "process_time"
-        when ALLOCATIONS
-          "allocations"
-        when MEMORY
-          "memory"
-      end
-    end
-
-    # Hides methods that, when represented as a call graph, have
-    # extremely large in and out degrees and make navigation impossible.
-    def exclude_common_methods!
-      ExcludeCommonMethods.apply!(self)
-    end
-
-    def exclude_methods!(mod, *method_or_methods)
-      [method_or_methods].flatten.each do |name|
-        exclude_method!(mod, name)
-      end
-    end
-
-    def exclude_singleton_methods!(mod, *method_or_methods)
-      exclude_methods!(mod.singleton_class, *method_or_methods)
-    end
-
-    # call-seq:
-    # merge! -> self
-    #
-    # Merges RubyProf threads whose root call_trees reference the same target method. This is useful
-    # when profiling code that uses a main thread/fiber to distribute work to multiple workers.
-    # If there are tens or hundreds of workers, viewing results per worker thread/fiber can be
-    # overwhelming. Using +merge!+ will combine the worker times together into one result.
-    #
-    # Note the reported time will be much greater than the actual wall time. For example, if there
-    # are 10 workers that each run for 5 seconds, merged results will show one thread that
-    # ran for 50 seconds.
-    #
-    def merge!
-      # First group threads by their root call tree target (method). If the methods are
-      # different than there is nothing to merge
-      grouped = threads.group_by do |thread|
-        thread.call_tree.target
-      end
-
-      # For each target, get the first thread. Then loop over the remaining threads,
-      # and merge them into the first one and ten delete them. So we will be left with
-      # one thread per target.
-      grouped.each do |target, threads|
-        thread = threads.shift
-        threads.each do |other_thread|
-          thread.merge!(other_thread)
-          remove_thread(other_thread)
-        end
-        thread
-      end
-
-      self
-    end
-  end
-end
+# encoding: utf-8
+
+require 'ruby-prof/exclude_common_methods'
+
+module RubyProf
+  class Profile
+    def measure_mode_string
+      case self.measure_mode
+        when WALL_TIME
+          "wall_time"
+        when PROCESS_TIME
+          "process_time"
+        when ALLOCATIONS
+          "allocations"
+        when MEMORY
+          "memory"
+      end
+    end
+
+    # Hides methods that, when represented as a call graph, have
+    # extremely large in and out degrees and make navigation impossible.
+    def exclude_common_methods!
+      ExcludeCommonMethods.apply!(self)
+    end
+
+    def exclude_methods!(mod, *method_names)
+      [method_names].flatten.each do |method_name|
+        exclude_method!(mod, method_name)
+      end
+    end
+
+    def exclude_singleton_methods!(mod, *method_names)
+      exclude_methods!(mod.singleton_class, *method_names)
+    end
+
+    # call-seq:
+    # merge! -> self
+    #
+    # Merges RubyProf threads whose root call_trees reference the same target method. This is useful
+    # when profiling code that uses a main thread/fiber to distribute work to multiple workers.
+    # If there are tens or hundreds of workers, viewing results per worker thread/fiber can be
+    # overwhelming. Using +merge!+ will combine the worker times together into one result.
+    #
+    # Note the reported time will be much greater than the actual wall time. For example, if there
+    # are 10 workers that each run for 5 seconds, merged results will show one thread that
+    # ran for 50 seconds.
+    #
+    def merge!
+      # First group threads by their root call tree target (method). If the methods are
+      # different than there is nothing to merge
+      grouped = threads.group_by do |thread|
+        thread.call_tree.target
+      end
+
+      # For each target, get the first thread. Then loop over the remaining threads,
+      # and merge them into the first one and ten delete them. So we will be left with
+      # one thread per target.
+      grouped.each do |target, threads|
+        thread = threads.shift
+        threads.each do |other_thread|
+          thread.merge!(other_thread)
+          remove_thread(other_thread)
+        end
+        thread
+      end
+
+      self
+    end
+  end
+end

data/lib/ruby-prof/rack.rb

@@ -6,7 +6,6 @@ module Rack
     def initialize(app, options = {})
       @app = app
       @options = options
-      @options[:min_percent] ||= 1
 
       @tmpdir = options[:path] || Dir.tmpdir
       FileUtils.mkdir_p(@tmpdir)
@@ -26,14 +25,19 @@ module Rack
       if should_profile?(request.path)
         begin
           result = nil
-          data = ::RubyProf::Profile.profile(profiling_options) do
+          profile = ::RubyProf::Profile.profile(profiling_options) do
             result = @app.call(env)
           end
 
+          if @options[:merge_fibers]
+            profile.merge!
+          end
+
+
           path = request.path.gsub('/', '-')
           path.slice!(0)
 
-          print(data, path)
+          print(profile, path)
           result
         end
       else
@@ -54,39 +58,45 @@ module Rack
     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]
+      result = {}
+      result[:measure_mode] = @options[:measure_mode] || ::RubyProf::WALL_TIME
+      result[:track_allocations] = @options[:track_allocations] || false
+      result[:exclude_common] = @options[:exclude_common] || false
+
+      if @options[:ignore_existing_threads]
+        result[:exclude_threads] = Thread.list.select {|thread| thread != Thread.current}
       end
-      if @options[:merge_fibers]
-        options[:merge_fibers] = true
+
+      if @options[:request_thread_only]
+        result[:include_threads] = [Thread.current]
       end
-      options
+
+      result
+    end
+
+    def print_options
+      result = {}
+      result[:min_percent] = @options[:min_percent] || 1
+      result[:sort_method] = @options[:sort_method] || :total_time
+      result
     end
 
-    def print(data, path)
+    def print(profile, path)
       @printer_klasses.each do |printer_klass, base_name|
-        printer = printer_klass.new(data)
+        printer = printer_klass.new(profile)
 
         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}"))
+          printer.print(print_options.merge(:profile => "#{path}-#{base_name}"))
         elsif printer_klass == ::RubyProf::CallTreePrinter
-          printer.print(@options.merge(:profile => "#{path}-#{base_name}"))
+          printer.print(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)
+            printer.print(file, print_options)
           end
         end
       end

data/lib/ruby-prof/version.rb

@@ -1,3 +1,3 @@
 module RubyProf
-  VERSION = "1.5.0"
+  VERSION = "1.6.2"
 end

data/test/abstract_printer_test.rb

@@ -5,6 +5,7 @@ require File.expand_path('../test_helper', __FILE__)
 
 class AbstractPrinterTest < TestCase
   def setup
+    super
     @result = {}
     @printer = RubyProf::AbstractPrinter.new(@result)
     @options = {}

data/test/alias_test.rb

@@ -15,13 +15,8 @@ class AliasTest < TestCase
     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
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
       TestMe.new.some_method
     end
 
@@ -31,7 +26,7 @@ class AliasTest < TestCase
     # Method 0
     method = methods[0]
     assert_equal('AliasTest#test_alias', method.full_name)
-    assert_equal(25, method.line)
+    assert_equal(20, method.line)
     refute(method.recursive?)
 
     assert_equal(0, method.call_trees.callers.count)
@@ -39,11 +34,11 @@ class AliasTest < TestCase
     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)
+    assert_equal(20, 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)
+    assert_equal(20, call_tree.line)
 
     # Method 1
     method = methods[1]
@@ -54,7 +49,7 @@ class AliasTest < TestCase
     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(20, call_tree.line)
 
     assert_equal(1, method.call_trees.callees.count)
     call_tree = method.call_trees.callees[0]
@@ -83,7 +78,7 @@ class AliasTest < TestCase
     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(20, call_tree.line)
 
     assert_equal(1, method.call_trees.callees.count)
     call_tree = method.call_trees.callees[0]