stackprof 0.2.10 → 0.2.25

data/test/test_middleware.rb

@@ -9,31 +9,31 @@ class StackProf::MiddlewareTest < MiniTest::Test
   def test_path_default
     StackProf::Middleware.new(Object.new)
 
-    assert_equal 'tmp', StackProf::Middleware.path
+    assert_equal 'tmp/', StackProf::Middleware.path
   end
 
   def test_path_custom
-    StackProf::Middleware.new(Object.new, { path: '/foo' })
+    StackProf::Middleware.new(Object.new, { path: 'foo/' })
 
-    assert_equal '/foo', StackProf::Middleware.path
+    assert_equal 'foo/', StackProf::Middleware.path
   end
 
   def test_save_default
     StackProf::Middleware.new(Object.new)
 
     StackProf.stubs(:results).returns({ mode: 'foo' })
-    FileUtils.expects(:mkdir_p).with('tmp')
+    FileUtils.expects(:mkdir_p).with('tmp/')
     File.expects(:open).with(regexp_matches(/^tmp\/stackprof-foo/), 'wb')
 
     StackProf::Middleware.save
   end
 
   def test_save_custom
-    StackProf::Middleware.new(Object.new, { path: '/foo' })
+    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')
+    FileUtils.expects(:mkdir_p).with('foo/')
+    File.expects(:open).with(regexp_matches(/^foo\/stackprof-foo/), 'wb')
 
     StackProf::Middleware.save
   end
@@ -64,4 +64,10 @@ class StackProf::MiddlewareTest < MiniTest::Test
     StackProf::Middleware.new(Object.new, raw: true)
     assert StackProf::Middleware.raw
   end
+
+  def test_metadata
+    metadata = { key: 'value' }
+    StackProf::Middleware.new(Object.new, metadata: metadata)
+    assert_equal metadata, StackProf::Middleware.metadata
+  end
 end

data/test/test_report.rb

@@ -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

@@ -2,11 +2,16 @@ $:.unshift File.expand_path('../../lib', __FILE__)
 require 'stackprof'
 require 'minitest/autorun'
 require 'tempfile'
+require 'pathname'
 
 class StackProfTest < MiniTest::Test
+  def setup
+    Object.new # warm some caches to avoid flakiness
+  end
+
   def test_info
     profile = StackProf.run{}
-    assert_equal 1.1, profile[:version]
+    assert_equal 1.2, profile[:version]
     assert_equal :wall, profile[:mode]
     assert_equal 1000, profile[:interval]
     assert_equal 0, profile[:samples]
@@ -18,16 +23,16 @@ class StackProfTest < MiniTest::Test
   end
 
   def test_start_stop_results
-    assert_equal nil, StackProf.results
+    assert_nil StackProf.results
     assert_equal true, StackProf.start
     assert_equal false, StackProf.start
     assert_equal true, StackProf.running?
-    assert_equal nil, StackProf.results
+    assert_nil StackProf.results
     assert_equal true, StackProf.stop
     assert_equal false, StackProf.stop
     assert_equal false, StackProf.running?
     assert_kind_of Hash, StackProf.results
-    assert_equal nil, StackProf.results
+    assert_nil StackProf.results
   end
 
   def test_object_allocation
@@ -38,17 +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_equal "block in StackProfTest#test_object_allocation", frame[:name]
+    assert_includes frame[:name], "StackProfTest#test_object_allocation"
     assert_equal 2, frame[:samples]
-    assert_equal 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]
+    assert_includes [profile_base_line - 2, profile_base_line], frame[:line]
+    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'
 
-    frame = profile[:frames].values[1]
-    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
@@ -63,9 +81,15 @@ class StackProfTest < MiniTest::Test
       math
     end
 
-    assert_operator profile[:samples], :>, 1
-    frame = profile[:frames].values.first
-    assert_equal "block in StackProfTest#math", frame[:name]
+    assert_operator profile[:samples], :>=, 1
+    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
@@ -74,8 +98,12 @@ class StackProfTest < MiniTest::Test
     end
 
     frame = profile[:frames].values.first
-    assert_equal "StackProfTest#idle", frame[:name]
-    assert_in_delta 200, frame[:samples], 5
+    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
   end
 
   def test_custom
@@ -89,23 +117,81 @@ class StackProfTest < MiniTest::Test
     assert_equal :custom, profile[:mode]
     assert_equal 10, profile[:samples]
 
-    frame = profile[:frames].values.first
-    assert_equal "block (2 levels) in StackProfTest#test_custom", frame[:name]
-    assert_equal profile_base_line+1, frame[:line]
-    assert_equal [10, 10], frame[:lines][profile_base_line+2]
+    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]
+
+    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]
     assert_equal 10, raw[-1]
     assert_equal raw[0] + 2, raw.size
-    assert_equal 'block (2 levels) in StackProfTest#test_raw', profile[:frames][raw[-2]][:name]
+
+    offset = RUBY_VERSION >= '3' ? -3 : -2
+    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
+    metadata = {
+      path: '/foo/bar',
+      revision: '5c0b01f1522ae8c194510977ae29377296dd236b',
+    }
+    profile = StackProf.run(mode: :cpu, metadata: metadata) do
+      math
+    end
+
+    assert_equal metadata, profile[:metadata]
+  end
+
+  def test_empty_metadata
+    profile = StackProf.run(mode: :cpu) do
+      math
+    end
+
+    assert_equal({}, profile[:metadata])
+  end
+
+  def test_raises_if_metadata_is_not_a_hash
+    exception = assert_raises ArgumentError do
+      StackProf.run(mode: :cpu, metadata: 'foobar') do
+        math
+      end
+    end
+
+    assert_equal 'metadata should be a hash', exception.message
   end
 
   def test_fork
@@ -119,16 +205,47 @@ class StackProfTest < MiniTest::Test
     end
   end
 
+  def foo(n = 10)
+    if n == 0
+      StackProf.sample
+      return
+    end
+    foo(n - 1)
+  end
+
+  def test_recursive_total_samples
+    profile = StackProf.run(mode: :cpu, raw: true) do
+      10.times do
+        foo
+      end
+    end
+
+    frame = profile[:frames].values.find do |frame|
+      frame[:name] == "StackProfTest#foo"
+    end
+    assert_equal 10, frame[:total_samples]
+  end
+
   def test_gc
-    profile = StackProf.run(interval: 100) do
+    profile = StackProf.run(interval: 100, raw: true) do
       5.times do
         GC.start
       end
     end
 
-    assert_empty profile[:frames]
+    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)" }
+
+    assert gc_frame
+    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(:+)
+
     assert_operator profile[:gc_samples], :>, 0
-    assert_equal 0, profile[:missed_samples]
+    assert_operator profile[:missed_samples], :<=, 25
   end
 
   def test_out
@@ -143,6 +260,41 @@ class StackProfTest < MiniTest::Test
     refute_empty profile[:frames]
   end
 
+  def test_out_to_path_string
+    tmpfile = Tempfile.new('stackprof-out')
+    ret = StackProf.run(mode: :custom, out: tmpfile.path) do
+      StackProf.sample
+    end
+
+    refute_equal tmpfile, ret
+    assert_equal tmpfile.path, ret.path
+    tmpfile.rewind
+    profile = Marshal.load(tmpfile.read)
+    refute_empty profile[:frames]
+  end
+
+  def test_pathname_out
+    tmpfile  = Tempfile.new('stackprof-out')
+    pathname = Pathname.new(tmpfile.path)
+    ret = StackProf.run(mode: :custom, out: pathname) do
+      StackProf.sample
+    end
+
+    assert_equal tmpfile.path, ret.path
+    tmpfile.rewind
+    profile = Marshal.load(tmpfile.read)
+    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
@@ -156,4 +308,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