ruby-prof 2.0.4 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9994be0a9bf3c5d097d5064e0c950b6f494acd4cd2fd288fd8bb8c64c3a4a854
-  data.tar.gz: 13fef04d65fb66ce56c0eb32e2d03071f757776e048fcc1c39afdeb2e9af1951
+  metadata.gz: bea4b44182333b828042bdc616b790f75c5153b8e6685ce009e1544e0ae72a77
+  data.tar.gz: 19d0c19e31d7d28cb49e7e962425d16b841fe2ac62e7ad033a6ec6d4be7367ae
 SHA512:
-  metadata.gz: 4967192c074e787a847cba962eb93e7bfc890ad91aa2d92becf151c726979e1944e46bd4196d63192c35e4067742019ebc4b6450e07d7b047c722924f9d61ab8
-  data.tar.gz: 98a6be45f8b4597ffa66d5ef4f679ce1b99e7e2563853f496c84733c9954dc77a70284ec06d682031119f7069107b7557b628c9ca899059543971d1f6eae7b74
+  metadata.gz: a50821527f7cc6a24af9d167cb9b3c68d076b53ce495c1d2efde4cf90f6b90775e14f1599df660c4f0fddfc7f2c1274065a6bead8e0cd4dd8916ff2b11e65b4e
+  data.tar.gz: d43d3352a8d7a1d275621e5eea0c4c251f2084725317ac0e0120202dbcebd25654d433ca01e1de3567d99389585fb76805b80d677a3442a3da1ca1b46c8962c2

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 2.0.5 (2026-06-21)
+* Fix FlameGraphPrinter crashing with `JSON::NestingError` on deep call trees (issue #353)
+* Fix link to API documentation (issue #351)
+
 ## 2.0.4 (2026-03-03)
 * Fix NoMethodError when sort_method is nil (issue #349)
 * Fix broken source_code_uri on rubygems.org (issue #350)
@@ -28,7 +32,7 @@
 
 ### Backwards Incompatible Changes
 * Removed `RubyProf::MEMORY` measurement mode (no longer works on Ruby 4.0+)
-* Rremove compatibility API that was scheduled for removal in 2023
+* Remove compatibility API that was scheduled for removal in 2023
 * Printer options now use keyword arguments instead of an options hash. For example:
   ```ruby
   # Before:
@@ -162,7 +166,7 @@ Changes (Charlie Savage):
 
 * Profiling is significantly faster - 5x in some cases
 * Recursive profiles are finally handled correctly.  Yeah!!!
-* Redesigned reports (Chirs Whitefield)
+* Redesigned reports (Chris Whitefield)
 * New documentation website (https://ruby-prof.github.io)
 * The ability to measure allocations and memory usage using a standard (unpatched) version of ruby
 * The ability to save and reload profiling results for later analysis

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

@@ -1,78 +1,80 @@
-# encoding: utf-8
-
-require 'erb'
-require 'json'
-
-module RubyProf
-  # Prints a HTML flame graph visualization of the call tree.
-  #
-  # To use the printer:
-  #
-  #   result = RubyProf.profile do
-  #     [code to profile]
-  #   end
-  #
-  #   printer = RubyProf::FlameGraphPrinter.new(result)
-  #   printer.print(STDOUT)
-
-  class FlameGraphPrinter < AbstractPrinter
-    include ERB::Util
-
-    # Specify print options.
-    #
-    # output - Any IO object, including STDOUT or a file.
-    #
-    # Keyword arguments:
-    #   title:       - a String to override the default "ruby-prof flame graph"
-    #                  title of the report.
-    #
-    # Also accepts min_percent:, max_percent:, filter_by:, and sort_method:
-    # from AbstractPrinter.
-    def print(output = STDOUT, title: "ruby-prof flame graph",
-              min_percent: 0, max_percent: 100, filter_by: :self_time, sort_method: nil, max_depth: nil, **)
-      @min_percent = min_percent
-      @max_percent = max_percent
-      @filter_by = filter_by
-      @sort_method = sort_method
-      @max_depth = max_depth
-      @title = title
-      output << ERB.new(self.template).result(binding)
-    end
-
-    attr_reader :title
-
-    def build_flame_data(call_tree, depth = 0)
-      node = {
-        name: call_tree.target.full_name,
-        value: call_tree.total_time,
-        self_value: call_tree.self_time,
-        called: call_tree.called,
-        children: []
-      }
-
-      if @max_depth.nil? || depth < @max_depth
-        call_tree.children.each do |child|
-          node[:children] << build_flame_data(child, depth + 1)
-        end
-      end
-
-      node
-    end
-
-    def flame_data_json
-      threads = @result.threads.map do |thread|
-        {
-          id: thread.id,
-          fiber_id: thread.fiber_id,
-          total_time: thread.total_time,
-          data: build_flame_data(thread.call_tree)
-        }
-      end
-      JSON.generate(threads)
-    end
-
-    def template
-      open_asset('flame_graph_printer.html.erb')
-    end
-  end
-end
+# encoding: utf-8
+
+require 'erb'
+require 'json'
+
+module RubyProf
+  # Prints a HTML flame graph visualization of the call tree.
+  #
+  # To use the printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::FlameGraphPrinter.new(result)
+  #   printer.print(STDOUT)
+
+  class FlameGraphPrinter < AbstractPrinter
+    include ERB::Util
+
+    # Specify print options.
+    #
+    # output - Any IO object, including STDOUT or a file.
+    #
+    # Keyword arguments:
+    #   title:       - a String to override the default "ruby-prof flame graph"
+    #                  title of the report.
+    #
+    # Also accepts min_percent:, max_percent:, filter_by:, and sort_method:
+    # from AbstractPrinter.
+    def print(output = STDOUT, title: "ruby-prof flame graph",
+              min_percent: 0, max_percent: 100, filter_by: :self_time, sort_method: nil, max_depth: nil, **)
+      @min_percent = min_percent
+      @max_percent = max_percent
+      @filter_by = filter_by
+      @sort_method = sort_method
+      @max_depth = max_depth
+      @title = title
+      output << ERB.new(self.template).result(binding)
+    end
+
+    attr_reader :title
+
+    def build_flame_data(call_tree, depth = 0)
+      node = {
+        name: call_tree.target.full_name,
+        value: call_tree.total_time,
+        self_value: call_tree.self_time,
+        called: call_tree.called,
+        children: []
+      }
+
+      if @max_depth.nil? || depth < @max_depth
+        call_tree.children.each do |child|
+          node[:children] << build_flame_data(child, depth + 1)
+        end
+      end
+
+      node
+    end
+
+    def flame_data_json
+      threads = @result.threads.map do |thread|
+        {
+          id: thread.id,
+          fiber_id: thread.fiber_id,
+          total_time: thread.total_time,
+          data: build_flame_data(thread.call_tree)
+        }
+      end
+      # Disable JSON nesting limit (default 100) so deep call trees serialize.
+      # See https://github.com/ruby-prof/ruby-prof/issues/353
+      JSON.generate(threads, max_nesting: false)
+    end
+
+    def template
+      open_asset('flame_graph_printer.html.erb')
+    end
+  end
+end

data/lib/ruby-prof/version.rb

@@ -1,3 +1,3 @@
 module RubyProf
-  VERSION = "2.0.4"
+  VERSION = "2.0.5"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-prof
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.0.5
 platform: ruby
 authors:
 - Shugo Maeda, Charlie Savage, Roger Pack, Stefan Kaes
 bindir: bin
 cert_chain: []
-date: 2026-03-03 00:00:00.000000000 Z
+date: 2026-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -97,38 +97,8 @@ files:
 - CHANGELOG.md
 - LICENSE
 - README.md
-- Rakefile
 - bin/ruby-prof
 - bin/ruby-prof-check-trace
-- docs/advanced-usage.md
-- docs/alternatives.md
-- docs/architecture.md
-- docs/best-practices.md
-- docs/getting-started.md
-- docs/history.md
-- docs/index.md
-- docs/profiling-rails.md
-- docs/public/examples/example.rb
-- docs/public/examples/generate_reports.rb
-- docs/public/examples/reports/call_info.txt
-- docs/public/examples/reports/call_stack.html
-- docs/public/examples/reports/callgrind.out
-- docs/public/examples/reports/flame_graph.html
-- docs/public/examples/reports/flat.txt
-- docs/public/examples/reports/graph.dot
-- docs/public/examples/reports/graph.html
-- docs/public/examples/reports/graph.txt
-- docs/public/examples/reports/graphviz_viewer.html
-- docs/public/images/call_stack.png
-- docs/public/images/class_diagram.png
-- docs/public/images/dot_printer.png
-- docs/public/images/flame_graph.png
-- docs/public/images/flat.png
-- docs/public/images/graph.png
-- docs/public/images/graph_html.png
-- docs/public/images/ruby-prof-logo.svg
-- docs/reports.md
-- docs/stylesheets/extra.css
 - ext/ruby_prof/extconf.rb
 - ext/ruby_prof/rp_allocation.c
 - ext/ruby_prof/rp_allocation.h
@@ -179,56 +149,6 @@ files:
 - lib/ruby-prof/thread.rb
 - lib/ruby-prof/version.rb
 - lib/unprof.rb
-- ruby-prof.gemspec
-- test/abstract_printer_test.rb
-- test/alias_test.rb
-- test/call_tree_builder.rb
-- test/call_tree_test.rb
-- test/call_tree_visitor_test.rb
-- test/call_trees_test.rb
-- test/duplicate_names_test.rb
-- test/dynamic_method_test.rb
-- test/enumerable_test.rb
-- test/exceptions_test.rb
-- test/exclude_methods_test.rb
-- test/exclude_threads_test.rb
-- test/fiber_test.rb
-- test/gc_test.rb
-- test/inverse_call_tree_test.rb
-- test/line_number_test.rb
-- test/marshal_test.rb
-- test/measure_allocations.rb
-- test/measure_allocations_test.rb
-- test/measure_process_time_test.rb
-- test/measure_times.rb
-- test/measure_wall_time_test.rb
-- test/measurement_test.rb
-- test/merge_test.rb
-- test/method_info_test.rb
-- test/multi_printer_test.rb
-- test/no_method_class_test.rb
-- test/pause_resume_test.rb
-- test/prime.rb
-- test/prime_script.rb
-- test/printer_call_stack_test.rb
-- test/printer_call_tree_test.rb
-- test/printer_flame_graph_test.rb
-- test/printer_flat_test.rb
-- test/printer_graph_html_test.rb
-- test/printer_graph_test.rb
-- test/printers_test.rb
-- test/printing_recursive_graph_test.rb
-- test/profile_test.rb
-- test/rack_test.rb
-- test/recursive_test.rb
-- test/scheduler.rb
-- test/singleton_test.rb
-- test/stack_printer_test.rb
-- test/start_stop_test.rb
-- test/test_helper.rb
-- test/thread_test.rb
-- test/unique_call_path_test.rb
-- test/yarv_test.rb
 homepage: https://github.com/ruby-prof/ruby-prof
 licenses:
 - BSD-2-Clause
@@ -236,7 +156,7 @@ metadata:
   bug_tracker_uri: https://github.com/ruby-prof/ruby-prof/issues
   changelog_uri: https://github.com/ruby-prof/ruby-prof/blob/master/CHANGELOG.md
   documentation_uri: https://ruby-prof.github.io/
-  source_code_uri: https://github.com/ruby-prof/ruby-prof/tree/2.0.4
+  source_code_uri: https://github.com/ruby-prof/ruby-prof/tree/2.0.5
 rdoc_options: []
 require_paths:
 - lib
@@ -254,5 +174,4 @@ requirements: []
 rubygems_version: 4.0.6
 specification_version: 4
 summary: Fast Ruby profiler
-test_files:
-- test/test_helper.rb
+test_files: []

data/Rakefile

@@ -1,98 +0,0 @@
-# encoding: utf-8
-
-require "rubygems/package_task"
-require "rake/extensiontask"
-require "rake/testtask"
-require "rdoc/task"
-require "date"
-require "rake/clean"
-
-# To release a version of ruby-prof:
-#   * Update lib/ruby-prof/version.rb
-#   * Update CHANGES
-#   * git commit to commit files
-#   * rake clobber to remove extra files
-#   * rake compile to build windows gems
-#   * rake package to create the gems
-#   * Tag the release (git tag 0.10.1)
-#   * Push to ruybgems.org (gem push pkg/<gem files>)
-
-GEM_NAME = 'ruby-prof'
-SO_NAME = 'ruby_prof'
-
-default_spec = Gem::Specification.load("#{GEM_NAME}.gemspec")
-
-# specify which versions/builds to cross compile
-Rake::ExtensionTask.new do |ext|
-  ext.gem_spec = default_spec
-  ext.name = SO_NAME
-  ext.ext_dir = "ext/#{SO_NAME}"
-  ext.lib_dir = "lib/#{Gem::Version.new(RUBY_VERSION).segments[0..1].join('.')}"
-  ext.cross_compile = true
-  ext.cross_platform = ['x64-mingw32']
-end
-
-# Rake task to build the default package
-Gem::PackageTask.new(default_spec) do |pkg|
-  pkg.need_tar = true
-end
-
-# make sure rdoc has been built when packaging
-# why do we ship rdoc as part of the gem?
-Rake::Task[:package].enhance [:rdoc]
-
-# Setup Windows Gem
-if RUBY_PLATFORM.match(/mswin|mingw/)
-  # Windows specification
-  win_spec = default_spec.clone
-  win_spec.platform = Gem::Platform::CURRENT
-  win_spec.files += Dir.glob('lib/**/*.so')
-
-  # Unset extensions
-  win_spec.extensions = nil
-
-  # Rake task to build the windows package
-  Gem::PackageTask.new(win_spec) do |pkg|
-    pkg.need_tar = false
-  end
-end
-
-# ---------  RDoc Documentation ------
-desc "Generate rdoc documentation"
-RDoc::Task.new("rdoc") do |rdoc|
-  rdoc.rdoc_dir = 'doc'
-  rdoc.title = "ruby-prof"
-  # Show source inline with line numbers
-  rdoc.options << "--line-numbers"
-  # Make the readme file the start page for the generated html
-  rdoc.options << '--main' << 'README.md'
-  rdoc.rdoc_files.include('bin/*',
-                          'doc/*.rdoc',
-                          'lib/**/*.rb',
-                          'ext/ruby_prof/*.c',
-                          'ext/ruby_prof/*.h',
-                          'README.md',
-                          'LICENSE')
-end
-
-task :default => :test
-
-for file in Dir['lib/**/*.{o,so,bundle}']
-  CLEAN.include file
-end
-for file in Dir['doc/**/*.{txt,dat,png,html}']
-  CLEAN.include file
-end
-CLEAN.reject!{|f| !File.exist?(f)}
-task :clean do
-  # remove tmp dir contents completely after cleaning
-  FileUtils.rm_rf('tmp/*')
-end
-
-desc 'Run the ruby-prof test suite'
-Rake::TestTask.new do |t|
-  t.libs += %w(lib ext test)
-  t.test_files = Dir['test/**_test.rb']
-  t.verbose = true
-  t.warning = true
-end

data/docs/advanced-usage.md

@@ -1,132 +0,0 @@
-# Advanced Usage
-
-This section describes advanced usage of ruby-prof. Additional documentation for every class is also [available](index.md#api-documentation). For workflow guidance, see [Best Practices](best-practices.md).
-
-## Profiling Options
-
-ruby-prof understands the following options when profiling code:
-
-**measure_mode** - What ruby-prof should measure. For more information see the [Measurement Mode](#measurement-mode) section.
-
-**track_allocations** - Tracks each object location, including the object class and source file location. For more information see the [Allocation Tracking](#allocation-tracking) section.
-
-**exclude_threads** - Array of threads which should not be profiled. For more information see the [Thread Inclusion/Exclusion](#thread-inclusionexclusion) section.
-
-**include_threads** - Array of threads which should be profiled. All other threads will be ignored. For more information see the [Thread Inclusion/Exclusion](#thread-inclusionexclusion) section.
-
-**allow_exceptions** - Whether to raise exceptions encountered during profiling, or to suppress them. Defaults to false.
-
-**exclude_common** - Automatically calls `exclude_common_methods!` to exclude commonly cluttering methods. Defaults to false. For more information see the [Method Exclusion](#method-exclusion) section.
-
-## Measurement Mode
-
-The measurement mode determines what ruby-prof measures when profiling code. Supported measurements are:
-
-### Wall Time
-
-Wall time measures the real-world time elapsed between any two moments in seconds. If there are other processes concurrently running on the system that use significant CPU or disk time during a profiling run then the reported results will be larger than expected. On Windows, wall time is measured using `QueryPerformanceCounter` and on other platforms by `clock_gettime(CLOCK_MONOTONIC)`. Use `RubyProf::WALL_TIME` to select this mode.
-
-### Process Time
-
-Process time measures the time used by a process between any two moments in seconds. It is unaffected by other processes concurrently running on the system. Remember with process time that calls to methods like sleep will not be included in profiling results. On Windows, process time is measured using `GetProcessTimes` and on other platforms by `clock_gettime`. Use `RubyProf::PROCESS_TIME` to select this mode.
-
-### Object Allocations
-
-Object allocations measures how many objects each method in a program allocates. Measurements are done via Ruby's `RUBY_INTERNAL_EVENT_NEWOBJ` trace event, counting each new object created (excluding internal `T_IMEMO` objects). Use `RubyProf::ALLOCATIONS` to select this mode.
-
-To set the measurement mode:
-
-```ruby
-profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
-profile = RubyProf::Profile.new(measure_mode: RubyProf::PROCESS_TIME)
-profile = RubyProf::Profile.new(measure_mode: RubyProf::ALLOCATIONS)
-```
-
-The default value is `RubyProf::WALL_TIME`. You may also specify the measure mode by using the `RUBY_PROF_MEASURE_MODE` environment variable:
-
-```
-export RUBY_PROF_MEASURE_MODE=wall
-export RUBY_PROF_MEASURE_MODE=process
-export RUBY_PROF_MEASURE_MODE=allocations
-```
-
-## Allocation Tracking
-
-ruby-prof also has the ability to track object allocations. This functionality can be turned on via the track_allocations option:
-
-```ruby
-require 'ruby-prof'
-
-RubyProf::Profile.profile(track_allocations: true) do
-  ...
-end
-```
-
-Note the `RubyProf::ALLOCATIONS` measure mode is slightly different than tracking allocations. The measurement mode provides high level information about the number of allocations performed in each method. In contrast, tracking allocations provides detailed information about allocation type, count, and source location. Currently, to see allocations results you must use the `RubyProf::GraphHtmlPrinter`.
-
-## Thread Inclusion/Exclusion
-
-ruby-prof can profile multiple threads. Sometimes this can be overwhelming. For example, assume you want to determine why your tests are running slowly. If you are using minitest, it can run tests in parallel by spawning worker threads (to force a single worker, set `N=0` when running tests). Thus, ruby-prof provides two options to specify which threads should be profiled:
-
-**exclude_threads** - Array of threads which should not be profiled.
-
-**include_threads** - Array of threads which should be profiled. All other threads will be ignored.
-
-## Method Exclusion
-
-ruby-prof supports excluding specific methods and threads from profiling results. This is useful for reducing connectivity in the call graph, making it easier to identify the source of performance problems when using a graph printer. For example, consider `Integer#times`: it's hardly ever useful to know how much time is spent in the method itself. We are more interested in how much the passed in block contributes to the time spent in the method which contains the `Integer#times` call. The effect on collected metrics are identical to eliminating methods from the profiling result in a post process step.
-
-```ruby
-profile = RubyProf::Profile.new(...)
-profile.exclude_methods!(Integer, :times, ...)
-profile.start
-```
-
-A convenience method is provided to exclude a large number of methods which usually clutter up profiles:
-
-```ruby
-profile.exclude_common_methods!
-```
-
-However, this is a somewhat opinionated method collection. It's usually better to view it as an inspiration instead of using it directly (see [exclude_common_methods.rb](https://github.com/ruby-prof/ruby-prof/blob/e087b7d7ca11eecf1717d95a5c5fea1e36ea3136/lib/ruby-prof/profile/exclude_common_methods.rb)).
-
-## Merging Threads and Fibers
-
-ruby-prof profiles each thread and fiber separately. A common design pattern is to have a main thread delegate work to background threads or fibers. Examples include web servers such as Puma and Falcon, as well as code that uses `Enumerator`, `Fiber.new`, or async libraries.
-
-Understanding profiling results can be very difficult when there are many threads or fibers because each one appears as a separate entry in the output. To help with this, ruby-prof includes the ability to merge results for threads and fibers that start with the same root method. In the best case, this can collapse results into just two entries - one for the parent thread and one for all workers.
-
-Note the collapsed results show the sum of times for all merged threads/fibers. For example, assume there are 10 worker fibers that each took 5 seconds to run. The single merged entry will show a total time of 50 seconds.
-
-To merge threads and fibers:
-
-```ruby
-profile = RubyProf::Profile.profile do
-            ...
-          end
-profile.merge!
-```
-
-This is also supported in the Rack adapter via the `merge_fibers` option:
-
-```ruby
-config.middleware.use Rack::RubyProf, path: Rails.root.join("tmp/profile"), merge_fibers: true
-```
-
-## Saving Results
-
-It can be helpful to save the results of a profiling run for later analysis. Results can be saved using Ruby's [marshal](https://docs.ruby-lang.org/en/master/Marshal.html) library.
-
-```ruby
-profile_1 = RubyProf::Profile.profile do
-  ...
-end
-
-# Save the results
-data = Marshal.dump(profile_1)
-
-# Sometime later load the results
-profile_2 = Marshal.load(data)
-```
-
-**!!!WARNING!!!** - Only load ruby-prof profiles that you know are safe. Demarshaling data can lead to arbitrary code execution and thus can be [dangerous](https://docs.ruby-lang.org/en/master/Marshal.html#module-Marshal-label-Security+considerations).

data/docs/alternatives.md

@@ -1,98 +0,0 @@
-# Comparison with Other Profilers
-
-Ruby has several excellent profiling tools, each with different strengths. This page compares ruby-prof with three popular alternatives to help you choose the right tool for your needs.
-
-## Tracing vs Sampling
-
-The most important distinction between profilers is **tracing** vs **sampling**:
-
-- **Tracing profilers** (ruby-prof) instrument every method call and return. This provides exact call counts and complete call graphs, but adds overhead to every method invocation.
-- **Sampling profilers** (stackprof, rbspy, vernier) periodically capture stack snapshots. This has much lower overhead but may miss short-lived method calls.
-
-## Overview
-
-The table below compares ruby-prof with [stackprof](https://github.com/tmm1/stackprof), [rbspy](https://github.com/rbspy/rbspy), and [vernier](https://github.com/jhawthorn/vernier) — the three most popular sampling profilers for Ruby.
-
-| | ruby-prof | stackprof | rbspy | vernier |
-|---|---|---|---|---|
-| **Type** | Tracing | Sampling | Sampling | Sampling |
-| **Implementation** | C extension (TracePoint API) | C extension (signals) | External Rust binary | C extension (signals) |
-| **Code changes** | None ([CLI](getting-started.md#command-line)) or minimal | Minimal | None | Minimal |
-| **Ruby versions** | All, since 2006 (currently 3.2+) | 2.2+ | 1.9.3+ | 3.2.1+ |
-| **OS support** | Linux, macOS, Windows | Linux | Linux, macOS, Windows, FreeBSD | Linux, macOS |
-
-## Measurement Capabilities
-
-| | ruby-prof | stackprof | rbspy | vernier |
-|---|---|---|---|---|
-| **Wall time** | Yes | Yes | Yes | Yes |
-| **CPU/Process time** | Yes | Yes | No | No |
-| **Allocations** | Yes | Yes | No | Yes |
-| **GVL visibility** | No | No | No | Yes |
-| **GC pauses** | No | No | No | Yes |
-| **Retained memory** | No | No | No | Yes |
-| **Multi-thread** | Yes | No | No | Yes |
-| **Fibers** | Yes | No | No | No |
-
-## Report Formats
-
-| | ruby-prof | stackprof | rbspy | vernier |
-|---|---|---|---|---|
-| **Flat/Summary** | Yes | Yes | Yes | No |
-| **Call graph** | Yes (text + HTML) | No | No | No |
-| **Flame graph** | Yes (HTML) | Yes | Yes (SVG) | Yes (Firefox Profiler) |
-| **Call stack** | Yes (HTML) | No | No | No |
-| **Callgrind** | Yes | No | Yes | No |
-| **Graphviz dot** | Yes | Yes | No | No |
-
-## When to Use Each
-
-### ruby-prof
-
-ruby-prof is the longest-standing Ruby profiler, with its [first](./history.md) release in 2005. It has been continuously maintained for nearly two decades, evolving alongside Ruby itself from 1.8 through 4.0. Over that time it has supported every major Ruby version and platform, including Windows — a rarity among Ruby C extensions.
-
-Being a tracing profiler, ruby-prof provides *exact* information about your program. It tracks every thread, every fiber and every method call. It shines with its support for multiple measurements modes and excellent reporting capabilities. 
-
-ruby-prof can be used from the [command line](getting-started.md#command-line) with no code changes, or via an API for more control.
-
-The biggest downsides of ruby-prof are:
-
-* It adds significant overhead for running programs, so is not suitable for production use
-* It must start a Ruby program, it cannot attach to an already running program
-
-### stackprof
-
-[stackprof](https://github.com/tmm1/stackprof) is a low-overhead, sampling profiler that is good for development. It adds minimal overhead while still providing useful flame graphs and per-line hit counts. A good choice when you want something lightweight and well-established.
-
-The biggest downsides of stackprof are:
-
- * Single-thread only
- * Linux only for time-based modes
-
-### rbspy
-
-[rbspy](https://github.com/rbspy/rbspy) is a sampling profiler best for profiling in production or when you cannot modify the application code. As an external process, it attaches to a running Ruby process by PID with zero code changes. It is particularly useful for profiling third-party Ruby applications (Chef, Puppet, etc.), investigating slow test runs, or quick profiling of scripts via `rbspy record ruby my-script.rb`. Supports the widest range of Ruby versions.
-
-The biggest downsides of rbspy are:
-
-* No allocation profiling
-* No call graph or caller/callee data
-
-### vernier
-
-[vernier](https://github.com/jhawthorn/vernier) is a sampling profiler best for diagnosing concurrency issues and understanding GVL contention. It is the only Ruby profiler that reports GVL state, GC pauses and idle time. Its Firefox Profiler integration provides rich interactive visualizations with per-thread timelines.
-
-The biggest downsides of vernier are:
-
-* Requires Ruby 3.2.1+
-* No Windows support
-
-### rack-mini-profiler
-
-[rack-mini-profiler](https://github.com/MiniProfiler/rack-mini-profiler) is a "batteries-included" profiling tool for Rails and Rack applications. It uses stackprof under the hood for CPU profiling while also supporting memory profiling. It is a good choice if you want an integrated profiling solution that works directly in the browser during development.
-
-## Memory Profiling
-
-[memory_profiler](https://github.com/SamSaffron/memory_profiler) is another profiler, but it focuses exclusively on memory usage. It uses Ruby's `ObjectSpace` API to track every object allocation during a block of code, recording the source file, line number, object type, and size via `ObjectSpace.memsize_of`. By snapshotting the GC generation before and after, it distinguishes between allocated objects (created during the block) and retained objects (still alive after GC). This makes it useful for finding memory leaks and identifying allocation-heavy code. It's pure Ruby with no C extension, so it works across Ruby versions and platforms.
-
-ruby-prof can track allocation counts via its `RubyProf::ALLOCATIONS` mode, but memory_profiler gives deeper insight into memory specifically — object sizes, retained vs allocated, and per-gem breakdowns.