stackprof 0.2.15 → 0.2.27

data/lib/stackprof/autorun.rb

@@ -0,0 +1,19 @@
+require "stackprof"
+
+options = {}
+options[:mode] = ENV["STACKPROF_MODE"].to_sym if ENV.key?("STACKPROF_MODE")
+options[:interval] = Integer(ENV["STACKPROF_INTERVAL"]) if ENV.key?("STACKPROF_INTERVAL")
+options[:raw] = true if ENV["STACKPROF_RAW"]
+options[:ignore_gc] = true if ENV["STACKPROF_IGNORE_GC"]
+
+at_exit do
+  StackProf.stop
+  output_path = ENV.fetch("STACKPROF_OUT") do
+    require "tempfile"
+    Tempfile.create(["stackprof", ".dump"]).path
+  end
+  StackProf.results(output_path)
+  $stderr.puts("StackProf results dumped at: #{output_path}")
+end
+
+StackProf.start(**options)

data/lib/stackprof/report.rb

@@ -1,8 +1,44 @@
+# frozen_string_literal: true
+
 require 'pp'
-require 'digest/md5'
+require 'digest/sha2'
+require 'json'
 
 module StackProf
   class Report
+    MARSHAL_SIGNATURE = "\x04\x08"
+
+    class << self
+      def from_file(file)
+        if (content = IO.binread(file)).start_with?(MARSHAL_SIGNATURE)
+          new(Marshal.load(content))
+        else
+          from_json(JSON.parse(content))
+        end
+      end
+
+      def from_json(json)
+        new(parse_json(json))
+      end
+
+      def parse_json(json)
+        json.keys.each do |key|
+          value = json.delete(key)
+          from_json(value) if value.is_a?(Hash)
+
+          new_key = case key
+          when /\A[0-9]*\z/
+            key.to_i
+          else
+            key.to_sym
+          end
+
+          json[new_key] = value
+        end
+        json
+      end
+    end
+
     def initialize(data)
       @data = data
     end
@@ -16,7 +52,7 @@ module StackProf
     def normalized_frames
       id2hash = {}
       @data[:frames].each do |frame, info|
-        id2hash[frame.to_s] = info[:hash] = Digest::MD5.hexdigest("#{info[:name]}#{info[:file]}#{info[:line]}")
+        id2hash[frame.to_s] = info[:hash] = Digest::SHA256.hexdigest("#{info[:name]}#{info[:file]}#{info[:line]}")
       end
       @data[:frames].inject(Hash.new) do |hash, (frame, info)|
         info = hash[id2hash[frame.to_s]] = info.dup
@@ -38,7 +74,7 @@ module StackProf
     end
 
     def max_samples
-      @data[:max_samples] ||= frames.max_by{ |addr, frame| frame[:samples] }.last[:samples]
+      @data[:max_samples] ||= @data[:frames].values.max_by{ |frame| frame[:samples] }[:samples]
     end
 
     def files
@@ -96,15 +132,7 @@ module StackProf
     def print_flamegraph(f, skip_common, alphabetical=false)
       raise "profile does not include raw samples (add `raw: true` to collecting StackProf.run)" unless raw = data[:raw]
 
-      stacks = []
-      max_x = 0
-      max_y = 0
-      while len = raw.shift
-        max_y = len if len > max_y
-        stack = raw.slice!(0, len+1)
-        stacks << stack
-        max_x += stack.last
-      end
+      stacks, max_x, max_y = flamegraph_stacks(raw)
 
       stacks.sort! if alphabetical
 
@@ -156,8 +184,26 @@ module StackProf
       f.puts '])'
     end
 
+    def flamegraph_stacks(raw)
+      stacks = []
+      max_x = 0
+      max_y = 0
+      idx = 0
+
+      while len = raw[idx]
+        idx += 1
+        max_y = len if len > max_y
+        stack = raw.slice(idx, len+1)
+        idx += len+1
+        stacks << stack
+        max_x += stack.last
+      end
+
+      return stacks, max_x, max_y
+    end
+
     def flamegraph_row(f, x, y, weight, addr)
-      frame = frames[addr]
+      frame = @data[:frames][addr]
       f.print ',' if @rows_started
       @rows_started = true
       f.puts %{{"x":#{x},"y":#{y},"width":#{weight},"frame_id":#{addr},"frame":#{frame[:name].dump},"file":#{frame[:file].dump}}}
@@ -178,8 +224,8 @@ module StackProf
             weight += stack.last
           end
         else
-          frame = frames[val]
-          child_name = "#{ frame[:name] } : #{ frame[:file] }"
+          frame = @data[:frames][val]
+          child_name = "#{ frame[:name] } : #{ frame[:file] } : #{ frame[:line] }"
           child_data = convert_to_d3_flame_graph_format(child_name, child_stacks, depth + 1)
           weight += child_data["value"]
           children << child_data
@@ -196,15 +242,7 @@ module StackProf
     def print_d3_flamegraph(f=STDOUT, skip_common=true)
       raise "profile does not include raw samples (add `raw: true` to collecting StackProf.run)" unless raw = data[:raw]
 
-      stacks = []
-      max_x = 0
-      max_y = 0
-      while len = raw.shift
-        max_y = len if len > max_y
-        stack = raw.slice!(0, len+1)
-        stacks << stack
-        max_x += stack.last
-      end
+      stacks, * = flamegraph_stacks(raw)
 
       # d3-flame-grpah supports only alphabetical flamegraph
       stacks.sort!
@@ -410,7 +448,7 @@ module StackProf
         call, total = info.values_at(:samples, :total_samples)
         break if total < node_minimum || (limit && index >= limit)
 
-        sample = ''
+        sample = ''.dup
         sample << "#{call} (%2.1f%%)\\rof " % (call*100.0/overall_samples) if call < total
         sample << "#{total} (%2.1f%%)\\r" % (total*100.0/overall_samples)
         fontsize = (1.0 * call / max_samples) * 28 + 10
@@ -654,7 +692,8 @@ module StackProf
           end
         end
       end
+    rescue SystemCallError
+      f.puts "        SOURCE UNAVAILABLE"
     end
-
   end
 end

data/lib/stackprof/truffleruby.rb

@@ -0,0 +1,37 @@
+module StackProf
+  # Define the same methods as stackprof.c
+  class << self
+    def running?
+      false
+    end
+
+    def run(*args)
+      unimplemented
+    end
+
+    def start(*args)
+      unimplemented
+    end
+
+    def stop
+      unimplemented
+    end
+
+    def results(*args)
+      unimplemented
+    end
+
+    def sample
+      unimplemented
+    end
+
+    def use_postponed_job!
+      # noop
+    end
+
+    private def unimplemented
+      raise "Use --cpusampler=flamegraph or --cpusampler instead of StackProf on TruffleRuby.\n" \
+            "See https://www.graalvm.org/tools/profiling/ and `ruby --help:cpusampler` for more details."
+    end
+  end
+end

data/lib/stackprof.rb

@@ -1,7 +1,24 @@
-require "stackprof/stackprof"
+if RUBY_ENGINE == 'truffleruby'
+  require "stackprof/truffleruby"
+else
+  require "stackprof/stackprof"
+end
+
+if defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?
+  if RUBY_VERSION < "3.3"
+    # On 3.3 we don't need postponed jobs:
+    # https://github.com/ruby/ruby/commit/a1dc1a3de9683daf5a543d6f618e17aabfcb8708
+    StackProf.use_postponed_job!
+  end
+elsif RUBY_VERSION == "3.2.0"
+  # 3.2.0 crash is the signal is received at the wrong time.
+  # Fixed in https://github.com/ruby/ruby/pull/7116
+  # The fix is backported in 3.2.1: https://bugs.ruby-lang.org/issues/19336
+  StackProf.use_postponed_job!
+end
 
 module StackProf
-  VERSION = '0.2.15'
+  VERSION = '0.2.27'
 end
 
 StackProf.autoload :Report, "stackprof/report.rb"

data/stackprof.gemspec

@@ -1,11 +1,18 @@
 Gem::Specification.new do |s|
   s.name = 'stackprof'
-  s.version = '0.2.15'
+  s.version = '0.2.27'
   s.homepage = 'http://github.com/tmm1/stackprof'
 
   s.authors = 'Aman Gupta'
   s.email   = 'aman@tmm1.net'
 
+  s.metadata = {
+    'bug_tracker_uri'   => 'https://github.com/tmm1/stackprof/issues',
+    'changelog_uri'     => "https://github.com/tmm1/stackprof/blob/v#{s.version}/CHANGELOG.md",
+    'documentation_uri' => "https://www.rubydoc.info/gems/stackprof/#{s.version}",
+    'source_code_uri'   => "https://github.com/tmm1/stackprof/tree/v#{s.version}"
+  }
+
   s.files = `git ls-files`.split("\n")
   s.extensions = 'ext/stackprof/extconf.rb'
 
@@ -22,6 +29,5 @@ Gem::Specification.new do |s|
   s.license = 'MIT'
 
   s.add_development_dependency 'rake-compiler', '~> 0.9'
-  s.add_development_dependency 'mocha', '~> 0.14'
   s.add_development_dependency 'minitest', '~> 5.0'
 end

data/test/fixtures/profile.dump

@@ -0,0 +1 @@
+{:	modeI"cpu:ET

data/test/fixtures/profile.json

@@ -0,0 +1 @@
+{ "mode": "cpu" }

data/test/test_middleware.rb

@@ -2,9 +2,9 @@ $:.unshift File.expand_path('../../lib', __FILE__)
 require 'stackprof'
 require 'stackprof/middleware'
 require 'minitest/autorun'
-require 'mocha/setup'
+require 'tmpdir'
 
-class StackProf::MiddlewareTest < MiniTest::Test
+class StackProf::MiddlewareTest < Minitest::Test
 
   def test_path_default
     StackProf::Middleware.new(Object.new)
@@ -19,23 +19,36 @@ class StackProf::MiddlewareTest < MiniTest::Test
   end
 
   def test_save_default
-    StackProf::Middleware.new(Object.new)
-
-    StackProf.stubs(:results).returns({ mode: 'foo' })
-    FileUtils.expects(:mkdir_p).with('tmp/')
-    File.expects(:open).with(regexp_matches(/^tmp\/stackprof-foo/), 'wb')
-
-    StackProf::Middleware.save
+    middleware = StackProf::Middleware.new(->(env) { 100.times { Object.new } },
+                                          save_every: 1,
+                                          enabled: true)
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) { middleware.call({}) }
+      dir = File.join(dir, "tmp")
+      assert File.directory? dir
+      profile = Dir.entries(dir).reject { |x| File.directory?(x) }.first
+      assert profile
+      assert_equal "stackprof", profile.split("-")[0]
+      assert_equal "cpu", profile.split("-")[1]
+      assert_equal Process.pid.to_s, profile.split("-")[2]
+    end
   end
 
   def test_save_custom
-    StackProf::Middleware.new(Object.new, { path: 'foo/' })
-
-    StackProf.stubs(:results).returns({ mode: 'foo' })
-    FileUtils.expects(:mkdir_p).with('foo/')
-    File.expects(:open).with(regexp_matches(/^foo\/stackprof-foo/), 'wb')
-
-    StackProf::Middleware.save
+    middleware = StackProf::Middleware.new(->(env) { 100.times { Object.new } },
+                                          path: "foo/",
+                                          save_every: 1,
+                                          enabled: true)
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) { middleware.call({}) }
+      dir = File.join(dir, "foo")
+      assert File.directory? dir
+      profile = Dir.entries(dir).reject { |x| File.directory?(x) }.first
+      assert profile
+      assert_equal "stackprof", profile.split("-")[0]
+      assert_equal "cpu", profile.split("-")[1]
+      assert_equal Process.pid.to_s, profile.split("-")[2]
+    end
   end
 
   def test_enabled_should_use_a_proc_if_passed
@@ -70,4 +83,4 @@ class StackProf::MiddlewareTest < MiniTest::Test
     StackProf::Middleware.new(Object.new, metadata: metadata)
     assert_equal metadata, StackProf::Middleware.metadata
   end
-end
+end unless RUBY_ENGINE == 'truffleruby'

data/test/test_report.rb

@@ -2,7 +2,7 @@ $:.unshift File.expand_path('../../lib', __FILE__)
 require 'stackprof'
 require 'minitest/autorun'
 
-class ReportDumpTest < MiniTest::Test
+class ReportDumpTest < Minitest::Test
   require 'stringio'
 
   def test_dump_to_stdout
@@ -32,3 +32,27 @@ class ReportDumpTest < MiniTest::Test
     assert_equal expected, Marshal.load(marshal_data)
   end
 end
+
+class ReportReadTest < Minitest::Test
+  require 'pathname'
+
+  def test_from_file_read_json
+    file = fixture("profile.json")
+    report = StackProf::Report.from_file(file)
+
+    assert_equal({ mode: "cpu" }, report.data)
+  end
+
+  def test_from_file_read_marshal
+    file = fixture("profile.dump")
+    report = StackProf::Report.from_file(file)
+
+    assert_equal({ mode: "cpu" }, report.data)
+  end
+
+  private
+
+  def fixture(name)
+    Pathname.new(__dir__).join("fixtures", name)
+  end
+end

data/test/test_stackprof.rb

@@ -4,7 +4,11 @@ require 'minitest/autorun'
 require 'tempfile'
 require 'pathname'
 
-class StackProfTest < MiniTest::Test
+class StackProfTest < Minitest::Test
+  def setup
+    Object.new # warm some caches to avoid flakiness
+  end
+
   def test_info
     profile = StackProf.run{}
     assert_equal 1.2, profile[:version]
@@ -39,16 +43,30 @@ class StackProfTest < MiniTest::Test
     end
     assert_equal :object, profile[:mode]
     assert_equal 1, profile[:interval]
-    assert_equal 2, profile[:samples]
+    if RUBY_VERSION >= '3'
+      assert_equal 4, profile[:samples]
+    else
+      assert_equal 2, profile[:samples]
+    end
 
     frame = profile[:frames].values.first
     assert_includes frame[:name], "StackProfTest#test_object_allocation"
     assert_equal 2, frame[:samples]
     assert_includes [profile_base_line - 2, profile_base_line], frame[:line]
-    assert_equal [1, 1], frame[:lines][profile_base_line+1]
-    assert_equal [1, 1], frame[:lines][profile_base_line+2]
+    if RUBY_VERSION >= '3'
+      assert_equal [2, 1], frame[:lines][profile_base_line+1]
+      assert_equal [2, 1], frame[:lines][profile_base_line+2]
+    else
+      assert_equal [1, 1], frame[:lines][profile_base_line+1]
+      assert_equal [1, 1], frame[:lines][profile_base_line+2]
+    end
     frame = profile[:frames].values[1] if RUBY_VERSION < '2.3'
-    assert_equal [2, 0], frame[:lines][profile_base_line]
+
+    if RUBY_VERSION >= '3'
+      assert_equal [4, 0], frame[:lines][profile_base_line]
+    else
+      assert_equal [2, 0], frame[:lines][profile_base_line]
+    end
   end
 
   def test_object_allocation_interval
@@ -64,18 +82,31 @@ class StackProfTest < MiniTest::Test
     end
 
     assert_operator profile[:samples], :>=, 1
-    frame = profile[:frames].values.first
-    assert_includes frame[:name], "StackProfTest#math"
+    if RUBY_VERSION >= '3'
+      assert profile[:frames].values.take(2).map { |f|
+        f[:name].include? "StackProfTest#math"
+      }.any?
+    else
+      frame = profile[:frames].values.first
+      assert_includes frame[:name], "StackProfTest#math"
+    end
   end
 
   def test_walltime
+    GC.disable
     profile = StackProf.run(mode: :wall) do
       idle
     end
 
     frame = profile[:frames].values.first
-    assert_equal "StackProfTest#idle", frame[:name]
+    if RUBY_VERSION >= '3'
+      assert_equal "IO.select", frame[:name]
+    else
+      assert_equal "StackProfTest#idle", frame[:name]
+    end
     assert_in_delta 200, frame[:samples], 25
+  ensure
+    GC.enable
   end
 
   def test_custom
@@ -89,24 +120,54 @@ class StackProfTest < MiniTest::Test
     assert_equal :custom, profile[:mode]
     assert_equal 10, profile[:samples]
 
-    frame = profile[:frames].values.first
+    offset = RUBY_VERSION >= '3' ? 1 : 0
+    frame = profile[:frames].values[offset]
     assert_includes frame[:name], "StackProfTest#test_custom"
     assert_includes [profile_base_line-2, profile_base_line+1], frame[:line]
-    assert_equal [10, 10], frame[:lines][profile_base_line+2]
+
+    if RUBY_VERSION >= '3'
+      assert_equal [10, 0], frame[:lines][profile_base_line+2]
+    else
+      assert_equal [10, 10], frame[:lines][profile_base_line+2]
+    end
   end
 
   def test_raw
+    before_monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+
     profile = StackProf.run(mode: :custom, raw: true) do
       10.times do
         StackProf.sample
+        sleep 0.0001
       end
     end
 
+    after_monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+
     raw = profile[:raw]
+    raw_lines = profile[:raw_lines]
     assert_equal 10, raw[-1]
     assert_equal raw[0] + 2, raw.size
-    assert_includes profile[:frames][raw[-2]][:name], 'StackProfTest#test_raw'
+    assert_equal 10, raw_lines[-1] # seen 10 times
+
+    offset = RUBY_VERSION >= '3' ? -3 : -2
+    assert_equal 140, raw_lines[offset] # sample caller is on 140
+    assert_includes profile[:frames][raw[offset]][:name], 'StackProfTest#test_raw'
+
+    assert_equal 10, profile[:raw_sample_timestamps].size
+    profile[:raw_sample_timestamps].each_cons(2) do |t1, t2|
+      assert_operator t1, :>, before_monotonic
+      assert_operator t2, :>=, t1
+      assert_operator t2, :<, after_monotonic
+    end
+
     assert_equal 10, profile[:raw_timestamp_deltas].size
+    total_duration = after_monotonic - before_monotonic
+    assert_operator profile[:raw_timestamp_deltas].inject(&:+), :<, total_duration
+
+    profile[:raw_timestamp_deltas].each do |delta|
+      assert_operator delta, :>, 0
+    end
   end
 
   def test_metadata
@@ -178,7 +239,6 @@ class StackProfTest < MiniTest::Test
       end
     end
 
-    raw = profile[:raw]
     gc_frame = profile[:frames].values.find{ |f| f[:name] == "(garbage collection)" }
     marking_frame = profile[:frames].values.find{ |f| f[:name] == "(marking)" }
     sweeping_frame = profile[:frames].values.find{ |f| f[:name] == "(sweeping)" }
@@ -187,8 +247,12 @@ class StackProfTest < MiniTest::Test
     assert marking_frame
     assert sweeping_frame
 
-    assert_equal gc_frame[:total_samples], profile[:gc_samples]
-    assert_equal profile[:gc_samples], [gc_frame, marking_frame, sweeping_frame].map{|x| x[:samples] }.inject(:+)
+    # We can't guarantee a certain number of GCs to run, so just assert
+    # that it's within some kind of delta
+    assert_in_delta gc_frame[:total_samples], profile[:gc_samples], 2
+
+    # Lazy marking / sweeping can cause this math to not add up, so also use a delta
+    assert_in_delta profile[:gc_samples], [gc_frame, marking_frame, sweeping_frame].map{|x| x[:samples] }.inject(:+), 2
 
     assert_operator profile[:gc_samples], :>, 0
     assert_operator profile[:missed_samples], :<=, 25
@@ -232,6 +296,15 @@ class StackProfTest < MiniTest::Test
     refute_empty profile[:frames]
   end
 
+  def test_min_max_interval
+    [-1, 0, 1_000_000, 1_000_001].each do |invalid_interval|
+      err = assert_raises(ArgumentError, "invalid interval #{invalid_interval}") do
+        StackProf.run(interval: invalid_interval, debug: true) {}
+      end
+      assert_match(/microseconds/, err.message)
+    end
+  end
+
   def math
     250_000.times do
       2 ** 10
@@ -245,4 +318,4 @@ class StackProfTest < MiniTest::Test
     r.close
     w.close
   end
-end
+end unless RUBY_ENGINE == 'truffleruby'

data/test/test_truffleruby.rb

@@ -0,0 +1,18 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'stackprof'
+require 'minitest/autorun'
+
+if RUBY_ENGINE == 'truffleruby'
+  class StackProfTruffleRubyTest < Minitest::Test
+    def test_error
+      error = assert_raises RuntimeError do
+        StackProf.run(mode: :cpu) do
+          unreacheable
+        end
+      end
+
+      assert_match(/TruffleRuby/, error.message)
+      assert_match(/--cpusampler/, error.message)
+    end
+  end
+end